@outputai/core 0.10.0 → 0.10.1-next.09ed166.0

package/src/worker/loader/activities.spec.js

@@ -5,8 +5,7 @@ vi.mock( '#consts', () => ( {
   ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
-  SHARED_STEP_PREFIX: '$shared'
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
 } ) );
 
 const sendHttpRequestMock = vi.fn();
@@ -63,6 +62,7 @@ describe( 'loadActivities', () => {
   it( 'loadActivities returns map including system activity and writes options file', async () => {
     const { loadActivities } = await import( './activities.js' );
 
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield {
         fn: () => {},
@@ -70,7 +70,6 @@ describe( 'loadActivities', () => {
         path: '/a/steps.js'
       };
     } );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     const { activities, optionsFile } = await loadActivities( '/root', workflows );
@@ -89,11 +88,11 @@ describe( 'loadActivities', () => {
 
   it( 'loadActivities omits activity options when component has no options or no activityOptions', async () => {
     const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'NoOptions' }, path: '/a/steps.js' };
       yield { fn: () => {}, metadata: { name: 'EmptyOptions', options: {} }, path: '/a/steps2.js' };
     } );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
 
     await loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] );
     const written = JSON.parse(
@@ -105,6 +104,7 @@ describe( 'loadActivities', () => {
 
   it( 'loadActivities throws when two activities in the same workflow share a name', async () => {
     const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/steps.js' };
       yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/evaluators.js' };
@@ -118,7 +118,6 @@ Activity names must be unique within a workflow.'
 
   it( 'loadActivities throws when two shared activities share a name', async () => {
     const { loadActivities } = await import( './activities.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/steps/a.js' };
       yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/evaluators/a.js' };
@@ -133,8 +132,8 @@ Activity names must be unique within a workflow.'
     const { loadActivities } = await import( './activities.js' );
     const workflowFiles = [ { path: '/a/steps/foo.js' } ];
     const sharedFiles = [ { path: '/root/shared/steps/baz.js' } ];
-    matchFilesMock.mockReturnValueOnce( workflowFiles );
     matchFilesMock.mockReturnValueOnce( sharedFiles );
+    matchFilesMock.mockReturnValueOnce( workflowFiles );
     importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {} );
 
@@ -143,12 +142,12 @@ Activity names must be unique within a workflow.'
 
     expect( matchFilesMock ).toHaveBeenCalledTimes( 2 );
     expect( buildActivityMatcherMock ).toHaveBeenCalledWith( '/a' );
-    expect( matchFilesMock ).toHaveBeenNthCalledWith( 1, '/a', [ activityMatcherMock ] );
-    expect( matchFilesMock ).toHaveBeenNthCalledWith( 2, '/root', [ sharedStepsDirMock, sharedEvaluatorsDirMock ] );
+    expect( matchFilesMock ).toHaveBeenNthCalledWith( 1, '/root', [ sharedStepsDirMock, sharedEvaluatorsDirMock ] );
+    expect( matchFilesMock ).toHaveBeenNthCalledWith( 2, '/a', [ activityMatcherMock ] );
 
     expect( importComponentsMock ).toHaveBeenCalledTimes( 2 );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, workflowFiles );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 2, sharedFiles );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, sharedFiles );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 2, workflowFiles );
   } );
 
   it( 'loads shared activities from external workflow packages', async () => {
@@ -157,8 +156,6 @@ Activity names must be unique within a workflow.'
     const localWorkflow = { name: 'Local', path: '/root/workflows/local/workflow.js' };
     const externalWorkflow = { name: 'External', path: '/root/node_modules/pkg/workflows/a/workflow.js', external: true };
     findSharedActivitiesFromWorkflowsMock.mockReturnValue( externalSharedFiles );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield {
         fn: () => {},
@@ -170,27 +167,29 @@ Activity names must be unique within a workflow.'
     const { activities } = await loadActivities( '/root', [ localWorkflow, externalWorkflow ] );
 
     expect( findSharedActivitiesFromWorkflowsMock ).toHaveBeenCalledWith( [ externalWorkflow ] );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 3, externalSharedFiles );
-    expect( activities['$shared#ExternalShared'] ).toBeTypeOf( 'function' );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, externalSharedFiles );
+    expect( activities['Local#ExternalShared'] ).toBeTypeOf( 'function' );
+    expect( activities['External#ExternalShared'] ).toBeTypeOf( 'function' );
     const written = JSON.parse(
       writeFileInTempDirMock.mock.calls[0][0].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
     );
-    expect( written['$shared#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
+    expect( written['Local#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
+    expect( written['External#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
   } );
 
   it( 'loadActivities includes nested workflow steps and shared evaluators', async () => {
     const { loadActivities } = await import( './activities.js' );
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
+      yield { fn: () => {}, metadata: { name: 'SharedEval' }, path: '/root/shared/evaluators/bar.js' };
     } );
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { fn: () => {}, metadata: { name: 'SharedEval' }, path: '/root/shared/evaluators/bar.js' };
+      yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
     } );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     const { activities } = await loadActivities( '/root', workflows );
     expect( activities['A#ActNested'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedEval'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedEval'] ).toBeTypeOf( 'function' );
   } );
 
   it( 'collects shared nested steps and evaluators across multiple subfolders', async () => {
@@ -205,9 +204,9 @@ Activity names must be unique within a workflow.'
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     const { activities } = await loadActivities( '/root', workflows );
-    expect( activities['$shared#SharedStepPrimary'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedStepSecondary'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedEvalPrimary'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedEvalSecondary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedStepPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedStepSecondary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedEvalPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedEvalSecondary'] ).toBeTypeOf( 'function' );
   } );
 } );

package/src/worker/loader/workflows.spec.js

@@ -5,8 +5,7 @@ vi.mock( '#consts', () => ( {
   ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
-  SHARED_STEP_PREFIX: '$shared'
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
 } ) );
 
 const { importComponentsMock, findWorkflowsInNodeModulesMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {

package/src/worker/log_hooks.js

@@ -1,4 +1,4 @@
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { createChildLogger } from '#logger';
 import { ACTIVITY_GET_TRACE_DESTINATIONS, BusEventType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
 
@@ -25,21 +25,21 @@ const serializedActivityFields = activityInfo => ( {
 
 const shouldLogActivity = activityInfo => activityInfo.activityType !== ACTIVITY_GET_TRACE_DESTINATIONS;
 
-messageBus.on( BusEventType.ACTIVITY_START, ( { activityInfo, outputActivityKind } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_START, ( { activityInfo, outputActivityKind } ) =>
   shouldLogActivity( activityInfo ) && activityLog.info( `Started ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.START,
     ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind } ) =>
   shouldLogActivity( activityInfo ) && activityLog.info( `Ended ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.END,
     ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
   shouldLogActivity( activityInfo ) && activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
     ...serializedActivityFields( activityInfo ),
@@ -47,7 +47,7 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
   activityLog[level]( message, {
     ...metadata ?? {},
     ...serializedActivityFields( activityInfo )
@@ -68,21 +68,21 @@ const serializeWorkflowFields = workflowDetails => ( {
 
 const shouldLogWorkflow = workflowDetails => workflowDetails.workflowType !== WORKFLOW_CATALOG;
 
-messageBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails } ) =>
   shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Started ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.START,
     ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
   shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Ended ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.END,
     ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
   shouldLogWorkflow( workflowDetails ) && workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
     ...serializeWorkflowFields( workflowDetails ),
@@ -90,7 +90,7 @@ messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
   workflowLog[level]( message, {
     ...metadata ?? {},
     ...serializeWorkflowFields( workflowDetails )

package/src/worker/log_hooks.spec.js

@@ -22,14 +22,14 @@ const createChildLoggerMock = vi.hoisted( () =>
 );
 
 const onHandlers = vi.hoisted( () => ( {} ) );
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   on: vi.fn( ( eventType, handler ) => {
     onHandlers[eventType] = handler;
   } )
 } ) );
 
 vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 
 import './log_hooks.js';
 

package/src/worker/sinks.js

@@ -1,6 +1,6 @@
 import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
@@ -12,15 +12,15 @@ export const sinks = {
   workflow: {
     log: {
       fn: ( workflowInfo, { level, message, metadata } ) => {
-        messageBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        mainEventBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
       },
       callDuringReplay: false
     },
     start: {
       fn: ( workflowInfo, input ) => {
         const { runId, workflowType, memo: { traceInfo }, parent } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_START, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
-        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+        mainEventBus.emit( BusEventType.WORKFLOW_START, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        if ( traceInfo ) {
           Tracing.addEventStart( {
             id: runId,
             kind: ComponentType.WORKFLOW,
@@ -37,8 +37,8 @@ export const sinks = {
     end: {
       fn: ( workflowInfo, output ) => {
         const { runId, memo: { traceInfo } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_END, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
-        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+        mainEventBus.emit( BusEventType.WORKFLOW_END, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        if ( traceInfo ) {
           Tracing.addEventEnd( { id: runId, details: output, traceInfo } );
         }
       },
@@ -48,8 +48,8 @@ export const sinks = {
     error: {
       fn: ( workflowInfo, error ) => {
         const { runId, memo: { traceInfo } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
-        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+        mainEventBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
+        if ( traceInfo ) {
           Tracing.addEventError( { id: runId, details: error, traceInfo } );
         }
       },

package/src/worker/sinks.spec.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { BusEventType, ComponentType } from '#consts';
 
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   emit: vi.fn()
 } ) );
 
@@ -15,7 +15,7 @@ const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
   runId: workflowInfo.runId
 } ) ) );
 
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '#tracing', () => ( {
   addEventStart: addEventStartMock,
   addEventEnd: addEventEndMock,
@@ -69,7 +69,7 @@ describe( 'worker/sinks', () => {
     } );
 
     expect( createWorkflowDetailsMock ).toHaveBeenCalledWith( workflowInfo );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
       level: 'info',
       message: 'workflow detail',
       metadata,
@@ -83,7 +83,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.start.fn( workflowInfo, input );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
     expect( addEventStartMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       kind: ComponentType.WORKFLOW,
@@ -99,7 +99,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.start.fn( { ...workflowInfo, memo: {} }, { value: 'input' } );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
     expect( addEventStartMock ).not.toHaveBeenCalled();
   } );
 
@@ -109,7 +109,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.end.fn( workflowInfo, output );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
     expect( addEventEndMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       details: output,
@@ -122,7 +122,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.end.fn( { ...workflowInfo, memo: {} }, { value: 'output' } );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
 
@@ -132,7 +132,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.error.fn( workflowInfo, error );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
     expect( addEventErrorMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       details: error,
@@ -146,7 +146,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
 

package/src/worker/webpack_loaders/consts.js

@@ -7,3 +7,9 @@ export const ComponentFile = {
   STEPS: 'steps',
   WORKFLOW: 'workflow'
 };
+
+export const ComponentFactory = {
+  EVALUATOR: 'evaluator',
+  STEP: 'step',
+  WORKFLOW: 'workflow'
+};

package/src/worker/webpack_loaders/tools.js

@@ -2,27 +2,14 @@ import parser from '@babel/parser';
 import { resolve as resolvePath } from 'node:path';
 import { readFileSync } from 'node:fs';
 import {
-  blockStatement,
-  callExpression,
-  functionExpression,
-  identifier,
-  isArrowFunctionExpression,
   isAssignmentPattern,
-  isBlockStatement,
   isCallExpression,
   isExportNamedDeclaration,
-  isFunctionExpression,
   isIdentifier,
-  isVariableDeclarator,
   isStringLiteral,
   isVariableDeclaration,
   isObjectExpression,
-  memberExpression,
-  returnStatement,
-  stringLiteral,
-  thisExpression,
-  isExportDefaultDeclaration,
-  isFunctionDeclaration
+  isExportDefaultDeclaration
 } from '@babel/types';
 import { ComponentFile, NodeType } from './consts.js';
 
@@ -100,17 +87,6 @@ export const getLocalNameFromDestructuredProperty = prop => {
   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 or is in a steps folder.
  * Matches: steps.js, /steps.js, /steps/*.js
@@ -231,38 +207,6 @@ export const getFileKind = path => {
   return null;
 };
 
-/**
- * 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 ] );
-
-/**
- * Build a CallExpression that binds `this` at the call site:
- *   fn(arg1, arg2) -> fn.call(this, arg1, arg2)
- *
- * When to use:
- * - Inside workflow `fn` rewriting, local call-chain functions must receive the dynamic `this`
- *   so that emitted `this.invokeStep(...)` and similar calls inside them operate correctly.
- *
- * Example:
- *   // Input AST intent:
- *   foo(a, b);
- *
- *   // Rewritten AST:
- *   foo.call(this, a, b);
- *
- * @param {string} calleeName - Identifier name of the function being called (e.g., 'foo').
- * @param {import('@babel/types').Expression[]} args - Original call arguments.
- * @returns {import('@babel/types').CallExpression} CallExpression node representing `callee.call(this, ...args)`.
- */
-export const bindThisAtCallSite = ( calleeName, args ) =>
-  callExpression( memberExpression( identifier( calleeName ), identifier( 'call' ) ), [ thisExpression(), ...args ] );
-
 /**
  * Resolve an options object's name property to a string.
  * Accepts literal strings or top-level const string identifiers.
@@ -466,92 +410,3 @@ export const buildWorkflowNameMap = ( path, cache ) => {
   return result;
 };
 
-/**
- * Determine whether a node represents a function body usable as a workflow `fn`.
- *
- * Why this matters:
- * - Workflow `fn` needs a dynamic `this` so the rewriter can emit calls like `this.invokeStep(...)`.
- * - Arrow functions do not have their own `this`; they capture `this` lexically, which breaks the runtime contract.
- *
- * Accepts:
- * - FunctionExpression (possibly async/generator), e.g.:
- *   const obj = {
- *     fn: async function (input) {
- *       return input;
- *     }
- *   };
- *
- * Rejects:
- * - ArrowFunctionExpression, e.g.:
- *   const obj = {
- *     fn: async (input) => input
- *   };
- *
- * - Any other non-function expression.
- *
- * Notes:
- * - The rewriter will proactively convert arrow `fn` to a FunctionExpression before further processing.
- *
- * @param {import('@babel/types').Expression} v - Candidate node for `fn` value.
- * @returns {boolean} True if `v` is a FunctionExpression and not an arrow function.
- */
-export const isFunction = v => isFunctionExpression( v ) && !isArrowFunctionExpression( v );
-
-/**
- * Determine whether a variable declarator represents a function-like value.
- *
- * Use case:
- * - When `fn` calls a locally-declared function (directly or transitively), we need to:
- *   - propagate `this` to that function call (`callee.call(this, ...)`)
- *   - traverse into that function's body to rewrite imported step/workflow/evaluator calls.
- *
- * Matches patterns like:
- * - Function expression:
- *   const foo = function (x) { return x + 1; };
- *
- * - Async/generator function expression:
- *   const foo = async function (x) { return await work(x); };
- *
- * - Arrow function (will be normalized to FunctionExpression by the rewriter):
- *   const foo = (x) => x + 1;
- *   const foo = async (x) => await work(x);
- *
- * Does not match:
- * - Non-function initializers:
- *   const foo = 42;
- *   const foo = someIdentifier;
- *
- * @param {import('@babel/types').Node} v - AST node (typically a VariableDeclarator).
- * @returns {boolean} True if the declarator's initializer is a function (arrow or function expression).
- */
-export const isVarFunction = v =>
-  isVariableDeclarator( v ) && ( isFunctionExpression( v.init ) || isArrowFunctionExpression( v.init ) );
-
-/**
- * Determine whether a binding node corresponds to a function-like declaration usable
- * as a call-chain function target during workflow rewriting.
- *
- * Matches:
- * - FunctionDeclaration:
- *     function foo(x) { return x + 1; }
- *
- * - VariableDeclarator initialized with a function or arrow (normalized later):
- *     const foo = function (x) { return x + 1; };
- *     const foo = (x) => x + 1;
- *
- * Non-matches:
- * - Any binding that is not a function declaration nor a variable declarator with a function initializer.
- *
- * Why this matters:
- * - The rewriter traverses call chains from the workflow `fn`. It must recognize which local
- *   callees are valid function bodies to rewrite and into which it can propagate `this`.
- *
- * @param {import('@babel/types').Node} node - Binding path node (FunctionDeclaration or VariableDeclarator).
- * @returns {boolean} True if the node represents a function-like binding.
- */
-export const isFunctionLikeBinding = node =>
-  isFunctionDeclaration( node ) ||
-  (
-    isVariableDeclarator( node ) &&
-    ( isFunctionExpression( node.init ) || isArrowFunctionExpression( node.init ) )
-  );

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

@@ -9,7 +9,6 @@ import {
   extractTopLevelStringConsts,
   getObjectKeyName,
   getLocalNameFromDestructuredProperty,
-  toFunctionExpression,
   isStepsPath,
   isSharedStepsPath,
   isAnyStepsPath,
@@ -17,7 +16,6 @@ import {
   isSharedEvaluatorsPath,
   isWorkflowPath,
   isAbsoluteWorkflowJsResource,
-  createThisMethodCall,
   resolveNameFromArg,
   resolveNameFromOptions,
   buildStepsNameMap,
@@ -130,17 +128,6 @@ describe( 'workflow_rewriter tools', () => {
     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 LOCAL steps.js (no path traversal)', () => {
     // Local steps (without ../ or /shared/)
     expect( isStepsPath( 'steps.js' ) ).toBe( true );
@@ -226,16 +213,6 @@ describe( 'workflow_rewriter tools', () => {
     expect( isSharedEvaluatorsPath( '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 );
-  } );
-
   it( 'buildSharedStepsNameMap: reads names from shared steps module and caches result', () => {
     const dir = mkdtempSync( join( tmpdir(), 'tools-shared-steps-' ) );
     mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );