@output.ai/core 0.2.2 → 0.3.0-dev.pr263-a59dd0e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.2.2",
+  "version": "0.3.0-dev.pr263-a59dd0e",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/worker/loader.js

@@ -1,4 +1,4 @@
-import { basename, dirname, join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { EOL } from 'node:os';
 import { fileURLToPath } from 'url';
@@ -35,8 +35,7 @@ const writeActivityOptionsFile = map => {
 export async function loadActivities( target ) {
   const activities = {};
   const activityOptionsMap = {};
-  for await ( const { fn, metadata, path } of importComponents( target, [ 'steps.js', 'evaluators.js', 'shared_steps.js' ] ) ) {
-    const isShared = basename( path ) === 'shared_steps.js';
+  for await ( const { fn, metadata, path, isShared } of importComponents( target, [ 'steps.js', 'evaluators.js' ] ) ) {
     const prefix = isShared ? SHARED_STEP_PREFIX : dirname( path );
 
     console.log( '[Core.Scanner]', 'Component loaded:', metadata.type, metadata.name, 'at', path );

package/src/worker/loader.spec.js

@@ -53,6 +53,27 @@ describe( 'worker/loader', () => {
     expect( mkdirSyncMock ).toHaveBeenCalled();
   } );
 
+  it( 'loadActivities uses SHARED_STEP_PREFIX for components with isShared flag', async () => {
+    const { loadActivities } = await import( './loader.js' );
+
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => 'local', metadata: { name: 'LocalStep' }, path: '/workflows/example/steps.js', isShared: false };
+      yield { fn: () => 'shared', metadata: { name: 'SharedStep' }, path: '/shared/steps/tools.js', isShared: true };
+    } );
+
+    const activities = await loadActivities( '/root' );
+
+    // Local step uses dirname as prefix
+    expect( activities['/workflows/example#LocalStep'] ).toBeTypeOf( 'function' );
+
+    // Shared step uses SHARED_STEP_PREFIX ('/shared' from mock)
+    expect( activities['/shared#SharedStep'] ).toBeTypeOf( 'function' );
+
+    // Verify they're different functions
+    expect( activities['/workflows/example#LocalStep']() ).toBe( 'local' );
+    expect( activities['/shared#SharedStep']() ).toBe( 'shared' );
+  } );
+
   it( 'loadWorkflows returns array of workflows with metadata', async () => {
     const { loadWorkflows } = await import( './loader.js' );
 

package/src/worker/loader_tools.js

@@ -7,14 +7,51 @@ import { readdirSync } from 'fs';
  * @typedef {object} CollectedFile
  * @property {string} path - The file path
  * @property {string} url - The resolved url of the file, ready to be imported
+ * @property {boolean} [isShared] - Whether this file is in a shared/steps/ directory
  */
 /**
  * @typedef {object} Component
  * @property {Function} fn - The loaded component function
  * @property {object} metadata - Associated metadata with the component
- * @property {string} path - Associated metadata with the component
+ * @property {string} path - The file path of the component
+ * @property {boolean} [isShared] - Whether this component is from a shared/steps/ directory
  */
 
+/**
+ * Check if the search is targeting step or evaluator files.
+ * @param {string[]} filenames - The filenames being searched for.
+ * @returns {boolean} True if searching for steps.js or evaluators.js.
+ */
+const isSearchingForStepFiles = filenames =>
+  filenames.includes( 'steps.js' ) || filenames.includes( 'evaluators.js' );
+
+/**
+ * Check if a directory is a shared steps directory.
+ * @param {string} dirName - The directory name.
+ * @param {string} parentPath - The parent path.
+ * @returns {boolean} True if this is a shared/steps directory.
+ */
+const isSharedStepsDirectory = ( dirName, parentPath ) =>
+  dirName === 'steps' && parentPath.endsWith( '/shared' );
+
+/**
+ * Collect all .js files from a shared steps directory.
+ * @param {string} dirPath - The directory path.
+ * @param {CollectedFile[]} collection - The collection to add files to.
+ */
+const collectSharedStepsFiles = ( dirPath, collection ) => {
+  for ( const entry of readdirSync( dirPath, { withFileTypes: true } ) ) {
+    if ( entry.isFile() && entry.name.endsWith( '.js' ) ) {
+      const filePath = resolve( dirPath, entry.name );
+      collection.push( {
+        path: filePath,
+        url: pathToFileURL( filePath ).href,
+        isShared: true
+      } );
+    }
+  }
+};
+
 /**
  * Recursive traverse directories looking for files with given name.
  *
@@ -30,7 +67,11 @@ const findByNameRecursively = ( parentPath, filenames, collection = [], ignoreDi
 
     const path = resolve( parentPath, entry.name );
     if ( entry.isDirectory() ) {
-      findByNameRecursively( path, filenames, collection );
+      if ( isSharedStepsDirectory( entry.name, parentPath ) && isSearchingForStepFiles( filenames ) ) {
+        collectSharedStepsFiles( path, collection );
+      } else {
+        findByNameRecursively( path, filenames, collection, ignoreDirNames );
+      }
     } else if ( filenames.includes( entry.name ) ) {
       collection.push( { path, url: pathToFileURL( path ).href } );
     }
@@ -50,14 +91,14 @@ const findByNameRecursively = ( parentPath, filenames, collection = [], ignoreDi
  * @yields {Component}
  */
 export async function *importComponents( target, filenames ) {
-  for ( const { url, path } of findByNameRecursively( target, filenames ) ) {
+  for ( const { url, path, isShared } of findByNameRecursively( target, filenames ) ) {
     const imported = await import( url );
     for ( const fn of Object.values( imported ) ) {
       const metadata = fn[METADATA_ACCESS_SYMBOL];
       if ( !metadata ) {
         continue;
       }
-      yield { fn, metadata, path };
+      yield { fn, metadata, path, isShared };
     }
   }
 };

package/src/worker/loader_tools.spec.js

@@ -86,4 +86,84 @@ describe( '.importComponents', () => {
 
     rmSync( root, { recursive: true, force: true } );
   } );
+
+  it( 'collects all .js files from shared/steps/ directory with isShared flag', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-shared` );
+    const sharedStepsDir = join( root, 'shared', 'steps' );
+    const workflowDir = join( root, 'workflows', 'example' );
+    mkdirSync( sharedStepsDir, { recursive: true } );
+    mkdirSync( workflowDir, { recursive: true } );
+
+    const sharedToolsFile = join( sharedStepsDir, 'tools.js' );
+    const sharedUtilsFile = join( sharedStepsDir, 'utils.js' );
+    const workflowStepsFile = join( workflowDir, 'steps.js' );
+
+    const sharedFileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const SharedStep = () => {};',
+      'SharedStep[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "sharedStep" };'
+    ].join( '\n' );
+    const workflowFileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const LocalStep = () => {};',
+      'LocalStep[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "localStep" };'
+    ].join( '\n' );
+    writeFileSync( sharedToolsFile, sharedFileContents );
+    writeFileSync( sharedUtilsFile, sharedFileContents );
+    writeFileSync( workflowStepsFile, workflowFileContents );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ 'steps.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 3 );
+
+    const sharedComponents = collected.filter( m => m.isShared === true );
+    const localComponents = collected.filter( m => !m.isShared );
+
+    expect( sharedComponents.length ).toBe( 2 );
+    expect( localComponents.length ).toBe( 1 );
+
+    expect( sharedComponents.map( m => m.path ).sort() ).toEqual( [ sharedToolsFile, sharedUtilsFile ].sort() );
+    expect( localComponents[0].path ).toBe( workflowStepsFile );
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'does not collect shared/steps/ files when searching for workflow.js', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-workflow-exclude` );
+    const sharedStepsDir = join( root, 'shared', 'steps' );
+    const workflowDir = join( root, 'workflows', 'example' );
+    mkdirSync( sharedStepsDir, { recursive: true } );
+    mkdirSync( workflowDir, { recursive: true } );
+
+    const sharedToolsFile = join( sharedStepsDir, 'tools.js' );
+    const workflowFile = join( workflowDir, 'workflow.js' );
+
+    const sharedFileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const SharedStep = () => {};',
+      'SharedStep[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "sharedStep" };'
+    ].join( '\n' );
+    const workflowFileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export default function myWorkflow() {};',
+      'myWorkflow[METADATA_ACCESS_SYMBOL] = { kind: "workflow", name: "myWorkflow" };'
+    ].join( '\n' );
+    writeFileSync( sharedToolsFile, sharedFileContents );
+    writeFileSync( workflowFile, workflowFileContents );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ 'workflow.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 1 );
+    expect( collected[0].path ).toBe( workflowFile );
+    expect( collected[0].metadata.kind ).toBe( 'workflow' );
+    expect( collected[0].isShared ).toBeUndefined();
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
 } );

package/src/worker/webpack_loaders/consts.js

@@ -5,23 +5,9 @@ export const NodeType = {
 export const ComponentFile = {
   EVALUATORS: 'evaluators',
   STEPS: 'steps',
-  SHARED_STEPS: 'shared_steps',
   WORKFLOW: 'workflow'
 };
 
-export const EXTRANEOUS_FILE = 'extraneous';
-export const ExtraneousFileList = [
-  'types',
-  'consts',
-  'constants',
-  'vars',
-  'variables',
-  'utils',
-  'tools',
-  'functions',
-  'shared'
-];
-
 export const CoreModule = {
   LOCAL: 'local_core',
   NPM: '@output.ai/core'

package/src/worker/webpack_loaders/tools.js

@@ -24,7 +24,15 @@ import {
   isExportDefaultDeclaration,
   isFunctionDeclaration
 } from '@babel/types';
-import { ComponentFile, EXTRANEOUS_FILE, ExtraneousFileList, NodeType } from './consts.js';
+import { ComponentFile, NodeType } from './consts.js';
+
+// Path pattern regexes - shared across multiple helper functions
+const STEPS_FILE_REGEX = /(^|\/)steps\.js$/;
+const STEPS_FOLDER_REGEX = /\/steps\/[^/]+\.js$/;
+const EVALUATORS_FILE_REGEX = /(^|\/)evaluators\.js$/;
+const EVALUATORS_FOLDER_REGEX = /\/evaluators\/[^/]+\.js$/;
+const PATH_TRAVERSAL_REGEX = /\.\.\//;
+const SHARED_PATH_REGEX = /\/shared\//;
 
 /**
  * Resolve a relative module specifier against a base directory.
@@ -104,25 +112,67 @@ export const toFunctionExpression = arrow => {
 };
 
 /**
- * Check if a module specifier or request string points to steps.js.
+ * 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
+ * This matches LOCAL steps only (no path traversal).
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches a local steps path.
+ */
+export const isStepsPath = value => {
+  // Exclude shared steps (paths with ../ or containing /shared/)
+  if ( PATH_TRAVERSAL_REGEX.test( value ) || SHARED_PATH_REGEX.test( value ) ) {
+    return false;
+  }
+  return STEPS_FILE_REGEX.test( value ) || STEPS_FOLDER_REGEX.test( value );
+};
+
+/**
+ * Check if a module specifier or request string points to shared steps.
+ * Shared steps are steps imported from outside the current workflow directory.
+ * Matches paths with ../ traversal or /shared/ and containing steps pattern.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches a shared steps path.
+ */
+export const isSharedStepsPath = value => {
+  const hasStepsPattern = STEPS_FILE_REGEX.test( value ) || STEPS_FOLDER_REGEX.test( value );
+  if ( !hasStepsPattern ) {
+    return false;
+  }
+  return PATH_TRAVERSAL_REGEX.test( value ) || SHARED_PATH_REGEX.test( value );
+};
+
+/**
+ * Check if a path matches any steps pattern (local or shared).
+ * Used for validation purposes.
  * @param {string} value - Module path or request string.
- * @returns {boolean} True if it matches steps.js.
+ * @returns {boolean} True if it matches any steps path pattern.
  */
-export const isStepsPath = value => /(^|\/)steps\.js$/.test( value );
+export const isAnyStepsPath = value =>
+  STEPS_FILE_REGEX.test( value ) || STEPS_FOLDER_REGEX.test( value );
 
 /**
- * Check if a module specifier or request string points to shared_steps.js.
+ * Check if a module specifier or request string points to evaluators.js or is in an evaluators folder.
+ * Matches: evaluators.js, /evaluators.js, /evaluators/*.js
  * @param {string} value - Module path or request string.
- * @returns {boolean} True if it matches shared_steps.js.
+ * @returns {boolean} True if it matches an evaluators path.
  */
-export const isSharedStepsPath = value => /(^|\/)shared_steps\.js$/.test( value );
+export const isEvaluatorsPath = value =>
+  EVALUATORS_FILE_REGEX.test( value ) || EVALUATORS_FOLDER_REGEX.test( value );
 
 /**
- * Check if a module specifier or request string points to evaluators.js.
+ * Check if a module specifier or request string points to shared evaluators.
+ * Shared evaluators are evaluators imported from outside the current workflow directory.
+ * Matches paths with ../ traversal or /shared/ and containing evaluators pattern.
  * @param {string} value - Module path or request string.
- * @returns {boolean} True if it matches evaluators.js.
+ * @returns {boolean} True if it matches a shared evaluators path.
  */
-export const isEvaluatorsPath = value => /(^|\/)evaluators\.js$/.test( value );
+export const isSharedEvaluatorsPath = value => {
+  const hasEvaluatorsPattern = EVALUATORS_FILE_REGEX.test( value ) || EVALUATORS_FOLDER_REGEX.test( value );
+  if ( !hasEvaluatorsPattern ) {
+    return false;
+  }
+  return PATH_TRAVERSAL_REGEX.test( value ) || SHARED_PATH_REGEX.test( value );
+};
 
 /**
  * Check if a module specifier or request string points to workflow.js.
@@ -132,35 +182,29 @@ export const isEvaluatorsPath = value => /(^|\/)evaluators\.js$/.test( value );
 export const isWorkflowPath = value => /(^|\/)workflow\.js$/.test( value );
 
 /**
- * Check if a module specifier or request string points to types.js.
+ * Check if a path is a component file (steps, evaluators, or workflow).
  * @param {string} value - Module path or request string.
- * @returns {boolean} True if it matches types.js.
+ * @returns {boolean} True if it matches any component file path.
  */
-export const isTypesPath = value => /(^|\/)types\.js$/.test( value );
-
-export const isExtraneousFile = value => ExtraneousFileList.map( t => new RegExp( `(^|\/)${t}\\.js$` ) ).find( rx => rx.test( value ) );
+export const isComponentFile = value =>
+  isAnyStepsPath( value ) || isEvaluatorsPath( value ) || isWorkflowPath( value );
 
 /**
  * Determine file kind based on its path.
- * @param {string} filename
- * @returns {'workflow'|'steps'|'shared_steps'|'evaluators'|null}
+ * Returns the component type if it's a component file, null otherwise.
+ * @param {string} path
+ * @returns {'workflow'|'steps'|'evaluators'|null}
  */
 export const getFileKind = path => {
-  if ( isStepsPath( path ) ) {
+  if ( isAnyStepsPath( path ) ) {
     return ComponentFile.STEPS;
   }
-  if ( isSharedStepsPath( path ) ) {
-    return ComponentFile.SHARED_STEPS;
-  }
   if ( isEvaluatorsPath( path ) ) {
     return ComponentFile.EVALUATORS;
   }
   if ( isWorkflowPath( path ) ) {
     return ComponentFile.WORKFLOW;
   }
-  if ( isExtraneousFile( path ) ) {
-    return EXTRANEOUS_FILE;
-  }
   return null;
 };
 
@@ -283,12 +327,12 @@ export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
 
 /**
  * Build a map from exported shared step identifier to declared step name.
- * Parses `shared_steps.js` for `export const X = step({ name: '...' })`.
- * Uses the same factory as regular steps.
+ * Same as buildStepsNameMap but for shared steps.
  *
  * @param {string} path - Absolute path to the shared steps module file.
- * @param {Map<string, Map<string,string>>} cache - Cache of computed name maps.
+ * @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 buildSharedStepsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve as resolvePath } from 'node:path';
 import * as t from '@babel/types';
@@ -12,7 +12,9 @@ import {
   toFunctionExpression,
   isStepsPath,
   isSharedStepsPath,
+  isAnyStepsPath,
   isEvaluatorsPath,
+  isSharedEvaluatorsPath,
   isWorkflowPath,
   createThisMethodCall,
   resolveNameFromOptions,
@@ -20,7 +22,6 @@ import {
   buildSharedStepsNameMap,
   buildWorkflowNameMap,
   buildEvaluatorsNameMap,
-  isExtraneousFile,
   getFileKind
 } from './tools.js';
 
@@ -138,14 +139,49 @@ describe( 'workflow_rewriter tools', () => {
     expect( t.isFunctionExpression( fn2 ) ).toBe( true );
   } );
 
-  it( 'isStepsPath: matches steps.js at root or subpath', () => {
+  it( 'isStepsPath: matches LOCAL steps.js (no path traversal)', () => {
+    // Local steps (without ../ or /shared/)
     expect( isStepsPath( 'steps.js' ) ).toBe( true );
     expect( isStepsPath( './steps.js' ) ).toBe( true );
     expect( isStepsPath( '/a/b/steps.js' ) ).toBe( true );
+    expect( isStepsPath( './steps/fetch.js' ) ).toBe( true );
+    // Shared steps (with ../ or /shared/) should NOT match isStepsPath
+    expect( isStepsPath( '../steps.js' ) ).toBe( false );
+    expect( isStepsPath( '../../shared/steps/common.js' ) ).toBe( false );
+    // Non-steps
     expect( isStepsPath( 'steps.ts' ) ).toBe( false );
     expect( isStepsPath( 'workflow.js' ) ).toBe( false );
   } );
 
+  it( 'isSharedStepsPath: matches steps imported from outside workflow directory', () => {
+    // Shared steps: must have steps pattern AND have path traversal or /shared/
+    expect( isSharedStepsPath( '../steps.js' ) ).toBe( true );
+    expect( isSharedStepsPath( '../../steps.js' ) ).toBe( true );
+    expect( isSharedStepsPath( '../../shared/steps/common.js' ) ).toBe( true );
+    expect( isSharedStepsPath( '../other_workflow/steps.js' ) ).toBe( true );
+    expect( isSharedStepsPath( '/src/shared/steps/common.js' ) ).toBe( true );
+    // Local steps (no traversal, no /shared/) should NOT match
+    expect( isSharedStepsPath( './steps.js' ) ).toBe( false );
+    expect( isSharedStepsPath( 'steps.js' ) ).toBe( false );
+    expect( isSharedStepsPath( './steps/fetch.js' ) ).toBe( false );
+    // Non-steps should NOT match
+    expect( isSharedStepsPath( '../utils.js' ) ).toBe( false );
+    expect( isSharedStepsPath( 'evaluators.js' ) ).toBe( false );
+  } );
+
+  it( 'isAnyStepsPath: matches any steps pattern (local or shared)', () => {
+    // Local steps
+    expect( isAnyStepsPath( 'steps.js' ) ).toBe( true );
+    expect( isAnyStepsPath( './steps.js' ) ).toBe( true );
+    expect( isAnyStepsPath( './steps/fetch.js' ) ).toBe( true );
+    // Shared steps
+    expect( isAnyStepsPath( '../steps.js' ) ).toBe( true );
+    expect( isAnyStepsPath( '../../shared/steps/common.js' ) ).toBe( true );
+    // Non-steps
+    expect( isAnyStepsPath( 'workflow.js' ) ).toBe( false );
+    expect( isAnyStepsPath( 'utils.js' ) ).toBe( false );
+  } );
+
   it( 'isWorkflowPath: matches workflow.js at root or subpath', () => {
     expect( isWorkflowPath( 'workflow.js' ) ).toBe( true );
     expect( isWorkflowPath( './workflow.js' ) ).toBe( true );
@@ -154,63 +190,29 @@ describe( 'workflow_rewriter tools', () => {
     expect( isWorkflowPath( 'steps.js' ) ).toBe( false );
   } );
 
-  it( 'isSharedStepsPath: matches shared_steps.js at root or subpath', () => {
-    expect( isSharedStepsPath( 'shared_steps.js' ) ).toBe( true );
-    expect( isSharedStepsPath( './shared_steps.js' ) ).toBe( true );
-    expect( isSharedStepsPath( '/a/b/shared_steps.js' ) ).toBe( true );
-    expect( isSharedStepsPath( 'shared_steps.ts' ) ).toBe( false );
-    expect( isSharedStepsPath( 'evaluators.js' ) ).toBe( false );
-  } );
-
   it( 'isEvaluatorsPath: matches evaluators.js at root or subpath', () => {
     expect( isEvaluatorsPath( 'evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( './evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( '/a/b/evaluators.js' ) ).toBe( true );
+    expect( isEvaluatorsPath( './evaluators/quality.js' ) ).toBe( true );
     expect( isEvaluatorsPath( 'evaluators.ts' ) ).toBe( false );
     expect( isEvaluatorsPath( 'steps.js' ) ).toBe( false );
   } );
 
-  it( 'isExtraneousFile: returns truthy for extraneous files (types/consts/constants/vars/variables)', () => {
-    const ok = [
-      'types.js',
-      './types.js',
-      '/a/b/types.js',
-      'consts.js',
-      './consts.js',
-      '/a/b/consts.js',
-      'constants.js',
-      './constants.js',
-      '/a/b/constants.js',
-      'vars.js',
-      './vars.js',
-      '/a/b/vars.js',
-      'variables.js',
-      './variables.js',
-      '/a/b/variables.js'
-    ];
-    for ( const p of ok ) {
-      expect( Boolean( isExtraneousFile( p ) ) ).toBe( true );
-    }
-  } );
-
-  it( 'isExtraneousFile: returns falsy for non-extraneous or non-.js files', () => {
-    const bad = [
-      'types.ts',
-      '/a/b/types.ts',
-      'types.mjs',
-      'variables.jsx',
-      'variables.mjs',
-      'myconstants.js',
-      'steps.js',
-      'evaluators.js',
-      'shared_steps.js',
-      'workflow.js',
-      'typess.js',
-      '/a/b/c/variables.json'
-    ];
-    for ( const p of bad ) {
-      expect( isExtraneousFile( p ) ).toBeFalsy();
-    }
+  it( 'isSharedEvaluatorsPath: matches evaluators imported from outside workflow directory', () => {
+    // Shared evaluators: must have evaluators pattern AND have path traversal or /shared/
+    expect( isSharedEvaluatorsPath( '../evaluators.js' ) ).toBe( true );
+    expect( isSharedEvaluatorsPath( '../../evaluators.js' ) ).toBe( true );
+    expect( isSharedEvaluatorsPath( '../../shared/evaluators/quality.js' ) ).toBe( true );
+    expect( isSharedEvaluatorsPath( '../other_workflow/evaluators.js' ) ).toBe( true );
+    expect( isSharedEvaluatorsPath( '/src/shared/evaluators/quality.js' ) ).toBe( true );
+    // Local evaluators (no traversal, no /shared/) should NOT match
+    expect( isSharedEvaluatorsPath( './evaluators.js' ) ).toBe( false );
+    expect( isSharedEvaluatorsPath( 'evaluators.js' ) ).toBe( false );
+    expect( isSharedEvaluatorsPath( './evaluators/quality.js' ) ).toBe( false );
+    // Non-evaluators should NOT match
+    expect( isSharedEvaluatorsPath( '../utils.js' ) ).toBe( false );
+    expect( isSharedEvaluatorsPath( 'steps.js' ) ).toBe( false );
   } );
 
   it( 'createThisMethodCall: builds this.method(\'name\', ...args) call', () => {
@@ -223,9 +225,10 @@ describe( 'workflow_rewriter tools', () => {
     expect( call.arguments.length ).toBe( 3 );
   } );
 
-  it( 'buildSharedStepsNameMap: reads names from shared_steps module and caches result', () => {
+  it( 'buildSharedStepsNameMap: reads names from shared steps module and caches result', () => {
     const dir = mkdtempSync( join( tmpdir(), 'tools-shared-steps-' ) );
-    const stepsPath = join( dir, 'shared_steps.js' );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
+    const stepsPath = join( dir, 'shared', 'steps', 'common.js' );
     writeFileSync( stepsPath, [
       'export const StepA = step({ name: "shared.step.a" })',
       'export const StepB = step({ name: "shared.step.b" })'
@@ -243,9 +246,13 @@ describe( 'workflow_rewriter tools', () => {
   it( 'getFileKind: classifies file by its path', () => {
     expect( getFileKind( '/p/workflow.js' ) ).toBe( 'workflow' );
     expect( getFileKind( '/p/steps.js' ) ).toBe( 'steps' );
-    expect( getFileKind( '/p/shared_steps.js' ) ).toBe( 'shared_steps' );
+    // Files in steps folder are steps
+    expect( getFileKind( '/p/steps/fetch.js' ) ).toBe( 'steps' );
+    expect( getFileKind( '/p/shared/steps/common.js' ) ).toBe( 'steps' );
     expect( getFileKind( '/p/evaluators.js' ) ).toBe( 'evaluators' );
+    expect( getFileKind( '/p/evaluators/quality.js' ) ).toBe( 'evaluators' );
     expect( getFileKind( '/p/other.js' ) ).toBe( null );
+    expect( getFileKind( '/p/utils.js' ) ).toBe( null );
+    expect( getFileKind( '/p/clients/api.js' ) ).toBe( null );
   } );
 } );
-

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import loader from './index.mjs';
@@ -48,12 +48,15 @@ const obj = {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'rewrites ESM shared_steps imports to invokeSharedStep', async () => {
+  it( 'rewrites ESM shared steps imports to invokeSharedStep', async () => {
+    // Create directory structure: shared/steps/common.js
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-shared-' ) );
-    writeFileSync( join( dir, 'shared_steps.js' ), 'export const SharedA = step({ name: \'shared.a\' });' );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedA = step({ name: \'shared.a\' });' );
 
     const source = `
-import { SharedA } from './shared_steps.js';
+import { SharedA } from '../../shared/steps/common.js';
 
 const obj = {
   fn: async (x) => {
@@ -61,21 +64,24 @@ const obj = {
   }
 }`;
 
-    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( code ).not.toMatch( /from '\.\/shared_steps\.js'/ );
+    expect( code ).not.toMatch( /from '\.\.\/\.\.\/shared\/steps\/common\.js'/ );
     expect( code ).toMatch( /fn:\s*async function \(x\)/ );
     expect( code ).toMatch( /this\.invokeSharedStep\('shared\.a',\s*1\)/ );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'rewrites CJS shared_steps requires to invokeSharedStep', async () => {
+  it( 'rewrites CJS shared steps requires to invokeSharedStep', async () => {
+    // Create directory structure: shared/steps/common.js
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-shared-' ) );
-    writeFileSync( join( dir, 'shared_steps.js' ), 'export const SharedB = step({ name: \'shared.b\' });' );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedB = step({ name: \'shared.b\' });' );
 
     const source = `
-const { SharedB } = require( './shared_steps.js' );
+const { SharedB } = require( '../../shared/steps/common.js' );
 
 const obj = {
   fn: async (y) => {
@@ -83,9 +89,9 @@ const obj = {
   }
 }`;
 
-    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( code ).not.toMatch( /require\('\.\/shared_steps\.js'\)/ );
+    expect( code ).not.toMatch( /require\('\.\.\/\.\.\/shared\/steps\/common\.js'\)/ );
     expect( code ).toMatch( /fn:\s*async function \(y\)/ );
     expect( code ).toMatch( /this\.invokeSharedStep\('shared\.b'\)/ );