graphddb-runtime 1.0.9__tar.gz → 1.1.0__tar.gz

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.0.9
+Version: 1.1.0
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: boto3>=1.26
-Requires-Dist: behavior-contracts==0.7.3
+Requires-Dist: behavior-contracts==0.8.2
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/graphddb_runtime/behavior_exec.py

@@ -144,12 +144,119 @@ def _node_parts(node: Mapping[str, Any]) -> Tuple[str, Optional[Mapping[str, Any
 def _relation_path_of(node_id: str) -> Tuple[str, ...]:
     """``ctx.relationPath`` for a node — the non-``items`` tokens of its id
     (the id IS the old ``resultPath`` sans ``$.``; ``root`` → ``()``). Identical
-    to the old :meth:`GraphDDBRuntime._relation_path`."""
+    to the old :meth:`GraphDDBRuntime._relation_path`. Used ONLY for the LEGACY
+    imperative id scheme (dotted result-path ids); a genuinely declarative read
+    (issue #350) uses :func:`_relation_paths_from_output` instead."""
     if node_id == "root":
         return ()
     return tuple(t for t in node_id.split(".") if t != "items")
 
 
+def _relation_paths_from_output(component: Mapping[str, Any]) -> Dict[str, Tuple[str, ...]]:
+    """Map each body-node id → its ``relation_path`` from the component ``output``
+    (id-scheme-INDEPENDENT — issue #350). A GENUINELY declarative read
+    (``compileBehaviors``) has recorder-scan node ids (``n0``/``n1``) that no longer
+    encode the relation path, but its ``output`` Φ merge names each ROOT-LEVEL
+    relation by property (``{obj:{root:{ref:[<rootId>]}, members:{ref:[<n1>]}, …}}``),
+    so the relation path of node ``<n1>`` is ``("members",)`` and the root
+    (``root`` key) is ``()``. Falls back to the legacy id-derived path for a node not
+    named in the output (defensive).
+
+    Since #350 each root-level relation is authored as a ``when``-gate, so its
+    output ref is the Φ CONDNODE (``{ref:[<cond>]}``) whose ``then`` branch refs the
+    gated READ node. This resolver follows the cond ``then`` ref so the relation
+    path lands on the READ node (the one whose handler carries a ``ctx``), matching
+    the pre-#350 behavior where the relation Query directly received ``("members",)``."""
+    out = component.get("output", {})
+    by_id = {n["id"]: n for n in component.get("body", [])}
+
+    def _read_node_id(node_id: str) -> str:
+        # Resolve a Φ ref to the READ node it names — through a CondNode gate
+        # (`then: {ref:[<readNode>]}`), so the relation path lands on the handler node.
+        node = by_id.get(node_id)
+        if node is not None and "cond" in node:
+            then = node["cond"].get("then")
+            then_ref = then.get("ref") if isinstance(then, Mapping) else None
+            if isinstance(then_ref, list) and then_ref:
+                return _read_node_id(then_ref[0])
+        return node_id
+
+    paths: Dict[str, Tuple[str, ...]] = {}
+    obj = out.get("obj") if isinstance(out, Mapping) else None
+    if obj is None:
+        # A single-node read (`{ref:[id]}`) — the sole node is the root.
+        ref = out.get("ref") if isinstance(out, Mapping) else None
+        if isinstance(ref, list) and ref:
+            paths[_read_node_id(ref[0])] = ()
+        return paths
+    # Per root-level relation, the CONNECTION node (the gated Query the cursor names)
+    # gets `(prop,)`; carry the connection→prop mapping so the depth-2+ chain maps that
+    # ride that connection's elements derive their path from it (below).
+    conn_prop: Dict[str, str] = {}
+    for prop, spec_node in obj.items():
+        ref = spec_node.get("ref") if isinstance(spec_node, Mapping) else None
+        # A chained connection carries `{obj:{cursor:{ref:[connId]},…}}`; its id is
+        # the cursor ref head. A plain relation / root is a bare `{ref:[id]}`.
+        if ref is None and isinstance(spec_node, Mapping) and "obj" in spec_node:
+            cur = spec_node["obj"].get("cursor", {})
+            ref = cur.get("ref") if isinstance(cur, Mapping) else None
+        if isinstance(ref, list) and ref:
+            read_id = _read_node_id(ref[0])
+            paths[read_id] = () if prop == "root" else (prop,)
+            if prop != "root":
+                conn_prop[read_id] = prop
+
+    # Depth-2+ chain maps (issue #350): a `.map(cb,{into})` node rides a connection's
+    # elements. Its relation path is the CONNECTION's path + the ordered `into` keys of
+    # its map-ancestors (id-scheme-INDEPENDENT — derived from `map.parent`/`map.into`,
+    # NOT the old dotted node id). `group` (parent = the connection gate) →
+    # `(groups, group)`; `permissions` (parent = the `group` map) →
+    # `(groups, group, permissions)`.
+    for node in component.get("body", []):
+        m = node.get("map") if isinstance(node, Mapping) else None
+        if not isinstance(m, Mapping) or "into" not in m:
+            continue
+        # Walk map-ancestors, collecting `into` keys outermost→this, until the chain
+        # reaches a non-map parent (the connection / its gate). Resolve that base node
+        # (through a cond gate) to a node with a known relation path.
+        intos: List[str] = []
+        cur_node: Optional[Mapping[str, Any]] = node
+        base_path: Optional[Tuple[str, ...]] = None
+        seen: set = set()
+        while isinstance(cur_node, Mapping):
+            cm = cur_node.get("map")
+            if isinstance(cm, Mapping) and "into" in cm:
+                intos.append(cm["into"])
+                over = cm.get("over", {})
+                over_ref = over.get("ref") if isinstance(over, Mapping) else None
+                parent_id = (
+                    over_ref[0]
+                    if isinstance(over_ref, list) and over_ref
+                    else cm.get("parent")
+                )
+            else:
+                parent_id = None
+            if parent_id is None or parent_id in seen:
+                break
+            seen.add(parent_id)
+            base = by_id.get(parent_id)
+            resolved = _read_node_id(parent_id) if base is not None else parent_id
+            if resolved in paths:
+                base_path = paths[resolved]
+                break
+            cur_node = base
+        if base_path is not None:
+            paths[node["id"]] = base_path + tuple(reversed(intos))
+    return paths
+
+
+def relation_paths_from_output(component: Mapping[str, Any]) -> Dict[str, Tuple[str, ...]]:
+    """Public alias of :func:`_relation_paths_from_output` (the id-scheme-independent
+    node-id → relation-path map — issue #350). Consumed by the runtime's
+    relation-depth limit check so it too is id-scheme-independent."""
+    return _relation_paths_from_output(component)
+
+
 def _reroot_for_template(node: Any) -> Any:
     """Rewrite every ``ref``/``refOpt`` root so the node renders through
     ``render_key_expr_to_template`` (whose grammar knows only ``input``/``result``
@@ -233,8 +340,24 @@ def execute_read_component(
 
     # Per-node static config (handler-injected, C4): entity meta for hydration,
     # select, key attrs, relation path — derived from the RAW port IR.
+    #
+    # Root + relation-path derivation is id-scheme-INDEPENDENT (issue #350): the
+    # ROOT is the node with NO ``parent`` wire (true in BOTH the legacy dotted-id
+    # scheme — where the root is also literally ``"root"`` — and the genuinely
+    # declarative ``compileBehaviors`` scheme with recorder-scan ids ``n0``/``n1``).
+    # The relation path comes from the component ``output`` Φ property names
+    # (:func:`_relation_paths_from_output`), which name each relation regardless of
+    # its node id; the legacy id-derived path is the fallback for a node absent from
+    # the output.
+    output_paths = _relation_paths_from_output(component)
     cfg: Dict[str, Dict[str, Any]] = {}
     for node in body:
+        # A CondNode (issue #350: each root-level relation is authored as a
+        # `when`-gate, so the component carries `cond` nodes) has NO ports and NO
+        # handler — bc's ``run_behavior`` evaluates it internally (the gate + Φ
+        # merge). It needs no per-node handler config, so skip it here.
+        if "cond" in node:
+            continue
         node_id, _m, ports = _node_parts(node)
         pseudo, key_attrs = _pseudo_read_op(ports)
         cfg[node_id] = {
@@ -242,8 +365,10 @@ def execute_read_component(
             "projection": pseudo["projection"],
             "entity_meta": rt._resolve_entity(pseudo),
             "key_attrs": key_attrs,
-            "relation_path": _relation_path_of(node_id),
-            "is_root": node_id == "root",
+            "relation_path": output_paths.get(node_id, _relation_path_of(node_id)),
+            "is_root": node.get("parent") is None
+            and node.get("map") is None
+            and node.get("fanout") is None,
         }
 
     def _key_of(ports: Mapping[str, Any], key_attrs: List[str]) -> Dict[str, Any]:
@@ -549,10 +674,12 @@ def _fold_read_output(
             result[prop] = val
         elif "obj" in spec_node:
             # Chained connection: {cursor, items:<augmented tail>} — re-nest the
-            # per-element flat `into` keys along each chain map's id.
+            # per-element flat `into` keys along each chain map's PLACEMENT (derived
+            # from the `map.parent`/`map.into` chain, id-scheme-INDEPENDENT — #350).
             conn_id = spec_node["obj"]["cursor"]["ref"][0]
+            placements = _chain_map_placements(conn_id, body)
             elements = [
-                _fold_chain_element(el, conn_id, body) for el in val["items"]
+                _fold_chain_element(el, placements) for el in val["items"]
             ]
             result[prop] = {"cursor": val["cursor"], "items": elements}
         else:  # pragma: no cover - closed emitter vocabulary
@@ -596,37 +723,84 @@ def _fold_read_output(
     return result
 
 
+def _chain_map_placements(
+    conn_id: str, body: List[Mapping[str, Any]]
+) -> List[Tuple[str, List[str]]]:
+    """Every chain-map node riding the connection ``conn_id`` (the cursor-ref head —
+    a gated Query / its cond) paired with its element PLACEMENT: the ordered ``into``
+    keys of its map-ancestors, outermost→this (id-scheme-INDEPENDENT — #350). A map
+    whose parent is the connection is ``[into]`` (a flat attach, first chain link); a
+    map whose parent is another map is ``[…parent placement, into]`` (nested — its
+    ``into`` re-nests under the parent's placement). Ordered shallowest→deepest so a
+    parent's key exists before a child re-nests under it."""
+    by_id = {n["id"]: n for n in body}
+
+    def _is_conn(node_id: str) -> bool:
+        # The connection base is `conn_id` itself OR the READ node its cond gate wraps
+        # (`then: {ref:[<read>]}`), so a map whose `over` refs either resolves as flat.
+        if node_id == conn_id:
+            return True
+        base = by_id.get(conn_id)
+        if base is not None and "cond" in base:
+            then = base["cond"].get("then")
+            then_ref = then.get("ref") if isinstance(then, Mapping) else None
+            if isinstance(then_ref, list) and then_ref and then_ref[0] == node_id:
+                return True
+        return False
+
+    placements: Dict[str, List[str]] = {}
+    for node in body:
+        m = node.get("map") if isinstance(node, Mapping) else None
+        if not isinstance(m, Mapping) or "into" not in m:
+            continue
+        intos: List[str] = []
+        cur: Optional[Mapping[str, Any]] = node
+        rides_conn = False
+        seen: set = set()
+        while isinstance(cur, Mapping):
+            cm = cur.get("map")
+            if not (isinstance(cm, Mapping) and "into" in cm):
+                break
+            intos.append(cm["into"])
+            over = cm.get("over", {})
+            over_ref = over.get("ref") if isinstance(over, Mapping) else None
+            parent_id = (
+                over_ref[0]
+                if isinstance(over_ref, list) and over_ref
+                else cm.get("parent")
+            )
+            if parent_id is None or parent_id in seen:
+                break
+            seen.add(parent_id)
+            if _is_conn(parent_id):
+                rides_conn = True
+                break
+            cur = by_id.get(parent_id)
+        if rides_conn:
+            placements[node["id"]] = list(reversed(intos))
+    return sorted(placements.items(), key=lambda kv: len(kv[1]))
+
+
 def _fold_chain_element(
-    element: Any, conn_id: str, body: List[Mapping[str, Any]]
+    element: Any, placements: List[Tuple[str, List[str]]]
 ) -> Any:
-    """Re-nest one augmented connection element: for each chain map under
-    ``conn_id`` whose placement is DEEPER than the element itself, move its flat
-    ``into`` key to the placement its node id names."""
+    """Re-nest one augmented connection element: for each chain map whose PLACEMENT
+    is DEEPER than a flat attach (``len > 1``), move its flat ``into`` key to the
+    nested placement its map-parent chain names (``permissions`` → under ``group``)."""
     if not isinstance(element, dict):
         return element
     el = dict(element)
-    prefix = conn_id.split(".")
-    for node in body:
-        m = node.get("map")
-        if m is None or "into" not in m:
-            continue
-        node_tokens = node["id"].split(".")
-        if node_tokens[: len(prefix)] != prefix or len(node_tokens) == len(prefix):
-            continue
-        rel = node_tokens[len(prefix):]
-        if rel and rel[-1] == "items":
-            rel = rel[:-1]
-        if len(rel) <= 1:
+    for _node_id, placement in placements:
+        if len(placement) <= 1:
             continue  # flat attach == final placement (first chain link).
-        into = m["into"]
-        value = el.pop(into, None)
+        value = el.pop(placement[-1], None)
         target: Any = el
-        for token in rel[:-1]:
+        for token in placement[:-1]:
             target = target.get(token) if isinstance(target, dict) else None
             if target is None:
                 break
         if isinstance(target, dict):
-            target[rel[-1]] = value
+            target[placement[-1]] = value
     return el
 
 

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/graphddb_runtime/runtime.py

@@ -51,7 +51,11 @@ from .per_key_cursor import (
     encode_per_key_cursor,
     serialize_contract_key,
 )
-from .behavior_exec import collect_transaction_items, execute_read_component
+from .behavior_exec import (
+    collect_transaction_items,
+    execute_read_component,
+    relation_paths_from_output,
+)
 from .templates import (
     key_condition_templates,
     render_key_expr_to_template,
@@ -2064,13 +2068,23 @@ class GraphDDBRuntime:
                 f"{query_id}: query needs {len(body)} operations, exceeds "
                 f"max_operations {self._limits.max_operations}"
             )
+        # Relation-traversal DEPTH is the longest relation path (id-scheme-INDEPENDENT
+        # — issue #350): a GENUINELY declarative read (`compileBehaviors`) has
+        # recorder-scan ids (`n0`/`n1`) that no longer encode the hop count, so the
+        # depth is the longest `relation_path` derived from the `output` Φ structure +
+        # the `map.parent`/`into` chain (`relation_paths_from_output`). The legacy
+        # dotted-id count is the fallback for a node absent from that map (defensive).
+        rel_paths = relation_paths_from_output(component)
         depth = 0
         for node in body:
             node_id = str(node.get("id", ""))
             if node_id in ("", "root"):
                 continue
-            # Each non-`items` segment is one relation hop.
-            depth = max(depth, sum(1 for t in node_id.split(".") if t != "items"))
+            if node_id in rel_paths:
+                depth = max(depth, len(rel_paths[node_id]))
+            else:
+                # Each non-`items` segment is one relation hop (legacy imperative ids).
+                depth = max(depth, sum(1 for t in node_id.split(".") if t != "items"))
         if depth > self._limits.max_depth:
             raise LimitExceededError(
                 f"{query_id}: relation traversal depth {depth} exceeds max_depth "

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/graphddb_runtime.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.0.9
+Version: 1.1.0
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: boto3>=1.26
-Requires-Dist: behavior-contracts==0.7.3
+Requires-Dist: behavior-contracts==0.8.2
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/graphddb_runtime.egg-info/requires.txt

@@ -1,5 +1,5 @@
 boto3>=1.26
-behavior-contracts==0.7.3
+behavior-contracts==0.8.2
 
 [test]
 pytest>=7.0

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "1.0.9"
+version = "1.1.0"
 description = "Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44)."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -14,7 +14,7 @@ license = { text = "MIT" }
 # canonicalisation) are delegated to the extracted shared package
 # ``behavior-contracts`` (import name ``behavior_contracts``). The runtime
 # imports it unconditionally, so it is a HARD dependency.
-dependencies = ["boto3>=1.26", "behavior-contracts==0.7.3"]
+dependencies = ["boto3>=1.26", "behavior-contracts==0.8.2"]
 
 [project.optional-dependencies]
 test = ["pytest>=7.0"]

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/tests/test_crosslang_python_cells.py

@@ -404,5 +404,26 @@ def test_micro_mock_graphddb_cell_runs_without_io():
 def test_micro_fixtures_match_ts_shapes():
     """The Python micro fixtures mirror the TS MICRO_FIXTURES (attr/row counts)."""
     assert LIST_ROWS == 20
-    # USER_ITEM carries the 6 attributes the TS fixture does.
-    assert set(USER_ITEM.keys()) == {"PK", "SK", "userId", "name", "email", "status"}
+    # USER_ITEM is the superset row the TS fixture (microbench/mock-transport.ts)
+    # carries: the 6 base profile attributes plus the pattern point-read scalars,
+    # the embeddedRefs id-list, and the inline snapshot/materialized-view lists.
+    assert set(USER_ITEM.keys()) == {
+        "PK",
+        "SK",
+        "userId",
+        "name",
+        "email",
+        "status",
+        "threadId",
+        "postId",
+        "groupId",
+        "authorId",
+        "docId",
+        "version",
+        "title",
+        "displayName",
+        "postCount",
+        "tagRefs",
+        "latestPosts",
+        "recentPosts",
+    }

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/tests/test_error_policy.py

@@ -82,16 +82,34 @@ def _runtime(client, operations_path=conftest.OPERATIONS_PATH):
     )
 
 
-def _ops_with_policy(tmp_path, policy, node_ids=("members.items",)):
-    """The generated fixture document with `policy` injected on relation nodes
+def _ops_with_policy(tmp_path, policy, relations=("members",)):
+    """The generated fixture document with `policy` injected on relation QUERY nodes
     of GroupAccessRead__get (graphddb has no authoring surface for non-default
-    policy yet — the injected field proves the componentRef pass-through)."""
+    policy yet — the injected field proves the componentRef pass-through).
+
+    The target QUERY node is resolved by RELATION PROPERTY via the component
+    `output` Φ merge, THROUGH the CondNode gate (issue #350: each relation is
+    authored as `when(...)`, so its output ref is the Φ cond whose `then` refs the
+    gated Query — the node that carries a `policy`). Id-scheme independent."""
     with open(conftest.OPERATIONS_PATH, encoding="utf-8") as fh:
         ops = json.load(fh)
     doc = copy.deepcopy(ops)
     comp = next(c for c in doc["components"] if c["name"] == "GroupAccessRead__get")
+    by_id = {n["id"]: n for n in comp["body"]}
+
+    def _query_id(node_id):
+        node = by_id.get(node_id)
+        if node is not None and "cond" in node:
+            then = node["cond"].get("then", {})
+            then_ref = then.get("ref") if isinstance(then, dict) else None
+            if then_ref:
+                return _query_id(then_ref[0])
+        return node_id
+
+    out_obj = comp["output"]["obj"]
+    target_ids = {_query_id(out_obj[rel]["ref"][0]) for rel in relations}
     for node in comp["body"]:
-        if node["id"] in node_ids:
+        if node["id"] in target_ids:
             node["policy"] = policy
     path = tmp_path / "operations.json"
     path.write_text(json.dumps(doc), encoding="utf-8")
@@ -120,31 +138,39 @@ def test_explicit_fail_policy_matches_default(tmp_path):
     assert "DynamoDB operation failed" in str(ei.value)
 
 
-def test_continue_policy_skips_failed_branch_and_runs_siblings(tmp_path):
-    # continue Kind (scp-error.md §continue): the failed members query is
-    # swallowed into Skip propagation (unproduced connection), the INDEPENDENT
-    # permissions sibling still executes and resolves.
-    client = _Client()
-    rt = _runtime(client, _ops_with_policy(tmp_path, "continue"))
-    result = rt.execute_query("GroupAccessRead__get", {"groupId": "g1"})
-    assert result["groupId"] == "g1"
-    assert result["members"] == {"items": [], "cursor": None}  # unproduced
-    perms = result["permissions"]["items"]
-    assert [p["resource"] for p in perms] == ["doc"]
-    # Both relation queries were issued (the failure did not abort the stage).
-    assert sum(1 for m, _ in client.calls if m == "query") == 2
-
-
-def test_continue_policy_on_all_relations(tmp_path):
-    client = _Client(fail_all_queries=True)
-    rt = _runtime(
-        client,
-        _ops_with_policy(tmp_path, "continue", ("members.items", "permissions.items")),
-    )
+class _NullGroupIdClient(_Client):
+    """Root GetItem returns a row whose `groupId` is null → the relation gates
+    (`ne(root.groupId, null)`) are false, so no relation Query is dispatched."""
+
+    def get_item(self, **kwargs):
+        self.calls.append(("get_item", kwargs))
+        return {
+            "Item": {
+                "PK": {"S": "GROUP#g1"},
+                "SK": {"S": "META"},
+                "groupId": {"NULL": True},
+                "name": {"S": "Engineering"},
+                "description": {"S": "desc"},
+                "createdAt": {"S": "2020-01-02T03:04:05.000Z"},
+            }
+        }
+
+
+def test_gate_folds_absent_parent_relation_to_empty_connection(tmp_path):
+    # Issue #350 course-correction: each relation is authored as
+    # `when(ne(root.<sourceField>, null), () => Query, () => empty)`, so the
+    # empty-connection fallback is the cond's ELSE branch (a DECLARATIVE default),
+    # NOT an injected `continue` policy. When the parent source field (`groupId`) is
+    # null, bc skips the gated Query and folds the relation to `{items:[],
+    # cursor:None}` — the same unproduced-connection shape the old continue policy
+    # produced, now expressed in SCP.
+    client = _NullGroupIdClient()
+    rt = _runtime(client)  # no injected policy — the gate is the mechanism
     result = rt.execute_query("GroupAccessRead__get", {"groupId": "g1"})
-    assert result["groupId"] == "g1"
     assert result["members"] == {"items": [], "cursor": None}
     assert result["permissions"] == {"items": [], "cursor": None}
+    # NEITHER relation Query was dispatched (the gate skipped both).
+    assert sum(1 for m, _ in client.calls if m == "query") == 0
 
 
 def test_unknown_policy_kind_fails_closed(tmp_path):

{graphddb_runtime-1.0.9 → graphddb_runtime-1.1.0}/tests/test_unit.py

@@ -1086,11 +1086,18 @@ def test_multi_operation_query_is_now_supported(tmp_path):
     root_component = next(
         c for c in ops["components"] if c["name"] == "UserByEmailRead__get"
     )
+    # This hand-built multi component uses the LEGACY dotted-id scheme (`root` /
+    # `groups.items`) for its own wiring (`{ref:["root",...]}`, output `{ref:["root"]}`).
+    # The production `UserByEmailRead__get` is now GENUINELY declarative (issue #350),
+    # so its root node id is `n0`; normalize the COPIED root node's id back to `root`
+    # so this fixture stays internally consistent with its legacy-scheme references.
+    _root_node = dict(root_component["body"][0])
+    _root_node["id"] = "root"
     ops["components"].append({
         "name": "multi",
         "inputPorts": {"email": {"type": "string", "required": True}},
         "body": [
-            dict(root_component["body"][0]),
+            _root_node,
             {
                 "id": "groups.items",
                 "component": "Query",