renamite_model/

lib.rs

//! Serializable document model + pure evaluator.
//!
//! Group evaluation: pass 1 accumulates shape paths and applies modifiers in
//! document order; pass 2 recurses/emits styles bottom-first so `Scene.items`
//! is in painter's order. Nodes live in a slotmap arena. Tree membership is
//! attach/detach so undo/redo never changes a NodeId.

use kurbo::{Affine, BezPath, ParamCurveNearest, Point, Shape as KurboShape};
use renamite_animation::{
    Angle, Animated, AnimatedTransform, EasingHandle, Frame, Interpolation, Tween,
};
use renamite_geometry::{VectorPath, dash_bez_path, offset_bez_path};
pub use renamite_text::TextAlign;
use serde::de::{Deserializer, Error as DeError, Visitor};
use serde::{Deserialize, Serialize};
use slotmap::{SlotMap, new_key_type};

new_key_type! {
    pub struct NodeId;
    pub struct CompId;
    pub struct AssetId;
}

pub type NodeMap = SlotMap<NodeId, Node>;
pub type CompMap = SlotMap<CompId, Composition>;
pub type AssetMap = SlotMap<AssetId, Asset>;

#[derive(Clone, Serialize, Deserialize)]
pub struct Document {
    pub format_version: u32,
    pub compositions: CompMap,
    pub nodes: NodeMap,
    pub assets: AssetMap,

    /// Live/attached assets in UI order.
    #[serde(default)]
    pub asset_order: Vec<AssetId>,

    pub main: CompId,
}

#[derive(Clone, Serialize, Deserialize)]
pub struct Composition {
    pub name: String,
    pub size: (u32, u32),
    pub rate: renamite_animation::FrameRate,
    pub range: (Frame, Frame),
    /// z-order: index 0 = top of stack.
    pub children: Vec<NodeId>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Node {
    pub name: String,
    pub parent: Option<NodeId>,
    pub children: Vec<NodeId>,
    pub visible: bool,
    pub locked: bool,
    pub transform: AnimatedTransform,
    pub opacity: Animated<f64>,
    pub kind: NodeKind,
}

impl Node {
    pub fn new(name: impl Into<String>, kind: NodeKind) -> Self {
        Self {
            name: name.into(),
            parent: None,
            children: Vec::new(),
            visible: true,
            locked: false,
            transform: AnimatedTransform::identity(),
            opacity: Animated::new(1.0),
            kind,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum NodeKind {
    Group,
    Layer(LayerProps),
    Shape(ShapeKind),
    Style(StyleKind),
    Modifier(ModifierKind),
    Text(TextNode),
    Image(ImageNode),
    Precomp {
        comp: CompId,
        #[serde(default)]
        time_map: TimeMap,
    },
    Mask(MaskProps),
}

#[derive(Clone, Debug, Serialize)]
pub struct LayerProps {
    #[serde(default)]
    pub in_frame: Frame,
    #[serde(default = "default_out_frame")]
    pub out_frame: Frame,
    #[serde(default = "default_time_stretch")]
    pub time_stretch: f64,
    #[serde(default)]
    pub blend: BlendMode,
}

fn default_out_frame() -> Frame {
    Frame(i64::MAX / 2)
}
fn default_time_stretch() -> f64 {
    1.0
}

impl Default for LayerProps {
    fn default() -> Self {
        Self {
            in_frame: Frame(0),
            out_frame: Frame(i64::MAX / 2),
            time_stretch: 1.0,
            blend: BlendMode::Normal,
        }
    }
}

impl<'de> Deserialize<'de> for LayerProps {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LayerPropsVisitor;
        impl<'de> Visitor<'de> for LayerPropsVisitor {
            type Value = LayerProps;
            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                f.write_str("LayerProps")
            }
            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                let mut in_frame: Option<Frame> = None;
                let mut out_frame: Option<Frame> = None;
                let mut time_stretch: Option<f64> = None;
                let mut blend: Option<BlendMode> = None;
                while let Some(key) = map.next_key::<String>()? {
                    match key.as_str() {
                        "in_frame" => in_frame = Some(map.next_value()?),
                        "out_frame" => out_frame = Some(map.next_value()?),
                        "time_stretch" => time_stretch = Some(map.next_value()?),
                        "blend" => blend = Some(map.next_value()?),
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(LayerProps {
                    in_frame: in_frame.unwrap_or_default(),
                    out_frame: out_frame.unwrap_or_else(default_out_frame),
                    time_stretch: time_stretch.unwrap_or_else(default_time_stretch),
                    blend: blend.unwrap_or_default(),
                })
            }
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::SeqAccess<'de>,
            {
                let in_frame: Frame = seq.next_element()?.unwrap_or_default();
                let out_frame: Frame = seq.next_element()?.unwrap_or_else(default_out_frame);
                let time_stretch: f64 = seq.next_element()?.unwrap_or_else(default_time_stretch);
                let blend: BlendMode = seq.next_element()?.unwrap_or_default();
                Ok(LayerProps {
                    in_frame,
                    out_frame,
                    time_stretch,
                    blend,
                })
            }
        }
        if deserializer.is_human_readable() {
            deserializer.deserialize_any(LayerPropsVisitor)
        } else {
            deserializer.deserialize_struct(
                "LayerProps",
                &["in_frame", "out_frame", "time_stretch", "blend"],
                LayerPropsVisitor,
            )
        }
    }
}

/// Multi-contour geometry: boolean results and stroke expansions produce
/// outer contours plus holes, which one `VectorPath` cannot represent.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct CompoundPath {
    /// Every entry is one contour. Linesweeper's orientation guarantees that
    /// holes work under both NonZero and EvenOdd filling.
    pub contours: Vec<Animated<VectorPath>>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ShapeKind {
    Path(Animated<VectorPath>),
    Rect {
        pos: Animated<glam::DVec2>,
        size: Animated<glam::DVec2>,
        rounded: Animated<f64>,
    },
    Ellipse {
        pos: Animated<glam::DVec2>,
        size: Animated<glam::DVec2>,
    },
    Star {
        pos: Animated<glam::DVec2>,
        points: Animated<f64>,
        inner_r: Animated<f64>,
        outer_r: Animated<f64>,
        roundness: Animated<f64>,
        kind: StarKind,
    },
    Polygon {
        pos: Animated<glam::DVec2>,
        points: Animated<f64>,
        outer_r: Animated<f64>,
        roundness: Animated<f64>,
    },

    // Appended last to keep postcard enum indices of existing variants stable.
    CompoundPath(CompoundPath),
}

impl CompoundPath {
    /// All contours flattened into one multi-subpath `BezPath` at `frame`.
    pub fn to_bez_path(&self, frame: f64) -> BezPath {
        let mut result = BezPath::new();
        for contour in &self.contours {
            result.extend(
                contour
                    .value_at(frame)
                    .to_bez_path()
                    .elements()
                    .iter()
                    .copied(),
            );
        }
        result
    }
}

/// One color anchor along a gradient axis. `offset` is in 0..=1.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GradientStop {
    pub offset: f64,
    pub color: Color,
}

/// Ordered gradient stops, sampled by `sample`. Kept small (usually 2-4).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GradientStops(pub Vec<GradientStop>);

impl Default for GradientStops {
    fn default() -> Self {
        Self(vec![
            GradientStop {
                offset: 0.0,
                color: Color::rgba(1.0, 1.0, 1.0, 1.0),
            },
            GradientStop {
                offset: 1.0,
                color: Color::rgba(0.0, 0.0, 0.0, 1.0),
            },
        ])
    }
}

impl GradientStops {
    /// Sample the gradient at normalized position `t` (clamped to 0..=1).
    pub fn sample(&self, t: f64) -> Color {
        let t = t.clamp(0.0, 1.0);
        let stops = &self.0;
        if stops.is_empty() {
            return Color::BLACK;
        }
        if t <= stops[0].offset {
            return stops[0].color;
        }
        for w in stops.windows(2) {
            let (a, b) = (&w[0], &w[1]);
            if t <= b.offset {
                let span = (b.offset - a.offset).max(1e-9);
                let u = ((t - a.offset) / span).clamp(0.0, 1.0);
                return Color::rgba(
                    a.color.r + (b.color.r - a.color.r) * u,
                    a.color.g + (b.color.g - a.color.g) * u,
                    a.color.b + (b.color.b - a.color.b) * u,
                    a.color.a + (b.color.a - a.color.a) * u,
                );
            }
        }
        stops.last().unwrap().color
    }
}

impl Tween for GradientStops {
    fn tween(a: &Self, b: &Self, t: f64) -> Self {
        if a.0.len() != b.0.len() {
            return if t < 1.0 { a.clone() } else { b.clone() };
        }
        Self(
            a.0.iter()
                .zip(&b.0)
                .map(|(x, y)| GradientStop {
                    offset: x.offset + (y.offset - x.offset) * t,
                    color: Color::rgba(
                        x.color.r + (y.color.r - x.color.r) * t,
                        x.color.g + (y.color.g - x.color.g) * t,
                        x.color.b + (y.color.b - x.color.b) * t,
                        x.color.a + (y.color.a - x.color.a) * t,
                    ),
                })
                .collect(),
        )
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum GradientKind {
    Linear,
    Radial,
}

/// A gradient in the *node's* local space. The evaluator folds the owning
/// shape's world transform into `start`/`end` before baking vertex colors.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Gradient {
    pub kind: GradientKind,
    /// Linear: start point. Radial: center.
    pub start: Animated<glam::DVec2>,
    /// Linear: end point. Radial: circumference point (radius = |end-start|).
    pub end: Animated<glam::DVec2>,
    pub stops: Animated<GradientStops>,
}

/// Paint on a style node: solid color or gradient. Animated so whole-list
/// keyframes (e.g. stop-color morphs) work through the existing machinery.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum StylePaint {
    Solid { color: Animated<Color> },
    Gradient(Gradient),
}

impl StylePaint {
    pub fn solid(color: Color) -> Self {
        Self::Solid {
            color: Animated::new(color),
        }
    }

    pub fn linear(start: glam::DVec2, end: glam::DVec2, stops: GradientStops) -> Self {
        Self::Gradient(Gradient {
            kind: GradientKind::Linear,
            start: Animated::new(start),
            end: Animated::new(end),
            stops: Animated::new(stops),
        })
    }

    pub fn radial(center: glam::DVec2, end: glam::DVec2, stops: GradientStops) -> Self {
        Self::Gradient(Gradient {
            kind: GradientKind::Radial,
            start: Animated::new(center),
            end: Animated::new(end),
            stops: Animated::new(stops),
        })
    }

    /// Sample the paint into a `ScenePaint` at `frame`.
    pub fn sample(&self, frame: f64) -> ScenePaint {
        match self {
            StylePaint::Solid { color } => ScenePaint::Solid(color.value_at(frame)),
            StylePaint::Gradient(g) => {
                let start = g.start.value_at(frame);
                let end = g.end.value_at(frame);
                let stops = g.stops.value_at(frame);
                match g.kind {
                    GradientKind::Linear => ScenePaint::LinearGradient { start, end, stops },
                    GradientKind::Radial => ScenePaint::RadialGradient {
                        center: start,
                        end,
                        stops,
                    },
                }
            }
        }
    }

    /// Produce a static paint snapshot at `frame`.
    ///
    /// Current paint is tool state, not an animation track, so copying paint
    /// from a document should sample it rather than copying its keyframes.
    pub fn snapshot(&self, frame: f64) -> Self {
        match self {
            StylePaint::Solid { color } => StylePaint::solid(color.value_at(frame)),
            StylePaint::Gradient(gradient) => StylePaint::Gradient(Gradient {
                kind: gradient.kind,
                start: Animated::new(gradient.start.value_at(frame)),
                end: Animated::new(gradient.end.value_at(frame)),
                stops: Animated::new(gradient.stops.value_at(frame)),
            }),
        }
    }

    /// Change the representative color while preserving paint type.
    ///
    /// For a gradient, this updates its first stop rather than destroying the
    /// gradient and converting it to a solid.
    pub fn set_base_color(&mut self, color: Color) {
        match self {
            StylePaint::Solid { color: animated } => {
                animated.base = color;
                animated.keyframes.clear();
            }
            StylePaint::Gradient(gradient) => {
                gradient.start.keyframes.clear();
                gradient.end.keyframes.clear();
                gradient.stops.keyframes.clear();

                if let Some(first) = gradient.stops.base.0.first_mut() {
                    first.color = color;
                } else {
                    gradient
                        .stops
                        .base
                        .0
                        .push(GradientStop { offset: 0.0, color });
                }
            }
        }
    }
}

impl Tween for StylePaint {
    fn tween(a: &Self, b: &Self, t: f64) -> Self {
        match (a, b) {
            (StylePaint::Solid { color: ca }, StylePaint::Solid { color: cb }) => {
                StylePaint::Solid {
                    color: Animated::new(Tween::tween(&ca.base, &cb.base, t)),
                }
            }
            (StylePaint::Gradient(ga), StylePaint::Gradient(gb)) => {
                if ga.kind != gb.kind {
                    return if t < 1.0 { a.clone() } else { b.clone() };
                }
                StylePaint::Gradient(Gradient {
                    kind: ga.kind,
                    start: Animated::new(Tween::tween(&ga.start.base, &gb.start.base, t)),
                    end: Animated::new(Tween::tween(&ga.end.base, &gb.end.base, t)),
                    stops: Animated::new(Tween::tween(&ga.stops.base, &gb.stops.base, t)),
                })
            }
            _ => {
                if t < 1.0 {
                    a.clone()
                } else {
                    b.clone()
                }
            }
        }
    }
}

impl StyleKind {
    /// Replace the paint (fill or stroke), returning the previous one (undo).
    pub fn swap_paint(&mut self, paint: StylePaint) -> StylePaint {
        match self {
            StyleKind::Fill { paint: p, .. } | StyleKind::Stroke { paint: p, .. } => {
                std::mem::replace(p, paint)
            }
        }
    }

    pub fn paint(&self) -> &StylePaint {
        match self {
            StyleKind::Fill { paint, .. } | StyleKind::Stroke { paint, .. } => paint,
        }
    }
}

impl StylePaint {
    /// For a solid paint: the (possibly keyed) base color. For a gradient:
    /// the first stop's color (stable handle for conversions).
    pub fn base_color(&self) -> Color {
        match self {
            StylePaint::Solid { color } => color.base,
            StylePaint::Gradient(g) => g
                .stops
                .base
                .0
                .first()
                .map(|s| s.color)
                .unwrap_or(Color::BLACK),
        }
    }
}

fn default_miter_limit() -> Animated<f64> {
    Animated::new(4.0)
}

#[derive(Clone, Debug, PartialEq, Serialize)]
pub enum StyleKind {
    Fill {
        paint: StylePaint,
        rule: FillRule,
    },
    Stroke {
        paint: StylePaint,
        width: Animated<f64>,
        cap: StrokeCap,
        join: StrokeJoin,
        dash: Option<AnimatedDash>,
        #[serde(default = "default_miter_limit")]
        miter_limit: Animated<f64>,
    },
}

#[derive(Default)]
struct StyleCompatContent {
    paint: Option<StylePaint>,
    color: Option<Animated<Color>>,
    width: Option<Animated<f64>>,
    cap: Option<StrokeCap>,
    join: Option<StrokeJoin>,
    miter_limit: Option<Animated<f64>>,
    dash: Option<AnimatedDash>,
    rule: Option<FillRule>,
}

impl<'de> Deserialize<'de> for StyleKind {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        enum StyleTag {
            Fill,
            Stroke,
        }

