@output.ai/core 0.5.6 → 0.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/interface/evaluation_result.d.ts

@@ -158,3 +158,16 @@ export class EvaluationBooleanResult extends EvaluationResult {
    */
   constructor( args: EvaluationResultArgs<boolean> );
 }
+
+/**
+ * An evaluation result where the value is a verdict (pass, partial, fail)
+ * @extends EvaluationResult
+ */
+export class EvaluationVerdictResult extends EvaluationResult {
+  /**
+   * @constructor
+   * @param args - See {@link EvaluationResultArgs} for full parameter documentation.
+   * @param args.value - The verdict: 'pass', 'partial', or 'fail'.
+   */
+  constructor( args: EvaluationResultArgs<'pass' | 'partial' | 'fail'> );
+}

package/src/interface/evaluation_result.js

@@ -200,3 +200,16 @@ export class EvaluationBooleanResult extends EvaluationResult {
 export class EvaluationNumberResult extends EvaluationResult {
   static valueSchema = z.number();
 };
+
+/**
+ * An evaluation result that uses a verdict value (pass, partial, fail)
+ * @extends EvaluationResult
+ * @property {'pass' | 'partial' | 'fail'} value - The evaluation verdict
+ * @constructor
+ * @param {object} args
+ * @param {'pass' | 'partial' | 'fail'} args.value - The verdict value
+ * @see EvaluationResult#constructor for other parameters (confidence, reasoning)
+ */
+export class EvaluationVerdictResult extends EvaluationResult {
+  static valueSchema = z.enum( [ 'pass', 'partial', 'fail' ] );
+};

package/src/interface/index.js

@@ -1,4 +1,10 @@
-import { EvaluationStringResult, EvaluationNumberResult, EvaluationBooleanResult, EvaluationFeedback } from './evaluation_result.js';
+import {
+  EvaluationStringResult,
+  EvaluationNumberResult,
+  EvaluationBooleanResult,
+  EvaluationVerdictResult,
+  EvaluationFeedback
+} from './evaluation_result.js';
 import { evaluator } from './evaluator.js';
 import { step } from './step.js';
 import { workflow } from './workflow.js';
@@ -12,6 +18,7 @@ export {
   EvaluationNumberResult,
   EvaluationStringResult,
   EvaluationBooleanResult,
+  EvaluationVerdictResult,
   EvaluationFeedback,
   executeInParallel,
   sendHttpRequest,

package/src/interface/workflow.d.ts

@@ -51,7 +51,7 @@ export type WorkflowContext<
      *
      * @returns True if a continue-as-new is suggested for the current run; otherwise false.
      */
-    isContinueAsNewSuggested: () => boolean
+    isContinueAsNewSuggested: () => boolean,
   },
 
   /**

package/src/interface/workflow.js

@@ -75,8 +75,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       // validation comes after setting memo to have that info already set for interceptor even if validations fail
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
 
-      // binds the methods called in the code that Webpack loader will add, they will exposed via "this"
-      const output = await fn.call( {
+      const dispatchers = {
         invokeStep: async ( stepName, input, options ) => steps[`${name}#${stepName}`]( input, options ),
         invokeSharedStep: async ( stepName, input, options ) => steps[`${SHARED_STEP_PREFIX}#${stepName}`]( input, options ),
         invokeEvaluator: async ( evaluatorName, input, options ) => steps[`${name}#${evaluatorName}`]( input, options ),
@@ -90,7 +89,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
          * @param {object} extra
          * @param {boolean} extra.detached
          * @param {import('@temporalio/workflow').ActivityOptions} extra.options
-         * @returns
+         * @returns {Promise<unknown>}
          */
         startWorkflow: async ( childName, input, extra = {} ) =>
           executeChild( childName, {
@@ -100,11 +99,12 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
             memo: {
               executionContext,
               parentId: workflowId,
-              // new configuration for activities of the child workflow, this will be omitted so it will use what that workflow have defined
               ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
             }
           } )
-      }, input, context );
+      };
+
+      const output = await fn.call( dispatchers, input, context );
 
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
 

package/src/interface/workflow.spec.js

@@ -447,34 +447,6 @@ describe( 'workflow()', () => {
     } );
   } );
 
