@output.ai/core 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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/evaluator.js

@@ -81,6 +81,7 @@ export class EvaluationStringResult extends EvaluationResult {
    * @param {number} args.confidence - The confidence on the evaluation
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
+  // eslint-disable-next-line no-useless-constructor
   constructor( args ) {
     super( args );
   }
@@ -103,6 +104,7 @@ export class EvaluationBooleanResult extends EvaluationResult {
    * @param {number} args.confidence - The confidence on the evaluation
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
+  // eslint-disable-next-line no-useless-constructor
   constructor( args ) {
     super( args );
   }
@@ -125,6 +127,7 @@ export class EvaluationNumberResult extends EvaluationResult {
    * @param {number} args.confidence - The confidence on the evaluation
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
+  // eslint-disable-next-line no-useless-constructor
   constructor( args ) {
     super( args );
   }

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/webpack_loaders/consts.js

@@ -9,19 +9,6 @@ export const ComponentFile = {
   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,7 @@ import {
   isExportDefaultDeclaration,
   isFunctionDeclaration
 } from '@babel/types';
-import { ComponentFile, EXTRANEOUS_FILE, ExtraneousFileList, NodeType } from './consts.js';
+import { ComponentFile, NodeType } from './consts.js';
 
 /**
  * Resolve a relative module specifier against a base directory.
@@ -138,8 +138,6 @@ export const isWorkflowPath = value => /(^|\/)workflow\.js$/.test( value );
  */
 export const isTypesPath = value => /(^|\/)types\.js$/.test( value );
 
-export const isExtraneousFile = value => ExtraneousFileList.map( t => new RegExp( `(^|\/)${t}\\.js$` ) ).find( rx => rx.test( value ) );
-
 /**
  * Determine file kind based on its path.
  * @param {string} filename
@@ -158,9 +156,6 @@ export const getFileKind = path => {
   if ( isWorkflowPath( path ) ) {
     return ComponentFile.WORKFLOW;
   }
-  if ( isExtraneousFile( path ) ) {
-    return EXTRANEOUS_FILE;
-  }
   return null;
 };
 

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

@@ -20,7 +20,6 @@ import {
   buildSharedStepsNameMap,
   buildWorkflowNameMap,
   buildEvaluatorsNameMap,
-  isExtraneousFile,
   getFileKind
 } from './tools.js';
 
@@ -170,49 +169,6 @@ describe( 'workflow_rewriter tools', () => {
     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( 'createThisMethodCall: builds this.method(\'name\', ...args) call', () => {
     const call = createThisMethodCall( 'invoke', 'n', [ t.numericLiteral( 1 ), t.identifier( 'x' ) ] );
     expect( t.isCallExpression( call ) ).toBe( true );

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

@@ -1,7 +1,7 @@
 import traverseModule from '@babel/traverse';
 import { dirname } from 'node:path';
 import { parse, toAbsolutePath, getFileKind } from '../tools.js';
-import { ComponentFile, CoreModule, EXTRANEOUS_FILE, ExtraneousFileList } from '../consts.js';
+import { ComponentFile } from '../consts.js';
 import {
   isCallExpression,
   isFunctionExpression,
@@ -17,19 +17,6 @@ import {
 // 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 ) === EXTRANEOUS_FILE;
-  if ( !isCore && !isComponent && !isAllowedExtraneous ) {
-    throw new Error( `Invalid dependency in workflow.js: '${specifier}'. \
-Only components (${Object.values( ComponentFile ) } ), @output.ai/core, or whitelisted (${ExtraneousFileList}) imports are allowed in ${filename}` );
-  }
-};
-
 /**
  * Check if evaluators, steps or shared_steps import invalid dependencies
  */
@@ -41,12 +28,10 @@ Steps, shared_steps, evaluators or workflows are not allowed dependencies in ${f
 };
 
 /**
- * Validate import for evaluators, steps, shared_steps, workflow
+ * Validate import for evaluators, steps, shared_steps
  */
 const executeImportValidations = ( { fileKind, specifier, filename } ) => {
-  if ( fileKind === ComponentFile.WORKFLOW ) {
-    validateWorkflowImports( { fileKind, specifier, filename } );
-  } else if ( Object.values( ComponentFile ).includes( fileKind ) ) {
+  if ( Object.values( ComponentFile ).includes( fileKind ) && fileKind !== ComponentFile.WORKFLOW ) {
     validateStepEvaluatorImports( { fileKind, specifier, filename } );
   }
 };
@@ -62,7 +47,6 @@ const executeImportValidations = ( { fileKind, specifier, filename } ) => {
  *  - 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

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

@@ -36,13 +36,6 @@ describe( 'workflow_validator loader', () => {
     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 "./foo.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 = [
@@ -125,24 +118,6 @@ describe( 'workflow_validator loader', () => {
     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";' ) )
@@ -210,25 +185,6 @@ describe( 'workflow_validator loader', () => {
     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( 'workflow.js: allows importing extraneous files (consts/constants/vars/variables)', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'wf-extra-allow-' ) );
-    const bases = [ 'consts', 'constants', 'vars', 'variables' ];
-    for ( const base of bases ) {
-      writeFileSync( join( dir, `${base}.js` ), 'export const X = 1\n' );
-      const src = `import x from "./${base}.js";`;
-      await expect( runLoader( join( dir, 'workflow.js' ), src ) ).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");' ) )