        struct StyleKindVisitor;
        impl<'de> Visitor<'de> for StyleKindVisitor {
            type Value = StyleKind;

            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                f.write_str("a Fill or Stroke style")
            }

            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::EnumAccess<'de>,
            {
                use serde::de::VariantAccess as _;
                struct ContentVisitor {
                    fill: bool,
                }
                impl<'de> Visitor<'de> for ContentVisitor {
                    type Value = StyleCompatContent;
                    fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                        f.write_str("style variant fields")
                    }
                    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
                    where
                        A: serde::de::MapAccess<'de>,
                    {
                        let mut content = StyleCompatContent::default();
                        while let Some(key) = map.next_key::<String>()? {
                            match key.as_str() {
                                "paint" => content.paint = Some(map.next_value()?),
                                "color" => content.color = Some(map.next_value()?),
                                "width" => content.width = Some(map.next_value()?),
                                "cap" => content.cap = Some(map.next_value()?),
                                "join" => content.join = Some(map.next_value()?),
                                "miter_limit" => content.miter_limit = Some(map.next_value()?),
                                "dash" => {
                                    content.dash = map.next_value::<Option<AnimatedDash>>()?
                                }
                                "rule" => content.rule = Some(map.next_value()?),
                                other => {
                                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
                                    let _ = other;
                                }
                            }
                        }
                        Ok(content)
                    }
                    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                    where
                        A: serde::de::SeqAccess<'de>,
                    {
                        use serde::de::Error as _;
                        // Postcard encodes struct-variant content positionally
                        // (no keys), in derived declaration order.
                        let mut content = StyleCompatContent {
                            paint: Some(
                                seq.next_element()?
                                    .ok_or_else(|| A::Error::invalid_length(0, &"paint"))?,
                            ),
                            ..Default::default()
                        };
                        if self.fill {
                            content.rule = Some(
                                seq.next_element()?
                                    .ok_or_else(|| A::Error::invalid_length(1, &"rule"))?,
                            );
                        } else {
                            content.width = Some(
                                seq.next_element()?
                                    .ok_or_else(|| A::Error::invalid_length(1, &"width"))?,
                            );
                            content.cap = Some(
                                seq.next_element()?
                                    .ok_or_else(|| A::Error::invalid_length(2, &"cap"))?,
                            );
                            content.join = Some(
                                seq.next_element()?
                                    .ok_or_else(|| A::Error::invalid_length(3, &"join"))?,
                            );
                            content.dash = seq
                                .next_element::<Option<AnimatedDash>>()?
                                .ok_or_else(|| A::Error::invalid_length(4, &"dash"))?;
                            // legacy encodings omit it.
                            content.miter_limit = seq
                                .next_element::<Animated<f64>>()?
                                .or(Some(default_miter_limit()));
                        }
                        Ok(content)
                    }
                }
                let (tag, content) = data.variant::<StyleTag>()?;
                let content = match tag {
                    StyleTag::Fill => {
                        content.struct_variant(&["paint", "rule"], ContentVisitor { fill: true })?
                    }
                    StyleTag::Stroke => content.struct_variant(
                        &["paint", "width", "cap", "join", "dash", "miter_limit"],
                        ContentVisitor { fill: false },
                    )?,
                };
                let paint = match content.paint {
                    Some(p) => p,
                    None => match content.color {
                        Some(color) => StylePaint::Solid { color },
                        None => return Err(A::Error::missing_field("paint")),
                    },
                };
                match tag {
                    StyleTag::Fill => Ok(StyleKind::Fill {
                        paint,
                        rule: content
                            .rule
                            .ok_or_else(|| A::Error::missing_field("rule"))?,
                    }),
                    StyleTag::Stroke => Ok(StyleKind::Stroke {
                        paint,
                        width: content
                            .width
                            .ok_or_else(|| A::Error::missing_field("width"))?,
                        cap: content.cap.ok_or_else(|| A::Error::missing_field("cap"))?,
                        join: content
                            .join
                            .ok_or_else(|| A::Error::missing_field("join"))?,
                        dash: content.dash,
                        miter_limit: content.miter_limit.unwrap_or_else(default_miter_limit),
                    }),
                }
            }
        }

        deserializer.deserialize_enum("StyleKind", &["Fill", "Stroke"], StyleKindVisitor)
    }
}

