diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 46c4413..2001f24 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -50,6 +50,9 @@ jobs:
           STACK_SPECIFICATION_DIR: ${{ github.workspace }}/.stack-specification
         run: cargo +stable test -p stack-engine --features conformance --locked
 
+      - name: Validate standalone SVG snapshots
+        run: python3 scripts/validate-svg.py
+
       - name: Build pure engine for WebAssembly
         run: |
           rustup target add wasm32-unknown-unknown wasm32-wasip1 --toolchain stable
diff --git a/README.md b/README.md
index 3d45c21..4ca9ec5 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,11 @@
 
 `stack-sh/engine` is the pure Rust execution engine for Stack architecture diagrams.
 
-The workspace now provides canonical Stack source formatting, the pure `stack-engine` operation facade, deterministic theme-aware scene layout, and orthogonal edge routing. SVG rendering and WebAssembly adapters remain planned work.
+The workspace now provides canonical Stack source formatting, the pure `stack-engine` operation facade, deterministic theme-aware scene layout and orthogonal edge routing, and safe standalone SVG rendering. A WebAssembly adapter remains planned work.
 
-## Planned workspace
+## Workspace
 
-- `stack-engine`: implemented operation/output boundary, theme resolution, deterministic scene layout, edge routing, and validation beyond the compiler stage, plus planned standalone SVG rendering;
+- `stack-engine`: operation/output boundary, theme and icon fallback resolution, deterministic scene layout, edge routing, validation beyond the compiler stage, and standalone SVG rendering;
 - `stack-formatter`: comment-preserving canonical formatting for Stack source files (implemented);
 - a WebAssembly adapter exposing the same pure operations to browser consumers.
 
@@ -26,6 +26,7 @@ The workspace uses Rust 2024 with Rust 1.85 as its minimum supported version. Ru
 cargo test --workspace
 STACK_SPECIFICATION_DIR=../specification cargo test -p stack-formatter --features conformance --test conformance
 STACK_SPECIFICATION_DIR=../specification cargo test -p stack-engine --features conformance
+python3 scripts/validate-svg.py
 cargo build -p stack-engine --target wasm32-unknown-unknown
 CARGO_TARGET_WASM32_WASIP1_RUNNER=wasmtime cargo test -p stack-engine --lib --target wasm32-wasip1 cross_target_numeric_fixture
 cargo fmt --check
@@ -35,7 +36,9 @@ cargo doc --workspace --no-deps
 
 `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 reserved `render` methods through an engine bound to the embedded or a caller-provided validated catalog. Every normal output carries engine, authored language, theme catalog version, and theme catalog revision metadata. User-source failures stay in ordered portable diagnostics. Invalid provided catalogs, invalid normalized containment, routing failure, and unavailable pipeline stages use a separate operational-error channel. Checks and compiler-valid render attempts resolve the requested theme, validate deterministic integer geometry, and route ordered edges outside node interiors. An unsatisfied authored order hint produces `STK4001` at its source-map range; a satisfied hint does not. Rendering remains unavailable until SVG integration lands. CI executes one exact numeric geometry fixture in both the native suite and a WASI build.
+`stack-engine` exposes byte-oriented `format`, `check`, and `render` methods through an engine bound to the embedded or a caller-provided validated catalog. Every normal output carries engine, authored language, theme catalog version, and theme catalog revision metadata. User-source failures stay in ordered portable diagnostics. Invalid provided catalogs and violated normalized pipeline invariants use a separate operational-error channel. Checks and renders resolve the requested theme, 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.
+
+The renderer emits fixed-dimension standalone SVG with embedded catalog icons, local marker references, escaped authored text, accessible title and description metadata, and no script, event handler, external URL, host font measurement, or runtime I/O. Canonical SVG snapshots are byte-stable and parsed by `scripts/validate-svg.py`; set `UPDATE_STACK_SNAPSHOTS=1` only when intentionally regenerating them. CI also executes one exact numeric geometry fixture in both the native suite and a WASI build.
 
 ## Architecture
 
@@ -43,6 +46,7 @@ cargo doc --workspace --no-deps
 - [`docs/decisions/0002-use-a-pure-versioned-engine-facade.md`](./docs/decisions/0002-use-a-pure-versioned-engine-facade.md)
 - [`docs/decisions/0003-use-integer-ranked-scene-layout.md`](./docs/decisions/0003-use-integer-ranked-scene-layout.md)
 - [`docs/decisions/0004-route-orthogonal-edges-on-a-visibility-grid.md`](./docs/decisions/0004-route-orthogonal-edges-on-a-visibility-grid.md)
+- [`docs/decisions/0005-serialize-safe-standalone-svg.md`](./docs/decisions/0005-serialize-safe-standalone-svg.md)
 - [`docs/dependency-audit.md`](./docs/dependency-audit.md)
 
 ## Licensing
diff --git a/crates/stack-engine/src/lib.rs b/crates/stack-engine/src/lib.rs
index 2ca0347..993d3b0 100644
--- a/crates/stack-engine/src/lib.rs
+++ b/crates/stack-engine/src/lib.rs
@@ -4,7 +4,7 @@
 //! never reads the filesystem, network, process environment, clock, locale, or
 //! host font APIs. Invalid user source is returned as ordered diagnostics in a
 //! successful operation result; [`OperationalError`] is reserved for failures
-//! in the supplied execution inputs or unavailable engine capabilities.
+//! in supplied execution inputs or violated internal pipeline invariants.
 //!
 //! ```
 //! use stack_engine::Engine;
@@ -24,8 +24,10 @@ use std::fmt;
 
 use stack_compiler::diagnostic as compiler_diagnostic;
 
+mod resources;
 mod routing;
 mod scene;
+mod svg;
 
 /// Version of the Rust engine facade.
 pub const ENGINE_VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -40,6 +42,13 @@ pub struct Engine<'catalog> {
     catalog_revision: &'catalog str,
 }
 
+#[derive(Debug)]
+struct PreparedScene<'catalog> {
+    scene: scene::Scene,
+    resources: resources::Resources<'catalog>,
+    diagnostics: Vec<Diagnostic>,
+}
+
 impl Engine<'static> {
     /// Creates an engine backed by the catalog embedded in `stack-theme`.
     #[must_use]
@@ -119,7 +128,7 @@ impl<'catalog> Engine<'catalog> {
                     reason: "compiler omitted the source map for normalized IR",
                 },
             )?;
-            diagnostics.extend(self.validate_scene(diagram, source_map)?);
+            diagnostics.extend(self.prepare_scene(diagram, source_map)?.diagnostics);
         }
         Ok(CheckOutput {
             diagnostics,
@@ -127,13 +136,11 @@ impl<'catalog> Engine<'catalog> {
         })
     }
 
-    /// Applies compiler error semantics to the reserved render operation.
+    /// Produces a deterministic standalone SVG from valid Stack source.
     ///
     /// Invalid source returns a normal [`RenderOutput`] with ordered diagnostics
-    /// and no SVG. A compiler-valid document reaches the not-yet-integrated
-    /// layout and renderer boundary and returns [`OperationalError::PipelineUnavailable`].
-    /// The latter branch is replaced by deterministic SVG output when the render
-    /// pipeline lands.
+    /// and no SVG. Resource and layout warnings preserve a fallback SVG, while
+    /// invalid catalog or intermediate pipeline state uses [`OperationalError`].
     pub fn render(&self, source: &[u8]) -> OperationResult<RenderOutput> {
         let compiled = stack_compiler::compile_bytes_with_source_map(source);
         let metadata = self.metadata(declared_language_version(source));
@@ -145,17 +152,28 @@ impl<'catalog> Engine<'catalog> {
             });
         }
 
