@outputai/core 0.1.0

package/src/worker/interceptors/activity.js

@@ -0,0 +1,62 @@
+import { Context } from '@temporalio/activity';
+import { Storage } from '#async_storage';
+import * as Tracing from '#tracing';
+import { headersToObject } from '../sandboxed_utils.js';
+import { BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
+import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
+import { messageBus } from '#bus';
+
+/*
+  This interceptor wraps every activity execution with cross-cutting concerns:
+
+  1. Tracing: records start/end/error events and sets up AsyncLocalStorage context
+     so nested operations (e.g. HTTP calls inside steps) can be traced back to the parent activity.
+
+  2. Heartbeating: sends periodic heartbeat signals to Temporal so it can detect dead workers
+     without waiting for the full startToCloseTimeout (which can be up to 1h+).
+     This is critical during deploys — when a worker restarts, Temporal will notice
+     the missing heartbeat within the heartbeatTimeout window and retry the activity
+     on a new worker, instead of waiting the entire startToCloseTimeout.
+
+  Context information comes from two sources:
+  - Temporal's Activity Context (workflowId, activityId, activityType)
+  - Headers injected by the workflow interceptor (executionContext)
+*/
+export class ActivityExecutionInterceptor {
+  constructor( { activities, workflows } ) {
+    this.activities = activities;
+    this.workflowsMap = workflows.reduce( ( map, w ) => map.set( w.name, w ), new Map() );
+  };
+
+  async execute( input, next ) {
+    const startDate = Date.now();
+    const { workflowExecution: { workflowId }, activityId: id, activityType: name, workflowType: workflowName } = Context.current().info;
+    const { executionContext } = headersToObject( input.headers );
+    const { type: kind } = this.activities?.[name]?.[METADATA_ACCESS_SYMBOL];
+    const workflowFilename = this.workflowsMap.get( workflowName ).path;
+
+    messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
+    Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
+
+    const intervals = { heartbeat: null };
+    try {
+      // Sends heartbeat to communicate that activity is still alive
+      intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
+
+      // Wraps the execution with accessible metadata for the activity
+      const output = await Storage.runWithContext( async _ => next( input ), { parentId: id, executionContext, workflowFilename } );
+
+      messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
+      Tracing.addEventEnd( { id, details: output, executionContext } );
+      return output;
+
+    } catch ( error ) {
+      messageBus.emit( BusEventType.ACTIVITY_ERROR, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate, error } );
+      Tracing.addEventError( { id, details: error, executionContext } );
+
+      throw error;
+    } finally {
+      clearInterval( intervals.heartbeat );
+    }
+  }
+};

package/src/worker/interceptors/activity.spec.js

