facett_syschart/

lib.rs

//! **facett-syschart** — a **system-map chart**: a handful of *free-positioned*
//! peer nodes (not a layered DAG) joined by edges, each carrying a **badge**
//! (a count / status number) and, when selected, an **inline expandable detail
//! panel**. Click a node to select it; its detail renders in a panel under the
//! canvas. The host owns *what* a node's detail is (a string here; richer hosts
//! draw their own widgets after `ui()` keyed off [`SystemChart::selected`]).
//!
//! This is the piece [`facett_core::draw`]/[`facett_graph::GraphView`] don't
//! cover — those paint a *non-interactive* `Scene`; `DepGraphView` is a
//! *layered* DAG with a fixed deps/dependents drill-down. A "monitoring map" of
//! a few peer systems (a PKI/OIDC/Nexus triangle, a service mesh) wants
//! deterministic positions, a per-node badge, click-select, and a free-form
//! detail panel — that's [`SystemChart`].
//!
//! ## FC-2 / FC-9 contract
//! Built on [`facett_core::Elm`]: the complete observable state lives in one
//! serializable [`SysChartModel`] ([`state`](facett_core::Elm::state)); every
//! input is a [`Msg`] applied through the single mutation path
//! [`update`](SystemChart::update) (FC-2); and [`view`](SystemChart::view) is a
//! **pure** function of `&self` that paints and *returns* the [`Msg`]s the frame
//! produced (FC-9). [`impl_facet_via_elm!`](facett_core::impl_facet_via_elm)
//! writes the `impl Facet` bridge (`for m in view(ui) { update(m) }`). A headless
//! driver ([`facett_core::harness`]) feeds a `Vec<Msg>` and snapshots
//! [`state`](facett_core::Elm::state) with no egui / no GPU.

use egui::{Align2, Color32, FontId, Pos2, Rect, Sense, Stroke, Ui, vec2};
use facett_core::clip::{ClipKind, ClipPayload, CopySource};
use facett_core::{FacetCaps, Semantics, a11y_node, theme};
use serde::{Deserialize, Serialize};

/// One system in the map. Positions are **normalized** (`0.0..=1.0` of the
/// canvas), so the layout is resolution-independent and deterministic — ideal
/// for headless rendering and screenshots.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SysNode {
    /// Stable id (used for selection + edges). Unique within a chart.
    pub id: String,
    /// Human label drawn next to the node.
    pub label: String,
    /// Node colour (the host picks the policy — by status, by hash, …).
    pub color: Color32,
    /// A small count/status badge drawn on the node (e.g. an event count).
    pub badge: u64,
    /// Normalized position in the canvas (`0,0` = top-left, `1,1` = bottom-right).
    pub pos: (f32, f32),
    /// Free-form detail shown in the inline panel when this node is selected.
    /// Hosts that draw richer detail can leave this empty and render their own
    /// widgets after `ui()` keyed off [`SystemChart::selected`].
    pub detail: String,
}

impl SysNode {
    pub fn new(id: impl Into<String>, label: impl Into<String>, color: Color32, pos: (f32, f32)) -> Self {
        Self { id: id.into(), label: label.into(), color, badge: 0, pos, detail: String::new() }
    }
    pub fn badge(mut self, n: u64) -> Self {
        self.badge = n;
        self
    }
    pub fn detail(mut self, d: impl Into<String>) -> Self {
        self.detail = d.into();
        self
    }
}

/// An undirected link between two node ids.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SysEdge {
    pub a: String,
    pub b: String,
}

impl SysEdge {
    pub fn new(a: impl Into<String>, b: impl Into<String>) -> Self {
        Self { a: a.into(), b: b.into() }
    }
}

