chore: import upstream snapshot with attribution

apps/sim/executor/variables/resolvers/parallel.test.ts

@@ -0,0 +1,741 @@
+import { describe, expect, it } from 'vitest'
+import { compactExecutionPayload } from '@/lib/execution/payloads/serializer'
+import { InvalidFieldError } from '@/executor/utils/block-reference'
+import { ParallelResolver } from './parallel'
+import type { ResolutionContext } from './reference'
+
+interface BlockDef {
+  id: string
+  name: string
+}
+
+/**
+ * Creates a minimal workflow for testing.
+ */
+function createTestWorkflow(
+  parallels: Record<
+    string,
+    {
+      nodes: string[]
+      id?: string
+      distribution?: any
+      parallelType?: 'count' | 'collection'
+    }
+  > = {},
+  blockDefs: BlockDef[] = [],
+  loops: Record<string, { id?: string; nodes: string[] }> = {}
+) {
+  const normalizedParallels: Record<
+    string,
+    {
+      id: string
+      nodes: string[]
+      distribution?: any
+      parallelType?: 'count' | 'collection'
+    }
+  > = {}
+  for (const [key, parallel] of Object.entries(parallels)) {
+    normalizedParallels[key] = {
+      id: parallel.id ?? key,
+      nodes: parallel.nodes,
+      distribution: parallel.distribution,
+      parallelType: parallel.parallelType,
+    }
+  }
+  const blocks = blockDefs.map((b) => ({
+    id: b.id,
+    position: { x: 0, y: 0 },
+    config: { tool: 'test', params: {} },
+    inputs: {},
+    outputs: {},
+    metadata: { id: 'function', name: b.name },
+    enabled: true,
+  }))
+  return {
+    version: '1.0',
+    blocks,
+    connections: [],
+    loops,
+    parallels: normalizedParallels,
+  }
+}
+
+/**
+ * Creates a parallel scope for runtime context.
+ */
+function createParallelScope(items: any[]) {
+  return {
+    parallelId: 'parallel-1',
+    totalBranches: items.length,
+    branchOutputs: new Map(),
+    items,
+  }
+}
+
+/**
+ * Creates a minimal ResolutionContext for testing.
+ */
+function createTestContext(
+  currentNodeId: string,
+  parallelExecutions?: Map<string, any>,
+  blockOutputs?: Record<string, any>,
+  parallelBlockMapping?: Map<string, any>,
+  subflowParentMap?: Map<string, any>
+): ResolutionContext {
+  return {
+    executionContext: {
+      workflowId: 'workflow-1',
+      workspaceId: 'workspace-1',
+      executionId: 'execution-1',
+      parallelExecutions: parallelExecutions ?? new Map(),
+      parallelBlockMapping,
+      subflowParentMap,
+    },
+    executionState: {
+      getBlockOutput: (id: string) => blockOutputs?.[id],
+    },
+    currentNodeId,
+  } as ResolutionContext
+}
+
+describe('ParallelResolver', () => {
+  describe('canResolve', () => {
+    it.concurrent('should return true for bare parallel reference', () => {
+      const resolver = new ParallelResolver(createTestWorkflow())
+      expect(resolver.canResolve('<parallel>')).toBe(true)
+    })
+
+    it.concurrent('should return true for known parallel properties', () => {
+      const resolver = new ParallelResolver(createTestWorkflow())
+      expect(resolver.canResolve('<parallel.index>')).toBe(true)
+      expect(resolver.canResolve('<parallel.currentItem>')).toBe(true)
+      expect(resolver.canResolve('<parallel.items>')).toBe(true)
+    })
+
+    it.concurrent('should return true for parallel references with nested paths', () => {
+      const resolver = new ParallelResolver(createTestWorkflow())
+      expect(resolver.canResolve('<parallel.currentItem.name>')).toBe(true)
+      expect(resolver.canResolve('<parallel.items.0>')).toBe(true)
+    })
+
+    it.concurrent(
+      'should return true for unknown parallel properties (validates in resolve)',
+      () => {
+        const resolver = new ParallelResolver(createTestWorkflow())
+        expect(resolver.canResolve('<parallel.results>')).toBe(true)
+        expect(resolver.canResolve('<parallel.output>')).toBe(true)
+        expect(resolver.canResolve('<parallel.unknownProperty>')).toBe(true)
+      }
+    )
+
+    it.concurrent('should return false for non-parallel references', () => {
+      const resolver = new ParallelResolver(createTestWorkflow())
+      expect(resolver.canResolve('<block.output>')).toBe(false)
+      expect(resolver.canResolve('<variable.myvar>')).toBe(false)
+      expect(resolver.canResolve('<loop.index>')).toBe(false)
+      expect(resolver.canResolve('plain text')).toBe(false)
+      expect(resolver.canResolve('{{ENV_VAR}}')).toBe(false)
+    })
+
+    it.concurrent('should return false for malformed references', () => {
+      const resolver = new ParallelResolver(createTestWorkflow())
+      expect(resolver.canResolve('parallel.index')).toBe(false)
+      expect(resolver.canResolve('<parallel.index')).toBe(false)
+      expect(resolver.canResolve('parallel.index>')).toBe(false)
+    })
+  })
+
+  describe('resolve index property', () => {
+    it.concurrent('should resolve branch index from node ID', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b', 'c'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(0)
+    })
+
+    it.concurrent('should resolve different branch indices', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b', 'c'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+
+      expect(resolver.resolve('<parallel.index>', createTestContext('block-1₍0₎'))).toBe(0)
+      expect(resolver.resolve('<parallel.index>', createTestContext('block-1₍1₎'))).toBe(1)
+      expect(resolver.resolve('<parallel.index>', createTestContext('block-1₍2₎'))).toBe(2)
+    })
+
+    it.concurrent('uses runtime branch mapping for batched local branch node IDs', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b', 'c', 'd'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const parallelScope = createParallelScope(['a', 'b', 'c', 'd'])
+      const parallelExecutions = new Map([['parallel-1', parallelScope]])
+      const parallelBlockMapping = new Map([
+        [
+          'block-1₍0₎',
+          {
+            originalBlockId: 'block-1',
+            parallelId: 'parallel-1',
+            iterationIndex: 2,
+          },
+        ],
+      ])
+      const ctx = createTestContext(
+        'block-1₍0₎',
+        parallelExecutions,
+        undefined,
+        parallelBlockMapping
+      )
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(2)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('c')
+    })
+
+    it.concurrent('should return undefined when branch index cannot be extracted', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1')
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBeUndefined()
+    })
+  })
+
+  describe('resolve currentItem property', () => {
+    it.concurrent('should resolve current item from array distribution', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['apple', 'banana', 'cherry'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+
+      expect(resolver.resolve('<parallel.currentItem>', createTestContext('block-1₍0₎'))).toBe(
+        'apple'
+      )
+      expect(resolver.resolve('<parallel.currentItem>', createTestContext('block-1₍1₎'))).toBe(
+        'banana'
+      )
+      expect(resolver.resolve('<parallel.currentItem>', createTestContext('block-1₍2₎'))).toBe(
+        'cherry'
+      )
+    })
+
+    it.concurrent('should resolve current item from object distribution as entries', () => {
+      // When an object is used as distribution, it gets converted to entries [key, value]
+      const workflow = createTestWorkflow({
+        'parallel-1': {
+          nodes: ['block-1'],
+          distribution: { key1: 'value1', key2: 'value2' },
+        },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx0 = createTestContext('block-1₍0₎')
+      const ctx1 = createTestContext('block-1₍1₎')
+
+      const item0 = resolver.resolve('<parallel.currentItem>', ctx0)
+      const item1 = resolver.resolve('<parallel.currentItem>', ctx1)
+
+      // Object entries are returned as [key, value] tuples
+      expect(item0).toEqual(['key1', 'value1'])
+      expect(item1).toEqual(['key2', 'value2'])
+    })
+
+    it.concurrent('should resolve current item with nested path', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': {
+          nodes: ['block-1'],
+          distribution: [
+            { name: 'Alice', age: 30 },
+            { name: 'Bob', age: 25 },
+          ],
+        },
+      })
+      const resolver = new ParallelResolver(workflow)
+
+      expect(resolver.resolve('<parallel.currentItem.name>', createTestContext('block-1₍0₎'))).toBe(
+        'Alice'
+      )
+      expect(resolver.resolve('<parallel.currentItem.age>', createTestContext('block-1₍1₎'))).toBe(
+        25
+      )
+    })
+
+    it.concurrent('should use runtime parallelScope items when available', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['static1', 'static2'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const parallelScope = createParallelScope(['runtime1', 'runtime2', 'runtime3'])
+      const parallelExecutions = new Map([['parallel-1', parallelScope]])
+      const ctx = createTestContext('block-1₍1₎', parallelExecutions)
+
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('runtime2')
+    })
+  })
+
+  describe('resolve items property', () => {
+    it.concurrent('should resolve all items from array distribution', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: [1, 2, 3] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual([1, 2, 3])
+    })
+
+    it.concurrent('should resolve items with nested path', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': {
+          nodes: ['block-1'],
+          distribution: [{ id: 1 }, { id: 2 }, { id: 3 }],
+        },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.items.1>', ctx)).toEqual({ id: 2 })
+      expect(resolver.resolve('<parallel.items.1.id>', ctx)).toBe(2)
+    })
+
+    it.concurrent('should use runtime parallelScope items when available', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['static'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const parallelScope = createParallelScope(['runtime1', 'runtime2'])
+      const parallelExecutions = new Map([['parallel-1', parallelScope]])
+      const ctx = createTestContext('block-1₍0₎', parallelExecutions)
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual(['runtime1', 'runtime2'])
+    })
+  })
+
+  describe('edge cases', () => {
+    it.concurrent('should return context object for bare parallel reference', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b', 'c'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍1₎')
+
+      expect(resolver.resolve('<parallel>', ctx)).toEqual({
+        index: 1,
+        currentItem: 'b',
+        items: ['a', 'b', 'c'],
+      })
+    })
+
+    it.concurrent('should return minimal context object when no distribution', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      const result = resolver.resolve('<parallel>', ctx)
+      expect(result).toHaveProperty('index', 0)
+      expect(result).toHaveProperty('items')
+    })
+
+    it.concurrent('should throw InvalidFieldError for unknown parallel property', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(() => resolver.resolve('<parallel.unknownProperty>', ctx)).toThrow(InvalidFieldError)
+      expect(() => resolver.resolve('<parallel.unknownProperty>', ctx)).toThrow(
+        'Available fields: index'
+      )
+    })
+
+    it.concurrent('should return undefined when block is not in any parallel', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['other-block'], distribution: ['a'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBeUndefined()
+    })
+
+    it.concurrent('should return undefined when parallel config not found', () => {
+      const workflow = createTestWorkflow({})
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBeUndefined()
+    })
+
+    it.concurrent('should handle empty distribution array', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: [] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual([])
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBeUndefined()
+    })
+
+    it.concurrent('should handle JSON string distribution', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: '["x", "y", "z"]' },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍1₎')
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual(['x', 'y', 'z'])
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('y')
+    })
+
+    it.concurrent('should handle JSON string with single quotes', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: "['a', 'b']" },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual(['a', 'b'])
+    })
+
+    it.concurrent('should return empty array for reference strings', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: '<block.output>' },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual([])
+    })
+
+    it.concurrent('should resolve distribution items from distribution property', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['fallback1', 'fallback2'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(resolver.resolve('<parallel.items>', ctx)).toEqual(['fallback1', 'fallback2'])
+    })
+  })
+
+  describe('nested parallel blocks', () => {
+    it.concurrent('should resolve for block with multiple parallel parents', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1', 'block-2'], distribution: ['p1', 'p2'] },
+        'parallel-2': { nodes: ['block-3'], distribution: ['p3', 'p4'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+
+      expect(resolver.resolve('<parallel.currentItem>', createTestContext('block-1₍0₎'))).toBe('p1')
+      expect(resolver.resolve('<parallel.currentItem>', createTestContext('block-3₍1₎'))).toBe('p4')
+    })
+  })
+
+  describe('named parallel references', () => {
+    it.concurrent('should resolve result from anywhere after parallel completes', () => {
+      const workflow = createTestWorkflow(
+        { 'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const results = [[{ response: 'a' }], [{ response: 'b' }]]
+      const ctx = createTestContext('block-outside', new Map(), {
+        'parallel-1': { results },
+      })
+
+      expect(resolver.resolve('<parallel1.result>', ctx)).toEqual(results)
+      expect(resolver.resolve('<parallel1.results>', ctx)).toEqual(results)
+    })
+
+    it('uses parallel block mappings to resolve cloned parallel outputs in later batches', () => {
+      const workflow = createTestWorkflow(
+        { 'nested-parallel': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'nested-parallel', name: 'Nested Parallel' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map<string, any>([
+        ['nested-parallel', { parallelId: 'nested-parallel', branchOutputs: new Map() }],
+        [
+          'nested-parallel__obranch-2',
+          { parallelId: 'nested-parallel__obranch-2', branchOutputs: new Map() },
+        ],
+      ])
+      const ctx = createTestContext(
+        'consumer₍0₎',
+        parallelExecutions,
+        {
+          'nested-parallel': { results: ['branch-0'] },
+          'nested-parallel__obranch-2': { results: ['branch-2'] },
+        },
+        new Map([
+          [
+            'consumer₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'parallel-1', iterationIndex: 2 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<nestedparallel.results>', ctx)).toEqual(['branch-2'])
+    })
+
+    it('uses outer branch suffix over inner parallel mappings for cloned parallel outputs', () => {
+      const workflow = createTestWorkflow(
+        { 'nested-parallel': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'nested-parallel', name: 'Nested Parallel' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map<string, any>([
+        [
+          'nested-parallel__obranch-1',
+          { parallelId: 'nested-parallel__obranch-1', branchOutputs: new Map() },
+        ],
+        [
+          'nested-parallel__obranch-2',
+          { parallelId: 'nested-parallel__obranch-2', branchOutputs: new Map() },
+        ],
+      ])
+      const ctx = createTestContext(
+        'consumer__cloneabc__obranch-2₍0₎',
+        parallelExecutions,
+        {
+          'nested-parallel__obranch-1': { results: ['outer-branch-1'] },
+          'nested-parallel__obranch-2': { results: ['outer-branch-2'] },
+        },
+        new Map([
+          [
+            'consumer__cloneabc__obranch-2₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'inner-parallel', iterationIndex: 1 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<nestedparallel.results>', ctx)).toEqual(['outer-branch-2'])
+    })
+
+    it.concurrent('should resolve result with nested path', () => {
+      const workflow = createTestWorkflow(
+        { 'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const results = [[{ response: 'a' }], [{ response: 'b' }]]
+      const ctx = createTestContext('block-outside', new Map(), {
+        'parallel-1': { results },
+      })
+
+      expect(resolver.resolve('<parallel1.result.0>', ctx)).toEqual([{ response: 'a' }])
+      expect(resolver.resolve('<parallel1.result.1.0.response>', ctx)).toBe('b')
+      expect(resolver.resolve('<parallel1.results[1][0].response>', ctx)).toBe('b')
+    })
+
+    it('should resolve nested paths inside compacted result references', async () => {
+      const workflow = createTestWorkflow(
+        { 'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const compacted = await compactExecutionPayload(
+        { results: [[{ response: 'a' }], [{ response: 'b', payload: 'x'.repeat(2048) }]] },
+        {
+          thresholdBytes: 256,
+          workspaceId: 'workspace-1',
+          workflowId: 'workflow-1',
+          executionId: 'execution-1',
+        }
+      )
+      const ctx = createTestContext('block-outside', new Map(), {
+        'parallel-1': compacted,
+      })
+
+      expect(resolver.resolve('<parallel1.result.1.0.response>', ctx)).toBe('b')
+      expect(resolver.resolve('<parallel1.results[1][0].response>', ctx)).toBe('b')
+      expect(() => resolver.resolve('<parallel1.results>', ctx)).toThrow('too large to inline')
+    })
+
+    it.concurrent('should resolve result with empty currentNodeId', () => {
+      const workflow = createTestWorkflow(
+        { 'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const results = [[{ output: 'x' }], [{ output: 'y' }]]
+      const ctx = createTestContext('', new Map(), {
+        'parallel-1': { results },
+      })
+
+      expect(resolver.resolve('<parallel1.results>', ctx)).toEqual(results)
+    })
+
+    it.concurrent('should return undefined when no output stored yet', () => {
+      const workflow = createTestWorkflow(
+        { 'parallel-1': { nodes: ['block-1'], distribution: ['a'] } },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-outside', new Map())
+
+      expect(resolver.resolve('<parallel1.results>', ctx)).toBeUndefined()
+    })
+
+    it.concurrent('should resolve iteration properties via named reference', () => {
+      const workflow = createTestWorkflow(
+        {
+          'parallel-1': {
+            nodes: ['block-1'],
+            distribution: ['x', 'y', 'z'],
+            parallelType: 'collection',
+          },
+        },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍1₎')
+
+      expect(resolver.resolve('<parallel1.index>', ctx)).toBe(1)
+      expect(resolver.resolve('<parallel1.currentItem>', ctx)).toBe('y')
+      expect(resolver.resolve('<parallel1.items>', ctx)).toEqual(['x', 'y', 'z'])
+    })
+
+    it.concurrent('should throw InvalidFieldError for unknown property on named ref', () => {
+      const workflow = createTestWorkflow(
+        {
+          'parallel-1': {
+            nodes: ['block-1'],
+            distribution: ['a'],
+            parallelType: 'collection',
+          },
+        },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-1₍0₎')
+
+      expect(() => resolver.resolve('<parallel1.unknownProp>', ctx)).toThrow(InvalidFieldError)
+      expect(() => resolver.resolve('<parallel1.unknownProp>', ctx)).toThrow(
+        'Available fields: index, currentItem, items'
+      )
+    })
+
+    it.concurrent('should list only results for contextual fields outside a named parallel', () => {
+      const workflow = createTestWorkflow(
+        {
+          'parallel-1': {
+            nodes: ['block-1'],
+            distribution: ['a'],
+            parallelType: 'collection',
+          },
+        },
+        [{ id: 'parallel-1', name: 'Parallel 1' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext('block-outside', new Map())
+
+      expect(() => resolver.resolve('<parallel1.index>', ctx)).toThrow(InvalidFieldError)
+      expect(() => resolver.resolve('<parallel1.index>', ctx)).toThrow('Available fields: results')
+      expect(() => resolver.resolve('<parallel1.cooked>', ctx)).toThrow(InvalidFieldError)
+      expect(() => resolver.resolve('<parallel1.cooked>', ctx)).toThrow('Available fields: results')
+    })
+
+    it.concurrent('should not resolve named ref when no matching block exists', () => {
+      const workflow = createTestWorkflow({ 'parallel-1': { nodes: ['block-1'] } }, [
+        { id: 'parallel-1', name: 'Parallel 1' },
+      ])
+      const resolver = new ParallelResolver(workflow)
+      expect(resolver.canResolve('<parallel99.index>')).toBe(false)
+    })
+
+    it.concurrent('should resolve generic parallel results from inside a branch', () => {
+      const workflow = createTestWorkflow({
+        'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const results = [[{ response: 'a' }], [{ response: 'b' }]]
+      const ctx = createTestContext('block-1₍0₎', new Map(), {
+        'parallel-1': { results },
+      })
+
+      expect(resolver.resolve('<parallel.results>', ctx)).toEqual(results)
+      expect(resolver.resolve('<parallel.result>', ctx)).toEqual(results)
+    })
+
+    it('resolves generic parallel context from inside a loop nested in a parallel', () => {
+      const workflow = createTestWorkflow(
+        {
+          'parallel-1': {
+            nodes: ['loop-1'],
+            distribution: ['a', 'b', 'c'],
+            parallelType: 'collection',
+          },
+        },
+        [],
+        { 'loop-1': { id: 'loop-1', nodes: ['block-1'] } }
+      )
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext(
+        'block-1__cloneaaa__obranch-2',
+        new Map([['parallel-1', createParallelScope(['a', 'b', 'c'])]])
+      )
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(2)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('c')
+    })
+
+    it('resolves inner parallel branch context independently from the outer clone index', () => {
+      const workflow = createTestWorkflow({
+        'outer-parallel': {
+          nodes: ['inner-parallel'],
+          distribution: ['outer0', 'outer1', 'outer2'],
+        },
+        'inner-parallel': {
+          nodes: ['block-1'],
+          distribution: ['inner0', 'inner1'],
+        },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map([
+        ['inner-parallel__obranch-2', createParallelScope(['inner0', 'inner1'])],
+      ])
+      const ctx = createTestContext('block-1__cloneabc__obranch-2₍1₎', parallelExecutions)
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(1)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('inner1')
+    })
+
+    it('resolves parent parallel context for branch-zero nested subflow descendants', () => {
+      const workflow = createTestWorkflow(
+        {
+          'outer-parallel': {
+            nodes: ['inner-loop'],
+            distribution: ['outer0', 'outer1'],
+          },
+        },
+        [],
+        { 'inner-loop': { id: 'inner-loop', nodes: ['loop-task'] } }
+      )
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map([
+        ['outer-parallel', createParallelScope(['outer0', 'outer1'])],
+      ])
+      const ctx = createTestContext(
+        'loop-task',
+        parallelExecutions,
+        undefined,
+        undefined,
+        new Map([
+          ['inner-loop', { parentId: 'outer-parallel', parentType: 'parallel', branchIndex: 0 }],
+        ])
+      )
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(0)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('outer0')
+    })
+  })
+})