-        if let Some(diagram) = &compiled.diagram {
-            let source_map = compiled.source_map.as_ref().ok_or(
-                OperationalError::InvalidIntermediateRepresentation {
-                    reason: "compiler omitted the source map for normalized IR",
-                },
-            )?;
-            self.validate_scene(diagram, source_map)?;
-        }
-
-        Err(OperationalError::PipelineUnavailable {
-            operation: Operation::Render,
+        let diagram = compiled.diagram.as_ref().ok_or(
+            OperationalError::InvalidIntermediateRepresentation {
+                reason: "compiler omitted normalized IR after successful compilation",
+            },
+        )?;
+        let source_map = compiled.source_map.as_ref().ok_or(
+            OperationalError::InvalidIntermediateRepresentation {
+                reason: "compiler omitted the source map for normalized IR",
+            },
+        )?;
+        let prepared = self.prepare_scene(diagram, source_map)?;
+        let mut diagnostics = portable_diagnostics(compiled.diagnostics);
+        diagnostics.extend(prepared.diagnostics);
+        let svg = svg::render(diagram, &prepared.scene, &prepared.resources, &metadata).map_err(
+            |error| OperationalError::InvalidIntermediateRepresentation {
+                reason: error.reason(),
+            },
+        )?;
+        Ok(RenderOutput {
+            svg: Some(svg),
+            diagnostics,
+            metadata,
         })
     }
 
@@ -168,11 +186,16 @@ impl<'catalog> Engine<'catalog> {
         }
     }
 
-    fn validate_scene(
+    fn prepare_scene(
         &self,
         diagram: &stack_compiler::ir::Diagram,
         source_map: &stack_compiler::source_map::SourceMap,
-    ) -> OperationResult<Vec<Diagnostic>> {
+    ) -> OperationResult<PreparedScene<'catalog>> {
+        let resources = resources::Resources::resolve(diagram, self.catalog).map_err(|error| {
+            OperationalError::InvalidCatalog {
+                reason: error.reason(),
+            }
+        })?;
         let scene = scene::layout(diagram, self.catalog).map_err(|error| {
             OperationalError::InvalidIntermediateRepresentation {
                 reason: error.reason(),
@@ -183,14 +206,63 @@ impl<'catalog> Engine<'catalog> {
                 reason: "layout produced invalid containment or overlap geometry",
             });
         }
-        scene
-            .unsatisfied_orders
+        let mut diagnostics = resources
+            .warnings
             .iter()
-            .map(|scope| order_diagnostic(scope, source_map))
-            .collect()
+            .map(|warning| resource_diagnostic(warning, source_map))
+            .collect::<OperationResult<Vec<_>>>()?;
+        diagnostics.extend(
+            scene
+                .unsatisfied_orders
+                .iter()
+                .map(|scope| order_diagnostic(scope, source_map))
+                .collect::<OperationResult<Vec<_>>>()?,
+        );
+        Ok(PreparedScene {
+            scene,
+            resources,
+            diagnostics,
+        })
     }
 }
 
+fn resource_diagnostic(
+    warning: &resources::ResourceWarning,
+    source_map: &stack_compiler::source_map::SourceMap,
+) -> OperationResult<Diagnostic> {
+    let (code, message, help, origin) = match warning {
+        resources::ResourceWarning::MissingTheme(identifier) => (
+            "STK6001",
+            format!("theme '{identifier}' is unavailable; default theme was used"),
+            "Install the requested theme or select an available theme.",
+            source_map.theme(),
+        ),
+        resources::ResourceWarning::MissingIcon { node_id, icon_id } => (
+            "STK5001",
+            format!("icon '{icon_id}' is unavailable; the missing-icon fallback was used"),
+            "Install the icon in the effective theme or remove the icon property.",
+            source_map.node_icon(node_id).ok_or(
+                OperationalError::InvalidIntermediateRepresentation {
+                    reason: "source map omitted a normalized node",
+                },
+            )?,
+        ),
+    };
+    let span = origin
+        .span()
+        .ok_or(OperationalError::InvalidIntermediateRepresentation {
+            reason: "source map omitted an authored resource identifier",
+        })?;
+    Ok(Diagnostic {
+        code: code.to_owned(),
+        severity: Severity::Warning,
+        message,
+        range: SourceRange::from(span),
+        help: Some(help.to_owned()),
+        related: Vec::new(),
+    })
+}
+
 fn order_diagnostic(
     scope: &scene::SceneScope,
     source_map: &stack_compiler::source_map::SourceMap,
@@ -218,28 +290,7 @@ fn order_diagnostic(
     })
 }
 
-/// Operation whose execution may produce an operational error.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Operation {
-    /// Canonical source formatting.
-    Format,
-    /// Full renderability validation without SVG serialization.
-    Check,
-    /// Full validation followed by standalone SVG serialization.
-    Render,
-}
-
-impl fmt::Display for Operation {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.write_str(match self {
-            Self::Format => "format",
-            Self::Check => "check",
-            Self::Render => "render",
-        })
-    }
-}
-
-/// Failure in execution inputs or engine capability, not in Stack source.
+/// Failure in execution inputs or internal pipeline invariants, not in Stack source.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum OperationalError {
@@ -253,11 +304,6 @@ pub enum OperationalError {
         /// Stable explanation of the violated invariant.
         reason: &'static str,
     },
-    /// The requested pure stage has not landed in this engine revision.
-    PipelineUnavailable {
-        /// Operation whose downstream stages are unavailable.
-        operation: Operation,
-    },
 }
 
 impl fmt::Display for OperationalError {
@@ -267,9 +313,6 @@ impl fmt::Display for OperationalError {
             Self::InvalidIntermediateRepresentation { reason } => {
                 write!(formatter, "invalid intermediate representation: {reason}")
             }
-            Self::PipelineUnavailable { operation } => {
-                write!(formatter, "{operation} pipeline is unavailable")
-            }
         }
     }
 }