@@ -0,0 +1,212 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { BusEventType } from '#consts';
+
+const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
+
+const heartbeatMock = vi.fn();
+const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
+const contextInfoMock = {
+  workflowExecution: { workflowId: 'wf-1' },
+  activityId: 'act-1',
+  activityType: 'myWorkflow#myStep',
+  workflowType: 'myWorkflow'
+};
+
+vi.mock( '@temporalio/activity', () => ( {
+  Context: {
+    current: () => ( {
+      info: contextInfoMock,
+      heartbeat: heartbeatMock
+    } )
+  }
+} ) );
+
+vi.mock( '#async_storage', () => ( {
+  Storage: {
+    runWithContext: runWithContextMock
+  }
+} ) );
+
+const addEventStartMock = vi.fn();
+const addEventEndMock = vi.fn();
+const addEventErrorMock = vi.fn();
+vi.mock( '#tracing', () => ( {
+  addEventStart: addEventStartMock,
+  addEventEnd: addEventEndMock,
+  addEventError: addEventErrorMock
+} ) );
+
+vi.mock( '../sandboxed_utils.js', () => ( {
+  headersToObject: () => ( { executionContext: { workflowId: 'wf-1' } } )
+} ) );
+
+const messageBusEmitMock = vi.fn();
+vi.mock( '#bus', () => ( { messageBus: { emit: messageBusEmitMock } } ) );
+
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual, get METADATA_ACCESS_SYMBOL() {
+      return METADATA_ACCESS_SYMBOL;
+    }
+  };
+} );
+
+vi.mock( '../configs.js', () => ( {
+  get activityHeartbeatEnabled() {
+    return process.env.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED !== 'false';
+  },
+  get activityHeartbeatIntervalMs() {
+    return parseInt( process.env.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS || '120000', 10 );
+  }
+} ) );
+
+const makeActivities = () => ( {
+  'myWorkflow#myStep': { [METADATA_ACCESS_SYMBOL]: { type: 'step' } }
+} );
+
+const makeWorkflows = () => [ { name: 'myWorkflow', path: '/workflows/myWorkflow.js' } ];
+
+const makeInput = () => ( {
+  args: [ { someInput: 'data' } ],
+  headers: {}
+} );
+
+describe( 'ActivityExecutionInterceptor', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.resetModules();
+    // Default: heartbeat enabled with 50ms interval for fast tests
+    vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED', 'true' );
+    vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS', '50' );
+  } );
+
+  afterEach( () => {
+    vi.useRealTimers();
+    vi.unstubAllEnvs();
+  } );
+
+  it( 'records trace start and end events on successful execution', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    const promise = interceptor.execute( makeInput(), next );
+    vi.advanceTimersByTime( 0 );
+    const output = await promise;
+
+    expect( output ).toEqual( { result: 'ok' } );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.objectContaining( {
+      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow'
+    } ) );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.objectContaining( {
+      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow', duration: expect.any( Number )
+    } ) );
+    expect( addEventStartMock ).toHaveBeenCalledOnce();
+    expect( addEventEndMock ).toHaveBeenCalledOnce();
+    expect( addEventErrorMock ).not.toHaveBeenCalled();
+    expect( runWithContextMock ).toHaveBeenCalledWith(
+      expect.any( Function ),
+      {
+        parentId: 'act-1',
+        executionContext: { workflowId: 'wf-1' },
+        workflowFilename: '/workflows/myWorkflow.js'
+      }
+    );
+  } );
+
+  it( 'records trace error event on failed execution', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const error = new Error( 'step failed' );
+    const next = vi.fn().mockRejectedValue( error );
+
+    const promise = interceptor.execute( makeInput(), next );
+    vi.advanceTimersByTime( 0 );
+
+    await expect( promise ).rejects.toThrow( 'step failed' );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.objectContaining( {
+      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow',
+      duration: expect.any( Number ), error: expect.any( Error )
+    } ) );
+    expect( addEventStartMock ).toHaveBeenCalledOnce();
+    expect( addEventErrorMock ).toHaveBeenCalledOnce();
+    expect( addEventEndMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'sends periodic heartbeats during activity execution', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+
+    // next() resolves only after we manually resolve it, simulating a long-running activity
+    const deferred = { resolve: null };
+    const next = vi.fn().mockImplementation( () => new Promise( r => {
+      deferred.resolve = r;
+    } ) );
+
+    const promise = interceptor.execute( makeInput(), next );
+
+    expect( heartbeatMock ).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime( 50 );
+    expect( heartbeatMock ).toHaveBeenCalledTimes( 1 );
+
+    vi.advanceTimersByTime( 50 );
+    expect( heartbeatMock ).toHaveBeenCalledTimes( 2 );
+
+    vi.advanceTimersByTime( 50 );
+    expect( heartbeatMock ).toHaveBeenCalledTimes( 3 );
+
+    deferred.resolve( { result: 'done' } );
+    await promise;
+  } );
+
+  it( 'clears heartbeat interval after activity completes', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    const promise = interceptor.execute( makeInput(), next );
+    vi.advanceTimersByTime( 0 );
+    await promise;
+
+    heartbeatMock.mockClear();
+    vi.advanceTimersByTime( 500 );
+    expect( heartbeatMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'clears heartbeat interval after activity fails', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn().mockRejectedValue( new Error( 'boom' ) );
+
+    const promise = interceptor.execute( makeInput(), next );
+    vi.advanceTimersByTime( 0 );
+    await promise.catch( () => {} );
+
+    heartbeatMock.mockClear();
+    vi.advanceTimersByTime( 500 );
+    expect( heartbeatMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'does not heartbeat when OUTPUT_ACTIVITY_HEARTBEAT_ENABLED is false', async () => {
+    vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED', 'false' );
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+
+    const deferred = { resolve: null };
+    const next = vi.fn().mockImplementation( () => new Promise( r => {
+      deferred.resolve = r;
+    } ) );
+
+    const promise = interceptor.execute( makeInput(), next );
+
+    vi.advanceTimersByTime( 200 );
+    expect( heartbeatMock ).not.toHaveBeenCalled();
+
+    deferred.resolve( { result: 'done' } );
+    await promise;
+  } );
+} );

package/src/worker/interceptors/workflow.js

