Sweep buffer input, lead-in line direction, readable pressure commands

Generate G-Code options:
- Sweep Buffer (mm) input next to the raster pattern: the valve-settle
travel before/after each raster line (was hardcoded to one fil_width;
0 disables it). Applies to the axis rasters and both woodpiles; the
same value drives every shape so the shared motion stays in sync
- Lead In Line Direction dropdown (Auto/Horizontal/Vertical) decouples
the purge strokes' direction from the patch position: e.g. a patch
BELOW the shape can now print HORIZONTAL strokes. Auto keeps the
historical toward-the-shape behavior byte-for-byte. Across-oriented
lines step further away from the shape, and the return route still
exits past the wet patch and comes home on virgin ground.
"Lead In Direction" renamed to "Lead In Position"; clearance/length
inputs gained hint text (clearance IS the distance from the shape)
- Both new options join the stale-G-code fingerprint

G-code output:
- Every pressure command now uses the readable eval(setpress(...)) /
eval(togglepress()) dialect - previously the per-layer ramp and the
closing toggle were precomputed raw byte strings. The host execs both
forms identically (setpress builds the same serial bytes), so wire
traffic is unchanged; the hex/checksum builders became dead code and
were removed

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

README.md

@@ -57,6 +57,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - **Infill %** per shape skips dispensing on evenly-distributed raster lines (rings for the circle spiral) — at 50% every other line prints. Parallel shapes with different infill still share one print path, and lines that **no** shape dispenses on are dropped from the motion entirely instead of being swept valve-off (every shape at 50% roughly halves the print path; with mixed infills a line survives if any shape prints it). The rectangular spiral keeps its full continuous walk; circle-spiral perimeter walls always stay
 - Appends a shape outline contour after each enabled shape layer by tracing that layer's polygon boundary
 - 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)
+- **Sweep Buffer (mm)** sets the valve-settle travel before and after each raster line (default 0.8, 0 disables it); it applies to the axis rasters and both woodpiles, and the same value drives every shape so the shared motion stays in sync
 - Slicing is automatic: **Generate G-Code** slices every shape (fresh or stale) before writing G-code, and **Split Selected Shape into Grid Pieces** slices before splitting — "upload, then Generate G-Code" works in one click with no separate slice step
 - The generation status leads with the shared print path length and a time estimate at the Visualization tab's nozzle speed, and generation auto-renders the parallel view so switching to the Visualization tab always shows the current print
 - A **stale-G-code banner** appears above the Generate button whenever the table or any generation option changes after files were generated (each file carries a settings fingerprint), so outdated G-code is never downloaded or printed unnoticed
@@ -115,7 +116,7 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - Pressure commands are written **once per port**: when shapes share a serial port, only the first shape's file carries the preset, toggle, and per-layer ramp — the print host compiles every file onto one timeline, and duplicated toggles would flip the regulator on/off/on at start. Valve commands stay per shape in every file.
 - Pressure increases by `0.1` psi per layer by default.
 - 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.
+- **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.
 - **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.

app.py