/// Serde default for a scalar animation pinned to a constant `1.0`.
fn animated_one() -> Animated<f64> {
    Animated::new(1.0)
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ModifierKind {
    TrimPath {
        start: Animated<f64>,
        end: Animated<f64>,
        offset: Animated<f64>,
        #[serde(default)]
        mode: TrimMode,
    },
    Repeater {
        copies: Animated<f64>,
        offset: Animated<f64>,
        transform: Box<AnimatedTransform>,
        /// Opacity of the first copy (0..=1). Lottie `so` / 100.
        #[serde(default = "animated_one")]
        start_opacity: Animated<f64>,
        /// Opacity of the last copy (0..=1). Lottie `eo` / 100.
        #[serde(default = "animated_one")]
        end_opacity: Animated<f64>,
    },
    RoundCorners {
        radius: Animated<f64>,
    },
    OffsetPath {
        amount: Animated<f64>,
    },
    ZigZag {
        amplitude: Animated<f64>,
        frequency: Animated<f64>,
        /// false = corner zig-zag; true = smooth wave (cubic).
        #[serde(default)]
        smooth: bool,
    },
    PuckerBloat {
        /// Percent. Positive = pucker (vertices toward centroid,
        /// handles away); negative = bloat (vertices away).
        amount: Animated<f64>,
    },
}

/// How Trim distributes [start, end] across multiple accumulated paths.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum TrimMode {
    /// Each path is trimmed to [start, end] of its own perimeter.
    #[default]
    Individually,
    /// The concatenation of all paths is treated as one arc-length domain.
    Simultaneously,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TimeMap {
    #[serde(default)]
    pub offset: Frame,
    #[serde(default = "default_time_stretch")]
    pub stretch: f64,
}

impl Default for TimeMap {
    fn default() -> Self {
        Self {
            offset: Frame(0),
            stretch: 1.0,
        }
    }
}

fn default_text_size() -> Animated<f64> {
    Animated::new(48.0)
}
fn default_tracking() -> Animated<f64> {
    Animated::new(0.0)
}
fn default_leading() -> Animated<f64> {
    Animated::new(0.0)
}

#[derive(Clone, Debug, Serialize)]
pub struct TextNode {
    pub text: String,
    /// Em size in document units.
    #[serde(default = "default_text_size")]
    pub size: Animated<f64>,
    #[serde(default)]
    pub align: TextAlign,
    /// Reserved for document-embedded fonts; `None` = bundled default.
    #[serde(default)]
    pub font: Option<String>,
    /// Letter spacing in document units (extra advance per glyph).
    #[serde(default = "default_tracking")]
    pub tracking: Animated<f64>,
    /// Additional line spacing in document units (added to default line height).
    #[serde(default = "default_leading")]
    pub leading: Animated<f64>,
}

impl<'de> Deserialize<'de> for TextNode {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct TextNodeVisitor;
        impl<'de> Visitor<'de> for TextNodeVisitor {
            type Value = TextNode;
            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                f.write_str("TextNode")
            }
            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                let mut text: Option<String> = None;
                let mut size: Option<Animated<f64>> = None;
                let mut align: Option<TextAlign> = None;
                let mut font: Option<Option<String>> = None;
                let mut tracking: Option<Animated<f64>> = None;
                let mut leading: Option<Animated<f64>> = None;
                while let Some(key) = map.next_key::<String>()? {
                    match key.as_str() {
                        "text" => text = Some(map.next_value()?),
                        "size" => size = Some(map.next_value()?),
                        "align" => align = Some(map.next_value()?),
                        "font" => font = Some(map.next_value()?),
                        "tracking" => tracking = Some(map.next_value()?),
                        "leading" => leading = Some(map.next_value()?),
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let text = text.ok_or_else(|| DeError::missing_field("text"))?;
                Ok(TextNode {
                    text,
                    size: size.unwrap_or_else(default_text_size),
                    align: align.unwrap_or_default(),
                    font: font.unwrap_or_default(),
                    tracking: tracking.unwrap_or_else(default_tracking),
                    leading: leading.unwrap_or_else(default_leading),
                })
            }
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::SeqAccess<'de>,
            {
                let text: String = seq
                    .next_element()?
                    .ok_or_else(|| DeError::invalid_length(0, &self))?;
                let size: Animated<f64> = seq.next_element()?.unwrap_or_else(default_text_size);
                let align: TextAlign = seq.next_element()?.unwrap_or_default();
                let font: Option<String> = seq.next_element()?.unwrap_or_default();
                let tracking: Animated<f64> = seq.next_element()?.unwrap_or_else(default_tracking);
                let leading: Animated<f64> = seq.next_element()?.unwrap_or_else(default_leading);
                Ok(TextNode {
                    text,
                    size,
                    align,
                    font,
                    tracking,
                    leading,
                })
            }
        }
        if deserializer.is_human_readable() {
            deserializer.deserialize_any(TextNodeVisitor)
        } else {
            deserializer.deserialize_struct(
                "TextNode",
                &["text", "size", "align", "font", "tracking", "leading"],
                TextNodeVisitor,
            )
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MaskProps {
    pub inverted: bool,

    /// The actual vector geometry of the mask.
    ///
    /// Defaults to an empty path so legacy documents deserialize safely.
    #[serde(default)]
    pub shape: ShapeKind,
}

impl Default for ShapeKind {
    fn default() -> Self {
        ShapeKind::Path(Animated::new(renamite_geometry::VectorPath::default()))
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct Color {
    pub r: f64,
    pub g: f64,
    pub b: f64,
    pub a: f64,
}

impl Color {
    pub const BLACK: Self = Self {
        r: 0.0,
        g: 0.0,
        b: 0.0,
        a: 1.0,
    };
    pub const WHITE: Self = Self {
        r: 1.0,
        g: 1.0,
        b: 1.0,
        a: 1.0,
    };
    pub fn rgba(r: f64, g: f64, b: f64, a: f64) -> Self {
        Self { r, g, b, a }
    }
}

impl Tween for Color {
    fn tween(a: &Self, b: &Self, t: f64) -> Self {
        Self {
            r: a.r + (b.r - a.r) * t,
            g: a.g + (b.g - a.g) * t,
            b: a.b + (b.b - a.b) * t,
            a: a.a + (b.a - a.a) * t,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
pub enum FillRule {
    #[default]
    NonZero,
    EvenOdd,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum StrokeCap {
    Butt,
    Round,
    Square,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum StrokeJoin {
    Miter,
    Round,
    Bevel,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AnimatedDash {
    pub dashes: Vec<Animated<f64>>,
    pub offset: Animated<f64>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum StarKind {
    Star,
    Burst,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum BlendMode {
    #[default]
    Normal,
    Multiply,
    Screen,
    Overlay,
    Darken,
    Lighten,
    ColorDodge,
    ColorBurn,
    HardLight,
    SoftLight,
    Difference,
    Exclusion,
    Hue,
    Saturation,
    Color,
    Luminosity,
}

fn default_tint() -> Animated<Color> {
    Animated::new(Color::WHITE)
}

fn default_crop_vec4() -> glam::DVec4 {
    glam::DVec4::new(0.0, 0.0, 1.0, 1.0)
}

#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct ImageNode {
    pub asset: AssetId,
    #[serde(default = "default_tint")]
    pub tint: Animated<Color>,
    #[serde(default = "default_crop_vec4")]
    pub crop: glam::DVec4,
}

impl ImageNode {
    pub fn new(asset: AssetId) -> Self {
        Self {
            asset,
            tint: default_tint(),
            crop: default_crop_vec4(),
        }
    }
    pub fn asset(&self) -> AssetId {
        self.asset
    }
    pub fn tint(&self) -> &Animated<Color> {
        &self.tint
    }
    pub fn tint_mut(&mut self) -> Option<&mut Animated<Color>> {
        Some(&mut self.tint)
    }
    pub fn crop(&self) -> glam::DVec4 {
        self.crop
    }
    pub fn crop_mut(&mut self) -> Option<&mut glam::DVec4> {
        Some(&mut self.crop)
    }
}

impl<'de> serde::Deserialize<'de> for ImageNode {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct ImageNodeVisitor;
        impl<'de> Visitor<'de> for ImageNodeVisitor {
            type Value = ImageNode;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("ImageNode struct or bare AssetId")
            }
            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                let mut asset: Option<AssetId> = None;
                let mut tint: Option<Animated<Color>> = None;
                let mut crop: Option<glam::DVec4> = None;
                let mut idx: Option<u32> = None;
                let mut version: Option<u32> = None;
                while let Some(key) = map.next_key::<String>()? {
                    match key.as_str() {
                        "asset" => asset = Some(map.next_value()?),
                        "tint" => tint = Some(map.next_value()?),
                        "crop" => crop = Some(map.next_value()?),
                        "idx" => idx = Some(map.next_value()?),
                        "version" => version = Some(map.next_value()?),
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                if let Some(a) = asset {
                    Ok(ImageNode {
                        asset: a,
                        tint: tint.unwrap_or_else(default_tint),
                        crop: crop.unwrap_or_else(default_crop_vec4),
                    })
                } else if let (Some(i), Some(v)) = (idx, version) {
                    let kd = slotmap::KeyData::from_ffi(((v as u64) << 32) | i as u64);
                    Ok(ImageNode {
                        asset: AssetId::from(kd),
                        tint: default_tint(),
                        crop: default_crop_vec4(),
                    })
                } else {
                    Err(DeError::custom(
                        "expected ImageNode with `asset` or bare SerKey with `idx`/`version`",
                    ))
                }
            }
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::SeqAccess<'de>,
            {
                let asset: Option<AssetId> = seq.next_element()?;
                let Some(asset) = asset else {
                    return Err(DeError::invalid_length(0, &self));
                };
                // If there's a next element, it's tint (full struct), otherwise legacy bare.
                if let Some(tint) = seq.next_element::<Animated<Color>>()? {
                    let crop: glam::DVec4 = seq.next_element()?.unwrap_or_else(default_crop_vec4);
                    Ok(ImageNode { asset, tint, crop })
                } else {
                    Ok(ImageNode {
                        asset,
                        tint: default_tint(),
                        crop: default_crop_vec4(),
                    })
                }
            }
        }
        if deserializer.is_human_readable() {
            deserializer.deserialize_any(ImageNodeVisitor)
        } else {
            deserializer.deserialize_struct(
                "ImageNode",
                &["asset", "tint", "crop"],
                ImageNodeVisitor,
            )
        }
    }
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Asset {
    Image(ImageAsset),
    Font(FontAsset),
}

fn default_true() -> bool {
    true
}

/// An embedded image asset. Stores the original encoded PNG/JPEG/WebP bytes
/// and the decoded pixel dimensions established at import time.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ImageAsset {
    pub name: String,
    pub mime: String,

    /// Original encoded PNG/JPEG/WebP bytes.
    pub bytes: Vec<u8>,

    /// Decoded pixel dimensions, established during import.
    pub width: u32,
    pub height: u32,

    /// Decode/upload using an sRGB texture.
    #[serde(default = "default_true")]
    pub srgb: bool,
}

/// A project font: the user-visible name, the logical family key text nodes
/// reference, and the raw TTF/OTF bytes (saved/loaded inside the project).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FontAsset {
    /// Display name in the UI (e.g. "Inter-Regular.ttf").
    pub name: String,
    /// Logical family key that `TextNode.font` references.
    pub family: String,
    /// Raw TTF/OTF bytes.
    pub bytes: Vec<u8>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct Scene {
    pub items: Vec<SceneItem>,
    pub clips: Vec<ClipPath>,
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SceneItem {
    /// World space, transforms folded in.
    pub path: BezPath,
    /// The *shape* node that produced this geometry (used for picking).
    pub node: NodeId,
    /// The style node (Fill/Stroke) whose paint produced this item. Lets the
    /// gradient tool / inspector target the exact style to edit.
    pub style: NodeId,
    /// Resolved paint. Gradient coordinates are in world space (the owning
    /// shape's local transform is folded in during evaluation), matching the
    /// vertex positions the renderer bakes colors from.
    pub paint: ScenePaint,
    pub kind: PaintKind,
    pub opacity: f64,

    /// Clip stack applied to this item, outermost → innermost.
    #[serde(default)]
    pub clips: Vec<u32>,

    pub blend: BlendMode,
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum PaintKind {
    Fill(FillRule),
    Stroke(StrokeSample),
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StrokeSample {
    pub width: f64,
    pub cap: StrokeCap,
    pub join: StrokeJoin,
    #[serde(default = "default_miter_limit_f64")]
    pub miter_limit: f64,
    pub dash: Option<DashSample>,
}

fn default_miter_limit_f64() -> f64 {
    4.0
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DashSample {
    pub dashes: Vec<f64>,
    pub offset: f64,
}

/// Resolved, per-frame paint attached to a scene item. The renderer bakes
/// this into mesh vertex colors at tessellation time.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ScenePaint {
    Solid(Color),
    LinearGradient {
        start: glam::DVec2,
        end: glam::DVec2,
        stops: GradientStops,
    },
    RadialGradient {
        center: glam::DVec2,
        end: glam::DVec2,
        stops: GradientStops,
    },
    Image {
        asset: AssetId,

        /// Local image rectangle dimensions.
        width: u32,
        height: u32,

        /// Full local-image → world affine.
        affine: [f64; 6],

        /// Multiplicative tint. WHITE means unchanged.
        tint: Color,
    },
}

impl ScenePaint {
    /// Color at world-space position `p` (used by vertex baking).
    pub fn color_at(&self, p: glam::DVec2) -> Color {
        match self {
            ScenePaint::Solid(c) => *c,
            ScenePaint::Image { tint, .. } => *tint,
            ScenePaint::LinearGradient { start, end, stops } => {
                let d = *end - *start;
                let len2 = d.length_squared().max(1e-12);
                let t = ((p - *start).dot(d) / len2).clamp(0.0, 1.0);
                stops.sample(t)
            }
            ScenePaint::RadialGradient { center, end, stops } => {
                let r = (*end - *center).length().max(1e-12);
                let t = ((p - *center).length() / r).clamp(0.0, 1.0);
                stops.sample(t)
            }
        }
    }
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ClipPath {
    pub path: BezPath,
    #[serde(default)]
    pub rule: FillRule,
}

/// Per-frame property patch. Produced by clip/state-machine playback,
/// consumed by `evaluate_with`. Never touches the document.
///
/// Internally `values` is keyed `NodeId -> prop-name -> value` so
/// [`Overrides::get`] borrows `&str` with no per-lookup allocation.
/// `PropPath` stays the canonical `String` newtype on disk for a stable
/// `.ren` format; only the hot lookup path avoids allocating.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Overrides {
    values: std::collections::HashMap<NodeId, std::collections::HashMap<Box<str>, Value>>,
}

impl Overrides {
    pub fn set(&mut self, id: NodeId, prop: PropPath, v: Value) {
        let key: Box<str> = canonical_prop(prop).0.into_boxed_str();
        self.values.entry(id).or_default().insert(key, v);
    }
    /// Borrowed insert used when the caller already has `&str`
    /// (e.g. replaying host overrides without rebuilding a `PropPath`).
    pub fn set_str(&mut self, id: NodeId, prop: &str, v: Value) {
        let key: Box<str> = Box::from(canonical_prop_str(prop));
        self.values.entry(id).or_default().insert(key, v);
    }
    /// Allocation-free lookup: `Box<str>` borrows as `str`.
    pub fn get(&self, id: NodeId, prop: &str) -> Option<&Value> {
        self.values.get(&id)?.get(canonical_prop_str(prop))
    }
    /// Iterate `(node, prop-name, value)` without allocating `PropPath`s.
    pub fn iter(&self) -> impl Iterator<Item = (NodeId, &str, &Value)> {
        self.values
            .iter()
            .flat_map(|(id, inner)| inner.iter().map(move |(prop, v)| (*id, prop.as_ref(), v)))
    }
    pub fn is_empty(&self) -> bool {
        self.values.is_empty()
    }
    pub fn clear(&mut self) {
        self.values.clear();
    }
}

/// Long-term prop naming: `image.tint()` (with parens) shipped by mistake.
/// Canonical name is `image.tint`; accept the legacy spelling.
fn canonical_prop_str(prop: &str) -> &str {
    if prop == "image.tint()" {
        "image.tint"
    } else {
        prop
    }
}

fn canonical_prop(prop: PropPath) -> PropPath {
    PropPath::new(canonical_prop_str(prop.as_str()))
}

fn ov_f64(ov: &Overrides, id: NodeId, prop: &str, dflt: f64) -> f64 {
    match ov.get(id, prop) {
        Some(Value::F64(x)) => *x,
        _ => dflt,
    }
}
fn ov_vec2(ov: &Overrides, id: NodeId, prop: &str, dflt: glam::DVec2) -> glam::DVec2 {
    match ov.get(id, prop) {
        Some(Value::DVec2(x)) => *x,
        _ => dflt,
    }
}
fn ov_angle(ov: &Overrides, id: NodeId, prop: &str, dflt: f64) -> f64 {
    match ov.get(id, prop) {
        Some(Value::Angle(a)) => a.0,
        Some(Value::F64(x)) => *x,
        _ => dflt,
    }
}
fn ov_color(ov: &Overrides, id: NodeId, prop: &str, dflt: Color) -> Color {
    match ov.get(id, prop) {
        Some(Value::Color(c)) => *c,
        _ => dflt,
    }
}

fn sample_transform(
    n: &Node,
    id: NodeId,
    frame: f64,
    ov: &Overrides,
) -> renamite_animation::TransformSample {
    let mut ts = n.transform.sample(frame);
    if !ov.is_empty() {
        ts.anchor = ov_vec2(ov, id, "transform.anchor", ts.anchor);
        ts.position = ov_vec2(ov, id, "transform.position", ts.position);
        ts.scale = ov_vec2(ov, id, "transform.scale", ts.scale);
        ts.rotation_deg = ov_angle(ov, id, "transform.rotation", ts.rotation_deg);
        ts.skew = ov_f64(ov, id, "transform.skew", ts.skew);
        ts.skew_axis = ov_f64(ov, id, "transform.skew_axis", ts.skew_axis);
    }
    ts
}

/// The topmost fill style that paints `shape`: the last Fill style sibling
/// in the closest ancestor scope that has one. Used by the inspector to edit
/// a shape's fill (the tool instead tracks the exact style via `SceneItem`).
/// Children are z-ordered with index 0 = top, so the first Fill wins.
pub fn fill_style_for(doc: &Document, shape: NodeId) -> Option<NodeId> {
    let mut scope = doc.locate(shape).map(|(p, _)| p)?;
    loop {
        let children: Vec<NodeId> = match scope {
            Parent::Comp(c) => doc.compositions.get(c)?.children.clone(),
            Parent::Node(p) => doc.nodes.get(p)?.children.clone(),
        };
        if let Some(fill) = children.iter().find(|id| {
            matches!(
                doc.nodes.get(**id).map(|n| &n.kind),
                Some(NodeKind::Style(StyleKind::Fill { .. }))
            )
        }) {
            return Some(*fill);
        }
        match scope {
            Parent::Comp(_) => return None,
            Parent::Node(p) => scope = doc.locate(p).map(|(parent, _)| parent)?,
        }
    }
}

/// Topmost stroke style in the closest ancestor scope that has one.
/// Children are z-ordered with index 0 = top, so the first Stroke wins.
pub fn stroke_style_for(doc: &Document, shape: NodeId) -> Option<NodeId> {
    let mut scope = doc.locate(shape).map(|(p, _)| p)?;
    loop {
        let children: Vec<NodeId> = match scope {
            Parent::Comp(c) => doc.compositions.get(c)?.children.clone(),
            Parent::Node(p) => doc.nodes.get(p)?.children.clone(),
        };
        if let Some(stroke) = children.iter().find(|id| {
            matches!(
                doc.nodes.get(**id).map(|n| &n.kind),
                Some(NodeKind::Style(StyleKind::Stroke { .. }))
            )
        }) {
            return Some(*stroke);
        }
        match scope {
            Parent::Comp(_) => return None,
            Parent::Node(p) => scope = doc.locate(p).map(|(parent, _)| parent)?,
        }
    }
}

/// The node's own transform as an affine, ignoring group/accumulated
/// transforms. Gradient handles are authored in this space and folded into
/// world space with this same affine during evaluation, so the inverse maps
/// world gradient handles back to local coordinates for editing.
pub fn node_affine(doc: &Document, id: NodeId, frame: f64) -> Affine {
    let Some(n) = doc.nodes.get(id) else {
        return Affine::IDENTITY;
    };
    affine_of(&sample_transform(n, id, frame, &Overrides::default()))
}

fn linear_affine_of(sample: &renamite_animation::TransformSample) -> Affine {
    let axis = sample.skew_axis.to_radians();
    let skew = Affine::rotate(axis)
        * Affine::skew(sample.skew.to_radians().tan(), 0.0)
        * Affine::rotate(-axis);
    Affine::rotate(sample.rotation_deg.to_radians())
        * skew
        * Affine::scale_non_uniform(sample.scale.x / 100.0, sample.scale.y / 100.0)
}

fn affine_of(sample: &renamite_animation::TransformSample) -> Affine {
    Affine::translate((sample.position.x, sample.position.y))
        * linear_affine_of(sample)
        * Affine::translate((-sample.anchor.x, -sample.anchor.y))
}

/// Resolved transform information for one node at an editor frame.
#[derive(Clone, Copy, Debug)]
pub struct NodeTransformContext {
    /// Transform from the node's parent coordinate space into world space.
    pub parent_world: Affine,

    /// Linear part of this node's transform: rotation * skew * scale.
    /// Does not contain position or anchor translations.
    pub linear: Affine,

    /// Full node-local to parent transform.
    pub local: Affine,

    /// Full node-local to world transform.
    pub world: Affine,

    /// Effective frame after ancestor layer time-stretch mappings.
    pub frame: f64,

    /// Node position in parent coordinates.
    pub position: glam::DVec2,

    /// Node anchor/pivot in local coordinates.
    pub anchor: glam::DVec2,

    /// Pivot location in world coordinates.
    pub pivot_world: glam::DVec2,
}

fn node_effective_frame(node: &Node, incoming_frame: f64) -> f64 {
    match &node.kind {
        NodeKind::Layer(layer) => {
            (incoming_frame - layer.in_frame.0 as f64) / layer.time_stretch.max(1e-9)
                + layer.in_frame.0 as f64
        }

        _ => incoming_frame,
    }
}

/// Resolve one attached node's parent/world transforms.
///
/// This follows the node's actual parent chain and applies the same Layer
/// time-stretch convention used by the evaluator. It intentionally does not
/// traverse through `Precomp` references because precomposition contents live
/// in a separate composition tree.
pub fn node_transform_context(
    doc: &Document,
    id: NodeId,
    root_frame: f64,
) -> Option<NodeTransformContext> {
    let mut chain = Vec::new();
    let mut current = id;

    loop {
        chain.push(current);

        let node = doc.nodes.get(current)?;

        let Some(parent) = node.parent else {
            break;
        };

        current = parent;
    }

    chain.reverse();

    let mut parent_world = Affine::IDENTITY;
    let mut frame = root_frame;

    for current in chain {
        let node = doc.nodes.get(current)?;
        let effective = node_effective_frame(node, frame);
        let sample = node.transform.sample(effective);
        let linear = linear_affine_of(&sample);
        let local = affine_of(&sample);

        if current == id {
            let pivot = parent_world * Point::new(sample.position.x, sample.position.y);

            return Some(NodeTransformContext {
                parent_world,
                linear,
                local,
                world: parent_world * local,
                frame: effective,
                position: sample.position,
                anchor: sample.anchor,
                pivot_world: glam::DVec2::new(pivot.x, pivot.y),
            });
        }

        parent_world *= local;
        frame = effective;
    }

    None
}

const SHAPE_TOL: f64 = 0.1;

/// The vector outline of a shape (or mask shape) node's geometry in its own
/// local coordinate space at `frame`, honoring any `shape.*` overrides.
pub fn shape_path(kind: &ShapeKind, id: NodeId, frame: f64, ov: &Overrides) -> BezPath {
    match kind {
        ShapeKind::Path(p) => {
            if let Some(Value::Path(p)) = ov.get(id, "shape.path") {
                return p.to_bez_path();
            }
            p.value_at(frame).to_bez_path()
        }
        ShapeKind::Rect { pos, size, rounded } => {
            let c = ov_vec2(ov, id, "shape.pos", pos.value_at(frame));
            let s = ov_vec2(ov, id, "shape.size", size.value_at(frame));
            let r = kurbo::Rect::from_center_size((c.x, c.y), (s.x.abs(), s.y.abs()));
            let radius = ov_f64(ov, id, "shape.rounded", rounded.value_at(frame));
            if radius > 1e-9 {
                kurbo::RoundedRect::from_rect(r, radius).to_path(SHAPE_TOL)
            } else {
                r.to_path(SHAPE_TOL)
            }
        }
        ShapeKind::Ellipse { pos, size } => {
            let c = ov_vec2(ov, id, "shape.pos", pos.value_at(frame));
            let s = ov_vec2(ov, id, "shape.size", size.value_at(frame));
            kurbo::Ellipse::new((c.x, c.y), (s.x.abs() / 2.0, s.y.abs() / 2.0), 0.0)
                .to_path(SHAPE_TOL)
        }
        ShapeKind::Star {
            pos,
            points,
            inner_r,
            outer_r,
            roundness,
            kind,
        } => {
            let pts = clamp_shape_points(ov_f64(ov, id, "shape.points", points.value_at(frame)));
            let outer = ov_f64(ov, id, "shape.outer_r", outer_r.value_at(frame));
            let inner = match kind {
                StarKind::Burst => None,
                StarKind::Star => Some(ov_f64(ov, id, "shape.inner_r", inner_r.value_at(frame))),
            };
            star_path(
                ov_vec2(ov, id, "shape.pos", pos.value_at(frame)),
                pts,
                inner,
                outer,
                ov_f64(ov, id, "shape.roundness", roundness.value_at(frame)).max(0.0),
            )
        }
        ShapeKind::Polygon {
            pos,
            points,
            outer_r,
            roundness,
        } => star_path(
            ov_vec2(ov, id, "shape.pos", pos.value_at(frame)),
            clamp_shape_points(ov_f64(ov, id, "shape.points", points.value_at(frame))),
            None,
            ov_f64(ov, id, "shape.outer_r", outer_r.value_at(frame)),
            ov_f64(ov, id, "shape.roundness", roundness.value_at(frame)).max(0.0),
        ),
        ShapeKind::CompoundPath(compound) => compound.to_bez_path(frame),
    }
}

/// Star/polygon outline. `roundness` is corner radius in local units (0 = sharp).
/// Matches RoundCorners modifier semantics (not Lottie % outer-roundness).
fn clamp_shape_points(v: f64) -> usize {
    if !v.is_finite() {
        return 3;
    }
    (v.round().max(3.0).min(256.0)) as usize
}

fn star_path(
    center: glam::DVec2,
    points: usize,
    inner: Option<f64>,
    outer: f64,
    roundness: f64,
) -> BezPath {
    let n = if inner.is_some() { points * 2 } else { points };
    let mut anchors = Vec::with_capacity(n);
    for k in 0..n {
        let ang = -std::f64::consts::FRAC_PI_2 + std::f64::consts::TAU * k as f64 / n as f64;
        let r = match inner {
            Some(ir) if k % 2 == 1 => ir,
            _ => outer,
        };
        anchors.push(renamite_geometry::Anchor::corner(glam::DVec2::new(
            center.x + r * ang.cos(),
            center.y + r * ang.sin(),
        )));
    }
    let sharp = renamite_geometry::VectorPath {
        closed: true,
        anchors,
    };
    if roundness <= 1e-9 {
        return sharp.to_bez_path();
    }
    sharp.round_corners(roundness).to_bez_path()
}

pub fn evaluate(doc: &Document, comp: CompId, frame: f64) -> Scene {
    evaluate_with(doc, comp, frame, &Overrides::default())
}

fn mask_shape_path(shape: &ShapeKind, id: NodeId, frame: f64, ov: &Overrides) -> BezPath {
    shape_path(shape, id, frame, ov)
}

fn inverted_clip_path(scope_world: &BezPath, mask_world: &BezPath) -> ClipPath {
    let mut path = scope_world.clone();
    path.extend(mask_world.clone());
    ClipPath {
        path,
        rule: FillRule::EvenOdd,
    }
}

pub fn evaluate_with(doc: &Document, comp: CompId, frame: f64, ov: &Overrides) -> Scene {
    let mut scene = Scene::default();
    if let Some(c) = doc.compositions.get(comp) {
        let scope = kurbo::Rect::new(0.0, 0.0, c.size.0 as f64, c.size.1 as f64);
        eval_group(
            doc,
            &c.children,
            frame,
            Affine::IDENTITY,
            1.0,
            BlendMode::Normal,
            &mut scene,
            0,
            ov,
            scope,
            &[],
            &[],
        );
    }
    scene
}

const MAX_DEPTH: u32 = 32; // precomp cycle guard

#[allow(clippy::too_many_arguments)]
fn eval_group(
    doc: &Document,
    children: &[NodeId],
    frame: f64,
    tf: Affine,
    opacity: f64,
    blend: BlendMode,
    scene: &mut Scene,
    depth: u32,
    ov: &Overrides,
    scope_rect: kurbo::Rect,
    inherited_clips: &[u32],
    seed_paths: &[ShapeEntry],
) {
    if depth > MAX_DEPTH {
        return;
    }

    // Pass 1: accumulate shape paths + modifiers, in document order.
    let mut paths: Vec<ShapeEntry> = seed_paths.to_vec();
    for &id in children {
        let Some(n) = doc.nodes.get(id) else { continue };
        if !n.visible {
            continue;
        }
        match &n.kind {
            NodeKind::Shape(s) => {
                let ntf = affine_of(&sample_transform(n, id, frame, ov));
                paths.push(ShapeEntry {
                    node: id,
                    affine: ntf,
                    opacity: 1.0,
                    path: tf * ntf * shape_path(s, id, frame, ov),
                });
            }
            NodeKind::Text(t) => {
                let ntf = affine_of(&sample_transform(n, id, frame, ov));
                let size = ov_f64(ov, id, "text.size", t.size.value_at(frame)).max(0.1);
                let tracking = ov_f64(ov, id, "text.tracking", t.tracking.value_at(frame));
                let leading = ov_f64(ov, id, "text.leading", t.leading.value_at(frame));
                // Prefer an embedded project font by family.
                let outline = if let Some((_, font)) =
                    t.font.as_deref().and_then(|f| doc.font_asset_for_family(f))
                {
                    renamite_text::shape_text_from_bytes(
                        &font.bytes,
                        &t.text,
                        size,
                        t.align,
                        tracking,
                        leading,
                    )
                    .unwrap_or_else(|_| {
                        renamite_text::shape_text_default(&t.text, size, t.align, tracking, leading)
                    })
                } else {
                    renamite_text::shape_text_default(&t.text, size, t.align, tracking, leading)
                };
                paths.push(ShapeEntry {
                    node: id,
                    affine: ntf,
                    opacity: 1.0,
                    path: tf * ntf * outline,
                });
            }
            NodeKind::Modifier(m) => apply_modifier(m, id, frame, ov, &mut paths),
            NodeKind::Mask(_) => {}
            _ => {}
        }
    }

    // Pass 2: resolve the clip stack for every sibling.
    let mut active: Vec<Vec<u32>> = Vec::with_capacity(children.len());
    let mut acc = inherited_clips.to_vec();
    for &id in children {
        active.push(acc.clone());
        let Some(n) = doc.nodes.get(id) else { continue };
        if !n.visible {
            continue;
        }
        if let NodeKind::Mask(mask) = &n.kind {
            let local = affine_of(&sample_transform(n, id, frame, ov));
            let world_mask = tf * local * mask_shape_path(&mask.shape, id, frame, ov);
            let clip = if mask.inverted {
                inverted_clip_path(&(tf * scope_rect.to_path(0.1)), &world_mask)
            } else {
                ClipPath {
                    path: world_mask,
                    rule: FillRule::NonZero,
                }
            };
            scene.clips.push(clip);
            acc.push((scene.clips.len() - 1) as u32);
        }
    }

    // Pass 3: emit bottom-first (painter's order), carrying each child's
    // active clip stack down into recursion and style emission.
    for (i, &id) in children.iter().enumerate().rev() {
        let Some(n) = doc.nodes.get(id) else { continue };
        if !n.visible {
            continue;
        }
        let node_op = if node_supports_opacity(&n.kind) {
            opacity * ov_f64(ov, id, "opacity", n.opacity.value_at(frame)).clamp(0.0, 1.0)
        } else {
            opacity
        };
        let clips = &active[i];
        match &n.kind {
            NodeKind::Mask(_) => {}
            NodeKind::Group => {
                let ntf = tf * affine_of(&sample_transform(n, id, frame, ov));
                eval_group(
                    doc,
                    &n.children,
                    frame,
                    ntf,
                    node_op,
                    blend,
                    scene,
                    depth + 1,
                    ov,
                    scope_rect,
                    clips,
                    &[],
                );
            }
            NodeKind::Layer(lp) => {
                if frame < lp.in_frame.0 as f64 || frame > lp.out_frame.0 as f64 {
                    continue;
                }
                let lf = (frame - lp.in_frame.0 as f64) / lp.time_stretch.max(1e-9)
                    + lp.in_frame.0 as f64;
                let ntf = tf * affine_of(&sample_transform(n, id, lf, ov));
                eval_group(
                    doc,
                    &n.children,
                    lf,
                    ntf,
                    node_op,
                    lp.blend,
                    scene,
                    depth + 1,
                    ov,
                    scope_rect,
                    clips,
                    &[],
                );
            }
            NodeKind::Image(image_node) => {
                let Some(asset) = doc.image_asset(image_node.asset()) else {
                    continue;
                };

                let node_transform = affine_of(&sample_transform(n, id, frame, ov));
                let full_transform = tf * node_transform;

                let tint = ov_color(ov, id, "image.tint", image_node.tint().value_at(frame));
                let crop = image_node.crop();
                let local_rect = {
                    let (cx, cy, cw, ch) = (crop.x, crop.y, crop.z, crop.w);
                    if (cw - 1.0).abs() < 1e-6
                        && (ch - 1.0).abs() < 1e-6
                        && cx.abs() < 1e-6
                        && cy.abs() < 1e-6
                    {
                        kurbo::Rect::new(0.0, 0.0, asset.width as f64, asset.height as f64)
                    } else {
                        kurbo::Rect::new(
                            asset.width as f64 * cx,
                            asset.height as f64 * cy,
                            asset.width as f64 * (cx + cw),
                            asset.height as f64 * (cy + ch),
                        )
                    }
                };

                let world_path = full_transform * local_rect.to_path(0.1);
                let paint_width = (asset.width as f64 * crop.z).round().max(1.0) as u32;
                let paint_height = (asset.height as f64 * crop.w).round().max(1.0) as u32;
                let crop_affine =
                    Affine::translate((asset.width as f64 * crop.x, asset.height as f64 * crop.y));
                let paint_affine = full_transform * crop_affine;

                scene.items.push(SceneItem {
                    path: world_path,
                    node: id,
                    style: id,
                    paint: ScenePaint::Image {
                        asset: image_node.asset(),
                        width: paint_width,
                        height: paint_height,
                        affine: paint_affine.as_coeffs(),
                        tint,
                    },
                    kind: PaintKind::Fill(FillRule::NonZero),
                    opacity: node_op,
                    clips: clips.to_vec(),
                    blend,
                });
            }
            NodeKind::Precomp { comp, time_map } => {
                let ntf = tf * affine_of(&sample_transform(n, id, frame, ov));
                let cf = (frame - time_map.offset.0 as f64) / time_map.stretch.max(1e-9);
                if let Some(c) = doc.compositions.get(*comp) {
                    let pre_scope = kurbo::Rect::new(0.0, 0.0, c.size.0 as f64, c.size.1 as f64);
                    eval_group(
                        doc,
                        &c.children,
                        cf,
                        ntf,
                        node_op,
                        blend,
                        scene,
                        depth + 1,
                        ov,
                        pre_scope,
                        clips,
                        &[],
                    );
                }
            }
            NodeKind::Style(st) => {
                emit_style(st, id, frame, ov, &paths, node_op, blend, clips, scene)
            }
            // Modifiers apply in pass 1; pass 3 only propagates their own
            // opacity to nested children, if any.
            NodeKind::Modifier(_) if !n.children.is_empty() => {
                eval_group(
                    doc,
                    &n.children,
                    frame,
                    tf,
                    node_op,
                    blend,
                    scene,
                    depth + 1,
                    ov,
                    scope_rect,
                    clips,
                    &[],
                );
            }
            NodeKind::Shape(_) | NodeKind::Text(_) if !n.children.is_empty() => {
                let seeds: Vec<ShapeEntry> =
                    paths.iter().filter(|e| e.node == id).cloned().collect();
                eval_group(
                    doc,
                    &n.children,
                    frame,
                    tf,
                    node_op,
                    blend,
                    scene,
                    depth + 1,
                    ov,
                    scope_rect,
                    clips,
                    &seeds,
                );
            }
            _ => {}
        }
    }
}

/// One accumulated shape path in pass 1 of group evaluation, carrying the
/// shape's local affine (gradient folding) and a per-copy opacity factor
/// (repeater falloff) that rides along until style emission.
#[derive(Clone)]
struct ShapeEntry {
    node: NodeId,
    affine: Affine,
    opacity: f64,
    path: BezPath,
}

fn apply_modifier(
    m: &ModifierKind,
    id: NodeId,
    frame: f64,
    ov: &Overrides,
    paths: &mut Vec<ShapeEntry>,
) {
    match m {
        ModifierKind::Repeater {
            copies,
            offset,
            transform,
            start_opacity,
            end_opacity,
        } => {
            let count = ov_f64(ov, id, "repeater.copies", copies.value_at(frame))
                .round()
                .max(0.0) as usize;
            let off = ov_f64(ov, id, "repeater.offset", offset.value_at(frame));
            let so = ov_f64(
                ov,
                id,
                "repeater.start_opacity",
                start_opacity.value_at(frame),
            )
            .clamp(0.0, 1.0);
            let eo =
                ov_f64(ov, id, "repeater.end_opacity", end_opacity.value_at(frame)).clamp(0.0, 1.0);
            let mut ts = transform.sample(frame);
            ts.position = ov_vec2(ov, id, "repeater.transform.position", ts.position);
            ts.scale = ov_vec2(ov, id, "repeater.transform.scale", ts.scale);
            ts.rotation_deg = ov_angle(ov, id, "repeater.transform.rotation", ts.rotation_deg);
            ts.anchor = ov_vec2(ov, id, "repeater.transform.anchor", ts.anchor);
            ts.skew = ov_f64(ov, id, "repeater.transform.skew", ts.skew);
            ts.skew_axis = ov_f64(ov, id, "repeater.transform.skew_axis", ts.skew_axis);
            let step = affine_of(&ts);
            let original = std::mem::take(paths);
            let n = count.max(1);
            for i in 0..n {
                // Linear falloff: first copy = so, last copy = eo.
                let t = if n <= 1 {
                    0.0
                } else {
                    i as f64 / (n - 1) as f64
                };
                let copy_opacity = so + (eo - so) * t;

                let mut a = Affine::IDENTITY;
                let reps = (i as f64 + off).max(0.0) as usize;
                for _ in 0..reps {
                    a *= step;
                }
                for e in &original {
                    paths.push(ShapeEntry {
                        node: e.node,
                        affine: e.affine,
                        opacity: e.opacity * copy_opacity,
                        path: a * e.path.clone(),
                    });
                }
            }
        }
        ModifierKind::TrimPath {
            start,
            end,
            offset,
            mode,
        } => {
            let mut s = ov_f64(ov, id, "trim.start", start.value_at(frame)).clamp(0.0, 1.0);
            let mut e = ov_f64(ov, id, "trim.end", end.value_at(frame)).clamp(0.0, 1.0);
            if s > e {
                std::mem::swap(&mut s, &mut e);
            }
            let o = ov_f64(ov, id, "trim.offset", offset.value_at(frame)).rem_euclid(1.0);

            if (e - s).abs() < 1e-9 {
                paths.clear();
                return;
            }

            let originals = std::mem::take(paths);
            match mode {
                TrimMode::Individually => {
                    for entry in originals {
                        if let Some(trimmed) = trim_path(&entry.path, s, e, o) {
                            paths.push(ShapeEntry {
                                path: trimmed,
                                ..entry
                            });
                        }
                    }
                }
                TrimMode::Simultaneously => {
                    let lengths: Vec<f64> = originals
                        .iter()
                        .map(|entry| entry.path.perimeter(1e-3))
                        .collect();
                    let total: f64 = lengths.iter().sum();
                    if total <= 1e-9 {
                        return;
                    }
                    let s_g = s + o;
                    let e_g = e + o;
                    let mut cursor = 0.0;
                    for (entry, len) in originals.into_iter().zip(lengths) {
                        let frac = len / total;
                        if frac > 1e-12 {
                            let lo = cursor;
                            let hi = cursor + frac;
                            let mut ranges: Vec<(f64, f64)> = Vec::new();
                            for shift in [0.0, 1.0] {
                                let a = (s_g.max(lo + shift) - (lo + shift)) / frac;
                                let b = (e_g.min(hi + shift) - (lo + shift)) / frac;
                                let (a, b) = (a.clamp(0.0, 1.0), b.clamp(0.0, 1.0));
                                if b > a + 1e-9 {
                                    ranges.push((a, b));
                                }
                            }
                            for (ps, pe) in ranges {
                                if let Some(t) = trim_path(&entry.path, ps, pe, 0.0) {
                                    paths.push(ShapeEntry { path: t, ..entry });
                                }
                            }
                        }
                        cursor += frac;
                    }
                }
            }
        }
        ModifierKind::RoundCorners { radius } => {
            let r = ov_f64(ov, id, "round.radius", radius.value_at(frame)).max(0.0);
            if r > 1e-9 {
                // RoundCorners needs anchor-level data, so round-trip each
                // flattened path back through `VectorPath` before rounding.
                // `from_bez_path` re-detects tangent modes from the flattened
                // geometry: already-curved (Smooth) paths pass through untouched,
                // while hard cuts (e.g. from a preceding Trim) detect as Corner
                // and get rounded - Lottie modifier-order semantics.
                for entry in paths.iter_mut() {
                    let vp = renamite_geometry::VectorPath::from_bez_path(&entry.path);
                    entry.path = vp.round_corners(r).to_bez_path();
                }
            }
        }
        ModifierKind::OffsetPath { amount } => {
            let amount = ov_f64(ov, id, "offset.amount", amount.value_at(frame));
            if amount.abs() > 1e-9 {
                for entry in paths.iter_mut() {
                    if let Some(offset) = offset_bez_path(&entry.path, amount, SHAPE_TOL) {
                        entry.path = offset;
                    }
                }
            }
        }
        ModifierKind::ZigZag {
            amplitude,
            frequency,
            smooth,
        } => {
            let amp = ov_f64(ov, id, "zigzag.amplitude", amplitude.value_at(frame));
            let freq = ov_f64(ov, id, "zigzag.frequency", frequency.value_at(frame));
            if amp.abs() > 1e-9 && freq.abs() > 1e-9 {
                for entry in paths.iter_mut() {
                    entry.path = renamite_geometry::zigzag_path(&entry.path, amp, freq, *smooth);
                }
            }
        }
        ModifierKind::PuckerBloat { amount } => {
            let amt = ov_f64(ov, id, "pucker.amount", amount.value_at(frame));
            if amt.abs() > 1e-9 {
                for entry in paths.iter_mut() {
                    let vp = renamite_geometry::VectorPath::from_bez_path(&entry.path);
                    entry.path =
                        renamite_geometry::pucker_bloat_vector_path(&vp, amt).to_bez_path();
                }
            }
        }
    }
}

fn trim_path(path: &BezPath, s: f64, e: f64, offset: f64) -> Option<BezPath> {
    use kurbo::ParamCurveArclen;

    if (e - s).abs() < 1e-9 {
        return None;
    }

    let segments: Vec<kurbo::PathSeg> = path.segments().collect();
    if segments.is_empty() {
        return None;
    }
    let lengths: Vec<f64> = segments.iter().map(|seg| seg.arclen(1e-3)).collect();
    let total: f64 = lengths.iter().sum();
    if total <= 1e-9 {
        return None;
    }

    let s_offset = s + offset;
    let e_offset = e + offset;
    // Wrap decision in the PRE-modulo domain: the interval touches/crosses 1.0.
    // (Comparing the rem_euclid'd `a` vs `b` is unreliable near the seam where
    // FP noise flips `<` and silently empties the span.)
    let wraps = s_offset < 1.0 && e_offset >= 1.0;
    let a = s_offset.rem_euclid(1.0);
    let b = e_offset.rem_euclid(1.0);

    let mut out = BezPath::new();
    let mut last_end: Option<Point> = None;
    if wraps {
        // Wraps: [a, 1] then [0, b]. (a == b arises when e - s covers the
        // whole domain after offset; both halves together emit the full path.)
        emit_range(&segments, &lengths, total, a, 1.0, &mut out, &mut last_end);
        emit_range(&segments, &lengths, total, 0.0, b, &mut out, &mut last_end);
    } else {
        emit_range(&segments, &lengths, total, a, b, &mut out, &mut last_end);
    }

    if out.elements().is_empty() {
        None
    } else {
        Some(out)
    }
}

fn emit_range(
    segments: &[kurbo::PathSeg],
    lengths: &[f64],
    total: f64,
    a: f64,
    b: f64,
    out: &mut BezPath,
    last_end: &mut Option<Point>,
) {
    use kurbo::ParamCurve;

    let a_len = a * total;
    let b_len = b * total;
    let mut cursor = 0.0;

    for (seg, &len) in segments.iter().zip(lengths) {
        let seg_start = cursor;
        let seg_end = cursor + len;
        cursor = seg_end;

        if seg_end <= a_len {
            continue;
        }
        if seg_start >= b_len {
            break;
        }

        let t0 = if seg_start < a_len {
            arclen_to_t(seg, a_len - seg_start)
        } else {
            0.0
        };
        let t1 = if seg_end > b_len {
            arclen_to_t(seg, b_len - seg_start)
        } else {
            1.0
        };
        if t1 <= t0 + 1e-9 {
            continue;
        }

        let sub = seg.subsegment(t0..t1);
        let start_pt = sub.start();
        // Continuity check: new subpath (MoveTo break / wrap seam) → move_to.
        let connected = last_end
            .map(|p| (p - start_pt).hypot() < 1e-6)
            .unwrap_or(false);
        if !connected {
            out.move_to(start_pt);
        }
        append_seg(out, &sub);
        *last_end = Some(sub.end());
    }
}

fn arclen_to_t(seg: &kurbo::PathSeg, target: f64) -> f64 {
    use kurbo::{ParamCurve, ParamCurveArclen};
    let (mut lo, mut hi) = (0.0_f64, 1.0_f64);
    for _ in 0..24 {
        let mid = 0.5 * (lo + hi);
        if seg.subsegment(0.0..mid).arclen(1e-3) < target {
            lo = mid;
        } else {
            hi = mid;
        }
    }
    0.5 * (lo + hi)
}

fn append_seg(out: &mut BezPath, seg: &kurbo::PathSeg) {
    match seg {
        kurbo::PathSeg::Line(l) => out.line_to(l.p1),
        kurbo::PathSeg::Quad(q) => out.quad_to(q.p1, q.p2),
        kurbo::PathSeg::Cubic(c) => out.curve_to(c.p1, c.p2, c.p3),
    }
}

fn fold_gradient_point(affine: &Affine, local: glam::DVec2) -> glam::DVec2 {
    let p = *affine * Point::new(local.x, local.y);
    glam::DVec2::new(p.x, p.y)
}

#[allow(clippy::too_many_arguments)]
fn emit_style(
    st: &StyleKind,
    style_id: NodeId,
    frame: f64,
    ov: &Overrides,
    paths: &[ShapeEntry],
    opacity: f64,
    blend: BlendMode,
    active_clips: &[u32],
    scene: &mut Scene,
) {
    for e in paths {
        let (paint, kind, is_stroke) = match st {
            StyleKind::Fill { paint, rule } => (paint, PaintKind::Fill(*rule), false),
            StyleKind::Stroke {
                paint,
                width,
                cap,
                join,
                miter_limit,
                dash,
            } => (
                paint,
                PaintKind::Stroke(StrokeSample {
                    width: ov_f64(ov, style_id, "stroke.width", width.value_at(frame)).max(0.0),
                    cap: *cap,
                    join: *join,
                    miter_limit: ov_f64(
                        ov,
                        style_id,
                        "stroke.miter_limit",
                        miter_limit.value_at(frame),
                    )
                    .clamp(1.0, 10.0),
                    dash: dash.as_ref().map(|d| {
                        let mut dashes: Vec<f64> = d
                            .dashes
                            .iter()
                            .map(|x| {
                                let v = x.value_at(frame);
                                if !v.is_finite() || v < 0.0 { 0.0 } else { v }
                            })
                            .collect();
                        let offset = d.offset.value_at(frame);
                        let offset = if offset.is_finite() { offset } else { 0.0 };
                        if renamite_geometry::normalize_dash_pattern(&dashes).is_none() {
                            dashes.clear();
                        }
                        DashSample { dashes, offset }
                    }),
                }),
                true,
            ),
        };

        let paint = sample_paint_world(paint, frame, &e.affine, ov, style_id, is_stroke);

        scene.items.push(SceneItem {
            path: e.path.clone(),
            node: e.node,
            style: style_id,
            paint,
            kind,
            opacity: opacity * e.opacity,
            clips: active_clips.to_vec(),
            blend,
        });
    }
}

fn sample_paint_world(
    paint: &StylePaint,
    frame: f64,
    affine: &Affine,
    ov: &Overrides,
    style_id: NodeId,
    is_stroke: bool,
) -> ScenePaint {
    match paint {
        StylePaint::Solid { color } => {
            let path = if is_stroke {
                "stroke.color"
            } else {
                "fill.color"
            };
            ScenePaint::Solid(ov_color(ov, style_id, path, color.value_at(frame)))
        }
        StylePaint::Gradient(g) => {
            let kind = g.kind;
            let start_local = ov_vec2(ov, style_id, "grad.start", g.start.value_at(frame));
            let end_local = ov_vec2(ov, style_id, "grad.end", g.end.value_at(frame));
            let stops = ov_stops(ov, style_id, "grad.stops", &g.stops.value_at(frame));
            match kind {
                GradientKind::Linear => ScenePaint::LinearGradient {
                    start: fold_gradient_point(affine, start_local),
                    end: fold_gradient_point(affine, end_local),
                    stops,
                },
                GradientKind::Radial => ScenePaint::RadialGradient {
                    center: fold_gradient_point(affine, start_local),
                    end: fold_gradient_point(affine, end_local),
                    stops,
                },
            }
        }
    }
}

fn ov_stops(ov: &Overrides, id: NodeId, prop: &str, dflt: &GradientStops) -> GradientStops {
    match ov.get(id, prop) {
        Some(Value::Stops(s)) => s.clone(),
        _ => dflt.clone(),
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Parent {
    Node(NodeId),
    Comp(CompId),
}

#[derive(Clone, Debug, thiserror::Error)]
pub enum ModelError {
    #[error("node not found")]
    MissingNode,
    #[error("node kind mismatch (expected {0})")]
    WrongNodeKind(&'static str),
    #[error("composition not found")]
    MissingComp,
    #[error("precomposition cycle detected")]
    PrecompCycle,
    #[error("no property at path {0}")]
    MissingProp(String),
    #[error("value type mismatch for {0}")]
    TypeMismatch(String),
    #[error("no keyframe at frame {0}")]
    NoKeyframe(i64),
    #[error("keyframe already exists at frame {0}")]
    KeyframeExists(i64),
    #[error("node is not attached")]
    NotAttached,
    #[error("asset not found")]
    MissingAsset,
}

impl Document {
    pub fn empty() -> Self {
        let mut compositions = CompMap::default();
        let main = compositions.insert(Composition {
            name: "Main".into(),
            size: (512, 512),
            rate: renamite_animation::FrameRate { num: 60, den: 1 },
            range: (Frame(0), Frame(180)),
            children: Vec::new(),
        });
        Self {
            format_version: 1,
            compositions,
            nodes: NodeMap::default(),
            assets: AssetMap::default(),
            asset_order: Vec::new(),
            main,
        }
    }

    pub fn create_node(&mut self, node: Node) -> NodeId {
        self.nodes.insert(node)
    }

    pub fn attach(&mut self, id: NodeId, parent: Parent, index: usize) -> Result<(), ModelError> {
        if !self.nodes.contains_key(id) {
            return Err(ModelError::MissingNode);
        }
        match parent {
            Parent::Node(p) => {
                let pn = self.nodes.get_mut(p).ok_or(ModelError::MissingNode)?;
                let i = index.min(pn.children.len());
                pn.children.insert(i, id);
                self.nodes[id].parent = Some(p);
            }
            Parent::Comp(c) => {
                let comp = self
                    .compositions
                    .get_mut(c)
                    .ok_or(ModelError::MissingComp)?;
                let i = index.min(comp.children.len());
                comp.children.insert(i, id);
                self.nodes[id].parent = None;
            }
        }
        Ok(())
    }

    pub fn detach(&mut self, id: NodeId) -> Result<(Parent, usize), ModelError> {
        let (parent, index) = self.locate(id).ok_or(ModelError::NotAttached)?;
        match parent {
            Parent::Node(p) => {
                self.nodes[p].children.remove(index);
            }
            Parent::Comp(c) => {
                self.compositions[c].children.remove(index);
            }
        }
        if let Some(n) = self.nodes.get_mut(id) {
            n.parent = None;
        }
        Ok((parent, index))
    }

    pub fn locate(&self, id: NodeId) -> Option<(Parent, usize)> {
        let n = self.nodes.get(id)?;
        if let Some(p) = n.parent {
            let i = self.nodes.get(p)?.children.iter().position(|&c| c == id)?;
            return Some((Parent::Node(p), i));
        }
        for (cid, comp) in &self.compositions {
            if let Some(i) = comp.children.iter().position(|&c| c == id) {
                return Some((Parent::Comp(cid), i));
            }
        }
        None
    }

    /// Drop arena nodes not reachable from any composition (call before save).
    pub fn garbage_collect(&mut self) {
        // 1) Find compositions reachable from `main` through Precomp nodes (including nested in Groups/Layers)
        let mut live_comps = std::collections::HashSet::new();
        live_comps.insert(self.main);
        let mut comp_stack = vec![self.main];
        let mut visited_nodes_for_comps = std::collections::HashSet::new();
        while let Some(cid) = comp_stack.pop() {
            let Some(comp) = self.compositions.get(cid) else {
                continue;
            };
            // DFS through nodes in this composition to find Precomp targets
            let mut node_stack: Vec<NodeId> = comp.children.clone();
            visited_nodes_for_comps.clear();
            while let Some(nid) = node_stack.pop() {
                if !visited_nodes_for_comps.insert(nid) {
                    continue;
                }
                let Some(node) = self.nodes.get(nid) else {
                    continue;
                };
                if let NodeKind::Precomp { comp: target, .. } = &node.kind {
                    if live_comps.insert(*target) {
                        comp_stack.push(*target);
                    }
                }
                if matches!(node.kind, NodeKind::Group | NodeKind::Layer(_)) {
                    node_stack.extend(node.children.iter().copied());
                }
            }
        }
        // Prune orphan compositions (keep at least main even if cycle handling above kept it)
        self.compositions.retain(|id, _| live_comps.contains(&id));
        // Ensure main still exists (should, but guard)
        if !self.compositions.contains_key(self.main) {
            // Should not happen; keep GC conservative
            return;
        }

        let mut live = std::collections::HashSet::new();
        fn mark(doc: &Document, id: NodeId, live: &mut std::collections::HashSet<NodeId>) {
            if !live.insert(id) {
                return;
            }
            if let Some(n) = doc.nodes.get(id) {
                for &c in &n.children {
                    mark(doc, c, live);
                }
            }
        }
        let roots: Vec<NodeId> = self
            .compositions
            .values()
            .flat_map(|c| c.children.clone())
            .collect();
        for r in roots {
            mark(self, r, &mut live);
        }
        self.nodes.retain(|id, _| live.contains(&id));

        // Retain attached or node-referenced assets.
        let mut live_assets: std::collections::HashSet<AssetId> =
            self.asset_order.iter().copied().collect();
        for node in self.nodes.values() {
            if let NodeKind::Image(img) = &node.kind {
                live_assets.insert(img.asset());
            }
        }
        self.assets.retain(|id, _| live_assets.contains(&id));
        self.asset_order.retain(|id| self.assets.contains_key(*id));
    }

    /// Rebuild `asset_order` to match the arena: every attached id must exist
    /// and be unique. Any arena asset missing from the order gets appended.
    /// (Call after loading legacy projects that predate `asset_order`.)
    pub fn normalize_assets(&mut self) {
        let mut seen = std::collections::HashSet::new();

        self.asset_order
            .retain(|id| self.assets.contains_key(*id) && seen.insert(*id));

        for id in self.assets.keys() {
            if seen.insert(id) {
                self.asset_order.push(id);
            }
        }
    }

    /// The embedded image asset behind `id`, if it is an image.
    pub fn image_asset(&self, id: AssetId) -> Option<&ImageAsset> {
        match self.assets.get(id)? {
            Asset::Image(image) => Some(image),
            _ => None,
        }
    }

    /// Number of image-layer nodes referencing `asset`.
    pub fn image_usage_count(&self, asset: AssetId) -> usize {
        self.nodes
            .values()
            .filter(|node| matches!(&node.kind, NodeKind::Image(img) if img.asset() == asset))
            .count()
    }

    /// The font asset whose family matches `family`, if the project has one.
    /// Surfaces the `AssetId` (for removal) alongside the asset.
    pub fn font_asset_for_family(&self, family: &str) -> Option<(AssetId, &FontAsset)> {
        self.assets.iter().find_map(|(id, asset)| match asset {
            Asset::Font(font) if font.family == family => Some((id, font)),
            _ => None,
        })
    }

    /// Sorted, deduplicated family keys of every font asset in the project.
    pub fn font_families(&self) -> Vec<String> {
        let mut out: Vec<String> = self
            .asset_order
            .iter()
            .filter_map(|id| match self.assets.get(*id) {
                Some(Asset::Font(font)) => Some(font.family.clone()),
                _ => None,
            })
            .collect();
        out.sort();
        out.dedup();
        out
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
pub struct PropPath(String);

impl<'de> Deserialize<'de> for PropPath {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct PropPath(String);
        let raw = PropPath::deserialize(deserializer)?;
        Ok(Self::new(raw.0))
    }
}

impl PropPath {
    pub fn new(s: impl Into<String>) -> Self {
        let s = s.into();
        Self(canonical_prop_str(&s).to_owned())
    }
    pub fn as_str(&self) -> &str {
        &self.0
    }
    /// Owned canonical string (e.g. for undo-map keys).
    pub fn as_string(&self) -> String {
        self.0.clone()
    }
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Value {
    F64(f64),
    DVec2(glam::DVec2),
    Angle(Angle),
    Color(Color),
    Path(VectorPath),
    Bool(bool),
    I64(i64),
    /// Whole gradient stop list (animatable as one unit; v1).
    Stops(GradientStops),
    /// Whole style paint (structural swaps like solid<->gradient).
    Paint(StylePaint),
}

/// Low-level geometry hit: returns the leaf shape/text/image node.
pub fn pick(scene: &Scene, pt: glam::DVec2) -> Option<NodeId> {
    let q = Point::new(pt.x, pt.y);
    for item in scene.items.iter().rev() {
        if scene_item_hits(scene, item, q) {
            return Some(item.node);
        }
    }
    None
}

fn scene_item_hits(scene: &Scene, item: &SceneItem, q: Point) -> bool {
    if item.opacity <= 0.0 {
        return false;
    }

    let dashed_path = match &item.kind {
        PaintKind::Stroke(stroke) => stroke
            .dash
            .as_ref()
            .and_then(|dash| dash_bez_path(&item.path, &dash.dashes, dash.offset)),
        PaintKind::Fill(_) => None,
    };

    let hit_path = dashed_path.as_ref().unwrap_or(&item.path);

    let padding = match &item.kind {
        PaintKind::Stroke(stroke) => (stroke.width * 0.5).max(1.0),
        PaintKind::Fill(_) => 0.0,
    };

    if !hit_path
        .bounding_box()
        .inflate(padding, padding)
        .contains(q)
    {
        return false;
    }
    let clips_ok = item.clips.iter().all(|&ci| {
        let Some(c) = scene.clips.get(ci as usize) else {
            return false; // dangling index: not pickable
        };
        match c.rule {
            FillRule::NonZero => c.path.winding(q) != 0,
            FillRule::EvenOdd => c.path.winding(q) % 2 != 0,
        }
    });
    if !clips_ok {
        return false;
    }
    match &item.kind {
        PaintKind::Fill(rule) => match rule {
            FillRule::NonZero => hit_path.winding(q) != 0,
            FillRule::EvenOdd => hit_path.winding(q) % 2 != 0,
        },
        PaintKind::Stroke(_) => nearest_dist(hit_path, q) <= padding,
    }
}

/// Outermost selectable container for `picked` under `comp`.
pub fn outer_select_target(doc: &Document, comp: CompId, picked: NodeId) -> NodeId {
    let mut candidate: Option<NodeId> = match doc.nodes.get(picked).map(|n| &n.kind) {
        Some(NodeKind::Group) | Some(NodeKind::Layer(_)) => Some(picked),
        _ => None,
    };
    let mut cur = picked;
    // Follow parent links; `attach/detach` keeps them acyclic, but guard anyway.
    for _ in 0..256 {
        let Some(node) = doc.nodes.get(cur) else {
            break;
        };
        let Some(parent) = node.parent else {
            break;
        };
        let Some(parent_node) = doc.nodes.get(parent) else {
            break;
        };
        if matches!(parent_node.kind, NodeKind::Group | NodeKind::Layer(_)) {
            candidate = Some(parent);
        }
        cur = parent;
    }
    let Some(outer) = candidate else {
        return picked;
    };
    if is_under_comp(doc, comp, outer) {
        outer
    } else {
        picked
    }
}

fn is_under_comp(doc: &Document, comp: CompId, node: NodeId) -> bool {
    let mut cur = node;
    for _ in 0..256 {
        // Direct child of `comp`?
        if let Some(c) = doc.compositions.get(comp)
            && c.children.contains(&cur)
        {
            return true;
        }
        let Some(n) = doc.nodes.get(cur) else {
            return false;
        };
        let Some(parent) = n.parent else {
            return false;
        };
        cur = parent;
    }
    false
}

fn pick_chain_locked(doc: &Document, leaf: NodeId, outer: NodeId) -> bool {
    let mut cur = leaf;
    for _ in 0..256 {
        let Some(node) = doc.nodes.get(cur) else {
            return false;
        };
        if node.locked {
            return true;
        }
        if cur == outer {
            return false;
        }
        let Some(parent) = node.parent else {
            return false;
        };
        cur = parent;
    }
    false
}

/// Topmost `(outer, leaf)` hit under `pt`, skipping locked subtrees.
pub fn pick_selectable_with_leaf(
    doc: &Document,
    scene: &Scene,
    comp: CompId,
    pt: glam::DVec2,
) -> Option<(NodeId, NodeId)> {
    let q = Point::new(pt.x, pt.y);
    for item in scene.items.iter().rev() {
        if !scene_item_hits(scene, item, q) {
            continue;
        }
        let outer = outer_select_target(doc, comp, item.node);
        if pick_chain_locked(doc, item.node, outer) {
            continue;
        }
        return Some((outer, item.node));
    }
    None
}

pub fn pick_selectable(
    doc: &Document,
    scene: &Scene,
    comp: CompId,
    pt: glam::DVec2,
) -> Option<NodeId> {
    pick_selectable_with_leaf(doc, scene, comp, pt).map(|(outer, _)| outer)
}

fn nearest_dist(path: &BezPath, q: Point) -> f64 {
    let mut best = f64::MAX;
    for seg in path.segments() {
        best = best.min(seg.nearest(q, 1e-6).distance_sq);
    }
    best.sqrt()
}

/// Nodes whose geometry is FULLY CONTAINED in the box (rubber-band semantics).
/// `min`/`max` are normalized so drags in any direction work.
pub fn pick_box(scene: &Scene, min: glam::DVec2, max: glam::DVec2) -> Vec<NodeId> {
    let (min_x, max_x) = if min.x <= max.x {
        (min.x, max.x)
    } else {
        (max.x, min.x)
    };
    let (min_y, max_y) = if min.y <= max.y {
        (min.y, max.y)
    } else {
        (max.y, min.y)
    };
    let mut out = Vec::new();
    for item in &scene.items {
        if item.opacity <= 0.0 {
            continue;
        }
        let bb = item.path.bounding_box();
        if bb.x0 >= min_x
            && bb.x1 <= max_x
            && bb.y0 >= min_y
            && bb.y1 <= max_y
            && !out.contains(&item.node)
        {
            out.push(item.node);
        }
    }
    out
}

/// Rubber-band variant of [`pick_selectable`].
pub fn pick_box_selectable(
    doc: &Document,
    scene: &Scene,
    comp: CompId,
    min: glam::DVec2,
    max: glam::DVec2,
) -> Vec<NodeId> {
    let mut out = Vec::new();
    for leaf in pick_box(scene, min, max) {
        let outer = outer_select_target(doc, comp, leaf);
        if pick_chain_locked(doc, leaf, outer) {
            continue;
        }
        if !out.contains(&outer) {
            out.push(outer);
        }
    }
    out
}

/// Union bbox of all items belonging to `nodes` (selection bounds).
pub fn nodes_bounds(scene: &Scene, nodes: &[NodeId]) -> Option<(glam::DVec2, glam::DVec2)> {
    let mut acc: Option<kurbo::Rect> = None;
    for item in &scene.items {
        if !nodes.contains(&item.node) {
            continue;
        }
        let bb = item.path.bounding_box();
        acc = Some(acc.map_or(bb, |a| a.union(bb)));
    }
    acc.map(|r| (glam::DVec2::new(r.x0, r.y0), glam::DVec2::new(r.x1, r.y1)))
}

fn transform_vector(affine: Affine, value: glam::DVec2) -> glam::DVec2 {
    let [a, b, c, d, _, _] = affine.as_coeffs();

    glam::DVec2::new(a * value.x + c * value.y, b * value.x + d * value.y)
}

/// Convert a world-space drag delta to a node's parent coordinate system.
pub fn world_delta_to_parent(
    doc: &Document,
    id: NodeId,
    frame: f64,
    delta: glam::DVec2,
) -> Option<glam::DVec2> {
    let context = node_transform_context(doc, id, frame)?;
    let inverse = context.parent_world.inverse();

    let result = transform_vector(inverse, delta);

    result.is_finite().then_some(result)
}

pub fn node_is_ancestor(doc: &Document, ancestor: NodeId, mut node: NodeId) -> bool {
    while let Some(current) = doc.nodes.get(node) {
        let Some(parent) = current.parent else {
            return false;
        };

        if parent == ancestor {
            return true;
        }

        node = parent;
    }

    false
}

/// Single source of truth for which props a node kind honors at render,
/// keyed by section (not path string): one `match` instead of three parallel
/// tables. `prop_mut`/`prop_ref` consult this, so unsupported edits fail
/// loudly instead of writing dead values. Keep the arms in sync with
/// `eval_group`/`emit_style`/`apply_modifier`.
pub fn node_supports_transform(kind: &NodeKind) -> bool {
    matches!(
        kind,
        NodeKind::Group
            | NodeKind::Layer(_)
            | NodeKind::Shape(_)
            | NodeKind::Text(_)
            | NodeKind::Image(_)
            | NodeKind::Precomp { .. }
            | NodeKind::Mask(_)
    )
}

/// Opacity multiplies into emission for every kind except masks, which only
/// contribute a clip path and never emit paint. Modifier opacity applies to
/// nested children (pass 3); it does not attenuate the pass-1 path effect.
pub fn node_supports_opacity(kind: &NodeKind) -> bool {
    !matches!(kind, NodeKind::Mask(_))
}

/// Sections of `PropPath`s a node kind supports, mirroring the section
/// strings in `renamite_behavior_common::inspect` descriptors. `None` means
/// the path belongs to no known section and is always rejected.
pub fn prop_section_of(prop: &str) -> Option<&'static str> {
    let section = prop.split('.').next()?;
    match section {
        "transform" | "opacity" => Some("Transform"),
        "shape" => Some("Shape"),
        "text" => Some("Text"),
        "image" => Some("Image"),
        "fill" | "grad" => Some("Fill"),
        "stroke" => Some("Stroke"),
        "mask" => Some("Mask"),
        "trim" => Some("Trim"),
        "round" => Some("Round Corners"),
        "repeater" => Some("Repeater"),
        "offset" => Some("Offset Path"),
        "zigzag" => Some("Zig Zag"),
        "pucker" => Some("Pucker & Bloat"),
        "star" => Some("Shape"),
        "layer" => Some("Layer"),
        _ => None,
    }
}

/// Whether `kind` honors anything in `section`. Sections group paths, so one
/// arm covers a whole feature; per-path granularity (star Burst inner radius,
/// solid-vs-gradient color, dash presence) stays in the descriptor filter and
/// the `prop_mut`/`prop_ref` match arms.
pub fn node_supports_section(kind: &NodeKind, section: &str) -> bool {
    match section {
        "Transform" => node_supports_transform(kind) || node_supports_opacity(kind),
        "Shape" => matches!(
            kind,
            NodeKind::Shape(_) | NodeKind::Mask(_) | NodeKind::Modifier(_)
        ),
        "Text" => matches!(kind, NodeKind::Text(_)),
        "Image" => matches!(kind, NodeKind::Image(_)),
        "Fill" => matches!(kind, NodeKind::Style(StyleKind::Fill { .. })),
        "Stroke" => matches!(kind, NodeKind::Style(StyleKind::Stroke { .. })),
        "Mask" => matches!(kind, NodeKind::Mask(_)),
        "Trim" => matches!(kind, NodeKind::Modifier(ModifierKind::TrimPath { .. })),
        "Round Corners" => matches!(
            kind,
            NodeKind::Modifier(ModifierKind::RoundCorners { .. })
        ),
        "Repeater" => matches!(kind, NodeKind::Modifier(ModifierKind::Repeater { .. })),
        "Offset Path" => matches!(
            kind,
            NodeKind::Modifier(ModifierKind::OffsetPath { .. })
        ),
        "Zig Zag" => matches!(kind, NodeKind::Modifier(ModifierKind::ZigZag { .. })),
        "Pucker & Bloat" => matches!(
            kind,
            NodeKind::Modifier(ModifierKind::PuckerBloat { .. })
        ),
        "Layer" => matches!(kind, NodeKind::Layer(_)),
        _ => false,
    }
}

/// Full per-prop support: section gate above, then path granularity.
/// Anything returning false here is rejected by `prop_mut`/`prop_ref`.
pub fn node_supports_prop(kind: &NodeKind, prop: &str) -> bool {
    let Some(section) = prop_section_of(prop) else {
        return false;
    };
    if !node_supports_section(kind, section) {
        return false;
    }
    if prop == "opacity" {
        return node_supports_opacity(kind);
    }
    if prop.starts_with("transform.") {
        return node_supports_transform(kind);
    }
    if prop.starts_with("shape.") {
        let shape = match kind {
            NodeKind::Shape(s) => Some(s),
            NodeKind::Mask(m) => Some(&m.shape),
            _ => None,
        };
        let Some(shape) = shape else {
            return false;
        };
        return match prop {
            "shape.path" => matches!(shape, ShapeKind::Path(_)),
            "shape.pos" => matches!(
                shape,
                ShapeKind::Rect { .. }
                    | ShapeKind::Ellipse { .. }
                    | ShapeKind::Star { .. }
                    | ShapeKind::Polygon { .. }
            ),
            "shape.size" => matches!(shape, ShapeKind::Rect { .. } | ShapeKind::Ellipse { .. }),
            "shape.rounded" => matches!(shape, ShapeKind::Rect { .. }),
            "shape.points" => matches!(
                shape,
                ShapeKind::Star { .. } | ShapeKind::Polygon { .. }
            ),
            "shape.inner_r" => matches!(shape, ShapeKind::Star { .. }),
            "shape.outer_r" => matches!(
                shape,
                ShapeKind::Star { .. } | ShapeKind::Polygon { .. }
            ),
            "shape.roundness" => matches!(
                shape,
                ShapeKind::Star { .. } | ShapeKind::Polygon { .. }
            ),
            _ => false,
        };
    }
    if prop.starts_with("text.") {
        if !matches!(kind, NodeKind::Text(_)) {
            return false;
        }
        return matches!(
            prop,
            "text.size" | "text.tracking" | "text.leading" | "text.align"
        );
    }
    if prop.starts_with("image.") {
        return matches!(kind, NodeKind::Image(_)) && matches!(prop, "image.tint" | "image.tint()");
    }
    if prop == "fill.color" {
        return matches!(
            kind,
            NodeKind::Style(StyleKind::Fill {
                paint: StylePaint::Solid { .. },
                ..
            })
        );
    }
    if prop.starts_with("stroke.") {
        let NodeKind::Style(StyleKind::Stroke { paint, dash, .. }) = kind else {
            return false;
        };
        if prop == "stroke.dash.offset" || dash_index(prop).is_some() {
            return dash.is_some();
        }
        if prop == "stroke.color" {
            return matches!(paint, StylePaint::Solid { .. });
        }
        return matches!(
            prop,
            "stroke.width" | "stroke.miter_limit" | "stroke.cap" | "stroke.join"
        );
    }
    if prop == "stroke.color" {
        return false;
    }
    if prop.starts_with("grad.") {
        let (NodeKind::Style(StyleKind::Fill { paint, .. })
        | NodeKind::Style(StyleKind::Stroke { paint, .. })) = kind
        else {
            return false;
        };
        if !matches!(paint, StylePaint::Gradient(_)) {
            return false;
        }
        return matches!(prop, "grad.start" | "grad.end" | "grad.stops");
    }
    if prop.starts_with("trim.") {
        return matches!(kind, NodeKind::Modifier(ModifierKind::TrimPath { .. }))
            && matches!(prop, "trim.start" | "trim.end" | "trim.offset");
    }
    if prop.starts_with("repeater.") {
        if !matches!(kind, NodeKind::Modifier(ModifierKind::Repeater { .. })) {
            return false;
        }
        return matches!(
            prop,
            "repeater.copies"
                | "repeater.offset"
                | "repeater.start_opacity"
                | "repeater.end_opacity"
                | "repeater.transform.position"
                | "repeater.transform.scale"
                | "repeater.transform.rotation"
                | "repeater.transform.anchor"
                | "repeater.transform.skew"
                | "repeater.transform.skew_axis"
        );
    }
    if prop.starts_with("round.") {
        return matches!(
            kind,
            NodeKind::Modifier(ModifierKind::RoundCorners { .. })
        ) && prop == "round.radius";
    }
    if prop.starts_with("offset.") {
        return matches!(kind, NodeKind::Modifier(ModifierKind::OffsetPath { .. }))
            && prop == "offset.amount";
    }
    if prop.starts_with("zigzag.") {
        return matches!(kind, NodeKind::Modifier(ModifierKind::ZigZag { .. }))
            && matches!(prop, "zigzag.amplitude" | "zigzag.frequency");
    }
    if prop.starts_with("pucker.") {
        return matches!(
            kind,
            NodeKind::Modifier(ModifierKind::PuckerBloat { .. })
        ) && prop == "pucker.amount";
    }
    if prop.starts_with("star.") {
        let is_star = matches!(kind, NodeKind::Shape(ShapeKind::Star { .. }))
            || matches!(kind, NodeKind::Mask(m) if matches!(&m.shape, ShapeKind::Star { .. }));
        return is_star && prop == "star.kind";
    }
    if prop.starts_with("mask.") {
        return matches!(kind, NodeKind::Mask(_)) && prop == "mask.inverted";
    }
    if prop.starts_with("layer.") {
        return matches!(kind, NodeKind::Layer(_)) && prop == "layer.blend";
    }
    false
}

/// If `picked` belongs to an already-selected group/layer, return that selected
/// ancestor instead of replacing it with the leaf shape.
pub fn selected_ancestor_for_pick(
    doc: &Document,
    picked: NodeId,
    selection: &[NodeId],
) -> Option<NodeId> {
    selection
        .iter()
        .copied()
        .find(|selected| *selected == picked || node_is_ancestor(doc, *selected, picked))
}

/// Return the immediate child of `ancestor` that contains `descendant`.
pub fn immediate_child_below(
    doc: &Document,
    ancestor: NodeId,
    descendant: NodeId,
) -> Option<NodeId> {
    if ancestor == descendant {
        return None;
    }

    let mut current = descendant;

    loop {
        let parent = doc.nodes.get(current)?.parent?;

        if parent == ancestor {
            return Some(current);
        }

        current = parent;
    }
}

/// Union bounds of selected leaf nodes and all rendered descendants of selected
/// groups/layers.
pub fn selection_bounds(
    doc: &Document,
    scene: &Scene,
    selection: &[NodeId],
) -> Option<(glam::DVec2, glam::DVec2)> {
    let mut bounds: Option<kurbo::Rect> = None;

    for item in &scene.items {
        let included = selection
            .iter()
            .copied()
            .any(|selected| selected == item.node || node_is_ancestor(doc, selected, item.node));

        if !included {
            continue;
        }

        let item_bounds = item.path.bounding_box();

        bounds = Some(match bounds {
            Some(existing) => existing.union(item_bounds),
            None => item_bounds,
        });
    }

    bounds.map(|rect| {
        (
            glam::DVec2::new(rect.x0, rect.y0),
            glam::DVec2::new(rect.x1, rect.y1),
        )
    })
}

/// Serialized keyframe (for RestoreKeyframe / undo).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct KeyframeData {
    pub frame: Frame,
    pub value: Value,
    pub interpolation: Interpolation,
    pub ease_out: EasingHandle,
    pub ease_in: EasingHandle,
}

pub trait PropValue: Tween + Clone {
    fn into_value(self) -> Value;
    fn from_value(v: &Value) -> Option<Self>;
}
impl PropValue for f64 {
    fn into_value(self) -> Value {
        Value::F64(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        if let Value::F64(x) = v {
            Some(*x)
        } else {
            None
        }
    }
}
impl PropValue for glam::DVec2 {
    fn into_value(self) -> Value {
        Value::DVec2(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        if let Value::DVec2(x) = v {
            Some(*x)
        } else {
            None
        }
    }
}
impl PropValue for Angle {
    fn into_value(self) -> Value {
        Value::Angle(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        match v {
            Value::Angle(a) => Some(*a),
            Value::F64(x) => Some(Angle(*x)),
            _ => None,
        }
    }
}
impl PropValue for Color {
    fn into_value(self) -> Value {
        Value::Color(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        if let Value::Color(c) = v {
            Some(*c)
        } else {
            None
        }
    }
}
impl PropValue for VectorPath {
    fn into_value(self) -> Value {
        Value::Path(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        if let Value::Path(p) = v {
            Some(p.clone())
        } else {
            None
        }
    }
}
impl PropValue for GradientStops {
    fn into_value(self) -> Value {
        Value::Stops(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        if let Value::Stops(s) = v {
            Some(s.clone())
        } else {
            None
        }
    }
}
impl PropValue for StylePaint {
    fn into_value(self) -> Value {
        Value::Paint(self)
    }
    fn from_value(v: &Value) -> Option<Self> {
        if let Value::Paint(p) = v {
            Some(p.clone())
        } else {
            None
        }
    }
}

pub enum PropMut<'a> {
    F64(&'a mut Animated<f64>),
    Vec2(&'a mut Animated<glam::DVec2>),
    Angle(&'a mut Animated<Angle>),
    Color(&'a mut Animated<Color>),
    Path(&'a mut Animated<VectorPath>),
    Stops(&'a mut Animated<GradientStops>),
}
pub enum PropRef<'a> {
    F64(&'a Animated<f64>),
    Vec2(&'a Animated<glam::DVec2>),
    Angle(&'a Animated<Angle>),
    Color(&'a Animated<Color>),
    Path(&'a Animated<VectorPath>),
    Stops(&'a Animated<GradientStops>),
}

pub trait PropVisitor {
    type Out;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out;
}
pub trait PropReader {
    type Out;
    fn read<T: PropValue>(self, a: &Animated<T>) -> Self::Out;
}

pub fn visit_prop<V: PropVisitor>(p: PropMut<'_>, v: V) -> V::Out {
    match p {
        PropMut::F64(a) => v.visit(a),
        PropMut::Vec2(a) => v.visit(a),
        PropMut::Angle(a) => v.visit(a),
        PropMut::Color(a) => v.visit(a),
        PropMut::Path(a) => v.visit(a),
        PropMut::Stops(a) => v.visit(a),
    }
}
pub fn read_prop<V: PropReader>(p: PropRef<'_>, v: V) -> V::Out {
    match p {
        PropRef::F64(a) => v.read(a),
        PropRef::Vec2(a) => v.read(a),
        PropRef::Angle(a) => v.read(a),
        PropRef::Color(a) => v.read(a),
        PropRef::Path(a) => v.read(a),
        PropRef::Stops(a) => v.read(a),
    }
}

fn dash_index(path: &str) -> Option<usize> {
    path.strip_prefix("stroke.dash.")?.parse().ok()
}

impl Node {
    pub fn prop_mut(&mut self, prop: &PropPath) -> Option<PropMut<'_>> {
        use PropMut::*;
        let s = prop.as_str();
        if !node_supports_prop(&self.kind, s) {
            return None;
        }
        if s == "stroke.dash.offset" || dash_index(s).is_some() {
            if let NodeKind::Style(StyleKind::Stroke {
                dash: Some(dash), ..
            }) = &mut self.kind
            {
                if s == "stroke.dash.offset" {
                    return Some(F64(&mut dash.offset));
                }
                if let Some(index) = dash_index(s) {
                    return dash.dashes.get_mut(index).map(PropMut::F64);
                }
            }
            return None;
        }

        match (s, &mut self.kind) {
            ("opacity", _) => Some(F64(&mut self.opacity)),
            ("transform.anchor", _) => Some(Vec2(&mut self.transform.anchor)),
            ("transform.position", _) => Some(Vec2(&mut self.transform.position)),
            ("transform.scale", _) => Some(Vec2(&mut self.transform.scale)),
            ("transform.rotation", _) => Some(Angle(&mut self.transform.rotation)),
            ("transform.skew", _) => Some(F64(&mut self.transform.skew)),
            ("transform.skew_axis", _) => Some(F64(&mut self.transform.skew_axis)),
            ("shape.path", NodeKind::Shape(ShapeKind::Path(p))) => Some(Path(p)),
            ("shape.pos", NodeKind::Shape(ShapeKind::Rect { pos, .. }))
            | ("shape.pos", NodeKind::Shape(ShapeKind::Ellipse { pos, .. }))
            | ("shape.pos", NodeKind::Shape(ShapeKind::Star { pos, .. }))
            | ("shape.pos", NodeKind::Shape(ShapeKind::Polygon { pos, .. })) => Some(Vec2(pos)),
            ("shape.size", NodeKind::Shape(ShapeKind::Rect { size, .. }))
            | ("shape.size", NodeKind::Shape(ShapeKind::Ellipse { size, .. })) => Some(Vec2(size)),
            ("shape.rounded", NodeKind::Shape(ShapeKind::Rect { rounded, .. })) => {
                Some(F64(rounded))
            }
            ("shape.points", NodeKind::Shape(ShapeKind::Star { points, .. }))
            | ("shape.points", NodeKind::Shape(ShapeKind::Polygon { points, .. })) => {
                Some(F64(points))
            }
            ("shape.inner_r", NodeKind::Shape(ShapeKind::Star { inner_r, .. })) => {
                Some(F64(inner_r))
            }
            ("shape.outer_r", NodeKind::Shape(ShapeKind::Star { outer_r, .. }))
            | ("shape.outer_r", NodeKind::Shape(ShapeKind::Polygon { outer_r, .. })) => {
                Some(F64(outer_r))
            }
            ("shape.roundness", NodeKind::Shape(ShapeKind::Star { roundness, .. }))
            | ("shape.roundness", NodeKind::Shape(ShapeKind::Polygon { roundness, .. })) => {
                Some(F64(roundness))
            }
            ("text.size", NodeKind::Text(t)) => Some(F64(&mut t.size)),
            ("text.tracking", NodeKind::Text(t)) => Some(F64(&mut t.tracking)),
            ("text.leading", NodeKind::Text(t)) => Some(F64(&mut t.leading)),
            (
                "shape.path",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Path(p),
                    ..
                }),
            ) => Some(Path(p)),
            (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Rect { pos, .. },
                    ..
                }),
            )
            | (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Ellipse { pos, .. },
                    ..
                }),
            )
            | (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { pos, .. },
                    ..
                }),
            )
            | (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Polygon { pos, .. },
                    ..
                }),
            ) => Some(Vec2(pos)),
            (
                "shape.size",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Rect { size, .. },
                    ..
                }),
            )
            | (
                "shape.size",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Ellipse { size, .. },
                    ..
                }),
            ) => Some(Vec2(size)),
            (
                "shape.rounded",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Rect { rounded, .. },
                    ..
                }),
            ) => Some(F64(rounded)),
            (
                "shape.points",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { points, .. } | ShapeKind::Polygon { points, .. },
                    ..
                }),
            ) => Some(F64(points)),
            (
                "shape.inner_r",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { inner_r, .. },
                    ..
                }),
            ) => Some(F64(inner_r)),
            (
                "shape.outer_r",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { outer_r, .. } | ShapeKind::Polygon { outer_r, .. },
                    ..
                }),
            ) => Some(F64(outer_r)),
            (
                "shape.roundness",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { roundness, .. } | ShapeKind::Polygon { roundness, .. },
                    ..
                }),
            ) => Some(F64(roundness)),
            (
                "fill.color",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Solid { color },
                    ..
                }),
            ) => Some(Color(color)),
            (
                "stroke.color",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Solid { color },
                    ..
                }),
            ) => Some(Color(color)),
            ("stroke.width", NodeKind::Style(StyleKind::Stroke { width, .. })) => Some(F64(width)),
            ("stroke.miter_limit", NodeKind::Style(StyleKind::Stroke { miter_limit, .. })) => {
                Some(F64(miter_limit))
            }
            ("image.tint" | "image.tint()", NodeKind::Image(img)) => {
                let tint = img.tint_mut()?;
                Some(Color(tint))
            }
            (
                "grad.start",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            )
            | (
                "grad.start",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            ) => Some(Vec2(&mut g.start)),
            (
                "grad.end",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            )
            | (
                "grad.end",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            ) => Some(Vec2(&mut g.end)),
            (
                "grad.stops",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            )
            | (
                "grad.stops",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            ) => Some(Stops(&mut g.stops)),
            ("trim.start", NodeKind::Modifier(ModifierKind::TrimPath { start, .. })) => {
                Some(F64(start))
            }
            ("trim.end", NodeKind::Modifier(ModifierKind::TrimPath { end, .. })) => Some(F64(end)),
            ("trim.offset", NodeKind::Modifier(ModifierKind::TrimPath { offset, .. })) => {
                Some(F64(offset))
            }
            ("repeater.copies", NodeKind::Modifier(ModifierKind::Repeater { copies, .. })) => {
                Some(F64(copies))
            }
            ("repeater.offset", NodeKind::Modifier(ModifierKind::Repeater { offset, .. })) => {
                Some(F64(offset))
            }
            (
                "repeater.start_opacity",
                NodeKind::Modifier(ModifierKind::Repeater { start_opacity, .. }),
            ) => Some(F64(start_opacity)),
            (
                "repeater.end_opacity",
                NodeKind::Modifier(ModifierKind::Repeater { end_opacity, .. }),
            ) => Some(F64(end_opacity)),
            (
                "repeater.transform.position",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Vec2(&mut transform.position)),
            (
                "repeater.transform.scale",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Vec2(&mut transform.scale)),
            (
                "repeater.transform.rotation",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Angle(&mut transform.rotation)),
            (
                "repeater.transform.anchor",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Vec2(&mut transform.anchor)),
            (
                "repeater.transform.skew",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(F64(&mut transform.skew)),
            (
                "repeater.transform.skew_axis",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(F64(&mut transform.skew_axis)),
            ("round.radius", NodeKind::Modifier(ModifierKind::RoundCorners { radius })) => {
                Some(F64(radius))
            }
            ("offset.amount", NodeKind::Modifier(ModifierKind::OffsetPath { amount })) => {
                Some(F64(amount))
            }
            ("zigzag.amplitude", NodeKind::Modifier(ModifierKind::ZigZag { amplitude, .. })) => {
                Some(F64(amplitude))
            }
            ("zigzag.frequency", NodeKind::Modifier(ModifierKind::ZigZag { frequency, .. })) => {
                Some(F64(frequency))
            }
            ("pucker.amount", NodeKind::Modifier(ModifierKind::PuckerBloat { amount })) => {
                Some(F64(amount))
            }
            _ => None,
        }
    }

    pub fn prop_ref(&self, prop: &PropPath) -> Option<PropRef<'_>> {
        use PropRef::*;
        let s = prop.as_str();
        if !node_supports_prop(&self.kind, s) {
            return None;
        }
        if s == "stroke.dash.offset" || dash_index(s).is_some() {
            if let NodeKind::Style(StyleKind::Stroke {
                dash: Some(dash), ..
            }) = &self.kind
            {
                if s == "stroke.dash.offset" {
                    return Some(F64(&dash.offset));
                }
                if let Some(index) = dash_index(s) {
                    return dash.dashes.get(index).map(PropRef::F64);
                }
            }
            return None;
        }

        match (s, &self.kind) {
            ("opacity", _) => Some(F64(&self.opacity)),
            ("transform.anchor", _) => Some(Vec2(&self.transform.anchor)),
            ("transform.position", _) => Some(Vec2(&self.transform.position)),
            ("transform.scale", _) => Some(Vec2(&self.transform.scale)),
            ("transform.rotation", _) => Some(Angle(&self.transform.rotation)),
            ("transform.skew", _) => Some(F64(&self.transform.skew)),
            ("transform.skew_axis", _) => Some(F64(&self.transform.skew_axis)),
            ("shape.path", NodeKind::Shape(ShapeKind::Path(p))) => Some(Path(p)),
            ("shape.pos", NodeKind::Shape(ShapeKind::Rect { pos, .. }))
            | ("shape.pos", NodeKind::Shape(ShapeKind::Ellipse { pos, .. }))
            | ("shape.pos", NodeKind::Shape(ShapeKind::Star { pos, .. }))
            | ("shape.pos", NodeKind::Shape(ShapeKind::Polygon { pos, .. })) => Some(Vec2(pos)),
            ("shape.size", NodeKind::Shape(ShapeKind::Rect { size, .. }))
            | ("shape.size", NodeKind::Shape(ShapeKind::Ellipse { size, .. })) => Some(Vec2(size)),
            ("shape.rounded", NodeKind::Shape(ShapeKind::Rect { rounded, .. })) => {
                Some(F64(rounded))
            }
            ("shape.points", NodeKind::Shape(ShapeKind::Star { points, .. }))
            | ("shape.points", NodeKind::Shape(ShapeKind::Polygon { points, .. })) => {
                Some(F64(points))
            }
            ("shape.inner_r", NodeKind::Shape(ShapeKind::Star { inner_r, .. })) => {
                Some(F64(inner_r))
            }
            ("shape.outer_r", NodeKind::Shape(ShapeKind::Star { outer_r, .. }))
            | ("shape.outer_r", NodeKind::Shape(ShapeKind::Polygon { outer_r, .. })) => {
                Some(F64(outer_r))
            }
            ("shape.roundness", NodeKind::Shape(ShapeKind::Star { roundness, .. }))
            | ("shape.roundness", NodeKind::Shape(ShapeKind::Polygon { roundness, .. })) => {
                Some(F64(roundness))
            }
            ("text.size", NodeKind::Text(t)) => Some(F64(&t.size)),
            ("text.tracking", NodeKind::Text(t)) => Some(F64(&t.tracking)),
            ("text.leading", NodeKind::Text(t)) => Some(F64(&t.leading)),
            (
                "shape.path",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Path(p),
                    ..
                }),
            ) => Some(Path(p)),
            (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Rect { pos, .. },
                    ..
                }),
            )
            | (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Ellipse { pos, .. },
                    ..
                }),
            )
            | (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { pos, .. },
                    ..
                }),
            )
            | (
                "shape.pos",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Polygon { pos, .. },
                    ..
                }),
            ) => Some(Vec2(pos)),
            (
                "shape.size",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Rect { size, .. },
                    ..
                }),
            )
            | (
                "shape.size",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Ellipse { size, .. },
                    ..
                }),
            ) => Some(Vec2(size)),
            (
                "shape.rounded",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Rect { rounded, .. },
                    ..
                }),
            ) => Some(F64(rounded)),
            (
                "shape.points",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { points, .. } | ShapeKind::Polygon { points, .. },
                    ..
                }),
            ) => Some(F64(points)),
            (
                "shape.inner_r",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { inner_r, .. },
                    ..
                }),
            ) => Some(F64(inner_r)),
            (
                "shape.outer_r",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { outer_r, .. } | ShapeKind::Polygon { outer_r, .. },
                    ..
                }),
            ) => Some(F64(outer_r)),
            (
                "shape.roundness",
                NodeKind::Mask(MaskProps {
                    shape: ShapeKind::Star { roundness, .. } | ShapeKind::Polygon { roundness, .. },
                    ..
                }),
            ) => Some(F64(roundness)),
            (
                "fill.color",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Solid { color },
                    ..
                }),
            ) => Some(Color(color)),
            (
                "stroke.color",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Solid { color },
                    ..
                }),
            ) => Some(Color(color)),
            ("stroke.width", NodeKind::Style(StyleKind::Stroke { width, .. })) => Some(F64(width)),
            ("stroke.miter_limit", NodeKind::Style(StyleKind::Stroke { miter_limit, .. })) => {
                Some(F64(miter_limit))
            }
            ("image.tint" | "image.tint()", NodeKind::Image(img)) => Some(Color(img.tint())),
            (
                "grad.start",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            )
            | (
                "grad.start",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            ) => Some(Vec2(&g.start)),
            (
                "grad.end",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            )
            | (
                "grad.end",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            ) => Some(Vec2(&g.end)),
            (
                "grad.stops",
                NodeKind::Style(StyleKind::Fill {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            )
            | (
                "grad.stops",
                NodeKind::Style(StyleKind::Stroke {
                    paint: StylePaint::Gradient(g),
                    ..
                }),
            ) => Some(Stops(&g.stops)),
            ("trim.start", NodeKind::Modifier(ModifierKind::TrimPath { start, .. })) => {
                Some(F64(start))
            }
            ("trim.end", NodeKind::Modifier(ModifierKind::TrimPath { end, .. })) => Some(F64(end)),
            ("trim.offset", NodeKind::Modifier(ModifierKind::TrimPath { offset, .. })) => {
                Some(F64(offset))
            }
            ("repeater.copies", NodeKind::Modifier(ModifierKind::Repeater { copies, .. })) => {
                Some(F64(copies))
            }
            ("repeater.offset", NodeKind::Modifier(ModifierKind::Repeater { offset, .. })) => {
                Some(F64(offset))
            }
            (
                "repeater.start_opacity",
                NodeKind::Modifier(ModifierKind::Repeater { start_opacity, .. }),
            ) => Some(F64(start_opacity)),
            (
                "repeater.end_opacity",
                NodeKind::Modifier(ModifierKind::Repeater { end_opacity, .. }),
            ) => Some(F64(end_opacity)),
            (
                "repeater.transform.position",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Vec2(&transform.position)),
            (
                "repeater.transform.scale",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Vec2(&transform.scale)),
            (
                "repeater.transform.rotation",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Angle(&transform.rotation)),
            (
                "repeater.transform.anchor",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(Vec2(&transform.anchor)),
            (
                "repeater.transform.skew",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(F64(&transform.skew)),
            (
                "repeater.transform.skew_axis",
                NodeKind::Modifier(ModifierKind::Repeater { transform, .. }),
            ) => Some(F64(&transform.skew_axis)),
            ("round.radius", NodeKind::Modifier(ModifierKind::RoundCorners { radius })) => {
                Some(F64(radius))
            }
            ("offset.amount", NodeKind::Modifier(ModifierKind::OffsetPath { amount })) => {
                Some(F64(amount))
            }
            ("zigzag.amplitude", NodeKind::Modifier(ModifierKind::ZigZag { amplitude, .. })) => {
                Some(F64(amplitude))
            }
            ("zigzag.frequency", NodeKind::Modifier(ModifierKind::ZigZag { frequency, .. })) => {
                Some(F64(frequency))
            }
            ("pucker.amount", NodeKind::Modifier(ModifierKind::PuckerBloat { amount })) => {
                Some(F64(amount))
            }
            _ => None,
        }
    }
}

struct SetStaticOp<'a>(&'a Value, &'a str);
impl PropVisitor for SetStaticOp<'_> {
    type Out = Result<Value, ModelError>;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out {
        let new = T::from_value(self.0).ok_or_else(|| ModelError::TypeMismatch(self.1.into()))?;
        Ok(std::mem::replace(&mut a.base, new).into_value())
    }
}