@@ -0,0 +1,70 @@
+// THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
+import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew } from '@temporalio/workflow';
+import { memoToHeaders } from '../sandboxed_utils.js';
+import { deepMerge } from '#utils';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+// this is a dynamic generated file with activity configs overwrites
+import stepOptions from '../temp/__activity_options.js';
+
+/*
+  This is not an AI comment!
+
+  This interceptor adds information value from workflowInfo().memo as Activity invocation headers.
+
+  This is a strategy to share values between the workflow context and activity context.
+
+  We also want to preserve existing headers that might have been inject somewhere else and
+*/
+class HeadersInjectionInterceptor {
+  async scheduleActivity( input, next ) {
+    const memo = workflowInfo().memo ?? {};
+    Object.assign( input.headers, memoToHeaders( memo ) );
+    // apply per-invocation options passed as second argument by rewritten calls
+    const options = stepOptions[input.activityType];
+    if ( options ) {
+      input.options = deepMerge( memo.activityOptions, options );
+    }
+    return next( input );
+  }
+};
+
+const sinks = proxySinks();
+
+class WorkflowExecutionInterceptor {
+  async execute( input, next ) {
+    sinks.workflow.start( input.args[0] );
+    try {
+      const output = await next( input );
+      sinks.workflow.end( output );
+      return output;
+    } catch ( error ) {
+      /*
+       * When the error is a ContinueAsNew instance, it represents the point where the actual workflow code was
+       * delegated to another run. In this case the result in the traces will be the string below and
+       * a new trace file will be generated
+       */
+      if ( error instanceof ContinueAsNew ) {
+        sinks.workflow.end( '<continued_as_new>' );
+        throw error;
+      }
+
+      sinks.workflow.error( error );
+      const failure = new ApplicationFailure( error.message, error.constructor.name, undefined, undefined, error );
+
+      /*
+       * If intercepted error has metadata, set it to .details property of Temporal's ApplicationFailure instance.
+       * This make it possible for this information be retrieved by Temporal's client instance.
+       * Ref: https://typescript.temporal.io/api/classes/common.ApplicationFailure#details
+       */
+      if ( error[METADATA_ACCESS_SYMBOL] ) {
+        failure.details = [ error[METADATA_ACCESS_SYMBOL] ];
+      }
+      throw failure;
+    }
+  }
+};
+
+export const interceptors = () => ( {
+  inbound: [ new WorkflowExecutionInterceptor() ],
+  outbound: [ new HeadersInjectionInterceptor( workflowInfo().workflowType ) ]
+} );

