@output.ai/core 0.0.7 → 0.0.9

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

@@ -0,0 +1,58 @@
+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 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, workflowNameCache };
+
+  try {
+    const filename = this.resourcePath;
+    const ast = parse( String( source ), filename );
+    const fileDir = dirname( filename );
+    const { stepImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+
+    // No imports
+    if ( stepImports.length + flowImports.length === 0 ) {
+      return callback( null, source, inputMap );
+    }
+
+    const rewrote = rewriteFnBodies( ast, stepImports, 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,129 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } 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\' })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'export const FlowA = workflow({ name: \'flow.a\' })',
+      'export default workflow({ name: \'flow.def\' })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepA } from \'./steps.js\';',
+      'import FlowDef, { FlowA } from \'./workflow.js\';',
+      '',
+      'const obj = {',
+      '  fn: async (x) => {',
+      '    StepA(1);',
+      '    FlowA(2);',
+      '    FlowDef(3);',
+      '  }',
+      '}',
+      ''
+    ].join( '\n' );
+
+    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 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\' })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' })\n' );
+
+    const source = [
+      'const { StepB } = require(\'./steps.js\');',
+      'const FlowDefault = require(\'./workflow.js\');',
+      '',
+      'const obj = {',
+      '  fn: async (y) => {',
+      '    StepB();',
+      '    FlowDefault();',
+      '  }',
+      '}',
+      ''
+    ].join( '\n' );
+
+    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 })'
+    ].join( '\n' ) );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'const WF = \'wf.const\'',
+      'export const FlowC = workflow({ name: WF })',
+      'const D = \'wf.def\'',
+      'export default workflow({ name: D })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepC } from \'./steps.js\';',
+      'import FlowDef, { FlowC } from \'./workflow.js\';',
+      'const obj = { fn: async () => { StepC(); FlowC(); FlowDef(); } }'
+    ].join( '\n' );
+
+    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( '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() })'
+    ].join( '\n' ) );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'const base = \'a\'',
+      'export default workflow({ name: `${base}-b` })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepX } from \'./steps.js\';',
+      'import WF from \'./workflow.js\';',
+      'const obj = { fn: async () => { StepX(); WF(); } }'
+    ].join( '\n' );
+
+    await expect( runLoader( source, join( dir, 'file.js' ) ) ).rejects.toThrow( /Invalid (step|default workflow) name/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );

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

