@output.ai/core 0.1.0 → 0.1.1

package/src/configs.spec.js

@@ -1,331 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-describe( 'configs', () => {
-  const originalEnv = process.env;
-
-  beforeEach( () => {
-    vi.resetModules();
-    process.env = { ...originalEnv };
-  } );
-
-  afterEach( () => {
-    process.env = originalEnv;
-  } );
-
-  describe( 'Environment Variable Validation', () => {
-    describe( 'TEMPORAL_ADDRESS', () => {
-      it( 'should accept string addresses', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'localhost:7233' );
-      } );
-
-      it( 'should use default when omitted', async () => {
-        process.env = {
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'localhost:7233' );
-      } );
-
-      it( 'should reject non-string values', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: '123',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        // Convert to number to test non-string
-        const originalEnv = process.env.TEMPORAL_ADDRESS;
-        process.env.TEMPORAL_ADDRESS = 123;
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-
-        process.env.TEMPORAL_ADDRESS = originalEnv;
-      } );
-    } );
-
-    describe( 'CATALOG_ID', () => {
-      it( 'should accept valid catalog IDs with letters and numbers', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'catalog123'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( 'catalog123' );
-        expect( worker.taskQueue ).toBe( 'catalog123' );
-      } );
-
-      it( 'should accept catalog IDs with dots and hyphens', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'my.catalog-id'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( 'my.catalog-id' );
-      } );
-
-      it( 'should accept catalog IDs with underscores', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'my_catalog_id'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( 'my_catalog_id' );
-      } );
-
-      it( 'should accept catalog IDs with @ symbol', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: '@my-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( '@my-catalog' );
-      } );
-
-      it( 'should reject catalog IDs with special characters', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'catalog!@#$'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-
-      it( 'should reject when CATALOG_ID is missing', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-
-      it( 'should reject empty CATALOG_ID', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: ''
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-    } );
-
-    describe( 'Optional Fields', () => {
-      it( 'should use default namespace when TEMPORAL_NAMESPACE is not provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.namespace ).toBe( 'default' );
-      } );
-
-      it( 'should use custom namespace when provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          TEMPORAL_NAMESPACE: 'custom-namespace'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.namespace ).toBe( 'custom-namespace' );
-      } );
-
-      it( 'should handle TEMPORAL_API_KEY when provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          TEMPORAL_API_KEY: 'secret-api-key'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.apiKey ).toBe( 'secret-api-key' );
-      } );
-
-      it( 'should handle missing TEMPORAL_API_KEY', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.apiKey ).toBeUndefined();
-      } );
-
-      it( 'should handle API_AUTH_KEY when provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          API_AUTH_KEY: 'api-secret-key'
-        };
-
-        const { api } = await import( './configs.js' );
-        expect( api.authKey ).toBe( 'api-secret-key' );
-      } );
-
-      it( 'should handle missing API_AUTH_KEY', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { api } = await import( './configs.js' );
-        expect( api.authKey ).toBeUndefined();
-      } );
-    } );
-  } );
-
-  describe( 'Exported Config Objects', () => {
-    it( 'should export worker config with all properties', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        TEMPORAL_NAMESPACE: 'test-namespace',
-        TEMPORAL_API_KEY: 'test-api-key'
-      };
-
-      const { worker } = await import( './configs.js' );
-
-      expect( worker ).toEqual( {
-        address: 'http://localhost:7233',
-        apiKey: 'test-api-key',
-        executionTimeout: '1m',
-        maxActivities: 100,
-        maxWorkflows: 100,
-        namespace: 'test-namespace',
-        taskQueue: 'test-catalog',
-        catalogId: 'test-catalog'
-      } );
-    } );
-
-    it( 'should export api config', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        API_AUTH_KEY: 'test-auth-key'
-      };
-
-      const { api } = await import( './configs.js' );
-
-      expect( api ).toEqual( {
-        authKey: 'test-auth-key'
-      } );
-    } );
-
-    it( 'should have correct static worker config values', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog'
-      };
-
-      const { worker } = await import( './configs.js' );
-
-      expect( worker.executionTimeout ).toBe( '1m' );
-      expect( worker.maxActivities ).toBe( 100 );
-      expect( worker.maxWorkflows ).toBe( 100 );
-    } );
-  } );
-
-  describe( 'Error Handling', () => {
-    it( 'should throw InvalidEnvVarsErrors for invalid configuration', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'localhost:7233',
-        CATALOG_ID: 'invalid!@#'
-      };
-
-      await expect( import( './configs.js' ) ).rejects.toThrow();
-    } );
-
-    it( 'should handle multiple validation errors', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'localhost:7233',
-        CATALOG_ID: 'invalid!@#'
-      };
-
-      await expect( import( './configs.js' ) ).rejects.toThrow();
-    } );
-  } );
-
-  describe( 'Edge Cases', () => {
-    it( 'should handle environment variables with spaces', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        TEMPORAL_NAMESPACE: '  custom-namespace  '
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.namespace ).toBe( '  custom-namespace  ' );
-    } );
-
-    it( 'should handle very long catalog IDs', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'a'.repeat( 100 )
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.catalogId ).toBe( 'a'.repeat( 100 ) );
-    } );
-
-    it( 'should handle URLs with ports outside typical range', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:65535',
-        CATALOG_ID: 'test-catalog'
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.address ).toBe( 'http://localhost:65535' );
-    } );
-
-    it( 'should handle container names with numbers', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'temporal123:7233',
-        CATALOG_ID: 'test-catalog'
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.address ).toBe( 'temporal123:7233' );
-    } );
-
-    it( 'should handle mixed case in catalog ID', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'Test.Catalog-ID_123'
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.catalogId ).toBe( 'Test.Catalog-ID_123' );
-    } );
-  } );
-
-  describe( 'Complete Valid Configuration', () => {
-    it( 'should handle a complete valid configuration with all optional fields', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'https://temporal.cloud.example.com',
-        TEMPORAL_NAMESPACE: 'production',
-        TEMPORAL_API_KEY: 'prod-api-key-123',
-        CATALOG_ID: 'prod.catalog@v1',
-        API_AUTH_KEY: 'secure-auth-key'
-      };
-
-      const { worker, api } = await import( './configs.js' );
-
-      expect( worker.address ).toBe( 'https://temporal.cloud.example.com' );
-      expect( worker.namespace ).toBe( 'production' );
-      expect( worker.apiKey ).toBe( 'prod-api-key-123' );
-      expect( worker.catalogId ).toBe( 'prod.catalog@v1' );
-      expect( worker.taskQueue ).toBe( 'prod.catalog@v1' );
-      expect( api.authKey ).toBe( 'secure-auth-key' );
-    } );
-  } );
-} );

