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

package/src/interface/workflow.spec.js

@@ -1,684 +1,800 @@
-import { ACTIVITY_WRAPPER_VERSION_FIELD, Signal, WORKFLOW_WRAPPER_VERSION_FIELD } from '#consts';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { z } from 'zod';
+import {
+  ACTIVITY_GET_TRACE_DESTINATIONS,
+  ACTIVITY_WRAPPER_VERSION_FIELD,
+  METADATA_ACCESS_SYMBOL,
+  SHARED_STEP_PREFIX,
+  WORKFLOW_WRAPPER_VERSION_FIELD
+} from '#consts';
+import { ValidationError } from '#errors';
+
+const inWorkflowContextMock = vi.hoisted( () => vi.fn() );
+const proxyActivitiesMock = vi.hoisted( () => vi.fn() );
+const executeChildMock = vi.hoisted( () => vi.fn() );
+const workflowInfoMock = vi.hoisted( () => vi.fn() );
+const continueAsNewMock = vi.hoisted( () => vi.fn() );
+const validateDefinitionMock = vi.hoisted( () => vi.fn() );
+const validateInputMock = vi.hoisted( () => vi.fn() );
+const validateOutputMock = vi.hoisted( () => vi.fn() );
+const validateInvocationOptionsMock = vi.hoisted( () => vi.fn() );
+const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( './validations/index.js', () => {
+  class WorkflowValidator {
+    static validateDefinition( ...args ) {
+      return validateDefinitionMock( ...args );
+    }
 
-const inWorkflowContextMock = vi.hoisted( () => vi.fn( () => true ) );
-const defineSignalMock = vi.hoisted( () => vi.fn( name => name ) );
-const setHandlerMock = vi.hoisted( () => vi.fn() );
-const workflowContextBuildMock = vi.hoisted( () => vi.fn() );
-const traceInfoBuildMock = vi.hoisted( () => vi.fn() );
-const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
-const executeChildMock = vi.fn().mockResolvedValue( undefined );
-const continueAsNewMock = vi.fn().mockResolvedValue( undefined );
-
-const createStepsProxy = ( stepSpy = vi.fn() ) =>
-  new Proxy( {}, {
-    get: ( _, prop ) => {
-      if ( prop === '__internal#getTraceDestinations' ) {
-        return traceDestinationsStepMock;
-      }
-      if ( typeof prop === 'string' && ( prop.includes( '#' ) ) ) {
-        return stepSpy;
-      }
-      return vi.fn();
+    constructor( ...args ) {
+      validatorConstructorMock( ...args );
+      this.validateInput = validateInputMock;
+      this.validateOutput = validateOutputMock;
+      this.validateInvocationOptions = validateInvocationOptionsMock;
     }
-  } );
+  }
 
-const stepSpyRef = { current: vi.fn().mockResolvedValue( {} ) };
-const proxyActivitiesMock = vi.fn( () => {
-  stepSpyRef.current = vi.fn().mockResolvedValue( {} );
-  return createStepsProxy( stepSpyRef.current );
+  return { WorkflowValidator };
 } );
 
-const workflowInfoReturn = {
-  workflowId: 'wf-test-123',
+vi.mock( '@temporalio/workflow', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    inWorkflowContext: inWorkflowContextMock,
+    proxyActivities: proxyActivitiesMock,
+    executeChild: executeChildMock,
+    workflowInfo: workflowInfoMock,
+    continueAsNew: continueAsNewMock,
+    uuid4: () => '550e8400e29b41d4a716446655440000'
+  };
+} );
+
+const baseWorkflowInfo = () => ( {
+  workflowId: 'workflow-123',
   workflowType: 'test_wf',
-  runId: 'run-test-123',
+  runId: 'run-123',
+  startTime: new Date( '2025-01-01T00:00:00.000Z' ),
   memo: {},
-  startTime: new Date( '2025-01-01T00:00:00Z' ),
   continueAsNewSuggested: false
+} );
+
+const setWorkflowInfo = overrides => {
+  const info = {
+    ...baseWorkflowInfo(),
+    ...overrides,
+    memo: overrides?.memo ?? {}
+  };
+  workflowInfoMock.mockImplementation( () => info );
+  return info;
 };
-const workflowInfoMock = vi.fn( () => ( { ...workflowInfoReturn } ) );
-
-vi.mock( '@temporalio/workflow', () => ( {
-  proxyActivities: ( ...args ) => proxyActivitiesMock( ...args ),
-  inWorkflowContext: inWorkflowContextMock,
-  executeChild: ( ...args ) => executeChildMock( ...args ),
-  workflowInfo: workflowInfoMock,
-  uuid4: () => '550e8400e29b41d4a716446655440000',
-  ParentClosePolicy: { TERMINATE: 'TERMINATE', ABANDON: 'ABANDON' },
-  ChildWorkflowFailure: class ChildWorkflowFailure extends Error {
-    constructor( message, cause ) {
-      super( message );
-      this.name = 'ChildWorkflowFailure';
-      this.cause = cause;
-    }
-  },
-  continueAsNew: continueAsNewMock,
-  defineSignal: ( ...args ) => defineSignalMock( ...args ),
-  setHandler: ( ...args ) => setHandlerMock( ...args )
-} ) );
 
-vi.mock( '#internal_utils/workflow_context', () => ( {
-  WorkflowContext: { build: workflowContextBuildMock }
-} ) );
+const activityOutput = output => ( {
+  output,
+  [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
+} );
 
-vi.mock( '#internal_utils/trace_info', () => ( {
-  TraceInfo: { build: traceInfoBuildMock }
-} ) );
+const createActivities = handlers => new Proxy( {}, {
+  get: ( _, prop ) => typeof prop === 'string' ?
+    handlers[prop] ?? vi.fn().mockResolvedValue( activityOutput( undefined ) ) :
+    undefined
+} );
 
-vi.mock( '#consts', async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    SHARED_STEP_PREFIX: '__shared',
-    ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations'
-  };
+const mockActivities = handlers => {
+  const activities = createActivities( handlers );
+  proxyActivitiesMock.mockReturnValue( activities );
+  return activities;
+};
+
+const workflowDefinition = overrides => ( {
+  name: 'test_wf',
+  description: 'Test workflow',
+  inputSchema: z.object( {} ),
+  outputSchema: z.object( {} ),
+  fn: async () => ( {} ),
+  ...overrides
 } );
 
+const invokeWorkflowFromHelper = ( wf, input, options ) => wf( input, options );
+
 describe( 'workflow()', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     inWorkflowContextMock.mockReturnValue( true );
-    defineSignalMock.mockImplementation( name => name );
-    workflowInfoReturn.memo = {};
-    delete workflowInfoReturn.root;
-    workflowInfoMock.mockReturnValue( { ...workflowInfoReturn } );
-    workflowContextBuildMock.mockReturnValue( {
-      control: {},
-      info: { workflowId: 'test-workflow', runId: 'test-run' }
+    executeChildMock.mockResolvedValue( { output: {} } );
+    setWorkflowInfo();
+    mockActivities( {
+      [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/trace' } ) )
+    } );
+  } );
+
+  it( 'validates workflow definition at creation time', async () => {
+    const { workflow } = await import( './workflow.js' );
+    const inputSchema = z.object( {} );
+    const outputSchema = z.object( {} );
+    const fn = async () => ( {} );
+    const options = { activityOptions: { retry: { maximumAttempts: 1 } } };
+
+    workflow( {
+      name: 'definition_wf',
+      description: 'Definition workflow',
+      inputSchema,
+      outputSchema,
+      fn,
+      options,
+      aliases: [ 'old_definition_wf' ]
+    } );
+
+    expect( validateDefinitionMock ).toHaveBeenCalledWith( {
+      name: 'definition_wf',
+      description: 'Definition workflow',
+      inputSchema,
+      outputSchema,
+      fn,
+      options,
+      aliases: [ 'old_definition_wf' ]
+    } );
+    expect( validatorConstructorMock ).toHaveBeenCalledWith( {
+      name: 'definition_wf',
+      inputSchema,
+      outputSchema
+    } );
+  } );
+
+  it( 'propagates definition validation errors', async () => {
+    const { workflow } = await import( './workflow.js' );
+    const error = new ValidationError( 'invalid definition' );
+    validateDefinitionMock.mockImplementationOnce( () => {
+      throw error;
     } );
-    traceInfoBuildMock.mockImplementation( ( { disableTrace } ) => ( {
-      workflowId: 'trace-workflow-id',
-      workflowType: 'trace-workflow-type',
-      runId: 'trace-run-id',
-      startTime: 12345,
-      disableTrace
+
+    expect( () => workflow( workflowDefinition( { name: 'invalid_name' } ) ) ).toThrow( error );
+  } );
+
+  it( 'attaches workflow metadata to the wrapper', async () => {
+    const { workflow } = await import( './workflow.js' );
+    const inputSchema = z.object( { value: z.string() } );
+    const outputSchema = z.object( { ok: z.boolean() } );
+
+    const wf = workflow( workflowDefinition( {
+      name: 'metadata_wf',
+      description: 'Metadata workflow',
+      inputSchema,
+      outputSchema,
+      aliases: [ 'metadata_alias' ],
+      fn: async () => ( { ok: true } )
     } ) );
-    proxyActivitiesMock.mockImplementation( () => {
-      stepSpyRef.current = vi.fn().mockResolvedValue( {} );
-      return createStepsProxy( stepSpyRef.current );
+
+    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wf );
+    expect( wf[metadataSymbol] ).toEqual( {
+      name: 'metadata_wf',
+      description: 'Metadata workflow',
+      inputSchema,
+      outputSchema,
+      aliases: [ 'metadata_alias' ]
     } );
   } );
 
-  describe( 'options and defaults', () => {
-    it( 'does not throw when options is omitted (disableTrace defaults to false)', async () => {
+  describe( 'outside Temporal workflow context', () => {
+    beforeEach( () => {
+      inWorkflowContextMock.mockReturnValue( false );
+    } );
+
+    it( 'runs as a plain function with real test WorkflowContext and merged extra context', async () => {
       const { workflow } = await import( './workflow.js' );
 
-      const wf = workflow( {
-        name: 'no_options_wf',
-        description: 'Workflow without options',
-        inputSchema: z.object( { value: z.string() } ),
-        outputSchema: z.object( { value: z.string() } ),
-        fn: async ( { value } ) => ( { value } )
-      } );
+      const wf = workflow( workflowDefinition( {
+        name: 'plain_wf',
+        inputSchema: z.object( { suffix: z.string() } ),
+        outputSchema: z.object( { value: z.string(), extra: z.string() } ),
+        fn: async ( input, context ) => ( {
+          value: `${context.info.workflowId}${input.suffix}`,
+          extra: context.extra
+        } )
+      } ) );
 
-      const result = await wf( { value: 'hello' } );
-      expect( result.output ).toEqual( { value: 'hello' } );
+      await expect( wf( { suffix: '-ok' }, { context: { extra: 'custom' } } ) ).resolves.toEqual( {
+        value: 'test-workflow-ok',
+        extra: 'custom'
+      } );
+      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( { context: { extra: 'custom' } } );
+      expect( validateInputMock ).toHaveBeenCalledWith( { suffix: '-ok' } );
+      expect( validateOutputMock ).toHaveBeenCalledWith( { value: 'test-workflow-ok', extra: 'custom' } );
+      expect( workflowInfoMock ).not.toHaveBeenCalled();
+      expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'respects disableTrace: true when options is provided', async () => {
+    it( 'does not run fn when plain function input validation fails', async () => {
       const { workflow } = await import( './workflow.js' );
+      const error = new ValidationError( 'invalid input' );
+      validateInputMock.mockImplementationOnce( () => {
+        throw error;
+      } );
+      const fn = vi.fn();
 
-      const wf = workflow( {
-        name: 'trace_disabled_wf',
-        description: 'Workflow with tracing disabled',
+      const wf = workflow( workflowDefinition( {
+        name: 'plain_validation_wf',
         inputSchema: z.object( { value: z.string() } ),
-        outputSchema: z.object( { value: z.string() } ),
-        options: { disableTrace: true },
-        fn: async ( { value } ) => ( { value } )
-      } );
+        outputSchema: z.object( { result: z.string() } ),
+        fn
+      } ) );
 
-      const result = await wf( { value: 'hello' } );
-      expect( result.output ).toEqual( { value: 'hello' } );
+      await expect( wf( { value: 1 } ) ).rejects.toBe( error );
+      expect( fn ).not.toHaveBeenCalled();
+      expect( validateOutputMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'merges custom activityOptions with defaults via deepMerge', async () => {
+    it( 'propagates plain function output validation errors after fn runs', async () => {
       const { workflow } = await import( './workflow.js' );
-
-      workflow( {
-        name: 'custom_activity_wf',
-        description: 'Workflow with custom activity options',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        options: {
-          activityOptions: {
-            startToCloseTimeout: '5m',
-            retry: { maximumAttempts: 5 }
-          }
-        },
-        fn: async () => ( {} )
+      const error = new ValidationError( 'invalid output' );
+      validateOutputMock.mockImplementationOnce( () => {
+        throw error;
       } );
+      const output = { result: 1 };
+      const fn = vi.fn().mockResolvedValue( output );
 
-      expect( proxyActivitiesMock ).toHaveBeenCalledWith(
-        expect.objectContaining( {
-          startToCloseTimeout: '5m',
-          retry: expect.objectContaining( { maximumAttempts: 5 } )
-        } )
-      );
+      const wf = workflow( workflowDefinition( {
+        name: 'plain_output_validation_wf',
+        inputSchema: z.object( { value: z.string() } ),
+        outputSchema: z.object( { result: z.string() } ),
+        fn
+      } ) );
+
+      await expect( wf( { value: 'ok' } ) ).rejects.toBe( error );
+      expect( fn ).toHaveBeenCalledWith( { value: 'ok' }, expect.objectContaining( {
+        info: { workflowId: 'test-workflow', runId: 'test-run' }
+      } ) );
+      expect( validateOutputMock ).toHaveBeenCalledWith( output );
     } );
   } );
 
-  describe( 'wrapper metadata', () => {
-    it( 'attaches name, description, inputSchema, outputSchema to wrapper via setMetadata', async () => {
+  describe( 'child workflow trigger path', () => {
+    it( 'starts a child workflow when memo.stack already contains the current workflowId', async () => {
       const { workflow } = await import( './workflow.js' );
-      const inputSchema = z.object( { x: z.number() } );
-      const outputSchema = z.object( { y: z.number() } );
-
-      const wf = workflow( {
-        name: 'meta_wf',
-        description: 'Meta workflow',
-        inputSchema,
-        outputSchema,
-        fn: async input => ( { y: input.x } )
+      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      const memo = {
+        stack: [ 'root-workflow', 'workflow-123' ],
+        traceInfo: { workflowId: 'root-workflow' },
+        activityOptions: {
+          startToCloseTimeout: '10m',
+          retry: { maximumAttempts: 2 }
+        }
+      };
+      setWorkflowInfo( { memo } );
+      executeChildMock.mockResolvedValueOnce( { output: { child: 'ok' } } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'child_target_wf',
+        inputSchema: z.object( { id: z.number() } ),
+        outputSchema: z.object( { child: z.string() } ),
+        fn: vi.fn()
+      } ) );
+
+      await expect( wf( { id: 1 }, {
+        detached: true,
+        activityOptions: {
+          startToCloseTimeout: '2m',
+          retry: { maximumAttempts: 7 }
+        }
+      } ) ).resolves.toEqual( { child: 'ok' } );
+      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( {
+        detached: true,
+        activityOptions: {
+          startToCloseTimeout: '2m',
+          retry: { maximumAttempts: 7 }
+        }
       } );
 
-      const symbols = Object.getOwnPropertySymbols( wf );
-      expect( symbols ).toHaveLength( 1 );
-      const meta = wf[symbols[0]];
-      expect( meta ).toEqual( { name: 'meta_wf', description: 'Meta workflow', inputSchema, outputSchema, aliases: [] } );
+      expect( executeChildMock ).toHaveBeenCalledWith( 'child_target_wf', {
+        args: [ { id: 1 } ],
+        workflowId: expect.stringMatching( /^workflow-123-/ ),
+        parentClosePolicy: ParentClosePolicy.ABANDON,
+        memo: {
+          stack: [ 'root-workflow', 'workflow-123' ],
+          traceInfo: { workflowId: 'root-workflow' },
+          activityOptions: {
+            startToCloseTimeout: '2m',
+            retry: { maximumAttempts: 7 }
+          }
+        }
+      } );
+      expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
-  } );
 
-  describe( 'when not in workflow context (unit-test path)', () => {
-    it( 'validates input, runs fn with test context, validates output, returns plain output', async () => {
-      inWorkflowContextMock.mockReturnValue( false );
+    it( 'uses empty args and terminate policy by default for child workflow execution', async () => {
       const { workflow } = await import( './workflow.js' );
+      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      setWorkflowInfo( { memo: { stack: [ 'workflow-123' ], activityOptions: { heartbeatTimeout: '1m' } } } );
+      executeChildMock.mockResolvedValueOnce( { output: 'done' } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'no_input_child_wf',
+        inputSchema: undefined,
+        outputSchema: z.string(),
+        fn: vi.fn()
+      } ) );
 
-      const wf = workflow( {
-        name: 'unit_path_wf',
-        description: 'Unit path',
-        inputSchema: z.object( { a: z.string() } ),
-        outputSchema: z.object( { b: z.string() } ),
-        fn: async ( input, context ) => ( {
-          b: String( context.info.workflowId ) + input.a
+      await expect( wf() ).resolves.toBe( 'done' );
+      expect( executeChildMock ).toHaveBeenCalledWith( 'no_input_child_wf', expect.objectContaining( {
+        args: [],
+        parentClosePolicy: ParentClosePolicy.TERMINATE,
+        memo: { stack: [ 'workflow-123' ], activityOptions: { heartbeatTimeout: '1m' } }
+      } ) );
+    } );
+
+    it( 'starts a child workflow when the call is made through a helper outside the handler', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( null ) );
+      const info = setWorkflowInfo( { workflowType: 'indirect_parent_wf', memo: {} } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: getTraceDestinations } );
+      executeChildMock.mockResolvedValueOnce( { output: { child: 'ok' } } );
+      const childFn = vi.fn();
+
+      const childWorkflow = workflow( workflowDefinition( {
+        name: 'indirect_child_wf',
+        inputSchema: z.object( { id: z.number() } ),
+        outputSchema: z.object( { child: z.string() } ),
+        fn: childFn
+      } ) );
+      const parentWorkflow = workflow( workflowDefinition( {
+        name: 'indirect_parent_wf',
+        outputSchema: z.object( { child: z.string() } ),
+        fn: async () => invokeWorkflowFromHelper( childWorkflow, { id: 1 }, {
+          activityOptions: {
+            retry: { maximumAttempts: 1 }
+          }
         } )
-      } );
+      } ) );
 
-      const result = await wf( { a: '-ok' } );
-      expect( result ).toEqual( { b: 'test-workflow-ok' } );
-      expect( workflowInfoMock ).not.toHaveBeenCalled();
-      expect( traceDestinationsStepMock ).not.toHaveBeenCalled();
+      await expect( parentWorkflow( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { child: 'ok' }
+      } );
+      expect( childFn ).not.toHaveBeenCalled();
+      expect( executeChildMock ).toHaveBeenCalledWith( 'indirect_child_wf', expect.objectContaining( {
+        args: [ { id: 1 } ],
+        parentClosePolicy: ParentClosePolicy.TERMINATE,
+        memo: expect.objectContaining( {
+          stack: [ 'workflow-123' ],
+          traceInfo: info.memo.traceInfo,
+          activityOptions: expect.objectContaining( {
+            retry: expect.objectContaining( { maximumAttempts: 1 } )
+          } )
+        } )
+      } ) );
+      expect( getTraceDestinations ).toHaveBeenCalledWith( info.memo.traceInfo );
     } );
 
-    it( 'merges extra.context into context when provided', async () => {
-      inWorkflowContextMock.mockReturnValue( false );
+    it( 'falls back to workflow type matching when replaying an old child call without memo.stack', async () => {
       const { workflow } = await import( './workflow.js' );
+      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      setWorkflowInfo( { workflowType: 'old_parent_wf', memo: { traceInfo: { workflowId: 'root-workflow' } } } );
+      executeChildMock.mockResolvedValueOnce( { output: { child: 'replayed' } } );
+      const fn = vi.fn();
 
-      const wf = workflow( {
-        name: 'extra_ctx_wf',
-        description: 'Extra context',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( { id: z.string() } ),
-        fn: async ( _, context ) => ( { id: context.extraId ?? 'default' } )
-      } );
+      const wf = workflow( workflowDefinition( {
+        name: 'old_child_wf',
+        inputSchema: z.object( { id: z.number() } ),
+        outputSchema: z.object( { child: z.string() } ),
+        fn
+      } ) );
 
-      const result = await wf( {}, { context: { extraId: 'injected' } } );
-      expect( result ).toEqual( { id: 'injected' } );
+      await expect( wf( { id: 7 } ) ).resolves.toEqual( { child: 'replayed' } );
+      expect( fn ).not.toHaveBeenCalled();
+      expect( executeChildMock ).toHaveBeenCalledWith( 'old_child_wf', expect.objectContaining( {
+        args: [ { id: 7 } ],
+        parentClosePolicy: ParentClosePolicy.TERMINATE,
+        memo: { traceInfo: { workflowId: 'root-workflow' } }
+      } ) );
+      expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
-  } );
 
-  describe( 'input and output validation', () => {
-    it( 'throws ValidationError when input does not match inputSchema', async () => {
+    it( 'does not fallback to child execution when the replayed workflow type matches an alias', async () => {
       const { workflow } = await import( './workflow.js' );
-      const { ValidationError } = await import( '#errors' );
-
-      const wf = workflow( {
-        name: 'validate_in_wf',
-        description: 'Input validation',
-        inputSchema: z.object( { required: z.string() } ),
-        outputSchema: z.object( {} ),
-        fn: async () => ( {} )
-      } );
+      setWorkflowInfo( { workflowType: 'old_root_wf', memo: {} } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'renamed_root_wf',
+        aliases: [ 'old_root_wf' ],
+        outputSchema: z.object( { ok: z.boolean() } ),
+        fn: async () => ( { ok: true } )
+      } ) );
 
-      await expect( wf( { wrong: 1 } ) ).rejects.toThrow( ValidationError );
-      await expect( wf( { wrong: 1 } ) ).rejects.toThrow( /Workflow validate_in_wf input/ );
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { ok: true },
+        trace: { destinations: { local: '/tmp/trace' } }
+      } );
+      expect( executeChildMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'throws ValidationError when output does not match outputSchema', async () => {
+    it( 'propagates executeChild errors without root ApplicationFailure wrapping', async () => {
       const { workflow } = await import( './workflow.js' );
-      const { ValidationError } = await import( '#errors' );
-
-      const wf = workflow( {
-        name: 'validate_out_wf',
-        description: 'Output validation',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( { required: z.string() } ),
-        fn: async () => ( { other: 1 } )
-      } );
+      const error = new Error( 'child failed' );
+      setWorkflowInfo( { memo: { stack: [ 'workflow-123' ] } } );
+      executeChildMock.mockRejectedValueOnce( error );
+
+      const wf = workflow( workflowDefinition( { name: 'failing_child_wf' } ) );
 
-      await expect( wf( {} ) ).rejects.toThrow( ValidationError );
-      await expect( wf( {} ) ).rejects.toThrow( /Workflow validate_out_wf output/ );
+      await expect( wf( {} ) ).rejects.toBe( error );
     } );
   } );
 
-  describe( 'root workflow (in workflow context)', () => {
-    it( 'unwraps wrapped trace destinations and assigns traceInfo to memo', async () => {
-      traceDestinationsStepMock.mockResolvedValueOnce( {
-        output: { local: '/tmp/wrapped-trace' },
-        aggregations: null,
-        [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-      } );
+  describe( 'workflow execution path', () => {
+    it( 'initializes root memo, gets trace destinations, validates output, and returns an envelope', async () => {
       const { workflow } = await import( './workflow.js' );
+      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/root-trace' } ) );
+      const info = setWorkflowInfo( { workflowType: 'root_wf', memo: {} } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: getTraceDestinations } );
 
-      const wf = workflow( {
-        name: 'wrapped_trace_wf',
-        description: 'Wrapped trace',
-        inputSchema: z.object( {} ),
+      const wf = workflow( workflowDefinition( {
+        name: 'root_wf',
         outputSchema: z.object( { ok: z.boolean() } ),
-        fn: async () => ( { ok: true } )
-      } );
+        options: {
+          disableTrace: true,
+          activityOptions: {
+            startToCloseTimeout: '5m',
+            retry: { maximumAttempts: 5 }
+          }
+        },
+        fn: async ( _, context ) => ( { ok: context.info.workflowId === 'workflow-123' } )
+      } ) );
 
-      const result = await wf( {} );
-      expect( traceDestinationsStepMock ).toHaveBeenCalledTimes( 1 );
-      expect( result ).toEqual( {
+      await expect( wf( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
         output: { ok: true },
-        trace: { destinations: { local: '/tmp/wrapped-trace' } },
-        aggregations: null
-      } );
-      const memo = workflowInfoMock().memo;
-      expect( memo.traceInfo ).toEqual( {
-        workflowId: 'trace-workflow-id',
-        workflowType: 'trace-workflow-type',
-        runId: 'trace-run-id',
-        startTime: 12345,
-        disableTrace: false
+        trace: { destinations: { local: '/tmp/root-trace' } }
+      } );
+      expect( info.memo.stack ).toEqual( [ 'workflow-123' ] );
+      expect( info.memo.traceInfo ).toEqual( {
+        workflowId: 'workflow-123',
+        workflowType: 'root_wf',
+        runId: 'run-123',
+        startTime: new Date( '2025-01-01T00:00:00.000Z' ).getTime(),
+        disableTrace: true
       } );
-      expect( traceInfoBuildMock ).toHaveBeenCalledWith( { disableTrace: false } );
-      expect( traceDestinationsStepMock ).toHaveBeenCalledWith( memo.traceInfo );
+      expect( info.memo.activityOptions ).toEqual( expect.objectContaining( {
+        startToCloseTimeout: '5m',
+        heartbeatTimeout: '5m',
+        retry: expect.objectContaining( { maximumAttempts: 5 } )
+      } ) );
+      expect( proxyActivitiesMock ).toHaveBeenCalledWith( info.memo.activityOptions );
+      expect( getTraceDestinations ).toHaveBeenCalledWith( info.memo.traceInfo );
     } );
 
-    it( 'collects batched aggregation signals from failed activities', async () => {
+    it( 'runs non-root workflow execution without rebuilding trace info or fetching trace destinations', async () => {
       const { workflow } = await import( './workflow.js' );
-      const handlers = { sendAggregations: () => {} };
-      setHandlerMock.mockImplementation( ( signalName, handler ) => {
-        if ( signalName === Signal.SEND_AGGREGATIONS ) {
-          handlers.sendAggregations = handler;
+      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/trace' } ) );
+      const memo = {
+        stack: [ 'root-workflow' ],
+        traceInfo: { workflowId: 'root-workflow' },
+        activityOptions: {
+          startToCloseTimeout: '9m',
+          retry: { maximumAttempts: 8 }
         }
+      };
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: getTraceDestinations } );
+      const info = setWorkflowInfo( {
+        workflowId: 'child-workflow',
+        root: { workflowId: 'root-workflow', runId: 'root-run' },
+        memo
       } );
 
-      const wf = workflow( {
-        name: 'batched_attr_wf',
-        description: 'Batched aggregations',
-        inputSchema: z.object( {} ),
+      const wf = workflow( workflowDefinition( {
+        name: 'nested_wf',
+        options: {
+          activityOptions: {
+            startToCloseTimeout: '1m',
+            retry: { maximumAttempts: 2 }
+          }
+        },
         outputSchema: z.object( { ok: z.boolean() } ),
-        fn: async () => {
-          handlers.sendAggregations( { cost: { total: 3 }, tokens: { total: 0 }, httpRequests: { total: 1 } } );
-          return { ok: true };
-        }
-      } );
+        fn: async () => ( { ok: true } )
+      } ) );
 
-      const result = await wf( {} );
-      expect( result.cost ).toBeUndefined();
-      expect( result ).not.toHaveProperty( 'attributes' );
-      expect( result.aggregations.cost ).toEqual( { total: 3 } );
-      expect( result.aggregations.httpRequests ).toEqual( { total: 1 } );
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { ok: true }
+      } );
+      expect( info.memo.stack ).toEqual( [ 'root-workflow', 'child-workflow' ] );
+      expect( info.memo.traceInfo ).toBe( memo.traceInfo );
+      expect( info.memo.activityOptions ).toEqual( expect.objectContaining( {
+        startToCloseTimeout: '9m',
+        retry: expect.objectContaining( { maximumAttempts: 8 } )
+      } ) );
+      expect( proxyActivitiesMock ).toHaveBeenCalledWith( info.memo.activityOptions );
+      expect( getTraceDestinations ).not.toHaveBeenCalled();
     } );
 
-    it( 'sets traceInfo.disableTrace when options.disableTrace is true', async () => {
+    it( 'omits trace from the root result when getTraceDestinations returns no destinations', async () => {
       const { workflow } = await import( './workflow.js' );
+      setWorkflowInfo( { workflowType: 'no_trace_dest_wf' } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ) } );
 
-      const wf = workflow( {
-        name: 'root_no_trace_wf',
-        description: 'Root no trace',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        options: { disableTrace: true },
-        fn: async () => ( {} )
-      } );
-
-      await wf( {} );
-      expect( workflowInfoMock().memo.traceInfo ).toEqual( expect.objectContaining( {
-        workflowId: 'trace-workflow-id',
-        workflowType: 'trace-workflow-type',
-        runId: 'trace-run-id',
-        disableTrace: true
+      const wf = workflow( workflowDefinition( {
+        name: 'no_trace_dest_wf',
+        outputSchema: z.object( { ok: z.boolean() } ),
+        fn: async () => ( { ok: true } )
       } ) );
-      expect( traceInfoBuildMock ).toHaveBeenCalledWith( { disableTrace: true } );
-    } );
-  } );
 
-  describe( 'child workflow (memo.traceInfo already set)', () => {
-    it( 'does not call getTraceDestinations and returns an internal output envelope', async () => {
-      const traceInfo = { workflowId: 'parent-1', workflowType: 'parent_wf', runId: 'parent-run' };
-      workflowInfoMock.mockReturnValue( {
-        ...workflowInfoReturn,
-        root: { workflowId: 'root-wf', runId: 'root-run' },
-        memo: { traceInfo }
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { ok: true }
       } );
-      const { workflow } = await import( './workflow.js' );
+    } );
 
-      const wf = workflow( {
-        name: 'child_wf',
-        description: 'Child',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( { x: z.string() } ),
-        fn: async () => ( { x: 'child' } )
+    it( 'supports old unwrapped trace destination activity results during replay', async () => {
+      const { workflow } = await import( './workflow.js' );
+      setWorkflowInfo( { workflowType: 'old_trace_payload_wf' } );
+      mockActivities( {
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( { local: '/tmp/old-trace' } )
       } );
 
-      const result = await wf( {} );
-      expect( traceDestinationsStepMock ).not.toHaveBeenCalled();
-      expect( workflowInfoMock().memo.traceInfo ).toBe( traceInfo );
-      expect( result ).toEqual( {
+      const wf = workflow( workflowDefinition( {
+        name: 'old_trace_payload_wf',
+        outputSchema: z.object( { ok: z.boolean() } ),
+        fn: async () => ( { ok: true } )
+      } ) );
+
+      await expect( wf( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { x: 'child' },
-        aggregations: null
+        output: { ok: true },
+        trace: { destinations: { local: '/tmp/old-trace' } }
       } );
     } );
-  } );
-
-  describe( 'bound this: invokeStep, invokeSharedStep, invokeEvaluator', () => {
-    it( 'invokeStep unwraps step output and merges step aggregations', async () => {
-      const stepSpy = vi.fn().mockResolvedValue( {
-        output: { value: 'wrapped' },
-        aggregations: { cost: { total: 0 }, tokens: { total: 0 }, httpRequests: { total: 1 } },
-        [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-      } );
-      proxyActivitiesMock.mockImplementation( () => createStepsProxy( stepSpy ) );
 
+    it( 'supports old null trace destination activity results during replay', async () => {
       const { workflow } = await import( './workflow.js' );
+      setWorkflowInfo( { workflowType: 'old_null_trace_payload_wf' } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( null ) } );
 
-      const wf = workflow( {
-        name: 'unwrap_step_wf',
-        description: 'Unwrap step',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( { value: z.string() } ),
-        async fn() {
-          return this.invokeStep( 'myStep', { foo: 1 } );
-        }
-      } );
+      const wf = workflow( workflowDefinition( {
+        name: 'old_null_trace_payload_wf',
+        outputSchema: z.object( { ok: z.boolean() } ),
+        fn: async () => ( { ok: true } )
+      } ) );
 
-      const result = await wf( {} );
-      expect( result.output ).toEqual( { value: 'wrapped' } );
-      expect( result ).not.toHaveProperty( 'attributes' );
-      expect( result.aggregations.httpRequests ).toEqual( { total: 1 } );
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { ok: true }
+      } );
     } );
 
-    it( 'invokeSharedStep calls steps with SHARED_STEP_PREFIX#stepName', async () => {
+    it( 'validates input and output inside workflow context', async () => {
       const { workflow } = await import( './workflow.js' );
-      const sharedSpy = vi.fn().mockResolvedValue( {} );
-      proxyActivitiesMock.mockImplementation( () => new Proxy( {}, {
-        get: ( _, prop ) => {
-          if ( prop === '__internal#getTraceDestinations' ) {
-            return traceDestinationsStepMock;
-          }
-          if ( prop === '__shared#sharedStep' ) {
-            return sharedSpy;
-          }
-          return vi.fn();
-        }
+      const inputError = new ValidationError( 'invalid workflow input' );
+      const outputError = new ValidationError( 'invalid workflow output' );
+      setWorkflowInfo( { workflowType: 'runtime_validation_wf' } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'runtime_validation_wf',
+        inputSchema: z.object( { value: z.string() } ),
+        outputSchema: z.object( { result: z.string() } ),
+        fn: async () => ( { result: 1 } )
       } ) );
 
-      const wf = workflow( {
-        name: 'shared_wf',
-        description: 'Shared',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        async fn() {
-          await this.invokeSharedStep( 'sharedStep', { data: 2 } );
-          return {};
-        }
+      validateInputMock.mockImplementationOnce( () => {
+        throw inputError;
       } );
+      await expect( wf( { value: 1 } ) ).rejects.toBe( inputError );
+      expect( inputError[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
 
-      await wf( {} );
-      expect( sharedSpy ).toHaveBeenCalledWith( { data: 2 }, undefined );
+      setWorkflowInfo( { workflowType: 'runtime_validation_wf', memo: {} } );
+      validateOutputMock.mockImplementationOnce( () => {
+        throw outputError;
+      } );
+      await expect( wf( { value: 'ok' } ) ).rejects.toBe( outputError );
+      expect( outputError[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
     } );
+  } );
 
-    it( 'invokeEvaluator calls steps with workflowName#evaluatorName', async () => {
-      const evalSpy = vi.fn().mockResolvedValue( true );
-      proxyActivitiesMock.mockImplementation( () => new Proxy( {}, {
-        get: ( _, prop ) => {
-          if ( prop === '__internal#getTraceDestinations' ) {
-            return traceDestinationsStepMock;
-          }
-          if ( prop === 'eval_wf#myEvaluator' ) {
-            return evalSpy;
-          }
-          return vi.fn();
+  describe( 'activity dispatchers', () => {
+    it( 'invokes workflow-scoped steps and evaluators and unwraps activity output', async () => {
+      const { workflow } = await import( './workflow.js' );
+      setWorkflowInfo( { workflowType: 'dispatch_wf' } );
+      const step = vi.fn().mockResolvedValue( activityOutput( 'step-output' ) );
+      const evaluator = vi.fn().mockResolvedValue( activityOutput( 'eval-output' ) );
+      mockActivities( {
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
+        'dispatch_wf#stepA': step,
+        'dispatch_wf#evalA': evaluator
+      } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'dispatch_wf',
+        outputSchema: z.object( { stepResult: z.string(), evalResult: z.string() } ),
+        async fn() {
+          return {
+            stepResult: await this.invokeStep( 'stepA', { a: 1 }, { b: 2 } ),
+            evalResult: await this.invokeEvaluator( 'evalA', { c: 3 } )
+          };
         }
       } ) );
 
-      const { workflow } = await import( './workflow.js' );
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { stepResult: 'step-output', evalResult: 'eval-output' }
+      } );
+      expect( step ).toHaveBeenCalledWith( { a: 1 }, { b: 2 } );
+      expect( evaluator ).toHaveBeenCalledWith( { c: 3 } );
+    } );
 
-      const wf = workflow( {
-        name: 'eval_wf',
-        description: 'Eval',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
+    it( 'invokes shared steps and shared evaluators with the shared prefix', async () => {
+      const { workflow } = await import( './workflow.js' );
+      setWorkflowInfo( { workflowType: 'shared_dispatch_wf' } );
+      const sharedStep = vi.fn().mockResolvedValue( activityOutput( 'shared-step-output' ) );
+      const sharedEvaluator = vi.fn().mockResolvedValue( activityOutput( 'shared-eval-output' ) );
+      mockActivities( {
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
+        [`${SHARED_STEP_PREFIX}#stepA`]: sharedStep,
+        [`${SHARED_STEP_PREFIX}#evalA`]: sharedEvaluator
+      } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'shared_dispatch_wf',
+        outputSchema: z.object( { stepResult: z.string(), evalResult: z.string() } ),
         async fn() {
-          await this.invokeEvaluator( 'myEvaluator', { x: 3 } );
-          return {};
+          return {
+            stepResult: await this.invokeSharedStep( 'stepA' ),
+            evalResult: await this.invokeSharedEvaluator( 'evalA', { x: 1 } )
+          };
         }
-      } );
+      } ) );
 
-      await wf( {} );
-      expect( evalSpy ).toHaveBeenCalledWith( { x: 3 }, undefined );
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { stepResult: 'shared-step-output', evalResult: 'shared-eval-output' }
+      } );
+      expect( sharedStep ).toHaveBeenCalledWith();
+      expect( sharedEvaluator ).toHaveBeenCalledWith( { x: 1 } );
     } );
-  } );
 
-  describe( 'startWorkflow', () => {
-    it( 'calls executeChild with correct args and TERMINATE when not detached', async () => {
+    it( 'supports old unwrapped step and evaluator activity results during replay', async () => {
       const { workflow } = await import( './workflow.js' );
-      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
-      executeChildMock.mockResolvedValueOnce( { output: {}, aggregations: null } );
-
-      const wf = workflow( {
-        name: 'parent_wf',
-        description: 'Parent',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
+      setWorkflowInfo( { workflowType: 'old_activity_payload_wf' } );
+      const step = vi.fn().mockResolvedValue( 'legacy-step-output' );
+      const evaluator = vi.fn().mockResolvedValue( 'legacy-eval-output' );
+      mockActivities( {
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
+        'old_activity_payload_wf#stepA': step,
+        'old_activity_payload_wf#evalA': evaluator
+      } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'old_activity_payload_wf',
+        outputSchema: z.object( { stepResult: z.string(), evalResult: z.string() } ),
         async fn() {
-          await this.startWorkflow( 'child_wf', { id: 1 } );
-          return {};
+          return {
+            stepResult: await this.invokeStep( 'stepA' ),
+            evalResult: await this.invokeEvaluator( 'evalA' )
+          };
         }
-      } );
+      } ) );
 
-      await wf( {} );
-      expect( executeChildMock ).toHaveBeenCalledWith( 'child_wf', {
-        args: [ { id: 1 } ],
-        workflowId: expect.stringMatching( /^wf-test-123-/ ),
-        parentClosePolicy: ParentClosePolicy.TERMINATE,
-        memo: expect.objectContaining( {
-          traceInfo: {
-            workflowId: 'trace-workflow-id',
-            workflowType: 'trace-workflow-type',
-            runId: 'trace-run-id',
-            startTime: 12345,
-            disableTrace: false
-          },
-          activityOptions: expect.objectContaining( {
-            startToCloseTimeout: '20m',
-            heartbeatTimeout: '5m'
-          } )
-        } )
+      await expect( wf( {} ) ).resolves.toEqual( {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output: { stepResult: 'legacy-step-output', evalResult: 'legacy-eval-output' }
       } );
-      const [ , childOptions ] = executeChildMock.mock.calls[0];
-      expect( childOptions.memo ).not.toHaveProperty( 'executionContext' );
-      expect( childOptions.memo ).not.toHaveProperty( 'parentId' );
     } );
+  } );
 
-    it( 'uses ABANDON when extra.detached is true', async () => {
+  describe( 'error handling', () => {
+    it( 'attaches root trace destinations to root workflow errors before rethrowing', async () => {
       const { workflow } = await import( './workflow.js' );
-      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
-      executeChildMock.mockResolvedValueOnce( { output: {}, aggregations: null } );
+      const error = new Error( 'root failed' );
+      setWorkflowInfo( { workflowType: 'root_error_wf' } );
 
-      const wf = workflow( {
-        name: 'detach_wf',
-        description: 'Detach',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        async fn() {
-          await this.startWorkflow( 'child_wf', null, { detached: true } );
-          return {};
+      const wf = workflow( workflowDefinition( {
+        name: 'root_error_wf',
+        fn: async () => {
+          throw error;
         }
-      } );
-
-      await wf( {} );
-      expect( executeChildMock ).toHaveBeenCalledWith( 'child_wf', expect.objectContaining( {
-        args: [ null ],
-        parentClosePolicy: ParentClosePolicy.ABANDON
       } ) );
+
+      const thrown = await wf( {} ).catch( e => e );
+      expect( thrown ).toBe( error );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
     } );
 
-    it( 'passes empty args when input is omitted', async () => {
+    it( 'preserves existing error details when attaching root trace metadata', async () => {
       const { workflow } = await import( './workflow.js' );
-      executeChildMock.mockResolvedValueOnce( { output: {}, aggregations: null } );
+      const error = new Error( 'root failed with details' );
+      error.details = [ { domain: { reason: 'bad-input' } } ];
+      setWorkflowInfo( { workflowType: 'root_error_existing_details_wf' } );
 
-      const wf = workflow( {
-        name: 'no_input_wf',
-        description: 'No input',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        async fn() {
-          await this.startWorkflow( 'child_wf' );
-          return {};
+      const wf = workflow( workflowDefinition( {
+        name: 'root_error_existing_details_wf',
+        fn: async () => {
+          throw error;
         }
-      } );
-
-      await wf( {} );
-      expect( executeChildMock ).toHaveBeenCalledWith( 'child_wf', expect.objectContaining( {
-        args: []
       } ) );
+
+      await expect( wf( {} ) ).rejects.toBe( error );
+      expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
     } );
 
-    it( 'merges per-child activity options into the propagated memo', async () => {
+    it( 'rethrows root workflow errors without metadata when trace destinations are unavailable', async () => {
       const { workflow } = await import( './workflow.js' );
-      executeChildMock.mockResolvedValueOnce( { output: {}, aggregations: null } );
+      setWorkflowInfo( { workflowType: 'root_error_no_trace_wf' } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ) } );
+      const error = new Error( 'root failed without trace' );
 
-      const wf = workflow( {
-        name: 'child_options_wf',
-        description: 'Child options',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        async fn() {
-          await this.startWorkflow( 'child_wf', { id: 1 }, {
-            options: {
-              activityOptions: {
-                startToCloseTimeout: '2m',
-                retry: { maximumAttempts: 7 }
-              }
-            }
-          } );
-          return {};
+      const wf = workflow( workflowDefinition( {
+        name: 'root_error_no_trace_wf',
+        fn: async () => {
+          throw error;
         }
-      } );
-
-      await wf( {} );
-      expect( executeChildMock ).toHaveBeenCalledWith( 'child_wf', expect.objectContaining( {
-        memo: expect.objectContaining( {
-          traceInfo: expect.objectContaining( {
-            workflowId: 'trace-workflow-id',
-            runId: 'trace-run-id'
-          } ),
-          activityOptions: expect.objectContaining( {
-            startToCloseTimeout: '2m',
-            heartbeatTimeout: '5m',
-            retry: expect.objectContaining( {
-              initialInterval: '10s',
-              maximumAttempts: 7
-            } )
-          } )
-        } )
       } ) );
+
+      await expect( wf( {} ) ).rejects.toBe( error );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
     } );
 
-    it( 'returns child output and merges child workflow aggregations into the root aggregations', async () => {
+    it( 'preserves existing error details when trace destinations are unavailable', async () => {
       const { workflow } = await import( './workflow.js' );
-      executeChildMock.mockResolvedValueOnce( {
-        output: { child: 'ok' },
-        aggregations: {
-          cost: { total: 1.5 },
-          tokens: { total: 4, input: 4 },
-          httpRequests: { total: 2 }
-        }
-      } );
+      setWorkflowInfo( { workflowType: 'root_error_existing_details_no_trace_wf' } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ) } );
+      const error = new Error( 'root failed without trace' );
+      error.details = [ { domain: { reason: 'bad-input' } } ];
 
-      const wf = workflow( {
-        name: 'merge_child_aggregations_wf',
-        description: 'Merge child aggregations',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( { child: z.string() } ),
-        async fn() {
-          return this.startWorkflow( 'child_wf', { id: 1 } );
+      const wf = workflow( workflowDefinition( {
+        name: 'root_error_existing_details_no_trace_wf',
+        fn: async () => {
+          throw error;
         }
-      } );
+      } ) );
 
-      const result = await wf( {} );
-      expect( result ).toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { child: 'ok' },
-        trace: { destinations: { local: '/tmp/trace' } },
-        aggregations: {
-          cost: { total: 1.5 },
-          tokens: { total: 4, input: 4 },
-          httpRequests: { total: 2 }
-        }
-      } );
+      await expect( wf( {} ) ).rejects.toBe( error );
+      expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
     } );
 
-    it( 'merges child error aggregations before rethrowing to root metadata', async () => {
+    it( 'attaches trace metadata to existing root ApplicationFailure without wrapping it', async () => {
       const { workflow } = await import( './workflow.js' );
-      const { ChildWorkflowFailure } = await import( '@temporalio/workflow' );
-      const { METADATA_ACCESS_SYMBOL } = await import( '#consts' );
-      const childError = new ChildWorkflowFailure( 'child failed', {
-        message: 'Child workflow execution failed',
-        details: [ {
-          aggregations: {
-            cost: { total: 3 },
-            tokens: { total: 8, output: 8 },
-            httpRequests: { total: 0 }
-          }
-        } ]
+      const { ApplicationFailure } = await import( '@temporalio/workflow' );
+      setWorkflowInfo( { workflowType: 'root_application_failure_wf' } );
+      const error = ApplicationFailure.create( {
+        message: 'root application failed',
+        type: 'OriginalType',
+        nonRetryable: true,
+        details: [ { domain: { reason: 'bad-input' } } ]
       } );
-      executeChildMock.mockRejectedValueOnce( childError );
 
-      const wf = workflow( {
-        name: 'child_error_aggregations_wf',
-        description: 'Child error aggregations',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
-        async fn() {
-          await this.startWorkflow( 'child_wf', { id: 1 } );
-          return {};
+      const wf = workflow( workflowDefinition( {
+        name: 'root_application_failure_wf',
+        fn: async () => {
+          throw error;
         }
-      } );
+      } ) );
 
-      await expect( wf( {} ) ).rejects.toThrow( 'child failed' );
-      expect( childError[METADATA_ACCESS_SYMBOL] ).toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        trace: { destinations: { local: '/tmp/trace' } },
-        aggregations: {
-          cost: { total: 3 },
-          tokens: { total: 8, output: 8 },
-          httpRequests: { total: 0 }
-        }
-      } );
+      const thrown = await wf( {} ).catch( e => e );
+
+      expect( thrown ).toBe( error );
+      expect( error.type ).toBe( 'OriginalType' );
+      expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
     } );
-  } );
 
-  describe( 'error handling (root workflow)', () => {
-    it( 'rethrows error from fn with trace and aggregation metadata', async () => {
+    it( 'rethrows non-root workflow errors without ApplicationFailure wrapping', async () => {
       const { workflow } = await import( './workflow.js' );
-      const { METADATA_ACCESS_SYMBOL } = await import( '#consts' );
-      const error = new Error( 'workflow failed' );
-
-      const wf = workflow( {
-        name: 'err_wf',
-        description: 'Error',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {} ),
+      const error = new Error( 'nested failed' );
+      setWorkflowInfo( {
+        workflowId: 'nested-workflow',
+        root: { workflowId: 'root-workflow', runId: 'root-run' },
+        memo: { stack: [ 'root-workflow' ], traceInfo: { workflowId: 'root-workflow' } }
+      } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'nested_error_wf',
         fn: async () => {
           throw error;
         }
-      } );
+      } ) );
 
-      await expect( wf( {} ) ).rejects.toThrow( 'workflow failed' );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        trace: { destinations: { local: '/tmp/trace' } },
-        aggregations: null
-      } );
+      await expect( wf( {} ) ).rejects.toBe( error );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
     } );
   } );
 } );