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

package/package.json

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

package/src/index.d.ts

@@ -2,6 +2,18 @@ import type { z } from 'zod';
 import type { ActivityOptions } from '@temporalio/workflow';
 import type { SerializedFetchResponse } from './utils/index.d.ts';
 
+/**
+ * Similar to `Partial<T>` but applies to nested properties recursively, creating a deep optional variant of `T`:
+ * - Objects: All properties become optional, recursively.
+ * - Functions: Preserved as‑is (only the property itself becomes optional).
+ * - Primitives: Returned unchanged.
+ * Useful for config overrides with strong IntelliSense on nested fields and methods.
+ */
+type DeepPartial<T> =
+  T extends ( ...args: any[] ) => unknown ? T : // eslint-disable-line @typescript-eslint/no-explicit-any
+    T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } :
+      T;
+
 /**
  * Expose z from Zod as a convenience.
  */
@@ -211,7 +223,7 @@ export declare function step<
  *
  * Allows overriding Temporal Activity options for this workflow.
  */
-export type WorkflowInvocationConfiguration = {
+export type WorkflowInvocationConfiguration<Context extends WorkflowContext = WorkflowContext> = {
 
   /**
    * Native Temporal Activity options
@@ -223,6 +235,11 @@ export type WorkflowInvocationConfiguration = {
    * Detached workflows called without explicitly awaiting the result are "fire-and-forget" and may outlive the parent.
    */
   detached?: boolean
+
+  /**
+   * Allow to overwrite properties of the "context" of workflows when called in tests environments.
+   */
+  context?: DeepPartial<Context>
 };
 
 /**
@@ -265,7 +282,8 @@ export type WorkflowContext<
       ( input: z.infer<InputSchema> ) => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ) :
       () => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ),
 
-    /** Indicates whether the Temporal runtime suggests continuing this workflow as new.
+    /**
+     * Indicates whether the Temporal runtime suggests continuing this workflow as new.
      *
      * Use this to decide whether to `continueAsNew` before long waits or at loop boundaries.
      * Prefer returning the `continueAsNew(...)` call immediately when this becomes `true`.
@@ -275,6 +293,18 @@ export type WorkflowContext<
      * @returns True if a continue-as-new is suggested for the current run; otherwise false.
      */
     isContinueAsNewSuggested: () => boolean
+  },
+
+  /**
+   * Information about the workflow execution
+   */
+  info: {
+    /**
+     * Internal Temporal workflow id.
+     *
+     * @see {@link https://docs.temporal.io/workflow-execution/workflowid-runid#workflow-id}
+     */
+    workflowId: string
   }
 };
 