struct AddKeyOp<'a> {
    frame: Frame,
    value: &'a Value,
    prop: &'a str,
}
impl PropVisitor for AddKeyOp<'_> {
    type Out = Result<Option<KeyframeData>, ModelError>;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out {
        let new =
            T::from_value(self.value).ok_or_else(|| ModelError::TypeMismatch(self.prop.into()))?;
        let old = a.key_at(self.frame).map(|k| KeyframeData {
            frame: k.frame,
            value: k.value.clone().into_value(),
            interpolation: k.interpolation,
            ease_out: k.ease_out,
            ease_in: k.ease_in,
        });
        a.set_key(self.frame, new);
        Ok(old)
    }
}

struct RemoveKeyOp(Frame);
impl PropVisitor for RemoveKeyOp {
    type Out = Result<KeyframeData, ModelError>;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out {
        let k = a
            .remove_key(self.0)
            .ok_or(ModelError::NoKeyframe(self.0.0))?;
        Ok(KeyframeData {
            frame: k.frame,
            value: k.value.into_value(),
            interpolation: k.interpolation,
            ease_out: k.ease_out,
            ease_in: k.ease_in,
        })
    }
}

struct RestoreKeyOp<'a>(&'a KeyframeData, &'a str);
impl PropVisitor for RestoreKeyOp<'_> {
    type Out = Result<(), ModelError>;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out {
        let v =
            T::from_value(&self.0.value).ok_or_else(|| ModelError::TypeMismatch(self.1.into()))?;
        a.set_key(self.0.frame, v);
        a.set_easing(
            self.0.frame,
            self.0.interpolation,
            self.0.ease_out,
            self.0.ease_in,
        );
        Ok(())
    }
}

