pgc-runtime 6.0.0__tar.gz → 7.0.0__tar.gz

{pgc_runtime-6.0.0/pgc_runtime.egg-info → pgc_runtime-7.0.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pgc-runtime
-Version: 6.0.0
+Version: 7.0.0
 Summary: PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)
 Author-email: Bhash Ganti <bachipeachy@gmail.com>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://omnibachi.org/
 Project-URL: Repository, https://github.com/protocol-governed-computing/protocol_runtime
-Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150615
 Keywords: protocol-governed-computing,pgc,protocol,runtime,workflow,execution
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -22,8 +22,6 @@ License-File: LICENSE
 License-File: NOTICE
 Provides-Extra: reference
 Requires-Dist: pgc-governance>=2.0.0; extra == "reference"
-Provides-Extra: render
-Requires-Dist: pgc-inspector>=6.0.0; extra == "render"
 Dynamic: license-file
 
 # protocol_runtime
@@ -86,8 +84,6 @@ the data root:
 ```
 <data-root>/traces/<domain>/<WF>/<TRACE_ID>/
     <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V0 event per line
-    <TRACE_ID>.png      the path the run took, drawn only on request (`run --behavior-logic`,
-                        or `behavior-logic <trace>`)
 
 <data-root>/<domain>/<subdomain>/
     the stores the domain's runtime binding declares
@@ -113,7 +109,6 @@ the data root:
 | `coordinator` | serve as the coordinating node of a federated node group |
 | `worker` | serve as a worker node of a federated node group |
 | `examine` | read a completed trace: its path by node, contracts, results, events and errors |
-| `behavior-logic` | render a completed trace as a PNG: the path, each route's outcome, and why each node decided as far as the trace records it (drawn from the inspector's `si.execution.explain`; needs `pgc-runtime[render]`) |
 
 `PGC_SNAPSHOT_ROOT` overrides the snapshot location; `PGC_IMPL_ROOTS` is the colon-separated set of
 roots on `PYTHONPATH` for domain capability implementations.
@@ -216,4 +211,4 @@ Each repository's `VERSION` file holds the workspace's cycle ordinal, which name
 branch. It is development accounting, and it is never published. The standard the packages
 implement is a separate artifact on its own track, and none of these numbers is its revision.
 
-The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150615

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/README.md

@@ -58,8 +58,6 @@ the data root:
 ```
 <data-root>/traces/<domain>/<WF>/<TRACE_ID>/
     <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V0 event per line
-    <TRACE_ID>.png      the path the run took, drawn only on request (`run --behavior-logic`,
-                        or `behavior-logic <trace>`)
 
 <data-root>/<domain>/<subdomain>/
     the stores the domain's runtime binding declares
@@ -85,7 +83,6 @@ the data root:
 | `coordinator` | serve as the coordinating node of a federated node group |
 | `worker` | serve as a worker node of a federated node group |
 | `examine` | read a completed trace: its path by node, contracts, results, events and errors |
-| `behavior-logic` | render a completed trace as a PNG: the path, each route's outcome, and why each node decided as far as the trace records it (drawn from the inspector's `si.execution.explain`; needs `pgc-runtime[render]`) |
 
 `PGC_SNAPSHOT_ROOT` overrides the snapshot location; `PGC_IMPL_ROOTS` is the colon-separated set of
 roots on `PYTHONPATH` for domain capability implementations.
@@ -188,4 +185,4 @@ Each repository's `VERSION` file holds the workspace's cycle ordinal, which name
 branch. It is development accounting, and it is never published. The standard the packages
 implement is a separate artifact on its own track, and none of these numbers is its revision.
 
-The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150615

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0/pgc_runtime.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pgc-runtime
-Version: 6.0.0
+Version: 7.0.0
 Summary: PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)
 Author-email: Bhash Ganti <bachipeachy@gmail.com>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://omnibachi.org/
 Project-URL: Repository, https://github.com/protocol-governed-computing/protocol_runtime
-Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150615
 Keywords: protocol-governed-computing,pgc,protocol,runtime,workflow,execution
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -22,8 +22,6 @@ License-File: LICENSE
 License-File: NOTICE
 Provides-Extra: reference
 Requires-Dist: pgc-governance>=2.0.0; extra == "reference"
-Provides-Extra: render
-Requires-Dist: pgc-inspector>=6.0.0; extra == "render"
 Dynamic: license-file
 
 # protocol_runtime
@@ -86,8 +84,6 @@ the data root:
 ```
 <data-root>/traces/<domain>/<WF>/<TRACE_ID>/
     <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V0 event per line
-    <TRACE_ID>.png      the path the run took, drawn only on request (`run --behavior-logic`,
-                        or `behavior-logic <trace>`)
 
 <data-root>/<domain>/<subdomain>/
     the stores the domain's runtime binding declares
@@ -113,7 +109,6 @@ the data root:
 | `coordinator` | serve as the coordinating node of a federated node group |
 | `worker` | serve as a worker node of a federated node group |
 | `examine` | read a completed trace: its path by node, contracts, results, events and errors |
-| `behavior-logic` | render a completed trace as a PNG: the path, each route's outcome, and why each node decided as far as the trace records it (drawn from the inspector's `si.execution.explain`; needs `pgc-runtime[render]`) |
 
 `PGC_SNAPSHOT_ROOT` overrides the snapshot location; `PGC_IMPL_ROOTS` is the colon-separated set of
 roots on `PYTHONPATH` for domain capability implementations.
@@ -216,4 +211,4 @@ Each repository's `VERSION` file holds the workspace's cycle ordinal, which name
 branch. It is development accounting, and it is never published. The standard the packages
 implement is a separate artifact on its own track, and none of these numbers is its revision.
 
-The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150615

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/pgc_runtime.egg-info/SOURCES.txt

@@ -24,7 +24,6 @@ runtime/loader.py
 runtime/memory.py
 runtime/replay.py
 runtime/scheduler.py
-runtime/trace_viz.py
 runtime/examine/__init__.py
 runtime/examine/cli.py
 runtime/examine/parser.py

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/pgc_runtime.egg-info/requires.txt

@@ -1,6 +1,3 @@
 
 [reference]
 pgc-governance>=2.0.0
-
-[render]
-pgc-inspector>=6.0.0

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pgc-runtime"
-version = "6.0.0"
+version = "7.0.0"
 description = "PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,9 +32,6 @@ dependencies = []
 
 [project.optional-dependencies]
 reference = ["pgc-governance>=2.0.0"]
-# The PNG projection (`--behavior-logic`, `behavior-logic`) draws the inspector's explanation of a
-# run. Execution never imports the inspector; only `runtime.trace_viz` does.
-render = ["pgc-inspector>=6.0.0"]
 
 [project.scripts]
 protocol_runtime = "runtime.cli:main"
@@ -42,7 +39,7 @@ protocol_runtime = "runtime.cli:main"
 [project.urls]
 Homepage = "https://omnibachi.org/"
 Repository = "https://github.com/protocol-governed-computing/protocol_runtime"
-Standard = "https://doi.org/10.5281/zenodo.22150616"
+Standard = "https://doi.org/10.5281/zenodo.22150615"
 
 [tool.setuptools]
 include-package-data = false

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/runtime/api.py

@@ -78,8 +78,8 @@ def run_workflow(
         writer.error(str(exc))
         raise
     finally:
-        # The JSONL is the evidence. A picture of the path is a view of it, drawn on request
-        # (`run --behavior-logic`, or `behavior-logic <trace>`), never as a cost of every run.
+        # The JSONL is the evidence. A drawing of the path is a view of it, made by the inspector
+        # on request, never by the runtime and never as a cost of every run.
         writer.close()
 
     return RunResult(status=status, surface=surface or {}, trace_id=trace_id, trace_dir=trace_dir)

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/runtime/cli.py

@@ -4,7 +4,6 @@ cli.py — Token-native CLI entry point for the runtime.
 Commands:
     run           — Execute a workflow against the tokenized snapshot.
     examine       — Analyze a completed trace file and print a diagnostic report.
-    behavior-logic — Render a completed trace, explained, over its workflow graph (PNG).
 
 Execution path (run):
     1. Load tokenized snapshot for the domain via loader.load_domain()
@@ -13,7 +12,6 @@ Execution path (run):
     3. Open TraceWriter at traces/<domain>/<wf_code>/<trace_id>/
     4. Drive workflow topology via scheduler.run_wf()
     5. Print result summary; exit 1 on non-SUCCESS
-    6. If --behavior-logic: render the explained run as a PNG (trace_viz, a client of the inspector)
 
 All runtime behavior comes from the compiled tokenized_snapshot.
 The CLI does not implement any domain logic.
@@ -72,14 +70,6 @@ def _build_parser() -> argparse.ArgumentParser:
              "Default: sibling ../snapshot",
     )
 
-    # ── run: optional behavior-logic flag ────────────────────────
-    run_p.add_argument(
-        "--behavior-logic",
-        action="store_true",
-        dest="behavior_logic",
-        help="Render execution-path PNG after run (requires graphviz)",
-    )
-
     # ── replay ────────────────────────────────────────────────────
     rp_p = subs.add_parser(
         "replay",
@@ -136,23 +126,6 @@ def _build_parser() -> argparse.ArgumentParser:
         help="Path to a completed .jsonl trace file",
     )
 
-    # ── behavior-logic ────────────────────────────────────────────
-    bl_p = subs.add_parser(
-        "behavior-logic",
-        help="Render execution-path PNG from a completed trace file",
-    )
-    bl_p.add_argument(
-        "trace_file",
-        metavar="FILE",
-        help="Path to a completed .jsonl trace file",
-    )
-    bl_p.add_argument(
-        "--snapshot",
-        metavar="PATH",
-        help="Absolute path to the assembled snapshot the trace ran against "
-             "(or set PGC_SNAPSHOT_ROOT; default: the sibling ../snapshot)",
-    )
-
     return parser
 
 
@@ -208,12 +181,6 @@ def _handle_run(args: argparse.Namespace) -> None:
     print(f"[runtime] Trace dir: {trace_dir}")
     print()
 
-    # Evidence projection: render execution-path PNG if requested
-    trace_path = trace_dir / f"{trace_id}.jsonl"
-    png_path = None
-    if args.behavior_logic:
-        png_path = _render_behavior_logic(snapshot_root, trace_path, trace_root=data_root)
-
     print("=" * 60)
     print("[runtime] Workflow Complete")
     print("=" * 60)
@@ -224,10 +191,6 @@ def _handle_run(args: argparse.Namespace) -> None:
     if surface:
         print("Output:")
         print(_format_surface(surface))
-    if png_path:
-        print(f"Graph:      {png_path}")
-    elif args.behavior_logic:
-        print("Graph:      (graphviz not available — PNG skipped)")
     print("=" * 60)
 
     if result_status not in ("SUCCESS", "ALREADY_EXISTS"):
@@ -341,27 +304,6 @@ def _health_line(snapshot_root: Path, booted) -> str:
     return f"[runtime] ✓ Snapshot healthy — {n} domain(s) resident and hash-verified{gov}. No issues."
 
 
-def _handle_behavior_logic(args: argparse.Namespace) -> None:
-    trace_path = Path(args.trace_file)
-    if not trace_path.exists():
-        _fatal(f"Trace file not found: {args.trace_file}")
-
-    snapshot_str = args.snapshot or os.environ.get("PGC_SNAPSHOT_ROOT")
-    snapshot_root = Path(snapshot_str) if snapshot_str else default_snapshot_root()
-    if not snapshot_root.is_absolute():
-        _fatal(f"--snapshot must be an absolute path, got: {snapshot_str}")
-
-    png_path = _render_behavior_logic(snapshot_root, trace_path)
-    if png_path:
-        print(f"[runtime] Execution path PNG: {png_path}")
-    else:
-        print(
-            "[runtime] Behavior logic render skipped — graphviz (dot) not available.",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-
 def _handle_examine(args: argparse.Namespace) -> None:
     trace_path = Path(args.trace_file)
     if not trace_path.exists():
@@ -391,21 +333,6 @@ def _handle_examine(args: argparse.Namespace) -> None:
 # Utilities
 # ---------------------------------------------------------------------------
 
-def _render_behavior_logic(snapshot_root: Path, trace_path: Path,
-                           trace_root: Path | None = None) -> "Path | None":
-    """Render the explained run as a PNG. Best-effort: a refusal is reported, never drawn around."""
-    from runtime.trace_viz import render_trace_png
-    try:
-        return render_trace_png(snapshot_root, trace_path, trace_root=trace_root)
-    except ModuleNotFoundError as exc:
-        print(f"[runtime] Behavior logic render needs the snapshot inspector "
-              f"(pgc-runtime[render]): {exc}", file=sys.stderr)
-        return None
-    except (FileNotFoundError, ValueError) as exc:
-        print(f"[runtime] Behavior logic render error: {exc}", file=sys.stderr)
-        return None
-
-
 def _load_payload(payload_path: str | None) -> dict:
     if not payload_path:
         return {}
@@ -500,8 +427,6 @@ def main() -> None:
         _handle_worker(args)
     elif args.command == "examine":
         _handle_examine(args)
-    elif args.command == "behavior-logic":
-        _handle_behavior_logic(args)
 
 
 if __name__ == "__main__":

{pgc_runtime-6.0.0 → pgc_runtime-7.0.0}/runtime/evidence.py

@@ -19,8 +19,8 @@ The trace file is written to:
 
 subdomain is not known to this module — caller passes the full trace dir path.
 
-This module produces the raw JSONL evidence only. Evidence projection
-(execution-path PNG overlay) is handled separately in trace_viz.py.
+This module produces the raw JSONL evidence only. A reader draws a run from it through the
+inspector: its workflow page marks the path `si.execution.explain` gives (`/workflow/?trace=`).
 """
 
 from __future__ import annotations

pgc_runtime-6.0.0/runtime/trace_viz.py

@@ -1,233 +0,0 @@
-"""
-trace_viz.py — Evidence projection: a run drawn over its workflow, with why it went where it went.
-
-A client of the snapshot inspector, never a second reader of the trace. It asks two questions of
-`inspector.api.query` and draws the answers:
-
-    si.behavior_logic.show   the workflow's declared graph (every node and edge)
-    si.execution.explain     the run: the path, each route's outcome, each node's determination
-                             as far as the trace records it, captured inputs, how the run ended
-    ──────────────────────
-    → <trace_id>.png beside the trace
-
-It derives nothing. The inspector resolves the workflow's domain, ties the trace to the snapshot
-(and refuses a trace produced under another), and separates what the trace recorded from what it
-joined from the snapshot. This module only chooses how each answer looks:
-
-- **recorded** (from the trace) is drawn in red: the path, the outcome on each route taken, a
-  gate's failed checks, a node's recorded outcome, errors, captured inputs;
-- **joined** (from the snapshot) is drawn in grey: each node's declared capability;
-- **declared but not taken** is drawn pale, as before;
-- a route the run took that the graph does not declare is drawn dashed.
-
-The inspector is imported here and nowhere else in the runtime: execution never depends on it,
-and only this optional projection does (`pgc-runtime[render]`).
-
-Uses graphviz (dot) — returns None if dot is not available.
-"""
-
-from __future__ import annotations
-
-import subprocess
-from html import escape
-from pathlib import Path
-from typing import Any, Optional
-
-
-class ExplanationRefused(ValueError):
-    """The inspector would not explain this trace against this snapshot. `str(exc)` is its reason."""
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def render_trace_png(
-    snapshot_root: Path,
-    trace_path: Path,
-    trace_root: Path | None = None,
-) -> Optional[Path]:
-    """
-    Render the explained run over its workflow graph, beside the trace.
-
-    Args:
-        snapshot_root: The assembled snapshot the trace names.
-        trace_path:    The completed .jsonl trace.
-        trace_root:    The root the trace is named under — the run's data root. Defaults to the
-                       trace's own directory, which names the same file.
-
-    Returns:
-        Path to the PNG, or None if graphviz is unavailable.
-
-    Raises:
-        FileNotFoundError:   trace_path does not exist.
-        ExplanationRefused:  the inspector refused the trace or has no graph for its workflow.
-    """
-    from inspector.api import query   # optional projection; execution never imports this
-
-    trace_path = Path(trace_path).resolve()
-    if not trace_path.is_file():
-        raise FileNotFoundError(f"Trace file not found: {trace_path}")
-    root = Path(trace_root).resolve() if trace_root is not None else trace_path.parent
-    reference = trace_path.relative_to(root).as_posix()
-
-    status, explanation = query("si.execution.explain", {"trace": reference}, snapshot_root,
-                                trace_root=root)
-    if status != "SUCCESS":
-        raise ExplanationRefused(explanation.get("reason", status))
-    status, logic = query("si.behavior_logic.show", {"wf": explanation["wf"]}, snapshot_root)
-    if status != "SUCCESS":
-        raise ExplanationRefused(logic.get("reason", status))
-
-    dot_content = _generate_dot(logic["graph"], explanation)
-
-    png_path = trace_path.with_suffix(".png")
-    dot_path = trace_path.with_suffix(".dot")
-    dot_path.write_text(dot_content, encoding="utf-8")
-    try:
-        subprocess.run(
-            ["dot", "-Tpng", str(dot_path), "-o", str(png_path)],
-            check=True,
-            capture_output=True,
-        )
-        dot_path.unlink()
-        return png_path
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        dot_path.unlink(missing_ok=True)
-        return None
-
-
-# ---------------------------------------------------------------------------
-# What the explanation says, reduced to what is drawn
-# ---------------------------------------------------------------------------
-
-def _taken(explanation: dict[str, Any]) -> list[tuple[str, str, str]]:
-    """The path as (from_node, outcome, to_node), in order — read from the explanation's visits.
-
-    A route that reached neither routing nor an ending has no `to`, and the path stops at the node
-    that produced it. A visit with no node key means the trace predates node keys: refused, because
-    the path cannot be placed on the graph without guessing.
-    """
-    path: list[tuple[str, str, str]] = []
-    for visit in explanation.get("visits", []):
-        route = visit.get("route")
-        if route is None:
-            continue
-        if not visit.get("node"):
-            raise ExplanationRefused("the trace's routes carry no node keys — it predates them; re-run it")
-        if route.get("to") is None:
-            break
-        path.append((visit["node"], route.get("outcome"), route["to"]))
-    return path
-
-
-def _recorded_lines(visit: dict[str, Any]) -> list[str]:
-    """What the trace recorded about why this node decided as it did, as label lines."""
-    lines: list[str] = []
-    determination = visit.get("determination") or {}
-    basis = determination.get("basis")
-    if basis == "recorded admission checks":
-        failed = determination.get("failed") or []
-        if failed:
-            lines += [f"✗ {c['field']}: {c['rule']} {c['expected']}" for c in failed]
-        else:
-            lines.append(f"✓ {len(determination.get('checks') or [])} check(s) held")
-    elif basis == "capability outcome":
-        lines.append(f"→ {determination.get('outcome')}")
-    elif basis == "not recorded":
-        lines.append("checks not recorded")
-    for atom in visit.get("atoms") or []:
-        if atom.get("captured"):
-            name = (atom.get("atom") or "").split("::")[-1]
-            lines.append(f"captured: {name}{' (replayed)' if atom.get('replayed') else ''}")
-    for error in visit.get("errors") or []:
-        lines.append(f"ERROR: {error.get('message')}")
-    return lines
-
-
-# ---------------------------------------------------------------------------
-# DOT generation
-# ---------------------------------------------------------------------------
-
-_SHAPES = {"IN": ("ellipse", "lightblue"), "CC": ("box", "lightgreen"),
-           "EXIT": ("ellipse", "lightcoral")}
-
-
-def _label(node_id: str, joined: str | None, recorded: list[str]) -> str:
-    """An HTML-like label: the node, then what was joined (grey), then what was recorded (red)."""
-    rows = [f"<B>{escape(node_id)}</B>"]
-    if joined:
-        rows.append(f'<FONT POINT-SIZE="10" COLOR="gray35"><I>{escape(joined)}</I></FONT>')
-    rows += [f'<FONT POINT-SIZE="10" COLOR="red3">{escape(line)}</FONT>' for line in recorded]
-    return "<" + "<BR/>".join(rows) + ">"
-
-
-def _generate_dot(graph: dict[str, Any], explanation: dict[str, Any]) -> str:
-    """
-    The declared graph, with the explained run drawn over it.
-
-    Visited nodes: red border and fill, with what the trace recorded about the node.
-    Taken edges:   red, bold, labelled with the outcome that selected them.
-    Undeclared:    a route the run took that the graph does not declare — dashed red.
-    The deciding node of a declared ending carries a double border.
-    """
-    path = _taken(explanation)
-    visits = {v["node"]: v for v in explanation.get("visits", []) if v.get("node")}
-    taken_edges = {(f, t, o) for f, o, t in path}
-    ending = explanation.get("ending") or {}
-    decided_at = ending.get("decided_at") or ending.get("at")
-
-    tie = (explanation.get("tie") or {}).get("snapshot_id", "")
-    title = (f"{explanation.get('wf')}  ·  {explanation.get('status')}  ·  "
-             f"{ending.get('kind', '')}\\nsnapshot {tie[:12]} (claimed by the trace)")
-    lines = [
-        f'digraph "{graph["wf_id"]}" {{',
-        "  rankdir=LR;",
-        f'  label="{title}"; labelloc=t; fontname="Arial";',
-        '  node [fontname="Arial"];',
-        "",
-    ]
-
-    declared_ids = set()
-    for node in graph["nodes"]:
-        node_id = node["id"]
-        declared_ids.add(node_id)
-        shape, fill = _SHAPES.get(node["type"], ("box", "white"))
-        visit = visits.get(node_id)
-        capability = node.get("capability")
-        joined = capability.split("::")[-1] if capability else None
-        if visit is None:
-            lines.append(f'  "{node_id}" [label={_label(node_id, joined, [])}, shape={shape},'
-                         f" style=filled, fillcolor={fill}, color=gray];")
-            continue
-        extra = ", peripheries=2" if node_id == decided_at else ""
-        style = "filled,dashed" if visit.get("errors") else "filled"
-        lines.append(f'  "{node_id}" [label={_label(node_id, joined, _recorded_lines(visit))},'
-                     f' shape={shape}, style="{style}", fillcolor=mistyrose, color=red,'
-                     f" penwidth=2.5{extra}];")
-
-    # A place the run reached that the graph does not declare is still drawn: it was recorded.
-    for node_id, visit in visits.items():
-        if node_id not in declared_ids:
-            lines.append(f'  "{node_id}" [label={_label(node_id, None, _recorded_lines(visit))},'
-                         f' shape=box, style="filled,dashed", fillcolor=mistyrose, color=red];')
-
-    lines.append("")
-
-    declared_edges = set()
-    for edge in graph["edges"]:
-        from_id, to_id, condition = edge["from"], edge["to"], edge["condition"]
-        declared_edges.add((from_id, to_id, condition))
-        if (from_id, to_id, condition) in taken_edges:
-            lines.append(f'  "{from_id}" -> "{to_id}"'
-                         f' [label="{condition}", color=red, penwidth=2.5, fontcolor=red];')
-        else:
-            lines.append(f'  "{from_id}" -> "{to_id}"'
-                         f' [label="{condition}", color=gray, fontcolor=gray];')
-
-    for from_id, to_id, condition in sorted(taken_edges - declared_edges):
-        lines.append(f'  "{from_id}" -> "{to_id}"'
-                     f' [label="{condition} (undeclared)", color=red, style=dashed, fontcolor=red];')
-
-    lines.append("}")
-    return "\n".join(lines)