@@ -41,6 +41,8 @@ from vector_gcode import generate_vector_gcode
 from vector_toolpath import (
     LEAD_IN_DIRECTION_CHOICES,
     LEAD_IN_DIRECTION_LEFT,
+    LEAD_IN_LINE_AUTO,
+    LEAD_IN_LINE_CHOICES,
     RASTER_PATTERN_CHOICES,
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_Y_DIRECTION,
@@ -3983,6 +3985,8 @@ def _gcode_settings_snapshot(
     layer_height: float,
     fil_width: float,
     scale_mode: str | None,
+    sweep_buffer: float = 0.8,
+    lead_in_orientation: str | None = None,
 ) -> dict:
     """Fingerprint of every setting that shapes this record's G-code.
 
@@ -4008,10 +4012,12 @@ def _gcode_settings_snapshot(
             round(_coerce_float(lead_in_clearance, 5.0), 6),
             _coerce_int(lead_in_lines, 3),
             str(lead_in_direction or ""),
+            str(lead_in_orientation or LEAD_IN_LINE_AUTO),
         ),
         "layer_height": round(_coerce_float(layer_height, 0.8), 6),
         "fil_width": round(_coerce_float(fil_width, 0.8), 6),
         "scale_mode": _normalize_scale_mode(scale_mode),
+        "sweep_buffer": round(_coerce_float(sweep_buffer, 0.8), 6),
     }
 
 
@@ -4033,6 +4039,8 @@ def check_gcode_staleness(
     layer_height: float,
     fil_width: float,
     scale_mode: str | None,
+    sweep_buffer: float = 0.8,
+    lead_in_orientation: str | None = None,
 ) -> str:
     """Warning banner text when generated G-code no longer matches the settings."""
     records = _apply_shape_settings(records or [], settings_table)
@@ -4048,6 +4056,8 @@ def check_gcode_staleness(
         layer_height,
         fil_width,
         scale_mode,
+        sweep_buffer,
+        lead_in_orientation,
     )
     for record in records:
         if not record.get("gcode_path"):
@@ -4093,6 +4103,8 @@ def generate_dynamic_gcode(
     fil_width: float,
     scale_mode: str | None,
     nozzle_speed: Any = None,
+    sweep_buffer: float = 0.8,
+    lead_in_orientation: str | None = None,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     messages: list[str] = []
@@ -4174,11 +4186,14 @@ def generate_dynamic_gcode(
                 infill=_coerce_float(record.get("infill", 100.0), 100.0) / 100.0,
                 motion_infill_fractions=motion_infill_fractions,
                 emit_pressure_commands=owns_port_pressure,
+                # Same buffer for every shape: the shared motion must match.
+                sweep_buffer=max(0.0, _coerce_float(sweep_buffer, 0.8)),
                 lead_in_enabled=bool(lead_in_enabled),
                 lead_in_length=float(lead_in_length),
                 lead_in_clearance=effective_lead_in_clearance,
                 lead_in_lines=max(1, _coerce_int(lead_in_lines, 3)),
                 lead_in_direction=lead_in_direction or LEAD_IN_DIRECTION_LEFT,
+                lead_in_orientation=lead_in_orientation,
                 lead_in_dispense=bool(record.get("lead_in", True)),
                 wall_sources=wall_sources,
                 origin_sink=(origin_sink := {}),
@@ -4201,6 +4216,8 @@ def generate_dynamic_gcode(
                 layer_height,
                 fil_width,
                 scale_mode,
+                sweep_buffer,
+                lead_in_orientation,
             )
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
         except Exception as exc:
@@ -4663,23 +4680,49 @@ def build_dynamic_demo() -> gr.Blocks:
                 """
             )
             gcode_pressure_ramp_enabled = gr.Checkbox(label="Increase Pressure Each Layer", value=True)
-            gcode_raster_pattern = gr.Dropdown(
-                label="Raster Pattern",
-                choices=list(RASTER_PATTERN_CHOICES),
-                value=RASTER_PATTERN_SAME_DIRECTION,
-                allow_custom_value=False,
-            )
+            with gr.Row():
+                gcode_raster_pattern = gr.Dropdown(
+                    label="Raster Pattern",
+                    choices=list(RASTER_PATTERN_CHOICES),
+                    value=RASTER_PATTERN_SAME_DIRECTION,
+                    allow_custom_value=False,
+                    scale=3,
+                )
+                gcode_sweep_buffer = gr.Number(
+                    label="Sweep Buffer (mm)",
+                    value=0.8,
+                    minimum=0.0,
+                    step=0.1,
+                    scale=1,
+                    min_width=170,
+                    info="Valve-settle travel before/after each raster line (0 = none).",
+                )
             with gr.Accordion("Lead In Options", open=False, elem_classes=["settings-accordion"]):
                 gr.Markdown("Applies to shapes with **Lead In** checked in the Shape Settings table.")
                 with gr.Row():
-                    gcode_lead_in_length = gr.Number(label="Lead In Length (mm)", value=5.0, minimum=0.1, step=0.1)
-                    gcode_lead_in_clearance = gr.Number(label="Lead In Clearance (mm)", value=5.0, minimum=0.0, step=0.1)
+                    gcode_lead_in_length = gr.Number(label="Lead In Length (mm)", value=5.0, minimum=0.1, step=0.1, info="Length of each purge stroke.")
+                    gcode_lead_in_clearance = gr.Number(
+                        label="Lead In Clearance (mm)",
+                        value=5.0,
+                        minimum=0.0,
+                        step=0.1,
+                        info="Distance between the shape and the purge patch.",
+                    )
                     gcode_lead_in_lines = gr.Number(label="Lead In Raster Lines", value=3, minimum=1, step=1)
