@outputai/core 0.7.1-next.de30052.0 → 0.8.0

package/src/worker/{loader_tools.spec.js → loader/tools.spec.js}

@@ -1,26 +1,47 @@
-import { describe, it, expect, afterEach } from 'vitest';
+import { describe, it, expect, afterEach, beforeEach, vi } from 'vitest';
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, sep } from 'node:path';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
+
+const { workflowFileMatcherMock, sharedStepsDirMatcherMock, sharedEvaluatorsDirMatcherMock } = vi.hoisted( () => ( {
+  workflowFileMatcherMock: vi.fn(),
+  sharedStepsDirMatcherMock: vi.fn(),
+  sharedEvaluatorsDirMatcherMock: vi.fn()
+} ) );
+
+vi.mock( './matchers.js', () => ( {
+  staticMatchers: {
+    workflowFile: workflowFileMatcherMock,
+    sharedStepsDir: sharedStepsDirMatcherMock,
+    sharedEvaluatorsDir: sharedEvaluatorsDirMatcherMock
+  }
+} ) );
+
 import {
-  activityMatchersBuilder,
   matchFiles,
   findWorkflowsInNodeModules,
   findWorkflowsInPackages,
   findSharedActivitiesFromWorkflows,
   importComponents,
   findPackageRoot,
+  hashSourceCode,
   isPackageRoot,
   isPathDescendentFromNodeModules,
   resolveNodeModulesPath,
   resolveSymlink,
-  staticMatchers,
   packageExposesWorkflows
-} from './loader_tools.js';
+} from './tools.js';
 
 const TEMP_BASE = join( process.cwd(), 'sdk/core/temp_test_modules' );
 
+beforeEach( () => {
+  vi.clearAllMocks();
+  workflowFileMatcherMock.mockImplementation( path => path.endsWith( `${sep}workflow.js` ) );
+  sharedStepsDirMatcherMock.mockImplementation( path => path.includes( `${sep}shared${sep}steps${sep}` ) && path.endsWith( '.js' ) );
+  sharedEvaluatorsDirMatcherMock.mockImplementation( path => path.includes( `${sep}shared${sep}evaluators${sep}` ) && path.endsWith( '.js' ) );
+} );
+
 afterEach( () => {
   rmSync( TEMP_BASE, { recursive: true, force: true } );
 } );
@@ -158,36 +179,6 @@ describe( 'node_modules package resource helpers', () => {
   } );
 } );
 