/// A robot-/CLI-addressable control message — the named boundary a headless
/// driver (or a host toolbar) drives the chart through, the same effect the
/// canvas gestures produce. Applied by [`SystemChart::update`]; the pure
/// [`view`](SystemChart::view) *returns* these (it never mutates `self`).
#[derive(Clone, Debug, PartialEq)]
pub enum Msg {
    /// **Toggle**-select the node with this stable id: selecting the already-
    /// selected node clears it, an unknown id is a no-op (parity with the click).
    Select(String),
    /// Clear any selection.
    ClearSelection,
    /// Set a node's badge count by id (e.g. a live event count). No-op if unknown.
    SetBadge(String, u64),
    /// Set a node's detail text by id. No-op if unknown.
    SetDetail(String, String),
}

/// Side work as data (FC-8). The syschart does no I/O — every [`Msg`] mutates
/// only the in-memory [`SysChartModel`] — so this is uninhabited on purpose: the
/// type-checked statement that [`SystemChart::update`] never asks the host to do
/// anything.
#[derive(Clone, Debug, PartialEq)]
pub enum Effect {}

/// **The complete observable state (FC-1 / FC-3)** of a [`SystemChart`], in one
/// serializable, round-trippable struct: every node + edge, the selection (keyed
/// on the stable [`SysNode::id`], FC-5, so reorder/insert/delete preserves it),
/// and the canvas height. [`SystemChart::state`](facett_core::Elm::state) hands
/// back a `&SysChartModel`; a headless driver ([`facett_core::harness`]) snapshots
/// it after feeding a `Vec<Msg>`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SysChartModel {
    /// Free-positioned peer nodes.
    pub nodes: Vec<SysNode>,
    /// Undirected links between node ids.
    pub edges: Vec<SysEdge>,
    /// Stable id of the selected node (drives the detail panel), keyed on the
    /// domain id ([`SysNode::id`]) not an enumeration index (FC-5).
    pub selected: Option<String>,
    /// Height (px) the node canvas takes before the detail panel.
    pub canvas_h: f32,
}

/// The system-map chart [`Facet`](facett_core::Facet): a tab title plus the
/// complete observable [`SysChartModel`]. The FC-9 pure [`view`](Self::view) reads
/// it and the FC-2 [`update`](Self::update) is the sole path that mutates it.
pub struct SystemChart {
    /// Tab/panel title.
    pub title: String,
    /// All observable state (FC-3).
    pub state: SysChartModel,
}

const NODE_R: f32 = 16.0;

impl SystemChart {
    pub fn new(title: impl Into<String>, nodes: Vec<SysNode>, edges: Vec<SysEdge>) -> Self {
        Self {
            title: title.into(),
            state: SysChartModel { nodes, edges, selected: None, canvas_h: 280.0 },
        }
    }
    pub fn with_canvas_height(mut self, h: f32) -> Self {
        self.state.canvas_h = h;
        self
    }

    /// Build a **layered** system map — the architecture/topology "grouped by
    /// layer" shape. `layers` are top-to-bottom bands (e.g. ingress → services →
    /// storage); each band's nodes are spread evenly across the width and pinned to
    /// that band's vertical position, so the map reads as a constellation diagram
    /// organised by layer. Node `pos` fields are overwritten by the layout; `edges`
    /// (the dependencies) are added as given. This is [`SystemChart::new`] with the
    /// free positions computed from the layering instead of supplied.
    pub fn from_layers(title: impl Into<String>, layers: Vec<Vec<SysNode>>, edges: Vec<SysEdge>) -> Self {
        let n_layers = layers.len().max(1) as f32;
        let mut nodes = Vec::new();
        for (li, layer) in layers.into_iter().enumerate() {
            // Band y: single layer sits mid-canvas; otherwise 0.12..=0.88 evenly.
            let y = if n_layers <= 1.0 { 0.5 } else { 0.12 + (li as f32) * (0.76 / (n_layers - 1.0)) };
            let count = layer.len().max(1) as f32;
            for (ni, mut node) in layer.into_iter().enumerate() {
                let x = if count <= 1.0 { 0.5 } else { 0.1 + (ni as f32) * (0.8 / (count - 1.0)) };
                node.pos = (x, y);
                nodes.push(node);
            }
        }
        Self::new(title, nodes, edges)
    }

