refactor(engine): simplify asset and code generation helpers

crates/engine/src/assets/components.rs

@@ -33,7 +33,9 @@
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use figcraft_doc::*;
+use figcraft_doc::{
+    ChildLayout, ContentAlign, CrossAlign, DocError, Document, MainAlign, Node, NodeId, NodeKind, PropDef, Sizing, TextAutoResize, TextData,
+};
 use figcraft_geom::Affine;
 use serde_json::Value;
 

crates/engine/src/assets/components/diff.rs

@@ -1,5 +1,5 @@
 use super::instances::PROP_BINDING;
-use super::*;
+use super::{Document, Node, NodeId, NodeKind, PropDef, Sizing, TextAutoResize, TextData, inside_instance, owning_component, variant_set};
 
 /// The property groups whose value layer `n` takes from the same variables as its main layer
 /// `src` (they differ only where the two resolve in different variable modes).

crates/engine/src/assets/components/guard.rs

@@ -1,7 +1,10 @@
 use super::diff::geometry_derived;
 use super::rebase::rebase_instance;
 use super::variants::instance_issues;
-use super::*;
+use super::{
+    ContentAlign, CrossAlign, Document, MainAlign, Node, NodeId, NodeKind, SLOT, Sizing, enclosing_instance, inside_instance, is_instance,
+    owning_instance, structure_locked,
+};
 
 /// Slot `slot` (inside an instance) takes the instance's own content: the layers it shows (the
 /// main's default content until now) stop mirroring the main, and instances among them stand

crates/engine/src/assets/components/instances.rs

@@ -1,6 +1,9 @@
 use super::diff::{binding_group, bindings_of};
 use super::sync::{insert_linked, sync_instance_depth};
