Add Simple Shapes sample set, fix parallel circle-spiral edges, align spiral loops

Samples & UI:
- Sample Set dropdown under Load Sample STLs: Standard Shapes (pyramid,
rounded cube, half sphere) or the new Simple Shapes (circle, square,
triangle - flat 20x20x2 test pieces, bundled via Git LFS)
- Nozzle Spacing column/row gaps default to 5 mm

Rectangular spiral:
- Loops are anchored to the shape frame's family, not each layer's own
material bounds: layers with smaller footprints (e.g. the flag's
arms-only first layer) used to spiral at their own offsets, leaving
walls visibly out of line; outer loops that cannot touch a layer's
material are skipped instead of traveled

Circle spiral under shared reference motion:
- Rings centre on the reference ALIGN centre (where every shape's centre
is placed) instead of the union bbox centre, and whole-shape centering
no longer snaps to the fil grid - shapes are exactly concentric with
the ring set
- Every shape's own wall radius joins the ONE shared ring set (all heads
travel all walls, each dispenses only its own); when a grid ring
already hugs the boundary it serves as the wall instead
- Rings grazing a shape's boundary are suppressed for that shape: no
more spotty outer ring (dimensions on the 0.8 grid) or half-circle
edge (off-grid dimensions); square-corner fill is unaffected and all
parallel heads keep identical motion

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

README.md

@@ -38,7 +38,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 ## What the app does
 
 - Uploads any number of `.stl` files with a single multi-file uploader
-- Loads bundled sample STL files and merges them with already uploaded STLs
+- Loads bundled sample STL files and merges them with already uploaded STLs — a **Sample Set** dropdown under the button picks between the standard shapes (hollow pyramid, rounded cube, half sphere) and the simple flat shapes (circle, square, triangle)
 - Syncs the uploaded STL list back into Shape Settings if the table and uploader get out of step
 - Shows an interactive selected-shape 3D viewer for rotating each model
 - Shows model extents, face count, vertex count, and watertight status