    /// A self-contained **demo constellation map** — a small nordisk architecture in
    /// three layers (ingress `gateway` → the `korp`/`nornir`/`holger` services →
    /// the `skade`/`iceberg` storage), with dependency edges and per-service badges.
    /// The fixture the `syschart_panel` demo (and the Pages site) mounts.
    #[must_use]
    pub fn demo() -> Self {
        let c = Color32::from_rgb;
        let layers = vec![
            vec![SysNode::new("gateway", "Gateway", c(120, 200, 255), (0.0, 0.0)).badge(2).detail("ingress · TLS terminate")],
            vec![
                SysNode::new("korp", "korp", c(200, 160, 255), (0.0, 0.0)).badge(5).detail("case + analysis warehouse"),
                SysNode::new("nornir", "nornir", c(160, 255, 180), (0.0, 0.0)).badge(3).detail("orchestrator + test matrix"),
                SysNode::new("holger", "holger", c(255, 200, 140), (0.0, 0.0)).badge(1).detail("registry browser"),
            ],
            vec![
                SysNode::new("skade", "skade", c(140, 190, 255), (0.0, 0.0)).badge(8).detail("lakehouse warehouse"),
                SysNode::new("iceberg", "Iceberg", c(180, 220, 160), (0.0, 0.0)).badge(0).detail("table format"),
            ],
        ];
        let edges = vec![
            SysEdge::new("gateway", "korp"),
            SysEdge::new("gateway", "nornir"),
            SysEdge::new("korp", "holger"),
            SysEdge::new("korp", "skade"),
            SysEdge::new("nornir", "skade"),
            SysEdge::new("skade", "iceberg"),
        ];
        Self::from_layers("System Map", layers, edges)
    }

    /// The nodes (read-only view of the model).
    pub fn nodes(&self) -> &[SysNode] {
        &self.state.nodes
    }
    /// The edges (read-only view of the model).
    pub fn edges(&self) -> &[SysEdge] {
        &self.state.edges
    }

    fn index_of(&self, id: &str) -> Option<usize> {
        self.state.nodes.iter().position(|n| n.id == id)
    }

    /// Index of the currently-selected node, resolved from its stable id.
    fn selected_idx(&self) -> Option<usize> {
        self.state.selected.as_deref().and_then(|id| self.index_of(id))
    }

    /// **FC-2 / FC-8** — the single mutation path. Apply one [`Msg`]; returns the
    /// (always empty) [`Effect`]s the host should run. The canvas click routes its
    /// [`Msg`] here too, so live == headless.
    pub fn update(&mut self, msg: Msg) -> Vec<Effect> {
        match msg {
            Msg::Select(id) => {
                if self.index_of(&id).is_some() {
                    self.state.selected = if self.state.selected.as_deref() == Some(id.as_str()) {
                        None
                    } else {
                        Some(id)
                    };
                }
            }
            Msg::ClearSelection => self.state.selected = None,
            Msg::SetBadge(id, badge) => {
                if let Some(i) = self.index_of(&id) {
                    self.state.nodes[i].badge = badge;
                }
            }
            Msg::SetDetail(id, detail) => {
                if let Some(i) = self.index_of(&id) {
                    self.state.nodes[i].detail = detail;
                }
            }
        }
        Vec::new()
    }

    /// Select a node by id (headless-test + host entry point). Selecting the
    /// already-selected node deselects it. Unknown id is a no-op. Thin wrapper
    /// over [`update`](Self::update)`(`[`Msg::Select`]`)` — the single mutation path.
    pub fn select(&mut self, id: &str) {
        let _ = self.update(Msg::Select(id.to_string()));
    }
    /// Clear the selection ([`Msg::ClearSelection`]).
    pub fn clear_selection(&mut self) {
        let _ = self.update(Msg::ClearSelection);
    }
    /// The selected node's id, if any.
    pub fn selected(&self) -> Option<&str> {
        self.state.selected.as_deref()
    }

