Flow control nodes

Branching, loops, waits, limits, and calling other flows.

Generated from the node definitions in src/lib/flow/node/flow/ and the English labels (component.flow.node.flow). Every node also has the common settings.

Contents

• If — flow/if
• Loop over items — flow/loop
• Merge — flow/merge
• Return — flow/return
• Run flow — flow/run
• Stop and error — flow/stop
• Switch — flow/switch
• Wait — flow/wait
• Respond — flow/respond
• Repeat — flow/repeat

If

flow/if · icon git-branch

Takes the true or false path

Fields

Output dots

• true — True
• false — False

Output shape

Later nodes read its item as {{ item… }} (right after it) or {{ nodes.<id>.output… }}.

{
  "result": "boolean",
  "conditions": [
    "unknown"
  ]
}

Example node

{
  "id": "if",
  "type": "flow/if",
  "name": "If",
  "field": {
    "combine": "and",
    "condition": [
      {
        "left": "",
        "operator": "equals",
        "right": ""
      }
    ]
  },
  "setting": {
    "retry": {
      "count": 0,
      "waitMs": 1000,
      "backoff": "fixed"
    },
    "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } },
    "timeoutMs": 60000,
    "disabled": false
  },
  "pin": null
}

Loop over items

flow/loop · icon repeat

Runs the steps once per item

Fields

With parallel above 1 it starts that many items, each in a lane of its own (its own tab); a lane coming back takes the next waiting item, and done goes out once, when the last lane is back. failure: skip: an item that fails ends its lane's turn (logged as "Skipped a failed item") and the lane takes the next one, instead of failing the run. Needs a plan with lanes ().

Output dots

• item — Item
• done — Done

Output shape

Later nodes read its item as {{ item… }} (right after it) or {{ nodes.<id>.output… }}.

{
  "item": "unknown",
  "batch": [
    "unknown"
  ],
  "index": "number",
  "total": "number",
  "items": [
    "unknown"
  ],
  "count": "number",
  "isStopped": "boolean"
}

Its stack

The loop's items is a stack (take: "item"): on a campaign it shows as its own tab in . Each time it runs it takes the first waiting item of its stack, so reordering, removing or finishing (Done) an item while it runs changes what it takes next. The item it handed out is Now until it comes back, then Done. A different list starts a new lap.

Example node

{
  "id": "loop",
  "type": "flow/loop",
  "name": "Loop over items",
  "field": {
    "max": 100
  },
  "setting": {
    "retry": {
      "count": 0,
      "waitMs": 1000,
      "backoff": "fixed"
    },
    "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } },
    "timeoutMs": 60000,
    "disabled": false
  },
  "pin": null
}

Merge

flow/merge · icon merge · runs once with every item

Joins the items of its two inputs, A and B. It waits until both connected inputs have delivered; when nothing else can run it goes with what it has (an input that sent nothing counts as no items).

Input dots

• a — A
• b — B

Fields

• append: A's items, then B's.
• position: A's first item with B's first, and so on; the longer side's extra items go on alone.
• field: items whose key (a dotted path) is equal are joined; left also keeps A items without a match, outer everything from both.
• choose: one input's items as they are (the other only makes it wait).

Output dots

• next — Next

Example node

