@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

package/src/worker/webpack_loaders/{npm_workflow_export_resolve.js → workflow_validator/npm_workflow_export_resolve.js}

@@ -12,7 +12,7 @@ import {
   isStringLiteral
 } from '@babel/types';
 import { existsSync, readFileSync } from 'node:fs';
-import { parse, isWorkflowPath, buildWorkflowNameMap } from './tools.js';
+import { parse, isWorkflowPath, buildWorkflowNameMap } from '../tools.js';
 
 /**
  * Resolves bare npm imports to workflow runtime names:

package/src/worker/webpack_loaders/{npm_workflow_export_resolve.spec.js → workflow_validator/npm_workflow_export_resolve.spec.js}

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { parse } from './tools.js';
+import { parse } from '../tools.js';
 import {
   isBareNpmSpecifier,
   resolveBareImportSpecifiersAsWorkflows,

package/src/helpers/aggregations.js

@@ -1,44 +0,0 @@
-import { Attribute } from '#trace_attribute';
-import Decimal from 'decimal.js';
-
-/**
- * @typedef {object} Aggregation
- *
- * @property {object} cost
- * @property {object} cost.total - Total cost
- * @property {object} tokens
- * @property {object} tokens.total - Total tokens used
- * @property {object} tokens.input  - Total input tokens used
- * @property {object} tokens.input_cached - Total cached input tokens used
- * @property {object} tokens.output - Total output tokens used
- * @property {object} tokens.reasoning - Total reasoning tokens used
- * @property {object} httpRequests
- * @property {object} httpRequests.total - Total number of http requests made
- */
-/**
- * Aggregates a collection of Attributes into a object with totals
- *
- * @param {Attribute} attributes
- * @returns {Aggregation} aggregation object
- */
-export const aggregateAttributes = attributes => ( {
-  cost: {
-    total: attributes
-      .filter( a => [ Attribute.HTTPRequestCost.TYPE, Attribute.LLMUsage.TYPE ].includes( a.type ) )
-      .reduce( ( sum, a ) => sum.add( a.total ), Decimal( 0 ) ).toNumber()
-  },
-  tokens: {
-    total: attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .reduce( ( sum, a ) => sum.add( a.tokensUsed ), Decimal( 0 ) ).toNumber(),
-    ...Object.entries( attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .flatMap( a => a.usage )
-      .reduce( ( obj, a ) => Object.assign( obj, { [a.type]: ( obj[a.type] ?? Decimal( 0 ) ).add( a.amount ) } ), {} ) )
-      .reduce( ( obj, [ k, v ] ) => Object.assign( obj, { [k]: v.toNumber() } ), {} ) // convert all values to number
-
-  },
-  httpRequests: {
-    total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
-  }
-} );

package/src/helpers/aggregations.spec.js

@@ -1,92 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Attribute } from '#trace_attribute';
-import { aggregateAttributes } from './aggregations.js';
-
-describe( 'aggregateAttributes', () => {
-  it( 'returns zeroed aggregations when there are no attributes', () => {
-    expect( aggregateAttributes( [] ) ).toEqual( {
-      cost: { total: 0 },
-      tokens: { total: 0 },
-      httpRequests: { total: 0 }
-    } );
-  } );
-
-  it( 'aggregates costs, token usage, and HTTP request count by attribute type', () => {
-    const attributes = [
-      {
-        type: Attribute.HTTPRequestCount.TYPE,
-        url: 'https://api.example.test/a',
-        requestId: 'req-1'
-      },
-      {
-        type: Attribute.HTTPRequestCount.TYPE,
-        url: 'https://api.example.test/b',
-        requestId: 'req-2'
-      },
-      {
-        type: Attribute.HTTPRequestCost.TYPE,
-        url: 'https://api.example.test/a',
-        requestId: 'req-1',
-        total: 0.2
-      },
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'gpt-4o',
-        total: 0.3,
-        tokensUsed: 120,
-        usage: [
-          { type: 'input', ppm: 1, amount: 100, total: 0.1 },
-          { type: 'output', ppm: 2, amount: 20, total: 0.2 }
-        ]
-      },
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'gpt-4o-mini',
-        total: 0.05,
-        tokensUsed: 30,
-        usage: [
-          { type: 'input', ppm: 1, amount: 25, total: 0.025 },
-          { type: 'reasoning', ppm: 5, amount: 5, total: 0.025 }
-        ]
-      },
-      {
-        type: 'unrelated',
-        total: 100,
-        tokensUsed: 100
-      }
-    ];
-
-    expect( aggregateAttributes( attributes ) ).toEqual( {
-      cost: { total: 0.55 },
-      tokens: {
-        total: 150,
-        input: 125,
-        output: 20,
-        reasoning: 5
-      },
-      httpRequests: { total: 2 }
-    } );
-  } );
-
-  it( 'uses LLMUsage.tokensUsed for total tokens instead of summing usage amounts', () => {
-    const attributes = [
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'provider-model',
-        total: 0.1,
-        tokensUsed: 42,
-        usage: [
-          { type: 'input', ppm: 1, amount: 10, total: 0.01 },
-          { type: 'output', ppm: 1, amount: 5, total: 0.005 }
-        ]
-      }
-    ];
-
-    expect( aggregateAttributes( attributes ).tokens ).toEqual( {
-      total: 42,
-      input: 10,
-      output: 5
-    } );
-  } );
-} );
-

