Workflow node config reference

Generated from the schemas each kind declares, so this cannot disagree with what the server accepts.

One section per node kind, keyed by the type you write on a node. In XML, write configuration with typed <value> elements. The shared engine checks expression types where known; unknown-to-known bindings warn rather than fail.

agent

Invoke an AI agent with a prompt for freeform LLM processing within the workflow.

Freeform LLM call — returns the agent's parsed response directly as node output (shape depends on the referenced agent's configured response format), and also sets branchTaken from a task-outcome-style response if present. For AI selecting among a task definition's fixed outcomes, use 'agent_task'; for a human decision, use 'task'.

Field	Type	Required	Description
agentId	string	yes	The AI agent to use. Accepts a {{ … }} expression. References a ai_agent.
contextPaths	array of string	—	Extra context for the agent: each {{ … }} expression, such as {{ nodes.load.output }}, is resolved and added to the prompt. Each entry is a {{ … }} expression (the same dialect as 'prompt', not JSONPath) evaluated and appended under a '## Additional Context' section — use this instead of cramming everything into 'prompt' when you want several distinct upstream values attached.
prompt	string	yes	What to ask the agent. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Use {{ nodes..output. }} to weave upstream output into the prompt — not JSONPath. E.g. 'Summarize this: {{ nodes.fetch.output.body }}'.
responseVariable	string	—	Optional workflow variable that also receives the agent's reply. Accepts a {{ … }} expression.

agent_task

Use an AI agent to automatically resolve a task by choosing from predefined outcomes. Optionally falls back to a human task on failure.

The AI counterpart to 'task': the agent must pick one of the task definition's predefined outcomes and the workflow continues immediately (no wait), unlike 'task' which always pauses for a human. Set 'fallbackToHuman' to park the workflow on a human task only if the agent fails. Use plain 'agent' instead for freeform LLM output not constrained to fixed outcomes.

Field	Type	Required	Description
agentId	string	yes	The AI agent that decides the outcome. Accepts a {{ … }} expression. References a ai_agent.
contextPaths	array of string	—	Extra context for the agent: each {{ … }} expression is resolved and added to the prompt. Same {{ … }} expression dialect as 'prompt' (not JSONPath). Use for several distinct upstream values you want the agent to see under '### Additional Data', rather than concatenating them into 'prompt'.
fallbackToHuman	boolean	—	If the agent cannot resolve the task, create a task for a person instead and wait for them.
prompt	string	—	Extra instructions for the agent. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Use {{ nodes..output. }} to bring upstream data into the agent's decision — not JSONPath. Rendered under a '### Context' section alongside the task definition's own name/description and the list of allowed outcomes.
taskDefinitionId	string	yes	The task definition whose outcomes the agent chooses from. Accepts a {{ … }} expression. References a task_definition.

assert

Validates a condition and fails the workflow or branches based on result

Use assert to hard-fail (or, with softFail, soft-fail) a workflow when a predicate doesn't hold. If you instead want to branch execution down different edges without failing the workflow, use the condition node kind — assert and condition share the same predicate dialect.

Field	Type	Required	Description
condition	string	yes	The condition to check, for example input.quantity > 0. Accepts a {{ … }} expression. This is a predicate field: write a bare expression, no {{ … }} wrapping needed (unlike template fields). Reference upstream output as nodes..output., e.g. nodes.fetch.output.status == 200 — not JSONPath ($.data is wrong).
message	string	—	Message used when the check fails. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Template field: interpolate upstream output with {{ nodes..output. }} — not $.data, that's JSONPath, not this dialect. E.g. "Expected 200, got {{ nodes.fetch.output.status }}".
softFail	boolean	—	When true, a failed check does not stop the run; the node outputs passed: false instead.

condition

Condition node configuration with a workflow-expression predicate

Single yes/no branch: sets branchTaken to 'true' or 'false' and passes its input through unchanged (nodes..output has the same shape as the input). Give the two outgoing edges condition 'true' and 'false' to match. For 3+ mutually exclusive branches, use a switch node instead.

Field	Type	Required	Description
expression	string	yes	The condition to test, for example input.age >= 18. Accepts a {{ … }} expression. A bare predicate expression — unlike value/text fields, do NOT wrap it in {{ … }} (a single {{ … }} span is tolerated but not required). Reference an upstream node's output with nodes..output., e.g. nodes.fetch.output.status == 200. Not $.data — that's JSONPath, a different dialect.

csv_parse

CSV parse/encode node configuration for converting between CSV strings and structured data

Use 'parse' mode after a node whose output is a CSV string (e.g. a file read or HTTP fetch); use 'encode' before a node that writes CSV (e.g. a file write) to produce a CSV string from an array of objects.

Field	Type	Required	Description
columns	array of string	—	Column names. When parsing a file without a header row, they name the fields; when encoding, they set the column order.
delimiter	string	—	Character that separates columns.
hasHeaders	boolean	—	Parse mode: the first row holds the column names.
mode	parse | encode	yes	parse turns CSV text into records; encode turns records into CSV text.
source	any	—	The data to convert, written directly or as a {{ … }} expression such as {{ nodes.read.output.content }}. Accepts a {{ … }} expression. Reference an upstream node's output with {{ nodes..output. }} — not $.data, that's JSONPath, not this dialect. E.g. {{ nodes.fetch.output.body }} to parse an HTTP response body.

custom_workflow_action

Execute a user-defined custom action backed by a Lua script

Node output is exactly whatever the referenced custom action's Lua script returns — shape is defined by that specific action, not by this node type. Inspect the action (or its docs) rather than assuming a fixed output shape.

Field	Type	Required	Description
actionConfig	object	—	Settings for the action, as defined by the action. They are passed unchanged, without resolving {{ … }} expressions. Do not use {{ … }} expression templates here — the executor passes this object to the action's Lua script literally, it is never rendered through the workflow expression engine. Populate concrete values (or reference the action's own config schema for expected keys).
actionId	string	yes	The custom action to run. References a customWorkflowAction.

delay

Delay node pauses workflow execution for a configurable duration, then passes input through unchanged

Passes its input through unchanged after waiting — nodes..output has the same shape as this node's input, not a fixed shape of its own.

Field	Type	Required	Description
jitter	integer	—	Optional random variation, in seconds, added to or taken from the wait.
seconds	any	yes	How long to wait, in seconds: a number or a {{ … }} expression that gives one.

file_check

