@output.ai/core 0.0.7 → 0.0.8

package/src/worker/catalog_workflow/index.js

@@ -0,0 +1,21 @@
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { Catalog, CatalogActivity, CatalogWorkflow } from './catalog.js';
+
+/**
+ * Converts the list of workflows and the activities into the catalog information.
+ *
+ * This has information of all workflows and their activities from this worker.
+ *
+ * @param {object[]} workflows - The workflows objects, as they are returned from the loader module
+ * @param {object} activities - The activities functions map with metadata, as they are returned from the loader module
+ * @returns {Catalog} An catalog instance
+ */
+export const createCatalog = ( { workflows, activities } ) =>
+  workflows.reduce( ( catalog, workflow ) =>
+    catalog.addWorkflow( new CatalogWorkflow( {
+      ...workflow,
+      activities: Object.entries( activities )
+        .filter( ( [ k ] ) => k.startsWith( `${workflow.path}#` ) )
+        .map( ( [ _, v ] ) => new CatalogActivity( v[METADATA_ACCESS_SYMBOL] ) )
+    } ) )
+  , new Catalog() );

package/src/worker/catalog_workflow/index.spec.js

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Provide the same symbol to the module under test and to the test
+const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+vi.mock( '#consts', () => ( {
+  METADATA_ACCESS_SYMBOL
+} ) );
+
+const setMetadata = ( target, values ) =>
+  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
+
+describe( 'createCatalog', () => {
+  it( 'builds catalog with activities grouped by workflow path and returns Catalog with CatalogWorkflow entries', async () => {
+    const { createCatalog } = await import( './index.js' );
+
+    const workflows = [
+      {
+        name: 'flow1',
+        path: '/flows/flow1',
+        pathname: '/flows/flow1/workflow.js',
+        description: 'desc-flow1',
+        inputSchema: { in: 'f1' },
+        outputSchema: { out: 'f1' }
+      },
+      {
+        name: 'flow2',
+        path: '/flows/flow2',
+        pathname: '/flows/flow2/workflow.js',
+        description: 'desc-flow2',
+        inputSchema: { in: 'f2' },
+        outputSchema: { out: 'f2' }
+      }
+    ];
+
+    const activity1 = () => {};
+    setMetadata( activity1, {
+      name: 'A1',
+      path: '/flows/flow1#A1',
+      description: 'desc-a1',
+      inputSchema: { in: 'a1' },
+      outputSchema: { out: 'a1' }
+    } );
+
+    const activity2 = () => {};
+    setMetadata( activity2, {
+      name: 'A2',
+      path: '/flows/flow1#A2',
+      description: 'desc-a2',
+      inputSchema: { in: 'a2' },
+      outputSchema: { out: 'a2' }
+    } );
+
+    const activity3 = () => {};
+    setMetadata( activity3, {
+      name: 'B1',
+      path: '/flows/flow2#B1',
+      description: 'desc-b1',
+      inputSchema: { in: 'b1' },
+      outputSchema: { out: 'b1' }
+    } );
+
+    const activity4 = () => {};
+    setMetadata( activity4, {
+      name: 'X',
+      path: '/other#X',
+      description: 'desc-x',
+      inputSchema: { in: 'x' },
+      outputSchema: { out: 'x' }
+    } );
+
+    const activities = {
+      '/flows/flow1#A1': activity1,
+      '/flows/flow1#A2': activity2,
+      '/flows/flow2#B1': activity3,
+      '/other#X': activity4
+    };
+
+    const catalog = createCatalog( { workflows, activities } );
+
+    const mapped = catalog.workflows.map( w => ( {
+      name: w.name,
+      path: w.path,
+      description: w.description,
+      inputSchema: w.inputSchema,
+      outputSchema: w.outputSchema,
+      activities: w.activities.map( a => ( {
+        name: a.name,
+        description: a.description,
+        inputSchema: a.inputSchema,
+        outputSchema: a.outputSchema
+      } ) )
+    } ) );
+
+    expect( mapped ).toEqual( [
+      {
+        name: 'flow1',
+        path: '/flows/flow1',
+        description: 'desc-flow1',
+        inputSchema: { in: 'f1' },
+        outputSchema: { out: 'f1' },
+        activities: [
+          {
+            name: 'A1',
+            description: 'desc-a1',
+            inputSchema: { in: 'a1' },
+            outputSchema: { out: 'a1' }
+          },
+          {
+            name: 'A2',
+            description: 'desc-a2',
+            inputSchema: { in: 'a2' },
+            outputSchema: { out: 'a2' }
+          }
+        ]
+      },
+      {
+        name: 'flow2',
+        path: '/flows/flow2',
+        description: 'desc-flow2',
+        inputSchema: { in: 'f2' },
+        outputSchema: { out: 'f2' },
+        activities: [
+          {
+            name: 'B1',
+            description: 'desc-b1',
+            inputSchema: { in: 'b1' },
+            outputSchema: { out: 'b1' }
+          }
+        ]
+      }
+    ] );
+
+    // Original inputs are not mutated
+    expect( workflows[0].path ).toBe( '/flows/flow1' );
+    expect( workflows[0].pathname ).toBe( '/flows/flow1/workflow.js' );
+    expect( workflows[1].path ).toBe( '/flows/flow2' );
+    expect( workflows[1].pathname ).toBe( '/flows/flow2/workflow.js' );
+  } );
+} );