-use super::*;
+use super::{
+    Affine, BTreeMap, ChildLayout, DocError, Document, Node, NodeId, NodeKind, Value, default_instance_name, default_props, holds_content, is_slot,
+    slot_edited,
+};
 
 /// Create an instance of `component` under `parent` at `(x, y)` (parent space).
 pub fn create_instance(doc: &mut Document, component: NodeId, parent: NodeId, x: f64, y: f64) -> Result<NodeId, DocError> {

crates/engine/src/assets/components/patch.rs

@@ -2,7 +2,12 @@ use super::diff::{binding_group, bindings_of, diff_groups, follow_boolean_defaul
 use super::guard::{own_slot_content, relink_copy};
 use super::instances::{copy_group, field_group, sync_instance};
 use super::sync::insert_linked;
-use super::*;
+use super::{
+    BTreeMap, BTreeSet, Document, MAX_DEPTH, Node, NodeId, NodeKind, default_instance_name, holds_content, inside_instance, owning_component,
+    owning_instance, root_instance, scope, slot_edited, slot_scope,
+};
+
+type OverrideGroups = (Vec<&'static str>, Vec<&'static str>, Vec<&'static str>);
 
 /// After an edit: record overrides inside instances, then rebuild instances whose main changed,
 /// whose properties or main were switched, or whose overrides were reset.
@@ -14,93 +19,9 @@ pub fn sync_after_edit(doc: &mut Document, before: &Document, changed: &[NodeId]
         }
     }
     let changed = changed.as_slice();
-    // 0. A slot whose layers were added, removed or reordered holds the instance's own content
-    //    from now on; copies of instance layers placed elsewhere stop mirroring their main.
-    for &id in changed {
-        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
-        if n.children == b.children || owning_instance(doc, id).is_none() {
-            continue;
-        }
-        if let Some(slot) = slot_scope(doc, id)
-            && !slot_edited(doc, slot)
-        {
-            own_slot_content(doc, slot);
-        }
-    }
-    for &id in changed {
-        if !before.contains(id) {
-            relink_copy(doc, id);
-        }
-    }
+    adopt_slot_content(doc, before, changed);
     let mut resync: BTreeSet<NodeId> = BTreeSet::new();
-    // 1. Overrides for layers edited inside instances.
-    for &id in changed {
-        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
-        let Some(inst) = owning_instance(doc, id) else { continue };
-        let top_root = inst == id && !inside_instance(doc, id);
-        if top_root
-            && let (NodeKind::Instance { component: c1, props: p1 }, NodeKind::Instance { component: c2, props: p2 }) = (&n.kind, &b.kind)
-            && (c1 != c2 || p1 != p2)
-        {
-            // Switching the main or a property value of an instance isn't an override.
-            resync.insert(id);
-        }
-        let raw = diff_groups(b, n);
-        let mut groups = raw.clone();
-        // An instance's own place, resizing, export settings, interactions and variable modes are
-        // its own, not overrides.
-        if top_root {
-            groups.retain(|g| !matches!(*g, "component" | "props" | "position" | "resizing" | "exports" | "interactions" | "modes"));
-        }
-        if groups.iter().any(|g| matches!(*g, "size" | "position")) {
-            groups.retain(|g| !matches!(*g, "size" | "position") || !geometry_derived(doc, before, id, g));
-        }
-        // A value equal to the main's isn't an override (setting it back clears the override).
-        let mut cleared = Vec::new();
-        if let Some(src) = n.source.and_then(|s| doc.node(s)) {
-            let mut differs = diff_groups(src, n);
-            if inst == id {
-                differs.retain(|g| *g != "name");
-                if n.name != default_instance_name(doc, src.id) {
-                    differs.push("name");
-                }
-            }
-            // A value from the same variable as the main's (resolved in this layer's modes) isn't an
-            // override either.
-            let from_variables = variable_groups(n, src);
-            groups.retain(|g| differs.contains(g) && !from_variables.contains(g));
-            // Binding another variable (or none) where the main binds one is an override.
-            for (k, _) in b.bound.iter().chain(n.bound.iter()) {
-                let Some(g) = binding_group(k) else { continue };
-                let rebound = b.bound.get(k) != n.bound.get(k) && !bindings_of(n, g).eq(bindings_of(src, g));
-                if rebound && !groups.contains(&g) {
-                    groups.push(g);
-                }
-            }
-            cleared =
-                raw.iter().filter(|g| !matches!(**g, "size" | "position") && !differs.contains(g) && n.overrides.contains(**g)).copied().collect();
-            if top_root {
-                cleared.retain(|g| !matches!(*g, "component" | "props"));
-            }
-        }
-        let lost = b.overrides.iter().any(|g| !n.overrides.contains(g));
-        let nested_switch = !top_root && raw.iter().any(|g| matches!(*g, "component" | "props"));
-        if (!groups.is_empty() || !cleared.is_empty())
-            && let Some(m) = doc.node_mut(id)
-        {
-            for g in groups {
-                m.overrides.insert(g.to_string());
-            }
-            for g in cleared {
-                m.overrides.remove(g);
-            }
-        }
-        if (lost || nested_switch)
-            && let Some(r) = root_instance(doc, id)
-        {
-            resync.insert(r);
-        }
-    }
+    record_overrides(doc, before, changed, &mut resync);
     // 2. Components whose layers changed, were added or removed. Value-only edits (paint, text,
     //    visibility, …) are carried to the copies directly; anything else rebuilds the instances.
     let mut comps: BTreeSet<NodeId> = BTreeSet::new();
@@ -172,6 +93,105 @@ pub fn sync_after_edit(doc: &mut Document, before: &Document, changed: &[NodeId]
     rebuild_instances(doc, &comps);
 }
 
+/// Slot content changes: layers added, removed or reordered in a slot become the instance's own.
+fn adopt_slot_content(doc: &mut Document, before: &Document, changed: &[NodeId]) {
+    // 0. A slot whose layers were added, removed or reordered holds the instance's own content
+    //    from now on; copies of instance layers placed elsewhere stop mirroring their main.
+    for &id in changed {
+        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
+        if n.children == b.children || owning_instance(doc, id).is_none() {
+            continue;
+        }
+        if let Some(slot) = slot_scope(doc, id)
+            && !slot_edited(doc, slot)
+        {
+            own_slot_content(doc, slot);
+        }
+    }
+    for &id in changed {
+        if !before.contains(id) {
+            relink_copy(doc, id);
+        }
+    }
+}
+
+/// Overrides for layers edited inside instances; the instances to rebuild go into `resync`.
+fn record_overrides(doc: &mut Document, before: &Document, changed: &[NodeId], resync: &mut BTreeSet<NodeId>) {
+    for &id in changed {
+        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
+        let Some(inst) = owning_instance(doc, id) else { continue };
+        let top_root = inst == id && !inside_instance(doc, id);
+        if top_root
+            && let (NodeKind::Instance { component: c1, props: p1 }, NodeKind::Instance { component: c2, props: p2 }) = (&n.kind, &b.kind)
+            && (c1 != c2 || p1 != p2)
+        {
+            // Switching the main or a property value of an instance isn't an override.
+            resync.insert(id);
+        }
+        let (raw, groups, cleared) = override_groups(doc, before, id, n, b, inst, top_root);
+        let lost = b.overrides.iter().any(|g| !n.overrides.contains(g));
+        let nested_switch = !top_root && raw.iter().any(|g| matches!(*g, "component" | "props"));
+        if (!groups.is_empty() || !cleared.is_empty())
+            && let Some(m) = doc.node_mut(id)
+        {
+            for g in groups {
+                m.overrides.insert(g.to_string());
+            }
+            for g in cleared {
+                m.overrides.remove(g);
+            }
+        }
+        if (lost || nested_switch)
+            && let Some(r) = root_instance(doc, id)
+        {
+            resync.insert(r);
+        }
+    }
+}
+
+/// `(raw, groups, cleared)` of layer `id` edited from `b` to `n`: the raw changed groups, the ones
+/// that are now overrides and the overrides that were set back to the main's value.
+fn override_groups(doc: &Document, before: &Document, id: NodeId, n: &Node, b: &Node, inst: NodeId, top_root: bool) -> OverrideGroups {
+    let raw = diff_groups(b, n);
+    let mut groups = raw.clone();
+    // An instance's own place, resizing, export settings, interactions and variable modes are
+    // its own, not overrides.
+    if top_root {
+        groups.retain(|g| !matches!(*g, "component" | "props" | "position" | "resizing" | "exports" | "interactions" | "modes"));
+    }
+    if groups.iter().any(|g| matches!(*g, "size" | "position")) {
+        groups.retain(|g| !matches!(*g, "size" | "position") || !geometry_derived(doc, before, id, g));
+    }
+    // A value equal to the main's isn't an override (setting it back clears the override).
+    let mut cleared = Vec::new();
+    if let Some(src) = n.source.and_then(|s| doc.node(s)) {
+        let mut differs = diff_groups(src, n);
+        if inst == id {
+            differs.retain(|g| *g != "name");
+            if n.name != default_instance_name(doc, src.id) {
+                differs.push("name");
+            }
+        }
+        // A value from the same variable as the main's (resolved in this layer's modes) isn't an
+        // override either.
+        let from_variables = variable_groups(n, src);
+        groups.retain(|g| differs.contains(g) && !from_variables.contains(g));
+        // Binding another variable (or none) where the main binds one is an override.
+        for (k, _) in b.bound.iter().chain(n.bound.iter()) {
+            let Some(g) = binding_group(k) else { continue };
+            let rebound = b.bound.get(k) != n.bound.get(k) && !bindings_of(n, g).eq(bindings_of(src, g));
+            if rebound && !groups.contains(&g) {
+                groups.push(g);
+            }
+        }
+        cleared = raw.iter().filter(|g| !matches!(**g, "size" | "position") && !differs.contains(g) && n.overrides.contains(**g)).copied().collect();
+        if top_root {
+            cleared.retain(|g| !matches!(*g, "component" | "props"));
+        }
+    }
+    (raw, groups, cleared)
+}
+
 #[cfg(test)]
 thread_local! {
     /// Tests: rebuild instances even for edits that could be patched (to compare both ways).

crates/engine/src/assets/components/rebase.rs

@@ -1,6 +1,6 @@
 use super::diff::{diff_groups, variable_groups};
 use super::instances::{field_group, path_map};
-use super::*;
+use super::{BTreeMap, BTreeSet, Document, MAX_DEPTH, Node, NodeId, NodeKind, default_instance_name, holds_content};
 
 /// Bounded source and parent lookups while a rebase reads an unchanged document.
 pub(super) struct RebaseSources<'a> {

crates/engine/src/assets/components/sync.rs

@@ -1,6 +1,9 @@
 use super::diff::diff_groups;
 use super::instances::{Carry, apply_prop, carry_overrides, carry_prop_bindings, copy_group, field_group, follow_variant_resizing, path_map};
-use super::*;
+use super::{
+    Affine, BTreeMap, BTreeSet, DocError, Document, MAX_DEPTH, Node, NodeId, NodeKind, SLOT, Sizing, Value, default_instance_name, default_props,
+    holds_content, inside_instance, is_slot, owning_component, variant_set,
+};
 
 /// `spare`: layers the outer rebuild didn't reuse that were below `inst` (a swapped nested
 /// instance): its layers the outer main doesn't have, matched here so they keep ids and overrides.
@@ -16,31 +19,10 @@ pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize
         // A missing main, or an instance inside its own main (would recurse forever).
         return;
     }
-    let mut eff_props = default_props(&comp);
-    for (k, v) in root_props {
-        if eff_props.contains_key(k) {
-            eff_props.insert(k.clone(), v.clone());
-        }
-    }
+    let eff_props = effective_props(&comp, root_props);
     // Old layers (kept alive for their overrides), by (parent, source), by source alone (when only
     // one layer mirrors it) and, only when those don't match, by name path.
-    let mut old_ids = old_layers(doc, inst);
-    old_ids.extend(spare.keys().copied());
-    old_ids.sort();
-    old_ids.dedup();
-    let mut old: BTreeMap<NodeId, std::sync::Arc<Node>> = spare;
-    let mut by_source: BTreeMap<(NodeId, NodeId), NodeId> = BTreeMap::new();
-    let mut by_src: BTreeMap<NodeId, Option<NodeId>> = BTreeMap::new();
-    for i in &old_ids {
-        let Some(n) = doc.node_arc(*i).or_else(|| old.get(i)).cloned() else { continue };
-        if let Some(s) = n.source {
-            if let Some(p) = n.parent {
-                by_source.entry((p, s)).or_insert(*i);
-            }
-            by_src.entry(s).and_modify(|e| *e = None).or_insert(Some(*i));
-        }
-        old.insert(*i, n);
-    }
+    let (mut old, by_source, by_src) = index_old_layers(doc, inst, spare);
     let mut by_path: Option<BTreeMap<String, NodeId>> = None;
     let mut main_paths: Option<BTreeMap<NodeId, String>> = None;
     // Ids for the copies: reuse the matching old layer's id (a layer the main moved to another
@@ -124,23 +106,7 @@ pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize
         // Component properties: the main layer's bindings use this instance's values; layers of
         // nested instances use the nested instance's values (one level per source hop).
         let enc = enclosing.get(&parent).cloned().unwrap_or_default();
-        let mut chain: Vec<&Node> = vec![orig];
-        while chain.len() < enc.len() {
-            let Some(next) = chain.last().and_then(|c| c.source).and_then(|x| doc.node(x)) else { break };
-            chain.push(next);
-        }
-        for (j, level) in chain.iter().enumerate().rev() {
-            let Some(props) = enc.get(j).and_then(|e| inst_props.get(e)) else { continue };
-            for (field, prop) in &level.prop_refs {
-                let g = field_group(field);
-                if n.overrides.contains(g) || (j > 0 && orig.overrides.contains(g)) {
-                    continue;
-                }
-                if let Some(val) = props.get(prop) {
-                    apply_prop(doc, &mut n, field, val);
-                }
-            }
-        }
+        apply_enclosing_props(doc, &mut n, orig, &enc, &inst_props);
         if let NodeKind::Instance { component: c, props } = &n.kind {
             inst_props.insert(nid, props.clone());
             let mut e = enc;
@@ -167,6 +133,155 @@ pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize
             p.children.retain(|c| *c != id);
         }
     }
+    let fresh = fresh_root(doc, &mut root, &comp, inst, component, &map);
+    if let Some(r) = doc.node_mut(inst) {
+        *r = fresh;
+    }
+    // A resized instance: children follow their constraints (auto layout re-flows later).
+    let (iw, ih) = doc.node(inst).map(|n| (n.width, n.height)).unwrap_or((comp.width, comp.height));
+    if (iw - comp.width).abs() > 1e-9 || (ih - comp.height).abs() > 1e-9 {
+        figcraft_layout::apply_constraints(doc, inst, comp.width, comp.height);
+        remeasure = map.values().copied().collect();
+    }
+    follow_geometry_overrides(doc, &src, &map, &old, &mut remeasure);
+    remeasure_text(doc, remeasure);
+    rebuild_nested(doc, nested, &old, &used, depth);
+}
+
+/// Geometry overrides of children win over constraints.
+fn follow_geometry_overrides(
+    doc: &mut Document,
+    src: &[NodeId],
+    map: &BTreeMap<NodeId, NodeId>,
+    old: &BTreeMap<NodeId, std::sync::Arc<Node>>,
+    remeasure: &mut Vec<NodeId>,
+) {
+    for s in src {
+        let Some(nid) = map.get(s).copied() else { continue };
+        let Some(o) = old.get(&nid) else { continue };
+        // A frame that kept the size its own resizing gave it: its layers (copied at their main
+        // layers' places) follow their constraints from its main layer's size.
+        if o.overrides.contains("resizing")
+            && !o.overrides.contains("size")
+            && doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none())
+            && let Some((mw, mh)) = doc.node(*s).map(|m| (m.width, m.height))
+        {
+            figcraft_layout::apply_constraints(doc, nid, mw, mh);
+        }
+        if !o.overrides.contains("size") && !o.overrides.contains("position") {
+            continue;
+        }
+        remeasure.push(nid);
+        let Some((ow, oh)) = doc.node(nid).map(|n| (n.width, n.height)) else { continue };
+        if o.overrides.contains("size") {
+            // Through set_size so vector networks scale with the box.
+            figcraft_layout::set_size(doc, nid, o.width, o.height);
+            if doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none()) {
+                figcraft_layout::apply_constraints(doc, nid, ow, oh);
+            }
+        }
+        if let Some(n) = doc.node_mut(nid) {
+            carry_overrides(o, n, Carry::Geometry);
+        }
+    }
+}
+
+/// Nested instances showing another main than the main's copy (swapped): rebuild from it,
+/// with the old layers below them this rebuild didn't reuse.
+fn rebuild_nested(doc: &mut Document, nested: Vec<NodeId>, old: &BTreeMap<NodeId, std::sync::Arc<Node>>, used: &BTreeSet<NodeId>, depth: usize) {
+    let unused: BTreeMap<NodeId, std::sync::Arc<Node>> =
+        old.iter().filter(|(i, _)| !used.contains(*i) && !doc.contains(**i)).map(|(i, x)| (*i, x.clone())).collect();
+    for n in nested {
+        let mut below: BTreeMap<NodeId, std::sync::Arc<Node>> = unused
+            .iter()
+            .filter(|(_, x)| {
+                let mut cur = x.parent;
+                for _ in 0..=MAX_DEPTH * 4 {
+                    match cur {
+                        Some(p) if p == n => return true,
+                        Some(p) => cur = unused.get(&p).and_then(|a| a.parent),
+                        None => return false,
+                    }
+                }
+                false
+            })
+            .map(|(i, x)| (*i, x.clone()))
+            .collect();
+        take_placing_overrides(doc, n, old, &mut below);
+        sync_instance_depth(doc, n, depth + 1, below);
+    }
+}
+
+fn apply_enclosing_props(doc: &Document, n: &mut Node, orig: &Node, enc: &[NodeId], inst_props: &BTreeMap<NodeId, BTreeMap<String, Value>>) {
+    let mut chain: Vec<&Node> = vec![orig];
+    while chain.len() < enc.len() {
+        let Some(next) = chain.last().and_then(|c| c.source).and_then(|x| doc.node(x)) else { break };
+        chain.push(next);
+    }
+    for (j, level) in chain.iter().enumerate().rev() {
+        let Some(props) = enc.get(j).and_then(|e| inst_props.get(e)) else { continue };
+        for (field, prop) in &level.prop_refs {
+            let g = field_group(field);
+            if n.overrides.contains(g) || (j > 0 && orig.overrides.contains(g)) {
+                continue;
+            }
+            if let Some(val) = props.get(prop) {
+                apply_prop(doc, n, field, val);
+            }
+        }
+    }
+}
+
+/// Text whose characters or style differ from the main re-measures.
+fn remeasure_text(doc: &mut Document, remeasure: Vec<NodeId>) {
+    for nid in remeasure {
+        if let Some(n) = doc.node(nid)
+            && let Some((w, h)) = figcraft_text::auto_size(n)
+            && ((w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
+        {
+            figcraft_layout::set_size(doc, nid, w, h);
+        }
+    }
+}
+
+/// The component's property defaults with the instance's values for the ones it has.
+fn effective_props(comp: &Node, root_props: &BTreeMap<String, Value>) -> BTreeMap<String, Value> {
+    let mut eff_props = default_props(comp);
+    for (k, v) in root_props {
+        if eff_props.contains_key(k) {
+            eff_props.insert(k.clone(), v.clone());
+        }
+    }
+    eff_props
+}
+
+type OldIndex = (BTreeMap<NodeId, std::sync::Arc<Node>>, BTreeMap<(NodeId, NodeId), NodeId>, BTreeMap<NodeId, Option<NodeId>>);
+
+/// The old layers of `inst` (and `spare`) by id, by (parent, source) and by source alone (`None`
+/// when several layers mirror it).
+fn index_old_layers(doc: &Document, inst: NodeId, spare: BTreeMap<NodeId, std::sync::Arc<Node>>) -> OldIndex {
+    let mut old_ids = old_layers(doc, inst);
+    old_ids.extend(spare.keys().copied());
+    old_ids.sort();
+    old_ids.dedup();
+    let mut old = spare;
+    let mut by_source: BTreeMap<(NodeId, NodeId), NodeId> = BTreeMap::new();
+    let mut by_src: BTreeMap<NodeId, Option<NodeId>> = BTreeMap::new();
+    for i in &old_ids {
+        let Some(n) = doc.node_arc(*i).or_else(|| old.get(i)).cloned() else { continue };
+        if let Some(s) = n.source {
+            if let Some(p) = n.parent {
+                by_source.entry((p, s)).or_insert(*i);
+            }
+            by_src.entry(s).and_modify(|e| *e = None).or_insert(Some(*i));
+        }
+        old.insert(*i, n);
+    }
+    (old, by_source, by_src)
+}
+
+/// The rebuilt root of instance `inst` of `comp`.
+fn fresh_root(doc: &Document, root: &mut Node, comp: &Node, inst: NodeId, component: NodeId, map: &BTreeMap<NodeId, NodeId>) -> Node {
     // Root: follows the main except its own placement, name, size and overrides.
     let order: Vec<NodeId> = comp.children.iter().filter_map(|c| map.get(c).copied()).filter(|c| doc.contains(*c)).collect();
     let mut fresh = comp.clone();
@@ -175,7 +290,7 @@ pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize
     fresh.children = order;
     fresh.transform = root.transform;
     fresh.kind = root.kind.clone();
-    carry_prop_bindings(&root, &mut fresh);
+    carry_prop_bindings(root, &mut fresh);
     // A nested instance keeps mirroring its layer of the outer main.
     let nested_copy = inside_instance(doc, inst);
     fresh.source = if nested_copy { root.source } else { Some(component) };
@@ -212,81 +327,12 @@ pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize
     fresh.name = if renamed { root.name.clone() } else { default_instance_name(doc, component) };
     // Switched to another variant: its own overrides stay where both variants agreed.
     if let Some(prev) = root.source.and_then(|p| doc.node(p)).filter(|p| sibling_variants(doc, p.id, component)) {
-        let differs = diff_groups(prev, &comp);
+        let differs = diff_groups(prev, comp);
         root.overrides.retain(|g| g == "name" || !differs.contains(&g.as_str()));
         follow_variant_resizing(&mut fresh.child_layout, &prev.child_layout, &comp.child_layout);
     }
-    carry_overrides(&root, &mut fresh, Carry::Root);
-    if let Some(r) = doc.node_mut(inst) {
-        *r = fresh;
-    }
-    // A resized instance: children follow their constraints (auto layout re-flows later).
-    let (iw, ih) = doc.node(inst).map(|n| (n.width, n.height)).unwrap_or((comp.width, comp.height));
-    if (iw - comp.width).abs() > 1e-9 || (ih - comp.height).abs() > 1e-9 {
-        figcraft_layout::apply_constraints(doc, inst, comp.width, comp.height);
-        remeasure = map.values().copied().collect();
-    }
-    // Geometry overrides of children win over constraints.
-    for s in &src {
-        let Some(nid) = map.get(s).copied() else { continue };
-        let Some(o) = old.get(&nid) else { continue };
-        // A frame that kept the size its own resizing gave it: its layers (copied at their main
-        // layers' places) follow their constraints from its main layer's size.
-        if o.overrides.contains("resizing")
-            && !o.overrides.contains("size")
-            && doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none())
-            && let Some((mw, mh)) = doc.node(*s).map(|m| (m.width, m.height))
-        {
-            figcraft_layout::apply_constraints(doc, nid, mw, mh);
-        }
-        if !o.overrides.contains("size") && !o.overrides.contains("position") {
-            continue;
-        }
-        remeasure.push(nid);
-        let Some((ow, oh)) = doc.node(nid).map(|n| (n.width, n.height)) else { continue };
-        if o.overrides.contains("size") {
-            // Through set_size so vector networks scale with the box.
-            figcraft_layout::set_size(doc, nid, o.width, o.height);
-            if doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none()) {
-                figcraft_layout::apply_constraints(doc, nid, ow, oh);
-            }
-        }
-        if let Some(n) = doc.node_mut(nid) {
-            carry_overrides(o, n, Carry::Geometry);
-        }
-    }
-    // Text whose characters or style differ from the main re-measures.
-    for nid in remeasure {
-        if let Some(n) = doc.node(nid)
-            && let Some((w, h)) = figcraft_text::auto_size(n)
-            && ((w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
-        {
-            figcraft_layout::set_size(doc, nid, w, h);
-        }
-    }
-    // Nested instances showing another main than the main's copy (swapped): rebuild from it,
-    // with the old layers below them this rebuild didn't reuse.
-    let unused: BTreeMap<NodeId, std::sync::Arc<Node>> =
-        old.iter().filter(|(i, _)| !used.contains(*i) && !doc.contains(**i)).map(|(i, x)| (*i, x.clone())).collect();
-    for n in nested {
-        let mut below: BTreeMap<NodeId, std::sync::Arc<Node>> = unused
-            .iter()
-            .filter(|(_, x)| {
-                let mut cur = x.parent;
-                for _ in 0..=MAX_DEPTH * 4 {
-                    match cur {
-                        Some(p) if p == n => return true,
-                        Some(p) => cur = unused.get(&p).and_then(|a| a.parent),
-                        None => return false,
-                    }
-                }
-                false
-            })
-            .map(|(i, x)| (*i, x.clone()))
-            .collect();
-        take_placing_overrides(doc, n, &old, &mut below);
-        sync_instance_depth(doc, n, depth + 1, below);
-    }
+    carry_overrides(root, &mut fresh, Carry::Root);
+    fresh
 }
 
 /// Before swapped nested instance `n` is rebuilt from its new main: each of its old layers (the

crates/engine/src/assets/components/tests.rs

@@ -383,6 +383,22 @@ fn resized_instances_follow_constraints_and_auto_layout() {
     healthy(&s);
 }
 
+/// The tail of `component_properties_apply_to_instances`: unbind, delete, then a variant property.
+fn unbind_delete_and_vary(s: &mut Session, c: NodeId, i: NodeId, title: NodeId, dot: NodeId) {
+    // Unbind and delete.
+    ex(s, "component.bindProperty", json!({"layer": dot, "property": null, "field": "visible"}));
+    assert!(node(s, copy_of(s, i, dot)).visible);
+    ex(s, "component.deleteProperty", json!({"id": c, "name": "Heading"}));
+    assert!(node(s, title).prop_refs.is_empty());
+    assert!(matches!(&node(s, i).kind, NodeKind::Instance { props, .. } if !props.contains_key("Heading")));
+    let desc = ex(s, "component.properties", json!({"id": i}));
+    assert_eq!(desc["properties"].as_array().unwrap().len(), 1);
+    // A variant property on a lone component makes it a component set.
+    let set = idv(&ex(s, "component.addProperty", json!({"id": c, "name": "Theme", "type": "variant", "default": "Light"})));
+    assert!(matches!(node(s, set).kind, NodeKind::ComponentSet { .. }));
+    assert_eq!(node(s, c).name, "Theme=Light");
+}
+
 #[test]
 fn component_properties_apply_to_instances() {
     let mut s = Session::new();
@@ -414,18 +430,7 @@ fn component_properties_apply_to_instances() {
     assert!(s.execute("component.bindProperty", &json!({"layer": dot, "property": "Heading"})).is_err());
     assert!(s.execute("component.bindProperty", &json!({"layer": ititle, "property": "Heading"})).is_err());
     assert!(s.execute("component.addProperty", &json!({"id": c, "name": "Heading", "type": "text"})).is_err());
-    // Unbind and delete.
-    ex(&mut s, "component.bindProperty", json!({"layer": dot, "property": null, "field": "visible"}));
-    assert!(node(&s, copy_of(&s, i, dot)).visible);
-    ex(&mut s, "component.deleteProperty", json!({"id": c, "name": "Heading"}));
-    assert!(node(&s, title).prop_refs.is_empty());
-    assert!(matches!(&node(&s, i).kind, NodeKind::Instance { props, .. } if !props.contains_key("Heading")));
-    let desc = ex(&mut s, "component.properties", json!({"id": i}));
-    assert_eq!(desc["properties"].as_array().unwrap().len(), 1);
-    // A variant property on a lone component makes it a component set.
-    let set = idv(&ex(&mut s, "component.addProperty", json!({"id": c, "name": "Theme", "type": "variant", "default": "Light"})));
-    assert!(matches!(node(&s, set).kind, NodeKind::ComponentSet { .. }));
-    assert_eq!(node(&s, c).name, "Theme=Light");
+    unbind_delete_and_vary(&mut s, c, i, title, dot);
     healthy(&s);
 }
 

crates/engine/src/assets/components/variants.rs

@@ -1,4 +1,4 @@
-use super::*;
+use super::{BTreeMap, Document, MAX_DEPTH, Node, NodeId, NodeKind, holds_content, inside_instance};
 
 /// A set's default variant: the one in its top-left corner (nearest to it, then the top-most, then
 /// the left-most).

crates/engine/src/assets/library.rs

@@ -15,7 +15,11 @@ use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::sync::Arc;
 
 use figcraft_doc::proto::Action;
-use figcraft_doc::*;
+use figcraft_doc::{
+    Collection, CollectionId, Document, ImportedComponent, ImportedRecord, ImportedStyle, LibraryAsset, LibraryCollection, LibraryLink,
+    LibraryManifest, LibraryStyle, LibraryVariable, Node, NodeId, NodeKind, PropDef, PublishedLibrary, Style, StyleKind, Variable, VariableId,
+    VariableValue, Variables, node_images, paint_images, used_images,
+};
 use serde_json::Value;
 
 use crate::components::inside_instance;

crates/engine/src/assets/library/tests.rs

@@ -107,6 +107,49 @@ fn publish_to(s: &mut Session, path: &str) -> String {
     r["id"].as_str().unwrap().to_string()
 }
 
+/// `publish_manifest_roundtrip`: the file saved and read back keeps the manifest.
+fn saved_and_read_back(doc: &Document, lib: &PublishedLibrary) {
+    let m = &lib.manifest;
+    // Saved and read back: the author's file and a reader of the library see the same manifest.
+    let bytes = figcraft_format::save_bytes(doc, None).unwrap();
+    let (back, issues) = figcraft_format::load_bytes(&bytes).unwrap();
+    assert!(issues.is_empty(), "{issues:?}");
+    assert_eq!(back.published.as_ref().map(|p| &p.manifest), Some(m));
+    let read = figcraft_format::read_library(std::io::Cursor::new(&bytes)).unwrap().unwrap();
+    assert_eq!(read.manifest, *m);
+    assert_eq!(read.doc.node_count(), lib.doc.node_count());
+    // Older files and files never published have no library; readers that don't know libraries
+    // are unaffected (the entries are extra archive members).
+    let plain = figcraft_format::save_bytes(&Document::new("x"), None).unwrap();
+    assert!(figcraft_format::read_library(std::io::Cursor::new(&plain)).unwrap().is_none());
+    assert!(figcraft_format::load_bytes(&plain).unwrap().0.published.is_none());
+}
+
+/// `publish_manifest_roundtrip`: a republish bumps only what changed.
+fn republish_bumps_touched(s: &mut Session, k: &Kit) {
+    // Nothing changed: refused. A change bumps only what it touches (and what uses it).
+    let e = s.execute("library.publish", &json!({})).unwrap_err();
+    assert!(e.to_string().contains("no changes"), "{e}");
+    ex(s, "node.set", json!({"id": k.card, "props": {"fill": "#eeeeee"}}));
+    let r = ex(s, "library.publish", json!({}));
+    assert_eq!(r["version"], 2);
+    let m = s.doc().unwrap().published.clone().unwrap().manifest.clone();
+    assert_eq!(m.component(k.card).map(|a| a.version), Some(2));
+    assert_eq!(m.component(k.button).map(|a| a.version), Some(1), "untouched assets keep their version");
+    assert_eq!(m.description, "Our kit", "the description carries over");
+    // Excluding an asset; a used component still comes along (not offered).
+    let r = ex(s, "library.publish", json!({"exclude": ["Button"]}));
+    assert_eq!(r["components"], 1);
+    let m = s.doc().unwrap().published.clone().unwrap().manifest.clone();
+    assert!(m.component(k.button).is_some_and(|a| !a.published));
+    // Unknown assets are an error, not ignored.
+    assert!(s.execute("library.publish", &json!({"include": ["Nope"]})).is_err());
+    assert!(s.execute("library.publish", &json!({"include": "Button"})).is_err());
+    // Undo takes the publish back.
+    s.undo().unwrap();
+    assert_eq!(s.doc().unwrap().published.as_ref().map(|p| p.manifest.version), Some(2));
+}
+
 #[test]
 fn publish_manifest_roundtrip() {
     let mut s = Session::new();
@@ -126,41 +169,74 @@ fn publish_manifest_roundtrip() {
     assert!(lib.doc.node(k.label).is_some());
     assert!(lib.doc.validate().is_empty());
     assert_eq!(lib.doc.styles.len(), 1);
-    // Saved and read back: the author's file and a reader of the library see the same manifest.
-    let bytes = figcraft_format::save_bytes(doc, None).unwrap();
-    let (back, issues) = figcraft_format::load_bytes(&bytes).unwrap();
-    assert!(issues.is_empty(), "{issues:?}");
-    assert_eq!(back.published.as_ref().map(|p| &p.manifest), Some(m));
-    let read = figcraft_format::read_library(std::io::Cursor::new(&bytes)).unwrap().unwrap();
-    assert_eq!(read.manifest, *m);
-    assert_eq!(read.doc.node_count(), lib.doc.node_count());
-    // Older files and files never published have no library; readers that don't know libraries
-    // are unaffected (the entries are extra archive members).
-    let plain = figcraft_format::save_bytes(&Document::new("x"), None).unwrap();
-    assert!(figcraft_format::read_library(std::io::Cursor::new(&plain)).unwrap().is_none());
-    assert!(figcraft_format::load_bytes(&plain).unwrap().0.published.is_none());
+    saved_and_read_back(doc, &lib);
 
-    // Nothing changed: refused. A change bumps only what it touches (and what uses it).
-    let e = s.execute("library.publish", &json!({})).unwrap_err();
-    assert!(e.to_string().contains("no changes"), "{e}");
-    ex(&mut s, "node.set", json!({"id": k.card, "props": {"fill": "#eeeeee"}}));
-    let r = ex(&mut s, "library.publish", json!({}));
-    assert_eq!(r["version"], 2);
-    let m = s.doc().unwrap().published.clone().unwrap().manifest.clone();
-    assert_eq!(m.component(k.card).map(|a| a.version), Some(2));
-    assert_eq!(m.component(k.button).map(|a| a.version), Some(1), "untouched assets keep their version");
-    assert_eq!(m.description, "Our kit", "the description carries over");
-    // Excluding an asset; a used component still comes along (not offered).
-    let r = ex(&mut s, "library.publish", json!({"exclude": ["Button"]}));
-    assert_eq!(r["components"], 1);
-    let m = s.doc().unwrap().published.clone().unwrap().manifest.clone();
-    assert!(m.component(k.button).is_some_and(|a| !a.published));
-    // Unknown assets are an error, not ignored.
-    assert!(s.execute("library.publish", &json!({"include": ["Nope"]})).is_err());
-    assert!(s.execute("library.publish", &json!({"include": "Button"})).is_err());
-    // Undo takes the publish back.
-    s.undo().unwrap();
-    assert_eq!(s.doc().unwrap().published.as_ref().map(|p| p.manifest.version), Some(2));
+    republish_bumps_touched(&mut s, &k);
+}
+
+/// `add_place_and_update_keep_overrides`: library copies refuse every edit and roll back.
+fn assert_remote_read_only(s: &mut Session, b: NodeId, remote_button: NodeId) {
+    let unchanged = s.doc().unwrap().clone();
+    let e = s.execute("node.set", &json!({"id": remote_button, "props": {"fill": "#ff0000"}})).unwrap_err();
+    assert!(e.to_string().contains("can't be edited"), "{e}");
+    assert_eq!(s.doc().unwrap(), &unchanged, "a refused remote edit rolls back");
+    for (cmd, args) in
+        [("node.reparent", json!({"ids": [remote_button], "parent": s.page().unwrap()})), ("edit.delete", json!({"ids": [remote_button]}))]
+    {
+        assert!(s.execute(cmd, &args).is_err(), "{cmd} must preserve read-only copies");
+        assert_eq!(s.doc().unwrap(), &unchanged, "refused {cmd} rolls back");
+    }
+    let style = s.doc().unwrap().styles[0].id.clone();
+    assert!(s.execute("style.update", &json!({"style": style, "name": "Mine"})).is_err());
+    assert!(s.execute("style.delete", &json!({"style": style})).is_err());
+    let e = s.execute("component.goToMain", &json!({"id": b})).unwrap_err();
+    assert!(e.to_string().contains("library"), "{e}");
+    assert!(s.execute("select.set", &json!({"ids": [remote_button]})).is_err(), "library copies can't be selected");
+    assert!(s.doc().unwrap().pages.contains(&s.page().unwrap()));
+    assert!(s.execute("component.pushChanges", &json!({"id": b})).is_err());
+    assert_eq!(fill(s, remote_button), "0000FF");
+}
+
+/// `add_place_and_update_keep_overrides`: the library changes and publishes; the copies follow. Returns the Card's instance.
+fn library_updates_flow(s: &mut Session, lib: &mut Session, k: &Kit, lid: &str, [b, b_label, remote_button, main]: [NodeId; 4]) -> NodeId {
+    // The library changes the Button (fill via its style, and its label) and publishes again.
+    ex(lib, "style.update", json!({"style": "Brand", "value": "#00ff00"}));
+    ex(lib, "text.set", json!({"id": k.label, "characters": "Go"}));
+    ex(lib, "library.publish", json!({}));
+    ex(lib, "file.save", json!({}));
+
+    let u = ex(s, "library.updates", json!({}));
+    assert_eq!(u["count"], 3, "Button, Card and the style: {u}");
+    let label_ids: Vec<NodeId> = s.doc().unwrap().subtree(b);
+    ex(s, "library.acceptUpdates", json!({}));
+    assert_eq!(fill(s, b), "00FF00", "the instance follows the updated main");
+    assert_eq!(chars(s, b_label), "Buy", "its override is kept");
+    assert_eq!(s.doc().unwrap().subtree(b), label_ids, "layer ids are kept");
+    assert_eq!(fill(s, remote_button), "00FF00");
+    let style = s.doc().unwrap().styles[0].clone();
+    assert!(matches!(&style.kind, StyleKind::Paint { paints } if paints[0].solid_color().unwrap().to_hex() == "00FF00"));
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.libraries.link(lid).map(|l| l.version), Some(2));
+    // The Card's nested Button follows too.
+    let card_inst = doc.nodes().find(|n| matches!(n.kind, NodeKind::Instance { component, .. } if component == main)).map(|n| n.id).unwrap();
+    let nested = node(s, card_inst).children[0];
+    assert_eq!(fill(s, nested), "00FF00");
+    assert_eq!(ex(s, "library.updates", json!({}))["count"], 0);
+    healthy(s);
+    // A structural change: the Button gains a layer (the Card's nested Button too).
+    ex(lib, "shape.ellipse", json!({"x": 80, "y": 10, "width": 8, "height": 8, "parent": k.button, "props": {"name": "Dot"}}));
+    ex(lib, "library.publish", json!({}));
+    ex(lib, "file.save", json!({}));
+    ex(s, "library.acceptUpdates", json!({"ids": [lid]}));
+    assert_eq!(node(s, b).children.len(), 2);
+    assert_eq!(node(s, nested).children.len(), 2);
+    assert_eq!(chars(s, b_label), "Buy", "overrides survive a structural update");
+    assert_eq!(s.doc().unwrap().libraries.link(lid).map(|l| l.version), Some(3));
+    healthy(s);
+    // Overrides still work after the update; resetting shows the library's text.
+    ex(s, "component.resetInstance", json!({"ids": [b]}));
+    assert_eq!(chars(s, node(s, b).children[0]), "Go");
+    card_inst
 }
 
 #[test]
@@ -211,63 +287,9 @@ fn add_place_and_update_keep_overrides() {
         NodeKind::Instance { component, .. } => component,
         _ => panic!("not an instance"),
     };
-    let unchanged = s.doc().unwrap().clone();
-    let e = s.execute("node.set", &json!({"id": remote_button, "props": {"fill": "#ff0000"}})).unwrap_err();
-    assert!(e.to_string().contains("can't be edited"), "{e}");
-    assert_eq!(s.doc().unwrap(), &unchanged, "a refused remote edit rolls back");
-    for (cmd, args) in
-        [("node.reparent", json!({"ids": [remote_button], "parent": s.page().unwrap()})), ("edit.delete", json!({"ids": [remote_button]}))]
-    {
-        assert!(s.execute(cmd, &args).is_err(), "{cmd} must preserve read-only copies");
-        assert_eq!(s.doc().unwrap(), &unchanged, "refused {cmd} rolls back");
-    }
-    let style = s.doc().unwrap().styles[0].id.clone();
-    assert!(s.execute("style.update", &json!({"style": style, "name": "Mine"})).is_err());
-    assert!(s.execute("style.delete", &json!({"style": style})).is_err());
-    let e = s.execute("component.goToMain", &json!({"id": b})).unwrap_err();
-    assert!(e.to_string().contains("library"), "{e}");
-    assert!(s.execute("select.set", &json!({"ids": [remote_button]})).is_err(), "library copies can't be selected");
-    assert!(s.doc().unwrap().pages.contains(&s.page().unwrap()));
-    assert!(s.execute("component.pushChanges", &json!({"id": b})).is_err());
-    assert_eq!(fill(&s, remote_button), "0000FF");
+    assert_remote_read_only(&mut s, b, remote_button);
 
-    // The library changes the Button (fill via its style, and its label) and publishes again.
-    ex(&mut lib, "style.update", json!({"style": "Brand", "value": "#00ff00"}));
-    ex(&mut lib, "text.set", json!({"id": k.label, "characters": "Go"}));
-    ex(&mut lib, "library.publish", json!({}));
-    ex(&mut lib, "file.save", json!({}));
-
-    let u = ex(&mut s, "library.updates", json!({}));
-    assert_eq!(u["count"], 3, "Button, Card and the style: {u}");
-    let label_ids: Vec<NodeId> = s.doc().unwrap().subtree(b);
-    ex(&mut s, "library.acceptUpdates", json!({}));
-    assert_eq!(fill(&s, b), "00FF00", "the instance follows the updated main");
-    assert_eq!(chars(&s, b_label), "Buy", "its override is kept");
-    assert_eq!(s.doc().unwrap().subtree(b), label_ids, "layer ids are kept");
-    assert_eq!(fill(&s, remote_button), "00FF00");
-    let style = s.doc().unwrap().styles[0].clone();
-    assert!(matches!(&style.kind, StyleKind::Paint { paints } if paints[0].solid_color().unwrap().to_hex() == "00FF00"));
-    let doc = s.doc().unwrap();
-    assert_eq!(doc.libraries.link(&lid).map(|l| l.version), Some(2));
-    // The Card's nested Button follows too.
-    let card_inst = doc.nodes().find(|n| matches!(n.kind, NodeKind::Instance { component, .. } if component == main)).map(|n| n.id).unwrap();
-    let nested = node(&s, card_inst).children[0];
-    assert_eq!(fill(&s, nested), "00FF00");
-    assert_eq!(ex(&mut s, "library.updates", json!({}))["count"], 0);
-    healthy(&s);
-    // A structural change: the Button gains a layer (the Card's nested Button too).
-    ex(&mut lib, "shape.ellipse", json!({"x": 80, "y": 10, "width": 8, "height": 8, "parent": k.button, "props": {"name": "Dot"}}));
-    ex(&mut lib, "library.publish", json!({}));
-    ex(&mut lib, "file.save", json!({}));
-    ex(&mut s, "library.acceptUpdates", json!({"ids": [lid]}));
-    assert_eq!(node(&s, b).children.len(), 2);
-    assert_eq!(node(&s, nested).children.len(), 2);
-    assert_eq!(chars(&s, b_label), "Buy", "overrides survive a structural update");
-    assert_eq!(s.doc().unwrap().libraries.link(&lid).map(|l| l.version), Some(3));
-    healthy(&s);
-    // Overrides still work after the update; resetting shows the library's text.
-    ex(&mut s, "component.resetInstance", json!({"ids": [b]}));
-    assert_eq!(chars(&s, node(&s, b).children[0]), "Go");
+    let card_inst = library_updates_flow(&mut s, &mut lib, &k, &lid, [b, b_label, remote_button, main]);
 
     // Saved and reopened, the document keeps its links, copies and records.
     let user_path = path_str(&d.join("app.figcraft"));

crates/engine/src/assets/library_swap.rs

@@ -6,7 +6,7 @@
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use figcraft_doc::*;
+use figcraft_doc::{Document, ImportedComponent, ImportedRecord, LibraryManifest, NodeId, NodeKind, PublishedLibrary, VariableValue};
 use serde_json::Value;
 
 use crate::cmd::component::{main_of, swap_instance};
@@ -41,6 +41,35 @@ fn b_main(doc: &Document, a_main: NodeId, a_root: NodeId, b_root: NodeId) -> Opt
     }
 }
 
+/// Local style id → the library's style id, matched by name and type (the rest go to `out.unmatched`).
+fn match_styles(doc: &Document, recs: &[ImportedRecord], m: &LibraryManifest, out: &mut Swapped) -> BTreeMap<String, String> {
+    let mut keys = BTreeMap::new();
+    for r in recs {
+        let Some(st) = doc.style(&r.local) else { continue };
+        let kind = st.kind.type_name();
+        match m.styles.iter().find(|x| x.published && x.name == st.name && x.kind == kind) {
+            Some(x) => {
+                keys.insert(r.local.clone(), x.id.clone());
+            }
+            None => out.unmatched.push(format!("style {}", st.name)),
+        }
+    }
+    keys
+}
+
+/// (local component root, the library's component id) by name; the rest go to `out.unmatched`.
+fn match_components(doc: &Document, records: &[ImportedComponent], m: &LibraryManifest, out: &mut Swapped) -> Vec<(NodeId, NodeId)> {
+    let mut pairs = Vec::new();
+    for r in records {
+        let name = doc.node(r.root).map(|n| n.name.clone()).unwrap_or_default();
+        match m.components.iter().find(|a| a.published && a.name == name) {
+            Some(a) => pairs.push((r.root, a.id)),
+            None => out.unmatched.push(format!("component {name}")),
+        }
+    }
+    pairs
+}
+
 /// Swap the copies of library `from` in `doc` to library `to` by names (see the module docs).
 pub fn swap_library(doc: &mut Document, from: &str, to: &PublishedLibrary) -> Result<Swapped> {
     let m = &to.manifest;
@@ -64,14 +93,7 @@ pub fn swap_library(doc: &mut Document, from: &str, to: &PublishedLibrary) -> Re
         })
         .collect();
     let records: Vec<ImportedComponent> = doc.libraries.components.iter().filter(|r| r.library == from && shown.contains(&r.root)).cloned().collect();