struct MoveKeyOp {
    from: Frame,
    to: Frame,
}
impl PropVisitor for MoveKeyOp {
    type Out = Result<(), ModelError>;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out {
        if self.from == self.to {
            return Ok(());
        }
        if a.key_at(self.to).is_some() {
            return Err(ModelError::KeyframeExists(self.to.0));
        }
        if a.move_key(self.from, self.to) {
            Ok(())
        } else {
            Err(ModelError::NoKeyframe(self.from.0))
        }
    }
}

struct SetEasingOp {
    frame: Frame,
    i: Interpolation,
    o: EasingHandle,
    e: EasingHandle,
}
impl PropVisitor for SetEasingOp {
    type Out = Result<(Interpolation, EasingHandle, EasingHandle), ModelError>;
    fn visit<T: PropValue>(self, a: &mut Animated<T>) -> Self::Out {
        a.set_easing(self.frame, self.i, self.o, self.e)
            .ok_or(ModelError::NoKeyframe(self.frame.0))
    }
}

struct IsAnimatedOp;
impl PropReader for IsAnimatedOp {
    type Out = bool;
    fn read<T: PropValue>(self, a: &Animated<T>) -> bool {
        a.has_keys()
    }
}

struct ValueAtOp(f64);
impl PropReader for ValueAtOp {
    type Out = Value;
    fn read<T: PropValue>(self, a: &Animated<T>) -> Value {
        a.value_at(self.0).into_value()
    }
}

