diff --git a/crates/ui-egui/src/present.rs b/crates/ui-egui/src/present.rs
index 9c0f1608..a538db4b 100644
--- a/crates/ui-egui/src/present.rs
+++ b/crates/ui-egui/src/present.rs
@@ -511,6 +511,16 @@ impl Presenter {
         self.rev += 1;
     }
 
+    /// After an action changed layers of `design` (since `before`): text resizes to what it shows,
+    /// instances follow and auto layout reflows, as after an edit on the canvas; then
+    /// [`relayout`](Self::relayout).
+    fn settle(&mut self, before: &Document) {
+        if let Some(d) = self.design.as_mut() {
+            figcraft_engine::normalize(d, before);
+        }
+        self.relayout();
+    }
+
     /// Responsive prototypes: resize the presented frame to a screen of `size` (None: frames
     /// keep their size). Lays out again only when it changes.
     fn respond_to(&mut self, size: Option<(f64, f64)>) {
@@ -879,28 +889,31 @@ impl Presenter {
                 }
                 self.begin(tr, dur, easing, now);
                 let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
                 if let Some(n) = d.node_mut(inst)
                     && let NodeKind::Instance { component, .. } = &mut n.kind
                 {
                     *component = *dest;
                 }
                 figcraft_engine::components::sync_instance(d, inst);
-                self.relayout();
+                self.settle(&before);
                 true
             }
             Action::SetVariable { variable, value, expr } => {
                 let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
                 let set = figcraft_engine::proto_run::set_variable(d, node, variable, value, expr.as_ref());
                 if set {
-                    self.relayout();
+                    self.settle(&before);
                 }
                 set
             }
             Action::SetVariableMode { collection, mode } => {
                 let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
                 let set = figcraft_engine::proto_run::set_mode(d, self.current, collection, mode);
                 if set {
-                    self.relayout();
+                    self.settle(&before);
                 }
                 set
             }
diff --git a/crates/ui-egui/src/present_behaviour_tests.rs b/crates/ui-egui/src/present_behaviour_tests.rs
index 791e0d3f..e9a036f2 100644
--- a/crates/ui-egui/src/present_behaviour_tests.rs
+++ b/crates/ui-egui/src/present_behaviour_tests.rs
@@ -454,6 +454,99 @@ fn interactive_components_change_in_place() {
     }
 }
 
+/// A hugging auto layout frame (in `parent`, else on the page) holding text `chars`: (frame, text).
+fn hugging_label(s: &mut Session, parent: Option<NodeId>, name: &str, x: f64, chars: &str) -> (NodeId, NodeId) {
+    let f = id(&ex(s, "frame.create", json!({"x": x, "y": 600, "width": 60, "height": 30, "name": name, "parent": parent})));
+    let t = id(&ex(s, "text.create", json!({"text": chars, "x": 0, "y": 0, "parent": f})));
+    ex(s, "node.set", json!({"ids": [f], "props": {"layout": "horizontal", "padding": 8, "sizingH": "hug", "sizingV": "hug"}}));
+    (f, t)
+}
+
+fn size(d: &Document, n: NodeId) -> (f64, f64) {
+    d.node(n).map(|n| (n.width, n.height)).unwrap()
+}
+
+#[test]
+fn change_to_lays_out_the_instance_around_its_own_content() {
+    // Change to shows the other variant in place: the instance keeps its overrides (a longer
+    // label), so it is laid out around them, as switching the variant on the canvas does.
+    figcraft_text::scan_system_fonts();
+    let mut s = Session::new();
+    let variants: Vec<NodeId> = ["Default", "Hover"]
+        .iter()
+        .enumerate()
+        .map(|(k, state)| {
+            let (f, _) = hugging_label(&mut s, None, &format!("State={state}"), k as f64 * 150.0, "Button");
+            id(&ex(&mut s, "component.create", json!({"ids": [f]})))
+        })
+        .collect();
+    let set = id(&ex(&mut s, "component.combineVariants", json!({"ids": variants.clone()})));
+    on(&mut s, variants[0], json!({"type": "onClick"}), json!({"type": "changeTo", "dest": variants[1]}), json!({"type": "instant"}), 0);
+    let screen = frame(&mut s, "Screen", 0.0, 400.0, 300.0);
+    let button = id(&ex(&mut s, "instance.create", json!({"component": set, "x": 20, "y": 20, "parent": screen})));
+    let label = s.doc().unwrap().node(button).unwrap().children[0];
+    ex(&mut s, "text.set", json!({"id": label, "characters": "A much longer label"}));
+    let (main, canvas, canvas_label) = {
+        let d = s.doc().unwrap();
+        (size(d, variants[1]), size(d, button), size(d, label))
+    };
+    // Without any font nothing is measured and both sizes are the main's.
+    if figcraft_text::layout_node(s.doc().unwrap().node(label).unwrap()).is_some_and(|(l, _)| !l.glyphs.is_empty()) {
+        assert!(canvas.0 > main.0 + 20.0, "on the canvas the instance hugs its longer label");
+    }
+    let mut p = player(s.doc().unwrap().clone(), screen);
+    assert!(p.fire(button, 0, None, 1.0));
+    let d = p.doc.as_ref().unwrap();
+    assert!(matches!(d.node(button).unwrap().kind, NodeKind::Instance { component, .. } if component == variants[1]));
+    assert_eq!((size(d, button), size(d, label)), (canvas, canvas_label), "the Hover variant, laid out around the instance's label");
+}
+
+/// A screen holding a hugging chip whose text is bound to string variable `label` of collection
+/// "Copy" (modes A "Short" and B "A much longer label"), the chip's click running `action`:
+/// (session, screen, chip, text).
+fn bound_chip(action: Value) -> (Session, NodeId, NodeId, NodeId) {
+    figcraft_text::scan_system_fonts();
+    let mut s = Session::new();
+    ex(&mut s, "variable.createCollection", json!({"name": "Copy", "modes": ["A", "B"]}));
+    ex(
+        &mut s,
+        "variable.create",
+        json!({"collection": "Copy", "name": "label", "type": "string", "values": {"A": "Short", "B": "A much longer label"}}),
+    );
+    let screen = frame(&mut s, "Screen", 0.0, 400.0, 300.0);
+    let (chip, text) = hugging_label(&mut s, Some(screen), "Chip", 20.0, "Short");
+    ex(&mut s, "variable.bind", json!({"ids": [text], "field": "characters", "variable": "label"}));
+    on(&mut s, chip, json!({"type": "onClick"}), action, json!({"type": "instant"}), 0);
+    (s, screen, chip, text)
+}
+
+#[test]
+fn set_variable_and_set_mode_lay_out_the_text_they_change() {
+    // A text bound to a string variable shows what an interaction sets, measured: the hugging
+    // chip around it grows with it, to the size the canvas gives the same text.
+    let cases = [
+        (
+            json!({"type": "setVariable", "variable": "label", "value": "A much longer label"}),
+            "variable.set",
+            json!({"variable": "label", "value": "A much longer label"}),
+        ),
+        (json!({"type": "setVariableMode", "collection": "Copy", "mode": "B"}), "variable.setMode", json!({"collection": "Copy", "mode": "B"})),
+    ];
+    for (action, canvas_cmd, canvas_params) in cases {
+        let (mut s, screen, chip, text) = bound_chip(action.clone());
+        let mut p = player(s.doc().unwrap().clone(), screen);
+        assert!(p.fire(chip, 0, None, 1.0), "{action}");
+        let page = s.doc().unwrap().page_of(screen).unwrap();
+        let mut params = canvas_params;
+        if canvas_cmd == "variable.setMode" {
+            params["ids"] = json!([page]);
+        }
+        ex(&mut s, canvas_cmd, params);
+        let (d, canvas) = (p.doc.as_ref().unwrap(), s.doc().unwrap());
+        assert_eq!((size(d, chip), size(d, text)), (size(canvas, chip), size(canvas, text)), "{action}: the chip grows with its text");
+    }
+}
+
 #[test]
 fn a_drag_started_transition_follows_the_pointer() {
     let (mut u, hot) = one_interaction(json!({"type": "onDrag"}), json!({"type": "push", "direction": "left"}), 400);
diff --git a/docs/prototyping-parity.md b/docs/prototyping-parity.md
index e4cf8c7f..3adb30c0 100644
--- a/docs/prototyping-parity.md
+++ b/docs/prototyping-parity.md
@@ -56,6 +56,7 @@ case pins the current behaviour).
 | Interactive components: every instance plays the interactions of the variant it shows; an interaction on the instance with the same trigger wins | **fixed** | instances played only interactions copied onto them when they were placed: an instance placed before its main got interactions did nothing, and one placed after kept the first variant's interactions after changing (a toggle went on but never off). New instances no longer copy them, and copies in older files give way to the variant shown; `instances_play_their_variants_interactions` |
 | Change to on a layer inside a nested instance changes the instance whose variant set holds the destination | **fixed** | the innermost instance (an icon inside a button) was changed instead |
 | Set variable, set variable mode, conditional | pass | `proto_run_tests`, `proto_conditional_tests`, `present_variables_tests` |
+| Change to, set variable and set variable mode lay out what they change as the canvas does: text sizes to what it shows, hugging frames around it | **fixed** | the player didn't lay out after them: an instance with a longer label changed to the main's width, and a bound text kept its old size; `change_to_lays_out_the_instance_around_its_own_content`, `set_variable_and_set_mode_lay_out_the_text_they_change` |
 | Expressions: a variable reads the mode where the interaction runs (a frame that chose a mode, else the page's); `name[Mode]` reads a given mode whatever is chosen; operators on numbers, text (`+` joins), booleans and comparisons | pass | `mode_lookups_read_a_given_mode_or_the_layers_current_one`, `proto_expr_mode_tests` |
 | Set variable mode, then a conditional or set variable later in the same interaction: they see the new mode | pass | `set_variable_mode_changes_what_later_expressions_read` |
 | A set variable writes every mode of the variable, so a lookup of any mode reads the new value; a frame inside the screen that chose a mode keeps it after set variable mode | silent | pinned as stated |