Checks if a file exists in a Folder (controller / S3-hostPath storage backend / control cloud)

Use before file_read/file_delete when the path may not exist — file_check never fails the node for a missing path, it just returns exists: false, whereas file_read and file_delete (without ignoreNotFound) fail the node in that case. Folders address files (objects), not directories.

Field	Type	Required	Description
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
folderId	string	—	Folder ID (a TypeID starting fld_), or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. All three bindings support the existence check (stat). Omitted → the tenant's default (control cloud) Folder.
path	string	yes	Path of the file to check, or a {{ … }} expression. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Paths are relative to the Folder's root — never absolute. Reference an upstream node's output with {{ nodes..output. }} to build the path dynamically — not JSONPath.

file_copy

Copies a file from one Folder to another (or within the same Folder)

Requires read on the source Folder and write on the destination Folder. Unconditionally overwrites an existing object at destinationKey.

Field	Type	Required	Description
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
destinationFolderId	string	—	Folder to copy to: its ID (a TypeID starting fld_) or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. May be the same Folder as sourceFolderId (to duplicate under a new key) or a different one. When both source and destination Folders are bound to the exact same storage backend account, the copy uses that provider's native server-side copy — no bytes pass through this server.
destinationKey	string	yes	Path to copy to, or a {{ … }} expression. An existing file at that path is overwritten. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Paths are relative to the destination Folder's root — never absolute.
sourceFolderId	string	—	Folder to copy from: its ID (a TypeID starting fld_) or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath/Google-Drive/Dropbox storage backend, or the control cloud store. Omitted → the tenant's default (control cloud) Folder.
sourceKey	string	yes	Path of the file to copy, or a {{ … }} expression. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Paths are relative to the source Folder's root — never absolute.

file_delete

Deletes a file from a Folder (controller / S3-hostPath storage backend); control-cloud folders do not support delete

ignoreNotFound defaults to false, so deleting an already-missing file fails the node — set it to true for idempotent cleanup steps (e.g. a delete that may run twice on retry).

Field	Type	Required	Description
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
folderId	string	—	Folder ID (a TypeID starting fld_), or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. Control-cloud folders do NOT support delete — the node fails with a capability error; the tenant's default Folder is control-cloud-bound, so file_delete usually needs an explicit folderId.
ignoreNotFound	boolean	—	When true, succeed even if the file does not exist.
path	string	yes	Path of the file to delete, or a {{ … }} expression. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Paths are relative to the Folder's root — never absolute. Reference an upstream node's output with {{ nodes..output. }} to build the path dynamically — not JSONPath.

file_list

Lists files in a Folder (controller / S3-hostPath storage backend); control-cloud folders do not support list

Listing is files-only — directories are never returned (Folders address objects). Each entry's 'name' is the full folder-relative key, usable directly as another file node's 'path'. On controller-bound folders the listing is SHALLOW (one directory level per call) and entries carry no size/modifiedAt; storage-backend folders list deeply with size and modifiedAt by default. Control-cloud folders don't support list at all. Set recursive: false for a cheaper one-level listing (matches how controller-bound folders have always behaved) — useful when a folder uses processing/done/error sibling subfolders and you only want directly-dropped files.

Field	Type	Required	Description
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
folderId	string	—	Folder ID (a TypeID starting fld_), or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. Control-cloud folders do NOT support list — the node fails with a capability error; the tenant's default Folder is control-cloud-bound, so file_list usually needs an explicit folderId.
path	string	—	Optional path prefix to list under, or a {{ … }} expression. Leave it out to list the whole folder. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Prefixes are relative to the Folder's root — never absolute. Reference an upstream node's output with {{ nodes..output. }} to build the prefix dynamically — not JSONPath.
recursive	boolean	—	true lists every file under the prefix, at any depth; false lists only files directly in it. Left out, most folders list everything, while controller folders list one level.

file_read

Reads file content from a Folder (controller / S3-hostPath storage backend / control cloud)

Fails the node if the path doesn't exist. If the file may be missing, run file_check first (it just reports exists: false) instead of relying on file_read's error to detect that. All Folder bindings (controller, storage backend, control cloud) support read. Content is capped at 8 MB — this node is for text/data files a workflow inspects, not for artwork or other large binaries; pass those between nodes as a Folder path instead.

Field	Type	Required	Description
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
folderId	string	—	Folder ID (a TypeID starting fld_), or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. Usually a literal Folder TypeID picked by the workflow author; use {{ nodes..output. }} only when the folder is resolved dynamically upstream — not JSONPath ($.data). Omitted → the tenant's default (control cloud) Folder.
path	string	yes	Path of the file to read, or a {{ … }} expression. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Paths are relative to the Folder's root — never absolute. Reference an upstream node's output with {{ nodes..output. }} to build the path dynamically — not JSONPath. E.g. {{ nodes.list.output.entries[0].name }}.

file_wait

Suspends the workflow until a specific file appears in a Folder

Requires only stat, so every Folder binding is supported. Polled periodically in the background by FileWaitResumeService — there is no timeout; a file that never appears waits forever, same as an unresolved file_wait's sibling task/agent_task human-approval nodes today.

Field	Type	Required	Description
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
folderId	string	—	Folder ID (a TypeID starting fld_), or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. Works on every Folder binding, including control-cloud (only stat is needed, unlike file_list/file_copy which need list). Omitted → the tenant's default Folder.
key	string	yes	Exact path of the file to wait for, or a {{ … }} expression. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Waits for one specific, exact key — not a pattern or prefix. If the file already exists when this node runs, it completes immediately without ever waiting. Use this after triggering an external process (e.g. a RIP) whose output filename you already know.

file_write

Writes content to a file in a Folder (controller / S3-hostPath storage backend / control cloud)

All Folder bindings support write. Parent directories are created implicitly — folder paths are object keys. The output's 'path' is the authoritative stored key: on control-cloud folders it differs from the requested path (the store mints its own keys).

