rote-cli 0.12.1__tar.gz → 0.13.0__tar.gz

{rote_cli-0.12.1 → rote_cli-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rote-cli
-Version: 0.12.1
+Version: 0.13.0
 Summary: Compile AI agent skills into cheap, fast, deterministic pipelines that run without an LLM in the loop
 Project-URL: Homepage, https://roteskills.com
 Project-URL: Repository, https://github.com/trevhud/rote
@@ -434,9 +434,8 @@ plain-Python subprocess); those need a Node toolchain / Docker, so they
 run locally with `pytest tests/ -m slow`, not in CI.
 
 Known gaps: the extracted modules are `NotImplementedError` stubs
-you fill in with real API-client code, a Restate adapter is planned, and
-`fan_out` nodes currently receive the whole upstream list in one
-invocation (per-element dispatch is a planned enhancement). Published on
+you fill in with real API-client code, and a Restate adapter is planned.
+Published on
 PyPI as [`rote-cli`](https://pypi.org/project/rote-cli/) via tag-driven
 Trusted Publishing ([docs/releasing.md](docs/releasing.md)).
 
@@ -517,9 +516,7 @@ In rough priority order:
    Cloudflare; a separate node makes the short-circuit uniform.
 3. **More example skills**: BDR is one shape; research-heavy,
    retrieval-heavy, and code-review skills stress the IR differently.
-4. **`fan_out` per-element dispatch**: currently the whole upstream list
-   arrives in one invocation.
-5. **The compiler compiling itself**: `rote-compile` is a SKILL.md;
+4. **The compiler compiling itself**: `rote-compile` is a SKILL.md;
    pointing `rote compile` at it should crystallize its rubric-grade
    pieces and leave only the genuinely fuzzy judgments in the loop.
 

{rote_cli-0.12.1 → rote_cli-0.13.0}/README.md

@@ -378,9 +378,8 @@ plain-Python subprocess); those need a Node toolchain / Docker, so they
 run locally with `pytest tests/ -m slow`, not in CI.
 
 Known gaps: the extracted modules are `NotImplementedError` stubs