    /// Update a node's badge by id (e.g. a live event count). No-op if unknown.
    /// Thin wrapper over [`update`](Self::update)`(`[`Msg::SetBadge`]`)`.
    pub fn set_badge(&mut self, id: &str, badge: u64) {
        let _ = self.update(Msg::SetBadge(id.to_string(), badge));
    }
    /// Update a node's detail text by id. No-op if unknown. Thin wrapper over
    /// [`update`](Self::update)`(`[`Msg::SetDetail`]`)`.
    pub fn set_detail(&mut self, id: &str, detail: impl Into<String>) {
        let _ = self.update(Msg::SetDetail(id.to_string(), detail.into()));
    }

    /// **Test/host hook (additive).** The public, return-asserted view of the
    /// private [`center`](Self::center) layout node — the absolute pixel centre
    /// node `i`'s circle is painted at inside `rect`. Exposed so the syschart
    /// call-chain matrix can assert the *layout/place* stage (finite, confined to
    /// the padded inner rect, monotone in the normalized pos) without a painter.
    /// Calls the **same** private fn `view` paints with — additive, no behaviour
    /// change. The node radius the layout pads for is [`SystemChart::NODE_R`].
    pub fn node_center(&self, i: usize, rect: Rect) -> Pos2 {
        self.center(i, rect)
    }
    /// The node radius (px) the free-position layout pads the canvas by, exposed so
    /// the matrix can assert nodes land inside `rect` by exactly this inset.
    pub const NODE_R: f32 = NODE_R;

    /// Absolute pixel centre of node `i` inside `rect`.
    fn center(&self, i: usize, rect: Rect) -> Pos2 {
        let (nx, ny) = self.state.nodes[i].pos;
        let pad = NODE_R + 6.0;
        let inner = Rect::from_min_max(
            rect.min + vec2(pad, pad),
            rect.max - vec2(pad, pad),
        );
        Pos2::new(
            inner.min.x + nx.clamp(0.0, 1.0) * inner.width().max(1.0),
            inner.min.y + ny.clamp(0.0, 1.0) * inner.height().max(1.0),
        )
    }
}

impl SystemChart {
    /// The copyable text: the selected node's `label · detail` (badge in a suffix)
    /// when a node is selected, else the whole node list as a TSV rectangle
    /// (`id \t label \t badge`).
    pub fn copy_text(&self) -> Option<String> {
        if self.state.nodes.is_empty() {
            return None;
        }
        if let Some(n) = self.selected().and_then(|id| self.state.nodes.iter().find(|n| n.id == id)) {
            let mut s = format!("{} (badge {})", n.label, n.badge);
            if !n.detail.is_empty() {
                s.push('\n');
                s.push_str(&n.detail);
            }
            return Some(s);
        }
        let mut out = String::from("id\tlabel\tbadge");
        for n in &self.state.nodes {
            out.push('\n');
            out.push_str(&format!("{}\t{}\t{}", n.id, n.label, n.badge));
        }
        Some(out)
    }

