Add Download All zip, sliced-layer preview; always-on shared motion and G1 moves

Generate G-Code tab:
- New "Download All (.zip)" button next to the individual G-code file
list; the zip is rebuilt wherever the file list refreshes (generate,
delete, split, sync) and hides when nothing is generated. Name-
colliding entries get a _2 suffix instead of overwriting
- G-code files are named <shape>_gcode.txt (SnakePath dropped), so
individual and zipped downloads carry the shape's name
- Shared reference motion is always on: the checkbox is gone and every
generation rebuilds the combined outline at the current fil width -
forgetting it silently produced non-parallel G-code
- Constant speed is always on: the all-G1 checkbox is gone; every move
is emitted as G1 and the valve commands mark print vs travel

Shapes & Slicing tab:
- Sliced Layer Preview next to the 3D viewer: a layer slider through
the selected shape's polygon outlines drawn in its print color.
Shapes sharing the nozzle (assemblies, split cell-mates) are drawn
together at the same Z, dimmer with a legend - multi-material
slicing and Flip Z can be checked before generating G-code. Refreshes
on selection, slicing, and slider release; fixed axes across layers

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

README.md

@@ -47,11 +47,12 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Slices each shape into per-layer vector outlines held in memory (no intermediate image files)
 - Shapes that share a **nozzle number** are treated automatically as one multi-material assembly: sliced on one shared Z grid and kept exactly where they were modeled, while shapes alone on their nozzle behave as ordinary independent parts
 - 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 and Flip Z can be checked before generating G-code)
 - Splits one sliced shape's geometry into an editable row/column grid for multi-nozzle printing of one large shape
 - Converts sliced layers into G-code files with pressure, valve, nozzle, port, and infill % settings per shape from the Shape Settings table
 - **Infill %** per shape skips dispensing on evenly-distributed raster lines (rings/revolutions for spiral patterns) — at 50% every other line prints — while the motion path stays exactly the same, so parallel shapes with different infill still share one print path
 - Appends a shape outline contour after each enabled shape layer by tracing that layer's polygon boundary
-- Offers G-code generation options for raster pattern, **Use G1 for all moves** (no rapid travel command), and **Use combined reference outline for motion** (all shapes share one nozzle path; each dispenses only its own geometry)
+- Offers a choice of raster pattern for G-code generation; all shapes always share one combined reference outline for motion (one nozzle path; each dispenses only its own geometry), and every move is emitted as `G1` at one constant speed (no `G0` rapid travel)
 - Re-slices shapes automatically during G-code generation when their slices are missing or stale, so "upload, then Generate G-Code" works in one click
 - Calculates X/Y nozzle spacing from a grid layout (columns/rows plus gaps), with an optional per-connection Advanced Grid Spacing table, then visualizes the resulting nozzle layout
 - Previews selected generated G-code inline
@@ -81,7 +82,7 @@ For a multi-material object exported as separate STLs (one per material), give e
 - The group is aligned into the reference union as **one rigid unit**: each part keeps exactly the position it was modeled at relative to the others, so asymmetric assemblies line up the way they do in the 3D preview.
 - Shapes alone on their nozzle keep the normal behavior (centered onto the common reference), so regular shapes and multi-material assemblies can print together in one job.
 - **Contour Tracing** on assembly parts outlines only the assembly's true outer surface: edges where one material meets (or nearly meets, within half a bead — fit tolerances included) another material are internal interfaces and are skipped, exactly like the cut seams of grid-split pieces.
