@output.ai/core 0.0.16 → 0.1.1

package/src/worker/catalog_workflow/index.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { dirname } from 'node:path';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
 import { Catalog, CatalogActivity, CatalogWorkflow } from './catalog.js';
 
@@ -37,7 +38,7 @@ export const createCatalog = ( { workflows, activities } ) =>
       inputSchema: convertToJsonSchema( workflow.inputSchema ),
       outputSchema: convertToJsonSchema( workflow.outputSchema ),
       activities: Object.entries( activities )
-        .filter( ( [ k ] ) => k.startsWith( `${workflow.path}#` ) )
+        .filter( ( [ k ] ) => k.startsWith( `${dirname( workflow.path )}#` ) )
         .map( ( [ _, v ] ) => {
           const metadata = v[METADATA_ACCESS_SYMBOL];
           return new CatalogActivity( {

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

@@ -17,16 +17,14 @@ describe( 'createCatalog', () => {
     const workflows = [
       {
         name: 'flow1',
-        path: '/flows/flow1',
-        pathname: '/flows/flow1/workflow.js',
+        path: '/flows/flow1/workflow.js',
         description: 'desc-flow1',
         inputSchema: z.object( { in: z.literal( 'f1' ) } ),
         outputSchema: z.object( { out: z.literal( 'f1' ) } )
       },
       {
         name: 'flow2',
-        path: '/flows/flow2',
-        pathname: '/flows/flow2/workflow.js',
+        path: '/flows/flow2/workflow.js',
         description: 'desc-flow2',
         inputSchema: z.object( { in: z.literal( 'f2' ) } ),
         outputSchema: z.object( { out: z.literal( 'f2' ) } )
@@ -95,7 +93,7 @@ describe( 'createCatalog', () => {
     expect( mapped ).toEqual( [
       {
         name: 'flow1',
-        path: '/flows/flow1',
+        path: '/flows/flow1/workflow.js',
         description: 'desc-flow1',
         inputSchema: {
           $schema: 'https://json-schema.org/draft/2020-12/schema',
@@ -152,7 +150,7 @@ describe( 'createCatalog', () => {
       },
       {
         name: 'flow2',
-        path: '/flows/flow2',
+        path: '/flows/flow2/workflow.js',
         description: 'desc-flow2',
         inputSchema: {
           $schema: 'https://json-schema.org/draft/2020-12/schema',
@@ -192,9 +190,7 @@ describe( 'createCatalog', () => {
     ] );
 
     // 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' );
+    expect( workflows[0].path ).toBe( '/flows/flow1/workflow.js' );
+    expect( workflows[1].path ).toBe( '/flows/flow2/workflow.js' );
   } );
 } );

package/src/worker/configs.js

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+
+class InvalidEnvVarsErrors extends Error { }
+
+const envVarSchema = z.object( {
+  CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
+  TEMPORAL_ADDRESS: z.string().default( 'localhost:7233' ),
+  TEMPORAL_API_KEY: z.string().optional(),
+  TEMPORAL_NAMESPACE: z.string().optional().default( 'default' )
+} );
+
+const { data: envVars, error } = envVarSchema.safeParse( process.env );
+if ( error ) {
+  throw new InvalidEnvVarsErrors( z.prettifyError( error ) );
+}
+
+export const address = envVars.TEMPORAL_ADDRESS;
+export const apiKey = envVars.TEMPORAL_API_KEY;
+export const executionTimeout = '1m';
+export const maxActivities = 100;
+export const maxWorkflows = 100;
+export const namespace = envVars.TEMPORAL_NAMESPACE;
+export const taskQueue = envVars.CATALOG_ID;
+export const catalogId = envVars.CATALOG_ID;

package/src/worker/index.js

@@ -3,20 +3,16 @@ 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 { address, apiKey, maxActivities, maxWorkflows, namespace, taskQueue, catalogId } from './configs.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';
+import { init as initTracing } from '#tracing';
+import { WORKFLOW_CATALOG } from '#consts';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-// expose the coreTracker so other parts of the SDK can use it
-setupGlobalTracer();
-
-const { address, apiKey, maxActivities, maxWorkflows, namespace, taskQueue, catalogId } = workerConfig;
-
 // Get caller directory from command line arguments
 const callerDir = process.argv[2];
 
@@ -30,6 +26,9 @@ const callerDir = process.argv[2];
   console.log( '[Core]', 'Creating worker entry point...' );
   const workflowsPath = createWorkflowsEntryPoint( workflows );
 
+  console.log( '[Core]', 'Initializing tracing...' );
+  await initTracing();
+
   console.log( '[Core]', 'Creating workflows catalog...' );
   const catalog = createCatalog( { workflows, activities } );
 
@@ -73,7 +72,7 @@ const callerDir = process.argv[2];
   } );
 
   console.log( '[Core]', 'Starting catalog workflow...' );
-  await new Client( { connection, namespace } ).workflow.start( 'catalog', {
+  await new Client( { connection, namespace } ).workflow.start( WORKFLOW_CATALOG, {
     taskQueue,
     workflowId: catalogId, // use the name of the task queue as the catalog name, ensuring uniqueness
     workflowIdConflictPolicy: WorkflowIdConflictPolicy.TERMINATE_EXISTING,

package/src/worker/interceptors/activity.js

@@ -1,8 +1,7 @@
 import { Context } from '@temporalio/activity';
-import { Storage } from '../async_storage.js';
-import { trace } from '../tracer/index.js';
+import { Storage } from '#async_storage';
+import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { THIS_LIB_NAME } from '#consts';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
 
 /*
@@ -20,22 +19,21 @@ export class ActivityExecutionInterceptor {
   };
 
   async execute( input, next ) {
-    const { workflowExecution: { workflowId }, activityId, activityType, workflowType } = Context.current().info;
+    const { workflowExecution: { workflowId }, activityId, activityType } = Context.current().info;
+    const { executionContext } = headersToObject( input.headers );
+    const { type: kind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
 
-    const activityFn = this.activities?.[activityType];
-    const { type: componentType, skipTrace } = activityFn?.[METADATA_ACCESS_SYMBOL];
+    const traceArguments = { kind, id: activityId, parentId: workflowId, name: activityType, executionContext };
+    addEventStart( { details: input.args[0], ...traceArguments } );
 
-    const context = { workflowId, workflowType, activityId, activityType, ...headersToObject( input.headers ) };
-
-    return Storage.runWithContext( async _ => {
-      if ( !skipTrace ) {
-        trace( { lib: THIS_LIB_NAME, event: `${componentType}_start`, input: input.args } );
-      }
-      const output = await next( input );
-      if ( !skipTrace ) {
-        trace( { lib: THIS_LIB_NAME, event: `${componentType}_end`, output } );
-      }
+    // creates a context for the nested tracing
+    try {
+      const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, executionContext } );
+      addEventEnd( { details: output, ...traceArguments } );
       return output;
-    }, context );
+    } catch ( error ) {
+      addEventError( { details: error, ...traceArguments } );
+      throw error;
+    }
   }
 };

package/src/worker/interceptors/workflow.js

@@ -1,5 +1,5 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ApplicationFailure } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
 
 /*
@@ -18,6 +18,23 @@ class HeadersInjectionInterceptor {
   }
 };
 
+const sinks = proxySinks();
+
+class WorkflowExecutionInterceptor {
+  async execute( input, next ) {
+    sinks.trace.addWorkflowEventStart( input.args[0] );
+    try {
+      const output = await next( input );
+      sinks.trace.addWorkflowEventEnd( output );
+      return output;
+    } catch ( error ) {
+      sinks.trace.addWorkflowEventError( error );
+      throw new ApplicationFailure( error.message, error.constructor.name );
+    }
+  }
+};
+
 export const interceptors = () => ( {
+  inbound: [ new WorkflowExecutionInterceptor() ],
   outbound: [ new HeadersInjectionInterceptor( workflowInfo().workflowType ) ]
 } );

package/src/worker/loader.js

@@ -1,51 +1,60 @@
-import { dirname, join } from 'path';
+import { dirname, join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { EOL } from 'node:os';
 import { fileURLToPath } from 'url';
-import { sendWebhookPost, readTraceFile } from '#internal_activities';
-import { SEND_WEBHOOK_ACTIVITY_NAME, WORKFLOWS_INDEX_FILENAME, READ_TRACE_FILE } from '#consts';
-import {
-  iteratorOverImportedComponents,
-  recursiveNavigateWhileCollecting,
-  writeFileOnLocationSync
-} from './internal_utils.js';
+import { sendWebhook } from '#internal_activities';
+import { ACTIVITY_SEND_WEBHOOK, WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG } from '#consts';
+import { importComponents } from './loader_tools.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-// 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', 'evaluators.js' ] );
-  const activities = [];
-  for await ( const { component, metadata, pathname, path } of iteratorOverImportedComponents( activityPaths ) ) {
-    console.log( '[Core.Scanner]', 'Component loaded:', metadata.type, metadata.name, 'at', pathname );
-    activities[`${path}#${metadata.name}`] = component;
+/**
+ * Builds a map of activities, where the key is their path and name and the value is the function
+ *
+ * @param {string} target
+ * @returns {object}
+ */
+export async function loadActivities( target ) {
+  const activities = {};
+  for await ( const { fn, metadata, path } of importComponents( target, [ 'steps.js', 'evaluators.js' ] ) ) {
+    console.log( '[Core.Scanner]', 'Component loaded:', metadata.type, metadata.name, 'at', path );
+    activities[`${dirname( path )}#${metadata.name}`] = fn;
   }
 
   // system activities
-  activities[SEND_WEBHOOK_ACTIVITY_NAME] = sendWebhookPost;
-  activities[READ_TRACE_FILE] = readTraceFile;
+  activities[ACTIVITY_SEND_WEBHOOK] = sendWebhook;
   return activities;
 };
 
-// Returns array of workflow object, which are function with metadata attached
-export async function loadWorkflows( path ) {
-  const workflowPaths = recursiveNavigateWhileCollecting( path, [ 'workflow.js' ] );
+/**
+ * Builds an array of workflow objects
+ *
+ * @param {string} target
+ * @returns {object[]}
+ */
+export async function loadWorkflows( target ) {
   const workflows = [];
-  for await ( const { metadata, pathname, path } of iteratorOverImportedComponents( workflowPaths ) ) {
-    workflows.push( { ...metadata, pathname, path } );
-    console.log( '[Core.Scanner]', 'Workflow loaded:', metadata.name, 'at', pathname );
+  for await ( const { metadata, path } of importComponents( target, [ 'workflow.js' ] ) ) {
+    console.log( '[Core.Scanner]', 'Workflow loaded:', metadata.name, 'at', path );
+    workflows.push( { ...metadata, path } );
   }
   return workflows;
 };
 
-// Creates a temporary index file importing all workflows
+/**
+ * Creates a temporary index file importing all workflows
+ *
+ * @param {object[]} workflows
+ * @returns
+ */
 export function createWorkflowsEntryPoint( workflows ) {
-  const entryPoint = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
+  const path = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
 
   // 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' );
+  const catalog = { name: WORKFLOW_CATALOG, path: join( __dirname, './catalog_workflow/workflow.js' ) };
+  const content = [ ... workflows, catalog ].map( ( { name, path } ) => `export { default as ${name} } from '${path}';` ).join( EOL );
 
-  writeFileOnLocationSync( entryPoint, workflowsIndex );
-  return entryPoint;
+  mkdirSync( dirname( path ), { recursive: true } );
+  writeFileSync( path, content, 'utf-8' );
+  return path;
 };

package/src/worker/loader.spec.js

@@ -1,29 +1,24 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
-
 vi.mock( '#consts', () => ( {
-  SEND_WEBHOOK_ACTIVITY_NAME: '__internal#sendWebhookPost',
-  READ_TRACE_FILE: '__internal#readTraceFile',
+  ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
-  METADATA_ACCESS_SYMBOL
+  WORKFLOW_CATALOG: 'catalog'
 } ) );
 
-const sendWebhookPostMock = vi.fn();
-const readTraceFileMock = vi.fn();
+const sendWebhookMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhookPost: sendWebhookPostMock,
-  readTraceFile: readTraceFileMock
+  sendWebhook: sendWebhookMock
 } ) );
 
-// 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
+const importComponentsMock = vi.fn();
+vi.mock( './loader_tools.js', () => ( { importComponents: importComponentsMock } ) );
+
+const mkdirSyncMock = vi.fn();
+const writeFileSyncMock = vi.fn();
+vi.mock( 'node:fs', () => ( {
+  mkdirSync: mkdirSyncMock,
+  writeFileSync: writeFileSyncMock
 } ) );
 
 describe( 'worker/loader', () => {
@@ -34,39 +29,37 @@ describe( 'worker/loader', () => {
   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' };
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'Act1' }, path: '/a/steps.js' };
     } );
 
     const activities = await loadActivities( '/root' );
     expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
-    expect( activities['__internal#sendWebhookPost'] ).toBe( sendWebhookPostMock );
-    expect( activities['__internal#readTraceFile'] ).toBe( readTraceFileMock );
+    expect( activities['__internal#sendWebhook'] ).toBe( sendWebhookMock );
   } );
 
   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' };
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
     } );
 
     const workflows = await loadWorkflows( '/root' );
-    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', pathname: '/b/workflow.js', path: '/b' } ] );
+    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js' } ] );
   } );
 
   it( 'createWorkflowsEntryPoint writes index and returns its path', async () => {
     const { createWorkflowsEntryPoint } = await import( './loader.js' );
 
-    const workflows = [ { name: 'W', pathname: '/abs/wf.js' } ];
+    const workflows = [ { name: 'W', path: '/abs/wf.js' } ];
     const entry = createWorkflowsEntryPoint( workflows );
 
-    expect( writeFileMock ).toHaveBeenCalledTimes( 1 );
-    const [ writtenPath, contents ] = writeFileMock.mock.calls[0];
+    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath, contents ] = writeFileSyncMock.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 }' );
+    expect( mkdirSyncMock ).toHaveBeenCalledTimes( 1 );
   } );
 } );

package/src/worker/loader_tools.js

@@ -0,0 +1,63 @@
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+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
+ */
+/**
+ * @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
+ */
+
+/**
+ * Recursive traverse directories looking for files with given name.
+ *
+ * @param {string} path - The path to scan
+ * @param {string[]} filenames  - The filenames to look for
+ * @returns {CollectedFile[]} An array containing the collected files
+ * */
+const findByNameRecursively = ( parentPath, filenames, collection = [], ignoreDirNames = [ 'vendor', 'node_modules' ] ) => {
+  for ( const entry of readdirSync( parentPath, { withFileTypes: true } ) ) {
+    if ( ignoreDirNames.includes( entry.name ) ) {
+      continue;
+    }
+
+    const path = resolve( parentPath, entry.name );
+    if ( entry.isDirectory() ) {
+      findByNameRecursively( path, filenames, collection );
+    } else if ( filenames.includes( entry.name ) ) {
+      collection.push( { path, url: pathToFileURL( path ).href } );
+    }
+  }
+
+  return collection;
+};
+
+/**
+ * For each path, dynamic import it, and for each exported component with metadata (step, workflow), yields it.
+ *
+ * @generator
+ * @async
+ * @function importComponents
+ * @param {string} target - Place to look for files
+ * @param {string[]} filenames - File names to load recursively from target
+ * @yields {Component}
+ */
+export async function *importComponents( target, filenames ) {
+  for ( const { url, path } 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 };
+    }
+  }
+};

package/src/worker/loader_tools.spec.js

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { importComponents } from './loader_tools.js';
+
+describe( '.importComponents', () => {
+  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 collected = [];
+    for await ( const m of importComponents( root, [ 'meta.module.js' ] ) ) {
+      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.path ).toBe( file );
+      expect( typeof m.fn ).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 collected = [];
+    for await ( const m of importComponents( root, [ 'meta.module.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 0 );
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'skips files inside ignored directories (node_modules, vendor)', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-ignoredirs` );
+    const okDir = join( root, 'ok' );
+    const nmDir = join( root, 'node_modules' );
+    const vendorDir = join( root, 'vendor' );
+    mkdirSync( okDir, { recursive: true } );
+    mkdirSync( nmDir, { recursive: true } );
+    mkdirSync( vendorDir, { recursive: true } );
+
+    const okFile = join( okDir, 'meta.module.js' );
+    const nmFile = join( nmDir, 'meta.module.js' );
+    const vendorFile = join( vendorDir, 'meta.module.js' );
+
+    const fileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const C = () => {};',
+      'C[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "c" };'
+    ].join( '\n' );
+    writeFileSync( okFile, fileContents );
+    writeFileSync( nmFile, fileContents );
+    writeFileSync( vendorFile, fileContents );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ 'meta.module.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 1 );
+    expect( collected[0].path ).toBe( okFile );
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+} );

package/src/worker/sinks.js

@@ -1,16 +1,66 @@
-import { Storage } from './async_storage.js';
-import { trace } from './tracer/index.js';
-import { THIS_LIB_NAME } from '#consts';
+import { WORKFLOW_CATALOG } from '#consts';
+import { addEventStart, addEventEnd, addEventError } from '#tracing';
 
+/**
+ * Start a workflow trace event
+ *
+ * @param {function} method - Trace function to call
+ * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {object} details - Teh details to attach to the event
+ */
+const addWorkflowEvent = ( method, workflowInfo, details ) => {
+  const { workflowId: id, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
+  if ( name === WORKFLOW_CATALOG ) {
+    return;
+  } // ignore internal catalog events
+  method( { id, kind: 'workflow', name, details, parentId, executionContext } );
+};
+
+/**
+ * Start a trace event with given configuration
+ *
+ * @param {function} method - Trace function to call
+ * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {object} options - Trace options, like id, kind, name and details
+ */
+const addEvent = ( method, workflowInfo, options ) => {
+  const { id, name, kind, details } = options;
+  const { workflowId, memo: { executionContext } } = workflowInfo;
+  method( { id, kind, name, details, parentId: workflowId, executionContext } );
+};
+
+// This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
-  // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
-  log: {
-    trace: {
-      fn( workflowInfo, args ) {
-        const { workflowId, workflowType, memo } = workflowInfo;
-        Storage.runWithContext( _ => trace( { lib: THIS_LIB_NAME, ...args } ), { workflowId, workflowType, ...memo } );
-      },
+  trace: {
+    addWorkflowEventStart: {
+      fn: ( ...args ) => addWorkflowEvent( addEventStart, ...args ),
+      callDuringReplay: false
+    },
+
+    addWorkflowEventEnd: {
+      fn: ( ...args ) => addWorkflowEvent( addEventEnd, ...args ),
+      callDuringReplay: false
+    },
+
+    addWorkflowEventError: {
+      fn: ( ...args ) => addWorkflowEvent( addEventError, ...args ),
       callDuringReplay: false
+    },
+
+    addEventStart: {
+      fn: ( ...args ) => addEvent( addEventStart, ...args ),
+      callDuringReplay: false
+    },
+
+    addEventEnd: {
+      fn: ( ...args ) => addEvent( addEventEnd, ...args ),
+      callDuringReplay: false
+    },
+
+    addEventError: {
+      fn: ( ...args ) => addEvent( addEventError, ...args ),
+      callDuringReplay: false
+
     }
   }
 };

package/src/configs.js

@@ -1,36 +0,0 @@
-import * as z from 'zod';
-
-class InvalidEnvVarsErrors extends Error { }
-
-const envVarSchema = z.object( {
-  TEMPORAL_ADDRESS: z.string().optional().default( 'localhost:7233' ),
-  TEMPORAL_NAMESPACE: z.string().optional().default( 'default' ),
-  TEMPORAL_API_KEY: z.string().optional(),
-  CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
-  API_AUTH_KEY: z.string().optional(),
-  TRACING_ENABLED: z.stringbool().optional()
-} );
-
-const { data: safeEnvVar, error } = envVarSchema.safeParse( process.env );
-if ( error ) {
-  throw new InvalidEnvVarsErrors( z.prettifyError( error ) );
-}
-
-export const worker = {
-  address: safeEnvVar.TEMPORAL_ADDRESS,
-  apiKey: safeEnvVar.TEMPORAL_API_KEY,
-  executionTimeout: '1m',
-  maxActivities: 100,
-  maxWorkflows: 100,
-  namespace: safeEnvVar.TEMPORAL_NAMESPACE ?? 'default',
-  taskQueue: safeEnvVar.CATALOG_ID,
-  catalogId: safeEnvVar.CATALOG_ID
-};
-
-export const api = {
-  authKey: safeEnvVar.API_AUTH_KEY
-};
-
-export const tracing = {
-  enabled: safeEnvVar.TRACING_ENABLED
-};