@@ -455,7 +498,7 @@ mod tests {
     use stack_compiler::diagnostic as compiler_diagnostic;
 
     use super::{
-        Diagnostic, ENGINE_VERSION, Engine, LanguageVersion, Operation, OperationalError, Severity,
+        Diagnostic, ENGINE_VERSION, Engine, LanguageVersion, OperationalError, Severity,
         SourcePosition,
     };
 
@@ -603,7 +646,95 @@ mod tests {
     }
 
     #[test]
-    fn invalid_render_input_is_not_an_operational_error() {
+    fn resource_fallbacks_report_authored_ranges_and_render_svg() -> Result<(), Box<dyn Error>> {
+        let source = "stack 1.0 diagram \"Fallbacks\" { theme neon layout { direction right order [b, a] } node a \"A\" { icon \"missing\" } node b \"B\" }";
+        let checked = Engine::bundled().check(source.as_bytes())?;
+        let rendered = Engine::bundled().render(source.as_bytes())?;
+        assert_eq!(checked.diagnostics, rendered.diagnostics);
+        assert_eq!(
+            rendered
+                .diagnostics
+                .iter()
+                .map(|diagnostic| diagnostic.code.as_str())
+                .collect::<Vec<_>>(),
+            vec!["STK6001", "STK5001", "STK4001"]
+        );
+
+        let theme_start = source.find("neon").ok_or("missing theme identifier")?;
+        assert_eq!(
+            rendered.diagnostics[0].range.start.byte_offset,
+            theme_start as u64
+        );
+        assert_eq!(
+            rendered.diagnostics[0].range.end.byte_offset,
+            (theme_start + "neon".len()) as u64
+        );
+        let icon_start = source.find("\"missing\"").ok_or("missing icon string")?;
+        assert_eq!(
+            rendered.diagnostics[1].range.start.byte_offset,
+            icon_start as u64
+        );
+        assert_eq!(
+            rendered.diagnostics[1].range.end.byte_offset,
+            (icon_start + "\"missing\"".len()) as u64
+        );
+        let svg = rendered.svg.ok_or("render produced no SVG")?;
+        assert!(svg.contains("data-theme-id=\"default\""));
+        assert!(svg.contains("data-icon-id=\"kind-external\""));
+        Ok(())
+    }
+
+    #[test]
+    fn render_is_repeatable_and_escapes_source_text() -> Result<(), Box<dyn Error>> {
+        let source = b"stack 1.0 diagram \"<script>&\" { node client \"\\\" onload=\\\"alert(1)<&>\" edge client -> api \"javascript:alert(1)\" node api \"API\" }";
+        let first = Engine::bundled().render(source)?;
+        let second = Engine::bundled().render(source)?;
+        assert_eq!(first, second);
+        let svg = first.svg.ok_or("render produced no SVG")?;
+        assert!(svg.contains("&lt;script&gt;&amp;"));
+        assert!(svg.contains("&quot; onload=&quot;alert(1)&lt;&amp;&gt;"));
+        assert!(!svg.contains("<script"));
+        assert!(!svg.contains("href="));
+        Ok(())
+    }
+
+    #[cfg(feature = "conformance")]
+    #[test]
+    fn canonical_valid_fixtures_render_standalone_svg() -> Result<(), Box<dyn Error>> {
+        let specification = std::env::var("STACK_SPECIFICATION_DIR")?;
+        let valid_root = std::path::Path::new(&specification).join("conformance/valid");
+        let mut cases = std::fs::read_dir(&valid_root)?.collect::<Result<Vec<_>, _>>()?;
+        cases.sort_by_key(|entry| entry.file_name());
+        if cases.is_empty() {
+            return Err(format!("no valid fixtures found in {}", valid_root.display()).into());
+        }
+
+        for case in cases {
+            let source_path = case.path().join("source.stack");
+            if !source_path.is_file() {
+                continue;
+            }
+            let output = Engine::bundled().render(&std::fs::read(&source_path)?)?;
+            if output
+                .diagnostics
+                .iter()
+                .any(|diagnostic| diagnostic.severity == Severity::Error)
+            {
+                return Err(
+                    format!("{} produced an error diagnostic", source_path.display()).into(),
+                );
+            }
+            let svg = output
+                .svg
+                .ok_or_else(|| format!("{} produced no standalone SVG", source_path.display()))?;
+            assert!(svg.starts_with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"));
+            assert!(svg.ends_with("</svg>\n"));
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn render_separates_invalid_input_from_success() -> Result<(), Box<dyn Error>> {
         let engine = Engine::bundled();
         let result = engine.render(b"\xff");
         assert!(result.is_ok());
@@ -613,12 +744,15 @@ mod tests {
             assert_eq!(output.metadata.language_version, None);
         }
 
-        assert_eq!(
-            engine.render(VALID_SOURCE),
-            Err(OperationalError::PipelineUnavailable {
-                operation: Operation::Render,
-            })
+        let output = engine.render(VALID_SOURCE)?;
+        assert!(output.diagnostics.is_empty());
+        assert!(
+            output
+                .svg
+                .as_deref()
+                .is_some_and(|svg| svg.contains("<svg"))
         );
+        Ok(())
     }
 
     #[test]
@@ -684,21 +818,11 @@ mod tests {
     }
 
     #[test]
-    fn operation_and_error_messages_are_stable() {
-        assert_eq!(Operation::Format.to_string(), "format");
-        assert_eq!(Operation::Check.to_string(), "check");
-        assert_eq!(Operation::Render.to_string(), "render");
+    fn operational_error_messages_are_stable() {
         assert_eq!(
             OperationalError::InvalidCatalog { reason: "reason" }.to_string(),
             "invalid theme catalog: reason"
         );
-        assert_eq!(
-            OperationalError::PipelineUnavailable {
-                operation: Operation::Render,
-            }
-            .to_string(),
-            "render pipeline is unavailable"
-        );
         assert_eq!(
             OperationalError::InvalidIntermediateRepresentation { reason: "reason" }.to_string(),
             "invalid intermediate representation: reason"
diff --git a/crates/stack-engine/src/resources.rs b/crates/stack-engine/src/resources.rs
new file mode 100644
index 0000000..9b46d42
--- /dev/null
+++ b/crates/stack-engine/src/resources.rs
@@ -0,0 +1,131 @@
+//! Deterministic theme and icon resolution for scene validation and rendering.
+
+use stack_compiler::ir::{Diagram, NodeKind};
+use stack_theme::{Catalog, FontMetrics, Icon, NodeVisual, Theme};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ResourceWarning {
+    MissingTheme(String),
+    MissingIcon { node_id: String, icon_id: String },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct ResourceError {
+    reason: &'static str,
+}
+
+impl ResourceError {
+    pub(crate) const fn reason(self) -> &'static str {
+        self.reason
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ResolvedNode<'catalog> {
+    pub(crate) node_id: String,
+    pub(crate) visual: &'catalog NodeVisual,
+    pub(crate) icon: &'catalog Icon,
+    pub(crate) icon_svg: &'static str,
+}
+
+#[derive(Debug)]
+pub(crate) struct Resources<'catalog> {
+    pub(crate) theme: &'catalog Theme,
+    pub(crate) metrics: &'catalog FontMetrics,
+    pub(crate) nodes: Vec<ResolvedNode<'catalog>>,
+    pub(crate) warnings: Vec<ResourceWarning>,
+}
+
+impl<'catalog> Resources<'catalog> {
+    pub(crate) fn resolve(
+        diagram: &Diagram,
+        catalog: &'catalog Catalog,
+    ) -> Result<Self, ResourceError> {
+        let requested_theme = catalog
+            .themes
+            .iter()
+            .find(|theme| theme.id == diagram.theme_id);
+        let (theme, mut warnings) = match requested_theme {
+            Some(theme) => (theme, Vec::new()),
+            None => (
+                catalog
+                    .themes
+                    .iter()
+                    .find(|theme| theme.id == catalog.fallbacks.missing_theme_id)
+                    .ok_or(ResourceError {
+                        reason: "missing-theme fallback is unavailable",
+                    })?,
+                vec![ResourceWarning::MissingTheme(diagram.theme_id.clone())],
+            ),
+        };
+        let metrics = catalog
+            .font_metrics
+            .iter()
+            .find(|metrics| metrics.id == theme.typography.font_metrics_id)
+            .ok_or(ResourceError {
+                reason: "resolved theme font metrics are unavailable",
+            })?;
+
+        let mut nodes = Vec::with_capacity(diagram.nodes.len());
+        for node in &diagram.nodes {
+            let visual = node_visual(theme, node.kind);
+            let requested_icon = node.icon_id.as_deref().unwrap_or(&visual.fallback_icon_id);
+            let icon = match theme.icons.iter().find(|icon| icon.id == requested_icon) {
+                Some(icon) => icon,
+                None if node.icon_id.is_some() => {
+                    warnings.push(ResourceWarning::MissingIcon {
+                        node_id: node.id.clone(),
+                        icon_id: requested_icon.to_owned(),
+                    });
+                    theme
+                        .icons
+                        .iter()
+                        .find(|icon| icon.id == catalog.fallbacks.missing_icon_id)
+                        .ok_or(ResourceError {
+                            reason: "missing-icon fallback is unavailable in the resolved theme",
+                        })?
+                }
+                None => {
+                    return Err(ResourceError {
+                        reason: "node-kind fallback icon is unavailable in the resolved theme",
+                    });
+                }
+            };
+            let icon_svg = stack_theme::icon_svg(&icon.asset.path).ok_or(ResourceError {
+                reason: "resolved icon bytes are not embedded in stack-theme",
+            })?;
+            nodes.push(ResolvedNode {
+                node_id: node.id.clone(),
+                visual,
+                icon,
+                icon_svg,
+            });
+        }
+
+        Ok(Self {
+            theme,
+            metrics,
+            nodes,
+            warnings,
+        })
+    }
+
+    pub(crate) fn node(&self, identifier: &str) -> Option<&ResolvedNode<'catalog>> {
+        self.nodes.iter().find(|node| node.node_id == identifier)
+    }
+}
+
+pub(crate) fn node_visual(theme: &Theme, kind: NodeKind) -> &NodeVisual {
+    match kind {
+        NodeKind::Actor => &theme.node_kind_fallbacks.actor,
+        NodeKind::Client => &theme.node_kind_fallbacks.client,
+        NodeKind::Service => &theme.node_kind_fallbacks.service,
+        NodeKind::Function => &theme.node_kind_fallbacks.function_,
+        NodeKind::Worker => &theme.node_kind_fallbacks.worker,
+        NodeKind::Database => &theme.node_kind_fallbacks.database,
+        NodeKind::Cache => &theme.node_kind_fallbacks.cache,
+        NodeKind::Queue => &theme.node_kind_fallbacks.queue,
+        NodeKind::Storage => &theme.node_kind_fallbacks.storage,
+        NodeKind::External => &theme.node_kind_fallbacks.external,
+    }
+}
diff --git a/crates/stack-engine/src/scene.rs b/crates/stack-engine/src/scene.rs
index 85deb6e..ea01c06 100644
--- a/crates/stack-engine/src/scene.rs
+++ b/crates/stack-engine/src/scene.rs
@@ -5,8 +5,9 @@ use std::error::Error;
 use std::fmt;
 
 use stack_compiler::ir::{Diagram, Direction, ElementId, Group, Layout, Node};
-use stack_theme::{Catalog, FontMetrics, Theme, Typography};
+use stack_theme::{Catalog, FontMetrics, NodeShape, Theme, Typography};
 
+use crate::resources::node_visual;
 use crate::routing::{self, Point, SceneEdge};
 
 const NODE_MIN_WIDTH: i64 = 160_000;
@@ -439,9 +440,18 @@ fn node_size(node: &Node, theme: &Theme, metrics: &FontMetrics) -> Size {
             )
     });
 
-    Size {
+    let size = Size {
         width: NODE_MIN_WIDTH.max(content_width + 2 * NODE_HORIZONTAL_PADDING),
         height: NODE_MIN_HEIGHT.max(label_height + detail_height + 2 * NODE_VERTICAL_PADDING),
+    };
+    if matches!(node_visual(theme, node.kind).shape, NodeShape::Circle) {
+        let diameter = size.width.max(size.height);
+        Size {
+            width: diameter,
+            height: diameter,
+        }
+    } else {
+        size
     }
 }
 
@@ -678,7 +688,7 @@ fn resolve_direction(child_count: usize, authored: Option<Direction>) -> SceneDi
     }
 }
 
-fn text_width(text: &str, size_milli_px: u32, metrics: &FontMetrics) -> i64 {
+pub(crate) fn text_width(text: &str, size_milli_px: u32, metrics: &FontMetrics) -> i64 {
     let advance = text
         .chars()
         .map(|character| glyph_advance(character, metrics) as i64)
@@ -710,7 +720,7 @@ fn unicode_scalar(label: &str) -> Option<u32> {
         .and_then(|digits| u32::from_str_radix(digits, 16).ok())
 }
 
-fn line_height(size_milli_px: u32, typography: &Typography) -> i64 {
+pub(crate) fn line_height(size_milli_px: u32, typography: &Typography) -> i64 {
     (i64::from(size_milli_px) * i64::from(typography.line_height_permille) + 999) / 1000
 }
 
diff --git a/crates/stack-engine/src/svg.rs b/crates/stack-engine/src/svg.rs
new file mode 100644
index 0000000..cd527f1
--- /dev/null
+++ b/crates/stack-engine/src/svg.rs
@@ -0,0 +1,720 @@
+//! Safe standalone SVG serialization for a resolved scene.
+
+use stack_compiler::ir::{Diagram, EdgeDirection, EdgeKind, NodeKind};
+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};
+
+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 {
+    reason: &'static str,
+}
+
+impl SvgError {
+    pub(crate) const fn reason(self) -> &'static str {
+        self.reason
+    }
+}
+
+pub(crate) fn render(
+    diagram: &Diagram,
+    scene: &Scene,
+    resources: &Resources<'_>,
+    metadata: &EngineMetadata,
+) -> Result<String, SvgError> {
+    let theme = resources.theme;
+    let mut output = String::new();
+    output.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+    output.push_str(&format!(
+        "<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,
+        escape_attribute(&metadata.engine_version),
+        escape_attribute(&theme.id),
+        escape_attribute(&metadata.theme_catalog_version),
+        escape_attribute(&metadata.theme_catalog_revision),
+    ));
+    output.push_str(&format!(
+        "  <title id=\"stack-title\">{}</title>\n",
+        escape_text(&diagram.title)
+    ));
+    output.push_str(&format!(
+        "  <desc id=\"stack-description\">Architecture diagram with {}, {}, and {}.</desc>\n",
+        counted(diagram.nodes.len(), "node", "nodes"),
+        counted(diagram.groups.len(), "group", "groups"),
+        counted(diagram.edges.len(), "relationship", "relationships")
+    ));
+    output.push_str(&format!(
+        "  <metadata>stack-engine {}; language {}.{}; theme {} at {}</metadata>\n",
+        escape_text(&metadata.engine_version),
+        metadata.language_version.map_or(0, |version| version.major),
+        metadata.language_version.map_or(0, |version| version.minor),
+        escape_text(&metadata.theme_catalog_version),
+        escape_text(&metadata.theme_catalog_revision)
+    ));
+    output.push_str(&format!(
+        "  <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" fill=\"{}\"/>\n",
+        scene.bounds.x,
+        scene.bounds.y,
+        scene.bounds.width,
+        scene.bounds.height,
+        escape_attribute(&theme.palette.canvas)
+    ));
+    render_definitions(&mut output, theme);
+    render_diagram_title(&mut output, diagram, scene, resources);
+
+    output.push_str("  <g data-stack-layer=\"groups\">\n");
+    for group in &scene.groups {
+        let authored = diagram
+            .groups
+            .iter()
+            .find(|authored| authored.id == group.id)
+            .ok_or(SvgError {
+                reason: "scene group has no normalized IR record",
+            })?;
+        render_group(&mut output, group, &authored.label, resources);
+    }
+    output.push_str("  </g>\n");
+
+    output.push_str("  <g data-stack-layer=\"edges\">\n");
+    for edge in &scene.edges {
+        render_edge(&mut output, edge, diagram, resources)?;
+    }
+    output.push_str("  </g>\n");
+
+    output.push_str("  <g data-stack-layer=\"nodes\">\n");
+    for node in &scene.nodes {
+        let authored = diagram
+            .nodes
+            .iter()
+            .find(|authored| authored.id == node.id)
+            .ok_or(SvgError {
+                reason: "scene node has no normalized IR record",
+            })?;
+        let resolved = resources.node(&node.id).ok_or(SvgError {
+            reason: "scene node has no resolved theme record",
+        })?;
+        render_node(&mut output, node, authored, resolved, resources)?;
+    }
+    output.push_str("  </g>\n");
+    render_edge_labels(&mut output, scene, resources);
+    output.push_str("</svg>\n");
+    Ok(output)
+}
+
+fn render_definitions(output: &mut String, theme: &Theme) {
+    let connector = palette_color(theme, theme.connector.stroke);
+    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
+    ));
+    output.push_str(&format!(
+        "      <path d=\"M 0 0 L 10000 5000 L 0 10000 z\" fill=\"{}\"/>\n",
+        escape_attribute(connector)
+    ));
+    output.push_str("    </marker>\n  </defs>\n");
+}
+
+fn render_diagram_title(
+    output: &mut String,
+    diagram: &Diagram,
+    scene: &Scene,
+    resources: &Resources<'_>,
+) {
+    let typography = &resources.theme.typography;
+    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,
+        escape_attribute(&resources.theme.palette.text),
+        escape_attribute(&resources.metrics.family),
+        typography.group_label_size_milli_px,
+        typography.label_weight,
+        escape_text(&diagram.title)
+    ));
+}
+
+fn render_group(output: &mut String, group: &SceneGroup, label: &str, resources: &Resources<'_>) {
+    let theme = resources.theme;
+    output.push_str(&format!(
+        "    <g role=\"group\" aria-label=\"{}\" data-stack-id=\"{}\">\n",
+        escape_attribute(label),
+        escape_attribute(&group.id)
+    ));
+    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,
+        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),
+        escape_attribute(&theme.palette.text),
+        escape_attribute(&resources.metrics.family),
+        theme.typography.group_label_size_milli_px,
+        theme.typography.label_weight,
+        escape_text(label)
+    ));
+    output.push_str("    </g>\n");
+}
+
+fn render_edge(
+    output: &mut String,
+    edge: &SceneEdge,
+    diagram: &Diagram,
+    resources: &Resources<'_>,
+) -> Result<(), SvgError> {
+    let source_label = diagram
+        .nodes
+        .iter()
+        .find(|node| node.id == edge.from)
+        .map(|node| node.label.as_str())
+        .ok_or(SvgError {
+            reason: "edge source has no normalized node",
+        })?;
+    let target_label = diagram
+        .nodes
+        .iter()
+        .find(|node| node.id == edge.to)
+        .map(|node| node.label.as_str())
+        .ok_or(SvgError {
+            reason: "edge target has no normalized node",
+        })?;
+    let direction = direction_name(edge.direction);
+    let relationship = accessible_direction(edge.direction);
+    let kind = kind_name(edge.kind);
+    let accessible_label = edge.label.as_ref().map_or_else(
+        || format!("{source_label} {relationship} {target_label}"),
+        |label| format!("{source_label} {relationship} {target_label}: {label}"),
+    );
+    output.push_str(&format!(
+        "    <g role=\"group\" aria-label=\"{}\" data-edge-kind=\"{}\" data-edge-direction=\"{}\">\n",
+        escape_attribute(&accessible_label),
+        kind,
+        direction
+    ));
+    output.push_str(&format!(
+        "      <title>{}</title>\n",
+        escape_text(&accessible_label)
+    ));
+    let points = edge
+        .path
+        .iter()
+        .map(|point| format!("{},{}", point.x, point.y))
+        .collect::<Vec<_>>()
+        .join(" ");
+    let marker_start = marker_attribute("marker-start", edge.start_marker);
+    let marker_end = marker_attribute("marker-end", edge.end_marker);
+    let dash = dash_attribute(edge, resources.theme);
+    output.push_str(&format!(
+        "      <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,
+        marker_start,
+        marker_end,
+        dash
+    ));
+    output.push_str("    </g>\n");
+    Ok(())
+}
+
+fn marker_attribute(name: &str, marker: Marker) -> String {
+    match marker {
+        Marker::None => String::new(),
+        Marker::Arrow => format!(" {name}=\"url(#stack-arrow)\""),
+    }
+}
+
+fn dash_attribute(edge: &SceneEdge, theme: &Theme) -> String {
+    let values = if edge.direction == EdgeDirection::Association {
+        Some(vec![8_000, 6_000])
+    } else {
+        theme.connector.dash_milli_px.clone()
+    };
+    values.map_or_else(String::new, |values| {
+        format!(
+            " stroke-dasharray=\"{}\"",
+            values
+                .iter()
+                .map(u32::to_string)
+                .collect::<Vec<_>>()
+                .join(" ")
+        )
+    })
+}
+
+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));
+        }
+    }
+    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<'_>,
+) {
+    let typography = &resources.theme.typography;
+    output.push_str(&format!(
+        "    <g data-edge-label=\"{}\">\n      <rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" rx=\"4000\" fill=\"{}\"/>\n",
+        escape_attribute(label),
+        anchor.x - dimensions.width / 2,
+        anchor.y - dimensions.height / 2,
+        dimensions.width,
+        dimensions.height,
+        escape_attribute(palette_color(
+            resources.theme,
+            resources.theme.connector.label_background
+        ))
+    ));
+    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,
+        escape_attribute(palette_color(
+            resources.theme,
+            resources.theme.connector.text
+        )),
+        escape_attribute(&resources.metrics.family),
+        typography.edge_label_size_milli_px,
+        escape_text(label)
+    ));
+}
+
+fn render_node(
+    output: &mut String,
+    scene_node: &SceneNode,
+    node: &stack_compiler::ir::Node,
+    resolved: &ResolvedNode<'_>,
+    resources: &Resources<'_>,
+) -> Result<(), SvgError> {
+    let accessible_label = node.detail.as_ref().map_or_else(
+        || node.label.clone(),
+        |detail| format!("{}: {detail}", node.label),
+    );
+    output.push_str(&format!(
+        "    <g role=\"group\" aria-label=\"{}\" data-stack-id=\"{}\" data-node-kind=\"{}\">\n",
+        escape_attribute(&accessible_label),
+        escape_attribute(&node.id),
+        node_kind_name(node.kind)
+    ));
+    output.push_str(&format!(
+        "      <title>{}</title>\n",
+        escape_text(&accessible_label)
+    ));
+    render_node_shape(output, scene_node.rect, resolved, resources.theme);
+    render_icon(output, scene_node.rect, resolved, resources.theme)?;
+    render_node_text(output, scene_node.rect, node, resolved, resources);
+    output.push_str("    </g>\n");
+    Ok(())
+}
+
+fn render_node_shape(output: &mut String, rect: Rect, resolved: &ResolvedNode<'_>, theme: &Theme) {
+    let fill = escape_attribute(palette_color(theme, resolved.visual.fill));
+    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,
+            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,
+            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,
+                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,
+                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,
+            fill,
+            stroke
+        )),
+    }
+}
+
+fn render_icon(
+    output: &mut String,
+    rect: Rect,
+    resolved: &ResolvedNode<'_>,
+    theme: &Theme,
+) -> Result<(), SvgError> {
+    let body = embedded_svg_body(resolved.icon_svg).ok_or(SvgError {
+        reason: "embedded icon is not a complete SVG document",
+    })?;
+    let view_box = resolved.icon.asset.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,
+        view_box[0],
+        view_box[1],
+        view_box[2],
+        view_box[3],
+        escape_attribute(palette_color(theme, resolved.visual.accent)),
+        escape_attribute(&resolved.icon.id),
+        body.trim()
+    ));
+    Ok(())
+}
+
+fn embedded_svg_body(svg: &str) -> Option<&str> {
+    let start = svg.find('>')? + 1;
+    let end = svg.rfind("</svg>")?;
+    (start <= end).then_some(&svg[start..end])
+}
+
+fn render_node_text(
+    output: &mut String,
+    rect: Rect,
+    node: &stack_compiler::ir::Node,
+    resolved: &ResolvedNode<'_>,
+    resources: &Resources<'_>,
+) {
+    let typography = &resources.theme.typography;
+    let text_x = rect.x + NODE_HORIZONTAL_PADDING + ICON_SIZE + ICON_TEXT_GAP;
+    let label_y = if node.detail.is_some() {
+        rect.y + rect.height / 2 - 9_000
+    } else {
+        rect.y + rect.height / 2
+    };
+    output.push_str(&format!(
+        "      <text x=\"{}\" y=\"{}\" dominant-baseline=\"middle\" fill=\"{}\" font-family=\"{}\" font-size=\"{}\" font-weight=\"{}\">{}</text>\n",
+        text_x,
+        label_y,
+        escape_attribute(palette_color(resources.theme, resolved.visual.text)),
+        escape_attribute(&resources.metrics.family),
+        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,
+            escape_attribute(&resources.theme.palette.text_muted),
+            escape_attribute(&resources.metrics.family),
+            typography.node_detail_size_milli_px,
+            typography.detail_weight,
+            escape_text(detail)
+        ));
+    }
+}
+
+fn palette_color(theme: &Theme, token: PaletteToken) -> &str {
+    match token {
+        PaletteToken::Canvas => &theme.palette.canvas,
+        PaletteToken::Surface => &theme.palette.surface,
+        PaletteToken::SurfaceMuted => &theme.palette.surface_muted,
+        PaletteToken::Text => &theme.palette.text,
+        PaletteToken::TextMuted => &theme.palette.text_muted,
+        PaletteToken::Border => &theme.palette.border,
+        PaletteToken::Accent => &theme.palette.accent,
+        PaletteToken::Danger => &theme.palette.danger,
+        PaletteToken::Connector => &theme.palette.connector,
+    }
+}
+
+fn direction_name(direction: EdgeDirection) -> &'static str {
+    match direction {
+        EdgeDirection::Forward => "forward",
+        EdgeDirection::Bidirectional => "bidirectional",
+        EdgeDirection::Association => "association",
+    }
+}
+
+fn accessible_direction(direction: EdgeDirection) -> &'static str {
+    match direction {
+        EdgeDirection::Forward => "flows to",
+        EdgeDirection::Bidirectional => "is connected bidirectionally with",
+        EdgeDirection::Association => "is associated with",
+    }
+}
+
+fn kind_name(kind: EdgeKind) -> &'static str {
+    match kind {
+        EdgeKind::Flow => "flow",
+        EdgeKind::Request => "request",
+        EdgeKind::Event => "event",
+        EdgeKind::Data => "data",
+        EdgeKind::Dependency => "dependency",
+    }
+}
+
+fn node_kind_name(kind: NodeKind) -> &'static str {
+    match kind {
+        NodeKind::Actor => "actor",
+        NodeKind::Client => "client",
+        NodeKind::Service => "service",
+        NodeKind::Function => "function",
+        NodeKind::Worker => "worker",
+        NodeKind::Database => "database",
+        NodeKind::Cache => "cache",
+        NodeKind::Queue => "queue",
+        NodeKind::Storage => "storage",
+        NodeKind::External => "external",
+    }
+}
+
+fn pixel_dimension(milli_pixels: i64) -> String {
+    let whole = milli_pixels / 1000;
+    let remainder = milli_pixels % 1000;
+    if remainder == 0 {
+        whole.to_string()
+    } else {
+        format!("{whole}.{remainder:03}")
+            .trim_end_matches('0')
+            .to_owned()
+    }
+}
+
+fn counted(count: usize, singular: &str, plural: &str) -> String {
+    format!("{count} {}", if count == 1 { singular } else { plural })
+}
+
+fn escape_text(value: &str) -> String {
+    value
+        .replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+}
+
+fn escape_attribute(value: &str) -> String {
+    escape_text(value)
+        .replace('"', "&quot;")
+        .replace('\'', "&apos;")
+}
+
+#[cfg(test)]
+mod tests {
+    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;");
+        assert_eq!(escape_attribute("\"<&>'"), "&quot;&lt;&amp;&gt;&apos;");
+    }
+
+    #[test]
+    fn formats_milli_pixel_dimensions_without_float_rounding() {
+        assert_eq!(pixel_dimension(504_000), "504");
+        assert_eq!(pixel_dimension(1_081_200), "1081.2");
+        assert_eq!(pixel_dimension(1_081_234), "1081.234");
+    }
+
+    #[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,
+            height: 72_000,
+        };
+        assert_eq!(
+            choose_label_anchor(
+                Point {
+                    x: 80_000,
+                    y: 136_000,
+                },
+                32_000,
+                24_000,
+                bounds,
+                &[node],
+            ),
+            Point {
+                x: 56_000,
+                y: 136_000,
+            }
+        );
+    }
+}
diff --git a/crates/stack-engine/tests/render_snapshots.rs b/crates/stack-engine/tests/render_snapshots.rs
new file mode 100644
index 0000000..4b97b3b
--- /dev/null
+++ b/crates/stack-engine/tests/render_snapshots.rs
@@ -0,0 +1,59 @@
+#![cfg(feature = "conformance")]
+
+use std::error::Error;
+use std::path::{Path, PathBuf};
+
+use stack_engine::{Engine, Severity};
+
+#[test]
+fn canonical_valid_fixtures_match_standalone_svg_snapshots() -> Result<(), Box<dyn Error>> {
+    let specification = specification_root()?;
+    let cases = [
+        ("default-normalization", Vec::<&str>::new()),
+        ("complete-semantics", vec!["STK5001"]),
+    ];
+    for (case, expected_codes) in cases {
+        let source = std::fs::read(
+            specification
+                .join("conformance/valid")
+                .join(case)
+                .join("source.stack"),
+        )?;
+        let output = Engine::bundled().render(&source)?;
+        if output
+            .diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.severity == Severity::Error)
+        {
+            return Err(format!("{case} produced an error diagnostic").into());
+        }
+        assert_eq!(
+            output
+                .diagnostics
+                .iter()
+                .map(|diagnostic| diagnostic.code.as_str())
+                .collect::<Vec<_>>(),
+            expected_codes
+        );
+        let svg = output.svg.ok_or("valid fixture produced no SVG")?;
+        let snapshot = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/snapshots/render")
+            .join(format!("{case}.svg"));
+        if std::env::var_os("UPDATE_STACK_SNAPSHOTS").is_some() {
+            std::fs::write(&snapshot, &svg)?;
+        } else {
+            assert_eq!(svg, std::fs::read_to_string(&snapshot)?);
+        }
+    }
+    Ok(())
+}
+
+fn specification_root() -> Result<PathBuf, Box<dyn Error>> {
+    let configured = std::env::var_os("STACK_SPECIFICATION_DIR")
+        .ok_or("STACK_SPECIFICATION_DIR must point to stack-sh/specification")?;
+    let root = Path::new(&configured);
+    if !root.is_dir() {
+        return Err(format!("{} is not a directory", root.display()).into());
+    }
+    Ok(root.to_path_buf())
+}
diff --git a/crates/stack-engine/tests/snapshots/complete-semantics.scene.txt b/crates/stack-engine/tests/snapshots/complete-semantics.scene.txt
index 9bba2d2..5708fbf 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,1081200|content=32000,70200,440000,979000|direction=Right
-group|system|parent=-|rect=32000,166600,440000,882600|content=56000,220800,392000,804400|direction=Down
-group|compute|parent=system|rect=56000,316800,392000,150200|content=80000,371000,344000,72000|direction=Right
-group|state|parent=system|rect=56000,491000,208000,438200|content=80000,545200,160000,360000|direction=Down
-node|user|parent=-|rect=32000,70200,160000,72400
-node|web|parent=system|rect=56000,220800,160000,72000
-node|api|parent=system|rect=240000,220800,160000,72000
-node|function|parent=compute|rect=80000,371000,160000,72000
-node|worker|parent=compute|rect=264000,371000,160000,72000
-node|database|parent=state|rect=80000,545200,160000,72000
-node|cache|parent=state|rect=80000,641200,160000,72000
-node|queue|parent=state|rect=80000,737200,160000,72000
-node|storage|parent=state|rect=80000,833200,160000,72000
-node|vendor|parent=system|rect=56000,953200,192200,72000
-edge|user|web|direction=Forward|kind=Request|label=HTTPS|markers=None,Arrow|anchor=112000,193700|path=112000,142600;112000,220800;136000,220800
-edge|web|api|direction=Bidirectional|kind=Flow|label=WebSocket|markers=Arrow,Arrow|anchor=228000,256800|path=216000,256800;240000,256800
-edge|api|function|direction=Forward|kind=Dependency|label=Invoke|markers=None,Arrow|anchor=240000,331900|path=240000,256800;240000,407000
-edge|function|database|direction=Forward|kind=Data|label=SQL|markers=None,Arrow|anchor=160000,494100|path=160000,443000;160000,545200
-edge|function|queue|direction=Forward|kind=Event|label=Job|markers=None,Arrow|anchor=80000,590100|path=80000,407000;80000,773200
-edge|worker|storage|direction=Association|kind=Data|label=Archive|markers=None,None|anchor=264000,650100|path=264000,407000;264000,869200;240000,869200
-edge|api|cache|direction=Forward|kind=Data|label=Read|markers=None,Arrow|anchor=240000,467000|path=240000,256800;240000,677200
-edge|api|vendor|direction=Forward|kind=Request|label=API|markers=None,Arrow|anchor=248200,605100|path=320000,292800;248200,292800;248200,989200
+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
+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
diff --git a/crates/stack-engine/tests/snapshots/render/complete-semantics.svg b/crates/stack-engine/tests/snapshots/render/complete-semantics.svg
new file mode 100644
index 0000000..c5cc081
--- /dev/null
+++ b/crates/stack-engine/tests/snapshots/render/complete-semantics.svg
@@ -0,0 +1,171 @@
+<?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.1.0" data-theme-id="dark" data-theme-version="0.1.0" data-theme-revision="sha256:b54ca3435931675d36d6a69b5154a0bd6ce2cbae1cfe14a20a095a8e24f8bae4">
+  <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.1.0; language 1.0; theme 0.1.0 at sha256:b54ca3435931675d36d6a69b5154a0bd6ce2cbae1cfe14a20a095a8e24f8bae4</metadata>
+  <rect x="0" y="0" width="504000" height="1168800" 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">
+      <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>
+  <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>
+    </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>
+    </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>
+    </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)" />
+    </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)" />
+    </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)" />
+    </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)" />
+    </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)" />
+    </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" />
+    </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)" />
+    </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)" />
+    </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"/>
+  <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>
+    </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>
+    </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="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>
+    </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>
+    </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"/>
+  <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>
+    </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"/>
+  <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>
+    </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>
+    </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"/>
+  <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>
+    </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"/>
+  <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>
+    </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>
+    </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>
+    </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>
+    </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>
+    </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>
+    </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>
+    </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>
+    </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>
+    </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>
+    </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
new file mode 100644
index 0000000..7d2146d
--- /dev/null
+++ b/crates/stack-engine/tests/snapshots/render/default-normalization.svg
@@ -0,0 +1,41 @@
+<?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.1.0" data-theme-id="default" data-theme-version="0.1.0" data-theme-revision="sha256:b54ca3435931675d36d6a69b5154a0bd6ce2cbae1cfe14a20a095a8e24f8bae4">
+  <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.1.0; language 1.0; theme 0.1.0 at sha256:b54ca3435931675d36d6a69b5154a0bd6ce2cbae1cfe14a20a095a8e24f8bae4</metadata>
+  <rect x="0" y="0" width="408000" height="174200" 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">
+      <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>
+  <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)" />
+    </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="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>
+    </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="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>
+    </g>
+  </g>
+  <g data-stack-layer="edge-labels" aria-hidden="true">
+  </g>
+</svg>
diff --git a/docs/decisions/0002-use-a-pure-versioned-engine-facade.md b/docs/decisions/0002-use-a-pure-versioned-engine-facade.md
index 935adf2..5abb8ec 100644
--- a/docs/decisions/0002-use-a-pure-versioned-engine-facade.md
+++ b/docs/decisions/0002-use-a-pure-versioned-engine-facade.md
@@ -22,15 +22,15 @@ The facade owns portable diagnostics and these result records:
 
 Every metadata record identifies the engine version, authored language version when parsing can recover it, theme catalog version, and theme catalog content revision. Diagnostics use owned codes and messages plus end-exclusive ranges whose offsets, lines, and columns are fixed-width unsigned integers for native/WASM parity.
 