package/src/tracing/index.private.spec.js

@@ -1,84 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir, EOL } from 'node:os';
-import { join } from 'path';
-
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-' ) );
-
-// Use env var to enable tracing
-
-vi.mock( '#async_storage', () => ( { Storage: { load: () => ( { parentId: undefined, traceId: 'trace-1', traceHelm: 'tests' } ) } } ) );
-vi.mock( 'path', async importActual => {
-  const actual = await importActual();
-  return { ...actual, join: ( first, ...rest ) => actual.join( first ?? process.cwd(), ...rest ) };
-} );
-vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
-
-describe( 'tracing private exports', () => {
-  beforeEach( () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-    vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
-    process.env.TRACING_ENABLED = '1';
-  } );
-
-  afterEach( () => {
-    vi.useRealTimers();
-    delete process.env.TRACING_ENABLED;
-  } );
-
-  it( 'addEventStart (private) writes start', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    const { addEventStart } = await import( './index.js?v=private1' );
-    addEventStart( { id: 'a', kind: 'evaluator', name: 'start', details: { foo: 1 }, traceId: 'trace-1', traceHelm: 'tests' } );
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const logPath = buildLogTree.mock.calls[0][0];
-    const raw = readFileSync( logPath, 'utf-8' );
-    const entry = JSON.parse( raw.split( EOL )[0] );
-    expect( entry.phase ).toBe( 'start' );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'addEventEnd (private) writes end', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    const { addEventEnd } = await import( './index.js?v=private2' );
-    addEventEnd( { id: 'a', details: { ok: true }, traceId: 'trace-1', traceHelm: 'tests' } );
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const logPath = buildLogTree.mock.calls[0][0];
-    const raw = readFileSync( logPath, 'utf-8' );
-    const entry = JSON.parse( raw.split( EOL )[0] );
-    expect( entry.phase ).toBe( 'end' );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'addEventError (private) writes error', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    const { addEventError } = await import( './index.js?v=private3' );
-    addEventError( { id: 'a', details: new Error( 'oops' ), traceId: 'trace-1', traceHelm: 'tests' } );
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const logPath = buildLogTree.mock.calls[0][0];
-    const raw = readFileSync( logPath, 'utf-8' );
-    const entry = JSON.parse( raw.split( EOL )[0] );
-    expect( entry.phase ).toBe( 'error' );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-} );

package/src/tracing/index.public.spec.js

@@ -1,86 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir, EOL } from 'node:os';
-import { join } from 'path';
-
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-' ) );
-
-// Async storage mock to drive parent ids
-
-const mockStorageData = { parentId: undefined, traceId: 'trace-1', traceHelm: 'tests' };
-vi.mock( '#async_storage', () => ( { Storage: { load: () => mockStorageData } } ) );
-
-vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
-
-describe( 'Tracing (public namespace)', () => {
-  beforeEach( () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-    vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
-    process.env.TRACING_ENABLED = '1';
-  } );
-
-  afterEach( () => {
-    vi.useRealTimers();
-    delete process.env.TRACING_ENABLED;
-  } );
-
-  it( 'addEventStart writes a start entry', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    const { Tracing } = await import( './index.js' );
-    Tracing.addEventStart( { id: '1', kind: 'evaluator', name: 'start', details: { a: 1 } } );
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const logPath = buildLogTree.mock.calls[0][0];
-    const raw = readFileSync( logPath, 'utf-8' );
-    const firstLine = raw.split( EOL )[0];
-    const entry = JSON.parse( firstLine );
-    expect( entry ).toMatchObject( { phase: 'start', kind: 'evaluator', name: 'start', id: '1', details: { a: 1 } } );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'addEventEnd writes an end entry', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    const { Tracing } = await import( './index.js' );
-    Tracing.addEventEnd( { id: '1', details: { ok: true } } );
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const logPath = buildLogTree.mock.calls[0][0];
-    const raw = readFileSync( logPath, 'utf-8' );
-    const firstLine = raw.split( EOL )[0];
-    const entry = JSON.parse( firstLine );
-    expect( entry ).toMatchObject( { phase: 'end', id: '1', details: { ok: true } } );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'addEventError writes an error entry', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    const { Tracing } = await import( './index.js' );
-    const error = new Error( 'boom' );
-    Tracing.addEventError( { id: '1', details: error } );
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const logPath = buildLogTree.mock.calls[0][0];
-    const raw = readFileSync( logPath, 'utf-8' );
-    const firstLine = raw.split( EOL )[0];
-    const entry = JSON.parse( firstLine );
-    expect( entry.phase ).toBe( 'error' );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-} );

package/src/worker/internal_utils.js

@@ -1,60 +0,0 @@
-/*
- * 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

@@ -1,134 +0,0 @@
-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 } );
-  } );
-} );