-    let mut pairs = Vec::new();
-    for r in &records {
-        let name = doc.node(r.root).map(|n| n.name.clone()).unwrap_or_default();
-        match m.components.iter().find(|a| a.published && a.name == name) {
-            Some(a) => pairs.push((r.root, a.id)),
-            None => out.unmatched.push(format!("component {name}")),
-        }
-    }
+    let pairs = match_components(doc, &records, m, &mut out);
     let keys: Vec<NodeId> = pairs.iter().map(|(_, k)| *k).collect();
     let map = if keys.is_empty() { BTreeMap::new() } else { import(doc, to, &keys, false)? };
     // A's mains (each variant) and roots → B's.
@@ -121,17 +143,7 @@ pub fn swap_library(doc: &mut Document, from: &str, to: &PublishedLibrary) -> Re
     // Styles the document's own layers link to: by name and type.
     let linked: BTreeSet<String> = doc.nodes().filter(|n| outside(doc, n.id)).flat_map(|n| style_links(n).cloned()).collect();
     let style_recs: Vec<ImportedRecord> = doc.libraries.styles.iter().filter(|r| r.library == from && linked.contains(&r.local)).cloned().collect();
-    let mut style_keys: BTreeMap<String, String> = BTreeMap::new();
-    for r in &style_recs {
-        let Some(st) = doc.style(&r.local) else { continue };
-        let kind = st.kind.type_name();
-        match m.styles.iter().find(|x| x.published && x.name == st.name && x.kind == kind) {
-            Some(x) => {
-                style_keys.insert(r.local.clone(), x.id.clone());
-            }
-            None => out.unmatched.push(format!("style {}", st.name)),
-        }
-    }
+    let style_keys = match_styles(doc, &style_recs, m, &mut out);
     let imported = import_styles(doc, to, &style_keys.values().cloned().collect(), false);
     let styles: BTreeMap<String, String> = style_keys.iter().filter_map(|(a, k)| imported.get(k).map(|b| (a.clone(), b.clone()))).collect();
     out.styles = styles.len();