package/src/tracing/tools/utils.js

@@ -1,42 +0,0 @@
-import { inspect } from 'node:util';
-
-/**
- * @typedef {object} SerializedError
- * @property {string} name - The error constructor name
- * @property {string} message - The error message
- * @property {string} stack - The error stack trace
- */
-
-/**
- * Recursively Serialize an error object. Navigate using "cause" property.
- *
- * Goes up 10 levels deep.
- *
- * @param {Error} error
- * @returns {SerializedError}
- */
-export const serializeError = ( () => {
-
-  const serializeValue = v => {
-    try {
-      return JSON.parse( JSON.stringify( v ) );
-    } catch {
-      return inspect( v, { depth: 5, breakLength: Infinity, colors: false } );
-    }
-  };
-
-  return ( error, depth = 0 ) => {
-    if ( depth > 10 ) {
-      return { name: 'Error', message: 'Cause chain too deep' };
-    }
-    if ( error instanceof Error ) {
-      return {
-        name: error.constructor.name,
-        message: error.message,
-        stack: error.stack,
-        ...( error.cause !== undefined ? { cause: serializeError( error.cause, depth + 1 ) } : {} )
-      };
-    }
-    return serializeValue( error );
-  };
-} )();

package/src/tracing/tools/utils.spec.js

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { serializeError } from './utils.js';
-
-describe( 'serializeError', () => {
-  it( 'serializes basic Error fields', () => {
-    const error = new Error( 'boom' );
-
-    const result = serializeError( error );
-
-    expect( result ).toMatchObject( {
-      name: 'Error',
-      message: 'boom'
-    } );
-    expect( typeof result.stack ).toBe( 'string' );
-    expect( result ).not.toHaveProperty( 'cause' );
-  } );
-
-  it( 'preserves custom error constructor names', () => {
-    class CustomError extends Error {}
-    const error = new CustomError( 'custom boom' );
-
-    expect( serializeError( error ) ).toMatchObject( {
-      name: 'CustomError',
-      message: 'custom boom'
-    } );
-  } );
-
-  it( 'recursively serializes Error causes', () => {
-    const root = new TypeError( 'root failure' );
-    const wrapped = new Error( 'wrapped failure', { cause: root } );
-
-    expect( serializeError( wrapped ) ).toMatchObject( {
-      name: 'Error',
-      message: 'wrapped failure',
-      cause: {
-        name: 'TypeError',
-        message: 'root failure'
-      }
-    } );
-  } );
-
-  it( 'preserves JSON-serializable non-Error causes', () => {
-    const cause = {
-      code: 'bad_input',
-      path: [ 'items', 0, 'title' ],
-      message: 'Expected title'
-    };
-    const error = new Error( 'validation failed', { cause } );
-
-    expect( serializeError( error ) ).toMatchObject( {
-      name: 'Error',
-      message: 'validation failed',
-      cause
-    } );
-  } );
-
-  it( 'falls back to inspect for non-JSON-serializable causes', () => {
-    const cause = { name: 'circular' };
-    cause.self = cause;
-    const error = new Error( 'failed', { cause } );
-
-    const result = serializeError( error );
-
-    expect( result.cause ).toContain( 'circular' );
-    expect( result.cause ).toContain( 'Circular' );
-  } );
-
-  it( 'falls back to inspect for primitive values JSON cannot serialize', () => {
-    expect( serializeError( 1n ) ).toBe( '1n' );
-  } );
-
-  it( 'stops serializing cause chains after the depth limit', () => {
-    const makeErrorChain = depth => depth === 0 ?
-      new Error( 'leaf' ) :
-      new Error( `level ${depth}`, { cause: makeErrorChain( depth - 1 ) } );
-    const getCauseAtDepth = ( error, depth ) => depth === 0 ?
-      error :
-      getCauseAtDepth( error.cause, depth - 1 );
-
-    expect( getCauseAtDepth( serializeError( makeErrorChain( 11 ) ), 11 ) )
-      .toEqual( { name: 'Error', message: 'Cause chain too deep' } );
-  } );
-} );