package/src/worker/catalog_workflow/workflow.js

@@ -0,0 +1,13 @@
+import { defineQuery, setHandler } from '@temporalio/workflow';
+
+/**
+ * This is a special workflow, unique to each worker, which holds the meta information of all other workflows in that worker.
+ *
+ * The information is set in the startup and is accessible via a query called 'get'.
+ *
+ * @param {object} catalog - The catalog information
+ */
+export default async function catalogWorkflow( catalog ) {
+  setHandler( defineQuery( 'get' ), () => catalog );
+  await new Promise( () => {} ); // stay alive
+};

package/src/worker/index.js

@@ -1,11 +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 { worker as workerConfig } from '#configs';
-import { loadActivities, loadWorkflows } from './loader.js';
+import { loadActivities, loadWorkflows, createWorkflowsEntryPoint } from './loader.js';
 import { ActivityExecutionInterceptor } from './interceptors/activity.js';
 import { setupGlobalTracer } from './tracer/index.js';
 import { sinks } from './sinks.js';
+import { createCatalog } from './catalog_workflow/index.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
@@ -19,16 +22,22 @@ const callerDir = process.argv[2];
 
 ( async () => {
   console.log( '[Core]', 'Loading workflows...', { callerDir } );
-  const workflowsPath = await loadWorkflows( callerDir );
+  const workflows = await loadWorkflows( callerDir );
 
   console.log( '[Core]', 'Loading activities...', { callerDir } );
   const activities = await loadActivities( callerDir );
 
+  console.log( '[Core]', 'Creating worker entry point...' );
+  const workflowsPath = createWorkflowsEntryPoint( workflows );
+
+  console.log( '[Core]', 'Creating workflows catalog...' );
+  const catalog = createCatalog( { workflows, activities } );
+
   console.log( '[Core]', 'Connecting Temporal...' );
   // enable TLS only when connecting remove (api key is present)
   const connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey } );
 
-  console.log( '[Core]', 'Creating Worker...' );
+  console.log( '[Core]', 'Creating worker...' );
   const worker = await Worker.create( {
     connection,
     namespace,
@@ -41,9 +50,32 @@ const callerDir = process.argv[2];
       activityInbound: [ () => new ActivityExecutionInterceptor() ]
     },
     maxConcurrentWorkflowTaskExecutions: maxWorkflows,
-    maxConcurrentActivityTaskExecutions: maxActivities
+    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;
+      }
+    }
+  } );
+
+  console.log( '[Core]', 'Starting catalog workflow...' );
+  await new Client( { connection, namespace } ).workflow.start( 'catalog', {
+    taskQueue,
+    workflowId: taskQueue, // use the name of the task queue as the catalog name, ensuring uniqueness
+    workflowIdConflictPolicy: WorkflowIdConflictPolicy.TERMINATE_EXISTING,
+    args: [ catalog ]
   } );
 
-  console.log( '[Core] Starting...' );
+  console.log( '[Core]', 'Running worker...' );
   worker.run();
 } )();

package/src/worker/internal_utils.js