@@ -0,0 +1,70 @@
+import traverseModule from '@babel/traverse';
+import {
+  isArrowFunctionExpression,
+  isIdentifier,
+  isFunctionExpression
+} from '@babel/types';
+import { toFunctionExpression, createThisMethodCall } from './tools.js';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const traverse = traverseModule.default ?? traverseModule;
+
+/**
+ * Rewrite calls to imported steps/workflows within `fn` object properties.
+ * Converts arrow fns to functions and replaces `StepX(...)` with
+ * `this.invokeStep('name', ...)` and `FlowY(...)` with
+ * `this.startWorkflow('name', ...)`.
+ *
+ * @param {import('@babel/types').File} ast - Parsed file AST.
+ * @param {Array<{localName:string,stepName:string}>} stepImports - Step imports.
+ * @param {Array<{localName:string,workflowName:string}>} flowImports - Workflow imports.
+ * @returns {boolean} True if the AST was modified; false otherwise.
+ */
+export default function rewriteFnBodies( ast, stepImports, flowImports ) {
+  const state = { rewrote: false };
+  traverse( ast, {
+    ObjectProperty: path => {
+      // If it is not fn property: skip
+      if ( !isIdentifier( path.node.key, { name: 'fn' } ) ) {
+        return;
+      }
+
+      const val = path.node.value;
+
+      // if it is not function, return
+      if ( !isFunctionExpression( val ) && !isArrowFunctionExpression( val ) ) {
+        return;
+      }
+
+      // replace arrow fn in favor of a function
+      if ( isArrowFunctionExpression( val ) ) {
+        const func = toFunctionExpression( val );
+        path.get( 'value' ).replaceWith( func );
+        state.rewrote = true;
+      }
+
+      path.get( 'value.body' ).traverse( {
+        CallExpression: cPath => {
+          const callee = cPath.node.callee;
+          if ( !isIdentifier( callee ) ) {
+            return;
+          } // Skip: complex callee not supported
+          const step = stepImports.find( x => x.localName === callee.name );
+          if ( step ) {
+            const args = cPath.node.arguments;
+            cPath.replaceWith( createThisMethodCall( 'invokeStep', step.stepName, args ) );
+            state.rewrote = true;
+            return; // Stop after rewriting as step call
+          }
+          const flow = flowImports.find( x => x.localName === callee.name );
+          if ( flow ) {
+            const args = cPath.node.arguments;
+            cPath.replaceWith( createThisMethodCall( 'startWorkflow', flow.workflowName, args ) );
+            state.rewrote = true;
+          }
+        }
+      } );
+    }
+  } );
+  return state.rewrote;
+};

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

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { parse } from './tools.js';
+import rewriteFnBodies from './rewrite_fn_bodies.js';
+
+describe( 'rewrite_fn_bodies', () => {
+  it( 'converts arrow to function and rewrites step/workflow calls', () => {
+    const src = [
+      'const obj = {',
+      '  fn: async (x) => {',
+      '    StepA(1);',
+      '    FlowB(2);',
+      '  }',
+      '}'
+    ].join( '\n' );
+    const ast = parse( src, 'file.js' );
+    const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
+    const flowImports = [ { localName: 'FlowB', workflowName: 'flow.b' } ];
+
+    const rewrote = rewriteFnBodies( ast, stepImports, flowImports );
+    expect( rewrote ).toBe( true );
+
+    const code = ast.program.body.map( n => n.type ).length; // smoke: ast mutated
+    expect( code ).toBeGreaterThan( 0 );
+  } );
+
+  it( 'does nothing when no matching calls are present', () => {
+    const src = [ 'const obj = { fn: function() { other(); } }' ].join( '\n' );
+    const ast = parse( src, 'file.js' );
+    const rewrote = rewriteFnBodies( ast, [], [] );
+    expect( rewrote ).toBe( false );
+  } );
+} );
+

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