crates/engine/src/assets/playground.rs

@@ -8,7 +8,7 @@ use serde_json::{Map, Value, json};
 
 use crate::cmd::CommandSpec;
 use crate::codegen::CodeLang;
-use crate::params::*;
+use crate::params::{get, id_of, num, string, targets};
 use crate::{EngineError, Result, Session, bad, spec};
 
 /// The component a playground for `target` shows: an instance's component, a component or a

crates/engine/src/assets/style_vars.rs

@@ -8,7 +8,10 @@ use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet};
 
 use figcraft_color::PaintKind;
-use figcraft_doc::*;
+use figcraft_doc::{
+    CollectionId, Document, EffectKind, LetterSpacing, LineHeight, ModeId, Node, NodeId, NodeKind, Style, StyleId, StyleKind, TextStyle, VariableId,
+    VariableType, VariableValue, Variables,
+};
 
 use crate::cmd::lists::{BoundList, list_binding, stop_binding};
 

crates/engine/src/automation/inspect.rs

@@ -1,6 +1,6 @@
 //! Document inspection as JSON, so agents can verify their work without screenshots.
 
-use figcraft_doc::*;
+use figcraft_doc::{Document, Node, NodeId, NodeKind, StrokeJoin, TextData, TextDecoration};
 use serde_json::{Value, json};
 
 use crate::Session;
@@ -8,7 +8,6 @@ use crate::Session;
 /// A node and (to `depth`) its children, with the properties a designer would check.
 pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
     let Some(n) = doc.node(id) else { return Value::Null };
