Shape rotation: spin a shape on the bed to print it in any direction

- Rotate (°) input + Apply Rotation in the Selected Shape Preview
accordion: spins the selected shape about Z (around its center) before
slicing. Dimensions reset to the rotated bounding box; the 3D and
sliced-layer previews show the rotated shape; entering 0 clears it.
- The engine (rotate_mesh + slice_stl_to_layers rotation params) supports
full X/Y/Z rotations - the UI exposes only the bed spin for now, via a
thin wrapper, so tilts are a small follow-up when needed.
- Rotation is part of the slice fingerprint (auto re-slice on the next
generation) and the stale-G-code banner, and rides along in settings
export/import (with the rotated originals).
- Multi-material assembly parts rotate about the group's combined center,
so equal rotations turn the whole assembly as one rigid unit.
- Split pieces are derived geometry: rotating them is refused with a hint
to rotate the source shape and re-split.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -51,6 +51,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Port groups are marked too: shapes sharing a Port get a matching underline on their Pressure and Port cells and a summary line ("Port 1: A + B share one pressure regulator (25 psi)") — one regulator per serial port is why their pressures stay in sync
 - Automatically unions the sliced shapes into a combined reference layer set whenever shapes are sliced
 - Shows a sliced-layer preview in the Selected Shape Preview accordion (layer slider through the shape's polygon outlines, drawn in its print color; assembly parts sharing the nozzle are drawn together so multi-material slicing can be checked before generating G-code)
+- **Rotate a shape to print in any direction**: the Selected Shape Preview accordion has a Rotate (°) input that spins the selected shape on the bed (about Z, around its center) before slicing — the table dimensions reset to the rotated bounding box, and the 3D/layer previews show the rotated shape. Assembly parts sharing a nozzle rotate about the group's combined center, so equal rotations turn the whole assembly as one unit. The rotation exports/imports with the other settings. (The engine also supports X/Y tilts, not yet exposed in the UI)
 - Bundled sample sets include a **Multi-Material Demo** (checkerboard cube, wrapped egg, space helmet — two STLs each) that loads with the parts of each model already grouped onto shared nozzles, forming three assemblies in one click
 - **Save / Load Settings**: exports every table setting plus the generation options as a small JSON keyed by STL filename; re-upload the same STLs later (or after a Space restart) and import to restore the whole setup — files in the export that aren't loaded yet are listed so they can be added. Split pieces are derived geometry and don't round-trip
 - Generate G-Code reports live progress (slicing, reference building, then shape-by-shape generation)

app.py

@@ -35,6 +35,7 @@ from stl_slicer import (
     LayerStack,
     calculate_z_levels,
     load_mesh,
+    rotate_mesh,
     scale_factors_for_target_extents,
     scale_mesh,
     slice_stl_to_layers,
@@ -1986,6 +1987,29 @@ def _default_color(index: int) -> str:
     return DEFAULT_PARALLEL_COLORS[(index - 1) % len(DEFAULT_PARALLEL_COLORS)]
 
 
+def _record_rotation(record: dict) -> tuple[float, float, float]:
+    """The shape's print rotation (X, Y, Z degrees); (0, 0, 0) when unset."""
+    rotation = record.get("rotation")
+    if not isinstance(rotation, (list, tuple)):
+        return (0.0, 0.0, 0.0)
+    values = [_coerce_float(value, 0.0) for value in list(rotation)[:3]]
+    while len(values) < 3:
+        values.append(0.0)
+    return tuple(round(value, 1) for value in values)
+
+
+def _rotated_display_stl(stl_path: str, rotation: tuple[float, float, float]) -> str:
+    """A temp STL of the rotated mesh, so the 3D preview shows the shape the
+    way it will actually print."""
+    try:
+        mesh = rotate_mesh(load_mesh(stl_path), rotation)
+        out_path = Path(tempfile.mkdtemp(prefix="pp_rotated_")) / Path(stl_path).name
+        mesh.export(out_path)
+        return str(out_path)
+    except Exception:
+        return stl_path
+
+
 def _default_target_extents_for_stl(path: str) -> tuple[float, float, float]:
     try:
         extents = load_mesh(path).extents
@@ -2104,6 +2128,7 @@ def _records_from_files(files: Any, previous_records: list[dict] | None = None)
             "infill": previous.get("infill", 100.0),
             "contour_tracing": previous.get("contour_tracing", False),
             "lead_in": previous.get("lead_in", False),
+            "rotation": previous.get("rotation"),
             "layer_stack": previous.get("layer_stack"),
             "slice_params": previous.get("slice_params"),
             "gcode_path": previous.get("gcode_path"),
@@ -3450,8 +3475,14 @@ def show_selected_model(
     if pos < 0:
         return _viewer_update(None), "No model loaded."
     record = records[pos]
+    stl_path = record.get("stl_path")
+    rotation = _record_rotation(record)
+    if stl_path and any(rotation):
+        # Preview the shape the way it will print: rotated first, so the
+        # target dimensions apply to the rotated bounding box.
+        stl_path = _rotated_display_stl(str(stl_path), rotation)
     return load_single_model(
-        record.get("stl_path"),
+        stl_path,
         False,  # full opacity (the 75%-opacity option was removed)
         True,
         scale_mode,
@@ -3461,6 +3492,97 @@ def show_selected_model(
     )
 
 
+def apply_shape_rotation(
+    records: list[dict] | None,
+    selected: str | None,
+    settings_table: Any,
+    rotate_x: Any,
+    rotate_y: Any,
+    rotate_z: Any,
+) -> tuple:
+    """Store a print rotation on the selected shape.
+
+    The rotation turns the raw mesh (X, then Y, then Z, about its centre)
+    before slicing, so the shape can print lying in any orientation. The
+    dimensions reset to the rotated shape's natural bounding box — edit
+    them afterwards as usual; slicing picks the rotation up automatically
+    on the next Generate G-Code (or split).
+    """
+    records = _apply_shape_settings(records or [], settings_table)
+    pos = _selected_record_index(records, selected)
+    if pos < 0:
+        return records, _shape_settings_rows(records), "Load a shape before rotating it."
+    record = records[pos]
+    name = str(record.get("name") or f"Shape {record.get('idx', pos + 1)}")
+    if not record.get("stl_path"):
+        return (
+            records,
+            _shape_settings_rows(records),
+            f"{name} is a split piece and cannot be rotated — rotate the source "
+            "shape, then split again.",
+        )
+
+    rotation = tuple(
+        round(_coerce_float(value, 0.0) % 360.0, 1)
+        for value in (rotate_x, rotate_y, rotate_z)
+    )
+    try:
+        extents = tuple(
+            float(value)
+            for value in rotate_mesh(load_mesh(record["stl_path"]), rotation).extents
+        )
+    except Exception as exc:
+        return records, _shape_settings_rows(records), f"Rotation failed: {exc}"
+
+    record["rotation"] = rotation if any(rotation) else None
+    for axis, extent in zip(("x", "y", "z"), extents):
+        record[f"original_{axis}"] = round(extent, 1)
+        record[f"target_{axis}"] = round(extent, 1)
+
+    dims = " x ".join(f"{round(extent, 1):g}" for extent in extents)
+    if any(rotation):
+        if rotation[0] or rotation[1]:
+            angle_text = f"X {rotation[0]:g}°, Y {rotation[1]:g}°, Z {rotation[2]:g}°"
+        else:
+            angle_text = f"{rotation[2]:g}°"
+        status = (
+            f"Rotated {name} to {angle_text}. "
+            f"Dimensions reset to the rotated size ({dims} mm) — edit them as needed; "
+            "the next Generate G-Code (or split) slices the rotated shape."
+        )
+    else:
+        status = f"Rotation cleared for {name}; dimensions reset to {dims} mm."
+    return records, _shape_settings_rows(records), status
+
+
+def apply_shape_z_rotation(
+    records: list[dict] | None,
+    selected: str | None,
+    settings_table: Any,
+    angle: Any,
+) -> tuple:
+    """UI entry point: the single Rotate input spins the shape on the bed
+    (about Z). The engine supports X/Y tilts too — expose more inputs here
+    when they are needed."""
+    return apply_shape_rotation(records, selected, settings_table, 0.0, 0.0, angle)
+
+
+def selected_shape_rotation(
+    records: list[dict] | None, selected: str | None
+) -> tuple[float, float, float]:
+    """The stored rotation of the selected shape, for the rotation inputs."""
+    records = records or []
+    pos = _selected_record_index(records, selected)
+    if pos < 0:
+        return 0.0, 0.0, 0.0
+    return _record_rotation(records[pos])
+
+
+def selected_shape_z_rotation(records: list[dict] | None, selected: str | None) -> float:
+    """The stored bed rotation (Z) of the selected shape, for the Rotate input."""
+    return selected_shape_rotation(records, selected)[2]
+
+
 def _polygon_patch(polygon, **kwargs):
     """A filled matplotlib patch for a shapely Polygon, holes included."""
     from matplotlib.patches import PathPatch
@@ -3589,7 +3711,7 @@ def _slice_params_snapshot(
     record: dict,
     layer_height: float,
     scale_mode: str | None,
-    slice_plan: tuple[list[float], tuple[float, float, float]] | None = None,
+    slice_plan: tuple | None = None,
 ) -> dict:
     z_levels = slice_plan[0] if slice_plan else None
     anchor = slice_plan[1] if slice_plan else None
@@ -3599,6 +3721,7 @@ def _slice_params_snapshot(
         "target_x": record.get("target_x"),
         "target_y": record.get("target_y"),
         "target_z": record.get("target_z"),
+        "rotation": _record_rotation(record),
         # Multi-material groups: the shared Z grid + scale anchor
         # fingerprint. Adding/removing an assembly part changes them, which
         # correctly marks every part's slices stale.
@@ -3672,23 +3795,46 @@ def _multi_material_slice_plan(
     records: list[dict],
     layer_height: float,
     scale_mode: str | None,
-) -> tuple[list[float], tuple[float, float, float]] | None:
-    """(shared Z grid, shared scale anchor) for one multi-material group.
+) -> tuple[list[float], tuple[float, float, float], tuple[float, float, float] | None] | None:
+    """(shared Z grid, shared scale anchor, shared rotation centre) for one
+    multi-material group.
 
     Group members must slice on the SAME planes so a part that starts
     higher gets empty lower layers instead of having its first material
     layer treated as layer 0 — and any target-dimension scaling must happen
     about ONE shared point (the group's combined un-scaled corner), or
     same-factor scaling would still shift the parts relative to each other.
+    Rotations likewise happen about the group's combined RAW centre, so
+    equal rotations turn the whole assembly as one rigid unit.
     """
-    loaded: list[tuple[Any, tuple[float, float, float]]] = []
-    corner = [math.inf, math.inf, math.inf]
+    raw: list[tuple[dict, Any]] = []
+    raw_lo = [math.inf, math.inf, math.inf]
+    raw_hi = [-math.inf, -math.inf, -math.inf]
     for record in records:
         stl_path = record.get("stl_path")
         if not stl_path:
             continue
         try:
             mesh = load_mesh(stl_path)
+        except Exception:
+            continue
+        raw.append((record, mesh))
+        for axis in range(3):
+            raw_lo[axis] = min(raw_lo[axis], float(mesh.bounds[0][axis]))
+            raw_hi[axis] = max(raw_hi[axis], float(mesh.bounds[1][axis]))
+    if not raw or not all(math.isfinite(value) for value in raw_lo):
+        return None
+    rotation_center = tuple(
+        (lo + hi) / 2.0 for lo, hi in zip(raw_lo, raw_hi)
+    )
+
+    loaded: list[tuple[Any, tuple[float, float, float]]] = []
+    corner = [math.inf, math.inf, math.inf]
+    for record, mesh in raw:
+        rotation = _record_rotation(record)
+        if any(rotation):
+            mesh = rotate_mesh(mesh, rotation, center=rotation_center)
+        try:
             scale_factors = _resolve_mesh_scale_factors(
                 mesh,
                 True,
@@ -3717,7 +3863,7 @@ def _multi_material_slice_plan(
         z_hi = max(z_hi, float(scaled.bounds[1][2]))
     if not math.isfinite(z_lo) or not math.isfinite(z_hi):
         return None
-    return calculate_z_levels(z_lo, z_hi, float(layer_height)), anchor
+    return calculate_z_levels(z_lo, z_hi, float(layer_height)), anchor, rotation_center
 
 
 def _slice_record(
@@ -3725,10 +3871,16 @@ def _slice_record(
     layer_height: float,
     scale_mode: str | None,
     progress_callback=None,
-    slice_plan: tuple[list[float], tuple[float, float, float]] | None = None,
+    slice_plan: tuple | None = None,
 ) -> LayerStack:
     stl_path = record["stl_path"]
+    rotation = _record_rotation(record)
+    rotation_center = slice_plan[2] if slice_plan and len(slice_plan) > 2 else None
     mesh = load_mesh(stl_path)
+    if any(rotation):
+        # Scale factors come from the ROTATED bounding box: the target
+        # dimensions describe the shape as it will print.
+        mesh = rotate_mesh(mesh, rotation, center=rotation_center)
     scale_factors = _resolve_mesh_scale_factors(
         mesh,
         True,
@@ -3745,6 +3897,8 @@ def _slice_record(
         name=str(record.get("name") or Path(stl_path).stem),
         z_levels=slice_plan[0] if slice_plan else None,
         scale_anchor=slice_plan[1] if slice_plan else None,
+        rotation=rotation if any(rotation) else None,
+        rotation_center=rotation_center,
     )
     record["layer_stack"] = stack
     record["slice_params"] = _slice_params_snapshot(record, layer_height, scale_mode, slice_plan)
@@ -3756,10 +3910,10 @@ def _group_z_levels_by_record(
     layer_height: float,
     scale_mode: str | None,
     messages: list[str] | None = None,
-) -> dict[int, tuple[list[float], tuple[float, float, float]]]:
+) -> dict[int, tuple]:
     """Per multi-material group member: (shared Z grid, shared scale anchor),
     keyed by record id."""
-    plan_by_record: dict[int, tuple[list[float], tuple[float, float, float]]] = {}
+    plan_by_record: dict[int, tuple] = {}
     for nozzle, members in sorted(_multi_material_groups(records).items()):
         plan = _multi_material_slice_plan(members, layer_height, scale_mode)
         if plan is None:
@@ -4356,6 +4510,7 @@ def _gcode_settings_snapshot(
         "infill": round(_coerce_float(record.get("infill"), 100.0), 6),
         "contour_tracing": bool(record.get("contour_tracing")),
         "lead_in": bool(record.get("lead_in")),
+        "rotation": _record_rotation(record),
         "raster_pattern": str(raster_pattern or ""),
         "pressure_ramp": bool(pressure_ramp_enabled),
         "lead_in_params": (
@@ -4427,6 +4582,10 @@ _SHAPE_EXPORT_FIELDS = (
     "target_x",
     "target_y",
     "target_z",
+    "original_x",
+    "original_y",
+    "original_z",
+    "rotation",
     "pressure",
     "valve",
     "nozzle",
@@ -5251,6 +5410,19 @@ def build_dynamic_demo() -> gr.Blocks:
                     selected_shape = gr.Dropdown(label="Preview Shape", choices=[], value=None, allow_custom_value=False)
                     refresh_preview_button = gr.Button("Regenerate Preview", variant="secondary", size="sm")
 
+                with gr.Row():
+                    rotate_input = gr.Number(
+                        label="Rotate (°)", value=0.0, step=15.0, min_width=140,
+                        info="Spins the shape on the bed - print it in any direction.",
+                        scale=1,
+                    )
+                    apply_rotation_button = gr.Button(
+                        "Apply Rotation", variant="secondary", size="sm",
+                        min_width=140, scale=1,
+                    )
+                    gr.HTML("", scale=3)
+                rotation_status = gr.Markdown("")
+
                 with gr.Row():
                     with gr.Column(scale=2, min_width=420):
                         model_viewer = gr.Model3D(
@@ -5766,6 +5938,32 @@ def build_dynamic_demo() -> gr.Blocks:
                 queue=False,
             )
 
+        apply_rotation_button.click(
+            fn=apply_shape_z_rotation,
+            inputs=[shape_records, selected_shape, shape_settings, rotate_input],
+            outputs=[shape_records, shape_settings, rotation_status],
+        ).then(
+            fn=show_selected_model,
+            inputs=preview_inputs,
+            outputs=[model_viewer, model_details],
+        ).then(
+            fn=update_layer_preview,
+            inputs=layer_preview_inputs,
+            outputs=layer_preview_outputs,
+        ).then(
+            fn=check_gcode_staleness,
+            inputs=stale_inputs,
+            outputs=[gcode_stale_banner],
+            queue=False,
+        )
+        # Selecting a shape shows its stored rotation in the input.
+        selected_shape.change(
+            fn=selected_shape_z_rotation,
+            inputs=[shape_records, selected_shape],
+            outputs=[rotate_input],
+            queue=False,
+        )
+
         # Defined before the generate chain so it can auto-render the
         # parallel view with fresh files (the same lists drive the
         # Visualization tab wiring further down).

stl_slicer.py

@@ -119,6 +119,34 @@ def scale_mesh(
     return scaled
 
 
+def rotate_mesh(
+    mesh: trimesh.Trimesh,
+    rotation: Sequence[float] | None,
+    center: Sequence[float] | None = None,
+) -> trimesh.Trimesh:
+    """Rotated copy of `mesh`: X, then Y, then Z angles in degrees, about
+    `center` (the mesh's own bounding-box centre by default).
+
+    Multi-material assembly parts pass their GROUP's combined centre so
+    equal rotations turn the whole assembly as one rigid unit.
+    """
+    angles = tuple(float(value or 0.0) for value in (rotation or (0.0, 0.0, 0.0)))
+    rotated = mesh.copy()
+    if all(abs(angle) < 1e-9 for angle in angles):
+        return rotated
+    point = np.asarray(
+        (mesh.bounds[0] + mesh.bounds[1]) / 2.0 if center is None else center,
+        dtype=float,
+    )
+    for angle, axis in zip(angles, ((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0))):
+        if abs(angle) < 1e-9:
+            continue
+        rotated.apply_transform(
+            trimesh.transformations.rotation_matrix(math.radians(angle), axis, point)
+        )
+    return rotated
+
+
 def scale_factors_for_target_extents(
     mesh: trimesh.Trimesh,
     target_extents: Sequence[float],
@@ -301,6 +329,8 @@ def slice_stl_to_layers(
     scale_anchor: Sequence[float] | None = None,
     flip_z: bool = False,
     z_flip_mid: float | None = None,
+    rotation: Sequence[float] | None = None,
+    rotation_center: Sequence[float] | None = None,
 ) -> LayerStack:
     """Slice an STL into per-layer vector outlines (world-XY millimetres).
 
@@ -310,13 +340,22 @@ def slice_stl_to_layers(
     is the point target-dimension scaling happens about (assembly parts share
     their group's corner so they stay assembled when rescaled).
 
+    `rotation` turns the RAW mesh (X, then Y, then Z degrees, about
+    `rotation_center` — its own bbox centre by default) BEFORE scaling, so
+    the target dimensions apply to the rotated shape's bounding box: the
+    shape can be printed lying in any orientation. Callers computing scale
+    factors must derive them from the rotated mesh (see `rotate_mesh`).
+
     `flip_z` mirrors the scaled mesh about the horizontal plane at
     `z_flip_mid` (its own Z midpoint by default) — printing the shape the
     other way up. Assembly parts pass their GROUP's midplane so the whole
     assembly flips as one unit.
     """
     stl_path = Path(stl_path)
-    mesh = scale_mesh(load_mesh(stl_path), scale_factors, anchor=scale_anchor)
+    mesh = load_mesh(stl_path)
+    if rotation is not None:
+        mesh = rotate_mesh(mesh, rotation, center=rotation_center)
+    mesh = scale_mesh(mesh, scale_factors, anchor=scale_anchor)
     if flip_z:
         mid = (
             float(z_flip_mid)

tests/test_nozzle_spacing.py

@@ -1751,6 +1751,63 @@ def test_multi_material_demo_set_groups_parts_onto_shared_nozzles() -> None:
     assert [row[nozzle_pos] for row in outputs[2]] == [1, 1, 2, 2, 3, 3]
 
 
+def test_apply_shape_rotation_updates_dims_and_reslices(tmp_path) -> None:
+    import trimesh
+
+    from app import _slice_record, apply_shape_rotation, selected_shape_rotation
+
+    mesh = trimesh.creation.box(extents=(10.0, 4.0, 2.0))
+    stl_path = tmp_path / "bar.stl"
+    mesh.export(stl_path)
+
+    records = _records_from_files([str(stl_path)], None)
+    record = records[0]
+    assert (record["target_x"], record["target_y"], record["target_z"]) == (10.0, 4.0, 2.0)
+
+    # Slice unrotated, then rotate: the slice_params fingerprint must change
+    # so the auto re-slice kicks in on the next generation.
+    _slice_record(record, 1.0, None)
+    params_before = dict(record["slice_params"])
+
+    updated, rows, status = apply_shape_rotation(records, None, None, 90, 0, 0)
+    record = updated[0]
+    assert "Rotated" in status
+    assert record["rotation"] == (90.0, 0.0, 0.0)
+    # Dimensions reset to the rotated bounding box: (10, 4, 2) -> (10, 2, 4).
+    assert (record["target_x"], record["target_y"], record["target_z"]) == (10.0, 2.0, 4.0)
+    assert (record["original_x"], record["original_y"], record["original_z"]) == (10.0, 2.0, 4.0)
+    assert rows[0][2:5] == [10.0, 2.0, 4.0]
+
+    from app import _slice_params_snapshot
+
+    assert _slice_params_snapshot(record, 1.0, None) != params_before
+
+    # Re-slicing uses the rotated mesh: 4 layers of the stood-up bar.
+    stack = _slice_record(record, 1.0, None)
+    assert len(stack.layers) == 4
+    (x0, y0, _), (x1, y1, _) = stack.bounds
+    assert round(x1 - x0, 3) == 10.0
+    assert round(y1 - y0, 3) == 2.0
+
+    # The rotation inputs mirror the stored value; clearing it restores the
+    # unrotated dimensions.
+    assert selected_shape_rotation(updated, None) == (90.0, 0.0, 0.0)
+    cleared, _rows, cleared_status = apply_shape_rotation(updated, None, None, 0, 0, 0)
+    assert cleared[0]["rotation"] is None
+    assert "cleared" in cleared_status
+    assert (cleared[0]["target_x"], cleared[0]["target_y"], cleared[0]["target_z"]) == (10.0, 4.0, 2.0)
+
+    # The single-input UI wrapper spins the shape on the bed (about Z):
+    # the 10 x 4 bar's X and Y swap.
+    from app import apply_shape_z_rotation, selected_shape_z_rotation
+
+    spun, _rows, spun_status = apply_shape_z_rotation(cleared, None, None, 90)
+    assert spun[0]["rotation"] == (0.0, 0.0, 90.0)
+    assert "90°" in spun_status and "X " not in spun_status.split(".")[0]
+    assert (spun[0]["target_x"], spun[0]["target_y"], spun[0]["target_z"]) == (4.0, 10.0, 2.0)
+    assert selected_shape_z_rotation(spun, None) == 90.0
+
+
 def test_project_settings_export_import_round_trip(tmp_path) -> None:
     from app import export_project_settings, import_project_settings
 

tests/test_stl_slicer.py

@@ -9,12 +9,55 @@ import pytest
 from stl_slicer import (
     _compose_even_odd_polygons,
     calculate_z_levels,
+    rotate_mesh,
     scale_factors_for_target_extents,
     scale_mesh,
     slice_stl_to_layers,
 )
 
 
+def test_slice_stl_to_layers_applies_rotation(tmp_path) -> None:
+    mesh = trimesh.creation.box(extents=(10.0, 4.0, 2.0))
+    stl_path = tmp_path / "bar.stl"
+    mesh.export(stl_path)
+
+    # 90° about X stands the bar up: extents (10, 4, 2) -> (10, 2, 4).
+    stack = slice_stl_to_layers(stl_path, layer_height=1.0, rotation=(90.0, 0.0, 0.0))
+
+    bounds = np.array(stack.bounds)
+    np.testing.assert_allclose(bounds[1] - bounds[0], (10.0, 2.0, 4.0), atol=1e-6)
+    assert len(stack.layers) == 4
+    for layer in stack.layers:
+        assert layer.area == pytest.approx(20.0)
+
+    # Scale factors apply to the ROTATED bounding box.
+    rotated = rotate_mesh(trimesh.creation.box(extents=(10.0, 4.0, 2.0)), (90.0, 0.0, 0.0))
+    np.testing.assert_allclose(sorted(rotated.extents), sorted((10.0, 2.0, 4.0)), atol=1e-6)
+    factors = scale_factors_for_target_extents(rotated, (5.0, 2.0, 2.0))
+    scaled_stack = slice_stl_to_layers(
+        stl_path,
+        layer_height=1.0,
+        rotation=(90.0, 0.0, 0.0),
+        scale_factors=factors,
+    )
+    scaled_bounds = np.array(scaled_stack.bounds)
+    np.testing.assert_allclose(scaled_bounds[1] - scaled_bounds[0], (5.0, 2.0, 2.0), atol=1e-6)
+
+
+def test_rotate_mesh_uses_shared_center_for_assemblies() -> None:
+    left = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
+    right = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
+    right.apply_translation((4.0, 0.0, 0.0))
+    combined_center = (2.0, 0.0, 0.0)
+
+    # Rotating both parts 180° about Z around the SHARED centre swaps their
+    # positions — the assembly turns as one rigid unit.
+    left_rotated = rotate_mesh(left, (0.0, 0.0, 180.0), center=combined_center)
+    right_rotated = rotate_mesh(right, (0.0, 0.0, 180.0), center=combined_center)
+    np.testing.assert_allclose(left_rotated.bounds, right.bounds, atol=1e-9)
+    np.testing.assert_allclose(right_rotated.bounds, left.bounds, atol=1e-9)
+
+
 def test_calculate_z_levels_creates_single_layer_for_thin_mesh() -> None:
     z_values = calculate_z_levels(0.0, 0.01, 0.1)