Spirals start at the bottom; lead-in always finishes next to the print start

- Both spirals now start printing at the BOTTOM of the shape and work
upward, like the other raster patterns: the rectangular spiral runs the
bottom edge first (mirrored walk), and each circle-spiral revolution
starts/ends at the circle's lowest point (ring jumps happen there too).
A below-the-shape lead-in therefore lands directly under the spiral's
start, matching the other print paths.
- The purge patch always finishes at the corner nearest the toolpath
start, whatever the line count's parity: across-the-approach strokes
print the farthest line first and step back TOWARD the shape, and the
zigzag starts from whichever end makes the last stroke land on the
start corner. The return is one short straight travel through the
clearance lane - the primed nozzle no longer takes a long detour (or
finishes far from the print) on odd line counts or below+horizontal
patches.
- New tests: spirals' first print and toolpath origin sit at the shape's
lowest line; a geometric check that no lead-in travel crosses an
already-printed stroke for 1-4 lines.

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

README.md

@@ -125,10 +125,10 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - Pressure increases by `0.1` psi per layer by default.
 - Pressures are bounded to the regulator's range: table values clamp to 0–100 psi and snap to the tenths place (the serial protocol encodes `pressure × 10`), the per-layer ramp never climbs past 100 psi in the files, and the generation status warns when a ramp would hit the ceiling before the last layer.
 - 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 sets the patch geometry. Prints a purge patch before layer 1: **Lead In Position** (Left/Right/Up/Down) picks which side of the shape it sits on, **Lead In Clearance** how far away, and **Lead In Line Direction** which way the purge strokes run — Auto points them at the shape (the historical behavior), or force Horizontal/Vertical (e.g. a patch below the shape with horizontal strokes). When strokes run across the approach, lines step further away from the shape. 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.
+- **Lead In**: enabled per shape via the **Lead In** column in Shape Settings; the Lead In Options accordion sets the patch geometry. Prints a purge patch before layer 1: **Lead In Position** (Left/Right/Up/Down) picks which side of the shape it sits on, **Lead In Clearance** how far away, and **Lead In Line Direction** which way the purge strokes run — Auto points them at the shape (the historical behavior), or force Horizontal/Vertical (e.g. a patch below the shape with horizontal strokes). The purge always finishes at the patch corner nearest the toolpath start, whatever the line count's parity: strokes running across the approach print the farthest line first and step back toward the shape, and the zigzag starts from whichever end makes the last stroke land on the start corner — so the freshly primed nozzle travels only the short clearance lane to the print, never 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.
 - **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.