-you fill in with real API-client code, a Restate adapter is planned, and
-`fan_out` nodes currently receive the whole upstream list in one
-invocation (per-element dispatch is a planned enhancement). Published on
+you fill in with real API-client code, and a Restate adapter is planned.
+Published on
 PyPI as [`rote-cli`](https://pypi.org/project/rote-cli/) via tag-driven
 Trusted Publishing ([docs/releasing.md](docs/releasing.md)).
 
@@ -461,9 +460,7 @@ In rough priority order:
    Cloudflare; a separate node makes the short-circuit uniform.
 3. **More example skills**: BDR is one shape; research-heavy,
    retrieval-heavy, and code-review skills stress the IR differently.
-4. **`fan_out` per-element dispatch**: currently the whole upstream list
-   arrives in one invocation.
-5. **The compiler compiling itself**: `rote-compile` is a SKILL.md;
+4. **The compiler compiling itself**: `rote-compile` is a SKILL.md;
    pointing `rote compile` at it should crystallize its rubric-grade
    pieces and leave only the genuinely fuzzy judgments in the loop.
 

{rote_cli-0.12.1 → rote_cli-0.13.0}/pyproject.toml

@@ -138,7 +138,11 @@ extend-exclude = ["examples"]
 select = ["E", "F", "I", "UP", "B", "SIM"]
 
 [tool.pytest.ini_options]
-addopts = "-m 'not slow'"
+# -rs: always print the REASON for every skip. A conditional skip whose
+# condition silently becomes permanent is invisible behind a bare
+# "1 skipped" count — that is how `test_per_tool_override_changes_payload`
+# went from a real test to dead weight without anyone noticing.
+addopts = "-m 'not slow' -rs"
 markers = [
     "slow: tests that need an external toolchain (Node/npm/tsc) or take >5s. Run with `pytest -m slow` to include.",
 ]

{rote_cli-0.12.1 → rote_cli-0.13.0}/src/rote/__init__.py

@@ -1,3 +1,3 @@
 """rote — compile fuzzy AI skills into deterministic workflows."""
 
-__version__ = "0.12.1"
+__version__ = "0.13.0"

{rote_cli-0.12.1 → rote_cli-0.13.0}/src/rote/adapters/_common.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import hashlib
 import json
 import re
+from collections.abc import Sequence
 from pathlib import Path
 
 from rote.ir import Node, NodeKind, Pipeline, parse_input_ref
@@ -305,12 +306,20 @@ def ir_duration_to_human(s: str) -> str:
     Cloudflare's step config accepts directly. Strings that don't match
     the IR shorthand pattern are passed through unchanged (they're
     assumed to already be in an acceptable form).
+
+    A value of exactly 1 is singularized ('1 hour', not '1 hours').
+    Cloudflare's ``WorkflowDuration`` accepts either spelling, so this
+    is legibility rather than correctness — but emitted code is read by
+    humans, and '1 hours' in a reviewed artifact looks like a bug.
     """
     s = s.strip()
     m = _IR_DURATION_RE.fullmatch(s)
     if not m:
         return s
-    return f"{m.group(1)} {_UNIT_TO_HUMAN[m.group(2)]}"
+    value, unit = m.group(1), _UNIT_TO_HUMAN[m.group(2)]
+    if float(value) == 1:
+        unit = unit.removesuffix("s")
+    return f"{value} {unit}"
 
 
 _UNIT_TO_SECONDS = {
@@ -422,6 +431,72 @@ def check_input_refs_available(node: Node, available: set[str]) -> None:
             )
 
 
+def fan_out_element_param(node: Node, pipeline: Pipeline) -> str:
+    """Which ``inputs`` param carries the list a ``fan_out`` node fans over.
+
+    Every other input is shared verbatim by all invocations. Which param
+    is the list, in precedence order:
+
+    1. the param bound to the source of an incoming ``fan_out: true``
+       edge (the IR's explicit marker);
+    2. else the param bound to a node with any incoming edge — inputs
+       may also reference nodes *without* an edge (shared context, e.g.
+       BDR's ``intel``), which is what makes "the only node-bound
+       param" too naive;
+    3. else the only node-bound param.
+
+    Ambiguity after all three is an emit-time error, never a guess:
+    dispatching over the wrong list would silently judge the wrong
+    things.
+
+    This lives in the language-neutral common module because the answer
+    is a property of the IR, not of the target language — every adapter
+    must fan over the *same* input or the same pipeline would mean
+    different things on different runtimes.
+    """
+    if not node.inputs:
+        raise ValueError(f"fan_out node {node.id!r} has no inputs: nothing to fan over")
+    node_bound = {
+        param: parsed.node_id
+        for param, ref in node.inputs.items()
+        if (parsed := parse_input_ref(ref)).node_id is not None
+    }
+    edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id}
+    fan_edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id and e.fan_out}
+
+    # The tiers are tried narrowest-first, but the ORDER is provably
+    # unobservable: fan_edge_sources ⊆ edge_sources by construction, so
+    # matching(fan) ⊆ matching(edge), and a tier is accepted only when it
+    # singles out exactly one param. If the broader tier singles one out,
+    # it is necessarily the same one. (Mutation testing flags swapping
+    # these as a surviving mutant — it is equivalent, not a test gap.)
+    # The tiers still earn their place: they express which signal the
+    # author gave, and tier 2 is what handles a marker pointing at a node
+    # no input references.
+    for sources in (fan_edge_sources, edge_sources):
+        matching = sorted(p for p, src in node_bound.items() if src in sources)
+        if len(matching) == 1:
+            return matching[0]
+    if len(node_bound) != 1:
+        raise ValueError(
+            f"fan_out node {node.id!r}: cannot identify the element param — "
+            f"node-bound inputs {sorted(node_bound)} and incoming edges "
+            f"{sorted(edge_sources)} don't single one out; mark the list edge "
+            f"with `fan_out: true`"
+        )
+    return next(iter(node_bound))
+
+
+def fan_out_nodes(wave: Sequence[Node]) -> tuple[list[Node], list[Node]]:
+    """Split a wave into ``(fan_out_nodes, plain_nodes)``, order preserved.
+
+    A ``fan_out`` node dispatches once per element of its bound list, so
+    it never shares the single/parallel payload shapes an adapter emits
+    for plain nodes.
+    """
+    return [n for n in wave if n.fan_out], [n for n in wave if not n.fan_out]
+
+
 # ───────── MCP-capability refusal ─────────
 
 

{rote_cli-0.12.1 → rote_cli-0.13.0}/src/rote/adapters/_py_common.py

@@ -30,6 +30,7 @@ from rote.adapters._common import (
     DEFAULT_AGENT_MAX_ITERATIONS,
     EmitWriter,
     _to_pascal_case,
+    fan_out_element_param,
     safe_docstring_line,
 )
 from rote.ir import LLMSignature, Node, NodeKind, Pipeline, parse_input_ref
@@ -93,52 +94,65 @@ def _payload_literal(node: Node, indent: str) -> str:
     return "\n".join(lines)
 
 
-def fan_out_binding(node: Node, pipeline: Pipeline) -> tuple[str, str, dict[str, str]]:
-    """``(element_param, list_expr, scalar_exprs)`` for a ``fan_out`` node.
+_FAN_OUT_LIST_HELPER_PY = '''\
+def _fan_out_list(value: object, node_id: str, ref: str) -> list:
+    """The list a fan_out node dispatches over.
 
-    The element parameter is the one bound to the upstream *list* the
-    node fans over (ir-schema.md); every other input is shared verbatim
-    by all invocations. Which param that is, in precedence order:
-
-    1. the param bound to the source of an incoming ``fan_out: true``
-       edge (the IR's explicit marker);
-    2. else the param bound to a node with any incoming edge — inputs
-       may also reference nodes *without* an edge (shared context, e.g.
-       BDR's ``intel``), which is what makes "the only node-bound
-       param" too naive;
-    3. else the only node-bound param.
-
-    Ambiguity after all three is an emit-time error, never a guess:
-    dispatching over the wrong list would silently judge the wrong
-    things.
+    Iterating a missing key raises "'NoneType' object is not iterable",
+    which names neither the node nor the reference — in generated code
+    that is close to undebuggable, and the cause is almost always an
+    upstream node that didn't return the key the IR says it does. The
+    TypeScript runtimes emit the same guard (`fanOutList`), so a missing
+    key reports identically on every target.
     """
-    if not node.inputs:
-        raise ValueError(f"fan_out node {node.id!r} has no inputs: nothing to fan over")
-    node_bound = {
-        param: parsed.node_id
-        for param, ref in node.inputs.items()
-        if (parsed := parse_input_ref(ref)).node_id is not None
-    }
-    edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id}
-    fan_edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id and e.fan_out}
-
-    for sources in (fan_edge_sources, edge_sources):
-        matching = sorted(p for p, src in node_bound.items() if src in sources)
-        if len(matching) == 1:
-            element_param = matching[0]
-            break
-    else:
-        if len(node_bound) != 1:
-            raise ValueError(
-                f"fan_out node {node.id!r}: cannot identify the element param — "
-                f"node-bound inputs {sorted(node_bound)} and incoming edges "
-                f"{sorted(edge_sources)} don't single one out; mark the list edge "
-                f"with `fan_out: true`"
-            )
-        element_param = next(iter(node_bound))
+    if not isinstance(value, list):
+        raise TypeError(
+            f"fan_out node {node_id!r} expected a list from {ref!r}, got "
+            f"{type(value).__name__}. The upstream node must return that "
+            f"key as a list."
+        )
+    return value
+'''
+
+
+def fan_out_list_helper() -> str:
+    """The ``_fan_out_list`` guard emitted into Python runtimes that fan out.
 
+    Behavioral emitted code, like ``_serialize``: if the runtimes' guards
+    drift, the same broken pipeline reports differently per target.
+    """
+    return _FAN_OUT_LIST_HELPER_PY
+
+
+def fan_out_binding(
+    node: Node, pipeline: Pipeline, indent: str = ""
+) -> tuple[str, str, dict[str, str]]:
+    """``(element_param, list_expr, scalar_exprs)`` for a ``fan_out`` node.
+
+    The Python rendering of :func:`fan_out_element_param` — which input
+    is the list is a language-neutral property of the IR, so it is
+    resolved there and only the expressions are built here.
+
+    ``indent`` is the column the ``_fan_out_list(`` token sits at; the
+    guard call wraps against it rather than running long on one line.
+    """
+    element_param = fan_out_element_param(node, pipeline)
+    # Narrowing only: fan_out_element_param raises on a node with no
+    # inputs, so reaching here means there is something to fan over.
+    assert node.inputs is not None
     scalars = {p: _ref_to_python_expr(r) for p, r in node.inputs.items() if p != element_param}
-    return element_param, _ref_to_python_expr(node.inputs[element_param]), scalars
+    ref = node.inputs[element_param]
+    inner = indent + "    "
+    # json.dumps, not !r: emitted Python uses double quotes throughout
+    # (the repo's ruff-format style), same as _py_literal.
+    list_expr = (
+        "_fan_out_list(\n"
+        f"{inner}{_ref_to_python_expr(ref)},\n"
+        f"{inner}{json.dumps(node.id)},\n"
+        f"{inner}{json.dumps(ref)},\n"
+        f"{indent})"
+    )
+    return element_param, list_expr, scalars
 
 
 # ───────── JSON Schema → Pydantic source ─────────

{rote_cli-0.12.1 → rote_cli-0.13.0}/src/rote/adapters/_ts_common.py

@@ -40,6 +40,7 @@ from rote.adapters._common import (
     DEFAULT_AGENT_MAX_ITERATIONS,
     _to_camel_case,
     _to_pascal_case,
+    fan_out_element_param,
     safe_block_comment_line,
 )
 from rote.ir import LLMSignature, Node, NodeKind, Pipeline, parse_input_ref
@@ -593,6 +594,67 @@ def payload_ts_literal(node: Node, indent: str) -> str:
     return "\n".join(lines)
 
 
+FAN_OUT_LIST_HELPER_TS = """\
+/** The list a fan_out node dispatches over.
+ *
+ * A bare `.map()` on a missing key fails with "Cannot read properties
+ * of undefined (reading 'map')", which names neither the node nor the
+ * reference — in generated code that is close to undebuggable, and the
+ * cause is almost always an upstream node that didn't return the key
+ * the IR says it does. One call turns that into an actionable message.
+ * Found by running it: the first live fan_out run hit exactly this. */
+function fanOutList(value: unknown, nodeId: string, ref: string): unknown[] {
+    if (!Array.isArray(value)) {
+        const got = value === null ? "null" : typeof value;
+        throw new Error(
+            `fan_out node '${nodeId}' expected an array from '${ref}', got ${got}. ` +
+                `The upstream node must return that key as a list.`,
+        );
+    }
+    return value;
+}
+"""
+
+
+def fan_out_ts_binding(node: Node, pipeline: Pipeline, indent: str = "") -> tuple[str, str]:
+    """``(payload_literal, list_expr)`` for a ``fan_out`` node in TypeScript.
+
+    The payload is a one-line object binding the element param to the
+    loop variable ``_item`` and every other input to its shared
+    expression — the TS rendering of
+    :func:`rote.adapters._common.fan_out_element_param`, which decides
+    *which* input is the list.
+
+    The list expression goes through ``fanOutList``
+    (:data:`FAN_OUT_LIST_HELPER_TS`), which both narrows the type — node
+    results are ``Record<string, unknown>`` or ``never``, so neither
+    ``.map`` nor ``for…of`` compiles against them — and reports a
+    missing upstream key by node id instead of as a bare TypeError.
+
+    ``indent`` is the column the ``fanOutList(`` token sits at. The call
+    wraps against it instead of running to ~180 characters on one line —
+    emitted code is meant to be read and reviewed.
+    """
+    element_param = fan_out_element_param(node, pipeline)
+    entries = []
+    for param, input_ref in node.inputs.items() if node.inputs else []:
+        key = param if _TS_IDENT_RE.fullmatch(param) else json.dumps(param)
+        value = "_item" if param == element_param else ref_to_ts_expr(input_ref)
+        entries.append(f"{key}: {value}")
+    payload = "{ " + ", ".join(entries) + " }"
+    assert node.inputs is not None
+    ref = node.inputs[element_param]
+    inner = indent + "    "
+    list_expr = (
+        "fanOutList(\n"
+        f"{inner}{ref_to_ts_expr(ref)},\n"
+        f"{inner}{json.dumps(node.id)},\n"
+        f"{inner}{json.dumps(ref)},\n"
+        f"{indent})"
+    )
+    return payload, list_expr
+
+
 # ───────── Pipeline queries ─────────
 
 

{rote_cli-0.12.1 → rote_cli-0.13.0}/src/rote/adapters/cloudflare.py

@@ -42,6 +42,7 @@ from rote.adapters._common import (
     _pipeline_hash,
     _to_camel_case,
     check_input_refs_available,
+    fan_out_nodes,
     pipeline_identity,
     safe_block_comment_line,
     workflow_class_name,
@@ -52,6 +53,7 @@ from rote.adapters._common import (
 from rote.adapters._ts_common import (
     AI_UTILS_NPM_VERSION,
     ANTHROPIC_SDK_NPM_VERSION,
+    FAN_OUT_LIST_HELPER_TS,
     MCP_SDK_NPM_VERSION,
     ROTE_INFERENCE_HELPER_TS,
     ROTE_MCP_WORKERS_HELPER_TS,
@@ -60,6 +62,7 @@ from rote.adapters._ts_common import (
     emit_agent_loop_module,
     emit_ts_signature_module,
     emit_workers_mcp_call_module,
+    fan_out_ts_binding,
     llm_clients,
     mcp_backed_nodes,
     module_imports,
@@ -181,7 +184,12 @@ def auth_event_type(server: str) -> str:
 
 
 def _emit_step_call_mcp_parkable(
-    node: Node, cfg: CloudflareAdapterConfig, *, pipeline: Pipeline
+    node: Node,
+    cfg: CloudflareAdapterConfig,
+    *,
+    pipeline: Pipeline,
+    payload: str | None = None,
+    name_suffix: str = "",
 ) -> str:
     """MCP-backed dispatch: auth failures park the instance durably.
 
@@ -194,10 +202,15 @@ def _emit_step_call_mcp_parkable(
     behavior; and events sent before the wait starts are buffered
     per-instance, so `rote mcp release` can blast every non-terminal
     instance without a race.
+
+    ``payload`` and ``name_suffix`` are supplied by the fan_out path:
+    one element per call, and a step-name fragment (``[${_index}]``)
+    that keeps each element's step name unique within the instance.
     """
     fn_name = _to_camel_case(node.id)
     config = _step_config_literal(node, cfg)
-    payload = payload_ts_literal(node, indent=" " * 24)
+    if payload is None:
+        payload = payload_ts_literal(node, indent=" " * 24)
     nid = node.id
     if node.mcp is not None:
         # One binding, one server: the release event is known at emit time.
@@ -220,6 +233,10 @@ def _emit_step_call_mcp_parkable(
             "        // so `rote mcp release <server>` releases the right instances.\n"
         )
     label = "agent loop" if node.mcp is None else "MCP-backed"
+    # A fan_out element's step names carry its index; every step name
+    # must be unique within an instance or the elements collapse onto
+    # one cached step.
+    first_name = f"`{nid}{name_suffix}`" if name_suffix else json.dumps(nid)
     return (
         f"        // ─── {nid} ({label}): park on dead credentials ───\n"
         f"{release_hint}"
@@ -228,8 +245,8 @@ def _emit_step_call_mcp_parkable(
         f"            try {{\n"
         f"                {nid}_result = (await step.do(\n"
         f"                    {nid}_attempt === 0\n"
-        f"                        ? {json.dumps(nid)}\n"
-        f"                        : `{nid} (auth retry ${{{nid}_attempt}})`,\n"
+        f"                        ? {first_name}\n"
+        f"                        : `{nid}{name_suffix} (auth retry ${{{nid}_attempt}})`,\n"
         f"                    {config},\n"
         f"                    async () => {{\n"
         f"                        try {{\n"
@@ -252,7 +269,7 @@ def _emit_step_call_mcp_parkable(
         f"                // consecutive failure. Fresh step names per attempt.\n"
         f"                if ({nid}_attempt % 2 === 1) {{\n"
         f"                    await step.waitForEvent<any>(\n"
-        f"                        `{nid} auth wait ${{{nid}_attempt}}`,\n"
+        f"                        `{nid}{name_suffix} auth wait ${{{nid}_attempt}}`,\n"
         f'                        {{ type: {event_expr}, timeout: "30 days" }},\n'
         f"                    );\n"
         f"                }}\n"
@@ -341,6 +358,67 @@ def _emit_parallel_step_calls(nodes: list[Node], cfg: CloudflareAdapterConfig) -
     return "\n".join(lines) + "\n"
 
 
+def _emit_fan_out_parallel(node: Node, cfg: CloudflareAdapterConfig, *, pipeline: Pipeline) -> str:
+    """Emit a plain ``fan_out`` node as one ``step.do`` per element.
+
+    Same ``Promise.all`` reasoning as a parallel wave: it is
+    Cloudflare's documented concurrency primitive, each element persists
+    under its own step name, and a rejection means that element already
+    exhausted its own retries.
+
+    Step names are index-suffixed. Cloudflare caches a step's result by
+    name, so reusing one name for every element would return the first
+    element's result for all of them — the failure would look like a
+    correct run with suspiciously uniform output.
+    """
+    payload, list_expr = fan_out_ts_binding(node, pipeline, indent=" " * 12)
+    pass_env = node.kind in (NodeKind.LLM_JUDGE, NodeKind.AGENT_LOOP)
+    args = f"{payload}, this.env" if pass_env else payload
+    return "\n".join(
+        [
+            f"        // fan_out: {node.id} runs once per element of the bound list,",
+            "        // each as its own durable step (names are index-suffixed —",
+            "        // Cloudflare caches step results by name).",
+            f"        const {node.id}_result = await Promise.all(",
+            f"            {list_expr}.map((_item, _index) =>",
+            "                step.do(",
+            f"                    `{node.id}[${{_index}}]`,",
+            f"                    {_step_config_literal(node, cfg)},",
+            f"                    async () => {_to_camel_case(node.id)}({args}),",
+            "                ),",
+            "            ),",
+            "        );",
+        ]
+    )
+
+
+def _emit_fan_out_parkable(node: Node, cfg: CloudflareAdapterConfig, *, pipeline: Pipeline) -> str:
+    """Emit a parkable ``fan_out`` node: one element per iteration.
+
+    Sequential, for the same reason a parkable step leaves its parallel
+    wave — it can suspend on ``waitForEvent``, whose behavior inside a
+    promise combinator is undocumented and whose timeout *throws*, which
+    would reject every other element.
+    """
+    payload, list_expr = fan_out_ts_binding(node, pipeline, indent=" " * 8)
+    inner = _emit_step_call_mcp_parkable(
+        node, cfg, pipeline=pipeline, payload=payload, name_suffix="[${_index}]"
+    )
+    return "\n".join(
+        [
+            f"        // fan_out: {node.id} runs once per element of the bound list.",
+            "        // Parkable steps stay sequential — a waitForEvent inside a",
+            "        // promise combinator would reject every sibling on timeout.",
+            f"        const {node.id}_results: Record<string, unknown>[] = [];",
+            f"        for (const [_index, _item] of {list_expr}.entries()) {{",
+            textwrap.indent(inner.rstrip("\n"), "    "),
+            f"            {node.id}_results.push({node.id}_result);",
+            "        }",
+            f"        const {node.id}_result = {node.id}_results;",
+        ]
+    )
+
+
 def _emit_hitl_gate(node: Node, cfg: CloudflareAdapterConfig) -> str:
     assert node.signal is not None
     _validate_signal_name(node.signal, node.id)
@@ -508,7 +586,14 @@ def emit_workflow(pipeline: Pipeline, cfg: CloudflareAdapterConfig | None = None
         parkable = [n for n in wave if _is_parkable(n)]
         plain = [n for n in wave if n.kind is not NodeKind.HITL_GATE and not _is_parkable(n)]
 
-        for node in plain + parkable:
+        # fan_out nodes dispatch once per element of their bound list —
+        # they never share the single/parallel payload shapes below, but
+        # they keep the parkable/plain split (a parkable fan_out runs its
+        # elements sequentially, for the same waitForEvent reason).
+        fanned_parkable, parkable = fan_out_nodes(parkable)
+        fanned_plain, plain = fan_out_nodes(plain)
+
+        for node in plain + parkable + fanned_plain + fanned_parkable:
             check_input_refs_available(node, available)
 
         if len(plain) > 1:
@@ -527,6 +612,12 @@ def emit_workflow(pipeline: Pipeline, cfg: CloudflareAdapterConfig | None = None
                 _emit_step_call_mcp_parkable(node, cfg, pipeline=pipeline).rstrip("\n")
             )
 
+        for node in fanned_plain:
+            body_lines.append(_emit_fan_out_parallel(node, cfg, pipeline=pipeline))
+
+        for node in fanned_parkable:
+            body_lines.append(_emit_fan_out_parkable(node, cfg, pipeline=pipeline))
+
         for node in gates:
             body_lines.append(_emit_hitl_gate(node, cfg).rstrip("\n"))
 
@@ -552,6 +643,8 @@ def emit_workflow(pipeline: Pipeline, cfg: CloudflareAdapterConfig | None = None
     )
 
     helper_block = f"{_STEP_NEEDS_AUTH_HELPER}\n" if parks_on_auth else ""
+    if any(n.fan_out for n in pipeline.nodes):
+        helper_block += f"{FAN_OUT_LIST_HELPER_TS}\n"
 
     return header + imports + "\n" + env_block + helper_block + class_block
 

{rote_cli-0.12.1 → rote_cli-0.13.0}/src/rote/adapters/dbos.py

@@ -88,6 +88,7 @@ from rote.adapters._py_common import (
     _signature_path_parts,
     agent_loop_call,
     fan_out_binding,
+    fan_out_list_helper,
     resolve_extracted_source,
     serialize_helper,
     write_signature_package,
@@ -521,7 +522,7 @@ def _emit_workflow_body(pipeline: Pipeline, cfg: DbosAdapterConfig) -> str:
                     lines.append(f"    {node.id}_result = {node.id}_handle.get_result()")
 
         for node in fan_out_nodes:
-            element_param, list_expr, scalars = fan_out_binding(node, pipeline)
+            element_param, list_expr, scalars = fan_out_binding(node, pipeline, indent=" " * 8)
             payload_items = "".join(
                 f', "{param}": {expr}' for param, expr in sorted(scalars.items())
             )
@@ -660,6 +661,9 @@ def emit_main(pipeline: Pipeline, cfg: DbosAdapterConfig | None = None) -> str:
         "    portable across the system database."
     )
 
+    if any(n.fan_out for n in pipeline.nodes):
+        header += "\n\n" + fan_out_list_helper()
+
     if mcp_backed:
         header += "\n\n" + textwrap.dedent(
             '''\