@@ -0,0 +1,245 @@
+import parser from '@babel/parser';
+import { resolve as resolvePath } from 'node:path';
+import { readFileSync } from 'node:fs';
+import {
+  blockStatement,
+  callExpression,
+  functionExpression,
+  identifier,
+  isAssignmentPattern,
+  isBlockStatement,
+  isCallExpression,
+  isExportNamedDeclaration,
+  isIdentifier,
+  isStringLiteral,
+  isVariableDeclaration,
+  isObjectExpression,
+  memberExpression,
+  returnStatement,
+  stringLiteral,
+  thisExpression,
+  isExportDefaultDeclaration
+} from '@babel/types';
+import { NodeType } from './consts.js';
+
+/**
+ * Resolve a relative module specifier against a base directory.
+ * @param {string} fileDir - Base directory to resolve from.
+ * @param {string} rel - Relative path/specifier.
+ * @returns {string} Absolute path.
+ */
+export const toAbsolutePath = ( fileDir, rel ) => resolvePath( fileDir, rel );
+
+/**
+ * Parse JavaScript/TypeScript source into a Babel AST.
+ * @param {string} source - Source code to parse.
+ * @param {string} filename - Virtual filename for sourcemaps and diagnostics.
+ * @returns {import('@babel/types').File} Parsed AST.
+ */
+export const parse = ( source, filename ) => parser.parse( source, {
+  sourceType: 'module',
+  sourceFilename: filename,
+  plugins: [ 'jsx' ]
+} );
+
+/**
+ * Extract top-level constant string bindings (e.g., const NAME = 'value').
+ * @param {import('@babel/types').File} ast - Parsed file AST.
+ * @returns {Map<string, string>} Map from identifier to string literal value.
+ */
+export const extractTopLevelStringConsts = ast =>
+  ast.program.body
+    .filter( node => isVariableDeclaration( node ) && node.kind === NodeType.CONST )
+    .reduce( ( map, node ) => {
+      node.declarations
+        .filter( dec => isIdentifier( dec.id ) && isStringLiteral( dec.init ) )
+        .forEach( dec => map.set( dec.id.name, dec.init.value ) );
+      return map;
+    }, new Map() );
+
+/**
+ * Resolve an object key name from an Identifier or StringLiteral.
+ * @param {import('@babel/types').Expression} node - Object key node.
+ * @returns {string|null} Key name or null when unsupported.
+ */
+export const getObjectKeyName = node => {
+  if ( isIdentifier( node ) ) {
+    return node.name;
+  }
+  if ( isStringLiteral( node ) ) {
+    return node.value;
+  }
+  return null;
+};
+
+/**
+ * Extract the local identifier name from a destructured ObjectProperty.
+ * Supports: { a } and { a: local } and { a: local = default }.
+ * @param {import('@babel/types').ObjectProperty} prop - Object property.
+ * @returns {string|null} Local identifier name or null.
+ */
+export const getLocalNameFromDestructuredProperty = prop => {
+  if ( isIdentifier( prop.value ) ) {
+    return prop.value.name;
+  }
+  if ( isAssignmentPattern( prop.value ) && isIdentifier( prop.value.left ) ) {
+    return prop.value.left.name;
+  }
+  return null;
+};
+
+/**
+ * Convert an ArrowFunctionExpression to a FunctionExpression.
+ * Wraps expression bodies in a block with a return statement.
+ * @param {import('@babel/types').ArrowFunctionExpression} arrow - Arrow function.
+ * @returns {import('@babel/types').FunctionExpression} Function expression.
+ */
+export const toFunctionExpression = arrow => {
+  const body = isBlockStatement( arrow.body ) ? arrow.body : blockStatement( [ returnStatement( arrow.body ) ] );
+  return functionExpression( null, arrow.params, body, arrow.generator ?? false, arrow.async ?? false );
+};
+
+/**
+ * Check if a module specifier or request string points to steps.js.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches steps.js.
+ */
+export const isStepsPath = value => /(^|\/)steps\.js$/.test( value );
+
+/**
+ * Check if a module specifier or request string points to workflow.js.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches workflow.js.
+ */
+export const isWorkflowPath = value => /(^|\/)workflow\.js$/.test( value );
+
+/**
+ * Create a `this.method(literalName, ...args)` CallExpression.
+ * @param {string} method - Method name on `this`.
+ * @param {string} literalName - First string literal argument.
+ * @param {import('@babel/types').Expression[]} args - Remaining call arguments.
+ * @returns {import('@babel/types').CallExpression} Call expression node.
+ */
+export const createThisMethodCall = ( method, literalName, args ) =>
+  callExpression( memberExpression( thisExpression(), identifier( method ) ), [ stringLiteral( literalName ), ...args ] );
+
+/**
+ * Resolve an options object's name property to a string.
+ * Accepts literal strings or top-level const string identifiers.
+ * @param {import('@babel/types').Expression} optionsNode - The call options object.
+ * @param {Map<string,string>} consts - Top-level const string bindings.
+ * @param {string} errorMessagePrefix - Prefix used when throwing validation errors.
+ * @returns {string} Resolved name.
+ * @throws {Error} When name is missing or not a supported static form.
+ */
+export const resolveNameFromOptions = ( optionsNode, consts, errorMessagePrefix ) => {
+  // If it is not an object
+  if ( !isObjectExpression( optionsNode ) ) {
+    throw new Error( `${errorMessagePrefix}: Missing properties` );
+  }
+
+  // Look specifically for the 'name' property
+  for ( const prop of optionsNode.properties ) {
+    if ( getObjectKeyName( prop.key ) !== 'name' ) {
+      continue;
+    }
+
+    const val = prop.value;
+    // if it is a string literal: jackpot
+    if ( isStringLiteral( val ) ) {
+      return val.value;
+    }
+
+    // if it is an identifier, it needs to be deterministic (top-level const)
+    if ( isIdentifier( val ) ) {
+      if ( consts.has( val.name ) ) {
+        return consts.get( val.name );
+      }
+      throw new Error( `${errorMessagePrefix}: Name identifier "${val.name}" is not a top-level const string` );
+    }
+
+    throw new Error( `${errorMessagePrefix}: Name must be a string literal or a top-level const string` );
+  }
+
+  throw new Error( `${errorMessagePrefix}: Missing required name property` ); // No name field found
+};
+
+/**
+ * Build a map from exported step variable name to declared step name.
+ * Parses the steps module and extracts `step({ name: '...' })` names.
+ * @param {string} path - Absolute path to the steps module file.
+ * @param {Map<string, Map<string,string>>} cache - Cache of computed step name maps.
+ * @returns {Map<string,string>} Exported identifier -> step name.
+ * @throws {Error} When a step name is invalid (non-static or missing).
+ */
+export const buildStepsNameMap = ( path, cache ) => {
+  if ( cache.has( path ) ) {
+    return cache.get( path );
+  }
+  const text = readFileSync( path, 'utf8' );
+  const ast = parse( text, path );
+  const consts = extractTopLevelStringConsts( ast );
+
+  const stepMap = ast.program.body
+    .filter( node => isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) )
+    .reduce( ( map, node ) => {
+
+      node.declaration.declarations
+        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee, { name: 'step' } ) )
+        .map( dec => [
+          dec,
+          resolveNameFromOptions( dec.init.arguments[0], consts, `Invalid step name in ${path} for "${dec.id.name}"` )
+        ] )
+        .forEach( ( [ dec, name ] ) => map.set( dec.id.name, name ) );
+      return map;
+    }, new Map() );
+
+  cache.set( path, stepMap );
+  return stepMap;
+};
+
+/**
+ * Build a structure with default and named workflow names from a workflow module.
+ * Extracts names from `workflow({ name: '...' })` calls.
+ * @param {string} path - Absolute path to the workflow module file.
+ * @param {Map<string, {default: (string|null), named: Map<string,string>}>} cache - Cache of workflow names.
+ * @returns {{ default: (string|null), named: Map<string,string> }} Names.
+ * @throws {Error} When a workflow name is invalid (non-static or missing).
+ */
+export const buildWorkflowNameMap = ( path, cache ) => {
+  if ( cache.has( path ) ) {
+    return cache.get( path );
+  }
+  const text = readFileSync( path, 'utf8' );
+  const ast = parse( text, path );
+  const consts = extractTopLevelStringConsts( ast );
+
+  const result = { default: null, named: new Map() };
+
+  for ( const node of ast.program.body ) {
+
+    // named exports
+    if ( isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) ) {
+
+      for ( const d of node.declaration.declarations ) {
+        if ( isIdentifier( d.id ) && isCallExpression( d.init ) && isIdentifier( d.init.callee, { name: 'workflow' } ) ) {
+          const name = resolveNameFromOptions( d.init.arguments[0], consts, `Invalid workflow name in ${path} for '${d.id.name}` );
+          if ( name ) {
+            result.named.set( d.id.name, name );
+          }
+        }
+      }
+
+    // default exports
+    } else if (
+      isExportDefaultDeclaration( node ) &&
+      isCallExpression( node.declaration ) &&
+      isIdentifier( node.declaration.callee, { name: 'workflow' } )
+    ) {
+      result.default = resolveNameFromOptions( node.declaration.arguments[0], consts, `Invalid default workflow name in ${path}` );
+    }
+  }
+
+  cache.set( path, result );
+  return result;
+};

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