-  describe( 'context.control', () => {
-    it( 'exposes info.workflowId and control/info namespaces when not in workflow context', async () => {
-      inWorkflowContextMock.mockReturnValue( false );
-      const { workflow } = await import( './workflow.js' );
-
-      const wf = workflow( {
-        name: 'control_wf',
-        description: 'Control',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {
-          workflowId: z.string(),
-          hasControl: z.boolean(),
-          hasInfo: z.boolean()
-        } ),
-        fn: async ( _, context ) => ( {
-          workflowId: context.info?.workflowId,
-          hasControl: 'control' in context,
-          hasInfo: 'info' in context
-        } )
-      } );
-
-      const result = await wf( {} );
-      expect( result.workflowId ).toBe( 'test-workflow' );
-      expect( result.hasControl ).toBe( true );
-      expect( result.hasInfo ).toBe( true );
-    } );
-  } );
-
   describe( 'error handling (root workflow)', () => {
     it( 'rethrows error from fn and rejects with same message', async () => {
       const { workflow } = await import( './workflow.js' );

package/src/utils/index.d.ts

@@ -33,6 +33,14 @@ export function throws( error: Error ): void;
  */
 export function setMetadata( target: object, value: object ): void;
 
+/**
+ * Read metadata previously attached via setMetadata.
+ *
+ * @param target - The function or object to read metadata from.
+ * @returns The metadata object, or null if none is attached.
+ */
+export function getMetadata( target: Function ): { name: string; description?: string; type?: string } | null;
+
 /** Represents a {Response} serialized to plain object  */
 export type SerializedFetchResponse = {
   /** The response url */

package/src/utils/resolve_invocation_dir.js

@@ -8,8 +8,10 @@ const transformSeparators = path => path.replaceAll( '/', SEP );
 const defaultIgnorePaths = [
   '/@output.ai/core/',
   '/@output.ai/llm/',
+  '/@output.ai/evals/',
   '/sdk/core/',
   '/sdk/llm/',
+  '/sdk/evals/',
   'node:internal/',
   'evalmachine.',
   'webpack/bootstrap'

package/src/utils/utils.js

@@ -37,6 +37,13 @@ export const throws = e => {
 export const setMetadata = ( target, values ) =>
   Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
 
+/**
+ * Read metadata previously attached via setMetadata
+ * @param {Function} target
+ * @returns {object|null}
+ */
+export const getMetadata = target => target[METADATA_ACCESS_SYMBOL] ?? null;
+
 /**
  * Returns true if string value is stringbool and true
  * @param {string} v

package/src/worker/bundler_options.js

@@ -6,6 +6,17 @@ const workerDir = __dirname; // sdk/core/src/worker
 const interfaceDir = join( __dirname, '..', 'interface' );
 
 export const webpackConfigHook = config => {
+  // Prefer the "output-workflow-bundle" export condition when resolving packages.
+  // Packages that transitively depend on Node.js built-ins (which can't exist in the
+  // Temporal workflow bundle) can provide an alternative entry point under this condition
+  // that excludes the offending code paths. Packages without this condition fall through
+  // to the standard "import" / "module" / "default" conditions as normal.
+  config.resolve = config.resolve ?? {};
+  config.resolve.conditionNames = [
+    'output-workflow-bundle',
+    ...( config.resolve.conditionNames ?? [ 'import', 'module', 'webpack', 'default' ] )
+  ];
+
   config.module = config.module ?? { };
   config.module.rules = config.module.rules ?? [];
 

package/src/worker/webpack_loaders/tools.js

@@ -295,19 +295,46 @@ export const resolveNameFromOptions = ( optionsNode, consts, errorMessagePrefix
   throw new Error( `${errorMessagePrefix}: Missing required name property` ); // No name field found
 };
 
+/**
+ * Resolve a name from the first argument of a factory call.
+ * Handles two patterns:
+ * - String literal first arg: `verify('name', fn)` → returns 'name'
+ * - Identifier referencing top-level const: `verify(NAME, fn)` → resolves const
+ * - Object with name property: `evaluator({ name: '...' })` → delegates to resolveNameFromOptions
+ *
+ * @param {import('@babel/types').Expression} argNode - First argument to the factory call.
+ * @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 resolveNameFromArg = ( argNode, consts, errorMessagePrefix ) => {
+  if ( isStringLiteral( argNode ) ) {
+    return argNode.value;
+  }
+  if ( isIdentifier( argNode ) && consts.has( argNode.name ) ) {
+    return consts.get( argNode.name );
+  }
+  return resolveNameFromOptions( argNode, consts, errorMessagePrefix );
+};
+
 /**
  * Build a map of exported component identifiers to declared names by scanning a module.
- * Coerces only static, analyzable forms: `export const X = callee({ name: '...' })`.
+ * Matches any `export const X = identifier(...)` pattern — the callee name is intentionally
+ * unchecked because:
+ * - File path scoping (steps.js, evaluators.js) already constrains which files are parsed
+ * - External packages may define custom factory wrappers (e.g., verify() wraps evaluator())
+ * - Runtime metadata validation is the authoritative check for component type
+ * - Name extraction (resolveNameFromArg) rejects calls without a static name argument
  *
  * @param {object} params
  * @param {string} params.path - Absolute path to the module file.
  * @param {Map<string, Map<string,string>>} params.cache - Cache for memoizing results by file path.
- * @param {('step'|'evaluator')} params.calleeName - Factory function identifier to match.
  * @param {string} params.invalidMessagePrefix - Prefix used in thrown errors when name is invalid.
  * @returns {Map<string,string>} Map of `exportedIdentifier` -> `declaredName`.
  * @throws {Error} When names are missing, dynamic, or otherwise non-static.
  */
-const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix } ) => {
+const buildComponentNameMap = ( { path, cache, invalidMessagePrefix } ) => {
   if ( cache.has( path ) ) {
     return cache.get( path );
   }
@@ -319,10 +346,10 @@ const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix
     .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: calleeName } ) )
+        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee ) )
         .map( dec => [
           dec,
-          resolveNameFromOptions( dec.init.arguments[0], consts, `${invalidMessagePrefix} ${path} for "${dec.id.name}"` )
+          resolveNameFromArg( dec.init.arguments[0], consts, `${invalidMessagePrefix} ${path} for "${dec.id.name}"` )
         ] )
         .forEach( ( [ dec, name ] ) => map.set( dec.id.name, name ) );
       return map;
@@ -335,7 +362,6 @@ const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix
 export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'step',
   invalidMessagePrefix: 'Invalid step name in'
 } );
 
