@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

package/src/interface/workflow.spec.js

@@ -2,10 +2,7 @@ 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
+  INVOKE_ACTIVITY_SYMBOL
 } from '#consts';
 import { ValidationError } from '#errors';
 
@@ -13,11 +10,12 @@ 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 upsertMemoMock = 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 parseInputMock = vi.hoisted( () => vi.fn( input => input ) );
+const parseOutputMock = vi.hoisted( () => vi.fn( output => output ) );
+const parseInvocationOptionsMock = vi.hoisted( () => vi.fn( options => options ) );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
 const createWorkflowMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
@@ -29,9 +27,9 @@ vi.mock( './validations/index.js', () => {
 
     constructor( ...args ) {
       validatorConstructorMock( ...args );
-      this.validateInput = validateInputMock;
-      this.validateOutput = validateOutputMock;
-      this.validateInvocationOptions = validateInvocationOptionsMock;
+      this.parseInput = parseInputMock;
+      this.parseOutput = parseOutputMock;
+      this.parseInvocationOptions = parseInvocationOptionsMock;
     }
   }
 
@@ -50,6 +48,7 @@ vi.mock( '@temporalio/workflow', async importOriginal => {
     proxyActivities: proxyActivitiesMock,
     executeChild: executeChildMock,
     workflowInfo: workflowInfoMock,
+    upsertMemo: upsertMemoMock,
     continueAsNew: continueAsNewMock,
     uuid4: () => '550e8400e29b41d4a716446655440000'
   };
@@ -60,28 +59,24 @@ const baseWorkflowInfo = () => ( {
   workflowType: 'test_wf',
   runId: 'run-123',
   startTime: new Date( '2025-01-01T00:00:00.000Z' ),
-  memo: {},
+  memo: { traceInfo: { workflowId: 'workflow-123' } },
   continueAsNewSuggested: false
 } );
 
 const setWorkflowInfo = overrides => {
+  const base = baseWorkflowInfo();
   const info = {
-    ...baseWorkflowInfo(),
+    ...base,
     ...overrides,
-    memo: overrides?.memo ?? {}
+    memo: overrides?.memo ?? base.memo
   };
   workflowInfoMock.mockImplementation( () => info );
   return info;
 };
 
-const activityOutput = output => ( {
-  output,
-  [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-} );
-
 const createActivities = handlers => new Proxy( {}, {
   get: ( _, prop ) => typeof prop === 'string' ?
-    handlers[prop] ?? vi.fn().mockResolvedValue( activityOutput( undefined ) ) :
+    handlers[prop] ?? vi.fn().mockResolvedValue( undefined ) :
     undefined
 } );
 
@@ -91,6 +86,13 @@ const mockActivities = handlers => {
   return activities;
 };
 
+const installGlobalDispatcher = runId => {
+  const dispatcher = vi.fn();
+  dispatcher.runId = runId;
+  globalThis[INVOKE_ACTIVITY_SYMBOL] = dispatcher;
+  return dispatcher;
+};
+
 const workflowDefinition = overrides => ( {
   name: 'test_wf',
   description: 'Test workflow',
@@ -100,16 +102,15 @@ const workflowDefinition = overrides => ( {
   ...overrides
 } );
 
-const invokeWorkflowFromHelper = ( wf, input, options ) => wf( input, options );
-
 describe( 'workflow()', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    delete globalThis[INVOKE_ACTIVITY_SYMBOL];
     inWorkflowContextMock.mockReturnValue( true );
-    executeChildMock.mockResolvedValue( { output: {} } );
+    executeChildMock.mockResolvedValue( {} );
     setWorkflowInfo();
     mockActivities( {
-      [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/trace' } ) )
+      [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( { local: '/tmp/trace' } )
     } );
   } );
 
@@ -204,9 +205,9 @@ describe( 'workflow()', () => {
         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( parseInvocationOptionsMock ).toHaveBeenCalledWith( { context: { extra: 'custom' } } );
+      expect( parseInputMock ).toHaveBeenCalledWith( { suffix: '-ok' } );
+      expect( parseOutputMock ).toHaveBeenCalledWith( { value: 'test-workflow-ok', extra: 'custom' } );
       expect( workflowInfoMock ).not.toHaveBeenCalled();
       expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
@@ -214,7 +215,7 @@ describe( 'workflow()', () => {
     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( () => {
+      parseInputMock.mockImplementationOnce( () => {
         throw error;
       } );
       const fn = vi.fn();
@@ -228,13 +229,13 @@ describe( 'workflow()', () => {
 
       await expect( wf( { value: 1 } ) ).rejects.toBe( error );
       expect( fn ).not.toHaveBeenCalled();
-      expect( validateOutputMock ).not.toHaveBeenCalled();
+      expect( parseOutputMock ).not.toHaveBeenCalled();
     } );
 
     it( 'propagates plain function output validation errors after fn runs', async () => {
       const { workflow } = await import( './workflow.js' );
       const error = new ValidationError( 'invalid output' );
-      validateOutputMock.mockImplementationOnce( () => {
+      parseOutputMock.mockImplementationOnce( () => {
         throw error;
       } );
       const output = { result: 1 };
@@ -251,24 +252,27 @@ describe( 'workflow()', () => {
       expect( fn ).toHaveBeenCalledWith( { value: 'ok' }, expect.objectContaining( {
         info: { workflowId: 'test-workflow', runId: 'test-run' }
       } ) );
-      expect( validateOutputMock ).toHaveBeenCalledWith( output );
+      expect( parseOutputMock ).toHaveBeenCalledWith( output );
     } );
   } );
 
   describe( 'child workflow trigger path', () => {
-    it( 'starts a child workflow when memo.stack already contains the current workflowId', async () => {
+    it( 'starts a child workflow and forwards child-safe invocation options', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      installGlobalDispatcher( 'run-123' );
       const memo = {
-        stack: [ 'root-workflow', 'workflow-123' ],
         traceInfo: { workflowId: 'root-workflow' },
         activityOptions: {
-          startToCloseTimeout: '10m',
-          retry: { maximumAttempts: 2 }
+          heartbeatTimeout: '30s',
+          retry: {
+            maximumInterval: '20s',
+            maximumAttempts: 4
+          }
         }
       };
       setWorkflowInfo( { memo } );
-      executeChildMock.mockResolvedValueOnce( { output: { child: 'ok' } } );
+      executeChildMock.mockResolvedValueOnce( { child: 'ok' } );
 
       const wf = workflow( workflowDefinition( {
         name: 'child_target_wf',
@@ -279,13 +283,15 @@ describe( 'workflow()', () => {
 
       await expect( wf( { id: 1 }, {
         detached: true,
+        context: { testOnly: true },
         activityOptions: {
           startToCloseTimeout: '2m',
           retry: { maximumAttempts: 7 }
         }
       } ) ).resolves.toEqual( { child: 'ok' } );
-      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( {
+      expect( parseInvocationOptionsMock ).toHaveBeenCalledWith( {
         detached: true,
+        context: { testOnly: true },
         activityOptions: {
           startToCloseTimeout: '2m',
           retry: { maximumAttempts: 7 }
@@ -293,26 +299,29 @@ describe( 'workflow()', () => {
       } );
 
       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' },
+        args: [ {
+          id: 1
+        }, {
           activityOptions: {
             startToCloseTimeout: '2m',
             retry: { maximumAttempts: 7 }
           }
-        }
+        } ],
+        workflowId: expect.stringMatching( /^workflow-123-/ ),
+        parentClosePolicy: ParentClosePolicy.ABANDON,
+        memo
       } );
+      expect( executeChildMock.mock.calls[0][1].args[1] ).not.toHaveProperty( 'detached' );
+      expect( executeChildMock.mock.calls[0][1].args[1] ).not.toHaveProperty( 'context' );
       expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'uses empty args and terminate policy by default for child workflow execution', async () => {
+    it( 'uses undefined input 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' } );
+      installGlobalDispatcher( 'run-123' );
+      setWorkflowInfo( { memo: { traceInfo: { workflowId: 'root-workflow' } } } );
+      executeChildMock.mockResolvedValueOnce( 'done' );
 
       const wf = workflow( workflowDefinition( {
         name: 'no_input_child_wf',
@@ -323,92 +332,59 @@ describe( 'workflow()', () => {
 
       await expect( wf() ).resolves.toBe( 'done' );
       expect( executeChildMock ).toHaveBeenCalledWith( 'no_input_child_wf', expect.objectContaining( {
-        args: [],
+        args: [ undefined, { activityOptions: undefined } ],
         parentClosePolicy: ParentClosePolicy.TERMINATE,
-        memo: { stack: [ 'workflow-123' ], activityOptions: { heartbeatTimeout: '1m' } }
+        memo: { traceInfo: { workflowId: 'root-workflow' } }
       } ) );
     } );
 
-    it( 'starts a child workflow when the call is made through a helper outside the handler', async () => {
+    it( 'propagates executeChild errors without root ApplicationFailure wrapping', 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 error = new Error( 'child failed' );
+      installGlobalDispatcher( 'run-123' );
+      executeChildMock.mockRejectedValueOnce( error );
 
-      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 wf = workflow( workflowDefinition( { name: 'failing_child_wf' } ) );
 
-      await expect( parentWorkflow( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { child: 'ok' },
-        trace: { destinations: {} }
-      } );
-      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 );
+      await expect( wf( {} ) ).rejects.toBe( error );
     } );
+  } );
 
-    it( 'does not fallback to child execution when the replayed workflow type matches an alias', async () => {
+  describe( 'workflow execution path', () => {
+    it( 'validates invocation options before reading workflow information', async () => {
       const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'old_root_wf', memo: {} } );
+      const error = new ValidationError( 'invalid invocation options' );
+      parseInvocationOptionsMock.mockImplementationOnce( () => {
+        throw error;
+      } );
+      const wf = workflow( workflowDefinition() );
 
-      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( {}, { invalid: true } ) ).rejects.toBe( error );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true },
-        trace: { destinations: { local: '/tmp/trace' } }
-      } );
-      expect( executeChildMock ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).not.toHaveBeenCalled();
+      expect( workflowInfoMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'propagates executeChild errors without root ApplicationFailure wrapping', async () => {
+    it( 'rejects a global activity dispatcher left by another workflow run', async () => {
       const { workflow } = await import( './workflow.js' );
-      const error = new Error( 'child failed' );
-      setWorkflowInfo( { memo: { stack: [ 'workflow-123' ] } } );
-      executeChildMock.mockRejectedValueOnce( error );
+      const fn = vi.fn().mockResolvedValue( {} );
+      installGlobalDispatcher( 'stale-run' );
+      setWorkflowInfo( { runId: 'current-run' } );
 
-      const wf = workflow( workflowDefinition( { name: 'failing_child_wf' } ) );
+      const wf = workflow( workflowDefinition( {
+        name: 'contamination_wf',
+        fn
+      } ) );
 
-      await expect( wf( {} ) ).rejects.toBe( error );
+      await expect( wf( {} ) ).rejects.toThrow( /Contamination of the workflow Node global context/ );
+      expect( executeChildMock ).not.toHaveBeenCalled();
+      expect( proxyActivitiesMock ).not.toHaveBeenCalled();
+      expect( fn ).not.toHaveBeenCalled();
     } );
-  } );
 
-  describe( 'workflow execution path', () => {
-    it( 'initializes root memo, skips trace destinations when trace is disabled, validates output, and returns an envelope', async () => {
+    it( 'skips trace destinations when trace is disabled and returns raw output', async () => {
       const { workflow } = await import( './workflow.js' );
-      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/root-trace' } ) );
+      const getTraceDestinations = vi.fn().mockResolvedValue( { local: '/tmp/root-trace' } );
       const info = setWorkflowInfo( { workflowType: 'root_wf', memo: {} } );
       mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: getTraceDestinations } );
 
@@ -425,27 +401,82 @@ describe( 'workflow()', () => {
         fn: async ( _, context ) => ( { ok: context.info.workflowId === 'workflow-123' } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true },
-        trace: { destinations: {} }
-      } );
-      expect( info.memo.stack ).toEqual( [ 'workflow-123' ] );
+      await expect( wf( {} ) ).resolves.toEqual( { ok: true } );
       expect( info.memo.traceInfo ).toBeUndefined();
-      expect( info.memo.activityOptions ).toEqual( expect.objectContaining( {
+      expect( info.memo.activityOptions ).toBeUndefined();
+      expect( proxyActivitiesMock ).toHaveBeenCalledWith( expect.objectContaining( {
         startToCloseTimeout: '5m',
         heartbeatTimeout: '5m',
         retry: expect.objectContaining( { maximumAttempts: 5 } )
       } ) );
-      expect( proxyActivitiesMock ).toHaveBeenCalledWith( info.memo.activityOptions );
       expect( getTraceDestinations ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0]
+      } );
+    } );
+
+    it( 'resolves activity options by invocation, definition, inherited memo, then default precedence', async () => {
+      const { workflow } = await import( './workflow.js' );
+      setWorkflowInfo( {
+        workflowType: 'activity_options_wf',
+        memo: {
+          traceInfo: { workflowId: 'workflow-123' },
+          activityOptions: {
+            heartbeatTimeout: '30s',
+            retry: {
+              maximumInterval: '30s',
+              maximumAttempts: 4
+            }
+          }
+        }
+      } );
+
+      const wf = workflow( workflowDefinition( {
+        name: 'activity_options_wf',
+        options: {
+          activityOptions: {
+            startToCloseTimeout: '5m',
+            retry: {
+              backoffCoefficient: 3,
+              maximumAttempts: 2
+            }
+          }
+        }
+      } ) );
+
+      await wf( {}, {
+        activityOptions: {
+          heartbeatTimeout: '1m',
+          retry: {
+            initialInterval: '1s',
+            maximumAttempts: 9
+          }
+        }
+      } );
+
+      expect( proxyActivitiesMock ).toHaveBeenCalledWith( {
+        startToCloseTimeout: '5m',
+        heartbeatTimeout: '1m',
+        retry: {
+          initialInterval: '1s',
+          backoffCoefficient: 3,
+          maximumInterval: '30s',
+          maximumAttempts: 9,
+          nonRetryableErrorTypes: [ 'FatalError' ]
+        }
+      } );
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0],
+        trace: { local: '/tmp/trace' }
+      } );
     } );
 
     it( 'runs non-root workflow execution without rebuilding trace info or fetching trace destinations', async () => {
       const { workflow } = await import( './workflow.js' );
-      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/trace' } ) );
+      const getTraceDestinations = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
       const memo = {
-        stack: [ 'root-workflow' ],
         traceInfo: { workflowId: 'root-workflow' },
         activityOptions: {
           startToCloseTimeout: '9m',
@@ -471,24 +502,27 @@ describe( 'workflow()', () => {
         fn: async () => ( { ok: true } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true }
-      } );
-      expect( info.memo.stack ).toEqual( [ 'root-workflow', 'child-workflow' ] );
+      await expect( wf( {} ) ).resolves.toEqual( { ok: true } );
       expect( info.memo.traceInfo ).toBe( memo.traceInfo );
-      expect( info.memo.activityOptions ).toEqual( expect.objectContaining( {
-        startToCloseTimeout: '9m',
-        retry: expect.objectContaining( { maximumAttempts: 8 } )
+      expect( proxyActivitiesMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        startToCloseTimeout: '1m',
+        heartbeatTimeout: '5m',
+        retry: expect.objectContaining( { maximumAttempts: 2 } )
       } ) );
-      expect( proxyActivitiesMock ).toHaveBeenCalledWith( info.memo.activityOptions );
       expect( getTraceDestinations ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0]
+      } );
     } );
 
-    it( 'returns empty trace destinations when getTraceDestinations returns no destinations', async () => {
+    it( 'stores empty trace destinations in memo and returns raw output', async () => {
       const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'no_trace_dest_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
+      setWorkflowInfo( {
+        workflowType: 'no_trace_dest_wf',
+        memo: { traceInfo: { workflowId: 'workflow-123' } }
+      } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( {} ) } );
 
       const wf = workflow( workflowDefinition( {
         name: 'no_trace_dest_wf',
@@ -496,10 +530,11 @@ describe( 'workflow()', () => {
         fn: async () => ( { ok: true } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true },
-        trace: { destinations: {} }
+      await expect( wf( {} ) ).resolves.toEqual( { ok: true } );
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0],
+        trace: {}
       } );
     } );
 
@@ -516,29 +551,38 @@ describe( 'workflow()', () => {
         fn: async () => ( { result: 1 } )
       } ) );
 
-      validateInputMock.mockImplementationOnce( () => {
+      parseInputMock.mockImplementationOnce( () => {
         throw inputError;
       } );
       await expect( wf( { value: 1 } ) ).rejects.toBe( inputError );
-      expect( inputError[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
+      } ) );
 
-      setWorkflowInfo( { workflowType: 'runtime_validation_wf', memo: {} } );
-      validateOutputMock.mockImplementationOnce( () => {
+      delete globalThis[INVOKE_ACTIVITY_SYMBOL];
+      setWorkflowInfo( {
+        workflowType: 'runtime_validation_wf',
+        memo: { traceInfo: { workflowId: 'workflow-123' } }
+      } );
+      upsertMemoMock.mockClear();
+      parseOutputMock.mockImplementationOnce( () => {
         throw outputError;
       } );
       await expect( wf( { value: 'ok' } ) ).rejects.toBe( outputError );
-      expect( outputError[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
+      } ) );
     } );
   } );
 
   describe( 'activity dispatchers', () => {
-    it( 'invokes workflow-scoped steps and evaluators and unwraps activity output', async () => {
+    it( 'invokes workflow-scoped activities and returns their raw outputs', 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' ) );
+      const step = vi.fn().mockResolvedValue( 'step-output' );
+      const evaluator = vi.fn().mockResolvedValue( 'eval-output' );
       mockActivities( {
-        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( {} ),
         'dispatch_wf#stepA': step,
         'dispatch_wf#evalA': evaluator
       } );
@@ -546,49 +590,44 @@ describe( 'workflow()', () => {
       const wf = workflow( workflowDefinition( {
         name: 'dispatch_wf',
         outputSchema: z.object( { stepResult: z.string(), evalResult: z.string() } ),
-        async fn() {
+        fn: async () => {
           return {
-            stepResult: await this.invokeStep( 'stepA', { a: 1 }, { b: 2 } ),
-            evalResult: await this.invokeEvaluator( 'evalA', { c: 3 } )
+            stepResult: await globalThis[INVOKE_ACTIVITY_SYMBOL]( 'stepA', { a: 1 }, { b: 2 } ),
+            evalResult: await globalThis[INVOKE_ACTIVITY_SYMBOL]( 'evalA', { c: 3 } )
           };
         }
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'step-output', evalResult: 'eval-output' },
-        trace: { destinations: {} }
-      } );
+      await expect( wf( {} ) ).resolves.toEqual( { stepResult: 'step-output', evalResult: 'eval-output' } );
       expect( step ).toHaveBeenCalledWith( { a: 1 }, { b: 2 } );
       expect( evaluator ).toHaveBeenCalledWith( { c: 3 } );
     } );
 
-    it( 'invokes shared steps and shared evaluators with the shared prefix', async () => {
+    it( 'invokes shared activities through the workflow namespace', 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' ) );
+      const sharedStep = vi.fn().mockResolvedValue( 'shared-step-output' );
+      const sharedEvaluator = vi.fn().mockResolvedValue( 'shared-eval-output' );
       mockActivities( {
-        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
-        [`${SHARED_STEP_PREFIX}#stepA`]: sharedStep,
-        [`${SHARED_STEP_PREFIX}#evalA`]: sharedEvaluator
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( {} ),
+        'shared_dispatch_wf#stepA': sharedStep,
+        'shared_dispatch_wf#evalA': sharedEvaluator
       } );
 
       const wf = workflow( workflowDefinition( {
         name: 'shared_dispatch_wf',
         outputSchema: z.object( { stepResult: z.string(), evalResult: z.string() } ),
-        async fn() {
+        fn: async () => {
           return {
-            stepResult: await this.invokeSharedStep( 'stepA' ),
-            evalResult: await this.invokeSharedEvaluator( 'evalA', { x: 1 } )
+            stepResult: await globalThis[INVOKE_ACTIVITY_SYMBOL]( 'stepA' ),
+            evalResult: await globalThis[INVOKE_ACTIVITY_SYMBOL]( 'evalA', { x: 1 } )
           };
         }
       } ) );
 
       await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'shared-step-output', evalResult: 'shared-eval-output' },
-        trace: { destinations: {} }
+        stepResult: 'shared-step-output',
+        evalResult: 'shared-eval-output'
       } );
       expect( sharedStep ).toHaveBeenCalledWith();
       expect( sharedEvaluator ).toHaveBeenCalledWith( { x: 1 } );
@@ -596,9 +635,10 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'error handling', () => {
-    it( 'attaches root trace destinations to root workflow errors before rethrowing', async () => {
+    it( 'stores root trace destinations in memo and preserves workflow errors', async () => {
       const { workflow } = await import( './workflow.js' );
-      const error = new Error( 'root failed' );
+      const error = new Error( 'root failed with details' );
+      error.details = [ { domain: { reason: 'bad-input' } } ];
       setWorkflowInfo( { workflowType: 'root_error_wf' } );
 
       const wf = workflow( workflowDefinition( {
@@ -610,64 +650,13 @@ describe( 'workflow()', () => {
 
       const thrown = await wf( {} ).catch( e => e );
       expect( thrown ).toBe( error );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
-    } );
-
-    it( 'preserves existing error details when attaching root trace metadata', async () => {
-      const { workflow } = await import( './workflow.js' );
-      const error = new Error( 'root failed with details' );
-      error.details = [ { domain: { reason: 'bad-input' } } ];
-      setWorkflowInfo( { workflowType: 'root_error_existing_details_wf' } );
-
-      const wf = workflow( workflowDefinition( {
-        name: 'root_error_existing_details_wf',
-        fn: async () => {
-          throw error;
-        }
-      } ) );
-
-      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( 'attaches empty trace destinations to root workflow errors when no destinations are available', async () => {
-      const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'root_error_no_trace_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
-      const error = new Error( 'root failed without trace' );
-
-      const wf = workflow( workflowDefinition( {
-        name: 'root_error_no_trace_wf',
-        fn: async () => {
-          throw error;
-        }
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
       } ) );
-
-      await expect( wf( {} ) ).rejects.toBe( error );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: {} } } );
     } );
 
-    it( 'preserves existing error details when no trace destinations are available', async () => {
-      const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'root_error_existing_details_no_trace_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
-      const error = new Error( 'root failed without trace' );
-      error.details = [ { domain: { reason: 'bad-input' } } ];
-
-      const wf = workflow( workflowDefinition( {
-        name: 'root_error_existing_details_no_trace_wf',
-        fn: async () => {
-          throw error;
-        }
-      } ) );
-
-      await expect( wf( {} ) ).rejects.toBe( error );
-      expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: {} } } );
-    } );
-
-    it( 'attaches trace metadata to existing root ApplicationFailure without wrapping it', async () => {
+    it( 'preserves existing root ApplicationFailure metadata', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ApplicationFailure } = await import( '@temporalio/workflow' );
       setWorkflowInfo( { workflowType: 'root_application_failure_wf' } );
@@ -690,7 +679,9 @@ describe( 'workflow()', () => {
       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' } } } );
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
+      } ) );
     } );
 
     it( 'rethrows non-root workflow errors without ApplicationFailure wrapping', async () => {
@@ -699,7 +690,7 @@ describe( 'workflow()', () => {
       setWorkflowInfo( {
         workflowId: 'nested-workflow',
         root: { workflowId: 'root-workflow', runId: 'root-run' },
-        memo: { stack: [ 'root-workflow' ], traceInfo: { workflowId: 'root-workflow' } }
+        memo: { traceInfo: { workflowId: 'root-workflow' } }
       } );
 
       const wf = workflow( workflowDefinition( {
@@ -710,7 +701,10 @@ describe( 'workflow()', () => {
       } ) );
 
       await expect( wf( {} ) ).rejects.toBe( error );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0]
+      } );
     } );
   } );
 } );