struct GetStaticOp;
impl PropReader for GetStaticOp {
    type Out = Value;
    fn read<T: PropValue>(self, a: &Animated<T>) -> Value {
        a.base.clone().into_value()
    }
}

struct GetKeyOp(Frame);
impl PropReader for GetKeyOp {
    type Out = Option<KeyframeData>;
    fn read<T: PropValue>(self, a: &Animated<T>) -> Option<KeyframeData> {
        a.key_at(self.0).map(|k| KeyframeData {
            frame: k.frame,
            value: k.value.clone().into_value(),
            interpolation: k.interpolation,
            ease_out: k.ease_out,
            ease_in: k.ease_in,
        })
    }
}

/// Enumeration of keyframe frames (sorted; the source is sorted by invariant).
struct KeyFramesOp;
impl PropReader for KeyFramesOp {
    type Out = Vec<Frame>;
    fn read<T: PropValue>(self, a: &Animated<T>) -> Vec<Frame> {
        a.keyframes.iter().map(|k| k.frame).collect()
    }
}

impl Document {
    /// All live node ids whose name equals `name`. Lets hosts (games) find
    /// nodes by name without tracking `NodeId`s across document loads.
    pub fn find_nodes_by_name<'a>(&'a self, name: &'a str) -> impl Iterator<Item = NodeId> + 'a {
        self.nodes
            .iter()
            .filter(move |(_, n)| n.name == name)
            .map(|(id, _)| id)
    }