    /// **FC-9 pure view** — a function of `&self`: it paints the chart and *returns*
    /// the [`Msg`]s the frame produced (a node click → [`Msg::Select`]). It does
    /// **not** mutate the model; the [`impl_facet_via_elm!`](facett_core::impl_facet_via_elm)
    /// bridge applies the returned messages through [`update`](Self::update), so a
    /// headless driver feeding the same [`Msg`]s reproduces the live behaviour.
    pub fn view(&self, ui: &mut Ui) -> Vec<Msg> {
        let mut msgs: Vec<Msg> = Vec::new();
        let th = theme(ui);
        // ── node canvas ──────────────────────────────────────────────────────
        let canvas = vec2(
            ui.available_width(),
            self.state.canvas_h.min(ui.available_height().max(self.state.canvas_h)),
        );
        let (rect, _resp) = ui.allocate_exact_size(canvas, Sense::hover());
        let base = ui.id().with("syschart-node");
        let painter = ui.painter_at(rect);

        let centers: Vec<Pos2> = (0..self.state.nodes.len()).map(|i| self.center(i, rect)).collect();

        // edges first (under the nodes)
        for e in &self.state.edges {
            if let (Some(ai), Some(bi)) = (self.index_of(&e.a), self.index_of(&e.b)) {
                painter.line_segment([centers[ai], centers[bi]], Stroke::new(1.5, th.edge));
            }
        }

        // nodes — paint, plus an AccessKit node per element (FC-4) keyed on the
        // stable domain id (FC-5). A click is collected as a `Msg::Select` and
        // RETURNED; the `update` bridge applies the (toggle) selection — the view
        // itself stays pure (no `self` mutation).
        let sel_id = self.state.selected.clone();
        for (i, node) in self.state.nodes.iter().enumerate() {
            let c = centers[i];
            let selected = sel_id.as_deref() == Some(node.id.as_str());
            let r = if selected { NODE_R + 3.0 } else { NODE_R };
            // Elevation shadow under the raised node chip (Windows-pronounced /
            // macOS-restrained, per the active NativeFeel) — painted BEFORE the fill
            // so it sits behind the node. No-op under Device (effects-off).
            facett_core::look::elevation_shadow(ui, Rect::from_center_size(c, vec2(2.0 * r, 2.0 * r)), r);
            painter.circle_filled(c, r, node.color);
            let ring = if selected { th.accent } else { th.node_stroke };
            painter.circle_stroke(c, r, Stroke::new(if selected { 2.5 } else { 1.0 }, ring));
            // badge inside the node
            painter.text(c, Align2::CENTER_CENTER, node.badge.to_string(), FontId::proportional(11.0), th.text);
            // label under the node
            painter.text(
                c + vec2(0.0, r + 2.0),
                Align2::CENTER_TOP,
                &node.label,
                FontId::proportional(11.0),
                th.text,
            );

            // AccessKit hit-test node over the node's circle (FC-4): role=Button,
            // label = "{label} · {badge} events", numeric_value = badge, selected.
            let node_rect = Rect::from_center_size(c, vec2(2.0 * r, 2.0 * r));
            // ── native-feel cues (mac/windows parity): the Windows reveal glow on
            // hover + the platform focus ring/rect on the selected node. Both read
            // the active Theme's NativeFeel through the shared `look::feel` helpers,
            // so this node follows the platform preset (no-op on Neutral/Device).
            facett_core::look::reveal_on_hover(ui, node_rect, r);
            facett_core::look::apply_focus_ring(ui, node_rect, selected, r);
            let label = format!("{} · {} events", node.label, node.badge);
            let hit = a11y_node(
                ui,
                base,
                &node.id,
                Sense::click(),
                node_rect,
                Semantics::button(label).value(node.badge as f64).selected(selected),
            );
            if hit.clicked() {
                msgs.push(Msg::Select(node.id.clone()));
            }
        }

        // ── inline detail panel ──────────────────────────────────────────────
        ui.separator();
        match self.selected_idx() {
            None => {
                ui.weak("Click a node to expand its detail.");
            }
            Some(i) => {
                let node = &self.state.nodes[i];
                ui.horizontal(|ui| {
                    ui.strong(&node.label);
                    ui.weak(format!("· {} events", node.badge));
                });
                if node.detail.is_empty() {
                    ui.weak("(no detail)");
                } else {
                    for line in node.detail.lines() {
                        ui.monospace(line);
                    }
                }
            }
        }

        // ── render-lane emit: this view path RAN ──────────────────────────────
        #[cfg(feature = "testmatrix")]
        facett_core::testmatrix::emit(
            "facett-syschart::SystemChart::view",
            "ui_render",
            !self.state.nodes.is_empty(),
            &format!("nodes={} edges={}", self.state.nodes.len(), self.state.edges.len()),
        );

        msgs
    }
}