package/src/worker/interceptors/workflow.spec.js

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
+
+const workflowInfoMock = vi.fn();
+const workflowStartMock = vi.fn();
+const workflowEndMock = vi.fn();
+const workflowErrorMock = vi.fn();
+vi.mock( '@temporalio/workflow', () => ( {
+  workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
+  proxySinks: () => ( {
+    workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
+  } ),
+  ApplicationFailure: class ApplicationFailure {
+    constructor( message, type, nonRetryable, cause, originalError ) {
+      this.message = message;
+      this.type = type;
+      this.nonRetryable = nonRetryable;
+      this.cause = cause;
+      this.originalError = originalError;
+      this.details = undefined;
+    }
+  },
+  ContinueAsNew: class ContinueAsNew extends Error {
+    constructor() {
+      super( 'ContinueAsNew' );
+      this.name = 'ContinueAsNew';
+    }
+  }
+} ) );
+
+const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
+vi.mock( '../sandboxed_utils.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
+
+const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
+vi.mock( '#utils', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
+
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual, get METADATA_ACCESS_SYMBOL() {
+      return METADATA_ACCESS_SYMBOL;
+    }
+  };
+} );
+
+const stepOptionsDefault = {};
+vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );
+
+describe( 'workflow interceptors', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    workflowInfoMock.mockReturnValue( { workflowType: 'MyWorkflow', memo: { executionContext: { id: 'ctx-1' } } } );
+  } );
+
+  describe( 'HeadersInjectionInterceptor', () => {
+    it( 'assigns memo as headers via memoToHeaders and calls next', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { outbound } = interceptors();
+      const interceptor = outbound[0];
+      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1' };
+      const next = vi.fn().mockResolvedValue( 'result' );
+
+      memoToHeadersMock.mockReturnValue( { executionContext: { id: 'ctx-1' } } );
+
+      const out = await interceptor.scheduleActivity( input, next );
+
+      expect( memoToHeadersMock ).toHaveBeenCalledWith( { executionContext: { id: 'ctx-1' } } );
+      expect( input.headers ).toEqual( { existing: 'header', executionContext: { id: 'ctx-1' } } );
+      expect( next ).toHaveBeenCalledWith( input );
+      expect( out ).toBe( 'result' );
+    } );
+
+    it( 'merges stepOptions with memo.activityOptions when stepOptions exist for activityType', async () => {
+      stepOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
+      workflowInfoMock.mockReturnValue( {
+        workflowType: 'MyWorkflow',
+        memo: { executionContext: {}, activityOptions: { heartbeatTimeout: 10 } }
+      } );
+      memoToHeadersMock.mockReturnValue( {} );
+      deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
+
+      const { interceptors } = await import( './workflow.js' );
+      const { outbound } = interceptors();
+      const interceptor = outbound[0];
+      const input = { headers: {}, activityType: 'MyWorkflow#step1' };
+      const next = vi.fn().mockResolvedValue( undefined );
+
+      await interceptor.scheduleActivity( input, next );
+
+      expect( deepMergeMock ).toHaveBeenCalledWith( { heartbeatTimeout: 10 }, { scheduleToCloseTimeout: 60 } );
+      expect( input.options ).toEqual( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
+      delete stepOptionsDefault['MyWorkflow#step1'];
+    } );
+  } );
+
+  describe( 'WorkflowExecutionInterceptor', () => {
+    it( 'calls sinks.workflow.start, next, then sinks.workflow.end on success', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const input = { args: [ { input: 'data' } ] };
+      const next = vi.fn().mockResolvedValue( { output: 'ok' } );
+
+      const result = await interceptor.execute( input, next );
+
+      expect( workflowStartMock ).toHaveBeenCalledWith( { input: 'data' } );
+      expect( next ).toHaveBeenCalledWith( input );
+      expect( workflowEndMock ).toHaveBeenCalledWith( { output: 'ok' } );
+      expect( result ).toEqual( { output: 'ok' } );
+      expect( workflowErrorMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'calls sinks.workflow.error and throws ApplicationFailure on error', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const input = { args: [ {} ] };
+      const err = new Error( 'workflow failed' );
+      const next = vi.fn().mockRejectedValue( err );
+
+      await expect( interceptor.execute( input, next ) ).rejects.toMatchObject( {
+        message: 'workflow failed',
+        type: 'Error',
+        originalError: err
+      } );
+      expect( workflowStartMock ).toHaveBeenCalled();
+      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'sets failure.details from error metadata when present', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { ApplicationFailure } = await import( '@temporalio/workflow' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const meta = { code: 'CUSTOM' };
+      const err = new Error( 'custom' );
+      err[METADATA_ACCESS_SYMBOL] = meta;
+      const next = vi.fn().mockRejectedValue( err );
+
+      const error = await ( async () => {
+        try {
+          await interceptor.execute( { args: [ {} ] }, next );
+          return null;
+        } catch ( error ) {
+          return error;
+        }
+      } )();
+      expect( error ).toBeInstanceOf( ApplicationFailure );
+      expect( error.details ).toEqual( [ meta ] );
+    } );
+
+    it( 'on ContinueAsNew calls sinks.trace.addWorkflowEventEnd and rethrows', async () => {
+      const { ContinueAsNew } = await import( '@temporalio/workflow' );
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const continueErr = new ContinueAsNew();
+      const next = vi.fn().mockRejectedValue( continueErr );
+
+      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toThrow( ContinueAsNew );
+      expect( workflowEndMock ).toHaveBeenCalledWith( '<continued_as_new>' );
+      expect( workflowErrorMock ).not.toHaveBeenCalled();
+    } );
+  } );
+} );

package/src/worker/interceptors.js

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

package/src/worker/loader.js