-- Combine with **Use combined reference outline for motion** so all heads share one synchronized path while each dispenses only its own part.
+- Motion is always the combined reference outline, so all heads share one synchronized path while each dispenses only its own part.
 - Nozzle renumbering in the table takes effect on the next slice or G-code generation — groups are re-detected automatically.
 - **Dimension edits scale the whole assembly**: changing a dimension of one group member applies the same scale factor (target ÷ original, per axis) to every shape on that nozzle, in both scaling modes — in Keep Proportions one edit rescales every member proportionally; in Independent X/Y/Z the edited axis's factor propagates to the group. Factors (not absolute values) keep differently-sized parts proportional to each other, and group members are scaled about the assembly's shared corner so the parts stay assembled at any size.
 - **Flip Z** (per-shape checkbox) prints a shape the other way up by mirroring it about its Z midplane. Checking it on any assembly member flips the **whole group** about the group's shared midplane, so the assembly stays together — useful when a multi-material model is authored with its display face down (e.g. the detail layer would otherwise print first instead of last).
@@ -103,13 +104,12 @@ The **Multi-Nozzle Split** accordion on the **Shapes & Slicing** tab can split o
 ### G-code Output
 
 - Generated G-code starts in relative coordinate mode (`G91`).
-- `G0` is travel and `G1` is print/feed.
-- The app generates print/feed moves where the tool path is inside a shape's layer polygons and travel moves elsewhere.
+- The app opens the valve where the tool path is inside a shape's layer polygons and closes it elsewhere.
 - Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port; the nozzle number controls layout/spacing assignment.
 - Pressure increases by `0.1` psi per layer by default.
-- **Use G1 for all moves**: when enabled, every movement line is emitted as `G1` (no `G0` rapid travel); the WAGO valve still marks where material is dispensed. Applies to all shapes.
+- Every movement line is emitted as `G1` at one constant speed (no `G0` rapid travel); the WAGO valve commands mark where material is dispensed vs where the head just travels.
 - **Lead In**: enabled per shape via the **Lead In** column in Shape Settings; the Lead In Options accordion on the Generate G-Code tab sets the patch geometry. Prints a purge patch before layer 1, in a selectable direction (Left/Right/Up/Down) at the configured clearance from the start point. The return route exits the patch laterally and comes home through the clearance lane, so the primed nozzle never drags back across the wet purge lines. For grid-split pieces the clearance is automatically extended by the assembly's remaining extent along the purge axis (reported in the G-code status), so under shared reference motion every nozzle's purge patch lands clear of the whole assembled part instead of on a neighbor's print area. The **Lead In** column in Shape Settings controls dispensing per shape: an opted-out head still travels the shared patch (keeping parallel heads in sync) but keeps its valve shut, and skips the lead-in moves entirely when printing without shared motion.