@@ -0,0 +1,144 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve as resolvePath } from 'node:path';
+import * as t from '@babel/types';
+import {
+  toAbsolutePath,
+  parse,
+  extractTopLevelStringConsts,
+  getObjectKeyName,
+  getLocalNameFromDestructuredProperty,
+  toFunctionExpression,
+  isStepsPath,
+  isWorkflowPath,
+  createThisMethodCall,
+  resolveNameFromOptions,
+  buildStepsNameMap,
+  buildWorkflowNameMap
+} from './tools.js';
+
+describe( 'workflow_rewriter tools', () => {
+  it( 'parse: parses JS with JSX plugin enabled', () => {
+    const ast = parse( 'const A = 1; const C = () => <div />', 'file.js' );
+    expect( ast?.type ).toBe( 'File' );
+    expect( ast.program.body.length ).toBeGreaterThan( 0 );
+  } );
+
+  it( 'toAbsolutePath: resolves relative path against base directory', () => {
+    expect( toAbsolutePath( '/base/dir', './file.js' ) ).toBe( resolvePath( '/base/dir', './file.js' ) );
+  } );
+
+  it( 'extractTopLevelStringConsts: returns only const string bindings', () => {
+    const ast = parse( [
+      'const A = \"a\"; let B = \"b\"; const C = 3;',
+      'const D = `d`; const E = \"e\"'
+    ].join( '\n' ), 'file.js' );
+    const map = extractTopLevelStringConsts( ast );
+    expect( map.get( 'A' ) ).toBe( 'a' );
+    expect( map.has( 'B' ) ).toBe( false );
+    expect( map.has( 'C' ) ).toBe( false );
+    // Template literal is not a StringLiteral
+    expect( map.has( 'D' ) ).toBe( false );
+    expect( map.get( 'E' ) ).toBe( 'e' );
+  } );
+
+  it( 'resolveNameFromOptions: returns literal name from options object', () => {
+    const opts = t.objectExpression( [ t.objectProperty( t.identifier( 'name' ), t.stringLiteral( 'literal.name' ) ) ] );
+    const out = resolveNameFromOptions( opts, new Map(), 'X' );
+    expect( out ).toBe( 'literal.name' );
+  } );
+
+  it( 'getObjectKeyName: resolves from Identifier and StringLiteral', () => {
+    expect( getObjectKeyName( t.identifier( 'name' ) ) ).toBe( 'name' );
+    expect( getObjectKeyName( t.stringLiteral( 'x' ) ) ).toBe( 'x' );
+    expect( getObjectKeyName( t.numericLiteral( 1 ) ) ).toBeNull();
+  } );
+
+  it( 'buildStepsNameMap: reads names from steps module and caches result', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-steps-' ) );
+    const stepsPath = join( dir, 'steps.js' );
+    writeFileSync( stepsPath, [
+      'export const StepA = step({ name: "step.a" })',
+      'export const StepB = step({ name: "step.b" })'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const map1 = buildStepsNameMap( stepsPath, cache );
+    expect( map1.get( 'StepA' ) ).toBe( 'step.a' );
+    expect( map1.get( 'StepB' ) ).toBe( 'step.b' );
+    expect( cache.get( stepsPath ) ).toBe( map1 );
+    const map2 = buildStepsNameMap( stepsPath, cache );
+    expect( map2 ).toBe( map1 );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'getLocalNameFromDestructuredProperty: handles { a }, { a: b }, { a: b = 1 }', () => {
+    // { a }
+    const p1 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'a' ), false, true );
+    expect( getLocalNameFromDestructuredProperty( p1 ) ).toBe( 'a' );
+    // { a: b }
+    const p2 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'b' ) );
+    expect( getLocalNameFromDestructuredProperty( p2 ) ).toBe( 'b' );
+    // { a: b = 1 }
+    const p3 = t.objectProperty( t.identifier( 'a' ), t.assignmentPattern( t.identifier( 'b' ), t.numericLiteral( 1 ) ) );
+    expect( getLocalNameFromDestructuredProperty( p3 ) ).toBe( 'b' );
+    // Unsupported shape
+    const p4 = t.objectProperty( t.identifier( 'a' ), t.arrayExpression( [] ) );
+    expect( getLocalNameFromDestructuredProperty( p4 ) ).toBeNull();
+  } );
+
+  it( 'buildWorkflowNameMap: reads named and default workflow names and caches', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-flow-' ) );
+    const wfPath = join( dir, 'workflow.js' );
+    writeFileSync( wfPath, [
+      'export const FlowA = workflow({ name: "flow.a" })',
+      'export default workflow({ name: "flow.def" })'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const res1 = buildWorkflowNameMap( wfPath, cache );
+    expect( res1.named.get( 'FlowA' ) ).toBe( 'flow.a' );
+    expect( res1.default ).toBe( 'flow.def' );
+    expect( cache.get( wfPath ) ).toBe( res1 );
+    const res2 = buildWorkflowNameMap( wfPath, cache );
+    expect( res2 ).toBe( res1 );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'toFunctionExpression: converts arrow, wraps expression bodies', () => {
+    const arrowExprBody = t.arrowFunctionExpression( [ t.identifier( 'x' ) ], t.identifier( 'x' ) );
+    const arrowBlockBody = t.arrowFunctionExpression( [], t.blockStatement( [ t.returnStatement( t.numericLiteral( 1 ) ) ] ) );
+    const fn1 = toFunctionExpression( arrowExprBody );
+    const fn2 = toFunctionExpression( arrowBlockBody );
+    expect( t.isFunctionExpression( fn1 ) ).toBe( true );
+    expect( t.isBlockStatement( fn1.body ) ).toBe( true );
+    expect( t.isReturnStatement( fn1.body.body[0] ) ).toBe( true );
+    expect( t.isFunctionExpression( fn2 ) ).toBe( true );
+  } );
+
+  it( 'isStepsPath: matches steps.js at root or subpath', () => {
+    expect( isStepsPath( 'steps.js' ) ).toBe( true );
+    expect( isStepsPath( './steps.js' ) ).toBe( true );
+    expect( isStepsPath( '/a/b/steps.js' ) ).toBe( true );
+    expect( isStepsPath( 'steps.ts' ) ).toBe( false );
+    expect( isStepsPath( 'workflow.js' ) ).toBe( false );
+  } );
+
+  it( 'isWorkflowPath: matches workflow.js at root or subpath', () => {
+    expect( isWorkflowPath( 'workflow.js' ) ).toBe( true );
+    expect( isWorkflowPath( './workflow.js' ) ).toBe( true );
+    expect( isWorkflowPath( '/a/b/workflow.js' ) ).toBe( true );
+    expect( isWorkflowPath( 'workflow.ts' ) ).toBe( false );
+    expect( isWorkflowPath( 'steps.js' ) ).toBe( false );
+  } );
+
+  it( 'createThisMethodCall: builds this.method(\'name\', ...args) call', () => {
+    const call = createThisMethodCall( 'invoke', 'n', [ t.numericLiteral( 1 ), t.identifier( 'x' ) ] );
+    expect( t.isCallExpression( call ) ).toBe( true );
+    expect( t.isMemberExpression( call.callee ) ).toBe( true );
+    expect( t.isThisExpression( call.callee.object ) ).toBe( true );
+    expect( t.isIdentifier( call.callee.property, { name: 'invoke' } ) ).toBe( true );
+    expect( t.isStringLiteral( call.arguments[0], { value: 'n' } ) ).toBe( true );
+    expect( call.arguments.length ).toBe( 3 );
+  } );
+} );
+

package/src/errors.d.ts

@@ -1,3 +0,0 @@
-export declare class FatalError extends Error { }
-
-export declare class ValidationError extends Error { }