@@ -0,0 +1,151 @@
+import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { EOL } from 'node:os';
+import { fileURLToPath } from 'url';
+import { getTraceDestinations, sendHttpRequest } from '#internal_activities';
+import { importComponents, staticMatchers, activityMatchersBuilder } from './loader_tools.js';
+import {
+  ACTIVITY_SEND_HTTP_REQUEST,
+  ACTIVITY_OPTIONS_FILENAME,
+  SHARED_STEP_PREFIX,
+  WORKFLOWS_INDEX_FILENAME,
+  WORKFLOW_CATALOG,
+  ACTIVITY_GET_TRACE_DESTINATIONS
+} from '#consts';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Scanner' );
+
+const __dirname = dirname( fileURLToPath( import.meta.url ) );
+
+/**
+ * Writes to file the activity options
+ *
+ * @param {object} optionsMap
+ */
+const writeActivityOptionsFile = map => {
+  const path = join( __dirname, 'temp', ACTIVITY_OPTIONS_FILENAME );
+  mkdirSync( dirname( path ), { recursive: true } );
+  writeFileSync( path, `export default ${JSON.stringify( map, undefined, 2 )};`, 'utf-8' );
+};
+
+/**
+ * Creates the activity key that will identify it on Temporal.
+ *
+ * It composes it using a namespace and the name of the activity.
+ *
+ * No two activities with the same name can exist on the same namespace.
+ *
+ * @param {object} options
+ * @param {string} namespace
+ * @param {string} activityName
+ * @returns {string} key
+ */
+const generateActivityKey = ( { namespace, activityName } ) => `${namespace}#${activityName}`;
+
+/**
+ * Load activities:
+ *
+ * - Scans activities based on workflows, using each workflow folder as a point to lookup for steps, evaluators files;
+ * - Scans shared activities in the rootDir;
+ * - Loads internal activities as well;
+ *
+ * Builds a map of activities, where they is generated according to the type of activity and the value is the function itself and return it.
+ * - Shared activity keys have a common prefix followed by the activity name;
+ * - Internal activities are registered with a fixed key;
+ * - Workflow activities keys are composed using the workflow name and the activity name;
+ *
+ * @param {string} rootDir
+ * @param {object[]} workflows
+ * @returns {object}
+ */
+export async function loadActivities( rootDir, workflows ) {
+  const activities = {};
+  const activityOptionsMap = {};
+
+  // Load workflow based activities
+  for ( const { path: workflowPath, name: workflowName } of workflows ) {
+    const dir = dirname( workflowPath );
+    for await ( const { fn, metadata, path } of importComponents( dir, Object.values( activityMatchersBuilder( dir ) ) ) ) {
+      log.info( 'Component loaded', { type: metadata.type, name: metadata.name, path, workflow: workflowName } );
+      // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
+      const activityKey = generateActivityKey( { namespace: workflowName, activityName: metadata.name } );
+      activities[activityKey] = fn;
+      // propagate the custom options set on the step()/evaluator() constructor
+      activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
+    }
+  }
+
+  // Load shared activities/evaluators
+  for await ( const { fn, metadata, path } of importComponents( rootDir, [ staticMatchers.sharedStepsDir, staticMatchers.sharedEvaluatorsDir ] ) ) {
+    log.info( 'Shared component loaded', { type: metadata.type, name: metadata.name, path } );
+    // The namespace for shared activities is fixed
+    const activityKey = generateActivityKey( { namespace: SHARED_STEP_PREFIX, activityName: metadata.name } );
+    activities[activityKey] = fn;
+    activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
+  }
+
+  // writes down the activity option overrides
+  writeActivityOptionsFile( activityOptionsMap );
+
+  // system activities
+  activities[ACTIVITY_SEND_HTTP_REQUEST] = sendHttpRequest;
+  activities[ACTIVITY_GET_TRACE_DESTINATIONS] = getTraceDestinations;
+  return activities;
+};
+
+/**
+ * Scan and find workflow.js files and import them.
+ *
+ * Creates an array containing their metadata and path and return it.
+ *
+ * @param {string} rootDir
+ * @returns {object[]}
+ */
+export async function loadWorkflows( rootDir ) {
+  const workflows = [];
+  for await ( const { metadata, path } of importComponents( rootDir, [ staticMatchers.workflowFile ] ) ) {
+    if ( staticMatchers.workflowPathHasShared( path ) ) {
+      throw new Error( 'Workflow directory can\'t be named "shared"' );
+    }
+    log.info( 'Workflow loaded', { name: metadata.name, path } );
+    workflows.push( { ...metadata, path } );
+  }
+  return workflows;
+};
+
+/**
+ * Loads the hook files from package.json's output config section.
+ *
+ * @param {string} rootDir
+ * @returns {void}
+ */
+export async function loadHooks( rootDir ) {
+  const packageFile = join( rootDir, 'package.json' );
+  if ( existsSync( packageFile ) ) {
+    const pkg = await import( packageFile, { with: { type: 'json' } } );
+    for ( const path of pkg.default.output?.hookFiles ?? [] ) {
+      const hookFile = join( rootDir, path );
+      await import( hookFile );
+      log.info( 'Hook file loaded', { path } );
+    }
+  }
+};
+
+/**
+ * Creates a temporary index file importing all workflows for Temporal.
+ *
+ * @param {object[]} workflows
+ * @returns
+ */
+export function createWorkflowsEntryPoint( workflows ) {
+  const path = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
+
+  // default system catalog workflow
+  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 );
+
+  mkdirSync( dirname( path ), { recursive: true } );
+  writeFileSync( path, content, 'utf-8' );
+  return path;
+};