Field	Type	Required	Description
content	string	yes	What to write, written directly or as a {{ … }} expression. Accepts a {{ … }} expression. Almost always a {{ nodes..output. }} expression pulling data from an upstream node (e.g. {{ nodes.csv.output }} or {{ nodes.fetch.output.body }}) — not JSONPath. Large controller-bound payloads are transparently spooled out-of-band; no config changes needed for that.
controllerId	string	—	Older workflows only: routes to a controller when no folder is given. Use folderId in new workflows. Accepts a {{ … }} expression.
folderId	string	—	Folder ID (a TypeID starting fld_), or a {{ … }} expression. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. Usually a literal Folder TypeID; use a {{ … }} expression only when the folder is resolved dynamically upstream. Omitted → the tenant's default (control cloud) Folder.
path	string	yes	Path of the file to write, or a {{ … }} expression. Paths are relative to the folder; .. segments are rejected. Accepts a {{ … }} expression. Paths are relative to the Folder's root — never absolute. Reference an upstream node's output with {{ nodes..output. }} to build the path dynamically — not JSONPath. Intermediate directories are created implicitly. On control-cloud folders the store mints its own key — read the actual stored path from this node's output.path.

for_each

Iterates over an array and executes a body node for each item

Downstream nodes read the aggregated results via nodes..output.results (an array with one entry per item, in input order) and nodes..output.count — never nodes..output directly as the array. Per-item shape depends on the body node's own output type.

Field	Type	Required	Description
as	string	—	Name for the current item inside the nested step.
body	object	yes	The step to run for each item. A full node definition object ({type, config, ...}) run once per item. Inside body.config expressions use variables.item (or variables. for a custom 'as' name) and variables.index. For example, {{ variables.job.name }} and {{ variables.index + 1 }} when as is 'job'. These variables are set fresh for each iteration, not published as node outputs.
items	any	yes	The list to go through: a literal list, or a {{ … }} expression such as {{ nodes.list.output.entries }}. Value/text field: wrap references in {{ … }}, e.g. {{ nodes.file_list.output.entries }} — not $.data (JSONPath) and not a bare expression like a condition's predicate.
maxConcurrency	integer	—	How many items to process at the same time. Bounds how many items run at once. Default 1 = sequential. A value > 1 runs iterations in parallel (each item in an isolated scope); results stay in input order. Values below 1 are treated as 1.

graphql

GraphQL node configuration for executing queries and mutations against the Pulse API

Output is query-shaped, not fixed: nodes..output.data mirrors the field names and nesting of your query/mutation's selection set (e.g. a query selecting printJobs { id status } yields output.data.printJobs[].id). Any top-level GraphQL errors fail this node, including errors accompanying partial data.

Field	Type	Required	Description
operation	query | mutation	yes	query to read data, mutation to change it.
query	string	yes	The GraphQL document to run.
variables	object	—	Variables for the document: literals or {{ … }} expressions such as {{ input.jobId }}. Accepts a {{ … }} expression. Each variable value may be a literal or a {{ nodes..output. }} / {{ input. }} expression (this engine's dialect, not JSONPath's $.data). Variable names must match the $-prefixed names declared in the query string.

http_call

Issue an HTTP request to an arbitrary URL, subject to the host's HTTP policy.

Response body arrives as a raw string at nodes..output.body — pipe it through a json_parse or csv_parse node before treating it as structured data. Status code is nodes..output.status.

Field	Type	Required	Description
body	string	—	Request body, as text. Accepts a {{ … }} expression.
headers	object	—	Request headers. Accepts a {{ … }} expression.
method	GET | POST | PUT | DELETE | PATCH | HEAD	—	HTTP method. Accepts a {{ … }} expression.
timeoutSeconds	integer	—	How long to wait for a response, in seconds; at most 120.
url	string	yes	The full address to call. Your installation's HTTP access policy must allow it. Accepts a {{ … }} expression.

http_request

HTTP request node configuration for device communication

Targets a specific device over its DeviceActor (per-device circuit breaker, requires the device to be online) — use this for a device's onboard HTTP API. Use http_call instead for an arbitrary external URL unrelated to a device.

Field	Type	Required	Description
body	string	—	Request body. Accepts a {{ … }} expression. Use {{ nodes..output. }} to splice upstream data into the body string, e.g. {{ nodes.build.output.payload }}.
deviceId	string	yes	The device to call, or a {{ … }} expression. Accepts a {{ … }} expression. References a device. Reference an upstream node's output with {{ nodes..output. }} (this dialect, not JSONPath's $.data) if the device ID comes from a prior lookup, e.g. {{ nodes.lookup.output.deviceId }}.
headers	object	—	Request headers. Accepts a {{ … }} expression. Each header value may be a literal string or a {{ nodes..output. }} expression; header keys are always literal.
method	GET | POST | PUT | DELETE | PATCH	—	HTTP method. Accepts a {{ … }} expression.
path	string	—	Path on the device to request. Accepts a {{ … }} expression. Supports {{ nodes..output. }} expressions to build the path from prior node output, e.g. {{ nodes.lookup.output.itemId }}.
query	object	—	Query parameters. Accepts a {{ … }} expression. Each query parameter value may be a literal string or a {{ nodes..output. }} expression; parameter names are always literal.

impose_pdf

Imposes source PDFs onto press sheets per an imposition plan (inline or saved specs) and stores the print-ready PDF as a managed File. Exactly one of plan or impositionSpecIds must be specified.

Chain after an impose_plan node (plan: {{ nodes..output.plan }}) or point impositionSpecIds at a component's saved specs. Downstream nodes reference the result via nodes..output.fileId — e.g. a pdf_render node (fileId) for a sheet preview. Requires the native PDF-Writer backend on the server.

Set exactly one of: plan, or impositionSpecIds.

Field	Type	Required	Description
componentId	string	yes	The component (a TypeID starting cmp_) the imposition belongs to. It supplies the default artwork and receives the finished PDF. Accepts a {{ … }} expression. Required. Supports {{ … }} expressions, e.g. {{ input.componentId }}.
fileName	string	—	Name for the stored PDF. Defaults to imposition-<component short id>.pdf. Accepts a {{ … }} expression.
impositionSpecIds	array of string	—	Saved imposition specs for the component (TypeIDs starting imp_), imposed in order. Give either this or <plan>. Use this to impose a component's persisted imposition specs (e.g. the ones written by the calculateImposition mutation) instead of an inline plan. All specs must belong to componentId; each spec's stored sheet layout becomes one sheet, in the array's order.
outputFolderId	string	—	Folder for the imposed PDF (a TypeID starting fld_). Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. Omitted → the tenant's default (control cloud) Folder. Supports {{ … }} expressions.
pageBindings	array of object	—	Which source PDF supplies which placed pages. Optional when the component has exactly one artwork file. Provide explicit bindings whenever the component has multiple artwork files (e.g. cover + text) or pages come from a managed File produced upstream. Ranges must not overlap.
plan	object	—	One imposition plan, as produced by impose-plan. Give either this or <imposition-spec-ids>. Accepts a {{ … }} expression. Wire this from an upstream impose_plan node: {{ nodes.<impose_plan_id>.output.plan }}. The whole value may be one {{ … }} expression resolving to the plan object.
renderMode	production | debug_summary	—	production places the real source pages, with crop and registration marks; debug_summary writes a text summary of the placements instead, for testing. production imports and places the real source PDF pages with crop/registration marks — the print-ready output. debug_summary writes a textual placement summary instead of composing pages; use it only to verify wiring without valid sources.