@@ -0,0 +1,54 @@
+/*
+ * These tools cant be used in sandbox environment!!!
+ */
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
+
+/**
+ * Recursive traverse directories looking for files with given name,
+ * For each found file, return its path, pathname and URI
+ *
+ * @param {string} path - The path to scan
+ * @param {string[]} filenames  - The filenames to look for
+ * @returns {string[{}]} An array containing an object with path, pathname and URI for each file found
+ * */
+export function recursiveNavigateWhileCollecting( path, filenames, collection = [], ignoreDirNames = [ 'vendor', 'node_modules' ] ) {
+  for ( const entry of readdirSync( path, { withFileTypes: true } ) ) {
+    if ( ignoreDirNames.includes( entry.name ) ) { continue; }
+
+    const pathname = resolve( path, entry.name );
+    if ( entry.isDirectory() ) {
+      recursiveNavigateWhileCollecting( pathname, filenames, collection );
+    } else if ( filenames.includes( entry.name ) ) {
+      collection.push( { pathname, path, url: pathToFileURL( pathname ).href } );
+    }
+  }
+
+  return collection;
+};
+
+/**
+ * For each path, dynamic import it, and for each exported component with metadata (step, workflow), yields it.
+ * @param {string[]} paths - Paths of the files to import
+ */
+export async function *iteratorOverImportedComponents( paths ) {
+  for ( const { url, path, pathname } of paths ) {
+    const imported = await import( url );
+    for ( const component of Object.values( imported ) ) {
+      const metadata = component[METADATA_ACCESS_SYMBOL];
+      if ( !metadata ) { continue; }
+      yield { component, metadata, path, pathname };
+    }
+  }
+};
+
+/**
+ * Write a file using the same signature as Node's FS writeFileSync, but recursively creates the necessary directories in the path.
+ */
+export function writeFileOnLocationSync( path, content ) {
+  const targetDir = path.split( '/' ).slice( 0, -1 ).join( '/' );
+  if ( targetDir && !existsSync( targetDir ) ) { mkdirSync( targetDir, { recursive: true } ); }
+  writeFileSync( path, content, 'utf-8' );
+};

