@outputai/core 0.14.0 → 0.14.1-next.51e8690.0

package/src/worker/webpack_loaders/tools.spec.js

@@ -1,314 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, resolve as resolvePath } from 'node:path';
-import * as t from '@babel/types';
-import {
-  toAbsolutePath,
-  parse,
-  extractTopLevelStringConsts,
-  getObjectKeyName,
-  getLocalNameFromDestructuredProperty,
-  isStepsPath,
-  isSharedStepsPath,
-  isAnyStepsPath,
-  isEvaluatorsPath,
-  isSharedEvaluatorsPath,
-  isWorkflowPath,
-  isAbsoluteWorkflowJsResource,
-  resolveNameFromArg,
-  resolveNameFromOptions,
-  buildStepsNameMap,
-  buildSharedStepsNameMap,
-  buildWorkflowNameMap,
-  buildEvaluatorsNameMap,
-  getFileKind
-} from './tools.js';
-
-describe( 'workflow_rewriter tools', () => {
-  it( 'parse: parses JS with JSX plugin enabled', () => {
-    const ast = parse( 'const A = 1; const C = () => <div />', 'file.js' );
-    expect( ast?.type ).toBe( 'File' );
-    expect( ast.program.body.length ).toBeGreaterThan( 0 );
-  } );
-
-  it( 'toAbsolutePath: resolves relative path against base directory', () => {
-    expect( toAbsolutePath( '/base/dir', './file.js' ) ).toBe( resolvePath( '/base/dir', './file.js' ) );
-  } );
-
-  it( 'extractTopLevelStringConsts: returns only const string bindings', () => {
-    const ast = parse( [
-      'const A = \"a\"; let B = \"b\"; const C = 3;',
-      'const D = `d`; const E = \"e\"'
-    ].join( '\n' ), 'file.js' );
-    const map = extractTopLevelStringConsts( ast );
-    expect( map.get( 'A' ) ).toBe( 'a' );
-    expect( map.has( 'B' ) ).toBe( false );
-    expect( map.has( 'C' ) ).toBe( false );
-    // Template literal is not a StringLiteral
-    expect( map.has( 'D' ) ).toBe( false );
-    expect( map.get( 'E' ) ).toBe( 'e' );
-  } );
-
-  it( 'resolveNameFromOptions: returns literal name from options object', () => {
-    const opts = t.objectExpression( [ t.objectProperty( t.identifier( 'name' ), t.stringLiteral( 'literal.name' ) ) ] );
-    const out = resolveNameFromOptions( opts, new Map(), 'X' );
-    expect( out ).toBe( 'literal.name' );
-  } );
-
-  it( 'getObjectKeyName: resolves from Identifier and StringLiteral', () => {
-    expect( getObjectKeyName( t.identifier( 'name' ) ) ).toBe( 'name' );
-    expect( getObjectKeyName( t.stringLiteral( 'x' ) ) ).toBe( 'x' );
-    expect( getObjectKeyName( t.numericLiteral( 1 ) ) ).toBeNull();
-  } );
-
-  it( 'buildStepsNameMap: reads names from steps module and caches result', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-steps-' ) );
-    const stepsPath = join( dir, 'steps.js' );
-    writeFileSync( stepsPath, [
-      'export const StepA = step({ name: "step.a" })',
-      'export const StepB = step({ name: "step.b" })'
-    ].join( '\n' ) );
-    const cache = new Map();
-    const map1 = buildStepsNameMap( stepsPath, cache );
-    expect( map1.get( 'StepA' ) ).toBe( 'step.a' );
-    expect( map1.get( 'StepB' ) ).toBe( 'step.b' );
-    expect( cache.get( stepsPath ) ).toBe( map1 );
-    const map2 = buildStepsNameMap( stepsPath, cache );
-    expect( map2 ).toBe( map1 );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'buildEvaluatorsNameMap: reads names from evaluators module and caches result', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-evals-' ) );
-    const evalsPath = join( dir, 'evaluators.js' );
-    writeFileSync( evalsPath, [
-      'export const EvalA = evaluator({ name: "eval.a" })',
-      'export const EvalB = evaluator({ name: "eval.b" })'
-    ].join( '\n' ) );
-    const cache = new Map();
-    const map1 = buildEvaluatorsNameMap( evalsPath, cache );
-    expect( map1.get( 'EvalA' ) ).toBe( 'eval.a' );
-    expect( map1.get( 'EvalB' ) ).toBe( 'eval.b' );
-    expect( cache.get( evalsPath ) ).toBe( map1 );
-    const map2 = buildEvaluatorsNameMap( evalsPath, cache );
-    expect( map2 ).toBe( map1 );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'getLocalNameFromDestructuredProperty: handles { a }, { a: b }, { a: b = 1 }', () => {
-    // { a }
-    const p1 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'a' ), false, true );
-    expect( getLocalNameFromDestructuredProperty( p1 ) ).toBe( 'a' );
-    // { a: b }
-    const p2 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'b' ) );
-    expect( getLocalNameFromDestructuredProperty( p2 ) ).toBe( 'b' );
-    // { a: b = 1 }
-    const p3 = t.objectProperty( t.identifier( 'a' ), t.assignmentPattern( t.identifier( 'b' ), t.numericLiteral( 1 ) ) );
-    expect( getLocalNameFromDestructuredProperty( p3 ) ).toBe( 'b' );
-    // Unsupported shape
-    const p4 = t.objectProperty( t.identifier( 'a' ), t.arrayExpression( [] ) );
-    expect( getLocalNameFromDestructuredProperty( p4 ) ).toBeNull();
-  } );
-
-  it( 'buildWorkflowNameMap: reads named and default workflow names and caches', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-output-' ) );
-    const wfPath = join( dir, 'workflow.js' );
-    writeFileSync( wfPath, [
-      'export const FlowA = workflow({ name: "flow.a" })',
-      'export default workflow({ name: "flow.def" })'
-    ].join( '\n' ) );
-    const cache = new Map();
-    const res1 = buildWorkflowNameMap( wfPath, cache );
-    expect( res1.named.get( 'FlowA' ) ).toBe( 'flow.a' );
-    expect( res1.default ).toBe( 'flow.def' );
-    expect( cache.get( wfPath ) ).toBe( res1 );
-    const res2 = buildWorkflowNameMap( wfPath, cache );
-    expect( res2 ).toBe( res1 );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'isStepsPath: matches LOCAL steps.js (no path traversal)', () => {
-    // Local steps (without ../ or /shared/)
-    expect( isStepsPath( 'steps.js' ) ).toBe( true );
-    expect( isStepsPath( './steps.js' ) ).toBe( true );
-    expect( isStepsPath( '/a/b/steps.js' ) ).toBe( true );
-    expect( isStepsPath( './steps/fetch.js' ) ).toBe( true );
-    // Shared steps (with ../ or /shared/) should NOT match isStepsPath
-    expect( isStepsPath( '../steps.js' ) ).toBe( false );
-    expect( isStepsPath( '../../shared/steps/common.js' ) ).toBe( false );
-    // Non-steps
-    expect( isStepsPath( 'steps.ts' ) ).toBe( false );
-    expect( isStepsPath( 'workflow.js' ) ).toBe( false );
-  } );
-
-  it( 'isSharedStepsPath: matches steps imported from outside workflow directory', () => {
-    // Shared steps: must have steps pattern AND have path traversal or /shared/
-    expect( isSharedStepsPath( '../steps.js' ) ).toBe( true );
-    expect( isSharedStepsPath( '../../steps.js' ) ).toBe( true );
-    expect( isSharedStepsPath( '../../shared/steps/common.js' ) ).toBe( true );
-    expect( isSharedStepsPath( '../other_workflow/steps.js' ) ).toBe( true );
-    expect( isSharedStepsPath( '/src/shared/steps/common.js' ) ).toBe( true );
-    // Local steps (no traversal, no /shared/) should NOT match
-    expect( isSharedStepsPath( './steps.js' ) ).toBe( false );
-    expect( isSharedStepsPath( 'steps.js' ) ).toBe( false );
-    expect( isSharedStepsPath( './steps/fetch.js' ) ).toBe( false );
-    // Non-steps should NOT match
-    expect( isSharedStepsPath( '../utils.js' ) ).toBe( false );
-    expect( isSharedStepsPath( 'evaluators.js' ) ).toBe( false );
-  } );
-
-  it( 'isAnyStepsPath: matches any steps pattern (local or shared)', () => {
-    // Local steps
-    expect( isAnyStepsPath( 'steps.js' ) ).toBe( true );
-    expect( isAnyStepsPath( './steps.js' ) ).toBe( true );
-    expect( isAnyStepsPath( './steps/fetch.js' ) ).toBe( true );
-    // Shared steps
-    expect( isAnyStepsPath( '../steps.js' ) ).toBe( true );
-    expect( isAnyStepsPath( '../../shared/steps/common.js' ) ).toBe( true );
-    // Non-steps
-    expect( isAnyStepsPath( 'workflow.js' ) ).toBe( false );
-    expect( isAnyStepsPath( 'utils.js' ) ).toBe( false );
-  } );
-
-  it( 'isWorkflowPath: matches workflow.js at root or subpath', () => {
-    expect( isWorkflowPath( 'workflow.js' ) ).toBe( true );
-    expect( isWorkflowPath( './workflow.js' ) ).toBe( true );
-    expect( isWorkflowPath( '/a/b/workflow.js' ) ).toBe( true );
-    expect( isWorkflowPath( 'workflow.ts' ) ).toBe( false );
-    expect( isWorkflowPath( 'steps.js' ) ).toBe( false );
-  } );
-
-  it( 'isAbsoluteWorkflowJsResource: normalizes slashes', () => {
-    expect( isAbsoluteWorkflowJsResource( '/a/b/workflow.js' ) ).toBe( true );
-    expect( isAbsoluteWorkflowJsResource( 'C:\\\\a\\\\workflow.js' ) ).toBe( true );
-    expect( isAbsoluteWorkflowJsResource( '/a/b/steps.js' ) ).toBe( false );
-  } );
-
-  it( 'isEvaluatorsPath: matches local evaluators.js but excludes shared', () => {
-    expect( isEvaluatorsPath( 'evaluators.js' ) ).toBe( true );
-    expect( isEvaluatorsPath( './evaluators.js' ) ).toBe( true );
-    expect( isEvaluatorsPath( '/a/b/evaluators.js' ) ).toBe( true );
-    expect( isEvaluatorsPath( './evaluators/quality.js' ) ).toBe( true );
-    // Shared evaluators should NOT match (path traversal or /shared/)
-    expect( isEvaluatorsPath( '../evaluators.js' ) ).toBe( false );
-    expect( isEvaluatorsPath( '../../shared/evaluators/common.js' ) ).toBe( false );
-    expect( isEvaluatorsPath( 'evaluators.ts' ) ).toBe( false );
-    expect( isEvaluatorsPath( 'steps.js' ) ).toBe( false );
-  } );
-
-  it( 'isSharedEvaluatorsPath: matches evaluators imported from outside workflow directory', () => {
-    // Shared evaluators: must have evaluators pattern AND have path traversal or /shared/
-    expect( isSharedEvaluatorsPath( '../evaluators.js' ) ).toBe( true );
-    expect( isSharedEvaluatorsPath( '../../evaluators.js' ) ).toBe( true );
-    expect( isSharedEvaluatorsPath( '../../shared/evaluators/quality.js' ) ).toBe( true );
-    expect( isSharedEvaluatorsPath( '../other_workflow/evaluators.js' ) ).toBe( true );
-    expect( isSharedEvaluatorsPath( '/src/shared/evaluators/quality.js' ) ).toBe( true );
-    // Local evaluators (no traversal, no /shared/) should NOT match
-    expect( isSharedEvaluatorsPath( './evaluators.js' ) ).toBe( false );
-    expect( isSharedEvaluatorsPath( 'evaluators.js' ) ).toBe( false );
-    expect( isSharedEvaluatorsPath( './evaluators/quality.js' ) ).toBe( false );
-    // Non-evaluators should NOT match
-    expect( isSharedEvaluatorsPath( '../utils.js' ) ).toBe( false );
-    expect( isSharedEvaluatorsPath( 'steps.js' ) ).toBe( false );
-  } );
-
-  it( 'buildSharedStepsNameMap: reads names from shared steps module and caches result', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-shared-steps-' ) );
-    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
-    const stepsPath = join( dir, 'shared', 'steps', 'common.js' );
-    writeFileSync( stepsPath, [
-      'export const StepA = step({ name: "shared.step.a" })',
-      'export const StepB = step({ name: "shared.step.b" })'
-    ].join( '\n' ) );
-    const cache = new Map();
-    const map1 = buildSharedStepsNameMap( stepsPath, cache );
-    expect( map1.get( 'StepA' ) ).toBe( 'shared.step.a' );
-    expect( map1.get( 'StepB' ) ).toBe( 'shared.step.b' );
-    expect( cache.get( stepsPath ) ).toBe( map1 );
-    const map2 = buildSharedStepsNameMap( stepsPath, cache );
-    expect( map2 ).toBe( map1 );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'getFileKind: classifies file by its path', () => {
-    expect( getFileKind( '/p/workflow.js' ) ).toBe( 'workflow' );
-    expect( getFileKind( '/p/steps.js' ) ).toBe( 'steps' );
-    // Files in steps folder are steps
-    expect( getFileKind( '/p/steps/fetch.js' ) ).toBe( 'steps' );
-    expect( getFileKind( '/p/shared/steps/common.js' ) ).toBe( 'steps' );
-    expect( getFileKind( '/p/evaluators.js' ) ).toBe( 'evaluators' );
-    expect( getFileKind( '/p/evaluators/quality.js' ) ).toBe( 'evaluators' );
-    expect( getFileKind( '/p/other.js' ) ).toBe( null );
-    expect( getFileKind( '/p/utils.js' ) ).toBe( null );
-    expect( getFileKind( '/p/clients/api.js' ) ).toBe( null );
-  } );
-
-  it( 'resolveNameFromArg: resolves string literal directly', () => {
-    expect( resolveNameFromArg( t.stringLiteral( 'my_name' ), new Map(), 'X' ) ).toBe( 'my_name' );
-  } );
-
-  it( 'resolveNameFromArg: resolves identifier from consts', () => {
-    const consts = new Map( [ [ 'MY_NAME', 'resolved_name' ] ] );
-    expect( resolveNameFromArg( t.identifier( 'MY_NAME' ), consts, 'X' ) ).toBe( 'resolved_name' );
-  } );
-
-  it( 'resolveNameFromArg: falls back to resolveNameFromOptions for objects', () => {
-    const opts = t.objectExpression( [ t.objectProperty( t.identifier( 'name' ), t.stringLiteral( 'obj_name' ) ) ] );
-    expect( resolveNameFromArg( opts, new Map(), 'X' ) ).toBe( 'obj_name' );
-  } );
-
-  it( 'buildEvaluatorsNameMap: reads names from string-arg factory pattern', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-evals-' ) );
-    const evalsPath = join( dir, 'evaluators.js' );
-    writeFileSync( evalsPath, 'export const EvalA = verify( \'eval_a\', async () => {} )' );
-    const cache = new Map();
-    const map = buildEvaluatorsNameMap( evalsPath, cache );
-    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'buildEvaluatorsNameMap: reads names from object-arg verify pattern', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-obj-evals-' ) );
-    const evalsPath = join( dir, 'evaluators.js' );
-    writeFileSync( evalsPath, 'export const EvalA = verify( { name: \'eval_a\' }, async () => {} )' );
-    const cache = new Map();
-    const map = buildEvaluatorsNameMap( evalsPath, cache );
-    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'buildEvaluatorsNameMap: reads names from mixed factory patterns', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-mixed-evals-' ) );
-    const evalsPath = join( dir, 'evaluators.js' );
-    writeFileSync( evalsPath, [
-      'export const EvalA = verify( { name: \'eval_a\' }, async () => {} )',
-      'export const EvalB = evaluator( { name: \'eval_b\' } )'
-    ].join( '\n' ) );
-    const cache = new Map();
-    const map = buildEvaluatorsNameMap( evalsPath, cache );
-    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
-    expect( map.get( 'EvalB' ) ).toBe( 'eval_b' );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'buildStepsNameMap: reads names from string-arg factory pattern', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-steps-' ) );
-    const stepsPath = join( dir, 'steps.js' );
-    writeFileSync( stepsPath, 'export const StepA = myStepHelper( \'step_a\', async () => {} )' );
-    const cache = new Map();
-    const map = buildStepsNameMap( stepsPath, cache );
-    expect( map.get( 'StepA' ) ).toBe( 'step_a' );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'buildWorkflowNameMap: reads names from string-arg factory pattern', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-workflow-' ) );
-    const wfPath = join( dir, 'workflow.js' );
-    writeFileSync( wfPath, 'export default myWorkflowHelper( { name: \'my_flow\' } )' );
-    const cache = new Map();
-    const res = buildWorkflowNameMap( wfPath, cache );
-    expect( res.default ).toBe( 'my_flow' );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-} );

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

