@outputai/core 0.1.0

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

@@ -0,0 +1,336 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+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 );
+}
+
+describe( 'collect_target_imports', () => {
+  it( 'collects ESM imports for steps and workflows and flags changes', () => {
+    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, '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' });` );
+
+    const source = `
+import { StepA } from './steps.js';
+import { EvalA } from './evaluators.js';
+import WF, { FlowA } from './workflow.js';
+const x = 1;`;
+
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { stepImports, evaluatorImports, flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: 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();
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS requires and removes declarators (steps + default workflow)', () => {
+    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, flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: 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)
+    const hasRequireDecl = ast.program.body.some( n =>
+      n.type === 'VariableDeclaration' && n.declarations.some( d => d.init && d.init.type === 'CallExpression' )
+    );
+    expect( hasRequireDecl ).toBe( false );
+
+    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(), workflowNameCache: 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(), workflowNameCache: 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(), workflowNameCache: 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(), workflowNameCache: 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', () => {
+    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( '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(),
+        workflowNameCache: new Map()
+      }
+    );
+    expect( sharedStepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
+
+    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' ) );
+
+    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: 'MyExport', evaluatorName: 'bad' } ] );
+
+    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' ) );
+
+    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: 'MyExport', evaluatorName: 'bad' } ] );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );
+

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

@@ -0,0 +1,61 @@
+import { dirname } from 'node:path';
+import generatorModule from '@babel/generator';
+import { parse } from '../tools.js';
+
+import rewriteFnBodies from './rewrite_fn_bodies.js';
+import collectTargetImports from './collect_target_imports.js';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const generate = generatorModule.default ?? generatorModule;
+
+// Caches to avoid re-reading files during a build
+const stepsNameCache = new Map(); // path -> Map<exported, stepName>
+const sharedStepsNameCache = new Map(); // path -> Map<exported, stepName> (shared)
+const evaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName>
+const 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
+ * the respective modules and transforming `fn` bodies accordingly.
+ * Preserves sourcemaps.
+ *
+ * @param {string|Buffer} source - Module source code.
+ * @param {any} inputMap - Incoming source map.
+ * @this {import('webpack').LoaderContext<{}>}
+ * @returns {void}
+ */
+export default function stepImportRewriterAstLoader( source, inputMap ) {
+  this.cacheable?.( true );
+  const callback = this.async?.() ?? this.callback;
+  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, sharedEvaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+
+    // No imports
+    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports ).length === 0 ) {
+      return callback( null, source, inputMap );
+    }
+
+    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } );
+    // No edits performed
+    if ( !rewrote ) {
+      return callback( null, source, inputMap );
+    }
+
+    const { code, map } = generate( ast, {
+      sourceMaps: true,
+      sourceFileName: filename,
+      quotes: 'single',
+      jsescOption: { quotes: 'single' }
+    }, String( source ) );
+    return callback( null, code, map ?? inputMap );
+  } catch ( err ) {
+    // Fail gracefully as loader error
+    return callback( err );
+  }
+};

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

@@ -0,0 +1,216 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import loader from './index.mjs';
+
+function runLoader( source, resourcePath ) {
+  return new Promise( ( resolve, reject ) => {
+    const ctx = {
+      resourcePath,
+      cacheable: () => {},
+      async: () => ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) ),
+      callback: ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) )
+    };
+    loader.call( ctx, source, null );
+  } );
+}
+
+describe( 'workflows_rewriter Webpack loader spec', () => {
+  it( 'rewrites ESM imports and converts fn arrow to function', 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' ), `
+export const FlowA = workflow({ name: 'flow.a' });
+export default workflow({ name: 'flow.def' });` );
+
+    const source = `
+import { StepA } from './steps.js';
+import FlowDef, { FlowA } from './workflow.js';
+
+const obj = {
+  fn: async (x) => {
+    StepA(1);
+    FlowA(2);
+    FlowDef(3);
+  }
+}`;
+
+    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( /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\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites ESM shared steps imports to invokeSharedStep', async () => {
+    // Create directory structure: shared/steps/common.js
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-shared-' ) );
+    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 = `
+import { SharedA } from '../../shared/steps/common.js';
+
+const obj = {
+  fn: async (x) => {
+    SharedA(1);
+  }
+}`;
+
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( code ).not.toMatch( /from '\.\.\/\.\.\/shared\/steps\/common\.js'/ );
+    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
+    expect( code ).toMatch( /this\.invokeSharedStep\('shared\.a',\s*1\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites CJS shared steps requires to invokeSharedStep', async () => {
+    // Create directory structure: shared/steps/common.js
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-shared-' ) );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedB = step({ name: \'shared.b\' });' );
+
+    const source = `
+const { SharedB } = require( '../../shared/steps/common.js' );
+
+const obj = {
+  fn: async (y) => {
+    SharedB();
+  }
+}`;
+
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( code ).not.toMatch( /require\('\.\.\/\.\.\/shared\/steps\/common\.js'\)/ );
+    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
+    expect( code ).toMatch( /this\.invokeSharedStep\('shared\.b'\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites CJS requires and converts fn arrow to function', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' });' );
+
+    const source = `
+const { StepB } = require( './steps.js' );
+const FlowDefault = require( './workflow.js' );
+
+const obj = {
+  fn: async (y) => {
+    StepB();
+    FlowDefault();
+  }
+}`;
+
+    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( /fn:\s*async function \(y\)/ );
+    expect( code ).toMatch( /this\.invokeStep\('step\.b'\)/ );
+    expect( code ).toMatch( /this\.startWorkflow\('flow\.c'\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'resolves top-level const name variables', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-const-' ) );
+    writeFileSync( join( dir, 'steps.js' ), `
+const NAME = 'step.const';
+export const StepC = step({ name: NAME });` );
+    writeFileSync( join( dir, 'workflow.js' ), `
+const WF = 'wf.const';
+export const FlowC = workflow({ name: WF });
+const D = 'wf.def';
+export default workflow({ name: D });` );
+
+    const source = `
+import { StepC } from './steps.js';
+import FlowDef, { FlowC } from './workflow.js';
+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'\)/ );
+    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' ), `
+function n() { return 'x'; }
+export const StepX = step({ name: n() });` );
+    writeFileSync( join( dir, 'workflow.js' ), `
+const base = 'a';
+export default workflow({ name: \`\${base}-b\` });` );
+
+    const source = `
+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/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );