`mock<IWorkflowExecutionDataProcess>({ workflowData })` deep-proxies the object
it wraps. The proxy leaves auto-created mock functions on the shared fixture
node, so `node.disabled` reads as a function in every test that runs after it.
Any code that reads a node flag then sees a truthy value. The sub-workflow
progress tests are the first to do so, and they counted zero reachable nodes.
Rebuild the node in the shared `beforeEach`, next to the existing `settings`
reset.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Use `--spacing--5xs` for the arc thickness instead of a hardcoded 2px. The
token is the same 2px, and the chat package's override of it is scoped to
`.n8n-chat`, so the arc is unchanged.
Correct the push payload docs. `currentNodeIndex` counts the distinct child
nodes reached; it is not an execution-order index, and it parks while a loop
iterates. `totalNodes` is an upper bound, and the editor no longer renders it
as a denominator.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The progress stream is off unless `N8N_ENV_FEAT_SUBWORKFLOW_PROGRESS` is set,
so the feature can ship to master dark and be enabled per instance.
Gated at hook registration rather than at emit time, so with the flag off a
sub-execution registers no extra handlers, walks no graph and sends no pushes.
The `N8N_ENV_FEAT_` prefix also exposes the same switch to the editor through
the env-feature-flag channel.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
A conic gradient's 0deg already sits at 12 o'clock and advances clockwise, so the
`from -90deg` offset — an SVG/canvas convention, where 0deg is 3 o'clock — started
the arc at 9 o'clock and swept it the wrong way. At 25% it filled the upper-left
quadrant instead of the upper-right, and at 90% the remaining gap sat at the
bottom-left rather than just short of the top, losing the "almost closed" read.
Found by pinning --node--progress--fraction to fixed values against a running
instance with the transition disabled. The unit tests assert the fraction value,
which was right all along — only where the ink landed was wrong.
Co-Authored-By: Claude <noreply@anthropic.com>
Two costs that scaled with the number of sub-executions rather than with
anything visible, both of which a parent loop over a few hundred items would
have multiplied.
The progress arc no longer trickles between steps. The trickle needed a
1s interval, and because the composable was called unconditionally, every
default node on the canvas ran one whether a sub-workflow was executing or
not. The arc's own reason for existing was weak once the point was granted
that the rotating running border already shows the node is alive, so this
drops the behaviour rather than gating the timer.
The reachable-node count is now computed on first emit instead of at hook
registration, and node events return early when no parent pushRef resolves.
Executions with no editor session — the overwhelming majority — no longer
walk the child workflow's graph at all. Nodes are still tallied before that
bail-out, so an editor attaching mid-run sees a truthful count.
Co-Authored-By: Claude <noreply@anthropic.com>
Replaces the in-body progress bar with a determinate arc on the node's own
border, plus a step count in the status-icon slot that gives way to the success
checkmark on finish. The running child node name reuses the subtitle line, so
nothing shifts as the child advances.
The arc is drawn on its own layer rather than sharing the running halo's ring:
compositing the two there made the shimmer's bright head vanish behind the solid
arc and read as a flicker. It trickles between steps, bounded to half a step, so
a slow child node doesn't read as a stalled bar, and stops short of a full turn
so only completion closes the loop.
The step count carries no denominator. Nodes reached is knowable, the total is
only estimated, so the count is reported unclamped and the estimate is used just
to scale the arc. That total now counts only nodes reachable from the
sub-workflow's entry point (plus their AI/tool sub-nodes), which stops leftover
trigger branches and disconnected islands from scaling the arc down.
Co-Authored-By: Claude <noreply@anthropic.com>
`clear` deleted the progress entry using only the parent execution id and node
name, while `updateProgress` already ignored events from a superseded child.
That asymmetry meant a late `subworkflowExecutionFinished` from a previous child
could wipe the overlay of a newer one that is still running.
Pass the child execution id through from the push handler and only clear when it
matches the stored entry, mirroring the existing guard in `updateProgress`. The
id is optional so a caller with no specific child (such as a reset) still clears
unconditionally.
Co-Authored-By: Claude <noreply@anthropic.com>
The progress stream forwarded from a sub-workflow to the parent's canvas was
effectively unthrottled. The previous guard only suppressed consecutive
`nodeExecuteBefore` events for the same node with no intervening
`nodeExecuteAfter` — a sequence the engine does not produce — so steady state
was two messages per child node execution. Each of those is a pubsub broadcast
in scaling mode and a full canvas re-map in the editor, so a looping child
workflow could emit thousands of messages for one run.
Replace it with a trailing-edge throttle: the leading edge still emits
immediately so the overlay appears at once, subsequent events inside the window
coalesce into a single pending snapshot, and a trailing timer sends the latest
state. The overlay only renders the running node name, an "X / Y" counter and a
bar, so intermediate states are disposable. A 200-iteration child now emits two
messages instead of ~400. `workflowExecuteAfter` drops any pending snapshot,
since the finished event clears the overlay outright.
Also stop forwarding progress for nested sub-workflows. Only the workflow open
on the canvas renders the overlay, so a grandchild's parent node is not on
screen and the editor discarded those messages anyway. Resolving the direct
parent's pushRef instead of walking the whole ancestor chain removes that
wasted traffic and simplifies the lookup.
Tests now exercise real engine before/after sequences rather than the synthetic
double-`nodeExecuteBefore` the old throttle keyed on.
Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: n8n-cat-bot[bot] <n8n-cat-bot[bot]@users.noreply.github.com>
Co-authored-by: Jonathan <jon@n8n.io>
Co-authored-by: Jon <jonathan.bennetts@gmail.com>