-describe( 'activityMatchersBuilder', () => {
-  const base = `${sep}app${sep}proj`;
-
-  it( 'stepsFile matches only steps.js at base', () => {
-    const m = activityMatchersBuilder( base );
-    expect( m.stepsFile( `${base}${sep}steps.js` ) ).toBe( true );
-    expect( m.stepsFile( `${base}${sep}nested${sep}steps.js` ) ).toBe( false );
-  } );
-
-  it( 'evaluatorsFile matches only evaluators.js at base', () => {
-    const m = activityMatchersBuilder( base );
-    expect( m.evaluatorsFile( `${base}${sep}evaluators.js` ) ).toBe( true );
-    expect( m.evaluatorsFile( `${base}${sep}sub${sep}evaluators.js` ) ).toBe( false );
-  } );
-
-  it( 'stepsDir matches js under steps/', () => {
-    const m = activityMatchersBuilder( base );
-    expect( m.stepsDir( `${base}${sep}steps${sep}a.js` ) ).toBe( true );
-    expect( m.stepsDir( `${base}${sep}steps${sep}sub${sep}b.js` ) ).toBe( true );
-    expect( m.stepsDir( `${base}${sep}other${sep}a.js` ) ).toBe( false );
-  } );
-
-  it( 'evaluatorsDir matches js under evaluators/', () => {
-    const m = activityMatchersBuilder( base );
-    expect( m.evaluatorsDir( `${base}${sep}evaluators${sep}x.js` ) ).toBe( true );
-    expect( m.evaluatorsDir( `${base}${sep}evaluators${sep}y${sep}z.js` ) ).toBe( true );
-    expect( m.evaluatorsDir( `${base}${sep}steps${sep}x.js` ) ).toBe( false );
-  } );
-} );
-
 describe( 'matchFiles', () => {
   it( 'collects files matching matchers', () => {
     const root = join( TEMP_BASE, `fbnr-files-${Date.now()}` );
@@ -568,60 +559,37 @@ describe( 'findSharedActivitiesFromWorkflows', () => {
   } );
 } );
 
-describe( 'staticMatchers', () => {
-  describe( 'workflowFile', () => {
-    it( 'matches paths ending with path separator and workflow.js', () => {
-      expect( staticMatchers.workflowFile( `${sep}x${sep}y${sep}workflow.js` ) ).toBe( true );
-    } );
-
-    it( 'rejects workflow.ts', () => {
-      expect( staticMatchers.workflowFile( `${sep}a${sep}workflow.ts` ) ).toBe( false );
-    } );
-  } );
-
-  describe( 'workflowPathHasShared', () => {
-    it( 'matches workflow.js under a shared folder segment', () => {
-      expect( staticMatchers.workflowPathHasShared( `${sep}foo${sep}shared${sep}workflow.js` ) ).toBe( true );
-    } );
-
-    it( 'rejects workflow.js not under shared', () => {
-      expect( staticMatchers.workflowPathHasShared( `${sep}foo${sep}workflow.js` ) ).toBe( false );
-    } );
-  } );
-
-  describe( 'sharedStepsDir', () => {
-    it( 'matches .js files inside shared/steps/', () => {
-      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}dist${sep}shared${sep}steps${sep}tools.js` ) ).toBe( true );
-    } );
-
-    it( 'matches .js files in nested subdirectories of shared/steps/', () => {
-      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}dist${sep}shared${sep}steps${sep}utils${sep}helper.js` ) ).toBe( true );
-    } );
-
-    it( 'rejects .ts files inside shared/steps/', () => {
-      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}src${sep}shared${sep}steps${sep}tools.ts` ) ).toBe( false );
-    } );
+describe( 'hashSourceCode', () => {
+  const writeSource = root => {
+    mkdirSync( join( root, 'src' ), { recursive: true } );
+    writeFileSync( join( root, 'package.json' ), JSON.stringify( { name: 'proj' } ) );
+    writeFileSync( join( root, 'src', 'workflow.js' ), 'export default {};\n' );
+  };
+
+  it( 'ignores excluded folders so accumulated run logs do not change the hash', async () => {
+    const baseline = join( TEMP_BASE, `hash-baseline-${Date.now()}` );
+    const withCruft = join( TEMP_BASE, `hash-cruft-${Date.now()}` );
+    writeSource( baseline );
+    writeSource( withCruft );
+
+    // The cruft tree is identical source plus large excluded artifacts that
+    // boot must not walk: local trace dumps under logs/ and build output under dist/.
+    for ( const excluded of [ 'logs', 'logs/runs', 'dist', 'node_modules' ] ) {
+      const dir = join( withCruft, excluded );
+      mkdirSync( dir, { recursive: true } );
+      writeFileSync( join( dir, 'dump.json' ), JSON.stringify( { blob: 'x'.repeat( 50_000 ) } ) );
+    }
 
-    it( 'rejects non-.js files inside shared/steps/', () => {
-      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}dist${sep}shared${sep}steps${sep}readme.md` ) ).toBe( false );
-    } );
+    expect( await hashSourceCode( withCruft ) ).toBe( await hashSourceCode( baseline ) );
   } );
 
-  describe( 'sharedEvaluatorsDir', () => {
-    it( 'matches .js files inside shared/evaluators/', () => {
-      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}dist${sep}shared${sep}evaluators${sep}quality.js` ) ).toBe( true );
-    } );
-
-    it( 'matches .js files in nested subdirectories of shared/evaluators/', () => {
-      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}dist${sep}shared${sep}evaluators${sep}utils${sep}helper.js` ) ).toBe( true );
-    } );
-
-    it( 'rejects .ts files inside shared/evaluators/', () => {
-      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}src${sep}shared${sep}evaluators${sep}quality.ts` ) ).toBe( false );
-    } );
+  it( 'changes the hash when actual source changes', async () => {
+    const before = join( TEMP_BASE, `hash-src-before-${Date.now()}` );
+    const after = join( TEMP_BASE, `hash-src-after-${Date.now()}` );
+    writeSource( before );
+    writeSource( after );
+    writeFileSync( join( after, 'src', 'workflow.js' ), 'export default { changed: true };\n' );
 
-    it( 'rejects non-.js files inside shared/evaluators/', () => {
-      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}dist${sep}shared${sep}evaluators${sep}readme.md` ) ).toBe( false );
-    } );
+    expect( await hashSourceCode( after ) ).not.toBe( await hashSourceCode( before ) );
   } );
 } );

package/src/worker/loader/workflows.js

