@output.ai/core 0.1.4 → 0.1.6

package/package.json

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

package/src/consts.js

@@ -1,4 +1,5 @@
 export const ACTIVITY_SEND_WEBHOOK = '__internal#sendWebhook';
+export const ACTIVITY_GET_TRACE_DESTINATIONS = '__internal#getTraceDestinations';
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
 export const SHARED_STEP_PREFIX = '__shared#';
 export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';

package/src/interface/workflow.js

@@ -2,7 +2,7 @@
 import { proxyActivities, inWorkflowContext, executeChild, workflowInfo } from '@temporalio/workflow';
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
-import { SHARED_STEP_PREFIX } from '#consts';
+import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
 import { mergeActivityOptions, resolveInvocationDir, setMetadata } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
@@ -36,6 +36,9 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
 
     const { workflowId, memo, startTime } = workflowInfo();
 
+    // Root workflows will not have the execution context yet, since it is set here.
+    const isRoot = !memo.executionContext;
+
     // Create the execution context object or preserve if it already exists:
     // It will always contains the information about the root workflow
     // It will be used to as context for tracing (connecting events)
@@ -57,12 +60,21 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       invokeEvaluator: async ( evaluatorName, input, options ) => steps[`${workflowPath}#${evaluatorName}`]( input, options ),
 
       startWorkflow: async ( childName, input ) => {
-        return executeChild( childName, { args: input ? [ input ] : [], memo: { executionContext, parentId: workflowId } } );
+        return executeChild( childName, {
+          args: input ? [ input ] : [],
+          workflowId: `${workflowId}-${childName}-${Date.now()}`,
+          memo: { executionContext, parentId: workflowId }
+        } );
       }
     }, input );
 
     validateWithSchema( outputSchema, output, `Workflow ${name} output` );
 
+    if ( isRoot ) {
+      const destinations = await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( { startTime, workflowId, workflowName: name } );
+      return { output, trace: { destinations } };
+    }
+
     return output;
   };
 

package/src/internal_activities/index.js

@@ -1,6 +1,8 @@
 import { FatalError } from '#errors';
-import { setMetadata } from '#utils';
+import { setMetadata, isStringboolTrue } from '#utils';
 import { ComponentType } from '#consts';
+import * as localProcessor from '../tracing/processors/local/index.js';
+import * as s3Processor from '../tracing/processors/s3/index.js';
 
 /**
  * Send a post to a given URL
@@ -37,3 +39,10 @@ export const sendWebhook = async ( { url, workflowId, payload } ) => {
 };
 
 setMetadata( sendWebhook, { type: ComponentType.INTERNAL_STEP } );
+
+export const getTraceDestinations = ( { startTime, workflowId, workflowName } ) => ( {
+  local: isStringboolTrue( process.env.TRACE_LOCAL_ON ) ? localProcessor.getDestination( { startTime, workflowId, workflowName } ) : null,
+  remote: isStringboolTrue( process.env.TRACE_REMOTE_ON ) ? s3Processor.getDestination( { startTime, workflowId, workflowName } ) : null
+} );
+
+setMetadata( getTraceDestinations, { type: ComponentType.INTERNAL_STEP } );

package/src/tracing/processors/local/index.js

@@ -27,6 +27,13 @@ export const init = () => {
   cleanupOldTempFiles();
 };
 
+const getOutputDir = workflowName => join( process.argv[2], 'logs', 'runs', workflowName );
+
+const buildOutputFileName = ( { startTime, workflowId } ) => {
+  const timestamp = new Date( startTime ).toISOString().replace( /[:T.]/g, '-' );
+  return `${timestamp}_${workflowId}.json`;
+};
+
 /**
  * Execute this processor:
  *
@@ -35,16 +42,26 @@ export const init = () => {
  * @param {object} args
  * @param {object} entry - Trace event phase
  * @param {object} executionContext - Execution info: workflowId, workflowName, startTime
- * @returns
+ * @returns {void}
  */
 export const exec = ( { entry, executionContext } ) => {
   const { workflowId, workflowName, startTime } = executionContext;
   const content = buildTraceTree( accumulate( { entry, executionContext } ) );
 
-  const timestamp = new Date( startTime ).toISOString().replace( /[:T.]/g, '-' );
-  const dir = join( process.argv[2], 'logs', 'runs', workflowName );
-  const path = join( dir, `${timestamp}_${workflowId}.json` );
+  const dir = getOutputDir( workflowName );
+  const path = join( dir, buildOutputFileName( { startTime, workflowId } ) );
 
   mkdirSync( dir, { recursive: true } );
   writeFileSync( path, JSON.stringify( content, undefined, 2 ) + EOL, 'utf-8' );
 };
