diff --git a/Cargo.lock b/Cargo.lock
index 5413dea..a0fba5d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2078,6 +2078,15 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "roxmltree"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"
@@ -2187,6 +2196,17 @@ dependencies = [
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "rusty-xaml"
+version = "0.1.0"
+dependencies = [
+ "roxmltree",
+ "rusty",
+ "serde",
+ "serde_json",
+ "tokio",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.23"
diff --git a/Cargo.toml b/Cargo.toml
index 7ee0431..9401a38 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,14 @@
 [workspace]
-members = ["rusty", "rusty-filter", "rusty-macros", "rusty-ivyml", "rusty-server", "rusty-docs", "rusty-desktop"]
+members = [
+    "rusty",
+    "rusty-filter",
+    "rusty-macros",
+    "rusty-ivyml",
+    "rusty-xaml",
+    "rusty-server",
+    "rusty-docs",
+    "rusty-desktop",
+]
 resolver = "2"
 
 [workspace.package]
@@ -21,3 +30,4 @@ tower-http = { version = "0.6", features = ["fs"] }
 clap = { version = "4", features = ["derive", "env"] }
 tokio-tungstenite = "0.29"
 bytes = "1"
+roxmltree = "0.21"
diff --git a/README.md b/README.md
index aa9880f..033a0cd 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,7 @@ Rusty-Framework follows the same architecture as Ivy-Framework:
 | `rusty-macros` | Proc macros for `#[derive(Widget)]`, `#[prop]`, `#[event]` |
 | `rusty-ivyml` | Proc macros for `ivyml!` / `ivyml_file!` declarative markup |
 | `rusty-filter` | Filter query lexer/parser/AST and evaluator |
+| `rusty-xaml` | Parses XAML markup into widget trees at runtime |
 | `rusty-server` | Standalone server binary |
 | `rusty-docs` | Docs site binary; `build.rs` generates `src/generated/` |
 | `rusty-desktop` | Native shell via wry/tao behind the optional `shell` feature |
diff --git a/rusty-xaml/Cargo.toml b/rusty-xaml/Cargo.toml
new file mode 100644
index 0000000..4e8fed5
--- /dev/null
+++ b/rusty-xaml/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "rusty-xaml"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "Parses XAML UI documents into Rusty widget trees at runtime"
+
+[dependencies]
+rusty = { path = "../rusty" }
+roxmltree.workspace = true
+# `value.rs` deserializes XAML enum words straight into `rusty`'s enums, which
+# needs the `DeserializeOwned` bound that `serde_json` does not re-export.
+serde.workspace = true
+serde_json.workspace = true
+
+[dev-dependencies]
+# For `examples/xaml_counter.rs`, which serves the parsed tree like the
+# examples in `rusty/examples`.
+tokio.workspace = true
diff --git a/rusty-xaml/examples/xaml_counter.rs b/rusty-xaml/examples/xaml_counter.rs
new file mode 100644
index 0000000..17fd58a
--- /dev/null
+++ b/rusty-xaml/examples/xaml_counter.rs
@@ -0,0 +1,82 @@
+//! `rusty/examples/counter.rs`, with the UI in XAML instead of builder calls.
+//!
+//! Run it with `cargo run -p rusty-xaml --example xaml_counter`, then open
+//! <http://127.0.0.1:3000>.
+//!
+//! The point of interest is where the parse happens: *inside* `build`, against a
+//! context rebuilt from the current state. A binding is resolved once, when the
+//! document is parsed, so parsing per build is what makes `{Binding Count}` track
+//! the counter — see the crate docs. The markup itself could equally come from a
+//! file with `parse_file_with`, which is the case this crate exists for.
+
+use rusty::prelude::*;
+use rusty_xaml::XamlContext;
+
+/// Hand-written here to keep the example self-contained; a real app would load
+/// this from disk, from a database, or from an editor.
+const MARKUP: &str = r#"
+<StackPanel Spacing="16" Padding="24">
+    <TextBlock Text="XAML Counter" Variant="Heading1" />
+    <TextBlock Text="{Binding CountLabel}" />
+
+    <StackPanel Orientation="Horizontal" Spacing="8">
+        <Button Content="Increment" Click="OnIncrement" />
+        <Button Content="Decrement" Variant="Secondary" Click="OnDecrement" />
+        <Button Content="Reset" Variant="Ghost" Click="OnReset" />
+    </StackPanel>
+
+    <Separator />
+
+    <ProgressBar Value="{Binding Progress}" Label="Progress to 10" />
+</StackPanel>
+"#;
+
+struct XamlCounterApp;
+
+#[rusty::view]
+impl View for XamlCounterApp {
+    fn build(&self, ctx: &mut BuildContext) -> Element {
+        let count = use_state(ctx, 0i32);
+
+        let count_inc = count.clone();
+        let count_dec = count.clone();
+        let count_reset = count.clone();
+
+        let xaml = XamlContext::new()
+            .value("CountLabel", format!("Count: {}", count.get()))
+            .value("Progress", f64::from(count.get().clamp(0, 10)) / 10.0)
+            .handler("OnIncrement", move || {
+                count_inc.update(|v| v + 1);
+            })
+            .handler("OnDecrement", move || {
+                count_dec.update(|v| v - 1);
+            })
+            .handler("OnReset", move || {
+                count_reset.set(0);
+            });
+
+        // A runtime parser can fail at runtime, so the app has to say something
+        // rather than panic: the error already names the element, the attribute
+        // and the line it came from.
+        match rusty_xaml::parse_with(MARKUP, &xaml) {
+            Ok(element) => element,
+            Err(err) => Layout::vertical()
+                .gap(8.0)
+                .padding(24.0)
+                .child(TextBlock::h1("The markup did not parse"))
+                .child(TextBlock::code(&err.to_string()))
+                .into(),
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let port = std::env::var("PORT")
+        .ok()
+        .and_then(|p| p.parse().ok())
+        .unwrap_or(3000);
+
+    // `RustyServer` binds `DEFAULT_BIND_ADDRESS`, which is loopback.
+    RustyServer::new(port, || XamlCounterApp).serve().await
+}
diff --git a/rusty-xaml/src/build.rs b/rusty-xaml/src/build.rs
new file mode 100644
index 0000000..53d56bf
--- /dev/null
+++ b/rusty-xaml/src/build.rs
@@ -0,0 +1,1136 @@
+//! The XAML vocabulary, and how it maps onto `rusty::widgets`.
+//!
+//! This is the runtime counterpart of `rusty-ivyml`'s `codegen::shape_for`, and
+//! it is a table for the same reason: the constructors are not uniform
+//! (`Layout::vertical()` vs `TextBlock::new(content)` vs `Card::new()`), `List`
+//! attaches children with `.item` rather than `.child`, and several attributes
+//! are consumed by the constructor instead of by a builder call. None of that
+//! can be derived from a tag name.
+//!
+//! Two rules hold everywhere:
+//!
+//! - Nothing is dropped silently. An unknown element, an unknown attribute, an
+//!   unparseable value, a child on a leaf — each is an error. A XAML document
+//!   that looks styled and renders unstyled is the harder bug to find.
+//! - Every XAML spelling has its Rusty spelling as an accepted alias, so a tree
+//!   can be written either way (`<StackPanel>` or `<Layout>`, `Spacing` or
+//!   `Gap`).
+
+use roxmltree::{Document, Node};
+
+use rusty::views::Element;
+use rusty::widgets::badge::BadgeVariant;
+use rusty::widgets::button::ButtonVariant;
+use rusty::widgets::text::TextVariant;
+use rusty::widgets::{
+    Badge, Button, Card, Container, Image, Layout, List, ListItem, Progress, Separator, Spacer,
+    TextBlock, TextInput,
+};
+
+use crate::context::{Handler, XamlContext};
+use crate::error::{Position, XamlError};
+use crate::value::{self, Site};
+
+/// The namespace `x:Name`, `x:Key` and the other XAML directives live in.
+/// Attributes in it are ignored — see the crate docs for why `x:Name` in
+/// particular cannot become a widget id.
+const XAML_DIRECTIVE_NS: &str = "http://schemas.microsoft.com/winfx/2006/xaml";
+
+/// One attribute, with its value still unresolved.
+#[derive(Debug)]
+struct Attr {
+    name: String,
+    raw: String,
+    pos: Position,
+}
+
+/// An element's attributes, minus the ones a constructor has taken.
+///
+/// `take` removes, so whatever is left after the constructor runs is exactly the
+/// set that must map onto builder calls — the runtime form of `codegen.rs`'s
+/// `consumed_by_ctor` list.
+#[derive(Debug)]
+struct Attrs {
+    /// The element's own position, used for errors about a missing attribute.
+    pos: Position,
+    list: Vec<Attr>,
+}
+
+impl Attrs {
+    fn take(&mut self, names: &[&str]) -> Option<Attr> {
+        let index = self
+            .list
+            .iter()
+            .position(|a| names.contains(&a.name.as_str()))?;
+        Some(self.list.remove(index))
+    }
+
+    fn require(&mut self, element: &str, names: &[&str]) -> Result<Attr, XamlError> {
+        self.take(names).ok_or_else(|| XamlError::MissingAttribute {
+            element: element.to_string(),
+            attribute: names[0].to_string(),
+            pos: self.pos,
+        })
+    }
+
+    /// The first attribute that was not consumed, for widgets that take none.
+    fn any(&self) -> Option<&Attr> {
+        self.list.first()
+    }
+}
+
+/// One parse in progress: the document (for positions) and the runtime data.
+struct Build<'a, 'input> {
+    doc: &'a Document<'input>,
+    ctx: &'a XamlContext,
+}
+
+/// Parse the document's root element into a widget tree.
+pub(crate) fn build_root(doc: &Document<'_>, ctx: &XamlContext) -> Result<Element, XamlError> {
+    // Not `Document::root_element`, which panics when there is no element.
+    let root = doc
+        .root()
+        .children()
+        .find(|node| node.is_element())
+        .ok_or(XamlError::NoRoot)?;
+
+    Build { doc, ctx }.element(root)
+}
+
+impl Build<'_, '_> {
+    fn element(&self, node: Node<'_, '_>) -> Result<Element, XamlError> {
+        let name = node.tag_name().name();
+        let pos = self.position(node.range().start);
+        let mut attrs = self.attrs(node, name, pos)?;
+        let text = text_content(node);
+        let children: Vec<Node<'_, '_>> = node.children().filter(|n| n.is_element()).collect();
+
+        match name {
+            "StackPanel" | "Layout" => {
+                let layout = match attrs.take(&["Orientation", "Direction"]) {
+                    None => Layout::vertical(),
+                    Some(attr) => match self.text_of(&attr, name)?.as_str() {
+                        "Vertical" => Layout::vertical(),
+                        other => {
+                            if other == "Horizontal" {
+                                Layout::horizontal()
+                            } else {
+                                return Err(site(name, &attr).unsupported(
+                                    other,
+                                    "expected `Vertical` or `Horizontal`; \
+                                     a grid is `<Grid Columns=\"..\">`",
+                                ));
+                            }
+                        }
+                    },
+                };
+                self.layout(layout, name, attrs, text, &children)
+            }
+            "Grid" => {
+                let attr = attrs.require(name, &["Columns"])?;
+                let columns = value::as_usize(&self.resolve(&attr, name)?, site(name, &attr))?;
+                self.layout(Layout::grid(columns), name, attrs, text, &children)
+            }
+            "WrapPanel" => self.layout(
+                Layout::horizontal().wrap(true),
+                name,
+                attrs,
+                text,
+                &children,
+            ),
+            "Border" | "Container" => {
+                reject_text(name, &text, pos)?;
+                let mut widget = Container::new();
+                for attr in &attrs.list {
+                    widget = self.container_attr(widget, attr, name)?;
+                }
+                for child in &children {
+                    widget = widget.child(self.element(*child)?);
+                }
+                Ok(widget.into())
+            }
+            "GroupBox" | "Card" => {
+                reject_text(name, &text, pos)?;
+                let mut widget = Card::new();
+                for attr in &attrs.list {
+                    widget = self.card_attr(widget, attr, name)?;
+                }
+                for child in &children {
+                    widget = widget.child(self.element(*child)?);
+                }
+                Ok(widget.into())
+            }
+            "ItemsControl" | "ListView" | "List" => {
+                reject_text(name, &text, pos)?;
+                // `List` holds only `items`; it has no builder to apply.
+                if let Some(attr) = attrs.any() {
+                    return Err(unknown_attribute(name, &attr.name, attr.pos));
+                }
+                let mut widget = List::new();
+                for child in &children {
+                    // `.item`, not `.child`: see `List` in `rusty::widgets::list`.
+                    widget = widget.item(self.element(*child)?);
+                }
+                Ok(widget.into())
+            }
+            "ListViewItem" | "ListItem" => {
+                reject_children(name, &children, pos)?;
+                let title = self.content(name, &mut attrs, &["Content", "Title"], &text)?;
+                let mut widget = ListItem::new(&title);
+                for attr in &attrs.list {
+                    widget = self.list_item_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "TextBlock" => {
+                reject_children(name, &children, pos)?;
+                let content = self.content(name, &mut attrs, &["Text", "Content"], &text)?;
+                let mut widget = TextBlock::new(&content);
+                for attr in &attrs.list {
+                    widget = self.text_block_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "Button" => {
+                reject_children(name, &children, pos)?;
+                let title = self.content(name, &mut attrs, &["Content", "Title"], &text)?;
+                let mut widget = Button::new(&title);
+                for attr in &attrs.list {
+                    widget = self.button_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "Badge" => {
+                reject_children(name, &children, pos)?;
+                let label = self.content(name, &mut attrs, &["Content", "Label"], &text)?;
+                let mut widget = Badge::new(&label);
+                for attr in &attrs.list {
+                    widget = self.badge_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "TextBox" | "TextInput" => {
+                reject_children(name, &children, pos)?;
+                reject_text(name, &text, pos)?;
+                let mut widget = TextInput::new();
+                for attr in &attrs.list {
+                    widget = self.text_input_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "Image" => {
+                reject_children(name, &children, pos)?;
+                reject_text(name, &text, pos)?;
+                let source = attrs.require(name, &["Source"])?;
+                let mut widget = Image::new(&self.text_of(&source, name)?);
+                for attr in &attrs.list {
+                    widget = self.image_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "ProgressBar" | "Progress" => {
+                reject_children(name, &children, pos)?;
+                reject_text(name, &text, pos)?;
+                let attr = attrs.require(name, &["Value"])?;
+                let value = value::as_f64(&self.resolve(&attr, name)?, site(name, &attr))?;
+                let mut widget = Progress::new(value);
+                for attr in &attrs.list {
+                    widget = self.progress_attr(widget, attr, name)?;
+                }
+                Ok(widget.into())
+            }
+            "Separator" => {
+                reject_children(name, &children, pos)?;
+                reject_text(name, &text, pos)?;
+                let mut widget = match attrs.take(&["Orientation"]) {
+                    None => Separator::horizontal(),
+                    Some(attr) => match self.text_of(&attr, name)?.as_str() {
+                        "Horizontal" => Separator::horizontal(),
+                        other => {
+                            if other == "Vertical" {
+                                Separator::vertical()
+                            } else {
+                                return Err(site(name, &attr)
+                                    .unsupported(other, "expected `Horizontal` or `Vertical`"));
+                            }
+                        }
+                    },
+                };
+                for attr in &attrs.list {
+                    widget = match attr.name.as_str() {
+                        "Text" => widget.text(&self.text_of(attr, name)?),
+                        _ => return Err(unknown_attribute(name, &attr.name, attr.pos)),
+                    };
+                }
+                Ok(widget.into())
+            }
+            "Spacer" => {
+                reject_children(name, &children, pos)?;
+                reject_text(name, &text, pos)?;
+                if let Some(attr) = attrs.any() {
+                    return Err(unknown_attribute(name, &attr.name, attr.pos));
+                }
+                Ok(Spacer::new().into())
+            }
+            other => Err(XamlError::UnknownElement {
+                element: other.to_string(),
+                pos,
+            }),
+        }
+    }
+
+    /// `StackPanel`, `Grid` and `WrapPanel` differ only in their constructor.
+    fn layout(
+        &self,
+        mut widget: Layout,
+        element: &str,
+        attrs: Attrs,
+        text: Option<String>,
+        children: &[Node<'_, '_>],
+    ) -> Result<Element, XamlError> {
+        reject_text(element, &text, attrs.pos)?;
+        for attr in &attrs.list {
+            widget = self.layout_attr(widget, attr, element)?;
+        }
+        for child in children {
+            widget = widget.child(self.element(*child)?);
+        }
+        Ok(widget.into())
+    }
+
+    fn layout_attr(&self, w: Layout, attr: &Attr, element: &str) -> Result<Layout, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Spacing" | "Gap" => w.gap(value::as_f64(&value, site)?),
+            "Padding" => w.padding(value::as_f64(&value, site)?),
+            "HorizontalAlignment" | "Align" => w.align(value::as_align(&value, site)?),
+            "VerticalAlignment" | "Justify" => w.justify(value::as_justify(&value, site)?),
+            "Width" => w.width(value::as_size(&value, site)?),
+            "Height" => w.height(value::as_size(&value, site)?),
+            "Wrap" => w.wrap(value::as_bool(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn container_attr(
+        &self,
+        w: Container,
+        attr: &Attr,
+        element: &str,
+    ) -> Result<Container, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Padding" => w.padding(value::as_f64(&value, site)?),
+            "Width" => w.width(value::as_size(&value, site)?),
+            "Height" => w.height(value::as_size(&value, site)?),
+            // `Container` is the one widget with a background, so `Background` is
+            // honoured here and rejected everywhere else.
+            "Background" => w.background(value::as_color(&value, site)?),
+            "Border" => w.border(value::as_bool(&value, site)?),
+            "Rounded" => w.rounded(value::as_bool(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn card_attr(&self, w: Card, attr: &Attr, element: &str) -> Result<Card, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            // `Card::new()` takes no argument, so a `GroupBox`'s `Header` is a
+            // builder call rather than a constructor argument.
+            "Header" | "Title" => w.title(&value::as_text(&value)),
+            "Subtitle" => w.subtitle(&value::as_text(&value)),
+            "Padding" => w.padding(value::as_f64(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn list_item_attr(
+        &self,
+        w: ListItem,
+        attr: &Attr,
+        element: &str,
+    ) -> Result<ListItem, XamlError> {
+        if attr.name == "Click" {
+            let handler = self.handler(attr, element)?;
+            return Ok(w.on_click(move || handler()));
+        }
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Subtitle" => w.subtitle(&value::as_text(&value)),
+            "Icon" => w.icon(value::as_text(&value).as_str()),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn text_block_attr(
+        &self,
+        w: TextBlock,
+        attr: &Attr,
+        element: &str,
+    ) -> Result<TextBlock, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Variant" => w.variant(value::as_enum::<TextVariant>(&value, site)?),
+            "Foreground" | "Color" => w.color(value::as_color(&value, site)?),
+            // `TextBlock::bold` takes no argument, so `FontWeight` accepts the one
+            // value it can express rather than a whole `FontWeight` enum.
+            "FontWeight" => match value::as_text(&value).as_str() {
+                "Bold" => w.bold(),
+                other => return Err(site.unsupported(other, "expected `Bold`")),
+            },
+            "Bold" => {
+                if value::as_bool(&value, site)? {
+                    w.bold()
+                } else {
+                    w
+                }
+            }
+            "Italic" => {
+                if value::as_bool(&value, site)? {
+                    w.italic()
+                } else {
+                    w
+                }
+            }
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn button_attr(&self, w: Button, attr: &Attr, element: &str) -> Result<Button, XamlError> {
+        if attr.name == "Click" {
+            let handler = self.handler(attr, element)?;
+            return Ok(w.on_click(move || handler()));
+        }
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Variant" => w.variant(value::as_enum::<ButtonVariant>(&value, site)?),
+            // XAML says what is enabled; Rusty says what is disabled.
+            "IsEnabled" => w.disabled(!value::as_bool(&value, site)?),
+            "Disabled" => w.disabled(value::as_bool(&value, site)?),
+            "Loading" => w.loading(value::as_bool(&value, site)?),
+            "Foreground" | "Color" => w.color(value::as_color(&value, site)?),
+            "Icon" => w.icon(value::as_text(&value).as_str()),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn badge_attr(&self, w: Badge, attr: &Attr, element: &str) -> Result<Badge, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Variant" => w.variant(value::as_enum::<BadgeVariant>(&value, site)?),
+            "Foreground" | "Color" => w.color(value::as_color(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn text_input_attr(
+        &self,
+        w: TextInput,
+        attr: &Attr,
+        element: &str,
+    ) -> Result<TextInput, XamlError> {
+        if attr.name == "Changed" {
+            let handler = self.handler(attr, element)?;
+            // `TextInput::on_change` is `Fn(String)` while a context handler is
+            // `Fn()`, so the new text is dropped. A handler that needs the text
+            // belongs in Rust, wired with `TextInput::on_change` directly.
+            return Ok(w.on_change(move |_| handler()));
+        }
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Text" | "Value" => w.value(&value::as_text(&value)),
+            "Placeholder" => w.placeholder(&value::as_text(&value)),
+            "Label" => w.label(&value::as_text(&value)),
+            "IsEnabled" => w.disabled(!value::as_bool(&value, site)?),
+            "Disabled" => w.disabled(value::as_bool(&value, site)?),
+            "IsReadOnly" | "ReadOnly" => w.read_only(value::as_bool(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn image_attr(&self, w: Image, attr: &Attr, element: &str) -> Result<Image, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Alt" => w.alt(&value::as_text(&value)),
+            "Width" => w.width(value::as_size(&value, site)?),
+            "Height" => w.height(value::as_size(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    fn progress_attr(
+        &self,
+        w: Progress,
+        attr: &Attr,
+        element: &str,
+    ) -> Result<Progress, XamlError> {
+        let site = site(element, attr);
+        let value = self.resolve(attr, element)?;
+        Ok(match attr.name.as_str() {
+            "Maximum" | "Max" => w.max(value::as_f64(&value, site)?),
+            "Label" => w.label(&value::as_text(&value)),
+            "Foreground" | "Color" => w.color(value::as_color(&value, site)?),
+            _ => return Err(unknown_attribute(element, &attr.name, attr.pos)),
+        })
+    }
+
+    /// The constructor argument, from an attribute or from text content.
+    ///
+    /// `<TextBlock>Hello</TextBlock>` and `<TextBlock Text="Hello" />` are the
+    /// same tree; both at once is an error rather than a silent winner.
+    fn content(
+        &self,
+        element: &str,
+        attrs: &mut Attrs,
+        names: &[&str],
+        text: &Option<String>,
+    ) -> Result<String, XamlError> {
+        match (attrs.take(names), text) {
+            (Some(attr), Some(_)) => Err(XamlError::DuplicateContent {
+                element: element.to_string(),
+                attribute: attr.name,
+                pos: attr.pos,
+            }),
+            (Some(attr), None) => self.text_of(&attr, element),
+            (None, Some(text)) => {
+                // Text content resolves exactly as the attribute would, so
+                // `<TextBlock>{Binding Title}</TextBlock>` binds.
+                let site = Site {
+                    element,
+                    attribute: names[0],
+                    pos: attrs.pos,
+                };
+                Ok(value::as_text(&value::resolve(text, self.ctx, site)?))
+            }
+            (None, None) => Err(XamlError::MissingAttribute {
+                element: element.to_string(),
+                attribute: names[0].to_string(),
+                pos: attrs.pos,
+            }),
+        }
+    }
+
+    fn resolve(&self, attr: &Attr, element: &str) -> Result<serde_json::Value, XamlError> {
+        value::resolve(&attr.raw, self.ctx, site(element, attr))
+    }
+
+    fn text_of(&self, attr: &Attr, element: &str) -> Result<String, XamlError> {
+        Ok(value::as_text(&self.resolve(attr, element)?))
+    }
+
+    /// An event attribute's value is a handler *name*, never a binding.
+    fn handler(&self, attr: &Attr, element: &str) -> Result<Handler, XamlError> {
+        let name = attr.raw.trim();
+        self.ctx
+            .handler_of(name)
+            .ok_or_else(|| XamlError::UnknownHandler {
+                element: element.to_string(),
+                attribute: attr.name.clone(),
+                handler: name.to_string(),
+                pos: attr.pos,
+            })
+    }
+
+    /// Collect the attributes that describe the widget, dropping the XAML
+    /// directives that describe the document.
+    fn attrs(&self, node: Node<'_, '_>, element: &str, pos: Position) -> Result<Attrs, XamlError> {
+        let mut list = Vec::new();
+
+        for attr in node.attributes() {
+            // `xmlns` and `xmlns:*` are namespace declarations, which roxmltree
+            // does not report as attributes at all.
+            if let Some(uri) = attr.namespace() {
+                let prefix = node.lookup_prefix(uri);
+                if uri == XAML_DIRECTIVE_NS || prefix == Some("x") {
+                    continue;
+                }
+                // Some other prefix, e.g. a design-time `d:DesignHeight`. It is
+                // reported rather than ignored: a prefix this crate does not know
+                // is a prefix whose effect it cannot honour.
+                let qualified = match prefix {
+                    Some(prefix) => format!("{}:{}", prefix, attr.name()),
+                    None => attr.name().to_string(),
+                };
+                return Err(unknown_attribute(
+                    element,
+                    &qualified,
+                    self.position(attr.range().start),
+                ));
+            }
+
+            list.push(Attr {
+                name: attr.name().to_string(),
+                raw: attr.value().to_string(),
+                pos: self.position(attr.range().start),
+            });
+        }
+
+        Ok(Attrs { pos, list })
+    }
+
+    /// A byte offset as a line and column.
+    ///
+    /// `text_pos_at` rescans the input, so it is called once per element and once
+    /// per attribute, never once per error: an error outlives the `Document` that
+    /// could resolve its offset, so the position has to be resolved eagerly.
+    fn position(&self, offset: usize) -> Position {
+        let pos = self.doc.text_pos_at(offset);
+        Position::new(pos.row, pos.col)
+    }
+}
+
+/// The element's text content, or `None` when there is only whitespace.
+///
+/// Comments and processing instructions are separate node kinds in roxmltree, so
+/// they are skipped by construction rather than by filtering.
+fn text_content(node: Node<'_, '_>) -> Option<String> {
+    let mut text = String::new();
+    for child in node.children().filter(|n| n.is_text()) {
+        text.push_str(child.text().unwrap_or_default());
+    }
+
+    let trimmed = text.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+fn reject_text(element: &str, text: &Option<String>, pos: Position) -> Result<(), XamlError> {
+    match text {
+        None => Ok(()),
+        Some(text) => Err(XamlError::UnsupportedValue {
+            element: element.to_string(),
+            attribute: "text content".to_string(),
+            value: text.clone(),
+            reason: "text content is only accepted by `TextBlock`, `Button`, `Badge` \
+                     and `ListViewItem`"
+                .to_string(),
+            pos,
+        }),
+    }
+}
+
+fn reject_children(
+    element: &str,
+    children: &[Node<'_, '_>],
+    pos: Position,
+) -> Result<(), XamlError> {
+    if children.is_empty() {
+        Ok(())
+    } else {
+        Err(XamlError::NoChildrenAllowed {
+            element: element.to_string(),
+            pos,
+        })
+    }
+}
+
+fn unknown_attribute(element: &str, attribute: &str, pos: Position) -> XamlError {
+    XamlError::UnknownAttribute {
+        element: element.to_string(),
+        attribute: attribute.to_string(),
+        pos,
+    }
+}
+
+fn site<'a>(element: &'a str, attr: &'a Attr) -> Site<'a> {
+    Site {
+        element,
+        attribute: &attr.name,
+        pos: attr.pos,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{parse, parse_with, XamlContext, XamlError};
+    use rusty::views::Element;
+    use serde_json::{json, Value};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::Arc;
+
+    /// The wire form of a tree, which is what a widget actually is.
+    fn wire(xaml: &str) -> Value {
+        serde_json::to_value(parse(xaml).expect("parses")).expect("serializes")
+    }
+
+    fn err(xaml: &str) -> XamlError {
+        parse(xaml).expect_err("should not parse")
+    }
+
+    #[test]
+    fn stack_panel_is_a_vertical_layout_by_default() {
+        let json = wire(r#"<StackPanel />"#);
+        assert_eq!(json["type"], "layout");
+        assert_eq!(json["direction"], "vertical");
+    }
+
+    #[test]
+    fn stack_panel_orientation_selects_the_constructor() {
+        assert_eq!(
+            wire(r#"<StackPanel Orientation="Horizontal" />"#)["direction"],
+            "horizontal"
+        );
+        assert_eq!(
+            wire(r#"<StackPanel Orientation="Vertical" />"#)["direction"],
+            "vertical"
+        );
+    }
+
+    #[test]
+    fn an_unknown_orientation_is_rejected_and_names_the_value() {
+        let err = err(r#"<StackPanel Orientation="Diagonal" />"#);
+        assert!(matches!(err, XamlError::UnsupportedValue { .. }), "{err:?}");
+        assert!(err.to_string().contains("Diagonal"), "{}", err);
+    }
+
+    #[test]
+    fn layout_is_an_accepted_alias_for_stack_panel() {
+        assert_eq!(wire(r#"<Layout />"#), wire(r#"<StackPanel />"#));
+    }
+
+    #[test]
+    fn grid_takes_its_columns_from_the_constructor() {
+        let json = wire(r#"<Grid Columns="3" />"#);
+        assert_eq!(json["type"], "layout");
+        assert_eq!(json["direction"], "grid");
+        assert_eq!(json["columns"], 3);
+    }
+
+    #[test]
+    fn a_grid_without_columns_is_an_error() {
+        let err = err(r#"<Grid />"#);
+        assert!(
+            matches!(&err, XamlError::MissingAttribute { attribute, .. } if attribute == "Columns"),
+            "{err:?}"
+        );
+    }
+
+    #[test]
+    fn wrap_panel_is_a_wrapping_horizontal_layout() {
+        let json = wire(r#"<WrapPanel />"#);
+        assert_eq!(json["direction"], "horizontal");
+        assert_eq!(json["wrap"], true);
+    }
+
+    #[test]
+    fn border_is_a_container() {
+        let json = wire(
+            r#"<Border Padding="8" Width="240" Height="50%" Background="Primary"
+                       Border="True" Rounded="True" />"#,
+        );
+
+        assert_eq!(json["type"], "container");
+        assert_eq!(json["padding"], 8.0);
+        assert_eq!(json["width"], "240px");
+        assert_eq!(json["height"], "50%");
+        assert_eq!(json["background"], "primary");
+        assert_eq!(json["border"], true);
+        assert_eq!(json["rounded"], true);
+    }
+
+    #[test]
+    fn group_box_is_a_card_and_header_is_its_title() {
+        let json = wire(r#"<GroupBox Header="Totals" Subtitle="This month" Padding="12" />"#);
+
+        assert_eq!(json["type"], "card");
+        assert_eq!(json["title"], "Totals");
+        assert_eq!(json["subtitle"], "This month");
+        assert_eq!(json["padding"], 12.0);
+    }
+
+    #[test]
+    fn items_control_attaches_children_as_items() {
+        let json = wire(
+            r#"<ItemsControl>
+                   <ListViewItem Content="First" Subtitle="1" Icon="mail" />
+                   <ListViewItem Content="Second" />
+               </ItemsControl>"#,
+        );
+
+        assert_eq!(json["type"], "list");
+        assert_eq!(json["items"][0]["type"], "list_item");
+        assert_eq!(json["items"][0]["title"], "First");
+        assert_eq!(json["items"][0]["subtitle"], "1");
+        assert_eq!(json["items"][0]["icon"], "mail");
+        assert_eq!(json["items"][1]["title"], "Second");
+        // Children landed in `items`, not `children`.
+        assert!(json["children"].is_null());
+    }
+
+    #[test]
+    fn list_view_and_list_are_accepted_aliases() {
+        assert_eq!(wire(r#"<ListView />"#), wire(r#"<List />"#));
+        assert_eq!(wire(r#"<ItemsControl />"#), wire(r#"<List />"#));
+    }
+
+    #[test]
+    fn list_takes_no_attributes() {
+        let err = err(r#"<ListView Padding="4" />"#);
+        assert!(
+            matches!(&err, XamlError::UnknownAttribute { attribute, .. } if attribute == "Padding"),
+            "{err:?}"
+        );
+    }
+
+    #[test]
+    fn text_block_carries_variant_colour_and_weight() {
+        // `r##` so the `#` of the hex colour does not close the raw string.
+        let json = wire(
+            r##"<TextBlock Text="Hi" Variant="Heading1" Foreground="#ff0000" FontWeight="Bold" />"##,
+        );
+
+        assert_eq!(json["type"], "text_block");
+        assert_eq!(json["content"], "Hi");
+        assert_eq!(json["variant"], "heading1");
+        assert_eq!(json["color"], "#ff0000");
+        assert_eq!(json["bold"], true);
+    }
+
+    #[test]
+    fn font_weight_accepts_only_bold() {
+        let err = err(r#"<TextBlock Text="Hi" FontWeight="SemiBold" />"#);
+        assert!(matches!(err, XamlError::UnsupportedValue { .. }), "{err:?}");
+        assert!(err.to_string().contains("SemiBold"), "{}", err);
+    }
+
+    #[test]
+    fn text_content_and_the_text_attribute_are_the_same_tree() {
+        assert_eq!(
+            wire(r#"<TextBlock>Hello</TextBlock>"#),
+            wire(r#"<TextBlock Text="Hello" />"#)
+        );
+    }
+
+    #[test]
+    fn setting_the_content_twice_is_an_error() {
+        let err = err(r#"<TextBlock Text="Hello">Hello</TextBlock>"#);
+        assert!(matches!(err, XamlError::DuplicateContent { .. }), "{err:?}");
+        assert!(err.to_string().contains("TextBlock"), "{}", err);
+    }
+
+    #[test]
+    fn a_text_block_without_content_is_an_error() {
+        let err = err(r#"<TextBlock />"#);
+        assert!(
+            matches!(&err, XamlError::MissingAttribute { attribute, .. } if attribute == "Text"),
+            "{err:?}"
+        );
+    }
+
+    #[test]
+    fn button_maps_content_variant_and_enabled() {
+        let json =
+            wire(r#"<Button Content="Save" Variant="Ghost" IsEnabled="False" Icon="save" />"#);
+
+        assert_eq!(json["type"], "button");
+        assert_eq!(json["title"], "Save");
+        assert_eq!(json["variant"], "ghost");
+        // `IsEnabled="False"` is `disabled = true`.
+        assert_eq!(json["disabled"], true);
+        assert_eq!(json["icon"], "save");
+    }
+
+    #[test]
+    fn text_box_is_a_text_input() {
+        let json = wire(
+            r#"<TextBox Text="abc" Placeholder="Name" Label="Name" IsReadOnly="True" IsEnabled="False" />"#,
+        );
+
+        assert_eq!(json["type"], "text_input");
+        assert_eq!(json["value"], "abc");
+        assert_eq!(json["placeholder"], "Name");
+        assert_eq!(json["label"], "Name");
+        assert_eq!(json["readOnly"], true);
+        assert_eq!(json["disabled"], true);
+    }
+
+    #[test]
+    fn image_takes_its_source_from_the_constructor() {
+        let json = wire(r#"<Image Source="/logo.png" Alt="Logo" Width="120" Height="Auto" />"#);
+
+        assert_eq!(json["type"], "image");
+        assert_eq!(json["src"], "/logo.png");
+        assert_eq!(json["alt"], "Logo");
+        assert_eq!(json["width"], "120px");
+        assert_eq!(json["height"], "auto");
+    }
+
+    #[test]
+    fn an_image_without_a_source_is_an_error() {
+        let err = err(r#"<Image />"#);
+        assert!(
+            matches!(&err, XamlError::MissingAttribute { attribute, .. } if attribute == "Source"),
+            "{err:?}"
+        );
+    }
+
+    #[test]
+    fn progress_bar_takes_its_value_from_the_constructor() {
+        let json = wire(r#"<ProgressBar Value="0.4" Maximum="1" Label="Loading" Color="Info" />"#);
+
+        assert_eq!(json["type"], "progress");
+        assert_eq!(json["value"], 0.4);
+        assert_eq!(json["max"], 1.0);
+        assert_eq!(json["label"], "Loading");
+        assert_eq!(json["color"], "info");
+    }
+
+    #[test]
+    fn separator_orientation_selects_the_constructor() {
+        assert_eq!(wire(r#"<Separator />"#)["orientation"], "horizontal");
+        assert_eq!(
+            wire(r#"<Separator Orientation="Vertical" />"#)["orientation"],
+            "vertical"
+        );
+        assert_eq!(wire(r#"<Separator Text="OR" />"#)["text"], "OR");
+    }
+
+    #[test]
+    fn badge_maps_content_and_variant() {
+        let json = wire(r#"<Badge Content="New" Variant="Outline" Color="Success" />"#);
+
+        assert_eq!(json["type"], "badge");
+        assert_eq!(json["label"], "New");
+        assert_eq!(json["variant"], "outline");
+        assert_eq!(json["color"], "success");
+    }
+
+    #[test]
+    fn spacer_is_a_leaf_with_no_attributes() {
+        assert_eq!(wire(r#"<Spacer />"#)["type"], "spacer");
+
+        let err = err(r#"<Spacer Width="4" />"#);
+        assert!(matches!(err, XamlError::UnknownAttribute { .. }), "{err:?}");
+    }
+
+    #[test]
+    fn layout_alignment_uses_xaml_words() {
+        let json = wire(
+            r#"<StackPanel HorizontalAlignment="Right" VerticalAlignment="Top"
+                           Spacing="8" Padding="16" Wrap="True" />"#,
+        );
+
+        assert_eq!(json["align"], "end");
+        assert_eq!(json["justify"], "start");
+        assert_eq!(json["gap"], 8.0);
+        assert_eq!(json["padding"], 16.0);
+        assert_eq!(json["wrap"], true);
+    }
+
+    #[test]
+    fn an_unknown_element_names_itself() {
+        let err = err(r#"<Canvas />"#);
+        assert!(matches!(err, XamlError::UnknownElement { .. }), "{err:?}");
+        assert!(err.to_string().contains("Canvas"), "{}", err);
+    }
+
+    #[test]
+    fn an_unknown_attribute_names_itself_and_its_element() {
+        let err = err(r#"<StackPanel Margin="8" />"#);
+        assert!(matches!(err, XamlError::UnknownAttribute { .. }), "{err:?}");
+
+        let message = err.to_string();
+        assert!(message.contains("Margin"), "{}", message);
+        assert!(message.contains("StackPanel"), "{}", message);
+    }
+
+    #[test]
+    fn background_is_rejected_where_no_widget_can_honour_it() {
+        let err = err(r#"<StackPanel Background="Primary" />"#);
+        assert!(
+            matches!(&err, XamlError::UnknownAttribute { attribute, .. } if attribute == "Background"),
+            "{err:?}"
+        );
+    }
+
+    #[test]
+    fn children_on_a_leaf_are_an_error() {
+        let err = err(r#"<TextBlock Text="Hi"><Spacer /></TextBlock>"#);
+        assert!(
+            matches!(err, XamlError::NoChildrenAllowed { .. }),
+            "{err:?}"
+        );
+        assert!(err.to_string().contains("TextBlock"), "{}", err);
+    }
+
+    #[test]
+    fn text_content_on_a_container_is_an_error_not_a_dropped_node() {
+        let err = err(r#"<StackPanel>stray</StackPanel>"#);
+        assert!(matches!(err, XamlError::UnsupportedValue { .. }), "{err:?}");
+        assert!(err.to_string().contains("stray"), "{}", err);
+    }
+
+    #[test]
+    fn whitespace_between_tags_is_ignorable() {
+        let spaced = wire("<StackPanel>\n    <Spacer />\n</StackPanel>");
+        let tight = wire("<StackPanel><Spacer /></StackPanel>");
+        assert_eq!(spaced, tight);
+    }
+
+    #[test]
+    fn a_click_resolves_through_the_context() {
+        let calls = Arc::new(AtomicUsize::new(0));
+        let counter = calls.clone();
+        let ctx = XamlContext::new().handler("OnSave", move || {
+            counter.fetch_add(1, Ordering::SeqCst);
+        });
+
+        let element = parse_with(r#"<Button Content="Save" Click="OnSave" />"#, &ctx).unwrap();
+        let json = serde_json::to_value(&element).unwrap();
+        assert_eq!(json["hasOnClick"], true);
+
+        fire_click(&element);
+        assert_eq!(calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn a_missing_handler_is_an_error() {
+        let err = parse(r#"<Button Content="Save" Click="OnSave" />"#).unwrap_err();
+        assert!(
+            matches!(&err, XamlError::UnknownHandler { handler, .. } if handler == "OnSave"),
+            "{err:?}"
+        );
+        assert!(err.to_string().contains("OnSave"), "{}", err);
+    }
+
+    #[test]
+    fn a_list_item_click_and_a_text_box_change_both_resolve() {
+        let calls = Arc::new(AtomicUsize::new(0));
+        let on_pick = calls.clone();
+        let on_type = calls.clone();
+        let ctx = XamlContext::new()
+            .handler("OnPick", move || {
+                on_pick.fetch_add(1, Ordering::SeqCst);
+            })
+            .handler("OnType", move || {
+                on_type.fetch_add(10, Ordering::SeqCst);
+            });
+
+        let item = parse_with(r#"<ListViewItem Content="One" Click="OnPick" />"#, &ctx).unwrap();
+        assert_eq!(serde_json::to_value(&item).unwrap()["hasOnClick"], true);
+
+        let input = parse_with(r#"<TextBox Changed="OnType" />"#, &ctx).unwrap();
+        assert_eq!(serde_json::to_value(&input).unwrap()["hasOnChange"], true);
+
+        fire_click(&item);
+        assert_eq!(calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn bindings_reach_typed_builder_slots() {
+        let ctx = XamlContext::new()
+            .value("Title", "Dashboard")
+            .value("Columns", 2)
+            .value("Gap", 12.5);
+
+        let json = serde_json::to_value(
+            parse_with(
+                r#"<Grid Columns="{Binding Columns}" Spacing="{Binding Gap}">
+                       <TextBlock Text="{Binding Title}" />
+                   </Grid>"#,
+                &ctx,
+            )
+            .unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(json["columns"], 2);
+        assert_eq!(json["gap"], 12.5);
+        assert_eq!(json["children"][0]["content"], "Dashboard");
+    }
+
+    #[test]
+    fn xaml_directives_and_namespaces_are_ignored() {
+        let decorated = wire(
+            r#"<StackPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                           x:Name="root">
+                   <!-- a comment -->
+                   <TextBlock x:Uid="t" Text="Hi" />
+               </StackPanel>"#,
+        );
+
+        assert_eq!(
+            decorated,
+            wire(r#"<StackPanel><TextBlock Text="Hi" /></StackPanel>"#)
+        );
+    }
+
+    #[test]
+    fn an_unrecognised_prefix_is_reported_rather_than_ignored() {
+        let err = err(
+            r#"<StackPanel xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+                           d:DesignHeight="400" />"#,
+        );
+
+        assert!(
+            matches!(&err, XamlError::UnknownAttribute { attribute, .. } if attribute == "d:DesignHeight"),
+            "{err:?}"
+        );
+    }
+
+    #[test]
+    fn errors_carry_the_line_and_column_of_the_offending_markup() {
+        let err = err("<StackPanel>\n    <Canvas />\n</StackPanel>");
+        assert!(err.to_string().contains("2:5"), "{}", err);
+    }
+
+    #[test]
+    fn the_tree_matches_the_equivalent_builder_chain() {
+        use rusty::widgets::{Layout, TextBlock};
+
+        let parsed =
+            parse(r#"<StackPanel Spacing="8"><TextBlock Text="Hi" /></StackPanel>"#).unwrap();
+        let built: Element = Layout::vertical()
+            .gap(8.0)
+            .child(TextBlock::new("Hi"))
+            .into();
+
+        assert_eq!(
+            serde_json::to_value(&parsed).unwrap(),
+            serde_json::to_value(&built).unwrap()
+        );
+    }
+
+    #[test]
+    fn a_widget_serializes_with_its_kind_tag() {
+        // Guards the assumption every other test here rests on: `Element`'s
+        // `kind` tag and the widget's own props share one JSON object.
+        assert_eq!(
+            wire(r#"<Spacer />"#),
+            json!({"kind": "widget", "type": "spacer", "id": null})
+        );
+    }
+
+    /// Assign ids, then invoke the widget's registered `click` handler.
+    fn fire_click(element: &Element) {
+        use rusty::hooks::hook_store::HookStore;
+        use rusty::views::BuildContext;
+
+        let mut element = element.clone();
+        let mut store = HookStore::default();
+        let mut ctx = BuildContext::new(&mut store, None);
+        element.assign_ids(&mut ctx);
+
+        let id = serde_json::to_value(&element).unwrap()["id"]
+            .as_str()
+            .expect("id was assigned")
+            .to_string();
+
+        assert!(
+            ctx.event_registry_mut().dispatch(&id, "click", Value::Null),
+            "no `click` handler was registered"
+        );
+    }
+}
diff --git a/rusty-xaml/src/context.rs b/rusty-xaml/src/context.rs
new file mode 100644
index 0000000..c3d4ce9
--- /dev/null
+++ b/rusty-xaml/src/context.rs
@@ -0,0 +1,143 @@
+//! The runtime data a document is parsed against.
+
+use std::collections::HashMap;
+use std::fmt;
+use std::sync::Arc;
+
+use serde_json::Value;
+
+/// A named event handler, stored type-erased so the whole context is one type.
+pub type Handler = Arc<dyn Fn() + Send + Sync>;
+
+/// Values for `{Binding ..}` attributes and handlers for event attributes.
+///
+/// This is the only place runtime data enters a parse: the markup itself is
+/// inert text. Built fluently:
+///
+/// ```
+/// # use rusty_xaml::XamlContext;
+/// let ctx = XamlContext::new()
+///     .value("Title", "Dashboard")
+///     .value("Count", 3)
+///     .handler("OnIncrement", || println!("clicked"));
+///
+/// assert!(ctx.value_of("Title").is_some());
+/// assert!(ctx.handler_of("OnIncrement").is_some());
+/// ```
+#[derive(Clone, Default)]
+pub struct XamlContext {
+    values: HashMap<String, Value>,
+    handlers: HashMap<String, Handler>,
+}
+
+impl XamlContext {
+    /// An empty context. `parse` is `parse_with` against this.
+    pub fn new() -> Self {
+        XamlContext::default()
+    }
+
+    /// Bind a value that `{Binding <name>}` resolves to.
+    ///
+    /// Any JSON scalar works: a string reaches a `&str` builder slot verbatim, a
+    /// number reaches an `f64`/`usize` slot without a round trip through text.
+    pub fn value(mut self, name: impl Into<String>, value: impl Into<Value>) -> Self {
+        self.values.insert(name.into(), value.into());
+        self
+    }
+
+    /// Register a handler an event attribute can name.
+    ///
+    /// The value of `Click="OnIncrement"` is a *name*, not an expression — there
+    /// is no interpreter here — so the closure is supplied from Rust.
+    pub fn handler(
+        mut self,
+        name: impl Into<String>,
+        handler: impl Fn() + Send + Sync + 'static,
+    ) -> Self {
+        self.handlers.insert(name.into(), Arc::new(handler));
+        self
+    }
+
+    /// The value bound to `name`, if any.
+    pub fn value_of(&self, name: &str) -> Option<&Value> {
+        self.values.get(name)
+    }
+
+    /// The handler registered under `name`, if any.
+    ///
+    /// Returns a clone of the `Arc` rather than a reference: attaching it means
+    /// calling e.g. `Button::on_click`, which takes `impl Fn() + Send + Sync +
+    /// 'static` by value, and `Arc<dyn Fn()>` does not itself implement `Fn`.
+    /// The caller wraps the clone in `move || handler()`.
+    pub fn handler_of(&self, name: &str) -> Option<Handler> {
+        self.handlers.get(name).cloned()
+    }
+}
+
+impl fmt::Debug for XamlContext {
+    /// Hand-written because a `Handler` is not `Debug`; handler names are still
+    /// worth printing, so they are listed as bare names.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut handlers: Vec<&str> = self.handlers.keys().map(String::as_str).collect();
+        handlers.sort_unstable();
+
+        f.debug_struct("XamlContext")
+            .field("values", &self.values)
+            .field("handlers", &handlers)
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[test]
+    fn values_accept_any_json_scalar() {
+        let ctx = XamlContext::new()
+            .value("Title", "Dashboard")
+            .value("Count", 3)
+            .value("Ready", true);
+
+        assert_eq!(ctx.value_of("Title"), Some(&Value::from("Dashboard")));
+        assert_eq!(ctx.value_of("Count"), Some(&Value::from(3)));
+        assert_eq!(ctx.value_of("Ready"), Some(&Value::from(true)));
+        assert_eq!(ctx.value_of("Missing"), None);
+    }
+
+    #[test]
+    fn a_later_value_replaces_an_earlier_one_of_the_same_name() {
+        let ctx = XamlContext::new().value("Count", 1).value("Count", 2);
+        assert_eq!(ctx.value_of("Count"), Some(&Value::from(2)));
+    }
+
+    #[test]
+    fn handler_round_trips_and_is_callable() {
+        let calls = Arc::new(AtomicUsize::new(0));
+        let counter = calls.clone();
+        let ctx = XamlContext::new().handler("OnIncrement", move || {
+            counter.fetch_add(1, Ordering::SeqCst);
+        });
+
+        let handler = ctx
+            .handler_of("OnIncrement")
+            .expect("handler is registered");
+        handler();
+        handler();
+
+        assert_eq!(calls.load(Ordering::SeqCst), 2);
+        assert!(ctx.handler_of("OnDecrement").is_none());
+    }
+
+    #[test]
+    fn debug_lists_handler_names_without_requiring_debug_handlers() {
+        let ctx = XamlContext::new()
+            .value("Count", 1)
+            .handler("OnClick", || {});
+        let text = format!("{:?}", ctx);
+
+        assert!(text.contains("Count"), "{}", text);
+        assert!(text.contains("OnClick"), "{}", text);
+    }
+}
diff --git a/rusty-xaml/src/error.rs b/rusty-xaml/src/error.rs
new file mode 100644
index 0000000..8ed6d01
--- /dev/null
+++ b/rusty-xaml/src/error.rs
@@ -0,0 +1,262 @@
+//! The one error type the crate returns.
+//!
+//! Unlike `rusty-ivyml`, which reports a mistake as a `syn::Error` carrying a
+//! span that `rustc` renders, this crate sees its input at runtime. Every
+//! variant that refers to markup therefore carries the offending element name
+//! and a [`Position`], resolved from the byte offset with
+//! `roxmltree::Document::text_pos_at` while the document is still in scope.
+
+use std::fmt;
+use std::path::PathBuf;
+
+/// A line and column in the parsed document, both 1-based.
+///
+/// Stored rather than the raw byte offset, because the offset is only meaningful
+/// next to the `roxmltree::Document` that produced it, and an error outlives the
+/// document it came from.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Position {
+    pub line: u32,
+    pub column: u32,
+}
+
+impl Position {
+    pub fn new(line: u32, column: u32) -> Self {
+        Position { line, column }
+    }
+}
+
+impl fmt::Display for Position {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}", self.line, self.column)
+    }
+}
+
+/// Everything that can go wrong turning XAML into a widget tree.
+///
+/// Not `PartialEq`: [`XamlError::Xml`] wraps `roxmltree::Error`, which is not
+/// comparable. Assert on `matches!` and on the `Display` string instead.
+#[derive(Debug)]
+pub enum XamlError {
+    /// The input is not well-formed XML. `roxmltree`'s own message already
+    /// carries a line and column.
+    Xml(roxmltree::Error),
+    /// A `.xaml` file could not be read.
+    Io {
+        path: PathBuf,
+        source: std::io::Error,
+    },
+    /// The document contains no element. XML makes this all but unreachable —
+    /// `roxmltree` rejects an empty document itself — so this guards the one
+    /// path where it would otherwise panic.
+    NoRoot,
+    /// An element name outside the vocabulary in [`crate::build`].
+    UnknownElement { element: String, pos: Position },
+    /// An attribute that maps onto no builder of that widget.
+    UnknownAttribute {
+        element: String,
+        attribute: String,
+        pos: Position,
+    },
+    /// An attribute the constructor needs, absent.
+    MissingAttribute {
+        element: String,
+        attribute: String,
+        pos: Position,
+    },
+    /// The attribute exists, but its value cannot be coerced to what the
+    /// builder takes. `reason` is the coercion's own complaint — for an enum it
+    /// is serde's, which lists the accepted variants.
+    UnsupportedValue {
+        element: String,
+        attribute: String,
+        value: String,
+        reason: String,
+        pos: Position,
+    },
+    /// A `{..}` markup extension other than `{Binding ..}`.
+    UnsupportedMarkupExtension {
+        element: String,
+        attribute: String,
+        value: String,
+        pos: Position,
+    },
+    /// `{Binding X}` where `X` is absent from the [`crate::XamlContext`].
+    UnresolvedBinding {
+        element: String,
+        attribute: String,
+        path: String,
+        pos: Position,
+    },
+    /// An event attribute naming a handler absent from the
+    /// [`crate::XamlContext`].
+    UnknownHandler {
+        element: String,
+        attribute: String,
+        handler: String,
+        pos: Position,
+    },
+    /// The constructor argument was given twice: once as an attribute and once
+    /// as text content.
+    DuplicateContent {
+        element: String,
+        attribute: String,
+        pos: Position,
+    },
+    /// A leaf element with element children.
+    NoChildrenAllowed { element: String, pos: Position },
+}
+
+impl fmt::Display for XamlError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            XamlError::Xml(err) => write!(f, "malformed XAML: {}", err),
+            XamlError::Io { path, source } => {
+                write!(f, "cannot read `{}`: {}", path.display(), source)
+            }
+            XamlError::NoRoot => write!(f, "the document contains no root element"),
+            XamlError::UnknownElement { element, pos } => {
+                write!(f, "unknown XAML element `<{}>` at {}", element, pos)
+            }
+            XamlError::UnknownAttribute {
+                element,
+                attribute,
+                pos,
+            } => write!(
+                f,
+                "unknown attribute `{}` on `<{}>` at {}",
+                attribute, element, pos
+            ),
+            XamlError::MissingAttribute {
+                element,
+                attribute,
+                pos,
+            } => write!(
+                f,
+                "`<{}>` requires `{}`, missing at {}",
+                element, attribute, pos
+            ),
+            XamlError::UnsupportedValue {
+                element,
+                attribute,
+                value,
+                reason,
+                pos,
+            } => write!(
+                f,
+                "`{}=\"{}\"` on `<{}>` at {}: {}",
+                attribute, value, element, pos, reason
+            ),
+            XamlError::UnsupportedMarkupExtension {
+                element,
+                attribute,
+                value,
+                pos,
+            } => write!(
+                f,
+                "unsupported markup extension `{}` in `{}` on `<{}>` at {}; \
+                 only `{{Binding ..}}` is supported",
+                value, attribute, element, pos
+            ),
+            XamlError::UnresolvedBinding {
+                element,
+                attribute,
+                path,
+                pos,
+            } => write!(
+                f,
+                "unresolved binding `{}` in `{}` on `<{}>` at {}; \
+                 supply it with `XamlContext::value`",
+                path, attribute, element, pos
+            ),
+            XamlError::UnknownHandler {
+                element,
+                attribute,
+                handler,
+                pos,
+            } => write!(
+                f,
+                "unknown handler `{}` for `{}` on `<{}>` at {}; \
+                 supply it with `XamlContext::handler`",
+                handler, attribute, element, pos
+            ),
+            XamlError::DuplicateContent {
+                element,
+                attribute,
+                pos,
+            } => write!(
+                f,
+                "`<{}>` at {} sets its content twice: as `{}` and as text content",
+                element, pos, attribute
+            ),
+            XamlError::NoChildrenAllowed { element, pos } => {
+                write!(f, "`<{}>` at {} does not accept children", element, pos)
+            }
+        }
+    }
+}
+
+impl std::error::Error for XamlError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            XamlError::Xml(err) => Some(err),
+            XamlError::Io { source, .. } => Some(source),
+            _ => None,
+        }
+    }
+}
+
+impl From<roxmltree::Error> for XamlError {
+    fn from(err: roxmltree::Error) -> Self {
+        XamlError::Xml(err)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn xml_display_includes_line_and_column() {
+        let err: XamlError = roxmltree::Document::parse("<Grid>\n  <StackPanel>\n</Grid>")
+            .unwrap_err()
+            .into();
+        let message = err.to_string();
+
+        assert!(message.starts_with("malformed XAML: "), "{}", message);
+        assert!(message.contains("3:1"), "{}", message);
+    }
+
+    #[test]
+    fn unknown_element_display_names_element_and_position() {
+        let err = XamlError::UnknownElement {
+            element: "Canvas".to_string(),
+            pos: Position::new(4, 7),
+        };
+
+        assert_eq!(err.to_string(), "unknown XAML element `<Canvas>` at 4:7");
+    }
+
+    #[test]
+    fn io_display_names_the_path() {
+        let err = XamlError::Io {
+            path: PathBuf::from("/tmp/missing.xaml"),
+            source: std::io::Error::new(std::io::ErrorKind::NotFound, "no such file"),
+        };
+
+        let message = err.to_string();
+        assert!(message.contains("/tmp/missing.xaml"), "{}", message);
+        assert!(message.contains("no such file"), "{}", message);
+    }
+
+    #[test]
+    fn error_source_is_the_wrapped_cause() {
+        use std::error::Error;
+
+        let xml: XamlError = roxmltree::Document::parse("<").unwrap_err().into();
+        assert!(xml.source().is_some());
+
+        let no_root = XamlError::NoRoot;
+        assert!(no_root.source().is_none());
+    }
+}
diff --git a/rusty-xaml/src/lib.rs b/rusty-xaml/src/lib.rs
new file mode 100644
index 0000000..90c5bf4
--- /dev/null
+++ b/rusty-xaml/src/lib.rs
@@ -0,0 +1,110 @@
+//! Parses XAML markup into [`rusty`] widget trees at runtime.
+//!
+//! `rusty-ivyml` compiles markup into builder calls at compile time; this crate
+//! does the same job with a `&str` that only exists once the program is running —
+//! a document loaded from disk, from a database, or edited while the app is up.
+//! The cost of that is the obvious one: a mistake in the markup is a
+//! [`XamlError`] rather than a compiler error, so every function here returns a
+//! `Result`.
+//!
+//! ```
+//! use rusty_xaml::XamlContext;
+//!
+//! let ctx = XamlContext::new()
+//!     .value("Title", "Dashboard")
+//!     .handler("OnIncrement", || println!("clicked"));
+//!
+//! let element = rusty_xaml::parse_with(
+//!     r#"<StackPanel Spacing="8">
+//!            <TextBlock Text="{Binding Title}" Variant="Heading1" />
+//!            <Button Content="Increment" Click="OnIncrement" />
+//!        </StackPanel>"#,
+//!     &ctx,
+//! )?;
+//!
+//! # let json = serde_json::to_value(&element).unwrap();
+//! # assert_eq!(json["children"][0]["content"], "Dashboard");
+//! # Ok::<(), rusty_xaml::XamlError>(())
+//! ```
+//!
+//! # Bindings are a snapshot
+//!
+//! `{Binding X}` is resolved once, while parsing, from the [`XamlContext`] handed
+//! to [`parse_with`]. The returned [`Element`] holds the resolved value, not a
+//! live link back to it — there is no data-context machinery here.
+//!
+//! Re-rendering therefore works exactly as it does for a hand-built tree: call
+//! [`parse_with`] *inside* `View::build`, with a context built from the current
+//! state. Every rebuild re-parses, and every rebuild sees fresh values. Parsing
+//! once into a `static` and expecting a bound label to change will not work.
+//!
+//! # Widget ids
+//!
+//! `x:Name` is ignored, along with the rest of the `x:` directives. Rusty assigns
+//! widget ids itself during `Element::assign_ids`, keyed by position in the tree,
+//! and the event registry is keyed by those ids — so honouring `x:Name` would
+//! mean either two id schemes or an id that `assign_ids` immediately overwrites.
+//! Naming an element is still useful documentation, so it parses rather than
+//! erroring.
+//!
+//! Events are wired the same way: `Click="OnIncrement"` names a handler that
+//! [`XamlContext::handler`] must have registered. The value is a name, never an
+//! expression; there is no interpreter in this crate.
+//!
+//! # What the markup may contain
+//!
+//! The vocabulary is the WPF-flavoured spelling of Rusty's widgets
+//! (`<StackPanel>`, `<Border>`, `<TextBlock Text=".." />`), and each widget's
+//! Rusty name is accepted as an alias. Anything outside it — an unknown element,
+//! an unknown attribute, an unparseable value, a child on a leaf — is an error
+//! rather than a silent omission, because markup that renders half its styling is
+//! worse than markup that refuses to render.
+
+mod build;
+mod context;
+mod error;
+mod value;
+
+use std::fs;
+use std::path::Path;
+
+use roxmltree::Document;
+use rusty::views::Element;
+
+pub use crate::context::{Handler, XamlContext};
+pub use crate::error::{Position, XamlError};
+
+/// Parse a XAML document with no bindings and no handlers.
+///
+/// Equivalent to [`parse_with`] against a default [`XamlContext`]: a document
+/// containing `{Binding ..}` or an event attribute fails here, naming what was
+/// missing.
+pub fn parse(xaml: &str) -> Result<Element, XamlError> {
+    parse_with(xaml, &XamlContext::new())
+}
+
+/// Parse a XAML document, resolving bindings and handlers against `ctx`.
+pub fn parse_with(xaml: &str, ctx: &XamlContext) -> Result<Element, XamlError> {
+    let doc = Document::parse(xaml)?;
+    build::build_root(&doc, ctx)
+}
+
+/// Read a `.xaml` file and parse it.
+pub fn parse_file(path: impl AsRef<Path>) -> Result<Element, XamlError> {
+    parse_file_with(path, &XamlContext::new())
+}
+
+/// Read a `.xaml` file and parse it, resolving against `ctx`.
+///
+/// The file is read into a `String` first: `roxmltree` borrows from the text for
+/// as long as the `Document` lives, while an [`Element`] owns everything it
+/// needs, so neither outlives this call.
+pub fn parse_file_with(path: impl AsRef<Path>, ctx: &XamlContext) -> Result<Element, XamlError> {
+    let path = path.as_ref();
+    let xaml = fs::read_to_string(path).map_err(|source| XamlError::Io {
+        path: path.to_path_buf(),
+        source,
+    })?;
+
+    parse_with(&xaml, ctx)
+}
diff --git a/rusty-xaml/src/value.rs b/rusty-xaml/src/value.rs
new file mode 100644
index 0000000..e4cd14e
--- /dev/null
+++ b/rusty-xaml/src/value.rs
@@ -0,0 +1,431 @@
+//! Turning one attribute string into the argument a builder takes.
+//!
+//! Two steps, deliberately separate:
+//!
+//! 1. [`resolve`] strips XAML's markup extensions, so `{Binding Count}` becomes
+//!    whatever the [`XamlContext`] holds under `Count`. The result is a
+//!    `serde_json::Value`, which is also what a widget's props serialize to.
+//! 2. The `as_*` coercions turn that value into an `f64`, a `Size`, an enum, and
+//!    so on. Enums go through serde rather than hand-written match arms: the
+//!    variant list lives on the enum in `rusty::shared`, and duplicating it here
+//!    is how the two drift apart.
+
+use serde::de::DeserializeOwned;
+use serde_json::Value;
+
+use rusty::shared::{Align, Color, Justify, Size};
+
+use crate::context::XamlContext;
+use crate::error::{Position, XamlError};
+
+/// Where in the document a value came from, carried so a coercion failure can
+/// name the element and attribute it belongs to without threading the whole
+/// document into every helper.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct Site<'a> {
+    pub element: &'a str,
+    pub attribute: &'a str,
+    pub pos: Position,
+}
+
+impl Site<'_> {
+    pub(crate) fn unsupported(
+        &self,
+        value: impl Into<String>,
+        reason: impl Into<String>,
+    ) -> XamlError {
+        XamlError::UnsupportedValue {
+            element: self.element.to_string(),
+            attribute: self.attribute.to_string(),
+            value: value.into(),
+            reason: reason.into(),
+            pos: self.pos,
+        }
+    }
+}
+
+/// Resolve an attribute string, expanding a `{Binding ..}` markup extension
+/// against `ctx`.
+///
+/// Resolution happens once, here, at parse time — the returned tree is a
+/// snapshot. See the crate docs for what that means for re-rendering.
+pub(crate) fn resolve(raw: &str, ctx: &XamlContext, site: Site<'_>) -> Result<Value, XamlError> {
+    // `{}` is XAML's escape for a literal opening brace, so `{}{Binding x}` is
+    // the text `{Binding x}`. It has to be checked before the `{` branch.
+    if let Some(literal) = raw.strip_prefix("{}") {
+        return Ok(Value::String(literal.to_string()));
+    }
+
+    let Some(inner) = raw
+        .strip_prefix('{')
+        .and_then(|rest| rest.strip_suffix('}'))
+    else {
+        if raw.starts_with('{') {
+            return Err(unsupported_extension(&site, raw));
+        }
+        return Ok(Value::String(raw.to_string()));
+    };
+
+    let inner = inner.trim();
+    let Some(rest) = inner.strip_prefix("Binding") else {
+        return Err(unsupported_extension(&site, raw));
+    };
+    // `{BindingSource ..}` is not `{Binding ..}` with a path of `Source ..`.
+    if !rest.is_empty() && !rest.starts_with(char::is_whitespace) {
+        return Err(unsupported_extension(&site, raw));
+    }
+
+    // `{Binding Count}` and `{Binding Path=Count}` are the same binding.
+    let path = rest.trim();
+    let path = path.strip_prefix("Path=").unwrap_or(path).trim();
+    if path.is_empty() {
+        return Err(site.unsupported(
+            raw,
+            "a binding needs a path, e.g. `{Binding Count}`; there is no data context to bind to",
+        ));
+    }
+
+    ctx.value_of(path)
+        .cloned()
+        .ok_or_else(|| XamlError::UnresolvedBinding {
+            element: site.element.to_string(),
+            attribute: site.attribute.to_string(),
+            path: path.to_string(),
+            pos: site.pos,
+        })
+}
+
+fn unsupported_extension(site: &Site<'_>, raw: &str) -> XamlError {
+    XamlError::UnsupportedMarkupExtension {
+        element: site.element.to_string(),
+        attribute: site.attribute.to_string(),
+        value: raw.to_string(),
+        pos: site.pos,
+    }
+}
+
+/// The text form of a resolved value.
+///
+/// A bound number reaches a `&str` slot as its digits rather than as JSON, so
+/// `Text="{Binding Count}"` with `Count = 3` renders `3`, not `"3"`.
+pub(crate) fn as_text(value: &Value) -> String {
+    match value {
+        Value::String(text) => text.clone(),
+        Value::Null => String::new(),
+        other => other.to_string(),
+    }
+}
+
+pub(crate) fn as_f64(value: &Value, site: Site<'_>) -> Result<f64, XamlError> {
+    if let Some(number) = value.as_f64() {
+        return Ok(number);
+    }
+    let text = as_text(value);
+    text.trim()
+        .parse::<f64>()
+        .map_err(|_| site.unsupported(text, "expected a number"))
+}
+
+pub(crate) fn as_usize(value: &Value, site: Site<'_>) -> Result<usize, XamlError> {
+    if let Some(number) = value.as_u64() {
+        return Ok(number as usize);
+    }
+    let text = as_text(value);
+    text.trim()
+        .parse::<usize>()
+        .map_err(|_| site.unsupported(text, "expected a non-negative whole number"))
+}
+
+/// XAML writes booleans `True` / `False`; the wire form is `true` / `false`.
+pub(crate) fn as_bool(value: &Value, site: Site<'_>) -> Result<bool, XamlError> {
+    if let Some(flag) = value.as_bool() {
+        return Ok(flag);
+    }
+    let text = as_text(value);
+    match text.trim() {
+        t if t.eq_ignore_ascii_case("true") => Ok(true),
+        t if t.eq_ignore_ascii_case("false") => Ok(false),
+        _ => Err(site.unsupported(text, "expected `True` or `False`")),
+    }
+}
+
+/// `Width="120"`, `Width="240px"`, `Width="50%"` and `Width="Auto"`.
+///
+/// `Size::parse_css` covers the last three. The bare number is XAML's own
+/// spelling (device-independent pixels) and `parse_css` rejects it, deliberately,
+/// because it also deserializes the wire format — so the fallback lives here.
+/// Star sizing (`*`, `2*`) has no `Size` variant and is rejected rather than
+/// silently rounded to something else.
+pub(crate) fn as_size(value: &Value, site: Site<'_>) -> Result<Size, XamlError> {
+    let text = as_text(value);
+    if let Some(size) = Size::parse_css(&text) {
+        return Ok(size);
+    }
+    if let Ok(px) = text.trim().parse::<f64>() {
+        return Ok(Size::Px(px));
+    }
+    Err(site.unsupported(
+        text,
+        "expected a length such as `120`, `240px`, `50%` or `Auto`; \
+         XAML star sizing is not supported",
+    ))
+}
+
+pub(crate) fn as_color(value: &Value, site: Site<'_>) -> Result<Color, XamlError> {
+    let raw = as_text(value);
+    serde_json::from_value::<Color>(Value::String(camel_case(&raw)))
+        .map_err(|err| site.unsupported(raw, err.to_string()))
+}
+
+/// `HorizontalAlignment` in XAML terms, `align` in Rusty terms.
+///
+/// `Left` / `Right` are XAML's words for the same thing `Align::Start` / `End`
+/// mean, so they are translated before serde sees the value; every other word
+/// goes straight to the enum, which stays the single source of truth for the
+/// variant set.
+pub(crate) fn as_align(value: &Value, site: Site<'_>) -> Result<Align, XamlError> {
+    let raw = as_text(value);
+    let mapped = match raw.as_str() {
+        "Left" => "Start",
+        "Right" => "End",
+        other => other,
+    };
+    as_enum_from(mapped, &raw, site)
+}
+
+/// `VerticalAlignment` in XAML terms, `justify` in Rusty terms.
+pub(crate) fn as_justify(value: &Value, site: Site<'_>) -> Result<Justify, XamlError> {
+    let raw = as_text(value);
+    let mapped = match raw.as_str() {
+        "Top" => "Start",
+        "Bottom" => "End",
+        other => other,
+    };
+    as_enum_from(mapped, &raw, site)
+}
+
+/// A PascalCase XAML value onto a `#[serde(rename_all = "camelCase")]` variant.
+pub(crate) fn as_enum<T: DeserializeOwned>(value: &Value, site: Site<'_>) -> Result<T, XamlError> {
+    let raw = as_text(value);
+    as_enum_from(&raw, &raw, site)
+}
+
+fn as_enum_from<T: DeserializeOwned>(
+    text: &str,
+    raw: &str,
+    site: Site<'_>,
+) -> Result<T, XamlError> {
+    serde_json::from_value::<T>(Value::String(camel_case(text)))
+        .map_err(|err| site.unsupported(raw, err.to_string()))
+}
+
+/// `SpaceBetween` -> `spaceBetween`, `Heading1` -> `heading1`.
+///
+/// Lowercasing the first character is the whole conversion: the wire names are
+/// camelCase of the same words, so anything more (splitting on case boundaries,
+/// say) would break `Heading1`.
+fn camel_case(value: &str) -> String {
+    let mut chars = value.chars();
+    match chars.next() {
+        Some(first) => first.to_lowercase().collect::<String>() + chars.as_str(),
+        None => String::new(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rusty::widgets::text::TextVariant;
+
+    fn site() -> Site<'static> {
+        Site {
+            element: "TextBlock",
+            attribute: "Text",
+            pos: Position::new(1, 2),
+        }
+    }
+
+    fn resolved(raw: &str, ctx: &XamlContext) -> Result<Value, XamlError> {
+        resolve(raw, ctx, site())
+    }
+
+    #[test]
+    fn plain_text_passes_through() {
+        let ctx = XamlContext::new();
+        assert_eq!(
+            resolved("Dashboard", &ctx).unwrap(),
+            Value::from("Dashboard")
+        );
+        assert_eq!(resolved("", &ctx).unwrap(), Value::from(""));
+    }
+
+    #[test]
+    fn binding_and_explicit_path_resolve_identically() {
+        let ctx = XamlContext::new().value("Count", 3);
+
+        let short = resolved("{Binding Count}", &ctx).unwrap();
+        let explicit = resolved("{Binding Path=Count}", &ctx).unwrap();
+
+        assert_eq!(short, Value::from(3));
+        assert_eq!(short, explicit);
+    }
+
+    #[test]
+    fn binding_tolerates_surrounding_whitespace() {
+        let ctx = XamlContext::new().value("Title", "Dashboard");
+        assert_eq!(
+            resolved("{ Binding  Title }", &ctx).unwrap(),
+            Value::from("Dashboard")
+        );
+    }
+
+    #[test]
+    fn brace_escape_yields_the_literal_braces() {
+        let ctx = XamlContext::new();
+        assert_eq!(
+            resolved("{}{Binding literal}", &ctx).unwrap(),
+            Value::from("{Binding literal}")
+        );
+    }
+
+    #[test]
+    fn other_markup_extensions_are_rejected() {
+        let ctx = XamlContext::new();
+
+        for raw in [
+            "{StaticResource Brush}",
+            "{TemplateBinding Width}",
+            "{x:Static Colors.Red}",
+            "{BindingSource Count}",
+            "{Binding Count",
+        ] {
+            let err = resolved(raw, &ctx).unwrap_err();
+            assert!(
+                matches!(err, XamlError::UnsupportedMarkupExtension { .. }),
+                "{raw} produced {err:?}"
+            );
+            assert!(err.to_string().contains(raw), "{}", err);
+        }
+    }
+
+    #[test]
+    fn an_empty_binding_path_is_rejected() {
+        let ctx = XamlContext::new();
+        let err = resolved("{Binding}", &ctx).unwrap_err();
+        assert!(matches!(err, XamlError::UnsupportedValue { .. }), "{err:?}");
+    }
+
+    #[test]
+    fn an_unresolved_binding_is_an_error_not_an_empty_string() {
+        let ctx = XamlContext::new().value("Other", 1);
+        let err = resolved("{Binding Count}", &ctx).unwrap_err();
+
+        assert!(
+            matches!(&err, XamlError::UnresolvedBinding { path, .. } if path == "Count"),
+            "{err:?}"
+        );
+        assert!(err.to_string().contains("Count"), "{}", err);
+    }
+
+    #[test]
+    fn text_of_a_bound_number_is_its_digits() {
+        assert_eq!(as_text(&Value::from(3)), "3");
+        assert_eq!(as_text(&Value::from(1.5)), "1.5");
+        assert_eq!(as_text(&Value::from(true)), "true");
+        assert_eq!(as_text(&Value::from("x")), "x");
+        assert_eq!(as_text(&Value::Null), "");
+    }
+
+    #[test]
+    fn numbers_come_from_json_or_from_text() {
+        assert_eq!(as_f64(&Value::from(1.5), site()).unwrap(), 1.5);
+        assert_eq!(as_f64(&Value::from("2.5"), site()).unwrap(), 2.5);
+        assert_eq!(as_usize(&Value::from(3), site()).unwrap(), 3);
+        assert_eq!(as_usize(&Value::from(" 4 "), site()).unwrap(), 4);
+
+        assert!(as_f64(&Value::from("wide"), site()).is_err());
+        assert!(as_usize(&Value::from("-1"), site()).is_err());
+    }
+
+    #[test]
+    fn booleans_accept_xaml_casing() {
+        assert!(as_bool(&Value::from("True"), site()).unwrap());
+        assert!(!as_bool(&Value::from("False"), site()).unwrap());
+        assert!(as_bool(&Value::from(true), site()).unwrap());
+        assert!(as_bool(&Value::from("yes"), site()).is_err());
+    }
+
+    #[test]
+    fn sizes_accept_bare_pixels_percent_and_auto() {
+        assert_eq!(
+            as_size(&Value::from("120"), site()).unwrap(),
+            Size::Px(120.0)
+        );
+        assert_eq!(
+            as_size(&Value::from("240px"), site()).unwrap(),
+            Size::Px(240.0)
+        );
+        assert_eq!(
+            as_size(&Value::from("50%"), site()).unwrap(),
+            Size::Percent(50.0)
+        );
+        assert_eq!(as_size(&Value::from("Auto"), site()).unwrap(), Size::Auto);
+        assert_eq!(as_size(&Value::from(120), site()).unwrap(), Size::Px(120.0));
+    }
+
+    #[test]
+    fn star_sizing_is_rejected() {
+        for raw in ["*", "2*", "1.5*"] {
+            let err = as_size(&Value::from(raw), site()).unwrap_err();
+            assert!(matches!(err, XamlError::UnsupportedValue { .. }), "{err:?}");
+            assert!(err.to_string().contains("star sizing"), "{}", err);
+        }
+    }
+
+    #[test]
+    fn enums_resolve_through_serde() {
+        assert_eq!(
+            as_enum::<TextVariant>(&Value::from("Heading1"), site()).unwrap(),
+            TextVariant::Heading1
+        );
+        assert_eq!(
+            as_align(&Value::from("Left"), site()).unwrap(),
+            Align::Start
+        );
+        assert_eq!(as_align(&Value::from("Right"), site()).unwrap(), Align::End);
+        assert_eq!(
+            as_align(&Value::from("Stretch"), site()).unwrap(),
+            Align::Stretch
+        );
+        assert_eq!(
+            as_justify(&Value::from("Top"), site()).unwrap(),
+            Justify::Start
+        );
+        assert_eq!(
+            as_justify(&Value::from("SpaceBetween"), site()).unwrap(),
+            Justify::SpaceBetween
+        );
+    }
+
+    #[test]
+    fn an_unknown_enum_value_reports_the_accepted_variants() {
+        let err = as_align(&Value::from("Middle"), site()).unwrap_err();
+        let message = err.to_string();
+
+        assert!(message.contains("Middle"), "{}", message);
+        assert!(message.contains("stretch"), "{}", message);
+    }
+
+    #[test]
+    fn colors_accept_named_hex_and_rgba() {
+        assert_eq!(
+            as_color(&Value::from("Primary"), site()).unwrap(),
+            Color::Named(rusty::shared::NamedColor::Primary)
+        );
+        assert_eq!(
+            as_color(&Value::from("#ff0000"), site()).unwrap(),
+            Color::Hex("#ff0000".to_string())
+        );
+        assert!(as_color(&Value::from("Chartreuse"), site()).is_err());
+    }
+}
diff --git a/rusty-xaml/tests/fixtures/dashboard.xaml b/rusty-xaml/tests/fixtures/dashboard.xaml
new file mode 100644
index 0000000..f7dadbd
--- /dev/null
+++ b/rusty-xaml/tests/fixtures/dashboard.xaml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- A document shaped like something a real app would load from disk. -->
+<StackPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+            x:Name="Dashboard"
+            Spacing="16"
+            Padding="24">
+    <TextBlock Text="Dashboard" Variant="Heading1" />
+
+    <Grid Columns="2" Spacing="12">
+        <GroupBox Header="Revenue" Subtitle="This month">
+            <StackPanel Spacing="4">
+                <TextBlock Text="£12,480" Variant="Heading2" />
+                <Badge Content="+8%" Variant="Outline" Color="Success" />
+            </StackPanel>
+        </GroupBox>
+
+        <GroupBox Header="Progress">
+            <StackPanel Spacing="8">
+                <ProgressBar Value="0.62" Label="Quarterly target" />
+                <Separator />
+                <TextBlock Text="62% of target" Variant="Caption" />
+            </StackPanel>
+        </GroupBox>
+    </Grid>
+
+    <Border Padding="12" Border="True" Rounded="True">
+        <ListView>
+            <ListViewItem Content="Invoice #1041" Subtitle="Paid" Icon="check" />
+            <ListViewItem Content="Invoice #1042" Subtitle="Pending" Icon="clock" />
+        </ListView>
+    </Border>
+</StackPanel>
diff --git a/rusty-xaml/tests/parse.rs b/rusty-xaml/tests/parse.rs
new file mode 100644
index 0000000..ece3258
--- /dev/null
+++ b/rusty-xaml/tests/parse.rs
@@ -0,0 +1,344 @@
+//! The crate from the outside: whole documents, whole trees.
+//!
+//! The unit tests in `src/build.rs` cover one element at a time. These cover the
+//! properties that only show up once several elements are nested — that a parsed
+//! tree is indistinguishable from a hand-built one, that ids and events survive
+//! the trip through `assign_ids`, and that the vocabulary has not fallen behind
+//! `rusty-ivyml`'s.
+
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+
+use rusty::hooks::hook_store::HookStore;
+use rusty::views::{BuildContext, Element};
+use rusty::widgets::text::TextVariant;
+use rusty::widgets::{Badge, Button, Card, Container, Layout, List, ListItem, TextBlock};
+use rusty_xaml::{parse, parse_file, parse_with, XamlContext, XamlError};
+use serde_json::Value;
+
+fn json(element: &Element) -> Value {
+    serde_json::to_value(element).expect("a widget tree serializes")
+}
+
+fn fixture(name: &str) -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("tests/fixtures")
+        .join(name)
+}
+
+#[test]
+fn a_nested_document_matches_the_equivalent_builder_chain() {
+    let parsed = parse(
+        r#"<Grid Columns="2" Spacing="16" Padding="24">
+               <StackPanel Orientation="Horizontal" Spacing="8" HorizontalAlignment="Center">
+                   <Border Padding="12" Rounded="True">
+                       <TextBlock Text="Revenue" Variant="Heading2" />
+                   </Border>
+                   <Button Content="Refresh" Variant="Secondary" />
+               </StackPanel>
+           </Grid>"#,
+    )
+    .expect("parses");
+
+    let built: Element = Layout::grid(2)
+        .gap(16.0)
+        .padding(24.0)
+        .child(
+            Layout::horizontal()
+                .gap(8.0)
+                .align(rusty::shared::Align::Center)
+                .child(
+                    Container::new()
+                        .padding(12.0)
+                        .rounded(true)
+                        .child(TextBlock::new("Revenue").variant(TextVariant::Heading2)),
+                )
+                .child(
+                    Button::new("Refresh")
+                        .variant(rusty::widgets::button::ButtonVariant::Secondary),
+                ),
+        )
+        .into();
+
+    assert_eq!(json(&parsed), json(&built));
+}
+
+#[test]
+fn nesting_three_deep_mixes_child_and_item_attachment() {
+    let parsed = parse(
+        r#"<Card Header="Invoices">
+               <List>
+                   <ListItem Content="Invoice #1041" Subtitle="Paid" />
+                   <Container>
+                       <Badge Content="2 overdue" Variant="Dot" />
+                   </Container>
+               </List>
+           </Card>"#,
+    )
+    .expect("parses");
+
+    let built: Element = Card::new()
+        .title("Invoices")
+        .child(
+            List::new()
+                .item(ListItem::new("Invoice #1041").subtitle("Paid"))
+                .item(Container::new().child(
+                    Badge::new("2 overdue").variant(rusty::widgets::badge::BadgeVariant::Dot),
+                )),
+        )
+        .into();
+
+    let wire = json(&parsed);
+    assert_eq!(wire, json(&built));
+
+    // The middle level attached with `item`, not `child`: a `List` has no
+    // `children` at all, and getting this wrong renders an empty list.
+    assert_eq!(wire["children"][0]["type"], "list");
+    assert_eq!(wire["children"][0]["items"][0]["title"], "Invoice #1041");
+    assert!(wire["children"][0]["children"].is_null());
+    assert_eq!(
+        wire["children"][0]["items"][1]["children"][0]["type"],
+        "badge"
+    );
+}
+
+#[test]
+fn parse_file_matches_parsing_the_same_text() {
+    let path = fixture("dashboard.xaml");
+    let text = std::fs::read_to_string(&path).expect("the fixture is readable");
+
+    let from_file = parse_file(&path).expect("the fixture parses");
+    let from_text = parse(&text).expect("the fixture text parses");
+
+    assert_eq!(json(&from_file), json(&from_text));
+
+    // A spot check that it is the document, not just two equal errors.
+    let wire = json(&from_file);
+    assert_eq!(wire["type"], "layout");
+    assert_eq!(wire["children"][0]["content"], "Dashboard");
+    assert_eq!(wire["children"][1]["columns"], 2);
+}
+
+#[test]
+fn a_missing_file_names_the_path_it_tried() {
+    let path = fixture("does-not-exist.xaml");
+    let err = parse_file(&path).expect_err("a missing file is an error");
+
+    assert!(matches!(err, XamlError::Io { .. }), "{err:?}");
+    assert!(
+        err.to_string().contains("does-not-exist.xaml"),
+        "{}",
+        err.to_string()
+    );
+
+    // The cause is preserved, so a caller can distinguish "missing" from
+    // "unreadable".
+    let source = std::error::Error::source(&err).expect("the io error is the cause");
+    assert!(source.to_string().to_lowercase().contains("no such file"));
+}
+
+#[test]
+fn document_furniture_does_not_change_the_tree() {
+    let bare = parse(r#"<StackPanel Spacing="8"><TextBlock Text="Hi" /></StackPanel>"#).unwrap();
+    let decorated = parse(
+        r#"<?xml version="1.0" encoding="utf-8"?>
+           <!-- a leading comment -->
+           <StackPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                       x:Name="Root"
+                       Spacing="8">
+               <!-- an inner comment -->
+               <TextBlock x:Name="Greeting" Text="Hi" />
+           </StackPanel>"#,
+    )
+    .unwrap();
+
+    assert_eq!(json(&bare), json(&decorated));
+}
+
+#[test]
+fn ids_and_events_survive_assign_ids() {
+    let clicks = Arc::new(AtomicUsize::new(0));
+    let on_refresh = clicks.clone();
+    let on_pick = clicks.clone();
+    let ctx = XamlContext::new()
+        .value("Heading", "Invoices")
+        .handler("OnRefresh", move || {
+            on_refresh.fetch_add(1, Ordering::SeqCst);
+        })
+        .handler("OnPick", move || {
+            on_pick.fetch_add(1, Ordering::SeqCst);
+        });
+
+    let mut element = parse_with(
+        r#"<StackPanel>
+               <TextBlock Text="{Binding Heading}" />
+               <Button Content="Refresh" Click="OnRefresh" />
+               <List>
+                   <ListItem Content="Invoice #1041" Click="OnPick" />
+               </List>
+           </StackPanel>"#,
+        &ctx,
+    )
+    .expect("parses");
+
+    let mut store = HookStore::default();
+    let mut build = BuildContext::new(&mut store, None);
+    element.assign_ids(&mut build);
+
+    let wire = json(&element);
+    let clickable = clickable_ids(&wire);
+    assert_eq!(clickable.len(), 2, "{:#?}", clickable);
+
+    for (id, _) in &clickable {
+        assert!(
+            build
+                .event_registry_mut()
+                .dispatch(id, "click", Value::Null),
+            "no handler registered for {id}"
+        );
+    }
+
+    assert_eq!(clicks.load(Ordering::SeqCst), 2);
+
+    // Every widget was given an id, including the ones with no handler.
+    assert!(ids(&wire).len() >= 5, "{:#?}", ids(&wire));
+}
+
+/// Every element `rusty-ivyml` accepts at compile time is also accepted here.
+///
+/// A drift guard rather than a list: `codegen.rs` is the compile-time
+/// vocabulary, and an element added there but not here would silently mean
+/// "IvyML can express this, XAML cannot". The table below is the claim being
+/// checked — that each name has markup this crate can parse — so adding a name
+/// upstream fails this test until a mapping exists.
+#[test]
+fn mapping_covers_every_ivyml_element() {
+    // Minimal markup per IvyML element, using its Rusty name so the alias path
+    // is what gets exercised.
+    let mapping: BTreeMap<&str, &str> = BTreeMap::from([
+        ("Badge", r#"<Badge Content="New" />"#),
+        ("Button", r#"<Button Content="Go" />"#),
+        ("Card", r#"<Card />"#),
+        ("Container", r#"<Container />"#),
+        ("Layout", r#"<Layout />"#),
+        ("List", r#"<List />"#),
+        ("ListItem", r#"<ListItem Content="One" />"#),
+        ("Spacer", r#"<Spacer />"#),
+        ("TextBlock", r#"<TextBlock Text="Hi" />"#),
+        ("TextInput", r#"<TextInput />"#),
+    ]);
+
+    for name in ivyml_element_names() {
+        let markup = mapping.get(name.as_str()).unwrap_or_else(|| {
+            panic!(
+                "`<{name}>` is an IvyML element with no XAML mapping. Add it to \
+                 `Build::element` in `rusty-xaml/src/build.rs`, then to this table."
+            )
+        });
+
+        let element = parse(markup)
+            .unwrap_or_else(|err| panic!("the mapping for `<{name}>` does not parse: {err}"));
+        assert_eq!(
+            json(&element)["kind"],
+            "widget",
+            "the mapping for `<{name}>` did not produce a widget"
+        );
+    }
+}
+
+/// The element names in `rusty-ivyml`'s `shape_for`.
+///
+/// Read from source rather than imported: `shape_for` is private, and the arms
+/// are string literals in a `match`, so there is nothing to import even if it
+/// were public.
+fn ivyml_element_names() -> Vec<String> {
+    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../rusty-ivyml/src/codegen.rs");
+    let source = std::fs::read_to_string(&path)
+        .unwrap_or_else(|err| panic!("cannot read {}: {err}", path.display()));
+
+    let body = source
+        .split_once("fn shape_for(")
+        .expect("`shape_for` still exists")
+        .1;
+    // The leading newline matters: `shape_for`'s nested `match` has a catch-all of
+    // its own, deeper indented, and without it the scan stops at the first one.
+    let body = body
+        .split_once("\n        other => {")
+        .expect("`shape_for` still ends in a catch-all arm")
+        .0;
+
+    // The arms of `shape_for`'s own `match` are indented by exactly eight spaces;
+    // the nested `match` on `direction` is deeper, which is what keeps
+    // `"vertical"` out of this list.
+    let names: Vec<String> = body
+        .lines()
+        .filter_map(|line| {
+            let rest = line.strip_prefix("        \"")?;
+            let (name, tail) = rest.split_once('"')?;
+            tail.trim_start()
+                .starts_with("=>")
+                .then(|| name.to_string())
+        })
+        .collect();
+
+    assert!(
+        names.len() >= 10,
+        "only found {} IvyML elements, so the scan is probably broken: {:?}",
+        names.len(),
+        names
+    );
+
+    names
+}
+
+/// Every `id` in a serialized tree.
+fn ids(wire: &Value) -> Vec<String> {
+    let mut found = Vec::new();
+    walk(wire, &mut |node| {
+        if let Some(id) = node.get("id").and_then(Value::as_str) {
+            found.push(id.to_string());
+        }
+    });
+    found
+}
+
+/// The `id` of every widget that reported a click handler.
+fn clickable_ids(wire: &Value) -> Vec<(String, String)> {
+    let mut found = Vec::new();
+    walk(wire, &mut |node| {
+        if node.get("hasOnClick") == Some(&Value::Bool(true)) {
+            let id = node
+                .get("id")
+                .and_then(Value::as_str)
+                .expect("a widget with a handler was given an id")
+                .to_string();
+            let kind = node
+                .get("type")
+                .and_then(Value::as_str)
+                .unwrap_or_default()
+                .to_string();
+            found.push((id, kind));
+        }
+    });
+    found
+}
+
+fn walk(value: &Value, visit: &mut impl FnMut(&Value)) {
+    match value {
+        Value::Object(map) => {
+            visit(value);
+            for child in map.values() {
+                walk(child, visit);
+            }
+        }
+        Value::Array(items) => {
+            for item in items {
+                walk(item, visit);
+            }
+        }
+        _ => {}
+    }
+}