-Invalid user bytes or source return a successful operation result with diagnostics and no unavailable artifact. Invalid provided catalog state and unavailable engine capability return `OperationalError`. Host filesystem and process failures remain responsibilities of adapters such as the private CLI and never become Stack diagnostics.
+Invalid user bytes or source return a successful operation result with diagnostics and no unavailable artifact. Invalid provided catalog state or an internal normalized pipeline invariant returns `OperationalError`. Host filesystem and process failures remain responsibilities of adapters such as the private CLI and never become Stack diagnostics.
 
-The initial facade delegates formatting to `stack-formatter` and checking to `stack-compiler`. Invalid input already exercises render error semantics. Compiler-valid rendering explicitly returns a pipeline-unavailable operational error until theme resolution, layout, and SVG serialization are integrated; it never returns an ambiguous empty successful render.
+The facade delegates formatting to `stack-formatter` and compilation to `stack-compiler`. Valid rendering continues through theme and icon resolution, deterministic layout and routing, and standalone SVG serialization. Resource and layout warnings preserve an SVG; compiler error diagnostics prevent it. The temporary pipeline-unavailable branch used before renderer integration has been removed.
 
 ## Consequences
 
 - Native and WASM adapters can share one output and diagnostic model without copying compiler or formatter logic.
-- Render provenance is available before SVG generation begins and can be embedded in future output.
+- Render provenance is embedded in standalone SVG output.
 - Ordered compiler diagnostics survive conversion byte-for-byte in sequence and source location.
 - New engine-stage diagnostics can be appended behind the same public type.
 - The facade stays host-independent, while adapters retain responsibility for I/O and process semantics.