+
+/**
+ * Returns where the trace is saved
+ * @param {object} args
+ * @param {string} args.startTime - The start time of the workflow
+ * @param {string} args.workflowId - The id of the workflow execution
+ * @param {string} args.workflowName - The name of the workflow
+ * @returns {string} The path where the trace will be saved
+ */
+export const getDestination = ( { startTime, workflowId, workflowName } ) =>
+  join( getOutputDir( workflowName ), buildOutputFileName( { workflowId, startTime } ) );

package/src/tracing/processors/s3/index.js

@@ -49,3 +49,14 @@ export const exec = async ( { entry, executionContext } ) => {
     content: JSON.stringify( content, undefined, 2 ) + EOL
   } ) : 0;
 };
+
+/**
+ * Returns where the trace is saved
+ * @param {object} args
+ * @param {string} args.startTime - The start time of the workflow
+ * @param {string} args.workflowId - The id of the workflow execution
+ * @param {string} args.workflowName - The name of the workflow
+ * @returns {string} The S3 url of the trace file
+ */
+export const getDestination = ( { startTime, workflowId, workflowName } ) =>
+  `https://${process.env.TRACE_REMOTE_S3_BUCKET}.s3.amazonaws.com/${getS3Key( { workflowId, workflowName, startTime } )}`;

package/src/tracing/tools/utils.js

@@ -19,10 +19,3 @@ export const serializeError = error =>
     message: error.message,
     stack: error.stack
   };
-
-/**
- * Returns true if string value is stringbool and true
- * @param {string} v
- * @returns
- */
-export const isStringboolTrue = v => [ '1', 'true', 'on' ].includes( v );

package/src/tracing/trace_engine.js

@@ -1,6 +1,7 @@
 import { Storage } from '#async_storage';
 import { EventEmitter } from 'node:events';
-import { serializeError, isStringboolTrue } from './tools/utils.js';
+import { serializeError } from './tools/utils.js';
+import { isStringboolTrue } from '#utils';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
 

package/src/utils/resolve_invocation_dir.js

@@ -28,8 +28,5 @@ export default ( additionalIgnorePaths = [] ) => {
   if ( !frame ) {
     throw new Error( `Invocation dir resolution via stack trace failed. Stack: ${stack}` );
   }
-  console.log( 'frame', frame );
-  const invocationDir = frame.file.replace( 'file://', '' ).split( SEP ).slice( 0, -1 ).join( SEP );
-  console.log( 'invocationDir', invocationDir );
-  return invocationDir;
+  return frame.file.replace( 'file://', '' ).split( SEP ).slice( 0, -1 ).join( SEP );
 };

package/src/utils/utils.js

@@ -35,3 +35,10 @@ export const mergeActivityOptions = ( base = {}, ext = {} ) =>
   Object.entries( ext ).reduce( ( options, [ k, v ] ) =>
     Object.assign( options, { [k]: typeof v === 'object' ? mergeActivityOptions( options[k], v ) : v } )
   , clone( base ) );
+
+/**
+ * Returns true if string value is stringbool and true
+ * @param {string} v
+ * @returns
+ */
+export const isStringboolTrue = v => [ '1', 'true', 'on' ].includes( v );

package/src/worker/bundler_options.js

@@ -0,0 +1,32 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname( fileURLToPath( import.meta.url ) );
+const workerDir = __dirname; // sdk/core/src/worker
+const interfaceDir = join( __dirname, '..', 'interface' );
+
+export const webpackConfigHook = config => {
+  config.module = config.module ?? { };
+  config.module.rules = config.module.rules ?? [];
+
+  // Validation loader (runs first)
+  config.module.rules.push( {
+    test: /\.js$/,
+    // Exclude node_modules and internal core worker files
+    exclude: resource => /node_modules/.test( resource ) || resource.startsWith( workerDir ) || resource.startsWith( interfaceDir ),
+    enforce: 'pre',
+    use: {
+      loader: join( __dirname, './webpack_loaders/workflow_validator/index.mjs' )
+    }
+  } );
+  // Use AST-based loader for rewriting steps/workflows
+  config.module.rules.push( {
+    test: /\.js$/,
+    // Exclude node_modules and internal core worker files
+    exclude: resource => /node_modules/.test( resource ) || resource.startsWith( workerDir ) || resource.startsWith( interfaceDir ),
+    use: {
+      loader: join( __dirname, './webpack_loaders/workflow_rewriter/index.mjs' )
+    }
+  } );
+  return config;
+};

package/src/worker/index.js