// ── typed copy (§16) — read-only: selected node text or node-list rows ─────────
impl CopySource for SystemChart {
    fn copy_kinds(&self) -> &[ClipKind] {
        &[ClipKind::Text]
    }

    fn copy_payload(&self) -> Option<ClipPayload> {
        self.copy_text().map(ClipPayload::Text)
    }
}

// ── the Elm contract (FC-2 / FC-9) ─────────────────────────────────────────────
impl facett_core::Elm for SystemChart {
    type Model = SysChartModel;
    type Msg = Msg;
    type Effect = Effect;

    fn title(&self) -> &str {
        &self.title
    }
    fn state(&self) -> &SysChartModel {
        &self.state
    }
    fn update(&mut self, msg: Msg) -> Vec<Effect> {
        SystemChart::update(self, msg)
    }
    fn view(&self, ui: &mut Ui) -> Vec<Msg> {
        SystemChart::view(self, ui)
    }
}

// The bridge macro writes `impl Facet for SystemChart` from the `Elm` impl:
// `title`, the FC-9 `ui` loop (`for m in view(ui) { update(m) }`), plus the extra
// overrides below. **Form 3** (`custom_state_json`) because the chart publishes a
// RICHER `state_json` than plain `serde(state())` — it flattens each node to
// `id/label/badge/pos/has_detail` (colour omitted, detail as a bool) and each edge
// to an `[a,b]` pair, exactly the observable shape the demo's mega-matrix asserts.
facett_core::impl_facet_via_elm!(SystemChart, custom_state_json, {
    fn copy(&mut self) -> Option<String> {
        self.copy_payload().map(|p| p.as_text())
    }

    fn state_json(&self) -> serde_json::Value {
        let s = &self.state;
        serde_json::json!({
            "nodes": s.nodes.iter().map(|n| serde_json::json!({
                "id": n.id,
                "label": n.label,
                "badge": n.badge,
                "pos": [n.pos.0, n.pos.1],
                "has_detail": !n.detail.is_empty(),
            })).collect::<Vec<_>>(),
            "edges": s.edges.iter().map(|e| serde_json::json!([e.a, e.b])).collect::<Vec<_>>(),
            "selected": self.selected(),
        })
    }

    fn selection_json(&self) -> serde_json::Value {
        match self.selected() {
            Some(id) => serde_json::json!(id),
            None => serde_json::Value::Null,
        }
    }

    /// Painted with the active `Theme` (nodes/edges/text/accent ring), and its
    /// canvas takes the host's available width — themeable + resizable.
    fn caps(&self) -> FacetCaps {
        FacetCaps::NONE.themeable().resizable().selectable().copyable()
    }

    /// Opt into typed downcast so a host (e.g. the demo's robot-UI node-select
    /// toolbar) can forward a selection to [`SystemChart::select`] when this chart
    /// lives boxed inside a `FacetDeck`.
    fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
        Some(self)
    }
});

#[cfg(test)]
mod tests {
    use super::*;
    // `Elm` for `state()`; `Facet` for `state_json`/`selection_json`.
    use facett_core::{Elm, Facet, harness};

    #[test]
    fn typed_copy_is_selected_node_or_node_list_rows() {
        use facett_core::clip::{ClipKind, CopySource};
        let mut c = SystemChart::new(
            "sys",
            vec![
                SysNode::new("pki", "PKI", Color32::WHITE, (0.1, 0.1)).badge(3),
                SysNode::new("oidc", "OIDC", Color32::WHITE, (0.9, 0.1)).badge(7),
            ],
            vec![SysEdge::new("pki", "oidc")],
        );
        // No selection -> the node list as a TSV rectangle.
        let p = c.copy_payload().unwrap();
        assert_eq!(p.kind(), ClipKind::Text);
        assert!(p.as_text().starts_with("id\tlabel\tbadge"), "{}", p.as_text());
        assert!(p.as_text().contains("\npki\tPKI\t3"));
        // Selecting narrows to that node's label + badge.
        c.select("oidc");
        assert_eq!(c.copy_payload().unwrap().as_text(), "OIDC (badge 7)");
        assert!(SystemChart::new("empty", vec![], vec![]).copy_payload().is_none());
    }