@@ -1,134 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mkdtempSync, mkdirSync, 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';
-
-const caches = () => ( {
-  stepsNameCache: new Map(),
-  evaluatorsNameCache: new Map(),
-  sharedStepsNameCache: new Map(),
-  sharedEvaluatorsNameCache: new Map()
-} );
-
-const makeAst = ( source, filename ) => parse( source, filename );
-
-describe( 'collect_target_imports', () => {
-  it( 'collects ESM activity imports and leaves workflow imports intact', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalA = evaluator({ name: \'eval.a\' });' );
-    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowA = workflow({ name: \'flow.a\' });' );
-
-    const ast = makeAst( `
-import { StepA } from './steps.js';
-import { EvalA } from './evaluators.js';
-import { FlowA } from './workflow.js';`, join( dir, 'file.js' ) );
-
-    const { activityImports } = collectTargetImports( ast, dir, caches() );
-
-    expect( activityImports ).toEqual( [
-      { localName: 'StepA', activityName: 'step.a' },
-      { localName: 'EvalA', activityName: 'eval.a' }
-    ] );
-    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' )?.source.value ).toBe( './workflow.js' );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'collects CJS activity requires and leaves workflow requires intact', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalB = evaluator({ name: \'eval.b\' });' );
-    writeFileSync( join( dir, 'workflow.js' ), 'export const helper = () => 42;' );
-
-    const ast = makeAst( `
-const { StepB } = require('./steps.js');
-const { EvalB } = require('./evaluators.js');
-const { helper } = require('./workflow.js');`, join( dir, 'file.js' ) );
-
-    const { activityImports } = collectTargetImports( ast, dir, caches() );
-
-    expect( activityImports ).toEqual( [
-      { localName: 'StepB', activityName: 'step.b' },
-      { localName: 'EvalB', activityName: 'eval.b' }
-    ] );
-    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'uses file path to choose component type instead of factory callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-path-scoped-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepExport = evaluator({ name: \'from.steps\' });' );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalExport = step({ name: \'from.evaluators\' });' );
-
-    const esmAst = makeAst( `
-import { StepExport } from './steps.js';
-import { EvalExport } from './evaluators.js';`, join( dir, 'esm.js' ) );
-    const cjsAst = makeAst( `
-const { StepExport } = require('./steps.js');
-const { EvalExport } = require('./evaluators.js');`, join( dir, 'cjs.js' ) );
-
-    expect( collectTargetImports( esmAst, dir, caches() ).activityImports ).toEqual( [
-      { localName: 'StepExport', activityName: 'from.steps' },
-      { localName: 'EvalExport', activityName: 'from.evaluators' }
-    ] );
-    expect( collectTargetImports( cjsAst, dir, caches() ).activityImports ).toEqual( [
-      { localName: 'StepExport', activityName: 'from.steps' },
-      { localName: 'EvalExport', activityName: 'from.evaluators' }
-    ] );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'collects shared steps and evaluators from ESM and CJS imports', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-shared-' ) );
-    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
-    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedStep = step({ name: \'shared.step\' });' );
-    writeFileSync(
-      join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const SharedEval = evaluator({ name: \'shared.eval\' });'
-    );
-
-    const fileDir = join( dir, 'workflows', 'my_workflow' );
-    const esmAst = makeAst( `
-import { SharedStep } from '../../shared/steps/common.js';
-import { SharedEval } from '../../shared/evaluators/common.js';`, join( fileDir, 'workflow.js' ) );
-    const cjsAst = makeAst( `
-const { SharedStep } = require('../../shared/steps/common.js');
-const { SharedEval } = require('../../shared/evaluators/common.js');`, join( fileDir, 'helper.js' ) );
-
-    expect( collectTargetImports( esmAst, fileDir, caches() ).activityImports ).toEqual( [
-      { localName: 'SharedStep', activityName: 'shared.step' },
-      { localName: 'SharedEval', activityName: 'shared.eval' }
-    ] );
-    expect( collectTargetImports( cjsAst, fileDir, caches() ).activityImports ).toEqual( [
-      { localName: 'SharedStep', activityName: 'shared.step' },
-      { localName: 'SharedEval', activityName: 'shared.eval' }
-    ] );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'leaves destructured workflow requires untouched', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-workflow-require-' ) );
-    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowX = workflow({ name: \'flow.x\' });' );
-
-    const ast = makeAst( 'const { FlowX } = require(\'./workflow.js\');', join( dir, 'file.js' ) );
-    const { activityImports } = collectTargetImports( ast, dir, caches() );
-
-    expect( activityImports ).toEqual( [] );
-    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'throws when a named activity import cannot be resolved from the target file', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-unresolved-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
-
-    const ast = makeAst( 'import { MissingStep } from \'./steps.js\';', join( dir, 'file.js' ) );
-
-    expect( () => collectTargetImports( ast, dir, caches() ) ).toThrow( /Unresolved import 'MissingStep'/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-} );

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

@@ -1,154 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import loader from './index.mjs';
-
-const { invokeActivitySymbolKey } = vi.hoisted( () => ( {
-  invokeActivitySymbolKey: 'test:invoke_activity'
-} ) );
-
-vi.mock( '#consts', async importOriginal => ( {
-  ...await importOriginal(),
-  INVOKE_ACTIVITY_SYMBOL: Symbol.for( invokeActivitySymbolKey )
-} ) );
-
-function runLoader( source, resourcePath ) {
-  return new Promise( ( resolve, reject ) => {
-    const ctx = {
-      resourcePath,
-      cacheable: () => {},
-      async: () => ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) ),
-      callback: ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) )
-    };
-    loader.call( ctx, source, null );
-  } );
-}
-
-const escapeRegExp = value => value.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
-const invokeActivityPattern = activityName =>
-  new RegExp( `globalThis\\[globalThis\\.Symbol\\.for\\(([\"'])${escapeRegExp( invokeActivitySymbolKey )}\\1\\)\\]\\('${activityName}'` );
-
-describe( 'workflows_rewriter Webpack loader spec', () => {
-  it( 'rewrites ESM activity imports and leaves workflow imports intact', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
-    writeFileSync( join( dir, 'workflow.js' ), `
-export const FlowA = workflow({ name: 'flow.a' });
-export default workflow({ name: 'flow.def' });` );
-
-    const source = `
-import { StepA } from './steps.js';
-import FlowDef, { FlowA } from './workflow.js';
-
-const obj = {
-  fn: async x => {
-    StepA(1);
-    FlowA(2);
-    FlowDef(3);
-  }
-}`;
-
-    const { code } = await runLoader( source, join( dir, 'file.js' ) );
-
-    expect( code ).not.toMatch( /from '\.\/steps\.js'/ );
-    expect( code ).toMatch( /from '\.\/workflow\.js'/ );
-    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
-    expect( code ).toMatch( /,\s*1\)/ );
-    expect( code ).toMatch( /FlowA\(2\)/ );
-    expect( code ).toMatch( /FlowDef\(3\)/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'rewrites CJS activity requires and leaves workflow requires intact', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
-    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' });' );
-
-    const source = `
-const { StepB } = require( './steps.js' );
-const FlowDefault = require( './workflow.js' );
-
-const obj = {
-  fn: async y => {
-    StepB(y);
-    FlowDefault();
-  }
-}`;
-
-    const { code } = await runLoader( source, join( dir, 'file.js' ) );
-
-    expect( code ).not.toMatch( /require\('\.\/steps\.js'\)/ );
-    expect( code ).toMatch( /require\('\.\/workflow\.js'\)/ );
-    expect( code ).toMatch( invokeActivityPattern( 'step\\.b' ) );
-    expect( code ).toMatch( /,\s*y\)/ );
-    expect( code ).toMatch( /FlowDefault\(\)/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'rewrites shared activity imports from helper modules', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-shared-helper-' ) );
-    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync(
-      join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const SharedEval = evaluator({ name: \'shared.eval\' });'
-    );
-
-    const source = `
-import { SharedEval } from '../../shared/evaluators/common.js';
-
-export const helper = async value => SharedEval(value);`;
-
-    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'helper.js' ) );
-
-    expect( code ).not.toMatch( /shared\/evaluators\/common\.js/ );
-    expect( code ).toMatch( invokeActivityPattern( 'shared\\.eval' ) );
-    expect( code ).toMatch( /,\s*value\)/ );
-    expect( code ).toMatch( /export const helper = async value =>/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves top-level const activity names', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-const-' ) );
-    writeFileSync( join( dir, 'steps.js' ), `
-const NAME = 'step.const';
-export const StepC = step({ name: NAME });` );
-
-    const source = `
-import { StepC } from './steps.js';
-const obj = { fn: async () => StepC() };`;
-
-    const { code } = await runLoader( source, join( dir, 'file.js' ) );
-    expect( code ).toMatch( invokeActivityPattern( 'step\\.const' ) );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'throws when globalThis is shadowed at a rewritten call site', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-globalthis-shadow-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.shadow\' });' );
-
-    const source = `
-import { StepA } from './steps.js';
-export function helper(globalThis) {
-  return StepA();
-}`;
-
-    await expect( runLoader( source, join( dir, 'helper.js' ) ) ).rejects.toThrow( /globalThis.*shadowed/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'propagates errors for non-static activity names', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-error-' ) );
-    writeFileSync( join( dir, 'steps.js' ), `
-function n() { return 'x'; }
-export const StepX = step({ name: n() });` );
-
-    const source = `
-import { StepX } from './steps.js';
-const obj = { fn: async () => StepX() };`;
-
-    await expect( runLoader( source, join( dir, 'file.js' ) ) ).rejects.toThrow( /Invalid step name/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-} );