    fn pm<'a>(&'a mut self, id: NodeId, prop: &PropPath) -> Result<PropMut<'a>, ModelError> {
        self.nodes
            .get_mut(id)
            .ok_or(ModelError::MissingNode)?
            .prop_mut(prop)
            .ok_or_else(|| ModelError::MissingProp(prop.as_string()))
    }
    fn pr<'a>(&'a self, id: NodeId, prop: &PropPath) -> Result<PropRef<'a>, ModelError> {
        self.nodes
            .get(id)
            .ok_or(ModelError::MissingNode)?
            .prop_ref(prop)
            .ok_or_else(|| ModelError::MissingProp(prop.as_string()))
    }

    /// Set the base value; returns previous base (for undo).
    pub fn set_static(
        &mut self,
        id: NodeId,
        prop: &PropPath,
        v: &Value,
    ) -> Result<Value, ModelError> {
        let name = prop.as_string();
        visit_prop(self.pm(id, prop)?, SetStaticOp(v, &name))
    }
    /// Insert/update key at frame; returns replaced key if any (for undo).
    pub fn add_keyframe(
        &mut self,
        id: NodeId,
        prop: &PropPath,
        frame: Frame,
        v: &Value,
    ) -> Result<Option<KeyframeData>, ModelError> {
        let name = prop.as_string();
        visit_prop(
            self.pm(id, prop)?,
            AddKeyOp {
                frame,
                value: v,
                prop: &name,
            },
        )
    }
    pub fn remove_keyframe(
        &mut self,
        id: NodeId,
        prop: &PropPath,
        frame: Frame,
    ) -> Result<KeyframeData, ModelError> {
        visit_prop(self.pm(id, prop)?, RemoveKeyOp(frame))
    }
    pub fn restore_keyframe(
        &mut self,
        id: NodeId,
        prop: &PropPath,
        key: &KeyframeData,
    ) -> Result<(), ModelError> {
        let name = prop.as_string();
        visit_prop(self.pm(id, prop)?, RestoreKeyOp(key, &name))
    }
    pub fn move_keyframe(
        &mut self,
        id: NodeId,
        prop: &PropPath,
        from: Frame,
        to: Frame,
    ) -> Result<(), ModelError> {
        visit_prop(self.pm(id, prop)?, MoveKeyOp { from, to })
    }
    /// Returns previous easing (for undo).
    pub fn set_easing(
        &mut self,
        id: NodeId,
        prop: &PropPath,
        frame: Frame,
        i: Interpolation,
        o: EasingHandle,
        e: EasingHandle,
    ) -> Result<(Interpolation, EasingHandle, EasingHandle), ModelError> {
        visit_prop(self.pm(id, prop)?, SetEasingOp { frame, i, o, e })
    }

    pub fn property_is_animated(&self, id: NodeId, prop: &PropPath) -> bool {
        self.pr(id, prop)
            .map(|p| read_prop(p, IsAnimatedOp))
            .unwrap_or(false)
    }
    pub fn value_at(&self, id: NodeId, prop: &PropPath, frame: f64) -> Result<Value, ModelError> {
        Ok(read_prop(self.pr(id, prop)?, ValueAtOp(frame)))
    }
    pub fn get_static(&self, id: NodeId, prop: &PropPath) -> Result<Value, ModelError> {
        Ok(read_prop(self.pr(id, prop)?, GetStaticOp))
    }
    pub fn keyframe_data(&self, id: NodeId, prop: &PropPath, frame: Frame) -> Option<KeyframeData> {
        self.pr(id, prop)
            .ok()
            .and_then(|p| read_prop(p, GetKeyOp(frame)))
    }
    /// All keyframe frames on a property, sorted (empty if missing).
    pub fn key_frames(&self, id: NodeId, prop: &PropPath) -> Vec<Frame> {
        self.pr(id, prop)
            .map(|p| read_prop(p, KeyFramesOp))
            .unwrap_or_default()
    }
}