-    let c = doc.frame_relative(id).as_coeffs();
     let mut v = json!({
         "id": n.id,
         "name": n.name,
@@ -16,226 +15,259 @@ pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
     });
     let Some(o) = v.as_object_mut() else { return v };
     if !n.is_page() {
-        o.insert("x".into(), json!(round(c[4])));
-        o.insert("y".into(), json!(round(c[5])));
-        o.insert("width".into(), json!(round(n.width)));
-        o.insert("height".into(), json!(round(n.height)));
-        let rot = figcraft_geom::rotation_degrees(n.transform);
-        if rot.abs() > 1e-6 {
-            o.insert("rotation".into(), json!(round(rot)));
-        }
-        if let Some(b) = doc.world_bounds(id) {
-            o.insert("absoluteBounds".into(), json!({"x": round(b.x0), "y": round(b.y0), "width": round(b.width()), "height": round(b.height())}));
-        }
-        if !n.visible {
-            o.insert("visible".into(), json!(false));
-        }
-        if n.locked {
-            o.insert("locked".into(), json!(true));
-        }
-        if n.opacity < 1.0 {
-            o.insert("opacity".into(), json!(n.opacity));
-        }
-        if !matches!(n.blend, figcraft_color::BlendMode::Normal | figcraft_color::BlendMode::PassThrough) {
-            o.insert("blend".into(), json!(n.blend));
-        }
-        if !n.fills.is_empty() {
-            o.insert("fills".into(), paints(&n.fills));
-        }
-        if !n.strokes.is_empty() {
-            o.insert("strokes".into(), paints(&n.strokes));
-            o.insert("strokeWeight".into(), json!(n.stroke.weight));
-            o.insert("strokeAlign".into(), json!(n.stroke.align));
-            if n.stroke.sides.is_some() {
-                o.insert("strokeSides".into(), json!(n.stroke.sides));
-            }
-            if !n.stroke.dashes.is_empty() {
-                o.insert("dashes".into(), json!(n.stroke.dashes));
-            }
-            if n.stroke.join != StrokeJoin::Miter {
-                o.insert("strokeJoin".into(), json!(n.stroke.join));
-            } else if n.stroke.miter_limit != 4.0 {
-                o.insert("miterAngle".into(), json!((n.stroke.miter_angle() * 100.0).round() / 100.0));
-            }
-            if let Some(p) = n.stroke.profile() {
-                let points = crate::cmd::props::width_points_json(Some(p));
-                o.insert("widthProfile".into(), json!({"preset": p.preset().map(|x| x.id()), "points": points}));
-            }
-            if let Some(b) = &n.stroke.brush {
-                o.insert("brush".into(), camel(serde_json::to_value(b).unwrap_or(Value::Null)));
-            }
-        }
-        if !n.effects.is_empty() {
-            o.insert("effects".into(), camel(serde_json::to_value(&n.effects).unwrap_or(Value::Null)));
-        }
-        if n.corners.radii.iter().any(|r| *r > 0.0) {
-            o.insert(
-                "cornerRadius".into(),
-                match n.corners.uniform() {
-                    Some(r) => json!(r),
-                    None => json!(n.corners.radii),
-                },
-            );
-            if n.corners.smoothing > 0.0 {
-                o.insert("cornerSmoothing".into(), json!(n.corners.smoothing));
-            }
-        }
-        if let Some(l) = &n.layout {
-            o.insert("layout".into(), camel(serde_json::to_value(l).unwrap_or(Value::Null)));
-        }
-        let parent_al = n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some());
-        if n.layout.is_some() || parent_al || matches!(n.kind, NodeKind::Text(_)) {
-            o.insert("sizing".into(), json!({"horizontal": n.child_layout.sizing_h, "vertical": n.child_layout.sizing_v}));
-        }
-        let cl = &n.child_layout;
-        if cl.absolute {
-            o.insert("absolute".into(), json!(true));
-        }
-        for (k, v) in [("minWidth", cl.min_w), ("maxWidth", cl.max_w), ("minHeight", cl.min_h), ("maxHeight", cl.max_h)] {
-            if let Some(v) = v {
-                o.insert(k.into(), json!(v));
-            }
-        }
-        if let Some(cell) = parent_al
-            .then(|| n.parent.and_then(|p| figcraft_layout::grid_geometry(doc, p)))
-            .flatten()
-            .and_then(|g| g.cells.into_iter().find(|c| c.id == n.id))
-        {
-            o.insert(
-                "gridCell".into(),
-                json!({"column": cell.column, "row": cell.row, "columnSpan": cell.column_span, "rowSpan": cell.row_span,
-                       "anchored": cl.grid_column.is_some() || cl.grid_row.is_some(), "alignH": cl.grid_align_h, "alignV": cl.grid_align_v}),
-            );
-        }
-        if (!parent_al || cl.absolute) && n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.kind.is_frame_like()) {
-            o.insert("constraints".into(), serde_json::to_value(n.constraints).unwrap_or(Value::Null));
-        }
-        if n.kind.is_frame_like() {
-            o.insert("clip".into(), json!(n.clip));
-        }
-        if !n.dev_status.is_none() {
-            o.insert("devStatus".into(), json!(n.dev_status.id()));
-        }
-        if n.dev_changed {
-            o.insert("devChanged".into(), json!(true));
-        }
-        if !n.dev_note.is_empty() {
-            o.insert("devNote".into(), json!(n.dev_note));
-        }
-        if let NodeKind::Section { contents_hidden } = n.kind {
-            o.insert("sectionContentsHidden".into(), json!(contents_hidden));
-        }
-        if n.is_mask {
-            o.insert("isMask".into(), json!(true));
-            o.insert("maskType".into(), json!(n.mask_type.id()));
-        }
-        if !n.grids.is_empty() {
-            o.insert("grids".into(), camel(serde_json::to_value(&n.grids).unwrap_or(Value::Null)));
-        }
-        if !n.exports.is_empty() {
-            o.insert("exports".into(), serde_json::to_value(&n.exports).unwrap_or(Value::Null));
-        }
-        if let Some(b) = &n.board {
-            o.insert("board".into(), serde_json::to_value(b).unwrap_or(Value::Null));
-        }
-        if !n.annotations.is_empty() {
-            o.insert("annotations".into(), serde_json::to_value(&n.annotations).unwrap_or(Value::Null));
-        }
-        if !n.code_links.is_empty() {
-            o.insert("codeLinks".into(), camel(serde_json::to_value(&n.code_links).unwrap_or(Value::Null)));
-        }
-        if !n.measurements.is_empty() {
-            o.insert("measurements".into(), serde_json::to_value(&n.measurements).unwrap_or(Value::Null));
-        }
-        let dev = crate::dev_resources::list_json(doc, n.id);
-        if dev.as_array().is_some_and(|a| !a.is_empty()) {
-            o.insert("devResources".into(), dev);
-        }
-        if !n.interactions.is_empty() {
-            o.insert("interactions".into(), serde_json::to_value(&n.interactions).unwrap_or(Value::Null));
-        }
-        if !n.styles.is_empty() {
-            o.insert("styles".into(), serde_json::to_value(&n.styles).unwrap_or(Value::Null));
-        }
-        if !n.bound.is_empty() {
-            o.insert("boundVariables".into(), json!(n.bound));
-        }
-        if !n.overrides.is_empty() {
-            o.insert("overrides".into(), json!(n.overrides));
-        }
-        if let Some(slot) = crate::components::slot_name(doc, n.id) {
-            o.insert("slot".into(), json!(slot));
-        }
-        // An operand combining by an operation of its own.
-        if let Some(op) = n.bool_op.filter(|_| crate::booleans::group_of(doc, n.id).is_some()) {
-            o.insert("operandOperation".into(), json!(op));
-        }
+        base_props(doc, n, id, o);
+        paint_props(n, o);
+        layout_props(doc, n, o);
+        dev_props(doc, n, o);
     }
     // Layer data written with `node.set {props: {pluginData}}` (pages too).
     if !n.plugin_data.is_empty() {
         o.insert("pluginData".into(), json!(n.plugin_data));
     }
     match &n.kind {
-        NodeKind::Text(t) => {
-            o.insert("characters".into(), json!(t.characters));
-            o.insert("fontFamily".into(), json!(t.style.font_family));
-            o.insert("fontStyle".into(), json!(t.style.font_style));
-            o.insert("fontSize".into(), json!(t.style.font_size));
-            if !t.style.variations.is_empty() {
-                o.insert("fontVariations".into(), json!(t.style.variations));
-            }
-            o.insert("lineHeight".into(), json!(t.style.line_height.label()));
-            o.insert("letterSpacing".into(), json!(t.style.letter_spacing.label()));
-            o.insert("textAlign".into(), json!(t.align_h));
-            o.insert("textAutoResize".into(), json!(t.auto_resize));
-            if t.max_lines > 0 {
-                o.insert("maxLines".into(), json!(t.max_lines));
-            }
-            if let Some(tp) = &t.path {
-                o.insert("textPath".into(), json!(tp));
-            }
-            if t.style.decoration != TextDecoration::None {
-                o.insert("textDecoration".into(), json!(t.style.decoration));
-            }
-            if let Some(l) = t.style.decoration_look.as_deref() {
-                o.insert("textDecorationStyle".into(), json!(l.style));
-                o.insert("textDecorationThickness".into(), json!(l.thickness.label()));
-                o.insert("textDecorationOffset".into(), json!(l.offset.label()));
-                o.insert("textDecorationSkipInk".into(), json!(l.skip_ink));
-                o.insert("textDecorationColor".into(), l.color.map_or(json!("auto"), |c| json!(format!("#{}", c.to_hex()))));
-            }
-            // Lists: one style for the layer, or each paragraph's type, nesting level and start.
-            if t.paragraphs.is_empty() {
-                if t.list != figcraft_doc::ListStyle::None {
-                    o.insert("listStyle".into(), json!(t.list));
-                }
-            } else {
-                o.insert("lineTypes".into(), t.paragraphs.iter().map(|p| json!(p.list)).collect());
-                o.insert("lineIndentations".into(), t.paragraphs.iter().map(|p| json!(p.indent)).collect());
-                if t.paragraphs.iter().any(|p| p.start_offset > 0) {
-                    o.insert("listStartOffsets".into(), t.paragraphs.iter().map(|p| json!(p.start_offset)).collect());
-                }
-            }
-            if t.list_spacing != 0.0 {
-                o.insert("listSpacing".into(), json!(t.list_spacing));
-            }
-            for (k, on) in [("hangingPunctuation", t.hanging_punctuation), ("hangingList", t.hanging_list)] {
-                if on {
-                    o.insert(k.into(), json!(true));
-                }
-            }
-            if t.leading_trim != figcraft_doc::LeadingTrim::None {
-                o.insert("leadingTrim".into(), json!(t.leading_trim));
-            }
-            if !t.runs.is_empty() {
-                o.insert("styledRuns".into(), serde_json::to_value(&t.runs).unwrap_or(Value::Null));
-            }
-            // Chars linked to text styles: [start, end, style id] (the layer as a whole: `styles.text`).
-            let linked: Vec<Value> = t.spans().into_iter().filter_map(|(a, b, s)| s.style_id.as_ref().map(|id| json!([a, b, id]))).collect();
-            if !linked.is_empty() {
-                o.insert("textStyleRanges".into(), Value::Array(linked));
-            }
+        NodeKind::Text(t) => text_props(t, o),
+        _ => kind_props(doc, n, o),
+    }
+    if !n.children.is_empty() {
+        if depth > 0 {
+            o.insert("children".into(), Value::Array(n.children.iter().map(|c| node_json(doc, *c, depth - 1)).collect()));
+        } else {
+            o.insert("childCount".into(), json!(n.children.len()));
         }
+    }
+    v
+}
+
+fn base_props(doc: &Document, n: &Node, id: NodeId, o: &mut serde_json::Map<String, Value>) {
+    let c = doc.frame_relative(id).as_coeffs();
+    o.insert("x".into(), json!(round(c[4])));
+    o.insert("y".into(), json!(round(c[5])));
+    o.insert("width".into(), json!(round(n.width)));
+    o.insert("height".into(), json!(round(n.height)));
+    let rot = figcraft_geom::rotation_degrees(n.transform);
+    if rot.abs() > 1e-6 {
+        o.insert("rotation".into(), json!(round(rot)));
+    }
+    if let Some(b) = doc.world_bounds(id) {
+        o.insert("absoluteBounds".into(), json!({"x": round(b.x0), "y": round(b.y0), "width": round(b.width()), "height": round(b.height())}));
+    }
+    if !n.visible {
+        o.insert("visible".into(), json!(false));
+    }
+    if n.locked {
+        o.insert("locked".into(), json!(true));
+    }
+    if n.opacity < 1.0 {
+        o.insert("opacity".into(), json!(n.opacity));
+    }
+    if !matches!(n.blend, figcraft_color::BlendMode::Normal | figcraft_color::BlendMode::PassThrough) {
+        o.insert("blend".into(), json!(n.blend));
+    }
+}
+
+fn paint_props(n: &Node, o: &mut serde_json::Map<String, Value>) {
+    if !n.fills.is_empty() {
+        o.insert("fills".into(), paints(&n.fills));
+    }
+    if !n.strokes.is_empty() {
+        o.insert("strokes".into(), paints(&n.strokes));
+        o.insert("strokeWeight".into(), json!(n.stroke.weight));
+        o.insert("strokeAlign".into(), json!(n.stroke.align));
+        if n.stroke.sides.is_some() {
+            o.insert("strokeSides".into(), json!(n.stroke.sides));
+        }
+        if !n.stroke.dashes.is_empty() {
+            o.insert("dashes".into(), json!(n.stroke.dashes));
+        }
+        if n.stroke.join != StrokeJoin::Miter {
+            o.insert("strokeJoin".into(), json!(n.stroke.join));
+        } else if n.stroke.miter_limit != 4.0 {
+            o.insert("miterAngle".into(), json!((n.stroke.miter_angle() * 100.0).round() / 100.0));
+        }
+        if let Some(p) = n.stroke.profile() {
+            let points = crate::cmd::props::width_points_json(Some(p));
+            o.insert("widthProfile".into(), json!({"preset": p.preset().map(|x| x.id()), "points": points}));
+        }
+        if let Some(b) = &n.stroke.brush {
+            o.insert("brush".into(), camel(serde_json::to_value(b).unwrap_or(Value::Null)));
+        }
+    }
+    if !n.effects.is_empty() {
+        o.insert("effects".into(), camel(serde_json::to_value(&n.effects).unwrap_or(Value::Null)));
+    }
+    if n.corners.radii.iter().any(|r| *r > 0.0) {
+        o.insert(
+            "cornerRadius".into(),
+            match n.corners.uniform() {
+                Some(r) => json!(r),
+                None => json!(n.corners.radii),
+            },
+        );
+        if n.corners.smoothing > 0.0 {
+            o.insert("cornerSmoothing".into(), json!(n.corners.smoothing));
+        }
+    }
+}
+
+fn layout_props(doc: &Document, n: &Node, o: &mut serde_json::Map<String, Value>) {
+    if let Some(l) = &n.layout {
+        o.insert("layout".into(), camel(serde_json::to_value(l).unwrap_or(Value::Null)));
+    }
+    let parent_al = n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some());
+    if n.layout.is_some() || parent_al || matches!(n.kind, NodeKind::Text(_)) {
+        o.insert("sizing".into(), json!({"horizontal": n.child_layout.sizing_h, "vertical": n.child_layout.sizing_v}));
+    }
+    let cl = &n.child_layout;
+    if cl.absolute {
+        o.insert("absolute".into(), json!(true));
+    }
+    for (k, v) in [("minWidth", cl.min_w), ("maxWidth", cl.max_w), ("minHeight", cl.min_h), ("maxHeight", cl.max_h)] {
+        if let Some(v) = v {
+            o.insert(k.into(), json!(v));
+        }
+    }
+    if let Some(cell) = parent_al
+        .then(|| n.parent.and_then(|p| figcraft_layout::grid_geometry(doc, p)))
+        .flatten()
+        .and_then(|g| g.cells.into_iter().find(|c| c.id == n.id))
+    {
+        o.insert(
+            "gridCell".into(),
+            json!({"column": cell.column, "row": cell.row, "columnSpan": cell.column_span, "rowSpan": cell.row_span,
+                       "anchored": cl.grid_column.is_some() || cl.grid_row.is_some(), "alignH": cl.grid_align_h, "alignV": cl.grid_align_v}),
+        );
+    }
+    if (!parent_al || cl.absolute) && n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.kind.is_frame_like()) {
+        o.insert("constraints".into(), serde_json::to_value(n.constraints).unwrap_or(Value::Null));
+    }
+    if n.kind.is_frame_like() {
+        o.insert("clip".into(), json!(n.clip));
+    }
+}
+
+fn dev_props(doc: &Document, n: &Node, o: &mut serde_json::Map<String, Value>) {
+    if !n.dev_status.is_none() {
+        o.insert("devStatus".into(), json!(n.dev_status.id()));
+    }
+    if n.dev_changed {
+        o.insert("devChanged".into(), json!(true));
+    }
+    if !n.dev_note.is_empty() {
+        o.insert("devNote".into(), json!(n.dev_note));
+    }
+    if let NodeKind::Section { contents_hidden } = n.kind {
+        o.insert("sectionContentsHidden".into(), json!(contents_hidden));
+    }
+    if n.is_mask {
+        o.insert("isMask".into(), json!(true));
+        o.insert("maskType".into(), json!(n.mask_type.id()));
+    }
+    if !n.grids.is_empty() {
+        o.insert("grids".into(), camel(serde_json::to_value(&n.grids).unwrap_or(Value::Null)));
+    }
+    if !n.exports.is_empty() {
+        o.insert("exports".into(), serde_json::to_value(&n.exports).unwrap_or(Value::Null));
+    }
+    if let Some(b) = &n.board {
+        o.insert("board".into(), serde_json::to_value(b).unwrap_or(Value::Null));
+    }
+    if !n.annotations.is_empty() {
+        o.insert("annotations".into(), serde_json::to_value(&n.annotations).unwrap_or(Value::Null));
+    }
+    if !n.code_links.is_empty() {
+        o.insert("codeLinks".into(), camel(serde_json::to_value(&n.code_links).unwrap_or(Value::Null)));
+    }
+    if !n.measurements.is_empty() {
+        o.insert("measurements".into(), serde_json::to_value(&n.measurements).unwrap_or(Value::Null));
+    }
+    let dev = crate::dev_resources::list_json(doc, n.id);
+    if dev.as_array().is_some_and(|a| !a.is_empty()) {
+        o.insert("devResources".into(), dev);
+    }
+    if !n.interactions.is_empty() {
+        o.insert("interactions".into(), serde_json::to_value(&n.interactions).unwrap_or(Value::Null));
+    }
+    if !n.styles.is_empty() {
+        o.insert("styles".into(), serde_json::to_value(&n.styles).unwrap_or(Value::Null));
+    }
+    if !n.bound.is_empty() {
+        o.insert("boundVariables".into(), json!(n.bound));
+    }
+    if !n.overrides.is_empty() {
+        o.insert("overrides".into(), json!(n.overrides));
+    }
+    if let Some(slot) = crate::components::slot_name(doc, n.id) {
+        o.insert("slot".into(), json!(slot));
+    }
+    // An operand combining by an operation of its own.
+    if let Some(op) = n.bool_op.filter(|_| crate::booleans::group_of(doc, n.id).is_some()) {
+        o.insert("operandOperation".into(), json!(op));
+    }
+}
+
+fn text_props(t: &TextData, o: &mut serde_json::Map<String, Value>) {
+    o.insert("characters".into(), json!(t.characters));
+    o.insert("fontFamily".into(), json!(t.style.font_family));
+    o.insert("fontStyle".into(), json!(t.style.font_style));
+    o.insert("fontSize".into(), json!(t.style.font_size));
+    if !t.style.variations.is_empty() {
+        o.insert("fontVariations".into(), json!(t.style.variations));
+    }
+    o.insert("lineHeight".into(), json!(t.style.line_height.label()));
+    o.insert("letterSpacing".into(), json!(t.style.letter_spacing.label()));
+    o.insert("textAlign".into(), json!(t.align_h));
+    o.insert("textAutoResize".into(), json!(t.auto_resize));
+    if t.max_lines > 0 {
+        o.insert("maxLines".into(), json!(t.max_lines));
+    }
+    if let Some(tp) = &t.path {
+        o.insert("textPath".into(), json!(tp));
+    }
+    if t.style.decoration != TextDecoration::None {
+        o.insert("textDecoration".into(), json!(t.style.decoration));
+    }
+    if let Some(l) = t.style.decoration_look.as_deref() {
+        o.insert("textDecorationStyle".into(), json!(l.style));
+        o.insert("textDecorationThickness".into(), json!(l.thickness.label()));
+        o.insert("textDecorationOffset".into(), json!(l.offset.label()));
+        o.insert("textDecorationSkipInk".into(), json!(l.skip_ink));
+        o.insert("textDecorationColor".into(), l.color.map_or(json!("auto"), |c| json!(format!("#{}", c.to_hex()))));
+    }
+    // Lists: one style for the layer, or each paragraph's type, nesting level and start.
+    if t.paragraphs.is_empty() {
+        if t.list != figcraft_doc::ListStyle::None {
+            o.insert("listStyle".into(), json!(t.list));
+        }
+    } else {
+        o.insert("lineTypes".into(), t.paragraphs.iter().map(|p| json!(p.list)).collect());
+        o.insert("lineIndentations".into(), t.paragraphs.iter().map(|p| json!(p.indent)).collect());
+        if t.paragraphs.iter().any(|p| p.start_offset > 0) {
+            o.insert("listStartOffsets".into(), t.paragraphs.iter().map(|p| json!(p.start_offset)).collect());
+        }
+    }
+    if t.list_spacing != 0.0 {
+        o.insert("listSpacing".into(), json!(t.list_spacing));
+    }
+    for (k, on) in [("hangingPunctuation", t.hanging_punctuation), ("hangingList", t.hanging_list)] {
+        if on {
+            o.insert(k.into(), json!(true));
+        }
+    }
+    if t.leading_trim != figcraft_doc::LeadingTrim::None {
+        o.insert("leadingTrim".into(), json!(t.leading_trim));
+    }
+    if !t.runs.is_empty() {
+        o.insert("styledRuns".into(), serde_json::to_value(&t.runs).unwrap_or(Value::Null));
+    }
+    // Chars linked to text styles: [start, end, style id] (the layer as a whole: `styles.text`).
+    let linked: Vec<Value> = t.spans().into_iter().filter_map(|(a, b, s)| s.style_id.as_ref().map(|id| json!([a, b, id]))).collect();
+    if !linked.is_empty() {
+        o.insert("textStyleRanges".into(), Value::Array(linked));
+    }
+}
+
+fn kind_props(doc: &Document, n: &Node, o: &mut serde_json::Map<String, Value>) {
+    match &n.kind {
         NodeKind::Ellipse { start, sweep, inner } if (*sweep).abs() < std::f64::consts::TAU - 1e-9 || *inner > 0.0 => {
             o.insert("arc".into(), json!({"start": start.to_degrees(), "sweep": sweep.to_degrees(), "inner": inner}));
         }
@@ -276,14 +308,6 @@ pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
         }
         _ => {}
     }