@@ -0,0 +1,82 @@
+import { EOL } from 'node:os';
+import { writeFileInTempDir, findWorkflowsInNodeModules, importComponents, matchFiles } from './tools.js';
+import { staticMatchers } from './matchers.js';
+import { WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG } from '#consts';
+import { createChildLogger } from '#logger';
+import { ValidationError } from '#errors';
+
+const log = createChildLogger( 'Workflow Loader' );
+
+/**
+ * Creates a temporary index file importing all workflows for Temporal.
+ * @param {object[]} workflows
+ * @returns {string} Filename
+ */
+const createWorkflowsEntrypoint = workflows => {
+  // default system catalog workflow
+  const catalog = { name: WORKFLOW_CATALOG, path: import.meta.resolve( '../catalog_workflow/workflow.js' ) };
+  const aliasExports = workflows.flatMap( ( { aliases = [], path } ) =>
+    aliases.map( alias => ( { name: alias, path } ) )
+  );
+
+  const content = [ ...workflows, ...aliasExports, catalog ]
+    .map( ( { name, path } ) => `export { default as ${name} } from '${path}';` ).join( EOL );
+
+  return writeFileInTempDir( content, WORKFLOWS_INDEX_FILENAME );
+};
+
+/**
+ * @typedef Workflow
+ * @property {string} path
+ * @property {boolean} external
+ * @property {string} name
+ * @property {string[]} aliases
+ * @property {object} inputSchema
+ * @property {object} outputSchema
+ */
+/**
+ * @typedef LoadWorkflowsResult
+ * @property {Workflow[]} workflows - Loaded workflows
+ * @property {string} entrypoint - Index file loading all workflows
+ */
+/**
+ * Scan and find workflow.js files and import them.
+ * Look into local and external (node_modules) folders.
+ * @param {string} rootDir
+ * @returns {LoadWorkflowsResult}
+ */
+export async function loadWorkflows( rootDir ) {
+  const workflowNames = new Set();
+  const workflows = [];
+  const localWorkflows = matchFiles( rootDir, [ staticMatchers.workflowFile ] );
+  const externalWorkflows = findWorkflowsInNodeModules( rootDir );
+  for await ( const { metadata, path } of importComponents( [ ...localWorkflows, ...externalWorkflows ] ) ) {
+    const external = externalWorkflows.some( a => a.path === path );
+    if ( staticMatchers.workflowPathHasShared( path ) ) {
+      throw new ValidationError( 'Workflow directory can\'t be named "shared"' );
+    }
+    const { name, aliases } = metadata;
+    if ( workflowNames.has( name ) ) {
+      throw new ValidationError( `Workflow name "${name}" conflicts with another workflow or alias. \
+Workflow names and aliases must be unique.` );
+    }
+    if ( WORKFLOW_CATALOG === name ) {
+      throw new ValidationError( `Workflow name "${name}" is reserved for the internal catalog workflow.` );
+    }
+    workflowNames.add( name );
+    for ( const alias of aliases ?? [] ) {
+      if ( workflowNames.has( alias ) ) {
+        throw new ValidationError( `Workflow "${name}" alias "${alias}" conflicts with another workflow or alias. \
+Workflow names and aliases must be unique.` );
+      }
+      if ( WORKFLOW_CATALOG === alias ) {
+        throw new ValidationError( `Workflow "${name}" alias "${alias}" is reserved for the internal catalog workflow.` );
+      }
+      workflowNames.add( alias );
+    }
+
+    log.info( name, { path, aliases, ...( external && { external } ) } );
+    workflows.push( { ...metadata, path, external } );
+  }
+  return { workflows, entrypoint: createWorkflowsEntrypoint( workflows ) };
+};

