M3: .fig imports keep the properties variant layers are bound to

Each variant of a component set keeps a copy of the set's property
definitions (an id and a parentPropDefId, no name or type), and the
variant's layers and its instances' assignments use the copy's id. Those
copies were skipped, so imported variants lost every boolean, text and
instance swap binding, and instances lost their property values. In
Untitled UI (8,074 copies) an input's "Hint text" no longer followed its
property. A copy now names the definition it was made from.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/format/src/fig/map.rs

@@ -368,6 +368,9 @@ struct Mapper<'a> {
     blobs: Vec<&'a [u8]>,
     /// Component property definitions: id → (REST name "Name#id", type).
     prop_defs: BTreeMap<String, (String, &'a str)>,
+    /// The copies of a set's definitions each variant keeps (no name or type of their own; the
+    /// variant's layers and its instances' assignments use them): copy id → the definition's id.
+    prop_parents: BTreeMap<String, String>,
     /// File nodes by asset `key` and `version`: references can name a collection, variable or
     /// style as the asset instead of the guid, and the file carries the resources to resolve
     /// them (the collection node itself says the same `key`).
@@ -402,6 +405,7 @@ impl<'a> Mapper<'a> {
         let mut nodes = BTreeMap::new();
         let mut kids: BTreeMap<String, Vec<(&'a str, String)>> = BTreeMap::new();
         let mut prop_defs = BTreeMap::new();
+        let mut prop_parents = BTreeMap::new();
         let changes = msg.get("nodeChanges").map(Kv::list).unwrap_or_default();
         // The last change of a GUID wins; a REMOVED change deletes what came before it.
         for n in changes {
@@ -423,10 +427,11 @@ impl<'a> Mapper<'a> {
                 kids.entry(parent).or_default().push((p.get("position").and_then(Kv::str).unwrap_or(""), id.clone()));
             }
             for d in n.get("componentPropDefs").map(Kv::list).unwrap_or_default() {
-                if let (Some(did), Some(name), Some(ty)) =
-                    (d.get("id").and_then(guid), d.get("name").and_then(Kv::str), d.get("type").and_then(Kv::str))
-                {
+                let Some(did) = d.get("id").and_then(guid) else { continue };
+                if let (Some(name), Some(ty)) = (d.get("name").and_then(Kv::str), d.get("type").and_then(Kv::str)) {
                     prop_defs.insert(did.clone(), (format!("{name}#{did}"), ty));
+                } else if let Some(parent) = d.get("parentPropDefId").and_then(guid) {
+                    prop_parents.insert(did, parent);
                 }
             }
         }
@@ -450,6 +455,7 @@ impl<'a> Mapper<'a> {
             kids,
             blobs,
             prop_defs,
+            prop_parents,
             assets,
             styles: Obj::new(),
             components: Obj::new(),
@@ -651,7 +657,19 @@ impl<'a> Mapper<'a> {
     }
 
     fn is_instance_swap(&self, def: &Kv) -> Option<()> {
-        matches!(self.prop_defs.get(&guid(def)?), Some((_, "INSTANCE_SWAP"))).then_some(())
+        matches!(self.prop_def(&guid(def)?), Some((_, "INSTANCE_SWAP"))).then_some(())
+    }
+
+    /// The definition `def` names: its own, or the set's for a variant's copy of it.
+    fn prop_def(&self, def: &str) -> Option<&(String, &'a str)> {
+        let mut def = def;
+        for _ in 0..=MAX_DEPTH {
+            if let Some(found) = self.prop_defs.get(def) {
+                return Some(found);
+            }
+            def = self.prop_parents.get(def)?;
+        }
+        None
     }
 
     /// The branches of the internal canvas `id` that hold the `required_mains` (with the frames
@@ -1892,7 +1910,7 @@ impl<'a> Mapper<'a> {
             // Expanded frames must follow their main frame's source link. A direct slot reference
             // makes the engine resolve ownership against the instance, where the property is not defined.
             if !(field == "slot" && inst.is_some())
-                && let Some((name, _)) = self.prop_defs.get(&def)
+                && let Some((name, _)) = self.prop_def(&def)
             {
                 refs.insert(field.into(), json!(name));
             }
@@ -1945,7 +1963,7 @@ impl<'a> Mapper<'a> {
         let assignments = v.list("componentPropAssignments");
         let mut props = Obj::new();
         for a in assignments {
-            let Some((name, ty)) = a.get("defID").and_then(guid).and_then(|d| self.prop_defs.get(&d).cloned()) else { continue };
+            let Some((name, ty)) = a.get("defID").and_then(guid).and_then(|d| self.prop_def(&d).cloned()) else { continue };
             let val = a.get("value");
             let p = match ty {
                 "BOOL" => val.and_then(|x| x.get("boolValue")).and_then(Kv::bool).map(|b| json!({"type": "BOOLEAN", "value": b})),
@@ -2031,7 +2049,7 @@ impl<'a> Mapper<'a> {
                 all_props.entry(d).or_insert(val);
             }
             let Some(def) = a.get("defID").and_then(guid) else { continue };
-            if self.prop_defs.get(&def).is_none_or(|(_, ty)| *ty != "SLOT") {
+            if self.prop_def(&def).is_none_or(|(_, ty)| *ty != "SLOT") {
                 continue;
             }
             let var_value = a.get("varValue");

crates/format/src/fig/mod.rs

@@ -26,6 +26,8 @@ pub mod kiwi;
 mod map;
 mod network;
 #[cfg(test)]
+mod prop_value_tests;
+#[cfg(test)]
 mod slot_tests;
 #[cfg(test)]
 mod source_identity_tests;

crates/format/src/fig/prop_value_tests.rs

@@ -0,0 +1,107 @@
+//! Component properties as current `.fig` files write them, on synthetic messages: the copy of a
+//! set's definitions each variant keeps (`parentPropDefId`, no name or type of its own).
+
+use figcraft_doc::NodeKind;
+use serde_json::Value;
+
+use super::kiwi::Kv;
+use super::map::to_rest;
+
+fn g(local: u32) -> Kv<'static> {
+    Kv::Object(vec![("sessionID", Kv::Uint(9)), ("localID", Kv::Uint(u64::from(local)))])
+}
+
+fn o(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn s(text: &str) -> Kv<'static> {
+    Kv::Str(text.into())
+}
+
+fn node(local: u32, kind: &'static str, name: &str, parent: Option<u32>, mut fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    let mut all = vec![("guid", g(local)), ("type", Kv::Enum(kind)), ("name", s(name))];
+    if let Some(parent) = parent {
+        all.push(("parentIndex", o(vec![("guid", g(parent)), ("position", s("!"))])));
+    }
+    all.append(&mut fields);
+    o(all)
+}
+
+/// A layer's `field` bound to property definition `def`.
+fn bound(field: &'static str, def: u32) -> (&'static str, Kv<'static>) {
+    let entry = o(vec![
+        ("variableField", Kv::Enum(field)),
+        ("variableData", o(vec![("value", o(vec![("propRefValue", o(vec![("defId", g(def))]))])), ("dataType", Kv::Enum("PROP_REF"))])),
+    ]);
+    ("parameterConsumptionMap", o(vec![("entries", Kv::Array(vec![entry]))]))
+}
+
+fn definition(id: u32, name: &str, kind: &'static str, initial: Kv<'static>) -> Kv<'static> {
+    o(vec![("id", g(id)), ("name", s(name)), ("type", Kv::Enum(kind)), ("initialValue", initial)])
+}
+
+fn message(nodes: Vec<Kv<'static>>) -> Kv<'static> {
+    let mut all = vec![node(1, "DOCUMENT", "Document", None, vec![]), node(2, "CANVAS", "Page", Some(1), vec![])];
+    all.extend(nodes);
+    o(vec![("nodeChanges", Kv::Array(all))])
+}
+
+fn by_id<'v>(v: &'v Value, id: &str) -> &'v Value {
+    fn find<'v>(v: &'v Value, id: &str) -> Option<&'v Value> {
+        if v.get("id").and_then(Value::as_str) == Some(id) {
+            return Some(v);
+        }
+        v.get("children").and_then(Value::as_array).into_iter().flatten().find_map(|v| find(v, id))
+    }
+    find(v, id).unwrap_or_else(|| panic!("no layer {id}"))
+}
+
+fn instance_props(doc: &figcraft_doc::Document) -> &std::collections::BTreeMap<String, Value> {
+    let instance = doc.ids().filter_map(|id| doc.node(id)).find(|n| n.name == "Instance").unwrap();
+    let NodeKind::Instance { props, .. } = &instance.kind else { panic!("not an instance") };
+    props
+}
+
+#[test]
+fn variant_layers_bind_to_the_set_properties_their_copies_name() {
+    let msg = message(vec![
+        node(
+            9,
+            "FRAME",
+            "Field",
+            Some(2),
+            vec![
+                ("isStateGroup", Kv::Bool(true)),
+                ("componentPropDefs", Kv::Array(vec![definition(70, "Hint", "BOOL", o(vec![("boolValue", Kv::Bool(true))]))])),
+            ],
+        ),
+        node(
+            10,
+            "SYMBOL",
+            "State=Default",
+            Some(9),
+            vec![("componentPropDefs", Kv::Array(vec![o(vec![("id", g(71)), ("parentPropDefId", g(70))])]))],
+        ),
+        node(11, "TEXT", "Hint text", Some(10), vec![bound("VISIBLE", 71)]),
+        node(
+            20,
+            "INSTANCE",
+            "Instance",
+            Some(2),
+            vec![
+                ("symbolData", o(vec![("symbolID", g(10))])),
+                ("componentPropAssignments", Kv::Array(vec![o(vec![("defID", g(71)), ("value", o(vec![("boolValue", Kv::Bool(false))]))])])),
+            ],
+        ),
+    ]);
+    let (rest, _, _) = to_rest(&msg, "Synthetic", crate::rest::MAX_NODES);
+    assert_eq!(by_id(&rest["document"], "9:9")["componentPropertyDefinitions"]["Hint#9:70"]["type"], "BOOLEAN");
+    assert_eq!(by_id(&rest["document"], "9:11")["componentPropertyReferences"]["visible"], "Hint#9:70");
+    assert_eq!(by_id(&rest["document"], "9:20")["componentProperties"]["Hint#9:70"]["value"], false);
+
+    let (doc, _) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
+    let hint = doc.ids().filter_map(|id| doc.node(id)).find(|n| n.name == "Hint text" && n.source.is_none()).unwrap();
+    assert_eq!(hint.prop_refs.get("visible").map(String::as_str), Some("Hint"));
+    assert_eq!(instance_props(&doc).get("Hint"), Some(&Value::Bool(false)));
+}