@@ -351,13 +377,13 @@ export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
 export const buildSharedStepsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'step',
   invalidMessagePrefix: 'Invalid shared step name in'
 } );
 
 /**
  * Build a map from exported evaluator identifier to declared evaluator name.
- * Parses `evaluators.js` for `export const X = evaluator({ name: '...' })`.
+ * Matches `export const X = evaluator({ name: '...' })` and wrapper patterns
+ * like `export const X = verify('name', fn)`.
  *
  * @param {string} path - Absolute path to the evaluators module file.
  * @param {Map<string, Map<string,string>>} cache - Cache of computed evaluator name maps.
@@ -367,7 +393,6 @@ export const buildSharedStepsNameMap = ( path, cache ) => buildComponentNameMap(
 export const buildEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'evaluator',
   invalidMessagePrefix: 'Invalid evaluator name in'
 } );
 
@@ -383,7 +408,6 @@ export const buildEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap(
 export const buildSharedEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'evaluator',
   invalidMessagePrefix: 'Invalid shared evaluator name in'
 } );
 
@@ -411,8 +435,8 @@ export const buildWorkflowNameMap = ( path, cache ) => {
     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 ( isIdentifier( d.id ) && isCallExpression( d.init ) && isIdentifier( d.init.callee ) ) {
+          const name = resolveNameFromArg( d.init.arguments[0], consts, `Invalid workflow name in ${path} for '${d.id.name}` );
           if ( name ) {
             result.named.set( d.id.name, name );
           }
@@ -423,9 +447,9 @@ export const buildWorkflowNameMap = ( path, cache ) => {
     } else if (
       isExportDefaultDeclaration( node ) &&
       isCallExpression( node.declaration ) &&
-      isIdentifier( node.declaration.callee, { name: 'workflow' } )
+      isIdentifier( node.declaration.callee )
     ) {
-      result.default = resolveNameFromOptions( node.declaration.arguments[0], consts, `Invalid default workflow name in ${path}` );
+      result.default = resolveNameFromArg( node.declaration.arguments[0], consts, `Invalid default workflow name in ${path}` );
     }
   }
 

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

@@ -17,6 +17,7 @@ import {
   isSharedEvaluatorsPath,
   isWorkflowPath,
   createThisMethodCall,
+  resolveNameFromArg,
   resolveNameFromOptions,
   buildStepsNameMap,
   buildSharedStepsNameMap,
@@ -258,4 +259,72 @@ describe( 'workflow_rewriter tools', () => {
     expect( getFileKind( '/p/utils.js' ) ).toBe( null );
     expect( getFileKind( '/p/clients/api.js' ) ).toBe( null );
   } );
+
+  it( 'resolveNameFromArg: resolves string literal directly', () => {
+    expect( resolveNameFromArg( t.stringLiteral( 'my_name' ), new Map(), 'X' ) ).toBe( 'my_name' );
+  } );
+
+  it( 'resolveNameFromArg: resolves identifier from consts', () => {
+    const consts = new Map( [ [ 'MY_NAME', 'resolved_name' ] ] );
+    expect( resolveNameFromArg( t.identifier( 'MY_NAME' ), consts, 'X' ) ).toBe( 'resolved_name' );
+  } );
+
+  it( 'resolveNameFromArg: falls back to resolveNameFromOptions for objects', () => {
+    const opts = t.objectExpression( [ t.objectProperty( t.identifier( 'name' ), t.stringLiteral( 'obj_name' ) ) ] );
+    expect( resolveNameFromArg( opts, new Map(), 'X' ) ).toBe( 'obj_name' );
+  } );
+
+  it( 'buildEvaluatorsNameMap: reads names from string-arg factory pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, 'export const EvalA = verify( \'eval_a\', async () => {} )' );
+    const cache = new Map();
+    const map = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildEvaluatorsNameMap: reads names from object-arg verify pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-obj-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, 'export const EvalA = verify( { name: \'eval_a\' }, async () => {} )' );
+    const cache = new Map();
+    const map = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildEvaluatorsNameMap: reads names from mixed factory patterns', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-mixed-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, [
+      'export const EvalA = verify( { name: \'eval_a\' }, async () => {} )',
+      'export const EvalB = evaluator( { name: \'eval_b\' } )'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const map = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
+    expect( map.get( 'EvalB' ) ).toBe( 'eval_b' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildStepsNameMap: reads names from string-arg factory pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-steps-' ) );
+    const stepsPath = join( dir, 'steps.js' );
+    writeFileSync( stepsPath, 'export const StepA = myStepHelper( \'step_a\', async () => {} )' );
+    const cache = new Map();
+    const map = buildStepsNameMap( stepsPath, cache );
+    expect( map.get( 'StepA' ) ).toBe( 'step_a' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildWorkflowNameMap: reads names from string-arg factory pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-workflow-' ) );
+    const wfPath = join( dir, 'workflow.js' );
+    writeFileSync( wfPath, 'export default myWorkflowHelper( { name: \'my_flow\' } )' );
+    const cache = new Map();
+    const res = buildWorkflowNameMap( wfPath, cache );
+    expect( res.default ).toBe( 'my_flow' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
 } );

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

@@ -76,66 +76,70 @@ const obj = {};`;
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM import from evaluators.js uses step() instead of evaluator()', () => {
+  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 BadExport = step({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
 
-    const source = 'import { BadExport } from \'./evaluators.js\';';
+    const source = 'import { MyExport } from \'./evaluators.js\';';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { evaluatorImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from evaluators file/ );
+    );
+    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM import from steps.js uses evaluator() instead of step()', () => {
+  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 BadExport = evaluator({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
 
-    const source = 'import { BadExport } from \'./steps.js\';';
+    const source = 'import { MyExport } from \'./steps.js\';';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { stepImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from steps file/ );
+    );
+    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS require from evaluators.js uses step() instead of evaluator()', () => {
+  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 BadExport = step({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
 
-    const source = 'const { BadExport } = require( \'./evaluators.js\' );';
+    const source = 'const { MyExport } = require( \'./evaluators.js\' );';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { evaluatorImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from evaluators file/ );
+    );
+    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS require from steps.js uses evaluator() instead of step()', () => {
+  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 BadExport = evaluator({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
 
-    const source = 'const { BadExport } = require( \'./steps.js\' );';
+    const source = 'const { MyExport } = require( \'./steps.js\' );';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { stepImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from steps file/ );
+    );
+    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
@@ -259,19 +263,19 @@ const obj = {};`;
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS shared steps require uses evaluator() instead of step()', () => {
+  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 BadExport = evaluator({ name: \'bad\' });'
+      'export const MyExport = evaluator({ name: \'bad\' });'
     );
 
-    const source = 'const { BadExport } = require( \'../../shared/steps/common.js\' );';
+    const source = 'const { MyExport } = require( \'../../shared/steps/common.js\' );';
     const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( () => collectTargetImports(
+    const { sharedStepImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
       {
@@ -279,49 +283,52 @@ const obj = {};`;
         evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(),
         workflowNameCache: new Map()
       }
-    ) ).toThrow( /Unresolved import 'BadExport' from shared steps file/ );
+    );
+    expect( sharedStepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS shared evaluator require uses step() instead of evaluator()', () => {
+  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 BadExport = step({ name: \'bad\' });'
+      'export const MyExport = step({ name: \'bad\' });'
     );
 
-    const source = 'const { BadExport } = require( \'../../shared/evaluators/common.js\' );';
+    const source = 'const { MyExport } = require( \'../../shared/evaluators/common.js\' );';
     const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( () => collectTargetImports(
+    const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from shared evaluators file/ );
+    );
+    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM shared evaluator import uses step() instead of evaluator()', () => {
+  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 BadExport = step({ name: \'bad\' });'
+      'export const MyExport = step({ name: \'bad\' });'
     );
 
-    const source = 'import { BadExport } from \'../../shared/evaluators/common.js\';';
+    const source = 'import { MyExport } from \'../../shared/evaluators/common.js\';';
     const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( () => collectTargetImports(
+    const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from shared evaluators file/ );
+    );
+    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );

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

@@ -285,12 +285,12 @@ describe( 'workflow_validator loader', () => {
       rmSync( dir, { recursive: true, force: true } );
     } );
 
-    it( 'workflow.js: allows imports from ../../shared/clients/pokeapi.js', async () => {
-      const dir = mkdtempSync( join( tmpdir(), 'wf-shared-clients-' ) );
+    it( 'workflow.js: allows imports from ../../clients/pokeapi.js', async () => {
+      const dir = mkdtempSync( join( tmpdir(), 'wf-clients-' ) );
       mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-      mkdirSync( join( dir, 'shared', 'clients' ), { recursive: true } );
-      writeFileSync( join( dir, 'shared', 'clients', 'pokeapi.js' ), 'export const getPokemon = () => {};\n' );
-      const src = 'import { getPokemon } from "../../shared/clients/pokeapi.js";';
+      mkdirSync( join( dir, 'clients' ), { recursive: true } );
+      writeFileSync( join( dir, 'clients', 'pokeapi.js' ), 'export const getPokemon = () => {};\n' );
+      const src = 'import { getPokemon } from "../../clients/pokeapi.js";';
       await expect( runLoader( join( dir, 'workflows', 'my_workflow', 'workflow.js' ), src ) ).resolves.toBeTruthy();
       rmSync( dir, { recursive: true, force: true } );
     } );
@@ -305,12 +305,12 @@ describe( 'workflow_validator loader', () => {
       rmSync( dir, { recursive: true, force: true } );
     } );
 
-    it( 'steps.ts: allows imports from ../../shared/clients/redis.js', async () => {
-      const dir = mkdtempSync( join( tmpdir(), 'steps-shared-clients-' ) );
+    it( 'steps.ts: allows imports from ../../clients/redis.js', async () => {
+      const dir = mkdtempSync( join( tmpdir(), 'steps-clients-' ) );
       mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-      mkdirSync( join( dir, 'shared', 'clients' ), { recursive: true } );
-      writeFileSync( join( dir, 'shared', 'clients', 'redis.js' ), 'export const client = {};\n' );
-      const src = 'import { client } from "../../shared/clients/redis.js";';
+      mkdirSync( join( dir, 'clients' ), { recursive: true } );
+      writeFileSync( join( dir, 'clients', 'redis.js' ), 'export const client = {};\n' );
+      const src = 'import { client } from "../../clients/redis.js";';
       await expect( runLoader( join( dir, 'workflows', 'my_workflow', 'steps.js' ), src ) ).resolves.toBeTruthy();
       rmSync( dir, { recursive: true, force: true } );
     } );