Run Function Parallel

Overview

Run Function Parallel calls a function defined by Function Def Start and Function Def End on a separate flow path, in parallel with this node.

Nodes between this node's Start and End handles run once on the current path. Output is the Function Def End return value.

Place this node on a trigger path. The function definition stays on its own subgraph.

Use Run Function Series instead to run the function on the same path and always wait. See How function nodes work together.

Input

Function Definition Node

string required

Function Def Start node to run.

The picker lists Function Def Start nodes anywhere on the canvas, not only upstream of this node.

The selected Start must have a paired Function Def End so this node's outValue can follow the End return schema.

Wait for Function to Finish

boolean required

If on, wait until the function finishes before continuing on the current path. outValue is this call's return.

If off, continue as soon as the function starts. outValue then comes from the last completed run of that same function, captured when this node fires — not from the run that just started. Until that function has finished at least once, outValue may be empty.

Default: off

Output

outValue

object

Function return value. Structure and field types follow the paired Function Def End Function Return Schema.

When Wait for Function to Finish is off, this is the last completed run, not the run that just started.

This node has no argument fields. For a parallel body, prefer shared variables for live data. See Arguments and return values.

Flow Behavior

The function body is not the Start/End sidecar. The body is the subgraph from the selected Function Def Start to Function Def End, and it always runs on a separate path.

Start path (loopStart)

Optional. Connect work that should run once on the current path while the function runs aside.

End input (loopEnd)

Connect the end of that once-through sidecar back to this input.

Normal output (default handle)

Continues the current path after this node. Timing depends on Wait for Function to Finish and whether a sidecar is wired.

Runtime notes:

• Finishing the function path does not complete the trigger that called this node, and does not start the next queued trigger.
• Shared variables are visible to both the current path and the function path.
• If this function already runs when another call starts, overlapping runs use separate body-node instances so local body state does not mix. Shared variables stay shared.
• The function body may call other functions. Nested and recursive calls are allowed, up to depth 8.