package/src/worker/internal_utils.spec.js

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+import { recursiveNavigateWhileCollecting, iteratorOverImportedComponents, writeFileOnLocationSync } from './internal_utils.js';
+
+function makeTmpRoot( prefix ) {
+  return mkdtempSync( join( tmpdir(), prefix ) );
+}
+
+describe( '.recursiveNavigateWhileCollecting', () => {
+  it( 'collects matching files recursively (happy path)', () => {
+    const root = makeTmpRoot( 'nsu-happy-' );
+    const target = 'target.txt';
+
+    // layout:
+    // root/target.txt
+    // root/a/target.txt
+    // root/b/c/target.txt
+    mkdirSync( join( root, 'a' ), { recursive: true } );
+    mkdirSync( join( root, 'b', 'c' ), { recursive: true } );
+    writeFileSync( join( root, target ), 'root' );
+    writeFileSync( join( root, 'a', target ), 'a' );
+    writeFileSync( join( root, 'b', 'c', target ), 'bc' );
+
+    const results = recursiveNavigateWhileCollecting( root, [ target ] );
+
+    expect( results.length ).toBe( 3 );
+    for ( const { pathname, path, url } of results ) {
+      expect( url ).toBe( pathToFileURL( pathname ).href );
+      expect( resolve( path, target ) ).toBe( pathname );
+    }
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'skips files inside ignored directories (ignoreDirNames)', () => {
+    const root = makeTmpRoot( 'nsu-ignore-' );
+    const target = 'target.txt';
+
+    // layout:
+    // root/node_modules/target.txt   (ignored)
+    // root/vendor/target.txt         (ignored)
+    // root/ok/target.txt             (collected)
+    mkdirSync( join( root, 'node_modules' ), { recursive: true } );
+    mkdirSync( join( root, 'vendor' ), { recursive: true } );
+    mkdirSync( join( root, 'ok' ), { recursive: true } );
+    writeFileSync( join( root, 'node_modules', target ), 'nm' );
+    writeFileSync( join( root, 'vendor', target ), 'v' );
+    writeFileSync( join( root, 'ok', target ), 'ok' );
+
+    const results = recursiveNavigateWhileCollecting( root, [ target ] );
+
+    expect( results.length ).toBe( 1 );
+    expect( results[0].pathname ).toBe( join( root, 'ok', target ) );
+    expect( results[0].path ).toBe( join( root, 'ok' ) );
+    expect( results[0].url ).toBe( pathToFileURL( results[0].pathname ).href );
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+} );
+
+describe( '.iteratorOverImportedComponents', () => {
+  it( 'imports modules and yields metadata from exports tagged with METADATA_ACCESS_SYMBOL', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}` );
+    mkdirSync( root, { recursive: true } );
+    const file = join( root, 'meta.module.js' );
+    writeFileSync( file, [
+      'import { METADATA_ACCESS_SYMBOL } from \"#consts\";',
+      'export const StepA = () => {};',
+      'StepA[METADATA_ACCESS_SYMBOL] = { kind: \"step\", name: \"a\" };',
+      'export const FlowB = () => {};',
+      'FlowB[METADATA_ACCESS_SYMBOL] = { kind: \"workflow\", name: \"b\" };'
+    ].join( '\n' ) );
+
+    const paths = recursiveNavigateWhileCollecting( root, [ 'meta.module.js' ] );
+    const collected = [];
+    for await ( const m of iteratorOverImportedComponents( paths ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 2 );
+    expect( collected.map( m => m.metadata.name ).sort() ).toEqual( [ 'a', 'b' ] );
+    expect( collected.map( m => m.metadata.kind ).sort() ).toEqual( [ 'step', 'workflow' ] );
+    for ( const m of collected ) {
+      expect( m.pathname ).toBe( file );
+      expect( m.path ).toBe( root );
+      expect( typeof m.component ).toBe( 'function' );
+    }
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'ignores exports without metadata symbol', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-nometa` );
+    mkdirSync( root, { recursive: true } );
+    const file = join( root, 'meta.module.js' );
+    writeFileSync( file, [
+      'export const Plain = () => {};',
+      'export const AlsoPlain = {}'
+    ].join( '\n' ) );
+
+    const paths = recursiveNavigateWhileCollecting( root, [ 'meta.module.js' ] );
+    const collected = [];
+    for await ( const m of iteratorOverImportedComponents( paths ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 0 );
+    rmSync( root, { recursive: true, force: true } );
+  } );
+} );
+
+describe( '.writeFileOnLocationSync', () => {
+  it( 'creates missing directories and writes file', () => {
+    const root = makeTmpRoot( 'nsu-write-' );
+    const nested = join( root, 'a', 'b', 'c.txt' );
+    writeFileOnLocationSync( nested, 'hello' );
+    expect( existsSync( join( root, 'a', 'b' ) ) ).toBe( true );
+    expect( readFileSync( nested, 'utf-8' ) ).toBe( 'hello' );
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'overwrites existing content', () => {
+    const root = makeTmpRoot( 'nsu-write2-' );
+    const file = join( root, 'x', 'y.txt' );
+    mkdirSync( join( root, 'x' ), { recursive: true } );
+    writeFileSync( file, 'old' );
+    writeFileOnLocationSync( file, 'new' );
+    expect( readFileSync( file, 'utf-8' ) ).toBe( 'new' );
+    rmSync( root, { recursive: true, force: true } );
+  } );
+} );

package/src/worker/loader.js

@@ -1,64 +1,50 @@
-import { readdirSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-import { pathToFileURL, fileURLToPath } from 'url';
-import { nameSymbol, sendWebhookPostName, workflowsIndexFileName } from '#consts';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { sendWebhookPost } from '#internal_activities';
-
-const ignoreDirNames = [ 'vendor', 'node_modules' ];
+import { SEND_WEBHOOK_ACTIVITY_NAME, WORKFLOWS_INDEX_FILENAME } from '#consts';
+import {
+  iteratorOverImportedComponents,
+  recursiveNavigateWhileCollecting,
+  writeFileOnLocationSync
+} from './internal_utils.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-// recursive run directories and when find files with given name, save their path, pathname and URI
-const recursiveNavigateWhileCollecting = ( path, filenames, collection = [] ) => {
-  for ( const entry of readdirSync( path, { withFileTypes: true } ) ) {
-    if ( ignoreDirNames.includes( entry.name ) ) { continue; }
-
-    const pathname = resolve( path, entry.name );
-    if ( entry.isDirectory() ) {
-      recursiveNavigateWhileCollecting( pathname, filenames, collection );
-    } else if ( filenames.includes( entry.name ) ) {
-      collection.push( { pathname, path, url: pathToFileURL( pathname ).href } );
-    }
-  }
-
-  return collection;
-};
-
+// returns a map of activities, where the key is they path + name and the value is the function with metadata
 export async function loadActivities( path ) {
   const activityPaths = recursiveNavigateWhileCollecting( path, [ 'steps.js' ] );
   const activities = [];
-  for ( const { path, pathname, url } of activityPaths ) {
-    const exported = await import( url );
-    for ( const [ name, fn ] of Object.values( exported ).map( v => [ v[nameSymbol], v ] ).filter( v => v[0] ) ) {
-      console.log( '[Core.Scanner]', 'Activity loaded', name, pathname );
-      activities[`${path}#${name}`] = fn;
-    }
+  for await ( const { component, metadata, pathname, path } of iteratorOverImportedComponents( activityPaths ) ) {
+    console.log( '[Core.Scanner]', 'Activity loaded:', metadata.name, 'at', pathname );
+    activities[`${path}#${metadata.name}`] = component;
   }
 
   // system activities
-  activities[sendWebhookPostName] = sendWebhookPost;
+  activities[SEND_WEBHOOK_ACTIVITY_NAME] = sendWebhookPost;
   return activities;
 };
 
+// Returns array of workflow object, which are function with metadata attached
 export async function loadWorkflows( path ) {
-  const workflowPaths = recursiveNavigateWhileCollecting( path, [ 'index.js' ] );
+  const workflowPaths = recursiveNavigateWhileCollecting( path, [ 'workflow.js' ] );
   const workflows = [];
-  for ( const { pathname, url } of workflowPaths ) {
-    const exported = await import( url );
-
-    for ( const name of Object.values( exported ).map( v => v[nameSymbol] ).filter( n => n ) ) {
-      console.log( '[Core.Scanner]', 'Workflow loaded', name, pathname );
-      workflows.push( { name, pathname } );
-    }
+  for await ( const { metadata, pathname, path } of iteratorOverImportedComponents( workflowPaths ) ) {
+    workflows.push( { ...metadata, pathname, path } );
+    console.log( '[Core.Scanner]', 'Workflow loaded:', metadata.name, 'at', pathname );
   }
+  return workflows;
+};
 
-  const tempFolder = join( __dirname, 'temp' );
-  const entryPoint = join( tempFolder, workflowsIndexFileName );
-  const workflowsIndex = workflows.map( ( { name, pathname } ) => `export { default as ${name} } from '${pathname}';` ).join( '\n' );
+// Creates a temporary index file importing all workflows
+export function createWorkflowsEntryPoint( workflows ) {
+  const entryPoint = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
 
-  if ( !existsSync( tempFolder ) ) {
-    mkdirSync( tempFolder );
-  }
-  writeFileSync( entryPoint, workflowsIndex, 'utf-8' );
+  // default system catalog workflow
+  const catalogWorkflow = { name: 'catalog', pathname: join( __dirname, './catalog_workflow/workflow.js' ) };
+  const workflowsIndex = [ ... workflows, catalogWorkflow ]
+    .map( ( { name, pathname } ) => `export { default as ${name} } from '${pathname}';` )
+    .join( '\n' );
+
+  writeFileOnLocationSync( entryPoint, workflowsIndex );
   return entryPoint;
 };

package/src/worker/loader.spec.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+
+vi.mock( '#consts', () => ( {
+  SEND_WEBHOOK_ACTIVITY_NAME: '__internal#sendWebhookPost',
+  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
+  METADATA_ACCESS_SYMBOL
+} ) );
+
+const sendWebhookPostMock = vi.fn();
+vi.mock( '#internal_activities', () => ( {
+  sendWebhookPost: sendWebhookPostMock
+} ) );
+
+// Mock internal_utils to control filesystem-independent behavior
+const iteratorMock = vi.fn();
+const recursiveMock = vi.fn();
+const writeFileMock = vi.fn();
+vi.mock( './internal_utils.js', () => ( {
+  iteratorOverImportedComponents: iteratorMock,
+  recursiveNavigateWhileCollecting: recursiveMock,
+  writeFileOnLocationSync: writeFileMock
+} ) );
+
+describe( 'worker/loader', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'loadActivities returns map including system activity', async () => {
+    const { loadActivities } = await import( './loader.js' );
+
+    recursiveMock.mockReturnValue( [ { pathname: '/a/steps.js', path: '/a', url: 'file:///a/steps.js' } ] );
+    iteratorMock.mockImplementation( async function *() {
+      yield { component: () => {}, metadata: { name: 'Act1' }, pathname: '/a/steps.js', path: '/a' };
+    } );
+
+    const activities = await loadActivities( '/root' );
+    expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
+    expect( activities['__internal#sendWebhookPost'] ).toBe( sendWebhookPostMock );
+  } );
+
+  it( 'loadWorkflows returns array of workflows with metadata', async () => {
+    const { loadWorkflows } = await import( './loader.js' );
+
+    recursiveMock.mockReturnValue( [ { pathname: '/b/workflow.js', path: '/b', url: 'file:///b/workflow.js' } ] );
+    iteratorMock.mockImplementation( async function *() {
+      yield { metadata: { name: 'Flow1', description: 'd' }, pathname: '/b/workflow.js', path: '/b' };
+    } );
+
+    const workflows = await loadWorkflows( '/root' );
+    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', pathname: '/b/workflow.js', path: '/b' } ] );
+  } );
+
+  it( 'createWorkflowsEntryPoint writes index and returns its path', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [ { name: 'W', pathname: '/abs/wf.js' } ];
+    const entry = createWorkflowsEntryPoint( workflows );
+
+    expect( writeFileMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath, contents ] = writeFileMock.mock.calls[0];
+    expect( entry ).toBe( writtenPath );
+    expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as catalog }' );
+  } );
+} );