+- **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. Both spirals start printing at the BOTTOM of the shape and work upward, like the other patterns — so a below-the-shape lead-in connects directly to the start of the print. `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. **Generate G-Code runs it automatically** whenever the table contains split pieces, so the parallel view comes up already reassembled; the button remains for re-aligning after manual spacing edits. The layout keeps the split's grid arrangement: the reassembled pieces form one rigid block, and non-split shapes flow into the remaining grid slots, always kept clear of everything already placed (with the default column/row spacing as the margins) — nothing can overlap.
 - **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.
 

tests/test_vector_gcode.py

@@ -242,26 +242,33 @@ def test_lead_in_line_direction_can_run_across_the_approach(tmp_path) -> None:
     )
     moves = _moves_with_colors(gcode_path.read_text())
 
-    # The purge patch sits BELOW the shape with HORIZONTAL strokes: the
-    # first travel drops straight to y = -clearance, and every purge stroke
-    # runs in X only, stepping half a fil further down between strokes.
-    assert moves[0]["end"] == (0.0, -4.0, 0.0)
+    # The purge patch sits BELOW the shape with HORIZONTAL strokes. The
+    # FARTHEST row prints first and every next stroke steps back TOWARD the
+    # shape, so the purge finishes on the nearest row: the first travel
+    # drops to the farthest row y = -(clearance + spacing*(lines-1)).
+    assert moves[0]["end"] == (0.0, -5.0, 0.0)
     home_index = next(i for i, m in enumerate(moves[1:], start=1) if m["end"] == (0.0, 0.0, 0.0))
     lead_prints = [m for m in moves[:home_index] if m["color"] == 255]
     assert len(lead_prints) == 3
     assert all(abs(m["end"][1] - m["start"][1]) < 1e-9 for m in lead_prints)  # horizontal
     assert all(abs(abs(m["end"][0] - m["start"][0]) - 3.0) < 1e-9 for m in lead_prints)
-    stroke_rows = sorted(m["start"][1] for m in lead_prints)
-    assert stroke_rows == [-5.0, -4.5, -4.0]  # stepping AWAY from the shape
-
-    # The return route comes home without re-crossing a wet stroke row:
-    # travels between strokes' rows happen only beyond the patch or on the
-    # clean lane outside the stroke span (x < 0).
-    for travel in [m for m in moves[1:home_index] if m["color"] == 0]:
-        y0, y1 = travel["start"][1], travel["end"][1]
-        x0, x1 = travel["start"][0], travel["end"][0]
-        if abs(y1 - y0) < 1e-9 and abs(x1 - x0) > 1e-9 and y0 in stroke_rows:
-            # Horizontal travel on a wet row must be a stroke, not a travel.
+    # Farthest first, stepping toward the shape.
+    assert [round(m["start"][1], 6) for m in lead_prints] == [-5.0, -4.5, -4.0]
+    # The odd line count starts the zigzag from the far end, so the LAST
+    # stroke lands on the corner nearest the toolpath start — the return is
+    # one short straight travel home through the clearance lane.
+    assert lead_prints[-1]["end"] == (0.0, -4.0, 0.0)
+    assert moves[home_index]["start"] == (0.0, -4.0, 0.0)
+
+    # No travel drags along a row that has ALREADY been printed.
+    wet_rows: list[float] = []
+    for move in moves[1:home_index]:
+        if move["color"] == 255:
+            wet_rows.append(round(move["start"][1], 6))
+            continue
+        y0, y1 = move["start"][1], move["end"][1]
+        x0, x1 = move["start"][0], move["end"][0]
+        if abs(y1 - y0) < 1e-9 and abs(x1 - x0) > 1e-9 and round(y0, 6) in wet_rows:
             raise AssertionError(f"travel drags along wet row y={y0}")
 
 
@@ -372,24 +379,22 @@ def test_gcode_lead_in_runs_once_before_first_layer(tmp_path) -> None:
 
     moves = _moves_with_colors(gcode_path.read_text())
 
-    assert moves[:9] == [
+    assert moves[:7] == [
         {"start": (0.0, 0.0, 0.0), "end": (-7.0, 0.0, 0.0), "color": 0},
         {"start": (-7.0, 0.0, 0.0), "end": (-4.0, 0.0, 0.0), "color": 255},
         {"start": (-4.0, 0.0, 0.0), "end": (-4.0, 0.5, 0.0), "color": 0},
         {"start": (-4.0, 0.5, 0.0), "end": (-7.0, 0.5, 0.0), "color": 255},
         {"start": (-7.0, 0.5, 0.0), "end": (-7.0, 1.0, 0.0), "color": 0},
         {"start": (-7.0, 1.0, 0.0), "end": (-4.0, 1.0, 0.0), "color": 255},
-        # Return route: exit the patch one spacing to the outside, travel
-        # home through the clearance lane, then step onto the start point —
-        # never dragging the primed nozzle back across the purge lines.
-        {"start": (-4.0, 1.0, 0.0), "end": (-4.0, -0.5, 0.0), "color": 0},
-        {"start": (-4.0, -0.5, 0.0), "end": (0.0, -0.5, 0.0), "color": 0},
-        {"start": (0.0, -0.5, 0.0), "end": (0.0, 0.0, 0.0), "color": 0},
+        # The last stroke ends on the clearance line; the return is one
+        # straight travel home through the clearance lane (all strokes sit
+        # beyond it, so nothing wet is crossed).
+        {"start": (-4.0, 1.0, 0.0), "end": (0.0, 0.0, 0.0), "color": 0},
     ]
-    assert all(move["end"][2] == 0.0 for move in moves[:9])
+    assert all(move["end"][2] == 0.0 for move in moves[:7])
 
     first_z_index = next(index for index, move in enumerate(moves) if move["end"][2] > 0.0)
-    assert first_z_index > 9
+    assert first_z_index > 7
     assert not any(
         move["start"][0] < -3.0 or move["end"][0] < -3.0
         for move in moves[first_z_index:]
@@ -416,18 +421,20 @@ def test_gcode_lead_in_direction_points_the_purge_patch(tmp_path) -> None:
     )
 
     moves = _moves_with_colors(gcode_path.read_text())
-    # Patch is ABOVE the start: first travel goes +7 in Y, purge strokes are
-    # vertical and sit in y in [4, 7]; only the half-fil-wide return lane
-    # dips to the negative lateral side.
-    assert moves[0]["end"] == (0.0, 7.0, 0.0)
+    # Patch is ABOVE the start with vertical strokes in y in [4, 7]. The
+    # EVEN line count starts from the near end (first travel = clearance
+    # only) so the second stroke prints back down and lands on the
+    # clearance line — the purge always finishes nearest the start.
+    assert moves[0]["end"] == (0.0, 4.0, 0.0)
     lead_prints = [m for m in moves[:6] if m["color"] == 255]
-    assert lead_prints
+    assert len(lead_prints) == 2
     assert all(abs(m["end"][0] - m["start"][0]) < 1e-9 for m in lead_prints)
     assert all(
         3.9 <= min(m["start"][1], m["end"][1]) and max(m["start"][1], m["end"][1]) <= 7.1
         for m in lead_prints
     )
-    assert all(m["end"][0] >= -0.5 - 1e-9 for m in moves[:9])
+    assert abs(lead_prints[-1]["end"][1] - 4.0) < 1e-9  # ends on the clearance line
+    assert all(abs(m["end"][0]) <= 0.5 + 1e-9 for m in moves[:6])
 
 
 def test_lead_in_opt_out_travels_shared_patch_but_skips_it_solo(tmp_path) -> None:
@@ -486,21 +493,38 @@ def test_gcode_lead_in_return_never_crosses_the_purge_lines(tmp_path) -> None:
             lead_in_lines=lines,
             output_dir=tmp_path / str(lines),
         )
+        from shapely.geometry import LineString
+
         moves = _moves_with_colors(gcode_path.read_text())
         lead_end = next(i for i, m in enumerate(moves) if m["end"] == (0.0, 0.0, 0.0))
+        # Whatever the line count's parity, the purge finishes on the
+        # clearance line and no travel crosses an ALREADY-printed stroke
+        # anywhere but at a shared endpoint.
         prints = [m for m in moves[: lead_end + 1] if m["color"] == 255]
-        travels = [m for m in moves[: lead_end + 1] if m["color"] == 0]
-        # No travel move's interior crosses a printed purge line: every
-        # printed line sits on a lane y = k*0.5, and travels only run along
-        # x = const (lane changes at line ends) or at y = -0.5 / y <= 0.
-        for travel in travels[1:]:
-            y0, y1 = travel["start"][1], travel["end"][1]
-            x0, x1 = travel["start"][0], travel["end"][0]
-            if abs(y1 - y0) < 1e-9 and abs(x1 - x0) > 1e-9:
-                # Horizontal travel: must be outside the printed lanes.
-                assert y0 < -1e-9 or not any(
-                    abs(p["start"][1] - y0) < 1e-9 for p in prints
-                ), (lines, travel)
+        patch_far = min(min(p["start"][0], p["end"][0]) for p in prints)
+        assert abs(patch_far + 7.0) < 1e-9
+        assert prints[-1]["end"][0] == -4.0  # last stroke ends on the clearance line
+
+        wet: list[LineString] = []
+        for move in moves[: lead_end + 1]:
+            if move["color"] == 255:
+                wet.append(LineString([move["start"][:2], move["end"][:2]]))
+                continue
+            travel_line = LineString([move["start"][:2], move["end"][:2]])
+            for stroke in wet:
+                crossing = travel_line.intersection(stroke)
+                if crossing.is_empty:
+                    continue
+                assert crossing.geom_type == "Point", (lines, move)
+                point = (crossing.x, crossing.y)
+                endpoints = [
+                    move["start"][:2], move["end"][:2],
+                    tuple(stroke.coords[0]), tuple(stroke.coords[-1]),
+                ]
+                assert any(
+                    abs(point[0] - ex) < 1e-6 and abs(point[1] - ey) < 1e-6
+                    for ex, ey in endpoints
+                ), (lines, move)
 
 
 def test_gcode_pressure_ramp_can_be_disabled(tmp_path) -> None:
@@ -784,6 +808,43 @@ def test_raster_crosses_interior_holes_with_valve_off(tmp_path) -> None:
     )
 
 
+def test_spirals_start_printing_at_the_bottom(tmp_path) -> None:
+    layer = box(0.0, 0.0, 6.0, 6.0)
+    stack = _stack(layer, layer, name="spiral_bottom")
+    for pattern in (RASTER_PATTERN_RECTANGULAR_SPIRAL, RASTER_PATTERN_CIRCLE_SPIRAL):
+        tag = pattern.replace(" ", "_")
+        path = generate_vector_gcode(
+            stack,
+            shape_name=f"start_{tag}",
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            raster_pattern=pattern,
+            output_dir=tmp_path / tag,
+        )
+        moves = _moves_with_colors(path.read_text())
+        layer0 = [
+            m
+            for m in moves
+            if m["color"] == 255
+            and abs(m["end"][2] - m["start"][2]) < 1e-9
+            and m["start"][2] == 0.0
+        ]
+        assert layer0, pattern
+        min_y = min(min(m["start"][1], m["end"][1]) for m in layer0)
+        first = layer0[0]
+        # Like the other patterns, the spiral starts printing at the BOTTOM
+        # of the shape (within one fil of its lowest printed line) and works
+        # upward — so a below-the-shape lead-in connects directly to the
+        # start of the print.
+        assert min(first["start"][1], first["end"][1]) <= min_y + 1.0 + 1e-6, pattern
+        # The toolpath origin itself (where the lead-in would attach) also
+        # sits at the bottom.
+        origin_y = moves[0]["start"][1]
+        assert origin_y <= min_y + 1.0 + 1e-6, pattern
+
+
 def test_rectangular_spiral_polyline_reverses_center_to_edge() -> None:
     inward = _rectangular_spiral_polyline((0.0, 0.0, 3.0, 3.0), 1.0)
     outward = _rectangular_spiral_polyline((0.0, 0.0, 3.0, 3.0), 1.0, reverse=True)

vector_toolpath.py

@@ -682,7 +682,12 @@ def _rectangular_spiral_polyline(
     fil_width: float,
     reverse: bool = False,
 ) -> list[tuple[float, float]]:
-    """Corner polyline spiralling from the bounds inward (or outward if reversed)."""
+    """Corner polyline spiralling from the bounds inward (or outward if reversed).
+
+    Starts at the BOTTOM-left corner and runs the bottom edge first, climbing
+    upward — matching the other raster patterns (and putting the toolpath
+    start where a below-the-shape lead-in ends).
+    """
     min_x, min_y, max_x, max_y = bounds
     half = fil_width / 2.0
     left = min_x + half
@@ -702,21 +707,21 @@ def _rectangular_spiral_polyline(
             points.append((x, y))
 
     while left <= right + eps and bottom <= top + eps:
-        add(left, top)
-        add(right, top)
-        top -= fil_width
+        add(left, bottom)
+        add(right, bottom)
+        bottom += fil_width
 
         if bottom <= top + eps:
-            add(right, bottom)
+            add(right, top)
         right -= fil_width
 
         if bottom <= top + eps:
-            add(left, bottom)
-            bottom += fil_width
+            add(left, top)
+            top -= fil_width
 
         if left <= right + eps:
             if bottom <= top + eps:
-                add(left, top)
+                add(left, bottom)
             left += fil_width
 
     if len(points) == 1:
@@ -905,8 +910,11 @@ def _circle_rings_polyline(
     """Concentric-ring "spiral": one full circle per radius, in list order.
 
     Each revolution stays at a CONSTANT radius (so the printed walls are true
-    smooth circles); consecutive rings are joined by a radial jump at theta 0,
-    which the caller classifies as valve-off travel.
+    smooth circles) and starts/ends at the BOTTOM of the circle — the path
+    begins at the shape's lowest point and sweeps upward, matching the other
+    raster patterns (and putting the toolpath start where a below-the-shape
+    lead-in ends). Consecutive rings are joined by a radial jump at the
+    bottom, which the caller classifies as valve-off travel.
     """
     pitch = max(float(pitch), 1e-9)
     points: list[tuple[float, float]] = []
@@ -917,7 +925,7 @@ def _circle_rings_polyline(
         d_theta = min(math.pi / 10.0, pitch / max(radius, pitch))
         steps = max(8, int(math.ceil((2.0 * math.pi) / d_theta)))
         for index in range(steps + 1):
-            theta = (2.0 * math.pi) * index / steps
+            theta = -math.pi / 2.0 + (2.0 * math.pi) * index / steps
             points.append(
                 (
                     center_x + (radius * math.cos(theta)),
@@ -1352,11 +1360,13 @@ def _lead_in_moves(
     `clearance` away). `orientation` sets which way the purge strokes RUN:
     Auto points them at the shape (horizontal for Left/Right patches,
     vertical for Up/Down), Horizontal/Vertical force an absolute direction.
-    When strokes run along the approach, lines step laterally; when they run
-    across it, lines step further AWAY from the shape — either way the
-    return route exits one step outside the wet patch and comes home through
-    virgin ground, so the freshly primed nozzle never drags back across the
-    purge lines.
+
+    The purge always FINISHES at the patch corner nearest the toolpath
+    start, whatever the line count's parity: strokes across the approach
+    print the farthest line first and step back toward the shape, and the
+    zigzag starts from whichever end makes the LAST stroke land on the
+    start corner. The freshly primed nozzle then travels only the short
+    clearance lane home — never back across the purge lines.
     """
     if not enabled:
         return []
@@ -1395,43 +1405,48 @@ def _lead_in_moves(
         current_v += delta_v
 
     if strokes_along_away:
-        append_move(lead_clearance + lead_length, 0.0, off_color)
-        stroke = -1.0  # first stroke prints back toward the part
+        # Strokes run along the approach, stepping laterally between lines.
+        # The LAST stroke must print TOWARD the part (ending at the
+        # clearance line): with an odd count that means starting from the
+        # far end, with an even count from the near end.
+        if pass_count % 2 == 1:
+            append_move(lead_clearance + lead_length, 0.0, off_color)
+            stroke = -1.0
+        else:
+            append_move(lead_clearance, 0.0, off_color)
+            stroke = 1.0
         for pass_index in range(pass_count):
             append_move(stroke * lead_length, 0.0, print_color)
             stroke *= -1.0
             if pass_index < pass_count - 1:
                 append_move(0.0, spacing, off_color)
 
-        # Return: step one spacing outside the patch laterally, travel home
-        # through the clearance lane, then step back onto the start point.
-        if spacing > 0.0:
-            append_move(0.0, -(current_v + spacing), off_color)
-            append_move(-current_a, 0.0, off_color)
-            append_move(0.0, -current_v, off_color)
-        else:
-            append_move(-current_a, -current_v, off_color)
+        # Ends at the clearance line, one lateral span from the start:
+        # travel home through the clearance lane (the strokes all sit
+        # beyond it, so nothing wet is crossed).
+        append_move(-current_a, -current_v, off_color)
     else:
-        # Strokes run ACROSS the approach: lines step further away from the
-        # shape, so the patch grows outward from `clearance`.
-        append_move(lead_clearance, 0.0, off_color)
-        stroke = 1.0
+        # Strokes run ACROSS the approach: the FARTHEST line prints first
+        # and each next line steps back TOWARD the shape, so the purge
+        # finishes on the nearest line. With an odd count the zigzag starts
+        # from the far lateral end so the last stroke also lands on the
+        # start corner.
+        append_move(lead_clearance + spacing * (pass_count - 1), 0.0, off_color)
+        if pass_count % 2 == 1:
+            append_move(0.0, lead_length, off_color)
+            stroke = -1.0
+        else:
+            stroke = 1.0
         for pass_index in range(pass_count):
             append_move(0.0, stroke * lead_length, print_color)
             stroke *= -1.0
             if pass_index < pass_count - 1:
-                append_move(spacing, 0.0, off_color)
-
-        # Return: step one spacing PAST the outermost wet line, cross to the
-        # clean lane one spacing outside the stroke span, come home along
-        # it, then step onto the start point.
-        if spacing > 0.0:
-            append_move(spacing, 0.0, off_color)
-            append_move(0.0, -(current_v + spacing), off_color)
-            append_move(-current_a, 0.0, off_color)
-            append_move(0.0, -current_v, off_color)
-        else:
-            append_move(-current_a, -current_v, off_color)
+                append_move(-spacing, 0.0, off_color)
+
+        # Ends at the near line's start-corner end: straight home along the
+        # clearance lane (later lines were printed closer, so the route
+        # never crosses a wet stroke).
+        append_move(-current_a, -current_v, off_color)
     return moves