-    if !n.children.is_empty() {
-        if depth > 0 {
-            o.insert("children".into(), Value::Array(n.children.iter().map(|c| node_json(doc, *c, depth - 1)).collect()));
-        } else {
-            o.insert("childCount".into(), json!(n.children.len()));
-        }
-    }
-    v
 }
 
 fn round(v: f64) -> f64 {

crates/engine/src/content/synthetic_ds.rs

@@ -11,7 +11,10 @@
 use std::collections::BTreeMap;
 
 use figcraft_color::{Color, Paint};
-use figcraft_doc::*;
+use figcraft_doc::{
+    AutoLayout, Collection, CollectionId, CrossAlign, DocError, DocResult, Document, LayoutMode, Mode, ModeId, Node, NodeId, NodeKind, PropDef,
+    Sizing, Style, StyleKind, TextAutoResize, TextData, TextStyle, Variable, VariableType, VariableValue,
+};
 use serde_json::Value;
 
 use crate::components::{create_instance, sync_instance};

crates/engine/src/content/templates/dashboard.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::{Value, json};
 
 use super::glyphs::{self, Glyph};
-use super::kit::*;
+use super::kit::{ACCENT, BORDER, BOTTOM_EDGE, CARD, H, ICON, INK, Kit, MUTED, ON_BRAND, PAGE, PRIMARY, RIGHT_EDGE, SOFT, V, merged};
 use crate::Result;
 
 const NAV: [(&str, Glyph); 6] = [

crates/engine/src/content/templates/design_system.rs

@@ -6,7 +6,7 @@
 use figcraft_doc::NodeId;
 use serde_json::{Value, json};
 
-use super::kit::*;
+use super::kit::{H, Kit, TYPE, V, merged};
 use crate::Result;
 
 const THEME: &str = "Theme";

crates/engine/src/content/templates/icon_set.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::json;
 
 use super::glyphs;
-use super::kit::*;
+use super::kit::{BORDER, CARD, H, ICON, INK, Kit, MUTED, PAGE, V, merged};
 use crate::Result;
 
 const STROKE: &str = "Icon/Stroke";

crates/engine/src/content/templates/landing.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::{Value, json};
 
 use super::glyphs::{self, Glyph};
-use super::kit::*;
+use super::kit::{BORDER, BOTTOM_EDGE, CARD, H, ICON, INK, Kit, MUTED, ON_BRAND, PAGE, PRIMARY, SOFT, SUNKEN, TOP_EDGE, V, merged, shadow};
 use crate::Result;
 
 /// The widest the content gets.

crates/engine/src/content/templates/mobile.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::json;
 
 use super::glyphs::{self, Glyph};
-use super::kit::*;
+use super::kit::{BORDER, CARD, H, ICON, INK, Kit, MUTED, ON_BRAND, PAGE, PRIMARY, SUNKEN, TOP_EDGE, V, shadow};
 use crate::Result;
 
 const W: f64 = 390.0;

crates/engine/src/content/templates/slides.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::{Value, json};
 
 use super::glyphs;
-use super::kit::*;
+use super::kit::{ACCENT, BORDER, BOTTOM_EDGE, CARD, DEEP, H, INK, Kit, MUTED, ON_BRAND, PAGE, PRIMARY, TOP_EDGE, V, merged};
 use crate::Result;
 
 const W: f64 = 1920.0;

crates/engine/src/content/templates/social.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::json;
 
 use super::glyphs;
-use super::kit::*;
+use super::kit::{ACCENT, DEEP, H, INK, Kit, ON_BRAND, V};
 use crate::Result;
 
 /// (name, width, height, x, y) on the canvas.

crates/engine/src/content/templates/wireframe.rs

@@ -6,7 +6,7 @@ use figcraft_doc::NodeId;
 use serde_json::{Value, json};
 
 use super::glyphs;
-use super::kit::*;
+use super::kit::{BOTTOM_EDGE, H, Kit, TOP_EDGE, TYPE, V, merged};
 use crate::Result;
 
 const WIRE_INK: &str = "Wire/Ink";

crates/engine/src/dev/annotations.rs

@@ -7,12 +7,12 @@
 
 use std::sync::LazyLock;
 
-use figcraft_doc::*;
+use figcraft_doc::{Annotation, AnnotationCategory, Document, NodeId};
 use serde_json::{Value, json};
 
 use crate::cmd::CommandSpec;
 use crate::devinspect::{Prop, Section, properties};
-use crate::params::*;
+use crate::params::{color_of, get, id, req_index, req_string, string, targets};
 use crate::{bad, spec};
 
 /// Most annotations on one layer.

crates/engine/src/dev/code_connect.rs

@@ -10,14 +10,14 @@
 //! keeps JSX's braces: `size={size}` → `size="Large"`, `{label}` → `{"Buy"}`), and
 //! `{prop ? "a" : "b"}` picks one of two strings. Any other `{…}` stays as written.
 
-use figcraft_doc::*;
+use figcraft_doc::{CodeLink, Document, NodeId, NodeKind};
 use serde_json::{Value, json};
 
 use crate::cmd::CommandSpec;
 use crate::codegen::{CodeLang, Ctx};
 use crate::component_codegen::{Component, Param, ParamKind, describe, instance_values, js_string, main_of, value_expr};
 use crate::components::{slots_of, variant_set};
-use crate::params::*;
+use crate::params::{get, id_of, targets};
 use crate::{EngineError, Result, Session, bad, spec};
 
 /// Longest template (chars).

crates/engine/src/dev/codegen.rs

@@ -6,12 +6,15 @@
 //! output is a starting point, not a pixel-exact translation.
 
 use figcraft_color::{Color, PaintKind};
-use figcraft_doc::*;
+use figcraft_doc::{
+    ContentAlign, CrossAlign, Document, EffectKind, LayoutMode, LetterSpacing, LineHeight, MainAlign, Node, NodeId, NodeKind, Shadow, Sizing,
+    TextAlignH, TextCase, TextDecoration, Variable,
+};
 use serde_json::json;
 
 use crate::cmd::CommandSpec;
 use crate::component_codegen::{Component, Param};
-use crate::params::*;
+use crate::params::{get, id_of, num_or, string, targets};
 use crate::{bad, spec};
 
 mod arkui;

crates/engine/src/dev/codegen/arkui.rs

@@ -1,5 +1,8 @@
 use super::swift::one_line;
-use super::*;
+use super::{
+    CodeLang, Color, CrossAlign, Ctx, LayoutMode, LetterSpacing, LineHeight, MainAlign, Node, NodeId, NodeKind, TextAlignH, TextCase, TextDecoration,
+    drop_shadow, first_fill, indent, literal, num, radius, stroke_color,
+};
 
 // ------------------------------------------------------------------ ArkUI (ArkTS)
 
@@ -37,8 +40,121 @@ pub(crate) fn arkui(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String, extra
     arkui_layer(ctx, n, depth, out, extra);
 }
 
-fn arkui_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
+fn text_layer(ctx: &Ctx, n: &Node, t: &figcraft_doc::TextData, pad: &str, out: &mut String, mods: &mut Vec<String>) {
+    let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, false), |p| format!("this.{}", p.ident));
+    out.push_str(&format!("{pad}Text({text})\n"));
+    let s = &t.style;
+    mods.push(format!(".fontSize({})", num(s.font_size)));
+    mods.push(format!(".fontWeight({})", s.weight().clamp(100, 900)));
+    mods.push(format!(".fontFamily({})", literal(&s.font_family, false)));
+    if s.italic() {
+        mods.push(".fontStyle(FontStyle.Italic)".into());
+    }
+    if let Some(c) = first_fill(n) {
+        mods.push(format!(".fontColor({})", ark_color(c)));
+    }
+    match s.line_height {
+        LineHeight::Pixels(v) => mods.push(format!(".lineHeight({})", num(v))),
+        LineHeight::Percent(p) => mods.push(format!(".lineHeight('{}%')", num(p))),
+        LineHeight::Auto => {}
+    }
+    match s.letter_spacing {
+        LetterSpacing::Pixels(v) if v != 0.0 => mods.push(format!(".letterSpacing({})", num(v))),
+        LetterSpacing::Percent(p) if p != 0.0 => mods.push(format!(".letterSpacing('{}%')", num(p))),
+        _ => {}
+    }
+    match t.align_h {
+        TextAlignH::Left => {}
+        TextAlignH::Center => mods.push(".textAlign(TextAlign.Center)".into()),
+        TextAlignH::Right => mods.push(".textAlign(TextAlign.End)".into()),
+        TextAlignH::Justified => mods.push(".textAlign(TextAlign.JUSTIFY)".into()),
+    }
+    // Aligning needs a box to align in: the text layer's own width.
+    if !matches!(t.align_h, TextAlignH::Left) {
+        mods.push(format!(".width({})", num(n.width)));
+    }
+    match s.case {
+        TextCase::Upper => mods.push(".textCase(TextCase.UpperCase)".into()),
+        TextCase::Lower => mods.push(".textCase(TextCase.LowerCase)".into()),
+        _ => {}
+    }
+    match s.decoration {
+        TextDecoration::Underline => mods.push(".decoration({ type: TextDecorationType.Underline })".into()),
+        TextDecoration::Strikethrough => mods.push(".decoration({ type: TextDecorationType.LineThrough })".into()),
+        TextDecoration::None => {}
+    }
+}
+
+fn frame_layer(ctx: &Ctx, n: &Node, depth: usize, pad: &str, out: &mut String, mods: &mut Vec<String>) {
     let doc = ctx.doc;
+    let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
+        Some((LayoutMode::Vertical, l)) => format!("Column({{ space: {} }})", num(l.gap)),
+        Some((_, l)) => format!("Row({{ space: {} }})", num(l.gap)),
+        None => "Stack({ alignContent: Alignment.TopStart })".to_string(),
+    };
+    out.push_str(&format!("{pad}{open} {{\n"));
+    match ctx.param(n, "slot") {
+        // A slot shows the instance's content, or else the main's (its default builder).
+        Some(p) => out.push_str(&format!("{pad}    this.{}()\n", p.ident)),
+        None => {
+            for c in ctx.kids(n) {
+                // Free children sit at their position inside a Stack, and so does a child
+                // that ignores its auto layout parent.
+                let pos: Vec<String> = match doc.node(c).filter(|cn| n.layout.is_none() || cn.child_layout.absolute) {
+                    Some(cn) => {
+                        let [_, _, _, _, x, y] = cn.transform.as_coeffs();
+                        vec![format!(".position({{ x: {}, y: {} }})", num(x), num(y))]
+                    }
+                    None => Vec::new(),
+                };
+                arkui(ctx, c, depth + 1, out, &pos);
+            }
+        }
+    }
+    out.push_str(&format!("{pad}}}\n"));
+    if let Some(l) = &n.layout {
+        layout_mods(l, mods);
+    }
+    mods.push(format!(".width({})", num(n.width)));
+    mods.push(format!(".height({})", num(n.height)));
+    if let Some(c) = first_fill(n) {
+        mods.push(format!(".backgroundColor({})", ark_color(c)));
+    }
+    if radius(n) > 0.0 {
+        mods.push(".clip(true)".into());
+    }
+    ark_radius(n, mods);
+}
+
+fn layout_mods(l: &figcraft_doc::AutoLayout, mods: &mut Vec<String>) {
+    let [t, r, b, lft] = l.padding;
+    if [t, r, b, lft].iter().any(|v| *v > 0.0) {
+        mods.push(format!(".padding({{ top: {}, right: {}, bottom: {}, left: {} }})", num(t), num(r), num(b), num(lft)));
+    }
+    let justify = match l.main_align {
+        MainAlign::Min => None,
+        MainAlign::Center => Some("FlexAlign.Center"),
+        MainAlign::Max => Some("FlexAlign.End"),
+        MainAlign::SpaceBetween => Some("FlexAlign.SpaceBetween"),
+        MainAlign::SpaceAround => Some("FlexAlign.SpaceAround"),
+        MainAlign::SpaceEvenly => Some("FlexAlign.SpaceEvenly"),
+    };
+    if let Some(j) = justify {
+        mods.push(format!(".justifyContent({j})"));
+    }
+    let cross = match l.cross_align {
+        CrossAlign::Min => None,
+        CrossAlign::Center => Some("Center"),
+        CrossAlign::Max => Some(if l.mode == LayoutMode::Vertical { "End" } else { "Bottom" }),
+        CrossAlign::Baseline => None,
+    };
+    if let Some(c) = cross {
+        let ty = if l.mode == LayoutMode::Vertical { "HorizontalAlign" } else { "VerticalAlign" };
+        mods.push(format!(".alignItems({ty}.{c})"));
+    }
+}
+
+fn arkui_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
     let pad = indent(depth);
     if ctx.too_deep(depth) {
         out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
@@ -68,48 +184,7 @@ fn arkui_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[Str
     let mut mods: Vec<String> = Vec::new();
     match &n.kind {
         NodeKind::Text(t) => {
-            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, false), |p| format!("this.{}", p.ident));
-            out.push_str(&format!("{pad}Text({text})\n"));
-            let s = &t.style;
-            mods.push(format!(".fontSize({})", num(s.font_size)));
-            mods.push(format!(".fontWeight({})", s.weight().clamp(100, 900)));
-            mods.push(format!(".fontFamily({})", literal(&s.font_family, false)));
-            if s.italic() {
-                mods.push(".fontStyle(FontStyle.Italic)".into());
-            }
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".fontColor({})", ark_color(c)));
-            }
-            match s.line_height {
-                LineHeight::Pixels(v) => mods.push(format!(".lineHeight({})", num(v))),
-                LineHeight::Percent(p) => mods.push(format!(".lineHeight('{}%')", num(p))),
-                LineHeight::Auto => {}
-            }
-            match s.letter_spacing {
-                LetterSpacing::Pixels(v) if v != 0.0 => mods.push(format!(".letterSpacing({})", num(v))),
-                LetterSpacing::Percent(p) if p != 0.0 => mods.push(format!(".letterSpacing('{}%')", num(p))),
-                _ => {}
-            }
-            match t.align_h {
-                TextAlignH::Left => {}
-                TextAlignH::Center => mods.push(".textAlign(TextAlign.Center)".into()),
-                TextAlignH::Right => mods.push(".textAlign(TextAlign.End)".into()),
-                TextAlignH::Justified => mods.push(".textAlign(TextAlign.JUSTIFY)".into()),
-            }
-            // Aligning needs a box to align in: the text layer's own width.
-            if !matches!(t.align_h, TextAlignH::Left) {
-                mods.push(format!(".width({})", num(n.width)));
-            }
-            match s.case {
-                TextCase::Upper => mods.push(".textCase(TextCase.UpperCase)".into()),
-                TextCase::Lower => mods.push(".textCase(TextCase.LowerCase)".into()),
-                _ => {}
-            }
-            match s.decoration {
-                TextDecoration::Underline => mods.push(".decoration({ type: TextDecorationType.Underline })".into()),
-                TextDecoration::Strikethrough => mods.push(".decoration({ type: TextDecorationType.LineThrough })".into()),
-                TextDecoration::None => {}
-            }
+            text_layer(ctx, n, t, &pad, out, &mut mods);
         }
         NodeKind::Ellipse { .. } => {
             out.push_str(&format!("{pad}Ellipse({{ width: {}, height: {} }})\n", num(n.width), num(n.height)));
@@ -131,67 +206,7 @@ fn arkui_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[Str
             mods.push(format!(".height({})", num(n.height)));
         }
         k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
-            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
-                Some((LayoutMode::Vertical, l)) => format!("Column({{ space: {} }})", num(l.gap)),
-                Some((_, l)) => format!("Row({{ space: {} }})", num(l.gap)),
-                None => "Stack({ alignContent: Alignment.TopStart })".to_string(),
-            };
-            out.push_str(&format!("{pad}{open} {{\n"));
-            match ctx.param(n, "slot") {
-                // A slot shows the instance's content, or else the main's (its default builder).
-                Some(p) => out.push_str(&format!("{pad}    this.{}()\n", p.ident)),
-                None => {
-                    for c in ctx.kids(n) {
-                        // Free children sit at their position inside a Stack, and so does a child
-                        // that ignores its auto layout parent.
-                        let pos: Vec<String> = match doc.node(c).filter(|cn| n.layout.is_none() || cn.child_layout.absolute) {
-                            Some(cn) => {
-                                let [_, _, _, _, x, y] = cn.transform.as_coeffs();
-                                vec![format!(".position({{ x: {}, y: {} }})", num(x), num(y))]
-                            }
-                            None => Vec::new(),
-                        };
-                        arkui(ctx, c, depth + 1, out, &pos);
-                    }
-                }
-            }
-            out.push_str(&format!("{pad}}}\n"));
-            if let Some(l) = &n.layout {
-                let [t, r, b, lft] = l.padding;
-                if [t, r, b, lft].iter().any(|v| *v > 0.0) {
-                    mods.push(format!(".padding({{ top: {}, right: {}, bottom: {}, left: {} }})", num(t), num(r), num(b), num(lft)));
-                }
-                let justify = match l.main_align {
-                    MainAlign::Min => None,
-                    MainAlign::Center => Some("FlexAlign.Center"),
-                    MainAlign::Max => Some("FlexAlign.End"),
-                    MainAlign::SpaceBetween => Some("FlexAlign.SpaceBetween"),
-                    MainAlign::SpaceAround => Some("FlexAlign.SpaceAround"),
-                    MainAlign::SpaceEvenly => Some("FlexAlign.SpaceEvenly"),
-                };
-                if let Some(j) = justify {
-                    mods.push(format!(".justifyContent({j})"));
-                }
-                let cross = match l.cross_align {
-                    CrossAlign::Min => None,
-                    CrossAlign::Center => Some("Center"),
-                    CrossAlign::Max => Some(if l.mode == LayoutMode::Vertical { "End" } else { "Bottom" }),
-                    CrossAlign::Baseline => None,
-                };
-                if let Some(c) = cross {
-                    let ty = if l.mode == LayoutMode::Vertical { "HorizontalAlign" } else { "VerticalAlign" };
-                    mods.push(format!(".alignItems({ty}.{c})"));
-                }
-            }
-            mods.push(format!(".width({})", num(n.width)));
-            mods.push(format!(".height({})", num(n.height)));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".backgroundColor({})", ark_color(c)));
-            }
-            if radius(n) > 0.0 {
-                mods.push(".clip(true)".into());
-            }
-            ark_radius(n, &mut mods);
+            frame_layer(ctx, n, depth, &pad, out, &mut mods);
         }
         _ => {
             out.push_str(&format!("{pad}// {}: export as an image asset\n{pad}Image($r('app.media.asset'))\n", n.kind.label()));

crates/engine/src/dev/codegen/compose.rs

@@ -1,5 +1,5 @@
 use super::swift::one_line;
-use super::*;
+use super::{CodeLang, Color, Ctx, LayoutMode, Node, NodeId, NodeKind, drop_shadow, first_fill, indent, literal, num, radius, stroke_color};
 
 // ------------------------------------------------------------------ Jetpack Compose
 

crates/engine/src/dev/codegen/css.rs

@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    ContentAlign, CrossAlign, Document, EffectKind, LayoutMode, LetterSpacing, LineHeight, MainAlign, Node, NodeId, NodeKind, PaintKind, TextAlignH,
+    TextCase, TextDecoration, Variable, css_borders, num,
+};
 
 // ------------------------------------------------------------------ CSS
 