impose_pdf.pageBindings[]

Field	Type	Required	Description
pageRangeEnd	integer	yes	Last placed page this source covers (inclusive).
pageRangeStart	integer	yes	First placed page this source covers (inclusive, counting from 1).
sourceDocumentId	string	yes	The source PDF: an artwork file (caf_…) or a managed file (fil_…).
sourcePageOffset	integer	—	Added to the page number when mapping a placed page to a source page.

impose_plan

Run the pure imposition engine and output the recommended plan as structured data — no persistence, no PDF.

Provide EXACTLY ONE geometry source: componentId (derives everything from the component, needs the database) OR totalPages+finishedWidthMm+finishedHeightMm (inline). Inline geometry takes substrates from substrateIds (DB) or inline substrates (no DB at all). Typically feeds impose_pdf with nodes..output.plan, or a condition node branching on plan economics (e.g. nodes..output.plan.wastePages).

Set exactly one of: componentId, or totalPages + finishedWidthMm + finishedHeightMm.

Field	Type	Required	Description
bindingType	SADDLE_STITCH | PERFECT_BOUND | CASE_BOUND | WIRE_BOUND | FLATWORK | FOLDED | OTHER	—	Binding method; it decides how pages are ordered on the sheet. SADDLE_STITCH nests all sheets into one booklet (power-of-2 folds only, creep compensation applied); PERFECT_BOUND/CASE_BOUND/WIRE_BOUND gather independent signatures.
bleedMm	number	—	Bleed on every edge, in millimetres. With componentId, it replaces the component's bleed.
componentId	string	—	Component (a TypeID starting cmp_) to take page size, quantity and substrates from, or a {{ … }} expression. Use this or the size attributes, not both. Accepts a {{ … }} expression. Use {{ input.componentId }} or {{ nodes..output. }} to reference the component dynamically — not JSONPath. Derives totalPages, finished size, bleed, quantity and grain from the component's print details, exactly like the calculateImposition mutation. Requires the Pulse host (database).
finishedHeightMm	number	—	Trimmed page height in millimetres, when you give the size directly.
finishedWidthMm	number	—	Trimmed page width in millimetres, when you give the size directly.
fullResult	boolean	—	Also return every ranked plan as plans, not only the best one. Leave false unless a downstream node compares alternatives — the full array repeats complete sheet geometry per plan and can be large.
maxPagesUp	integer	—	Most pages to place per section; larger fold patterns are left out.
mode	signature | ganging	—	signature plans folded sections for bound or folded work; ganging plans flat step-and-repeat layouts, several copies to a sheet. signature = folded sections for bound/folded work; ganging = flat step-and-repeat N-up. Web imposition needs a web press profile this node cannot supply — use the calculateImposition mutation for web.
permittedFolds	array of string	—	Only consider these fold patterns, for example f8 and f16. Unknown patterns are rejected. Valid IDs come from the fold catalog: f2, f4, f6, f8, f10, f12, f14, f16, f18, f20, f24, f28, f32, f36, f40, f48, f64. Leave unset to consider all patterns.
quantity	integer	—	Copies to produce, used to estimate total sheets. With componentId, it replaces the component's quantity.
substrateIds	array of string	—	Substrates to plan against (TypeIDs starting sub_). With componentId, it narrows the component's substrates. Requires the Pulse host (database). For zero-DB what-if planning use inline 'substrates' instead.
substrates	array of object	—	Sheets to plan against, written out in full. Only with a size given directly, and not together with <substrate-ids>. The fastest way to run what-if imposition with no tenant data: e.g. [{"name": "SRA3", "widthMm": 320, "heightMm": 450}].
totalPages	integer	—	Total trimmed pages, when you give the size directly (with the width and height).

impose_plan.substrates[]

Field	Type	Required	Description
heightMm	number	yes	Sheet height in millimetres.
name	string	yes	Sheet name, for example SRA3.
widthMm	number	yes	Sheet width in millimetres.

integration_action

Execute an action exported by an installed integration

Node output is exactly whatever the installed integration's action script returns — a third-party-defined, unmodeled passthrough. Shape depends entirely on which integration instance and action are referenced; don't assume a fixed output shape.

Field	Type	Required	Description
actionConfig	object	—	Settings for the action, as the integration defines them. They are passed unchanged, without resolving {{ … }} expressions. Do not use {{ … }} expression templates here — it is passed to the integration's Lua action script literally, never rendered through the workflow expression engine. Values depend entirely on the specific action named in 'actionName'.
actionName	string	yes	The integration action to run.
instanceId	string	yes	The installed integration to use (a TypeID).

invoke_edge_app

Invokes an edge app function on a controller via the edge-app invocation service

Calls exports. on an installed edge app; the function's own JSON return value is wrapped under nodes..output.result, so its inner shape is app-specific — reference it as nodes..output.result. once you know what that function returns.

Field	Type	Required	Description
controllerId	string	yes	The controller (a TypeID) where the edge app is installed. Accepts a {{ … }} expression. Use {{ nodes..output. }} to target a controller resolved by an upstream node — not JSONPath.
edgeAppHandle	string	yes	The edge app to call. Accepts a {{ … }} expression. Use {{ nodes..output. }} to resolve this dynamically (e.g. from a lookup node) — not JSONPath. All three fields on this node (edgeAppHandle, controllerId, function) are rendered through the same expression dialect via context.renderExpression.
function	string	yes	The function to call, as the app exports it. Accepts a {{ … }} expression. Like the other fields on this node, this is rendered through context.renderExpression before use, so {{ … }} templates work here too — not JSONPath.

join

Join node (AND): waits for all LIVE inbound paths and merges them. A path excluded by an untaken branch is ignored; a live path that FAILED triggers onPartialFailure. For tolerant OR fan-in, use a merge node.