package/src/worker/proxy.js

@@ -1,20 +0,0 @@
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
-import { createChildLogger } from '#logger';
-
-const log = createChildLogger( 'Proxy' );
-
-/**
- * Routes all `fetch()` calls (including those inside Temporal activities)
- * through an HTTP/HTTPS proxy when standard proxy env vars are set.
- * No-op when none are set.
- */
-export const bootstrapFetchProxy = () => {
-  const httpProxyUrl = process.env.http_proxy ?? process.env.HTTP_PROXY;
-  const httpsProxyUrl = process.env.https_proxy ?? process.env.HTTPS_PROXY;
-
-  if ( httpProxyUrl?.length > 0 || httpsProxyUrl?.length > 0 ) {
-    log.info( 'Proxy env vars detected, setting up global fetch dispatcher EnvHttpProxyAgent', { httpProxyUrl, httpsProxyUrl } );
-    /* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
-    setGlobalDispatcher( new EnvHttpProxyAgent( { allowH2: false } ) );
-  }
-};

package/src/worker/proxy.spec.js

@@ -1,51 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const mockSetGlobalDispatcher = vi.fn();
-const MockEnvHttpProxyAgent = vi.fn();
-const mockLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-
-vi.mock( 'undici', () => ( {
-  EnvHttpProxyAgent: MockEnvHttpProxyAgent,
-  setGlobalDispatcher: mockSetGlobalDispatcher
-} ) );
-
-vi.mock( '#logger', () => ( {
-  createChildLogger: () => mockLogger
-} ) );
-
-describe( 'worker/proxy', () => {
-  const proxyEnv = [ 'http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY' ];
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    for ( const key of proxyEnv ) {
-      delete process.env[key];
-    }
-  } );
-
-  afterEach( () => {
-    vi.resetModules();
-  } );
-
-  it( 'does nothing when no proxy env vars are set', async () => {
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).not.toHaveBeenCalled();
-    expect( mockSetGlobalDispatcher ).not.toHaveBeenCalled();
-    expect( mockLogger.info ).not.toHaveBeenCalled();
-  } );
-
-  it( 'sets global dispatcher when proxy URL is available', async () => {
-    process.env.HTTP_PROXY = 'http://proxy:8080/';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).toHaveBeenCalledWith( { allowH2: false } );
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-    expect( mockLogger.info ).toHaveBeenCalledWith(
-      'Proxy env vars detected, setting up global fetch dispatcher EnvHttpProxyAgent',
-      { httpProxyUrl: 'http://proxy:8080/', httpsProxyUrl: undefined }
-    );
-  } );
-} );

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

@@ -1,193 +0,0 @@
-import traverseModule from '@babel/traverse';
-import { isArrowFunctionExpression, isIdentifier } from '@babel/types';
-import {
-  toFunctionExpression,
-  createThisMethodCall,
-  isFunction,
-  bindThisAtCallSite,
-  isFunctionLikeBinding
-} from '../tools.js';
-
-// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
-const traverse = traverseModule.default ?? traverseModule;
-
-/**
- * Check whether a CallExpression callee is a simple Identifier.
- * Only direct identifier calls are rewritten; member/dynamic calls are skipped.
- *
- * We only support rewriting `Foo()` calls that refer to imported steps/evaluators
- * or local call-chain functions. Calls like `obj.Foo()` or `(getFn())()` are out of scope.
- *
- * Examples:
- * - Supported: `Foo()`
- * - Skipped:   `obj.Foo()`, `(getFn())()`
- *
- * @param {import('@babel/traverse').NodePath} cPath - Path to a CallExpression node.
- * @returns {boolean} True when callee is an Identifier.
- */
-const isIdentifierCallee = cPath => isIdentifier( cPath.node.callee );
-
-/**
- * Convert an ArrowFunctionExpression at the given path into a FunctionExpression
- * to ensure dynamic `this` semantics inside the function body.
- *
- * Workflow code relies on `this` to invoke steps/evaluators (e.g., `this.invokeStep(...)`).
- * Arrow functions capture `this` lexically, which would break that contract.
- *
- * If the node is an arrow, it is replaced by an equivalent FunctionExpression and
- * the `state.rewrote` flag is set. If not an arrow, this is a no-op.
- *
- * @param {import('@babel/traverse').NodePath} nodePath - Path to a function node.
- * @param {{ rewrote: boolean }} state - Mutation target to indicate a rewrite occurred.
- * @returns {void}
- */
-const normalizeArrowToFunctionPath = ( nodePath, state ) => {
-  if ( isArrowFunctionExpression( nodePath.node ) ) {
-    nodePath.replaceWith( toFunctionExpression( nodePath.node ) );
-    state.rewrote = true;
-  }
-};
-/**
- * Rewrite calls inside a function body and collect call-chain functions discovered within.
- * - Imported calls (steps/shared/evaluators) are rewritten to `this.invokeX`.
- * - Local call-chain function calls are rewritten to `fn.call(this, ...)` to bind `this` correctly.
- * - Returns a map of call-chain function name -> binding path for further recursive processing.
- *
- * @param {import('@babel/traverse').NodePath} bodyPath - Path to a function's body node.
- * @param {Array<{ list: Array<any>, method: string, key: string }>} descriptors - Import rewrite descriptors.
- * @param {{ rewrote: boolean }} state - Mutable state used to flag that edits were performed.
- * @returns {Map<string, import('@babel/traverse').NodePath>} Discovered call-chain function bindings.
- */
-const rewriteCallsInBody = ( bodyPath, descriptors, state ) => {
-  const callChainFunctions = new Map();
-  bodyPath.traverse( {
-    CallExpression: cPath => {
-      if ( !isIdentifierCallee( cPath ) ) {
-        return; // Only identifier callees are supported (skip member/dynamic)
-      }
-      const callee = cPath.node.callee;
-
-      // Rewrite imported calls (steps/shared/evaluators)
-      for ( const { list, method, key } of descriptors ) {
-        const found = list.find( x => x.localName === callee.name );
-        if ( found ) {
-          const args = cPath.node.arguments;
-          cPath.replaceWith( createThisMethodCall( method, found[key], args ) );
-          state.rewrote = true;
-          return;
-        }
-      }
-
-      // Rewrite local call-chain function calls and track for recursive processing
-      const binding = cPath.scope.getBinding( callee.name );
-      if ( !binding ) {
-        return;
-      }
-      if ( !isFunctionLikeBinding( binding.path.node ) ) {
-        return; // Not a function-like binding
-      }
-
-      // Queue call-chain function for recursive processing
-      if ( !callChainFunctions.has( callee.name ) ) {
-        callChainFunctions.set( callee.name, binding.path );
-      }
-
-      // Bind `this` at callsite: fn(...) -> fn.call(this, ...)
-      cPath.replaceWith( bindThisAtCallSite( callee.name, cPath.node.arguments ) );
-      state.rewrote = true;
-    }
-  } );
-  return callChainFunctions;
-};
-
-/**
- * Recursively process a call-chain function:
- * - Ensures the function is a FunctionExpression (converts arrow when needed).
- * - Rewrites calls inside the function using `rewriteCallsInBody`.
- * - Follows nested call-chain functions depth-first while avoiding cycles via `processedFns`.
- *
- * @param {object} params - Params for processing a call-chain function.
- * @param {string} params.name - Local identifier name in the current scope.
- * @param {import('@babel/traverse').NodePath} params.bindingPath - Binding path of the function declaration.
- * @param {{ rewrote: boolean }} params.state - Mutable state used to flag that edits were performed.
- * @param {Array<{ list: Array<any>, method: string, key: string }>} params.descriptors - Import rewrite descriptors.
- * @param {Set<string>} [params.processedFns] - Already processed names to avoid cycles.
- */
-const processFunction = ( { name, bindingPath, state, descriptors, processedFns = new Set() } ) => {
-  // Avoid infinite loops for recursive/repeated references
-  if ( processedFns.has( name ) || bindingPath.removed ) {
-    return;
-  }
-  processedFns.add( name );
-
-  if ( bindingPath.isVariableDeclarator() ) {
-    // Case 1: const foo = <function or arrow>
-    const initPath = bindingPath.get( 'init' );
-    // Arrow functions capture `this` lexically; normalize for dynamic `this`
-    normalizeArrowToFunctionPath( initPath, state );
-    // Rewrite calls in body; collect nested call-chain functions from this scope
-    const callChainFunctions = rewriteCallsInBody( initPath.get( 'body' ), descriptors, state );
-    // DFS: process nested call-chain functions (processedFns prevents cycles)
-    callChainFunctions.forEach( ( childBindingPath, childName ) => {
-      processFunction( { name: childName, bindingPath: childBindingPath, state, descriptors, processedFns } );
-    } );
-  } else if ( bindingPath.isFunctionDeclaration() ) {
-    // Case 2: function foo(...) { ... }
-    // Function declarations already have dynamic `this`; no normalization needed
-    const callChainFunctions = rewriteCallsInBody( bindingPath.get( 'body' ), descriptors, state );
-    // Continue DFS into any functions called from this declaration
-    callChainFunctions.forEach( ( childBindingPath, childName ) => {
-      processFunction( { name: childName, bindingPath: childBindingPath, state, descriptors, processedFns } );
-    } );
-  }
-};
-
-/**
- * Rewrite calls to imported steps/evaluators within `fn` object properties.
- * Converts arrow fns to functions and replaces `StepX(...)` with
- * `this.invokeStep('name', ...)`.
- *
- * @param {object} params
- * @param {import('@babel/types').File} params.ast - Parsed file AST.
- * @param {Array<{localName:string,stepName:string}>} params.stepImports - Step imports.
- * @param {Array<{localName:string,stepName:string}>} params.sharedStepImports - Shared step imports.
- * @param {Array<{localName:string,evaluatorName:string}>} params.evaluatorImports - Evaluator imports.
- * @returns {boolean} True if the AST was modified; false otherwise.
- */
-export default function rewriteFnBodies( { ast, stepImports, sharedStepImports = [], evaluatorImports, sharedEvaluatorImports = [] } ) {
-  const state = { rewrote: false };
-  // Build rewrite descriptors once per traversal
-  const descriptors = [
-    { list: stepImports, method: 'invokeStep', key: 'stepName' },
-    { list: sharedStepImports, method: 'invokeSharedStep', key: 'stepName' },
-    { list: evaluatorImports, method: 'invokeEvaluator', key: 'evaluatorName' },
-    { list: sharedEvaluatorImports, method: 'invokeSharedEvaluator', key: 'evaluatorName' }
-  ];
-  traverse( ast, {
-    ObjectProperty: path => {
-      // Only transform object properties named 'fn'
-      if ( !isIdentifier( path.node.key, { name: 'fn' } ) ) {
-        return;
-      }
-
-      const val = path.node.value;
-
-      // Only functions (including arrows) are eligible
-      if ( !isFunction( val ) && !isArrowFunctionExpression( val ) ) {
-        return;
-      }
-
-      // Normalize arrow to function for correct dynamic `this`
-      normalizeArrowToFunctionPath( path.get( 'value' ), state );
-
-      // Rewrite the main workflow fn body and collect call-chain functions discovered within it
-      const callChainFunctions = rewriteCallsInBody( path.get( 'value.body' ), descriptors, state );
-
-      // Recursively rewrite call-chain functions and any functions they call
-      callChainFunctions.forEach( ( bindingPath, name ) => {
-        processFunction( { name, bindingPath, state, descriptors } );
-      } );
-    }
-  } );
-  return state.rewrote;
-};

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

@@ -1,123 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import generatorModule from '@babel/generator';
-import { parse } from '../tools.js';
-import rewriteFnBodies from './rewrite_fn_bodies.js';
-
-const generate = generatorModule.default ?? generatorModule;
-
-describe( 'rewrite_fn_bodies', () => {
-  it( 'converts arrow to function and rewrites step calls without rewriting workflow calls', () => {
-    const src = `
-const obj = {
-  fn: async x => {
-    StepA( 1 );
-    FlowB( 2 );
-  }
-}`;
-    const ast = parse( src, 'file.js' );
-    const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
-
-    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [] } );
-    expect( rewrote ).toBe( true );
-
-    const { code } = generate( ast, { quotes: 'single' } );
-    expect( code ).toMatch( /this\.invokeStep\(([\"'])step\.a\1,\s*1\)/ );
-    expect( code ).toMatch( /FlowB\(2\)/ );
-  } );
-
-  it( 'rewrites evaluator calls to this.invokeEvaluator', () => {
-    const src = `
-const obj = {
-  fn: async x => {
-    EvalA(3);
-  }
-};`;
-    const ast = parse( src, 'file.js' );
-    const evaluatorImports = [ { localName: 'EvalA', evaluatorName: 'eval.a' } ];
-    const rewrote = rewriteFnBodies( { ast, stepImports: [], evaluatorImports } );
-    expect( rewrote ).toBe( true );
-  } );
-
-  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, stepImports: [], evaluatorImports: [] } );
-    expect( rewrote ).toBe( false );
-  } );
-
-  it( 'rewrites helper calls and helper bodies (steps and evaluators)', () => {
-    const src = `
-const foo = async () => {
-  StepA( 1 );
-};
-
-function bar( x ) {
-  EvalA( x );
-}
-
-const obj = {
-  fn: async x => {
-    foo();
-    bar( 2 );
-  }
-}`;
-
-    const ast = parse( src, 'file.js' );
-    const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
-    const evaluatorImports = [ { localName: 'EvalA', evaluatorName: 'eval.a' } ];
-
-    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports: [], evaluatorImports } );
-    expect( rewrote ).toBe( true );
-
-    const { code } = generate( ast, { quotes: 'single' } );
-
-    // Helper calls in fn are rewritten to call(this, ...)
-    expect( code ).toMatch( /foo\.call\(this\)/ );
-    expect( code ).toMatch( /bar\.call\(this,\s*2\)/ );
-
-    // Inside helpers, calls are rewritten
-    expect( code ).toMatch( /this\.invokeStep\(([\"'])step\.a\1,\s*1\)/ );
-    expect( code ).toMatch( /this\.invokeEvaluator\(([\"'])eval\.a\1,\s*x\)/ );
-
-    // Arrow helper converted to function expression to allow dynamic this
-    expect( code ).toMatch( /const foo = async function/ );
-  } );
-
-  it( 'rewrites nested helper chains until the step invocation', () => {
-    const src = `
-const foo = () => {
-  bar();
-};
-
-function bar() {
-  baz( 42 );
-}
-
-const baz = n => {
-  StepA( n );
-};
-
-const obj = {
-  fn: async () => {
-    foo();
-  }
-}`;
-
-    const ast = parse( src, 'file.js' );
-    const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
-    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [] } );
-    expect( rewrote ).toBe( true );
-
-    const { code } = generate( ast, { quotes: 'single' } );
-    // Calls along the chain are bound with this
-    expect( code ).toMatch( /foo\.call\(this\)/ );
-    expect( code ).toMatch( /bar\.call\(this\)/ );
-    expect( code ).toMatch( /baz\.call\(this,\s*42\)/ );
-    // Deep step rewrite in the last helper
-    expect( code ).toMatch( /this\.invokeStep\(([\"'])step\.a\1,\s*n\)/ );
-    // Arrow helpers converted to functions
-    expect( code ).toMatch( /const foo = function/ );
-    expect( code ).toMatch( /const baz = function/ );
-  } );
-} );
-