@@ -1,17 +1,14 @@
 import { Worker, NativeConnection } from '@temporalio/worker';
 import { Client } from '@temporalio/client';
 import { WorkflowIdConflictPolicy } from '@temporalio/common';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'node:url';
 import { address, apiKey, maxActivities, maxWorkflows, namespace, taskQueue, catalogId } from './configs.js';
 import { loadActivities, loadWorkflows, createWorkflowsEntryPoint } from './loader.js';
-import { ActivityExecutionInterceptor } from './interceptors/activity.js';
 import { sinks } from './sinks.js';
 import { createCatalog } from './catalog_workflow/index.js';
 import { init as initTracing } from '#tracing';
 import { WORKFLOW_CATALOG } from '#consts';
-
-const __dirname = dirname( fileURLToPath( import.meta.url ) );
+import { webpackConfigHook } from './bundler_options.js';
+import { initInterceptors } from './interceptors.js';
 
 // Get caller directory from command line arguments
 const callerDir = process.argv[2];
@@ -44,31 +41,10 @@ const callerDir = process.argv[2];
     workflowsPath,
     activities,
     sinks,
-    interceptors: {
-      workflowModules: [ join( __dirname, './interceptors/workflow.js' ) ],
-      activityInbound: [ () => new ActivityExecutionInterceptor( activities ) ]
-    },
+    interceptors: initInterceptors( { activities } ),
     maxConcurrentWorkflowTaskExecutions: maxWorkflows,
     maxConcurrentActivityTaskExecutions: maxActivities,
-    bundlerOptions: {
-      webpackConfigHook: config => {
-        if ( !config.module ) {
-          config.module = { };
-        }
-        if ( !config.module.rules ) {
-          config.module.rules = [];
-        }
-        // Use AST-based loader for rewriting steps/workflows
-        config.module.rules.push( {
-          test: /\.js$/,
-          exclude: /node_modules/,
-          use: {
-            loader: join( __dirname, './webpack_loaders/workflow_rewriter/index.mjs' )
-          }
-        } );
-        return config;
-      }
-    }
+    bundlerOptions: { webpackConfigHook }
   } );
 
   console.log( '[Core]', 'Starting catalog workflow...' );

package/src/worker/interceptors.js

@@ -0,0 +1,10 @@
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'node:url';
+import { ActivityExecutionInterceptor } from './interceptors/activity.js';
+
+const __dirname = dirname( fileURLToPath( import.meta.url ) );
+
+export const initInterceptors = ( { activities } ) => ( {
+  workflowModules: [ join( __dirname, './interceptors/workflow.js' ) ],
+  activityInbound: [ () => new ActivityExecutionInterceptor( activities ) ]
+} );

package/src/worker/loader.js

@@ -2,14 +2,15 @@ import { basename, dirname, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { EOL } from 'node:os';
 import { fileURLToPath } from 'url';
-import { sendWebhook } from '#internal_activities';
+import { getTraceDestinations, sendWebhook } from '#internal_activities';
 import { importComponents } from './loader_tools.js';
 import {
   ACTIVITY_SEND_WEBHOOK,
   ACTIVITY_OPTIONS_FILENAME,
   SHARED_STEP_PREFIX,
   WORKFLOWS_INDEX_FILENAME,
-  WORKFLOW_CATALOG
+  WORKFLOW_CATALOG,
+  ACTIVITY_GET_TRACE_DESTINATIONS
 } from '#consts';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
@@ -50,6 +51,7 @@ export async function loadActivities( target ) {
 
   // system activities
   activities[ACTIVITY_SEND_WEBHOOK] = sendWebhook;
+  activities[ACTIVITY_GET_TRACE_DESTINATIONS] = getTraceDestinations;
   return activities;
 };
 

package/src/worker/loader.spec.js

@@ -2,14 +2,18 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 vi.mock( '#consts', () => ( {
   ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
+  ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
+  SHARED_STEP_PREFIX: '/shared'
 } ) );
 
 const sendWebhookMock = vi.fn();
+const getTraceDestinationsMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhook: sendWebhookMock
+  sendWebhook: sendWebhookMock,
+  getTraceDestinations: getTraceDestinationsMock
 } ) );
 
 const importComponentsMock = vi.fn();

package/src/worker/webpack_loaders/consts.js

@@ -0,0 +1,19 @@
+export const NodeType = {
+  CONST: 'const'
+};
+
+export const ComponentFile = {
+  STEPS: 'steps',
+  SHARED_STEPS: 'shared_steps',
+  EVALUATORS: 'evaluators',
+  WORKFLOW: 'workflow'
+};
+
+export const ExtraneousFile = {
+  TYPES: 'types'
+};
+
+export const CoreModule = {
+  LOCAL: 'local_core',
+  NPM: '@output.ai/core'
+};

