diff --git a/crates/doc/src/orient.rs b/crates/doc/src/orient.rs
index e524d6ca37..a2ff76d83f 100644
--- a/crates/doc/src/orient.rs
+++ b/crates/doc/src/orient.rs
@@ -3,6 +3,8 @@
 //! square to it: scaling by a side handle stretches it along its own width or height. Path
 //! geometry is still baked; Object ▸ Transform ▸ Reset Bounding Box sets the angle back to 0.
 
+use std::sync::Arc;
+
 use vectorcraft_geom::{Affine, Point, Rect, Vec2, normalize_deg, union_opt};
 
 use crate::{Document, Node, NodeId, NodeKind, SymbolBoxes};
@@ -84,7 +86,35 @@ pub fn transformed_angle(angle: f64, a: Affine) -> f64 {
     }
 }
 
+/// The turn (counter-clockwise degrees) from the boxes of art placed by a symbol instance's
+/// transform `xf` to the instance's own box at `angle`: 0 while the box turns with the transform,
+/// otherwise the change Reset Bounding Box made to it. Under a mirroring `xf` the instance's box can
+/// stand 180° from the one `xf` gives in one step ([`transformed_angle`] keeps the angle nearer the
+/// one before at each step); the turn is then 180°, so the art's boxes match the instance's.
+pub fn placed_turn(angle: f64, xf: Affine) -> f64 {
+    let turn = normalize_deg(angle - transformed_angle(0.0, xf));
+    if turn.is_finite() && turn.abs() > EPS_DEG { turn } else { 0.0 }
+}
+
 impl Node {
+    /// Turns the box of this object, and of every object that turns with it ([`Node::transform`]:
+    /// its children and the art of a linked opacity mask), by `by` degrees counter-clockwise.
+    /// Layers have no box.
+    pub fn turn_boxes(&mut self, by: f64) {
+        if !self.is_layer() {
+            let a = normalize_deg(self.bbox_angle + by);
+            self.bbox_angle = if a.abs() <= EPS_DEG { 0.0 } else { a };
+        }
+        for c in self.children_mut().into_iter().flatten() {
+            Arc::make_mut(c).turn_boxes(by);
+        }
+        if let Some(m) = self.extras_if_any().and_then(|e| e.mask.as_mut())
+            && m.linked
+        {
+            Arc::make_mut(&mut m.art).turn_boxes(by);
+        }
+    }
+
     /// Bounds of this object as `a` would place it (geometric, or `visual` with its strokes),
     /// without changing it, symbol instances measured by their art from `symbols`
     /// ([`Node::geometric_bounds_with`]).
@@ -185,6 +215,44 @@ mod tests {
         assert_eq!(transformed_angle(30.0, Affine::scale(0.0)), 30.0);
     }
 
+    #[test]
+    fn placed_turn_is_what_reset_bounding_box_took_off_the_instance() {
+        let xf = Affine::translate((40.0, 10.0)) * rot(20.0) * Affine::scale_non_uniform(2.0, 0.5);
+        // The box turns with the transform: no turn.
+        assert_eq!(placed_turn(transformed_angle(0.0, xf), xf), 0.0);
+        assert_eq!(placed_turn(0.0, Affine::scale(3.0)), 0.0);
+        // Reset to 0: the placed art turns back by the 20°.
+        assert!(close(placed_turn(0.0, xf), -20.0));
+        // Mirrored: turned 170° and then flipped, the instance's box stands 180° from the box the
+        // whole transform gives in one step, and the art turns the half turn to match it.
+        let flip = Affine::scale_non_uniform(1.0, -1.0);
+        let flipped = flip * rot(170.0);
+        let stepwise = transformed_angle(transformed_angle(0.0, rot(170.0)), flip);
+        assert!(close(stepwise, -170.0) && close(transformed_angle(0.0, flipped), 10.0));
+        assert!(close(placed_turn(stepwise, flipped).abs(), 180.0));
+        assert!(close(normalize_deg(placed_turn(0.0, flipped) + transformed_angle(0.0, flipped)), 0.0));
+        // Degenerate and non-finite transforms turn nothing.
+        assert_eq!(placed_turn(0.0, Affine::scale(0.0)), 0.0);
+        assert_eq!(placed_turn(f64::NAN, xf), 0.0);
+    }
+
+    #[test]
+    fn turn_boxes_turns_children_and_linked_mask_art_but_not_layers() {
+        let mut d = Document::new(500.0, 500.0);
+        let a = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default_art());
+        let mut g = Node::group(d.alloc_id(), vec![Arc::new(a.clone())]);
+        g.bbox_angle = 170.0;
+        g.extras_mut().mask = Some(Box::new(crate::OpacityMask::new(a.clone(), true)));
+        let mut layer = (*d.layers[0]).clone();
+        layer.children_mut().unwrap().push(Arc::new(g));
+        layer.turn_boxes(20.0);
+        assert_eq!(layer.bbox_angle, 0.0);
+        let g = &layer.children().unwrap()[0];
+        assert!(close(g.bbox_angle, -170.0), "wraps to (-180, 180]");
+        assert!(close(g.children().unwrap()[0].bbox_angle, 20.0));
+        assert!(close(g.extras().mask.as_ref().unwrap().art.bbox_angle, 20.0));
+    }
+
     #[test]
     fn oriented_bounds_hug_a_rotated_rectangle() {
         let mut d = Document::new(500.0, 500.0);
diff --git a/crates/doc/src/symbol_nine_slice.rs b/crates/doc/src/symbol_nine_slice.rs
index 53f84e869c..3c8c1b324d 100644
--- a/crates/doc/src/symbol_nine_slice.rs
+++ b/crates/doc/src/symbol_nine_slice.rs
@@ -614,6 +614,8 @@ impl NineSliceMap {
     /// `n`, whose box at the natural size is `b`, drawn in each cell it reaches: a clip group of
     /// the cell around a copy placed by the cell's map, all in a group with `n`'s id. `n` placed
     /// by `center` when it draws symbol art ([`draws_symbol_art`]), and in [`Self::place_unclipped`].
+    /// The clip groups and clip paths take the angle of the cell map that places them. The group
+    /// and each copy keep `n`'s box angle, turned by the map that places them.
     ///
     /// The drop shadows, outer glows and blurs ([`PAINTED_EFFECTS`]) at the end of `n`'s own
     /// effects, after its last other visible effect, go on that group with its opacity, blending
@@ -647,11 +649,15 @@ impl NineSliceMap {
                 area.transform(local);
                 let mut clip = Node::new(NodeId(0), NodeKind::Path { path: area, rule: FillRule::NonZero, live: None, clipping: true, guide: false });
                 clip.appearance = Appearance::default().into();
+                clip.bbox_angle = crate::orient::transformed_angle(0.0, local);
                 let copy = transformed(n, local * self.natural);
-                cells.push(Arc::new(Node::new(NodeId(0), NodeKind::Group { children: vec![Arc::new(clip), Arc::new(copy)], clip: true })));
+                let mut cell = Node::new(NodeId(0), NodeKind::Group { children: vec![Arc::new(clip), Arc::new(copy)], clip: true });
+                cell.bbox_angle = crate::orient::transformed_angle(0.0, local);
+                cells.push(Arc::new(cell));
             }
         }
         let mut out = Node::group(n.id, cells);
+        out.bbox_angle = crate::orient::transformed_angle(n.bbox_angle, center);
         out.visible = n.visible;
         out.locked = n.locked;
         out.name = n.name.clone();
diff --git a/crates/effects/src/live.rs b/crates/effects/src/live.rs
index 2c02f886c0..5a878d42d3 100644
--- a/crates/effects/src/live.rs
+++ b/crates/effects/src/live.rs
@@ -23,15 +23,22 @@ pub fn text_outliner() -> Outliner<'static> {
 /// Type outlined, or a symbol instance as its symbol's art (from `doc`) placed by the instance,
 /// through the symbol's 9-slice guides when it has them ([`Document::place_symbol_art`], `None`
 /// past its object limit). As an [`OutlineHook`](crate::OutlineHook), it gives compound shapes and
-/// Pathfinder operations the symbol instances among their members.
+/// Pathfinder operations the symbol instances among their members. The group around the art takes
+/// the instance's box angle, and the art's boxes turn with it, as Break Link turns them.
 pub fn outline_object(doc: Option<&Document>, n: &Node) -> Option<Node> {
     match &n.kind {
         NodeKind::SymbolInstance { symbol, xf } => {
             let doc = doc?;
             let sym = doc.symbols.iter().find(|s| s.name == *symbol)?;
             let art = vectorcraft_doc::symbol_overrides::dynamic_art(&sym.art, n);
-            let art = doc.place_symbol_art(symbol, &art, *xf)?;
-            Some(Node::group(n.id, vec![Arc::new(art)]))
+            let mut art = doc.place_symbol_art(symbol, &art, *xf)?;
+            let turn = vectorcraft_doc::orient::placed_turn(n.bbox_angle, *xf);
+            if turn != 0.0 {
+                art.turn_boxes(turn);
+            }
+            let mut out = Node::group(n.id, vec![Arc::new(art)]);
+            out.bbox_angle = n.bbox_angle;
+            Some(out)
         }
         _ => outline_text(n),
     }
diff --git a/crates/effects/src/tests.rs b/crates/effects/src/tests.rs
index 627cc1be03..0023fc5b16 100644
--- a/crates/effects/src/tests.rs
+++ b/crates/effects/src/tests.rs
@@ -1570,6 +1570,27 @@ fn outline_object_is_a_geometry_effect_that_keeps_the_path() {
     assert_eq!(apply_geometry(&[fx("path.outlineObject", json!({})), offset.clone()], &square(), b), apply_geometry(&[offset], &square(), b));
 }
 
+/// A symbol instance given to Pathfinder and compound shapes as its art: the group takes the
+/// instance's box angle and the art turns with it, turned with the instance or reset to 0.
+#[test]
+fn outline_object_turns_an_instances_art_with_its_box() {
+    use std::sync::Arc;
+
+    use vectorcraft_doc::orient::transformed_angle;
+    use vectorcraft_doc::{Appearance, Document, NodeId, Symbol};
+    let mut d = Document::new(500.0, 500.0);
+    d.symbols.push(Symbol { dynamic: false, name: "s".into(), art: Arc::new(Node::path(NodeId(0), square(), Appearance::default())) });
+    let xf = Affine::translate((200.0, 100.0)) * Affine::rotate(0.35);
+    for box_angle in [transformed_angle(0.0, xf), 0.0] {
+        let mut inst = Node::new(NodeId(3), NodeKind::SymbolInstance { symbol: "s".into(), xf });
+        inst.bbox_angle = box_angle;
+        let out = outline_object(Some(&d), &inst).unwrap();
+        let mut angles = vec![];
+        out.walk(&mut |c| angles.push(c.bbox_angle));
+        assert!(angles.len() == 2 && angles.iter().all(|a| close(*a, box_angle, 1e-9)), "{box_angle}: {angles:?}");
+    }
+}
+
 #[test]
 fn convert_to_shape_sizes() {
     let r = run("convertToShape.rectangle", json!({"extraW": 20, "extraH": 10}), &square()).bounds().unwrap();
diff --git a/crates/engine/src/cmd/brushsym.rs b/crates/engine/src/cmd/brushsym.rs
index 50c63b59cd..32b0f9fcd0 100644
--- a/crates/engine/src/cmd/brushsym.rs
+++ b/crates/engine/src/cmd/brushsym.rs
@@ -226,7 +226,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Break Link to Symbol",
             [],
             None,
-            "{ids?|id?} expand selected instances into plain art (with their appearance changes to a dynamic symbol), placed through the symbol's 9-slice guides when it has them, with the instance's opacity mask; a hidden or locked instance's art stays hidden or locked and is not selected → {ids}",
+            "{ids?|id?} expand selected instances into plain art (with their appearance changes to a dynamic symbol), placed through the symbol's 9-slice guides when it has them, with the instance's opacity mask and its own bounding box (square after Reset Bounding Box); a hidden or locked instance's art stays hidden or locked and is not selected → {ids}",
             has_selection,
             symbol_break_link
         ),
diff --git a/crates/engine/src/cmd/brushsym/symbols.rs b/crates/engine/src/cmd/brushsym/symbols.rs
index 2fb31c5f6b..1bfb8edea7 100644
--- a/crates/engine/src/cmd/brushsym/symbols.rs
+++ b/crates/engine/src/cmd/brushsym/symbols.rs
@@ -393,8 +393,10 @@ pub(super) fn symbol_place(s: &mut Session, p: &Value) -> Result<Value> {
 
 /// The plain art of instance `inst` in document space (fresh ids), with the instance's own
 /// appearance changes to a dynamic symbol's art when `own`, placed through its symbol's 9-slice
-/// guides when it has them. The instance's opacity mask goes on the art, or on a group around it
-/// when the art has a mask of its own.
+/// guides when it has them. The art's bounding boxes turn with the instance's own box, so after
+/// Reset Bounding Box they stand as the instance's box does. The instance's opacity mask goes on
+/// the art, or on a group around it when the art has a mask of its own; a group added around the
+/// art takes the instance's box angle.
 fn expanded_instance(d: &mut Document, inst: &Node, own: bool) -> Option<Node> {
     let NodeKind::SymbolInstance { symbol, xf } = &inst.kind else { return None };
     let sym = d.symbols.iter().find(|s| &s.name == symbol)?;
@@ -402,12 +404,17 @@ fn expanded_instance(d: &mut Document, inst: &Node, own: bool) -> Option<Node> {
     if let Some((color, amount)) = brush::stain(inst) {
         brush::tint_node(&mut art, &color, amount);
     }
-    let art = d.place_symbol_art(symbol, &art, *xf)?;
+    let mut art = d.place_symbol_art(symbol, &art, *xf)?;
+    let turn = vectorcraft_doc::orient::placed_turn(inst.bbox_angle, *xf);
+    if turn != 0.0 {
+        art.turn_boxes(turn);
+    }
     let mut art = d.reid(&art);
     if inst.opacity < 1.0 || inst.blend != vectorcraft_color::BlendMode::Normal {
         if !matches!(art.kind, NodeKind::Group { .. }) {
             let id = d.alloc_id();
             art = Node::group(id, vec![Arc::new(art)]);
+            art.bbox_angle = inst.bbox_angle;
         }
         art.opacity *= inst.opacity;
         art.blend = inst.blend;
@@ -416,6 +423,7 @@ fn expanded_instance(d: &mut Document, inst: &Node, own: bool) -> Option<Node> {
         if art.extras().mask.is_some() {
             let id = d.alloc_id();
             art = Node::group(id, vec![Arc::new(art)]);
+            art.bbox_angle = inst.bbox_angle;
         }
         art.extras_mut().mask = Some(mask.clone());
     }
diff --git a/crates/engine/src/tests/bboxrotate.rs b/crates/engine/src/tests/bboxrotate.rs
index aa1c14885c..6dc1c9b410 100644
--- a/crates/engine/src/tests/bboxrotate.rs
+++ b/crates/engine/src/tests/bboxrotate.rs
@@ -560,6 +560,125 @@ fn reset_bounding_box_then_release_intertwine() {
     reset_then_release("object.intertwine.make", "object.intertwine.release");
 }
 
+/// A symbol of two rectangles, the first turned `inner` degrees before the symbol is made, placed
+/// as an instance that is then turned 20°.
+fn turned_instance(inner: f64) -> (Session, NodeId) {
+    let mut s = session();
+    let a = rect(&mut s, 100.0, 100.0, 100.0, 50.0);
+    let b = rect(&mut s, 150.0, 220.0, 100.0, 50.0);
+    if inner != 0.0 {
+        sel(&mut s, &[a]);
+        s.execute("object.rotate", &json!({"angle": inner})).unwrap();
+    }
+    sel(&mut s, &[a, b]);
+    let inst = id_of(&s.execute("symbol.new", &json!({"name": "Pair"})).unwrap());
+    sel(&mut s, &[inst]);
+    s.execute("object.rotate", &json!({"angle": 20})).unwrap();
+    assert!(near(angle(&s, inst), 20.0));
+    (s, inst)
+}
+
+/// Break Link and Expand with the parameters that turn instance `inst` into its art.
+fn expand_instance(s: &mut Session, command: &str, inst: NodeId) {
+    sel(s, &[inst]);
+    let params = if command == "symbol.breakLink" { json!({"ids": [inst.0]}) } else { json!({"object": true, "fill": false, "stroke": false}) };
+    s.execute(command, &params).unwrap();
+    assert!(s.doc().unwrap().doc.node(inst).is_none_or(|n| !matches!(n.kind, vectorcraft_doc::NodeKind::SymbolInstance { .. })), "{command}");
+}
+
+/// The angles of the objects inside the document's only top-level object, that object included.
+fn art_angles(s: &Session) -> Vec<f64> {
+    let d = &s.doc().unwrap().doc;
+    let layer = d.layers.first().unwrap();
+    let top = layer.children().unwrap();
+    assert_eq!(top.len(), 1);
+    let mut out = vec![];
+    subtree_angles(&top[0], &mut out);
+    out
+}
+
+#[test]
+fn reset_bounding_box_then_expand_symbol_instance() {
+    for command in ["symbol.breakLink", "object.expand"] {
+        let (mut s, inst) = turned_instance(0.0);
+        assert_eq!(s.execute("object.resetBoundingBox", &json!({})).unwrap()["changed"], 1);
+        assert_eq!(angle(&s, inst), 0.0);
+        expand_instance(&mut s, command, inst);
+        let angles = art_angles(&s);
+        assert!(angles.len() >= 2 && angles.iter().all(|a| near(*a, 0.0)), "{command}: {angles:?}");
+        s.execute("select.all", &json!({})).unwrap();
+        assert_eq!(selection_box(&s).angle, 0.0, "{command}");
+    }
+}
+
+#[test]
+fn expanding_a_turned_symbol_instance_keeps_its_angle() {
+    for command in ["symbol.breakLink", "object.expand"] {
+        let (mut s, inst) = turned_instance(0.0);
+        expand_instance(&mut s, command, inst);
+        let angles = art_angles(&s);
+        assert!(angles.len() >= 2 && angles.iter().all(|a| near(*a, 20.0)), "{command}: {angles:?}");
+    }
+}
+
+#[test]
+fn reset_bounding_box_then_expand_keeps_the_angles_inside_the_symbol() {
+    for command in ["symbol.breakLink", "object.expand"] {
+        let (mut s, inst) = turned_instance(30.0);
+        s.execute("object.resetBoundingBox", &json!({})).unwrap();
+        expand_instance(&mut s, command, inst);
+        // The turned rectangle keeps the 30° it had in the symbol; the rest stand square.
+        let mut angles = art_angles(&s);
+        angles.sort_by(f64::total_cmp);
+        assert!(near(*angles.last().unwrap(), 30.0) && angles[..angles.len() - 1].iter().all(|a| near(*a, 0.0)), "{command}: {angles:?}");
+    }
+}
+
+/// The group that an instance's opacity adds around the art of a one-object symbol stands as the
+/// instance's box does, turned or reset.
+#[test]
+fn expanding_a_faded_symbol_instance_gives_its_group_the_instance_box() {
+    for command in ["symbol.breakLink", "object.expand"] {
+        for reset in [false, true] {
+            let mut s = session();
+            let a = rect(&mut s, 100.0, 100.0, 100.0, 50.0);
+            sel(&mut s, &[a]);
+            let inst = id_of(&s.execute("symbol.new", &json!({"name": "One"})).unwrap());
+            sel(&mut s, &[inst]);
+            s.execute("object.rotate", &json!({"angle": 20})).unwrap();
+            s.execute("object.setProps", &json!({"ids": [inst.0], "opacity": 50})).unwrap();
+            if reset {
+                s.execute("object.resetBoundingBox", &json!({})).unwrap();
+            }
+            expand_instance(&mut s, command, inst);
+            let want = if reset { 0.0 } else { 20.0 };
+            let angles = art_angles(&s);
+            assert!(angles.len() == 2 && angles.iter().all(|a| near(*a, want)), "{command}, reset {reset}: {angles:?}");
+        }
+    }
+}
+
+/// A mirrored instance: turned 170° and then reflected, its box stands 180° from the box its
+/// transform gives in one step. The art takes the instance's box, and stands square after a reset.
+#[test]
+fn expanding_a_reflected_symbol_instance_keeps_its_box() {
+    for command in ["symbol.breakLink", "object.expand"] {
+        for reset in [false, true] {
+            let (mut s, inst) = turned_instance(0.0);
+            s.execute("object.rotate", &json!({"angle": 150})).unwrap();
+            s.execute("object.reflect", &json!({"axis": "horizontal"})).unwrap();
+            assert!(near(angle(&s, inst), -170.0), "{}", angle(&s, inst));
+            if reset {
+                s.execute("object.resetBoundingBox", &json!({})).unwrap();
+            }
+            let want = angle(&s, inst);
+            expand_instance(&mut s, command, inst);
+            let angles = art_angles(&s);
+            assert!(angles.len() >= 2 && angles.iter().all(|a| near(*a, want)), "{command}, reset {reset}: {angles:?}");
+        }
+    }
+}
+
 #[test]
 fn reset_bounding_box_then_release_linked_opacity_mask() {
     let mut s = session();
diff --git a/crates/engine/src/tests/symbol_nine_slice.rs b/crates/engine/src/tests/symbol_nine_slice.rs
index b0689d1587..cba8b8c984 100644
--- a/crates/engine/src/tests/symbol_nine_slice.rs
+++ b/crates/engine/src/tests/symbol_nine_slice.rs
@@ -20,9 +20,18 @@ fn close(a: Rect, b: Rect) -> bool {
 /// A 100 × 100 frame with a 10 × 10 square in its top-left corner and one in its center, made
 /// into symbol "Panel" with 9-slice guides on, its instance selected at its natural size.
 fn panel_symbol() -> (Session, NodeId) {
+    panel_symbol_filled(None)
+}
+
+/// [`panel_symbol`] with the frame filled with `fill` when there is one.
+fn panel_symbol_filled(fill: Option<vectorcraft_color::Paint>) -> (Session, NodeId) {
     let mut s = Session::new();
     s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
     let ids = [rect(&mut s, 50.0, 50.0, 100.0, 100.0), rect(&mut s, 50.0, 50.0, 10.0, 10.0), rect(&mut s, 95.0, 95.0, 10.0, 10.0)];
+    if let Some(fill) = fill {
+        let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+        doc.node_mut(ids[0]).unwrap().appearance = vectorcraft_doc::Appearance::basic(fill, vectorcraft_color::Paint::None, 0.0).into();
+    }
     s.select(|_, sel| sel.set(ids)).unwrap();
     let r = s.execute("symbol.new", &json!({"name": "Panel", "nineSlice": true})).unwrap();
     assert_eq!(r["nineSlice"], json!([0.25, 0.25, 0.25, 0.25]));
@@ -350,3 +359,39 @@ fn guides_outside_the_art_survive_saving_and_reopening_a_native_file() {
         assert!(back.symbol_slice_map(symbol, *xf).is_none(), "{bad}: scaled as a whole");
     }
 }
+
+/// [`panel_symbol`] with a gradient on the frame, so that the frame is drawn in a clip group for
+/// each cell, its instance resized to 200 × 150 and turned 20°.
+fn turned_gradient_panel() -> (Session, NodeId) {
+    let gradient = vectorcraft_color::Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default())));
+    let (mut s, id) = panel_symbol_filled(Some(gradient));
+    s.execute("object.setBounds", &json!({"x": 50, "y": 50, "width": 200, "height": 150, "reference": 0})).unwrap();
+    s.execute("object.rotate", &json!({"angle": 20})).unwrap();
+    (s, id)
+}
+
+/// The bounding box angles of the objects under the art that replaced an instance, and whether
+/// that art holds a clip group.
+fn expanded_angles(s: &Session, art: NodeId) -> (Vec<f64>, bool) {
+    let (mut angles, mut clips) = (vec![], false);
+    s.doc().unwrap().doc.node(art).unwrap().walk(&mut |c| {
+        angles.push(c.bbox_angle);
+        clips |= matches!(c.kind, NodeKind::Group { clip: true, .. });
+    });
+    (angles, clips)
+}
+
+#[test]
+fn break_link_turns_the_cells_of_a_sliced_instance_with_its_box() {
+    for reset in [false, true] {
+        let (mut s, _) = turned_gradient_panel();
+        if reset {
+            assert_eq!(s.execute("object.resetBoundingBox", &json!({})).unwrap()["changed"], 1);
+        }
+        let r = s.execute("symbol.breakLink", &json!({})).unwrap();
+        let (angles, clips) = expanded_angles(&s, NodeId(r["ids"][0].as_u64().unwrap()));
+        assert!(clips, "the frame is drawn in clip groups");
+        let want = if reset { 0.0 } else { 20.0 };
+        assert!(angles.iter().all(|a| (a - want).abs() < 1e-6), "reset {reset}: {angles:?}");
+    }
+}
diff --git a/docs/mcp.md b/docs/mcp.md
index f756bc8c97..40c873cadf 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -2991,7 +2991,8 @@ already walks Image Trace. Short agent entry points:
   a symbol with guides keeps its corners at their size, and `symbol.breakLink` gives its art as it draws; dragging a
   guide on the canvas in symbol editing mode sends `nineSliceGuides` in one undo step; `type` is
   Symbol Type, `static` by default for the command and `dynamic` by default in the Symbol Options dialog),
-  `symbol.place {name?, x?, y?}`, `symbol.breakLink {ids?}` (the art keeps the instance's opacity mask; a hidden or locked instance's
+  `symbol.place {name?, x?, y?}`, `symbol.breakLink {ids?}` (the art keeps the instance's opacity mask and its bounding box, square after
+  `object.resetBoundingBox`; a hidden or locked instance's
   art stays hidden or locked and is not selected), `symbol.replace`,
   `symbol.edit {id?, ids?, name?, x?, y?, artboard?, viewCenter?}` (symbol editing mode: the symbol's art on a temporary
   isolated layer, where the instance `id` shows it or centered on (x, y), by default on the center of artboard
@@ -8129,7 +8130,9 @@ square to the page. `object.resetBoundingBox` squares the box again without movi
 object inside the selected ones: the children of groups, compound paths, clip groups, blends, envelopes, repeats and
 intertwines, and the art of linked opacity masks (an unlinked mask's art keeps its angle). Ungroup, Release Clipping
 Mask, Release Compound Path, Blend Expand, Release Envelope, Release Repeat, Release Intertwine and Release Opacity Mask
-then bring back boxes square to the page.
+then bring back boxes square to the page. `symbol.breakLink` and `object.expand` give a symbol instance's art the
+instance's own box: after a reset the art stands square to the page, and an object turned inside the symbol keeps its
+angle relative to the instance's box.
 
 ```json
 {"name":"run_command","arguments":{"command":"object.rotate","params":{"angle":45,"absolute":true}}}
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 85dc6bbb36..de0f4e8529 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -911,6 +911,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - The Transform panel menu's Transform Object Only, Transform Pattern Only and Transform Both (`transformPanelPatterns`) choose whether the fields, flips and menu flips of the Transform panel and the Properties panel's Transform section move the object and leave its pattern tiles, move the tiles alone, or both (until a choice they follow General › Transform Pattern Tiles, as before); Use Registration Point for Symbol (`useRegistrationPointForSymbol`) measures and transforms one selected symbol instance from its symbol's registration point, where the instance's flips, rotations and shears put it ([Transform panel overview](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/transform-panel-overview.html); `panels::transform::tests::the_menu_chooses_whether_the_object_its_pattern_or_both_transform`, `use_registration_point_for_symbol_measures_an_instance_from_its_registration_point`, `use_registration_point_for_symbol_follows_a_transformed_instance`, `tests_prefs::transform_panel_patterns_defaults_to_following_the_general_preference`).
   - The Transform panel's Align to Pixel Grid checkbox (`object.setPixelAligned`) gives paths and compound paths a pixel-aligned property, saved in the native file: their horizontal and vertical straight segments sit on whole points (half points under an odd centered stroke) with whole stroke weights, and every move, scale, rotation, reflection, Transform Each, Align move, Transform panel change, move of direct-selected anchors or of one anchor, move of a compound path's path on its own, artboard move, resize or copy that carries the art, Duplicate or paste that moves a copy, stroke edit and appearance edit that adds, removes, hides, repaints or reweighs a stroke snaps them again, while diagonal segments and curves keep their shape; a compound path made from an aligned path or compound path is aligned and snaps its paths with its own stroke; the box shows a dash for a mixed selection and is unavailable for type, images and groups ([Pixel-aligned property](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/pixel-preview-mode-for-web-graphics.html); `tests::pixelalign::turning_it_on_snaps_the_path_in_one_undo_step`, `it_stays_aligned_through_transforms`, `it_stays_aligned_when_its_artboard_moves`, `diagonal_segments_and_curves_keep_their_shape`, `type_and_images_cannot_be_aligned`, `the_property_is_saved_and_read_back`, `stroke_edits_keep_it_aligned`, `a_compound_path_of_aligned_paths_is_aligned`, `a_compound_path_of_an_aligned_compound_path_is_aligned`, `a_stroke_without_paint_snaps_to_whole_points`, `moving_direct_selected_anchors_keeps_it_aligned`, `moving_one_anchor_keeps_it_aligned`, `moving_a_path_of_an_aligned_compound_path_keeps_it_aligned`, `artboard_options_and_artboard_copies_keep_it_aligned`, `appearance_edits_keep_it_aligned`, `placed_gradients_follow_the_snapped_path`, `duplicates_and_pastes_keep_it_aligned`, `paths_added_to_or_moved_in_an_aligned_compound_path_keep_it_aligned`, `the_art_of_a_linked_opacity_mask_keeps_it_aligned`, `a_linked_opacity_mask_follows_a_snap`, `aligning_direct_selected_anchors_keeps_it_aligned`, `global_edit_keeps_its_members_aligned`, `a_path_with_live_corners_snaps_its_inner_edges`, `geometry_edits_keep_it_aligned`, `other_path_edits_keep_it_aligned`, `panels::transform::tests::align_to_pixel_grid_shows_and_sets_the_property`).
   - Align New Objects to Pixel Grid (`document.setup {alignNewObjectsToPixelGrid}`, a checkbox in New Document's Advanced Options and a checked item in the Transform panel menu) gives every path and compound path drawn in the document, the paths of a new grid or flare included, the pixel-aligned property, snapped in the step that draws it; it is on in the Mobile and Web presets and off in the others, saved presets and Recent keep it, and the document saves it. Type, images and groups do not take it, and art already in the document, pasted, duplicated or placed keeps its own property (VectorCraft's own rules) ([Pixel-aligned property](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/pixel-preview-mode-for-web-graphics.html); `tests::pixelalign::align_new_objects_makes_new_paths_pixel_aligned`, `align_new_objects_reaches_grids_flares_and_add_on_shapes`, `align_new_objects_is_saved_and_read_back`, `tests::newdoc::align_new_objects_to_pixel_grid_follows_the_preset`, `panels::transform::tests::align_new_objects_menu_item_toggles_the_active_document`, `dialogs::new_document::tests::align_new_objects_checkbox_follows_the_preset_and_reaches_the_document`).
+  - Break Link to Symbol and Object › Expand give a symbol instance's art the instance's own bounding box: after Reset Bounding Box the art stands square to the page, an object turned inside the symbol keeps its angle relative to the instance's box, a group added for the instance's opacity takes the instance's box, and the clip groups of 9-slice art take the angle of their cell. Compound shapes and Pathfinder receive an instance's art with the same angles (VectorCraft's own behavior; `bboxrotate::reset_bounding_box_then_expand_symbol_instance`, `reset_bounding_box_then_expand_keeps_the_angles_inside_the_symbol`, `expanding_a_faded_symbol_instance_gives_its_group_the_instance_box`, `expanding_a_reflected_symbol_instance_keeps_its_box`, `symbol_nine_slice::break_link_turns_the_cells_of_a_sliced_instance_with_its_box`, effects `outline_object_turns_an_instances_art_with_its_box`).
   - Object › Transform › Reset Bounding Box squares the box of every object inside the selected ones as well: the children of groups, compound paths, clip groups, blends, envelopes, repeats and intertwines, and the art of linked opacity masks. Ungroup and the release commands then bring back boxes square to the page (VectorCraft's own behavior; `bboxrotate::reset_bounding_box_squares_the_objects_inside_a_group`, `reset_bounding_box_squares_the_turned_members_of_a_square_group`, `reset_bounding_box_then_release_clipping_mask` and the other `reset_bounding_box_then_*` tests, `reset_bounding_box_leaves_the_art_of_an_unlinked_opacity_mask`).
   - After a rotation the Free Transform tool shows and drags the same turned bounding box as the Selection tool: its handles, their cursors and its rotate zone sit on the selection's own sides, a handle scales along those sides from the opposite handle ([the help page](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/scale-objects.html)), Cmd/Ctrl on a side handle shears along that side, and Perspective Distort and Free Distort start from the turned box's corners (`object.distort` takes `angle` with `from`). The Scale and Reflect tools, their dialogs and commands, and the Transform panel's flips keep the page's axes (VectorCraft's own rule; `bboxrotate::free_transform_handles_turn_with_the_object_and_scale_along_its_axes`, `free_transform_shears_along_the_turned_side`, `free_transform_distort_starts_from_the_turned_box`, `xform::distort_reads_from_in_a_turned_frame_and_rejects_a_bad_angle`, tools `xform::free::tests::the_box_and_its_handles_turn_with_the_selection`).
   - Perspective Distort and Free Distort (`object.distort`) turn each warped object's bounding box as the warp turns the object at its own center, the objects inside groups, compound paths and clip groups and the art of linked opacity masks included, so the next Selection or Free Transform drag uses the tilted box; Object › Transform › Reset Bounding Box squares it again, and corners left where they are add no undo step (VectorCraft's own rule; `bboxrotate::distort_turns_an_upright_box_with_the_warp_at_its_center`, `distort_turns_each_member_and_linked_mask_by_its_own_warp`, `mirrored_and_collapsing_distorts_keep_valid_angles`, `distort_angles_undo_redo_and_reopen_together`, `xform::unchanged_distort_records_no_history`).