Fan-in counterpart to split, AND semantics: the wave scheduler runs this after all predecessors, and it merges every live path. A branch-excluded path is fine; a failed live path applies onPartialFailure ('fail' by default, else 'skip'). Pick 'array' when order doesn't matter, 'keyed' when downstream addresses each predecessor by name, 'merge' when predecessor outputs are objects with non-overlapping keys.

Set exactly one of: strategy, or strategy.

Field	Type	Required	Description
keys	object	—	Names to use instead of node IDs with the keyed strategy. Only read when strategy is 'keyed'. Keys are predecessor node IDs; values are the output key name to use instead of the node ID.
onPartialFailure	fail | skip	—	What to do if an incoming branch failed but the run continued: fail marks the join as failed; skip skips it. A branch that was simply not taken does not count as a failure. Read by the engine's join gate, not the executor. Default 'fail'. Only relevant under continueOnError; a switch/condition-excluded branch never triggers it. Use a merge node instead if you want tolerant OR fan-in that ignores failed paths.
strategy	merge | array | keyed	—	merge combines the results into one object; array lists them; keyed stores each under its node's ID, or under the names in <keys>. If omitted, defaults to 'keyed'. 'merge' shallow-merges all input objects' top-level keys — if two predecessors share a key, the winner is unspecified (dictionary iteration order), so avoid overlapping keys. 'array' collects inputs sorted alphabetically by predecessor node ID, not graph/execution order. 'keyed' builds an object keyed by predecessor node ID (or the 'keys' mapping) — reference a branch downstream as nodes.<join_id>.output..

json_parse

JSON parse/encode node configuration for converting between JSON strings and structured data

Use json_parse when upstream output is a JSON string (e.g. an HTTP response body with a JSON content type). Prefer yaml_parse for YAML text and csv_parse for tabular CSV text — pick by the actual wire format, not by what the data represents.

Field	Type	Required	Description
mode	parse | encode	yes	parse turns JSON text into data; encode turns data into JSON text.
pretty	boolean	—	Encode mode: format the JSON with line breaks and indentation.
source	any	—	The data to convert, written directly or as a {{ … }} expression such as {{ nodes.read.output.content }}. Accepts a {{ … }} expression. Reference an upstream node's output with {{ nodes..output. }} — not $.data, that's JSONPath, not this dialect. E.g. {{ nodes.fetch.output.body }} to parse an HTTP response body.

log

Logs a message to the execution log and passes input through unchanged

Use for diagnostic/debugging output mid-workflow. Passes its input through unchanged as nodes..output.value, alongside the rendered message and the level used.

Field	Type	Required	Description
level	debug | info | warning | error	—	How important the message is.
message	string	yes	The message. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Interpolate upstream output with {{ nodes..output. }} — not $.data, that's JSONPath, not this dialect. E.g. "fetched {{ nodes.fetch.output.status }}".

logic

Boolean gate over workflow-expression predicates

Combines several predicates into one boolean: sets branchTaken to 'true'/'false' (give outgoing edges condition 'true'/'false' to branch, like the condition node) and outputs {result, operands} for downstream value use. For a single predicate use condition; for multi-way routing use switch.

Field	Type	Required	Description
op	and | or | not | nand | nor | xor | xnor	yes	How to combine the conditions. xor/xnor over 3+ operands use odd parity ((a XOR b) XOR c). 'not' takes exactly 1 operand; all other ops take 2 or more.
operands	array of string	yes	The conditions to combine, in order. Each operand is a bare predicate like the condition node's expression — do NOT wrap it in {{ … }}. Reference an upstream node's output with nodes..output.. Not $.data — that's JSONPath, a different dialect.

merge

Merge node fans 2+ live inputs into a single output (OR — tolerates missing/failed paths).

Fan-in counterpart to split, OR semantics. Pick 'array' when order doesn't matter, 'keyed' when downstream addresses each predecessor by name, 'merge' when predecessor outputs are objects with non-overlapping keys. Use join for AND (wait-for-all-live) semantics.

Field	Type	Required	Description
keys	object	—	With the keyed strategy, names to use instead of node IDs. Only read when strategy is 'keyed'. Keys are predecessor node IDs; values are the output key name to use instead of the node ID.
strategy	merge | array | keyed	—	merge combines the results into one object; array lists them; keyed stores each under its node's ID. If omitted, defaults to 'keyed'. Tolerant fan-in (OR): merges whatever live predecessor outputs arrived; a not-taken or failed path is excluded. For strict wait-for-all-live, use a join node instead.

message

Send a templated notification to a group or individual recipient.

Email-only today: recipients are filtered to notification recipients whose delivery channel is email — a group member or recipient without an email channel is silently skipped, not an error. Provide exactly one of groupId or recipientId (the node fails if both are omitted).

Field	Type	Required	Description
body	string	yes	Message text. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Same {{ nodes..output. }} template syntax as subject — interpolates plain text, not HTML.
bodyHtml	string	—	Optional HTML version of the message. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Same {{ nodes..output. }} template syntax as subject/body. Optional — omit it to send a plain-text-only message.
groupId	string	—	Notification group to send to; everyone in it receives the message. Use this or recipientId. Accepts a {{ … }} expression. References a notification_group. Usually a literal notification-group TypeID picked by the workflow author. Use {{ nodes..output. }} only when the group is resolved dynamically upstream — not JSONPath ($.data). Provide exactly one of groupId or recipientId.
recipientId	string	—	Person to send to. Use this or groupId. Accepts a {{ … }} expression. References a user. Usually a literal recipient TypeID picked by the workflow author. Use {{ nodes..output. }} only when the recipient is resolved dynamically upstream — not JSONPath. Provide exactly one of groupId or recipientId.
subject	string	yes	Subject line. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Interpolate upstream data with {{ nodes..output. }} (a Jinja-subset template, not JSONPath — $.data is wrong here). E.g. {{ nodes.fetchOrder.output.customerName }} to personalize the subject.

microsql

Run a MicroSQL query against the platform's reporting engine