package/src/worker/webpack_loaders/{workflow_rewriter/tools.js → tools.js}

@@ -20,7 +20,7 @@ import {
   thisExpression,
   isExportDefaultDeclaration
 } from '@babel/types';
-import { NodeType } from './consts.js';
+import { ComponentFile, ExtraneousFile, NodeType } from './consts.js';
 
 /**
  * Resolve a relative module specifier against a base directory.
@@ -127,6 +127,37 @@ 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.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches types.js.
+ */
+export const isTypesPath = value => /(^|\/)types\.js$/.test( value );
+
+/**
+ * Determine file kind based on its path.
+ * @param {string} filename
+ * @returns {'workflow'|'steps'|'shared_steps'|'evaluators'|null}
+ */
+export const getFileKind = path => {
+  if ( isStepsPath( path ) ) {
+    return ComponentFile.STEPS;
+  }
+  if ( isSharedStepsPath( path ) ) {
+    return ComponentFile.SHARED_STEPS;
+  }
+  if ( isEvaluatorsPath( path ) ) {
+    return ComponentFile.EVALUATORS;
+  }
+  if ( isWorkflowPath( path ) ) {
+    return ComponentFile.WORKFLOW;
+  }
+  if ( isTypesPath( path ) ) {
+    return ExtraneousFile.TYPES;
+  }
+  return null;
+};
+
 /**
  * Create a `this.method(literalName, ...args)` CallExpression.
  * @param {string} method - Method name on `this`.

package/src/worker/webpack_loaders/{workflow_rewriter/tools.spec.js → tools.spec.js}

@@ -11,12 +11,16 @@ import {
   getLocalNameFromDestructuredProperty,
   toFunctionExpression,
   isStepsPath,
+  isSharedStepsPath,
+  isEvaluatorsPath,
   isWorkflowPath,
   createThisMethodCall,
   resolveNameFromOptions,
   buildStepsNameMap,
+  buildSharedStepsNameMap,
   buildWorkflowNameMap,
-  buildEvaluatorsNameMap
+  buildEvaluatorsNameMap,
+  getFileKind
 } from './tools.js';
 
 describe( 'workflow_rewriter tools', () => {
@@ -149,6 +153,22 @@ 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.ts' ) ).toBe( false );
+    expect( isEvaluatorsPath( '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 );
@@ -158,5 +178,30 @@ describe( 'workflow_rewriter tools', () => {
     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-' ) );
+    const stepsPath = join( dir, 'shared_steps.js' );
+    writeFileSync( stepsPath, [
+      'export const StepA = step({ name: "shared.step.a" })',
+      'export const StepB = step({ name: "shared.step.b" })'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const map1 = buildSharedStepsNameMap( stepsPath, cache );
+    expect( map1.get( 'StepA' ) ).toBe( 'shared.step.a' );
+    expect( map1.get( 'StepB' ) ).toBe( 'shared.step.b' );
+    expect( cache.get( stepsPath ) ).toBe( map1 );
+    const map2 = buildSharedStepsNameMap( stepsPath, cache );
+    expect( map2 ).toBe( map1 );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  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' );
+    expect( getFileKind( '/p/evaluators.js' ) ).toBe( 'evaluators' );
+    expect( getFileKind( '/p/other.js' ) ).toBe( null );
+  } );
 } );
 

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

@@ -10,7 +10,7 @@ import {
   buildSharedStepsNameMap,
   buildEvaluatorsNameMap,
   toAbsolutePath
-} from './tools.js';
+} from '../tools.js';
 import {
   isCallExpression,
   isIdentifier,

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

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { parse } from './tools.js';
+import { parse } from '../tools.js';
 import collectTargetImports from './collect_target_imports.js';
 
 function makeAst( source, filename ) {

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

@@ -1,6 +1,6 @@
 import { dirname } from 'node:path';
 import generatorModule from '@babel/generator';
-import { parse } from './tools.js';
+import { parse } from '../tools.js';
 
 import rewriteFnBodies from './rewrite_fn_bodies.js';
 import collectTargetImports from './collect_target_imports.js';

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

@@ -1,10 +1,6 @@
 import traverseModule from '@babel/traverse';
-import {
-  isArrowFunctionExpression,
-  isIdentifier,
-  isFunctionExpression
-} from '@babel/types';
-import { toFunctionExpression, createThisMethodCall } from './tools.js';
+import { isArrowFunctionExpression, isIdentifier, isFunctionExpression } from '@babel/types';
+import { toFunctionExpression, createThisMethodCall } from '../tools.js';
 
 // Handle CJS/ESM interop for Babel packages when executed as a webpack loader
 const traverse = traverseModule.default ?? traverseModule;

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parse } from './tools.js';
+import { parse } from '../tools.js';
 import rewriteFnBodies from './rewrite_fn_bodies.js';
 
 describe( 'rewrite_fn_bodies', () => {

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

@@ -0,0 +1,196 @@
+import traverseModule from '@babel/traverse';
+import { dirname } from 'node:path';
+import { parse, toAbsolutePath, getFileKind } from '../tools.js';
+import { ComponentFile, CoreModule, ExtraneousFile } from '../consts.js';
+import {
+  isCallExpression,
+  isFunctionExpression,
+  isArrowFunctionExpression,
+  isIdentifier,
+  isImportDefaultSpecifier,
+  isImportSpecifier,
+  isObjectPattern,
+  isObjectProperty,
+  isStringLiteral
+} from '@babel/types';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const traverse = traverseModule.default ?? traverseModule;
+
+/**
+ * Check if workflow dependencies
+ */
+const validateWorkflowImports = ( { specifier, filename } ) => {
+  const isCore = Object.values( CoreModule ).includes( specifier );
+  const isComponent = Object.values( ComponentFile ).includes( getFileKind( specifier ) );
+  const isAllowedExtraneous = getFileKind( specifier ) === ExtraneousFile.TYPES;
+  if ( !isCore && !isComponent && !isAllowedExtraneous ) {
+    throw new Error( `Invalid dependency in workflow.js: '${specifier}'. \
+Only evaluators, steps, shared_steps, types, workflows or @output.ai/* imports are allowed in ${filename}` );
+  }
+};
+
+/**
+ * Check if evaluators, steps or shared_steps import invalid dependencies
+ */
+const validateStepEvaluatorImports = ( { fileKind, specifier, filename } ) => {
+  if ( Object.values( ComponentFile ).includes( getFileKind( specifier ) ) ) {
+    throw new Error( `Invalid dependency in ${fileKind}.js: '${specifier}'. \
+Steps, shared_steps, evaluators or workflows are not allowed dependencies in ${filename}` );
+  }
+};
+
+/**
+ * Validate import for evaluators, steps, shared_steps, workflow
+ */
+const executeImportValidations = ( { fileKind, specifier, filename } ) => {
+  if ( fileKind === ComponentFile.WORKFLOW ) {
+    validateWorkflowImports( { fileKind, specifier, filename } );
+  } else if ( Object.values( ComponentFile ).includes( fileKind ) ) {
+    validateStepEvaluatorImports( { fileKind, specifier, filename } );
+  }
+};
+
+/**
+ * Webpack loader that validates imports and disallowed calls across modules.
+ * Returns the source unchanged unless a validation error is found.
+ *
+ * Rules enforced:
+ *  - evaluators.js `fn`: at each evaluator().fn body: calling any evaluator, step, shared_step or workflow is forbidden
+ *  - evaluators.js: may not import evaluators.js, steps.js/shared_steps.js, workflow.js
+ *  - shared_steps.js `fn`: at each step().fn body: calling any evaluator, step, shared_step or workflow is forbidden
+ *  - shared_steps.js: may not import evaluators.js, steps.js, shared_steps.js, workflow.js
+ *  - steps.js: at each step().fn body: calling any evaluator, step, shared_step or workflow is forbidden
+ *  - steps.js: may not import evaluators.js, steps.js, shared_steps.js, workflow.js
+ *  - workflow.js: may only import components: evaluators.js, steps.js, shared_steps.js, workflow.js; and files: types.js or `@output.ai/core`
+ *
+ * @param {string|Buffer} source
+ * @param {any} inputMap
+ * @this {import('webpack').LoaderContext<{}>}
+ */
+export default function workflowValidatorLoader( source, inputMap ) {
+  this.cacheable?.( true );
+  const callback = this.async?.() ?? this.callback;
+
+  try {
+    const filename = this.resourcePath;
+    const fileDir = dirname( filename );
+    const ast = parse( String( source ), filename );
+
+    const fileKind = getFileKind( filename );
+
+    // Collect local declarations and imported identifiers by type
+    const localStepIds = new Set();
+    const localEvaluatorIds = new Set();
+    const importedStepIds = new Set(); // includes shared_steps
+    const importedEvaluatorIds = new Set();
+    const importedWorkflowIds = new Set();
+
+    // First pass: module-level import validation + collect imported ids
+    traverse( ast, {
+      ImportDeclaration: path => {
+        const specifier = path.node.source.value;
+
+        executeImportValidations( { fileKind, specifier, filename } );
+
+        // Collect imported identifiers for later call checks
+        const accumulator = ( {
+          [ComponentFile.STEPS]: importedStepIds,
+          [ComponentFile.SHARED_STEPS]: importedStepIds,
+          [ComponentFile.EVALUATORS]: importedEvaluatorIds,
+          [ComponentFile.WORKFLOW]: importedWorkflowIds
+        } )[fileKind];
+        if ( accumulator ) {
+          for ( const s of path.node.specifiers ) {
+            if ( isImportSpecifier( s ) || isImportDefaultSpecifier( s ) ) {
+              accumulator.add( s.local.name );
+            }
+          }
+        }
+      },
+      VariableDeclarator: path => {
+        const init = path.node.init;
+        if ( !isCallExpression( init ) ) {
+          return;
+        }
+
+        // Collect local step/evaluator declarations: const X = step({...}) / evaluator({...})
+        if ( isIdentifier( init.callee, { name: 'step' } ) && isIdentifier( path.node.id ) ) {
+          localStepIds.add( path.node.id.name );
+        }
+        if ( isIdentifier( init.callee, { name: 'evaluator' } ) && isIdentifier( path.node.id ) ) {
+          localEvaluatorIds.add( path.node.id.name );
+        }
+
+        // CommonJS requires: validate source and collect identifiers
+        if ( isIdentifier( init.callee, { name: 'require' } ) ) {
+          const firstArg = init.arguments[0];
+          if ( !isStringLiteral( firstArg ) ) {
+            return;
+          }
+          const req = firstArg.value;
+          executeImportValidations( { fileKind, specifier: req, filename } );
+
+          // Collect imported identifiers from require patterns
+          if ( isStringLiteral( firstArg ) ) {
+            const reqType = getFileKind( toAbsolutePath( fileDir, req ) );
+            if ( [ ComponentFile.STEPS, ComponentFile.SHARED_STEPS ].includes( reqType ) && isObjectPattern( path.node.id ) ) {
+              for ( const prop of path.node.id.properties ) {
+                if ( isObjectProperty( prop ) && isIdentifier( prop.value ) ) {
+                  importedStepIds.add( prop.value.name );
+                }
+              }
+            }
+            if ( reqType === ComponentFile.EVALUATORS && isObjectPattern( path.node.id ) ) {
+              for ( const prop of path.node.id.properties ) {
+                if ( isObjectProperty( prop ) && isIdentifier( prop.value ) ) {
+                  importedEvaluatorIds.add( prop.value.name );
+                }
+              }
+            }
+            if ( reqType === ComponentFile.WORKFLOW && isIdentifier( path.node.id ) ) {
+              importedWorkflowIds.add( path.node.id.name );
+            }
+          }
+        }
+      }
+    } );
+
+    // Function-body call validations for steps/evaluators files
+    if ( [ ComponentFile.STEPS, ComponentFile.SHARED_STEPS, ComponentFile.EVALUATORS ].includes( fileKind ) ) {
+      traverse( ast, {
+        ObjectProperty: path => {
+          if ( !isIdentifier( path.node.key, { name: 'fn' } ) ) {
+            return;
+          }
+          const val = path.node.value;
+          if ( !isFunctionExpression( val ) && !isArrowFunctionExpression( val ) ) {
+            return;
+          }
+
+          path.get( 'value' ).traverse( {
+            CallExpression: cPath => {
+              const callee = cPath.node.callee;
+              if ( isIdentifier( callee ) ) {
+                const { name } = callee;
+                const violation = [
+                  [ 'step', localStepIds.has( name ) || importedStepIds.has( name ) ],
+                  [ 'evaluator', localEvaluatorIds.has( name ) || importedEvaluatorIds.has( name ) ],
+                  [ 'workflow', importedWorkflowIds.has( name ) ]
+                ].find( v => v[1] )?.[0];
+
+                if ( violation ) {
+                  throw new Error( `Invalid call in ${fileKind}.js fn: calling a ${violation} ('${name}') is not allowed in ${filename}` );
+                }
+              }
+            }
+          } );
+        }
+      } );
+    }
+
+    return callback( null, source, inputMap );
+  } catch ( err ) {
+    return callback( err );
+  }
+}

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