-- The temporary valid-render unavailable branch remains visible until the renderer replaces it in the later integration task.
+- Rendering remains deterministic and host-independent because all catalog assets and metrics are supplied in memory.
diff --git a/docs/decisions/0003-use-integer-ranked-scene-layout.md b/docs/decisions/0003-use-integer-ranked-scene-layout.md
index 59287eb..cf7d4d4 100644
--- a/docs/decisions/0003-use-integer-ranked-scene-layout.md
+++ b/docs/decisions/0003-use-integer-ranked-scene-layout.md
@@ -27,5 +27,5 @@ The implementation has no layout dependency and no host access. The canonical co
 - Repeated layout for the same normalized IR, catalog revision, and options produces the same scene.
 - Native and WebAssembly builds share integer geometry code and do not require platform font APIs.
 - The automatic policy is intentionally simple and stable; changing it is an observable scene-layout change and requires snapshot review.
-- SVG serialization can consume scene rectangles without owning ranking, measurement, or containment semantics.
+- SVG serialization consumes scene rectangles without owning ranking, measurement, or containment semantics.
 - More advanced routing and constraint optimization can be added behind the scene boundary without changing compiler IR.
diff --git a/docs/decisions/0004-route-orthogonal-edges-on-a-visibility-grid.md b/docs/decisions/0004-route-orthogonal-edges-on-a-visibility-grid.md
index d01f563..63aac18 100644
--- a/docs/decisions/0004-route-orthogonal-edges-on-a-visibility-grid.md
+++ b/docs/decisions/0004-route-orthogonal-edges-on-a-visibility-grid.md
@@ -24,6 +24,6 @@ After placement, evaluate each authored order list using doubled cross-axis cent
 
 - Routing depends only on normalized IR and existing integer scene geometry.
 - Paths may touch or follow a node boundary but never enter a node interior.
