@teleporthq/teleport-plugin-next-workflows 0.45.15 → 0.45.16

package/__tests__/cron-route-loop-templateparams.test.ts

@@ -6,6 +6,7 @@
 // fields and its loop body would never run.
 import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
 import { generateCronAPIRoute } from '../src/api-route-generator'
+import { generateServerRuntimeCode } from '../src/server-runtime-code'
 
 const TRIGGER_ID = 'cron-1'
 const SCAN_ID = 'scan-1'
@@ -124,10 +125,10 @@ describe('generateCronAPIRoute — loop + templateParams support', () => {
   })
 
   it('uses the loop-capable executor (handles general-loop body discovery)', () => {
-    // The shared execution loop keys the loop body off the 'loop' sourceHandle
-    // and walks 'loop-body-out' edges — markers absent from the old naive loop.
-    expect(route).toContain("e.sourceHandle === 'loop'")
-    expect(route).toContain('loop-body-out')
+    // The route runs a loop through the server runtime, which finds its body
+    // by walking from the 'loop' edge up to the loop-back edge.
+    expect(route).toContain('utils.runServerLoop(node, resolved, sortedNodes, ')
+    expect(generateServerRuntimeCode()).toContain('utils.getLoopBodyNodeIds(loopNode.id, edges)')
   })
 
   it('merges templateParams into email body + subject', () => {

package/__tests__/custom-js-loop-scope.test.ts

@@ -1,6 +1,7 @@
 import { generateServerSegmentAPIRoute, generateSharedRuntimeUtilsCode } from '../src'
 import type { WorkflowSegment } from '../src/types'
 import { loadHandler, HandlerFn } from './_helpers/load-handler'
+import { generateServerRuntimeCode } from '../src/server-runtime-code'
 
 // Regression guard for the "loop body custom-js sees the wrong innerParams"
 // bug.
@@ -500,16 +501,20 @@ describe('runtime emission — loop scope stack is pushed and popped', () => {
   })
 
   it('pushes a loop scope before iterating and pops after', () => {
+    // The route hands its loops to runServerLoop, which manages the stack.
     const route = generateServerSegmentAPIRoute(buildSegment())
-    expect(route).toMatch(
-      /context\.__loopScopeStack\.push\(\{\s*loopNodeId:\s*node\.id,\s*bodyNodeIds:\s*bodyNodeIds\s*\}\)/
+    expect(route).toContain('utils.runServerLoop(node, resolved, sortedNodes, ')
+    const runtime = generateServerRuntimeCode()
+    expect(runtime).toMatch(
+      /context\.__loopScopeStack\.push\(\{\s*loopNodeId:\s*loopNode\.id,\s*bodyNodeIds:\s*bodyNodeIds\s*\}\)/
     )
-    expect(route).toContain('context.__loopScopeStack.pop();')
+    expect(runtime).toContain('context.__loopScopeStack.pop();')
   })
 
   it('initialises __loopScopeStack lazily (does not assume caller seeded it)', () => {
-    const route = generateServerSegmentAPIRoute(buildSegment())
-    expect(route).toMatch(/if \(!context\.__loopScopeStack\) context\.__loopScopeStack = \[\];/)
+    expect(generateServerRuntimeCode()).toMatch(
+      /if \(!context\.__loopScopeStack\) context\.__loopScopeStack = \[\];/
+    )
   })
 })
 

package/__tests__/loop-collection-unwrap.test.ts

@@ -1,5 +1,6 @@
 import { generateSharedRuntimeUtilsCode, generateServerSegmentAPIRoute } from '../src'
 import type { WorkflowSegment } from '../src/types'
+import { generateServerRuntimeCode } from '../src/server-runtime-code'
 
 // Regression guard for the "loop iterates 0 times even though the
 // upstream node returned data" bug.
@@ -317,8 +318,12 @@ describe('every loop emit site routes through unwrapWorkflowCollection', () => {
   })
 
   it('regular server segment uses utils.unwrapWorkflowCollection for the loop collection', () => {
+    // Every server route runs its loops through runServerLoop, which unwraps.
     const src = generateServerSegmentAPIRoute(buildLoopSegment(), 'T')
-    expect(src).toContain('utils.unwrapWorkflowCollection(resolved.collection)')
+    expect(src).toContain('utils.runServerLoop(node, resolved, sortedNodes, ')
+    expect(generateServerRuntimeCode()).toContain(
+      'utils.unwrapWorkflowCollection(config.collection)'
+    )
   })
 
   it('client-side runtime uses unwrapWorkflowCollection in executeLoop', () => {

package/__tests__/server-loop-body-branches.test.ts

@@ -0,0 +1,188 @@
+import {
+  generateCronAPIRoute,
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+} from '../src/api-route-generator'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+import { withEnv } from './_helpers/fake-fetch'
+
+/**
+ * An if-statement inside a loop body takes one branch per pass. The server
+ * routes ran the body as a flat list, so both branches ran on every pass.
+ * Each route kind runs a four-pass loop whose body branches on the pass index.
+ */
+
+const LOOP_ID = 'loop-1'
+const IF_ID = 'if-1'
+const HIGH_ID = 'high-1'
+const LOW_ID = 'low-1'
+const AFTER_ID = 'after-1'
+const ITER_ID = LOOP_ID + '_iter'
+const RUNS_KEY = '__serverLoopBranchRuns'
+
+const runs = (): string[] => (globalThis as Record<string, any>)[RUNS_KEY] || []
+
+const recordingNode = (id: string, stepNumber: number) => ({
+  id,
+  type: 'general-custom-js',
+  config: {
+    code: [
+      'function customHandler() {',
+      `  globalThis.${RUNS_KEY} = (globalThis.${RUNS_KEY} || []).concat('${id}');`,
+      '  return { ok: true };',
+      '}',
+    ].join('\n'),
+    context: 'server',
+  },
+  stepNumber,
+  label: id,
+})
+
+const nodes = [
+  {
+    id: LOOP_ID,
+    type: 'general-loop',
+    config: { loopType: 'for', endIndex: 4 },
+    stepNumber: 1,
+    label: 'Loop',
+  },
+  {
+    id: IF_ID,
+    type: 'general-if-statement',
+    config: {
+      conditionType: 'simple-comparison',
+      leftValue: { type: 'workflowContext', nodeId: ITER_ID, path: [ITER_ID, 'index'] },
+      operator: '>=',
+      rightValue: 2,
+    },
+    stepNumber: 2,
+    label: 'Index Is High',
+  },
+  recordingNode(HIGH_ID, 3),
+  recordingNode(LOW_ID, 4),
+  recordingNode(AFTER_ID, 5),
+]
+
+const edges = [
+  { id: 'e1', source: LOOP_ID, target: IF_ID, sourceHandle: 'loop', targetHandle: 'loop-body-in' },
+  { id: 'e2', source: IF_ID, target: HIGH_ID, sourceHandle: 'true' },
+  { id: 'e3', source: IF_ID, target: LOW_ID, sourceHandle: 'false' },
+  {
+    id: 'e4',
+    source: HIGH_ID,
+    target: LOOP_ID,
+    sourceHandle: 'loop-body-out',
+    targetHandle: 'loop-back',
+  },
+  {
+    id: 'e5',
+    source: LOW_ID,
+    target: LOOP_ID,
+    sourceHandle: 'loop-body-out',
+    targetHandle: 'loop-back',
+  },
+  { id: 'e6', source: LOOP_ID, target: AFTER_ID, sourceHandle: 'exit' },
+]
+
+const ONE_BRANCH_PER_PASS = [LOW_ID, LOW_ID, HIGH_ID, HIGH_ID, AFTER_ID]
+
+const requireRuntime = () => {
+  const runtime = loadServerRuntime()
+  return (id: string): unknown => {
+    if (id.endsWith('/utils/workflows/server-runtime')) {
+      return runtime
+    }
+    throw new Error('Unexpected require: ' + id)
+  }
+}
+
+const bootRoute = (source: string) => {
+  const routeModule: { exports: any } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', source)(
+    routeModule,
+    routeModule.exports,
+    requireRuntime()
+  )
+  return routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+}
+
+const jsonReply = () => {
+  const reply = { status: 0, body: undefined as any }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  return { reply, res }
+}
+
+const segment = {
+  id: 'seg-loop-branches',
+  env: 'server',
+  nodeIds: nodes.map((node) => node.id),
+  nodes,
+  edges,
+} as unknown as WorkflowSegment
+
+beforeEach(() => {
+  delete (globalThis as Record<string, any>)[RUNS_KEY]
+})
+
+afterAll(() => {
+  delete (globalThis as Record<string, any>)[RUNS_KEY]
+})
+
+describe.each<[string, () => string]>([
+  ['a server segment route', () => generateServerSegmentAPIRoute(segment)],
+  ['a streaming server segment route', () => generateStreamingServerSegmentAPIRoute(segment)],
+])('%s runs one branch of a loop body per pass', (_route, generate) => {
+  it('skips the branch the if-statement did not take, on that pass only', async () => {
+    const handler = bootRoute(generate())
+    const { reply, res } = jsonReply()
+
+    await handler({ method: 'POST', body: { context: {} }, headers: { host: 'site.example' } }, res)
+
+    expect(reply.status).toBe(200)
+    expect(runs()).toEqual(ONE_BRANCH_PER_PASS)
+  })
+})
+
+describe('a scheduled route runs one branch of a loop body per pass', () => {
+  it('skips the branch the if-statement did not take, on that pass only', async () => {
+    const workflow: any = {
+      id: 'wf-scheduled-loop-branches',
+      name: 'Scheduled Loop Branches',
+      trigger: {
+        type: 'event-cron-triggered',
+        nodeId: 't',
+        scope: 'global',
+        config: { schedule: '5 * * * *', urlPath: 'cron_loop_branches' },
+      },
+      nodes,
+      edges: [{ id: 'e0', source: 't', target: LOOP_ID }, ...edges],
+    }
+    const handler = bootRoute(generateCronAPIRoute(workflow, undefined as never))
+    const { reply, res } = jsonReply()
+    const req = {
+      method: 'POST',
+      url: '/api/workflows/cron_loop_branches',
+      headers: { host: 'site.example', 'x-forwarded-proto': 'https' },
+      body: {},
+    }
+
+    await withEnv({ TELEPORT_CRON_ALLOW_UNSIGNED: 'true', TELEPORT_CRON_SECRET: undefined }, () =>
+      handler(req, res)
+    )
+
+    expect(reply.status).toBe(200)
+    expect(runs()).toEqual(ONE_BRANCH_PER_PASS)
+  })
+})

package/__tests__/server-nested-loops.test.ts

@@ -0,0 +1,392 @@
+import {
+  generateCronAPIRoute,
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+} from '../src/api-route-generator'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+import { withEnv } from './_helpers/fake-fetch'
+
+/**
+ * A loop inside the body of another loop runs all of its passes on every pass
+ * of the outer one. The server routes ran an outer body as one flat list: the
+ * inner loop node fell through to a stub and its body ran once per outer pass.
+ * Each route kind is booted here and run with nested loops.
+ */
+
+const OUTER_ID = 'outer-1'
+const MIDDLE_ID = 'middle-1'
+const INNER_ID = 'inner-1'
+const MAKE_ID = 'make-1'
+const IF_ID = 'if-1'
+const BODY_ID = 'body-1'
+const HIGH_ID = 'high-1'
+const LOW_ID = 'low-1'
+const AFTER_ID = 'after-1'
+const REPORT_ID = 'report-1'
+const INNER_ITER_ID = INNER_ID + '_iter'
+const RUNS_KEY = '__serverNestedLoopRuns'
+const MADE_KEY = '__serverNestedLoopMade'
+
+type GraphNode = Record<string, unknown> & { id: string }
+type GraphEdge = Record<string, unknown> & { id: string; source: string; target: string }
+interface Graph {
+  nodes: GraphNode[]
+  edges: GraphEdge[]
+}
+interface Run {
+  status: number
+  loopResult: (loopId: string) => unknown
+}
+
+const runs = (): unknown[] => (globalThis as Record<string, any>)[RUNS_KEY] || []
+
+const loopNode = (id: string, stepNumber: number, config: Record<string, unknown>): GraphNode => ({
+  id,
+  type: 'general-loop',
+  config,
+  stepNumber,
+  label: id,
+})
+
+const recordingNode = (id: string, stepNumber: number): GraphNode => ({
+  id,
+  type: 'general-custom-js',
+  config: {
+    code: [
+      'function customHandler() {',
+      `  globalThis.${RUNS_KEY} = (globalThis.${RUNS_KEY} || []).concat('${id}');`,
+      `  return { n: globalThis.${RUNS_KEY}.length };`,
+      '}',
+    ].join('\n'),
+    context: 'server',
+  },
+  stepNumber,
+  label: id,
+})
+
+const bodyEntry = (id: string, loopId: string, target: string): GraphEdge => ({
+  id,
+  source: loopId,
+  target,
+  sourceHandle: 'loop',
+  targetHandle: 'loop-body-in',
+})
+
+const loopBack = (id: string, source: string, loopId: string): GraphEdge => ({
+  id,
+  source,
+  target: loopId,
+  sourceHandle: 'loop-body-out',
+  targetHandle: 'loop-back',
+})
+
+const exitTo = (id: string, loopId: string, target: string): GraphEdge => ({
+  id,
+  source: loopId,
+  target,
+  sourceHandle: 'exit',
+})
+
+const forLoopInForLoop = (): Graph => ({
+  nodes: [
+    loopNode(OUTER_ID, 1, { loopType: 'for', endIndex: 2 }),
+    loopNode(INNER_ID, 2, { loopType: 'for', endIndex: 3 }),
+    recordingNode(BODY_ID, 3),
+    recordingNode(AFTER_ID, 4),
+  ],
+  edges: [
+    bodyEntry('e1', OUTER_ID, INNER_ID),
+    bodyEntry('e2', INNER_ID, BODY_ID),
+    loopBack('e3', BODY_ID, INNER_ID),
+    loopBack('e4', INNER_ID, OUTER_ID),
+    exitTo('e5', OUTER_ID, AFTER_ID),
+  ],
+})
+
+const threeLoopsDeep = (): Graph => ({
+  nodes: [
+    loopNode(OUTER_ID, 1, { loopType: 'for', endIndex: 2 }),
+    loopNode(MIDDLE_ID, 2, { loopType: 'forEach', collection: ['a', 'b'] }),
+    loopNode(INNER_ID, 3, { loopType: 'map', collection: ['x', 'y', 'z'] }),
+    recordingNode(BODY_ID, 4),
+    recordingNode(AFTER_ID, 5),
+  ],
+  edges: [
+    bodyEntry('e1', OUTER_ID, MIDDLE_ID),
+    bodyEntry('e2', MIDDLE_ID, INNER_ID),
+    bodyEntry('e3', INNER_ID, BODY_ID),
+    loopBack('e4', BODY_ID, INNER_ID),
+    loopBack('e5', INNER_ID, MIDDLE_ID),
+    loopBack('e6', MIDDLE_ID, OUTER_ID),
+    exitTo('e7', OUTER_ID, AFTER_ID),
+  ],
+})
+
+/**
+ * The outer body first makes a collection (one item on the first outer pass,
+ * two on the second), then walks it with the inner loop, whose body records
+ * the item it was handed.
+ */
+const forEachOverWhatTheOuterPassMade = (): Graph => ({
+  nodes: [
+    loopNode(OUTER_ID, 1, { loopType: 'for', endIndex: 2 }),
+    {
+      id: MAKE_ID,
+      type: 'general-custom-js',
+      config: {
+        code: [
+          'function customHandler() {',
+          `  globalThis.${MADE_KEY} = (globalThis.${MADE_KEY} || 0) + 1;`,
+          `  return { items: globalThis.${MADE_KEY} === 1 ? ['a'] : ['b', 'c'] };`,
+          '}',
+        ].join('\n'),
+        context: 'server',
+      },
+      stepNumber: 2,
+      label: 'Make The Items',
+    },
+    loopNode(INNER_ID, 3, {
+      loopType: 'forEach',
+      collection: { type: 'workflowContext', nodeId: MAKE_ID, path: [MAKE_ID, 'items'] },
+    }),
+    {
+      id: BODY_ID,
+      type: 'general-custom-js',
+      config: {
+        code: [
+          'function customHandler(params) {',
+          `  globalThis.${RUNS_KEY} = (globalThis.${RUNS_KEY} || []).concat(params.item);`,
+          '  return { ok: true };',
+          '}',
+        ].join('\n'),
+        params: {
+          item: { type: 'workflowContext', nodeId: INNER_ID, path: [INNER_ID, 'currentItem'] },
+        },
+        context: 'server',
+      },
+      stepNumber: 4,
+      label: 'Record The Item',
+    },
+  ],
+  edges: [
+    bodyEntry('e1', OUTER_ID, MAKE_ID),
+    { id: 'e2', source: MAKE_ID, target: INNER_ID },
+    bodyEntry('e3', INNER_ID, BODY_ID),
+    loopBack('e4', BODY_ID, INNER_ID),
+    loopBack('e5', INNER_ID, OUTER_ID),
+  ],
+})
+
+const branchInTheInnerBody = (): Graph => ({
+  nodes: [
+    loopNode(OUTER_ID, 1, { loopType: 'for', endIndex: 2 }),
+    loopNode(INNER_ID, 2, { loopType: 'for', endIndex: 4 }),
+    {
+      id: IF_ID,
+      type: 'general-if-statement',
+      config: {
+        conditionType: 'simple-comparison',
+        leftValue: {
+          type: 'workflowContext',
+          nodeId: INNER_ITER_ID,
+          path: [INNER_ITER_ID, 'index'],
+        },
+        operator: '>=',
+        rightValue: 2,
+      },
+      stepNumber: 3,
+      label: 'Index Is High',
+    },
+    recordingNode(HIGH_ID, 4),
+    recordingNode(LOW_ID, 5),
+    recordingNode(AFTER_ID, 6),
+  ],
+  edges: [
+    bodyEntry('e1', OUTER_ID, INNER_ID),
+    bodyEntry('e2', INNER_ID, IF_ID),
+    { id: 'e3', source: IF_ID, target: HIGH_ID, sourceHandle: 'true' },
+    { id: 'e4', source: IF_ID, target: LOW_ID, sourceHandle: 'false' },
+    loopBack('e5', HIGH_ID, INNER_ID),
+    loopBack('e6', LOW_ID, INNER_ID),
+    loopBack('e7', INNER_ID, OUTER_ID),
+    exitTo('e8', OUTER_ID, AFTER_ID),
+  ],
+})
+
+const requireRuntime = (extra: Record<string, unknown> = {}) => {
+  const runtime = loadServerRuntime()
+  return (id: string): unknown => {
+    if (id.endsWith('/utils/workflows/server-runtime')) {
+      return runtime
+    }
+    const known = Object.keys(extra).find((suffix) => id.endsWith(suffix))
+    if (known) {
+      return extra[known]
+    }
+    throw new Error('Unexpected require: ' + id)
+  }
+}
+
+const bootRoute = (source: string, requireFn: (id: string) => unknown) => {
+  const routeModule: { exports: any } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', source)(routeModule, routeModule.exports, requireFn)
+  return routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+}
+
+const jsonReply = () => {
+  const reply = { status: 0, body: undefined as any }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  return { reply, res }
+}
+
+const runSegmentRoute =
+  (generate: (segment: WorkflowSegment) => string) =>
+  async (graph: Graph): Promise<Run> => {
+    const segment = {
+      id: 'seg-nested-loops',
+      env: 'server',
+      nodeIds: graph.nodes.map((node) => node.id),
+      nodes: graph.nodes,
+      edges: graph.edges,
+    } as unknown as WorkflowSegment
+    const handler = bootRoute(generate(segment), requireRuntime())
+    const { reply, res } = jsonReply()
+    await handler({ method: 'POST', body: { context: {} }, headers: { host: 'site.example' } }, res)
+    return { status: reply.status, loopResult: (loopId) => reply.body.results[loopId] }
+  }
+
+/**
+ * A scheduled route replies with no results, so its last step is a custom node
+ * that is handed the result of every loop of the graph.
+ */
+const runScheduledRoute = async (graph: Graph): Promise<Run> => {
+  const loopIds = graph.nodes.filter((node) => node.type === 'general-loop').map((node) => node.id)
+  const parameters: Record<string, unknown> = {}
+  loopIds.forEach((loopId) => {
+    parameters[loopId] = { type: 'workflowContext', nodeId: loopId, path: [loopId] }
+  })
+  const reportNode = {
+    id: REPORT_ID,
+    type: 'general-custom-node',
+    config: { customNodeId: 'cn-report', parameters },
+    stepNumber: graph.nodes.length + 1,
+    label: 'Report The Loops',
+  }
+  const workflow: any = {
+    id: 'wf-scheduled-nested-loops',
+    name: 'Scheduled Nested Loops',
+    trigger: {
+      type: 'event-cron-triggered',
+      nodeId: 't',
+      scope: 'global',
+      config: { schedule: '5 * * * *', urlPath: 'cron_nested_loops' },
+    },
+    nodes: [...graph.nodes, reportNode],
+    edges: [
+      { id: 'e0', source: 't', target: OUTER_ID },
+      ...graph.edges,
+      exitTo('e-report', OUTER_ID, REPORT_ID),
+    ],
+  }
+  const customNodes: Record<string, unknown> = {
+    'cn-report': { id: 'cn-report', name: 'Report', nodes: [], edges: [] },
+  }
+  let reported: Record<string, unknown> = {}
+  const customNodeModule = {
+    'cn-report': async (_context: unknown, handed: Record<string, unknown>) => {
+      reported = handed
+      return { ok: true }
+    },
+  }
+  const handler = bootRoute(
+    generateCronAPIRoute(workflow, customNodes as never),
+    requireRuntime({ '/utils/workflows/custom-nodes': customNodeModule })
+  )
+  const { reply, res } = jsonReply()
+  const req = {
+    method: 'POST',
+    url: '/api/workflows/cron_nested_loops',
+    headers: { host: 'site.example', 'x-forwarded-proto': 'https' },
+    body: {},
+  }
+  await withEnv({ TELEPORT_CRON_ALLOW_UNSIGNED: 'true', TELEPORT_CRON_SECRET: undefined }, () =>
+    handler(req, res)
+  )
+  return { status: reply.status, loopResult: (loopId) => reported[loopId] }
+}
+
+const clearRecordings = () => {
+  delete (globalThis as Record<string, any>)[RUNS_KEY]
+  delete (globalThis as Record<string, any>)[MADE_KEY]
+}
+
+beforeEach(clearRecordings)
+afterAll(clearRecordings)
+
+describe.each<[string, (graph: Graph) => Promise<Run>]>([
+  ['a server segment route', runSegmentRoute(generateServerSegmentAPIRoute)],
+  ['a streaming server segment route', runSegmentRoute(generateStreamingServerSegmentAPIRoute)],
+  ['a scheduled route', runScheduledRoute],
+])('%s runs a loop inside a loop', (_route, run) => {
+  it('runs every pass of the inner loop on every pass of the outer loop', async () => {
+    const result = await run(forLoopInForLoop())
+
+    expect(result.status).toBe(200)
+    expect(runs()).toEqual([BODY_ID, BODY_ID, BODY_ID, BODY_ID, BODY_ID, BODY_ID, AFTER_ID])
+    expect(result.loopResult(OUTER_ID)).toEqual({ completed: true, iterations: 2, results: [] })
+    expect(result.loopResult(INNER_ID)).toEqual({ completed: true, iterations: 3, results: [] })
+  })
+
+  it('runs a loop in a loop in a loop', async () => {
+    const result = await run(threeLoopsDeep())
+
+    expect(result.status).toBe(200)
+    expect(runs()).toEqual([...Array(12).fill(BODY_ID), AFTER_ID])
+    expect(result.loopResult(OUTER_ID)).toEqual({ completed: true, iterations: 2, results: [] })
+    expect(result.loopResult(MIDDLE_ID)).toEqual({ completed: true, iterations: 2, results: [] })
+    expect(result.loopResult(INNER_ID)).toEqual({
+      completed: true,
+      iterations: 3,
+      results: [{ n: 10 }, { n: 11 }, { n: 12 }],
+    })
+  })
+
+  it('walks the collection the current outer pass made', async () => {
+    const result = await run(forEachOverWhatTheOuterPassMade())
+
+    expect(result.status).toBe(200)
+    expect(runs()).toEqual(['a', 'b', 'c'])
+    expect(result.loopResult(OUTER_ID)).toEqual({ completed: true, iterations: 2, results: [] })
+    expect(result.loopResult(INNER_ID)).toEqual({ completed: true, iterations: 2, results: [] })
+  })
+
+  it('takes one branch of the inner body per inner pass', async () => {
+    const result = await run(branchInTheInnerBody())
+
+    expect(result.status).toBe(200)
+    expect(runs()).toEqual([
+      LOW_ID,
+      LOW_ID,
+      HIGH_ID,
+      HIGH_ID,
+      LOW_ID,
+      LOW_ID,
+      HIGH_ID,
+      HIGH_ID,
+      AFTER_ID,
+    ])
+    expect(result.loopResult(INNER_ID)).toEqual({ completed: true, iterations: 4, results: [] })
+  })
+})