@@ -111,7 +111,7 @@ The **Multi-Nozzle Split** accordion on the **Shapes & Slicing** tab can split o
 - **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.
 - Every generated file starts with a `; PathOrigin X.. Y..` comment: the world position (in the shape's own frame) that the relative toolpath starts from. Tools use it 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 each layer from the outer layer bounds toward the center, then reverses from center to edge on the next layer. `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.
+- **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 (`PathOrigin` 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.
 - **Contour Tracing**: enabled per row in Shape Settings. The app traces the layer polygon's boundary rings (holes traced separately), travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer. For grid-split pieces only the parent shape's true outer surface is traced — the cut seams between sibling pieces are excluded (open arcs are printed end-to-end without closing the loop; fully interior pieces get no contour). Multi-material assembly parts (shapes sharing a nozzle) work the same way: boundary within half a bead of a sibling material counts as an internal interface and is not contoured — only the assembled shape's true outer surface is traced, and a part fully embedded in the assembly gets no contour at all.
 

app.py

@@ -50,7 +50,11 @@ from vector_toolpath import (
 )
 
 
-SAMPLE_STL_FILENAMES = ("Hollow_Pyramid.stl", "Rounded_Cube_Through_Holes.stl", "halfsphere.stl")
+SAMPLE_STL_SETS = {
+    "Standard Shapes": ("Hollow_Pyramid.stl", "Rounded_Cube_Through_Holes.stl", "halfsphere.stl"),
+    "Simple Shapes": ("Simple_Circle.stl", "Simple_Square.stl", "Simple_Triangle.stl"),
+}
+DEFAULT_SAMPLE_STL_SET = "Standard Shapes"
 SAMPLE_STL_DIR = Path(__file__).resolve().parent / "sample_stls"
 DEFAULT_TARGET_EXTENTS = (20.0, 20.0, 20.0)
 DELETE_SHAPE_COOLDOWN_SECONDS = 1.0
@@ -2291,9 +2295,13 @@ def load_sample_shapes(
     files: Any,
     records: list[dict] | None,
     settings_table: Any | None = None,
+    sample_set: str | None = None,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
-    paths = [str(SAMPLE_STL_DIR / filename) for filename in SAMPLE_STL_FILENAMES if (SAMPLE_STL_DIR / filename).exists()]
+    filenames = SAMPLE_STL_SETS.get(
+        str(sample_set or ""), SAMPLE_STL_SETS[DEFAULT_SAMPLE_STL_SET]
+    )
+    paths = [str(SAMPLE_STL_DIR / filename) for filename in filenames if (SAMPLE_STL_DIR / filename).exists()]
     merged_paths = _append_file_paths(files, paths)
     return (
         gr.update(value=merged_paths),
@@ -3389,6 +3397,15 @@ def generate_dynamic_gcode(
     if contour_sources:
         enabled = ", ".join(f"Shape {source.owner_idx}" for source in contour_sources)
         messages.append(f"Contour tracing enabled for {enabled}.")
+    # Circle Spiral under shared motion: every shape's own wall radius joins
+    # the one shared ring set (same list for every shape, so motion stays in
+    # sync). Split pieces carry a scan frame and are excluded.
+    wall_sources = [
+        record["layer_stack"]
+        for record in records
+        if record.get("layer_stack") is not None
+        and getattr(record["layer_stack"], "scan_frame", None) is None
+    ]
     # Lead-in is driven entirely by the per-shape "Lead In" column: the
     # purge motion exists whenever any shape dispenses it (all heads must
     # share the motion), and each shape's own flag gates its valve.
@@ -3433,6 +3450,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,
             )
             record["gcode_path"] = str(gcode_path)
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
@@ -3694,6 +3712,12 @@ def build_dynamic_demo() -> gr.Blocks:
                 )
                 with gr.Column(scale=0, min_width=200):
                     load_samples_button = gr.Button("Load Sample STLs", variant="secondary", size="sm", elem_id="load-sample-stls-button")
+                    sample_set_selector = gr.Dropdown(
+                        choices=list(SAMPLE_STL_SETS),
+                        value=DEFAULT_SAMPLE_STL_SET,
+                        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")
                     model_opacity = gr.Checkbox(label="Use 75% 3D Model Opacity", value=False)
@@ -3825,8 +3849,8 @@ def build_dynamic_demo() -> gr.Blocks:
                         )
                         nozzle_grid_columns = gr.Number(label="Grid Columns", value=2, minimum=1, step=1)
                         nozzle_grid_rows = gr.Number(label="Grid Rows", value=2, minimum=1, step=1)
-                        nozzle_grid_column_spacing = gr.Number(label="Column Gap (X, mm)", value=0.0, step=0.1)
-                        nozzle_grid_row_spacing = gr.Number(label="Row Gap (Y, mm)", value=0.0, step=0.1)
+                        nozzle_grid_column_spacing = gr.Number(label="Column Gap (X, mm)", value=5.0, step=0.1)
+                        nozzle_grid_row_spacing = gr.Number(label="Row Gap (Y, mm)", value=5.0, step=0.1)
                     with gr.Row():
                         auto_align_split_parts_button = gr.Button("Auto Align Split Parts", variant="secondary", size="sm")
                         nozzle_grid_use_individual_spacing = gr.Checkbox(label="Advanced Grid Spacing", value=False)
@@ -3960,7 +3984,7 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[nozzle_grid_spacing_table],
             queue=False,
         )
-        load_samples_button.click(fn=load_sample_shapes, inputs=[stl_upload, shape_records, shape_settings], outputs=[stl_upload, *shape_sync_outputs]).then(
+        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=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],

sample_stls/Simple_Circle.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74239bc674be23b3e265ab1830e7e9968f07ddb97e3771dc699b48afce9ecbee
+size 14484

sample_stls/Simple_Square.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:774f7323942243b6810307e44126e2e6f5175ac77e3e6559f73691af86c3209f
+size 684

sample_stls/Simple_Triangle.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d109f3f99963f82eebda45cb7144560603c790b30fe9b7c7b1d815a421b9bdd
+size 484

tests/test_nozzle_spacing.py

@@ -1093,3 +1093,24 @@ def test_apply_bulk_bool_selection_sets_a_whole_column() -> None:
     color_pos = SHAPE_SETTINGS_HEADERS.index("Color")
     refused, _rows4 = apply_bulk_bool_selection(cleared, rows2, f"{color_pos}|1")
     assert refused[0].get("color") == cleared[0].get("color")
+
+
+def test_load_sample_shapes_respects_the_selected_set() -> None:
+    from app import DEFAULT_SAMPLE_STL_SET, SAMPLE_STL_SETS, load_sample_shapes
+
+    simple = load_sample_shapes(None, [], None, "Simple Shapes")
+    assert [record["name"] for record in simple[1]] == [
+        "Simple_Circle", "Simple_Square", "Simple_Triangle",
+    ]
+
+    standard = load_sample_shapes(None, [], None, "Standard Shapes")
+    assert [record["name"] for record in standard[1]] == [
+        "Hollow_Pyramid", "Rounded_Cube_Through_Holes", "halfsphere",
+    ]
+
+    # Unknown/empty selection falls back to the default set.
+    fallback = load_sample_shapes(None, [], None, None)
+    assert [record["name"] for record in fallback[1]] == [
+        "Hollow_Pyramid", "Rounded_Cube_Through_Holes", "halfsphere",
+    ]
+    assert DEFAULT_SAMPLE_STL_SET in SAMPLE_STL_SETS

tests/test_vector_gcode.py

@@ -1699,3 +1699,146 @@ def test_boundary_grid_line_grazing_from_outside_still_prints() -> None:
     )
     print_ys = sorted({y0 for _x0, y0, _x1, _y1, color in segments if color == 255})
     assert abs(print_ys[0] - (-15.2)) < 1e-6  # boundary sweep printed
+
+
+def test_rectangular_spiral_layers_share_one_loop_family(tmp_path) -> None:
+    from gcode_viewer import parse_gcode_path
+
+    # Layers with different footprints must walk the SAME frame-anchored
+    # rectangles — a smaller layer used to spiral at its own inset, leaving
+    # its walls visibly out of line with the rest of the print.
+    big = box(0.0, 0.0, 20.0, 20.0)
+    small = box(5.0, 5.0, 15.0, 15.0)
+    gcode_path = generate_vector_gcode(
+        _stack(big, small),
+        shape_name="loop_family",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=0.8,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_RECTANGULAR_SPIRAL,
+        output_dir=tmp_path,
+    )
+    parsed = parse_gcode_path(gcode_path.read_text())
+    origin_x, origin_y = parsed["path_origin"]
+
+    # Loop side lines = x positions of VERTICAL runs (valve-split points
+    # and the start stub sit mid-edge and are not loop lines).
+    per_layer_xs: dict[int, set] = {}
+    for kind in ("print_segments", "travel_segments"):
+        for segment in parsed[kind]:
+            for a, b in zip(segment, segment[1:]):
+                if abs(a[0] - b[0]) < 1e-9 and abs(a[1] - b[1]) > 1e-6:
+                    per_layer_xs.setdefault(int(round(a[2])), set()).add(
+                        round(a[0] + origin_x, 3)
+                    )
+    layer0 = per_layer_xs[0]
+    stray = {x for x in per_layer_xs[1] if x not in layer0}
+    assert not stray, stray
+
+
+def test_circle_spiral_interior_is_stepped_rings(tmp_path) -> None:
+    from gcode_viewer import parse_gcode_path
+
+    # The fill is concentric CONSTANT-RADIUS rings (wall at the material
+    # edge, interior rings on the global grid) stepping inward by one fil
+    # per revolution - not a continuously decreasing spiral.
+    disc = Point(5.0, 5.0).buffer(5.0, quad_segs=64)
+    gcode_path = generate_vector_gcode(
+        _stack(disc, disc),
+        shape_name="stepped",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=0.8,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_CIRCLE_SPIRAL,
+        output_dir=tmp_path,
+    )
+    parsed = parse_gcode_path(gcode_path.read_text())
+    origin_x, origin_y = parsed["path_origin"]
+
+    radii = sorted({
+        round(math.hypot(x + origin_x - 5.0, y + origin_y - 5.0), 1)
+        for seg in parsed["print_segments"]
+        for x, y, z in seg
+        if abs(z) < 0.5
+    })
+    # A handful of discrete radii: the wall (4.6) plus grid rings.
+    assert len(radii) <= 8, radii
+    assert abs(radii[-1] - (5.0 - 0.4)) < 0.05  # wall hugs the material edge
+    for radius in radii[:-1]:
+        ring = radius / 0.8 - 0.5
+        assert abs(ring - round(ring)) < 0.15  # interior rings on the grid
+
+
+def test_parallel_circle_keeps_a_complete_outer_ring(tmp_path) -> None:
+    from gcode_viewer import parse_gcode_path
+
+    # Under shared reference motion the ring set used to come from the
+    # UNION only: the grid ring nearest a circle's boundary grazed it and
+    # printed spotty specks (dimensions on the grid) or a half circle
+    # (off-grid dimensions). Every shape's own wall now joins the shared
+    # ring set and grazing rings are suppressed per shape.
+    for diameter in (20.0, 20.5):
+        disc_layer = Point(diameter / 2.0, diameter / 2.0).buffer(diameter / 2.0, quad_segs=64)
+        square_layer = box(0.0, 0.0, 20.0, 20.0)
+        disc = _stack(disc_layer, name=f"disc{int(diameter * 10)}")
+        square = _stack(square_layer, name=f"square{int(diameter * 10)}")
+        reference = build_reference_stack([disc, square], grid=0.8)
+        wall_sources = [disc, square]
+
+        lengths = []
+        for stack in (disc, square):
+            gcode_path = generate_vector_gcode(
+                stack,
+                shape_name=stack.name + "_p",
+                pressure=25,
+                valve=7,
+                port=3,
+                fil_width=0.8,
+                layer_height=1.0,
+                raster_pattern=RASTER_PATTERN_CIRCLE_SPIRAL,
+                motion=reference,
+                wall_sources=wall_sources,
+                output_dir=tmp_path,
+            )
+            parsed = parse_gcode_path(gcode_path.read_text())
+            lengths.append(
+                round(
+                    sum(
+                        math.dist(a[:2], b[:2])
+                        for kind in ("print_segments", "travel_segments")
+                        for seg in parsed[kind]
+                        for a, b in zip(seg, seg[1:])
+                    ),
+                    6,
+                )
+            )
+            if stack is not disc:
+                continue
+            origin_x, origin_y = parsed["path_origin"]
+            center = diameter / 2.0
+            per_ring: dict[float, dict[str, float]] = {}
+            for kind, key in (("print_segments", "p"), ("travel_segments", "t")):
+                for seg in parsed[kind]:
+                    for a, b in zip(seg, seg[1:]):
+                        radius = round(
+                            math.hypot(
+                                (a[0] + b[0]) / 2 + origin_x - center,
+                                (a[1] + b[1]) / 2 + origin_y - center,
+                            ),
+                            1,
+                        )
+                        per_ring.setdefault(radius, {"p": 0.0, "t": 0.0})[key] += math.dist(a[:2], b[:2])
+            printed = [r for r, v in per_ring.items() if v["p"] > 1.0]
+            outer = max(printed)
+            v = per_ring[outer]
+            # The disc's outermost ring is COMPLETE (no spotty/half arcs).
+            assert v["p"] / (v["p"] + v["t"]) > 0.98, (diameter, outer, v)
+            # And it hugs the boundary (within one bead of the radius).
+            assert diameter / 2.0 - outer < 0.8, (diameter, outer)
+        # Parallel sync: same path length (tolerance = 6-decimal G-code
+        # rounding; moves split at different valve boundaries per shape).
+        assert abs(lengths[0] - lengths[1]) < 1e-3, lengths

vector_gcode.py

@@ -30,6 +30,7 @@ from vector_toolpath import (
     _normalize_raster_pattern,
     align_stack_to,
     build_contour_layers,
+    circle_wall_radius,
     plan_layer_moves,
 )
 
@@ -211,6 +212,7 @@ def generate_vector_gcode(
     lead_in_lines: int = 3,
     lead_in_direction: str = LEAD_IN_DIRECTION_LEFT,
     lead_in_dispense: bool = True,
+    wall_sources: list[LayerStack] | None = None,
     output_dir: str | Path | None = None,
 ) -> Path:
     """Generate G-code for one sliced shape.
@@ -220,6 +222,11 @@ def generate_vector_gcode(
     follows the shared reference path while the valve opens only inside this
     shape's own geometry, aligned into the reference frame — so parallel
     heads share one motion but each dispenses only its own shape.
+
+    `wall_sources` (all shapes in the job, whole shapes only) matters for
+    the Circle Spiral under shared motion: every shape's own wall radius
+    joins the ONE shared ring set, so each shape keeps a smooth complete
+    outer circle. Pass the SAME list to every shape's generation call.
     """
     if shape is None or not shape.layers:
         raise ValueError("The shape has no sliced layers to generate G-code from.")
@@ -258,6 +265,53 @@ def generate_vector_gcode(
         (frame_x_min, frame_y_min, _fz), (frame_x_max, frame_y_max, _fz2) = frame_stack.bounds
         scan_frame = (frame_x_min, frame_y_min, frame_x_max, frame_y_max)
 
+    # Circle Spiral under shared motion (whole shapes): rings centre on the
+    # reference ALIGN centre (each shape is concentric with it), every
+    # shape's own wall radius joins the shared ring set, and each shape's
+    # dispensing is capped just outside its own wall so grid rings grazing
+    # its boundary stop printing spotty specks / half arcs.
+    extra_wall_radii = None
+    valve_ring_caps = None
+    ring_center = None
+    if (
+        raster_pattern == RASTER_PATTERN_CIRCLE_SPIRAL
+        and motion is not None
+        and motion.scan_frame is None
+        and shape.scan_frame is None
+    ):
+        if motion.align_center is not None:
+            ring_center = motion.align_center
+        else:
+            ring_center = (
+                (scan_frame[0] + scan_frame[2]) / 2.0,
+                (scan_frame[1] + scan_frame[3]) / 2.0,
+            )
+        n_layers = len(motion_layers)
+        valve_ring_caps = [
+            circle_wall_radius(valve_layers[index], ring_center[0], ring_center[1], fil_width)
+            for index in range(n_layers)
+        ]
+        extra_wall_radii = [[] for _ in range(n_layers)]
+        sources = [
+            source
+            for source in (wall_sources or [])
+            if source is not None and source.layers and source.scan_frame is None
+        ]
+        if sources:
+            for source in sources:
+                aligned = align_stack_to(source, motion, n_layers)
+                for index in range(n_layers):
+                    wall = circle_wall_radius(
+                        aligned[index], ring_center[0], ring_center[1], fil_width
+                    )
+                    if wall is not None:
+                        extra_wall_radii[index].append(wall)
+        else:
+            # No source list: at least this shape's own wall.
+            for index, cap in enumerate(valve_ring_caps):
+                if cap is not None:
+                    extra_wall_radii[index].append(cap)
+
     gcode_list, toolpath_origin = plan_layer_moves(
         motion_layers,
         valve_layers,
@@ -269,6 +323,9 @@ def generate_vector_gcode(
         shared_motion=motion is not None,
         scan_frame=scan_frame,
         infill_fraction=max(0.0, min(1.0, float(infill))),
+        extra_wall_radii=extra_wall_radii,
+        valve_ring_caps=valve_ring_caps,
+        ring_center=ring_center,
     )
 
     # World anchor: the toolpath origin expressed in the shape's own frame.

vector_toolpath.py

@@ -685,6 +685,76 @@ def _rectangular_spiral_polyline(
     return _extend_polyline_ends(points, half)
 
 
+def circle_wall_radius(
+    layer: MultiPolygon | None,
+    center_x: float,
+    center_y: float,
+    fil_width: float,
+) -> float | None:
+    """A layer's outermost COMPLETE ring radius about the ring centre.
+
+    Uses the minimum OUTER-boundary distance (holes ignored; the material
+    may sit slightly off the ring centre). When a global grid ring already
+    lies close under the boundary it IS the outer ring (no extra wall — a
+    custom wall a fraction of a bead away would just double-deposit);
+    otherwise the wall sits half a bead inside the closest boundary point.
+    Only meaningful when the material surrounds the centre.
+    """
+    if layer is None or layer.is_empty:
+        return None
+    center = Point(center_x, center_y)
+    for polygon in layer.geoms:
+        if not polygon.covers(center):
+            continue
+        d_min = float(polygon.exterior.distance(center))
+        grid_j = int(math.floor(d_min / fil_width - 0.5 + 1e-9))
+        if grid_j >= 0:
+            grid_ring = (grid_j + 0.5) * fil_width
+            if d_min - grid_ring <= fil_width * 0.75:
+                return grid_ring
+        wall = d_min - fil_width / 2.0
+        return wall if wall > fil_width * 0.25 else None
+    return None
+
+
+def _frame_spiral_bounds(
+    frame: tuple[float, float, float, float],
+    material_bounds: tuple[float, float, float, float],
+    fil_width: float,
+) -> tuple[float, float, float, float]:
+    """Outer bounds for a rectangular spiral, on the FRAME's loop family.
+
+    The spiral's loops live on the family "frame inset by half + k*fil per
+    side" so every layer (and every split sibling) walks the same
+    rectangles and walls stack. Loops that enclose this layer's material
+    with more than half a bead of margin on EVERY side are pure travel:
+    skip them by starting k0 loops in. Returns the frame shrunk by k0*fil
+    per side (still on the family).
+    """
+    frame_left, frame_bottom, frame_right, frame_top = frame
+    mat_left, mat_bottom, mat_right, mat_top = material_bounds
+    half = fil_width / 2.0
+    # Margin between the base loop (frame inset by half) and the material.
+    min_margin = min(
+        mat_left - (frame_left + half),
+        mat_bottom - (frame_bottom + half),
+        (frame_right - half) - mat_right,
+        (frame_top - half) - mat_top,
+    )
+    skip = max(0, int(math.ceil((min_margin - half) / fil_width - 1e-9)))
+    # Never shrink past the material's own footprint.
+    max_skip_x = (frame_right - frame_left - (mat_right - mat_left)) / (2.0 * fil_width)
+    max_skip_y = (frame_top - frame_bottom - (mat_top - mat_bottom)) / (2.0 * fil_width)
+    skip = min(skip, max(0, int(min(max_skip_x, max_skip_y))))
+    inset = skip * fil_width
+    return (
+        frame_left + inset,
+        frame_bottom + inset,
+        frame_right - inset,
+        frame_top - inset,
+    )
+
+
 def _circle_ring_radii(
     motion: MultiPolygon,
     center_x: float,
@@ -1237,6 +1307,9 @@ def plan_layer_moves(
     shared_motion: bool = False,
     scan_frame: tuple[float, float, float, float] | None = None,
     infill_fraction: float = 1.0,
+    extra_wall_radii: list[list[float]] | None = None,
+    valve_ring_caps: list[float | None] | None = None,
+    ring_center: tuple[float, float] | None = None,
 ) -> tuple[list[dict], tuple[float, float]]:
     """Assemble per-layer segments into a relative move list for all patterns.
 
@@ -1277,9 +1350,45 @@ def plan_layer_moves(
             # and rings that never touch this layer's material are skipped
             # instead of swept as full travel circles.
             frame = scan_frame if scan_frame is not None else motion.bounds
-            center_x = (frame[0] + frame[2]) / 2.0
-            center_y = (frame[1] + frame[3]) / 2.0
+            if ring_center is not None:
+                # Shared-motion whole shapes: rings centred where every
+                # shape's centre was ALIGNED to (the reference align
+                # centre), so each shape is concentric with the ring set —
+                # a bbox-union centre can sit off it when shapes differ in
+                # size, making rings graze boundaries.
+                center_x, center_y = ring_center
+            else:
+                center_x = (frame[0] + frame[2]) / 2.0
+                center_y = (frame[1] + frame[3]) / 2.0
             radii, wall_radii = _circle_ring_radii(motion, center_x, center_y, fil_width)
+
+            # Shared-motion parallel printing: every shape's own wall radius
+            # joins the ONE ring set (all heads travel all walls; each
+            # dispenses only on its own), so every shape keeps a smooth,
+            # complete outer circle instead of whatever grid ring happens to
+            # graze its boundary.
+            extra_walls = (
+                extra_wall_radii[layer_number]
+                if extra_wall_radii is not None and layer_number < len(extra_wall_radii)
+                else []
+            )
+            if extra_walls:
+                merged = sorted(set(radii) | set(extra_walls), reverse=True)
+                radii = []
+                for radius in merged:
+                    if radius <= EPS:
+                        continue
+                    if radii and radii[-1] - radius < fil_width * 0.05:
+                        continue  # near-duplicate wall/ring
+                    radii.append(radius)
+                wall_radii = tuple(sorted(set(wall_radii) | set(extra_walls), reverse=True))
+
+            valve_cap = (
+                valve_ring_caps[layer_number]
+                if valve_ring_caps is not None and layer_number < len(valve_ring_caps)
+                else None
+            )
+
             points = _circle_rings_polyline(center_x, center_y, radii, fil_width)
             if layer_number % 2 == 1:
                 points.reverse()
@@ -1294,9 +1403,20 @@ def plan_layer_moves(
                 radius_1 = math.hypot(x1 - center_x, y1 - center_y)
                 if abs(radius_1 - radius_0) > fil_width * 0.25:
                     return False  # radial jump between rings: travel only
+                radius_mid = (radius_0 + radius_1) / 2.0
+                if (
+                    valve_cap is not None
+                    and valve_cap + fil_width * 0.25
+                    < radius_mid
+                    <= valve_cap + fil_width
+                ):
+                    # The thin band just outside this shape's own wall:
+                    # rings there graze its boundary and would print spotty
+                    # specks/half arcs. Rings further out are genuine
+                    # crossings (e.g. a square's corners) and stay.
+                    return False
                 if infill_keep is None:
                     return True
-                radius_mid = (radius_0 + radius_1) / 2.0
                 if any(abs(radius_mid - wall) <= fil_width * 0.25 for wall in wall_radii):
                     return True  # perimeter walls always print, like contours
                 ring = round(radius_mid / fil_width - 0.5)
@@ -1304,16 +1424,24 @@ def plan_layer_moves(
 
             segments = _classify_polyline(points, valve, keep_segment=keep_segment)
         elif raster_pattern == RASTER_PATTERN_RECTANGULAR_SPIRAL:
+            # Anchor the loop family to the FRAME (constant across layers,
+            # shapes, and split pieces), not each layer's own material
+            # bounds: layers with smaller footprints would otherwise spiral
+            # at their own offsets and the walls would not stack. Outer
+            # loops that enclose this layer's material with more than half a
+            # bead to spare are skipped instead of traveled.
+            frame = scan_frame if scan_frame is not None else motion.bounds
+            spiral_bounds = _frame_spiral_bounds(frame, motion.bounds, fil_width)
             points = _rectangular_spiral_polyline(
-                motion.bounds,
+                spiral_bounds,
                 fil_width,
                 reverse=layer_number % 2 == 1,
             )
             keep_point = None
             if infill_keep is not None:
-                # A spiral "line" is one ring: ring k sits k*fil inside the
-                # half-fil-inset bounding box the spiral walks.
-                min_x, min_y, max_x, max_y = motion.bounds
+                # A spiral "line" is one ring; index rings from the FRAME's
+                # base loop so the selection lines up across layers.
+                min_x, min_y, max_x, max_y = frame
                 half = fil_width / 2.0
                 left, right = min_x + half, max_x - half
                 bottom, top = min_y + half, max_y - half
@@ -1528,10 +1656,12 @@ def _centering_delta(stack: LayerStack, reference: LayerStack) -> tuple[float, f
     else:
         reference_x, reference_y = _stack_center(reference)
     center_x, center_y = _alignment_center(stack)
-    return (
-        _snap_to_grid(reference_x - center_x, grid),
-        _snap_to_grid(reference_y - center_y, grid),
-    )
+    # No grid snap here: whole shapes centre EXACTLY on the align centre
+    # (circle-spiral rings are centred there, and a snapped residue of up
+    # to half a fil would make rings graze the shape's boundary). The snap
+    # only ever mattered for split pieces, which take the scan-frame corner
+    # rule above.
+    return (reference_x - center_x, reference_y - center_y)
 
 
 def align_stack_to(