@@ -85,51 +88,7 @@ pub(crate) fn css_decls(doc: &Document, n: &Node, t: &mut Tokens, hug: (bool, bo
         put("height", tok(doc, n, &["height"], px(n.height), t));
     }
     if let Some(l) = &n.layout {
-        put("display", "flex".into());
-        put("flex-direction", if l.mode == LayoutMode::Vertical { "column" } else { "row" }.into());
-        if l.wrap {
-            put("flex-wrap", "wrap".into());
-        }
-        put("gap", tok(doc, n, &["gap"], px(l.gap), t));
-        let [pt, pr, pb, pl] = l.padding;
-        let sides = [
-            tok(doc, n, &["paddingTop", "paddingVertical", "padding"], px(pt), t),
-            tok(doc, n, &["paddingRight", "paddingHorizontal", "padding"], px(pr), t),
-            tok(doc, n, &["paddingBottom", "paddingVertical", "padding"], px(pb), t),
-            tok(doc, n, &["paddingLeft", "paddingHorizontal", "padding"], px(pl), t),
-        ];
-        put("padding", sides.join(" "));
-        let justify = match l.main_align {
-            MainAlign::Min => "flex-start",
-            MainAlign::Center => "center",
-            MainAlign::Max => "flex-end",
-            MainAlign::SpaceBetween => "space-between",
-            MainAlign::SpaceAround => "space-around",
-            MainAlign::SpaceEvenly => "space-evenly",
-        };
-        put("justify-content", justify.into());
-        let align = match l.cross_align {
-            CrossAlign::Min => "flex-start",
-            CrossAlign::Center => "center",
-            CrossAlign::Max => "flex-end",
-            CrossAlign::Baseline => "baseline",
-        };
-        put("align-items", align.into());
-        if l.wrap {
-            // The lines: spread, or packed where the items align (baseline: at the start).
-            let spread = l.content_align == ContentAlign::SpaceBetween;
-            put(
-                "align-content",
-                if spread {
-                    "space-between"
-                } else if align == "baseline" {
-                    "flex-start"
-                } else {
-                    align
-                }
-                .into(),
-            );
-        }
+        layout_decls(doc, n, l, t, &mut put);
     }
     if matches!(n.kind, NodeKind::Ellipse { .. }) {
         put("border-radius", "50%".into());
@@ -169,6 +128,65 @@ pub(crate) fn css_decls(doc: &Document, n: &Node, t: &mut Tokens, hug: (bool, bo
     for (key, value) in css_borders(doc, n, t) {
         put(&key, value);
     }
+    effect_decls(n, &mut put);
+    if let NodeKind::Text(tx) = &n.kind {
+        text_decls(doc, n, tx, t, &mut put);
+    }
+    out
+}
+
+/// The flex declarations of auto layout `l` on `n`.
+fn layout_decls(doc: &Document, n: &Node, l: &figcraft_doc::AutoLayout, t: &mut Tokens, put: &mut impl FnMut(&str, String)) {
+    let px = |v: f64| format!("{}px", num(v));
+    put("display", "flex".into());
+    put("flex-direction", if l.mode == LayoutMode::Vertical { "column" } else { "row" }.into());
+    if l.wrap {
+        put("flex-wrap", "wrap".into());
+    }
+    put("gap", tok(doc, n, &["gap"], px(l.gap), t));
+    let [pt, pr, pb, pl] = l.padding;
+    let sides = [
+        tok(doc, n, &["paddingTop", "paddingVertical", "padding"], px(pt), t),
+        tok(doc, n, &["paddingRight", "paddingHorizontal", "padding"], px(pr), t),
+        tok(doc, n, &["paddingBottom", "paddingVertical", "padding"], px(pb), t),
+        tok(doc, n, &["paddingLeft", "paddingHorizontal", "padding"], px(pl), t),
+    ];
+    put("padding", sides.join(" "));
+    let justify = match l.main_align {
+        MainAlign::Min => "flex-start",
+        MainAlign::Center => "center",
+        MainAlign::Max => "flex-end",
+        MainAlign::SpaceBetween => "space-between",
+        MainAlign::SpaceAround => "space-around",
+        MainAlign::SpaceEvenly => "space-evenly",
+    };
+    put("justify-content", justify.into());
+    let align = match l.cross_align {
+        CrossAlign::Min => "flex-start",
+        CrossAlign::Center => "center",
+        CrossAlign::Max => "flex-end",
+        CrossAlign::Baseline => "baseline",
+    };
+    put("align-items", align.into());
+    if l.wrap {
+        // The lines: spread, or packed where the items align (baseline: at the start).
+        let spread = l.content_align == ContentAlign::SpaceBetween;
+        put(
+            "align-content",
+            if spread {
+                "space-between"
+            } else if align == "baseline" {
+                "flex-start"
+            } else {
+                align
+            }
+            .into(),
+        );
+    }
+}
+
+/// Shadows and blurs of `n`.
+fn effect_decls(n: &Node, put: &mut impl FnMut(&str, String)) {
     let shadows: Vec<String> = n
         .effects
         .iter()
@@ -196,75 +214,82 @@ pub(crate) fn css_decls(doc: &Document, n: &Node, t: &mut Tokens, hug: (bool, bo
             _ => {}
         }
     }
-    if let NodeKind::Text(tx) = &n.kind {
-        let s = &tx.style;
-        put("font-family", tok(doc, n, &["fontFamily"], format!("\"{}\"", s.font_family.replace('"', "'")), t));
-        put("font-size", tok(doc, n, &["fontSize"], px(s.font_size), t));
-        put("font-weight", s.weight().to_string());
-        if s.italic() {
-            put("font-style", "italic".into());
+}
+
+/// The type declarations of text layer `n`.
+fn text_decls(doc: &Document, n: &Node, tx: &figcraft_doc::TextData, t: &mut Tokens, put: &mut impl FnMut(&str, String)) {
+    let px = |v: f64| format!("{}px", num(v));
+    let s = &tx.style;
+    put("font-family", tok(doc, n, &["fontFamily"], format!("\"{}\"", s.font_family.replace('"', "'")), t));
+    put("font-size", tok(doc, n, &["fontSize"], px(s.font_size), t));
+    put("font-weight", s.weight().to_string());
+    if s.italic() {
+        put("font-style", "italic".into());
+    }
+    match s.line_height {
+        LineHeight::Pixels(v) => put("line-height", tok(doc, n, &["lineHeight"], px(v), t)),
+        LineHeight::Percent(p) => put("line-height", format!("{}%", num(p))),
+        LineHeight::Auto => {}
+    }
+    match s.letter_spacing {
+        LetterSpacing::Pixels(v) if v != 0.0 => put("letter-spacing", tok(doc, n, &["letterSpacing"], px(v), t)),
+        LetterSpacing::Percent(p) if p != 0.0 => put("letter-spacing", format!("{}em", num(p / 100.0))),
+        _ => {}
+    }
+    match tx.align_h {
+        TextAlignH::Left => {}
+        TextAlignH::Center => put("text-align", "center".into()),
+        TextAlignH::Right => put("text-align", "right".into()),
+        TextAlignH::Justified => put("text-align", "justify".into()),
+    }
+    match s.case {
+        TextCase::Original => {}
+        TextCase::Upper => put("text-transform", "uppercase".into()),
+        TextCase::Lower => put("text-transform", "lowercase".into()),
+        TextCase::Title => put("text-transform", "capitalize".into()),
+        TextCase::SmallCaps => put("font-variant", "small-caps".into()),
+    }
+    match s.decoration {
+        TextDecoration::None => {}
+        TextDecoration::Underline => put("text-decoration", "underline".into()),
+        TextDecoration::Strikethrough => put("text-decoration", "line-through".into()),
+    }
+    decoration_decls(s, put);
+    if tx.leading_trim == figcraft_doc::LeadingTrim::CapHeight {
+        put("text-box", "trim-both cap alphabetic".into());
+    }
+}
+
+fn decoration_decls(s: &figcraft_doc::TextStyle, put: &mut impl FnMut(&str, String)) {
+    let px = |v: f64| format!("{}px", num(v));
+    if s.decoration != TextDecoration::None {
+        let l = s.look();
+        let len = |m: LineHeight| match m {
+            LineHeight::Auto => None,
+            LineHeight::Pixels(v) => Some(px(v)),
+            LineHeight::Percent(p) => Some(format!("{}%", num(p))),
+        };
+        match l.style {
+            figcraft_doc::DecorationStyle::Solid => {}
+            figcraft_doc::DecorationStyle::Dotted => put("text-decoration-style", "dotted".into()),
+            figcraft_doc::DecorationStyle::Wavy => put("text-decoration-style", "wavy".into()),
         }
-        match s.line_height {
-            LineHeight::Pixels(v) => put("line-height", tok(doc, n, &["lineHeight"], px(v), t)),
-            LineHeight::Percent(p) => put("line-height", format!("{}%", num(p))),
-            LineHeight::Auto => {}
+        if let Some(v) = len(l.thickness) {
+            put("text-decoration-thickness", v);
         }
-        match s.letter_spacing {
-            LetterSpacing::Pixels(v) if v != 0.0 => put("letter-spacing", tok(doc, n, &["letterSpacing"], px(v), t)),
-            LetterSpacing::Percent(p) if p != 0.0 => put("letter-spacing", format!("{}em", num(p / 100.0))),
-            _ => {}
+        if let Some(c) = l.color {
+            put("text-decoration-color", c.to_css());
         }
-        match tx.align_h {
-            TextAlignH::Left => {}
-            TextAlignH::Center => put("text-align", "center".into()),
-            TextAlignH::Right => put("text-align", "right".into()),
-            TextAlignH::Justified => put("text-align", "justify".into()),
-        }
-        match s.case {
-            TextCase::Original => {}
-            TextCase::Upper => put("text-transform", "uppercase".into()),
-            TextCase::Lower => put("text-transform", "lowercase".into()),
-            TextCase::Title => put("text-transform", "capitalize".into()),
-            TextCase::SmallCaps => put("font-variant", "small-caps".into()),
-        }
-        match s.decoration {
-            TextDecoration::None => {}
-            TextDecoration::Underline => put("text-decoration", "underline".into()),
-            TextDecoration::Strikethrough => put("text-decoration", "line-through".into()),
-        }
-        if s.decoration != TextDecoration::None {
-            let l = s.look();
-            let len = |m: LineHeight| match m {
-                LineHeight::Auto => None,
-                LineHeight::Pixels(v) => Some(px(v)),
-                LineHeight::Percent(p) => Some(format!("{}%", num(p))),
-            };
-            match l.style {
-                figcraft_doc::DecorationStyle::Solid => {}
-                figcraft_doc::DecorationStyle::Dotted => put("text-decoration-style", "dotted".into()),
-                figcraft_doc::DecorationStyle::Wavy => put("text-decoration-style", "wavy".into()),
+        if s.decoration == TextDecoration::Underline {
+            if let Some(v) = len(l.offset) {
+                put("text-underline-offset", v);
             }
-            if let Some(v) = len(l.thickness) {
-                put("text-decoration-thickness", v);
+            // Browsers skip ink by default; the canvas only when asked.
+            if !l.skip_ink {
+                put("text-decoration-skip-ink", "none".into());
             }
-            if let Some(c) = l.color {
-                put("text-decoration-color", c.to_css());
-            }
-            if s.decoration == TextDecoration::Underline {
-                if let Some(v) = len(l.offset) {
-                    put("text-underline-offset", v);
-                }
-                // Browsers skip ink by default; the canvas only when asked.
-                if !l.skip_ink {
-                    put("text-decoration-skip-ink", "none".into());
-                }
-            }
-        }
-        if tx.leading_trim == figcraft_doc::LeadingTrim::CapHeight {
-            put("text-box", "trim-both cap alphabetic".into());
         }
     }
-    out
 }
 
 /// A gradient fill on a `w`×`h` box as a CSS background: linear along its handles' direction

crates/engine/src/dev/codegen/html.rs

@@ -1,5 +1,5 @@
 use super::css::{Tokens, css_decls};
-use super::*;
+use super::{CodeLang, Ctx, Document, LayoutMode, Node, NodeId, NodeKind, Param, Sizing, indent, num, with_v_if};
 
 // ------------------------------------------------------------------ HTML and React markup
 
@@ -127,6 +127,32 @@ pub(crate) struct Markup<'c, 'a> {
     pub fluid_leaves: f64,
 }
 
+/// How `n` sits in its parent: in the flex flow, or placed at its position.
+fn placement_decls(n: &Node, parent: Option<&Node>, root: bool, in_flow: bool) -> String {
+    let mut decls = String::new();
+    if root {
+        decls.push_str("position: relative;\n");
+    } else if in_flow {
+        let vertical = parent.and_then(|p| p.layout.as_ref()).is_some_and(|l| l.mode == LayoutMode::Vertical);
+        let (main, cross) =
+            if vertical { (n.child_layout.sizing_v, n.child_layout.sizing_h) } else { (n.child_layout.sizing_h, n.child_layout.sizing_v) };
+        if main == Sizing::Fill {
+            decls.push_str("flex: 1 1 0;\n");
+        }
+        if cross == Sizing::Fill {
+            decls.push_str("align-self: stretch;\n");
+        }
+    } else {
+        let c = n.transform.as_coeffs();
+        decls.push_str(&format!("position: absolute;\nleft: {}px;\ntop: {}px;\n", num(c[4]), num(c[5])));
+        let rot = figcraft_geom::rotation_degrees(n.transform);
+        if rot.abs() > 0.01 {
+            decls.push_str(&format!("transform: rotate({}deg);\ntransform-origin: 0 0;\n", num(-rot)));
+        }
+    }
+    decls
+}
+
 impl<'c, 'a> Markup<'c, 'a> {
     pub fn new(ctx: &'c Ctx<'a>, lang: CodeLang) -> Self {
         Markup {
@@ -196,6 +222,52 @@ impl<'c, 'a> Markup<'c, 'a> {
         self.rules.push((path.to_string(), class.to_string(), decls));
     }
 
+    /// An instance as a call to its component (see `element`); true when it was written.
+    fn instance_call(&mut self, n: &Node, depth: usize, path: &str, class: &str, decls: &str, root: bool) -> bool {
+        let pad = self.pad(depth);
+        let attr = if self.lang == CodeLang::React { "className" } else { "class" };
+        let connected = self.inline && crate::code_connect::link(self.ctx.doc, n.id, CodeLang::React).is_some();
+        if self.code() && (!self.inline || connected) && !root && matches!(n.kind, NodeKind::Instance { .. }) {
+            let at = depth + usize::from(!decls.is_empty());
+            let run = if self.lang == CodeLang::Leptos { ".run()" } else { "" };
+            let (inner, css) = match self.ctx.param(n, "mainComponent") {
+                Some(p) if self.lang == CodeLang::Vue => (Some(format!("{}<component :is=\"{}\" />\n", self.pad(at), self.ident(p))), String::new()),
+                Some(p) => (Some(format!("{}{{{}{run}}}\n", self.pad(at), self.ident(p))), String::new()),
+                None => self.ctx.call(n, self.lang, at).map_or((None, String::new()), |(code, css)| (Some(code), css)),
+            };
+            self.styles.push_str(&css);
+            if let Some(inner) = inner {
+                // A Vue guard set by `node` rides on the call when there is no wrapper.
+                let guard = if self.lang == CodeLang::Vue { self.v_if.take() } else { None };
+                if decls.is_empty() {
+                    self.markup.push_str(&with_v_if(&inner, guard.as_deref()));
+                } else {
+                    let guard = guard.map(|g| format!(" v-if=\"{g}\"")).unwrap_or_default();
+                    self.markup.push_str(&format!("{pad}<div {attr}=\"{class}\"{guard}>\n{inner}{pad}</div>\n"));
+                    self.rule(path, class, decls.to_string());
+                }
+                return true;
+            }
+        }
+        false
+    }
+
+    fn text_body(&self, n: &Node, t: &figcraft_doc::TextData) -> String {
+        match (self.ctx.param(n, "characters").filter(|_| self.code()), self.lang) {
+            (Some(p), CodeLang::Leptos) => format!("{{{}.clone()}}", self.ident(p)),
+            (Some(p), CodeLang::Vue) => format!("{{{{ {} }}}}", self.ident(p)),
+            (Some(p), _) => format!("{{{}}}", p.ident),
+            (None, CodeLang::React) => jsx_text(&t.characters),
+            // `view!` takes text as string literals and void elements self-closed.
+            (None, CodeLang::Leptos) => {
+                t.characters.chars().take(10_000).collect::<String>().lines().map(|l| format!("{l:?}")).collect::<Vec<_>>().join("<br/>")
+            }
+            // A Vue template reads `{{ }}` as interpolation, so braces are escaped.
+            (None, CodeLang::Vue) => html_escape(&t.characters).replace('{', "&#123;").replace('}', "&#125;"),
+            (None, _) => html_escape(&t.characters),
+        }
+    }
+
     fn element(&mut self, n: &Node, parent: Option<&Node>, depth: usize, path: &str) {
         let doc = self.ctx.doc;
         let root = n.id == self.ctx.root;
@@ -215,53 +287,13 @@ impl<'c, 'a> Markup<'c, 'a> {
         let pad = self.pad(depth);
         let attr = if self.lang == CodeLang::React { "className" } else { "class" };
         // How it sits in its parent: in the flex flow, or placed at its position.
-        let mut decls = String::new();
         let in_flow = parent.is_some_and(|p| p.layout.is_some()) && !n.child_layout.absolute;
-        if root {
-            decls.push_str("position: relative;\n");
-        } else if in_flow {
-            let vertical = parent.and_then(|p| p.layout.as_ref()).is_some_and(|l| l.mode == LayoutMode::Vertical);
-            let (main, cross) =
-                if vertical { (n.child_layout.sizing_v, n.child_layout.sizing_h) } else { (n.child_layout.sizing_h, n.child_layout.sizing_v) };
-            if main == Sizing::Fill {
-                decls.push_str("flex: 1 1 0;\n");
-            }
-            if cross == Sizing::Fill {
-                decls.push_str("align-self: stretch;\n");
-            }
-        } else {
-            let c = n.transform.as_coeffs();
-            decls.push_str(&format!("position: absolute;\nleft: {}px;\ntop: {}px;\n", num(c[4]), num(c[5])));
-            let rot = figcraft_geom::rotation_degrees(n.transform);
-            if rot.abs() > 0.01 {
-                decls.push_str(&format!("transform: rotate({}deg);\ntransform-origin: 0 0;\n", num(-rot)));
-            }
-        }
+        let mut decls = placement_decls(n, parent, root, in_flow);
         // Nested instances are calls (component code), in a wrapper that places them when needed.
         // Page code inlines instances, except those connected to code (codeConnect.set): their
         // snippet, e.g. a design-system `<Button>`.
-        let connected = self.inline && crate::code_connect::link(doc, n.id, CodeLang::React).is_some();
-        if self.code() && (!self.inline || connected) && !root && matches!(n.kind, NodeKind::Instance { .. }) {
-            let at = depth + usize::from(!decls.is_empty());
-            let run = if self.lang == CodeLang::Leptos { ".run()" } else { "" };
-            let (inner, css) = match self.ctx.param(n, "mainComponent") {
-                Some(p) if self.lang == CodeLang::Vue => (Some(format!("{}<component :is=\"{}\" />\n", self.pad(at), self.ident(p))), String::new()),
-                Some(p) => (Some(format!("{}{{{}{run}}}\n", self.pad(at), self.ident(p))), String::new()),
-                None => self.ctx.call(n, self.lang, at).map_or((None, String::new()), |(code, css)| (Some(code), css)),
-            };
-            self.styles.push_str(&css);
-            if let Some(inner) = inner {
-                // A Vue guard set by `node` rides on the call when there is no wrapper.
-                let guard = if self.lang == CodeLang::Vue { self.v_if.take() } else { None };
-                if decls.is_empty() {
-                    self.markup.push_str(&with_v_if(&inner, guard.as_deref()));
-                } else {
-                    let guard = guard.map(|g| format!(" v-if=\"{g}\"")).unwrap_or_default();
-                    self.markup.push_str(&format!("{pad}<div {attr}=\"{class}\"{guard}>\n{inner}{pad}</div>\n"));
-                    self.rule(path, &class, decls);
-                }
-                return;
-            }
+        if self.instance_call(n, depth, path, &class, &decls, root) {
+            return;
         }
         let hugs = n.layout.is_some() || matches!(n.kind, NodeKind::Text(_));
         let hug = (hugs && n.child_layout.sizing_h == Sizing::Hug, hugs && n.child_layout.sizing_v == Sizing::Hug);
@@ -286,19 +318,7 @@ impl<'c, 'a> Markup<'c, 'a> {
         let open = |tag: &str| format!("{pad}<{tag} {attr}=\"{class}\"{attrs}>");
         match &n.kind {
             NodeKind::Text(t) => {
-                let body = match (self.ctx.param(n, "characters").filter(|_| self.code()), self.lang) {
-                    (Some(p), CodeLang::Leptos) => format!("{{{}.clone()}}", self.ident(p)),
-                    (Some(p), CodeLang::Vue) => format!("{{{{ {} }}}}", self.ident(p)),
-                    (Some(p), _) => format!("{{{}}}", p.ident),
-                    (None, CodeLang::React) => jsx_text(&t.characters),
-                    // `view!` takes text as string literals and void elements self-closed.
-                    (None, CodeLang::Leptos) => {
-                        t.characters.chars().take(10_000).collect::<String>().lines().map(|l| format!("{l:?}")).collect::<Vec<_>>().join("<br/>")
-                    }
-                    // A Vue template reads `{{ }}` as interpolation, so braces are escaped.
-                    (None, CodeLang::Vue) => html_escape(&t.characters).replace('{', "&#123;").replace('}', "&#125;"),
-                    (None, _) => html_escape(&t.characters),
-                };
+                let body = self.text_body(n, t);
                 self.markup.push_str(&format!("{}{body}</p>\n", open("p")));
             }
             _ => {

crates/engine/src/dev/codegen/swift.rs

@@ -1,4 +1,4 @@
-use super::*;
+use super::{CodeLang, Color, Ctx, LayoutMode, Node, NodeId, NodeKind, drop_shadow, first_fill, indent, literal, num, radius, stroke_color};
 
 // ------------------------------------------------------------------ SwiftUI
 

crates/engine/src/dev/component_codegen.rs

@@ -7,13 +7,13 @@
 //! used by `inspect.code`. A component connected to code (see [`crate::code_connect`]) shows its
 //! real snippet instead.
 
-use figcraft_doc::*;
+use figcraft_doc::{Document, NodeId, NodeKind, PropDef};
 use serde_json::{Value, json};
 
 use crate::cmd::CommandSpec;
 use crate::codegen::{CodeLang, Ctx, Markup, arkui, class_name, compose, indent, literal, swift};
 use crate::components::{prop_default_value, slot_edited, slots_of, variant_options, variant_props, variant_set};
-use crate::params::*;
+use crate::params::{id_of, string, targets};
 use crate::{bad, spec};
 
 /// What a component property becomes in code.

crates/engine/src/dev/dev_resources.rs

@@ -7,12 +7,12 @@
 //! capped) and never fetched or opened by the engine. A link added without a name is named after
 //! its URL (no page title is looked up).
 
-use figcraft_doc::*;
+use figcraft_doc::{DevResource, Document, NodeId, NodeKind};
 use serde_json::{Value, json};
 
 use crate::cmd::CommandSpec;
 use crate::components::{inside_instance, variant_set};
-use crate::params::*;
+use crate::params::{get, req_index, targets};
 use crate::{Result, Session, bad, spec};
 
 /// Most dev resources on one layer.

crates/engine/src/dev/devcompare.rs

@@ -7,7 +7,7 @@
 
 use std::collections::BTreeSet;
 
-use figcraft_doc::*;
+use figcraft_doc::{DevStatus, Document, MAX_SNAPSHOT_NODES, Node, NodeId, NodeKind};
 use serde::Serialize;
 
 use crate::devinspect::{Prop, Section, properties};

crates/engine/src/dev/devinspect.rs

@@ -3,12 +3,15 @@
 //! one. The Inspect tab shows these, and `inspect.properties` returns them.
 
 use figcraft_color::{Color, GradientKind, Hsb, Hsl, PaintKind};
-use figcraft_doc::*;
+use figcraft_doc::{
+    AutoLayout, ContentAlign, CrossAlign, DevStatus, Document, EffectKind, ExportFormat, ExportSetting, LayoutMode, MainAlign, Node, NodeId,
+    NodeKind, NoiseMode, StrokeAlign, StyleId, TextAlignH, TextData, TextDecoration, Variable,
+};
 use serde::Serialize;
 use serde_json::{Value, json};
 
 use crate::cmd::CommandSpec;
-use crate::params::*;
+use crate::params::{get, id, id_of, string, targets};
 use crate::spec;
 
 /// One group of properties ("Layout", "Typography"…).