    fn sample() -> SystemChart {
        let nodes = vec![
            SysNode::new("pki", "PKI", Color32::from_rgb(120, 200, 255), (0.1, 0.1)).badge(3).detail("issued: a\nissued: b"),
            SysNode::new("oidc", "OIDC", Color32::from_rgb(200, 160, 255), (0.9, 0.1)).badge(7),
            SysNode::new("nexus", "Nexus", Color32::from_rgb(160, 255, 180), (0.5, 0.9)).badge(0),
        ];
        let edges = vec![
            SysEdge::new("pki", "oidc"),
            SysEdge::new("pki", "nexus"),
            SysEdge::new("oidc", "nexus"),
        ];
        SystemChart::new("System Map", nodes, edges)
    }

    #[test]
    fn select_toggles_and_reports() {
        let mut c = sample();
        assert_eq!(c.selected(), None);
        c.select("oidc");
        assert_eq!(c.selected(), Some("oidc"));
        c.select("oidc"); // toggle off
        assert_eq!(c.selected(), None);
        c.select("nope"); // unknown → no-op
        assert_eq!(c.selected(), None);
    }

    #[test]
    fn set_badge_and_detail_mutate_named_node() {
        let mut c = sample();
        c.set_badge("nexus", 42);
        c.set_detail("nexus", "repo: maven-releases");
        let nexus = c.nodes().iter().find(|n| n.id == "nexus").unwrap();
        assert_eq!(nexus.badge, 42);
        assert!(nexus.detail.contains("maven-releases"));
    }

    #[test]
    fn state_json_carries_every_node_edge_and_selection() {
        let mut c = sample();
        c.select("pki");
        let j = c.state_json();
        assert_eq!(j["nodes"].as_array().unwrap().len(), 3);
        assert_eq!(j["edges"].as_array().unwrap().len(), 3);
        assert_eq!(j["selected"], "pki");
        // badge + detail flags surfaced for robot assertions
        let pki = j["nodes"].as_array().unwrap().iter().find(|n| n["id"] == "pki").unwrap();
        assert_eq!(pki["badge"], 3);
        assert_eq!(pki["has_detail"], true);
    }

    #[test]
    fn headless_render_draws_and_selection_shows_detail() {
        // Inject a real chart + a real selection, render offscreen, assert it
        // both DREW pixels and reported the selected node in its state — the
        // inject-input/assert-output law, no display.
        let mut c = sample();
        c.select("pki");
        let r = harness::headless_render(&mut c);
        assert_eq!(r.title, "System Map");
        assert!(r.drew(), "a 3-node chart should tessellate to vertices");
        assert_eq!(r.state["selected"], "pki");
        assert_eq!(r.state["nodes"].as_array().unwrap().len(), 3);
    }

    #[test]
    fn caps_advertise_selectable_themeable_resizable() {
        let caps = sample().caps();
        assert!(caps.selectable);
        assert!(caps.themeable);
        assert!(caps.resizable);
        assert!(!caps.scalable, "syschart has no zoom yet");
    }

    // ── FC-2 / FC-9 harness properties: drive `Msg`s, snapshot `state()`, no GPU ──

    #[test]
    fn drive_select_toggles_via_msg_no_effects() {
        let mut c = sample();
        // Select → the id lands; select again → toggles off; unknown id → no-op.
        let fx = harness::drive(&mut c, [Msg::Select("oidc".into())]);
        assert!(fx.is_empty(), "syschart issues no Effects (uninhabited)");
        assert_eq!(c.state().selected.as_deref(), Some("oidc"));
        harness::drive(&mut c, [Msg::Select("oidc".into())]);
        assert_eq!(c.state().selected, None, "re-select toggles off");
        harness::drive(&mut c, [Msg::Select("ghost".into())]);
        assert_eq!(c.state().selected, None, "unknown id is a no-op");
    }

