From 869d739780882d204ae02f05857662bba657edc6 Mon Sep 17 00:00:00 2001
From: konojunya <junya03dance@gmail.com>
Date: Sun, 6 Sep 2026 09:32:42 +0900
Subject: [PATCH 1/3] test: establish geometry quality gates with a red corpus
 baseline

---
 crates/stack-engine/src/layout_quality.rs     | 1311 +++++++++++++++++
 .../src/layout_quality/geometry.rs            |  529 +++++++
 crates/stack-engine/src/lib.rs                |    3 +
 layout-corpus/README.md                       |   55 +
 4 files changed, 1898 insertions(+)
 create mode 100644 crates/stack-engine/src/layout_quality.rs
 create mode 100644 crates/stack-engine/src/layout_quality/geometry.rs

diff --git a/crates/stack-engine/src/layout_quality.rs b/crates/stack-engine/src/layout_quality.rs
new file mode 100644
index 0000000..6516293
--- /dev/null
+++ b/crates/stack-engine/src/layout_quality.rs
@@ -0,0 +1,1311 @@
+//! Independent quality gates over the final SVG, not approved snapshot equality.
+//!
+//! This module exists only in test builds. Geometry is a logical layout envelope,
+//! not a claim about platform-specific glyph rasterization or arbitrary SVG paths.
+
+mod geometry;
+
+use std::collections::BTreeSet;
+use std::error::Error;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use roxmltree::{Document, Node};
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use crate::{Engine, ProviderAsset, ProviderPack, scene};
+use geometry::{Point, Rect};
+
+type Result<T> = std::result::Result<T, Box<dyn Error>>;
+
+#[derive(Debug)]
+struct TextBox {
+    id: String,
+    rect: Rect,
+}
+
+#[derive(Debug)]
+struct Route {
+    id: String,
+    from: String,
+    to: String,
+    points: Vec<Point>,
+    radius: i64,
+}
+
+#[derive(Debug)]
+struct Drawing {
+    bounds: Rect,
+    texts: Vec<TextBox>,
+    nodes: Vec<(String, Rect)>,
+    routes: Vec<Route>,
+}
+
+fn rect(value: scene::Rect) -> Rect {
+    Rect {
+        x: value.x,
+        y: value.y,
+        width: value.width,
+        height: value.height,
+    }
+}
+
+fn required<'a>(node: Node<'a, '_>, name: &str) -> Result<&'a str> {
+    node.attribute(name)
+        .ok_or_else(|| format!("missing {name} on {}", node.tag_name().name()).into())
+}
+
+fn number(node: Node<'_, '_>, name: &str) -> Result<i64> {
+    Ok(required(node, name)?.parse()?)
+}
+
+fn rectangle(node: Node<'_, '_>) -> Result<Rect> {
+    let value = Rect {
+        x: number(node, "x")?,
+        y: number(node, "y")?,
+        width: number(node, "width")?,
+        height: number(node, "height")?,
+    };
+    if value.width <= 0 || value.height <= 0 {
+        return Err("non-positive rectangle".into());
+    }
+    Ok(value)
+}
+
+fn is_embedded(node: Node<'_, '_>) -> bool {
+    node.ancestors()
+        .skip(1)
+        .any(|ancestor| ancestor.has_tag_name("svg") && ancestor.parent_element().is_some())
+}
+
+fn text_rectangle(
+    node: Node<'_, '_>,
+    prepared: &crate::PreparedScene<'_>,
+    size: u32,
+) -> Result<Rect> {
+    let metrics = prepared.resources.metrics;
+    let width = scene::text_width(node.text().ok_or("empty text")?, size, metrics);
+    let ascent = (i64::from(metrics.ascent) * i64::from(size) + i64::from(metrics.units_per_em)
+        - 1)
+        / i64::from(metrics.units_per_em);
+    let descent = (i64::from(-metrics.descent) * i64::from(size) + i64::from(metrics.units_per_em)
+        - 1)
+        / i64::from(metrics.units_per_em);
+    let height =
+        scene::line_height(size, &prepared.resources.theme.typography).max(ascent + descent);
+    let mut x = number(node, "x")?;
+    match node.attribute("text-anchor").unwrap_or("start") {
+        "start" => {}
+        "middle" => x -= width / 2,
+        "end" => x -= width,
+        _ => return Err("unsupported text-anchor".into()),
+    }
+    let y = number(node, "y")?;
+    let top = match node.attribute("dominant-baseline").unwrap_or("alphabetic") {
+        "alphabetic" => y - ascent - (height - ascent - descent) / 2,
+        // A deterministic layout reservation, not the browser's exact glyph box:
+        // SVG middle depends on the font's x-height, absent from current metrics.
+        "middle" => y - height / 2,
+        _ => return Err("unsupported dominant-baseline".into()),
+    };
+    Ok(Rect {
+        x,
+        y: top,
+        width,
+        height,
+    })
+}
+
+fn point_list(value: &str) -> Result<Vec<Point>> {
+    value
+        .split_whitespace()
+        .map(|pair| {
+            let (x, y) = pair.split_once(',').ok_or("invalid point")?;
+            Ok(Point {
+                x: x.parse()?,
+                y: y.parse()?,
+            })
+        })
+        .collect()
+}
+
+fn point_envelope(points: &[Point]) -> Result<Rect> {
+    let x = points
+        .iter()
+        .map(|point| point.x)
+        .min()
+        .ok_or("empty geometry")?;
+    let y = points
+        .iter()
+        .map(|point| point.y)
+        .min()
+        .ok_or("empty geometry")?;
+    let right = points
+        .iter()
+        .map(|point| point.x)
+        .max()
+        .ok_or("empty geometry")?;
+    let bottom = points
+        .iter()
+        .map(|point| point.y)
+        .max()
+        .ok_or("empty geometry")?;
+    let width = right.checked_sub(x).ok_or("geometry overflow")?;
+    let height = bottom.checked_sub(y).ok_or("geometry overflow")?;
+    if width <= 0 || height <= 0 {
+        return Err("non-positive geometry envelope".into());
+    }
+    Ok(Rect {
+        x,
+        y,
+        width,
+        height,
+    })
+}
+
+fn shape_envelope(node: Node<'_, '_>) -> Result<Rect> {
+    match node.tag_name().name() {
+        "rect" => rectangle(node),
+        "circle" | "ellipse" => {
+            let rx = number(
+                node,
+                if node.has_tag_name("circle") {
+                    "r"
+                } else {
+                    "rx"
+                },
+            )?;
+            let ry = number(
+                node,
+                if node.has_tag_name("circle") {
+                    "r"
+                } else {
+                    "ry"
+                },
+            )?;
+            if rx <= 0 || ry <= 0 {
+                return Err("invalid shape radius".into());
+            }
+            Ok(Rect {
+                x: number(node, "cx")?
+                    .checked_sub(rx)
+                    .ok_or("geometry overflow")?,
+                y: number(node, "cy")?
+                    .checked_sub(ry)
+                    .ok_or("geometry overflow")?,
+                width: rx.checked_mul(2).ok_or("geometry overflow")?,
+                height: ry.checked_mul(2).ok_or("geometry overflow")?,
+            })
+        }
+        "polygon" => point_envelope(&point_list(required(node, "points")?)?),
+        "path" => {
+            // Only the current absolute cylinder grammar is supported. Control
+            // points bound each Bezier's convex hull, not its exact painted arc.
+            let tokens = required(node, "d")?.split_whitespace().collect::<Vec<_>>();
+            if tokens.len() != 22
+                || tokens[0] != "M"
+                || tokens[3] != "V"
+                || tokens[5] != "C"
+                || tokens[12] != "V"
+                || tokens[14] != "C"
+                || tokens[21] != "Z"
+            {
+                return Err("unsupported node path grammar".into());
+            }
+            let n = |index: usize| -> Result<i64> { Ok(tokens[index].parse()?) };
+            let mut points = vec![Point { x: n(1)?, y: n(2)? }, Point { x: n(1)?, y: n(4)? }];
+            for start in [6, 8, 10, 15, 17, 19] {
+                points.push(Point {
+                    x: n(start)?,
+                    y: n(start + 1)?,
+                });
+            }
+            points.push(Point {
+                x: n(10)?,
+                y: n(13)?,
+            });
+            point_envelope(&points)
+        }
+        _ => Err("unsupported node shape".into()),
+    }
+}
+
+fn drawing_layer<'a, 'input>(root: Node<'a, 'input>, name: &str) -> Result<Node<'a, 'input>> {
+    let layers = root
+        .children()
+        .filter(|node| node.attribute("data-stack-layer") == Some(name))
+        .collect::<Vec<_>>();
+    if layers.len() != 1 || !layers[0].has_tag_name("g") {
+        return Err(format!("expected one visible {name} group layer").into());
+    }
+    Ok(layers[0])
+}
+
+fn viewport_dimension(node: Node<'_, '_>, name: &str) -> Result<i64> {
+    let value = required(node, name)?;
+    let (whole, fraction) = value.split_once('.').unwrap_or((value, ""));
+    if whole.is_empty()
+        || !whole.bytes().all(|value| value.is_ascii_digit())
+        || fraction.len() > 3
+        || !fraction.bytes().all(|value| value.is_ascii_digit())
+    {
+        return Err("unsupported viewport dimension".into());
+    }
+    let whole: i64 = whole.parse()?;
+    let fraction: i64 = format!("{fraction:0<3}").parse()?;
+    let value = whole
+        .checked_mul(1000)
+        .and_then(|value| value.checked_add(fraction))
+        .ok_or("viewport overflow")?;
+    if value <= 0 {
+        return Err("non-positive viewport".into());
+    }
+    Ok(value)
+}
+
+fn node_envelopes(
+    root: Node<'_, '_>,
+    prepared: &crate::PreparedScene<'_>,
+) -> Result<Vec<(String, Rect)>> {
+    let layer = drawing_layer(root, "nodes")?;
+    let groups = layer
+        .children()
+        .filter(Node::is_element)
+        .collect::<Vec<_>>();
+    if groups.len() != prepared.scene.nodes.len() {
+        return Err("node inventory drift".into());
+    }
+    let mut nodes = Vec::new();
+    for (group, expected) in groups.into_iter().zip(&prepared.scene.nodes) {
+        if !group.has_tag_name("g")
+            || !group.has_attribute("data-node-kind")
+            || required(group, "data-stack-id")? != expected.id
+        {
+            return Err("node inventory drift".into());
+        }
+        let shapes = group
+            .children()
+            .filter(Node::is_element)
+            .filter(|node| !matches!(node.tag_name().name(), "title" | "text" | "svg"))
+            .collect::<Vec<_>>();
+        let shape = prepared
+            .resources
+            .node(&expected.id)
+            .ok_or("missing resolved node")?
+            .visual
+            .shape;
+        let expected_tags: &[&str] = match shape {
+            stack_theme::NodeShape::RoundedRectangle | stack_theme::NodeShape::Capsule => &["rect"],
+            stack_theme::NodeShape::Circle => &["circle"],
+            stack_theme::NodeShape::Cylinder => &["path", "ellipse"],
+            stack_theme::NodeShape::Hexagon => &["polygon"],
+        };
+        if shapes
+            .iter()
+            .map(|node| node.tag_name().name())
+            .collect::<Vec<_>>()
+            != expected_tags
+        {
+            return Err("node shape inventory drift".into());
+        }
+        let envelope = shape_envelope(shapes[0])?;
+        if envelope != rect(expected.rect) {
+            return Err("SVG/scene node envelope drift".into());
+        }
+        for detail in &shapes[1..] {
+            if !geometry::contains(envelope, shape_envelope(*detail)?) {
+                return Err("node decoration outside layout envelope".into());
+            }
+        }
+        let icons = group
+            .children()
+            .filter(|node| node.has_tag_name("svg"))
+            .collect::<Vec<_>>();
+        if icons.len() != 1
+            || required(icons[0], "data-icon-id")?
+                != prepared
+                    .resources
+                    .node(&expected.id)
+                    .ok_or("missing resolved node")?
+                    .icon_id
+            || !geometry::contains(envelope, rectangle(icons[0])?)
+        {
+            return Err("unverified icon SVG viewport".into());
+        }
+        nodes.push((expected.id.clone(), envelope));
+    }
+    Ok(nodes)
+}
+
+fn read_drawing(
+    svg: &str,
+    prepared: &crate::PreparedScene<'_>,
+    diagram: &stack_compiler::ir::Diagram,
+) -> Result<Drawing> {
+    let document = Document::parse(svg)?;
+    if document.descendants().any(|node| node.is_pi()) {
+        return Err("unsupported SVG processing instruction".into());
+    }
+    let root = document.root_element();
+    if !root.has_tag_name(("http://www.w3.org/2000/svg", "svg")) {
+        return Err("expected SVG root".into());
+    }
+    let view_box = required(root, "viewBox")?
+        .split_whitespace()
+        .map(str::parse)
+        .collect::<std::result::Result<Vec<i64>, _>>()?;
+    let expected = prepared.scene.bounds;
+    if view_box != [expected.x, expected.y, expected.width, expected.height] {
+        return Err("SVG/scene bounds drift".into());
+    }
+    if viewport_dimension(root, "width")? != expected.width
+        || viewport_dimension(root, "height")? != expected.height
+    {
+        return Err("SVG/scene viewport drift".into());
+    }
+    let nodes_layer = drawing_layer(root, "nodes")?;
+    let groups_layer = drawing_layer(root, "groups")?;
+    let edge_layer = drawing_layer(root, "edges")?;
+    let labels_layer = drawing_layer(root, "edge-labels")?;
+    for tag in ["title", "desc", "metadata", "rect", "defs", "text"] {
+        if root
+            .children()
+            .filter(|node| node.has_tag_name(tag))
+            .count()
+            != 1
+        {
+            return Err(format!("unexpected root {tag} inventory").into());
+        }
+    }
+    // The owned drawing currently uses untransformed integer coordinates. A new
+    // transform or text positioning mode must be supported, not silently skipped.
+    for node in root
+        .descendants()
+        .filter(Node::is_element)
+        .filter(|node| !is_embedded(*node))
+    {
+        if node.tag_name().namespace() != Some("http://www.w3.org/2000/svg") {
+            return Err("unexpected drawing namespace".into());
+        }
+        if node.has_attribute("data-stack-layer")
+            && (node.parent_element() != Some(root)
+                || ![nodes_layer, groups_layer, edge_layer, labels_layer].contains(&node))
+        {
+            return Err("unexpected drawing layer".into());
+        }
+        let parent = node.parent_element();
+        let in_group = |layer| {
+            parent.is_some_and(|parent| {
+                parent.has_tag_name("g") && parent.parent_element() == Some(layer)
+            })
+        };
+        let in_root = parent == Some(root);
+        let in_marker = parent.is_some_and(|parent| {
+            parent.has_tag_name("marker")
+                && parent.parent_element().is_some_and(|defs| {
+                    defs.has_tag_name("defs") && defs.parent_element() == Some(root)
+                })
+        });
+        let positioned = match node.tag_name().name() {
+            "svg" => node == root || (in_group(nodes_layer) && node.has_attribute("data-icon-id")),
+            "g" => {
+                [nodes_layer, groups_layer, edge_layer, labels_layer].contains(&node)
+                    || parent.is_some_and(|parent| {
+                        [nodes_layer, groups_layer, edge_layer, labels_layer].contains(&parent)
+                    })
+            }
+            "text" => {
+                in_root || in_group(nodes_layer) || in_group(groups_layer) || in_group(labels_layer)
+            }
+            "title" => {
+                in_root || in_group(nodes_layer) || in_group(groups_layer) || in_group(edge_layer)
+            }
+            "desc" | "metadata" | "defs" => in_root,
+            "marker" => parent.is_some_and(|parent| {
+                parent.has_tag_name("defs") && parent.parent_element() == Some(root)
+            }),
+            "rect" => {
+                in_root || in_group(nodes_layer) || in_group(groups_layer) || in_group(labels_layer)
+            }
+            "circle" | "ellipse" | "polygon" => in_group(nodes_layer),
+            "path" => in_group(nodes_layer) || in_marker,
+            "polyline" => in_group(edge_layer),
+            _ => false,
+        };
+        if !positioned {
+            return Err(format!(
+                "unsupported drawing element placement: {}",
+                node.tag_name().name()
+            )
+            .into());
+        }
+        for attribute in [
+            "transform",
+            "style",
+            "clip-path",
+            "mask",
+            "display",
+            "visibility",
+            "opacity",
+            "filter",
+            "dx",
+            "dy",
+            "rotate",
+            "textLength",
+            "lengthAdjust",
+            "alignment-baseline",
+            "baseline-shift",
+            "writing-mode",
+            "direction",
+            "letter-spacing",
+            "word-spacing",
+            "font-style",
+            "font-stretch",
+        ] {
+            if node.has_attribute(attribute) {
+                return Err(format!("unsupported drawing attribute {attribute}").into());
+            }
+        }
+        if !node.has_tag_name("text")
+            && [
+                "dominant-baseline",
+                "text-anchor",
+                "font-family",
+                "font-size",
+                "font-weight",
+            ]
+            .iter()
+            .any(|attribute| node.has_attribute(*attribute))
+        {
+            return Err("unsupported inherited text properties".into());
+        }
+    }
+    let mut texts = Vec::new();
+    let mut owners = BTreeSet::new();
+    let mut edge_label_index = 0;
+    for node in root
+        .descendants()
+        .filter(|node| node.has_tag_name("text") && !is_embedded(*node))
+    {
+        if node.children().count() != 1
+            || !node.first_child().is_some_and(|child| child.is_text())
+            || ["dx", "dy", "rotate", "textLength", "lengthAdjust"]
+                .iter()
+                .any(|attribute| node.has_attribute(*attribute))
+        {
+            return Err("unsupported text positioning".into());
+        }
+        let parent = node.parent_element().ok_or("text has no parent")?;
+        let value = node.text().ok_or("empty semantic text")?;
+        if required(node, "font-family")? != prepared.resources.metrics.family {
+            return Err("text uses unmeasured font family".into());
+        }
+        let size: u32 = required(node, "font-size")?.parse()?;
+        let text_bounds = text_rectangle(node, prepared, size)?;
+        let (id, owner, bounds) = if parent.has_attribute("data-edge-label") {
+            if !parent.has_tag_name("g") || parent.parent_element() != Some(labels_layer) {
+                return Err("edge label outside visible label layer".into());
+            }
+            let expected_label = diagram
+                .edges
+                .iter()
+                .filter_map(|edge| edge.label.as_deref())
+                .nth(edge_label_index)
+                .ok_or("unexpected edge label")?;
+            if value != expected_label || required(parent, "data-edge-label")? != expected_label {
+                return Err("edge label inventory drift".into());
+            }
+            if size != prepared.resources.theme.typography.edge_label_size_milli_px {
+                return Err("edge label font size drift".into());
+            }
+            let backgrounds = parent
+                .children()
+                .filter(|child| child.has_tag_name("rect"))
+                .collect::<Vec<_>>();
+            if backgrounds.len() != 1 {
+                return Err("edge label background inventory drift".into());
+            }
+            let background = rectangle(backgrounds[0])?;
+            if !geometry::contains(background, text_bounds) {
+                return Err("edge label text outside its background".into());
+            }
+            let id = format!("edge-label:{edge_label_index}:{value}");
+            let owner = format!("edge-label:{edge_label_index}");
+            edge_label_index += 1;
+            (id, owner, background)
+        } else {
+            let (owner, expected_text, expected_size) = if let Some(id) =
+                parent.attribute("data-stack-id")
+            {
+                if parent.has_attribute("data-node-kind") {
+                    if !parent.has_tag_name("g") || parent.parent_element() != Some(nodes_layer) {
+                        return Err("node text outside visible node layer".into());
+                    }
+                    let authored = diagram
+                        .nodes
+                        .iter()
+                        .find(|candidate| candidate.id == id)
+                        .ok_or("unknown text node")?;
+                    let ordinal = parent
+                        .children()
+                        .filter(|child| child.has_tag_name("text"))
+                        .position(|child| child == node)
+                        .ok_or("text position missing")?;
+                    match ordinal {
+                        0 => (
+                            format!("node:{id}:label"),
+                            authored.label.as_str(),
+                            prepared.resources.theme.typography.node_label_size_milli_px,
+                        ),
+                        1 => (
+                            format!("node:{id}:detail"),
+                            authored.detail.as_deref().ok_or("unexpected node detail")?,
+                            prepared
+                                .resources
+                                .theme
+                                .typography
+                                .node_detail_size_milli_px,
+                        ),
+                        _ => return Err("unexpected node text".into()),
+                    }
+                } else {
+                    if !parent.has_tag_name("g") || parent.parent_element() != Some(groups_layer) {
+                        return Err("group title outside visible group layer".into());
+                    }
+                    let group = diagram
+                        .groups
+                        .iter()
+                        .find(|candidate| candidate.id == id)
+                        .ok_or("unknown group title")?;
+                    (
+                        format!("group:{id}:title"),
+                        group.label.as_str(),
+                        prepared
+                            .resources
+                            .theme
+                            .typography
+                            .group_label_size_milli_px,
+                    )
+                }
+            } else if parent == root {
+                (
+                    "diagram:title".to_owned(),
+                    diagram.title.as_str(),
+                    prepared
+                        .resources
+                        .theme
+                        .typography
+                        .group_label_size_milli_px,
+                )
+            } else {
+                return Err("unknown semantic text owner".into());
+            };
+            if value != expected_text || size != expected_size {
+                return Err("semantic text content or size drift".into());
+            }
+            let id = format!(
+                "text:{}:{value}",
+                parent.attribute("data-stack-id").unwrap_or("diagram-title")
+            );
+            (id, owner, text_bounds)
+        };
+        if !owners.insert(owner) {
+            return Err("duplicate semantic text owner".into());
+        }
+        texts.push(TextBox { id, rect: bounds });
+    }
+    let expected_texts = 1
+        + diagram.groups.len()
+        + diagram.nodes.len()
+        + diagram
+            .nodes
+            .iter()
+            .filter(|node| node.detail.is_some())
+            .count()
+        + diagram
+            .edges
+            .iter()
+            .filter(|edge| edge.label.is_some())
+            .count();
+    if texts.len() != expected_texts
+        || edge_label_index
+            != diagram
+                .edges
+                .iter()
+                .filter(|edge| edge.label.is_some())
+                .count()
+    {
+        return Err("semantic text inventory drift".into());
+    }
+    let nodes = node_envelopes(root, prepared)?;
+    let mut routes = Vec::new();
+    for (index, group) in edge_layer.children().filter(Node::is_element).enumerate() {
+        if !group.has_tag_name("g") {
+            return Err("edge outside visible group".into());
+        }
+        let expected = prepared.scene.edges.get(index).ok_or("unexpected edge")?;
+        let lines = group
+            .children()
+            .filter(|node| node.has_tag_name("polyline"))
+            .collect::<Vec<_>>();
+        if lines.len() != 1 {
+            return Err("unsupported edge geometry: expected one polyline".into());
+        }
+        let line = lines[0];
+        let points = point_list(required(line, "points")?)?;
+        let expected_points = expected
+            .path
+            .iter()
+            .map(|point| Point {
+                x: point.x,
+                y: point.y,
+            })
+            .collect::<Vec<_>>();
+        if points != expected_points {
+            return Err("SVG/scene route drift".into());
+        }
+        if points.len() < 2
+            || points.windows(2).any(|pair| {
+                pair[0] == pair[1] || (pair[0].x != pair[1].x && pair[0].y != pair[1].y)
+            })
+        {
+            return Err("unsupported non-orthogonal or degenerate route".into());
+        }
+        let width = number(line, "stroke-width")?;
+        if width <= 0 {
+            return Err("invalid stroke width".into());
+        }
+        routes.push(Route {
+            id: format!("edge:{index}:{}->{}", expected.from, expected.to),
+            from: expected.from.clone(),
+            to: expected.to.clone(),
+            points,
+            radius: (width + 1) / 2,
+        });
+    }
+    if routes.len() != diagram.edges.len() {
+        return Err("edge inventory drift".into());
+    }
+    Ok(Drawing {
+        bounds: rect(expected),
+        texts,
+        nodes,
+        routes,
+    })
+}
+
+fn rectangle_json(rect: Rect) -> Value {
+    json!({"x":rect.x,"y":rect.y,"width":rect.width,"height":rect.height})
+}
+
+fn composition_metrics(drawing: &Drawing) -> Value {
+    let mut length = 0_i64;
+    let mut bends = 0;
+    for route in &drawing.routes {
+        for pair in route.points.windows(2) {
+            length += (pair[0].x - pair[1].x).abs() + (pair[0].y - pair[1].y).abs();
+        }
+        for triple in route.points.windows(3) {
+            if (triple[0].x == triple[1].x) != (triple[1].x == triple[2].x) {
+                bends += 1;
+            }
+        }
+    }
+    json!({"widthMilliPx":drawing.bounds.width,"heightMilliPx":drawing.bounds.height,"routeLengthMilliPx":length,"bends":bends,"nodes":drawing.nodes.len(),"textBoxes":drawing.texts.len(),"edges":drawing.routes.len()})
+}
+
+fn text_violations(drawing: &Drawing) -> Vec<Value> {
+    let mut violations = Vec::new();
+    for (index, text) in drawing.texts.iter().enumerate() {
+        if !geometry::contains(drawing.bounds, text.rect) {
+            violations.push(json!({"kind":"text-out-of-bounds","entity":text.id,"rect":rectangle_json(text.rect)}));
+        }
+        for other in &drawing.texts[index + 1..] {
+            if geometry::overlaps(text.rect, other.rect) {
+                violations.push(json!({"kind":"text-overlap","entities":[text.id,other.id],"rectangles":[rectangle_json(text.rect),rectangle_json(other.rect)]}));
+            }
+        }
+    }
+    violations
+}
+
+fn edge_violations(drawing: &Drawing) -> Result<Vec<Value>> {
+    let mut violations = Vec::new();
+    for route in &drawing.routes {
+        for text in &drawing.texts {
+            for pair in route.points.windows(2) {
+                if geometry::segment_hits_rect(pair[0], pair[1], text.rect, route.radius)? {
+                    violations.push(json!({"kind":"edge-text-collision","entities":[route.id,text.id],"rect":rectangle_json(text.rect)}));
+                    break;
+                }
+            }
+        }
+        for (id, bounds) in &drawing.nodes {
+            for (index, pair) in route.points.windows(2).enumerate() {
+                let allow_start = index == 0 && id == &route.from;
+                let allow_end = index + 2 == route.points.len() && id == &route.to;
+                if geometry::segment_hits_node(
+                    pair[0],
+                    pair[1],
+                    *bounds,
+                    route.radius,
+                    allow_start,
+                    allow_end,
+                )? {
+                    violations.push(json!({"kind":"edge-node-collision","entities":[route.id,id],"rect":rectangle_json(*bounds)}));
+                    break;
+                }
+            }
+        }
+    }
+    Ok(violations)
+}
+
+#[derive(Deserialize)]
+struct Catalog {
+    cases: Vec<Case>,
+}
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Case {
+    id: String,
+    source: String,
+    provider_fixture: Option<String>,
+}
+#[derive(Deserialize)]
+struct PackInput {
+    manifest: stack_theme::ProviderPack,
+    assets: Vec<AssetInput>,
+}
+#[derive(Deserialize)]
+struct AssetInput {
+    path: String,
+    svg: String,
+}
+
+fn root() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("../..")
+}
+
+fn run_corpus(gate: &str) -> Result<()> {
+    let root = root();
+    let catalog: Catalog =
+        serde_json::from_slice(&fs::read(root.join("layout-corpus/catalog.json"))?)?;
+    if catalog.cases.len() != 7 {
+        return Err("review corpus inventory changed; update quality coverage explicitly".into());
+    }
+    let output_dir = root.join("target/layout-quality").join(gate);
+    fs::create_dir_all(&output_dir)?;
+    let mut results = Vec::new();
+    let mut count = 0;
+    for case in catalog.cases {
+        let source = fs::read(root.join("layout-corpus").join(case.source))?;
+        let mut packs = Vec::new();
+        if let Some(provider) = case.provider_fixture {
+            let inputs: Vec<PackInput> =
+                serde_json::from_slice(&fs::read(root.join("layout-corpus").join(provider))?)?;
+            for input in inputs {
+                packs.push(ProviderPack::new(
+                    input.manifest,
+                    input
+                        .assets
+                        .into_iter()
+                        .map(|asset| ProviderAsset::new(asset.path, asset.svg))
+                        .collect(),
+                )?);
+            }
+        }
+        let engine = Engine::with_provider_packs(&packs)?;
+        let output = engine.render(&source)?;
+        if !output.diagnostics.is_empty() {
+            return Err(format!("{}: unexpected diagnostics", case.id).into());
+        }
+        let svg = output.svg.ok_or("render returned no SVG")?;
+        let compiled = stack_compiler::compile_bytes_with_source_map(&source);
+        let diagram = compiled.diagram.as_ref().ok_or("no compiled diagram")?;
+        let prepared = engine.prepare_scene(
+            diagram,
+            compiled.source_map.as_ref().ok_or("no source map")?,
+        )?;
+        let drawing = read_drawing(&svg, &prepared, diagram)?;
+        let violations = if gate == "text" {
+            text_violations(&drawing)
+        } else {
+            edge_violations(&drawing)?
+        };
+        count += violations.len();
+        fs::write(output_dir.join(format!("{}.svg", case.id)), svg)?;
+        eprintln!("{}: {} {gate} violation(s)", case.id, violations.len());
+        results.push(json!({"id":case.id,"violations":violations,"composition":composition_metrics(&drawing)}));
+    }
+    fs::write(
+        output_dir.join("report.json"),
+        serde_json::to_vec_pretty(
+            &json!({"schemaVersion":"1.0","gate":gate,"units":"1/1000 CSS px","engineVersion":crate::ENGINE_VERSION,"limitations":["logical text envelopes, not raster glyph bounds","middle-baseline reservation is centered line height, not font x-height measurement","node SVG and Bezier control-point envelopes, not exact painted shape outlines","arrowheads and group frame collisions are not measured","global composition metrics are not a beauty score"],"violations":count,"cases":results}),
+        )?,
+    )?;
+    if count > 0 {
+        return Err(format!(
+            "{count} {gate} quality violations; inspect {}",
+            output_dir.display()
+        )
+        .into());
+    }
+    Ok(())
+}
+
+#[test]
+fn corpus_text_quality() -> Result<()> {
+    run_corpus("text")
+}
+
+#[test]
+fn corpus_edge_quality() -> Result<()> {
+    run_corpus("edge")
+}
+
+#[test]
+fn detector_flags_text_collision_and_clipping_without_requiring_a_snapshot() {
+    let drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 100,
+            height: 100,
+        },
+        texts: vec![
+            TextBox {
+                id: "title".into(),
+                rect: Rect {
+                    x: 0,
+                    y: 0,
+                    width: 40,
+                    height: 20,
+                },
+            },
+            TextBox {
+                id: "label".into(),
+                rect: Rect {
+                    x: -5,
+                    y: 10,
+                    width: 30,
+                    height: 20,
+                },
+            },
+        ],
+        nodes: vec![],
+        routes: vec![],
+    };
+    let violations = text_violations(&drawing);
+    assert_eq!(violations.len(), 2);
+    assert!(
+        violations
+            .iter()
+            .any(|value| value["kind"] == "text-overlap")
+    );
+    assert!(
+        violations
+            .iter()
+            .any(|value| value["kind"] == "text-out-of-bounds")
+    );
+}
+
+#[test]
+fn detector_allows_separated_text_inside_the_canvas() {
+    let drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 100,
+            height: 100,
+        },
+        texts: vec![
+            TextBox {
+                id: "left".into(),
+                rect: Rect {
+                    x: 0,
+                    y: 0,
+                    width: 40,
+                    height: 20,
+                },
+            },
+            TextBox {
+                id: "right".into(),
+                rect: Rect {
+                    x: 60,
+                    y: 0,
+                    width: 40,
+                    height: 20,
+                },
+            },
+        ],
+        nodes: vec![],
+        routes: vec![],
+    };
+    assert!(text_violations(&drawing).is_empty());
+}
+
+#[test]
+fn metrics_do_not_trade_collisions_for_a_smaller_drawing() {
+    let drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 100,
+            height: 100,
+        },
+        texts: vec![],
+        nodes: vec![],
+        routes: vec![Route {
+            id: "edge:0".into(),
+            from: "a".into(),
+            to: "b".into(),
+            radius: 1,
+            points: vec![
+                Point { x: 10, y: 10 },
+                Point { x: 40, y: 10 },
+                Point { x: 40, y: 20 },
+                Point { x: 40, y: 40 },
+            ],
+        }],
+    };
+    let metrics = composition_metrics(&drawing);
+    assert_eq!(metrics["routeLengthMilliPx"], 60);
+    assert_eq!(metrics["bends"], 1);
+    assert!(metrics.get("beautyScore").is_none());
+}
+
+#[test]
+fn detector_does_not_exempt_an_edges_own_label() -> Result<()> {
+    let drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 100,
+            height: 100,
+        },
+        texts: vec![TextBox {
+            id: "edge-label:0:Request".into(),
+            rect: Rect {
+                x: 40,
+                y: 40,
+                width: 20,
+                height: 20,
+            },
+        }],
+        nodes: vec![],
+        routes: vec![Route {
+            id: "edge:0".into(),
+            from: "a".into(),
+            to: "b".into(),
+            points: vec![Point { x: 0, y: 50 }, Point { x: 100, y: 50 }],
+            radius: 1,
+        }],
+    };
+    let violations = edge_violations(&drawing)?;
+    assert_eq!(violations.len(), 1);
+    assert_eq!(violations[0]["kind"], "edge-text-collision");
+    Ok(())
+}
+
+#[test]
+fn detector_allows_only_terminal_node_contact() -> Result<()> {
+    let mut drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 100,
+            height: 100,
+        },
+        texts: vec![],
+        nodes: vec![
+            (
+                "a".into(),
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 20,
+                    height: 20,
+                },
+            ),
+            (
+                "b".into(),
+                Rect {
+                    x: 80,
+                    y: 0,
+                    width: 20,
+                    height: 20,
+                },
+            ),
+        ],
+        routes: vec![Route {
+            id: "edge:0".into(),
+            from: "a".into(),
+            to: "b".into(),
+            points: vec![Point { x: 20, y: 10 }, Point { x: 80, y: 10 }],
+            radius: 1,
+        }],
+    };
+    assert!(edge_violations(&drawing)?.is_empty());
+    drawing.nodes.push((
+        "unrelated".into(),
+        Rect {
+            x: 40,
+            y: 0,
+            width: 20,
+            height: 20,
+        },
+    ));
+    let violations = edge_violations(&drawing)?;
+    assert_eq!(violations.len(), 1);
+    assert_eq!(violations[0]["entities"][1], "unrelated");
+    // Re-entering the source on a later segment must not be exempted.
+    drawing.routes[0].points = vec![
+        Point { x: 20, y: 10 },
+        Point { x: 30, y: 10 },
+        Point { x: 30, y: 30 },
+        Point { x: 10, y: 30 },
+        Point { x: 10, y: 10 },
+        Point { x: 80, y: 10 },
+    ];
+    assert!(
+        edge_violations(&drawing)?
+            .iter()
+            .any(|violation| violation["entities"][1] == "a")
+    );
+    Ok(())
+}
+
+#[test]
+fn parser_rejects_unmeasured_geometry_and_dropped_content() -> Result<()> {
+    let source =
+        b"stack 1.0 diagram \"Example\" { node a \"A\" node b \"B\" edge a -> b \"Request\" }";
+    let engine = Engine::bundled();
+    let output = engine.render(source)?;
+    let svg = output.svg.ok_or("missing SVG")?;
+    let compiled = stack_compiler::compile_bytes_with_source_map(source);
+    let diagram = compiled.diagram.as_ref().ok_or("missing diagram")?;
+    let prepared = engine.prepare_scene(
+        diagram,
+        compiled.source_map.as_ref().ok_or("missing source map")?,
+    )?;
+    assert!(read_drawing(&svg, &prepared, diagram).is_ok());
+    for mutant in [
+        svg.replacen("<svg ", "<svg transform=\"scale(2)\" ", 1),
+        svg.replacen(">Example</text>", ">Wrong</text>", 1),
+        svg.replacen("<polyline ", "<path ", 1),
+        svg.replacen("<text ", "<text dx=\"100\" ", 1),
+        svg.replacen("data-node-kind=", "removed-node-kind=", 1),
+    ] {
+        assert_ne!(mutant, svg, "mutation must exercise the checker");
+        assert!(read_drawing(&mutant, &prepared, diagram).is_err());
+    }
+    Ok(())
+}
+
+#[test]
+fn parser_rejects_reviewed_false_green_mutations() -> Result<()> {
+    let source =
+        b"stack 1.0 diagram \"Example\" { node a \"A\" node b \"B\" edge a -> b \"Request\" }";
+    let engine = Engine::bundled();
+    let svg = engine.render(source)?.svg.ok_or("missing SVG")?;
+    let compiled = stack_compiler::compile_bytes_with_source_map(source);
+    let diagram = compiled.diagram.as_ref().ok_or("missing diagram")?;
+    let prepared = engine.prepare_scene(
+        diagram,
+        compiled.source_map.as_ref().ok_or("missing source map")?,
+    )?;
+    let document = Document::parse(&svg)?;
+    let title = document
+        .root_element()
+        .children()
+        .find(|node| node.has_tag_name("text"))
+        .ok_or("missing title")?;
+    let owner = document
+        .descendants()
+        .find(|node| node.attribute("data-stack-id") == Some("a"))
+        .ok_or("missing node")?;
+    let label = owner
+        .children()
+        .find(|node| node.has_tag_name("text"))
+        .ok_or("missing node label")?;
+    let shape = owner
+        .children()
+        .find(|node| node.has_tag_name("rect"))
+        .ok_or("missing node shape")?;
+    let edge_text = document
+        .descendants()
+        .find(|node| {
+            node.has_tag_name("text")
+                && node
+                    .parent_element()
+                    .is_some_and(|parent| parent.has_attribute("data-edge-label"))
+        })
+        .ok_or("missing edge text")?;
+    let replace = |node: Node<'_, '_>, replacement: &str| {
+        let mut mutant = svg.clone();
+        mutant.replace_range(node.range(), replacement);
+        mutant
+    };
+    let edge_markup = &svg[edge_text.range()];
+    let moved_edge = edge_markup.replacen(
+        &format!("x=\"{}\"", required(edge_text, "x")?),
+        "x=\"-999999\"",
+        1,
+    );
+    let oversized_edge = edge_markup.replacen(
+        &format!("font-size=\"{}\"", required(edge_text, "font-size")?),
+        "font-size=\"900000\"",
+        1,
+    );
+    let moved_shape = svg[shape.range()].replacen(
+        &format!("x=\"{}\"", required(shape, "x")?),
+        "x=\"-999999\"",
+        1,
+    );
+    let mut duplicated_title = replace(label, "");
+    let end = duplicated_title.rfind("</svg>").ok_or("missing root end")?;
+    duplicated_title.insert_str(end, &svg[title.range()]);
+    let hide_group = |group: Node<'_, '_>| -> Result<String> {
+        let mut hidden = svg[group.range()].replacen("<g ", "<defs ", 1);
+        let close = hidden.rfind("</g>").ok_or("missing group end")?;
+        hidden.replace_range(close..close + 4, "</defs>");
+        Ok(replace(group, &hidden))
+    };
+    let layer = |name: &str| -> Result<Node<'_, '_>> {
+        document
+            .root_element()
+            .children()
+            .find(|node| node.attribute("data-stack-layer") == Some(name))
+            .ok_or_else(|| "missing layer".into())
+    };
+    let hidden_edge_group = hide_group(
+        layer("edges")?
+            .children()
+            .find(Node::is_element)
+            .ok_or("missing edge group")?,
+    )?;
+    let mutants = [
+        (
+            "edge text moved outside its background",
+            replace(edge_text, &moved_edge),
+        ),
+        ("edge text enlarged", replace(edge_text, &oversized_edge)),
+        ("node shape moved", replace(shape, &moved_shape)),
+        ("node shape removed", replace(shape, "")),
+        ("node label replaced by duplicate title", duplicated_title),
+        (
+            "unsupported baseline",
+            svg.replacen(
+                "dominant-baseline=\"middle\"",
+                "dominant-baseline=\"text-before-edge\"",
+                1,
+            ),
+        ),
+        (
+            "stylesheet hides text",
+            svg.replacen("<defs>", "<style>text { display: none }</style><defs>", 1),
+        ),
+        (
+            "inherited text rotation",
+            svg.replacen("<svg ", "<svg rotate=\"90\" ", 1),
+        ),
+        (
+            "node layer hidden in definitions",
+            hide_group(layer("nodes")?)?,
+        ),
+        (
+            "edge layer hidden in definitions",
+            hide_group(layer("edges")?)?,
+        ),
+        ("edge group hidden in definitions", hidden_edge_group),
+        (
+            "label owner hidden in definitions",
+            hide_group(edge_text.parent_element().ok_or("missing owner")?)?,
+        ),
+        (
+            "zero root width",
+            svg.replacen(
+                &format!("width=\"{}\"", required(document.root_element(), "width")?),
+                "width=\"0\"",
+                1,
+            ),
+        ),
+        (
+            "zero root height",
+            svg.replacen(
+                &format!(
+                    "height=\"{}\"",
+                    required(document.root_element(), "height")?
+                ),
+                "height=\"0\"",
+                1,
+            ),
+        ),
+        ("extra root route", svg.replacen("</metadata>", "</metadata><polyline points=\"0,0 999999,0\" stroke=\"black\" stroke-width=\"1500\"/>", 1)),
+        ("unmeasured trailing text", svg.replacen(">Example</text>", ">Example<!-- split -->UNMEASURED</text>", 1)),
+        ("unverified nested SVG", replace(owner, &svg[owner.range()].replacen("</title>", "</title><svg><text x=\"0\" y=\"0\">UNMEASURED</text></svg>", 1))),
+        ("document stylesheet", svg.replacen("<svg ", "<?xml-stylesheet type=\"text/css\" href=\"data:text/css,text%7Bdisplay%3Anone%7D\"?><svg ", 1)),
+    ];
+    let mut accepted = Vec::new();
+    for (name, mutant) in mutants {
+        assert_ne!(mutant, svg, "mutation must exercise {name}");
+        if read_drawing(&mutant, &prepared, diagram).is_ok() {
+            accepted.push(name);
+        }
+    }
+    assert!(
+        accepted.is_empty(),
+        "unmeasured mutations accepted: {accepted:?}"
+    );
+    Ok(())
+}
+
+#[test]
+fn parser_reserves_logical_middle_baseline_text_boxes() -> Result<()> {
+    let source = b"stack 1.0 diagram \"Example\" { node a \"A\" }";
+    let engine = Engine::bundled();
+    let svg = engine.render(source)?.svg.ok_or("missing SVG")?;
+    let compiled = stack_compiler::compile_bytes_with_source_map(source);
+    let diagram = compiled.diagram.as_ref().ok_or("missing diagram")?;
+    let prepared = engine.prepare_scene(
+        diagram,
+        compiled.source_map.as_ref().ok_or("missing source map")?,
+    )?;
+    let drawing = read_drawing(&svg, &prepared, diagram)?;
+    let text = drawing
+        .texts
+        .iter()
+        .find(|text| text.id == "text:a:A")
+        .ok_or("missing measured label")?;
+    let document = Document::parse(&svg)?;
+    let element = document
+        .descendants()
+        .find(|node| node.has_tag_name("text") && node.text() == Some("A"))
+        .ok_or("missing label element")?;
+    assert_eq!(text.rect.y, number(element, "y")? - text.rect.height / 2);
+    Ok(())
+}
+
+#[test]
+fn parser_reads_every_current_node_shape_envelope() -> Result<()> {
+    for kind in ["actor", "client", "function", "worker", "database"] {
+        let source = format!("stack 1.0 diagram \"Shape\" {{ node a \"A\" {{ kind {kind} }} }}");
+        let engine = Engine::bundled();
+        let svg = engine.render(source.as_bytes())?.svg.ok_or("missing SVG")?;
+        let compiled = stack_compiler::compile_bytes_with_source_map(source.as_bytes());
+        let diagram = compiled.diagram.as_ref().ok_or("missing diagram")?;
+        let prepared = engine.prepare_scene(
+            diagram,
+            compiled.source_map.as_ref().ok_or("missing source map")?,
+        )?;
+        let drawing = read_drawing(&svg, &prepared, diagram)?;
+        assert_eq!(
+            drawing.nodes,
+            vec![("a".to_owned(), rect(prepared.scene.nodes[0].rect))],
+            "{kind}"
+        );
+    }
+    Ok(())
+}
diff --git a/crates/stack-engine/src/layout_quality/geometry.rs b/crates/stack-engine/src/layout_quality/geometry.rs
new file mode 100644
index 0000000..3c7fae5
--- /dev/null
+++ b/crates/stack-engine/src/layout_quality/geometry.rs
@@ -0,0 +1,529 @@
+//! Independent integer geometry for the test-only layout quality gates.
+//!
+//! Coordinates and stroke radii use thousandths of a CSS pixel. Computations use
+//! wider intermediates so that adding dimensions or expanding an obstacle never
+//! wraps at an `i64` coordinate boundary.
+
+use std::fmt;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct Rect {
+    pub(super) x: i64,
+    pub(super) y: i64,
+    pub(super) width: i64,
+    pub(super) height: i64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) struct Point {
+    pub(super) x: i64,
+    pub(super) y: i64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum GeometryError {
+    InvalidRect,
+    NegativeRadius,
+    DiagonalSegment,
+}
+
+impl fmt::Display for GeometryError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(match self {
+            Self::InvalidRect => "segment obstacles must have positive width and height",
+            Self::NegativeRadius => "stroke radius must not be negative",
+            Self::DiagonalSegment => "only axis-aligned segments are supported",
+        })
+    }
+}
+
+impl std::error::Error for GeometryError {}
+
+#[derive(Clone, Copy)]
+struct Bounds {
+    left: i128,
+    top: i128,
+    right: i128,
+    bottom: i128,
+}
+
+impl Bounds {
+    fn new(rect: Rect) -> Self {
+        Self {
+            left: i128::from(rect.x),
+            top: i128::from(rect.y),
+            right: i128::from(rect.x) + i128::from(rect.width),
+            bottom: i128::from(rect.y) + i128::from(rect.height),
+        }
+    }
+
+    fn expand(self, radius: i64) -> Self {
+        let radius = i128::from(radius);
+        Self {
+            left: self.left - radius,
+            top: self.top - radius,
+            right: self.right + radius,
+            bottom: self.bottom + radius,
+        }
+    }
+}
+
+/// Returns whether two nonempty rectangles share positive area.
+/// Empty or inverted rectangles cannot overlap; exact edge contact is excluded.
+pub(super) fn overlaps(left: Rect, right: Rect) -> bool {
+    if left.width <= 0 || left.height <= 0 || right.width <= 0 || right.height <= 0 {
+        return false;
+    }
+    let left = Bounds::new(left);
+    let right = Bounds::new(right);
+    left.left.max(right.left) < left.right.min(right.right)
+        && left.top.max(right.top) < left.bottom.min(right.bottom)
+}
+
+/// Returns inclusive containment, including zero-area inner rectangles.
+/// Negative dimensions are invalid and return false.
+pub(super) fn contains(outer: Rect, inner: Rect) -> bool {
+    if outer.width < 0 || outer.height < 0 || inner.width < 0 || inner.height < 0 {
+        return false;
+    }
+    let outer = Bounds::new(outer);
+    let inner = Bounds::new(inner);
+    outer.left <= inner.left
+        && inner.right <= outer.right
+        && outer.top <= inner.top
+        && inner.bottom <= outer.bottom
+}
+
+/// Tests a centerline against a rectangle expanded by the stroke radius.
+/// Positive-length contact on the expanded boundary counts; a single touching
+/// point does not. Zero-length segments therefore return false. This models an
+/// axis-aligned stroke envelope, not arrowheads or arbitrary stroke cap shapes.
+pub(super) fn segment_hits_rect(
+    start: Point,
+    end: Point,
+    rect: Rect,
+    radius: i64,
+) -> Result<bool, GeometryError> {
+    if rect.width <= 0 || rect.height <= 0 {
+        return Err(GeometryError::InvalidRect);
+    }
+    if radius < 0 {
+        return Err(GeometryError::NegativeRadius);
+    }
+    let bounds = Bounds::new(rect).expand(radius);
+    if start == end {
+        return Ok(false);
+    }
+    if start.x == end.x {
+        let x = i128::from(start.x);
+        return Ok(bounds.left <= x
+            && x <= bounds.right
+            && i128::from(start.y.min(end.y)).max(bounds.top)
+                < i128::from(start.y.max(end.y)).min(bounds.bottom));
+    }
+    if start.y == end.y {
+        let y = i128::from(start.y);
+        return Ok(bounds.top <= y
+            && y <= bounds.bottom
+            && i128::from(start.x.min(end.x)).max(bounds.left)
+                < i128::from(start.x.max(end.x)).min(bounds.right));
+    }
+    Err(GeometryError::DiagonalSegment)
+}
+
+/// Allows only a real terminal's normal departure or arrival at the original
+/// node boundary. Callers must enable these flags only on the first/last path
+/// segment for that segment's actual source/target node. Every other segment
+/// must be checked without the corresponding exemption, including later
+/// segments that return to the same node.
+pub(super) fn segment_hits_node(
+    start: Point,
+    end: Point,
+    rect: Rect,
+    radius: i64,
+    allow_start: bool,
+    allow_end: bool,
+) -> Result<bool, GeometryError> {
+    if !segment_hits_rect(start, end, rect, radius)? {
+        return Ok(false);
+    }
+    let bounds = Bounds::new(rect);
+    let allowed_departure = allow_start && departs_normally(start, end, bounds);
+    let allowed_arrival = allow_end && departs_normally(end, start, bounds);
+    Ok(!allowed_departure && !allowed_arrival)
+}
+
+fn departs_normally(terminal: Point, other: Point, rect: Bounds) -> bool {
+    let x = i128::from(terminal.x);
+    let y = i128::from(terminal.y);
+    if terminal.y == other.y && rect.top <= y && y <= rect.bottom {
+        return (x == rect.left && other.x < terminal.x)
+            || (x == rect.right && terminal.x < other.x);
+    }
+    if terminal.x == other.x && rect.left <= x && x <= rect.right {
+        return (y == rect.top && other.y < terminal.y)
+            || (y == rect.bottom && terminal.y < other.y);
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const NODE: Rect = rect(10, 20, 30, 40);
+
+    const fn rect(x: i64, y: i64, width: i64, height: i64) -> Rect {
+        Rect {
+            x,
+            y,
+            width,
+            height,
+        }
+    }
+
+    const fn point(x: i64, y: i64) -> Point {
+        Point { x, y }
+    }
+
+    fn assert_rect_hit(start: Point, end: Point, radius: i64, expected: bool) {
+        assert_eq!(
+            segment_hits_rect(start, end, NODE, radius),
+            Ok(expected),
+            "forward: {start:?} -> {end:?}, radius {radius}"
+        );
+        assert_eq!(
+            segment_hits_rect(end, start, NODE, radius),
+            Ok(expected),
+            "reverse: {end:?} -> {start:?}, radius {radius}"
+        );
+    }
+
+    #[test]
+    fn rectangle_overlap_requires_positive_area() {
+        for (other, expected) in [
+            (NODE, true),
+            (rect(11, 21, 1, 1), true),
+            (rect(9, 19, 2, 2), true),
+            (rect(0, 0, 50, 70), true),
+            (rect(40, 20, 10, 40), false),
+            (rect(10, 60, 30, 10), false),
+            (rect(40, 60, 10, 10), false),
+            (rect(41, 20, 10, 40), false),
+            (rect(11, 21, 0, 1), false),
+            (rect(11, 21, 1, 0), false),
+            (rect(11, 21, -1, 1), false),
+        ] {
+            assert_eq!(overlaps(NODE, other), expected, "{other:?}");
+            assert_eq!(overlaps(other, NODE), expected, "{other:?}");
+        }
+    }
+
+    #[test]
+    fn containment_includes_the_boundary_and_empty_inner_rectangles() {
+        for inner in [NODE, rect(10, 20, 1, 1), rect(40, 60, 0, 0)] {
+            assert!(contains(NODE, inner), "{inner:?}");
+        }
+        for inner in [
+            rect(9, 20, 2, 1),
+            rect(10, 19, 1, 2),
+            rect(39, 20, 2, 1),
+            rect(10, 59, 1, 2),
+            rect(41, 60, 0, 0),
+            rect(11, 21, -1, 1),
+        ] {
+            assert!(!contains(NODE, inner), "{inner:?}");
+        }
+        assert!(contains(rect(5, 5, 0, 0), rect(5, 5, 0, 0)));
+        assert!(!contains(rect(10, 20, -1, 40), NODE));
+    }
+
+    #[test]
+    fn crossing_and_travel_along_any_rectangle_edge_are_collisions() {
+        for (start, end) in [
+            (point(0, 40), point(50, 40)),
+            (point(25, 0), point(25, 70)),
+            (point(0, 20), point(50, 20)),
+            (point(0, 60), point(50, 60)),
+            (point(10, 0), point(10, 70)),
+            (point(40, 0), point(40, 70)),
+        ] {
+            assert_rect_hit(start, end, 0, true);
+        }
+    }
+
+    #[test]
+    fn point_only_contact_is_excluded_but_one_unit_of_boundary_travel_is_not() {
+        for (start, end) in [
+            (point(0, 20), point(10, 20)),
+            (point(0, 40), point(10, 40)),
+            (point(40, 60), point(50, 60)),
+            (point(10, 0), point(10, 20)),
+            (point(40, 60), point(40, 70)),
+        ] {
+            assert_rect_hit(start, end, 0, false);
+        }
+        assert_rect_hit(point(0, 20), point(11, 20), 0, true);
+        assert_rect_hit(point(10, 0), point(10, 21), 0, true);
+        assert_rect_hit(point(0, 17), point(7, 17), 3, false);
+        assert_rect_hit(point(0, 17), point(8, 17), 3, true);
+    }
+
+    #[test]
+    fn stroke_expansion_detects_collisions_without_centerline_overlap() {
+        assert_rect_hit(point(0, 18), point(50, 18), 0, false);
+        assert_rect_hit(point(0, 18), point(50, 18), 3, true);
+        assert_rect_hit(point(8, 0), point(8, 70), 0, false);
+        assert_rect_hit(point(8, 0), point(8, 70), 3, true);
+        assert_rect_hit(point(0, 17), point(50, 17), 3, true);
+        assert_rect_hit(point(7, 0), point(7, 70), 3, true);
+        assert_rect_hit(point(0, 16), point(50, 16), 3, false);
+        assert_rect_hit(point(6, 0), point(6, 70), 3, false);
+    }
+
+    #[test]
+    fn only_the_correct_terminal_flag_allows_normal_contact_on_all_sides() {
+        for (terminal, outside) in [
+            (point(10, 40), point(0, 40)),
+            (point(40, 40), point(50, 40)),
+            (point(25, 20), point(25, 10)),
+            (point(25, 60), point(25, 70)),
+        ] {
+            assert_rect_hit(terminal, outside, 3, true);
+            for (allow_start, allow_end, expected) in [
+                (false, false, true),
+                (true, false, false),
+                (false, true, true),
+                (true, true, false),
+            ] {
+                assert_eq!(
+                    segment_hits_node(terminal, outside, NODE, 3, allow_start, allow_end),
+                    Ok(expected),
+                    "departure: {terminal:?} -> {outside:?}"
+                );
+                assert_eq!(
+                    segment_hits_node(outside, terminal, NODE, 3, allow_end, allow_start),
+                    Ok(expected),
+                    "arrival: {outside:?} -> {terminal:?}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn terminal_flags_never_exempt_travel_along_the_node_boundary() {
+        for (start, end) in [
+            (point(10, 20), point(40, 20)),
+            (point(10, 60), point(40, 60)),
+            (point(10, 20), point(10, 60)),
+            (point(40, 20), point(40, 60)),
+            (point(10, 40), point(10, 10)),
+            (point(25, 20), point(50, 20)),
+        ] {
+            for radius in [0, 3] {
+                assert_eq!(
+                    segment_hits_node(start, end, NODE, radius, true, true),
+                    Ok(true),
+                    "{start:?} -> {end:?}, radius {radius}"
+                );
+                assert_eq!(
+                    segment_hits_node(end, start, NODE, radius, true, true),
+                    Ok(true)
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn a_corner_can_depart_outward_but_cannot_run_into_its_adjacent_boundary() {
+        for (terminal, outside) in [
+            (point(10, 20), point(0, 20)),
+            (point(10, 20), point(10, 10)),
+            (point(40, 60), point(50, 60)),
+            (point(40, 60), point(40, 70)),
+        ] {
+            assert_eq!(
+                segment_hits_node(terminal, outside, NODE, 3, true, false),
+                Ok(false)
+            );
+            assert_eq!(
+                segment_hits_node(outside, terminal, NODE, 3, false, true),
+                Ok(false)
+            );
+        }
+        assert_eq!(
+            segment_hits_node(point(10, 20), point(20, 20), NODE, 3, true, true),
+            Ok(true)
+        );
+        assert_eq!(
+            segment_hits_node(point(40, 60), point(40, 50), NODE, 3, true, true),
+            Ok(true)
+        );
+    }
+
+    #[test]
+    fn an_allowed_endpoint_cannot_cross_through_its_own_node() {
+        for (terminal, opposite_outside) in [
+            (point(10, 40), point(50, 40)),
+            (point(40, 40), point(0, 40)),
+            (point(25, 20), point(25, 70)),
+            (point(25, 60), point(25, 10)),
+        ] {
+            assert_eq!(
+                segment_hits_node(terminal, opposite_outside, NODE, 3, true, true),
+                Ok(true)
+            );
+            assert_eq!(
+                segment_hits_node(opposite_outside, terminal, NODE, 3, true, true),
+                Ok(true)
+            );
+        }
+    }
+
+    #[test]
+    fn interior_endpoints_are_collisions_even_when_both_flags_are_enabled() {
+        for (inside, other) in [
+            (point(20, 40), point(0, 40)),
+            (point(25, 30), point(25, 10)),
+            (point(20, 40), point(30, 40)),
+            (point(25, 30), point(25, 40)),
+        ] {
+            assert_eq!(
+                segment_hits_node(inside, other, NODE, 3, true, true),
+                Ok(true)
+            );
+            assert_eq!(
+                segment_hits_node(other, inside, NODE, 3, true, true),
+                Ok(true)
+            );
+        }
+    }
+
+    #[test]
+    fn a_terminal_must_be_on_the_original_rectangle_not_just_its_stroke_halo() {
+        for (near_boundary, outside) in [
+            (point(8, 40), point(0, 40)),
+            (point(42, 40), point(50, 40)),
+            (point(25, 18), point(25, 10)),
+            (point(25, 62), point(25, 70)),
+        ] {
+            assert_eq!(
+                segment_hits_node(near_boundary, outside, NODE, 3, true, true),
+                Ok(true)
+            );
+            assert_eq!(
+                segment_hits_node(outside, near_boundary, NODE, 3, true, true),
+                Ok(true)
+            );
+        }
+    }
+
+    #[test]
+    fn a_clean_departure_does_not_exempt_later_reentry() {
+        let path = [
+            point(10, 40),
+            point(0, 40),
+            point(0, 10),
+            point(25, 10),
+            point(25, 40),
+        ];
+        let expected = [false, false, false, true];
+        for (index, segment) in path.windows(2).enumerate() {
+            assert_eq!(
+                segment_hits_node(segment[0], segment[1], NODE, 3, index == 0, false),
+                Ok(expected[index]),
+                "segment {index}"
+            );
+        }
+    }
+
+    #[test]
+    fn a_short_normal_departure_does_not_exempt_the_next_segment_in_the_halo() {
+        assert_eq!(
+            segment_hits_node(point(25, 20), point(25, 18), NODE, 3, true, false),
+            Ok(false)
+        );
+        assert_eq!(
+            segment_hits_node(point(25, 18), point(35, 18), NODE, 3, false, false),
+            Ok(true)
+        );
+    }
+
+    #[test]
+    fn unsupported_geometry_returns_errors_instead_of_appearing_collision_free() {
+        assert_eq!(
+            segment_hits_rect(point(0, 0), point(50, 70), NODE, 3),
+            Err(GeometryError::DiagonalSegment)
+        );
+        assert_eq!(
+            segment_hits_node(point(10, 20), point(0, 0), NODE, 3, true, true),
+            Err(GeometryError::DiagonalSegment)
+        );
+        assert_eq!(
+            segment_hits_rect(point(0, 40), point(50, 40), NODE, -1),
+            Err(GeometryError::NegativeRadius)
+        );
+        for obstacle in [
+            rect(10, 20, 0, 40),
+            rect(10, 20, 30, 0),
+            rect(10, 20, -1, 40),
+            rect(10, 20, 30, -1),
+        ] {
+            assert_eq!(
+                segment_hits_rect(point(0, 40), point(50, 40), obstacle, 3),
+                Err(GeometryError::InvalidRect)
+            );
+        }
+    }
+
+    #[test]
+    fn zero_length_segments_have_no_positive_length_contact_but_validate_inputs() {
+        for position in [point(25, 40), point(10, 20), point(0, 0)] {
+            assert_rect_hit(position, position, 3, false);
+            assert_eq!(
+                segment_hits_node(position, position, NODE, 3, true, true),
+                Ok(false)
+            );
+        }
+        assert_eq!(
+            segment_hits_rect(point(25, 40), point(25, 40), NODE, -1),
+            Err(GeometryError::NegativeRadius)
+        );
+        assert_eq!(
+            segment_hits_rect(point(25, 40), point(25, 40), rect(0, 0, 0, 0), 0),
+            Err(GeometryError::InvalidRect)
+        );
+    }
+
+    #[test]
+    fn dimensions_and_stroke_expansion_do_not_overflow_i64_coordinates() {
+        let high = rect(i64::MAX - 5, 0, 10, 10);
+        let inner = rect(i64::MAX - 1, 1, 5, 5);
+        assert!(contains(high, inner));
+        assert!(overlaps(high, inner));
+        assert_eq!(
+            segment_hits_rect(point(i64::MAX, -10), point(i64::MAX, 20), high, 0),
+            Ok(true)
+        );
+        let low = rect(i64::MIN + 2, -2, 4, 4);
+        assert_eq!(
+            segment_hits_rect(point(i64::MIN, -10), point(i64::MIN, 10), low, i64::MAX),
+            Ok(true)
+        );
+        assert_eq!(
+            segment_hits_node(
+                point(i64::MIN + 2, 0),
+                point(i64::MIN, 0),
+                low,
+                i64::MAX,
+                true,
+                false
+            ),
+            Ok(false)
+        );
+        assert_eq!(
+            segment_hits_rect(point(i64::MIN, 5), point(i64::MAX, 5), high, i64::MAX),
+            Ok(true)
+        );
+    }
+}
diff --git a/crates/stack-engine/src/lib.rs b/crates/stack-engine/src/lib.rs
index c8de954..08aa089 100644
--- a/crates/stack-engine/src/lib.rs
+++ b/crates/stack-engine/src/lib.rs
@@ -29,6 +29,9 @@ mod routing;
 mod scene;
 mod svg;
 
+#[cfg(test)]
+mod layout_quality;
+
 mod language;
 mod provider;
 pub use language::{
diff --git a/layout-corpus/README.md b/layout-corpus/README.md
index 589a31a..1188d61 100644
--- a/layout-corpus/README.md
+++ b/layout-corpus/README.md
@@ -38,3 +38,58 @@ Commit the source, catalog, and updated snapshots together. Never update a snaps
 ## Runtime budget
 
 The benchmark warms each case three times and measures twenty release-mode renders. Every case must remain at or below 50 ms p95, and the complete seven-case suite including fixture loading must remain at or below 2,500 ms. These intentionally broad CI-safe ceilings detect algorithmic regressions without treating small host timing differences as product changes. The report shown in the gallery records observed timings; it is not a checked-in benchmark claim.
+
+## Geometry quality gates
+
+Snapshot equality does not prove legibility. Independent test-only gates examine
+the final SVG together with its prepared scene and versioned text metrics:
+
+```sh
+cargo test -p stack-engine --lib layout_quality::geometry --locked
+cargo test -p stack-engine --lib layout_quality::detector --locked
+cargo test -p stack-engine --lib layout_quality::parser --locked
+cargo test -p stack-engine --lib layout_quality::metrics --locked
+cargo test -p stack-engine --lib layout_quality::corpus_text_quality --locked -- --nocapture
+cargo test -p stack-engine --lib layout_quality::corpus_edge_quality --locked -- --nocapture
+```
+
+The text gate detects overlapping logical text envelopes (including diagram and
+group titles and edge-label backgrounds) and clipping. The edge gate detects
+stroke-envelope intersections with text and node layout envelopes. Only the
+actual first/last segment's normal contact with its own source/target boundary
+is exempt. Walking along a node boundary or re-entering it is not exempt. An
+edge's own label is not exempt either: painting an opaque rectangle over an edge
+is not proof that the route reserves space for that label.
+
+Each corpus command writes all candidate SVGs and an entity/geometry report to
+`target/layout-quality/text/` or `target/layout-quality/edge/` before failing on
+violations. Reports also record canvas dimensions, route length, and bends as
+separate composition measurements, not a weighted beauty score. Candidates do
+not overwrite approved snapshots. Current output intentionally fails these
+quality gates until the measured defects are resolved; skipping or allowing the
+existing violations would hide the work still needed.
+
+Checker unit tests cover colliding and separated boxes, stroke-only contact,
+endpoint exceptions, reversed segments, boundary traversal, re-entry, and
+unsupported geometry/content mutations. The parser rejects unmeasured transforms
+and unsupported text/route structures, CSS stylesheets, and inherited text
+positioning. Semantic text must occur once per owner and role; edge-label text
+must fit its background. Node shapes must exist and their SVG envelope must
+agree with the prepared scene. Rectangles, circles, polygons, and the current
+cylinder path grammar are supported; cylinder Bezier control points provide a
+conservative envelope, not exact curve extrema.
+
+Text uses theme advances and line height. Alphabetic reservations use the
+catalog's ascent/descent; `middle` reserves a centered line-height box. The latter
+is deliberately not an exact SVG glyph bound: SVG's middle baseline depends on
+font x-height, which the current metrics do not provide. Browser font fallback
+and actual glyph positioning still need visual validation.
+
+These are logical geometry checks, not
+pixel-level glyph measurements or arbitrary SVG validation. Exact decorative
+shape outlines, arrowheads, group-frame crossings, all theme variants, and a
+complete global composition metric remain outside this first gate. Passing it
+is necessary but not sufficient for visual approval: inspect the full diagram
+and review its composition before approving new snapshots or publishing a
+release. Candidate diagrams may be redesigned globally; label displacement
+alone is not a required implementation strategy.

From 19b43639227ac60de3963ae077fce099f7e4c887 Mon Sep 17 00:00:00 2001
From: konojunya <junya03dance@gmail.com>
Date: Sun, 6 Sep 2026 11:13:18 +0900
Subject: [PATCH 2/3] Compose graphs with label and frame clearance in
 pixel-space SVG

---
 README.md                                     |   1 +
 crates/stack-engine/src/labels.rs             | 702 ++++++++++++++
 crates/stack-engine/src/layout_quality.rs     | 605 +++++++++++-
 .../src/layout_quality/geometry.rs            | 278 ++++++
 crates/stack-engine/src/lib.rs                |   6 +-
 crates/stack-engine/src/placement_quality.rs  | 395 ++++++++
 crates/stack-engine/src/routing.rs            | 891 ++++++++++++++++--
 crates/stack-engine/src/scene.rs              | 500 +++++++++-
 crates/stack-engine/src/svg.rs                | 524 +++++-----
 .../fixtures/labelled-dag-regressions.json    | 422 +++++++++
 crates/stack-engine/tests/layout_corpus.rs    |  64 +-
 .../0005-serialize-safe-standalone-svg.md     |   5 +
 ...ose-graphs-with-reserved-label-geometry.md | 101 ++
 tests/wasm.test.mjs                           |  19 +-
 14 files changed, 4102 insertions(+), 411 deletions(-)
 create mode 100644 crates/stack-engine/src/labels.rs
 create mode 100644 crates/stack-engine/src/placement_quality.rs
 create mode 100644 crates/stack-engine/tests/fixtures/labelled-dag-regressions.json
 create mode 100644 docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md

diff --git a/README.md b/README.md
index 88f8299..161c101 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,7 @@ Public npm releases are produced from GitHub Releases after the repository check
 - [`docs/decisions/0005-serialize-safe-standalone-svg.md`](./docs/decisions/0005-serialize-safe-standalone-svg.md)
 - [`docs/decisions/0006-expose-one-typed-browser-wasm-adapter.md`](./docs/decisions/0006-expose-one-typed-browser-wasm-adapter.md)
 - [`docs/decisions/0007-adapt-language-intelligence-with-engine-catalogs.md`](./docs/decisions/0007-adapt-language-intelligence-with-engine-catalogs.md)
+- [`docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md`](./docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md) — unreleased visual-review candidate
 - [`docs/dependency-audit.md`](./docs/dependency-audit.md)
 
 ## Licensing
diff --git a/crates/stack-engine/src/labels.rs b/crates/stack-engine/src/labels.rs
new file mode 100644
index 0000000..e095f8d
--- /dev/null
+++ b/crates/stack-engine/src/labels.rs
@@ -0,0 +1,702 @@
+//! Deterministic label placement adjacent to each edge's own route.
+
+use std::cmp::Reverse;
+
+use stack_theme::{FontMetrics, Theme};
+
+use crate::routing::{Point, RoutingError, SceneEdge};
+use crate::scene::{self, Rect, SceneNode};
+
+const HORIZONTAL_PADDING: i64 = 6_000;
+const VERTICAL_PADDING: i64 = 4_000;
+const ROUTE_GAP: i64 = 8_000;
+
+#[derive(Clone, Copy)]
+struct Placement {
+    rect: Rect,
+    attachment: Point,
+}
+
+pub(crate) fn dimensions(label: &str, theme: &Theme, metrics: &FontMetrics) -> Rect {
+    let typography = &theme.typography;
+    Rect {
+        x: 0,
+        y: 0,
+        width: scene::text_width(label, typography.edge_label_size_milli_px, metrics)
+            + 2 * HORIZONTAL_PADDING,
+        height: scene::line_height(typography.edge_label_size_milli_px, typography)
+            + 2 * VERTICAL_PADDING,
+    }
+}
+
+pub(crate) fn place(
+    edges: &mut [SceneEdge],
+    nodes: &[SceneNode],
+    bounds: Rect,
+    fixed_text: &[Rect],
+    theme: &Theme,
+    metrics: &FontMetrics,
+) -> Result<(), RoutingError> {
+    let mut order = edges
+        .iter()
+        .enumerate()
+        .filter_map(|(index, edge)| {
+            edge.label
+                .as_ref()
+                .map(|label| (index, dimensions(label, theme, metrics)))
+        })
+        .collect::<Vec<_>>();
+    order.sort_by_key(|(index, size)| (Reverse(size.width), *index));
+    let mut occupied = nodes.iter().map(|node| node.rect).collect::<Vec<_>>();
+    occupied.extend_from_slice(fixed_text);
+    let mut placements = vec![None; edges.len()];
+    let stroke_width = i64::from(theme.connector.width_milli_px);
+
+    for (index, size) in order {
+        let placement = candidates(&edges[index].path, size, bounds)
+            .into_iter()
+            .find(|candidate| rect_is_clear(candidate.rect, bounds, &occupied, edges, stroke_width))
+            .ok_or(RoutingError)?;
+        occupied.push(placement.rect);
+        placements[index] = Some(placement);
+    }
+
+    // Commit only a complete placement so a failed attempt leaves its input intact.
+    for (edge, placement) in edges.iter_mut().zip(placements) {
+        edge.label_rect = placement.map(|placement| placement.rect);
+        edge.label_anchor = placement.map(|placement| placement.attachment);
+    }
+    Ok(())
+}
+
+pub(crate) fn place_next(
+    edge: &mut SceneEdge,
+    previous: &[SceneEdge],
+    nodes: &[SceneNode],
+    bounds: Rect,
+    fixed_text: &[Rect],
+    theme: &Theme,
+    metrics: &FontMetrics,
+) -> Result<(), RoutingError> {
+    let Some(label) = edge.label.as_ref() else {
+        edge.label_rect = None;
+        edge.label_anchor = None;
+        return Ok(());
+    };
+    let mut occupied = nodes.iter().map(|node| node.rect).collect::<Vec<_>>();
+    occupied.extend_from_slice(fixed_text);
+    occupied.extend(previous.iter().filter_map(|edge| edge.label_rect));
+    let stroke_width = i64::from(theme.connector.width_milli_px);
+    let placement = candidates(&edge.path, dimensions(label, theme, metrics), bounds)
+        .into_iter()
+        .find(|candidate| {
+            rect_is_clear(candidate.rect, bounds, &occupied, previous, stroke_width)
+                && rect_is_clear(
+                    candidate.rect,
+                    bounds,
+                    &[],
+                    std::slice::from_ref(edge),
+                    stroke_width,
+                )
+        })
+        .ok_or(RoutingError)?;
+    edge.label_rect = Some(placement.rect);
+    edge.label_anchor = Some(placement.attachment);
+    Ok(())
+}
+
+pub(crate) fn geometry_is_valid(
+    edges: &[SceneEdge],
+    nodes: &[SceneNode],
+    bounds: Rect,
+    fixed_text: &[Rect],
+    stroke_width: i64,
+) -> bool {
+    let mut occupied = nodes.iter().map(|node| node.rect).collect::<Vec<_>>();
+    occupied.extend_from_slice(fixed_text);
+    for edge in edges {
+        match (&edge.label, edge.label_rect, edge.label_anchor) {
+            (None, None, None) => {}
+            (Some(_), Some(rect), Some(attachment)) => {
+                if !rect_is_clear(rect, bounds, &occupied, edges, stroke_width)
+                    || !edge
+                        .path
+                        .windows(2)
+                        .any(|segment| is_adjacent(rect, attachment, segment[0], segment[1]))
+                {
+                    return false;
+                }
+                occupied.push(rect);
+            }
+            _ => return false,
+        }
+    }
+    true
+}
+
+fn candidates(path: &[Point], size: Rect, bounds: Rect) -> Vec<Placement> {
+    let mut segments = path.windows(2).enumerate().collect::<Vec<_>>();
+    segments.sort_by_key(|(index, segment)| {
+        (
+            Reverse((segment[1].x - segment[0].x).abs() + (segment[1].y - segment[0].y).abs()),
+            *index,
+        )
+    });
+    let mut candidates = Vec::new();
+    for (_, segment) in segments {
+        let start = segment[0];
+        let end = segment[1];
+        if start == end {
+            continue;
+        }
+        if start.y == end.y {
+            let positions = axis_positions(start.x, end.x, size.width, bounds.x, bounds.width);
+            for y in [start.y - ROUTE_GAP - size.height, start.y + ROUTE_GAP] {
+                for &x in &positions {
+                    candidates.push(Placement {
+                        rect: Rect {
+                            x: x - size.width / 2,
+                            y,
+                            ..size
+                        },
+                        attachment: Point { x, y: start.y },
+                    });
+                }
+            }
+        } else if start.x == end.x {
+            let positions = axis_positions(start.y, end.y, size.height, bounds.y, bounds.height);
+            for x in [start.x + ROUTE_GAP, start.x - ROUTE_GAP - size.width] {
+                for &y in &positions {
+                    candidates.push(Placement {
+                        rect: Rect {
+                            x,
+                            y: y - size.height / 2,
+                            ..size
+                        },
+                        attachment: Point { x: start.x, y },
+                    });
+                }
+            }
+        }
+    }
+    candidates
+}
+
+fn axis_positions(start: i64, end: i64, size: i64, origin: i64, extent: i64) -> Vec<i64> {
+    let low = start.min(end);
+    let high = start.max(end);
+    let minimum = (low + 1).max(origin + size / 2);
+    let maximum = (high - 1).min(origin + extent - (size - size / 2));
+    if size <= 0 || minimum > maximum {
+        return Vec::new();
+    }
+    let length = high - low;
+    let mut positions = Vec::new();
+    for preferred in [
+        low + length / 2,
+        low + length / 3,
+        low + 2 * length / 3,
+        low + size / 2,
+        high - (size - size / 2),
+    ] {
+        let position = preferred.clamp(minimum, maximum);
+        if !positions.contains(&position) {
+            positions.push(position);
+        }
+    }
+    positions
+}
+
+fn is_adjacent(rect: Rect, attachment: Point, start: Point, end: Point) -> bool {
+    if start.y == end.y && start.x != end.x {
+        attachment.y == start.y
+            && attachment.x > start.x.min(end.x)
+            && attachment.x < start.x.max(end.x)
+            && attachment.x == rect.x + rect.width / 2
+            && (rect.y + rect.height + ROUTE_GAP == attachment.y
+                || rect.y - ROUTE_GAP == attachment.y)
+    } else if start.x == end.x && start.y != end.y {
+        attachment.x == start.x
+            && attachment.y > start.y.min(end.y)
+            && attachment.y < start.y.max(end.y)
+            && attachment.y == rect.y + rect.height / 2
+            && (rect.x - ROUTE_GAP == attachment.x
+                || rect.x + rect.width + ROUTE_GAP == attachment.x)
+    } else {
+        false
+    }
+}
+
+fn rect_is_clear(
+    rect: Rect,
+    bounds: Rect,
+    occupied: &[Rect],
+    edges: &[SceneEdge],
+    stroke_width: i64,
+) -> bool {
+    rect.width > 0
+        && rect.height > 0
+        && stroke_width >= 0
+        && rect.x >= bounds.x
+        && rect.y >= bounds.y
+        && rect.x + rect.width <= bounds.x + bounds.width
+        && rect.y + rect.height <= bounds.y + bounds.height
+        && occupied.iter().all(|other| !rects_touch(rect, *other))
+        && edges.iter().all(|edge| {
+            edge.path.windows(2).all(|segment| {
+                !stroke_hits_rect(segment[0], segment[1], rect, (stroke_width + 1) / 2)
+            })
+        })
+}
+
+fn rects_touch(left: Rect, right: Rect) -> bool {
+    left.x <= right.x + right.width
+        && right.x <= left.x + left.width
+        && left.y <= right.y + right.height
+        && right.y <= left.y + left.height
+}
+
+fn stroke_hits_rect(start: Point, end: Point, rect: Rect, radius: i64) -> bool {
+    if start == end || (start.x != end.x && start.y != end.y) {
+        return true;
+    }
+    let envelope = Rect {
+        x: start.x.min(end.x) - radius,
+        y: start.y.min(end.y) - radius,
+        width: (end.x - start.x).abs() + 2 * radius,
+        height: (end.y - start.y).abs() + 2 * radius,
+    };
+    rects_touch(rect, envelope)
+}
+
+#[cfg(test)]
+mod tests {
+    use stack_compiler::ir::{EdgeDirection, EdgeKind};
+
+    use super::{dimensions, geometry_is_valid, place, place_next};
+    use crate::routing::{Marker, Point, SceneEdge};
+    use crate::scene::{self, Rect, SceneNode};
+
+    type TestResult<T = ()> = Result<T, Box<dyn std::error::Error>>;
+
+    fn resources() -> TestResult<(
+        &'static stack_theme::Theme,
+        &'static stack_theme::FontMetrics,
+    )> {
+        let catalog = stack_theme::catalog();
+        let theme = catalog
+            .themes
+            .first()
+            .ok_or("bundled catalog has no theme")?;
+        let metrics = catalog
+            .font_metrics
+            .iter()
+            .find(|metrics| metrics.id == theme.typography.font_metrics_id)
+            .ok_or("bundled theme has no font metrics")?;
+        Ok((theme, metrics))
+    }
+
+    fn bounds() -> Rect {
+        Rect {
+            x: 0,
+            y: 0,
+            width: 800_000,
+            height: 600_000,
+        }
+    }
+
+    fn edge(label: Option<&str>, path: &[(i64, i64)]) -> SceneEdge {
+        SceneEdge {
+            from: "source".to_owned(),
+            to: "target".to_owned(),
+            direction: EdgeDirection::Forward,
+            kind: EdgeKind::Flow,
+            label: label.map(str::to_owned),
+            path: path.iter().map(|&(x, y)| Point { x, y }).collect(),
+            start_marker: Marker::None,
+            end_marker: Marker::Arrow,
+            label_anchor: None,
+            label_rect: None,
+        }
+    }
+
+    fn place_labels(edges: &mut [SceneEdge], nodes: &[SceneNode], fixed: &[Rect]) -> TestResult {
+        let (theme, metrics) = resources()?;
+        place(edges, nodes, bounds(), fixed, theme, metrics)
+            .map_err(|_| "labels do not fit synthetic scene")?;
+        assert!(geometry_is_valid(
+            edges,
+            nodes,
+            bounds(),
+            fixed,
+            i64::from(theme.connector.width_milli_px),
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn dimensions_use_font_metrics_and_background_padding() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let measured = dimensions("Read records", theme, metrics);
+        assert_eq!(measured.x, 0);
+        assert_eq!(measured.y, 0);
+        assert_eq!(
+            measured.width,
+            scene::text_width(
+                "Read records",
+                theme.typography.edge_label_size_milli_px,
+                metrics
+            ) + 12_000,
+        );
+        assert_eq!(
+            measured.height,
+            scene::line_height(theme.typography.edge_label_size_milli_px, &theme.typography)
+                + 8_000,
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn horizontal_label_prefers_above_with_its_attachment_on_the_segment() -> TestResult {
+        let mut edges = [edge(
+            Some("HTTPS"),
+            &[(100_000, 200_000), (600_000, 200_000)],
+        )];
+        place_labels(&mut edges, &[], &[])?;
+        let rect = edges[0].label_rect.ok_or("missing label rectangle")?;
+        let anchor = edges[0].label_anchor.ok_or("missing label attachment")?;
+        assert_eq!(
+            anchor,
+            Point {
+                x: 350_000,
+                y: 200_000
+            }
+        );
+        assert_eq!(rect.x + rect.width / 2, anchor.x);
+        assert_eq!(rect.y + rect.height + 8_000, anchor.y);
+        Ok(())
+    }
+
+    #[test]
+    fn long_vertical_label_uses_reserved_space_on_the_right() -> TestResult {
+        let mut edges = [edge(
+            Some("A long description of the database connection"),
+            &[(100_000, 100_000), (100_000, 500_000)],
+        )];
+        place_labels(&mut edges, &[], &[])?;
+        let rect = edges[0].label_rect.ok_or("missing label rectangle")?;
+        let anchor = edges[0].label_anchor.ok_or("missing label attachment")?;
+        assert_eq!(rect.x, 108_000);
+        assert_eq!(rect.y + rect.height / 2, anchor.y);
+        assert_eq!(anchor.x, 100_000);
+        Ok(())
+    }
+
+    #[test]
+    fn unlabeled_routes_block_label_backgrounds() -> TestResult {
+        let mut edges = [
+            edge(Some("HTTPS"), &[(100_000, 200_000), (600_000, 200_000)]),
+            edge(None, &[(0, 180_000), (800_000, 180_000)]),
+        ];
+        place_labels(&mut edges, &[], &[])?;
+        assert!(edges[0].label_rect.ok_or("missing label rectangle")?.y > 200_000);
+        assert_eq!(edges[1].label_anchor, None);
+        assert_eq!(edges[1].label_rect, None);
+        Ok(())
+    }
+
+    #[test]
+    fn nodes_and_titles_can_force_a_non_midpoint_candidate() -> TestResult {
+        let mut edges = [edge(
+            Some("HTTPS"),
+            &[(100_000, 300_000), (700_000, 300_000)],
+        )];
+        let nodes = [SceneNode {
+            id: "blocker".to_owned(),
+            parent_group_id: None,
+            rect: Rect {
+                x: 350_000,
+                y: 230_000,
+                width: 100_000,
+                height: 62_000,
+            },
+        }];
+        let titles = [Rect {
+            x: 0,
+            y: 308_000,
+            width: 800_000,
+            height: 80_000,
+        }];
+        place_labels(&mut edges, &nodes, &titles)?;
+        assert_ne!(
+            edges[0].label_anchor.ok_or("missing label attachment")?.x,
+            400_000
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn labels_avoid_each_other_without_reordering_edges() -> TestResult {
+        let mut edges = [
+            edge(
+                Some("First connection"),
+                &[(100_000, 250_000), (700_000, 250_000)],
+            ),
+            edge(
+                Some("Second connection"),
+                &[(100_000, 250_000), (700_000, 250_000)],
+            ),
+            edge(Some("Third"), &[(100_000, 250_000), (700_000, 250_000)]),
+        ];
+        let original = edges.clone();
+        place_labels(&mut edges, &[], &[])?;
+        for (index, placed) in edges.iter().enumerate() {
+            assert_eq!(placed.label, original[index].label);
+            assert_eq!(placed.path, original[index].path);
+            assert_eq!(placed.direction, original[index].direction);
+        }
+        let mut repeated = original;
+        place_labels(&mut repeated, &[], &[])?;
+        assert_eq!(edges, repeated);
+        Ok(())
+    }
+
+    #[test]
+    fn placement_failure_does_not_send_a_label_to_unrelated_distant_space() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let mut edges = [edge(
+            Some("No room"),
+            &[(200_000, 200_000), (300_000, 200_000)],
+        )];
+        let fixed = [Rect {
+            x: 100_000,
+            y: 100_000,
+            width: 300_000,
+            height: 200_000,
+        }];
+        let original = edges.clone();
+        assert!(place(&mut edges, &[], bounds(), &fixed, theme, metrics).is_err());
+        assert_eq!(edges, original);
+        Ok(())
+    }
+
+    #[test]
+    fn labels_at_canvas_edges_keep_the_attachment_inside_the_segment() -> TestResult {
+        let mut edges = [edge(Some("Read"), &[(0, 10_000), (100_000, 10_000)])];
+        place_labels(&mut edges, &[], &[])?;
+        let rect = edges[0].label_rect.ok_or("missing label rectangle")?;
+        let anchor = edges[0].label_anchor.ok_or("missing label attachment")?;
+        assert!(rect.x >= 0);
+        assert!(rect.y > 10_000);
+        assert!(anchor.x > 0 && anchor.x < 100_000);
+        Ok(())
+    }
+
+    #[test]
+    fn labels_too_wide_for_the_canvas_report_failure() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let label = "A connection description ".repeat(50);
+        let mut edges = [edge(
+            Some(&label),
+            &[(100_000, 100_000), (100_000, 500_000)],
+        )];
+        assert!(place(&mut edges, &[], bounds(), &[], theme, metrics).is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn validator_rejects_labels_outside_bounds_or_touching_fixed_text() -> TestResult {
+        let (theme, _) = resources()?;
+        let width = i64::from(theme.connector.width_milli_px);
+        let mut edges = [edge(
+            Some("HTTPS"),
+            &[(100_000, 200_000), (600_000, 200_000)],
+        )];
+        place_labels(&mut edges, &[], &[])?;
+        let rect = edges[0].label_rect.ok_or("missing label rectangle")?;
+        let small_bounds = Rect {
+            height: 100_000,
+            ..bounds()
+        };
+        assert!(!geometry_is_valid(&edges, &[], small_bounds, &[], width));
+        let title = Rect {
+            y: rect.y - rect.height,
+            ..rect
+        };
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[title], width));
+        Ok(())
+    }
+
+    #[test]
+    fn validator_rejects_a_label_missing_its_rectangle_or_attached_far_away() -> TestResult {
+        let (theme, _) = resources()?;
+        let width = i64::from(theme.connector.width_milli_px);
+        let mut edges = [edge(
+            Some("HTTPS"),
+            &[(100_000, 200_000), (600_000, 200_000)],
+        )];
+        place_labels(&mut edges, &[], &[])?;
+        let original = edges.clone();
+        edges[0].label_rect = None;
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[], width));
+        edges = original.clone();
+        edges[0].label_anchor = Some(Point {
+            x: 350_000,
+            y: 400_000,
+        });
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[], width));
+        edges = original;
+        edges[0]
+            .label_rect
+            .as_mut()
+            .ok_or("missing label rectangle")?
+            .y -= 100_000;
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[], width));
+        Ok(())
+    }
+
+    #[test]
+    fn validator_rejects_contact_with_the_stroke_envelope() -> TestResult {
+        let mut edges = vec![edge(
+            Some("HTTPS"),
+            &[(100_000, 200_000), (600_000, 200_000)],
+        )];
+        place_labels(&mut edges, &[], &[])?;
+        let rect = edges[0].label_rect.ok_or("missing label rectangle")?;
+        edges.push(edge(
+            None,
+            &[(0, rect.y - 1_000), (800_000, rect.y - 1_000)],
+        ));
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[], 2_000));
+        Ok(())
+    }
+
+    #[test]
+    fn validator_rejects_overlapping_labels_and_unlabeled_rectangles() -> TestResult {
+        let (theme, _) = resources()?;
+        let width = i64::from(theme.connector.width_milli_px);
+        let mut edges = vec![edge(
+            Some("HTTPS"),
+            &[(100_000, 200_000), (600_000, 200_000)],
+        )];
+        place_labels(&mut edges, &[], &[])?;
+        edges.push(edges[0].clone());
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[], width));
+        edges.pop();
+        edges[0].label = None;
+        assert!(!geometry_is_valid(&edges, &[], bounds(), &[], width));
+        Ok(())
+    }
+
+    #[test]
+    fn place_next_preserves_previous_labels_and_routes() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let mut previous = vec![edge(
+            Some("Already placed"),
+            &[(100_000, 250_000), (700_000, 250_000)],
+        )];
+        place_labels(&mut previous, &[], &[])?;
+        let original = previous.clone();
+        let mut next = edge(
+            Some("Next connection"),
+            &[(100_000, 250_000), (700_000, 250_000)],
+        );
+        let original_next = next.clone();
+        place_next(&mut next, &previous, &[], bounds(), &[], theme, metrics)
+            .map_err(|_| "next label does not fit")?;
+        assert_eq!(previous, original);
+        assert_eq!(next.path, original_next.path);
+        assert_eq!(next.label, original_next.label);
+        assert_ne!(next.label_rect, previous[0].label_rect);
+        previous.push(next);
+        assert!(geometry_is_valid(
+            &previous,
+            &[],
+            bounds(),
+            &[],
+            i64::from(theme.connector.width_milli_px),
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn place_next_avoids_previous_labels_all_routes_nodes_and_titles() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let nodes = [SceneNode {
+            id: "blocker".to_owned(),
+            parent_group_id: None,
+            rect: Rect {
+                x: 460_000,
+                y: 208_000,
+                width: 150_000,
+                height: 37_000,
+            },
+        }];
+        let titles = [Rect {
+            x: 0,
+            y: 208_000,
+            width: 340_000,
+            height: 37_000,
+        }];
+        let mut previous = vec![
+            edge(Some("Old"), &[(100_000, 250_000), (700_000, 250_000)]),
+            edge(None, &[(0, 180_000), (800_000, 180_000)]),
+        ];
+        place_labels(&mut previous, &nodes, &titles)?;
+        let mut next = edge(Some("HTTPS"), &[(100_000, 200_000), (700_000, 200_000)]);
+        place_next(
+            &mut next,
+            &previous,
+            &nodes,
+            bounds(),
+            &titles,
+            theme,
+            metrics,
+        )
+        .map_err(|_| "next label does not fit beside the remaining segment")?;
+        let rect = next.label_rect.ok_or("missing next label rectangle")?;
+        assert!(rect.x > 610_000);
+        assert!(rect.y > 200_000);
+        previous.push(next);
+        assert!(geometry_is_valid(
+            &previous,
+            &nodes,
+            bounds(),
+            &titles,
+            i64::from(theme.connector.width_milli_px),
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn place_next_failure_preserves_the_entire_new_edge() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let mut next = edge(Some("No room"), &[(200_000, 200_000), (300_000, 200_000)]);
+        place_labels(std::slice::from_mut(&mut next), &[], &[])?;
+        let original = next.clone();
+        let occupied = [Rect {
+            x: 100_000,
+            y: 100_000,
+            width: 300_000,
+            height: 200_000,
+        }];
+        assert!(place_next(&mut next, &[], &[], bounds(), &occupied, theme, metrics).is_err());
+        assert_eq!(next, original);
+        Ok(())
+    }
+
+    #[test]
+    fn place_next_leaves_an_unlabeled_edge_without_label_metadata() -> TestResult {
+        let (theme, metrics) = resources()?;
+        let mut next = edge(Some("Old label"), &[(100_000, 200_000), (700_000, 200_000)]);
+        place_labels(std::slice::from_mut(&mut next), &[], &[])?;
+        next.label = None;
+        let original_path = next.path.clone();
+        place_next(&mut next, &[], &[], bounds(), &[], theme, metrics)
+            .map_err(|_| "unlabeled edge placement failed")?;
+        assert_eq!(next.label_rect, None);
+        assert_eq!(next.label_anchor, None);
+        assert_eq!(next.path, original_path);
+        Ok(())
+    }
+}
diff --git a/crates/stack-engine/src/layout_quality.rs b/crates/stack-engine/src/layout_quality.rs
index 6516293..b90f886 100644
--- a/crates/stack-engine/src/layout_quality.rs
+++ b/crates/stack-engine/src/layout_quality.rs
@@ -19,6 +19,9 @@ use geometry::{Point, Rect};
 
 type Result<T> = std::result::Result<T, Box<dyn Error>>;
 
+const MINIMUM_PAINTED_FRAME_CLEARANCE: i64 = 16_000;
+const MINIMUM_LABEL_FRAME_CLEARANCE: i64 = 8_000;
+
 #[derive(Debug)]
 struct TextBox {
     id: String,
@@ -34,11 +37,19 @@ struct Route {
     radius: i64,
 }
 
+#[derive(Debug)]
+struct GroupFrame {
+    id: String,
+    rect: Rect,
+    radius: i64,
+}
+
 #[derive(Debug)]
 struct Drawing {
     bounds: Rect,
     texts: Vec<TextBox>,
     nodes: Vec<(String, Rect)>,
+    frames: Vec<GroupFrame>,
     routes: Vec<Route>,
 }
 
@@ -56,8 +67,45 @@ fn required<'a>(node: Node<'a, '_>, name: &str) -> Result<&'a str> {
         .ok_or_else(|| format!("missing {name} on {}", node.tag_name().name()).into())
 }
 
+fn pixel_value(value: &str) -> Result<i64> {
+    // SVG uses pixel decimals; geometry stays in exact integer milli-pixels.
+    // Reject SVG's wider numeric grammar rather than silently rounding it.
+    let (negative, magnitude) = value
+        .strip_prefix('-')
+        .map_or((false, value), |magnitude| (true, magnitude));
+    let (whole, fraction) = match magnitude.split_once('.') {
+        Some((whole, fraction)) => {
+            if fraction.is_empty()
+                || fraction.len() > 3
+                || !fraction.bytes().all(|digit| digit.is_ascii_digit())
+            {
+                return Err("unsupported pixel fraction".into());
+            }
+            (whole, fraction)
+        }
+        None => (magnitude, ""),
+    };
+    if whole.is_empty()
+        || !whole.bytes().all(|digit| digit.is_ascii_digit())
+        || (whole.len() > 1 && whole.starts_with('0'))
+    {
+        return Err("unsupported pixel integer".into());
+    }
+    let whole: i128 = whole.parse()?;
+    let fraction = fraction
+        .bytes()
+        .chain(std::iter::repeat_n(b'0', 3 - fraction.len()))
+        .fold(0_i128, |value, digit| value * 10 + i128::from(digit - b'0'));
+    let magnitude = whole
+        .checked_mul(1000)
+        .and_then(|value| value.checked_add(fraction))
+        .ok_or("pixel coordinate overflow")?;
+    let value = if negative { -magnitude } else { magnitude };
+    Ok(i64::try_from(value)?)
+}
+
 fn number(node: Node<'_, '_>, name: &str) -> Result<i64> {
-    Ok(required(node, name)?.parse()?)
+    pixel_value(required(node, name)?)
 }
 
 fn rectangle(node: Node<'_, '_>) -> Result<Rect> {
@@ -94,21 +142,24 @@ fn text_rectangle(
         / i64::from(metrics.units_per_em);
     let height =
         scene::line_height(size, &prepared.resources.theme.typography).max(ascent + descent);
-    let mut x = number(node, "x")?;
-    match node.attribute("text-anchor").unwrap_or("start") {
-        "start" => {}
-        "middle" => x -= width / 2,
-        "end" => x -= width,
+    let offset = match node.attribute("text-anchor").unwrap_or("start") {
+        "start" => 0,
+        "middle" => width / 2,
+        "end" => width,
         _ => return Err("unsupported text-anchor".into()),
-    }
+    };
+    let x = number(node, "x")?
+        .checked_sub(offset)
+        .ok_or("text coordinate overflow")?;
     let y = number(node, "y")?;
-    let top = match node.attribute("dominant-baseline").unwrap_or("alphabetic") {
-        "alphabetic" => y - ascent - (height - ascent - descent) / 2,
+    let offset = match node.attribute("dominant-baseline").unwrap_or("alphabetic") {
+        "alphabetic" => ascent + (height - ascent - descent) / 2,
         // A deterministic layout reservation, not the browser's exact glyph box:
         // SVG middle depends on the font's x-height, absent from current metrics.
-        "middle" => y - height / 2,
+        "middle" => height / 2,
         _ => return Err("unsupported dominant-baseline".into()),
     };
+    let top = y.checked_sub(offset).ok_or("text coordinate overflow")?;
     Ok(Rect {
         x,
         y: top,
@@ -123,8 +174,8 @@ fn point_list(value: &str) -> Result<Vec<Point>> {
         .map(|pair| {
             let (x, y) = pair.split_once(',').ok_or("invalid point")?;
             Ok(Point {
-                x: x.parse()?,
-                y: y.parse()?,
+                x: pixel_value(x)?,
+                y: pixel_value(y)?,
             })
         })
         .collect()
@@ -213,7 +264,7 @@ fn shape_envelope(node: Node<'_, '_>) -> Result<Rect> {
             {
                 return Err("unsupported node path grammar".into());
             }
-            let n = |index: usize| -> Result<i64> { Ok(tokens[index].parse()?) };
+            let n = |index: usize| pixel_value(tokens[index]);
             let mut points = vec![Point { x: n(1)?, y: n(2)? }, Point { x: n(1)?, y: n(4)? }];
             for start in [6, 8, 10, 15, 17, 19] {
                 points.push(Point {
@@ -243,21 +294,7 @@ fn drawing_layer<'a, 'input>(root: Node<'a, 'input>, name: &str) -> Result<Node<
 }
 
 fn viewport_dimension(node: Node<'_, '_>, name: &str) -> Result<i64> {
-    let value = required(node, name)?;
-    let (whole, fraction) = value.split_once('.').unwrap_or((value, ""));
-    if whole.is_empty()
-        || !whole.bytes().all(|value| value.is_ascii_digit())
-        || fraction.len() > 3
-        || !fraction.bytes().all(|value| value.is_ascii_digit())
-    {
-        return Err("unsupported viewport dimension".into());
-    }
-    let whole: i64 = whole.parse()?;
-    let fraction: i64 = format!("{fraction:0<3}").parse()?;
-    let value = whole
-        .checked_mul(1000)
-        .and_then(|value| value.checked_add(fraction))
-        .ok_or("viewport overflow")?;
+    let value = number(node, name)?;
     if value <= 0 {
         return Err("non-positive viewport".into());
     }
@@ -338,6 +375,69 @@ fn node_envelopes(
     Ok(nodes)
 }
 
+fn group_frames(
+    root: Node<'_, '_>,
+    prepared: &crate::PreparedScene<'_>,
+) -> Result<Vec<GroupFrame>> {
+    let groups = drawing_layer(root, "groups")?
+        .children()
+        .filter(Node::is_element)
+        .collect::<Vec<_>>();
+    if groups.len() != prepared.scene.groups.len() {
+        return Err("group frame inventory drift".into());
+    }
+    let mut frames = Vec::new();
+    for (group, expected) in groups.into_iter().zip(&prepared.scene.groups) {
+        if !group.has_tag_name("g")
+            || group.has_attribute("data-node-kind")
+            || required(group, "data-stack-id")? != expected.id
+        {
+            return Err("group frame owner drift".into());
+        }
+        let elements = group
+            .children()
+            .filter(Node::is_element)
+            .collect::<Vec<_>>();
+        if elements
+            .iter()
+            .map(|element| element.tag_name().name())
+            .collect::<Vec<_>>()
+            != ["title", "rect", "text"]
+        {
+            return Err("group frame shape inventory drift".into());
+        }
+        let element = elements[1];
+        let envelope = rectangle(element)?;
+        if envelope != rect(expected.rect) {
+            return Err("SVG/scene group frame drift".into());
+        }
+        if matches!(required(element, "stroke")?, "none" | "transparent")
+            || element.ancestors().any(|ancestor| {
+                [
+                    "stroke-opacity",
+                    "stroke-dasharray",
+                    "stroke-dashoffset",
+                    "vector-effect",
+                ]
+                .iter()
+                .any(|attribute| ancestor.has_attribute(*attribute))
+            })
+        {
+            return Err("unsupported group frame stroke".into());
+        }
+        let width = number(element, "stroke-width")?;
+        if width <= 0 {
+            return Err("non-positive group frame stroke width".into());
+        }
+        frames.push(GroupFrame {
+            id: expected.id.clone(),
+            rect: envelope,
+            radius: width / 2 + width % 2,
+        });
+    }
+    Ok(frames)
+}
+
 fn read_drawing(
     svg: &str,
     prepared: &crate::PreparedScene<'_>,
@@ -353,8 +453,8 @@ fn read_drawing(
     }
     let view_box = required(root, "viewBox")?
         .split_whitespace()
-        .map(str::parse)
-        .collect::<std::result::Result<Vec<i64>, _>>()?;
+        .map(pixel_value)
+        .collect::<Result<Vec<_>>>()?;
     let expected = prepared.scene.bounds;
     if view_box != [expected.x, expected.y, expected.width, expected.height] {
         return Err("SVG/scene bounds drift".into());
@@ -378,8 +478,8 @@ fn read_drawing(
             return Err(format!("unexpected root {tag} inventory").into());
         }
     }
-    // The owned drawing currently uses untransformed integer coordinates. A new
-    // transform or text positioning mode must be supported, not silently skipped.
+    // The owned drawing uses untransformed pixel decimals. A new transform or
+    // text positioning mode must be supported, not silently skipped.
     for node in root
         .descendants()
         .filter(Node::is_element)
@@ -501,7 +601,7 @@ fn read_drawing(
         if required(node, "font-family")? != prepared.resources.metrics.family {
             return Err("text uses unmeasured font family".into());
         }
-        let size: u32 = required(node, "font-size")?.parse()?;
+        let size = u32::try_from(number(node, "font-size")?)?;
         let text_bounds = text_rectangle(node, prepared, size)?;
         let (id, owner, bounds) = if parent.has_attribute("data-edge-label") {
             if !parent.has_tag_name("g") || parent.parent_element() != Some(labels_layer) {
@@ -639,6 +739,7 @@ fn read_drawing(
         return Err("semantic text inventory drift".into());
     }
     let nodes = node_envelopes(root, prepared)?;
+    let frames = group_frames(root, prepared)?;
     let mut routes = Vec::new();
     for (index, group) in edge_layer.children().filter(Node::is_element).enumerate() {
         if !group.has_tag_name("g") {
@@ -681,7 +782,7 @@ fn read_drawing(
             from: expected.from.clone(),
             to: expected.to.clone(),
             points,
-            radius: (width + 1) / 2,
+            radius: width / 2 + width % 2,
         });
     }
     if routes.len() != diagram.edges.len() {
@@ -691,6 +792,7 @@ fn read_drawing(
         bounds: rect(expected),
         texts,
         nodes,
+        frames,
         routes,
     })
 }
@@ -762,6 +864,54 @@ fn edge_violations(drawing: &Drawing) -> Result<Vec<Value>> {
     Ok(violations)
 }
 
+fn frame_violations(drawing: &Drawing) -> Result<Vec<Value>> {
+    let mut violations = Vec::new();
+    for route in &drawing.routes {
+        for frame in &drawing.frames {
+            let clearance = MINIMUM_PAINTED_FRAME_CLEARANCE
+                .checked_add(route.radius)
+                .and_then(|value| value.checked_add(frame.radius))
+                .ok_or("frame clearance overflow")?;
+            for (index, pair) in route.points.windows(2).enumerate() {
+                if geometry::parallel_frame_contact(pair[0], pair[1], frame.rect, clearance)? {
+                    violations.push(json!({
+                        "kind":"edge-group-frame-clearance",
+                        "entities":[route.id,frame.id],
+                        "segmentIndex":index,
+                        "segment":[{"x":pair[0].x,"y":pair[0].y},{"x":pair[1].x,"y":pair[1].y}],
+                        "rect":rectangle_json(frame.rect),
+                        "requiredCenterlineClearanceMilliPx":clearance,
+                        "routeStrokeRadiusMilliPx":route.radius,
+                        "frameStrokeRadiusMilliPx":frame.radius
+                    }));
+                }
+            }
+        }
+    }
+    for label in drawing
+        .texts
+        .iter()
+        .filter(|text| text.id.starts_with("edge-label:"))
+    {
+        for frame in &drawing.frames {
+            let clearance = MINIMUM_LABEL_FRAME_CLEARANCE
+                .checked_add(frame.radius)
+                .ok_or("label frame clearance overflow")?;
+            if geometry::label_frame_contact(label.rect, frame.rect, clearance)? {
+                violations.push(json!({
+                    "kind":"label-group-frame-clearance",
+                    "entities":[label.id,frame.id],
+                    "labelRect":rectangle_json(label.rect),
+                    "frameRect":rectangle_json(frame.rect),
+                    "requiredCenterlineClearanceMilliPx":clearance,
+                    "frameStrokeRadiusMilliPx":frame.radius
+                }));
+            }
+        }
+    }
+    Ok(violations)
+}
+
 #[derive(Deserialize)]
 struct Catalog {
     cases: Vec<Case>,
@@ -829,21 +979,31 @@ fn run_corpus(gate: &str) -> Result<()> {
             compiled.source_map.as_ref().ok_or("no source map")?,
         )?;
         let drawing = read_drawing(&svg, &prepared, diagram)?;
-        let violations = if gate == "text" {
-            text_violations(&drawing)
-        } else {
-            edge_violations(&drawing)?
+        let violations = match gate {
+            "text" => text_violations(&drawing),
+            "edge" => edge_violations(&drawing)?,
+            "frame" => frame_violations(&drawing)?,
+            _ => return Err("unknown layout quality gate".into()),
         };
         count += violations.len();
         fs::write(output_dir.join(format!("{}.svg", case.id)), svg)?;
         eprintln!("{}: {} {gate} violation(s)", case.id, violations.len());
         results.push(json!({"id":case.id,"violations":violations,"composition":composition_metrics(&drawing)}));
     }
+    let mut report = json!({"schemaVersion":"1.0","gate":gate,"units":"1/1000 CSS px","engineVersion":crate::ENGINE_VERSION,"limitations":["logical text envelopes, not raster glyph bounds","middle-baseline reservation is centered line height, not font x-height measurement","node SVG and Bezier control-point envelopes, not exact painted shape outlines","arrowheads and group frame collisions are not measured","global composition metrics are not a beauty score"],"violations":count,"cases":results});
+    if gate == "frame" {
+        report["minimumPaintedClearanceMilliPx"] = json!(MINIMUM_PAINTED_FRAME_CLEARANCE);
+        report["minimumLabelPaintedFrameClearanceMilliPx"] = json!(MINIMUM_LABEL_FRAME_CLEARANCE);
+        report["limitations"] = json!([
+            "finite group frame centerline rectangles with conservative rounded-corner clearance",
+            "perpendicular crossings away from corners are allowed",
+            "arrowheads are not measured",
+            "global composition metrics are not a beauty score"
+        ]);
+    }
     fs::write(
         output_dir.join("report.json"),
-        serde_json::to_vec_pretty(
-            &json!({"schemaVersion":"1.0","gate":gate,"units":"1/1000 CSS px","engineVersion":crate::ENGINE_VERSION,"limitations":["logical text envelopes, not raster glyph bounds","middle-baseline reservation is centered line height, not font x-height measurement","node SVG and Bezier control-point envelopes, not exact painted shape outlines","arrowheads and group frame collisions are not measured","global composition metrics are not a beauty score"],"violations":count,"cases":results}),
-        )?,
+        serde_json::to_vec_pretty(&report)?,
     )?;
     if count > 0 {
         return Err(format!(
@@ -865,6 +1025,11 @@ fn corpus_edge_quality() -> Result<()> {
     run_corpus("edge")
 }
 
+#[test]
+fn corpus_frame_quality() -> Result<()> {
+    run_corpus("frame")
+}
+
 #[test]
 fn detector_flags_text_collision_and_clipping_without_requiring_a_snapshot() {
     let drawing = Drawing {
@@ -895,6 +1060,7 @@ fn detector_flags_text_collision_and_clipping_without_requiring_a_snapshot() {
             },
         ],
         nodes: vec![],
+        frames: vec![],
         routes: vec![],
     };
     let violations = text_violations(&drawing);
@@ -941,6 +1107,7 @@ fn detector_allows_separated_text_inside_the_canvas() {
             },
         ],
         nodes: vec![],
+        frames: vec![],
         routes: vec![],
     };
     assert!(text_violations(&drawing).is_empty());
@@ -957,6 +1124,7 @@ fn metrics_do_not_trade_collisions_for_a_smaller_drawing() {
         },
         texts: vec![],
         nodes: vec![],
+        frames: vec![],
         routes: vec![Route {
             id: "edge:0".into(),
             from: "a".into(),
@@ -995,6 +1163,7 @@ fn detector_does_not_exempt_an_edges_own_label() -> Result<()> {
             },
         }],
         nodes: vec![],
+        frames: vec![],
         routes: vec![Route {
             id: "edge:0".into(),
             from: "a".into(),
@@ -1039,6 +1208,7 @@ fn detector_allows_only_terminal_node_contact() -> Result<()> {
                 },
             ),
         ],
+        frames: vec![],
         routes: vec![Route {
             id: "edge:0".into(),
             from: "a".into(),
@@ -1095,7 +1265,7 @@ fn parser_rejects_unmeasured_geometry_and_dropped_content() -> Result<()> {
         svg.replacen("<svg ", "<svg transform=\"scale(2)\" ", 1),
         svg.replacen(">Example</text>", ">Wrong</text>", 1),
         svg.replacen("<polyline ", "<path ", 1),
-        svg.replacen("<text ", "<text dx=\"100\" ", 1),
+        svg.replacen("<text ", "<text dx=\"0.1\" ", 1),
         svg.replacen("data-node-kind=", "removed-node-kind=", 1),
     ] {
         assert_ne!(mutant, svg, "mutation must exercise the checker");
@@ -1151,17 +1321,17 @@ fn parser_rejects_reviewed_false_green_mutations() -> Result<()> {
     let edge_markup = &svg[edge_text.range()];
     let moved_edge = edge_markup.replacen(
         &format!("x=\"{}\"", required(edge_text, "x")?),
-        "x=\"-999999\"",
+        "x=\"-999.999\"",
         1,
     );
     let oversized_edge = edge_markup.replacen(
         &format!("font-size=\"{}\"", required(edge_text, "font-size")?),
-        "font-size=\"900000\"",
+        "font-size=\"900\"",
         1,
     );
     let moved_shape = svg[shape.range()].replacen(
         &format!("x=\"{}\"", required(shape, "x")?),
-        "x=\"-999999\"",
+        "x=\"-999.999\"",
         1,
     );
     let mut duplicated_title = replace(label, "");
@@ -1243,7 +1413,7 @@ fn parser_rejects_reviewed_false_green_mutations() -> Result<()> {
                 1,
             ),
         ),
-        ("extra root route", svg.replacen("</metadata>", "</metadata><polyline points=\"0,0 999999,0\" stroke=\"black\" stroke-width=\"1500\"/>", 1)),
+        ("extra root route", svg.replacen("</metadata>", "</metadata><polyline points=\"0,0 999.999,0\" stroke=\"black\" stroke-width=\"1.5\"/>", 1)),
         ("unmeasured trailing text", svg.replacen(">Example</text>", ">Example<!-- split -->UNMEASURED</text>", 1)),
         ("unverified nested SVG", replace(owner, &svg[owner.range()].replacen("</title>", "</title><svg><text x=\"0\" y=\"0\">UNMEASURED</text></svg>", 1))),
         ("document stylesheet", svg.replacen("<svg ", "<?xml-stylesheet type=\"text/css\" href=\"data:text/css,text%7Bdisplay%3Anone%7D\"?><svg ", 1)),
@@ -1309,3 +1479,346 @@ fn parser_reads_every_current_node_shape_envelope() -> Result<()> {
     }
     Ok(())
 }
+
+#[test]
+fn frame_detector_includes_both_stroke_radii_without_terminal_exemptions() -> Result<()> {
+    let mut drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 500_000,
+            height: 800_000,
+        },
+        texts: vec![],
+        nodes: vec![],
+        frames: vec![GroupFrame {
+            id: "a".into(),
+            rect: Rect {
+                x: 100_000,
+                y: 200_000,
+                width: 300_000,
+                height: 400_000,
+            },
+            radius: 500,
+        }],
+        routes: vec![Route {
+            id: "edge:0".into(),
+            from: "a".into(),
+            to: "b".into(),
+            points: vec![
+                Point {
+                    x: 150_000,
+                    y: 182_751,
+                },
+                Point {
+                    x: 350_000,
+                    y: 182_751,
+                },
+            ],
+            radius: 750,
+        }],
+    };
+    let violations = frame_violations(&drawing)?;
+    assert_eq!(violations.len(), 1);
+    assert_eq!(violations[0]["requiredCenterlineClearanceMilliPx"], 17_250);
+    for point in &mut drawing.routes[0].points {
+        point.y = 182_750;
+    }
+    assert!(frame_violations(&drawing)?.is_empty());
+    for point in &mut drawing.routes[0].points {
+        point.y = 200_000;
+    }
+    assert_eq!(frame_violations(&drawing)?.len(), 1);
+    drawing.routes[0].points = vec![
+        Point { x: 0, y: 400_000 },
+        Point {
+            x: 500_000,
+            y: 400_000,
+        },
+    ];
+    assert!(frame_violations(&drawing)?.is_empty());
+    Ok(())
+}
+
+#[test]
+fn parser_measures_final_svg_group_frames_and_rejects_missing_or_hidden_frames() -> Result<()> {
+    let source = b"stack 1.0 diagram \"Frame\" { group system \"System\" { node a \"A\" } }";
+    let engine = Engine::bundled();
+    let svg = engine.render(source)?.svg.ok_or("missing SVG")?;
+    let compiled = stack_compiler::compile_bytes_with_source_map(source);
+    let diagram = compiled.diagram.as_ref().ok_or("missing diagram")?;
+    let prepared = engine.prepare_scene(
+        diagram,
+        compiled.source_map.as_ref().ok_or("missing source map")?,
+    )?;
+    let document = Document::parse(&svg)?;
+    let owner = document
+        .descendants()
+        .find(|node| node.attribute("data-stack-id") == Some("system"))
+        .ok_or("missing group frame owner")?;
+    let frame = owner
+        .children()
+        .find(|node| node.has_tag_name("rect"))
+        .ok_or("missing group frame")?;
+    let frame_markup = &svg[frame.range()];
+    let replace = |node: Node<'_, '_>, replacement: &str| {
+        let mut mutant = svg.clone();
+        mutant.replace_range(node.range(), replacement);
+        mutant
+    };
+    let drawing = read_drawing(&svg, &prepared, diagram)?;
+    assert_eq!(drawing.frames.len(), 1);
+    assert_eq!(drawing.frames[0].rect, rectangle(frame)?);
+    assert_eq!(drawing.frames[0].radius, 500);
+
+    let wider_stroke = replace(
+        frame,
+        &frame_markup.replacen(
+            &format!("stroke-width=\"{}\"", required(frame, "stroke-width")?),
+            "stroke-width=\"1.001\"",
+            1,
+        ),
+    );
+    assert_ne!(wider_stroke, svg, "mutation must widen the frame stroke");
+    let wider = read_drawing(&wider_stroke, &prepared, diagram)?;
+    assert_eq!(wider.frames[0].radius, 501);
+
+    let mutations = [
+        ("removed frame", replace(frame, "")),
+        (
+            "duplicate frame",
+            replace(frame, &format!("{frame_markup}{frame_markup}")),
+        ),
+        (
+            "moved frame",
+            replace(
+                frame,
+                &frame_markup.replacen(
+                    &format!("x=\"{}\"", required(frame, "x")?),
+                    "x=\"-999.999\"",
+                    1,
+                ),
+            ),
+        ),
+        (
+            "zero frame width",
+            replace(
+                frame,
+                &frame_markup.replacen(
+                    &format!("width=\"{}\"", required(frame, "width")?),
+                    "width=\"0\"",
+                    1,
+                ),
+            ),
+        ),
+        (
+            "zero frame stroke",
+            replace(
+                frame,
+                &frame_markup.replacen(
+                    &format!("stroke-width=\"{}\"", required(frame, "stroke-width")?),
+                    "stroke-width=\"0\"",
+                    1,
+                ),
+            ),
+        ),
+        (
+            "invisible frame stroke",
+            replace(
+                frame,
+                &frame_markup.replacen(
+                    &format!("stroke=\"{}\"", required(frame, "stroke")?),
+                    "stroke=\"none\"",
+                    1,
+                ),
+            ),
+        ),
+        (
+            "inherited invisible frame",
+            replace(
+                owner,
+                &svg[owner.range()].replacen("<g ", "<g stroke-opacity=\"0\" ", 1),
+            ),
+        ),
+        (
+            "missing owner id",
+            replace(
+                owner,
+                &svg[owner.range()].replacen("data-stack-id=", "removed-stack-id=", 1),
+            ),
+        ),
+    ];
+    for (name, mutant) in mutations {
+        assert_ne!(mutant, svg, "mutation must exercise {name}");
+        assert!(
+            read_drawing(&mutant, &prepared, diagram).is_err(),
+            "accepted {name}"
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn frame_detector_measures_edge_label_backgrounds_without_excluding_group_interiors() -> Result<()>
+{
+    let mut drawing = Drawing {
+        bounds: Rect {
+            x: 0,
+            y: 0,
+            width: 500_000,
+            height: 800_000,
+        },
+        texts: vec![TextBox {
+            id: "edge-label:0:Request".into(),
+            rect: Rect {
+                x: 150_000,
+                y: 190_000,
+                width: 100_000,
+                height: 20_000,
+            },
+        }],
+        nodes: vec![],
+        frames: vec![GroupFrame {
+            id: "system".into(),
+            rect: Rect {
+                x: 100_000,
+                y: 200_000,
+                width: 300_000,
+                height: 400_000,
+            },
+            radius: 500,
+        }],
+        routes: vec![],
+    };
+    let violations = frame_violations(&drawing)?;
+    assert_eq!(violations.len(), 1);
+    assert_eq!(violations[0]["kind"], "label-group-frame-clearance");
+    assert_eq!(violations[0]["requiredCenterlineClearanceMilliPx"], 8_500);
+    drawing.texts[0].rect.y = 208_500;
+    assert!(frame_violations(&drawing)?.is_empty());
+    drawing.texts[0].rect.y -= 1;
+    assert_eq!(frame_violations(&drawing)?.len(), 1);
+    drawing.texts[0].rect.y = 171_500;
+    assert!(frame_violations(&drawing)?.is_empty());
+    Ok(())
+}
+
+#[test]
+fn px_parser_restores_exact_milli_pixels_without_floating_point() -> Result<()> {
+    for (value, expected) in [
+        ("0", 0),
+        ("-0", 0),
+        ("32", 32_000),
+        ("-32", -32_000),
+        ("1.5", 1_500),
+        ("1.25", 1_250),
+        ("1.001", 1_001),
+        ("0.001", 1),
+        ("-0.001", -1),
+        ("123.000", 123_000),
+        ("9223372036854775.807", i64::MAX),
+        ("-9223372036854775.808", i64::MIN),
+    ] {
+        assert_eq!(pixel_value(value)?, expected, "{value}");
+    }
+    Ok(())
+}
+
+#[test]
+fn px_parser_rejects_invalid_signs_precision_and_overflow() {
+    for value in [
+        "",
+        "+1",
+        "--1",
+        "-+1",
+        "1-",
+        "-",
+        ".5",
+        "-.5",
+        "1.",
+        "1.2.3",
+        "1.0001",
+        "-0.0001",
+        "1e3",
+        "NaN",
+        "Infinity",
+        "1px",
+        "1%",
+        " 1",
+        "1 ",
+        "1\n",
+        "1,5",
+        "１２",
+        "01",
+        "00.5",
+        "9223372036854775.808",
+        "-9223372036854775.809",
+        "9223372036854776",
+        "-9223372036854776",
+        "999999999999999999999999999999999999999999999999",
+    ] {
+        assert!(
+            pixel_value(value).is_err(),
+            "accepted unsupported px value {value:?}"
+        );
+    }
+}
+
+#[test]
+fn px_parser_scales_rectangle_points_and_absolute_path_coordinates() -> Result<()> {
+    assert_eq!(
+        point_list("-1.125,2.5 4,5.875")?,
+        vec![
+            Point {
+                x: -1_125,
+                y: 2_500
+            },
+            Point { x: 4_000, y: 5_875 }
+        ]
+    );
+    for (markup, expected) in [
+        (
+            r#"<rect x="-1.125" y="2.5" width="4" height="5.875"/>"#,
+            Rect {
+                x: -1_125,
+                y: 2_500,
+                width: 4_000,
+                height: 5_875,
+            },
+        ),
+        (
+            r#"<ellipse cx="2.125" cy="4.5" rx="1.125" ry="2.5"/>"#,
+            Rect {
+                x: 1_000,
+                y: 2_000,
+                width: 2_250,
+                height: 5_000,
+            },
+        ),
+        (
+            r#"<polygon points="-1.125,2.5 4,5.875 1,1.25"/>"#,
+            Rect {
+                x: -1_125,
+                y: 1_250,
+                width: 5_125,
+                height: 4_625,
+            },
+        ),
+        (
+            r#"<path d="M 1.25 2.5 V 6.75 C 1.25 7.5 5.875 7.5 5.875 6.75 V 2.5 C 5.875 1.125 1.25 1.125 1.25 2.5 Z"/>"#,
+            Rect {
+                x: 1_250,
+                y: 1_125,
+                width: 4_625,
+                height: 6_375,
+            },
+        ),
+    ] {
+        assert_eq!(
+            shape_envelope(Document::parse(markup)?.root_element())?,
+            expected,
+            "{markup}"
+        );
+    }
+    Ok(())
+}
diff --git a/crates/stack-engine/src/layout_quality/geometry.rs b/crates/stack-engine/src/layout_quality/geometry.rs
index 3c7fae5..b4cf2de 100644
--- a/crates/stack-engine/src/layout_quality/geometry.rs
+++ b/crates/stack-engine/src/layout_quality/geometry.rs
@@ -131,6 +131,104 @@ pub(super) fn segment_hits_rect(
     Err(GeometryError::DiagonalSegment)
 }
 
+/// Detects a segment running parallel to a finite group frame side without the
+/// requested centerline clearance. The projection extends by the same clearance
+/// around each corner, so a nearby bend cannot use a perpendicular crossing to
+/// hide its adjacent parallel segment. Ordinary perpendicular crossings away
+/// from corners remain valid. Exact clearance is allowed; travel on the frame
+/// is always contact. There are no source/target terminal exemptions.
+pub(super) fn parallel_frame_contact(
+    start: Point,
+    end: Point,
+    frame: Rect,
+    clearance: i64,
+) -> Result<bool, GeometryError> {
+    if frame.width <= 0 || frame.height <= 0 {
+        return Err(GeometryError::InvalidRect);
+    }
+    if clearance < 0 {
+        return Err(GeometryError::NegativeRadius);
+    }
+    if start == end {
+        return Ok(false);
+    }
+    let frame = Bounds::new(frame);
+    let clearance = i128::from(clearance);
+    let contact = |coordinate: i64, first: i64, last: i64, sides: [i128; 2], low, high| {
+        let coordinate = i128::from(coordinate);
+        let projected_length = i128::from(first.min(last)).max(low - clearance)
+            < i128::from(first.max(last)).min(high + clearance);
+        projected_length
+            && sides.iter().any(|side| {
+                let distance = (coordinate - side).abs();
+                distance == 0 || distance < clearance
+            })
+    };
+    if start.y == end.y {
+        return Ok(contact(
+            start.y,
+            start.x,
+            end.x,
+            [frame.top, frame.bottom],
+            frame.left,
+            frame.right,
+        ));
+    }
+    if start.x == end.x {
+        return Ok(contact(
+            start.x,
+            start.y,
+            end.y,
+            [frame.left, frame.right],
+            frame.top,
+            frame.bottom,
+        ));
+    }
+    Err(GeometryError::DiagonalSegment)
+}
+
+/// Detects a label rectangle touching or approaching the finite frame perimeter.
+/// The frame interior remains usable: only its four sides and their corner
+/// clearance constrain labels. Callers include the painted frame stroke radius
+/// in the required clearance. Exact clearance is allowed.
+pub(super) fn label_frame_contact(
+    label: Rect,
+    frame: Rect,
+    clearance: i64,
+) -> Result<bool, GeometryError> {
+    if label.width <= 0 || label.height <= 0 || frame.width <= 0 || frame.height <= 0 {
+        return Err(GeometryError::InvalidRect);
+    }
+    if clearance < 0 {
+        return Err(GeometryError::NegativeRadius);
+    }
+    let label = Bounds::new(label);
+    let frame = Bounds::new(frame);
+    let clearance = i128::from(clearance);
+    let near_interval = |side: i128, low: i128, high: i128| {
+        let distance = if side < low {
+            low - side
+        } else if side > high {
+            side - high
+        } else {
+            0
+        };
+        distance == 0 || distance < clearance
+    };
+    let horizontal_projection =
+        label.left.max(frame.left - clearance) < label.right.min(frame.right + clearance);
+    let vertical_projection =
+        label.top.max(frame.top - clearance) < label.bottom.min(frame.bottom + clearance);
+    Ok((horizontal_projection
+        && [frame.top, frame.bottom]
+            .iter()
+            .any(|side| near_interval(*side, label.top, label.bottom)))
+        || (vertical_projection
+            && [frame.left, frame.right]
+                .iter()
+                .any(|side| near_interval(*side, label.left, label.right))))
+}
+
 /// Allows only a real terminal's normal departure or arrival at the original
 /// node boundary. Callers must enable these flags only on the first/last path
 /// segment for that segment's actual source/target node. Every other segment
@@ -526,4 +624,184 @@ mod tests {
             Ok(true)
         );
     }
+
+    const FRAME: Rect = rect(100, 200, 300, 400);
+
+    fn assert_frame_contact(start: Point, end: Point, clearance: i64, expected: bool) {
+        assert_eq!(
+            parallel_frame_contact(start, end, FRAME, clearance),
+            Ok(expected),
+            "forward frame contact: {start:?} -> {end:?}, clearance {clearance}"
+        );
+        assert_eq!(
+            parallel_frame_contact(end, start, FRAME, clearance),
+            Ok(expected),
+            "reverse frame contact: {end:?} -> {start:?}, clearance {clearance}"
+        );
+    }
+
+    #[test]
+    fn frame_parallel_clearance_applies_inside_and_outside_all_four_sides() {
+        for offset in [-17_i64, -16, -15, 0, 15, 16, 17] {
+            let expected = offset.abs() < 16;
+            for (start, end) in [
+                (point(150, 200 + offset), point(350, 200 + offset)),
+                (point(150, 600 + offset), point(350, 600 + offset)),
+                (point(100 + offset, 250), point(100 + offset, 550)),
+                (point(400 + offset, 250), point(400 + offset, 550)),
+            ] {
+                assert_frame_contact(start, end, 16, expected);
+            }
+        }
+        assert_frame_contact(point(150, 200), point(350, 200), 0, true);
+    }
+
+    #[test]
+    fn frame_perpendicular_crossings_are_allowed_away_from_corners() {
+        for (start, end) in [
+            (point(0, 400), point(500, 400)),
+            (point(250, 100), point(250, 700)),
+            (point(0, 400), point(100, 400)),
+            (point(400, 400), point(500, 400)),
+            (point(250, 100), point(250, 200)),
+            (point(250, 600), point(250, 700)),
+        ] {
+            assert_frame_contact(start, end, 16, false);
+        }
+    }
+
+    #[test]
+    fn frame_corner_bends_cannot_hide_behind_a_perpendicular_crossing() {
+        for path in [
+            [point(50, 190), point(90, 190), point(90, 250)],
+            [point(450, 190), point(410, 190), point(410, 250)],
+            [point(50, 610), point(90, 610), point(90, 550)],
+            [point(450, 610), point(410, 610), point(410, 550)],
+        ] {
+            for segment in path.windows(2) {
+                assert_frame_contact(segment[0], segment[1], 16, true);
+            }
+        }
+    }
+
+    #[test]
+    fn frame_sides_have_finite_projections_including_corner_clearance() {
+        for (start, end, expected) in [
+            (point(0, 200), point(84, 200), false),
+            (point(0, 200), point(85, 200), true),
+            (point(416, 600), point(500, 600), false),
+            (point(415, 600), point(500, 600), true),
+            (point(100, 100), point(100, 184), false),
+            (point(100, 100), point(100, 185), true),
+            (point(400, 616), point(400, 700), false),
+            (point(400, 615), point(400, 700), true),
+        ] {
+            assert_frame_contact(start, end, 16, expected);
+        }
+    }
+
+    #[test]
+    fn frame_detector_rejects_invalid_geometry_and_uses_wide_intermediates() {
+        assert_eq!(
+            parallel_frame_contact(point(0, 0), point(1, 1), FRAME, 16),
+            Err(GeometryError::DiagonalSegment)
+        );
+        assert_eq!(
+            parallel_frame_contact(point(0, 0), point(1, 0), FRAME, -1),
+            Err(GeometryError::NegativeRadius)
+        );
+        assert_eq!(
+            parallel_frame_contact(point(0, 0), point(1, 0), rect(0, 0, 0, 1), 16),
+            Err(GeometryError::InvalidRect)
+        );
+        assert_frame_contact(point(100, 200), point(100, 200), 16, false);
+        assert_eq!(
+            parallel_frame_contact(
+                point(i64::MAX - 3, -5),
+                point(i64::MAX, -5),
+                rect(i64::MAX - 5, 0, 10, 10),
+                16
+            ),
+            Ok(true)
+        );
+        assert_eq!(
+            parallel_frame_contact(
+                point(i64::MIN, -5),
+                point(i64::MIN + 3, -5),
+                rect(i64::MIN + 2, 0, 10, 10),
+                16
+            ),
+            Ok(true)
+        );
+    }
+
+    #[test]
+    fn label_frame_clearance_rejects_masking_and_nearby_labels_on_all_sides() {
+        for gap in [0, 7, 8, 9] {
+            for label in [
+                rect(150, 180 - gap, 100, 20),
+                rect(150, 600 + gap, 100, 20),
+                rect(80 - gap, 250, 20, 100),
+                rect(400 + gap, 250, 20, 100),
+                rect(150, 200 + gap, 100, 20),
+                rect(150, 580 - gap, 100, 20),
+                rect(100 + gap, 250, 20, 100),
+                rect(380 - gap, 250, 20, 100),
+            ] {
+                assert_eq!(
+                    label_frame_contact(label, FRAME, 8),
+                    Ok(gap < 8),
+                    "{label:?}"
+                );
+            }
+        }
+        for label in [
+            rect(150, 195, 100, 20),
+            rect(150, 595, 100, 20),
+            rect(95, 250, 20, 100),
+            rect(395, 250, 20, 100),
+        ] {
+            assert_eq!(label_frame_contact(label, FRAME, 8), Ok(true), "{label:?}");
+        }
+    }
+
+    #[test]
+    fn label_frame_clearance_uses_finite_sides_and_preserves_interior_space() {
+        for label in [
+            rect(150, 250, 100, 100),
+            rect(0, 0, 50, 50),
+            rect(0, 195, 90, 20),
+            rect(410, 195, 90, 20),
+        ] {
+            assert_eq!(label_frame_contact(label, FRAME, 8), Ok(false), "{label:?}");
+        }
+        for label in [
+            rect(80, 180, 15, 15),
+            rect(405, 180, 15, 15),
+            rect(80, 605, 15, 15),
+            rect(405, 605, 15, 15),
+        ] {
+            assert_eq!(label_frame_contact(label, FRAME, 8), Ok(true), "{label:?}");
+        }
+    }
+
+    #[test]
+    fn label_frame_clearance_validates_inputs_and_avoids_coordinate_overflow() {
+        assert_eq!(
+            label_frame_contact(rect(0, 0, 0, 1), FRAME, 8),
+            Err(GeometryError::InvalidRect)
+        );
+        assert_eq!(
+            label_frame_contact(rect(0, 0, 1, 1), FRAME, -1),
+            Err(GeometryError::NegativeRadius)
+        );
+        assert_eq!(
+            label_frame_contact(
+                rect(i64::MAX - 2, -4, 5, 2),
+                rect(i64::MAX - 5, 0, 10, 10),
+                8
+            ),
+            Ok(true)
+        );
+    }
 }
diff --git a/crates/stack-engine/src/lib.rs b/crates/stack-engine/src/lib.rs
index 08aa089..3e52d7c 100644
--- a/crates/stack-engine/src/lib.rs
+++ b/crates/stack-engine/src/lib.rs
@@ -24,6 +24,7 @@ use std::fmt;
 
 use stack_compiler::diagnostic as compiler_diagnostic;
 
+mod labels;
 mod resources;
 mod routing;
 mod scene;
@@ -32,6 +33,9 @@ mod svg;
 #[cfg(test)]
 mod layout_quality;
 
+#[cfg(test)]
+mod placement_quality;
+
 mod language;
 mod provider;
 pub use language::{
@@ -830,7 +834,7 @@ mod tests {
     #[test]
     fn layout_warnings_follow_compiler_warnings() -> Result<(), Box<dyn Error>> {
         let mut source = String::from(
-            "stack 1.0 diagram \"Warnings\" { layout { direction right order [n1, n0] } node hub \"Hub\" ",
+            "stack 1.0 diagram \"Warnings\" { layout { direction right order [hub, n0] } node hub \"Hub\" ",
         );
         for index in 0..13 {
             source.push_str(&format!(
diff --git a/crates/stack-engine/src/placement_quality.rs b/crates/stack-engine/src/placement_quality.rs
new file mode 100644
index 0000000..67fb628
--- /dev/null
+++ b/crates/stack-engine/src/placement_quality.rs
@@ -0,0 +1,395 @@
+//! Behavioral regression tests for graph-aware scene composition.
+
+use std::error::Error;
+
+use crate::routing::Point;
+use crate::scene::{self, Rect, Scene, SceneDirection};
+
+#[test]
+fn labelled_dag_inventory_renders_without_hidden_collisions() -> Result<(), Box<dyn Error>> {
+    let fixtures: serde_json::Value = serde_json::from_str(include_str!(
+        "../tests/fixtures/labelled-dag-regressions.json"
+    ))?;
+    let cases = fixtures.as_array().ok_or("fixture array")?;
+    assert_eq!(cases.len(), 60);
+    let mut failures = Vec::new();
+    for case in cases {
+        let name = case["name"].as_str().ok_or("fixture name")?;
+        let source = case["input"]["value"].as_str().ok_or("fixture source")?;
+        match scene_from(source) {
+            Ok(scene) => {
+                assert!(scene.geometry_is_valid(), "{name}: geometry");
+                assert_eq!(scene, scene_from(source)?, "{name}: deterministic scene");
+            }
+            Err(error) => failures.push(format!("{name}: {error}")),
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+    Ok(())
+}
+
+fn scene_from(source: &str) -> Result<Scene, Box<dyn Error>> {
+    let compiled = stack_compiler::compile_bytes(source.as_bytes());
+    if !compiled.diagnostics.is_empty() {
+        return Err(format!("fixture produced diagnostics: {:?}", compiled.diagnostics).into());
+    }
+    let diagram = compiled.diagram.ok_or("fixture produced no diagram")?;
+    Ok(scene::layout(&diagram, stack_theme::catalog())?)
+}
+
+fn node_rect(scene: &Scene, id: &str) -> Result<Rect, Box<dyn Error>> {
+    scene
+        .nodes
+        .iter()
+        .find(|node| node.id == id)
+        .map(|node| node.rect)
+        .ok_or_else(|| format!("missing node {id}").into())
+}
+
+fn group_rect(scene: &Scene, id: &str) -> Result<Rect, Box<dyn Error>> {
+    scene
+        .groups
+        .iter()
+        .find(|group| group.id == id)
+        .map(|group| group.rect)
+        .ok_or_else(|| format!("missing group {id}").into())
+}
+
+fn assert_progresses(before: Rect, after: Rect, direction: SceneDirection) {
+    let (before_end, after_start) = match direction {
+        SceneDirection::Right => (before.x + before.width, after.x),
+        SceneDirection::Down => (before.y + before.height, after.y),
+    };
+    assert!(
+        before_end < after_start,
+        "connected elements must progress along {direction:?}: {before:?} -> {after:?}"
+    );
+}
+
+fn assert_reordered_dag_progresses(direction: SceneDirection) -> Result<(), Box<dyn Error>> {
+    let authored_direction = match direction {
+        SceneDirection::Right => "right",
+        SceneDirection::Down => "down",
+    };
+    let source = format!(
+        r#"stack 1.0
+diagram "Reordered pipeline" {{
+  layout {{ direction {authored_direction} }}
+  node sink "Sink"
+  node source "Source"
+  node processor "Processor"
+  edge source -> processor
+  edge processor -> sink
+}}"#
+    );
+    let scene = scene_from(&source)?;
+    assert_eq!(scene.direction, direction);
+    assert_progresses(
+        node_rect(&scene, "source")?,
+        node_rect(&scene, "processor")?,
+        direction,
+    );
+    assert_progresses(
+        node_rect(&scene, "processor")?,
+        node_rect(&scene, "sink")?,
+        direction,
+    );
+    assert!(scene.geometry_is_valid());
+    Ok(())
+}
+
+#[test]
+fn right_directed_dag_progresses_by_connections_instead_of_declaration_order()
+-> Result<(), Box<dyn Error>> {
+    assert_reordered_dag_progresses(SceneDirection::Right)
+}
+
+#[test]
+fn down_directed_dag_progresses_by_connections_instead_of_declaration_order()
+-> Result<(), Box<dyn Error>> {
+    assert_reordered_dag_progresses(SceneDirection::Down)
+}
+
+#[test]
+fn graph_ranking_preserves_mandatory_same_rank_and_authored_cross_axis_order()
+-> Result<(), Box<dyn Error>> {
+    for (authored_direction, direction) in [
+        ("right", SceneDirection::Right),
+        ("down", SceneDirection::Down),
+    ] {
+        let source = format!(
+            r#"stack 1.0
+diagram "Constrained fanout" {{
+  layout {{
+    direction {authored_direction}
+    rank same [primary, secondary]
+    order [secondary, primary]
+  }}
+  node sink "Sink"
+  node primary "Primary service"
+  node source "Source"
+  node secondary "Secondary service"
+  edge source -> primary
+  edge source -> secondary
+  edge primary -> sink
+  edge secondary -> sink
+}}"#
+        );
+        let scene = scene_from(&source)?;
+        let source = node_rect(&scene, "source")?;
+        let sink = node_rect(&scene, "sink")?;
+        let primary = node_rect(&scene, "primary")?;
+        let secondary = node_rect(&scene, "secondary")?;
+        match direction {
+            SceneDirection::Right => {
+                assert_eq!(primary.x, secondary.x);
+                assert!(secondary.y + secondary.height < primary.y);
+            }
+            SceneDirection::Down => {
+                assert_eq!(primary.y, secondary.y);
+                assert!(secondary.x + secondary.width < primary.x);
+            }
+        }
+        for branch in [primary, secondary] {
+            assert_progresses(source, branch, direction);
+            assert_progresses(branch, sink, direction);
+        }
+        assert!(scene.unsatisfied_orders.is_empty());
+        assert!(scene.geometry_is_valid());
+    }
+    Ok(())
+}
+
+#[test]
+fn reversing_descendant_connection_reverses_group_progression() -> Result<(), Box<dyn Error>> {
+    let source = r#"stack 1.0
+diagram "Projected group connection" {
+  layout { direction right }
+  group storage "Storage" {
+    layout { direction down }
+    group persistence "Persistence" { node database "Database" }
+  }
+  group platform "Platform" {
+    layout { direction down }
+    group application "Application" { node api "API" }
+  }
+  edge api -> database
+}"#;
+    let forward = scene_from(source)?;
+    let reverse = scene_from(&source.replace("edge api -> database", "edge database -> api"))?;
+
+    assert_progresses(
+        group_rect(&forward, "platform")?,
+        group_rect(&forward, "storage")?,
+        SceneDirection::Right,
+    );
+    assert_progresses(
+        group_rect(&reverse, "storage")?,
+        group_rect(&reverse, "platform")?,
+        SceneDirection::Right,
+    );
+    for scene in [&forward, &reverse] {
+        for id in ["storage", "platform"] {
+            let group = scene
+                .groups
+                .iter()
+                .find(|group| group.id == id)
+                .ok_or("missing directed group")?;
+            assert_eq!(group.direction, SceneDirection::Down);
+        }
+        assert!(scene.geometry_is_valid());
+    }
+    Ok(())
+}
+
+#[test]
+fn cyclic_graph_composition_is_deterministic() -> Result<(), Box<dyn Error>> {
+    let source = r#"stack 1.0
+diagram "Deterministic cycle" {
+  layout { direction right }
+  node downstream "Downstream"
+  node second "Second"
+  node upstream "Upstream"
+  node first "First"
+  edge upstream -> first
+  edge first -> second
+  edge second -> first
+  edge second -> downstream
+}"#;
+    let first = scene_from(source)?;
+    let second = scene_from(source)?;
+    assert_eq!(first, second);
+    assert!(first.geometry_is_valid());
+    Ok(())
+}
+
+fn contains(outer: Rect, inner: Rect) -> bool {
+    inner.x >= outer.x
+        && inner.y >= outer.y
+        && inner.x + inner.width <= outer.x + outer.width
+        && inner.y + inner.height <= outer.y + outer.height
+}
+
+fn overlaps(left: Rect, right: Rect) -> bool {
+    left.x < right.x + right.width
+        && right.x < left.x + left.width
+        && left.y < right.y + right.height
+        && right.y < left.y + left.height
+}
+
+fn point_on_segment(point: Point, start: Point, end: Point) -> bool {
+    if start.x == end.x {
+        point.x == start.x && (start.y.min(end.y)..=start.y.max(end.y)).contains(&point.y)
+    } else if start.y == end.y {
+        point.y == start.y && (start.x.min(end.x)..=start.x.max(end.x)).contains(&point.x)
+    } else {
+        false
+    }
+}
+
+fn segment_touches_rect(start: Point, end: Point, rect: Rect) -> bool {
+    if start.x == end.x {
+        (rect.x..=rect.x + rect.width).contains(&start.x)
+            && start.y.min(end.y) <= rect.y + rect.height
+            && start.y.max(end.y) >= rect.y
+    } else if start.y == end.y {
+        (rect.y..=rect.y + rect.height).contains(&start.y)
+            && start.x.min(end.x) <= rect.x + rect.width
+            && start.x.max(end.x) >= rect.x
+    } else {
+        // An unsupported segment is never accepted as collision-free.
+        true
+    }
+}
+
+#[test]
+fn multilingual_labels_have_scene_rectangles_beside_their_routes_without_collisions_or_clipping()
+-> Result<(), Box<dyn Error>> {
+    let catalog = stack_theme::catalog();
+    let theme = catalog
+        .themes
+        .iter()
+        .find(|theme| theme.id == "light")
+        .ok_or("missing light theme")?;
+    let metrics = catalog
+        .font_metrics
+        .iter()
+        .find(|metrics| metrics.id == theme.typography.font_metrics_id)
+        .ok_or("missing light theme metrics")?;
+    let source = include_str!("../../../layout-corpus/sources/multilingual-long-labels.stack");
+
+    for direction in ["right", "down"] {
+        let source = source.replace("direction down", &format!("direction {direction}"));
+        let scene = scene_from(&source)?;
+        let mut occupied_labels = Vec::new();
+        for edge in &scene.edges {
+            let label = edge.label.as_deref().ok_or("missing authored edge label")?;
+            let rect = edge
+                .label_rect
+                .ok_or("label geometry must be resolved by the scene")?;
+            let attachment = edge.label_anchor.ok_or("missing route attachment")?;
+            assert!(rect.width > 0 && rect.height > 0);
+            assert!(
+                rect.width
+                    >= scene::text_width(label, theme.typography.edge_label_size_milli_px, metrics),
+                "the complete measured label must fit: {label}"
+            );
+            assert!(
+                contains(scene.bounds, rect),
+                "label must stay inside the canvas: {label} {rect:?}"
+            );
+            assert!(
+                edge.path
+                    .windows(2)
+                    .any(|segment| point_on_segment(attachment, segment[0], segment[1])),
+                "label attachment must stay on its own route: {label}"
+            );
+            let nearest_x = attachment.x.clamp(rect.x, rect.x + rect.width);
+            let nearest_y = attachment.y.clamp(rect.y, rect.y + rect.height);
+            let gap_x = (attachment.x - nearest_x).abs();
+            let gap_y = (attachment.y - nearest_y).abs();
+            assert!(
+                (gap_x == 0 || gap_y == 0)
+                    && gap_x + gap_y > 0
+                    && gap_x + gap_y <= rect.width.min(rect.height),
+                "label must remain immediately beside its attachment: {label} {rect:?} {attachment:?}"
+            );
+            for node in &scene.nodes {
+                assert!(
+                    !overlaps(rect, node.rect),
+                    "label overlaps node {}: {label}",
+                    node.id
+                );
+            }
+            for occupied in &occupied_labels {
+                assert!(!overlaps(rect, *occupied), "labels overlap: {label}");
+            }
+            for route in &scene.edges {
+                assert!(
+                    route
+                        .path
+                        .windows(2)
+                        .all(|segment| !segment_touches_rect(segment[0], segment[1], rect)),
+                    "route {} -> {} touches label {label}",
+                    route.from,
+                    route.to
+                );
+            }
+            occupied_labels.push(rect);
+        }
+        assert_eq!(occupied_labels.len(), 3);
+        assert!(scene.geometry_is_valid());
+    }
+    Ok(())
+}
+
+#[test]
+fn long_labels_on_same_rank_connections_get_space_outside_the_node_column()
+-> Result<(), Box<dyn Error>> {
+    for direction in ["direction right", ""] {
+        let source = format!(
+            r#"stack 1.0 diagram "Flow" {{
+            layout {{ {direction} rank same [a, b] }}
+            node a "A" node b "B"
+            edge a -> b "retry request after timeout"
+        }}"#
+        );
+        let scene = scene_from(&source)?;
+        assert!(scene.geometry_is_valid());
+        assert!(scene.edges[0].label_rect.is_some());
+    }
+    Ok(())
+}
+
+#[test]
+fn labelled_skip_edges_have_outer_lanes_separate_from_the_central_spine()
+-> Result<(), Box<dyn Error>> {
+    let source = r#"stack 1.0 diagram "Probe" {
+        layout { direction down }
+        node n0 "Node 0" node n1 "Node 1" node n2 "Node 2"
+        edge n0 -> n1 "Connection 0"
+        edge n1 -> n2 "Connection 0"
+        edge n0 -> n2 "Connection 0"
+    }"#;
+    let scene = scene_from(source)?;
+    assert!(scene.geometry_is_valid());
+    assert!(scene.edges.iter().all(|edge| edge.label_rect.is_some()));
+    Ok(())
+}
+
+#[test]
+fn fanout_labels_reserve_space_before_later_routes_choose_nearby_lanes()
+-> Result<(), Box<dyn Error>> {
+    let scene = scene_from(
+        r#"stack 1.0 diagram "Probe" {
+        layout { direction down }
+        node n0 "Node 0" node n1 "Node 1" node n2 "Node 2" node n3 "Node 3"
+        edge n0 -> n3 "Connection 0"
+        edge n0 -> n2 "Connection 1"
+        edge n0 -> n1 "Connection 2"
+    }"#,
+    )?;
+    assert!(scene.geometry_is_valid());
+    assert!(scene.edges.iter().all(|edge| edge.label_rect.is_some()));
+    Ok(())
+}
diff --git a/crates/stack-engine/src/routing.rs b/crates/stack-engine/src/routing.rs
index 31d43c9..4e1edf7 100644
--- a/crates/stack-engine/src/routing.rs
+++ b/crates/stack-engine/src/routing.rs
@@ -9,6 +9,12 @@ use crate::scene::{Rect, SceneNode};
 
 const ROUTE_MARGIN: i64 = 8_000;
 const BEND_PENALTY: i64 = 32_000;
+const CROSSING_PENALTY: i64 = 48_000;
+const SHARED_LENGTH_PENALTY: i64 = 3;
+const FRAME_CLEARANCE: i64 = 16_000;
+// Reserve two extra pixels for the core connector and frame stroke radii.
+// The independent SVG gate uses the actual painted stroke widths.
+const FRAME_MARGIN: i64 = FRAME_CLEARANCE + 2_000;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) struct Point {
@@ -33,6 +39,7 @@ pub(crate) struct SceneEdge {
     pub(crate) start_marker: Marker,
     pub(crate) end_marker: Marker,
     pub(crate) label_anchor: Option<Point>,
+    pub(crate) label_rect: Option<Rect>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -42,8 +49,10 @@ pub(crate) fn route(
     edges: &[Edge],
     nodes: &[SceneNode],
     bounds: Rect,
+    fixed_obstacles: &[Rect],
+    frames: &[Rect],
 ) -> Result<Vec<SceneEdge>, RoutingError> {
-    let router = GridRouter::new(nodes, bounds);
+    let mut router = GridRouter::new(nodes, bounds, fixed_obstacles, frames);
     edges
         .iter()
         .map(|edge| {
@@ -62,12 +71,18 @@ pub(crate) fn route(
                 start_marker,
                 end_marker,
                 label_anchor,
+                label_rect: None,
             })
         })
         .collect()
 }
 
-pub(crate) fn geometry_is_valid(edges: &[SceneEdge], nodes: &[SceneNode], bounds: Rect) -> bool {
+pub(crate) fn geometry_is_valid(
+    edges: &[SceneEdge],
+    nodes: &[SceneNode],
+    bounds: Rect,
+    frames: &[Rect],
+) -> bool {
     edges.iter().all(|edge| {
         let Some(source) = node_rect(nodes, &edge.from) else {
             return false;
@@ -79,13 +94,34 @@ pub(crate) fn geometry_is_valid(edges: &[SceneEdge], nodes: &[SceneNode], bounds
             || !source.has_boundary_point(edge.path[0])
             || !target.has_boundary_point(edge.path[edge.path.len() - 1])
             || edge.path.iter().any(|point| !bounds.contains_point(*point))
-            || edge.path.windows(2).any(|segment| {
+            || !departs_normally(edge.path[0], edge.path[1], source)
+            || !departs_normally(
+                edge.path[edge.path.len() - 1],
+                edge.path[edge.path.len() - 2],
+                target,
+            )
+            || edge.path.windows(2).enumerate().any(|(index, segment)| {
                 segment[0] == segment[1]
                     || !segment_is_axis_aligned(segment[0], segment[1])
+                    || frames
+                        .iter()
+                        .any(|frame| !frame_segment_is_clear(segment[0], segment[1], *frame))
                     || nodes.iter().any(|node| {
-                        segment_crosses_rect_interior(segment[0], segment[1], node.rect)
+                        segment_hits_rect(segment[0], segment[1], node.rect)
+                            && !(index == 0
+                                && node.id == edge.from
+                                && departs_normally(segment[0], segment[1], node.rect))
+                            && !(index + 2 == edge.path.len()
+                                && node.id == edge.to
+                                && departs_normally(segment[1], segment[0], node.rect))
                     })
             })
+            || edge.path.windows(3).any(|points| {
+                (points[0].x == points[1].x) != (points[1].x == points[2].x)
+                    && frames
+                        .iter()
+                        .any(|frame| !frame_bend_is_clear(points[1], *frame))
+            })
         {
             return false;
         }
@@ -105,6 +141,55 @@ pub(crate) fn geometry_is_valid(edges: &[SceneEdge], nodes: &[SceneNode], bounds
     })
 }
 
+pub(crate) fn alternative_routes(
+    edge: &Edge,
+    nodes: &[SceneNode],
+    bounds: Rect,
+    fixed_obstacles: &[Rect],
+    frames: &[Rect],
+) -> Result<Vec<SceneEdge>, RoutingError> {
+    let source = node_rect(nodes, &edge.from).ok_or(RoutingError)?;
+    let target = node_rect(nodes, &edge.to).ok_or(RoutingError)?;
+    let mut router = GridRouter::new(nodes, bounds, fixed_obstacles, frames);
+    let mut paths = Vec::new();
+    for source_port in 0..4 {
+        for target_port in 0..4 {
+            if let Some(path) =
+                router.route_between(source, target, Some((source_port, target_port)))
+            {
+                paths.push(path);
+            }
+        }
+    }
+    paths.sort_by_cached_key(|path| {
+        let length = path
+            .windows(2)
+            .map(|segment| manhattan(segment[0], segment[1]))
+            .sum::<i64>();
+        (
+            length + path.len().saturating_sub(2) as i64 * BEND_PENALTY,
+            path.clone(),
+        )
+    });
+    paths.dedup();
+    let (start_marker, end_marker) = markers(edge.direction);
+    Ok(paths
+        .into_iter()
+        .map(|path| SceneEdge {
+            from: edge.from.clone(),
+            to: edge.to.clone(),
+            direction: edge.direction,
+            kind: edge.kind,
+            label: edge.label.clone(),
+            label_anchor: edge.label.as_ref().map(|_| path_midpoint(&path)),
+            label_rect: None,
+            path,
+            start_marker,
+            end_marker,
+        })
+        .collect())
+}
+
 fn node_rect(nodes: &[SceneNode], identifier: &str) -> Option<Rect> {
     nodes
         .iter()
@@ -141,6 +226,56 @@ fn ports(rect: Rect) -> [Point; 4] {
     ]
 }
 
+fn terminal_stubs(rect: Rect) -> [(Point, Point, usize); 4] {
+    let ports = ports(rect);
+    [
+        (
+            ports[0],
+            Point {
+                x: ports[0].x + ROUTE_MARGIN,
+                y: ports[0].y,
+            },
+            1,
+        ),
+        (
+            ports[1],
+            Point {
+                x: ports[1].x,
+                y: ports[1].y + ROUTE_MARGIN,
+            },
+            2,
+        ),
+        (
+            ports[2],
+            Point {
+                x: ports[2].x - ROUTE_MARGIN,
+                y: ports[2].y,
+            },
+            1,
+        ),
+        (
+            ports[3],
+            Point {
+                x: ports[3].x,
+                y: ports[3].y - ROUTE_MARGIN,
+            },
+            2,
+        ),
+    ]
+}
+
+fn departs_normally(terminal: Point, other: Point, rect: Rect) -> bool {
+    if terminal.y == other.y && between(terminal.y, rect.y, rect.y + rect.height) {
+        (terminal.x == rect.x && other.x < terminal.x)
+            || (terminal.x == rect.x + rect.width && other.x > terminal.x)
+    } else if terminal.x == other.x && between(terminal.x, rect.x, rect.x + rect.width) {
+        (terminal.y == rect.y && other.y < terminal.y)
+            || (terminal.y == rect.y + rect.height && other.y > terminal.y)
+    } else {
+        false
+    }
+}
+
 fn path_midpoint(path: &[Point]) -> Point {
     let total = path
         .windows(2)
@@ -213,6 +348,61 @@ fn segment_crosses_rect_interior(start: Point, end: Point, rect: Rect) -> bool {
     }
 }
 
+fn segment_hits_rect(start: Point, end: Point, rect: Rect) -> bool {
+    if start.y == end.y {
+        between(start.y, rect.y, rect.y + rect.height)
+            && start.x.min(end.x) < rect.x + rect.width
+            && start.x.max(end.x) > rect.x
+    } else if start.x == end.x {
+        between(start.x, rect.x, rect.x + rect.width)
+            && start.y.min(end.y) < rect.y + rect.height
+            && start.y.max(end.y) > rect.y
+    } else {
+        true
+    }
+}
+
+fn expanded(rect: Rect) -> Rect {
+    Rect {
+        x: rect.x - ROUTE_MARGIN,
+        y: rect.y - ROUTE_MARGIN,
+        width: rect.width + 2 * ROUTE_MARGIN,
+        height: rect.height + 2 * ROUTE_MARGIN,
+    }
+}
+
+fn frame_segment_is_clear(start: Point, end: Point, frame: Rect) -> bool {
+    // Only the finite, parallel sides constrain a segment. Extending their
+    // projection by the same margin also protects perpendicular corner grazes.
+    if start.y == end.y {
+        let near_side = (start.y - frame.y).abs() < FRAME_MARGIN
+            || (start.y - frame.y - frame.height).abs() < FRAME_MARGIN;
+        !near_side
+            || start.x.max(end.x) <= frame.x - FRAME_MARGIN
+            || start.x.min(end.x) >= frame.x + frame.width + FRAME_MARGIN
+    } else if start.x == end.x {
+        let near_side = (start.x - frame.x).abs() < FRAME_MARGIN
+            || (start.x - frame.x - frame.width).abs() < FRAME_MARGIN;
+        !near_side
+            || start.y.max(end.y) <= frame.y - FRAME_MARGIN
+            || start.y.min(end.y) >= frame.y + frame.height + FRAME_MARGIN
+    } else {
+        false
+    }
+}
+
+fn frame_bend_is_clear(point: Point, frame: Rect) -> bool {
+    let near_horizontal = ((point.y - frame.y).abs() < FRAME_MARGIN
+        || (point.y - frame.y - frame.height).abs() < FRAME_MARGIN)
+        && point.x > frame.x - FRAME_MARGIN
+        && point.x < frame.x + frame.width + FRAME_MARGIN;
+    let near_vertical = ((point.x - frame.x).abs() < FRAME_MARGIN
+        || (point.x - frame.x - frame.width).abs() < FRAME_MARGIN)
+        && point.y > frame.y - FRAME_MARGIN
+        && point.y < frame.y + frame.height + FRAME_MARGIN;
+    !near_horizontal && !near_vertical
+}
+
 impl Rect {
     fn contains_point(self, point: Point) -> bool {
         point.x >= self.x
@@ -240,14 +430,25 @@ impl Rect {
 #[derive(Debug)]
 struct GridRouter<'a> {
     nodes: &'a [SceneNode],
+    fixed_obstacles: &'a [Rect],
+    frames: &'a [Rect],
     bounds: Rect,
     xs: Vec<i64>,
     ys: Vec<i64>,
     valid: Vec<bool>,
+    bend_allowed: Vec<bool>,
+    links: Vec<[Option<usize>; 4]>,
+    shared: Vec<[u32; 2]>,
+    occupied: Vec<[u32; 2]>,
 }
 
 impl<'a> GridRouter<'a> {
-    fn new(nodes: &'a [SceneNode], bounds: Rect) -> Self {
+    fn new(
+        nodes: &'a [SceneNode],
+        bounds: Rect,
+        fixed_obstacles: &'a [Rect],
+        frames: &'a [Rect],
+    ) -> Self {
         let mut xs = vec![
             bounds.x + ROUTE_MARGIN,
             bounds.x + bounds.width - ROUTE_MARGIN,
@@ -260,78 +461,209 @@ impl<'a> GridRouter<'a> {
             let rect = node.rect;
             xs.extend([
                 rect.x - ROUTE_MARGIN,
-                rect.x,
                 rect.x + rect.width / 2,
-                rect.x + rect.width,
                 rect.x + rect.width + ROUTE_MARGIN,
             ]);
             ys.extend([
                 rect.y - ROUTE_MARGIN,
-                rect.y,
                 rect.y + rect.height / 2,
-                rect.y + rect.height,
                 rect.y + rect.height + ROUTE_MARGIN,
             ]);
         }
+        for rect in fixed_obstacles {
+            xs.extend([rect.x - ROUTE_MARGIN, rect.x + rect.width + ROUTE_MARGIN]);
+            ys.extend([rect.y - ROUTE_MARGIN, rect.y + rect.height + ROUTE_MARGIN]);
+        }
+        for frame in frames {
+            for side in [frame.x, frame.x + frame.width] {
+                xs.extend([side - FRAME_MARGIN, side + FRAME_MARGIN]);
+            }
+            for side in [frame.y, frame.y + frame.height] {
+                ys.extend([side - FRAME_MARGIN, side + FRAME_MARGIN]);
+            }
+        }
         xs.retain(|x| *x >= bounds.x && *x <= bounds.x + bounds.width);
         ys.retain(|y| *y >= bounds.y && *y <= bounds.y + bounds.height);
         xs.sort_unstable();
         ys.sort_unstable();
         xs.dedup();
         ys.dedup();
-        let valid = ys
+        let obstacles = nodes
+            .iter()
+            .map(|node| expanded(node.rect))
+            .chain(fixed_obstacles.iter().copied().map(expanded))
+            .collect::<Vec<_>>();
+        let valid: Vec<bool> = ys
             .iter()
             .flat_map(|y| {
+                let obstacles = &obstacles;
                 xs.iter().map(move |x| {
                     let point = Point { x: *x, y: *y };
-                    nodes
+                    obstacles
                         .iter()
-                        .all(|node| !node.rect.contains_point_interior(point))
+                        .all(|rect| !rect.contains_point_interior(point))
                 })
             })
             .collect();
-        Self {
+        let bend_allowed = (0..valid.len())
+            .map(|vertex| {
+                let point = Point {
+                    x: xs[vertex % xs.len()],
+                    y: ys[vertex / xs.len()],
+                };
+                frames
+                    .iter()
+                    .all(|frame| frame_bend_is_clear(point, *frame))
+            })
+            .collect();
+        let mut router = Self {
             nodes,
+            fixed_obstacles,
+            frames,
             bounds,
             xs,
             ys,
+            links: vec![[None; 4]; valid.len()],
+            shared: vec![[0; 2]; valid.len()],
+            occupied: vec![[0; 2]; valid.len()],
             valid,
+            bend_allowed,
+        };
+        // The clearance grid is fixed for the entire scene. Search only reads
+        // these visibility links, rather than rechecking every obstacle.
+        for vertex in 0..router.valid.len() {
+            if !router.valid[vertex] {
+                continue;
+            }
+            let x = vertex % router.xs.len();
+            let y = vertex / router.xs.len();
+            let candidates = [
+                x.checked_sub(1).map(|x| y * router.xs.len() + x),
+                (x + 1 < router.xs.len()).then_some(vertex + 1),
+                y.checked_sub(1).map(|y| y * router.xs.len() + x),
+                (y + 1 < router.ys.len()).then_some(vertex + router.xs.len()),
+            ];
+            for (slot, candidate) in candidates.into_iter().enumerate() {
+                if let Some(next) = candidate {
+                    if router.valid[next]
+                        && obstacles.iter().all(|rect| {
+                            !segment_crosses_rect_interior(
+                                router.point(vertex),
+                                router.point(next),
+                                *rect,
+                            )
+                        })
+                        && frames.iter().all(|frame| {
+                            frame_segment_is_clear(router.point(vertex), router.point(next), *frame)
+                        })
+                    {
+                        router.links[vertex][slot] = Some(next);
+                    }
+                }
+            }
         }
+        router
+    }
+
+    fn route(&mut self, source: Rect, target: Rect) -> Option<Vec<Point>> {
+        self.route_between(source, target, None)
     }
 
-    fn route(&self, source: Rect, target: Rect) -> Option<Vec<Point>> {
+    fn route_between(
+        &mut self,
+        source: Rect,
+        target: Rect,
+        port_pair: Option<(usize, usize)>,
+    ) -> Option<Vec<Point>> {
         let state_count = self.valid.len() * 3;
         let mut distances = vec![i64::MAX; state_count];
         let mut parents = vec![None; state_count];
         let mut pending = BinaryHeap::new();
-        for port in ports(source) {
-            let vertex = self.vertex(port)?;
-            let state = vertex * 3;
-            distances[state] = 0;
-            pending.push(Reverse((0_i64, state)));
+        let mut starts = Vec::new();
+        for (index, (port, stub, axis)) in terminal_stubs(source).into_iter().enumerate() {
+            if port_pair.is_some_and(|(source_port, _)| source_port != index) {
+                continue;
+            }
+            let Some(vertex) = self.vertex(stub) else {
+                continue;
+            };
+            if !self.stub_is_clear(port, stub, source) {
+                continue;
+            }
+            let state = vertex * 3 + axis;
+            distances[state] = ROUTE_MARGIN;
+            pending.push(Reverse((ROUTE_MARGIN, state)));
+            starts.push((state, port));
+            if source == target {
+                break;
+            }
         }
-        let target_vertices = ports(target)
+        let targets = terminal_stubs(target)
             .into_iter()
-            .map(|port| self.vertex(port))
-            .collect::<Option<Vec<_>>>()?;
+            .enumerate()
+            .filter_map(|(index, (port, stub, axis))| {
+                if port_pair.is_some_and(|(_, target_port)| target_port != index) {
+                    return None;
+                }
+                let vertex = self.vertex(stub)?;
+                (self.stub_is_clear(port, stub, target)
+                    && !(source == target && starts.iter().any(|(_, start)| *start == port)))
+                .then_some((vertex, port, axis))
+            })
+            .collect::<Vec<_>>();
+        if starts.is_empty() || targets.is_empty() {
+            return None;
+        }
+        let mut best: Option<(i64, usize, Point)> = None;
 
         while let Some(Reverse((cost, state))) = pending.pop() {
             if distances[state] != cost {
                 continue;
             }
+            if best.is_some_and(|(best_cost, _, _)| cost > best_cost) {
+                break;
+            }
             let vertex = state / 3;
             let incoming_axis = state % 3;
-            if incoming_axis != 0 && target_vertices.contains(&vertex) {
-                return Some(self.reconstruct(state, &parents));
+            for &(target_vertex, port, axis) in &targets {
+                if target_vertex == vertex && (incoming_axis == axis || self.bend_allowed[vertex]) {
+                    let candidate = (
+                        cost + ROUTE_MARGIN
+                            + if incoming_axis == axis {
+                                0
+                            } else {
+                                BEND_PENALTY
+                            },
+                        state,
+                        port,
+                    );
+                    if best.is_none_or(|best| candidate < best) {
+                        best = Some(candidate);
+                    }
+                }
             }
-            for (next_vertex, next_axis, length) in self.neighbors(vertex) {
-                let bend = if incoming_axis != 0 && incoming_axis != next_axis {
+            for (slot, next_vertex) in self.links[vertex].iter().enumerate() {
+                let Some(next_vertex) = *next_vertex else {
+                    continue;
+                };
+                let next_axis = if slot < 2 { 1 } else { 2 };
+                if incoming_axis != next_axis && !self.bend_allowed[vertex] {
+                    continue;
+                }
+                let length = manhattan(self.point(vertex), self.point(next_vertex));
+                let bend = if incoming_axis != next_axis {
                     BEND_PENALTY
                 } else {
                     0
                 };
+                let shared = i64::from(self.shared[vertex.min(next_vertex)][next_axis - 1]);
+                let crossing = i64::from(self.occupied[next_vertex][2 - next_axis]);
                 let next_state = next_vertex * 3 + next_axis;
-                let next_cost = cost + length + bend;
+                let next_cost = cost
+                    + length
+                    + bend
+                    + shared * length * SHARED_LENGTH_PENALTY
+                    + crossing * CROSSING_PENALTY;
                 if next_cost < distances[next_state] {
                     distances[next_state] = next_cost;
                     parents[next_state] = Some(state);
@@ -339,7 +671,76 @@ impl<'a> GridRouter<'a> {
                 }
             }
         }
-        None
+        let (_, state, target_port) = best?;
+        let (middle, root) = self.reconstruct(state, &parents);
+        let source_port = starts.iter().find(|(state, _)| *state == root)?.1;
+        let mut path = Vec::with_capacity(middle.len() + 2);
+        for point in std::iter::once(source_port)
+            .chain(middle)
+            .chain(std::iter::once(target_port))
+        {
+            push_point(&mut path, point);
+        }
+        if port_pair.is_none() {
+            self.reserve_path(&path);
+        }
+        Some(path)
+    }
+
+    fn stub_is_clear(&self, port: Point, stub: Point, terminal: Rect) -> bool {
+        self.bounds.contains_point(port)
+            && self.bounds.contains_point(stub)
+            && self.nodes.iter().all(|node| {
+                node.rect == terminal
+                    || !segment_crosses_rect_interior(port, stub, expanded(node.rect))
+            })
+            && self
+                .fixed_obstacles
+                .iter()
+                .all(|rect| !segment_crosses_rect_interior(port, stub, expanded(*rect)))
+            && self
+                .frames
+                .iter()
+                .all(|frame| frame_segment_is_clear(port, stub, *frame))
+    }
+
+    fn reserve_path(&mut self, path: &[Point]) {
+        for segment in path.windows(2) {
+            let horizontal = segment[0].y == segment[1].y;
+            let (coordinates, fixed, start, end, axis) = if horizontal {
+                (
+                    &self.xs,
+                    self.ys.binary_search(&segment[0].y),
+                    segment[0].x,
+                    segment[1].x,
+                    0,
+                )
+            } else {
+                (
+                    &self.ys,
+                    self.xs.binary_search(&segment[0].x),
+                    segment[0].y,
+                    segment[1].y,
+                    1,
+                )
+            };
+            let Ok(fixed) = fixed else { continue };
+            let first = coordinates.partition_point(|coordinate| *coordinate < start.min(end));
+            let last = coordinates.partition_point(|coordinate| *coordinate <= start.max(end));
+            for index in first..last {
+                let vertex = if horizontal {
+                    fixed * self.xs.len() + index
+                } else {
+                    index * self.xs.len() + fixed
+                };
+                if self.valid[vertex] {
+                    self.occupied[vertex][axis] += 1;
+                    if index + 1 < last && self.links[vertex][axis * 2 + 1].is_some() {
+                        self.shared[vertex][axis] += 1;
+                    }
+                }
+            }
+        }
     }
 
     fn vertex(&self, point: Point) -> Option<usize> {
@@ -356,53 +757,7 @@ impl<'a> GridRouter<'a> {
         }
     }
 
-    fn neighbors(&self, vertex: usize) -> Vec<(usize, usize, i64)> {
-        let x = vertex % self.xs.len();
-        let y = vertex / self.xs.len();
-        let mut neighbors = Vec::with_capacity(4);
-        self.scan_neighbor(x, y, -1, 0, 1, &mut neighbors);
-        self.scan_neighbor(x, y, 1, 0, 1, &mut neighbors);
-        self.scan_neighbor(x, y, 0, -1, 2, &mut neighbors);
-        self.scan_neighbor(x, y, 0, 1, 2, &mut neighbors);
-        neighbors
-    }
-
-    fn scan_neighbor(
-        &self,
-        x: usize,
-        y: usize,
-        x_step: isize,
-        y_step: isize,
-        axis: usize,
-        neighbors: &mut Vec<(usize, usize, i64)>,
-    ) {
-        let mut candidate_x = x as isize + x_step;
-        let mut candidate_y = y as isize + y_step;
-        while candidate_x >= 0
-            && candidate_y >= 0
-            && candidate_x < self.xs.len() as isize
-            && candidate_y < self.ys.len() as isize
-        {
-            let candidate = candidate_y as usize * self.xs.len() + candidate_x as usize;
-            if self.valid[candidate] {
-                let start = self.point(y * self.xs.len() + x);
-                let end = self.point(candidate);
-                if self.bounds.contains_point(end)
-                    && self
-                        .nodes
-                        .iter()
-                        .all(|node| !segment_crosses_rect_interior(start, end, node.rect))
-                {
-                    neighbors.push((candidate, axis, manhattan(start, end)));
-                }
-                break;
-            }
-            candidate_x += x_step;
-            candidate_y += y_step;
-        }
-    }
-
-    fn reconstruct(&self, state: usize, parents: &[Option<usize>]) -> Vec<Point> {
+    fn reconstruct(&self, state: usize, parents: &[Option<usize>]) -> (Vec<Point>, usize) {
         let mut states = Vec::new();
         let mut cursor = Some(state);
         while let Some(current) = cursor {
@@ -412,33 +767,285 @@ impl<'a> GridRouter<'a> {
         states.reverse();
 
         let mut path = Vec::new();
+        let root = states[0];
         for state in states {
-            let point = self.point(state / 3);
-            if path.last() == Some(&point) {
-                continue;
-            }
-            if path.len() >= 2 {
-                let previous: Point = path[path.len() - 2];
-                let last: Point = path[path.len() - 1];
-                if (previous.x == last.x && last.x == point.x)
-                    || (previous.y == last.y && last.y == point.y)
-                {
-                    path.pop();
-                }
-            }
-            path.push(point);
+            push_point(&mut path, self.point(state / 3));
         }
-        path
+        (path, root)
     }
 }
 
+fn push_point(path: &mut Vec<Point>, point: Point) {
+    if path.last() == Some(&point) {
+        return;
+    }
+    if path.len() >= 2 {
+        let previous = path[path.len() - 2];
+        let last = path[path.len() - 1];
+        if (previous.x == last.x && last.x == point.x)
+            || (previous.y == last.y && last.y == point.y)
+        {
+            path.pop();
+        }
+    }
+    path.push(point);
+}
+
 #[cfg(test)]
 mod tests {
     use std::error::Error;
 
     use stack_compiler::ir::{EdgeDirection, EdgeKind};
 
-    use super::Marker;
+    use super::{Marker, Point, SceneEdge};
+    use crate::scene::{Rect, SceneNode};
+
+    fn test_node(id: &str, x: i64, y: i64) -> SceneNode {
+        SceneNode {
+            id: id.to_owned(),
+            parent_group_id: None,
+            rect: Rect {
+                x,
+                y,
+                width: 100_000,
+                height: 100_000,
+            },
+        }
+    }
+
+    fn test_edge(path: &[(i64, i64)]) -> SceneEdge {
+        SceneEdge {
+            from: "source".to_owned(),
+            to: "target".to_owned(),
+            direction: EdgeDirection::Forward,
+            kind: EdgeKind::Flow,
+            label: None,
+            path: path.iter().map(|&(x, y)| Point { x, y }).collect(),
+            start_marker: Marker::None,
+            end_marker: Marker::Arrow,
+            label_anchor: None,
+            label_rect: None,
+        }
+    }
+
+    fn test_bounds() -> Rect {
+        Rect {
+            x: 0,
+            y: 0,
+            width: 500_000,
+            height: 400_000,
+        }
+    }
+
+    fn test_frame() -> Rect {
+        Rect {
+            x: 100_000,
+            y: 100_000,
+            width: 200_000,
+            height: 200_000,
+        }
+    }
+
+    #[test]
+    fn frame_rejects_parallel_border_travel() {
+        assert!(!super::frame_segment_is_clear(
+            Point {
+                x: 120_000,
+                y: 100_000
+            },
+            Point {
+                x: 280_000,
+                y: 100_000
+            },
+            test_frame(),
+        ));
+    }
+
+    #[test]
+    fn frame_rejects_parallel_routes_inside_the_painted_clearance() {
+        for y in [83_000, 117_000, 283_000, 317_000] {
+            assert!(!super::frame_segment_is_clear(
+                Point { x: 120_000, y },
+                Point { x: 280_000, y },
+                test_frame(),
+            ));
+        }
+        for x in [83_000, 117_000, 283_000, 317_000] {
+            assert!(!super::frame_segment_is_clear(
+                Point { x, y: 120_000 },
+                Point { x, y: 280_000 },
+                test_frame(),
+            ));
+        }
+    }
+
+    #[test]
+    fn frame_rejects_corner_crossings_and_bends_on_the_border() {
+        assert!(!super::frame_segment_is_clear(
+            Point {
+                x: 110_000,
+                y: 60_000
+            },
+            Point {
+                x: 110_000,
+                y: 160_000
+            },
+            test_frame(),
+        ));
+        assert!(!super::frame_bend_is_clear(
+            Point {
+                x: 100_000,
+                y: 200_000
+            },
+            test_frame(),
+        ));
+        assert!(!super::frame_bend_is_clear(
+            Point {
+                x: 90_000,
+                y: 90_000
+            },
+            test_frame(),
+        ));
+    }
+
+    #[test]
+    fn frame_allows_normal_crossings_and_clear_parallel_lanes() {
+        for (start, end) in [
+            ((200_000, 60_000), (200_000, 160_000)),
+            ((60_000, 200_000), (160_000, 200_000)),
+            ((120_000, 82_000), (280_000, 82_000)),
+            ((120_000, 118_000), (280_000, 118_000)),
+            ((10_000, 100_000), (50_000, 100_000)),
+        ] {
+            assert!(super::frame_segment_is_clear(
+                Point {
+                    x: start.0,
+                    y: start.1
+                },
+                Point { x: end.0, y: end.1 },
+                test_frame(),
+            ));
+        }
+    }
+
+    #[test]
+    fn frame_routes_leave_a_clear_parallel_lane() -> Result<(), Box<dyn Error>> {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let frames = [Rect {
+            x: 150_000,
+            y: 160_000,
+            width: 200_000,
+            height: 160_000,
+        }];
+        let mut edge = test_edge(&[(120_000, 150_000), (320_000, 150_000)]);
+        assert!(super::geometry_is_valid(
+            &[edge.clone()],
+            &nodes,
+            test_bounds(),
+            &[],
+        ));
+        assert!(!super::geometry_is_valid(
+            &[edge.clone()],
+            &nodes,
+            test_bounds(),
+            &frames,
+        ));
+        let mut router = super::GridRouter::new(&nodes, test_bounds(), &[], &frames);
+        edge.path = router
+            .route(nodes[0].rect, nodes[1].rect)
+            .ok_or("no clear route beside the frame")?;
+        assert!(super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &frames,
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn frame_routes_cross_straight_into_the_group() -> Result<(), Box<dyn Error>> {
+        let nodes = [
+            test_node("source", 20_000, 160_000),
+            test_node("target", 220_000, 160_000),
+        ];
+        let frames = [Rect {
+            x: 150_000,
+            y: 110_000,
+            width: 200_000,
+            height: 200_000,
+        }];
+        let mut router = super::GridRouter::new(&nodes, test_bounds(), &[], &frames);
+        let path = router
+            .route(nodes[0].rect, nodes[1].rect)
+            .ok_or("normal frame crossing is missing")?;
+        let edge = test_edge(&[(120_000, 210_000), (220_000, 210_000)]);
+        assert_eq!(path, edge.path);
+        assert!(super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &frames,
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn rejects_tangential_terminal_departure() {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let edge = test_edge(&[(70_000, 100_000), (370_000, 100_000)]);
+        assert!(!super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
+    }
+
+    #[test]
+    fn rejects_intervening_node_boundary_travel() {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("blocker", 170_000, 50_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let edge = test_edge(&[(120_000, 150_000), (320_000, 150_000)]);
+        assert!(!super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
+    }
+
+    #[test]
+    fn rejects_later_contact_with_the_source_boundary() {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let edge = test_edge(&[
+            (120_000, 150_000),
+            (150_000, 150_000),
+            (150_000, 100_000),
+            (70_000, 100_000),
+            (70_000, 50_000),
+            (370_000, 50_000),
+            (370_000, 100_000),
+        ]);
+        assert!(!super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
+    }
 
     fn scene_from(source: &[u8]) -> Result<crate::scene::Scene, Box<dyn Error>> {
         let compiled = stack_compiler::compile_bytes(source);
@@ -476,11 +1083,103 @@ mod tests {
 
     #[test]
     fn routes_around_an_intervening_node() -> Result<(), Box<dyn Error>> {
-        let scene = scene_from(
-            b"stack 1.0 diagram \"Obstacle\" { layout { direction right } node left \"Left\" node blocker \"Blocker\" node right \"Right\" edge left -> right }",
-        )?;
-        assert!(scene.edges[0].path.len() >= 4);
-        assert!(scene.geometry_is_valid());
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("blocker", 170_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let mut router = super::GridRouter::new(&nodes, test_bounds(), &[], &[]);
+        let path = router
+            .route(nodes[0].rect, nodes[2].rect)
+            .ok_or("no route around the intervening node")?;
+        assert!(path.len() >= 4);
+        let mut edge = test_edge(&[]);
+        edge.path = path;
+        assert!(super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn routes_around_reserved_title_boxes() -> Result<(), Box<dyn Error>> {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let title = Rect {
+            x: 180_000,
+            y: 125_000,
+            width: 70_000,
+            height: 50_000,
+        };
+        let fixed = [title];
+        let mut router = super::GridRouter::new(&nodes, test_bounds(), &fixed, &[]);
+        let path = router
+            .route(nodes[0].rect, nodes[1].rect)
+            .ok_or("no route around the reserved title")?;
+        assert!(
+            path.windows(2)
+                .all(|segment| { !super::segment_hits_rect(segment[0], segment[1], title) })
+        );
+        let mut edge = test_edge(&[]);
+        edge.path = path;
+        assert!(super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn separates_repeated_routes_when_another_clear_lane_exists() -> Result<(), Box<dyn Error>> {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let mut router = super::GridRouter::new(&nodes, test_bounds(), &[], &[]);
+        let first = router
+            .route(nodes[0].rect, nodes[1].rect)
+            .ok_or("first route is missing")?;
+        let second = router
+            .route(nodes[0].rect, nodes[1].rect)
+            .ok_or("second route is missing")?;
+        assert_ne!(first, second);
+        for path in [first, second] {
+            let mut edge = test_edge(&[]);
+            edge.path = path;
+            assert!(super::geometry_is_valid(
+                &[edge],
+                &nodes,
+                test_bounds(),
+                &[]
+            ));
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn self_edges_leave_and_return_through_different_normal_ports() -> Result<(), Box<dyn Error>> {
+        let nodes = [test_node("source", 100_000, 100_000)];
+        let mut router = super::GridRouter::new(&nodes, test_bounds(), &[], &[]);
+        let path = router
+            .route(nodes[0].rect, nodes[0].rect)
+            .ok_or("self route is missing")?;
+        assert_ne!(path.first(), path.last());
+        let mut edge = test_edge(&[]);
+        edge.to = "source".to_owned();
+        edge.path = path;
+        assert!(super::geometry_is_valid(
+            &[edge],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
         Ok(())
     }
 
diff --git a/crates/stack-engine/src/scene.rs b/crates/stack-engine/src/scene.rs
index ea01c06..bb47944 100644
--- a/crates/stack-engine/src/scene.rs
+++ b/crates/stack-engine/src/scene.rs
@@ -18,7 +18,7 @@ const NODE_ICON_SIZE: i64 = 24_000;
 const NODE_ICON_GAP: i64 = 12_000;
 const NODE_DETAIL_GAP: i64 = 4_000;
 const ITEM_GAP: i64 = 24_000;
-const GROUP_PADDING: i64 = 24_000;
+pub(crate) const GROUP_PADDING: i64 = 40_000;
 const GROUP_LABEL_GAP: i64 = 12_000;
 const DIAGRAM_PADDING: i64 = 32_000;
 const DIAGRAM_TITLE_GAP: i64 = 20_000;
@@ -78,6 +78,8 @@ pub(crate) struct Scene {
     pub(crate) groups: Vec<SceneGroup>,
     pub(crate) edges: Vec<SceneEdge>,
     pub(crate) unsatisfied_orders: Vec<SceneScope>,
+    text_obstacles: Vec<Rect>,
+    connector_width: i64,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -159,11 +161,22 @@ impl Scene {
             }
         }
 
-        if !routing::geometry_is_valid(&self.edges, &self.nodes, self.bounds) {
+        let frames = self
+            .groups
+            .iter()
+            .map(|group| group.rect)
+            .collect::<Vec<_>>();
+        if !routing::geometry_is_valid(&self.edges, &self.nodes, self.bounds, &frames) {
             return false;
         }
 
-        true
+        crate::labels::geometry_is_valid(
+            &self.edges,
+            &self.nodes,
+            self.bounds,
+            &label_obstacles(&self.text_obstacles, &frames),
+            self.connector_width,
+        )
     }
 
     fn parent_content_rect(&self, parent_group_id: Option<&str>) -> Option<Rect> {
@@ -226,6 +239,13 @@ struct Arrangement {
     items: Vec<PlacedItem>,
 }
 
+struct LayoutContext<'a> {
+    diagram: &'a Diagram,
+    theme: &'a Theme,
+    metrics: &'a FontMetrics,
+    gap_scale: i64,
+}
+
 pub(crate) fn layout(diagram: &Diagram, catalog: &Catalog) -> Result<Scene, SceneError> {
     let theme = selected_theme(diagram, catalog)?;
     let metrics = catalog
@@ -233,20 +253,42 @@ pub(crate) fn layout(diagram: &Diagram, catalog: &Catalog) -> Result<Scene, Scen
         .iter()
         .find(|metrics| metrics.id == theme.typography.font_metrics_id)
         .ok_or(SceneError::MissingFontMetrics)?;
+    for gap_scale in [1, 2, 3] {
+        let context = LayoutContext {
+            diagram,
+            theme,
+            metrics,
+            gap_scale,
+        };
+        match layout_attempt(&context) {
+            Err(SceneError::EdgeRoutingFailed) => continue,
+            result => return result,
+        }
+    }
+    Err(SceneError::EdgeRoutingFailed)
+}
+
+fn layout_attempt(context: &LayoutContext<'_>) -> Result<Scene, SceneError> {
+    let LayoutContext {
+        diagram,
+        theme,
+        metrics,
+        ..
+    } = *context;
 
     let mut sizes = BTreeMap::new();
     for node in &diagram.nodes {
         sizes.insert(node.id.clone(), node_size(node, theme, metrics));
     }
     for group in diagram.groups.iter().rev() {
-        let children = arrange(&group.children, group.layout.as_ref(), &sizes)?;
+        let children = arrange(&group.children, group.layout.as_ref(), &sizes, context)?;
         sizes.insert(
             group.id.clone(),
             group_size(group, children.size, &theme.typography, metrics),
         );
     }
 
-    let root = arrange(&diagram.children, diagram.layout.as_ref(), &sizes)?;
+    let root = arrange(&diagram.children, diagram.layout.as_ref(), &sizes, context)?;
     let title_height = line_height(
         theme.typography.group_label_size_milli_px,
         &theme.typography,
@@ -256,15 +298,34 @@ pub(crate) fn layout(diagram: &Diagram, catalog: &Catalog) -> Result<Scene, Scen
         theme.typography.group_label_size_milli_px,
         metrics,
     );
+    // A failed compact attempt can need an exterior label lane, not merely
+    // larger distances between ranks (for example a long skip connection).
+    let outer_label = diagram
+        .edges
+        .iter()
+        .filter_map(|edge| edge.label.as_ref())
+        .map(|label| crate::labels::dimensions(label, theme, metrics))
+        .fold(
+            Size {
+                width: 0,
+                height: 0,
+            },
+            |size, label| Size {
+                width: size.width.max(label.width),
+                height: size.height.max(label.height),
+            },
+        );
+    let horizontal_padding = DIAGRAM_PADDING + outer_label.width * (context.gap_scale - 1);
+    let vertical_padding = DIAGRAM_PADDING + outer_label.height * (context.gap_scale - 1);
     let bounds = Rect {
         x: 0,
         y: 0,
-        width: (root.size.width + 2 * DIAGRAM_PADDING).max(title_width + 2 * DIAGRAM_PADDING),
-        height: root.size.height + 2 * DIAGRAM_PADDING + title_height + DIAGRAM_TITLE_GAP,
+        width: (root.size.width + 2 * horizontal_padding).max(title_width + 2 * horizontal_padding),
+        height: root.size.height + 2 * vertical_padding + title_height + DIAGRAM_TITLE_GAP,
     };
     let root_origin = Point {
-        x: DIAGRAM_PADDING,
-        y: DIAGRAM_PADDING + title_height + DIAGRAM_TITLE_GAP,
+        x: horizontal_padding,
+        y: vertical_padding + title_height + DIAGRAM_TITLE_GAP,
     };
     let content_rect = Rect {
         x: root_origin.x,
@@ -272,7 +333,7 @@ pub(crate) fn layout(diagram: &Diagram, catalog: &Catalog) -> Result<Scene, Scen
         width: root.size.width,
         height: root.size.height,
     };
-    let mut placer = Placer::new(diagram, &sizes, theme);
+    let mut placer = Placer::new(context, &sizes);
     placer.place_scope(&diagram.children, diagram.layout.as_ref(), root_origin)?;
 
     let nodes = diagram
@@ -319,9 +380,39 @@ pub(crate) fn layout(diagram: &Diagram, catalog: &Catalog) -> Result<Scene, Scen
             })
         })
         .collect::<Result<Vec<_>, SceneError>>()?;
-    let edges = routing::route(&diagram.edges, &nodes, bounds)
+    let mut text_obstacles = vec![Rect {
+        x: horizontal_padding,
+        y: root_origin.y
+            - DIAGRAM_TITLE_GAP
+            - i64::from(theme.typography.group_label_size_milli_px),
+        width: title_width,
+        height: title_height,
+    }];
+    for group in &groups {
+        let authored = diagram
+            .groups
+            .iter()
+            .find(|entry| entry.id == group.id)
+            .ok_or(SceneError::InvalidIntermediateRepresentation)?;
+        text_obstacles.push(Rect {
+            x: group.rect.x + GROUP_PADDING,
+            y: group.rect.y + GROUP_PADDING,
+            width: text_width(
+                &authored.label,
+                theme.typography.group_label_size_milli_px,
+                metrics,
+            ),
+            height: title_height,
+        });
+    }
+    let frames = groups.iter().map(|group| group.rect).collect::<Vec<_>>();
+    let mut edges = routing::route(&diagram.edges, &nodes, bounds, &text_obstacles, &frames)
         .map_err(|_| SceneError::EdgeRoutingFailed)?;
-    let unsatisfied_orders = unsatisfied_orders(diagram, &nodes, &groups)?;
+    let label_obstacles = label_obstacles(&text_obstacles, &frames);
+    if crate::labels::place(&mut edges, &nodes, bounds, &label_obstacles, theme, metrics).is_err() {
+        edges = route_with_reserved_labels(context, &nodes, bounds, &text_obstacles, &frames)?;
+    }
+    let unsatisfied_orders = unsatisfied_orders(diagram, &nodes, &groups, root.direction)?;
 
     Ok(Scene {
         bounds,
@@ -331,19 +422,122 @@ pub(crate) fn layout(diagram: &Diagram, catalog: &Catalog) -> Result<Scene, Scen
         groups,
         edges,
         unsatisfied_orders,
+        text_obstacles,
+        connector_width: i64::from(theme.connector.width_milli_px),
     })
 }
 
+fn label_obstacles(fixed_text: &[Rect], frames: &[Rect]) -> Vec<Rect> {
+    // Label backgrounds must not mask group borders. Nine pixels conservatively
+    // reserve an 8px painted gap plus the current 1px frame stroke. These finite
+    // perimeter strips are label-only: routes may still cross frames normally.
+    const GAP: i64 = 9_000;
+    let mut obstacles = fixed_text.to_vec();
+    for frame in frames {
+        for y in [frame.y, frame.y + frame.height] {
+            obstacles.push(Rect {
+                x: frame.x - GAP,
+                y: y - GAP,
+                width: frame.width + 2 * GAP,
+                height: 2 * GAP,
+            });
+        }
+        for x in [frame.x, frame.x + frame.width] {
+            obstacles.push(Rect {
+                x: x - GAP,
+                y: frame.y - GAP,
+                width: 2 * GAP,
+                height: frame.height + 2 * GAP,
+            });
+        }
+    }
+    obstacles
+}
+
+fn route_with_reserved_labels(
+    context: &LayoutContext<'_>,
+    nodes: &[SceneNode],
+    bounds: Rect,
+    fixed_text: &[Rect],
+    frames: &[Rect],
+) -> Result<Vec<SceneEdge>, SceneError> {
+    let label_obstacles = label_obstacles(fixed_text, frames);
+    let mut order = (0..context.diagram.edges.len()).collect::<Vec<_>>();
+    order.sort_by_key(|index| {
+        let width = context.diagram.edges[*index]
+            .label
+            .as_ref()
+            .map_or(0, |label| {
+                crate::labels::dimensions(label, context.theme, context.metrics).width
+            });
+        (std::cmp::Reverse(width), *index)
+    });
+    let mut previous: Vec<SceneEdge> = Vec::with_capacity(order.len());
+    for &index in &order {
+        let mut obstacles = fixed_text.to_vec();
+        obstacles.extend(previous.iter().filter_map(|edge| edge.label_rect));
+        let mut edge = routing::route(
+            &context.diagram.edges[index..=index],
+            nodes,
+            bounds,
+            &obstacles,
+            frames,
+        )
+        .map_err(|_| SceneError::EdgeRoutingFailed)?
+        .pop()
+        .ok_or(SceneError::EdgeRoutingFailed)?;
+        if crate::labels::place_next(
+            &mut edge,
+            &previous,
+            nodes,
+            bounds,
+            &label_obstacles,
+            context.theme,
+            context.metrics,
+        )
+        .is_err()
+        {
+            edge = routing::alternative_routes(
+                &context.diagram.edges[index],
+                nodes,
+                bounds,
+                &obstacles,
+                frames,
+            )
+            .map_err(|_| SceneError::EdgeRoutingFailed)?
+            .into_iter()
+            .find_map(|mut alternative| {
+                crate::labels::place_next(
+                    &mut alternative,
+                    &previous,
+                    nodes,
+                    bounds,
+                    &label_obstacles,
+                    context.theme,
+                    context.metrics,
+                )
+                .is_ok()
+                .then_some(alternative)
+            })
+            .ok_or(SceneError::EdgeRoutingFailed)?;
+        }
+        previous.push(edge);
+    }
+    let mut indexed = order.into_iter().zip(previous).collect::<Vec<_>>();
+    indexed.sort_by_key(|(index, _)| *index);
+    Ok(indexed.into_iter().map(|(_, edge)| edge).collect())
+}
+
 fn unsatisfied_orders(
     diagram: &Diagram,
     nodes: &[SceneNode],
     groups: &[SceneGroup],
+    root_direction: SceneDirection,
 ) -> Result<Vec<SceneScope>, SceneError> {
     let mut unsatisfied = Vec::new();
     if let Some(layout) = &diagram.layout {
         if let Some(order) = &layout.order {
-            let direction = resolve_direction(diagram.children.len(), layout.direction);
-            if !order_is_satisfied(order, direction, nodes, groups) {
+            if !order_is_satisfied(order, root_direction, nodes, groups) {
                 unsatisfied.push(SceneScope::Diagram);
             }
         }
@@ -470,9 +664,8 @@ fn group_size(
 }
 
 struct Placer<'a> {
-    diagram: &'a Diagram,
+    context: &'a LayoutContext<'a>,
     sizes: &'a BTreeMap<String, Size>,
-    theme: &'a Theme,
     node_rects: BTreeMap<String, Rect>,
     group_rects: BTreeMap<String, Rect>,
     group_content_rects: BTreeMap<String, Rect>,
@@ -480,11 +673,10 @@ struct Placer<'a> {
 }
 
 impl<'a> Placer<'a> {
-    fn new(diagram: &'a Diagram, sizes: &'a BTreeMap<String, Size>, theme: &'a Theme) -> Self {
+    fn new(context: &'a LayoutContext<'a>, sizes: &'a BTreeMap<String, Size>) -> Self {
         Self {
-            diagram,
+            context,
             sizes,
-            theme,
             node_rects: BTreeMap::new(),
             group_rects: BTreeMap::new(),
             group_content_rects: BTreeMap::new(),
@@ -498,7 +690,7 @@ impl<'a> Placer<'a> {
         layout: Option<&Layout>,
         origin: Point,
     ) -> Result<(), SceneError> {
-        let arrangement = arrange(children, layout, self.sizes)?;
+        let arrangement = arrange(children, layout, self.sizes, self.context)?;
         for placed in arrangement.items {
             let child = children
                 .get(placed.index)
@@ -511,23 +703,34 @@ impl<'a> Placer<'a> {
             };
             match child {
                 ElementId::Node(identifier) => {
-                    if self.diagram.nodes.iter().all(|node| node.id != *identifier) {
+                    if self
+                        .context
+                        .diagram
+                        .nodes
+                        .iter()
+                        .all(|node| node.id != *identifier)
+                    {
                         return Err(SceneError::InvalidIntermediateRepresentation);
                     }
                     self.node_rects.insert(identifier.clone(), rect);
                 }
                 ElementId::Group(identifier) => {
                     let group = self
+                        .context
                         .diagram
                         .groups
                         .iter()
                         .find(|group| group.id == *identifier)
                         .ok_or(SceneError::InvalidIntermediateRepresentation)?;
-                    let child_arrangement =
-                        arrange(&group.children, group.layout.as_ref(), self.sizes)?;
+                    let child_arrangement = arrange(
+                        &group.children,
+                        group.layout.as_ref(),
+                        self.sizes,
+                        self.context,
+                    )?;
                     let label_height = line_height(
-                        self.theme.typography.group_label_size_milli_px,
-                        &self.theme.typography,
+                        self.context.theme.typography.group_label_size_milli_px,
+                        &self.context.theme.typography,
                     );
                     let content_origin = Point {
                         x: rect.x + GROUP_PADDING,
@@ -557,20 +760,118 @@ fn arrange(
     children: &[ElementId],
     layout: Option<&Layout>,
     sizes: &BTreeMap<String, Size>,
+    context: &LayoutContext<'_>,
 ) -> Result<Arrangement, SceneError> {
     if children.is_empty() {
         return Err(SceneError::InvalidIntermediateRepresentation);
     }
-    let direction = resolve_direction(children.len(), layout.and_then(|layout| layout.direction));
-    let ranks = ranks(children, layout);
+    let ranks = graph_ranks(children, layout, context.diagram);
+    let authored = layout.and_then(|layout| layout.direction);
+    let preferred = resolve_direction(children.len(), authored);
+    let first = arrange_direction(children, sizes, context, &ranks, preferred)?;
+    let incident = context.diagram.edges.iter().any(|edge| {
+        scope_owner(children, &edge.from, context.diagram).is_some()
+            || scope_owner(children, &edge.to, context.diagram).is_some()
+    });
+    let simple_unlabeled_pair = children.len() <= 2
+        && context
+            .diagram
+            .edges
+            .iter()
+            .all(|edge| edge.label.is_none());
+    if authored.is_some() || !incident || simple_unlabeled_pair {
+        return Ok(first);
+    }
+    let alternative = match preferred {
+        SceneDirection::Right => SceneDirection::Down,
+        SceneDirection::Down => SceneDirection::Right,
+    };
+    let second = arrange_direction(children, sizes, context, &ranks, alternative)?;
+    let cost = |arrangement: &Arrangement| {
+        (
+            arrangement.size.width.max(arrangement.size.height),
+            i128::from(arrangement.size.width) * i128::from(arrangement.size.height),
+        )
+    };
+    Ok(if cost(&second) < cost(&first) {
+        second
+    } else {
+        first
+    })
+}
+
+fn arrange_direction(
+    children: &[ElementId],
+    sizes: &BTreeMap<String, Size>,
+    context: &LayoutContext<'_>,
+    ranks: &[Vec<usize>],
+    direction: SceneDirection,
+) -> Result<Arrangement, SceneError> {
+    let label_size = context
+        .diagram
+        .edges
+        .iter()
+        .filter_map(|edge| {
+            let from = scope_owner(children, &edge.from, context.diagram)?;
+            let to = scope_owner(children, &edge.to, context.diagram)?;
+            if from == to {
+                return None;
+            }
+            edge.label
+                .as_ref()
+                .map(|label| crate::labels::dimensions(label, context.theme, context.metrics))
+        })
+        .fold(
+            Size {
+                width: 0,
+                height: 0,
+            },
+            |size, label| Size {
+                width: size.width.max(label.width),
+                height: size.height.max(label.height),
+            },
+        );
+    let primary_label = match direction {
+        SceneDirection::Right => label_size.width,
+        SceneDirection::Down => label_size.height,
+    };
+    let cross_label = match direction {
+        SceneDirection::Right => label_size.height,
+        SceneDirection::Down => label_size.width,
+    };
+    let primary_gap = ITEM_GAP.max(primary_label + if primary_label > 0 { 32_000 } else { 0 })
+        * context.gap_scale;
+    let cross_gap =
+        ITEM_GAP.max(cross_label + if cross_label > 0 { 16_000 } else { 0 }) * context.gap_scale;
     let mut items = Vec::with_capacity(children.len());
     let mut primary_cursor = 0;
-    let mut cross_extent = 0;
+    let cross_extent = ranks
+        .iter()
+        .map(|rank| {
+            rank.iter()
+                .map(|index| {
+                    sizes
+                        .get(children[*index].as_str())
+                        .map(|size| match direction {
+                            SceneDirection::Right => size.height,
+                            SceneDirection::Down => size.width,
+                        })
+                        .ok_or(SceneError::InvalidIntermediateRepresentation)
+                })
+                .collect::<Result<Vec<_>, _>>()
+                .map(|sizes| {
+                    sizes.into_iter().sum::<i64>() + cross_gap * rank.len().saturating_sub(1) as i64
+                })
+        })
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .max()
+        .unwrap_or(0);
 
     for rank in ranks {
         let mut primary_extent = 0;
         let mut rank_cross_cursor = 0;
-        for index in &rank {
+        for index in rank {
             let size = sizes
                 .get(children[*index].as_str())
                 .copied()
@@ -584,10 +885,10 @@ fn arrange(
                 SceneDirection::Down => size.width,
             };
         }
-        rank_cross_cursor += ITEM_GAP * (rank.len().saturating_sub(1) as i64);
+        rank_cross_cursor += cross_gap * (rank.len().saturating_sub(1) as i64);
 
-        let mut cross_cursor = 0;
-        for index in rank {
+        let mut cross_cursor = (cross_extent - rank_cross_cursor) / 2;
+        for &index in rank {
             let size = sizes
                 .get(children[index].as_str())
                 .copied()
@@ -607,16 +908,22 @@ fn arrange(
                 },
             };
             cross_cursor += match direction {
-                SceneDirection::Right => size.height + ITEM_GAP,
-                SceneDirection::Down => size.width + ITEM_GAP,
+                SceneDirection::Right => size.height + cross_gap,
+                SceneDirection::Down => size.width + cross_gap,
             };
             items.push(PlacedItem { index, rect });
         }
-        cross_extent = cross_extent.max(rank_cross_cursor);
-        primary_cursor += primary_extent + ITEM_GAP;
+        primary_cursor += primary_extent + primary_gap;
     }
 
-    primary_cursor -= ITEM_GAP;
+    primary_cursor -= primary_gap;
+    // Keep the node spine centered within its ranks while reserving space to
+    // its right for vertical edge labels, before computing parent bounds.
+    let cross_extent = if direction == SceneDirection::Down && label_size.width > 0 {
+        cross_extent.max(cross_extent / 2 + label_size.width + 16_000)
+    } else {
+        cross_extent
+    };
     let size = match direction {
         SceneDirection::Right => Size {
             width: primary_cursor,
@@ -634,6 +941,125 @@ fn arrange(
     })
 }
 
+fn scope_owner(children: &[ElementId], node_id: &str, diagram: &Diagram) -> Option<usize> {
+    let mut identifier = node_id;
+    for _ in 0..=diagram.groups.len() + 1 {
+        if let Some(index) = children
+            .iter()
+            .position(|child| child.as_str() == identifier)
+        {
+            return Some(index);
+        }
+        identifier = diagram
+            .nodes
+            .iter()
+            .find(|node| node.id == identifier)
+            .and_then(|node| node.parent_group_id.as_deref())
+            .or_else(|| {
+                diagram
+                    .groups
+                    .iter()
+                    .find(|group| group.id == identifier)
+                    .and_then(|group| group.parent_group_id.as_deref())
+            })?;
+    }
+    None
+}
+
+fn graph_ranks(
+    children: &[ElementId],
+    layout: Option<&Layout>,
+    diagram: &Diagram,
+) -> Vec<Vec<usize>> {
+    let blocks = ranks(children, layout);
+    let count = blocks.len();
+    let mut reachable = vec![vec![false; count]; count];
+    let mut has_connection = false;
+    for edge in &diagram.edges {
+        let (Some(from), Some(to)) = (
+            scope_owner(children, &edge.from, diagram),
+            scope_owner(children, &edge.to, diagram),
+        ) else {
+            continue;
+        };
+        if from == to {
+            continue;
+        }
+        let source = blocks
+            .iter()
+            .position(|block| block.contains(&from))
+            .unwrap_or(0);
+        let target = blocks
+            .iter()
+            .position(|block| block.contains(&to))
+            .unwrap_or(0);
+        if source != target {
+            reachable[source][target] = true;
+            has_connection = true;
+        }
+    }
+    if !has_connection {
+        return blocks;
+    }
+
+    // Collapse strongly connected components before layering. This also makes
+    // cycles introduced by authored same-rank constraints deterministic.
+    let adjacency = reachable.clone();
+    for via in 0..count {
+        for from in 0..count {
+            for to in 0..count {
+                reachable[from][to] |= reachable[from][via] && reachable[via][to];
+            }
+        }
+    }
+    let component = (0..count)
+        .map(|index| {
+            (0..index)
+                .find(|other| reachable[index][*other] && reachable[*other][index])
+                .unwrap_or(index)
+        })
+        .collect::<Vec<_>>();
+    let mut depth = vec![0; count];
+    for _ in 0..count {
+        let mut changed = false;
+        for from in 0..count {
+            for to in 0..count {
+                let (source, target) = (component[from], component[to]);
+                if adjacency[from][to] && source != target && depth[target] <= depth[source] {
+                    depth[target] = depth[source] + 1;
+                    changed = true;
+                }
+            }
+        }
+        if !changed {
+            break;
+        }
+    }
+    let mut layers = BTreeMap::<usize, Vec<usize>>::new();
+    for (index, block) in blocks.into_iter().enumerate() {
+        layers
+            .entry(depth[component[index]])
+            .or_default()
+            .extend(block);
+    }
+    let order = layout.and_then(|layout| layout.order.as_deref());
+    layers
+        .into_values()
+        .map(|mut layer| {
+            layer.sort_by_key(|member| {
+                order
+                    .and_then(|order| {
+                        order
+                            .iter()
+                            .position(|entry| entry == children[*member].as_str())
+                    })
+                    .map_or((1, *member), |position| (0, position))
+            });
+            layer
+        })
+        .collect()
+}
+
 fn ranks(children: &[ElementId], layout: Option<&Layout>) -> Vec<Vec<usize>> {
     let same_ranks = layout.map_or(&[][..], |layout| layout.same_ranks.as_slice());
     let order = layout.and_then(|layout| layout.order.as_deref());
diff --git a/crates/stack-engine/src/svg.rs b/crates/stack-engine/src/svg.rs
index 7182fd4..3f6a3bd 100644
--- a/crates/stack-engine/src/svg.rs
+++ b/crates/stack-engine/src/svg.rs
@@ -5,16 +5,13 @@ use stack_theme::{NodeShape, PaletteToken, Theme};
 
 use crate::EngineMetadata;
 use crate::resources::{ResolvedNode, Resources};
-use crate::routing::{Marker, Point, SceneEdge};
-use crate::scene::{self, Rect, Scene, SceneGroup, SceneNode};
+use crate::routing::{Marker, SceneEdge};
+use crate::scene::{GROUP_PADDING, Rect, Scene, SceneGroup, SceneNode};
 
 const GROUP_CORNER_RADIUS: i64 = 12_000;
 const ICON_SIZE: i64 = 24_000;
 const NODE_HORIZONTAL_PADDING: i64 = 20_000;
 const ICON_TEXT_GAP: i64 = 12_000;
-const EDGE_LABEL_HORIZONTAL_PADDING: i64 = 6_000;
-const EDGE_LABEL_VERTICAL_PADDING: i64 = 4_000;
-const EDGE_LABEL_CLEARANCE: i64 = 8_000;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct SvgError {
@@ -40,10 +37,10 @@ pub(crate) fn render(
         "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{}\" height=\"{}\" viewBox=\"{} {} {} {}\" role=\"img\" aria-labelledby=\"stack-title stack-description\" data-engine-version=\"{}\" data-theme-id=\"{}\" data-theme-version=\"{}\" data-theme-revision=\"{}\">\n",
         pixel_dimension(scene.bounds.width),
         pixel_dimension(scene.bounds.height),
-        scene.bounds.x,
-        scene.bounds.y,
-        scene.bounds.width,
-        scene.bounds.height,
+        pixel_dimension(scene.bounds.x),
+        pixel_dimension(scene.bounds.y),
+        pixel_dimension(scene.bounds.width),
+        pixel_dimension(scene.bounds.height),
         escape_attribute(&metadata.engine_version),
         escape_attribute(&theme.id),
         escape_attribute(&metadata.theme_catalog_version),
@@ -93,10 +90,10 @@ pub(crate) fn render(
     ));
     output.push_str(&format!(
         "  <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" fill=\"{}\"/>\n",
-        scene.bounds.x,
-        scene.bounds.y,
-        scene.bounds.width,
-        scene.bounds.height,
+        pixel_dimension(scene.bounds.x),
+        pixel_dimension(scene.bounds.y),
+        pixel_dimension(scene.bounds.width),
+        pixel_dimension(scene.bounds.height),
         escape_attribute(&theme.palette.canvas)
     ));
     render_definitions(&mut output, theme);
@@ -146,8 +143,8 @@ fn render_definitions(output: &mut String, theme: &Theme) {
     output.push_str("  <defs>\n");
     output.push_str(&format!(
         "    <marker id=\"stack-arrow\" markerUnits=\"userSpaceOnUse\" markerWidth=\"{}\" markerHeight=\"{}\" refX=\"9000\" refY=\"5000\" viewBox=\"0 0 10000 10000\" orient=\"auto-start-reverse\">\n",
-        theme.connector.arrow_size_milli_px,
-        theme.connector.arrow_size_milli_px
+        pixel_dimension(i64::from(theme.connector.arrow_size_milli_px)),
+        pixel_dimension(i64::from(theme.connector.arrow_size_milli_px))
     ));
     output.push_str(&format!(
         "      <path d=\"M 0 0 L 10000 5000 L 0 10000 z\" fill=\"{}\"/>\n",
@@ -166,11 +163,11 @@ fn render_diagram_title(
     let baseline = scene.content_rect.y - 20_000;
     output.push_str(&format!(
         "  <text x=\"{}\" y=\"{}\" fill=\"{}\" font-family=\"{}\" font-size=\"{}\" font-weight=\"{}\">{}</text>\n",
-        scene.content_rect.x,
-        baseline,
+        pixel_dimension(scene.content_rect.x),
+        pixel_dimension(baseline),
         escape_attribute(&resources.theme.palette.text),
         escape_attribute(&resources.metrics.family),
-        typography.group_label_size_milli_px,
+        pixel_dimension(i64::from(typography.group_label_size_milli_px)),
         typography.label_weight,
         escape_text(&diagram.title)
     ));
@@ -185,22 +182,22 @@ fn render_group(output: &mut String, group: &SceneGroup, label: &str, resources:
     ));
     output.push_str(&format!("      <title>{}</title>\n", escape_text(label)));
     output.push_str(&format!(
-        "      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"{}\" fill=\"{}\" fill-opacity=\"0.55\" stroke=\"{}\" stroke-width=\"1000\"/>\n",
-        group.rect.x,
-        group.rect.y,
-        group.rect.width,
-        group.rect.height,
-        GROUP_CORNER_RADIUS,
+        "      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"{}\" fill=\"{}\" fill-opacity=\"0.55\" stroke=\"{}\" stroke-width=\"1\"/>\n",
+        pixel_dimension(group.rect.x),
+        pixel_dimension(group.rect.y),
+        pixel_dimension(group.rect.width),
+        pixel_dimension(group.rect.height),
+        pixel_dimension(GROUP_CORNER_RADIUS),
         escape_attribute(&theme.palette.surface_muted),
         escape_attribute(&theme.palette.border)
     ));
     output.push_str(&format!(
         "      <text x=\"{}\" y=\"{}\" fill=\"{}\" font-family=\"{}\" font-size=\"{}\" font-weight=\"{}\">{}</text>\n",
-        group.rect.x + 24_000,
-        group.rect.y + 24_000 + i64::from(theme.typography.group_label_size_milli_px),
+        pixel_dimension(group.rect.x + GROUP_PADDING),
+        pixel_dimension(group.rect.y + GROUP_PADDING + i64::from(theme.typography.group_label_size_milli_px)),
         escape_attribute(&theme.palette.text),
         escape_attribute(&resources.metrics.family),
-        theme.typography.group_label_size_milli_px,
+        pixel_dimension(i64::from(theme.typography.group_label_size_milli_px)),
         theme.typography.label_weight,
         escape_text(label)
     ));
@@ -249,7 +246,7 @@ fn render_edge(
     let points = edge
         .path
         .iter()
-        .map(|point| format!("{},{}", point.x, point.y))
+        .map(|point| format!("{},{}", pixel_dimension(point.x), pixel_dimension(point.y)))
         .collect::<Vec<_>>()
         .join(" ");
     let marker_start = marker_attribute("marker-start", edge.start_marker);
@@ -259,7 +256,7 @@ fn render_edge(
         "      <polyline points=\"{}\" fill=\"none\" stroke=\"{}\" stroke-width=\"{}\" stroke-linecap=\"round\" stroke-linejoin=\"round\"{}{}{} />\n",
         points,
         escape_attribute(palette_color(resources.theme, resources.theme.connector.stroke)),
-        resources.theme.connector.width_milli_px,
+        pixel_dimension(i64::from(resources.theme.connector.width_milli_px)),
         marker_start,
         marker_end,
         dash
@@ -286,7 +283,7 @@ fn dash_attribute(edge: &SceneEdge, theme: &Theme) -> String {
             " stroke-dasharray=\"{}\"",
             values
                 .iter()
-                .map(u32::to_string)
+                .map(|value| pixel_dimension(i64::from(*value)))
                 .collect::<Vec<_>>()
                 .join(" ")
         )
@@ -294,126 +291,24 @@ fn dash_attribute(edge: &SceneEdge, theme: &Theme) -> String {
 }
 
 fn render_edge_labels(output: &mut String, scene: &Scene, resources: &Resources<'_>) {
-    let mut occupied = scene.nodes.iter().map(|node| node.rect).collect::<Vec<_>>();
     output.push_str("  <g data-stack-layer=\"edge-labels\" aria-hidden=\"true\">\n");
     for edge in &scene.edges {
-        if let (Some(label), Some(anchor)) = (&edge.label, edge.label_anchor) {
-            let dimensions = edge_label_dimensions(label, resources);
-            let anchor = choose_label_anchor(
-                anchor,
-                dimensions.width,
-                dimensions.height,
-                scene.bounds,
-                &occupied,
-            );
-            render_edge_label(output, label, anchor, dimensions, resources);
-            occupied.push(centered_rect(anchor, dimensions.width, dimensions.height));
+        if let (Some(label), Some(rect)) = (&edge.label, edge.label_rect) {
+            render_edge_label(output, label, rect, resources);
         }
     }
     output.push_str("  </g>\n");
 }
 
-fn edge_label_dimensions(label: &str, resources: &Resources<'_>) -> Rect {
-    let typography = &resources.theme.typography;
-    let text_width = scene::text_width(
-        label,
-        typography.edge_label_size_milli_px,
-        resources.metrics,
-    );
-    let line_height = scene::line_height(typography.edge_label_size_milli_px, typography);
-    Rect {
-        x: 0,
-        y: 0,
-        width: text_width + 2 * EDGE_LABEL_HORIZONTAL_PADDING,
-        height: line_height + 2 * EDGE_LABEL_VERTICAL_PADDING,
-    }
-}
-
-fn choose_label_anchor(
-    preferred: Point,
-    width: i64,
-    height: i64,
-    bounds: Rect,
-    occupied: &[Rect],
-) -> Point {
-    let mut candidates = vec![preferred];
-    for rect in occupied {
-        candidates.extend([
-            Point {
-                x: preferred.x,
-                y: rect.y - height / 2 - EDGE_LABEL_CLEARANCE,
-            },
-            Point {
-                x: preferred.x,
-                y: rect.y + rect.height + height / 2 + EDGE_LABEL_CLEARANCE,
-            },
-            Point {
-                x: rect.x - width / 2 - EDGE_LABEL_CLEARANCE,
-                y: preferred.y,
-            },
-            Point {
-                x: rect.x + rect.width + width / 2 + EDGE_LABEL_CLEARANCE,
-                y: preferred.y,
-            },
-        ]);
-    }
-    candidates
-        .into_iter()
-        .enumerate()
-        .filter(|(_, candidate)| {
-            let candidate = centered_rect(*candidate, width, height);
-            rect_contains(bounds, candidate)
-                && occupied
-                    .iter()
-                    .all(|occupied| !rects_overlap(candidate, *occupied))
-        })
-        .min_by_key(|(index, candidate)| {
-            (
-                (candidate.x - preferred.x).abs() + (candidate.y - preferred.y).abs(),
-                *index,
-            )
-        })
-        .map_or(preferred, |(_, candidate)| candidate)
-}
-
-fn centered_rect(center: Point, width: i64, height: i64) -> Rect {
-    Rect {
-        x: center.x - width / 2,
-        y: center.y - height / 2,
-        width,
-        height,
-    }
-}
-
-fn rect_contains(outer: Rect, inner: Rect) -> bool {
-    inner.x >= outer.x
-        && inner.y >= outer.y
-        && inner.x + inner.width <= outer.x + outer.width
-        && inner.y + inner.height <= outer.y + outer.height
-}
-
-fn rects_overlap(left: Rect, right: Rect) -> bool {
-    left.x < right.x + right.width
-        && right.x < left.x + left.width
-        && left.y < right.y + right.height
-        && right.y < left.y + left.height
-}
-
-fn render_edge_label(
-    output: &mut String,
-    label: &str,
-    anchor: Point,
-    dimensions: Rect,
-    resources: &Resources<'_>,
-) {
+fn render_edge_label(output: &mut String, label: &str, rect: Rect, resources: &Resources<'_>) {
     let typography = &resources.theme.typography;
     output.push_str(&format!(
-        "    <g data-edge-label=\"{}\">\n      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"4000\" fill=\"{}\"/>\n",
+        "    <g data-edge-label=\"{}\">\n      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"4\" fill=\"{}\"/>\n",
         escape_attribute(label),
-        anchor.x - dimensions.width / 2,
-        anchor.y - dimensions.height / 2,
-        dimensions.width,
-        dimensions.height,
+        pixel_dimension(rect.x),
+        pixel_dimension(rect.y),
+        pixel_dimension(rect.width),
+        pixel_dimension(rect.height),
         escape_attribute(palette_color(
             resources.theme,
             resources.theme.connector.label_background
@@ -421,14 +316,14 @@ fn render_edge_label(
     ));
     output.push_str(&format!(
         "      <text x=\"{}\" y=\"{}\" text-anchor=\"middle\" dominant-baseline=\"middle\" fill=\"{}\" font-family=\"{}\" font-size=\"{}\">{}</text>\n    </g>\n",
-        anchor.x,
-        anchor.y,
+        pixel_dimension(rect.x + rect.width / 2),
+        pixel_dimension(rect.y + rect.height / 2),
         escape_attribute(palette_color(
             resources.theme,
             resources.theme.connector.text
         )),
         escape_attribute(&resources.metrics.family),
-        typography.edge_label_size_milli_px,
+        pixel_dimension(i64::from(typography.edge_label_size_milli_px)),
         escape_text(label)
     ));
 }
@@ -466,69 +361,69 @@ fn render_node_shape(output: &mut String, rect: Rect, resolved: &ResolvedNode<'_
     let stroke = escape_attribute(palette_color(theme, resolved.visual.stroke));
     match resolved.visual.shape {
         NodeShape::RoundedRectangle | NodeShape::Capsule => output.push_str(&format!(
-            "      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1500\"/>\n",
-            rect.x,
-            rect.y,
-            rect.width,
-            rect.height,
-            resolved.visual.corner_radius_milli_px,
+            "      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1.5\"/>\n",
+            pixel_dimension(rect.x),
+            pixel_dimension(rect.y),
+            pixel_dimension(rect.width),
+            pixel_dimension(rect.height),
+            pixel_dimension(i64::from(resolved.visual.corner_radius_milli_px)),
             fill,
             stroke
         )),
         NodeShape::Circle => output.push_str(&format!(
-            "      <circle cx=\"{}\" cy=\"{}\" r=\"{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1500\"/>\n",
-            rect.x + rect.width / 2,
-            rect.y + rect.height / 2,
-            rect.width.min(rect.height) / 2,
+            "      <circle cx=\"{}\" cy=\"{}\" r=\"{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1.5\"/>\n",
+            pixel_dimension(rect.x + rect.width / 2),
+            pixel_dimension(rect.y + rect.height / 2),
+            pixel_dimension(rect.width.min(rect.height) / 2),
             fill,
             stroke
         )),
         NodeShape::Cylinder => {
             let radius_y = 10_000;
             output.push_str(&format!(
-                "      <path d=\"M {} {} V {} C {} {} {} {} {} {} V {} C {} {} {} {} {} {} Z\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1500\"/>\n",
-                rect.x,
-                rect.y + radius_y,
-                rect.y + rect.height - radius_y,
-                rect.x,
-                rect.y + rect.height,
-                rect.x + rect.width,
-                rect.y + rect.height,
-                rect.x + rect.width,
-                rect.y + rect.height - radius_y,
-                rect.y + radius_y,
-                rect.x + rect.width,
-                rect.y,
-                rect.x,
-                rect.y,
-                rect.x,
-                rect.y + radius_y,
+                "      <path d=\"M {} {} V {} C {} {} {} {} {} {} V {} C {} {} {} {} {} {} Z\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1.5\"/>\n",
+                pixel_dimension(rect.x),
+                pixel_dimension(rect.y + radius_y),
+                pixel_dimension(rect.y + rect.height - radius_y),
+                pixel_dimension(rect.x),
+                pixel_dimension(rect.y + rect.height),
+                pixel_dimension(rect.x + rect.width),
+                pixel_dimension(rect.y + rect.height),
+                pixel_dimension(rect.x + rect.width),
+                pixel_dimension(rect.y + rect.height - radius_y),
+                pixel_dimension(rect.y + radius_y),
+                pixel_dimension(rect.x + rect.width),
+                pixel_dimension(rect.y),
+                pixel_dimension(rect.x),
+                pixel_dimension(rect.y),
+                pixel_dimension(rect.x),
+                pixel_dimension(rect.y + radius_y),
                 fill,
                 stroke
             ));
             output.push_str(&format!(
-                "      <ellipse cx=\"{}\" cy=\"{}\" rx=\"{}\" ry=\"{}\" fill=\"none\" stroke=\"{}\" stroke-width=\"1500\"/>\n",
-                rect.x + rect.width / 2,
-                rect.y + radius_y,
-                rect.width / 2,
-                radius_y,
+                "      <ellipse cx=\"{}\" cy=\"{}\" rx=\"{}\" ry=\"{}\" fill=\"none\" stroke=\"{}\" stroke-width=\"1.5\"/>\n",
+                pixel_dimension(rect.x + rect.width / 2),
+                pixel_dimension(rect.y + radius_y),
+                pixel_dimension(rect.width / 2),
+                pixel_dimension(radius_y),
                 stroke
             ));
         }
         NodeShape::Hexagon => output.push_str(&format!(
-            "      <polygon points=\"{},{} {},{} {},{} {},{} {},{} {},{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1500\"/>\n",
-            rect.x + 16_000,
-            rect.y,
-            rect.x + rect.width - 16_000,
-            rect.y,
-            rect.x + rect.width,
-            rect.y + rect.height / 2,
-            rect.x + rect.width - 16_000,
-            rect.y + rect.height,
-            rect.x + 16_000,
-            rect.y + rect.height,
-            rect.x,
-            rect.y + rect.height / 2,
+            "      <polygon points=\"{},{} {},{} {},{} {},{} {},{} {},{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"1.5\"/>\n",
+            pixel_dimension(rect.x + 16_000),
+            pixel_dimension(rect.y),
+            pixel_dimension(rect.x + rect.width - 16_000),
+            pixel_dimension(rect.y),
+            pixel_dimension(rect.x + rect.width),
+            pixel_dimension(rect.y + rect.height / 2),
+            pixel_dimension(rect.x + rect.width - 16_000),
+            pixel_dimension(rect.y + rect.height),
+            pixel_dimension(rect.x + 16_000),
+            pixel_dimension(rect.y + rect.height),
+            pixel_dimension(rect.x),
+            pixel_dimension(rect.y + rect.height / 2),
             fill,
             stroke
         )),
@@ -547,10 +442,10 @@ fn render_icon(
     let view_box = resolved.icon_view_box;
     output.push_str(&format!(
         "      <svg x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" viewBox=\"{} {} {} {}\" color=\"{}\" aria-hidden=\"true\" focusable=\"false\" data-icon-id=\"{}\">{} </svg>\n",
-        rect.x + NODE_HORIZONTAL_PADDING,
-        rect.y + (rect.height - ICON_SIZE) / 2,
-        ICON_SIZE,
-        ICON_SIZE,
+        pixel_dimension(rect.x + NODE_HORIZONTAL_PADDING),
+        pixel_dimension(rect.y + (rect.height - ICON_SIZE) / 2),
+        pixel_dimension(ICON_SIZE),
+        pixel_dimension(ICON_SIZE),
         view_box[0],
         view_box[1],
         view_box[2],
@@ -584,22 +479,22 @@ fn render_node_text(
     };
     output.push_str(&format!(
         "      <text x=\"{}\" y=\"{}\" dominant-baseline=\"middle\" fill=\"{}\" font-family=\"{}\" font-size=\"{}\" font-weight=\"{}\">{}</text>\n",
-        text_x,
-        label_y,
+        pixel_dimension(text_x),
+        pixel_dimension(label_y),
         escape_attribute(palette_color(resources.theme, resolved.visual.text)),
         escape_attribute(&resources.metrics.family),
-        typography.node_label_size_milli_px,
+        pixel_dimension(i64::from(typography.node_label_size_milli_px)),
         typography.label_weight,
         escape_text(&node.label)
     ));
     if let Some(detail) = &node.detail {
         output.push_str(&format!(
             "      <text x=\"{}\" y=\"{}\" dominant-baseline=\"middle\" fill=\"{}\" font-family=\"{}\" font-size=\"{}\" font-weight=\"{}\">{}</text>\n",
-            text_x,
-            rect.y + rect.height / 2 + 10_000,
+            pixel_dimension(text_x),
+            pixel_dimension(rect.y + rect.height / 2 + 10_000),
             escape_attribute(&resources.theme.palette.text_muted),
             escape_attribute(&resources.metrics.family),
-            typography.node_detail_size_milli_px,
+            pixel_dimension(i64::from(typography.node_detail_size_milli_px)),
             typography.detail_weight,
             escape_text(detail)
         ));
@@ -662,12 +557,15 @@ fn node_kind_name(kind: NodeKind) -> &'static str {
 }
 
 fn pixel_dimension(milli_pixels: i64) -> String {
-    let whole = milli_pixels / 1000;
-    let remainder = milli_pixels % 1000;
+    // Serialize only at the SVG boundary; scene geometry stays in integer milli-pixels.
+    let magnitude = milli_pixels.unsigned_abs();
+    let sign = if milli_pixels < 0 { "-" } else { "" };
+    let whole = magnitude / 1000;
+    let remainder = magnitude % 1000;
     if remainder == 0 {
-        whole.to_string()
+        format!("{sign}{whole}")
     } else {
-        format!("{whole}.{remainder:03}")
+        format!("{sign}{whole}.{remainder:03}")
             .trim_end_matches('0')
             .to_owned()
     }
@@ -692,11 +590,11 @@ fn escape_attribute(value: &str) -> String {
 
 #[cfg(test)]
 mod tests {
+    use super::{escape_attribute, escape_text, pixel_dimension};
+    use crate::resources::Resources;
     use crate::routing::Point;
     use crate::scene::Rect;
 
-    use super::{choose_label_anchor, escape_attribute, escape_text, pixel_dimension};
-
     #[test]
     fn escapes_untrusted_text_and_attributes() {
         assert_eq!(escape_text("<&>"), "&lt;&amp;&gt;");
@@ -711,34 +609,204 @@ mod tests {
     }
 
     #[test]
-    fn moves_edge_labels_to_the_nearest_clear_position() {
-        let bounds = Rect {
-            x: 0,
-            y: 0,
-            width: 500_000,
-            height: 500_000,
-        };
-        let node = Rect {
-            x: 80_000,
-            y: 100_000,
-            width: 160_000,
+    fn formats_signed_milli_pixels_including_integer_limits() {
+        for (input, expected) in [
+            (0, "0"),
+            (1, "0.001"),
+            (-1, "-0.001"),
+            (-10, "-0.01"),
+            (-100, "-0.1"),
+            (-1000, "-1"),
+            (-1001, "-1.001"),
+            (i64::MIN, "-9223372036854775.808"),
+            (i64::MAX, "9223372036854775.807"),
+        ] {
+            assert_eq!(pixel_dimension(input), expected);
+        }
+    }
+
+    #[test]
+    fn serializes_the_outer_view_box_and_all_text_sizes_in_css_pixels()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let source = b"stack 1.0 diagram \"Units\" { group g \"Group\" { node a \"A\" { detail \"Detail\" } node b \"B\" } edge a -> b \"Label\" }";
+        let diagram = stack_compiler::compile_bytes(source)
+            .diagram
+            .ok_or("valid diagram")?;
+        let scene = crate::scene::layout(&diagram, stack_theme::catalog())?;
+        let output = crate::Engine::bundled()
+            .render(source)?
+            .svg
+            .ok_or("SVG document")?;
+        assert!(output.contains(&format!(
+            "width=\"{}\" height=\"{}\" viewBox=\"0 0 {} {}\"",
+            pixel_dimension(scene.bounds.width),
+            pixel_dimension(scene.bounds.height),
+            pixel_dimension(scene.bounds.width),
+            pixel_dimension(scene.bounds.height),
+        )));
+        let theme = &stack_theme::catalog().themes[0];
+        for size in [
+            theme.typography.node_label_size_milli_px,
+            theme.typography.node_detail_size_milli_px,
+            theme.typography.edge_label_size_milli_px,
+            theme.typography.group_label_size_milli_px,
+        ] {
+            assert!(output.contains(&format!(
+                "font-size=\"{}\"",
+                pixel_dimension(i64::from(size))
+            )));
+            assert!(!output.contains(&format!("font-size=\"{size}\"")));
+        }
+        assert!(output.contains("font-weight=\"600\""));
+        assert!(output.contains("rx=\"12\""));
+        assert!(output.contains("fill-opacity=\"0.55\""));
+        assert!(output.contains("stroke-width=\"1\""));
+        Ok(())
+    }
+
+    #[test]
+    fn serializes_every_node_shape_in_css_pixels() -> Result<(), Box<dyn std::error::Error>> {
+        let rect = Rect {
+            x: -1250,
+            y: 267_800,
+            width: 208_300,
             height: 72_000,
         };
-        assert_eq!(
-            choose_label_anchor(
-                Point {
-                    x: 80_000,
-                    y: 136_000,
-                },
-                32_000,
-                24_000,
-                bounds,
-                &[node],
+        for (kind, expected) in [
+            (
+                "service",
+                "<rect x=\"-1.25\" y=\"267.8\" width=\"208.3\" height=\"72\" rx=\"8\"",
+            ),
+            (
+                "worker",
+                "<rect x=\"-1.25\" y=\"267.8\" width=\"208.3\" height=\"72\" rx=\"16\"",
+            ),
+            ("actor", "<circle cx=\"102.9\" cy=\"303.8\" r=\"36\""),
+            (
+                "database",
+                "<path d=\"M -1.25 277.8 V 329.8 C -1.25 339.8 207.05 339.8 207.05 329.8 V 277.8 C 207.05 267.8 -1.25 267.8 -1.25 277.8 Z\"",
             ),
-            Point {
-                x: 56_000,
-                y: 136_000,
+            (
+                "function",
+                "<polygon points=\"14.75,267.8 191.05,267.8 207.05,303.8 191.05,339.8 14.75,339.8 -1.25,303.8\"",
+            ),
+        ] {
+            let source =
+                format!("stack 1.0 diagram \"Shape\" {{ node a \"A\" {{ kind {kind} }} }}");
+            let diagram = stack_compiler::compile_bytes(source.as_bytes())
+                .diagram
+                .ok_or("valid diagram")?;
+            let resources = Resources::resolve(&diagram, stack_theme::catalog(), &[])
+                .map_err(|error| error.reason())?;
+            let mut output = String::new();
+            super::render_node_shape(
+                &mut output,
+                rect,
+                resources.node("a").ok_or("resolved node")?,
+                resources.theme,
+            );
+            assert!(output.contains(expected), "{kind}: {output}");
+            assert!(output.contains("stroke-width=\"1.5\""));
+            if kind == "database" {
+                assert!(
+                    output.contains("<ellipse cx=\"102.9\" cy=\"277.8\" rx=\"104.15\" ry=\"10\"")
+                );
             }
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn scales_routes_dash_patterns_and_only_the_marker_viewport()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let source = b"stack 1.0 diagram \"Routes\" { node a \"A\" node b \"B\" edge a -> b }";
+        let diagram = stack_compiler::compile_bytes(source)
+            .diagram
+            .ok_or("valid diagram")?;
+        let resources = Resources::resolve(&diagram, stack_theme::catalog(), &[])
+            .map_err(|error| error.reason())?;
+        let mut scene = crate::scene::layout(&diagram, stack_theme::catalog())?;
+        let edge = scene.edges.first_mut().ok_or("scene edge")?;
+        edge.path = vec![Point { x: -1, y: 1250 }, Point { x: 20_000, y: 1250 }];
+        let mut output = String::new();
+        super::render_edge(&mut output, edge, &diagram, &resources)
+            .map_err(|error| error.reason())?;
+        assert!(output.contains("points=\"-0.001,1.25 20,1.25\""));
+        assert!(output.contains(&format!(
+            "stroke-width=\"{}\"",
+            pixel_dimension(i64::from(resources.theme.connector.width_milli_px))
+        )));
+        let mut theme = resources.theme.clone();
+        theme.connector.arrow_size_milli_px = 10_125;
+        theme.connector.dash_milli_px = Some(vec![1250, 2001]);
+        assert_eq!(
+            super::dash_attribute(edge, &theme),
+            " stroke-dasharray=\"1.25 2.001\""
         );
+        edge.direction = stack_compiler::ir::EdgeDirection::Association;
+        assert_eq!(
+            super::dash_attribute(edge, &theme),
+            " stroke-dasharray=\"8 6\""
+        );
+        super::render_definitions(&mut output, &theme);
+        assert!(output.contains("markerWidth=\"10.125\" markerHeight=\"10.125\""));
+        assert!(output.contains("refX=\"9000\" refY=\"5000\" viewBox=\"0 0 10000 10000\""));
+        assert!(output.contains("d=\"M 0 0 L 10000 5000 L 0 10000 z\""));
+        Ok(())
+    }
+
+    #[test]
+    fn scales_the_icon_viewport_without_rewriting_its_local_geometry()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let diagram = stack_compiler::compile_bytes(
+            b"stack 1.0 diagram \"Icon\" { node a \"A\" { kind database } }",
+        )
+        .diagram
+        .ok_or("valid diagram")?;
+        let resources = Resources::resolve(&diagram, stack_theme::catalog(), &[])
+            .map_err(|error| error.reason())?;
+        let resolved = resources.node("a").ok_or("resolved node")?;
+        let mut output = String::new();
+        super::render_icon(
+            &mut output,
+            Rect {
+                x: -1250,
+                y: 267_800,
+                width: 208_300,
+                height: 72_000,
+            },
+            resolved,
+            resources.theme,
+        )
+        .map_err(|error| error.reason())?;
+        assert!(output.contains(
+            "<svg x=\"18.75\" y=\"291.8\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\""
+        ));
+        let body = super::embedded_svg_body(resolved.icon_svg).ok_or("icon body")?;
+        assert!(output.contains(body.trim()));
+        Ok(())
+    }
+
+    #[test]
+    fn serializes_the_scene_label_rectangle_without_repositioning()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let engine = crate::Engine::bundled();
+        let source =
+            b"stack 1.0 diagram \"Labels\" { node a \"A\" node b \"B\" edge a -> b \"request\" }";
+        let compiled = stack_compiler::compile_bytes(source);
+        let scene = crate::scene::layout(
+            &compiled.diagram.ok_or("valid diagram")?,
+            stack_theme::catalog(),
+        )?;
+        let rect = scene.edges[0].label_rect.ok_or("scene label geometry")?;
+        let output = engine.render(source)?.svg.ok_or("SVG document")?;
+        assert!(output.contains(&format!(
+            "<rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"4\"",
+            pixel_dimension(rect.x),
+            pixel_dimension(rect.y),
+            pixel_dimension(rect.width),
+            pixel_dimension(rect.height)
+        )));
+        Ok(())
     }
 }
diff --git a/crates/stack-engine/tests/fixtures/labelled-dag-regressions.json b/crates/stack-engine/tests/fixtures/labelled-dag-regressions.json
new file mode 100644
index 0000000..3b210db
--- /dev/null
+++ b/crates/stack-engine/tests/fixtures/labelled-dag-regressions.json
@@ -0,0 +1,422 @@
+[
+  {
+    "name": "dag-00",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-01",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n0 -> n1 \"Connection 0\" edge n1 -> n3 \"Connection 1\" edge n2 -> n3 \"Connection 2\" }"
+    }
+  },
+  {
+    "name": "dag-02",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n2 -> n3 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n1 -> n4 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-03",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n0 -> n5 \"Connection 0\" edge n1 -> n4 \"Connection 1\" edge n3 -> n5 \"Connection 2\" edge n2 -> n3 \"Connection 3\" edge n1 -> n2 \"Connection 4\" }"
+    }
+  },
+  {
+    "name": "dag-04",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n2 -> n5 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n3 -> n5 \"retry request after timeout\" edge n0 -> n5 \"retry request after timeout\" edge n0 -> n6 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-05",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n2 -> n5 \"Connection 0\" edge n1 -> n3 \"Connection 1\" edge n0 -> n1 \"Connection 2\" edge n0 -> n2 \"Connection 3\" edge n0 -> n3 \"Connection 4\" edge n4 -> n6 \"Connection 5\" edge n2 -> n4 \"Connection 6\" }"
+    }
+  },
+  {
+    "name": "dag-06",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-07",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n0 -> n2 \"Connection 0\" edge n0 -> n1 \"Connection 1\" edge n2 -> n3 \"Connection 2\" edge n0 -> n3 \"Connection 3\" edge n1 -> n3 \"Connection 4\" edge n1 -> n2 \"Connection 5\" }"
+    }
+  },
+  {
+    "name": "dag-08",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n1 -> n4 \"retry request after timeout\" edge n0 -> n4 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-09",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n3 -> n5 \"Connection 0\" edge n0 -> n1 \"Connection 1\" edge n0 -> n4 \"Connection 2\" edge n2 -> n5 \"Connection 3\" edge n0 -> n3 \"Connection 4\" edge n1 -> n4 \"Connection 5\" edge n1 -> n3 \"Connection 6\" edge n1 -> n5 \"Connection 7\" edge n4 -> n5 \"Connection 8\" edge n0 -> n2 \"Connection 9\" edge n0 -> n5 \"Connection 10\" }"
+    }
+  },
+  {
+    "name": "dag-10",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n0 -> n4 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n4 -> n6 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n3 -> n6 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n4 -> n5 \"retry request after timeout\" edge n5 -> n6 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n3 -> n5 \"retry request after timeout\" edge n1 -> n5 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-11",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n2 -> n5 \"Connection 0\" edge n0 -> n3 \"Connection 1\" edge n6 -> n7 \"Connection 2\" edge n5 -> n6 \"Connection 3\" edge n3 -> n6 \"Connection 4\" edge n1 -> n2 \"Connection 5\" edge n1 -> n6 \"Connection 6\" edge n4 -> n7 \"Connection 7\" edge n2 -> n3 \"Connection 8\" edge n5 -> n7 \"Connection 9\" edge n0 -> n6 \"Connection 10\" edge n3 -> n4 \"Connection 11\" edge n0 -> n7 \"Connection 12\" }"
+    }
+  },
+  {
+    "name": "dag-12",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-13",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n0 -> n2 \"Connection 0\" edge n2 -> n3 \"Connection 1\" edge n0 -> n1 \"Connection 2\" }"
+    }
+  },
+  {
+    "name": "dag-14",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n1 -> n4 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-15",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n1 -> n4 \"Connection 0\" edge n0 -> n1 \"Connection 1\" edge n3 -> n5 \"Connection 2\" edge n4 -> n5 \"Connection 3\" edge n0 -> n2 \"Connection 4\" }"
+    }
+  },
+  {
+    "name": "dag-16",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n2 -> n5 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n4 -> n6 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n6 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-17",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n0 -> n7 \"Connection 0\" edge n4 -> n5 \"Connection 1\" edge n6 -> n7 \"Connection 2\" edge n2 -> n4 \"Connection 3\" edge n1 -> n3 \"Connection 4\" edge n3 -> n5 \"Connection 5\" edge n0 -> n1 \"Connection 6\" }"
+    }
+  },
+  {
+    "name": "dag-18",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-19",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n0 -> n3 \"Connection 0\" edge n2 -> n3 \"Connection 1\" edge n1 -> n2 \"Connection 2\" edge n0 -> n2 \"Connection 3\" edge n0 -> n1 \"Connection 4\" edge n1 -> n3 \"Connection 5\" }"
+    }
+  },
+  {
+    "name": "dag-20",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n2 -> n3 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n4 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n4 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-21",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n3 -> n4 \"Connection 0\" edge n3 -> n5 \"Connection 1\" edge n1 -> n3 \"Connection 2\" edge n0 -> n4 \"Connection 3\" edge n0 -> n1 \"Connection 4\" edge n0 -> n2 \"Connection 5\" edge n1 -> n5 \"Connection 6\" edge n0 -> n5 \"Connection 7\" edge n0 -> n3 \"Connection 8\" edge n2 -> n5 \"Connection 9\" edge n1 -> n4 \"Connection 10\" }"
+    }
+  },
+  {
+    "name": "dag-22",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n3 -> n6 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n5 -> n6 \"retry request after timeout\" edge n0 -> n5 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n6 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n0 -> n4 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-23",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n1 -> n7 \"Connection 0\" edge n4 -> n6 \"Connection 1\" edge n3 -> n7 \"Connection 2\" edge n2 -> n5 \"Connection 3\" edge n1 -> n4 \"Connection 4\" edge n1 -> n2 \"Connection 5\" edge n1 -> n6 \"Connection 6\" edge n0 -> n7 \"Connection 7\" edge n2 -> n7 \"Connection 8\" edge n1 -> n5 \"Connection 9\" edge n3 -> n6 \"Connection 10\" edge n4 -> n5 \"Connection 11\" edge n1 -> n3 \"Connection 12\" }"
+    }
+  },
+  {
+    "name": "dag-24",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-25",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n1 -> n2 \"Connection 0\" edge n0 -> n1 \"Connection 1\" edge n1 -> n3 \"Connection 2\" }"
+    }
+  },
+  {
+    "name": "dag-26",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n0 -> n3 \"retry request after timeout\" edge n1 -> n4 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-27",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n1 -> n2 \"Connection 0\" edge n2 -> n3 \"Connection 1\" edge n1 -> n4 \"Connection 2\" edge n0 -> n3 \"Connection 3\" edge n4 -> n5 \"Connection 4\" }"
+    }
+  },
+  {
+    "name": "dag-28",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n0 -> n1 \"retry request after timeout\" edge n2 -> n6 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n4 -> n6 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-29",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n2 -> n5 \"Connection 0\" edge n1 -> n6 \"Connection 1\" edge n3 -> n7 \"Connection 2\" edge n2 -> n3 \"Connection 3\" edge n6 -> n7 \"Connection 4\" edge n0 -> n1 \"Connection 5\" edge n3 -> n5 \"Connection 6\" }"
+    }
+  },
+  {
+    "name": "dag-30",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n0 -> n1 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-31",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n1 -> n3 \"Connection 0\" edge n2 -> n3 \"Connection 1\" edge n0 -> n1 \"Connection 2\" edge n0 -> n3 \"Connection 3\" edge n1 -> n2 \"Connection 4\" edge n0 -> n2 \"Connection 5\" }"
+    }
+  },
+  {
+    "name": "dag-32",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n1 -> n4 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n4 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-33",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n2 -> n4 \"Connection 0\" edge n0 -> n3 \"Connection 1\" edge n3 -> n5 \"Connection 2\" edge n3 -> n4 \"Connection 3\" edge n0 -> n2 \"Connection 4\" edge n2 -> n5 \"Connection 5\" edge n1 -> n5 \"Connection 6\" edge n2 -> n3 \"Connection 7\" edge n1 -> n2 \"Connection 8\" edge n0 -> n1 \"Connection 9\" edge n0 -> n4 \"Connection 10\" }"
+    }
+  },
+  {
+    "name": "dag-34",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n2 -> n6 \"retry request after timeout\" edge n0 -> n6 \"retry request after timeout\" edge n2 -> n5 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n3 -> n5 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n4 -> n6 \"retry request after timeout\" edge n5 -> n6 \"retry request after timeout\" edge n3 -> n6 \"retry request after timeout\" edge n4 -> n5 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-35",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n0 -> n1 \"Connection 0\" edge n0 -> n4 \"Connection 1\" edge n2 -> n6 \"Connection 2\" edge n1 -> n5 \"Connection 3\" edge n1 -> n6 \"Connection 4\" edge n0 -> n2 \"Connection 5\" edge n2 -> n7 \"Connection 6\" edge n1 -> n4 \"Connection 7\" edge n2 -> n5 \"Connection 8\" edge n1 -> n2 \"Connection 9\" edge n3 -> n7 \"Connection 10\" edge n2 -> n4 \"Connection 11\" edge n3 -> n5 \"Connection 12\" }"
+    }
+  },
+  {
+    "name": "dag-36",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-37",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n1 -> n3 \"Connection 0\" edge n1 -> n2 \"Connection 1\" edge n0 -> n3 \"Connection 2\" }"
+    }
+  },
+  {
+    "name": "dag-38",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n1 -> n3 \"retry request after timeout\" edge n1 -> n4 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-39",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n1 -> n3 \"Connection 0\" edge n0 -> n5 \"Connection 1\" edge n2 -> n4 \"Connection 2\" edge n2 -> n3 \"Connection 3\" edge n2 -> n5 \"Connection 4\" }"
+    }
+  },
+  {
+    "name": "dag-40",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n1 -> n3 \"retry request after timeout\" edge n5 -> n6 \"retry request after timeout\" edge n3 -> n6 \"retry request after timeout\" edge n0 -> n6 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n0 -> n5 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-41",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n0 -> n6 \"Connection 0\" edge n0 -> n4 \"Connection 1\" edge n2 -> n5 \"Connection 2\" edge n4 -> n6 \"Connection 3\" edge n0 -> n7 \"Connection 4\" edge n5 -> n7 \"Connection 5\" edge n1 -> n4 \"Connection 6\" }"
+    }
+  },
+  {
+    "name": "dag-42",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n0 -> n1 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-43",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n0 -> n3 \"Connection 0\" edge n0 -> n2 \"Connection 1\" edge n1 -> n2 \"Connection 2\" edge n2 -> n3 \"Connection 3\" edge n0 -> n1 \"Connection 4\" edge n1 -> n3 \"Connection 5\" }"
+    }
+  },
+  {
+    "name": "dag-44",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n4 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n1 -> n4 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-45",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n0 -> n1 \"Connection 0\" edge n4 -> n5 \"Connection 1\" edge n1 -> n4 \"Connection 2\" edge n0 -> n5 \"Connection 3\" edge n0 -> n4 \"Connection 4\" edge n3 -> n5 \"Connection 5\" edge n0 -> n2 \"Connection 6\" edge n2 -> n4 \"Connection 7\" edge n2 -> n3 \"Connection 8\" edge n0 -> n3 \"Connection 9\" edge n2 -> n5 \"Connection 10\" }"
+    }
+  },
+  {
+    "name": "dag-46",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n0 -> n1 \"retry request after timeout\" edge n4 -> n5 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n4 -> n6 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n1 -> n6 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n3 -> n5 \"retry request after timeout\" edge n2 -> n5 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-47",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n3 -> n7 \"Connection 0\" edge n2 -> n4 \"Connection 1\" edge n2 -> n5 \"Connection 2\" edge n0 -> n6 \"Connection 3\" edge n5 -> n6 \"Connection 4\" edge n1 -> n6 \"Connection 5\" edge n2 -> n7 \"Connection 6\" edge n6 -> n7 \"Connection 7\" edge n1 -> n4 \"Connection 8\" edge n0 -> n1 \"Connection 9\" edge n4 -> n5 \"Connection 10\" edge n0 -> n3 \"Connection 11\" edge n1 -> n3 \"Connection 12\" }"
+    }
+  },
+  {
+    "name": "dag-48",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n0 -> n1 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-49",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n0 -> n3 \"Connection 0\" edge n0 -> n2 \"Connection 1\" edge n0 -> n1 \"Connection 2\" }"
+    }
+  },
+  {
+    "name": "dag-50",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n0 -> n4 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-51",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n1 -> n5 \"Connection 0\" edge n0 -> n4 \"Connection 1\" edge n2 -> n3 \"Connection 2\" edge n0 -> n3 \"Connection 3\" edge n0 -> n1 \"Connection 4\" }"
+    }
+  },
+  {
+    "name": "dag-52",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n0 -> n4 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n0 -> n5 \"retry request after timeout\" edge n5 -> n6 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-53",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n5 -> n7 \"Connection 0\" edge n0 -> n3 \"Connection 1\" edge n1 -> n2 \"Connection 2\" edge n3 -> n7 \"Connection 3\" edge n3 -> n5 \"Connection 4\" edge n5 -> n6 \"Connection 5\" edge n1 -> n7 \"Connection 6\" }"
+    }
+  },
+  {
+    "name": "dag-54",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" edge n1 -> n2 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-55",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" edge n2 -> n3 \"Connection 0\" edge n0 -> n1 \"Connection 1\" edge n1 -> n3 \"Connection 2\" edge n0 -> n2 \"Connection 3\" edge n0 -> n3 \"Connection 4\" edge n1 -> n2 \"Connection 5\" }"
+    }
+  },
+  {
+    "name": "dag-56",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" edge n0 -> n1 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n3 \"retry request after timeout\" edge n0 -> n4 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n1 -> n4 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-57",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction right } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" edge n2 -> n3 \"Connection 0\" edge n3 -> n5 \"Connection 1\" edge n1 -> n3 \"Connection 2\" edge n1 -> n2 \"Connection 3\" edge n1 -> n5 \"Connection 4\" edge n3 -> n4 \"Connection 5\" edge n2 -> n5 \"Connection 6\" edge n2 -> n4 \"Connection 7\" edge n0 -> n3 \"Connection 8\" edge n0 -> n5 \"Connection 9\" edge n1 -> n4 \"Connection 10\" }"
+    }
+  },
+  {
+    "name": "dag-58",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" { layout { direction down } node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" edge n2 -> n4 \"retry request after timeout\" edge n0 -> n6 \"retry request after timeout\" edge n0 -> n5 \"retry request after timeout\" edge n0 -> n1 \"retry request after timeout\" edge n0 -> n2 \"retry request after timeout\" edge n3 -> n4 \"retry request after timeout\" edge n4 -> n5 \"retry request after timeout\" edge n1 -> n5 \"retry request after timeout\" edge n1 -> n2 \"retry request after timeout\" edge n2 -> n3 \"retry request after timeout\" edge n1 -> n3 \"retry request after timeout\" edge n3 -> n5 \"retry request after timeout\" }"
+    }
+  },
+  {
+    "name": "dag-59",
+    "input": {
+      "kind": "string",
+      "value": "stack 1.0 diagram \"Probe\" {  node n0 \"Node 0\" node n1 \"Node 1\" node n2 \"Node 2\" node n3 \"Node 3\" node n4 \"Node 4\" node n5 \"Node 5\" node n6 \"Node 6\" node n7 \"Node 7\" edge n2 -> n5 \"Connection 0\" edge n3 -> n6 \"Connection 1\" edge n1 -> n2 \"Connection 2\" edge n1 -> n5 \"Connection 3\" edge n4 -> n6 \"Connection 4\" edge n2 -> n6 \"Connection 5\" edge n1 -> n6 \"Connection 6\" edge n2 -> n4 \"Connection 7\" edge n0 -> n4 \"Connection 8\" edge n0 -> n6 \"Connection 9\" edge n0 -> n1 \"Connection 10\" edge n3 -> n7 \"Connection 11\" edge n1 -> n7 \"Connection 12\" }"
+    }
+  }
+]
diff --git a/crates/stack-engine/tests/layout_corpus.rs b/crates/stack-engine/tests/layout_corpus.rs
index 9406681..9b7a36a 100644
--- a/crates/stack-engine/tests/layout_corpus.rs
+++ b/crates/stack-engine/tests/layout_corpus.rs
@@ -79,6 +79,28 @@ struct ProviderAssetInput {
     svg: String,
 }
 
+#[test]
+fn svg_viewport_and_geometry_use_the_same_pixel_units() -> Result<(), Box<dyn Error>> {
+    let root = repository_root();
+    let catalog = load_catalog(&root)?;
+    let case = &catalog.cases[0];
+    let source = fs::read(root.join("layout-corpus").join(&case.source))?;
+    let svg = Engine::bundled()
+        .render(&source)?
+        .svg
+        .ok_or("missing SVG")?;
+    let document = roxmltree::Document::parse(&svg)?;
+    let element = document.root_element();
+    let width = element.attribute("width").ok_or("missing width")?;
+    let height = element.attribute("height").ok_or("missing height")?;
+    assert_eq!(
+        element.attribute("viewBox"),
+        Some(format!("0 0 {width} {height}").as_str())
+    );
+    validate_svg(case, &svg)?;
+    Ok(())
+}
+
 #[test]
 fn layout_corpus_matches_approved_snapshots() -> Result<(), Box<dyn Error>> {
     let root = repository_root();
@@ -327,7 +349,7 @@ fn validate_svg(case: &LayoutCase, svg: &str) -> Result<(), Box<dyn Error>> {
         .attribute("viewBox")
         .ok_or_else(|| format!("{} has no viewBox", case.id))?
         .split_ascii_whitespace()
-        .map(str::parse::<i64>)
+        .map(svg_dimension_milli_px)
         .collect::<Result<Vec<_>, _>>()?;
     if view_box.len() != 4
         || view_box[0] != 0
@@ -403,6 +425,46 @@ fn validate_svg(case: &LayoutCase, svg: &str) -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+fn svg_dimension_milli_px(value: &str) -> Result<i64, Box<dyn Error>> {
+    let (whole, fraction) = value.split_once('.').unwrap_or((value, ""));
+    if whole.is_empty()
+        || !whole.bytes().all(|byte| byte.is_ascii_digit())
+        || fraction.len() > 3
+        || !fraction.bytes().all(|byte| byte.is_ascii_digit())
+        || (value.contains('.') && fraction.is_empty())
+    {
+        return Err("unsupported SVG pixel dimension".into());
+    }
+    let whole: i64 = whole.parse()?;
+    let fraction: i64 = format!("{fraction:0<3}").parse()?;
+    whole
+        .checked_mul(1000)
+        .and_then(|whole| whole.checked_add(fraction))
+        .ok_or_else(|| "SVG pixel dimension overflow".into())
+}
+
+#[test]
+fn svg_pixel_dimensions_preserve_exact_millipixels() -> Result<(), Box<dyn Error>> {
+    for (value, expected) in [("0", 0), ("733.7", 733_700), ("1.001", 1001)] {
+        assert_eq!(svg_dimension_milli_px(value)?, expected);
+    }
+    for value in [
+        "",
+        ".1",
+        "1.",
+        "1.0001",
+        "NaN",
+        "inf",
+        "1e3",
+        "-1",
+        "1.2.3",
+        "9223372036854776",
+    ] {
+        assert!(svg_dimension_milli_px(value).is_err(), "{value}");
+    }
+    Ok(())
+}
+
 fn assert_inventory(root: &Path, catalog: &LayoutCatalog) -> Result<(), Box<dyn Error>> {
     let expected_sources = catalog
         .cases
diff --git a/docs/decisions/0005-serialize-safe-standalone-svg.md b/docs/decisions/0005-serialize-safe-standalone-svg.md
index a225eca..015fbf5 100644
--- a/docs/decisions/0005-serialize-safe-standalone-svg.md
+++ b/docs/decisions/0005-serialize-safe-standalone-svg.md
@@ -4,6 +4,11 @@
 
 Accepted
 
+[ADR-0008](0008-compose-graphs-with-reserved-label-geometry.md) proposes replacing
+the original SVG millipixel user space with exact decimal CSS pixels and moving
+edge-label placement into the scene. That unreleased candidate preserves the
+integer scene and the safety/resource boundaries below.
+
 ## Context
 
 Native and browser consumers need the same portable render artifact. Depending on a DOM, host fonts, external images, or runtime resource discovery would make output target-dependent and would weaken the pure engine boundary. Authored labels and details are untrusted text, and catalog icons must not introduce script or external references into the generated document.
diff --git a/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md b/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md
new file mode 100644
index 0000000..ac03994
--- /dev/null
+++ b/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md
@@ -0,0 +1,101 @@
+# ADR-0008: Compose graphs with reserved label geometry
+
+## Status
+
+Proposed; implemented as an unreleased visual-review candidate. Approved scene
+and SVG references remain unchanged until visual agreement.
+
+## Context
+
+Declaration-order placement can make connected elements run backwards and
+flatten nested architectures into long strips. Moving labels after routing can
+put them across a route, outside the canvas, or far from the edge they describe.
+Node-interior checks alone also admit paths along a block's border.
+
+Collision freedom is a hard requirement, not a score that can be traded for a
+smaller canvas. Alignment, spacing, bends, crossings, and overall composition
+still require human review; passing geometry checks does not prove beauty.
+
+## Decision
+
+Keep integer, host-independent bottom-up measurement and top-down placement.
+Project descendant connections onto direct children of each scope. Collapse
+authored disjoint same-rank sets, then strongly connected components, and use
+longest-path depth in the resulting DAG to form layers. Declaration index breaks
+ties. Authored order sorts members within a layer; diagnostics use the actual
+resolved scope direction and cross-axis positions.
+
+Center shorter layers on the common cross-axis. Measure labels with the selected
+catalog before allocating inter-layer and within-layer spacing. Reserve a
+right-side label band for vertical compositions. Explicit directions remain
+exact and independent between scopes. For connected automatic scopes, compare
+right and down by maximum dimension, then area, with the historical direction as
+the tie-break. Disconnected scopes and simple unlabeled pairs keep the historical
+policy. Bidirectional and association endpoints currently contribute their stored
+from-to order to composition; marker semantics remain unchanged.
+
+Route through a shared rectilinear visibility grid using four midpoint ports and
+normal terminal stubs. Avoid closed node envelopes with an 8px clearance and
+measured diagram/group titles. Penalize bends, shared lengths, and crossings with
+deterministic integer costs. Crossings are discouraged, not prohibited.
+
+Treat group frames as finite perimeter obstacles, not filled rectangles. A route
+may cross a side normally, but must not run parallel within its clearance band
+or turn close to a frame. Reserve 18px between centerlines, conservatively
+covering a 16px painted gap with current core strokes. Include corner clearance
+and apply the same rules to terminal stubs; node-terminal exceptions do not
+exempt group frames. Measure 40px group padding to leave room for these internal
+lanes, and use that same padding for group-title serialization.
+
+The scene owns both each label rectangle and its attachment on an interior point
+of its own route segment. Candidate positions are finite, exactly 8px from that
+segment, and prefer above horizontal or right of vertical segments. Reject
+contact with nodes, titles, other labels, and every route's stroke envelope.
+Commit placement only when every label fits. SVG serialization must not relocate
+labels or hide route sections beneath label backgrounds.
+
+Reserve separate 9px finite perimeter bands when placing labels, guaranteeing
+at least 8px between label backgrounds and current painted group frames. Do not
+pass these label-only obstacles to the router: normal frame crossings must stay
+possible. Validate label-frame separation against the emitted SVG as well.
+
+Keep millipixel integers inside the scene, but serialize diagram-space SVG
+coordinates, viewport, strokes, dashes, and font sizes in CSS pixels using exact
+decimal strings with at most three fractional digits. Large millipixel SVG user
+coordinates can trigger browser font-size clamping and shape rasterization
+defects even when the geometric scene is valid. Nested icon bodies retain their
+own local coordinate systems; marker viewport dimensions use diagram pixels.
+The independent SVG checker converts strict decimal pixels back to integer
+millipixels without floating-point rounding. Browser-rendered shape and font
+checks supplement this mathematical geometry validation.
+
+If jointly placing labels on the routed graph fails, route and label edges in
+descending label-width order, freezing prior labels as obstacles for later
+routes. If the shortest route has no label position, try at most sixteen normal
+source/target port pairs in deterministic length, bend-count, and path order.
+Keep previous paths and label boxes unchanged and restore authored edge order
+in the output. Validate the complete scene afterwards. If necessary,
+repeat composition with gap multipliers 2 and 3 and symmetric exterior label
+bands. The entire search is bounded to three composition attempts; it never uses
+elapsed time or accepts colliding fallback geometry.
+
+## Consequences
+
+- This candidate replaces the automatic placement policy in ADR-0003, boundary
+  contact and midpoint-label policy in ADR-0004, and SVG-owned label placement in
+  ADR-0005, including its millipixel SVG user-space policy; their remaining
+  integer-scene, semantic, diagnostic, and safety contracts
+  remain intact.
+- No syntax, public API, theme contract, dependency, or host capability is added.
+- Native/WASM parity, semantic and rank tests, independent final-SVG collision
+  gates, representative runtime budgets, and adversarial input regressions are
+  required in addition to visual review.
+- The frame gate reads the emitted rectangle and both actual stroke widths. It
+  requires a 16px painted gap, checks all four finite sides and nearby corners,
+  and permits normal crossings away from corners. Hidden, transformed, missing,
+  or otherwise unmeasured frame geometry fails closed.
+- Exact snapshots intentionally detect the changed output until new references
+  are explicitly approved. They are not automatically replaced by this work.
+- Finite heuristics are not a proof of feasible placement for every valid graph.
+  A failure must remain explicit and become a regression fixture, never a hidden
+  overlap, missing edge, or unmeasured text box.
diff --git a/tests/wasm.test.mjs b/tests/wasm.test.mjs
index edcc98c..ae18f2f 100644
--- a/tests/wasm.test.mjs
+++ b/tests/wasm.test.mjs
@@ -38,8 +38,8 @@ function browserInput(input) {
   return Uint8Array.from(input.value);
 }
 
-function wasmOutputs() {
-  return cases.map((fixture) => {
+function wasmOutputs(fixtures = cases) {
+  return fixtures.map((fixture) => {
     const source = browserInput(fixture.input);
     return {
       name: fixture.name,
@@ -106,6 +106,21 @@ test("browser exports match native engine results for shared fixtures", () => {
   assert.deepEqual(wasmOutputs(), native);
 });
 
+test("labelled DAG regressions render identically in native and WebAssembly", () => {
+  const path = join(repositoryRoot, "crates/stack-engine/tests/fixtures/labelled-dag-regressions.json");
+  const fixtures = JSON.parse(readFileSync(path, "utf8"));
+  assert.equal(fixtures.length, 60);
+  const native = JSON.parse(execFileSync("cargo", [
+    "run", "--quiet", "--locked", "-p", "stack-engine-wasm", "--example", "native-parity", "--", path,
+  ], { cwd: repositoryRoot, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 }));
+  const browser = wasmOutputs(fixtures);
+  for (const output of browser) {
+    assert.ok(output.render.svg, `${output.name}: missing SVG`);
+    assert.deepEqual(output.render.diagnostics, [], `${output.name}: diagnostics`);
+  }
+  assert.deepEqual(browser, native);
+});
+
 test("browser language intelligence matches native results for shared fixtures", () => {
   const native = JSON.parse(
     execFileSync(

From d31633ac9c9f9127445028b25b1f1c9930f4f02a Mon Sep 17 00:00:00 2001
From: konojunya <junya03dance@gmail.com>
Date: Sun, 6 Sep 2026 11:42:59 +0900
Subject: [PATCH 3/3] Prepare graph-aware rendering release 0.8.0 with coverage
 and package regressions

---
 Cargo.lock                                    |   8 +-
 Cargo.toml                                    |   2 +-
 README.md                                     |   4 +-
 THIRD_PARTY_LICENSES.md                       |   2 +-
 crates/stack-engine-wasm/Cargo.toml           |   2 +-
 crates/stack-engine/Cargo.toml                |   2 +-
 crates/stack-engine/README.md                 |   2 +-
 crates/stack-engine/THIRD_PARTY_LICENSES.md   |   2 +-
 crates/stack-engine/src/labels.rs             | 130 +++++--
 crates/stack-engine/src/layout_quality.rs     | 333 +++++++++++++++++-
 crates/stack-engine/src/lib.rs                |  37 +-
 crates/stack-engine/src/placement_quality.rs  |   6 +
 crates/stack-engine/src/resources.rs          |  59 ++++
 crates/stack-engine/src/routing.rs            |  78 ++++
 crates/stack-engine/src/svg.rs                |  47 ++-
 crates/stack-engine/tests/render_snapshots.rs |   2 +-
 .../snapshots/complete-semantics.scene.txt    |  42 +--
 .../snapshots/render/complete-semantics.svg   | 135 ++++---
 .../render/default-normalization.svg          |  24 +-
 .../snapshots/render/explicit-core-icon.svg   |  18 +-
 .../stack-formatter/THIRD_PARTY_LICENSES.md   |   2 +-
 docs/cargo-releasing.md                       |   4 +-
 ...ose-graphs-with-reserved-label-geometry.md |  15 +-
 docs/dependency-audit.md                      |   4 +-
 docs/releases/v0.8.0.md                       |  16 +
 layout-corpus/catalog.json                    |   2 +-
 layout-corpus/snapshots/dense-commerce.svg    | 188 +++++-----
 .../snapshots/fanout-cross-edges.svg          | 119 ++++---
 layout-corpus/snapshots/medium-group-flow.svg |  85 +++--
 .../snapshots/multilingual-long-labels.svg    |  61 ++--
 layout-corpus/snapshots/nested-platform.svg   | 105 +++---
 .../snapshots/provider-icon-boundary.svg      |  44 +--
 .../snapshots/small-request-path.svg          |  41 ++-
 package-lock.json                             |   6 +-
 package.json                                  |   2 +-
 packages/engine/THIRD_PARTY_LICENSES.md       |   2 +-
 packages/engine/package.json                  |   2 +-
 scripts/validate-svg.py                       |   4 +-
 tests/wasm.test.mjs                           |   8 +-
 39 files changed, 1139 insertions(+), 506 deletions(-)
 create mode 100644 docs/releases/v0.8.0.md

diff --git a/Cargo.lock b/Cargo.lock
index c458df8..a5e4228 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -196,7 +196,7 @@ checksum = "bdba45c0f7a85ef0ec0bfb766b387dbd90fc6141237ac74b559d08a424750bc6"
 
 [[package]]
 name = "stack-engine"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "roxmltree",
  "serde",
@@ -209,7 +209,7 @@ dependencies = [
 
 [[package]]
 name = "stack-engine-wasm"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "js-sys",
  "serde",
@@ -229,9 +229,9 @@ dependencies = [
 
 [[package]]
 name = "stack-theme"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f98e0418c819d61897beded19d5333b4f6c7a8dcf1be46d0a8c62409ff2e6db7"
+checksum = "87b3f19b223133b8da80e0a10c4cf5a7ec3024fb48105c1f9f2e0d635a9e8d56"
 dependencies = [
  "serde",
  "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index ac7051b..8102d15 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,4 +15,4 @@ serde_json = "=1.0.151"
 sha2 = "=0.11.0"
 stack-compiler = "=0.1.0"
 stack-formatter = { path = "crates/stack-formatter", version = "=0.1.0" }
-stack-theme = "=0.5.0"
+stack-theme = "=0.6.0"
diff --git a/README.md b/README.md
index 161c101..dfafbf2 100644
--- a/README.md
+++ b/README.md
@@ -53,6 +53,8 @@ npm run layout:gallery
 
 The review-first snapshot policy and corpus contract are documented in [`layout-corpus/README.md`](./layout-corpus/README.md).
 
+The independent text, edge, and frame quality gates run under the `conformance` feature with the repository's source corpus. CI runs these gates explicitly and includes them in its 95% line, function, and region coverage checks. Packaged crate unit tests do not require the repository-only corpus. See the [0.8.0 release notes](./docs/releases/v0.8.0.md) for the approved layout and SVG changes.
+
 `stack-formatter` is pure and accepts source bytes or UTF-8 text. Lexical and syntax errors return diagnostics without formatted output. Syntactically valid source remains formattable when semantic diagnostics exist.
 
 `stack-engine` exposes byte-oriented `format`, `check`, and `render` methods plus UTF-8 `completion` and `hover` methods through an engine bound to the embedded or a caller-provided validated catalog. Language-intelligence results implement schema version 1.0 from the pinned compiler and echo the caller's document version. The Engine derives completion entries from its core theme catalog and validated provider packs, while the compiler remains the single owner of grammar, context, diagnostics, hover semantics, and text edits. `ProviderPack::new` accepts a typed user-imported manifest and caller-owned SVG strings, verifies exact asset hashes and safe SVG structure, and computes a deterministic content revision before `Engine::with_provider_packs` can resolve namespaced IDs. Every normal format, check, or render output carries engine, authored language, theme catalog version, and theme catalog revision metadata. User-source failures stay in ordered portable diagnostics. Invalid provided catalogs or provider packs, invalid language-intelligence positions, and violated normalized pipeline invariants use a separate operational-error channel. Checks and renders resolve the requested theme and provider packs, validate deterministic integer geometry, and route ordered edges outside node interiors. Missing themes and icons produce source-mapped `STK6001` and `STK5001` warnings while a fallback SVG remains available. An unsatisfied authored order hint produces `STK4001` at its source-map range; a satisfied hint does not.
@@ -72,7 +74,7 @@ Public npm releases are produced from GitHub Releases after the repository check
 - [`docs/decisions/0005-serialize-safe-standalone-svg.md`](./docs/decisions/0005-serialize-safe-standalone-svg.md)
 - [`docs/decisions/0006-expose-one-typed-browser-wasm-adapter.md`](./docs/decisions/0006-expose-one-typed-browser-wasm-adapter.md)
 - [`docs/decisions/0007-adapt-language-intelligence-with-engine-catalogs.md`](./docs/decisions/0007-adapt-language-intelligence-with-engine-catalogs.md)
-- [`docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md`](./docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md) — unreleased visual-review candidate
+- [`docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md`](./docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md)
 - [`docs/dependency-audit.md`](./docs/dependency-audit.md)
 
 ## Licensing
diff --git a/THIRD_PARTY_LICENSES.md b/THIRD_PARTY_LICENSES.md
index 23a695b..179d1f5 100644
--- a/THIRD_PARTY_LICENSES.md
+++ b/THIRD_PARTY_LICENSES.md
@@ -5,7 +5,7 @@
 | Component | Revision | License | Source | Notes |
 | --- | --- | --- | --- | --- |
 | `stack-compiler` | `0.1.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/compiler> | Unmodified Rust dependency; its license and notice obligations apply to distributions that include it. |
-| `stack-theme` | `0.5.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> | Unmodified Rust dependency with repository-authored core assets and the asset-free provider-pack contract. |
+| `stack-theme` | `0.6.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> | Unmodified Rust dependency with repository-authored core assets and the asset-free provider-pack contract. |
 | `roxmltree` | `0.21.1` | MIT OR Apache-2.0 | <https://github.com/RazrFalcon/roxmltree> | Parses caller-owned processed provider SVG before allowlisted in-memory embedding. |
 | `sha2`, `digest`, `block-buffer`, `crypto-common`, `hybrid-array`, `const-oid`, `typenum` | `0.11.0`, `0.11.3`, `0.12.1`, `0.2.2`, `0.4.14`, `0.10.2`, `1.20.1` | MIT OR Apache-2.0 | <https://github.com/RustCrypto> | Verifies provider asset hashes and computes deterministic provider-pack revisions. |
 | `libc` / `cpufeatures` | `0.2.189`, `0.3.1` | MIT OR Apache-2.0 | <https://github.com/rust-lang/libc>, <https://github.com/RustCrypto/utils> | Target-specific SHA-256 acceleration support. |
diff --git a/crates/stack-engine-wasm/Cargo.toml b/crates/stack-engine-wasm/Cargo.toml
index edecb8f..8c84271 100644
--- a/crates/stack-engine-wasm/Cargo.toml
+++ b/crates/stack-engine-wasm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "stack-engine-wasm"
-version = "0.7.0"
+version = "0.8.0"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
diff --git a/crates/stack-engine/Cargo.toml b/crates/stack-engine/Cargo.toml
index d99e8c5..1297d15 100644
--- a/crates/stack-engine/Cargo.toml
+++ b/crates/stack-engine/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "stack-engine"
-version = "0.7.0"
+version = "0.8.0"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
diff --git a/crates/stack-engine/README.md b/crates/stack-engine/README.md
index 6834e4f..618e058 100644
--- a/crates/stack-engine/README.md
+++ b/crates/stack-engine/README.md
@@ -4,7 +4,7 @@ Pure Rust layout and SVG rendering for Stack diagrams. The engine reuses the reg
 
 ```toml
 [dependencies]
-stack-engine = "=0.7.0"
+stack-engine = "=0.8.0"
 ```
 
 Rust 1.85 or newer is supported. See the [API documentation](https://docs.rs/stack-engine) and [repository documentation](https://github.com/stack-sh/engine) for rendering, limits, and compatibility. The browser adapter is distributed separately as `@stack-sh/engine` on npm; this crate is the native library.
diff --git a/crates/stack-engine/THIRD_PARTY_LICENSES.md b/crates/stack-engine/THIRD_PARTY_LICENSES.md
index 23a695b..179d1f5 100644
--- a/crates/stack-engine/THIRD_PARTY_LICENSES.md
+++ b/crates/stack-engine/THIRD_PARTY_LICENSES.md
@@ -5,7 +5,7 @@
 | Component | Revision | License | Source | Notes |
 | --- | --- | --- | --- | --- |
 | `stack-compiler` | `0.1.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/compiler> | Unmodified Rust dependency; its license and notice obligations apply to distributions that include it. |
-| `stack-theme` | `0.5.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> | Unmodified Rust dependency with repository-authored core assets and the asset-free provider-pack contract. |
+| `stack-theme` | `0.6.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> | Unmodified Rust dependency with repository-authored core assets and the asset-free provider-pack contract. |
 | `roxmltree` | `0.21.1` | MIT OR Apache-2.0 | <https://github.com/RazrFalcon/roxmltree> | Parses caller-owned processed provider SVG before allowlisted in-memory embedding. |
 | `sha2`, `digest`, `block-buffer`, `crypto-common`, `hybrid-array`, `const-oid`, `typenum` | `0.11.0`, `0.11.3`, `0.12.1`, `0.2.2`, `0.4.14`, `0.10.2`, `1.20.1` | MIT OR Apache-2.0 | <https://github.com/RustCrypto> | Verifies provider asset hashes and computes deterministic provider-pack revisions. |
 | `libc` / `cpufeatures` | `0.2.189`, `0.3.1` | MIT OR Apache-2.0 | <https://github.com/rust-lang/libc>, <https://github.com/RustCrypto/utils> | Target-specific SHA-256 acceleration support. |
diff --git a/crates/stack-engine/src/labels.rs b/crates/stack-engine/src/labels.rs
index e095f8d..6629679 100644
--- a/crates/stack-engine/src/labels.rs
+++ b/crates/stack-engine/src/labels.rs
@@ -11,6 +11,11 @@ const HORIZONTAL_PADDING: i64 = 6_000;
 const VERTICAL_PADDING: i64 = 4_000;
 const ROUTE_GAP: i64 = 8_000;
 
+// Preserve core geometry while keeping labels outside thicker custom strokes.
+fn route_gap(stroke_width: i64) -> i64 {
+    ROUTE_GAP.max(stroke_width / 2 + stroke_width % 2 + 1_000)
+}
+
 #[derive(Clone, Copy)]
 struct Placement {
     rect: Rect,
@@ -53,7 +58,7 @@ pub(crate) fn place(
     let stroke_width = i64::from(theme.connector.width_milli_px);
 
     for (index, size) in order {
-        let placement = candidates(&edges[index].path, size, bounds)
+        let placement = candidates(&edges[index].path, size, bounds, route_gap(stroke_width))
             .into_iter()
             .find(|candidate| rect_is_clear(candidate.rect, bounds, &occupied, edges, stroke_width))
             .ok_or(RoutingError)?;
@@ -87,19 +92,24 @@ pub(crate) fn place_next(
     occupied.extend_from_slice(fixed_text);
     occupied.extend(previous.iter().filter_map(|edge| edge.label_rect));
     let stroke_width = i64::from(theme.connector.width_milli_px);
-    let placement = candidates(&edge.path, dimensions(label, theme, metrics), bounds)
-        .into_iter()
-        .find(|candidate| {
-            rect_is_clear(candidate.rect, bounds, &occupied, previous, stroke_width)
-                && rect_is_clear(
-                    candidate.rect,
-                    bounds,
-                    &[],
-                    std::slice::from_ref(edge),
-                    stroke_width,
-                )
-        })
-        .ok_or(RoutingError)?;
+    let placement = candidates(
+        &edge.path,
+        dimensions(label, theme, metrics),
+        bounds,
+        route_gap(stroke_width),
+    )
+    .into_iter()
+    .find(|candidate| {
+        rect_is_clear(candidate.rect, bounds, &occupied, previous, stroke_width)
+            && rect_is_clear(
+                candidate.rect,
+                bounds,
+                &[],
+                std::slice::from_ref(edge),
+                stroke_width,
+            )
+    })
+    .ok_or(RoutingError)?;
     edge.label_rect = Some(placement.rect);
     edge.label_anchor = Some(placement.attachment);
     Ok(())
@@ -119,10 +129,15 @@ pub(crate) fn geometry_is_valid(
             (None, None, None) => {}
             (Some(_), Some(rect), Some(attachment)) => {
                 if !rect_is_clear(rect, bounds, &occupied, edges, stroke_width)
-                    || !edge
-                        .path
-                        .windows(2)
-                        .any(|segment| is_adjacent(rect, attachment, segment[0], segment[1]))
+                    || !edge.path.windows(2).any(|segment| {
+                        is_adjacent(
+                            rect,
+                            attachment,
+                            segment[0],
+                            segment[1],
+                            route_gap(stroke_width),
+                        )
+                    })
                 {
                     return false;
                 }
@@ -134,7 +149,7 @@ pub(crate) fn geometry_is_valid(
     true
 }
 
-fn candidates(path: &[Point], size: Rect, bounds: Rect) -> Vec<Placement> {
+fn candidates(path: &[Point], size: Rect, bounds: Rect, gap: i64) -> Vec<Placement> {
     let mut segments = path.windows(2).enumerate().collect::<Vec<_>>();
     segments.sort_by_key(|(index, segment)| {
         (
@@ -151,7 +166,7 @@ fn candidates(path: &[Point], size: Rect, bounds: Rect) -> Vec<Placement> {
         }
         if start.y == end.y {
             let positions = axis_positions(start.x, end.x, size.width, bounds.x, bounds.width);
-            for y in [start.y - ROUTE_GAP - size.height, start.y + ROUTE_GAP] {
+            for y in [start.y - gap - size.height, start.y + gap] {
                 for &x in &positions {
                     candidates.push(Placement {
                         rect: Rect {
@@ -165,7 +180,7 @@ fn candidates(path: &[Point], size: Rect, bounds: Rect) -> Vec<Placement> {
             }
         } else if start.x == end.x {
             let positions = axis_positions(start.y, end.y, size.height, bounds.y, bounds.height);
-            for x in [start.x + ROUTE_GAP, start.x - ROUTE_GAP - size.width] {
+            for x in [start.x + gap, start.x - gap - size.width] {
                 for &y in &positions {
                     candidates.push(Placement {
                         rect: Rect {
@@ -207,21 +222,19 @@ fn axis_positions(start: i64, end: i64, size: i64, origin: i64, extent: i64) ->
     positions
 }
 
-fn is_adjacent(rect: Rect, attachment: Point, start: Point, end: Point) -> bool {
+fn is_adjacent(rect: Rect, attachment: Point, start: Point, end: Point, gap: i64) -> bool {
     if start.y == end.y && start.x != end.x {
         attachment.y == start.y
             && attachment.x > start.x.min(end.x)
             && attachment.x < start.x.max(end.x)
             && attachment.x == rect.x + rect.width / 2
-            && (rect.y + rect.height + ROUTE_GAP == attachment.y
-                || rect.y - ROUTE_GAP == attachment.y)
+            && (rect.y + rect.height + gap == attachment.y || rect.y - gap == attachment.y)
     } else if start.x == end.x && start.y != end.y {
         attachment.x == start.x
             && attachment.y > start.y.min(end.y)
             && attachment.y < start.y.max(end.y)
             && attachment.y == rect.y + rect.height / 2
-            && (rect.x - ROUTE_GAP == attachment.x
-                || rect.x + rect.width + ROUTE_GAP == attachment.x)
+            && (rect.x - gap == attachment.x || rect.x + rect.width + gap == attachment.x)
     } else {
         false
     }
@@ -356,6 +369,71 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn wide_connector_labels_clear_their_own_painted_stroke() -> TestResult {
+        let (theme, metrics) = resources()?;
+        for width in [1_500, 15_000, 15_999, 16_000, 32_000] {
+            let mut theme = theme.clone();
+            theme.connector.width_milli_px = width;
+            let mut edges = [edge(
+                Some("Call"),
+                &[(100_000, 300_000), (700_000, 300_000)],
+            )];
+            place(&mut edges, &[], bounds(), &[], &theme, metrics)
+                .map_err(|_| "wide connector label failed")?;
+            assert!(geometry_is_valid(
+                &edges,
+                &[],
+                bounds(),
+                &[],
+                i64::from(width)
+            ));
+            let label = edges[0].label_rect.ok_or("missing label rectangle")?;
+            let gap = 300_000 - label.y - label.height;
+            assert!(gap > (i64::from(width) + 1) / 2);
+            if width == 1_500 {
+                assert_eq!(gap, 8_000);
+            }
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn malformed_routes_cannot_produce_valid_label_attachments() -> TestResult {
+        let (theme, metrics) = resources()?;
+        for path in [
+            vec![],
+            vec![(100_000, 100_000)],
+            vec![(100_000, 100_000), (100_000, 100_000)],
+            vec![(100_000, 100_000), (200_000, 200_000)],
+        ] {
+            let original = edge(Some("Call"), &path);
+            let mut candidate = original.clone();
+            assert!(place_next(&mut candidate, &[], &[], bounds(), &[], theme, metrics).is_err());
+            assert_eq!(candidate, original);
+            assert!(!geometry_is_valid(&[candidate], &[], bounds(), &[], 1_500));
+        }
+        let rect = Rect {
+            x: 200_000,
+            y: 200_000,
+            width: 50_000,
+            height: 30_000,
+        };
+        let start = Point {
+            x: 100_000,
+            y: 100_000,
+        };
+        let end = Point {
+            x: 300_000,
+            y: 300_000,
+        };
+        assert!(super::stroke_hits_rect(start, end, rect, 1_500));
+        assert!(super::stroke_hits_rect(start, start, rect, -1));
+        assert!(!super::is_adjacent(rect, start, start, end, 8_000));
+        assert!(!super::is_adjacent(rect, start, start, start, 8_000));
+        Ok(())
+    }
+
     #[test]
     fn horizontal_label_prefers_above_with_its_attachment_on_the_segment() -> TestResult {
         let mut edges = [edge(
diff --git a/crates/stack-engine/src/layout_quality.rs b/crates/stack-engine/src/layout_quality.rs
index b90f886..b6e8119 100644
--- a/crates/stack-engine/src/layout_quality.rs
+++ b/crates/stack-engine/src/layout_quality.rs
@@ -7,14 +7,19 @@ mod geometry;
 
 use std::collections::BTreeSet;
 use std::error::Error;
+#[cfg(feature = "conformance")]
 use std::fs;
+#[cfg(feature = "conformance")]
 use std::path::{Path, PathBuf};
 
 use roxmltree::{Document, Node};
+#[cfg(feature = "conformance")]
 use serde::Deserialize;
 use serde_json::{Value, json};
 
-use crate::{Engine, ProviderAsset, ProviderPack, scene};
+use crate::{Engine, scene};
+#[cfg(feature = "conformance")]
+use crate::{ProviderAsset, ProviderPack};
 use geometry::{Point, Rect};
 
 type Result<T> = std::result::Result<T, Box<dyn Error>>;
@@ -346,6 +351,24 @@ fn node_envelopes(
         {
             return Err("node shape inventory drift".into());
         }
+        let mut paint_order = vec!["title"];
+        paint_order.extend_from_slice(expected_tags);
+        paint_order.push("svg");
+        paint_order.extend(
+            group
+                .children()
+                .filter(|node| node.has_tag_name("text"))
+                .map(|_| "text"),
+        );
+        if group
+            .children()
+            .filter(Node::is_element)
+            .map(|node| node.tag_name().name())
+            .collect::<Vec<_>>()
+            != paint_order
+        {
+            return Err("node paint order drift".into());
+        }
         let envelope = shape_envelope(shapes[0])?;
         if envelope != rect(expected.rect) {
             return Err("SVG/scene node envelope drift".into());
@@ -468,6 +491,23 @@ fn read_drawing(
     let groups_layer = drawing_layer(root, "groups")?;
     let edge_layer = drawing_layer(root, "edges")?;
     let labels_layer = drawing_layer(root, "edge-labels")?;
+    let paint_order = root
+        .children()
+        .filter(Node::is_element)
+        .filter(|node| {
+            !matches!(
+                node.tag_name().name(),
+                "title" | "desc" | "metadata" | "defs"
+            )
+        })
+        .map(|node| {
+            node.attribute("data-stack-layer")
+                .unwrap_or(node.tag_name().name())
+        })
+        .collect::<Vec<_>>();
+    if paint_order != ["rect", "text", "groups", "edges", "nodes", "edge-labels"] {
+        return Err("root paint order drift".into());
+    }
     for tag in ["title", "desc", "metadata", "rect", "defs", "text"] {
         if root
             .children()
@@ -540,6 +580,12 @@ fn read_drawing(
             )
             .into());
         }
+        if node.has_attribute("stroke-opacity")
+            || (node.has_attribute("fill-opacity")
+                && !(node.has_tag_name("rect") && in_group(groups_layer)))
+        {
+            return Err("unsupported drawing paint opacity".into());
+        }
         for attribute in [
             "transform",
             "style",
@@ -602,6 +648,9 @@ fn read_drawing(
             return Err("text uses unmeasured font family".into());
         }
         let size = u32::try_from(number(node, "font-size")?)?;
+        if !visible_color(required(node, "fill")?) {
+            return Err("invisible semantic text".into());
+        }
         let text_bounds = text_rectangle(node, prepared, size)?;
         let (id, owner, bounds) = if parent.has_attribute("data-edge-label") {
             if !parent.has_tag_name("g") || parent.parent_element() != Some(labels_layer) {
@@ -626,6 +675,15 @@ fn read_drawing(
             if backgrounds.len() != 1 {
                 return Err("edge label background inventory drift".into());
             }
+            if parent
+                .children()
+                .filter(Node::is_element)
+                .map(|child| child.tag_name().name())
+                .collect::<Vec<_>>()
+                != ["rect", "text"]
+            {
+                return Err("edge label paint order drift".into());
+            }
             let background = rectangle(backgrounds[0])?;
             if !geometry::contains(background, text_bounds) {
                 return Err("edge label text outside its background".into());
@@ -774,6 +832,9 @@ fn read_drawing(
             return Err("unsupported non-orthogonal or degenerate route".into());
         }
         let width = number(line, "stroke-width")?;
+        if !visible_color(required(line, "stroke")?) {
+            return Err("invisible edge stroke".into());
+        }
         if width <= 0 {
             return Err("invalid stroke width".into());
         }
@@ -801,6 +862,35 @@ fn rectangle_json(rect: Rect) -> Value {
     json!({"x":rect.x,"y":rect.y,"width":rect.width,"height":rect.height})
 }
 
+fn visible_color(color: &str) -> bool {
+    let Some(hex) = color.strip_prefix('#') else {
+        return false;
+    };
+    matches!(hex.len(), 6 | 8)
+        && hex.bytes().all(|byte| byte.is_ascii_hexdigit())
+        && (hex.len() == 6 || &hex[6..] != "00")
+}
+
+#[test]
+fn paint_colors_require_nontransparent_literal_hex() {
+    for color in ["#123456", "#ABCDEF", "#123456ff", "#12345601"] {
+        assert!(visible_color(color));
+    }
+    for color in [
+        "none",
+        "transparent",
+        "currentColor",
+        "url(#paint)",
+        "#123",
+        "#12345600",
+        "#12zzzz",
+        "#123456789",
+        "#123456é",
+    ] {
+        assert!(!visible_color(color));
+    }
+}
+
 fn composition_metrics(drawing: &Drawing) -> Value {
     let mut length = 0_i64;
     let mut bends = 0;
@@ -912,10 +1002,12 @@ fn frame_violations(drawing: &Drawing) -> Result<Vec<Value>> {
     Ok(violations)
 }
 
+#[cfg(feature = "conformance")]
 #[derive(Deserialize)]
 struct Catalog {
     cases: Vec<Case>,
 }
+#[cfg(feature = "conformance")]
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct Case {
@@ -923,21 +1015,25 @@ struct Case {
     source: String,
     provider_fixture: Option<String>,
 }
+#[cfg(feature = "conformance")]
 #[derive(Deserialize)]
 struct PackInput {
     manifest: stack_theme::ProviderPack,
     assets: Vec<AssetInput>,
 }
+#[cfg(feature = "conformance")]
 #[derive(Deserialize)]
 struct AssetInput {
     path: String,
     svg: String,
 }
 
+#[cfg(feature = "conformance")]
 fn root() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR")).join("../..")
 }
 
+#[cfg(feature = "conformance")]
 fn run_corpus(gate: &str) -> Result<()> {
     let root = root();
     let catalog: Catalog =
@@ -1016,16 +1112,19 @@ fn run_corpus(gate: &str) -> Result<()> {
 }
 
 #[test]
+#[cfg(feature = "conformance")]
 fn corpus_text_quality() -> Result<()> {
     run_corpus("text")
 }
 
 #[test]
+#[cfg(feature = "conformance")]
 fn corpus_edge_quality() -> Result<()> {
     run_corpus("edge")
 }
 
 #[test]
+#[cfg(feature = "conformance")]
 fn corpus_frame_quality() -> Result<()> {
     run_corpus("frame")
 }
@@ -1458,9 +1557,239 @@ fn parser_reserves_logical_middle_baseline_text_boxes() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn shape_parser_rejects_missing_malformed_and_overflowing_geometry() -> Result<()> {
+    for markup in [
+        "<rect y='0' width='1' height='1'/>",
+        "<rect x='0' width='1' height='1'/>",
+        "<rect x='0' y='0' height='1'/>",
+        "<rect x='0' y='0' width='1'/>",
+        "<rect x='0' y='0' width='-1' height='1'/>",
+        "<circle cx='0' cy='0' r='0'/>",
+        "<ellipse cx='0' cy='0' rx='1' ry='-1'/>",
+        "<circle cx='-9223372036854775.808' cy='0' r='1'/>",
+        "<circle cx='0' cy='-9223372036854775.808' r='1'/>",
+        "<ellipse cx='0' cy='0' rx='4611686018427388' ry='1'/>",
+        "<ellipse cx='0' cy='0' rx='1' ry='4611686018427388'/>",
+        "<polygon points=''/>",
+        "<polygon points='0,0 1,0'/>",
+        "<polygon points='0,0 0,1'/>",
+        "<polygon points='-9223372036854775.808,0 9223372036854775.807,1'/>",
+        "<polygon points='0,-9223372036854775.808 1,9223372036854775.807'/>",
+        "<polygon points='0 1'/>",
+        "<polygon points='bad,0 1,1'/>",
+        "<polygon points='0,bad 1,1'/>",
+        "<path d='M 0 0 L 1 1 Z'/>",
+        "<path d='M bad 0 V 1 C 0 1 1 1 1 1 V 0 C 1 0 0 0 0 0 Z'/>",
+        "<path d='M 0 bad V 1 C 0 1 1 1 1 1 V 0 C 1 0 0 0 0 0 Z'/>",
+        "<path d='M 0 0 V bad C 0 1 1 1 1 1 V 0 C 1 0 0 0 0 0 Z'/>",
+        "<path d='M 0 0 V 1 C bad 1 1 1 1 1 V 0 C 1 0 0 0 0 0 Z'/>",
+        "<path d='M 0 0 V 1 C 0 bad 1 1 1 1 V 0 C 1 0 0 0 0 0 Z'/>",
+        "<path d='M 0 0 V 1 C 0 1 1 1 1 1 V bad C 1 0 0 0 0 0 Z'/>",
+        "<line x1='0' y1='0' x2='1' y2='1'/>",
+    ] {
+        let document = Document::parse(markup)?;
+        assert!(shape_envelope(document.root_element()).is_err(), "{markup}");
+    }
+    Ok(())
+}
+
+#[test]
+fn parser_rejects_semantic_inventory_and_route_corruption() -> Result<()> {
+    let source = b"stack 1.0 diagram \"Example\" { group system \"System\" { node a \"A\" node b \"B\" } edge a -> b \"Request\" }";
+    let engine = Engine::bundled();
+    let svg = engine.render(source)?.svg.ok_or("missing SVG")?;
+    let compiled = stack_compiler::compile_bytes_with_source_map(source);
+    let diagram = compiled.diagram.as_ref().ok_or("missing diagram")?;
+    let prepared = engine.prepare_scene(
+        diagram,
+        compiled.source_map.as_ref().ok_or("missing source map")?,
+    )?;
+    let document = Document::parse(&svg)?;
+    let root = document.root_element();
+    let node = document
+        .descendants()
+        .find(|n| n.attribute("data-stack-id") == Some("a"))
+        .ok_or("missing mutation target")?;
+    let frame = document
+        .descendants()
+        .find(|n| n.attribute("data-stack-id") == Some("system"))
+        .ok_or("missing mutation target")?;
+    let label = document
+        .descendants()
+        .find(|n| n.has_attribute("data-edge-label"))
+        .ok_or("missing mutation target")?;
+    let line = document
+        .descendants()
+        .find(|n| n.has_tag_name("polyline"))
+        .ok_or("missing mutation target")?;
+    let node_text = node
+        .children()
+        .find(|n| n.has_tag_name("text"))
+        .ok_or("missing mutation target")?;
+    let edge_text = label
+        .children()
+        .find(|n| n.has_tag_name("text"))
+        .ok_or("missing mutation target")?;
+    let icon = node
+        .children()
+        .find(|n| n.has_tag_name("svg"))
+        .ok_or("missing mutation target")?;
+    let replace = |target: Node<'_, '_>, replacement: String| {
+        let mut mutant = svg.clone();
+        mutant.replace_range(target.range(), &replacement);
+        mutant
+    };
+    let attribute = |target: Node<'_, '_>, name: &str, value: &str| -> Result<String> {
+        let old = target.attribute(name).ok_or("missing mutation target")?;
+        Ok(replace(
+            target,
+            svg[target.range()].replacen(
+                &format!("{name}=\"{old}\""),
+                &format!("{name}=\"{value}\""),
+                1,
+            ),
+        ))
+    };
+    fn child<'a, 'input>(owner: Node<'a, 'input>, tag: &str) -> Result<Node<'a, 'input>> {
+        owner
+            .children()
+            .find(|n| n.has_tag_name(tag))
+            .ok_or_else(|| "missing mutation target".into())
+    }
+    let edge_group = line.parent_element().ok_or("missing mutation target")?;
+    let label_background = child(label, "rect")?;
+    let background = child(root, "rect")?;
+    let mut background_last = replace(background, String::new());
+    let end = background_last.rfind("</svg>").ok_or("missing root end")?;
+    background_last.insert_str(end, &svg[background.range()]);
+    let shape = child(node, "rect")?;
+    let node_shape_last = svg[node.range()]
+        .replace(&svg[shape.range()], "")
+        .replace("</g>", &format!("{}</g>", &svg[shape.range()]));
+    let label_background_last = svg[label.range()]
+        .replace(&svg[label_background.range()], "")
+        .replace("</g>", &format!("{}</g>", &svg[label_background.range()]));
+    let mutants = [
+        background_last,
+        replace(node, node_shape_last),
+        replace(label, label_background_last),
+        attribute(line, "stroke", "none")?,
+        attribute(line, "stroke", "transparent")?,
+        attribute(node_text, "fill", "none")?,
+        replace(
+            line,
+            svg[line.range()].replacen("<polyline ", "<polyline stroke-opacity=\"0\" ", 1),
+        ),
+        replace(
+            node_text,
+            svg[node_text.range()].replacen("<text ", "<text fill-opacity=\"0\" ", 1),
+        ),
+        svg.replace("http://www.w3.org/2000/svg", "urn:wrong"),
+        attribute(root, "viewBox", "0 0 1 1")?,
+        attribute(root, "width", "1")?,
+        svg.replacen("<rect ", "<rect xmlns=\"urn:wrong\" ", 1),
+        replace(
+            node,
+            svg[node.range()].replacen("<g ", "<g data-stack-layer=\"nodes\" ", 1),
+        ),
+        svg.replacen("<svg ", "<svg font-family=\"unknown\" ", 1),
+        attribute(node_text, "font-family", "unknown")?,
+        replace(
+            node_text,
+            svg[node_text.range()].replacen("<text ", "<text text-anchor=\"unsupported\" ", 1),
+        ),
+        attribute(node, "data-stack-id", "unknown")?,
+        attribute(frame, "data-stack-id", "unknown")?,
+        replace(
+            node_text,
+            format!(
+                "{}{}{}",
+                &svg[node_text.range()],
+                &svg[node_text.range()],
+                &svg[node_text.range()]
+            ),
+        ),
+        replace(node_text, String::new()),
+        replace(edge_text, String::new()),
+        attribute(label, "data-edge-label", "wrong")?,
+        attribute(edge_text, "font-size", "1")?,
+        replace(label_background, String::new()),
+        replace(
+            label_background,
+            format!(
+                "{}{}",
+                &svg[label_background.range()],
+                &svg[label_background.range()]
+            ),
+        ),
+        replace(node, String::new()),
+        replace(icon, String::new()),
+        attribute(icon, "data-icon-id", "unknown")?,
+        attribute(icon, "x", "-100")?,
+        replace(frame, String::new()),
+        replace(child(frame, "title")?, String::new()),
+        attribute(child(frame, "rect")?, "x", "-100")?,
+        attribute(line, "points", "0,0 1,0")?,
+        attribute(line, "stroke-width", "0")?,
+        replace(line, String::new()),
+        replace(
+            line,
+            format!("{}{}", &svg[line.range()], &svg[line.range()]),
+        ),
+        replace(edge_group, String::new()),
+        replace(
+            edge_group,
+            format!("{}{}", &svg[edge_group.range()], &svg[edge_group.range()]),
+        ),
+    ];
+    assert!(read_drawing(&svg, &prepared, diagram).is_ok());
+    for (index, mutant) in mutants.iter().enumerate() {
+        assert_ne!(mutant, &svg, "mutation {index} must change SVG");
+        assert!(
+            read_drawing(mutant, &prepared, diagram).is_err(),
+            "mutation {index}"
+        );
+    }
+    for (target, attributes) in [
+        (root, &["viewBox", "width", "height"][..]),
+        (shape, &["x", "y", "width", "height"][..]),
+        (icon, &["x", "y", "width", "height", "data-icon-id"][..]),
+        (
+            node_text,
+            &["x", "y", "font-family", "font-size", "fill"][..],
+        ),
+        (
+            edge_text,
+            &["x", "y", "font-family", "font-size", "fill"][..],
+        ),
+        (label_background, &["x", "y", "width", "height"][..]),
+        (
+            child(frame, "rect")?,
+            &["x", "y", "width", "height", "stroke", "stroke-width"][..],
+        ),
+        (line, &["points", "stroke", "stroke-width"][..]),
+    ] {
+        for name in attributes {
+            let value = required(target, name)?;
+            let mutant = replace(
+                target,
+                svg[target.range()].replacen(&format!(" {name}=\"{value}\""), "", 1),
+            );
+            assert_ne!(mutant, svg, "missing {name} must change SVG");
+            assert!(
+                read_drawing(&mutant, &prepared, diagram).is_err(),
+                "missing {name} on {}",
+                target.tag_name().name()
+            );
+        }
+    }
+    Ok(())
+}
+
 #[test]
 fn parser_reads_every_current_node_shape_envelope() -> Result<()> {
-    for kind in ["actor", "client", "function", "worker", "database"] {
+    for kind in ["actor", "client", "function", "worker", "database", "cache"] {
         let source = format!("stack 1.0 diagram \"Shape\" {{ node a \"A\" {{ kind {kind} }} }}");
         let engine = Engine::bundled();
         let svg = engine.render(source.as_bytes())?.svg.ok_or("missing SVG")?;
diff --git a/crates/stack-engine/src/lib.rs b/crates/stack-engine/src/lib.rs
index 3e52d7c..fdc286e 100644
--- a/crates/stack-engine/src/lib.rs
+++ b/crates/stack-engine/src/lib.rs
@@ -645,6 +645,35 @@ mod tests {
 
     const VALID_SOURCE: &[u8] = b"stack 1.0 diagram \"API\" { node api \"API\" }";
 
+    #[test]
+    fn valid_wide_connectors_render_labelled_edges_in_both_directions() -> Result<(), Box<dyn Error>>
+    {
+        for width in [1_500, 15_000, 15_998, 15_999, 16_000, 32_000] {
+            let mut catalog = stack_theme::catalog().clone();
+            for theme in &mut catalog.themes {
+                theme.connector.width_milli_px = width;
+            }
+            let engine = Engine::with_catalog(&catalog, stack_theme::CATALOG_REVISION)?;
+            for direction in ["right", "down"] {
+                let source = format!(
+                    "stack 1.0 diagram \"Wide stroke\" {{ layout {{ direction {direction} }} node a \"A\" node b \"B\" edge a -> b \"Request\" }}"
+                );
+                let output = engine.render(source.as_bytes())?;
+                assert!(
+                    output.diagnostics.is_empty(),
+                    "width={width}, direction={direction}"
+                );
+                assert!(
+                    output
+                        .svg
+                        .ok_or("missing wide-stroke SVG")?
+                        .contains("data-edge-label=\"Request\"")
+                );
+            }
+        }
+        Ok(())
+    }
+
     #[test]
     fn bundled_engine_reports_all_version_metadata() {
         let engine = Engine::bundled();
@@ -657,7 +686,7 @@ mod tests {
                 output.metadata.language_version,
                 Some(LanguageVersion { major: 1, minor: 0 })
             );
-            assert_eq!(output.metadata.theme_catalog_version, "0.5.0");
+            assert_eq!(output.metadata.theme_catalog_version, "0.6.0");
             assert_eq!(
                 output.metadata.theme_catalog_revision,
                 stack_theme::CATALOG_REVISION
@@ -701,10 +730,10 @@ mod tests {
             ("ai", "Artificial intelligence system"),
         ];
         let catalog = stack_theme::catalog();
-        assert_eq!(catalog.catalog_version, "0.5.0");
+        assert_eq!(catalog.catalog_version, "0.6.0");
         assert_eq!(
             stack_theme::CATALOG_REVISION,
-            "sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53"
+            "sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1"
         );
         for theme in &catalog.themes {
             for (identifier, subject) in expected_icons {
@@ -723,7 +752,7 @@ mod tests {
         let rendered = Engine::bundled().render(source)?;
         assert!(checked.diagnostics.is_empty());
         assert!(rendered.diagnostics.is_empty());
-        assert_eq!(rendered.metadata.theme_catalog_version, "0.5.0");
+        assert_eq!(rendered.metadata.theme_catalog_version, "0.6.0");
         assert_eq!(
             rendered.metadata.theme_catalog_revision,
             stack_theme::CATALOG_REVISION
diff --git a/crates/stack-engine/src/placement_quality.rs b/crates/stack-engine/src/placement_quality.rs
index 67fb628..6e1e0be 100644
--- a/crates/stack-engine/src/placement_quality.rs
+++ b/crates/stack-engine/src/placement_quality.rs
@@ -2,6 +2,7 @@
 
 use std::error::Error;
 
+#[cfg(feature = "conformance")]
 use crate::routing::Point;
 use crate::scene::{self, Rect, Scene, SceneDirection};
 
@@ -223,6 +224,7 @@ diagram "Deterministic cycle" {
     Ok(())
 }
 
+#[cfg(feature = "conformance")]
 fn contains(outer: Rect, inner: Rect) -> bool {
     inner.x >= outer.x
         && inner.y >= outer.y
@@ -230,6 +232,7 @@ fn contains(outer: Rect, inner: Rect) -> bool {
         && inner.y + inner.height <= outer.y + outer.height
 }
 
+#[cfg(feature = "conformance")]
 fn overlaps(left: Rect, right: Rect) -> bool {
     left.x < right.x + right.width
         && right.x < left.x + left.width
@@ -237,6 +240,7 @@ fn overlaps(left: Rect, right: Rect) -> bool {
         && right.y < left.y + left.height
 }
 
+#[cfg(feature = "conformance")]
 fn point_on_segment(point: Point, start: Point, end: Point) -> bool {
     if start.x == end.x {
         point.x == start.x && (start.y.min(end.y)..=start.y.max(end.y)).contains(&point.y)
@@ -247,6 +251,7 @@ fn point_on_segment(point: Point, start: Point, end: Point) -> bool {
     }
 }
 
+#[cfg(feature = "conformance")]
 fn segment_touches_rect(start: Point, end: Point, rect: Rect) -> bool {
     if start.x == end.x {
         (rect.x..=rect.x + rect.width).contains(&start.x)
@@ -263,6 +268,7 @@ fn segment_touches_rect(start: Point, end: Point, rect: Rect) -> bool {
 }
 
 #[test]
+#[cfg(feature = "conformance")]
 fn multilingual_labels_have_scene_rectangles_beside_their_routes_without_collisions_or_clipping()
 -> Result<(), Box<dyn Error>> {
     let catalog = stack_theme::catalog();
diff --git a/crates/stack-engine/src/resources.rs b/crates/stack-engine/src/resources.rs
index ea0fb3c..03752f2 100644
--- a/crates/stack-engine/src/resources.rs
+++ b/crates/stack-engine/src/resources.rs
@@ -5,6 +5,65 @@ use stack_theme::{Catalog, FontMetrics, NodeVisual, ProviderIcon, Theme};
 
 use crate::{ProviderNotice, ProviderNoticeIcon, ProviderNoticeSource, ProviderPack};
 
+#[cfg(test)]
+mod tests {
+    use super::{ResourceError, Resources};
+
+    #[test]
+    fn missing_catalog_records_return_explicit_resolution_errors()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let diagram =
+            stack_compiler::compile_bytes(b"stack 1.0 diagram \"Resources\" { node a \"A\" }")
+                .diagram
+                .ok_or("missing diagram")?;
+        for (case, expected) in [
+            (0, "missing-theme fallback is unavailable"),
+            (1, "resolved theme font metrics are unavailable"),
+            (
+                2,
+                "node-kind fallback icon is unavailable in the resolved theme",
+            ),
+            (3, "resolved icon bytes are not embedded in stack-theme"),
+            (
+                4,
+                "missing-icon fallback is unavailable in the resolved theme",
+            ),
+        ] {
+            let mut catalog = stack_theme::catalog().clone();
+            let mut diagram = diagram.clone();
+            match case {
+                0 => catalog.themes.clear(),
+                1 => catalog.font_metrics.clear(),
+                2 => {
+                    for theme in &mut catalog.themes {
+                        theme.icons.clear();
+                    }
+                }
+                3 => {
+                    for theme in &mut catalog.themes {
+                        for icon in &mut theme.icons {
+                            icon.asset.path = "missing.svg".into();
+                        }
+                    }
+                }
+                _ => {
+                    diagram.nodes[0].icon_id = Some("unknown".into());
+                    for theme in &mut catalog.themes {
+                        theme.icons.clear();
+                    }
+                }
+            }
+            assert_eq!(
+                Resources::resolve(&diagram, &catalog, &[])
+                    .map(|_| ())
+                    .map_err(ResourceError::reason),
+                Err(expected)
+            );
+        }
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ResourceWarning {
     MissingTheme(String),
diff --git a/crates/stack-engine/src/routing.rs b/crates/stack-engine/src/routing.rs
index 4e1edf7..16f9fc6 100644
--- a/crates/stack-engine/src/routing.rs
+++ b/crates/stack-engine/src/routing.rs
@@ -1236,4 +1236,82 @@ mod tests {
         assert!(!invalid.geometry_is_valid());
         Ok(())
     }
+
+    #[test]
+    fn missing_endpoints_and_enclosed_terminals_fail_without_partial_routes() {
+        let nodes = [
+            test_node("source", 20_000, 100_000),
+            test_node("target", 320_000, 100_000),
+        ];
+        let edge = stack_compiler::ir::Edge {
+            from: "source".into(),
+            to: "target".into(),
+            direction: EdgeDirection::Forward,
+            kind: EdgeKind::Flow,
+            label: None,
+        };
+        assert!(super::route(std::slice::from_ref(&edge), &nodes, test_bounds(), &[], &[]).is_ok());
+        for missing in [0, 1] {
+            let mut corrupted = edge.clone();
+            if missing == 0 {
+                corrupted.from = "absent".into();
+            } else {
+                corrupted.to = "absent".into();
+            }
+            assert!(
+                super::route(
+                    std::slice::from_ref(&corrupted),
+                    &nodes,
+                    test_bounds(),
+                    &[],
+                    &[]
+                )
+                .is_err()
+            );
+            assert!(
+                super::alternative_routes(&corrupted, &nodes, test_bounds(), &[], &[]).is_err()
+            );
+        }
+        let covering_obstacle = [test_bounds()];
+        assert!(
+            super::route(
+                std::slice::from_ref(&edge),
+                &nodes,
+                test_bounds(),
+                &covering_obstacle,
+                &[]
+            )
+            .is_err()
+        );
+        assert_eq!(
+            super::alternative_routes(&edge, &nodes, test_bounds(), &covering_obstacle, &[]),
+            Ok(Vec::new())
+        );
+        let mut invalid = test_edge(&[(120_000, 150_000), (320_000, 150_000)]);
+        invalid.to = "absent".into();
+        assert!(!super::geometry_is_valid(
+            &[invalid],
+            &nodes,
+            test_bounds(),
+            &[]
+        ));
+    }
+
+    #[test]
+    fn unsupported_diagonal_segments_fail_closed_in_routing_predicates() {
+        let start = Point { x: 0, y: 0 };
+        let end = Point {
+            x: 400_000,
+            y: 400_000,
+        };
+        assert!(!super::segment_is_axis_aligned(start, end));
+        assert!(!super::point_is_on_segment(start, start, end));
+        assert!(super::segment_hits_rect(start, end, test_frame()));
+        assert!(super::segment_crosses_rect_interior(
+            start,
+            end,
+            test_frame()
+        ));
+        assert!(!super::frame_segment_is_clear(start, end, test_frame()));
+    }
 }
diff --git a/crates/stack-engine/src/svg.rs b/crates/stack-engine/src/svg.rs
index 3f6a3bd..13b6f81 100644
--- a/crates/stack-engine/src/svg.rs
+++ b/crates/stack-engine/src/svg.rs
@@ -664,6 +664,49 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn renderer_rejects_missing_semantic_and_resource_records()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let source = b"stack 1.0 diagram \"Integrity\" { group g \"Group\" { node a \"A\" node b \"B\" } edge a -> b }";
+        let diagram = stack_compiler::compile_bytes(source)
+            .diagram
+            .ok_or("missing diagram")?;
+        let scene = crate::scene::layout(&diagram, stack_theme::catalog())?;
+        let metadata = crate::Engine::bundled().check(source)?.metadata;
+        for (case, expected) in [
+            (0, "scene group has no normalized IR record"),
+            (1, "edge source has no normalized node"),
+            (2, "edge target has no normalized node"),
+            (3, "scene node has no normalized IR record"),
+            (4, "scene node has no resolved theme record"),
+        ] {
+            let mut invalid = diagram.clone();
+            let mut scene = scene.clone();
+            let mut resources = Resources::resolve(&diagram, stack_theme::catalog(), &[])
+                .map_err(|error| error.reason())?;
+            match case {
+                0 => invalid.groups.clear(),
+                1 => {
+                    invalid.nodes.remove(0);
+                }
+                2 => {
+                    invalid.nodes.remove(1);
+                }
+                3 => {
+                    scene.edges.clear();
+                    invalid.nodes.clear();
+                }
+                _ => resources.nodes.clear(),
+            }
+            assert_eq!(
+                super::render(&invalid, &scene, &resources, &metadata)
+                    .map_err(|error| error.reason()),
+                Err(expected)
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn serializes_every_node_shape_in_css_pixels() -> Result<(), Box<dyn std::error::Error>> {
         let rect = Rect {
@@ -683,7 +726,7 @@ mod tests {
             ),
             ("actor", "<circle cx=\"102.9\" cy=\"303.8\" r=\"36\""),
             (
-                "database",
+                "cache",
                 "<path d=\"M -1.25 277.8 V 329.8 C -1.25 339.8 207.05 339.8 207.05 329.8 V 277.8 C 207.05 267.8 -1.25 267.8 -1.25 277.8 Z\"",
             ),
             (
@@ -707,7 +750,7 @@ mod tests {
             );
             assert!(output.contains(expected), "{kind}: {output}");
             assert!(output.contains("stroke-width=\"1.5\""));
-            if kind == "database" {
+            if kind == "cache" {
                 assert!(
                     output.contains("<ellipse cx=\"102.9\" cy=\"277.8\" rx=\"104.15\" ry=\"10\"")
                 );
diff --git a/crates/stack-engine/tests/render_snapshots.rs b/crates/stack-engine/tests/render_snapshots.rs
index 8e5a776..78b1e4f 100644
--- a/crates/stack-engine/tests/render_snapshots.rs
+++ b/crates/stack-engine/tests/render_snapshots.rs
@@ -53,7 +53,7 @@ fn explicit_core_icon_matches_standalone_svg_snapshot() -> Result<(), Box<dyn Er
     let source = include_bytes!("fixtures/explicit-core-icon.stack");
     let output = Engine::bundled().render(source)?;
     assert!(output.diagnostics.is_empty());
-    assert_eq!(output.metadata.theme_catalog_version, "0.5.0");
+    assert_eq!(output.metadata.theme_catalog_version, "0.6.0");
     assert_eq!(
         output.metadata.theme_catalog_revision,
         stack_theme::CATALOG_REVISION
diff --git a/crates/stack-engine/tests/snapshots/complete-semantics.scene.txt b/crates/stack-engine/tests/snapshots/complete-semantics.scene.txt
index 5708fbf..82aea1c 100644
--- a/crates/stack-engine/tests/snapshots/complete-semantics.scene.txt
+++ b/crates/stack-engine/tests/snapshots/complete-semantics.scene.txt
@@ -1,22 +1,22 @@
-scene|bounds=0,0,504000,1168800|content=32000,70200,440000,1066600|direction=Right
-group|system|parent=-|rect=32000,254200,440000,882600|content=56000,308400,392000,804400|direction=Down
-group|compute|parent=system|rect=56000,404400,392000,150200|content=80000,458600,344000,72000|direction=Right
-group|state|parent=system|rect=56000,578600,208000,438200|content=80000,632800,160000,360000|direction=Down
+scene|bounds=0,0,664150,1343000|content=32000,70200,600150,1240800|direction=Right
+group|system|parent=-|rect=32000,269600,600150,1041400|content=72000,339800,520150,931200|direction=Down
+group|compute|parent=system|rect=72000,467200,240000,278200|content=112000,537400,160000,168000|direction=Down
+group|state|parent=system|rect=212075,800800,240000,470200|content=252075,871000,160000,360000|direction=Down
 node|user|parent=-|rect=32000,70200,160000,160000
-node|web|parent=system|rect=56000,308400,160000,72000
-node|api|parent=system|rect=240000,308400,160000,72000
-node|function|parent=compute|rect=80000,458600,160000,72000
-node|worker|parent=compute|rect=264000,458600,160000,72000
-node|database|parent=state|rect=80000,632800,160000,72000
-node|cache|parent=state|rect=80000,728800,160000,72000
-node|queue|parent=state|rect=80000,824800,160000,72000
-node|storage|parent=state|rect=80000,920800,160000,72000
-node|vendor|parent=system|rect=56000,1040800,192200,72000
-edge|user|web|direction=Forward|kind=Request|label=HTTPS|markers=None,Arrow|anchor=112000,281300|path=112000,230200;112000,308400;136000,308400
-edge|web|api|direction=Bidirectional|kind=Flow|label=WebSocket|markers=Arrow,Arrow|anchor=228000,344400|path=216000,344400;240000,344400
-edge|api|function|direction=Forward|kind=Dependency|label=Invoke|markers=None,Arrow|anchor=240000,419500|path=240000,344400;240000,494600
-edge|function|database|direction=Forward|kind=Data|label=SQL|markers=None,Arrow|anchor=160000,581700|path=160000,530600;160000,632800
-edge|function|queue|direction=Forward|kind=Event|label=Job|markers=None,Arrow|anchor=80000,677700|path=80000,494600;80000,860800
-edge|worker|storage|direction=Association|kind=Data|label=Archive|markers=None,None|anchor=264000,737700|path=264000,494600;264000,956800;240000,956800
-edge|api|cache|direction=Forward|kind=Data|label=Read|markers=None,Arrow|anchor=240000,554600|path=240000,344400;240000,764800
-edge|api|vendor|direction=Forward|kind=Request|label=API|markers=None,Arrow|anchor=248200,692700|path=320000,380400;248200,380400;248200,1076800
+node|web|parent=system|rect=128100,339800,160000,72000
+node|api|parent=system|rect=376050,339800,160000,72000
+node|function|parent=compute|rect=112000,537400,160000,72000
+node|worker|parent=compute|rect=112000,633400,160000,72000
+node|database|parent=state|rect=252075,871000,160000,72000
+node|cache|parent=state|rect=252075,967000,160000,72000
+node|queue|parent=state|rect=252075,1063000,160000,72000
+node|storage|parent=state|rect=252075,1159000,160000,72000
+node|vendor|parent=system|rect=399950,467200,192200,72000
+edge|user|web|direction=Forward|kind=Request|label=HTTPS|markers=None,Arrow|anchor=208100,245000|path=192000,150200;208100,150200;208100,339800
+edge|web|api|direction=Bidirectional|kind=Flow|label=WebSocket|markers=Arrow,Arrow|anchor=332075,375800|path=288100,375800;376050,375800
+edge|api|function|direction=Forward|kind=Dependency|label=Invoke|markers=None,Arrow|anchor=368050,441666|path=376050,375800;368050,375800;368050,573400;272000,573400
+edge|function|database|direction=Forward|kind=Data|label=SQL|markers=None,Arrow|anchor=306037,832800|path=272000,573400;280000,573400;280000,832800;332075,832800;332075,871000
+edge|function|queue|direction=Forward|kind=Event|label=Job|markers=None,Arrow|anchor=104000,836200|path=112000,573400;104000,573400;104000,1099000;252075,1099000
+edge|worker|storage|direction=Association|kind=Data|label=Archive|markers=None,None|anchor=192000,950200|path=192000,705400;192000,1195000;252075,1195000
+edge|api|cache|direction=Forward|kind=Data|label=Read|markers=None,Arrow|anchor=391950,661100|path=456050,411800;456050,459200;391950,459200;391950,863000;420075,863000;420075,1003000;412075,1003000
+edge|api|vendor|direction=Forward|kind=Request|label=API|markers=None,Arrow|anchor=496050,443500|path=456050,411800;456050,419800;496050,419800;496050,467200
diff --git a/crates/stack-engine/tests/snapshots/render/complete-semantics.svg b/crates/stack-engine/tests/snapshots/render/complete-semantics.svg
index aae17ed..339b897 100644
--- a/crates/stack-engine/tests/snapshots/render/complete-semantics.svg
+++ b/crates/stack-engine/tests/snapshots/render/complete-semantics.svg
@@ -1,171 +1,170 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="504" height="1168.8" viewBox="0 0 504000 1168800" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="dark" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="664.15" height="1343" viewBox="0 0 664.15 1343" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="dark" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Complete semantics</title>
   <desc id="stack-description">Architecture diagram with 10 nodes, 3 groups, and 8 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="504000" height="1168800" fill="#0B1020"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="664.15" height="1343" fill="#0B1020"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7500" markerHeight="7500" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7.5" markerHeight="7.5" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#CBD5E1"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#F8FAFC" font-family="system-ui" font-size="13000" font-weight="600">Complete semantics</text>
+  <text x="32" y="50.2" fill="#F8FAFC" font-family="system-ui" font-size="13" font-weight="600">Complete semantics</text>
   <g data-stack-layer="groups">
     <g role="group" aria-label="System" data-stack-id="system">
       <title>System</title>
-      <rect x="32000" y="254200" width="440000" height="882600" rx="12000" fill="#1E293B" fill-opacity="0.55" stroke="#94A3B8" stroke-width="1000"/>
-      <text x="56000" y="291200" fill="#F8FAFC" font-family="system-ui" font-size="13000" font-weight="600">System</text>
+      <rect x="32" y="269.6" width="600.15" height="1041.4" rx="12" fill="#1E293B" fill-opacity="0.55" stroke="#94A3B8" stroke-width="1"/>
+      <text x="72" y="322.6" fill="#F8FAFC" font-family="system-ui" font-size="13" font-weight="600">System</text>
     </g>
     <g role="group" aria-label="Compute" data-stack-id="compute">
       <title>Compute</title>
-      <rect x="56000" y="404400" width="392000" height="150200" rx="12000" fill="#1E293B" fill-opacity="0.55" stroke="#94A3B8" stroke-width="1000"/>
-      <text x="80000" y="441400" fill="#F8FAFC" font-family="system-ui" font-size="13000" font-weight="600">Compute</text>
+      <rect x="72" y="467.2" width="240" height="278.2" rx="12" fill="#1E293B" fill-opacity="0.55" stroke="#94A3B8" stroke-width="1"/>
+      <text x="112" y="520.2" fill="#F8FAFC" font-family="system-ui" font-size="13" font-weight="600">Compute</text>
     </g>
     <g role="group" aria-label="State" data-stack-id="state">
       <title>State</title>
-      <rect x="56000" y="578600" width="208000" height="438200" rx="12000" fill="#1E293B" fill-opacity="0.55" stroke="#94A3B8" stroke-width="1000"/>
-      <text x="80000" y="615600" fill="#F8FAFC" font-family="system-ui" font-size="13000" font-weight="600">State</text>
+      <rect x="212.075" y="800.8" width="240" height="470.2" rx="12" fill="#1E293B" fill-opacity="0.55" stroke="#94A3B8" stroke-width="1"/>
+      <text x="252.075" y="853.8" fill="#F8FAFC" font-family="system-ui" font-size="13" font-weight="600">State</text>
     </g>
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="User flows to Web app: HTTPS" data-edge-kind="request" data-edge-direction="forward">
       <title>User flows to Web app: HTTPS</title>
-      <polyline points="112000,230200 112000,308400 136000,308400" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,150.2 208.1,150.2 208.1,339.8" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Web app is connected bidirectionally with API: WebSocket" data-edge-kind="flow" data-edge-direction="bidirectional">
       <title>Web app is connected bidirectionally with API: WebSocket</title>
-      <polyline points="216000,344400 240000,344400" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-start="url(#stack-arrow)" marker-end="url(#stack-arrow)" />
+      <polyline points="288.1,375.8 376.05,375.8" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-start="url(#stack-arrow)" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="API flows to Function: Invoke" data-edge-kind="dependency" data-edge-direction="forward">
       <title>API flows to Function: Invoke</title>
-      <polyline points="240000,344400 240000,494600" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="376.05,375.8 368.05,375.8 368.05,573.4 272,573.4" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Function flows to Database: SQL" data-edge-kind="data" data-edge-direction="forward">
       <title>Function flows to Database: SQL</title>
-      <polyline points="160000,530600 160000,632800" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="272,573.4 280,573.4 280,832.8 332.075,832.8 332.075,871" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Function flows to Queue: Job" data-edge-kind="event" data-edge-direction="forward">
       <title>Function flows to Queue: Job</title>
-      <polyline points="80000,494600 80000,860800" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="112,573.4 104,573.4 104,1099 252.075,1099" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Worker is associated with Storage: Archive" data-edge-kind="data" data-edge-direction="association">
       <title>Worker is associated with Storage: Archive</title>
-      <polyline points="264000,494600 264000,956800 240000,956800" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="8000 6000" />
+      <polyline points="192,705.4 192,1195 252.075,1195" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="8 6" />
     </g>
     <g role="group" aria-label="API flows to Cache: Read" data-edge-kind="data" data-edge-direction="forward">
       <title>API flows to Cache: Read</title>
-      <polyline points="240000,344400 240000,764800" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="456.05,411.8 456.05,459.2 391.95,459.2 391.95,863 420.075,863 420.075,1003 412.075,1003" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="API flows to External provider: API" data-edge-kind="request" data-edge-direction="forward">
       <title>API flows to External provider: API</title>
-      <polyline points="320000,380400 248200,380400 248200,1076800" fill="none" stroke="#CBD5E1" stroke-width="1750" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="456.05,411.8 456.05,419.8 496.05,419.8 496.05,467.2" fill="none" stroke="#CBD5E1" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="User: Purchaser" data-stack-id="user" data-node-kind="actor">
       <title>User: Purchaser</title>
-      <circle cx="112000" cy="150200" r="80000" fill="#141B2D" stroke="#94A3B8" stroke-width="1500"/>
-      <svg x="52000" y="138200" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-actor"><circle cx="12" cy="8" r="3" fill="none" stroke="currentColor" stroke-width="2"/>
+      <circle cx="112" cy="150.2" r="80" fill="#141B2D" stroke="#94A3B8" stroke-width="1.5"/>
+      <svg x="52" y="138.2" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-actor"><circle cx="12" cy="8" r="3" fill="none" stroke="currentColor" stroke-width="2"/>
   <path d="M5 20c.8-4 3-6 7-6s6.2 2 7 6" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"/> </svg>
-      <text x="88000" y="141200" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">User</text>
-      <text x="88000" y="160200" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="12000" font-weight="400">Purchaser</text>
+      <text x="88" y="141.2" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">User</text>
+      <text x="88" y="160.2" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="12" font-weight="400">Purchaser</text>
     </g>
     <g role="group" aria-label="Web app" data-stack-id="web" data-node-kind="client">
       <title>Web app</title>
-      <rect x="56000" y="308400" width="160000" height="72000" rx="8000" fill="#141B2D" stroke="#94A3B8" stroke-width="1500"/>
-      <svg x="76000" y="332400" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="112000" y="344400" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Web app</text>
+      <rect x="128.1" y="339.8" width="160" height="72" rx="8" fill="#141B2D" stroke="#94A3B8" stroke-width="1.5"/>
+      <svg x="148.1" y="363.8" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="184.1" y="375.8" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Web app</text>
     </g>
     <g role="group" aria-label="API" data-stack-id="api" data-node-kind="service">
       <title>API</title>
-      <rect x="240000" y="308400" width="160000" height="72000" rx="8000" fill="#141B2D" stroke="#69A7FF" stroke-width="1500"/>
-      <svg x="260000" y="332400" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="2"/>
+      <rect x="376.05" y="339.8" width="160" height="72" rx="8" fill="#141B2D" stroke="#69A7FF" stroke-width="1.5"/>
+      <svg x="396.05" y="363.8" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="2"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="2"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="2"/> </svg>
-      <text x="296000" y="344400" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">API</text>
+      <text x="432.05" y="375.8" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">API</text>
     </g>
     <g role="group" aria-label="Function" data-stack-id="function" data-node-kind="function">
       <title>Function</title>
-      <polygon points="96000,458600 224000,458600 240000,494600 224000,530600 96000,530600 80000,494600" fill="#1E293B" stroke="#69A7FF" stroke-width="1500"/>
-      <svg x="100000" y="482600" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-function"><path d="M6 20 11 4h2l5 16M8 14h8" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="136000" y="494600" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Function</text>
+      <polygon points="128,537.4 256,537.4 272,573.4 256,609.4 128,609.4 112,573.4" fill="#1E293B" stroke="#69A7FF" stroke-width="1.5"/>
+      <svg x="132" y="561.4" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-function"><path d="M6 20 11 4h2l5 16M8 14h8" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="168" y="573.4" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Function</text>
     </g>
     <g role="group" aria-label="Worker" data-stack-id="worker" data-node-kind="worker">
       <title>Worker</title>
-      <rect x="264000" y="458600" width="160000" height="72000" rx="16000" fill="#141B2D" stroke="#94A3B8" stroke-width="1500"/>
-      <svg x="284000" y="482600" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="2"/>
+      <rect x="112" y="633.4" width="160" height="72" rx="16" fill="#141B2D" stroke="#94A3B8" stroke-width="1.5"/>
+      <svg x="132" y="657.4" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="2"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"/> </svg>
-      <text x="320000" y="494600" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Worker</text>
+      <text x="168" y="669.4" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Worker</text>
     </g>
     <g role="group" aria-label="Database" data-stack-id="database" data-node-kind="database">
       <title>Database</title>
-      <path d="M 80000 642800 V 694800 C 80000 704800 240000 704800 240000 694800 V 642800 C 240000 632800 80000 632800 80000 642800 Z" fill="#141B2D" stroke="#69A7FF" stroke-width="1500"/>
-      <ellipse cx="160000" cy="642800" rx="80000" ry="10000" fill="none" stroke="#69A7FF" stroke-width="1500"/>
-      <svg x="100000" y="656800" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="2"/>
+      <rect x="252.075" y="871" width="160" height="72" rx="8" fill="#141B2D" stroke="#69A7FF" stroke-width="1.5"/>
+      <svg x="272.075" y="895" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="2"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="2"/> </svg>
-      <text x="136000" y="668800" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Database</text>
+      <text x="308.075" y="907" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Database</text>
     </g>
     <g role="group" aria-label="Cache" data-stack-id="cache" data-node-kind="cache">
       <title>Cache</title>
-      <path d="M 80000 738800 V 790800 C 80000 800800 240000 800800 240000 790800 V 738800 C 240000 728800 80000 728800 80000 738800 Z" fill="#1E293B" stroke="#94A3B8" stroke-width="1500"/>
-      <ellipse cx="160000" cy="738800" rx="80000" ry="10000" fill="none" stroke="#94A3B8" stroke-width="1500"/>
-      <svg x="100000" y="752800" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-cache"><path d="m12 3 9 5-9 5-9-5 9-5ZM3 12l9 5 9-5M3 16l9 5 9-5" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="136000" y="764800" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Cache</text>
+      <path d="M 252.075 977 V 1029 C 252.075 1039 412.075 1039 412.075 1029 V 977 C 412.075 967 252.075 967 252.075 977 Z" fill="#1E293B" stroke="#94A3B8" stroke-width="1.5"/>
+      <ellipse cx="332.075" cy="977" rx="80" ry="10" fill="none" stroke="#94A3B8" stroke-width="1.5"/>
+      <svg x="272.075" y="991" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-cache"><path d="m12 3 9 5-9 5-9-5 9-5ZM3 12l9 5 9-5M3 16l9 5 9-5" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="308.075" y="1003" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Cache</text>
     </g>
     <g role="group" aria-label="Queue" data-stack-id="queue" data-node-kind="queue">
       <title>Queue</title>
-      <rect x="80000" y="824800" width="160000" height="72000" rx="16000" fill="#1E293B" stroke="#69A7FF" stroke-width="1500"/>
-      <svg x="100000" y="848800" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="2"/>
+      <rect x="252.075" y="1063" width="160" height="72" rx="16" fill="#1E293B" stroke="#69A7FF" stroke-width="1.5"/>
+      <svg x="272.075" y="1087" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="2"/>
   <circle cx="5" cy="17" r="2" fill="none" stroke="currentColor" stroke-width="2"/>
   <path d="M7 7h10l3 3-3 3H7M7 17h12" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="136000" y="860800" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Queue</text>
+      <text x="308.075" y="1099" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Queue</text>
     </g>
     <g role="group" aria-label="Storage" data-stack-id="storage" data-node-kind="storage">
       <title>Storage</title>
-      <rect x="80000" y="920800" width="160000" height="72000" rx="4000" fill="#141B2D" stroke="#94A3B8" stroke-width="1500"/>
-      <svg x="100000" y="944800" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="2" stroke-linejoin="round"/>
+      <rect x="252.075" y="1159" width="160" height="72" rx="4" fill="#141B2D" stroke="#94A3B8" stroke-width="1.5"/>
+      <svg x="272.075" y="1183" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="2" stroke-linejoin="round"/>
   <path d="M3 9h18" fill="none" stroke="currentColor" stroke-width="2"/> </svg>
-      <text x="136000" y="956800" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Storage</text>
+      <text x="308.075" y="1195" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Storage</text>
     </g>
     <g role="group" aria-label="External provider" data-stack-id="vendor" data-node-kind="external">
       <title>External provider</title>
-      <polygon points="72000,1040800 232200,1040800 248200,1076800 232200,1112800 72000,1112800 56000,1076800" fill="#1E293B" stroke="#94A3B8" stroke-width="1500"/>
-      <svg x="76000" y="1064800" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="112000" y="1076800" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">External provider</text>
+      <polygon points="415.95,467.2 576.15,467.2 592.15,503.2 576.15,539.2 415.95,539.2 399.95,503.2" fill="#1E293B" stroke="#94A3B8" stroke-width="1.5"/>
+      <svg x="419.95" y="491.2" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="455.95" y="503.2" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">External provider</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="HTTPS">
-      <rect x="89500" y="269600" width="45000" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="112000" y="281300" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">HTTPS</text>
+      <rect x="216.1" y="233.3" width="45" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="238.6" y="245" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">HTTPS</text>
     </g>
     <g data-edge-label="WebSocket">
-      <rect x="192025" y="277000" width="71950" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="228000" y="288700" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">WebSocket</text>
+      <rect x="296.1" y="344.4" width="71.95" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="332.075" y="356.1" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">WebSocket</text>
     </g>
     <g data-edge-label="Invoke">
-      <rect x="215850" y="407800" width="48300" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="240000" y="419500" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">Invoke</text>
+      <rect x="376.05" y="429.966" width="48.3" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="400.2" y="441.666" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">Invoke</text>
     </g>
     <g data-edge-label="SQL">
-      <rect x="144100" y="570000" width="31800" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="160000" y="581700" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">SQL</text>
+      <rect x="290.137" y="840.8" width="31.8" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="306.037" y="852.5" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">SQL</text>
     </g>
     <g data-edge-label="Job">
-      <rect x="40200" y="666000" width="31800" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="56100" y="677700" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">Job</text>
+      <rect x="112" y="824.5" width="31.8" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="127.9" y="836.2" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">Job</text>
     </g>
     <g data-edge-label="Archive">
-      <rect x="248000" y="726000" width="52150" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="274075" y="737700" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">Archive</text>
+      <rect x="131.85" y="938.5" width="52.15" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="157.925" y="950.2" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">Archive</text>
     </g>
     <g data-edge-label="Read">
-      <rect x="220800" y="542900" width="38400" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="240000" y="554600" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">Read</text>
+      <rect x="399.95" y="649.4" width="38.4" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="419.15" y="661.1" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">Read</text>
     </g>
     <g data-edge-label="API">
-      <rect x="248000" y="681000" width="28500" height="23400" rx="4000" fill="#0B1020"/>
-      <text x="262250" y="692700" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11000">API</text>
+      <rect x="504.05" y="431.8" width="28.5" height="23.4" rx="4" fill="#0B1020"/>
+      <text x="518.3" y="443.5" text-anchor="middle" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="11">API</text>
     </g>
   </g>
 </svg>
diff --git a/crates/stack-engine/tests/snapshots/render/default-normalization.svg b/crates/stack-engine/tests/snapshots/render/default-normalization.svg
index 232f79a..005656c 100644
--- a/crates/stack-engine/tests/snapshots/render/default-normalization.svg
+++ b/crates/stack-engine/tests/snapshots/render/default-normalization.svg
@@ -1,39 +1,39 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="408" height="174.2" viewBox="0 0 408000 174200" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="408" height="174.2" viewBox="0 0 408 174.2" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Default normalization</title>
   <desc id="stack-description">Architecture diagram with 2 nodes, 0 groups, and 1 relationship.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="408000" height="174200" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="408" height="174.2" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Default normalization</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Default normalization</text>
   <g data-stack-layer="groups">
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Web app flows to API" data-edge-kind="flow" data-edge-direction="forward">
       <title>Web app flows to API</title>
-      <polyline points="192000,106200 216000,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,106.2 216,106.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Web app" data-stack-id="web" data-node-kind="service">
       <title>Web app</title>
-      <rect x="32000" y="70200" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="52000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="32" y="70.2" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="52" y="94.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="88000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Web app</text>
+      <text x="88" y="106.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Web app</text>
     </g>
     <g role="group" aria-label="API" data-stack-id="api" data-node-kind="service">
       <title>API</title>
-      <rect x="216000" y="70200" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="236000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="216" y="70.2" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="236" y="94.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="272000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">API</text>
+      <text x="272" y="106.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">API</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
diff --git a/crates/stack-engine/tests/snapshots/render/explicit-core-icon.svg b/crates/stack-engine/tests/snapshots/render/explicit-core-icon.svg
index 6dfa1a6..9e75e7a 100644
--- a/crates/stack-engine/tests/snapshots/render/explicit-core-icon.svg
+++ b/crates/stack-engine/tests/snapshots/render/explicit-core-icon.svg
@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="224" height="174.6" viewBox="0 0 224000 174600" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="dark" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="224" height="174.6" viewBox="0 0 224 174.6" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="dark" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Core icon</title>
   <desc id="stack-description">Architecture diagram with 1 node, 0 groups, and 0 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="224000" height="174600" fill="#0B1020"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="224" height="174.6" fill="#0B1020"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7500" markerHeight="7500" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7.5" markerHeight="7.5" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#CBD5E1"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#F8FAFC" font-family="system-ui" font-size="13000" font-weight="600">Core icon</text>
+  <text x="32" y="50.2" fill="#F8FAFC" font-family="system-ui" font-size="13" font-weight="600">Core icon</text>
   <g data-stack-layer="groups">
   </g>
   <g data-stack-layer="edges">
@@ -17,11 +17,11 @@
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Gateway: Public API" data-stack-id="gateway" data-node-kind="service">
       <title>Gateway: Public API</title>
-      <rect x="32000" y="70200" width="160000" height="72400" rx="8000" fill="#141B2D" stroke="#69A7FF" stroke-width="1500"/>
-      <svg x="52000" y="94400" width="24000" height="24000" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="32" y="70.2" width="160" height="72.4" rx="8" fill="#141B2D" stroke="#69A7FF" stroke-width="1.5"/>
+      <svg x="52" y="94.4" width="24" height="24" viewBox="0 0 24 24" color="#69A7FF" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h5M5.5 5.5 8 8l-2.5 2.5M21 16h-5M18.5 13.5 16 16l2.5 2.5" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="88000" y="97400" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14000" font-weight="600">Gateway</text>
-      <text x="88000" y="116400" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="12000" font-weight="400">Public API</text>
+      <text x="88" y="97.4" dominant-baseline="middle" fill="#F8FAFC" font-family="system-ui" font-size="14" font-weight="600">Gateway</text>
+      <text x="88" y="116.4" dominant-baseline="middle" fill="#CBD5E1" font-family="system-ui" font-size="12" font-weight="400">Public API</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
diff --git a/crates/stack-formatter/THIRD_PARTY_LICENSES.md b/crates/stack-formatter/THIRD_PARTY_LICENSES.md
index 23a695b..179d1f5 100644
--- a/crates/stack-formatter/THIRD_PARTY_LICENSES.md
+++ b/crates/stack-formatter/THIRD_PARTY_LICENSES.md
@@ -5,7 +5,7 @@
 | Component | Revision | License | Source | Notes |
 | --- | --- | --- | --- | --- |
 | `stack-compiler` | `0.1.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/compiler> | Unmodified Rust dependency; its license and notice obligations apply to distributions that include it. |
-| `stack-theme` | `0.5.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> | Unmodified Rust dependency with repository-authored core assets and the asset-free provider-pack contract. |
+| `stack-theme` | `0.6.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> | Unmodified Rust dependency with repository-authored core assets and the asset-free provider-pack contract. |
 | `roxmltree` | `0.21.1` | MIT OR Apache-2.0 | <https://github.com/RazrFalcon/roxmltree> | Parses caller-owned processed provider SVG before allowlisted in-memory embedding. |
 | `sha2`, `digest`, `block-buffer`, `crypto-common`, `hybrid-array`, `const-oid`, `typenum` | `0.11.0`, `0.11.3`, `0.12.1`, `0.2.2`, `0.4.14`, `0.10.2`, `1.20.1` | MIT OR Apache-2.0 | <https://github.com/RustCrypto> | Verifies provider asset hashes and computes deterministic provider-pack revisions. |
 | `libc` / `cpufeatures` | `0.2.189`, `0.3.1` | MIT OR Apache-2.0 | <https://github.com/rust-lang/libc>, <https://github.com/RustCrypto/utils> | Target-specific SHA-256 acceleration support. |
diff --git a/docs/cargo-releasing.md b/docs/cargo-releasing.md
index f3a9b66..1333340 100644
--- a/docs/cargo-releasing.md
+++ b/docs/cargo-releasing.md
@@ -1,6 +1,6 @@
 # Cargo publication
 
-The native `stack-formatter` 0.1.0 and `stack-engine` 0.7.0 crates use exact registry dependencies. The workspace retains local paths for development, with registry versions declared for Cargo packaging. `stack-engine-wasm` is not published to crates.io; its browser output remains the npm package.
+The native `stack-formatter` 0.1.0 and `stack-engine` 0.8.0 crates use exact registry dependencies. The workspace retains local paths for development, with registry versions declared for Cargo packaging. `stack-engine-wasm` is not published to crates.io; its browser output remains the npm package.
 
 ## Initial publication
 
@@ -8,7 +8,7 @@ The native `stack-formatter` 0.1.0 and `stack-engine` 0.7.0 crates use exact reg
 2. Set a short-lived `CARGO_INITIAL_PUBLISH_TOKEN` Actions secret with `publish-new` permission limited to the exact initial crate names. Never put the value into source, workflow inputs, issues, or logs.
 3. Dispatch `initial-publish.yaml` on `main` with the full successful `expected_sha` and package `stack-formatter`. The workflow checks repository, ref, commit, package metadata, successful CI, and registry absence before a credential-free package dry run and publication.
 4. Verify the formatter's registry version, checksum, source SHA, and registry-only consumer. Then dispatch the same workflow for `stack-engine`. Cargo verifies the engine package against the published formatter, compiler, and theme rather than Git dependencies.
-5. Verify the engine registry artifact and a clean consumer on Rust 1.85 and stable. Record immutable `stack-formatter-v0.1.0` and `stack-engine-v0.7.0` source tags without replacing any npm release tag.
+5. Verify the engine registry artifact and a clean consumer on Rust 1.85 and stable. Record immutable `stack-formatter-v0.1.0` and `stack-engine-v0.8.0` source tags without replacing any npm release tag.
 6. Remove the bootstrap GitHub secret and revoke the token after initial publications. Configure crate-specific trusted publishers before later releases. The bootstrap workflow cannot publish a second version and never persists a Cargo credential file.
 
 If Cargo times out after upload, inspect registry state before retrying. Never overwrite a version or tag: investigate failures and publish an explicitly versioned correction. No layout snapshot or language behavior is changed for registry packaging.
diff --git a/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md b/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md
index ac03994..bb8d68c 100644
--- a/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md
+++ b/docs/decisions/0008-compose-graphs-with-reserved-label-geometry.md
@@ -2,8 +2,8 @@
 
 ## Status
 
-Proposed; implemented as an unreleased visual-review candidate. Approved scene
-and SVG references remain unchanged until visual agreement.
+Accepted for Engine 0.8.0 after visual review. Scene and SVG references record
+the approved output with Theme 0.6.0.
 
 ## Context
 
@@ -48,8 +48,9 @@ exempt group frames. Measure 40px group padding to leave room for these internal
 lanes, and use that same padding for group-title serialization.
 
 The scene owns both each label rectangle and its attachment on an interior point
-of its own route segment. Candidate positions are finite, exactly 8px from that
-segment, and prefer above horizontal or right of vertical segments. Reject
+of its own route segment. Candidate positions are finite, 8px from that segment
+for core strokes, or the rounded-up stroke radius plus 1px when that is larger.
+They prefer above horizontal or right of vertical segments. Reject
 contact with nodes, titles, other labels, and every route's stroke envelope.
 Commit placement only when every label fits. SVG serialization must not relocate
 labels or hide route sections beneath label backgrounds.
@@ -81,7 +82,7 @@ elapsed time or accepts colliding fallback geometry.
 
 ## Consequences
 
-- This candidate replaces the automatic placement policy in ADR-0003, boundary
+- This policy replaces the automatic placement policy in ADR-0003, boundary
   contact and midpoint-label policy in ADR-0004, and SVG-owned label placement in
   ADR-0005, including its millipixel SVG user-space policy; their remaining
   integer-scene, semantic, diagnostic, and safety contracts
@@ -94,8 +95,8 @@ elapsed time or accepts colliding fallback geometry.
   requires a 16px painted gap, checks all four finite sides and nearby corners,
   and permits normal crossings away from corners. Hidden, transformed, missing,
   or otherwise unmeasured frame geometry fails closed.
-- Exact snapshots intentionally detect the changed output until new references
-  are explicitly approved. They are not automatically replaced by this work.
+- Exact snapshots record the visually approved output. Future reference changes
+  still require explicit visual review rather than automatic acceptance.
 - Finite heuristics are not a proof of feasible placement for every valid graph.
   A failure must remain explicit and become a regression fixture, never a hidden
   overlap, missing edge, or unmeasured text box.
diff --git a/docs/dependency-audit.md b/docs/dependency-audit.md
index 0576731..d576e5a 100644
--- a/docs/dependency-audit.md
+++ b/docs/dependency-audit.md
@@ -1,6 +1,6 @@
 # Dependency and host-I/O audit
 
-Audit date: 2026-09-05
+Audit date: 2026-09-06
 
 ## Runtime graph
 
@@ -8,7 +8,7 @@ Audit date: 2026-09-05
 
 - `stack-compiler` at `84ab5663a7f7c5b7dc0b5e9e2f04c8894ed02820` for byte decoding, parsing, validation, normalized IR, source maps, and compiler diagnostics;
 - the workspace-local `stack-formatter` for canonical source output;
-- `stack-theme` at `7e208d6a3c90d255799f390a4e8b86248c73caee` for the `0.5.0` embedded core catalog, 30 provider-neutral explicit icons, the local-only provider-pack contract, SVG bytes, deterministic font metrics, catalog version, and catalog revision;
+- `stack-theme` `0.6.0` from crates.io, source `dd366fbacfe1edceeb8c1bde04687027ccc99c24`, for the embedded core catalog with database cards, 30 provider-neutral explicit icons, the local-only provider-pack contract, SVG bytes, deterministic font metrics, catalog version, and catalog revision;
 - `roxmltree`, `serde_json`, and `sha2` for pure in-memory provider manifest serialization, processed-asset hash verification, pack revision computation, and defensive SVG validation. Vendor asset bytes are not included.
 
 `stack-engine-wasm` adds `serde`, `serde_json`, and the asset-free `stack-theme` types for its serializable native parity model and local provider-pack input, plus, only on `wasm32`, version-matched `wasm-bindgen` and `js-sys` for the JavaScript ABI, typed-array input, JSON-compatible local data, and plain object construction. It does not use `web-sys` or a WASI target.
diff --git a/docs/releases/v0.8.0.md b/docs/releases/v0.8.0.md
new file mode 100644
index 0000000..6a4986a
--- /dev/null
+++ b/docs/releases/v0.8.0.md
@@ -0,0 +1,16 @@
+# Stack Engine 0.8.0
+
+## Clearer diagrams by default
+
+- Compose connected nodes and nested groups in graph-aware ranks while preserving explicit direction, same-rank constraints, and authored cross-axis order.
+- Reserve room for measured labels before routing. Keep labels beside their own routes and keep lines away from text, node borders, and parallel group frames.
+- Bundle Theme 0.6.0: database nodes use a rounded card and their existing database icon.
+- Serialize diagram-space SVG coordinates, fonts, and strokes in exact CSS pixel decimals. This avoids browser clamping and rendering artifacts from oversized millipixel user coordinates.
+
+The native Rust engine and browser WASM adapter share these changes. Public operation and language-intelligence contracts are unchanged; generated SVG geometry and serialization intentionally differ from 0.7.0. Consumers comparing exact SVG bytes should update reviewed references. Existing custom catalogs with wider connector strokes retain labelled rendering support.
+
+## Verification and limits
+
+The release uses approved scene/SVG snapshots, a seven-diagram quality corpus, sixty fixed labelled-DAG regressions, native/WASM parity, and existing performance budgets. Independent gates measure logical text envelopes and painted frame clearance; they also reject missing content, unsupported geometry, hidden paint, and altered paint order. Geometry checks supplement rather than replace visual review; they do not prove beauty or measure exact rasterized glyphs and arrowheads.
+
+The engine remains pure Rust with no runtime filesystem, network, clock, DOM, or host-font access. No custom-palette configuration format or theme-authoring service is introduced in this release.
diff --git a/layout-corpus/catalog.json b/layout-corpus/catalog.json
index 8c690d3..ad4a8f0 100644
--- a/layout-corpus/catalog.json
+++ b/layout-corpus/catalog.json
@@ -1,7 +1,7 @@
 {
   "$schema": "./schema.json",
   "schemaVersion": "1.0",
-  "engineVersion": "0.7.0",
+  "engineVersion": "0.8.0",
   "performance": {
     "warmupIterations": 3,
     "measuredIterations": 20,
diff --git a/layout-corpus/snapshots/dense-commerce.svg b/layout-corpus/snapshots/dense-commerce.svg
index 9333eb8..96be8fa 100644
--- a/layout-corpus/snapshots/dense-commerce.svg
+++ b/layout-corpus/snapshots/dense-commerce.svg
@@ -1,239 +1,237 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="2960.9" height="262.2" viewBox="0 0 2960900 262200" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="2374.35" height="809.4" viewBox="0 0 2374.35 809.4" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Dense commerce platform</title>
   <desc id="stack-description">Architecture diagram with 13 nodes, 5 groups, and 12 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="2960900" height="262200" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="2374.35" height="809.4" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Dense commerce platform</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Dense commerce platform</text>
   <g data-stack-layer="groups">
     <g role="group" aria-label="Storefront" data-stack-id="storefront">
       <title>Storefront</title>
-      <rect x="216000" y="70200" width="420000" height="150600" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="240000" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Storefront</text>
+      <rect x="336.65" y="268.8" width="256.8" height="310" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="376.65" y="321.8" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Storefront</text>
     </g>
     <g role="group" aria-label="Commerce services" data-stack-id="commerce">
       <title>Commerce services</title>
-      <rect x="660000" y="70200" width="456200" height="150600" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="684000" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Commerce services</text>
+      <rect x="738.1" y="332.5" width="488.2" height="182.6" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="778.1" y="385.5" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Commerce services</text>
     </g>
     <g role="group" aria-label="Asynchronous processing" data-stack-id="asynchronous">
       <title>Asynchronous processing</title>
-      <rect x="1140200" y="70200" width="655800" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="1164200" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Asynchronous processing</text>
+      <rect x="1370.95" y="70.2" width="551.05" height="293.6" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="1410.95" y="123.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Asynchronous processing</text>
     </g>
     <g role="group" aria-label="Data" data-stack-id="data">
       <title>Data</title>
-      <rect x="1820000" y="70200" width="644600" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="1844000" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Data</text>
+      <rect x="1370.95" y="403.2" width="275.7" height="374.2" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="1410.95" y="456.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Data</text>
     </g>
     <g role="group" aria-label="External systems" data-stack-id="partners">
       <title>External systems</title>
-      <rect x="2488600" y="70200" width="440300" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="2512600" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">External systems</text>
+      <rect x="2066.65" y="284.7" width="275.7" height="278.2" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="2106.65" y="337.7" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">External systems</text>
     </g>
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Customer flows to Web storefront: Browse and buy" data-edge-kind="request" data-edge-direction="forward">
       <title>Customer flows to Web storefront: Browse and buy</title>
-      <polyline points="192000,150200 192000,160600 240000,160600" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,423.8 354.65,423.8 354.65,375.2 376.65,375.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Web storefront flows to Edge gateway: HTTPS" data-edge-kind="request" data-edge-direction="forward">
       <title>Web storefront flows to Edge gateway: HTTPS</title>
-      <polyline points="416800,160600 416800,160400 440800,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="465.05,411.4 465.05,466.8" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Edge gateway flows to Catalog API: Catalog requests" data-edge-kind="request" data-edge-direction="forward">
       <title>Edge gateway flows to Catalog API: Catalog requests</title>
-      <polyline points="612000,160400 612000,160600 684000,160600" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="550.65,502.8 720.1,502.8 720.1,438.9 778.1,438.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Edge gateway flows to Checkout API: Checkout requests" data-edge-kind="request" data-edge-direction="forward">
       <title>Edge gateway flows to Checkout API: Checkout requests</title>
-      <polyline points="612000,160400 612000,124400 903400,124400 903400,160600" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="550.65,502.8 720.1,502.8 720.1,483.1 981.5,483.1 981.5,438.9 997.5,438.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Catalog API flows to Product database: SQL" data-edge-kind="data" data-edge-direction="forward">
       <title>Catalog API flows to Product database: SQL</title>
-      <polyline points="879400,160600 879400,124400 1844000,124400 1844000,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="973.5,438.9 989.5,438.9 989.5,497.1 1388.95,497.1 1388.95,509.4 1410.95,509.4" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Catalog API flows to Product media: Media URLs" data-edge-kind="data" data-edge-direction="forward">
       <title>Catalog API flows to Product media: Media URLs</title>
-      <polyline points="879400,160600 879400,124400 2267300,124400 2267300,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="973.5,438.9 989.5,438.9 989.5,701.4 1422.15,701.4" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout API flows to Order database: Transactions" data-edge-kind="data" data-edge-direction="forward">
       <title>Checkout API flows to Order database: Transactions</title>
-      <polyline points="1092200,160600 1092200,196400 2063700,196400 2063700,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1186.3,438.9 1402.95,438.9 1402.95,605.4 1419,605.4" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout API flows to Payment provider: Payment API" data-edge-kind="request" data-edge-direction="forward">
       <title>Checkout API flows to Payment provider: Payment API</title>
-      <polyline points="1092200,160600 1092200,196400 2512600,196400 2512600,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1186.3,438.9 1402.95,438.9 1402.95,421.2 2084.65,421.2 2084.65,390.9 2106.65,390.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout API flows to Event bus: OrderPlaced" data-edge-kind="event" data-edge-direction="forward">
       <title>Checkout API flows to Event bus: OrderPlaced</title>
-      <polyline points="1092200,160600 1092200,160400 1164200,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1186.3,438.9 1388.95,438.9 1388.95,232.1 1410.95,232.1" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Event bus flows to Fulfillment worker: OrderPlaced" data-edge-kind="event" data-edge-direction="forward">
       <title>Event bus flows to Fulfillment worker: OrderPlaced</title>
-      <polyline points="1324200,160400 1348200,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1570.95,232.1 1664.65,232.1 1664.65,176.4 1679.3,176.4" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Event bus flows to Notification worker: OrderPlaced" data-edge-kind="event" data-edge-direction="forward">
       <title>Event bus flows to Notification worker: OrderPlaced</title>
-      <polyline points="1324200,160400 1324200,124400 1569300,124400 1569300,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1570.95,232.1 1664.65,232.1 1664.65,287.8 1679.3,287.8" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Notification worker flows to Email provider: Send receipt" data-edge-kind="request" data-edge-direction="forward">
       <title>Notification worker flows to Email provider: Send receipt</title>
-      <polyline points="1772000,160400 1772000,124400 2732300,124400 2732300,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1882,287.8 2048.65,287.8 2048.65,486.9 2118.2,486.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Customer" data-stack-id="customer" data-node-kind="actor">
       <title>Customer</title>
-      <circle cx="112000" cy="150200" r="80000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="52000" y="138200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-actor"><circle cx="12" cy="8" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <circle cx="112" cy="423.8" r="80" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="52" y="411.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-actor"><circle cx="12" cy="8" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M5 20c.8-4 3-6 7-6s6.2 2 7 6" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="88000" y="150200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Customer</text>
+      <text x="88" y="423.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Customer</text>
     </g>
     <g role="group" aria-label="Web storefront: Next.js" data-stack-id="web" data-node-kind="client">
       <title>Web storefront: Next.js</title>
-      <rect x="240000" y="124400" width="176800" height="72400" rx="8000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="260000" y="148600" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="376.65" y="339" width="176.8" height="72.4" rx="8" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="396.65" y="363.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h18M7 6h.01M10 6h.01" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="296000" y="151600" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Web storefront</text>
-      <text x="296000" y="170600" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="12000" font-weight="400">Next.js</text>
+      <text x="432.65" y="366.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Web storefront</text>
+      <text x="432.65" y="385.2" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="12" font-weight="400">Next.js</text>
     </g>
     <g role="group" aria-label="Edge gateway" data-stack-id="gateway" data-node-kind="service">
       <title>Edge gateway</title>
-      <rect x="440800" y="124400" width="171200" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="460800" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="379.45" y="466.8" width="171.2" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="399.45" y="490.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h5M5.5 5.5 8 8l-2.5 2.5M21 16h-5M18.5 13.5 16 16l2.5 2.5" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="496800" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Edge gateway</text>
+      <text x="435.45" y="502.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Edge gateway</text>
     </g>
     <g role="group" aria-label="Catalog API: Products and pricing" data-stack-id="catalog" data-node-kind="service">
       <title>Catalog API: Products and pricing</title>
-      <rect x="684000" y="124400" width="195400" height="72400" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="704000" y="148600" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="778.1" y="402.7" width="195.4" height="72.4" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="798.1" y="426.9" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="740000" y="151600" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Catalog API</text>
-      <text x="740000" y="170600" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="12000" font-weight="400">Products and pricing</text>
+      <text x="834.1" y="429.9" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Catalog API</text>
+      <text x="834.1" y="448.9" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="12" font-weight="400">Products and pricing</text>
     </g>
     <g role="group" aria-label="Checkout API: Order orchestration" data-stack-id="checkout" data-node-kind="service">
       <title>Checkout API: Order orchestration</title>
-      <rect x="903400" y="124400" width="188800" height="72400" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="923400" y="148600" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="997.5" y="402.7" width="188.8" height="72.4" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="1017.5" y="426.9" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="959400" y="151600" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Checkout API</text>
-      <text x="959400" y="170600" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="12000" font-weight="400">Order orchestration</text>
+      <text x="1053.5" y="429.9" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Checkout API</text>
+      <text x="1053.5" y="448.9" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="12" font-weight="400">Order orchestration</text>
     </g>
     <g role="group" aria-label="Event bus" data-stack-id="events" data-node-kind="queue">
       <title>Event bus</title>
-      <rect x="1164200" y="124400" width="160000" height="72000" rx="16000" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="1184200" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="1410.95" y="196.1" width="160" height="72" rx="16" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="1430.95" y="220.1" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <circle cx="5" cy="17" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M7 7h10l3 3-3 3H7M7 17h12" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="1220200" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Event bus</text>
+      <text x="1466.95" y="232.1" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Event bus</text>
     </g>
     <g role="group" aria-label="Fulfillment worker" data-stack-id="fulfillment" data-node-kind="worker">
       <title>Fulfillment worker</title>
-      <rect x="1348200" y="124400" width="197100" height="72000" rx="16000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="1368200" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="1679.3" y="140.4" width="197.1" height="72" rx="16" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="1699.3" y="164.4" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="1404200" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Fulfillment worker</text>
+      <text x="1735.3" y="176.4" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Fulfillment worker</text>
     </g>
     <g role="group" aria-label="Notification worker" data-stack-id="notifications" data-node-kind="worker">
       <title>Notification worker</title>
-      <rect x="1569300" y="124400" width="202700" height="72000" rx="16000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="1589300" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="1679.3" y="251.8" width="202.7" height="72" rx="16" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="1699.3" y="275.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="1625300" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Notification worker</text>
+      <text x="1735.3" y="287.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Notification worker</text>
     </g>
     <g role="group" aria-label="Product database" data-stack-id="products" data-node-kind="database">
       <title>Product database</title>
-      <path d="M 1844000 134400 V 186400 C 1844000 196400 2039700 196400 2039700 186400 V 134400 C 2039700 124400 1844000 124400 1844000 134400 Z" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <ellipse cx="1941850" cy="134400" rx="97850" ry="10000" fill="none" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="1864000" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="1410.95" y="473.4" width="195.7" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="1430.95" y="497.4" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="1900000" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Product database</text>
+      <text x="1466.95" y="509.4" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Product database</text>
     </g>
     <g role="group" aria-label="Order database" data-stack-id="orders" data-node-kind="database">
       <title>Order database</title>
-      <path d="M 2063700 134400 V 186400 C 2063700 196400 2243300 196400 2243300 186400 V 134400 C 2243300 124400 2063700 124400 2063700 134400 Z" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <ellipse cx="2153500" cy="134400" rx="89800" ry="10000" fill="none" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="2083700" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="1419" y="569.4" width="179.6" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="1439" y="593.4" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="2119700" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Order database</text>
+      <text x="1475" y="605.4" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Order database</text>
     </g>
     <g role="group" aria-label="Product media" data-stack-id="assets" data-node-kind="storage">
       <title>Product media</title>
-      <rect x="2267300" y="124400" width="173300" height="72000" rx="4000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="2287300" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
+      <rect x="1422.15" y="665.4" width="173.3" height="72" rx="4" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="1442.15" y="689.4" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
   <path d="M3 9h18" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="2323300" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Product media</text>
+      <text x="1478.15" y="701.4" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Product media</text>
     </g>
     <g role="group" aria-label="Payment provider" data-stack-id="payment" data-node-kind="external">
       <title>Payment provider</title>
-      <polygon points="2528600,124400 2692300,124400 2708300,160400 2692300,196400 2528600,196400 2512600,160400" fill="#E5EBF3" stroke="#64748B" stroke-width="1500"/>
-      <svg x="2532600" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="2568600" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Payment provider</text>
+      <polygon points="2122.65,354.9 2286.35,354.9 2302.35,390.9 2286.35,426.9 2122.65,426.9 2106.65,390.9" fill="#E5EBF3" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="2126.65" y="378.9" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="2162.65" y="390.9" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Payment provider</text>
     </g>
     <g role="group" aria-label="Email provider" data-stack-id="email" data-node-kind="external">
       <title>Email provider</title>
-      <polygon points="2748300,124400 2888900,124400 2904900,160400 2888900,196400 2748300,196400 2732300,160400" fill="#E5EBF3" stroke="#64748B" stroke-width="1500"/>
-      <svg x="2752300" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="2788300" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Email provider</text>
+      <polygon points="2134.2,450.9 2274.8,450.9 2290.8,486.9 2274.8,522.9 2134.2,522.9 2118.2,486.9" fill="#E5EBF3" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="2138.2" y="474.9" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-external"><path d="M11 5H5v14h14v-6M13 5h6v6M19 5l-9 9" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="2174.2" y="486.9" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Email provider</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="Browse and buy">
-      <rect x="162450" y="238200" width="96700" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="210800" y="249900" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Browse and buy</text>
+      <rect x="224.975" y="392.4" width="96.7" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="273.325" y="404.1" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Browse and buy</text>
     </g>
     <g data-edge-label="HTTPS">
-      <rect x="406200" y="93000" width="45000" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="428700" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">HTTPS</text>
+      <rect x="473.05" y="427.4" width="45" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="495.55" y="439.1" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">HTTPS</text>
     </g>
     <g data-edge-label="Catalog requests">
-      <rect x="596800" y="204400" width="102200" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="647900" y="216100" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Catalog requests</text>
+      <rect x="612.516" y="471.4" width="102.2" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="663.616" y="483.1" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Catalog requests</text>
     </g>
     <g data-edge-label="Checkout requests">
-      <rect x="701475" y="93000" width="112650" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="757800" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Checkout requests</text>
+      <rect x="607.291" y="510.8" width="112.65" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="663.616" y="522.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Checkout requests</text>
     </g>
     <g data-edge-label="SQL">
-      <rect x="1345700" y="93000" width="31800" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1361600" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">SQL</text>
+      <rect x="1239.9" y="465.7" width="31.8" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1255.8" y="477.4" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">SQL</text>
     </g>
     <g data-edge-label="Media URLs">
-      <rect x="1536725" y="93000" width="73050" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1573250" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Media URLs</text>
+      <rect x="1169.3" y="670" width="73.05" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1205.825" y="681.7" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Media URLs</text>
     </g>
     <g data-edge-label="Transactions">
-      <rect x="1536850" y="204400" width="82400" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1578050" y="216100" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Transactions</text>
+      <rect x="1253.425" y="407.5" width="82.4" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1294.625" y="419.2" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Transactions</text>
     </g>
     <g data-edge-label="Payment API">
-      <rect x="1763500" y="204400" width="78000" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1802500" y="216100" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Payment API</text>
+      <rect x="1704.8" y="389.8" width="78" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1743.8" y="401.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Payment API</text>
     </g>
     <g data-edge-label="OrderPlaced">
-      <rect x="1089925" y="93000" width="76350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1128100" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">OrderPlaced</text>
+      <rect x="1396.95" y="323.8" width="76.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1435.125" y="335.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">OrderPlaced</text>
     </g>
     <g data-edge-label="OrderPlaced">
-      <rect x="1298025" y="204400" width="76350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1336200" y="216100" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">OrderPlaced</text>
+      <rect x="1579.625" y="200.7" width="76.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1617.8" y="212.4" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">OrderPlaced</text>
     </g>
     <g data-edge-label="OrderPlaced">
-      <rect x="1408575" y="93000" width="76350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="1446750" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">OrderPlaced</text>
+      <rect x="1579.625" y="240.1" width="76.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1617.8" y="251.8" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">OrderPlaced</text>
     </g>
     <g data-edge-label="Send receipt">
-      <rect x="2212875" y="93000" width="78550" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="2252150" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Send receipt</text>
+      <rect x="1962.1" y="375.65" width="78.55" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="2001.375" y="387.35" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Send receipt</text>
     </g>
   </g>
 </svg>
diff --git a/layout-corpus/snapshots/fanout-cross-edges.svg b/layout-corpus/snapshots/fanout-cross-edges.svg
index 5a706aa..c769c1d 100644
--- a/layout-corpus/snapshots/fanout-cross-edges.svg
+++ b/layout-corpus/snapshots/fanout-cross-edges.svg
@@ -1,162 +1,161 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="1036.3" height="366.2" viewBox="0 0 1036300 366200" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="1391.3" height="397" viewBox="0 0 1391.3 397" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Fan-out and cross edges</title>
   <desc id="stack-description">Architecture diagram with 8 nodes, 0 groups, and 10 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="1036300" height="366200" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="1391.3" height="397" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Fan-out and cross edges</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Fan-out and cross edges</text>
   <g data-stack-layer="groups">
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Ingress flows to Identity service: Authenticate" data-edge-kind="request" data-edge-direction="forward">
       <title>Ingress flows to Identity service: Authenticate</title>
-      <polyline points="192000,106200 216000,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,217.6 200,217.6 200,106.2 304.75,106.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Ingress flows to Catalog service: Browse" data-edge-kind="request" data-edge-direction="forward">
       <title>Ingress flows to Catalog service: Browse</title>
-      <polyline points="192000,106200 192000,202200 216000,202200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,217.6 304.75,217.6" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Ingress flows to Checkout service: Purchase" data-edge-kind="request" data-edge-direction="forward">
       <title>Ingress flows to Checkout service: Purchase</title>
-      <polyline points="192000,106200 192000,298200 216000,298200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,217.6 200,217.6 200,329 304.75,329" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Identity service flows to Primary database: Session" data-edge-kind="data" data-edge-direction="forward">
       <title>Identity service flows to Primary database: Session</title>
-      <polyline points="397700,106200 397700,70200 808600,70200 808600,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="486.45,106.2 1058.85,106.2 1058.85,161.9 1163.6,161.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Catalog service flows to Primary database: Products" data-edge-kind="data" data-edge-direction="forward">
       <title>Catalog service flows to Primary database: Products</title>
-      <polyline points="397000,202200 808600,202200 808600,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="485.75,217.6 603.8,217.6 603.8,173.6 1155.6,173.6 1155.6,161.9 1163.6,161.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout service flows to Order events: OrderPlaced" data-edge-kind="event" data-edge-direction="forward">
       <title>Checkout service flows to Order events: OrderPlaced</title>
-      <polyline points="410300,298200 410300,106200 434300,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="499.05,329 693.2,329 693.2,253.6" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Order events flows to Order worker: Dispatch" data-edge-kind="event" data-edge-direction="forward">
       <title>Order events flows to Order worker: Dispatch</title>
-      <polyline points="597100,106200 621100,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="774.6,217.6 887.35,217.6" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Order worker flows to Primary database: Persist" data-edge-kind="data" data-edge-direction="forward">
       <title>Order worker flows to Primary database: Persist</title>
-      <polyline points="784600,106200 808600,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1050.85,217.6 1261.45,217.6 1261.45,197.9" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Identity service flows to Audit archive: Access log" data-edge-kind="data" data-edge-direction="forward">
       <title>Identity service flows to Audit archive: Access log</title>
-      <polyline points="397700,106200 397700,202200 808600,202200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="486.45,106.2 494.45,106.2 494.45,273.3 1163.6,273.3" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout service flows to Audit archive: Checkout log" data-edge-kind="data" data-edge-direction="forward">
       <title>Checkout service flows to Audit archive: Checkout log</title>
-      <polyline points="410300,298200 410300,202200 808600,202200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="499.05,329 507.05,329 507.05,317.3 1245.7,317.3 1245.7,309.3" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Ingress" data-stack-id="ingress" data-node-kind="service">
       <title>Ingress</title>
-      <rect x="32000" y="70200" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="52000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="32" y="181.6" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="52" y="205.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h5M5.5 5.5 8 8l-2.5 2.5M21 16h-5M18.5 13.5 16 16l2.5 2.5" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="88000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Ingress</text>
+      <text x="88" y="217.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Ingress</text>
     </g>
     <g role="group" aria-label="Identity service" data-stack-id="auth" data-node-kind="service">
       <title>Identity service</title>
-      <rect x="216000" y="70200" width="181700" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="236000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="identity"><path d="M12 3 5 6v5c0 4.5 2.8 8.2 7 10 4.2-1.8 7-5.5 7-10V6l-7-3Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
+      <rect x="304.75" y="70.2" width="181.7" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="324.75" y="94.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="identity"><path d="M12 3 5 6v5c0 4.5 2.8 8.2 7 10 4.2-1.8 7-5.5 7-10V6l-7-3Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
   <circle cx="12" cy="10" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8.5 16c.5-2 1.7-3 3.5-3s3 1 3.5 3" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="272000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Identity service</text>
+      <text x="360.75" y="106.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Identity service</text>
     </g>
     <g role="group" aria-label="Catalog service" data-stack-id="catalog" data-node-kind="service">
       <title>Catalog service</title>
-      <rect x="216000" y="166200" width="181000" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="236000" y="190200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="304.75" y="181.6" width="181" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="324.75" y="205.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="272000" y="202200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Catalog service</text>
+      <text x="360.75" y="217.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Catalog service</text>
     </g>
     <g role="group" aria-label="Checkout service" data-stack-id="checkout" data-node-kind="service">
       <title>Checkout service</title>
-      <rect x="216000" y="262200" width="194300" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="236000" y="286200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="304.75" y="293" width="194.3" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="324.75" y="317" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="272000" y="298200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Checkout service</text>
+      <text x="360.75" y="329" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Checkout service</text>
     </g>
     <g role="group" aria-label="Order events" data-stack-id="events" data-node-kind="queue">
       <title>Order events</title>
-      <rect x="434300" y="70200" width="162800" height="72000" rx="16000" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="454300" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="611.8" y="181.6" width="162.8" height="72" rx="16" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="631.8" y="205.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <circle cx="5" cy="17" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M7 7h10l3 3-3 3H7M7 17h12" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="490300" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Order events</text>
+      <text x="667.8" y="217.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Order events</text>
     </g>
     <g role="group" aria-label="Order worker" data-stack-id="worker" data-node-kind="worker">
       <title>Order worker</title>
-      <rect x="621100" y="70200" width="163500" height="72000" rx="16000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="641100" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="887.35" y="181.6" width="163.5" height="72" rx="16" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="907.35" y="205.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="677100" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Order worker</text>
+      <text x="943.35" y="217.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Order worker</text>
     </g>
     <g role="group" aria-label="Primary database" data-stack-id="database" data-node-kind="database">
       <title>Primary database</title>
-      <path d="M 808600 80200 V 132200 C 808600 142200 1004300 142200 1004300 132200 V 80200 C 1004300 70200 808600 70200 808600 80200 Z" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <ellipse cx="906450" cy="80200" rx="97850" ry="10000" fill="none" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="828600" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="1163.6" y="125.9" width="195.7" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="1183.6" y="149.9" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="864600" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Primary database</text>
+      <text x="1219.6" y="161.9" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Primary database</text>
     </g>
     <g role="group" aria-label="Audit archive" data-stack-id="audit" data-node-kind="storage">
       <title>Audit archive</title>
-      <rect x="808600" y="166200" width="164200" height="72000" rx="4000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="828600" y="190200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
+      <rect x="1163.6" y="237.3" width="164.2" height="72" rx="4" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="1183.6" y="261.3" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
   <path d="M3 9h18" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="864600" y="202200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Audit archive</text>
+      <text x="1219.6" y="273.3" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Audit archive</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="Authenticate">
-      <rect x="164450" y="38800" width="79100" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="204000" y="50500" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Authenticate</text>
+      <rect x="208" y="150.2" width="79.1" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="247.55" y="161.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Authenticate</text>
     </g>
     <g data-edge-label="Browse">
-      <rect x="156400" y="154500" width="51600" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="182200" y="166200" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Browse</text>
+      <rect x="222.575" y="186.2" width="51.6" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="248.375" y="197.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Browse</text>
     </g>
     <g data-edge-label="Purchase">
-      <rect x="145400" y="202500" width="62600" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="176700" y="214200" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Purchase</text>
+      <rect x="208" y="261.6" width="62.6" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="239.3" y="273.3" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Purchase</text>
     </g>
     <g data-edge-label="Session">
-      <rect x="575975" y="38800" width="54350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="603150" y="50500" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Session</text>
+      <rect x="745.475" y="74.8" width="54.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="772.65" y="86.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Session</text>
     </g>
     <g data-edge-label="Products">
-      <rect x="620875" y="190500" width="59850" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="650800" y="202200" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Products</text>
+      <rect x="849.775" y="142.2" width="59.85" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="879.7" y="153.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Products</text>
     </g>
     <g data-edge-label="OrderPlaced">
-      <rect x="405000" y="178500" width="76350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="443175" y="190200" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">OrderPlaced</text>
+      <rect x="557.95" y="337" width="76.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="596.125" y="348.7" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">OrderPlaced</text>
     </g>
     <g data-edge-label="Dispatch">
-      <rect x="580000" y="147100" width="58200" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="609100" y="158800" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Dispatch</text>
+      <rect x="801.875" y="186.2" width="58.2" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="830.975" y="197.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Dispatch</text>
     </g>
     <g data-edge-label="Persist">
-      <rect x="771900" y="38800" width="49400" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="796600" y="50500" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Persist</text>
+      <rect x="1096.35" y="186.2" width="49.4" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1121.05" y="197.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Persist</text>
     </g>
     <g data-edge-label="Access log">
-      <rect x="520000" y="190500" width="70300" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="555150" y="202200" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Access log</text>
+      <rect x="793.875" y="241.9" width="70.3" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="829.025" y="253.6" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Access log</text>
     </g>
     <g data-edge-label="Checkout log">
-      <rect x="521075" y="221900" width="80750" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="561450" y="233600" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Checkout log</text>
+      <rect x="836" y="285.9" width="80.75" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="876.375" y="297.6" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Checkout log</text>
     </g>
   </g>
 </svg>
diff --git a/layout-corpus/snapshots/medium-group-flow.svg b/layout-corpus/snapshots/medium-group-flow.svg
index 60b842a..1266a4c 100644
--- a/layout-corpus/snapshots/medium-group-flow.svg
+++ b/layout-corpus/snapshots/medium-group-flow.svg
@@ -1,115 +1,114 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="931.5" height="444.4" viewBox="0 0 931500 444400" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="1195" height="539.2" viewBox="0 0 1195 539.2" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Medium group flow</title>
   <desc id="stack-description">Architecture diagram with 6 nodes, 2 groups, and 5 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="931500" height="444400" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="1195" height="539.2" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Medium group flow</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Medium group flow</text>
   <g data-stack-layer="groups">
     <g role="group" aria-label="Clients" data-stack-id="clients">
       <title>Clients</title>
-      <rect x="32000" y="70200" width="392000" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="56000" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Clients</text>
+      <rect x="32" y="197.6" width="424" height="182.2" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="72" y="250.6" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Clients</text>
     </g>
     <g role="group" aria-label="Platform" data-stack-id="platform">
       <title>Platform</title>
-      <rect x="643200" y="70200" width="256300" height="342200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="667200" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Platform</text>
+      <rect x="874.7" y="70.2" width="288.3" height="437" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="914.7" y="123.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Platform</text>
     </g>
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Browser flows to Edge gateway: Browser HTTPS" data-edge-kind="request" data-edge-direction="forward">
       <title>Browser flows to Edge gateway: Browser HTTPS</title>
-      <polyline points="216000,160400 216000,106200 448000,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="232,303.8 248,303.8 248,259.8 474,259.8 474,288.7 579.75,288.7" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Mobile app flows to Edge gateway: Mobile HTTPS" data-edge-kind="request" data-edge-direction="forward">
       <title>Mobile app flows to Edge gateway: Mobile HTTPS</title>
-      <polyline points="400000,160400 400000,106200 448000,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="416,303.8 571.75,303.8 571.75,288.7 579.75,288.7" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Edge gateway flows to Application API: Route" data-edge-kind="request" data-edge-direction="forward">
       <title>Edge gateway flows to Application API: Route</title>
-      <polyline points="619200,106200 619200,160400 667200,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="750.95,288.7 906.7,288.7 906.7,176.4 931.5,176.4" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Application API flows to Background worker: Dispatch" data-edge-kind="event" data-edge-direction="forward">
       <title>Application API flows to Background worker: Dispatch</title>
-      <polyline points="754550,196400 754550,220400 771350,220400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1018.85,212.4 1018.85,267.8" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Background worker flows to Primary database: Persist" data-edge-kind="data" data-edge-direction="forward">
       <title>Background worker flows to Primary database: Persist</title>
-      <polyline points="771350,292400 771350,316400 765050,316400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="1018.85,339.8 1018.85,395.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Browser" data-stack-id="browser" data-node-kind="client">
       <title>Browser</title>
-      <rect x="56000" y="124400" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="76000" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="72" y="267.8" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="92" y="291.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h18M7 6h.01M10 6h.01" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="112000" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Browser</text>
+      <text x="128" y="303.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Browser</text>
     </g>
     <g role="group" aria-label="Mobile app" data-stack-id="mobile" data-node-kind="client">
       <title>Mobile app</title>
-      <rect x="240000" y="124400" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="260000" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="mobile"><rect x="6" y="2" width="12" height="20" rx="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="256" y="267.8" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="276" y="291.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="mobile"><rect x="6" y="2" width="12" height="20" rx="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M10 5h4M11 19h2" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="296000" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Mobile app</text>
+      <text x="312" y="303.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Mobile app</text>
     </g>
     <g role="group" aria-label="Edge gateway" data-stack-id="gateway" data-node-kind="service">
       <title>Edge gateway</title>
-      <rect x="448000" y="70200" width="171200" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="468000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="579.75" y="252.7" width="171.2" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="599.75" y="276.7" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="gateway"><rect x="8" y="4" width="8" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h5M5.5 5.5 8 8l-2.5 2.5M21 16h-5M18.5 13.5 16 16l2.5 2.5" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="504000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Edge gateway</text>
+      <text x="635.75" y="288.7" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Edge gateway</text>
     </g>
     <g role="group" aria-label="Application API" data-stack-id="api" data-node-kind="service">
       <title>Application API</title>
-      <rect x="667200" y="124400" width="174700" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="687200" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="931.5" y="140.4" width="174.7" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="951.5" y="164.4" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="723200" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Application API</text>
+      <text x="987.5" y="176.4" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Application API</text>
     </g>
     <g role="group" aria-label="Background worker" data-stack-id="worker" data-node-kind="worker">
       <title>Background worker</title>
-      <rect x="667200" y="220400" width="208300" height="72000" rx="16000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="687200" y="244400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="914.7" y="267.8" width="208.3" height="72" rx="16" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="934.7" y="291.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="723200" y="256400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Background worker</text>
+      <text x="970.7" y="303.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Background worker</text>
     </g>
     <g role="group" aria-label="Primary database" data-stack-id="database" data-node-kind="database">
       <title>Primary database</title>
-      <path d="M 667200 326400 V 378400 C 667200 388400 862900 388400 862900 378400 V 326400 C 862900 316400 667200 316400 667200 326400 Z" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <ellipse cx="765050" cy="326400" rx="97850" ry="10000" fill="none" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="687200" y="340400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="921" y="395.2" width="195.7" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="941" y="419.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="723200" y="352400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Primary database</text>
+      <text x="977" y="431.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Primary database</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="Browser HTTPS">
-      <rect x="259025" y="94500" width="91750" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="304900" y="106200" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Browser HTTPS</text>
+      <rect x="315.125" y="228.4" width="91.75" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="361" y="240.1" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Browser HTTPS</text>
     </g>
     <g data-edge-label="Mobile HTTPS">
-      <rect x="358800" y="97600" width="82400" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="400000" y="109300" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Mobile HTTPS</text>
+      <rect x="478.633" y="311.8" width="82.4" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="519.833" y="323.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Mobile HTTPS</text>
     </g>
     <g data-edge-label="Route">
-      <rect x="598075" y="145600" width="42250" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="619200" y="157300" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Route</text>
+      <rect x="807.7" y="257.3" width="42.25" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="828.825" y="269" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Route</text>
     </g>
     <g data-edge-label="Dispatch">
-      <rect x="725450" y="93000" width="58200" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="754550" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Dispatch</text>
+      <rect x="1026.85" y="228.4" width="58.2" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1055.95" y="240.1" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Dispatch</text>
     </g>
     <g data-edge-label="Persist">
-      <rect x="746650" y="396400" width="49400" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="771350" y="408100" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Persist</text>
+      <rect x="1026.85" y="355.8" width="49.4" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="1051.55" y="367.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Persist</text>
     </g>
   </g>
 </svg>
diff --git a/layout-corpus/snapshots/multilingual-long-labels.svg b/layout-corpus/snapshots/multilingual-long-labels.svg
index be32132..3d6b7de 100644
--- a/layout-corpus/snapshots/multilingual-long-labels.svg
+++ b/layout-corpus/snapshots/multilingual-long-labels.svg
@@ -1,79 +1,78 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="394.1" height="463.8" viewBox="0 0 394100 463800" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="light" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="467.7" height="558" viewBox="0 0 467.7 558" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="light" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Multilingual long labels</title>
   <desc id="stack-description">Architecture diagram with 4 nodes, 0 groups, and 3 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="394100" height="463800" fill="#FAF9F6"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="467.7" height="558" fill="#FAF9F6"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="6500" markerHeight="6500" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="6.5" markerHeight="6.5" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#57534E"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#1C1917" font-family="system-ui" font-size="13000" font-weight="600">Multilingual long labels</text>
+  <text x="32" y="50.2" fill="#1C1917" font-family="system-ui" font-size="13" font-weight="600">Multilingual long labels</text>
   <g data-stack-layer="groups">
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="注文受付サービス flows to 상품 정보 보강 워커: 注文内容を非同期で検証" data-edge-kind="event" data-edge-direction="forward">
       <title>注文受付サービス flows to 상품 정보 보강 워커: 注文内容を非同期で検証</title>
-      <polyline points="134500,142600 134500,166600 167500,166600" fill="none" stroke="#57534E" stroke-width="1250" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="197.05,142.6 197.05,198" fill="none" stroke="#57534E" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="상품 정보 보강 워커 flows to Real-time analytical event warehouse: 정규화된 분석 이벤트 적재" data-edge-kind="data" data-edge-direction="forward">
       <title>상품 정보 보강 워커 flows to Real-time analytical event warehouse: 정규화된 분석 이벤트 적재</title>
-      <polyline points="167500,239000 167500,263000 197050,263000" fill="none" stroke="#57534E" stroke-width="1250" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="197.05,270.4 197.05,325.8" fill="none" stroke="#57534E" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Real-time analytical event warehouse flows to 長期監査ログアーカイブ: Immutable compliance snapshot export" data-edge-kind="data" data-edge-direction="forward">
       <title>Real-time analytical event warehouse flows to 長期監査ログアーカイブ: Immutable compliance snapshot export</title>
-      <polyline points="32000,299200 32000,395600" fill="none" stroke="#57534E" stroke-width="1250" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="197.05,398.2 197.05,453.6" fill="none" stroke="#57534E" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="注文受付サービス: Customer order intake" data-stack-id="intake" data-node-kind="service">
       <title>注文受付サービス: Customer order intake</title>
-      <rect x="32000" y="70200" width="205000" height="72400" rx="8000" fill="#FFFFFF" stroke="#005DBB" stroke-width="1500"/>
-      <svg x="52000" y="94400" width="24000" height="24000" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.5"/>
+      <rect x="94.55" y="70.2" width="205" height="72.4" rx="8" fill="#FFFFFF" stroke="#005DBB" stroke-width="1.5"/>
+      <svg x="114.55" y="94.4" width="24" height="24" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-service"><rect x="4" y="4" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.5"/>
   <rect x="4" y="15" width="16" height="5" rx="2" fill="none" stroke="currentColor" stroke-width="1.5"/>
   <path d="M8 9v6M16 9v6" fill="none" stroke="currentColor" stroke-width="1.5"/> </svg>
-      <text x="88000" y="97400" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14000" font-weight="600">注文受付サービス</text>
-      <text x="88000" y="116400" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12000" font-weight="400">Customer order intake</text>
+      <text x="150.55" y="97.4" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14" font-weight="600">注文受付サービス</text>
+      <text x="150.55" y="116.4" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12" font-weight="400">Customer order intake</text>
     </g>
     <g role="group" aria-label="상품 정보 보강 워커: Catalog and inventory enrichment" data-stack-id="enrichment" data-node-kind="worker">
       <title>상품 정보 보강 워커: Catalog and inventory enrichment</title>
-      <rect x="32000" y="166600" width="271000" height="72400" rx="16000" fill="#FFFFFF" stroke="#78716C" stroke-width="1500"/>
-      <svg x="52000" y="190800" width="24000" height="24000" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.5"/>
+      <rect x="61.55" y="198" width="271" height="72.4" rx="16" fill="#FFFFFF" stroke="#78716C" stroke-width="1.5"/>
+      <svg x="81.55" y="222.2" width="24" height="24" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.5"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/> </svg>
-      <text x="88000" y="193800" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14000" font-weight="600">상품 정보 보강 워커</text>
-      <text x="88000" y="212800" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12000" font-weight="400">Catalog and inventory enrichment</text>
+      <text x="117.55" y="225.2" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14" font-weight="600">상품 정보 보강 워커</text>
+      <text x="117.55" y="244.2" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12" font-weight="400">Catalog and inventory enrichment</text>
     </g>
     <g role="group" aria-label="Real-time analytical event warehouse: Cross-region reporting dataset" data-stack-id="analytics" data-node-kind="database">
       <title>Real-time analytical event warehouse: Cross-region reporting dataset</title>
-      <path d="M 32000 273000 V 325400 C 32000 335400 362100 335400 362100 325400 V 273000 C 362100 263000 32000 263000 32000 273000 Z" fill="#FFFFFF" stroke="#005DBB" stroke-width="1500"/>
-      <ellipse cx="197050" cy="273000" rx="165050" ry="10000" fill="none" stroke="#005DBB" stroke-width="1500"/>
-      <svg x="52000" y="287200" width="24000" height="24000" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.5"/>
+      <rect x="32" y="325.8" width="330.1" height="72.4" rx="8" fill="#FFFFFF" stroke="#005DBB" stroke-width="1.5"/>
+      <svg x="52" y="350" width="24" height="24" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.5"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.5"/> </svg>
-      <text x="88000" y="290200" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14000" font-weight="600">Real-time analytical event warehouse</text>
-      <text x="88000" y="309200" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12000" font-weight="400">Cross-region reporting dataset</text>
+      <text x="88" y="353" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14" font-weight="600">Real-time analytical event warehouse</text>
+      <text x="88" y="372" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12" font-weight="400">Cross-region reporting dataset</text>
     </g>
     <g role="group" aria-label="長期監査ログアーカイブ: Seven-year retention" data-stack-id="archive" data-node-kind="storage">
       <title>長期監査ログアーカイブ: Seven-year retention</title>
-      <rect x="32000" y="359400" width="230000" height="72400" rx="4000" fill="#FFFFFF" stroke="#78716C" stroke-width="1500"/>
-      <svg x="52000" y="383600" width="24000" height="24000" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/>
+      <rect x="82.05" y="453.6" width="230" height="72.4" rx="4" fill="#FFFFFF" stroke="#78716C" stroke-width="1.5"/>
+      <svg x="102.05" y="477.8" width="24" height="24" viewBox="0 0 24 24" color="#005DBB" aria-hidden="true" focusable="false" data-icon-id="kind-storage"><path d="M3 6h7l2 3h9v10H3V6Z" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/>
   <path d="M3 9h18" fill="none" stroke="currentColor" stroke-width="1.5"/> </svg>
-      <text x="88000" y="386600" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14000" font-weight="600">長期監査ログアーカイブ</text>
-      <text x="88000" y="405600" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12000" font-weight="400">Seven-year retention</text>
+      <text x="138.05" y="480.8" dominant-baseline="middle" fill="#1C1917" font-family="system-ui" font-size="14" font-weight="600">長期監査ログアーカイブ</text>
+      <text x="138.05" y="499.8" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="12" font-weight="400">Seven-year retention</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="注文内容を非同期で検証">
-      <rect x="72500" y="38800" width="133000" height="23400" rx="4000" fill="#FAF9F6"/>
-      <text x="139000" y="50500" text-anchor="middle" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="11000">注文内容を非同期で検証</text>
+      <rect x="205.05" y="158.6" width="133" height="23.4" rx="4" fill="#FAF9F6"/>
+      <text x="271.55" y="170.3" text-anchor="middle" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="11">注文内容を非同期で検証</text>
     </g>
     <g data-edge-label="정규화된 분석 이벤트 적재">
-      <rect x="99650" y="439800" width="141250" height="23400" rx="4000" fill="#FAF9F6"/>
-      <text x="170275" y="451500" text-anchor="middle" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="11000">정규화된 분석 이벤트 적재</text>
+      <rect x="205.05" y="286.4" width="141.25" height="23.4" rx="4" fill="#FAF9F6"/>
+      <text x="275.675" y="298.1" text-anchor="middle" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="11">정규화된 분석 이벤트 적재</text>
     </g>
     <g data-edge-label="Immutable compliance snapshot export">
-      <rect x="-79325" y="335700" width="222650" height="23400" rx="4000" fill="#FAF9F6"/>
-      <text x="32000" y="347400" text-anchor="middle" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="11000">Immutable compliance snapshot export</text>
+      <rect x="205.05" y="414.2" width="222.65" height="23.4" rx="4" fill="#FAF9F6"/>
+      <text x="316.375" y="425.9" text-anchor="middle" dominant-baseline="middle" fill="#57534E" font-family="system-ui" font-size="11">Immutable compliance snapshot export</text>
     </g>
   </g>
 </svg>
diff --git a/layout-corpus/snapshots/nested-platform.svg b/layout-corpus/snapshots/nested-platform.svg
index 3529458..c0f093f 100644
--- a/layout-corpus/snapshots/nested-platform.svg
+++ b/layout-corpus/snapshots/nested-platform.svg
@@ -1,138 +1,137 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="713.2" height="679" viewBox="0 0 713200 679000" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="876.15" height="1093.2" viewBox="0 0 876.15 1093.2" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Nested platform boundaries</title>
   <desc id="stack-description">Architecture diagram with 7 nodes, 4 groups, and 6 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="713200" height="679000" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="876.15" height="1093.2" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Nested platform boundaries</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Nested platform boundaries</text>
   <g data-stack-layer="groups">
     <g role="group" aria-label="Platform" data-stack-id="platform">
       <title>Platform</title>
-      <rect x="216000" y="70200" width="465200" height="576800" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="240000" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Platform</text>
+      <rect x="269" y="70.2" width="575.15" height="991" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="309" y="123.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Platform</text>
     </g>
     <g role="group" aria-label="Experience" data-stack-id="experience">
       <title>Experience</title>
-      <rect x="240000" y="124400" width="415100" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="264000" y="161400" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Experience</text>
+      <rect x="419.125" y="140.4" width="274.9" height="309.6" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="459.125" y="193.4" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Experience</text>
     </g>
     <g role="group" aria-label="Processing" data-stack-id="processing">
       <title>Processing</title>
-      <rect x="240000" y="298600" width="394800" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="264000" y="335600" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Processing</text>
+      <rect x="309" y="505.4" width="495.15" height="182.2" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="349" y="558.4" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Processing</text>
     </g>
     <g role="group" aria-label="Operations" data-stack-id="operations">
       <title>Operations</title>
-      <rect x="240000" y="472800" width="417200" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="264000" y="509800" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Operations</text>
+      <rect x="423.975" y="743" width="265.2" height="278.2" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="463.975" y="796" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Operations</text>
     </g>
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Customer flows to Web application: HTTPS" data-edge-kind="request" data-edge-direction="forward">
       <title>Customer flows to Web application: HTTPS</title>
-      <polyline points="192000,150200 192000,214600 264000,214600" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="112,485.7 112,246.6 459.125,246.6" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Web application is connected bidirectionally with Public API: Live checkout" data-edge-kind="flow" data-edge-direction="bidirectional">
       <title>Web application is connected bidirectionally with Public API: Live checkout</title>
-      <polyline points="447100,214600 471100,214600" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-start="url(#stack-arrow)" marker-end="url(#stack-arrow)" />
+      <polyline points="550.675,282.6 550.675,338" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-start="url(#stack-arrow)" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Public API flows to Checkout: Invoke" data-edge-kind="dependency" data-edge-direction="forward">
       <title>Public API flows to Checkout: Invoke</title>
-      <polyline points="471100,214600 447100,214600 447100,388800 424000,388800" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="470.675,374 437.125,374 437.125,567.6 429,567.6 429,575.6" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout flows to Order events: OrderPlaced" data-edge-kind="event" data-edge-direction="forward">
       <title>Checkout flows to Order events: OrderPlaced</title>
-      <polyline points="424000,388800 448000,388800" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="509,611.6 601.35,611.6" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Checkout flows to Orders: Transaction" data-edge-kind="data" data-edge-direction="forward">
       <title>Checkout flows to Orders: Transaction</title>
-      <polyline points="344000,424800 344000,527000" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="509,611.6 556.575,611.6 556.575,813.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Public API is associated with Error monitoring: Telemetry" data-edge-kind="data" data-edge-direction="association">
       <title>Public API is associated with Error monitoring: Telemetry</title>
-      <polyline points="631100,214600 633200,214600 633200,563000" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="8000 6000" />
+      <polyline points="470.675,374 341,374 341,945.2 463.975,945.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="8 6" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Customer" data-stack-id="customer" data-node-kind="actor">
       <title>Customer</title>
-      <circle cx="112000" cy="150200" r="80000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="52000" y="138200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-actor"><circle cx="12" cy="8" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <circle cx="112" cy="565.7" r="80" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="52" y="553.7" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-actor"><circle cx="12" cy="8" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M5 20c.8-4 3-6 7-6s6.2 2 7 6" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="88000" y="150200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Customer</text>
+      <text x="88" y="565.7" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Customer</text>
     </g>
     <g role="group" aria-label="Web application" data-stack-id="web" data-node-kind="client">
       <title>Web application</title>
-      <rect x="264000" y="178600" width="183100" height="72000" rx="8000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="284000" y="202600" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="459.125" y="210.6" width="183.1" height="72" rx="8" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="479.125" y="234.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h18M7 6h.01M10 6h.01" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="320000" y="214600" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Web application</text>
+      <text x="515.125" y="246.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Web application</text>
     </g>
     <g role="group" aria-label="Public API" data-stack-id="api" data-node-kind="service">
       <title>Public API</title>
-      <rect x="471100" y="178600" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="491100" y="202600" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="api"><path d="m8 7-5 5 5 5M16 7l5 5-5 5M14 4l-4 16" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="527100" y="214600" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Public API</text>
+      <rect x="470.675" y="338" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="490.675" y="362" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="api"><path d="m8 7-5 5 5 5M16 7l5 5-5 5M14 4l-4 16" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="526.675" y="374" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Public API</text>
     </g>
     <g role="group" aria-label="Checkout" data-stack-id="checkout" data-node-kind="function">
       <title>Checkout</title>
-      <polygon points="280000,352800 408000,352800 424000,388800 408000,424800 280000,424800 264000,388800" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="284000" y="376800" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-function"><path d="M6 20 11 4h2l5 16M8 14h8" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="320000" y="388800" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Checkout</text>
+      <polygon points="365,575.6 493,575.6 509,611.6 493,647.6 365,647.6 349,611.6" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="369" y="599.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-function"><path d="M6 20 11 4h2l5 16M8 14h8" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="405" y="611.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Checkout</text>
     </g>
     <g role="group" aria-label="Order events" data-stack-id="events" data-node-kind="queue">
       <title>Order events</title>
-      <rect x="448000" y="352800" width="162800" height="72000" rx="16000" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="468000" y="376800" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="601.35" y="575.6" width="162.8" height="72" rx="16" fill="#E5EBF3" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="621.35" y="599.6" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-queue"><circle cx="5" cy="7" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <circle cx="5" cy="17" r="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M7 7h10l3 3-3 3H7M7 17h12" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="504000" y="388800" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Order events</text>
+      <text x="657.35" y="611.6" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Order events</text>
     </g>
     <g role="group" aria-label="Orders" data-stack-id="database" data-node-kind="database">
       <title>Orders</title>
-      <path d="M 264000 537000 V 589000 C 264000 599000 424000 599000 424000 589000 V 537000 C 424000 527000 264000 527000 264000 537000 Z" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <ellipse cx="344000" cy="537000" rx="80000" ry="10000" fill="none" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="284000" y="551000" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="476.575" y="813.2" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="496.575" y="837.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="320000" y="563000" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Orders</text>
+      <text x="532.575" y="849.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Orders</text>
     </g>
     <g role="group" aria-label="Error monitoring" data-stack-id="monitoring" data-node-kind="external">
       <title>Error monitoring</title>
-      <polygon points="464000,527000 617200,527000 633200,563000 617200,599000 464000,599000 448000,563000" fill="#E5EBF3" stroke="#64748B" stroke-width="1500"/>
-      <svg x="468000" y="551000" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="observability"><path d="M2.5 12s3.5-6 9.5-6 9.5 6 9.5 6-3.5 6-9.5 6-9.5-6-9.5-6Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
+      <polygon points="479.975,909.2 633.175,909.2 649.175,945.2 633.175,981.2 479.975,981.2 463.975,945.2" fill="#E5EBF3" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="483.975" y="933.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="observability"><path d="M2.5 12s3.5-6 9.5-6 9.5 6 9.5 6-3.5 6-9.5 6-9.5-6-9.5-6Z" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/>
   <path d="m7.5 12 2-2 2.5 4 2.5-4 2 2" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="504000" y="563000" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Error monitoring</text>
+      <text x="519.975" y="945.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Error monitoring</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="HTTPS">
-      <rect x="200000" y="202900" width="45000" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="222500" y="214600" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">HTTPS</text>
+      <rect x="205.208" y="215.2" width="45" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="227.708" y="226.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">HTTPS</text>
     </g>
     <g data-edge-label="Live checkout">
-      <rect x="415425" y="147200" width="87350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="459100" y="158900" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Live checkout</text>
+      <rect x="558.675" y="298.6" width="87.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="602.35" y="310.3" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Live checkout</text>
     </g>
     <g data-edge-label="Invoke">
-      <rect x="422950" y="289550" width="48300" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="447100" y="301250" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Invoke</text>
+      <rect x="445.125" y="459.1" width="48.3" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="469.275" y="470.8" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Invoke</text>
     </g>
     <g data-edge-label="OrderPlaced">
-      <rect x="397825" y="321400" width="76350" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="436000" y="333100" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">OrderPlaced</text>
+      <rect x="517" y="580.2" width="76.35" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="555.175" y="591.9" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">OrderPlaced</text>
     </g>
     <g data-edge-label="Transaction">
-      <rect x="306100" y="464200" width="75800" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="344000" y="475900" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Transaction</text>
+      <rect x="564.575" y="700.7" width="75.8" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="602.475" y="712.4" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Transaction</text>
     </g>
     <g data-edge-label="Telemetry">
-      <rect x="618800" y="376050" width="65900" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="651750" y="387750" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Telemetry</text>
+      <rect x="349" y="647.9" width="65.9" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="381.95" y="659.6" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Telemetry</text>
     </g>
   </g>
 </svg>
diff --git a/layout-corpus/snapshots/provider-icon-boundary.svg b/layout-corpus/snapshots/provider-icon-boundary.svg
index 2c0f1cf..a25bcba 100644
--- a/layout-corpus/snapshots/provider-icon-boundary.svg
+++ b/layout-corpus/snapshots/provider-icon-boundary.svg
@@ -1,62 +1,62 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="704.4" height="252.4" viewBox="0 0 704400 252400" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="587.5" height="411.8" viewBox="0 0 587.5 411.8" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Provider icon boundary</title>
   <desc id="stack-description">Architecture diagram with 3 nodes, 1 group, and 2 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53; providers example at sha256:6e05b396567a5fa3f141df079c515a8866033b98d11ec4027f486af31f14fa43 using example:storage</metadata>
-  <rect x="0" y="0" width="704400" height="252400" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1; providers example at sha256:6e05b396567a5fa3f141df079c515a8866033b98d11ec4027f486af31f14fa43 using example:storage</metadata>
+  <rect x="0" y="0" width="587.5" height="411.8" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Provider icon boundary</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Provider icon boundary</text>
   <g data-stack-layer="groups">
     <g role="group" aria-label="Provider services" data-stack-id="provider">
       <title>Provider services</title>
-      <rect x="218100" y="70200" width="454300" height="150200" rx="12000" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1000"/>
-      <text x="242100" y="107200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Provider services</text>
+      <rect x="273.85" y="70.2" width="281.65" height="309.6" rx="12" fill="#E5EBF3" fill-opacity="0.55" stroke="#64748B" stroke-width="1"/>
+      <text x="313.85" y="123.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Provider services</text>
     </g>
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Upload client flows to Example Storage: Upload" data-edge-kind="request" data-edge-direction="forward">
       <title>Upload client flows to Example Storage: Upload</title>
-      <polyline points="194100,106200 194100,160400 242100,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="194.1,225 305.85,225 305.85,176.4 314.9,176.4" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Example Storage flows to Object processor: Object created" data-edge-kind="event" data-edge-direction="forward">
       <title>Example Storage flows to Object processor: Object created</title>
-      <polyline points="432200,160400 456200,160400" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="409.95,212.4 409.95,267.8" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Upload client" data-stack-id="upload" data-node-kind="client">
       <title>Upload client</title>
-      <rect x="32000" y="70200" width="162100" height="72000" rx="8000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="52000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="32" y="189" width="162.1" height="72" rx="8" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="52" y="213" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h18M7 6h.01M10 6h.01" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="88000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Upload client</text>
+      <text x="88" y="225" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Upload client</text>
     </g>
     <g role="group" aria-label="Example Storage" data-stack-id="storage" data-node-kind="storage">
       <title>Example Storage</title>
-      <rect x="242100" y="124400" width="190100" height="72000" rx="4000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="262100" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="example:storage"><rect x="2" y="2" width="20" height="20" fill="#4285f4"/> </svg>
-      <text x="298100" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Example Storage</text>
+      <rect x="314.9" y="140.4" width="190.1" height="72" rx="4" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="334.9" y="164.4" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="example:storage"><rect x="2" y="2" width="20" height="20" fill="#4285f4"/> </svg>
+      <text x="370.9" y="176.4" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Example Storage</text>
     </g>
     <g role="group" aria-label="Object processor" data-stack-id="worker" data-node-kind="worker">
       <title>Object processor</title>
-      <rect x="456200" y="124400" width="192200" height="72000" rx="16000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="476200" y="148400" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="313.85" y="267.8" width="192.2" height="72" rx="16" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="333.85" y="291.8" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-worker"><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M12 3v3M12 18v3M3 12h3M18 12h3M5.6 5.6l2.1 2.1M16.3 16.3l2.1 2.1M18.4 5.6l-2.1 2.1M7.7 16.3l-2.1 2.1" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="512200" y="160400" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Object processor</text>
+      <text x="369.85" y="303.8" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Object processor</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="Upload">
-      <rect x="170225" y="145600" width="47750" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="194100" y="157300" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Upload</text>
+      <rect x="207.475" y="193.6" width="47.75" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="231.35" y="205.3" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Upload</text>
     </g>
     <g data-edge-label="Object created">
-      <rect x="399425" y="93000" width="89550" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="444200" y="104700" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">Object created</text>
+      <rect x="417.95" y="228.4" width="89.55" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="462.725" y="240.1" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">Object created</text>
     </g>
   </g>
 </svg>
diff --git a/layout-corpus/snapshots/small-request-path.svg b/layout-corpus/snapshots/small-request-path.svg
index 3cf3928..ce3f510 100644
--- a/layout-corpus/snapshots/small-request-path.svg
+++ b/layout-corpus/snapshots/small-request-path.svg
@@ -1,58 +1,57 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="627.7" height="174.2" viewBox="0 0 627700 174200" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.7.0" data-theme-id="default" data-theme-version="0.5.0" data-theme-revision="sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53">
+<svg xmlns="http://www.w3.org/2000/svg" width="733.7" height="174.2" viewBox="0 0 733.7 174.2" role="img" aria-labelledby="stack-title stack-description" data-engine-version="0.8.0" data-theme-id="default" data-theme-version="0.6.0" data-theme-revision="sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1">
   <title id="stack-title">Small request path</title>
   <desc id="stack-description">Architecture diagram with 3 nodes, 0 groups, and 2 relationships.</desc>
-  <metadata>stack-engine 0.7.0; language 1.0; theme 0.5.0 at sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53</metadata>
-  <rect x="0" y="0" width="627700" height="174200" fill="#F3F6FA"/>
+  <metadata>stack-engine 0.8.0; language 1.0; theme 0.6.0 at sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1</metadata>
+  <rect x="0" y="0" width="733.7" height="174.2" fill="#F3F6FA"/>
   <defs>
-    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7000" markerHeight="7000" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
+    <marker id="stack-arrow" markerUnits="userSpaceOnUse" markerWidth="7" markerHeight="7" refX="9000" refY="5000" viewBox="0 0 10000 10000" orient="auto-start-reverse">
       <path d="M 0 0 L 10000 5000 L 0 10000 z" fill="#475569"/>
     </marker>
   </defs>
-  <text x="32000" y="50200" fill="#142033" font-family="system-ui" font-size="13000" font-weight="600">Small request path</text>
+  <text x="32" y="50.2" fill="#142033" font-family="system-ui" font-size="13" font-weight="600">Small request path</text>
   <g data-stack-layer="groups">
   </g>
   <g data-stack-layer="edges">
     <g role="group" aria-label="Browser flows to Public API: HTTPS" data-edge-kind="request" data-edge-direction="forward">
       <title>Browser flows to Public API: HTTPS</title>
-      <polyline points="192000,106200 216000,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="192,106.2 269,106.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
     <g role="group" aria-label="Public API flows to Primary database: SQL" data-edge-kind="data" data-edge-direction="forward">
       <title>Public API flows to Primary database: SQL</title>
-      <polyline points="376000,106200 400000,106200" fill="none" stroke="#475569" stroke-width="1500" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
+      <polyline points="429,106.2 506,106.2" fill="none" stroke="#475569" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" marker-end="url(#stack-arrow)" />
     </g>
   </g>
   <g data-stack-layer="nodes">
     <g role="group" aria-label="Browser" data-stack-id="browser" data-node-kind="client">
       <title>Browser</title>
-      <rect x="32000" y="70200" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#64748B" stroke-width="1500"/>
-      <svg x="52000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="32" y="70.2" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#64748B" stroke-width="1.5"/>
+      <svg x="52" y="94.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="web"><rect x="3" y="4" width="18" height="16" rx="2" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M3 8h18M7 6h.01M10 6h.01" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/> </svg>
-      <text x="88000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Browser</text>
+      <text x="88" y="106.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Browser</text>
     </g>
     <g role="group" aria-label="Public API" data-stack-id="api" data-node-kind="service">
       <title>Public API</title>
-      <rect x="216000" y="70200" width="160000" height="72000" rx="8000" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="236000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="api"><path d="m8 7-5 5 5 5M16 7l5 5-5 5M14 4l-4 16" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
-      <text x="272000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Public API</text>
+      <rect x="269" y="70.2" width="160" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="289" y="94.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="api"><path d="m8 7-5 5 5 5M16 7l5 5-5 5M14 4l-4 16" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/> </svg>
+      <text x="325" y="106.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Public API</text>
     </g>
     <g role="group" aria-label="Primary database" data-stack-id="database" data-node-kind="database">
       <title>Primary database</title>
-      <path d="M 400000 80200 V 132200 C 400000 142200 595700 142200 595700 132200 V 80200 C 595700 70200 400000 70200 400000 80200 Z" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1500"/>
-      <ellipse cx="497850" cy="80200" rx="97850" ry="10000" fill="none" stroke="#1D63D8" stroke-width="1500"/>
-      <svg x="420000" y="94200" width="24000" height="24000" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
+      <rect x="506" y="70.2" width="195.7" height="72" rx="8" fill="#FFFFFF" stroke="#1D63D8" stroke-width="1.5"/>
+      <svg x="526" y="94.2" width="24" height="24" viewBox="0 0 24 24" color="#1D63D8" aria-hidden="true" focusable="false" data-icon-id="kind-database"><ellipse cx="12" cy="5" rx="8" ry="3" fill="none" stroke="currentColor" stroke-width="1.75"/>
   <path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7" fill="none" stroke="currentColor" stroke-width="1.75"/> </svg>
-      <text x="456000" y="106200" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14000" font-weight="600">Primary database</text>
+      <text x="562" y="106.2" dominant-baseline="middle" fill="#142033" font-family="system-ui" font-size="14" font-weight="600">Primary database</text>
     </g>
   </g>
   <g data-stack-layer="edge-labels" aria-hidden="true">
     <g data-edge-label="HTTPS">
-      <rect x="181500" y="38800" width="45000" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="204000" y="50500" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">HTTPS</text>
+      <rect x="208" y="74.8" width="45" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="230.5" y="86.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">HTTPS</text>
     </g>
     <g data-edge-label="SQL">
-      <rect x="372100" y="38800" width="31800" height="23400" rx="4000" fill="#F3F6FA"/>
-      <text x="388000" y="50500" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11000">SQL</text>
+      <rect x="451.6" y="74.8" width="31.8" height="23.4" rx="4" fill="#F3F6FA"/>
+      <text x="467.5" y="86.5" text-anchor="middle" dominant-baseline="middle" fill="#475569" font-family="system-ui" font-size="11">SQL</text>
     </g>
   </g>
 </svg>
diff --git a/package-lock.json b/package-lock.json
index 0eaea2e..91de3e0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "stack-engine-workspace",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "stack-engine-workspace",
-      "version": "0.7.0",
+      "version": "0.8.0",
       "workspaces": [
         "packages/engine"
       ],
@@ -454,7 +454,7 @@
     },
     "packages/engine": {
       "name": "@stack-sh/engine",
-      "version": "0.7.0",
+      "version": "0.8.0",
       "license": "Apache-2.0"
     }
   }
diff --git a/package.json b/package.json
index 6bdddc1..5534f9d 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "stack-engine-workspace",
   "private": true,
-  "version": "0.7.0",
+  "version": "0.8.0",
   "workspaces": [
     "packages/engine"
   ],
diff --git a/packages/engine/THIRD_PARTY_LICENSES.md b/packages/engine/THIRD_PARTY_LICENSES.md
index 2cbe7d6..706c690 100644
--- a/packages/engine/THIRD_PARTY_LICENSES.md
+++ b/packages/engine/THIRD_PARTY_LICENSES.md
@@ -5,7 +5,7 @@
 | Component | Version / revision | Selected license | Source |
 | --- | --- | --- | --- |
 | `stack-compiler` | `0.1.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/compiler> |
-| `stack-theme` | `0.5.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> |
+| `stack-theme` | `0.6.0 (crates.io)` | Apache-2.0 | <https://github.com/stack-sh/theme> |
 | `roxmltree` | `0.21.1` | Apache-2.0 | <https://github.com/RazrFalcon/roxmltree> |
 | `sha2`, `digest`, `block-buffer`, `crypto-common`, `hybrid-array`, `const-oid`, `typenum` | `0.11.0`, `0.11.3`, `0.12.1`, `0.2.2`, `0.4.14`, `0.10.2`, `1.20.1` | Apache-2.0 | <https://github.com/RustCrypto> |
 | `libc` / `cpufeatures` | `0.2.189`, `0.3.1` | Apache-2.0 | <https://github.com/rust-lang/libc>, <https://github.com/RustCrypto/utils> |
diff --git a/packages/engine/package.json b/packages/engine/package.json
index 1a69c88..1f3dfb2 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@stack-sh/engine",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Browser WebAssembly adapter for Stack diagram operations",
   "type": "module",
   "license": "Apache-2.0",
diff --git a/scripts/validate-svg.py b/scripts/validate-svg.py
index 3a1ef02..279188c 100644
--- a/scripts/validate-svg.py
+++ b/scripts/validate-svg.py
@@ -95,10 +95,10 @@ def main() -> None:
         "association",
     }
     assert values(explicit_icon, "data-icon-id") == {"gateway"}
-    assert explicit_icon.attrib.get("data-theme-version") == "0.5.0"
+    assert explicit_icon.attrib.get("data-theme-version") == "0.6.0"
     assert (
         explicit_icon.attrib.get("data-theme-revision")
-        == "sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53"
+        == "sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1"
     )
 
 
diff --git a/tests/wasm.test.mjs b/tests/wasm.test.mjs
index ae18f2f..a08d15d 100644
--- a/tests/wasm.test.mjs
+++ b/tests/wasm.test.mjs
@@ -210,7 +210,7 @@ test("browser diagnostics preserve actionable compiler guidance", () => {
   );
   assert.ok(actionable);
   assert.equal(actionable.render.svg, null);
-  assert.equal(actionable.check.metadata.engineVersion, "0.7.0");
+  assert.equal(actionable.check.metadata.engineVersion, "0.8.0");
   assert.deepEqual(actionable.check.diagnostics[0], {
     code: "STK2002",
     severity: "error",
@@ -232,11 +232,11 @@ test("browser rendering resolves the bundled explicit core icon", () => {
   assert.ok(explicitIcon);
   assert.deepEqual(explicitIcon.check.diagnostics, []);
   assert.deepEqual(explicitIcon.render.diagnostics, []);
-  assert.equal(explicitIcon.render.metadata.engineVersion, "0.7.0");
-  assert.equal(explicitIcon.render.metadata.themeCatalogVersion, "0.5.0");
+  assert.equal(explicitIcon.render.metadata.engineVersion, "0.8.0");
+  assert.equal(explicitIcon.render.metadata.themeCatalogVersion, "0.6.0");
   assert.equal(
     explicitIcon.render.metadata.themeCatalogRevision,
-    "sha256:3bfd66e1a96628b29b95b7273b54373bcce952f7285aefa506b4255a629eaf53",
+    "sha256:4d4e9dcda36bf2a5187a233c0be74c9e9302f41d5021e1fa2a73712837ff55c1",
   );
   assert.match(explicitIcon.render.svg, /data-icon-id="gateway"/);
   assert.doesNotMatch(explicitIcon.render.svg, /data-icon-id="kind-external"/);