-- Edge declaration order, kind, label, direction, path, markers, and anchors are snapshot-testable before SVG serialization exists.
+- Edge declaration order, kind, label, direction, path, markers, and anchors remain snapshot-testable independently of SVG serialization.
 - The bend penalty favors readable routes without making crossing minimization a semantic guarantee.
 - Layout diagnostics reuse the public compiler sidecar and do not add source spans to portable IR.
diff --git a/docs/decisions/0005-serialize-safe-standalone-svg.md b/docs/decisions/0005-serialize-safe-standalone-svg.md
new file mode 100644
index 0000000..a225eca
--- /dev/null
+++ b/docs/decisions/0005-serialize-safe-standalone-svg.md
@@ -0,0 +1,25 @@
+# ADR-0005: Serialize safe standalone SVG from resolved resources
+
+## Status
+
+Accepted
+
+## 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.
+
+## Decision
+
+Serialize standalone SVG directly from the deterministic scene and the already validated theme catalog. Use integer scene coordinates in the `viewBox`, explicit CSS-pixel dimensions, catalog font metrics and palette tokens, embedded catalog icon bodies, and one local marker definition. Escape all authored text and attributes. Do not emit script, event attributes, `href`, `src`, `foreignObject`, or arbitrary `url(...)` references.
+
+Give the root document an accessible title and description. Represent groups, nodes, and edges with semantic labels derived from authored display labels rather than identifiers. Render edge routes behind nodes and place visible edge labels in the nearest deterministic rectangle that does not overlap a node or an earlier edge label.
+
+Missing requested themes and icons produce source-mapped warnings and use catalog fallbacks. They do not suppress the SVG. Compiler error diagnostics continue to prevent render output.
+
+## Consequences
+
+- Native and future WASM adapters can return identical SVG bytes without browser APIs.
+- Output carries the engine version and exact theme catalog version and revision.
+- Canonical fixtures cover every node kind, edge kind, and direction in exact SVG snapshots.
+- CI parses snapshots as XML and rejects executable elements, event handlers, external references, duplicate identifiers, or non-local URL references.
+- Adding richer text shaping, external assets, or arbitrary catalog SVG requires a new validation and determinism decision rather than an implicit renderer change.
diff --git a/docs/dependency-audit.md b/docs/dependency-audit.md
index 480b2cb..15e3970 100644
--- a/docs/dependency-audit.md
+++ b/docs/dependency-audit.md
@@ -10,7 +10,7 @@ Audit date: 2026-09-03
 - the workspace-local `stack-formatter` for canonical source output;
 - `stack-theme` at `ed6c500762fc9ccffc8777172ac672a716dcd916` for the embedded core catalog, SVG bytes, deterministic font metrics, catalog version, and catalog revision.
 