package/src/worker/loader/workflows.spec.js

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock( '#consts', () => ( {
+  ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest',
+  ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
+  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
+  WORKFLOW_CATALOG: 'catalog',
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
+  SHARED_STEP_PREFIX: '$shared'
+} ) );
+
+const { importComponentsMock, findWorkflowsInNodeModulesMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {
+  importComponentsMock: vi.fn(),
+  findWorkflowsInNodeModulesMock: vi.fn(),
+  matchFilesMock: vi.fn(),
+  writeFileInTempDirMock: vi.fn()
+} ) );
+
+const { workflowFileMatcherMock, workflowPathHasSharedMock } = vi.hoisted( () => ( {
+  workflowFileMatcherMock: vi.fn(),
+  workflowPathHasSharedMock: vi.fn()
+} ) );
+
+vi.mock( './tools.js', () => ( {
+  importComponents: importComponentsMock,
+  findWorkflowsInNodeModules: findWorkflowsInNodeModulesMock,
+  matchFiles: matchFilesMock,
+  writeFileInTempDir: writeFileInTempDirMock
+} ) );
+
+vi.mock( './matchers.js', () => ( {
+  staticMatchers: {
+    workflowFile: workflowFileMatcherMock,
+    workflowPathHasShared: workflowPathHasSharedMock
+  }
+} ) );
+
+describe( 'loadWorkflows', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    importComponentsMock.mockReset();
+    importComponentsMock.mockImplementation( async function *() {} );
+    findWorkflowsInNodeModulesMock.mockReset();
+    findWorkflowsInNodeModulesMock.mockReturnValue( [] );
+    matchFilesMock.mockReset();
+    matchFilesMock.mockReturnValue( [] );
+    writeFileInTempDirMock.mockReset();
+    writeFileInTempDirMock.mockReturnValue( '/tmp/__workflows_entrypoint.js' );
+    workflowPathHasSharedMock.mockReset();
+    workflowPathHasSharedMock.mockReturnValue( false );
+  } );
+
+  it( 'returns local workflows from importComponents with metadata spread onto each entry', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    const localFiles = [ { path: '/b/workflow.js', url: 'file:///b/workflow.js' } ];
+    matchFilesMock.mockReturnValueOnce( localFiles );
+
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
+    } );
+
+    const { workflows, entrypoint } = await loadWorkflows( '/root' );
+    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js', external: false } ] );
+    expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, localFiles );
+    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
+    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/root' );
+  } );
+
+  it( 'calls matchFiles with rootDir and workflowFile matcher', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    const localFiles = [ { path: '/my/app/workflow.js', url: 'file:///my/app/workflow.js' } ];
+    const externalFiles = [ { path: '/my/app/node_modules/pkg/workflow.js', url: 'file:///my/app/node_modules/pkg/workflow.js' } ];
+    matchFilesMock.mockReturnValueOnce( localFiles );
+    findWorkflowsInNodeModulesMock.mockReturnValue( externalFiles );
+
+    await loadWorkflows( '/my/app' );
+
+    expect( matchFilesMock ).toHaveBeenCalledOnce();
+    expect( matchFilesMock ).toHaveBeenCalledWith( '/my/app', [ workflowFileMatcherMock ] );
+    expect( importComponentsMock ).toHaveBeenCalledTimes( 1 );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, [ ...localFiles, ...externalFiles ] );
+    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
+    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/my/app' );
+  } );
+
+  it( 'appends node_modules workflows after local ones and sets external: true', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'LocalFlow', description: 'local' }, path: '/my/app/workflows/wf/workflow.js' };
+      yield {
+        metadata: { name: '__sum_numbers', description: 'from catalog' },
+        path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js'
+      };
+    } );
+    findWorkflowsInNodeModulesMock.mockReturnValue( [ { path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js' } ] );
+
+    const { workflows } = await loadWorkflows( '/my/app' );
+    expect( workflows ).toEqual( [
+      { name: 'LocalFlow', description: 'local', path: '/my/app/workflows/wf/workflow.js', external: false },
+      {
+        name: '__sum_numbers',
+        description: 'from catalog',
+        path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js',
+        external: true
+      }
+    ] );
+
+  } );
+
+  it( 'returns only external workflows when the project root has none', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'PkgFlow', description: 'pkg' }, path: '/proj/node_modules/a/w/workflow.js' };
+    } );
+    findWorkflowsInNodeModulesMock.mockReturnValue( [ { path: '/proj/node_modules/a/w/workflow.js' } ] );
+
+    const { workflows } = await loadWorkflows( '/proj' );
+    expect( workflows ).toEqual( [
+      {
+        name: 'PkgFlow',
+        description: 'pkg',
+        path: '/proj/node_modules/a/w/workflow.js',
+        external: true
+      }
+    ] );
+  } );
+
+  it( 'throws when a local workflow path is under a shared directory', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Invalid' }, path: '/root/shared/workflow.js' };
+    } );
+    workflowPathHasSharedMock.mockReturnValueOnce( true );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow( 'Workflow directory can\'t be named "shared"' );
+    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
+    expect( workflowPathHasSharedMock ).toHaveBeenCalledWith( '/root/shared/workflow.js' );
+  } );
+
+  it( 'throws when a workflow name conflicts with an earlier workflow name', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'duplicate' }, path: '/root/a/workflow.js' };
+      yield { metadata: { name: 'duplicate' }, path: '/root/b/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow name "duplicate" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+    );
+  } );
+
+  it( 'throws when a workflow name conflicts with an earlier alias', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'alpha', aliases: [ 'legacy' ] }, path: '/root/a/workflow.js' };
+      yield { metadata: { name: 'legacy' }, path: '/root/b/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow name "legacy" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+    );
+  } );
+
+  it( 'throws when an alias conflicts with an earlier workflow name', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'alpha' }, path: '/root/a/workflow.js' };
+      yield { metadata: { name: 'beta', aliases: [ 'alpha' ] }, path: '/root/b/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow "beta" alias "alpha" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+    );
+  } );
+
+  it( 'throws when an alias conflicts with an earlier alias', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'alpha', aliases: [ 'shared_alias' ] }, path: '/root/a/workflow.js' };
+      yield { metadata: { name: 'beta', aliases: [ 'shared_alias' ] }, path: '/root/b/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow "beta" alias "shared_alias" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+    );
+  } );
+
+  it( 'throws when an alias is identical to its workflow name', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'alpha', aliases: [ 'alpha' ] }, path: '/root/a/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow "alpha" alias "alpha" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+    );
+  } );
+
+  it( 'allows workflow names and aliases that only differ by case', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Alpha', aliases: [ 'Legacy' ] }, path: '/root/a/workflow.js' };
+      yield { metadata: { name: 'alpha', aliases: [ 'legacy' ] }, path: '/root/b/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).resolves.toMatchObject( {
+      workflows: [
+        { name: 'Alpha', aliases: [ 'Legacy' ], path: '/root/a/workflow.js', external: false },
+        { name: 'alpha', aliases: [ 'legacy' ], path: '/root/b/workflow.js', external: false }
+      ]
+    } );
+  } );
+
+  it( 'throws when a workflow name is reserved for the internal catalog', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'catalog' }, path: '/root/catalog/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow name "catalog" is reserved for the internal catalog workflow.'
+    );
+  } );
+
+  it( 'throws when a workflow alias is reserved for the internal catalog', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'alpha', aliases: [ 'catalog' ] }, path: '/root/a/workflow.js' };
+    } );
+
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+      'Workflow "alpha" alias "catalog" is reserved for the internal catalog workflow.'
+    );
+  } );
+
+  it( 'writes an entrypoint with workflows, aliases, and the catalog workflow', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'W', aliases: [ 'W_old', 'W_legacy' ] }, path: '/abs/wf.js' };
+    } );
+
+    const { entrypoint } = await loadWorkflows( '/root' );
+
+    expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
+    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 1 );
+    const [ contents, filename ] = writeFileInTempDirMock.mock.calls[0];
+    expect( filename ).toBe( '__workflows_entrypoint.js' );
+    expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as W_old } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as W_legacy } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as catalog }' );
+  } );
+} );