@@ -310,8 +340,10 @@ export type WorkflowFunction<
  */
 export type WorkflowFunctionWrapper<WorkflowFunction> =
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
-    ( input?: undefined | null, config?: WorkflowInvocationConfiguration ) => ReturnType<WorkflowFunction> :
-    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration ) => ReturnType<WorkflowFunction>;
+    ( input?: undefined | null, config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ReturnType<WorkflowFunction> :
+    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ReturnType<WorkflowFunction>;
 
 /**
  * Creates a workflow.

package/src/interface/workflow.js

@@ -3,9 +3,41 @@ import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4,
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
-import { mergeActivityOptions, resolveInvocationDir, setMetadata } from '#utils';
+import { deepMerge, mergeActivityOptions, resolveInvocationDir, setMetadata } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
+/**
+ * Context instance builder
+ */
+class Context {
+
+  /**
+   * Builds a new context instance
+   * @param {object} options - Arguments to build a new context instance
+   * @param {string} workflowId
+   * @param {function} continueAsNew
+   * @param {function} isContinueAsNewSuggested
+   * @returns {object} context
+   */
+  static build( { workflowId, continueAsNew, isContinueAsNewSuggested } ) {
+    return {
+      /**
+       * Control namespace: This object adds functions to interact with Temporal flow mechanisms
+       */
+      control: {
+        continueAsNew,
+        isContinueAsNewSuggested
+      },
+      /**
+       * Info namespace: abstracts workflowInfo()
+       */
+      info: {
+        workflowId
+      }
+    };
+  }
+};
+
 const defaultActivityOptions = {
   startToCloseTimeout: '20m',
   retry: {
@@ -24,26 +56,26 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
   const activityOptions = mergeActivityOptions( defaultActivityOptions, options );
   const steps = proxyActivities( activityOptions );
 
-  const wrapper = async input => {
+  /**
+   * Wraps the `fn` function of the workflow
+   *
+   * @param {unknown} input - The input, must match the inputSchema
+   * @param {object} extra - Workflow configurations (received directly only in unit tests)
+   * @returns {unknown} The result, will match the outputSchema
+   */
+  const wrapper = async ( input, extra = {} ) => {
     // this returns a plain function, for example, in unit tests
     if ( !inWorkflowContext() ) {
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
-      const output = await fn( input );
+      const context = Context.build( { workflowId: 'test-workflow', continueAsNew: async () => {}, isContinueAsNewSuggested: () => false } );
+      const output = await fn( input, deepMerge( context, extra.context ?? {} ) );
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
       return output;
     }
 
     const { workflowId, memo, startTime } = workflowInfo();
 
-    /* Context Object definition
-       - Control namespace: This object adds functions to interact with Temporal flow mechanisms
-    */
-    const context = {
-      control: {
-        isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested,
-        continueAsNew
-      }
-    };
+    const context = Context.build( { workflowId, continueAsNew, isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested } );
 
     // Root workflows will not have the execution context yet, since it is set here.
     const isRoot = !memo.executionContext;

package/src/utils/index.d.ts

@@ -63,18 +63,48 @@ export type SerializedFetchResponse = {
 };
 
 /**
- * Consumes and HTTP Response and serialize it to a plain object
+ * Consumes an HTTP `Response` and serializes it to a plain object.
+ *
+ * @param response - The response to serialize.
+ * @returns SerializedFetchResponse
  */
 export function serializeFetchResponse( response: Response ): SerializedFetchResponse;
 
 export type SerializedBodyAndContentType = {
-  /** The body parsed to string if possible or kept as the types allowed in fetch's POST body */
+  /** The body as a string when possible; otherwise the original value */
   body: string | unknown,
-  /** The inferred content-type */
+  /** The inferred `Content-Type` header value, if any */
   contentType: string | undefined
 };
 
 /**
- * Based on the type of a payload, serialized it to be send as the body of a fetch POST request and also infer its Content Type.
+ * Serializes a payload for use as a fetch POST body and infers its `Content-Type`.
+ *
+ * @param body - The payload to serialize.
+ * @returns The serialized body and inferred `Content-Type`.
  */
 export function serializeBodyAndInferContentType( body: unknown ): SerializedBodyAndContentType;
+
+/**
+ * Returns true if the value is a plain object:
+ * - `{}`
+ * - `new Object()`
+ * - `Object.create(null)`
+ *
+ * @param object - The value to check.
+ * @returns Whether the value is a plain object.
+ */
+export function isPlainObject( object: unknown ): boolean;
+
+/**
+ * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
+ * - Fields in `b` overwrite fields in `a`.
+ * - Fields in `b` that don't exist in `a` are created.
+ * - Fields in `a` that don't exist in `b` are left unchanged.
+ *
+ * @param a - The base object.
+ * @param b - The overriding object.
+ * @throws {Error} If either `a` or `b` is not a plain object.
+ * @returns A new merged object.
+ */
+export function deepMerge( a: object, b: object ): object;

package/src/utils/utils.js

@@ -7,6 +7,18 @@ import { METADATA_ACCESS_SYMBOL } from '#consts';
  */
 export const clone = v => JSON.parse( JSON.stringify( v ) );
 
+/**
+ * Detect a JS plain object.
+ *
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+export const isPlainObject = v =>
+  typeof v === 'object' &&
+    !Array.isArray( v ) &&
+    v !== null &&
+    [ Object.prototype, null ].includes( Object.getPrototypeOf( v ) );
+
 /**
  * Throw given error
  * @param {Error} e
@@ -149,3 +161,26 @@ export const serializeBodyAndInferContentType = payload => {
 
   return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
 };
+
+/**
+ * Creates a new object merging object "b" onto object "a" biased to "b":
+ * - Object "b" will overwrite fields on object "a";
+ * - Object "b" fields that don't exist on object "a" will be created;
+ * - Object "a" fields that don't exist on object "b" will not be touched;
+ *
+ *
+ * @param {object} a - The base object
+ * @param {object} b - The target object
+ * @returns {object} A new object
+ */
+export const deepMerge = ( a, b ) => {
+  if ( !isPlainObject( a ) ) {
+    throw new Error( 'Parameter "a" is not an object.' );
+  }
+  if ( !isPlainObject( b ) ) {
+    throw new Error( 'Parameter "b" is not an object.' );
+  }
+  return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
+    Object.assign( obj, { [k]: isPlainObject( v ) && isPlainObject( a[k] ) ? deepMerge( a[k], v ) : v } )
+  , clone( a ) );
+};

package/src/utils/utils.spec.js

@@ -1,7 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
-import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse } from './utils.js';
-// Response is available globally in Node 18+ (undici)
+import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse, deepMerge, isPlainObject } from './utils.js';
 
 describe( 'clone', () => {
   it( 'produces a deep copy without shared references', () => {
@@ -260,3 +259,155 @@ describe( 'mergeActivityOptions', () => {
   } );
 } );
 
+describe( 'deepMerge', () => {
+  it( 'Overwrites properties in object "a"', () => {
+    const a = {
+      a: 1,
+      b: {
+        c: 2
+      }
+    };
+    const b = {
+      a: false,
+      b: {
+        c: true
+      }
+    };
+    expect( deepMerge( a, b ) ).toEqual( {
+      a: false,
+      b: {
+        c: true
+      }
+    } );
+  } );
+
+  it( 'Adds properties existing in "b" but absent in "a"', () => {
+    const a = {
+      a: 1
+    };
+    const b = {
+      a: false,
+      b: true
+    };
+    expect( deepMerge( a, b ) ).toEqual( {
+      a: false,
+      b: true
+    } );
+  } );
+
+  it( 'Keep extra properties in "a"', () => {
+    const a = {
+      a: 1
+    };
+    const b = {
+      b: true
+    };
+    expect( deepMerge( a, b ) ).toEqual( {
+      a: 1,
+      b: true
+    } );
+  } );
+
+  it( 'Throw error on non iterable object types', () => {
+    expect( () => deepMerge( Function, Function ) ).toThrow( Error );
+    expect( () => deepMerge( () => {}, () => {} ) ).toThrow( Error );
+    expect( () => deepMerge( 'a', 'a' ) ).toThrow( Error );
+    expect( () => deepMerge( true, true ) ).toThrow( Error );
+    expect( () => deepMerge( /a/, /a/ ) ).toThrow( Error );
+    expect( () => deepMerge( [], [] ) ).toThrow( Error );
+    expect( () => deepMerge( class Foo {}, class Foo {} ) ).toThrow( Error );
+    expect( () => deepMerge( Number.constructor, Number.constructor ) ).toThrow( Error );
+    expect( () => deepMerge( Number.constructor.prototype, Number.constructor.prototype ) ).toThrow( Error );
+  } );
+} );
+
+describe( 'isPlainObject', () => {
+  it( 'Detects plain objects', () => {
+    expect( isPlainObject( {} ) ).toBe( true );
+    expect( isPlainObject( { a: 1 } ) ).toBe( true );
+    expect( isPlainObject( new Object() ) ).toBe( true );
+    expect( isPlainObject( new Object( { foo: 'bar' } ) ) ).toBe( true );
+    expect( isPlainObject( Object.create( {}.constructor.prototype ) ) ).toBe( true );
+    expect( isPlainObject( Object.create( Object.prototype ) ) ).toBe( true );
+  } );
+
+  it( 'Detects plain objects with different prototypes than Object.prototype', () => {
+    // Object with null prototype
+    expect( isPlainObject( Object.create( null ) ) ).toBe( true );
+  } );
+
+  it( 'Detects non plain objects that had their __proto__ mutated to Object.prototype or null', () => {
+    class Foo {}
+    const x = new Foo();
+    x.__proto__ = Object.prototype;
+    expect( isPlainObject( x ) ).toBe( true );
+
+    const y = new Foo();
+    y.__proto__ = null;
+    expect( isPlainObject( y ) ).toBe( true );
+  } );
+
+  it( 'Returns false for object which the prototype is not Object.prototype or null', () => {
+    // Object which the prototype is a plain {}
+    expect( isPlainObject( Object.create( {} ) ) ).toBe( false );
+    // Object which prototype is a another object with null prototype
+    expect( isPlainObject( Object.create( Object.create( null ) ) ) ).toBe( false );
+  } );
+
+  it( 'Returns false for functions', () => {
+    expect( isPlainObject( Function ) ).toBe( false );
+    expect( isPlainObject( () => {} ) ).toBe( false );
+    expect( isPlainObject( class Foo {} ) ).toBe( false );
+    expect( isPlainObject( Number.constructor ) ).toBe( false );
+    expect( isPlainObject( Number.constructor.prototype ) ).toBe( false );
+  } );
+
+  it( 'Returns false for arrays', () => {
+    expect( isPlainObject( [ 1, 2, 3 ] ) ).toBe( false );
+    expect( isPlainObject( [] ) ).toBe( false );
+    expect( isPlainObject( Array( 3 ) ) ).toBe( false );
+  } );
+
+  it( 'Returns false for primitives', () => {
+    expect( isPlainObject( false ) ).toBe( false );
+    expect( isPlainObject( true ) ).toBe( false );
+    expect( isPlainObject( 1 ) ).toBe( false );
+    expect( isPlainObject( 0 ) ).toBe( false );
+    expect( isPlainObject( '' ) ).toBe( false );
+    expect( isPlainObject( 'foo' ) ).toBe( false );
+    expect( isPlainObject( Symbol( 'foo' ) ) ).toBe( false );
+    expect( isPlainObject( Symbol.for( 'foo' ) ) ).toBe( false );
+  } );
+
+  it( 'Returns true for built in objects', () => {
+    expect( isPlainObject( Math ) ).toBe( true );
+    expect( isPlainObject( JSON ) ).toBe( true );
+  } );
+
+  it( 'Returns false for built in types', () => {
+    expect( isPlainObject( String ) ).toBe( false );
+    expect( isPlainObject( Number ) ).toBe( false );
+    expect( isPlainObject( Date ) ).toBe( false );
+  } );
+
+  it( 'Returns false for other instance where prototype is not object or null', () => {
+    expect( isPlainObject( /foo/ ) ).toBe( false );
+    expect( isPlainObject( new RegExp( 'foo' ) ) ).toBe( false );
+    expect( isPlainObject( new Date() ) ).toBe( false );
+    class Foo {}
+    expect( isPlainObject( new Foo() ) ).toBe( false );
+    expect( isPlainObject( Object.create( ( class Foo {} ).prototype ) ) ).toBe( false );
+  } );
+
+  it( 'Returns false if tries to change the prototype to simulate an object', () => {
+    function Bar() {}
+    Bar.prototype = Object.create( null );
+    expect( isPlainObject( new Bar() ) ).toBe( false );
+  } );
+
+  it( 'Returns false if object proto was mutated to anything else than object or null', () => {
+    const zum = {};
+    zum.__proto__ = Number.prototype;
+    expect( isPlainObject( zum ) ).toBe( false );
+  } );
+} );

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'