-The resolved normal dependency graph adds only the `serde` and `serde_json` graph required by `stack-theme`. Exact versions and licenses are recorded in [`THIRD_PARTY_LICENSES.md`](../THIRD_PARTY_LICENSES.md) and pinned in `Cargo.lock`. Scene layout is implemented locally with fixed-width integer arithmetic and versioned catalog metrics. No layout, SVG, filesystem, network, asynchronous runtime, random, clock, locale, DOM, or platform-font dependency is present.
+The resolved normal dependency graph adds only the `serde` and `serde_json` graph required by `stack-theme`. Exact versions and licenses are recorded in [`THIRD_PARTY_LICENSES.md`](../THIRD_PARTY_LICENSES.md) and pinned in `Cargo.lock`. Scene layout is implemented locally with fixed-width integer arithmetic and versioned catalog metrics. Standalone SVG serialization is also local and embeds only validated catalog icon bodies and local marker references. No third-party layout or SVG serializer, filesystem, network, asynchronous runtime, random, clock, locale, DOM, or platform-font dependency is present.
 
 ## Runtime access boundary
 
@@ -28,6 +28,7 @@ cargo tree -p stack-engine --edges normal --locked
 cargo metadata --format-version 1 --locked
 cargo test --workspace --locked
 STACK_SPECIFICATION_DIR=../specification cargo test -p stack-engine --features conformance --locked