@@ -0,0 +1,248 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import validatorLoader from './index.mjs';
+
+function runLoader( filename, source ) {
+  return new Promise( ( resolve, reject ) => {
+    const ctx = {
+      resourcePath: filename,
+      cacheable: () => {},
+      async: () => ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) ),
+      callback: ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) )
+    };
+    validatorLoader.call( ctx, source, null );
+  } );
+}
+
+describe( 'workflow_validator loader', () => {
+  it( 'workflow.js: allows imports from steps/shared_steps/evaluators/workflow', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'wf-allow-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const S = step({ name: "s" })\n' );
+    writeFileSync( join( dir, 'shared_steps.js' ), 'export const SS = step({ name: "ss" })\n' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const E = evaluator({ name: "e" })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const W = workflow({ name: "w" })\n' );
+
+    const src = [
+      'import { S } from "./steps.js";',
+      'import { SS } from "./shared_steps.js";',
+      'import { E } from "./evaluators.js";',
+      'import { W } from "./workflow.js";',
+      'const x = 1;'
+    ].join( '\n' );
+
+    await expect( runLoader( join( dir, 'workflow.js' ), src ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'workflow.js: rejects external dependencies', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'wf-reject-' ) );
+    const src = 'import x from "./utils.js";';
+    await expect( runLoader( join( dir, 'workflow.js' ), src ) ).rejects.toThrow( /Invalid (import|dependency) in workflow\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'workflow.js: allows imports from @output.ai/core and local_core', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'wf-allow-external-' ) );
+    const src = [
+      'import a from "@output.ai/core";',
+      'import b from "local_core";',
+      'const z = 1;'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'workflow.js' ), src ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'steps.js: rejects importing steps/shared_steps/evaluators/workflow', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'steps-reject-' ) );
+    const src = 'import { S } from "./steps.js";';
+    await expect( runLoader( join( dir, 'steps.js' ), src ) ).rejects.toThrow( /Invalid (import|imports|dependency) in steps\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'steps.js: allows other imports', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'steps-allow-' ) );
+    const src = 'import x from "./util.js";\nconst obj = { fn: () => 1 };';
+    await expect( runLoader( join( dir, 'steps.js' ), src ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'evaluators.js: rejects importing evaluators/steps/shared_steps/workflow', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'evals-reject-' ) );
+    const src = 'import { E } from "./evaluators.js";';
+    await expect( runLoader( join( dir, 'evaluators.js' ), src ) ).rejects.toThrow( /Invalid (import|imports|dependency) in evaluators\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'steps.js: rejects calling another step/evaluator/workflow inside fn', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'steps-call-reject-' ) );
+    const src = [
+      'const A = step({ name: "a" });',
+      'const B = step({ name: "b" });',
+      'const obj = { fn: function() { B(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'steps.js' ), src ) ).rejects.toThrow( /Invalid call in .*\.js fn/ );
+
+    const src2 = [
+      'const E = evaluator({ name: "e" });',
+      'const obj = { fn: () => { E(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'steps.js' ), src2 ) ).rejects.toThrow( /Invalid call in .*\.js fn/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'evaluators.js: rejects calling another evaluator/step/workflow inside fn', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'evals-call-reject-' ) );
+    const src = [
+      'const E1 = evaluator({ name: "e1" });',
+      'const E2 = evaluator({ name: "e2" });',
+      'const obj = { fn: function() { E2(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'evaluators.js' ), src ) ).rejects.toThrow( /Invalid call in .*\.js fn/ );
+
+    const src2 = [
+      'const S = step({ name: "s" });',
+      'const obj = { fn: () => { S(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'evaluators.js' ), src2 ) ).rejects.toThrow( /Invalid call in .*\.js fn/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'steps.js/evaluators.js: allows calling unrelated local functions in fn', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'fn-allow-' ) );
+    const stepsSrc = [
+      'function helper() { return 1; }',
+      'const obj = { fn: function() { helper(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'steps.js' ), stepsSrc ) ).resolves.toBeTruthy();
+
+    const evalsSrc = [
+      'function helper() { return 1; }',
+      'const obj = { fn: () => { helper(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'evaluators.js' ), evalsSrc ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'workflow.js: allows require from steps/shared_steps/evaluators/workflow; rejects others', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'wf-req-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const S = step({ name: "s" })\n' );
+    writeFileSync( join( dir, 'shared_steps.js' ), 'export const SS = step({ name: "ss" })\n' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const E = evaluator({ name: "e" })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: "w" })\n' );
+    const ok = [
+      'const { S } = require("./steps.js");',
+      'const { SS } = require("./shared_steps.js");',
+      'const { E } = require("./evaluators.js");',
+      'const W = require("./workflow.js");'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'workflow.js' ), ok ) ).resolves.toBeTruthy();
+    const bad = 'const X = require("./util.js");';
+    await expect( runLoader( join( dir, 'workflow.js' ), bad ) ).rejects.toThrow( /Invalid (require|dependency) in workflow\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'steps.js: rejects importing shared_steps/evaluators/workflow variants', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'steps-reject2-' ) );
+    await expect( runLoader( join( dir, 'steps.js' ), 'import { SS } from "./shared_steps.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in steps\.js/ );
+    await expect( runLoader( join( dir, 'steps.js' ), 'import { E } from "./evaluators.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in steps\.js/ );
+    await expect( runLoader( join( dir, 'steps.js' ), 'import WF from "./workflow.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in steps\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'evaluators.js: rejects importing steps/shared_steps/workflow variants', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'evals-reject2-' ) );
+    await expect( runLoader( join( dir, 'evaluators.js' ), 'import { S } from "./steps.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in evaluators\.js/ );
+    await expect( runLoader( join( dir, 'evaluators.js' ), 'import { SS } from "./shared_steps.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in evaluators\.js/ );
+    await expect( runLoader( join( dir, 'evaluators.js' ), 'import WF from "./workflow.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in evaluators\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'top-level calls outside fn are allowed in steps.js and evaluators.js', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'toplevel-allowed-' ) );
+    const stepsTop = [ 'const A = step({ name: "a" });', 'A();' ].join( '\n' );
+    await expect( runLoader( join( dir, 'steps.js' ), stepsTop ) ).resolves.toBeTruthy();
+    const evaluatorsTop = [ 'const E = evaluator({ name: "e" });', 'E();' ].join( '\n' );
+    await expect( runLoader( join( dir, 'evaluators.js' ), evaluatorsTop ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'shared_steps.js: rejects importing steps/shared_steps/evaluators/workflow', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'shared-imp-reject-' ) );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), 'import { S } from "./steps.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in shared_steps\.js/ );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), 'import { SS } from "./shared_steps.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in shared_steps\.js/ );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), 'import { E } from "./evaluators.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in shared_steps\.js/ );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), 'import WF from "./workflow.js";' ) )
+      .rejects.toThrow( /Invalid (import|imports|dependency) in shared_steps\.js/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'shared_steps.js: rejects calling step/evaluator/workflow inside fn', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'shared-call-reject-' ) );
+    const src1 = [
+      'const A = step({ name: "a" });',
+      'const obj = { fn: function() { A(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), src1 ) ).rejects.toThrow( /Invalid call in .*\.js fn/ );
+
+    const src2 = [
+      'const E = evaluator({ name: "e" });',
+      'const obj = { fn: () => { E(); } };'
+    ].join( '\n' );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), src2 ) ).rejects.toThrow( /Invalid call in .*\.js fn/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'shared_steps.js: top-level calls outside fn are allowed', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'shared-toplevel-allowed-' ) );
+    const src = [ 'const A = step({ name: "a" });', 'A();' ].join( '\n' );
+    await expect( runLoader( join( dir, 'shared_steps.js' ), src ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'workflow.js: allows importing ./types.js and bare types', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'wf-types-allow-' ) );
+    writeFileSync( join( dir, 'types.js' ), 'export const T = {}\n' );
+    const src1 = 'import { T } from "./types.js";';
+    await expect( runLoader( join( dir, 'workflow.js' ), src1 ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'steps.js: rejects require of steps/shared_steps/evaluators/workflow; allows other require', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'steps-require-' ) );
+    await expect( runLoader( join( dir, 'steps.js' ), 'const { S } = require("./steps.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in steps\.js/ );
+    await expect( runLoader( join( dir, 'steps.js' ), 'const { SS } = require("./shared_steps.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in steps\.js/ );
+    await expect( runLoader( join( dir, 'steps.js' ), 'const { E } = require("./evaluators.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in steps\.js/ );
+    await expect( runLoader( join( dir, 'steps.js' ), 'const W = require("./workflow.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in steps\.js/ );
+    const ok = 'const util = require("./util.js");';
+    await expect( runLoader( join( dir, 'steps.js' ), ok ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'evaluators.js: rejects require of steps/shared_steps/workflow; allows other require', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'evals-require-' ) );
+    await expect( runLoader( join( dir, 'evaluators.js' ), 'const { S } = require("./steps.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in evaluators\.js/ );
+    await expect( runLoader( join( dir, 'evaluators.js' ), 'const { SS } = require("./shared_steps.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in evaluators\.js/ );
+    await expect( runLoader( join( dir, 'evaluators.js' ), 'const W = require("./workflow.js");' ) )
+      .rejects.toThrow( /Invalid (require|dependency) in evaluators\.js/ );
+    const ok = 'const util = require("./util.js");';
+    await expect( runLoader( join( dir, 'evaluators.js' ), ok ) ).resolves.toBeTruthy();
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );

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

@@ -1,3 +0,0 @@
-export const NodeType = {
-  CONST: 'const'
-};