@output.ai/core 0.0.7 → 0.0.9

package/src/worker/loader.spec.js

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

package/src/worker/sinks.js

@@ -1,5 +1,6 @@
 import { Storage } from './async_storage.js';
 import { trace } from './tracer/index.js';
+import { THIS_LIB_NAME } from '#consts';
 
 export const sinks = {
   // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
@@ -7,7 +8,7 @@ export const sinks = {
     trace: {
       fn( workflowInfo, args ) {
         const { workflowId, workflowType, memo } = workflowInfo;
-        Storage.runWithContext( _ => trace( { lib: 'core', ...args } ), { workflowId, workflowType, ...memo } );
+        Storage.runWithContext( _ => trace( { lib: THIS_LIB_NAME, ...args } ), { workflowId, workflowType, ...memo } );
       },
       callDuringReplay: false
     }

package/src/worker/tracer/index.js

@@ -7,12 +7,35 @@ import { tracing as tracingConfig } from '#configs';
 
 const callerDir = process.argv[2];
 
+/**
+ * Appends new information to a file
+ *
+ * Information has to be a JSON
+ *
+ * File is encoded in utf-8
+ *
+ * @param {string} path - The full filename
+ * @param {object} json - The content
+ */
 const flushEntry = ( path, json ) => appendFileSync( path, JSON.stringify( json ) + EOL, 'utf-8' );
 
-export function trace( { lib, event, input, output } ) {
+/**
+ * Add an event to the execution trace file.
+ *
+ * Events normally are the result of an operation, either a function call or an IO.
+ *
+ * @param {object} options
+ * @param {string} options.lib - The macro part of the platform that triggered the event
+ * @param {string} options.event - The name of the event
+ * @param {any} [options.input] - The input of the operation
+ * @param {any} [options.output] - The output of the operation
+ */
+export function trace( { lib, event, input = undefined, output = undefined } ) {
   const now = Date.now();
 
-  if ( !tracingConfig.enabled ) { return; }
+  if ( !tracingConfig.enabled ) {
+    return;
+  }
 
   const {
     activityId: stepId,
@@ -29,7 +52,9 @@ export function trace( { lib, event, input, output } ) {
 
   // test for rootWorkflow to append to the same file as the parent/grandparent
   const outputDir = join( callerDir, 'logs', 'runs', rootWorkflowType ?? workflowType );
-  if ( !existsSync( outputDir ) ) { mkdirSync( outputDir, { recursive: true } ); }
+  if ( !existsSync( outputDir ) ) {
+    mkdirSync( outputDir, { recursive: true } );
+  }
 
   const suffix = `-${rootWorkflowId ?? workflowId}.raw`;
   const logFile = readdirSync( outputDir ).find( f => f.endsWith( suffix ) ) ?? `${new Date( now ).toISOString()}-${suffix}`;
@@ -39,5 +64,12 @@ export function trace( { lib, event, input, output } ) {
   buildLogTree( logPath );
 };
 
+/**
+ * Setup the global tracer function, so it is available to be used by other libraries
+ *
+ * It will be situated in the global object, under Symbol.for('__trace')
+ *
+ * @returns {object} The assigned globalThis
+ */
 export const setupGlobalTracer = () =>
   Object.defineProperty( globalThis, Symbol.for( '__trace' ), { value: trace, writable: false, enumerable: false, configurable: false } );

package/src/worker/tracer/index.test.js

@@ -0,0 +1,115 @@
+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';
+import { THIS_LIB_NAME } from '#consts';
+
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-' ) );
+
+describe( 'tracer/index', () => {
+  beforeEach( () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
+  } );
+
+  afterEach( () => {
+    vi.useRealTimers();
+  } );
+
+  it( 'writes a raw log entry and calls buildLogTree (mocked)', async () => {
+    const originalArgv2 = process.argv[2];
+    const tmp = createTempDir();
+    process.argv[2] = tmp;
+
+    const prevTracing = process.env.TRACING_ENABLED;
+    process.env.TRACING_ENABLED = 'true';
+    vi.mock( '../async_storage.js', () => ( {
+      Storage: {
+        load: () => ( {
+          activityId: 's1',
+          activityType: 'Step 1',
+          workflowId: 'wf1',
+          workflowType: 'prompt',
+          workflowPath: '/workflows/prompt.js',
+          parentWorkflowId: undefined,
+          rootWorkflowId: undefined,
+          rootWorkflowType: undefined
+        } )
+      }
+    } ) );
+    vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
+    const { trace } = await import( './index.js' );
+
+    const input = { foo: 1 };
+    trace( { lib: THIS_LIB_NAME, event: 'workflow_start', input, output: null } );
+
+    const { buildLogTree } = await import( './tracer_tree.js' );
+    expect( buildLogTree ).toHaveBeenCalledTimes( 1 );
+    const logPath = buildLogTree.mock.calls[0][0];
+
+    const raw = readFileSync( logPath, 'utf-8' );
+    const [ firstLine ] = raw.split( EOL );
+    const entry = JSON.parse( firstLine );
+
+    expect( entry ).toMatchObject( {
+      lib: THIS_LIB_NAME,
+      event: 'workflow_start',
+      input,
+      output: null,
+      stepId: 's1',
+      stepName: 'Step 1',
+      workflowId: 'wf1',
+      workflowType: 'prompt',
+      workflowPath: '/workflows/prompt.js'
+    } );
+    expect( typeof entry.timestamp ).toBe( 'number' );
+
+    rmSync( tmp, { recursive: true, force: true } );
+    process.env.TRACING_ENABLED = prevTracing;
+    process.argv[2] = originalArgv2;
+  } );
+
+  it( 'does nothing when tracing is disabled', async () => {
+    const originalArgv2 = process.argv[2];
+    const tmp = createTempDir();
+    process.argv[2] = tmp;
+
+    const prevTracing = process.env.TRACING_ENABLED;
+    process.env.TRACING_ENABLED = 'false';
+    vi.mock( '../async_storage.js', () => ( {
+      Storage: {
+        load: () => ( {
+          activityId: 's1',
+          activityType: 'Step 1',
+          workflowId: 'wf1',
+          workflowType: 'prompt',
+          workflowPath: '/workflows/prompt.js'
+        } )
+      }
+    } ) );
+    vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
+    const { trace } = await import( './index.js' );
+
+    trace( { lib: THIS_LIB_NAME, event: 'workflow_start', input: {}, output: null } );
+
+    const { buildLogTree } = await import( './tracer_tree.js' );
+    expect( buildLogTree ).not.toHaveBeenCalled();
+
+    rmSync( tmp, { recursive: true, force: true } );
+    process.env.TRACING_ENABLED = prevTracing;
+    process.argv[2] = originalArgv2;
+  } );
+
+  it( 'setupGlobalTracer installs global symbol', async () => {
+    const prevTracing = process.env.TRACING_ENABLED;
+    process.env.TRACING_ENABLED = 'false';
+    const { setupGlobalTracer } = await import( './index.js' );
+    setupGlobalTracer();
+    const sym = Symbol.for( '__trace' );
+    expect( typeof globalThis[sym] ).toBe( 'function' );
+    process.env.TRACING_ENABLED = prevTracing;
+  } );
+} );
+

package/src/worker/tracer/tracer_tree.js

@@ -1,16 +1,40 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { EOL } from 'os';
 import { TraceEvent } from './types.js';
+import { THIS_LIB_NAME } from '#consts';
 
-const timestampAscSort = ( a, b ) => a.timestamp > b.timestamp ? -1 : 1;
+/**
+ * Sorting function that compares two objects and ASC sort them by either .startedAt or, if not present, .timestamp
+ *
+ * @param {object} a
+ * @param {object} b
+ * @returns {number} The sorting result [1,-1]
+ */
+const timestampAscSort = ( a, b ) => {
+  if ( a.startedAt ) {
+    return a.startedAt > b.startedAt ? 1 : 1;
+  }
+  return a.timestamp > b.timestamp ? 1 : -1;
+};
 
+/**
+ * Add a member to an array an sort it. It is a mutating method.
+ *
+ * @param {array} arr - The arr to be changed
+ * @param {any} entry - The entry to be added
+ * @param {Function} sorter - The sort function to be used (within .filter)
+ */
 const pushSort = ( arr, entry, sorter ) => {
   arr.push( entry );
   arr.sort( sorter );
 };
 
-const coreLib = 'core';
-
+/**
+ * Transform the trace file into a tree of events, where nested events are represented as children of parent events.
+ * And the events STEP_START/STEP_END and WORKFLOW_START/WORKFLOW_END are combined into single events with start and end timestamps.
+ *
+ * @param {string} src - The trace src filename
+ */
 export const buildLogTree = src => {
   const content = readFileSync( src, 'utf-8' );
   const entries = content.split( EOL ).slice( 0, -1 ).map( c => JSON.parse( c ) );
@@ -19,7 +43,7 @@ export const buildLogTree = src => {
   const workflowsMap = new Map();
 
   // close steps/workflows
-  for ( const entry of entries.filter( e => e.lib === coreLib ) ) {
+  for ( const entry of entries.filter( e => e.lib === THIS_LIB_NAME ) ) {
     const { event, workflowId, workflowType, workflowPath, parentWorkflowId, stepId, stepName, input, output, timestamp } = entry;
 
     const baseEntry = { children: [], startedAt: timestamp, workflowId };
@@ -41,7 +65,7 @@ export const buildLogTree = src => {
   }
 
   // insert operations inside steps
-  for ( const entry of entries.filter( e => e.lib !== coreLib ) ) {
+  for ( const entry of entries.filter( e => e.lib !== THIS_LIB_NAME ) ) {
     pushSort( stepsMap.get( `${entry.workflowId}:${entry.stepId}` ).children, entry, timestampAscSort );
   }
 

package/src/worker/tracer/tracer_tree.test.js

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+import { writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'path';
+import { EOL } from 'os';
+import { buildLogTree } from './tracer_tree.js';
+import { TraceEvent } from './types.js';
+import { THIS_LIB_NAME } from '#consts';
+
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-tree-' ) );
+
+describe( 'tracer/tracer_tree', () => {
+  it( 'builds a tree JSON from a raw log file', () => {
+    const tmp = createTempDir();
+    const rawPath = join( tmp, 'run-123.raw' );
+
+    const entries = [
+      // root workflow start
+      {
+        lib: THIS_LIB_NAME,
+        event: TraceEvent.WORKFLOW_START,
+        input: { a: 1 },
+        output: null,
+        timestamp: 1000,
+        stepId: undefined,
+        stepName: undefined,
+        workflowId: 'wf1',
+        workflowType: 'prompt',
+        workflowPath: '/workflows/prompt.js',
+        parentWorkflowId: undefined
+      },
+      // step start
+      {
+        lib: THIS_LIB_NAME,
+        event: TraceEvent.STEP_START,
+        input: { x: 1 },
+        output: null,
+        timestamp: 2000,
+        stepId: 's1',
+        stepName: 'Step 1',
+        workflowId: 'wf1',
+        workflowType: 'prompt',
+        workflowPath: '/workflows/prompt.js',
+        parentWorkflowId: undefined
+      },
+      // non-core operation within step
+      {
+        lib: 'tool',
+        event: 'call',
+        input: { y: 2 },
+        output: { y: 3 },
+        timestamp: 3000,
+        stepId: 's1',
+        stepName: 'Step 1',
+        workflowId: 'wf1'
+      },
+      // step end
+      {
+        lib: THIS_LIB_NAME,
+        event: TraceEvent.STEP_END,
+        input: null,
+        output: { done: true },
+        timestamp: 4000,
+        stepId: 's1',
+        stepName: 'Step 1',
+        workflowId: 'wf1',
+        workflowType: 'prompt',
+        workflowPath: '/workflows/prompt.js',
+        parentWorkflowId: undefined
+      },
+      // workflow end
+      {
+        lib: THIS_LIB_NAME,
+        event: TraceEvent.WORKFLOW_END,
+        input: null,
+        output: { ok: true },
+        timestamp: 5000,
+        stepId: undefined,
+        stepName: undefined,
+        workflowId: 'wf1',
+        workflowType: 'prompt',
+        workflowPath: '/workflows/prompt.js',
+        parentWorkflowId: undefined
+      }
+    ];
+
+    writeFileSync( rawPath, entries.map( e => JSON.stringify( e ) ).join( EOL ) + EOL, 'utf-8' );
+
+    buildLogTree( rawPath );
+
+    const tree = JSON.parse( readFileSync( rawPath.replace( /.raw$/, '.json' ), 'utf-8' ) );
+
+    expect( tree.event ).toBe( 'workflow' );
+    expect( tree.workflowId ).toBe( 'wf1' );
+    expect( tree.workflowType ).toBe( 'prompt' );
+    expect( tree.startedAt ).toBe( 1000 );
+    expect( tree.endedAt ).toBe( 5000 );
+    expect( tree.output ).toEqual( { ok: true } );
+    expect( Array.isArray( tree.children ) ).toBe( true );
+    expect( tree.children.length ).toBe( 1 );
+
+    const step = tree.children[0];
+    expect( step.event ).toBe( 'step' );
+    expect( step.stepId ).toBe( 's1' );
+    expect( step.startedAt ).toBe( 2000 );
+    expect( step.endedAt ).toBe( 4000 );
+    expect( step.output ).toEqual( { done: true } );
+    expect( step.children.length ).toBe( 1 );
+    expect( step.children[0].lib ).toBe( 'tool' );
+    expect( step.children[0].timestamp ).toBe( 3000 );
+
+    rmSync( tmp, { recursive: true, force: true } );
+  } );
+} );
+

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.js

@@ -0,0 +1,133 @@
+import traverseModule from '@babel/traverse';
+import {
+  buildWorkflowNameMap,
+  getLocalNameFromDestructuredProperty,
+  isStepsPath,
+  isWorkflowPath,
+  buildStepsNameMap,
+  toAbsolutePath
+} from './tools.js';
+import {
+  isCallExpression,
+  isIdentifier,
+  isImportDefaultSpecifier,
+  isImportSpecifier,
+  isObjectPattern,
+  isObjectProperty,
+  isStringLiteral,
+  isVariableDeclaration
+} from '@babel/types';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const traverse = traverseModule.default ?? traverseModule;
+
+/**
+ * Collect and strip target imports and requires from an AST, producing
+ * step/workflow import mappings for later rewrites.
+ *
+ * Mutates the AST by removing matching import declarations and require declarators.
+ *
+ * @param {import('@babel/types').File} ast - Parsed file AST.
+ * @param {string} fileDir - Absolute directory of the file represented by `ast`.
+ * @param {{ stepsNameCache: Map<string,Map<string,string>>, workflowNameCache: Map<string,{default:(string|null),named:Map<string,string>}> }} caches
+ *  Resolved-name caches to avoid re-reading same modules.
+ * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
+ *  flowImports: Array<{localName:string,workflowName:string}> }} Collected info mappings.
+ */
+export default function collectTargetImports( ast, fileDir, { stepsNameCache, workflowNameCache } ) {
+  const stepImports = [];
+  const flowImports = [];
+
+  traverse( ast, {
+    ImportDeclaration: path => {
+      const src = path.node.source.value;
+      // Ignore other imports
+      if ( !isStepsPath( src ) && !isWorkflowPath( src ) ) {
+        return;
+      }
+
+      const absolutePath = toAbsolutePath( fileDir, src );
+      if ( isStepsPath( src ) ) {
+        const nameMap = buildStepsNameMap( absolutePath, stepsNameCache );
+        for ( const s of path.node.specifiers.filter( s => isImportSpecifier( s ) ) ) {
+          const importedName = s.imported.name;
+          const localName = s.local.name;
+          const stepName = nameMap.get( importedName );
+          if ( stepName ) {
+            stepImports.push( { localName, stepName } );
+          }
+        }
+      }
+      if ( isWorkflowPath( src ) ) {
+        const { named, default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
+        for ( const s of path.node.specifiers ) {
+          if ( isImportDefaultSpecifier( s ) ) {
+            const localName = s.local.name;
+            flowImports.push( { localName, workflowName: defName ?? localName } );
+          } else if ( isImportSpecifier( s ) ) {
+            const importedName = s.imported.name;
+            const localName = s.local.name;
+            const workflowName = named.get( importedName );
+            if ( workflowName ) {
+              flowImports.push( { localName, workflowName } );
+            }
+          }
+        }
+      }
+      path.remove();
+    },
+    VariableDeclarator: path => {
+      const init = path.node.init;
+      // Not a require call
+      if ( !isCallExpression( init ) ) {
+        return;
+      }
+      // Different callee
+      if ( !isIdentifier( init.callee, { name: 'require' } ) ) {
+        return;
+      }
+      const firstArgument = init.arguments[0];
+      // Dynamic require is not supported
+      if ( !isStringLiteral( firstArgument ) ) {
+        return;
+      }
+
+      const req = firstArgument.value;
+      // Must be steps/workflows module
+      if ( !isStepsPath( req ) && !isWorkflowPath( req ) ) {
+        return;
+      }
+
+      const absolutePath = toAbsolutePath( fileDir, req );
+      if ( isStepsPath( req ) && isObjectPattern( path.node.id ) ) {
+        const nameMap = buildStepsNameMap( absolutePath, stepsNameCache );
+        for ( const prop of path.node.id.properties.filter( prop => isObjectProperty( prop ) && isIdentifier( prop.key ) ) ) {
+          const importedName = prop.key.name;
+          const localName = getLocalNameFromDestructuredProperty( prop );
+          if ( localName ) {
+            const stepName = nameMap.get( importedName );
+            if ( stepName ) {
+              stepImports.push( { localName, stepName } );
+            }
+          }
+        }
+        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+          path.parentPath.remove();
+        } else {
+          path.remove();
+        }
+      } else if ( isWorkflowPath( req ) && isIdentifier( path.node.id ) ) {
+        const { default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
+        const localName = path.node.id.name;
+        flowImports.push( { localName, workflowName: defName ?? localName } );
+        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+          path.parentPath.remove();
+        } else {
+          path.remove();
+        }
+      }
+    }
+  } );
+
+  return { stepImports, flowImports };
+};

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.spec.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parse } from './tools.js';
+import collectTargetImports from './collect_target_imports.js';
+
+function makeAst( source, filename ) {
+  return parse( source, filename );
+}
+
+describe( 'collect_target_imports', () => {
+  it( 'collects ESM imports for steps and workflows and flags changes', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-' ) );
+    writeFileSync( join( dir, 'steps.js' ), [
+      'export const StepA = step({ name: "step.a" })',
+      'export const StepB = step({ name: "step.b" })'
+    ].join( '\n' ) );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'export const FlowA = workflow({ name: "flow.a" })',
+      'export default workflow({ name: "flow.def" })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepA } from "./steps.js";',
+      'import WF, { FlowA } from "./workflow.js";',
+      'const x = 1;'
+    ].join( '\n' );
+
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { stepImports, flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+
+    expect( stepImports ).toEqual( [ { localName: 'StepA', stepName: 'step.a' } ] );
+    expect( flowImports ).toEqual( [
+      { localName: 'WF', workflowName: 'flow.def' },
+      { localName: 'FlowA', workflowName: 'flow.a' }
+    ] );
+    // Import declarations should have been removed
+    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' ) ).toBeUndefined();
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS requires and removes declarators (steps + default workflow)', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: "step.b" })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: "flow.c" })\n' );
+
+    const source = [
+      'const { StepB } = require("./steps.js");',
+      'const WF = require("./workflow.js");',
+      'const obj = {};'
+    ].join( '\n' );
+
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { stepImports, flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+
+    expect( stepImports ).toEqual( [ { localName: 'StepB', stepName: 'step.b' } ] );
+    expect( flowImports ).toEqual( [ { localName: 'WF', workflowName: 'flow.c' } ] );
+    // All require-based declarators should have been removed (only non-require decls may remain)
+    const hasRequireDecl = ast.program.body.some( n =>
+      n.type === 'VariableDeclaration' && n.declarations.some( d => d.init && d.init.type === 'CallExpression' )
+    );
+    expect( hasRequireDecl ).toBe( false );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );
+

package/src/worker/webpack_loaders/workflow_rewriter/consts.js

@@ -0,0 +1,3 @@
+export const NodeType = {
+  CONST: 'const'
+};