+python3 scripts/validate-svg.py
 cargo build -p stack-engine --target wasm32-unknown-unknown --locked
 CARGO_TARGET_WASM32_WASIP1_RUNNER=wasmtime cargo test -p stack-engine --lib --target wasm32-wasip1 cross_target_numeric_fixture --locked
 cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
diff --git a/scripts/validate-svg.py b/scripts/validate-svg.py
new file mode 100644
index 0000000..dc0fc5d
--- /dev/null
+++ b/scripts/validate-svg.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+import re
+import xml.etree.ElementTree as ET
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SNAPSHOTS = ROOT / "crates" / "stack-engine" / "tests" / "snapshots" / "render"
+SVG_NAMESPACE = "http://www.w3.org/2000/svg"
+FORBIDDEN_ELEMENTS = {"script", "foreignObject", "iframe", "object", "embed"}
+URL_PATTERN = re.compile(r"url\(([^)]+)\)", re.IGNORECASE)
+
+
+def local_name(name: str) -> str:
+    return name.rsplit("}", 1)[-1]
+
+
+def validate(path: Path) -> ET.Element:
+    document = ET.parse(path)
+    root = document.getroot()
+    assert root.tag == f"{{{SVG_NAMESPACE}}}svg", f"{path}: root is not SVG"
+    assert root.attrib.get("role") == "img", f"{path}: missing image role"
+    assert root.attrib.get("aria-labelledby") == "stack-title stack-description"
+
+    identifiers: set[str] = set()
+    for element in root.iter():
+        name = local_name(element.tag)
+        assert name not in FORBIDDEN_ELEMENTS, f"{path}: forbidden {name} element"
+        identifier = element.attrib.get("id")
+        if identifier is not None:
+            assert identifier not in identifiers, f"{path}: duplicate id {identifier}"
+            identifiers.add(identifier)
+        for attribute, value in element.attrib.items():
+            attribute_name = local_name(attribute).lower()
+            assert not attribute_name.startswith("on"), (
+                f"{path}: event attribute {attribute_name}"
+            )
+            assert attribute_name not in {"href", "src"}, (
+                f"{path}: external-reference attribute {attribute_name}"
+            )
+            for reference in URL_PATTERN.findall(value):
+                assert reference == "#stack-arrow", (
+                    f"{path}: non-local URL reference {reference}"
+                )
+
+    assert "stack-title" in identifiers, f"{path}: missing title"
+    assert "stack-description" in identifiers, f"{path}: missing description"
+    return root
+
+
+def values(root: ET.Element, attribute: str) -> set[str]:
+    return {
+        value
+        for element in root.iter()
+        if (value := element.attrib.get(attribute)) is not None
+    }
+
+
+def main() -> None:
+    snapshots = sorted(SNAPSHOTS.glob("*.svg"))
+    assert snapshots, "no render snapshots found"
+    documents = {path.stem: validate(path) for path in snapshots}
+    complete = documents["complete-semantics"]
+    assert values(complete, "data-node-kind") == {
+        "actor",
+        "client",
+        "service",
+        "function",
+        "worker",
+        "database",
+        "cache",
+        "queue",
+        "storage",
+        "external",
+    }
+    assert values(complete, "data-edge-kind") == {
+        "flow",
+        "request",
+        "event",
+        "data",
+        "dependency",
+    }
+    assert values(complete, "data-edge-direction") == {
+        "forward",
+        "bidirectional",
+        "association",
+    }
+
+
+if __name__ == "__main__":
+    main()