+                with gr.Row():
                     gcode_lead_in_direction = gr.Dropdown(
-                        label="Lead In Direction",
+                        label="Lead In Position",
                         choices=list(LEAD_IN_DIRECTION_CHOICES),
                         value=LEAD_IN_DIRECTION_LEFT,
                         allow_custom_value=False,
+                        info="Which side of the shape the purge patch sits on.",
+                    )
+                    gcode_lead_in_orientation = gr.Dropdown(
+                        label="Lead In Line Direction",
+                        choices=list(LEAD_IN_LINE_CHOICES),
+                        value=LEAD_IN_LINE_AUTO,
+                        allow_custom_value=False,
+                        info="Which way the purge strokes run within the patch.",
                     )
             gcode_stale_banner = gr.Markdown("", elem_id="gcode-stale-banner")
             gcode_button = gr.Button("Generate G-Code", variant="primary")
@@ -5034,6 +5077,8 @@ def build_dynamic_demo() -> gr.Blocks:
             layer_height,
             fil_width,
             scale_mode,
+            gcode_sweep_buffer,
+            gcode_lead_in_orientation,
         ]
         shape_settings.change(
             fn=check_gcode_staleness,
@@ -5051,6 +5096,8 @@ def build_dynamic_demo() -> gr.Blocks:
             layer_height,
             fil_width,
             scale_mode,
+            gcode_sweep_buffer,
+            gcode_lead_in_orientation,
         ):
             stale_control.change(
                 fn=check_gcode_staleness,
@@ -5093,6 +5140,8 @@ def build_dynamic_demo() -> gr.Blocks:
                 fil_width,
                 scale_mode,
                 viz_nozzle_speed,
+                gcode_sweep_buffer,
+                gcode_lead_in_orientation,
             ],
             outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source, gcode_download_all],
         ).then(

tests/test_vector_gcode.py

@@ -222,6 +222,81 @@ def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> No
     assert not any("WAGO_ValveCommands(100" in line for line in lines)
 
 
+def test_lead_in_line_direction_can_run_across_the_approach(tmp_path) -> None:
+    from vector_toolpath import LEAD_IN_DIRECTION_DOWN, LEAD_IN_LINE_HORIZONTAL
+
+    gcode_path = generate_vector_gcode(
+        _stack(box(0.0, 0.0, 0.5, 0.5)),
+        shape_name="lead_below_horizontal",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=0.5,
+        lead_in_enabled=True,
+        lead_in_length=3.0,
+        lead_in_clearance=4.0,
+        lead_in_lines=3,
+        lead_in_direction=LEAD_IN_DIRECTION_DOWN,
+        lead_in_orientation=LEAD_IN_LINE_HORIZONTAL,
+        output_dir=tmp_path,
+    )
+    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)
+    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.
+            raise AssertionError(f"travel drags along wet row y={y0}")
+
+
+def test_sweep_buffer_is_adjustable_and_can_be_disabled(tmp_path) -> None:
+    layer = box(0.0, 0.0, 4.0, 1.0)
+    stack = _stack(layer)
+
+    def _generate(label: str, **kwargs):
+        path = generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            output_dir=tmp_path / label,
+            **kwargs,
+        )
+        return _moves_with_colors(path.read_text())
+
+    # Default: the valve-settle approach travel is one fil_width long.
+    default = _generate("default")
+    assert default[0]["color"] == 0
+    assert abs(math.dist(default[0]["start"], default[0]["end"]) - 1.0) < 1e-9
+
+    # Custom buffer: the approach stretches to the requested length.
+    long_buffer = _generate("long", sweep_buffer=2.5)
+    assert abs(math.dist(long_buffer[0]["start"], long_buffer[0]["end"]) - 2.5) < 1e-9
+
+    # Zero buffer: no approach travel — the sweep starts on the material.
+    none = _generate("none", sweep_buffer=0.0)
+    assert none[0]["color"] == 255
+    assert none[0]["start"] == (0.0, 0.0, 0.0)
+
+
 def test_port_sharing_files_emit_pressure_commands_once(tmp_path) -> None:
     # The pressure regulator is a PORT device: a file generated WITHOUT
     # pressure ownership carries no serial commands at all (no preset, no