    #[test]
    fn drive_clear_selection_via_msg() {
        let mut c = sample();
        let snap = harness::snapshot(&mut c, [Msg::Select("pki".into()), Msg::ClearSelection]);
        assert_eq!(snap.selected, None);
    }

    #[test]
    fn drive_set_badge_and_detail_via_msg() {
        let mut c = sample();
        let snap = harness::snapshot(
            &mut c,
            [
                Msg::SetBadge("nexus".into(), 42),
                Msg::SetDetail("nexus".into(), "repo: maven-releases".into()),
                // unknown ids are inert
                Msg::SetBadge("ghost".into(), 99),
            ],
        );
        let nexus = snap.nodes.iter().find(|n| n.id == "nexus").unwrap();
        assert_eq!(nexus.badge, 42);
        assert!(nexus.detail.contains("maven-releases"));
        assert!(snap.nodes.iter().all(|n| n.id != "ghost"));
    }

    #[test]
    fn drive_produces_no_effects_for_any_msg() {
        let mut c = sample();
        let fx = harness::drive(
            &mut c,
            [
                Msg::Select("pki".into()),
                Msg::ClearSelection,
                Msg::SetBadge("oidc".into(), 5),
                Msg::SetDetail("oidc".into(), "x".into()),
            ],
        );
        assert!(fx.is_empty(), "the syschart never asks the host to do side work");
    }

    #[test]
    fn from_layers_groups_nodes_into_vertical_bands() {
        let c = SystemChart::from_layers(
            "layered",
            vec![
                vec![SysNode::new("a", "A", Color32::WHITE, (0.0, 0.0))],
                vec![
                    SysNode::new("b", "B", Color32::WHITE, (0.0, 0.0)),
                    SysNode::new("c", "C", Color32::WHITE, (0.0, 0.0)),
                ],
            ],
            vec![SysEdge::new("a", "b")],
        );
        // Every node survived the flatten, layout overwrote positions.
        assert_eq!(c.nodes().len(), 3);
        let y = |id: &str| c.nodes().iter().find(|n| n.id == id).unwrap().pos.1;
        // Band 0 (A) sits above band 1 (B, C), which share a y.
        assert!(y("a") < y("b"), "the first layer is above the second");
        assert!((y("b") - y("c")).abs() < f32::EPSILON, "same-layer nodes share a band");
        // A single node in a band is centred; two are spread apart horizontally.
        let x = |id: &str| c.nodes().iter().find(|n| n.id == id).unwrap().pos.0;
        assert!((x("a") - 0.5).abs() < f32::EPSILON, "a lone node centres");
        assert!(x("b") < x("c"), "peers spread across the band");
    }

    #[test]
    fn demo_is_a_layered_constellation_that_renders() {
        let mut c = SystemChart::demo();
        assert_eq!(c.nodes().len(), 6, "gateway + 3 services + 2 storage");
        assert_eq!(c.edges().len(), 6);
        // Three distinct vertical bands (gateway / services / storage).
        use std::collections::BTreeSet;
        let bands: BTreeSet<i32> = c.nodes().iter().map(|n| (n.pos.1 * 1000.0) as i32).collect();
        assert_eq!(bands.len(), 3, "three layers ⇒ three vertical bands");
        // The demo fixture paints headlessly (the same panel the host mounts).
        let r = harness::headless_render(&mut c);
        assert_eq!(r.title, "System Map");
        assert!(r.drew(), "a 6-node constellation tessellates to vertices");
        assert_eq!(r.state["nodes"].as_array().unwrap().len(), 6);
    }

    #[test]
    fn model_serde_round_trips() {
        let mut c = sample();
        c.select("oidc");
        let json = serde_json::to_value(c.state()).unwrap();
        let back: SysChartModel = serde_json::from_value(json).unwrap();
        assert_eq!(&back, c.state(), "the Model round-trips through serde (FC-3)");
    }
}