Runs against the platform's own reporting engine, scoped to the workflow's tenant. Requires a configured bot user with :list permission for every queried resource (distinct from sql_query, which runs against a device's database). Output is query-shaped: 'rows' contains arrays whose values line up with 'headers' in the same order — not a fixed schema of field names.

Field	Type	Required	Description
bindings	object	—	Parameter values: each name matches a :name in the query, and each value is a literal or a {{ … }} expression. Accepts a {{ … }} expression. Keys must match the ':paramName' placeholders declared in 'query'. Each value may be a literal or a {{ nodes..output. }} expression, e.g. { "tenantId": "{{ input.tenantId }}" }.
maxRows	integer	—	Most rows to return; at most 10,000.
query	string	yes	The query. Mark parameters as :name and give their values in <bindings>; {{ … }} expressions are also allowed. Accepts a {{ … }} expression. The {{ … }} expression templates splice text before the query is parsed (e.g. to build the query dynamically) — prefer the ':paramName' named parameters plus 'bindings' for actual data values, rather than splicing them into the query string.

ml_predict

Run an ML model: tabular models (regression/classification) take 'features'; forecast models take 'horizon'/'confidenceLevel'.

The output shape follows the named model's type: regression → {prediction}; classification → {predictedClass, confidence}; forecast → {forecast: [{step, point, lower?, upper?}], level?}. See this node's output schema.

Set exactly one of: modelName + features, or modelName.

Field	Type	Required	Description
confidenceLevel	number	—	Forecasts only: confidence level between 0 and 1 for the prediction range. Leave it out to use the model's own setting; without one, forecasts have no upper and lower bounds. Accepts a {{ … }} expression. Only read for forecast models. Must be between 0 and 1 (e.g. 0.95). When absent and the model has no stored default, the forecast rows omit lower/upper and the output omits level.
features	object	—	Inputs for a regression or classification model: a literal or a {{ … }} expression for each feature. Forecast models ignore it. Accepts a {{ … }} expression. Use {{ nodes..output. }} or {{ input. }} to pull each feature value from upstream data — not $.data, that's JSONPath, not this dialect. Keys must match the named model's expected feature names (see 'modelName'). Forecast models take no features — set horizon/confidenceLevel instead.
horizon	integer	—	Forecasts only: how many steps ahead to forecast. Leave it out to use the model's own setting. Accepts a {{ … }} expression. Only read for forecast models. Must be >= 1. Supports {{ … }} expressions, e.g. {{ input.weeks }}.
modelName	string	yes	The model to use. Accepts a {{ … }} expression. References a mlModelConfig.

mqtt_publish

MQTT publish node configuration. Device is optional - if present, message targets that device only.

Setting 'deviceId' targets a single device via its DeviceActor; leaving it unset broadcasts the message broker-wide via BrokerAPIActor. The output shape differs between the two modes — see this node's output schema.

Field	Type	Required	Description
deviceId	string	—	Optional device to send to, or a {{ … }} expression. When given, only that device receives the message. Accepts a {{ … }} expression. References a device. Reference an upstream node's output with {{ nodes..output. }} if the device ID comes from a prior lookup. Leave unset (or empty) to broadcast to the broker instead of targeting one device — the two modes produce differently-shaped output, see this node's output schema.
message	string	yes	The message to send, written directly or as a {{ … }} expression. Accepts a {{ … }} expression. Use {{ nodes..output. }} to build the payload from an upstream node's output, e.g. {{ nodes.build.output.payload }}. Not JSONPath — $.data is the wrong dialect here.
rpc	boolean	—	When true, wait for the device to reply. Accepts a {{ … }} expression.
topic	string	yes	The topic to publish to. Accepts a {{ … }} expression.

pdf_preflight

Run a PrepressKit preflight analysis on a component artwork file's PDF and optionally persist the report.

Typically followed by a condition node branching on nodes..output.passed (or a logic node inspecting status/errorCount) to gate approval vs. rework paths. The output carries a capped issue summary; the persisted report (reportId) holds the complete findings and document inventory.

Field	Type	Required	Description
artworkFileId	string	yes	The artwork file to check (a TypeID starting caf_), or a {{ … }} expression. Accepts a {{ … }} expression. Use {{ input.artworkFileId }} or {{ nodes..output. }} to reference the artwork dynamically — not JSONPath. The artwork must be stored as a managed cloud file; externalUri artwork is rejected.
persist	boolean	—	Save the full report on the component. Leave true so the report appears in the component's preflight history and downstream nodes can reference it by reportId. Set false only for throwaway checks — nothing is recorded and no reportId is emitted.
profile	COMMERCIAL_OFFSET | PDF_X_1A | PDF_X_3 | PDF_X_4 | PDF_X_CLAIMED	—	The standard to check against. COMMERCIAL_OFFSET is the general production-readiness check. The PDF_X_* profiles validate strict PDF/X conformance (1a/3/4); PDF_X_CLAIMED validates against whatever standard the file itself declares.

pdf_render

Renders one page of a managed PDF (artwork or file) to an image. Exactly one of artworkFileId or fileId must be specified.

Renders a single PDF page to jpeg/png/cmyk_tiff via the prepress engine. Chain from nodes that produce or reference a PDF: pass a ComponentArtworkFile id as artworkFileId, or any managed File id as fileId. Default delivery stores a managed File and outputs nodes..output.fileId; delivery: inline outputs nodes..output.imageBase64 instead.

Set exactly one of: artworkFileId, or fileId.

Field	Type	Required	Description
artworkFileId	string	—	Artwork file whose PDF to render (a TypeID starting caf_). Give either this or fileId. Accepts a {{ … }} expression. Use this when the PDF is a component's artwork. The rendered file (delivery: file) is attached to the artwork's owning component. Supports {{ … }} expressions, e.g. {{ input.artworkFileId }}.
delivery	file | inline	—	file stores the image as a file; inline returns it in the node's output. 'file' stores the image as a managed File (category PROOF) and outputs its fileId — the durable choice. 'inline' returns base64 image bytes in the node output; use inline only for small previews (low dpi or maxEdgePixels), since the bytes land in the workflow state.
dpi	integer	—	Resolution in dots per inch; 72 is the PDF's own size.
fileId	string	—	Managed file of the PDF to render (a TypeID starting fil_). Give either this or artworkFileId. Accepts a {{ … }} expression. Use this for any managed PDF that is not component artwork (e.g. an imposed sheet produced upstream). Supports {{ … }} expressions.
fileName	string	—	Name for the stored image, when delivered as a file. Defaults to render-p<page>.<extension>. Accepts a {{ … }} expression.
format	jpeg | png | cmyk_tiff	—	Image format. jpeg (image/jpeg) for compact web previews; png (image/png) for lossless RGB; cmyk_tiff (image/tiff) for a print-faithful CMYK raster. Spot inks are flattened to CMYK/RGB in all formats.
maxEdgePixels	integer	—	Optional limit on the image's longest side, in pixels; larger renders are scaled down. Set this for previews so output size stays bounded regardless of the page's physical dimensions (e.g. 2048). Leave unset to render at exactly 'dpi'.
outputFolderId	string	—	Folder for the stored image (a TypeID starting fld_), when delivered as a file. Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. Omitted → the tenant's default (control cloud) Folder. Supports {{ … }} expressions. Ignored with delivery: inline.
page	integer	—	Page to render, counting from 1.
quality	integer	—	JPEG quality from 1 to 100. Ignored for PNG and TIFF.

pdf_separations

Renders every ink plate of a managed PDF page (artwork or file) to grayscale PNGs stored as managed Files. Exactly one of artworkFileId or fileId must be specified.

Produces one grayscale-PNG managed File per ink (contone soft-proof plates, not screened output). Chain from nodes that produce or reference a PDF. Downstream nodes can for_each over nodes..output.plates to process each plate's fileId.

Set exactly one of: artworkFileId, or fileId.

Field	Type	Required	Description
artworkFileId	string	—	Artwork file whose PDF to separate (a TypeID starting caf_). Give either this or fileId. Accepts a {{ … }} expression. Use this when the PDF is a component's artwork. The stored plate files are attached to the artwork's owning component. Supports {{ … }} expressions, e.g. {{ input.artworkFileId }}.
colorants	array of string	—	Inks to render, for example Cyan or PANTONE 286 C. Leave it out to render CMYK plus every spot colour in the document. Passing explicit colorants skips the spot-color discovery analyze pass — faster when you already know the inks. An unknown colorant fails the whole node. Omit to auto-enumerate Cyan/Magenta/Yellow/Black plus every document spot ink.
dpi	integer	—	Resolution in dots per inch; 72 is the PDF's own size.
fileId	string	—	Managed file of the PDF to separate (a TypeID starting fil_). Give either this or artworkFileId. Accepts a {{ … }} expression. Use this for any managed PDF that is not component artwork (e.g. an imposed sheet produced upstream). Supports {{ … }} expressions.
fileName	string	—	Start of each stored file's name; files are named <prefix>-p<page>-<ink>.png. Accepts a {{ … }} expression.
outputFolderId	string	—	Folder for the plate images (a TypeID starting fld_). Leave it out to use your default folder. Accepts a {{ … }} expression. References a folder. A Folder is a named storage location bound to a controller filesystem, an S3/hostPath storage backend, or the control cloud store. All plates of one run land in the same Folder. Omitted → the tenant's default (control cloud) Folder. Supports {{ … }} expressions.
page	integer	—	Page to separate, counting from 1.
polarity	POSITIVE | NEGATIVE	—	Whether more ink shows as darker (POSITIVE) or lighter (NEGATIVE). positive = ink shown dark (full ink = black on white) — the Acrobat Output Preview / plate-preview convention, right for human review. negative = ink shown bright (full ink = white) — the raw ink-amount signal matching contone plate files.

producibility_audit

Run a feasibility audit against a job's production DAG using current progress data. Returns severity, findings, and at-risk items.

All threshold fields are optional and fall back to AuditThresholds.default (see each field's description) — only set the ones you want to override. Typically wired after a progresspoint.recorded-triggered path, or before a condition node that branches on nodes..output.severity or .canStillSucceed.

Field	Type	Required	Description
durationCriticalFactor	number	—	Run-time overrun that counts as critical: 1.5 means 50% over plan.
durationWarningFactor	number	—	Run-time overrun that counts as a warning: 1.2 means 20% over plan.
jobId	string	yes	The job to check, as a TypeID or a {{ … }} expression such as {{ input.jobId }}. Accepts a {{ … }} expression. Use {{ nodes..output. }} or {{ input.jobId }} to reference the job dynamically — not JSONPath. Common when this node runs after a trigger node that carries the job ID in its input/output.
wasteCriticalRatio	number	—	Waste share that counts as critical: 0.10 means 10%.
wasteWarningRatio	number	—	Waste share that counts as a warning: 0.05 means 5%.
yieldCriticalRatio	number	—	Yield below which the job counts as critical: 0.80 means 80%.
yieldMinProgressPercent	number	—	How far along, in percent, the job must be before yield is checked.
yieldWarningRatio	number	—	Yield below which the job counts as a warning: 0.90 means 90%.

regex

Performs regex match, extract, replace, or split operations on strings

Pick 'mode' by what you need: 'match' to test whether the pattern matches and collect the full matched substrings; 'extract' to pull capture groups out of each match; 'replace' to substitute matched text (set 'replacement', supports $1/$2 backreferences); 'split' to break the input on pattern matches. Each mode shapes nodes..output differently — see the output schema.

Field	Type	Required	Description
flags	string	—	Options for the pattern; i ignores upper and lower case.
input	string	yes	The text to work on, written directly or as a {{ … }} expression. Accepts a {{ … }} expression. Reference an upstream node's output with {{ nodes..output. }} — not $.data, that's JSONPath, not this dialect. E.g. {{ nodes.fetch.output.body }}.
mode	match | extract | replace | split	—	What to do with the matches.
pattern	string	yes	The regular expression.
replacement	string	—	Replace mode: the replacement text. $1, $2 and so on insert captured groups.

run_report

Field	Type	Required	Description
occurrenceKey	string	—	Inside a loop, a value that is unique for each item, so each item gets its own report run. Leave it out for a single run. Accepts a {{ … }} expression.
parameters	object	—	Values for the report's parameters; text values can use {{ … }} expressions. Accepts a {{ … }} expression.
versionId	string	yes	The published report version to run.

script

Script node configuration. Exactly one of scriptId, scriptName, or inline must be specified.

Runs an arbitrary user Lua script — nodes..output has no fixed shape; it is exactly whatever the chosen script returns. Don't assume specific output fields when wiring downstream nodes unless you've read the actual script source.

Set exactly one of: scriptId, or scriptName, or inline.

Field	Type	Required	Description
inline	string	—	Lua source to run, instead of a library script. The script's return value becomes this node's entire output — there is no fixed output shape, it's whatever the script computes. The node's input arrives as the script's first vararg. With predecessors it is a table keyed by upstream node id plus input (the workflow input) — so with one predecessor p read (...).p, not the bare output. A root node with no predecessors receives the workflow input itself. This is plain Lua on SwiftLua, not the {{ … }} expression dialect used elsewhere in node config.
scriptId	string	—	Script to run from your library, by ID (a TypeID).
scriptName	string	—	Script to run from your library, by name.
timeout	integer	—	Most time the script may take, in milliseconds. Defaults to your installation's script time limit.

set_variable

Sets workflow-level variables that can be read by subsequent nodes via variables.

Use set_variable when a value needs to be readable by name from any later node in the workflow (variables.), not just by the immediate downstream node — plain node-to-node data flow only needs nodes..output..

Field	Type	Required	Description
variables	object	yes	Object mapping variable names to literal values or {{ … }} expression templates Accepts a {{ … }} expression. Each value may be a literal or a {{ nodes..output. }} expression template — not $.data, that's JSONPath, not this dialect. Values set here are read downstream as variables. (workflow-global), not nodes..output..

split

Split node fans out a single input to all outgoing edges in parallel. No configuration required — simply connect multiple edges from this node.

Pure fan-out, no config: every outgoing edge receives this node's input unchanged (nodes..output has the same shape as the input). Required for fan-out — a plain node may have only one outgoing edge, so route parallel branches through split. branchTaken is left unset so no edge is filtered — pair it with a join (AND, wait-for-all-live) or merge (OR, tolerant) node downstream to fan back in.

sql_query

SQL query node configuration for device database queries

Runs against a device's own database via DeviceActor (distinct from microsql, which runs against the platform's reporting engine). Output is query-shaped: 'rows' contains arrays whose values match your SELECT list column-for-column, in the same order as 'columns' — not a fixed schema of field names.

Field	Type	Required	Description
bindings	array of string	—	Values for the query's parameters: literals or {{ … }} expressions. Accepts a {{ … }} expression. Each binding may be a literal or a {{ nodes..output. }} expression; bindings fill positional placeholders in 'query' in array order.
deviceId	string	yes	The device whose database to query, or a {{ … }} expression. Accepts a {{ … }} expression. References a device. Reference an upstream node's output with {{ nodes..output. }} if the device ID comes from a prior lookup.
postProcessScript	string	—	Optional script run on the device to reshape the results; {{ … }} expressions are allowed. Accepts a {{ … }} expression.
query	string	—	The SQL query; {{ … }} expressions are allowed. Prefer <bindings> for values. Accepts a {{ … }} expression. Use {{ nodes..output. }} to splice upstream values into the query text — not $.data, that's JSONPath, not this dialect. Prefer parameterized 'bindings' over splicing untrusted values directly into the query string.

switch

Switch node selects one output branch from alternatives using workflow-expression predicates

Multi-way branching: evaluates 'cases' in order and takes the first match, passing input through unchanged (nodes..output has the same shape as the input). Each case's 'name' (and 'default', if set) must match an outgoing edge's condition. For a single yes/no branch, use a condition node instead — it's simpler than a two-case switch.

Field	Type	Required	Description
cases	array of object	yes	The cases to test, in order; the first that matches wins.
default	string	—	Branch to take when no case matches. It must match an edge's when label. Only used when every case's predicate evaluates to false. Without a default, the node throws if no case matches — set this whenever the cases aren't exhaustive.

switch.cases[]

Field	Type	Required	Description
expression	string	yes	The condition for this case, for example input.value > 10. Accepts a {{ … }} expression. A bare predicate expression — unlike value/text fields, do NOT wrap it in {{ … }}. Reference an upstream node's output with nodes..output., e.g. nodes.classify.output.label == 'urgent'. Not $.data — that's JSONPath, a different dialect.
name	string	yes	The branch to take; it must match an edge's when label.

task

Create a human task and wait for resolution before continuing the workflow.

Human-in-the-loop: creates a task and pauses the workflow (nodeWaitingForSignal) until a person completes or rejects it. For AI-only outcome selection without a human, use 'agent_task' instead; for freeform LLM text/JSON generation with no task semantics, use 'agent'.

Field	Type	Required	Description
assignedTeamId	string	—	Team to assign the task to. Accepts a {{ … }} expression. References a team. Usually a literal team ID, but can be a {{ … }} expression (e.g. {{ nodes.route.output.teamId }}) to assign dynamically based on upstream output.
description	string	—	Task description, instead of the definition's. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Same {{ nodes..output. }} expression dialect as 'title' — not JSONPath. Useful for surfacing upstream context (e.g. {{ nodes.audit.output.summary }}) in the task the human sees.
priority	string	—	Task priority. Accepts a {{ … }} expression.
taskDefinitionId	string	yes	The task definition to create the task from. Accepts a {{ … }} expression. References a task_definition.
title	string	—	Task title, instead of the definition's name. Use {{ … }} to include inputs, earlier results or variables. Accepts a {{ … }} expression. Use {{ nodes..output. }} to reference an upstream node's output — not JSONPath's $.foo. E.g. {{ nodes.fetch.output.title }}. Leave unset to fall back to the task definition's own name.

transform

Transform node configuration with field mapping

Builds a new output object key-by-key from 'mapping' — unlike condition/switch's bare predicates, mapping leaves are value/text fields and need {{ … }} to pull a typed value out of an expression.

Field	Type	Required	Description
mapping	object	yes	Mapping of output keys to value specifications (expression templates, literals, or nested structures) Accepts a {{ … }} expression. Each leaf is a value/text field: a single {{ … }} span (e.g. {{ nodes.fetch.output.body }}) resolves to a typed value, plaintext without {{ }} stays a literal string, and nested objects/arrays recurse. Not $.data — that's JSONPath, a different dialect. Structural operations are filters inside the expression, e.g. {{ a | merge(b) }} or {{ input | pick('id', 'name') }}.

yaml_parse

YAML parse/encode node configuration for converting between YAML strings and structured data

Use yaml_parse when upstream output is YAML text (e.g. a config file read). Prefer json_parse for JSON strings and csv_parse for tabular CSV text — pick by the actual wire format, not by what the data represents.

Field	Type	Required	Description
mode	parse | encode	yes	parse turns YAML text into data; encode turns data into YAML text.
source	any	—	The data to convert, written directly or as a {{ … }} expression such as {{ nodes.read.output.content }}. Accepts a {{ … }} expression. Reference an upstream node's output with {{ nodes..output. }} — not $.data, that's JSONPath, not this dialect. E.g. {{ nodes.fetch.output.body }} to parse a YAML config file's contents.