vector_gcode.py

@@ -9,9 +9,7 @@ pressure ramp.
 from __future__ import annotations
 
 import tempfile
-from codecs import encode
 from pathlib import Path
-from textwrap import wrap
 
 from stl_slicer import LayerStack
 from vector_toolpath import (
@@ -50,44 +48,25 @@ __all__ = [
 ]
 
 
-def _setpress(pressure: float) -> str:
-    pressure_str = str(int(pressure * 10)).zfill(4)
-    command_bytes = bytes("08PS  " + pressure_str, "utf-8")
-    hex_command = encode(command_bytes, "hex").decode("utf-8")
-    format_command = "\\x" + "\\x".join(
-        hex_command[i : i + 2] for i in range(0, len(hex_command), 2)
-    )
-
-    hex_pairs = wrap(hex_command, 2)
-    decimal_sum = sum(int(pair, 16) for pair in hex_pairs)
-    checksum_bin = bin(decimal_sum % 256)[2:].zfill(8)
-    inverted = int("".join("1" if c == "0" else "0" for c in checksum_bin), 2) + 1
-    checksum_hex = hex(inverted)[2:].upper()
-    format_checksum = "\\x" + "\\x".join(
-        checksum_hex[i : i + 2] for i in range(0, len(checksum_hex), 2)
-    )
-
-    return "b'" + "\\x05\\x02" + format_command + format_checksum + "\\x03" + "'"
-
-
-def _togglepress() -> str:
-    return "b'\\x05\\x02\\x30\\x34\\x44\\x49\\x20\\x20\\x43\\x46\\x03'"
-
-
 def _setpress_cmd(port: str, pressure: float, start: bool) -> str:
-    # {preset} marks pressure setup for the Aerotech host runtime: presets
-    # execute at the controller's START signal, before the initial toggles.
+    """Pressure preset in the readable host dialect.
+
+    Every pressure command uses the same `eval(setpress(...))` form (the
+    print host defines `setpress`, which builds the serial byte string), so
+    the values are human-readable throughout the file. `start` adds the
+    {preset} marker: the host executes presets at the controller's START
+    signal, before the initial toggles; ramp commands mid-file run at their
+    scheduled times instead.
+    """
     if start:
         return f"\n\r{{preset}}{port}.write(eval(setpress({pressure:g})))"
-    insert = ""
-    return f"\n\r{insert}{port}.write({_setpress(pressure)})"
+    return f"\n\r{port}.write(eval(setpress({pressure:g})))"
 
 
 def _toggle_cmd(port: str, start: bool) -> str:
     if start:
         return f"\n\r{{preset}}{port}.write(eval(togglepress()))"
-    insert = ""
-    return f"\n\r{insert}{port}.write({_togglepress()})"
+    return f"\n\r{port}.write(eval(togglepress()))"
 
 
 def _valve_cmd(valve: int, command: int) -> str:
@@ -207,6 +186,7 @@ def generate_vector_gcode(
     infill: float = 1.0,
     motion_infill_fractions: list[float] | None = None,
     emit_pressure_commands: bool = True,
+    sweep_buffer: float | None = None,
     increase_pressure_per_layer: float = 0.1,
     pressure_ramp_enabled: bool = True,
     all_g1: bool = False,
@@ -215,6 +195,7 @@ def generate_vector_gcode(
     lead_in_clearance: float = 5.0,
     lead_in_lines: int = 3,
     lead_in_direction: str = LEAD_IN_DIRECTION_LEFT,
+    lead_in_orientation: str | None = None,
     lead_in_dispense: bool = True,
     wall_sources: list[LayerStack] | None = None,
     origin_sink: dict | None = None,
@@ -337,6 +318,9 @@ def generate_vector_gcode(
             if motion_infill_fractions is not None
             else None
         ),
+        # Valve-settle travel before/after each raster sweep; one fil_width
+        # when not given. Pass the SAME value for every shape sharing motion.
+        sweep_buffer=sweep_buffer,
     )
 
     # World anchor: the toolpath origin expressed in the shape's own frame.
@@ -365,6 +349,7 @@ def generate_vector_gcode(
         255 if lead_in_dispense else 0,
         0,
         direction=lead_in_direction,
+        orientation=lead_in_orientation,
     )
     if lead_in:
         gcode_list = [*lead_in, *gcode_list]

vector_toolpath.py

@@ -411,13 +411,15 @@ def _axis_raster_segments(
     scan_anchor: float | None = None,
     infill_keep=None,
     motion_keep=None,
+    sweep_buffer: float | None = None,
 ) -> list[Seg]:
     """Snake raster of `motion`, dispensing only inside `valve`.
 
     Axis "X" sweeps along X with rows stacked in Y; axis "Y" sweeps along Y
     with columns stacked in X. Each sweep spans from the first to the last
-    motion chord (crossing interior gaps valve-off) and gets a fil_width
-    valve-settle travel buffer before and after. `scan_anchor` pins the
+    motion chord (crossing interior gaps valve-off) and gets a valve-settle
+    travel buffer before and after (`sweep_buffer`, one fil_width when not
+    given; 0 disables it). `scan_anchor` pins the
     scanlines to a global grid (see `_scan_coords`). `infill_keep(k)` gates
     dispensing per grid line for partial infill: skipped lines are still
     swept with the valve closed. `motion_keep(k)` drops a grid line from the
@@ -427,6 +429,7 @@ def _axis_raster_segments(
     if motion is None or motion.is_empty:
         return []
 
+    buffer_length = fil_width if sweep_buffer is None else max(0.0, float(sweep_buffer))
     min_x, min_y, max_x, max_y = motion.bounds
     if axis == "Y":
         scan_lo, scan_hi = min_x, max_x
@@ -485,7 +488,7 @@ def _axis_raster_segments(
         sweep_number += 1
 
         if forward:
-            emit(sweep_lo - fil_width, sweep_lo, 0)
+            emit(sweep_lo - buffer_length, sweep_lo, 0)
             current = sweep_lo
             for lo, hi in valve_runs:
                 if lo - current > EPS:
@@ -498,9 +501,9 @@ def _axis_raster_segments(
             if sweep_hi - current > EPS:
                 emit(current, sweep_hi, 0)
                 current = sweep_hi
-            emit(current, current + fil_width, 0)
+            emit(current, current + buffer_length, 0)
         else:
-            emit(sweep_hi + fil_width, sweep_hi, 0)
+            emit(sweep_hi + buffer_length, sweep_hi, 0)
             current = sweep_hi
             for lo, hi in reversed(valve_runs):
                 if current - hi > EPS:
@@ -513,7 +516,7 @@ def _axis_raster_segments(
             if current - sweep_lo > EPS:
                 emit(current, sweep_lo, 0)
                 current = sweep_lo
-            emit(current, current - fil_width, 0)
+            emit(current, current - buffer_length, 0)
 
     return segments
 
@@ -529,6 +532,7 @@ def _oriented_axis_raster_segments(
     scan_anchor: float | None = None,
     infill_keep=None,
     motion_keep=None,
+    sweep_buffer: float | None = None,
 ) -> list[Seg]:
     """Pick the raster orientation whose start is nearest the current position."""
     default_segments = _axis_raster_segments(
@@ -539,6 +543,7 @@ def _oriented_axis_raster_segments(
         scan_anchor=scan_anchor,
         infill_keep=infill_keep,
         motion_keep=motion_keep,
+        sweep_buffer=sweep_buffer,
     )
     if prefer_default or not default_segments:
         return default_segments
@@ -556,6 +561,7 @@ def _oriented_axis_raster_segments(
                 scan_anchor=scan_anchor,
                 infill_keep=infill_keep,
                 motion_keep=motion_keep,
+                sweep_buffer=sweep_buffer,
             )
             if segments and segments not in candidates:
                 candidates.append(segments)
@@ -582,6 +588,7 @@ def _rotated_raster_segments(
     frame: tuple[float, float, float, float],
     infill_keep=None,
     motion_keep=None,
+    sweep_buffer: float | None = None,
 ) -> list[Seg]:
     """Snake raster at an arbitrary angle, reusing the axis raster machinery.
 
@@ -626,6 +633,7 @@ def _rotated_raster_segments(
         scan_anchor=anchor,
         infill_keep=infill_keep,
         motion_keep=motion_keep,
+        sweep_buffer=sweep_buffer,
     )
 
     theta_back = math.radians(angle_degrees)
@@ -1298,6 +1306,25 @@ def _normalize_lead_in_direction(direction: str | None) -> str:
     return LEAD_IN_DIRECTION_LEFT
 
 
+# Purge-stroke orientation: "Auto" keeps the strokes pointing at the shape
+# (the historical behavior — horizontal for Left/Right patches, vertical for
+# Up/Down); Horizontal/Vertical force an absolute stroke direction.
+LEAD_IN_LINE_AUTO = "Auto (toward the shape)"
+LEAD_IN_LINE_HORIZONTAL = "Horizontal"
+LEAD_IN_LINE_VERTICAL = "Vertical"
+LEAD_IN_LINE_CHOICES = (
+    LEAD_IN_LINE_AUTO,
+    LEAD_IN_LINE_HORIZONTAL,
+    LEAD_IN_LINE_VERTICAL,
+)
+
+
+def _normalize_lead_in_orientation(orientation: str | None) -> str:
+    if orientation in LEAD_IN_LINE_CHOICES:
+        return orientation
+    return LEAD_IN_LINE_AUTO
+
+
 def _lead_in_moves(
     enabled: bool,
     length: float,
@@ -1307,14 +1334,18 @@ def _lead_in_moves(
     print_color: int,
     off_color: int,
     direction: str | None = LEAD_IN_DIRECTION_LEFT,
+    orientation: str | None = None,
 ) -> list[dict]:
     """Purge patch printed before layer 1, in the chosen direction.
 
-    The patch sits `clearance` away from the toolpath start along the purge
-    direction and snakes `line_count` strokes of `length`, stepping one
-    `line_spacing` laterally between strokes. The return route exits the
-    patch one lateral step to the OUTSIDE and comes home through virgin
-    ground, so the freshly primed nozzle never drags back across the wet
+    `direction` places the patch (Left/Right/Up/Down of the toolpath start,
+    `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.
     """
     if not enabled:
@@ -1326,6 +1357,13 @@ def _lead_in_moves(
     pass_count = max(1, int(line_count))
     spacing = max(0.0, float(line_spacing))
     away, lateral = _LEAD_IN_AXES[_normalize_lead_in_direction(direction)]
+    orientation = _normalize_lead_in_orientation(orientation)
+    if orientation == LEAD_IN_LINE_HORIZONTAL:
+        strokes_along_away = abs(away[0]) > 0.0
+    elif orientation == LEAD_IN_LINE_VERTICAL:
+        strokes_along_away = abs(away[1]) > 0.0
+    else:
+        strokes_along_away = True
 
     moves: list[dict] = []
     # Patch-local frame: `a` runs along the away axis, `v` along the lateral.
@@ -1346,22 +1384,44 @@ def _lead_in_moves(
         current_a += delta_a
         current_v += delta_v
 
-    append_move(lead_clearance + lead_length, 0.0, off_color)
-    stroke = -1.0  # first stroke prints back toward the part
-    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)
+    if strokes_along_away:
+        append_move(lead_clearance + lead_length, 0.0, off_color)
+        stroke = -1.0  # first stroke prints back toward the part
+        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)
     else:
-        append_move(-current_a, -current_v, off_color)
+        # 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
+        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)
     return moves
 
 
@@ -1379,6 +1439,7 @@ def plan_layer_moves(
     extra_wall_radii: list[list[float]] | None = None,
     ring_center: tuple[float, float] | None = None,
     motion_infill_fractions: list[float] | None = None,
+    sweep_buffer: float | None = None,
 ) -> tuple[list[dict], tuple[float, float]]:
     """Assemble per-layer segments into a relative move list for all patterns.
 
@@ -1548,6 +1609,7 @@ def plan_layer_moves(
                 frame=frame,
                 infill_keep=infill_keep,
                 motion_keep=motion_keep,
+                sweep_buffer=sweep_buffer,
             )
         else:
             raster_axis = _raster_axis_for_pattern(raster_pattern, layer_number)
@@ -1565,6 +1627,7 @@ def plan_layer_moves(
                 scan_anchor=axis_anchor,
                 infill_keep=infill_keep,
                 motion_keep=motion_keep,
+                sweep_buffer=sweep_buffer,
             )
 
         if not segments: