Split progress, Undo Delete, slice-on-demand preview, assembly rotation note; drop two repair buttons

- Splitting reports live per-shape slicing progress (and Generate G-Code's
slicing phase now shows per-shape progress too).
- Undo Delete: every delete pushes a snapshot (settings, slices, and
G-code included; last 10) and one click restores the removed shape.
- Regenerate Preview slices the SELECTED shape on demand (plus its
nozzle-group assembly mates, which share one Z grid), so the
sliced-layer preview works before any G-code has been generated.
- Rotating an assembly member now notes that rotations turn about the
group's combined center - apply the same angle to every part to turn
the assembly as one unit.
- Removed the Sync Uploaded STLs and Assign Unique Valves buttons: the
uploader auto-syncs, and unique-valve assignment is automatic for new
shapes and split pieces (the assign_unique_valves logic stays, tested,
in case the button is ever wanted back).

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

README.md

@@ -54,7 +54,9 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - **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 configured table dimensions follow the rotation (a spun 20 × 8 shape becomes 8 × 20, keeping any custom scaling), and the 3D/layer previews show the rotated shape, and the table marks rotated shapes at the start of the STL column ("↻90° name"). **Rotate All Shapes** applies the same angle to every uploaded shape at once (each carrying its own dimensions through the turn; split pieces are skipped). 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 (Multi-Nozzle Split geometry options included) 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)
+- Generate G-Code reports live progress (per-shape slicing, reference building, then shape-by-shape generation); splitting reports the same per-shape slicing progress
+- Deleting a shape can be undone: **Undo Delete** restores the removed shape with all its settings, slices, and G-code (last 10 deletes)
+- **Regenerate Preview** slices the selected shape on demand (plus its assembly mates), so the sliced-layer preview works before any G-code has been generated
 - Splits one sliced shape's geometry into an editable row/column grid for multi-nozzle printing of one large shape. The Starting Nozzle / Starting Valve defaults always sit past every number in use (and re-bump after each split), so a default split never lands pieces on another shape's nozzle or valve
 - Converts sliced layers into G-code files with pressure, valve, nozzle, port, and infill % settings per shape from the Shape Settings table
 - **Pressure is a port property** (one pressure regulator per serial port): shapes sharing a Port always share one pressure — editing one shape's pressure updates every shape on that port, moving a shape onto a port adopts that port's pressure, and newly added shapes join at their port's existing pressure
@@ -66,7 +68,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Slicing is automatic: **Generate G-Code** slices every shape (fresh or stale) before writing G-code, and **Split Selected Shape into Grid Pieces** slices before splitting — "upload, then Generate G-Code" works in one click with no separate slice step
 - The generation status leads with the shared print path length and a time estimate at the Visualization tab's nozzle speed, and generation auto-renders the parallel view so switching to the Visualization tab always shows the current print
 - A **stale-G-code banner** appears above the Generate button whenever the table or any generation option changes after files were generated (each file carries a settings fingerprint), so outdated G-code is never downloaded or printed unnoticed
-- **Assign Unique Valves** resolves valve collisions in one click (first occurrence keeps its number; duplicates and unset valves move to the smallest unused), and **Undo Split** unwinds splits one at a time, newest first (each split pushes a snapshot onto an undo stack, kept for the last 10 splits)
+- **Undo Split** unwinds splits one at a time, newest first (each split pushes a snapshot onto an undo stack, kept for the last 10 splits)
 - Calculates X/Y nozzle spacing from a grid layout (columns/rows plus gaps) in the Visualization tab's Nozzle Spacing accordion, with an optional per-connection Advanced Grid Spacing table, then visualizes the resulting nozzle layout
 - Previews selected generated G-code inline
 - One Visualization tab that defaults to the parallel print of every generated shape (configured nozzle spacing, animated, with a server-side GIF export), and can switch to a single tool path from any generated shape or an uploaded G-code file

app.py

@@ -3033,13 +3033,14 @@ def _shape_select_noop() -> tuple:
     lands late); echoing records/rows here raced the dimension normalizer's
     write-back — the stale echo clobbered the recomputed proportions on the
     first Keep Proportions edit and re-rendered the table mid-typing."""
-    return tuple(gr.skip() for _ in range(9))
+    return tuple(gr.skip() for _ in range(10))
 
 
 def delete_shape_from_settings(
     records: list[dict] | None,
     settings_table: Any | None,
     last_delete_at: float | None,
+    undo_stack: list[list[dict]] | None,
     evt: gr.SelectData,
 ) -> tuple:
     now = time.monotonic()
@@ -3067,11 +3068,35 @@ def delete_shape_from_settings(
     next_records = _reindex_shape_records([
         record for record in current_records if int(record.get("idx", 0)) != delete_idx
     ])
+    if len(next_records) == len(current_records):
+        return _shape_select_noop()
+    # Undo stack: every delete pushes the pre-delete records (settings,
+    # slices, and G-code included), capped to the last 10 deletes.
+    next_undo_stack = [
+        *(undo_stack or []),
+        [dict(record) for record in current_records],
+    ][-10:]
     upload_paths = [record.get("stl_path") for record in next_records if record.get("stl_path")]
-    return _shape_delete_outputs(
-        next_records,
-        now,
-        gr.update(value=upload_paths),
+    return (
+        *_shape_delete_outputs(
+            next_records,
+            now,
+            gr.update(value=upload_paths),
+        ),
+        next_undo_stack,
+    )
+
+
+def undo_last_delete(undo_stack: list[list[dict]] | None) -> tuple:
+    """Restore the records from before the most recent delete."""
+    stack = list(undo_stack or [])
+    if not stack:
+        return _shape_select_noop()
+    restored = [dict(record) for record in stack.pop()]
+    upload_paths = [record.get("stl_path") for record in restored if record.get("stl_path")]
+    return (
+        *_shape_delete_outputs(restored, None, gr.update(value=upload_paths)),
+        stack,
     )
 
 
@@ -3655,6 +3680,14 @@ def apply_shape_rotation(
         )
     else:
         status = f"Rotation cleared for {name}; dimensions follow back to {dims} mm."
+    nozzle = _record_nozzle_number(record, int(record.get("idx", pos + 1) or (pos + 1)))
+    group_members = _multi_material_groups(records).get(nozzle)
+    if group_members and len(group_members) > 1:
+        status += (
+            f"  \n{name} is part of the nozzle {nozzle} multi-material assembly: "
+            "rotations turn about the group's combined center, so apply the SAME "
+            "angle to every part to turn the whole assembly as one unit."
+        )
     return records, _shape_settings_rows(records), status
 
 
@@ -3778,6 +3811,40 @@ def apply_all_shapes_z_rotation(
     return apply_all_shapes_rotation(records, settings_table, 0.0, 0.0, angle)
 
 
+def slice_selected_shape_for_preview(
+    records: list[dict] | None,
+    selected: str | None,
+    settings_table: Any,
+    layer_height: float,
+    scale_mode: str | None,
+    progress: gr.Progress = gr.Progress(),
+) -> list[dict]:
+    """Regenerate Preview slices the SELECTED shape on demand (plus its
+    nozzle-group assembly mates, which must share one Z grid) — the layer
+    preview works before any G-code has been generated."""
+    records = _apply_shape_settings(records or [], settings_table)
+    pos = _selected_record_index(records, selected)
+    if pos < 0:
+        return records
+    record = records[pos]
+    if not record.get("stl_path"):
+        return records
+    nozzle = _record_nozzle_number(record, int(record.get("idx", pos + 1) or (pos + 1)))
+    group = _multi_material_groups(records).get(nozzle) or [record]
+    messages: list[str] = []
+    progress(0.1, desc="Slicing for preview…")
+    _ensure_records_sliced(
+        group,
+        float(layer_height or 0.8),
+        scale_mode,
+        messages,
+        progress_callback=lambda done, total, name: progress(
+            0.1 + 0.8 * done / max(1, total), desc=f"Slicing {name}…"
+        ),
+    )
+    return records
+
+
 def apply_shape_z_rotation(
     records: list[dict] | None,
     selected: str | None,
@@ -3857,7 +3924,10 @@ def update_layer_preview(
     if stack is None or not getattr(stack, "layers", None):
         return (
             gr.update(maximum=1, value=1),
-            _layer_preview_message("Generate G-Code (or split) to slice this shape and see its layer outlines."),
+            _layer_preview_message(
+                "Press Regenerate Preview to slice this shape and see its layer "
+                "outlines. (Generate G-Code and splits slice automatically too.)"
+            ),
         )
 
     layer_count = len(stack.layers)
@@ -4440,6 +4510,7 @@ def split_selected_shape_for_grid(
     overlapping_rows: bool = False,
     overlap_size: float | None = None,
     row_overlap_direction: str | None = None,
+    progress: gr.Progress = gr.Progress(),
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     # Overlap depth for both interlock styles; blank/zero falls back to one
@@ -4453,7 +4524,17 @@ def split_selected_shape_for_grid(
     # separate slicing step.
     slice_messages: list[str] = []
     if records:
-        _ensure_records_sliced(records, float(layer_height or 0.8), scale_mode, slice_messages)
+        progress(0.02, desc="Checking slices…")
+        _ensure_records_sliced(
+            records,
+            float(layer_height or 0.8),
+            scale_mode,
+            slice_messages,
+            progress_callback=lambda done, total, name: progress(
+                0.05 + 0.7 * done / max(1, total), desc=f"Slicing {name}…"
+            ),
+        )
+        progress(0.8, desc="Splitting into grid pieces…")
     # Undo stack: each split PUSHES its pre-split records (sliced), and Undo
     # Split pops them one at a time (capped to the last 10 splits). Pushed
     # only when a split actually happened — every failure path returns the
@@ -4602,10 +4683,13 @@ def _ensure_records_sliced(
     layer_height: float,
     scale_mode: str | None,
     messages: list[str],
+    progress_callback=None,
 ) -> bool:
-    """Re-slice records whose layers are missing or stale for the current settings."""
+    """Re-slice records whose layers are missing or stale for the current
+    settings. `progress_callback(done, total, name)` is called before each
+    actual re-slice so callers can show per-shape progress."""
     plan_by_record = _group_z_levels_by_record(records, layer_height, scale_mode)
-    resliced = False
+    stale: list[tuple[dict, tuple | None]] = []
     for record in records:
         stl_path = record.get("stl_path")
         if not stl_path:
@@ -4614,6 +4698,14 @@ def _ensure_records_sliced(
         current = _slice_params_snapshot(record, layer_height, scale_mode, slice_plan)
         if record.get("layer_stack") is not None and record.get("slice_params") == current:
             continue
+        stale.append((record, slice_plan))
+    for position, (record, slice_plan) in enumerate(stale):
+        if progress_callback is not None:
+            progress_callback(
+                position,
+                len(stale),
+                str(record.get("name") or f"Shape {record.get('idx')}"),
+            )
         try:
             stack = _slice_record(record, layer_height, scale_mode, None, slice_plan)
             messages.append(
@@ -4622,8 +4714,7 @@ def _ensure_records_sliced(
         except Exception as exc:
             record["layer_stack"] = None
             messages.append(f"Shape {record['idx']}: slicing failed ({exc}).")
-        resliced = True
-    return resliced
+    return bool(stale)
 
 
 def _lead_in_assembly_extension(records: list[dict], direction: str | None) -> float:
@@ -5025,7 +5116,15 @@ def generate_dynamic_gcode(
     records = _apply_shape_settings(records or [], settings_table)
     messages: list[str] = []
     progress(0.02, desc="Slicing shapes…")
-    _ensure_records_sliced(records, layer_height, scale_mode, messages)
+    _ensure_records_sliced(
+        records,
+        layer_height,
+        scale_mode,
+        messages,
+        progress_callback=lambda done, total, name: progress(
+            0.02 + 0.09 * done / max(1, total), desc=f"Slicing {name}…"
+        ),
+    )
     # Shared reference motion is always on: every head traces the combined
     # outline and dispenses only its own geometry. Rebuilt with the CURRENT
     # fil width so the alignment snap grid matches this generation.
@@ -5491,6 +5590,7 @@ def build_dynamic_demo() -> gr.Blocks:
     with gr.Blocks(title="ParallelPrint: STL to G-Code", css=APP_CSS, head=APP_HEAD + TOOLPATH_ANIM_HEAD + PARALLEL_ANIM_HEAD) as demo:
         shape_records = gr.State([])
         last_shape_delete_at = gr.State(0.0)
+        delete_undo = gr.State(None)
         ref_layers = gr.State(None)
 
         with gr.Tab("Shapes & G-Code"):
@@ -5517,9 +5617,8 @@ def build_dynamic_demo() -> gr.Blocks:
                         label="Sample Set",
                         container=False,
                     )
-                    sync_uploads_button = gr.Button("Sync Uploaded STLs", variant="secondary", size="sm")
                     reset_dimensions_button = gr.Button("Reset Dimensions", variant="secondary", size="sm")
-                    assign_valves_button = gr.Button("Assign Unique Valves", variant="secondary", size="sm")
+                    undo_delete_button = gr.Button("Undo Delete", variant="secondary", size="sm")
                     scale_mode = gr.Radio(
                         choices=[SCALE_MODE_TARGET_DIMENSIONS, SCALE_MODE_UNIFORM_FACTOR],
                         value=SCALE_MODE_TARGET_DIMENSIONS,
@@ -5907,17 +6006,6 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[nozzle_grid_spacing_table],
             queue=False,
         )
-        sync_uploads_button.click(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings], outputs=shape_sync_outputs).then(
-            fn=refresh_split_sources,
-            inputs=[shape_records],
-            outputs=[split_source, split_start_nozzle, split_start_valve],
-            queue=False,
-        ).then(
-            fn=_grid_spacing_table_update,
-            inputs=grid_spacing_refresh_inputs,
-            outputs=[nozzle_grid_spacing_table],
-            queue=False,
-        )
         load_samples_button.click(fn=load_sample_shapes, inputs=[stl_upload, shape_records, shape_settings, sample_set_selector], outputs=[stl_upload, *shape_sync_outputs]).then(
             fn=refresh_split_sources,
             inputs=[shape_records],
@@ -5943,8 +6031,8 @@ def build_dynamic_demo() -> gr.Blocks:
         )
         shape_settings.select(
             fn=delete_shape_from_settings,
-            inputs=[shape_records, shape_settings, last_shape_delete_at],
-            outputs=[stl_upload, *shape_sync_outputs, last_shape_delete_at],
+            inputs=[shape_records, shape_settings, last_shape_delete_at, delete_undo],
+            outputs=[stl_upload, *shape_sync_outputs, last_shape_delete_at, delete_undo],
             queue=False,
         ).then(
             fn=refresh_split_sources,
@@ -5957,6 +6045,21 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[nozzle_grid_spacing_table],
             queue=False,
         )
+        undo_delete_button.click(
+            fn=undo_last_delete,
+            inputs=[delete_undo],
+            outputs=[stl_upload, *shape_sync_outputs, last_shape_delete_at, delete_undo],
+        ).then(
+            fn=refresh_split_sources,
+            inputs=[shape_records],
+            outputs=[split_source, split_start_nozzle, split_start_valve],
+            queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
+        )
 
         preview_inputs = [shape_records, selected_shape, shape_settings, scale_mode]
         # .change is the ONLY event the Dataframe emits for cell edits (it has
@@ -5976,14 +6079,27 @@ def build_dynamic_demo() -> gr.Blocks:
             queue=False,
         )
         selected_shape.change(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details])
-        refresh_preview_button.click(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details])
         # Sliced-layer preview. The slider uses .release only: the handler
         # writes the slider back (clamped max/value), and a .change wiring
         # would re-fire on that programmatic write.
         layer_preview_inputs = [shape_records, selected_shape, shape_settings, layer_preview_slider]
         layer_preview_outputs = [layer_preview_slider, layer_preview_plot]
         selected_shape.change(fn=update_layer_preview, inputs=layer_preview_inputs, outputs=layer_preview_outputs)
-        refresh_preview_button.click(fn=update_layer_preview, inputs=layer_preview_inputs, outputs=layer_preview_outputs)
+        # Regenerate Preview slices the selected shape on demand first, so
+        # the layer preview works before any G-code has been generated.
+        refresh_preview_button.click(
+            fn=slice_selected_shape_for_preview,
+            inputs=[shape_records, selected_shape, shape_settings, layer_height, scale_mode],
+            outputs=[shape_records],
+        ).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,
+        )
         layer_preview_slider.release(fn=update_layer_preview, inputs=layer_preview_inputs, outputs=layer_preview_outputs)
         scale_mode.change(
             fn=normalize_shape_dimensions_for_mode,
@@ -6100,12 +6216,6 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[split_start_nozzle, split_start_valve],
             queue=False,
         )
-        assign_valves_button.click(
-            fn=assign_unique_valves,
-            inputs=[shape_records, shape_settings],
-            outputs=[shape_records, shape_settings],
-            queue=False,
-        )
         export_settings_button.click(
             fn=export_project_settings,
             inputs=[

tests/test_nozzle_spacing.py

@@ -975,7 +975,7 @@ def test_delete_shape_reindexes_without_losing_shape_data() -> None:
         {"idx": 3, "name": "last", "stl_path": "last.stl", "target_x": 30.0, "target_y": 31.0, "target_z": 32.0, "pressure": 35, "valve": 6, "port": 3, "color": "#333333"},
     ]
 
-    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
+    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, None, Event())
     updated_records = outputs[1]
     updated_settings = outputs[2]
 
@@ -986,6 +986,21 @@ def test_delete_shape_reindexes_without_losing_shape_data() -> None:
     assert updated_settings[1][1] == "last"
     assert updated_settings[1][2:5] == [30.0, 31.0, 32.0]
 
+    # The delete pushed an undo snapshot; Undo Delete restores everything.
+    from app import undo_last_delete
+
+    undo_stack = outputs[-1]
+    assert isinstance(undo_stack, list) and len(undo_stack) == 1
+    restored_outputs = undo_last_delete(undo_stack)
+    restored = restored_outputs[1]
+    assert [record["name"] for record in restored] == ["first", "middle", "last"]
+    assert restored[1]["pressure"] == 30
+    assert restored_outputs[-1] == []  # stack popped
+
+    # Undo with an empty stack touches nothing.
+    empty = undo_last_delete([])
+    assert not isinstance(empty[1], list)
+
 
 def test_delete_shape_cooldown_blocks_immediate_second_delete() -> None:
     class Event:
@@ -997,12 +1012,13 @@ def test_delete_shape_cooldown_blocks_immediate_second_delete() -> None:
         {"idx": 3, "name": "last", "stl_path": "last.stl", "target_x": 30.0, "target_y": 31.0, "target_z": 32.0, "pressure": 35, "valve": 6, "port": 3, "color": "#333333"},
     ]
 
-    first_outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
+    first_outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, None, Event())
     assert [record["name"] for record in first_outputs[1]] == ["first", "last"]
 
     second_outputs = delete_shape_from_settings(
         first_outputs[1],
         first_outputs[2],
+        first_outputs[-2],  # last_delete_at (the undo stack is now last)
         first_outputs[-1],
         Event(),
     )
@@ -1022,9 +1038,9 @@ def test_non_delete_cell_selection_touches_nothing() -> None:
         {"idx": 1, "name": "first", "stl_path": "first.stl", "target_x": 10.0, "target_y": 11.0, "target_z": 12.0, "pressure": 25, "valve": 4, "port": 1, "color": "#111111"},
     ]
 
-    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
+    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, None, Event())
 
-    assert len(outputs) == 9
+    assert len(outputs) == 10
     assert all(not isinstance(value, list) for value in outputs)
     assert not isinstance(outputs[1], list)  # records State untouched
 
@@ -1904,6 +1920,47 @@ def test_rotation_marker_shows_in_table_and_strips_on_read() -> None:
     assert _display_shape_name(record) == "bar"
 
 
+def test_regenerate_preview_slices_the_selected_shape_on_demand(tmp_path) -> None:
+    import trimesh
+
+    from app import slice_selected_shape_for_preview
+
+    trimesh.creation.box(extents=(4.0, 4.0, 2.0)).export(tmp_path / "cube.stl")
+    records = _records_from_files([str(tmp_path / "cube.stl")], None)
+    assert records[0].get("layer_stack") is None
+
+    updated = slice_selected_shape_for_preview(records, None, None, 1.0, None)
+    stack = updated[0].get("layer_stack")
+    assert stack is not None and len(stack.layers) == 2
+
+    # Split pieces (no STL) are a no-op.
+    piece = [{"idx": 1, "name": "piece", "stl_path": None, "split_group_id": "s"}]
+    assert slice_selected_shape_for_preview(piece, None, None, 1.0, None) == piece
+
+
+def test_rotation_status_notes_assembly_membership(tmp_path) -> None:
+    import trimesh
+
+    from app import apply_shape_z_rotation
+
+    for name in ("inner", "outer"):
+        trimesh.creation.box(extents=(4.0, 4.0, 2.0)).export(tmp_path / f"{name}.stl")
+    records = _records_from_files(
+        [str(tmp_path / "inner.stl"), str(tmp_path / "outer.stl")], None
+    )
+    # Same nozzle -> a multi-material assembly.
+    records[0]["nozzle"] = records[1]["nozzle"] = 1
+
+    _updated, _rows, status = apply_shape_z_rotation(records, None, None, 90)
+    assert "multi-material assembly" in status
+    assert "SAME angle" in status
+
+    # A solo shape gets no assembly note.
+    solo = _records_from_files([str(tmp_path / "inner.stl")], None)
+    _updated, _rows, solo_status = apply_shape_z_rotation(solo, None, None, 90)
+    assert "assembly" not in solo_status
+
+
 def test_rotate_all_shapes_at_once(tmp_path) -> None:
     import trimesh