system-diff 0.2.0__py3-none-any.whl → 0.3.4__py3-none-any.whl

system_diff/__init__.py

@@ -5,4 +5,4 @@
     bp = extract.extract(DirSource(Path(".")), cfg)
     svg = graph.system_svg(bp, cfg)
 """
-__version__ = "0.2.0"
+__version__ = "0.3.4"

system_diff/activity.py

@@ -25,6 +25,15 @@ MAX_BYTES, KEEP = 256 * 1024, 400   # past MAX_BYTES, only the newest KEEP event
 EDIT, READ, PROMPT, STOP = "edit", "read", "prompt", "stop"
 
 
+SYSTEM_PROMPTS = ("<task-notification", "<command-name", "<command-message", "<local-command", "<system-reminder",
+                  "<bash-input", "<bash-stdout", "<user-memory-input")
+
+
+def is_system(text: str) -> bool:
+    """A prompt the person did not type: a background task's notice, a slash command's echo, a reminder."""
+    return (text or "").lstrip().startswith(SYSTEM_PROMPTS)
+
+
 def record(root: Path, event: Dict[str, Any]) -> None:
     """Add one event, e.g. {"event": "edit", "path": "app/api/routes.py"}, stamped with the time."""
     path = git_dir(root) / LOG
@@ -75,7 +84,7 @@ def now(evs: Iterable[dict], code: Code) -> Dict[str, Any]:
     touched = []
     for e in evs:
         kind = e.get("event")
-        if kind == PROMPT:
+        if kind == PROMPT and not is_system(e.get("text", "")):
             start, out["prompt"], out["working"] = e["at"], e.get("text", ""), True
         elif kind == STOP:
             out["said"], out["working"] = e.get("text", ""), False
@@ -107,7 +116,7 @@ def feed(evs: Iterable[dict], code: Code, cfg: Dict[str, Any], most: int = 14) -
     out: List[Dict[str, Any]] = []
     for e in sorted(evs, key=lambda e: e["at"]):
         kind, path = e.get("event"), e.get("path", "")
-        if kind == PROMPT:
+        if kind == PROMPT and not is_system(e.get("text", "")):
             out.append({"at": e["at"], "kind": kind, "text": f"You asked: {e.get('text', '')}"})
         elif kind in (READ, EDIT) and path and e.get("source") != "files":
             part = part_of(path, code)
@@ -196,9 +205,10 @@ def ago(at: float, clock: Optional[float] = None) -> str:
 
 # ── state.json: the latest diff in a few words ───────────────────────────────
 
-def write_state(root: Path, since: Optional[dict], label_since: str = "checkpoint", turn: Optional[dict] = None) -> None:
+def write_state(root: Path, since: Optional[dict], label_since: str = "checkpoint", turn: Optional[dict] = None,
+                noted: Optional[List[str]] = None) -> None:
     """Keep the diff since the checkpoint, and this turn's, in a few words and as sentences (learn.story); None for
-    nothing new."""
+    nothing new. `noted`: the turn's design notes (design.py) by their text, for telling what the next edit adds."""
     from .learn import story
 
     def brief(d: Optional[dict]) -> Dict[str, Any]:
@@ -208,6 +218,8 @@ def write_state(root: Path, since: Optional[dict], label_since: str = "checkpoin
                 "told": [t["text"] for t in told][:500],   # every sentence, for telling what the next edit adds
                 "headline": (d or {}).get("headline", "No change to the system's structure.")}
     state = {"at": round(time.time(), 3), "since": label_since, **brief(since), "turn": brief(turn) if turn else None}
+    if state["turn"] is not None:
+        state["turn"]["noted"] = list(noted or [])[:500]
     _replace(git_dir(root) / STATE, json.dumps(state, ensure_ascii=False) + "\n")
 
 
@@ -215,7 +227,7 @@ def new_turn(root: Path) -> None:
     """A prompt was sent: the turn has changed nothing yet."""
     state = read_state(root)
     if state:
-        state["turn"] = {"changes": 0, "short": "", "story": [], "count": 0, "told": [],
+        state["turn"] = {"changes": 0, "short": "", "story": [], "count": 0, "told": [], "noted": [],
                          "headline": "No change to the system's structure."}
         _replace(git_dir(root) / STATE, json.dumps(state, ensure_ascii=False) + "\n")
 

system_diff/agent.py

@@ -18,7 +18,7 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
-from . import activity, companion, config, learn
+from . import activity, companion, config, design, learn
 from .compare import compare_worktree, mark_turn, turn_sha
 from .extract import Code
 from .sources import git
@@ -122,6 +122,10 @@ def on_start(root: Path, payload: Dict[str, Any], env=os.environ) -> Optional[st
 
 
 def on_prompt(root: Path, payload: Dict[str, Any]) -> None:
+    """The person sent a prompt: a new turn starts. A notice Claude Code sends as a prompt (a background task done)
+    is not one: the turn goes on."""
+    if activity.is_system(payload.get("prompt") or ""):
+        return
     mark_turn(root)
     activity.new_turn(root)
     activity.record(root, {"event": activity.PROMPT, "text": _clip(payload.get("prompt"), 300),
@@ -155,10 +159,25 @@ def on_tool(root: Path, payload: Dict[str, Any]) -> Optional[str]:
         last = activity.read_state(root).get("turn") or {}
         before = last.get("told") or [s["text"] for s in last.get("story") or []]
         since, turn = compare_worktree(root, ["checkpoint", "turn"])
-        activity.write_state(root, since.diff, since.base, turn.diff)
+        notes = design.Reading(turn).notes()
+        record_step(root, path, part, last.get("noted") or [], notes)
+        activity.write_state(root, since.diff, since.base, turn.diff, noted=[n["text"] for n in notes])
         return step_message(before, learn.story(turn.diff))
 
 
+def record_step(root: Path, path: str, part: str, before: Iterable[str], notes: List[Dict[str, Any]]) -> None:
+    """What one edit did to the system's design, kept as a step of what just happened: each change it made, said as
+    a design note with why it matters, and each change of the turn it undid."""
+    had = set(before)
+    now = {n["text"] for n in notes}
+    items = [{"text": n["text"], "why": n["why"], "sign": n["sign"], "status": n["status"], "weight": n["weight"],
+              "change": n.get("change")} for n in notes if n["text"] not in had]
+    items += [{"text": t, "why": "undone: the turn no longer makes this change", "sign": "↺", "status": "muted"}
+              for t in sorted(had - now)]
+    if items:
+        activity.record(root, {"event": "change", "path": path, "part": part, "items": items, "source": "hook"})
+
+
 def on_stop(root: Path, payload: Dict[str, Any]) -> Optional[str]:
     turn_known = turn_sha(root) is not None
     found = compare_worktree(root, ["checkpoint", "turn"] if turn_known else ["checkpoint"])

system_diff/architecture.py

@@ -0,0 +1,324 @@
+"""The system as a system designer draws it, C4-style, rather than as a map of every module: who uses it (ACTORS,
+people and programs), where they come in (ENTRY POINTS), the containers that do the work with their COMPONENTS listed
+inside, the data it keeps (STORES) and the systems outside it; joined by FLOWS named for what travels on them
+(HTTPS, MCP, SQL, a terminal). Two levels:
+
+  system     every actor, entry point, container, store and outside system; a flow between two boxes stands for
+             all the connections between what they hold
+  container  one container's components as boxes with the connections between them, and every box outside it
+             they connect to (an entry point, another container, a store), with the flows to it
+
+Declared in system-diff.toml where the project says so: `[[actors]]` (id, label, kind person|program, uses = [part
+ids], via = "HTTPS"), a component's `group` (its container) and `about` (one line on what it does), an outside
+system's `used_by` and `via` where no setting names it. Inferred where it does not: the front end's people, an API's
+callers, an MCP server's AI agents, a command line's developer, from the technology each entry point imports; the
+parts of a crowded column held in one container named for it.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from . import graph
+from .design import kinds
+
+COLUMNS_FIRST = [("actors", "Who uses it")]
+SYSTEM_COLUMN = {"logic": "core", "data": "core", "store": "outside", "external": "outside"}  # four, at the top level
+MAIN_FLOWS = 4       # flows drawn from each box at the system level, strongest first
+CROWDED = 7          # more parts than this in a column, none grouped: they go in one container
+PROTOCOL = (("postgres", "SQL"), ("mysql", "SQL"), ("maria", "SQL"), ("sqlite", "SQL"), ("database", "SQL"),
+            ("redis", "Redis"), ("valkey", "Redis"), ("mongo", "MongoDB"), ("smtp", "SMTP"), ("mail", "SMTP"),
+            ("kafka", "Kafka"), ("rabbit", "AMQP"), ("s3", "S3 API"), ("minio", "S3 API"), ("git", "git"),
+            ("elastic", "HTTP"), ("search", "HTTP"))
+ACTOR_BY_TECH = (            # an entry point importing this is used by: (actor id, label, kind, via)
+    ("mcp", ("agents", "AI agents", "program", "MCP")),
+    ("fastapi", ("clients", "API clients", "program", "HTTPS")),
+    ("flask", ("clients", "API clients", "program", "HTTPS")),
+    ("django", ("clients", "API clients", "program", "HTTPS")),
+    ("express", ("clients", "API clients", "program", "HTTPS")),
+    ("http.server", ("browser", "Browser", "person", "HTTP")),
+    ("argparse", ("developer", "Developer", "person", "terminal")),
+    ("click", ("developer", "Developer", "person", "terminal")),
+    ("typer", ("developer", "Developer", "person", "terminal")),
+    ("textual", ("developer", "Developer", "person", "terminal")),
+)
+
+
+def protocol(label: str, shape: str = "") -> str:
+    low = label.lower()
+    hit = next((p for key, p in PROTOCOL if key in low), "")
+    return hit or ("SQL" if shape == "db" else "HTTPS")
+
+
+def _meta(cfg: Dict[str, Any]) -> Dict[str, dict]:
+    return {c["id"]: c for c in cfg.get("components", []) if "id" in c}
+
+
+def groups_of(bp: dict, cfg: Dict[str, Any], kind: Dict[str, str]) -> Dict[str, str]:
+    """Part -> its container ("g:<name>"), as declared; a crowded column with none declared is one container."""
+    meta = _meta(cfg)
+    out = {cid: "g:" + meta[cid]["group"] for cid in bp["components"] if meta.get(cid, {}).get("group")}
+    by_col: Dict[str, List[str]] = defaultdict(list)
+    for cid in bp["components"]:
+        if cid not in out and not bp["components"][cid].get("quiet"):
+            by_col[kind.get(cid, "logic")].append(cid)
+    heading = dict(cfg["picture"]["columns"])
+    for col, parts in by_col.items():
+        if col in ("logic", "data") and len(parts) > CROWDED and not any(kind.get(p) == col for p in out):
+            for p in parts:
+                out[p] = "g:" + heading.get(col, col)
+    return out
+
+
+def _stack(bp: dict, part: str, extra: Optional[Dict[str, Dict[str, int]]]) -> Set[str]:
+    names = set((bp.get("stack") or {}).get(part, {})) | set((extra or {}).get(part, {}))
+    return names | {n.split(".")[0] for n in names}
+
+
+def actors(bp: dict, cfg: Dict[str, Any], kind: Dict[str, str],
+           stack: Optional[Dict[str, Dict[str, int]]] = None) -> Tuple[List[dict], List[dict]]:
+    """The actors and their flows into the entry points: as declared, else inferred from what each entry point is
+    built with. A front end's people use it in a browser; an API a front end calls has the front end as its caller."""
+    declared = cfg.get("actors") or []
+    nodes, flows = [], []
+    if declared:
+        for a in declared:
+            aid = "a:" + a["id"]
+            nodes.append({"id": aid, "col": "actors", "type": "actor", "title": a.get("label", a["id"]),
+                          "sub": a.get("about", a.get("kind", "")), "status": "same"})
+            for use in a.get("uses", []):
+                part, _, via = str(use).partition(":")
+                if part in bp["components"]:
+                    flows.append({"from": aid, "to": part, "label": via or a.get("via", ""), "kind": "call"})
+        return nodes, flows
+    called_by_ui = {key.split(">")[1] for key in bp["api"]}
+    found: Dict[str, dict] = {}
+    for cid in sorted(bp["components"], key=lambda c: graph.part_order(bp["components"][c], c)):
+        k = kind.get(cid)
+        if k == "ui":
+            hit = ("people", "People", "person", "browser")
+        elif k == "interface":
+            names = _stack(bp, cid, stack)
+            hit = next((a for tech, a in ACTOR_BY_TECH if tech in names), None)
+            if hit and hit[0] == "clients" and cid in called_by_ui:
+                hit = None                          # its front end is its caller, drawn as a flow already
+            if hit is None and any(o == cid for o in bp["routes"].values()) and cid not in called_by_ui:
+                hit = ("clients", "API clients", "program", "HTTPS")
+        else:
+            continue
+        if hit:
+            aid = "a:" + hit[0]
+            found.setdefault(aid, {"id": aid, "col": "actors", "type": "actor", "title": hit[1], "sub": hit[2],
+                                   "status": "same"})
+            flows.append({"from": aid, "to": cid, "label": hit[3], "kind": "call"})
+    return list(found.values()), flows
+
+
+def _entry_sub(bp: dict, cid: str, cfg: Dict[str, Any]) -> str:
+    about = _meta(cfg).get(cid, {}).get("about", "")
+    routes = sum(1 for o in bp["routes"].values() if o == cid)
+    if routes:
+        return f"{routes} endpoint{'' if routes == 1 else 's'}" + (f" · {about}" if about else "")
+    return about or graph.files_word(bp["components"][cid]["files"])
+
+
+def outside_nodes(bp: dict, cfg: Dict[str, Any], before: Optional[dict] = None) -> Tuple[List[dict], List[dict]]:
+    """Stores and outside systems with the flows from the parts that use them: those the settings name (the
+    blueprint's), and those the config ties to parts itself (`used_by`)."""
+    nodes: Dict[str, dict] = {}
+    flows = []
+    for side in [s for s in (before, bp) if s]:
+        for x, e in side["externals"].items():
+            db = e.get("shape") == "db"
+            nodes["x:" + x] = {"id": "x:" + x, "col": "store" if db else "external", "type": "store" if db else "host",
+                               "title": e["label"], "status": "same", "sub": ""}
+    for x, e in bp["externals"].items():
+        tables = len(bp["tables"]) if x == bp.get("store", "postgres") else 0
+        nodes["x:" + x]["sub"] = f"{tables} tables" if tables else f"used by {len(e['used_by'])}"
+        for u in e["used_by"]:
+            flows.append({"from": u, "to": "x:" + x, "label": protocol(e["label"], e.get("shape", "")),
+                          "kind": "data" if e.get("shape") == "db" else "network"})
+    for e in cfg.get("externals", []):
+        users = [u for u in e.get("used_by", []) if u in bp["components"]]
+        if not users or "x:" + e["id"] in nodes and "x:" + e["id"] in {f["to"] for f in flows}:
+            continue
+        db = e.get("shape") in ("db", "files")
+        nodes["x:" + e["id"]] = {"id": "x:" + e["id"], "col": "store" if db else "external",
+                                 "type": "store" if db else "host", "title": e["label"], "status": "same",
+                                 "sub": e.get("about", "")}
+        for u in users:
+            flows.append({"from": u, "to": "x:" + e["id"], "label": e.get("via") or protocol(e["label"], e.get("shape", "")),
+                          "kind": "data" if db else "network"})
+    return list(nodes.values()), flows
+
+
+def _status(marks: dict, nid: str) -> str:
+    return marks["status"].get(nid, "same")
+
+
+def system(cmp, marks: Optional[dict] = None, agent: Optional[str] = None,
+           stack: Optional[Dict[str, Dict[str, int]]] = None) -> Dict[str, Any]:
+    """The system level: {"columns", "nodes", "edges"}, ready for canvas.layered. A container's node lists its
+    components as `items`; a flow names the boxes it joins and, where one end is a component in a container, that
+    component (`from_item`, `to_item`), so a picked component lights its own flows."""
+    bp, before, cfg = cmp.after, cmp.before, cmp.cfg
+    marks = marks or graph.change_marks(cmp.diff, before, bp)
+    kind = {**kinds(before, cfg), **kinds(bp, cfg)}
+    group = {**groups_of(before, cfg, kind), **groups_of(bp, cfg, kind)}
+    meta = _meta(cfg)
+    comps = {**before["components"], **bp["components"]}
+    gone = set(before["components"]) - set(bp["components"])
+
+    nodes: Dict[str, dict] = {}
+    box_of: Dict[str, str] = {}
+    for cid in sorted(comps, key=lambda c: graph.part_order(comps[c], c)):
+        c = comps[cid]
+        if c.get("quiet"):
+            continue
+        st = "removed" if cid in gone else _status(marks, cid)
+        col = kind.get(cid, "logic")
+        if cid in group:
+            gid = group[cid]
+            box = nodes.setdefault(gid, {"id": gid, "col": col, "type": "group", "title": gid[2:], "sub": "",
+                                         "status": "same", "items": []})
+            box["items"].append({"id": cid, "title": c["label"], "status": st, "agent": cid == agent,
+                                 "hub": bool(c.get("hub"))})
+            box_of[cid] = gid
+        else:
+            nodes[cid] = {"id": cid, "col": col, "type": "component", "title": c["label"], "status": st,
+                          "agent": cid == agent, "sub": (_entry_sub(bp, cid, cfg) if cid in bp["components"]
+                                                          and col in ("interface", "ui") else
+                                                          meta.get(cid, {}).get("about", "")
+                                                          or graph.files_word(c["files"]))}
+            box_of[cid] = cid
+    for box in nodes.values():
+        if box["type"] == "group":
+            items = box["items"]
+            box["sub"] = f"{len(items)} " + ("entry points" if box["col"] in ("interface", "ui") else "components")
+            if any(i["status"] != "same" for i in items):
+                box["status"] = "changed"
+            box["agent"] = any(i["agent"] for i in items)
+
+    acts, flows = actors(bp, cfg, kind, stack)
+    outs, out_flows = outside_nodes(bp, cfg, before)
+    for n in acts + outs:
+        n["status"] = _status(marks, n["id"])
+        nodes[n["id"]] = n
+        box_of[n["id"]] = n["id"]
+    flows += out_flows
+
+    # every connection between parts, lifted to the boxes that hold them; within one box it is not drawn
+    now = graph.connections(bp)
+    for (s, t), (k, _n) in now.items():
+        if k == "call" and not t.startswith("x:") and not comps.get(t, {}).get("hub"):
+            flows.append({"from": s, "to": t, "label": "HTTP" if f"{s}>{t}" in bp["api"] else "", "kind": "call"})
+    for (s, t), (k, st) in marks["edges"].items():
+        if st == "removed" and (s, t) not in now:
+            flows.append({"from": s, "to": t, "label": "", "kind": k, "status": "removed"})
+
+    edges: Dict[Tuple[str, str], dict] = {}
+    for f in flows:
+        a, b = box_of.get(f["from"]), box_of.get(f["to"])
+        if not a or not b or a == b:
+            continue
+        st = f.get("status") or marks["edges"].get((f["from"], f["to"]), (f["kind"], "same"))[1]
+        e = edges.setdefault((a, b), {"from": a, "to": b, "kind": f["kind"], "label": f.get("label", ""),
+                                      "status": "same", "pairs": []})
+        e["pairs"].append([f["from"], f["to"]])
+        if st != "same" and (e["status"] == "same" or st == "removed"):
+            e["status"] = st
+        if f.get("label") and f["label"] not in e["label"].split(", "):
+            e["label"] = f"{e['label']}, {f['label']}" if e["label"] else f["label"]
+    for e in edges.values():   # one component at an end: the flow meets it on its row
+        if len(e["label"]) > 16:
+            e["label"] = e["label"].split(", ")[0] + " +"
+        froms = {p[0] for p in e["pairs"]}
+        tos = {p[1] for p in e["pairs"]}
+        if nodes[e["from"]]["type"] == "group" and len(froms) == 1:
+            e["from_item"] = next(iter(froms))
+        if nodes[e["to"]]["type"] == "group" and len(tos) == 1:
+            e["to_item"] = next(iter(tos))
+    heading = dict(cfg["picture"]["columns"])
+    for n in nodes.values():
+        n["col"] = SYSTEM_COLUMN.get(n["col"], n["col"])
+    # the main flows: not one entry point starting another (one program's wiring), and from each box its strongest
+    # few; every flow that changed stays. The rest show in a box's own view.
+    kept: Dict[str, List[dict]] = defaultdict(list)
+    for e in sorted(edges.values(), key=lambda e: (e["status"] == "same", -len(e["pairs"]), e["to"])):
+        same_col = nodes[e["from"]]["col"] == nodes[e["to"]]["col"] in ("interface", "ui", "actors")
+        if e["status"] != "same" or (not same_col and len(kept[e["from"]]) < MAIN_FLOWS):
+            kept[e["from"]].append(e)
+    edges = {(e["from"], e["to"]): e for es in kept.values() for e in es}
+    columns = COLUMNS_FIRST + [("ui", heading.get("ui", "What people use")),
+                               ("interface", heading.get("interface", "Entry points")),
+                               ("core", "Inside the system"), ("outside", "Data and outside")]
+    return {"columns": columns, "nodes": list(nodes.values()), "edges": list(edges.values())}
+
+
+def container(cmp, box: str, marks: Optional[dict] = None, agent: Optional[str] = None,
+              stack: Optional[Dict[str, Dict[str, int]]] = None) -> Optional[Dict[str, Any]]:
+    """One box zoomed in on: a container's components (or a lone part) as boxes, with the connections between them
+    and every box outside it that they connect to, each flow as at the system level."""
+    whole = system(cmp, marks, agent, stack)
+    nodes = {n["id"]: n for n in whole["nodes"]}
+    if box not in nodes:
+        holder = next((n["id"] for n in whole["nodes"] if any(i["id"] == box for i in n.get("items", []))), None)
+        if holder is None:
+            return None
+        box = holder
+    me = nodes[box]
+    inside = [i["id"] for i in me.get("items", [])] or [box]
+    item = {i["id"]: i for i in me.get("items", [])}
+    bp, before, cfg = cmp.after, cmp.before, cmp.cfg
+    marks = marks or graph.change_marks(cmp.diff, before, bp)
+    kind = {**kinds(before, cfg), **kinds(bp, cfg)}
+    comps = {**before["components"], **bp["components"]}
+    out_nodes: Dict[str, dict] = {}
+    for cid in inside:
+        if cid in item:
+            i = item[cid]
+            out_nodes[cid] = {"id": cid, "col": kind.get(cid, me["col"]), "type": "component", "title": i["title"],
+                              "status": i["status"], "agent": i["agent"],
+                              "sub": _meta(cfg).get(cid, {}).get("about", "") or graph.files_word(comps[cid]["files"])}
+        else:
+            out_nodes[cid] = dict(me)
+    edges = []
+    # inside: component to component
+    now = graph.connections(bp)
+    for (s, t), (k, _n) in sorted(now.items()):
+        if s in inside and t in inside and s != t and k == "call":
+            edges.append({"from": s, "to": t, "kind": "call", "label": "",
+                          "status": marks["edges"].get((s, t), (k, "same"))[1]})
+    # out of and into the box: the system level's flows, met at their components
+    for e in whole["edges"]:
+        if box not in (e["from"], e["to"]):
+            continue
+        other = e["to"] if e["from"] == box else e["from"]
+        on = nodes[other]
+        out_nodes.setdefault(other, {**on, "items": None, "type": "component" if on["type"] == "group" else on["type"]}
+                             if on["type"] == "group" else dict(on))
+        if on["type"] == "group":
+            out_nodes[other]["sub"] = f"{len(on['items'])} components"
+        for s, t in e["pairs"]:
+            a = s if s in inside else other
+            b = t if t in inside else other
+            if a != b:
+                edges.append({"from": a, "to": b, "kind": e["kind"], "label": e["label"],
+                              "status": marks["edges"].get((s, t), (e["kind"], e["status"]))[1]
+                              if e["status"] == "same" else e["status"]})
+    seen, uniq = set(), []
+    for e in edges:
+        if (e["from"], e["to"]) not in seen:
+            seen.add((e["from"], e["to"]))
+            uniq.append(e)
+    for n in out_nodes.values():
+        if n["id"] in comps and n["id"] in kind:
+            n["col"] = kind[n["id"]]
+        elif n["id"].startswith("x:"):
+            n["col"] = "store" if n.get("type") == "store" else "external"
+        elif n["id"].startswith("g:"):
+            first = next((i["id"] for i in nodes[n["id"]].get("items", [])), "")
+            n["col"] = kind.get(first, "logic")
+    columns = COLUMNS_FIRST + [tuple(c) for c in cfg["picture"]["columns"]]
+    return {"columns": columns, "nodes": list(out_nodes.values()), "edges": uniq, "box": box,
+            "title": me["title"]}