package/src/worker/{setup_telemetry.js → telemetry.js}

@@ -4,8 +4,11 @@ import { workerTelemetryIntervalMs } from './configs.js';
 const log = createChildLogger( 'Telemetry' );
 
 export const setupTelemetry = ( { worker } ) => {
-  if ( workerTelemetryIntervalMs > 0 ) {
-    setInterval( () => {
+  if ( workerTelemetryIntervalMs <= 0 ) {
+    return;
+  }
+  setInterval( () => {
+    try {
       log.info( 'Worker', {
         status: worker.getStatus(),
         memory: {
@@ -14,6 +17,8 @@ export const setupTelemetry = ( { worker } ) => {
           memoryUsage: process.memoryUsage()
         }
       } );
-    }, workerTelemetryIntervalMs ).unref();
-  }
+    } catch ( error ) {
+      log.warn( 'Failure', { error: error.message } );
+    }
+  }, workerTelemetryIntervalMs ).unref();
 };

package/src/worker/{setup_telemetry.spec.js → telemetry.spec.js}

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const configMock = vi.hoisted( () => ( { workerTelemetryIntervalMs: 0 } ) );
-const logMock = vi.hoisted( () => ( { info: vi.fn() } ) );
+const logMock = vi.hoisted( () => ( { info: vi.fn(), warn: vi.fn() } ) );
 const createChildLoggerMock = vi.hoisted( () => vi.fn( () => logMock ) );
 
 vi.mock( './configs.js', () => ( {
@@ -14,13 +14,13 @@ vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
 
 const loadSetupTelemetry = async () => {
   vi.resetModules();
-  return import( './setup_telemetry.js' );
+  return import( './telemetry.js' );
 };
 
 const mockSetInterval = unrefMock =>
   vi.spyOn( globalThis, 'setInterval' ).mockReturnValue( { unref: unrefMock } );
 
-describe( 'worker/setup_telemetry', () => {
+describe( 'worker/telemetry', () => {
   const availableMemoryMock = vi.fn();
   const constrainedMemoryMock = vi.fn();
   const memoryUsageMock = vi.fn();