-- **Use combined reference outline for motion**: when enabled, every shape's *motion* is taken from the combined reference layer union while each shape's *valve/dispensing* comes from its own layer polygons — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference union is rebuilt automatically when shapes are sliced. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.
+- **Combined reference outline for motion** (always on): every shape's *motion* is taken from the combined reference layer union while each shape's *valve/dispensing* comes from its own layer polygons — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference union is rebuilt automatically whenever shapes are sliced or G-code is generated. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.
 - Generated files contain only machine commands (no metadata comments). The toolpath's world anchor — the position, in the shape's own frame, that the relative moves start from — is kept on the shape's session record and used to place parallel parts so split pieces reassemble.
 - **Raster Pattern**: `X-direction raster` sweeps every layer back-and-forth in X. `Y-direction raster` rasters every layer in Y. `90° Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps. `45° Woodpile raster` rotates the sweep 45 degrees per layer, cycling 0, 45, 90, 135 degrees. `Rectangular Spiral raster` walks rectangular loops from the outside toward the center, then reverses from center to edge on the next layer; the loops live on one family anchored to the shape frame, so every layer (and every split sibling) walks the same rectangles and the walls stack — outer loops that cannot touch a layer's material are skipped instead of traveled. `Circle Spiral raster` prints concentric circles stepping inward by one line width per revolution — each revolution stays at a constant radius, so the walls are smooth true circles — then reverses outward on the next layer. The outermost revolution is a perimeter wall hugging the layer's material edge (half a bead inside its farthest boundary point), so the printed silhouette follows the shape smoothly; a matching inner wall hugs a central hole when there is one. The fill rings between the walls come from one global radii grid anchored at the shape frame's center, so interior rings stack exactly across layers, and rings that cannot touch a layer's material (or would overlap a wall bead) are skipped instead of traveled. Walls always dispense even under partial infill, like contour tracing; elsewhere the valve opens only where the path is inside material. Under shared reference motion every shape's own wall radius joins the one shared ring set (all heads travel all walls, each dispenses only its own), and rings that would graze a shape's boundary are suppressed for that shape — so each parallel shape keeps a smooth, complete outer circle regardless of its dimensions.
 - **Auto Align Split Parts**: in Nozzle Spacing, computes exact per-connection grid gaps from the split pieces' generated G-code (world toolpath anchors + toolpath bounds), sets the grid columns/rows from the split, and fills the Advanced Grid Spacing table. Works for every raster pattern, filament width, reference-motion setting, and overlapping-layer split. Requires the pieces' G-code to be generated first.

app.py

@@ -4,6 +4,7 @@ import math
 import tempfile
 import time
 import warnings
+import zipfile
 from pathlib import Path
 from typing import Any
 
@@ -2253,6 +2254,32 @@ def _gcode_dropdown_update(records: list[dict], selected: str | None = None, inc
     return gr.update(choices=choices, value=value)
 
 
+def _gcode_zip_update(records: list[dict] | None) -> dict[str, Any]:
+    """Bundle every generated G-code file into one ZIP for the Download All
+    button. Rebuilt wherever the individual download list is refreshed so the
+    two can never disagree; the button hides when there is nothing to bundle."""
+    paths = [
+        record.get("gcode_path")
+        for record in (records or [])
+        if record.get("gcode_path") and Path(record["gcode_path"]).exists()
+    ]
+    if not paths:
+        return gr.update(visible=False)
+    zip_path = Path(tempfile.mkdtemp(prefix="gcode_zip_")) / "all_shapes_gcode.zip"
+    used_names: set[str] = set()
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as bundle:
+        for path in paths:
+            arcname = Path(path).name
+            stem, suffix = Path(path).stem, Path(path).suffix
+            counter = 2
+            while arcname in used_names:
+                arcname = f"{stem}_{counter}{suffix}"
+                counter += 1
+            used_names.add(arcname)
+            bundle.write(path, arcname=arcname)
+    return gr.update(value=str(zip_path), visible=True)
+
+
 def _merge_file_paths(*file_groups: Any) -> list[str]:
     merged: list[str] = []
     seen: set[str] = set()
@@ -2288,6 +2315,7 @@ def sync_uploaded_shapes(
         _gcode_dropdown_update(next_records),
         _gcode_dropdown_update(next_records, include_upload=True),
         [record.get("gcode_path") for record in next_records if record.get("gcode_path")],
+        _gcode_zip_update(next_records),
     )
 
 
@@ -2322,6 +2350,7 @@ def _shape_delete_outputs(
         _gcode_dropdown_update(records),
         _gcode_dropdown_update(records, include_upload=True),
         [record.get("gcode_path") for record in records if record.get("gcode_path")],
+        _gcode_zip_update(records),
         float(last_delete_at or 0.0),
     )
 
@@ -2332,7 +2361,7 @@ 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(8))
+    return tuple(gr.skip() for _ in range(9))
 
 
 def delete_shape_from_settings(
@@ -2727,6 +2756,130 @@ def show_selected_model(
     )
 
 
+def _polygon_patch(polygon, **kwargs):
+    """A filled matplotlib patch for a shapely Polygon, holes included."""
+    from matplotlib.patches import PathPatch
+    from matplotlib.path import Path as MplPath
+
+    verts: list[tuple[float, float]] = []
+    codes: list[int] = []
+    for ring in [polygon.exterior, *polygon.interiors]:
+        coords = list(ring.coords)
+        if len(coords) < 3:
+            continue
+        verts.extend(coords)
+        codes.extend([MplPath.MOVETO] + [MplPath.LINETO] * (len(coords) - 2) + [MplPath.CLOSEPOLY])
+    return PathPatch(MplPath(verts, codes), **kwargs)
+
+
+def _layer_preview_message(message: str):
+    from matplotlib.figure import Figure
+
+    fig = Figure(figsize=(5.4, 5.0), dpi=100)
+    ax = fig.add_subplot(111)
+    ax.axis("off")
+    ax.text(0.5, 0.5, message, ha="center", va="center", wrap=True, fontsize=11, color="#666666")
+    return fig
+
+
+def update_layer_preview(
+    records: list[dict] | None,
+    selected: str | None,
+    settings_table: Any,
+    layer_value: float,
+) -> tuple:
+    """Slider + figure for the sliced-layer preview.
+
+    Draws the selected shape's layer polygons in its print color. Shapes on
+    the same nozzle are parts of one assembly, so their polygons at the same
+    Z are drawn too (dimmer) — this is where multi-material slicing and Flip
+    Z can be checked before generating any G-code.
+    """
+    from matplotlib.figure import Figure
+    from matplotlib.patches import Patch
+
+    records = _apply_shape_settings(list(records or []), settings_table)
+    pos = _selected_record_index(records, selected)
+    if pos < 0:
+        return gr.update(maximum=1, value=1), _layer_preview_message("Load a shape to preview its sliced layers.")
+    record = records[pos]
+    stack = record.get("layer_stack")
+    if stack is None or not getattr(stack, "layers", None):
+        return (
+            gr.update(maximum=1, value=1),
+            _layer_preview_message("Slice Shapes to see this shape's layer outlines."),
+        )
+
+    layer_count = len(stack.layers)
+    layer_index = max(1, min(layer_count, _coerce_int(layer_value, 1)))
+    z_value = stack.z_values[layer_index - 1]
+    half_layer = float(stack.layer_height or 0.8) / 2.0
+
+    nozzle = _record_nozzle_number(record, int(record.get("idx", pos + 1) or (pos + 1)))
+    drawn: list[tuple[dict, Any]] = []  # (record, MultiPolygon at ~z)
+    for other_pos, other in enumerate(records):
+        other_stack = other.get("layer_stack")
+        if other_stack is None or not getattr(other_stack, "layers", None) or other_pos == pos:
+            continue
+        if _record_nozzle_number(other, int(other.get("idx", other_pos + 1) or (other_pos + 1))) != nozzle:
+            continue
+        z_values = other_stack.z_values
+        nearest = min(range(len(z_values)), key=lambda k: abs(z_values[k] - z_value))
+        if abs(z_values[nearest] - z_value) <= half_layer:
+            drawn.append((other, other_stack.layers[nearest]))
+    drawn.append((record, stack.layers[layer_index - 1]))  # selected on top
+
+    fig = Figure(figsize=(5.4, 5.0), dpi=100)
+    ax = fig.add_subplot(111)
+    legend_handles = []
+    has_material = False
+    for member, layer in drawn:
+        is_selected = member is record
+        color = str(member.get("color") or _default_color(int(member.get("idx", 0) or 0)))
+        for polygon in getattr(layer, "geoms", []):
+            if polygon.is_empty:
+                continue
+            has_material = True
+            ax.add_patch(
+                _polygon_patch(
+                    polygon,
+                    facecolor=color,
+                    alpha=0.85 if is_selected else 0.45,
+                    edgecolor="#333333",
+                    linewidth=0.7,
+                )
+            )
+        if len(drawn) > 1:
+            legend_handles.append(
+                Patch(facecolor=color, alpha=0.85 if is_selected else 0.45, label=str(member.get("name") or f"Shape {member.get('idx')}"))
+            )
+
+    # Fixed frame across the whole stack (assembly bounds) so the view
+    # doesn't jump between layers.
+    xs: list[float] = []
+    ys: list[float] = []
+    for member, _layer in drawn:
+        bounds = member["layer_stack"].bounds
+        xs.extend((bounds[0][0], bounds[1][0]))
+        ys.extend((bounds[0][1], bounds[1][1]))
+    margin = max(1.0, 0.05 * max(max(xs) - min(xs), max(ys) - min(ys)))
+    ax.set_xlim(min(xs) - margin, max(xs) + margin)
+    ax.set_ylim(min(ys) - margin, max(ys) + margin)
+    ax.set_aspect("equal")
+    ax.grid(True, linewidth=0.3, alpha=0.4)
+    ax.set_xlabel("X (mm)")
+    ax.set_ylabel("Y (mm)")
+    name = str(record.get("name") or f"Shape {record.get('idx')}")
+    title = f"{name} — layer {layer_index}/{layer_count} (z = {z_value:.2f} mm)"
+    if not has_material:
+        title += "  [empty layer]"
+    ax.set_title(title, fontsize=10)
+    if legend_handles:
+        ax.legend(handles=legend_handles, fontsize=8, loc="upper right")
+    fig.tight_layout()
+    return gr.update(maximum=layer_count, value=layer_index), fig
+
+
 def _slice_params_snapshot(
     record: dict,
     layer_height: float,
@@ -3188,6 +3341,7 @@ def split_selected_shape_for_grid(
             _gcode_dropdown_update(next_records, include_upload=True),
             _dropdown_update(next_records, selected_value),
             status,
+            _gcode_zip_update(next_records),
         )
 
     if not records:
@@ -3369,30 +3523,23 @@ def _lead_in_assembly_extension(records: list[dict], direction: str | None) -> f
 def generate_dynamic_gcode(
     records: list[dict] | None,
     settings_table: Any,
-    all_g1: bool,
-    use_reference_motion: bool,
     raster_pattern: str | None,
     pressure_ramp_enabled: bool,
     lead_in_length: float,
     lead_in_clearance: float,
     lead_in_lines: float,
     lead_in_direction: str | None,
-    ref_layers: LayerStack | None,
     layer_height: float,
     fil_width: float,
     scale_mode: str | None,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     messages: list[str] = []
-    resliced = _ensure_records_sliced(records, layer_height, scale_mode, messages)
-    if use_reference_motion or resliced:
-        # Always rebuild with the CURRENT fil width: the reference stack's
-        # alignment snap grid must match the fil the G-code is generated with.
-        ref_layers = generate_dynamic_reference_stack(records, fil_width)
-    else:
-        # Still refresh group frames + seam-free contours: nozzle numbers may
-        # have been edited in the table since the last slice.
-        _stamp_multi_material_frames(records, fil_width)
+    _ensure_records_sliced(records, layer_height, scale_mode, messages)
+    # 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.
+    ref_layers = generate_dynamic_reference_stack(records, fil_width)
     contour_sources = _contour_tracing_sources(records)
     if contour_sources:
         enabled = ", ".join(f"Shape {source.owner_idx}" for source in contour_sources)
@@ -3424,8 +3571,8 @@ def generate_dynamic_gcode(
         if stack is None or not getattr(stack, "layers", None):
             messages.append(f"Shape {record['idx']}: skipped (no sliced layers).")
             continue
-        if use_reference_motion and ref_layers is None:
-            messages.append(f"Shape {record['idx']}: skipped (Reference motion selected, but no shapes are sliced).")
+        if ref_layers is None:
+            messages.append(f"Shape {record['idx']}: skipped (no combined reference outline; slice a shape first).")
             continue
         shape_name = str(record.get("name") or stack.name or f"shape_{record['idx']}").replace(" ", "_")
         try:
@@ -3438,8 +3585,11 @@ def generate_dynamic_gcode(
                 layer_height=float(layer_height),
                 fil_width=float(fil_width),
                 pressure_ramp_enabled=bool(pressure_ramp_enabled),
-                all_g1=bool(all_g1),
-                motion=ref_layers if use_reference_motion else None,
+                # Always one constant speed: every move is emitted as G1 (no
+                # G0 rapid travel); the valve commands still mark print vs
+                # travel.
+                all_g1=True,
+                motion=ref_layers,
                 raster_pattern=raster_pattern,
                 contour_sources=contour_sources,
                 active_contour_owner=int(record.get("idx", 0)),
@@ -3450,7 +3600,7 @@ def generate_dynamic_gcode(
                 lead_in_lines=max(1, _coerce_int(lead_in_lines, 3)),
                 lead_in_direction=lead_in_direction or LEAD_IN_DIRECTION_LEFT,
                 lead_in_dispense=bool(record.get("lead_in", True)),
-                wall_sources=wall_sources if use_reference_motion else None,
+                wall_sources=wall_sources,
                 origin_sink=(origin_sink := {}),
             )
             record["gcode_path"] = str(gcode_path)
@@ -3467,6 +3617,7 @@ def generate_dynamic_gcode(
         "\n".join(messages),
         _gcode_dropdown_update(records),
         _gcode_dropdown_update(records, include_upload=True),
+        _gcode_zip_update(records),
     )
 
 
@@ -3803,6 +3954,15 @@ def build_dynamic_demo() -> gr.Blocks:
                             camera_position=FRONT_CAMERA,
                             height=360,
                         )
+                    with gr.Column(scale=2, min_width=380):
+                        layer_preview_plot = gr.Plot(label="Sliced Layer Preview")
+                        layer_preview_slider = gr.Slider(
+                            label="Layer",
+                            minimum=1,
+                            maximum=1,
+                            step=1,
+                            value=1,
+                        )
                     with gr.Column(scale=1, min_width=300):
                         model_details = gr.Markdown("No model loaded.")
 
@@ -3813,13 +3973,9 @@ def build_dynamic_demo() -> gr.Blocks:
                 """
                 # Generate G-Code
                 Generate G-code for every sliced shape. Pressure, valve, nozzle, port, and color come from the Shape Settings table.
+                All shapes share one combined nozzle path (each dispenses only its own geometry), so parallel heads always stay in sync.
                 """
             )
-            gcode_use_ref_motion = gr.Checkbox(
-                label="Use combined reference outline for motion (all shapes share one nozzle path; each dispenses only its own geometry).",
-                value=True,
-            )
-            gcode_all_g1 = gr.Checkbox(label="Move at one constant speed (no fast travel moves)", value=True)
             gcode_pressure_ramp_enabled = gr.Checkbox(label="Increase Pressure Each Layer", value=True)
             gcode_raster_pattern = gr.Dropdown(
                 label="Raster Pattern",
@@ -3840,7 +3996,15 @@ def build_dynamic_demo() -> gr.Blocks:
                         allow_custom_value=False,
                     )
             gcode_button = gr.Button("Generate G-Code", variant="primary")
-            gcode_downloads = gr.File(label="Download G-Code Files", file_count="multiple", interactive=False, elem_classes=["gcode-download"])
+            with gr.Row():
+                with gr.Column(scale=4):
+                    gcode_downloads = gr.File(label="Download G-Code Files", file_count="multiple", interactive=False, elem_classes=["gcode-download"])
+                with gr.Column(scale=1, min_width=200):
+                    gcode_download_all = gr.DownloadButton(
+                        "Download All (.zip)",
+                        variant="secondary",
+                        visible=False,
+                    )
             gcode_status = gr.Markdown("")
             with gr.Row():
                 gcode_text_source = gr.Dropdown(label="Preview G-Code", choices=[], value=None, allow_custom_value=False)
@@ -3970,7 +4134,7 @@ def build_dynamic_demo() -> gr.Blocks:
             nozzle_grid_use_individual_spacing,
         ]
 
-        shape_sync_outputs = [shape_records, shape_settings, selected_shape, gcode_text_source, gcode_source, gcode_downloads]
+        shape_sync_outputs = [shape_records, shape_settings, selected_shape, gcode_text_source, gcode_source, gcode_downloads, gcode_download_all]
         stl_upload.change(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings], outputs=shape_sync_outputs).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
@@ -4053,6 +4217,14 @@ def build_dynamic_demo() -> gr.Blocks:
         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])
         model_opacity.change(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)
+        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,
             inputs=[shape_records, shape_settings, scale_mode],
@@ -4077,6 +4249,10 @@ def build_dynamic_demo() -> gr.Blocks:
             fn=generate_dynamic_layer_stacks,
             inputs=[shape_records, shape_settings, layer_height, scale_mode, fil_width],
             outputs=[shape_records, slicer_status, ref_layers],
+        ).then(
+            fn=update_layer_preview,
+            inputs=layer_preview_inputs,
+            outputs=layer_preview_outputs,
         ).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
@@ -4115,6 +4291,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 gcode_source,
                 split_source,
                 split_status,
+                gcode_download_all,
             ],
         ).then(
             fn=generate_dynamic_reference_stack,
@@ -4132,20 +4309,17 @@ def build_dynamic_demo() -> gr.Blocks:
             inputs=[
                 shape_records,
                 shape_settings,
-                gcode_all_g1,
-                gcode_use_ref_motion,
                 gcode_raster_pattern,
                 gcode_pressure_ramp_enabled,
                 gcode_lead_in_length,
                 gcode_lead_in_clearance,
                 gcode_lead_in_lines,
                 gcode_lead_in_direction,
-                ref_layers,
                 layer_height,
                 fil_width,
                 scale_mode,
             ],
-            outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source],
+            outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source, gcode_download_all],
         ).then(
             fn=load_selected_gcode_text,
             inputs=[shape_records, gcode_text_source],

tests/test_nozzle_spacing.py

@@ -723,7 +723,7 @@ def test_non_delete_cell_selection_touches_nothing() -> None:
 
     outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
 
-    assert len(outputs) == 8
+    assert len(outputs) == 9
     assert all(not isinstance(value, list) for value in outputs)
     assert not isinstance(outputs[1], list)  # records State untouched
 
@@ -1101,6 +1101,84 @@ def test_apply_bulk_bool_selection_sets_a_whole_column() -> None:
     assert refused[0].get("color") == cleared[0].get("color")
 
 
+def test_download_all_zip_bundles_gcode_files_by_shape_name(tmp_path) -> None:
+    import zipfile
+
+    from app import _gcode_zip_update
+
+    first = tmp_path / "circle_gcode.txt"
+    first.write_text("G91\n")
+    other_dir = tmp_path / "other"
+    other_dir.mkdir()
+    duplicate = other_dir / "circle_gcode.txt"
+    duplicate.write_text("G91\n")
+    square = tmp_path / "square_gcode.txt"
+    square.write_text("G91\n")
+
+    update = _gcode_zip_update(
+        [
+            {"idx": 1, "gcode_path": str(first)},
+            {"idx": 2, "gcode_path": str(duplicate)},
+            {"idx": 3, "gcode_path": str(square)},
+            {"idx": 4, "gcode_path": None},
+        ]
+    )
+    assert update["visible"] is True
+    with zipfile.ZipFile(update["value"]) as bundle:
+        assert sorted(bundle.namelist()) == [
+            "circle_gcode.txt",
+            "circle_gcode_2.txt",
+            "square_gcode.txt",
+        ]
+
+    # Nothing generated yet: the button hides instead of offering an empty zip.
+    hidden = _gcode_zip_update([{"idx": 1, "gcode_path": None}])
+    assert hidden["visible"] is False
+
+
+def test_layer_preview_draws_the_selection_and_its_nozzle_group() -> None:
+    from shapely.geometry import MultiPolygon, box
+
+    from app import update_layer_preview
+    from stl_slicer import LayerStack
+
+    def _preview_stack(name: str, poly) -> LayerStack:
+        return LayerStack(
+            layers=[MultiPolygon([poly]), MultiPolygon([poly])],
+            z_values=[0.4, 1.2],
+            bounds=((0.0, 0.0, 0.0), (10.0, 10.0, 1.6)),
+            layer_height=0.8,
+            name=name,
+        )
+
+    records = [
+        {"idx": 1, "name": "base", "stl_path": "base.stl", "nozzle": 1, "color": "#ff0000",
+         "layer_stack": _preview_stack("base", box(0.0, 0.0, 10.0, 10.0))},
+        {"idx": 2, "name": "stripe", "stl_path": "stripe.stl", "nozzle": 1, "color": "#0000ff",
+         "layer_stack": _preview_stack("stripe", box(2.0, 2.0, 8.0, 8.0))},
+        {"idx": 3, "name": "solo", "stl_path": "solo.stl", "nozzle": 2, "color": "#00ff00",
+         "layer_stack": _preview_stack("solo", box(0.0, 0.0, 5.0, 5.0))},
+    ]
+
+    # Selected shape plus its same-nozzle assembly sibling are both drawn.
+    slider, fig = update_layer_preview(records, "1: base", None, 2)
+    assert slider["maximum"] == 2
+    assert slider["value"] == 2
+    assert len(fig.axes[0].patches) == 2
+
+    # A shape alone on its nozzle draws only itself; out-of-range slider
+    # values clamp to the layer count.
+    slider_solo, fig_solo = update_layer_preview(records, "3: solo", None, 99)
+    assert slider_solo["value"] == 2
+    assert len(fig_solo.axes[0].patches) == 1
+
+    # Unsliced shape: slider resets, figure carries the hint (no patches).
+    unsliced = [{"idx": 1, "name": "raw", "stl_path": "raw.stl", "nozzle": 1, "color": "#ff0000", "layer_stack": None}]
+    slider_reset, fig_hint = update_layer_preview(unsliced, "1: raw", None, 5)
+    assert slider_reset["maximum"] == 1
+    assert not fig_hint.axes[0].patches
+
+
 def test_load_sample_shapes_respects_the_selected_set() -> None:
     from app import DEFAULT_SAMPLE_STL_SET, SAMPLE_STL_SETS, load_sample_shapes
 

tests/test_vector_gcode.py

@@ -176,6 +176,21 @@ def test_slanted_shape_gcode_round_trips_through_the_viewer(tmp_path) -> None:
             assert -1.0 <= y <= 21.0
 
 
+def test_gcode_file_is_named_after_the_shape(tmp_path) -> None:
+    gcode_path = generate_vector_gcode(
+        _stack(box(0.0, 0.0, 1.0, 1.0)),
+        shape_name="Simple_Circle",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        origin_sink=(origin_sink := {}),
+        output_dir=tmp_path,
+    )
+
+    assert gcode_path.name == "Simple_Circle_gcode.txt"
+
+
 def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> None:
     gcode_path = generate_vector_gcode(
         _stack(box(0.0, 0.0, 1.0, 1.0)),

vector_gcode.py

@@ -353,7 +353,7 @@ def generate_vector_gcode(
         output_dir = Path(output_dir)
         output_dir.mkdir(parents=True, exist_ok=True)
 
-    gcode_path = output_dir / f"{shape_name}_SnakePath_gcode.txt"
+    gcode_path = output_dir / f"{shape_name}_gcode.txt"
     write_gcode_file(
         gcode_path,
         gcode_list,