{
  "id": "merge",
  "type": "flow/merge",
  "name": "Merge",
  "field": { "mode": "field", "key": "id", "join": "left", "prefer": "b" },
  "setting": { "retry": { "count": 0, "waitMs": 1000, "backoff": "fixed" }, "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } }, "timeoutMs": 60000, "disabled": false, "item": { "isOnce": false, "isAlways": false, "batch": { "size": 0, "waitMs": 0 } } },
  "pin": null
}

Wire the two branches into a and b (edge … -> merge.a, edge … -> merge.b).

Return

flow/return · icon corner-down-left

Ends a callable flow and hands back its output

Fields

Output dots

Output shape

Later nodes read its item as {{ item… }} (right after it) or {{ nodes.<id>.output… }}.

"the item it got (unchanged), or what its code returns"

Example node

{
  "id": "return",
  "type": "flow/return",
  "name": "Return",
  "field": {
    "output": {}
  },
  "setting": {
    "retry": {
      "count": 0,
      "waitMs": 1000,
      "backoff": "fixed"
    },
    "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } },
    "timeoutMs": 60000,
    "disabled": false
  },
  "pin": null
}

Run flow

flow/run · icon workflow

Runs another flow, and waits for its result or not

Fields

Output dots

• next — Next
• error — Error

Output shape

Later nodes read its item as {{ item… }} (right after it) or {{ nodes.<id>.output… }}.

"the item it got (unchanged), or what its code returns"

Default settings

timeout 15 minutes; the rest are the .

Example node

{
  "id": "run",
  "type": "flow/run",
  "name": "Run flow",
  "field": {
    "input": {},
    "cache": 0
  },
  "setting": {
    "retry": {
      "count": 0,
      "waitMs": 1000,
      "backoff": "fixed"
    },
    "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } },
    "timeoutMs": 900000,
    "disabled": false
  },
  "pin": null
}

Stop and error

flow/stop · icon octagon-x

Ends the run: failed with your message, or succeeded

Fields

Output dots

Default settings

on error stop; the rest are the .

Example node

{
  "id": "stop",
  "type": "flow/stop",
  "name": "Stop and error",
  "field": {},
  "setting": {
    "retry": {
      "count": 0,
      "waitMs": 1000,
      "backoff": "fixed"
    },
    "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } },
    "timeoutMs": 60000,
    "disabled": false
  },
  "pin": null
}

Switch

flow/switch · icon split

Routes to the rule that matches

Fields

Output dots

• fallback — Fallback
• one dot per rule entry

Output shape

Later nodes read its item as {{ item… }} (right after it) or {{ nodes.<id>.output… }}.

"the item it got (unchanged), or what its code returns"

Example node

{
  "id": "switch",
  "type": "flow/switch",
  "name": "Switch",
  "field": {},
  "setting": {
    "retry": {
      "count": 0,
      "waitMs": 1000,
      "backoff": "fixed"
    },
    "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } },
    "timeoutMs": 60000,
    "disabled": false
  },
  "pin": null
}

Wait

flow/wait · icon timer

Waits a time, until a moment, a random while, a free slot of a limit, a call or a form, then goes on. Pause and cancel interrupt it.

limit waits until a has a free slot: give it the key, max and period of the node limit it guards (limit.key x/post:{{ option.account.x }}, the same as that node's). It only looks; the guarded node takes the slot. Put before a posting round, nothing is read or written for a post that couldn't go: the posting templates start every round with Wait for a post slot.

Fields

call: the run waits until something calls its resume URL, {{ run.resume }}, with any method. Put that URL in a message or an outside system before the Wait. The call's method, query, header and body come out, and the caller gets 200 { "ok": true }. A link opened in a browser gets a short "Thanks" page. A link with ?answer=approve (or a body { "answer": … }) adds answer: that's how send-and-wait messages carry approve and decline links.

form: the run waits for its public form at /form/wait/<token> (the resume URL's token; the run's log shows the link). The answers come out as { answer: { <name>: … } }.

While it waits, the run is Waiting for you with no buttons: only the outside call answers it, a viewer can't. With limitMs, no answer in time takes the timeout dot.

until: "09:00" is the next 09:00; "2026-11-01 09:00" is read in the timezone; an ISO time keeps its offset; a moment already past goes on at once. every: in random mode it only waits each N-th time it's reached (N rolled again after each wait), the other times it goes straight on: a rest every few replies.

Output dots

• next — Next
• timeout — Timed out

Output shape

{
  "waitedMs": "number",
  "until": "string",
  "left": "number",
  "method": "string",
  "query": "unknown",
  "body": "unknown",
  "answer": "unknown"
}

until in until mode; left in random mode (how many more times until it waits again, 0 right after a wait); method, query, header, body and answer in call mode; answer in form mode.

Respond

flow/respond · icon reply

Answers the webhook call that started the run, when its is set to Respond: With a Respond node. Only the first Respond of a run counts; a second one logs that it was skipped. Its items go on unchanged (it runs once with all of them).

Output dots: next.

Default settings

timeout 7 days; the rest are the .

Example node

{
  "id": "rest",
  "type": "flow/wait",
  "name": "Pause like a person",
  "field": { "mode": "random", "minMs": 45000, "maxMs": 120000, "distribution": "human" },
  "setting": { "retry": { "count": 0, "waitMs": 1000, "backoff": "fixed" }, "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } }, "timeoutMs": 604800000, "disabled": false, "item": { "isOnce": false, "isAlways": false, "batch": { "size": 0, "waitMs": 0 } } },
  "pin": null
}

Repeat

flow/repeat · icon repeat

Repeats a branch: connect its again dot to the steps to repeat, and the last of them back into Repeat. A number of times: that many laps (default 3). While a condition holds: as long as the condition (a template such as {{ item.hasMore }}) is true, up to Laps at most (100). Each lap's item carries index (0, 1, 2…); when it's done, the item goes on through done and the count starts over.