#[cfg(test)]
mod prop_support_tests {
    use super::{
        Animated, Color, Document, FillRule, ModifierKind, Node, NodeKind, ShapeKind, StyleKind,
        StylePaint, node_supports_opacity, node_supports_prop, node_supports_transform,
    };
    use glam::DVec2;

    fn shape_node() -> Node {
        Node::new(
            "Rect",
            NodeKind::Shape(ShapeKind::Rect {
                pos: Animated::new(DVec2::ZERO),
                size: Animated::new(DVec2::new(10.0, 10.0)),
                rounded: Animated::new(0.0),
            }),
        )
    }

    fn fill_node() -> Node {
        Node::new(
            "Fill",
            NodeKind::Style(StyleKind::Fill {
                paint: StylePaint::solid(Color::WHITE),
                rule: FillRule::NonZero,
            }),
        )
    }

    fn trim_node() -> Node {
        Node::new(
            "Trim",
            NodeKind::Modifier(ModifierKind::TrimPath {
                start: Animated::new(0.0),
                end: Animated::new(1.0),
                offset: Animated::new(0.0),
                mode: super::TrimMode::Individually,
            }),
        )
    }

    #[test]
    fn style_nodes_reject_transform_but_keep_opacity() {
        let fill = fill_node();
        assert!(!node_supports_transform(&fill.kind));
        assert!(node_supports_opacity(&fill.kind));
        assert!(!node_supports_prop(&fill.kind, "transform.position"));
        assert!(node_supports_prop(&fill.kind, "opacity"));
        assert!(fill.prop_ref(&super::PropPath::new("transform.position")).is_none());
    }

    #[test]
    fn modifier_nodes_reject_transform_but_keep_opacity() {
        let trim = trim_node();
        assert!(!node_supports_transform(&trim.kind));
        assert!(node_supports_prop(&trim.kind, "trim.start"));
        assert!(!node_supports_prop(&trim.kind, "transform.position"));
        // Opacity propagates to nested children via pass 3.
        assert!(node_supports_opacity(&trim.kind));
        assert!(node_supports_prop(&trim.kind, "opacity"));
    }

    #[test]
    fn geometric_nodes_keep_transform() {
        let text = Node::new(
            "T",
            NodeKind::Text(super::TextNode {
                text: "T".into(),
                size: Animated::new(48.0),
                align: super::TextAlign::Left,
                font: None,
                tracking: Animated::new(0.0),
                leading: Animated::new(0.0),
            }),
        );
        for mut node in [shape_node(), Node::new("G", NodeKind::Group), text] {
            assert!(node_supports_transform(&node.kind), "{}", node.name);
            assert!(
                node.prop_mut(&super::PropPath::new("transform.position"))
                    .is_some(),
                "{}",
                node.name
            );
        }
    }

    #[test]
    fn mask_rejects_opacity_but_keeps_transform() {
        let mask = Node::new(
            "Mask",
            NodeKind::Mask(super::MaskProps {
                shape: ShapeKind::Rect {
                    pos: Animated::new(DVec2::ZERO),
                    size: Animated::new(DVec2::new(10.0, 10.0)),
                    rounded: Animated::new(0.0),
                },
                inverted: false,
            }),
        );
        assert!(node_supports_transform(&mask.kind));
        assert!(!node_supports_opacity(&mask.kind));
        assert!(!node_supports_prop(&mask.kind, "opacity"));
    }

    #[test]
    fn hidden_style_emits_nothing() {
        let mut doc = Document::empty();
        let shape = doc.create_node(shape_node());
        let mut fill = fill_node();
        fill.visible = false;
        let fill_id = doc.create_node(fill);
        let group = doc.create_node(Node::new("G", NodeKind::Group));
        doc.attach(shape, super::Parent::Node(group), 0).unwrap();
        doc.attach(fill_id, super::Parent::Node(group), 1).unwrap();
        doc.attach(group, super::Parent::Comp(doc.main), 0).unwrap();
        let scene = super::evaluate(&doc, doc.main, 0.0);
        assert!(scene.items.is_empty());
    }
}

#[cfg(test)]
mod prop_path_compat_tests {
    use super::PropPath;

    #[test]
    fn legacy_tuple_struct_form_parses() {
        let p: PropPath =
            ron::from_str(r#"PropPath("transform.position")"#).expect("legacy form must parse");
        assert_eq!(p.as_str(), "transform.position");
    }

    #[test]
    fn current_paren_form_parses() {
        let ser = ron::to_string(&PropPath::new("transform.position")).unwrap();
        let p: PropPath = ron::from_str(&ser).expect("current form must roundtrip");
        assert_eq!(p.as_str(), "transform.position");
    }

    #[test]
    fn json_roundtrip() {
        let p = PropPath::new("opacity");
        let s = serde_json::to_string(&p).unwrap();
        let back: PropPath = serde_json::from_str(&s).unwrap();
        assert_eq!(back, p);
    }
}