Improve parallel printing: shared contours, exact auto-align, infill %

- Contour tracing under reference motion: every head traces every traced
shape's contour on one identical path, valve open only on its own outline
- Auto Align Split Parts computes exact per-connection gaps from PathOrigin
anchors written into each G-code file (works for all raster patterns,
reference motion, and overlapping-layer splits; sets grid dims from the
split); grid controls listen on user input only so the first click sticks
- Split pieces raster on the parent's scan grid (seams keep an exact one-fil
pitch); cells are equal whole-fil multiples with blank boundary padding,
and reference alignment snaps to the fil grid so nozzle spacing is uniform
- New per-shape Infill % column: evenly-distributed lines (rings for
spirals) skip dispensing while the motion path stays identical
- Remove the redundant Custom Spacing mode; Advanced Grid Spacing table is
always visible and its checkbox controls only whether it is used
- Fix G-code corruption on curved shapes: coordinates are written in fixed
point (never scientific notation) and the viewer parses exponents safely

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

README.md

@@ -47,11 +47,12 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Slices each shape into per-layer vector outlines held in memory (no intermediate image files)
 - Automatically unions the sliced shapes into a combined reference layer set whenever shapes are sliced
 - Splits one sliced shape's geometry into an editable row/column grid for multi-nozzle printing of one large shape
-- Converts sliced layers into G-code files with pressure, valve, nozzle, and port settings per shape from the Shape Settings table
+- Converts sliced layers into G-code files with pressure, valve, nozzle, port, and infill % settings per shape from the Shape Settings table
+- **Infill %** per shape skips dispensing on evenly-distributed raster lines (rings/revolutions for spiral patterns) — at 50% every other line prints — while the motion path stays exactly the same, so parallel shapes with different infill still share one print path
 - Appends a shape outline contour after each enabled shape layer by tracing that layer's polygon boundary
 - Offers G-code generation options for raster pattern, **Use G1 for all moves** (no rapid travel command), and **Use combined reference outline for motion** (all shapes share one nozzle path; each dispenses only its own geometry)
 - Re-slices shapes automatically during G-code generation when their slices are missing or stale, so "upload, then Generate G-Code" works in one click
-- Calculates X/Y nozzle spacing from an editable adjacent-pair spacing table, then visualizes the resulting nozzle layout
+- Calculates X/Y nozzle spacing from a grid layout (columns/rows plus gaps), with an optional per-connection Advanced Grid Spacing table, then visualizes the resulting nozzle layout
 - Previews selected generated G-code inline
 - Visualizes generated or uploaded G-code tool paths, with the source selectable from any active generated shape or an uploaded file
 - Renders the tool path as a fast line plot or an animated 3D tube plot (play/pause, speed, scrub, frame-step, nozzle marker)
@@ -91,9 +92,10 @@ The **Multi-Nozzle Split** accordion on the **Shapes & Slicing** tab can split o
 - Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port; the nozzle number controls layout/spacing assignment.
 - Pressure increases by `0.1` psi per layer by default.
 - **Use G1 for all moves**: when enabled, every movement line is emitted as `G1` (no `G0` rapid travel); the WAGO valve still marks where material is dispensed. Applies to all shapes.
-- **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.
+- **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. `Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps. `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` uses a shrinking circular spiral from the layer bounds toward the center, then reverses outward on the next layer. Spiral motion covers the layer bounds; the valve opens only where the path is inside material.
-- **Auto Align Split Parts**: in Nozzle Spacing, fills Grid Layout gaps for split-piece alignment. X-direction raster uses X `-3.2` mm and Y `-0.8` mm; Y-direction raster switches those values.
+- **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.
 
 ### Print vs Travel Classification

app.py

@@ -55,8 +55,6 @@ SCALE_MODE_TARGET_DIMENSIONS = "Independent X/Y/Z"
 SCALE_MODE_UNIFORM_FACTOR = "Keep Proportions"
 TARGET_DIMENSION_KEYS = ("target_x", "target_y", "target_z")
 FRONT_CAMERA = (90, 80, None)
-NOZZLE_LAYOUT_GRID = "Grid Layout"
-NOZZLE_LAYOUT_PAIR_TABLE = "Custom Spacing"
 NOZZLE_LAYOUT_PRESETS = [
     "Custom",
     "One row",
@@ -68,8 +66,6 @@ NOZZLE_LAYOUT_PRESETS = [
     "2 x 5",
     "5 x 2",
 ]
-AUTO_ALIGN_X_RASTER_OFFSETS = (-3.2, -0.8)
-AUTO_ALIGN_Y_RASTER_OFFSETS = (-0.8, -3.2)
 APP_CSS = """
 .gradio-container {
     font-size: 90%;
@@ -1161,96 +1157,6 @@ PARALLEL_COLOR_CHOICES = [
 DEFAULT_PARALLEL_COLORS = ("#ff7f0e", "#1f77b4", "#2ca02c")
 
 
-def _resolve_nozzle_layout(
-    parts: list[dict],
-    same_spacing: bool | None,
-    part_gap_12_x: float | None,
-    part_gap_12_y: float | None,
-    part_gap_23_x: float | None,
-    part_gap_23_y: float | None,
-    *extra_pair_gaps: float | None,
-) -> tuple[dict[int, tuple[float, float]], list[dict]]:
-    offsets: dict[int, tuple[float, float]] = {}
-    spacings: list[dict] = []
-    if not parts:
-        return offsets, spacings
-
-    grouped: dict[int, list[dict]] = {}
-    for part in parts:
-        grouped.setdefault(_record_nozzle_number(part, int(part.get("idx", 1) or 1)), []).append(part)
-    ordered_nozzles = sorted(grouped)
-    offsets[ordered_nozzles[0]] = (0.0, 0.0)
-
-    def nozzle_bounds(nozzle: int) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
-        mins: list[tuple[float, float, float]] = []
-        maxs: list[tuple[float, float, float]] = []
-        for part in grouped[nozzle]:
-            part_min, part_max = part["parsed"]["bounds"]
-            mins.append(part_min)
-            maxs.append(part_max)
-        return (
-            tuple(min(values) for values in zip(*mins)),
-            tuple(max(values) for values in zip(*maxs)),
-        )
-
-    first_spacing = (float(part_gap_12_x or 0.0), float(part_gap_12_y or 0.0))
-    raw_pairs: list[tuple[float, float]] = [
-        first_spacing,
-        (float(part_gap_23_x or 0.0), float(part_gap_23_y or 0.0)),
-    ]
-    for index in range(0, len(extra_pair_gaps), 2):
-        raw_pairs.append((
-            float(extra_pair_gaps[index] or 0.0),
-            float(extra_pair_gaps[index + 1] or 0.0) if index + 1 < len(extra_pair_gaps) else 0.0,
-        ))
-    max_pair_count = max(0, len(ordered_nozzles) - 1)
-    while len(raw_pairs) < max_pair_count:
-        raw_pairs.append(first_spacing)
-    if same_spacing:
-        raw_pairs = [first_spacing for _ in raw_pairs]
-
-    pair_spacing = {
-        (ordered_nozzles[index], ordered_nozzles[index + 1]): raw_pairs[index]
-        for index in range(min(len(raw_pairs), max_pair_count))
-    }
-
-    def spacing_between(prev_idx: int, cur_idx: int) -> tuple[float, float]:
-        if (prev_idx, cur_idx) in pair_spacing:
-            return pair_spacing[(prev_idx, cur_idx)]
-        try:
-            start_pos = ordered_nozzles.index(prev_idx)
-            end_pos = ordered_nozzles.index(cur_idx)
-        except ValueError:
-            return 0.0, 0.0
-        if end_pos <= start_pos:
-            return 0.0, 0.0
-        total_x = 0.0
-        total_y = 0.0
-        for pair_pos in range(start_pos, end_pos):
-            pair = (ordered_nozzles[pair_pos], ordered_nozzles[pair_pos + 1])
-            step_x, step_y = pair_spacing.get(pair, first_spacing)
-            total_x += step_x
-            total_y += step_y
-        return total_x, total_y
-
-    for prev_idx, cur_idx in zip(ordered_nozzles, ordered_nozzles[1:]):
-        gap_x, y_step = spacing_between(prev_idx, cur_idx)
-        prev_offset_x, prev_offset_y = offsets[prev_idx]
-        (_, _, _), (prev_xmax, _prev_ymax, _) = nozzle_bounds(prev_idx)
-        (cur_xmin, _cur_ymin, _), (_, _, _) = nozzle_bounds(cur_idx)
-        dx = (prev_xmax + prev_offset_x + gap_x) - cur_xmin
-        dy = prev_offset_y + y_step
-        offsets[cur_idx] = (dx, dy)
-        spacings.append({
-            "from": prev_idx,
-            "to": cur_idx,
-            "dx": dx - prev_offset_x,
-            "dy": y_step,
-        })
-
-    return offsets, spacings
-
-
 def _group_parts_by_nozzle(parts: list[dict]) -> dict[int, list[dict]]:
     grouped: dict[int, list[dict]] = {}
     for part in parts:
@@ -1390,44 +1296,6 @@ def _resolve_nozzle_grid_layout(
     return offsets, spacings
 
 
-def _resolve_layout_from_spacing_controls(
-    parts: list[dict],
-    layout_mode: str | None,
-    columns: Any,
-    rows: Any,
-    column_spacing: Any,
-    row_spacing: Any,
-    use_grid_individual_spacing: bool | None,
-    grid_spacing_table: Any,
-    use_individual_spacing: bool,
-    spacing_table: Any,
-) -> tuple[dict[int, tuple[float, float]], list[dict]]:
-    if layout_mode != NOZZLE_LAYOUT_PAIR_TABLE:
-        return _resolve_nozzle_grid_layout(
-            parts,
-            columns,
-            rows,
-            column_spacing,
-            row_spacing,
-            use_grid_individual_spacing,
-            grid_spacing_table,
-        )
-    gap12x, gap12y, gap23x, gap23y, extra = _spacing_args_from_table(spacing_table, use_individual_spacing)
-    return _resolve_nozzle_layout(
-        parts,
-        _same_spacing_from_individual(use_individual_spacing),
-        gap12x,
-        gap12y,
-        gap23x,
-        gap23y,
-        *extra,
-    )
-
-
-def _same_spacing_from_individual(use_individual_spacing: bool | None) -> bool:
-    return not bool(use_individual_spacing)
-
-
 def _format_shape_dimensions(parts: list[dict]) -> list[str]:
     lines = ["**Shape dimensions from generated G-code:**"]
     for part in sorted(parts, key=lambda item: item["idx"]):
@@ -1492,6 +1360,7 @@ SHAPE_SETTINGS_HEADERS = [
     "Nozzle",
     "Port",
     "Color",
+    "Infill %",
     "Contour Tracing",
     "Delete",
 ]
@@ -1506,22 +1375,16 @@ SHAPE_SETTINGS_DATATYPES = [
     "number",
     "number",
     "str",
+    "number",
     "bool",
     "str",
 ]
-SIMPLE_NOZZLE_SPACING_HEADERS = [
-    "Spacing Mode",
-    "Applies To",
-    "X edge spacing (mm)",
-    "Y nozzle spacing (mm)",
-]
 ADVANCED_NOZZLE_SPACING_HEADERS = [
     "From Nozzle",
     "To Nozzle",
     "X edge spacing (mm)",
     "Y nozzle spacing (mm)",
 ]
-NOZZLE_SPACING_HEADERS = SIMPLE_NOZZLE_SPACING_HEADERS
 
 
 def _normalise_rows(table: Any) -> list[list[Any]]:
@@ -1660,6 +1523,7 @@ def _records_from_files(files: Any, previous_records: list[dict] | None = None)
             "nozzle": nozzle,
             "port": previous.get("port", 1),
             "color": previous.get("color", _default_color(index)),
+            "infill": previous.get("infill", 100.0),
             "contour_tracing": previous.get("contour_tracing", False),
             "layer_stack": previous.get("layer_stack"),
             "slice_params": previous.get("slice_params"),
@@ -1690,6 +1554,7 @@ def _shape_settings_rows(records: list[dict]) -> list[list[Any]]:
             _record_nozzle_number(record, int(record["idx"])),
             record.get("port", 1),
             record.get("color", _default_color(record["idx"])),
+            _coerce_float(record.get("infill", 100.0), 100.0),
             bool(record.get("contour_tracing", False)),
             "Delete",
         ]
@@ -1733,7 +1598,8 @@ def _apply_shape_settings(records: list[dict], settings_table: Any) -> list[dict
             nozzle_pos = 7 if has_nozzle_column else None
             port_pos = 8 if has_nozzle_column else 7
             color_pos = 9 if has_nozzle_column else 8
-            contour_pos = 10 if has_nozzle_column else 9
+            infill_pos = 10 if has_nozzle_column else 9
+            contour_pos = 11 if has_nozzle_column else 10
             copy["valve"] = _coerce_int(copy.get("valve", 4), 4)
             copy["nozzle"] = _coerce_int(
                 row[nozzle_pos] if nozzle_pos is not None else copy.get("nozzle", copy.get("idx", 1)),
@@ -1747,6 +1613,13 @@ def _apply_shape_settings(records: list[dict], settings_table: Any) -> list[dict
                 copy["nozzle"] = _record_nozzle_number(copy)
             if len(row) > color_pos and row[color_pos]:
                 copy["color"] = str(row[color_pos])
+            try:
+                copy["infill"] = max(
+                    0.0,
+                    min(100.0, float(row[infill_pos])),
+                )
+            except (IndexError, TypeError, ValueError):
+                copy["infill"] = _coerce_float(copy.get("infill", 100.0), 100.0)
             try:
                 copy["contour_tracing"] = _coerce_bool(row[contour_pos], bool(copy.get("contour_tracing", False)))
             except IndexError:
@@ -1821,38 +1694,6 @@ def _spacing_pairs_from_table(spacing_table: Any) -> list[tuple[float, float]]:
     return pairs
 
 
-def _spacing_table_update(records: list[dict], existing_table: Any | None = None, use_individual_spacing: bool | None = False) -> dict[str, Any]:
-    pairs = _spacing_pairs_from_table(existing_table)
-    first_pair = pairs[0] if pairs else (5.0, 0.0)
-
-    if not use_individual_spacing:
-        return gr.update(
-            headers=SIMPLE_NOZZLE_SPACING_HEADERS,
-            value=[["Same spacing", "All neighboring nozzles", first_pair[0], first_pair[1]]],
-            row_count=(1, "fixed"),
-            column_count=(len(SIMPLE_NOZZLE_SPACING_HEADERS), "fixed"),
-            label="Nozzle Spacing",
-        )
-
-    rows: list[list[Any]] = []
-    ordered_nozzles = _ordered_nozzle_numbers(records)
-    for index, (first, second) in enumerate(zip(ordered_nozzles, ordered_nozzles[1:])):
-        gap_x, gap_y = pairs[index] if index < len(pairs) else first_pair
-        rows.append([
-            _nozzle_spacing_label(first, records),
-            _nozzle_spacing_label(second, records),
-            gap_x,
-            gap_y,
-        ])
-    return gr.update(
-        headers=ADVANCED_NOZZLE_SPACING_HEADERS,
-        value=rows,
-        row_count=(len(rows), "fixed"),
-        column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
-        label="Advanced Nozzle Spacing",
-    )
-
-
 def _grid_spacing_rows(
     records: list[dict],
     columns: Any,
@@ -1904,8 +1745,6 @@ def _grid_spacing_table_update(
         value=spacing_rows,
         row_count=(len(spacing_rows), "fixed"),
         column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
-        label="Advanced Grid Spacing",
-        visible=bool(use_individual_grid_spacing),
     )
 
 
@@ -1932,14 +1771,73 @@ def _split_pair_was_created_together(records_by_nozzle: dict[int, list[dict]], f
     return False
 
 
+def _part_world_bounds(part: dict) -> tuple[tuple[float, float], tuple[float, float]] | None:
+    """XY bounding box of a part's toolpath in the shape's own world frame.
+
+    Requires the `; PathOrigin` header the G-code generator writes; parts
+    generated before that header exists return None.
+    """
+    parsed = part.get("parsed") or {}
+    origin = parsed.get("path_origin")
+    if origin is None:
+        return None
+    (x_min, y_min, _z_min), (x_max, y_max, _z_max) = parsed["bounds"]
+    return (
+        (x_min + origin[0], y_min + origin[1]),
+        (x_max + origin[0], y_max + origin[1]),
+    )
+
+
+def _nozzle_world_bounds(
+    grouped: dict[int, list[dict]],
+) -> dict[int, tuple[tuple[float, float], tuple[float, float]]]:
+    world: dict[int, tuple[tuple[float, float], tuple[float, float]]] = {}
+    for nozzle, parts in grouped.items():
+        boxes = [_part_world_bounds(part) for part in parts]
+        if not boxes or any(box is None for box in boxes):
+            continue
+        world[nozzle] = (
+            (min(box[0][0] for box in boxes), min(box[0][1] for box in boxes)),
+            (max(box[1][0] for box in boxes), max(box[1][1] for box in boxes)),
+        )
+    return world
+
+
+def _split_grid_shape(records: list[dict]) -> tuple[int, int] | None:
+    """The split grid (columns, rows) when records hold exactly one split group."""
+    groups = {
+        record.get("split_group_id")
+        for record in records
+        if record.get("split_group_id")
+    }
+    if len(groups) != 1:
+        return None
+    group_id = next(iter(groups))
+    for record in records:
+        if record.get("split_group_id") == group_id:
+            columns = _coerce_int(record.get("split_columns"), 0)
+            rows = _coerce_int(record.get("split_rows"), 0)
+            if columns >= 1 and rows >= 1:
+                return columns, rows
+    return None
+
+
 def _auto_align_grid_spacing_rows(
     records: list[dict],
     columns: Any,
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
-    raster_pattern: str | None,
-) -> tuple[list[list[Any]], int, int, int]:
+) -> tuple[list[list[Any]], int, int, int, int]:
+    """Exact per-pair gaps that reassemble split pieces in the parallel view.
+
+    Every generated G-code file records its PathOrigin: the world position of
+    the relative toolpath's start. Anchoring each piece back into its world
+    frame turns the required pair gaps into the actual world-frame gaps
+    between the parts' toolpath bounding boxes — which automatically accounts
+    for the raster pattern, filament width, travel buffers, reference-stack
+    motion, and overlapping-layer splits. No hardcoded offsets.
+    """
     spacing_rows, column_count, row_count = _grid_spacing_rows(
         records,
         columns,
@@ -1947,18 +1845,42 @@ def _auto_align_grid_spacing_rows(
         column_spacing,
         row_spacing,
     )
-    auto_x_gap, auto_y_gap = _auto_align_split_offsets(raster_pattern)
+    parts, _messages = _parts_from_records(records)
+    world = _nozzle_world_bounds(_group_parts_by_nozzle(parts))
     records_by_nozzle = _records_by_nozzle(records)
     ordered_nozzles = _ordered_nozzle_numbers(records)
+
     aligned_count = 0
+    missing_count = 0
     for index, (first, second) in enumerate(zip(ordered_nozzles, ordered_nozzles[1:])):
         if not _split_pair_was_created_together(records_by_nozzle, first, second):
             continue
-        gap_x, gap_y = _grid_default_gap_for_pair(index, column_count, auto_x_gap, auto_y_gap)
-        spacing_rows[index][2] = gap_x
-        spacing_rows[index][3] = gap_y
+
+        second_column = (index + 1) % column_count
+        if second_column == 0:
+            # Row transition: `second` opens a new grid row. The layout places
+            # it relative to the previous row's first nozzle (x) and the
+            # previous row's lowest edge (y).
+            previous_row = ordered_nozzles[index + 1 - column_count : index + 1]
+            anchors = [second, *previous_row]
+        else:
+            row_first = ordered_nozzles[index + 1 - second_column]
+            anchors = [first, second, row_first]
+        if any(nozzle not in world for nozzle in anchors):
+            missing_count += 1
+            continue
+
+        (second_min_x, second_min_y), _second_max = world[second]
+        if second_column == 0:
+            gap_x = second_min_x - world[previous_row[0]][0][0]
+            gap_y = second_min_y - max(world[nozzle][1][1] for nozzle in previous_row)
+        else:
+            gap_x = second_min_x - world[first][1][0]
+            gap_y = second_min_y - world[row_first][0][1]
+        spacing_rows[index][2] = round(gap_x, 4)
+        spacing_rows[index][3] = round(gap_y, 4)
         aligned_count += 1
-    return spacing_rows, column_count, row_count, aligned_count
+    return spacing_rows, column_count, row_count, aligned_count, missing_count
 
 
 def apply_nozzle_grid_spacing(
@@ -1988,46 +1910,57 @@ def apply_nozzle_grid_spacing(
     )
 
 
-def _auto_align_split_offsets(raster_pattern: str | None) -> tuple[float, float]:
-    if raster_pattern == RASTER_PATTERN_Y_DIRECTION:
-        return AUTO_ALIGN_Y_RASTER_OFFSETS
-    return AUTO_ALIGN_X_RASTER_OFFSETS
-
-
-def auto_align_split_parts_for_raster(
+def auto_align_split_parts(
     records: list[dict] | None,
     columns: Any,
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
-    raster_pattern: str | None,
 ) -> tuple:
-    x_gap, y_gap = _auto_align_split_offsets(raster_pattern)
-    raster_label = raster_pattern or RASTER_PATTERN_SAME_DIRECTION
-    spacing_rows, column_count, row_count, aligned_count = _auto_align_grid_spacing_rows(
-        records or [],
-        columns,
-        rows,
-        column_spacing,
-        row_spacing,
-        raster_pattern,
-    )
+    records = records or []
+    grid_shape = _split_grid_shape(records)
+    if grid_shape is not None:
+        columns, rows = grid_shape
+    (
+        spacing_rows,
+        column_count,
+        row_count,
+        aligned_count,
+        missing_count,
+    ) = _auto_align_grid_spacing_rows(records, columns, rows, column_spacing, row_spacing)
+
     if aligned_count <= 0:
+        if missing_count > 0:
+            status = (
+                "Auto align needs the split pieces' generated G-code: press "
+                "Generate G-Code first (files generated before this feature "
+                "lack the PathOrigin header), then align again."
+            )
+        else:
+            status = "No split-sibling nozzle connections found. Auto align was not applied."
         return (
-            gr.update(value=NOZZLE_LAYOUT_GRID),
-            gr.update(visible=True),
-            gr.update(visible=False),
             gr.update(),
             gr.update(),
             gr.update(),
             gr.update(),
-            "No split-sibling nozzle connections found. Auto align was not applied.",
+            gr.update(),
+            gr.update(),
+            status,
         )
 
+    status = (
+        f"Auto aligned {aligned_count} split nozzle connection(s) from the generated "
+        f"G-code in a {column_count} x {row_count} grid. The exact per-connection "
+        "gaps are in the Advanced Grid Spacing table."
+    )
+    if missing_count:
+        status += (
+            f"  \n{missing_count} connection(s) skipped: regenerate G-code for those "
+            "shapes to add the PathOrigin header, then align again."
+        )
     return (
-        gr.update(value=NOZZLE_LAYOUT_GRID),
-        gr.update(visible=True),
-        gr.update(visible=False),
+        gr.update(value=column_count),
+        gr.update(value=row_count),
         gr.update(),
         gr.update(),
         gr.update(value=True),
@@ -2036,13 +1969,8 @@ def auto_align_split_parts_for_raster(
             value=spacing_rows,
             row_count=(len(spacing_rows), "fixed"),
             column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
-            label="Advanced Grid Spacing",
-            visible=True,
-        ),
-        (
-            f"Auto aligned {aligned_count} split nozzle connection(s) for {raster_label} "
-            f"in a {column_count} x {row_count} grid: Column Gap X {x_gap:.2f} mm, Row Gap Y {y_gap:.2f} mm."
         ),
+        status,
     )
 
 
@@ -2063,11 +1991,6 @@ def update_nozzle_grid_preset(
     return gr.update(value=max(1, _coerce_int(columns, 1))), gr.update(value=max(1, _coerce_int(rows, 1)))
 
 
-def update_nozzle_spacing_mode(layout_mode: str | None) -> tuple[dict[str, Any], dict[str, Any]]:
-    custom_selected = layout_mode == NOZZLE_LAYOUT_PAIR_TABLE
-    return gr.update(visible=not custom_selected), gr.update(visible=custom_selected)
-
-
 def update_lead_in_options_visibility(enabled: bool | None) -> dict[str, Any]:
     return gr.update(visible=bool(enabled))
 
@@ -2110,17 +2033,13 @@ def sync_uploaded_shapes(
     files: Any,
     records: list[dict] | None,
     settings_table: Any | None = None,
-    existing_spacing: Any | None = None,
-    use_individual_spacing: bool | None = False,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     next_records = _records_from_files(files, records)
     settings = _shape_settings_rows(next_records)
-    spacing = _spacing_table_update(next_records, existing_spacing, use_individual_spacing)
     return (
         next_records,
         settings,
-        spacing,
         _dropdown_update(next_records),
         _gcode_dropdown_update(next_records),
         _gcode_dropdown_update(next_records, include_upload=True),
@@ -2132,30 +2051,18 @@ def load_sample_shapes(
     files: Any,
     records: list[dict] | None,
     settings_table: Any | None = None,
-    existing_spacing: Any | None = None,
-    use_individual_spacing: bool | None = False,
 ) -> 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()]
     merged_paths = _append_file_paths(files, paths)
     return (
         gr.update(value=merged_paths),
-        *sync_uploaded_shapes(merged_paths, records, None, existing_spacing, use_individual_spacing),
+        *sync_uploaded_shapes(merged_paths, records, None),
     )
 
 
-def update_nozzle_spacing_table_mode(
-    records: list[dict] | None,
-    existing_spacing: Any | None,
-    use_individual_spacing: bool | None,
-) -> dict[str, Any]:
-    return _spacing_table_update(records or [], existing_spacing, use_individual_spacing)
-
-
 def _shape_delete_outputs(
     records: list[dict],
-    existing_spacing: Any | None,
-    use_individual_spacing: bool | None,
     last_delete_at: float | None,
     upload_update: Any | None = None,
 ) -> tuple:
@@ -2163,7 +2070,6 @@ def _shape_delete_outputs(
         upload_update if upload_update is not None else gr.update(),
         records,
         _shape_settings_rows(records),
-        _spacing_table_update(records, existing_spacing, use_individual_spacing),
         _dropdown_update(records),
         _gcode_dropdown_update(records),
         _gcode_dropdown_update(records, include_upload=True),
@@ -2175,8 +2081,6 @@ def _shape_delete_outputs(
 def delete_shape_from_settings(
     records: list[dict] | None,
     settings_table: Any | None,
-    existing_spacing: Any | None,
-    use_individual_spacing: bool | None,
     last_delete_at: float | None,
     evt: gr.SelectData,
 ) -> tuple:
@@ -2185,17 +2089,17 @@ def delete_shape_from_settings(
     selected = getattr(evt, "index", None)
     current_records = _apply_shape_settings(records or [], settings_table)
     if not isinstance(selected, (list, tuple)) or len(selected) < 2:
-        return _shape_delete_outputs(current_records, existing_spacing, use_individual_spacing, last_delete_at)
+        return _shape_delete_outputs(current_records, last_delete_at)
 
     try:
         row_index, column_index = int(selected[0]), int(selected[1])
     except (TypeError, ValueError):
-        return _shape_delete_outputs(current_records, existing_spacing, use_individual_spacing, last_delete_at)
+        return _shape_delete_outputs(current_records, last_delete_at)
     delete_column_index = len(SHAPE_SETTINGS_HEADERS) - 1
     if column_index != delete_column_index or row_index < 0 or row_index >= len(rows):
-        return _shape_delete_outputs(current_records, existing_spacing, use_individual_spacing, last_delete_at)
+        return _shape_delete_outputs(current_records, last_delete_at)
     if last_delete_at and now - float(last_delete_at) < DELETE_SHAPE_COOLDOWN_SECONDS:
-        return _shape_delete_outputs(current_records, existing_spacing, use_individual_spacing, last_delete_at)
+        return _shape_delete_outputs(current_records, last_delete_at)
 
     try:
         delete_idx = int(float(rows[row_index][0]))
@@ -2208,8 +2112,6 @@ def delete_shape_from_settings(
     upload_paths = [record.get("stl_path") for record in next_records if record.get("stl_path")]
     return _shape_delete_outputs(
         next_records,
-        existing_spacing,
-        use_individual_spacing,
         now,
         gr.update(value=upload_paths),
     )
@@ -2289,21 +2191,6 @@ def normalize_shape_dimensions_for_mode(
     return normalized, _shape_settings_rows(normalized)
 
 
-def normalize_shape_settings_and_spacing(
-    records: list[dict] | None,
-    settings_table: Any | None,
-    scale_mode: str | None,
-    existing_spacing: Any | None,
-    use_individual_spacing: bool | None,
-) -> tuple:
-    updated_records, updated_settings = normalize_shape_dimensions_for_mode(records, settings_table, scale_mode)
-    return (
-        updated_records,
-        updated_settings,
-        _spacing_table_update(updated_records, existing_spacing, use_individual_spacing),
-    )
-
-
 def show_selected_model(
     records: list[dict] | None,
     selected: str | None,
@@ -2370,6 +2257,7 @@ def generate_dynamic_layer_stacks(
     settings_table: Any,
     layer_height: float,
     scale_mode: str | None,
+    fil_width: float = 0.8,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
@@ -2398,7 +2286,7 @@ def generate_dynamic_layer_stacks(
             )
         except Exception as exc:
             messages.append(f"Shape {record['idx']}: failed ({exc}).")
-    ref_layers = generate_dynamic_reference_stack(records)
+    ref_layers = generate_dynamic_reference_stack(records, fil_width)
     if ref_layers is not None:
         messages.append("Reference layers: updated automatically.")
     else:
@@ -2406,16 +2294,22 @@ def generate_dynamic_layer_stacks(
     return records, "\n".join(messages), ref_layers
 
 
-def generate_dynamic_reference_stack(records: list[dict] | None) -> LayerStack | None:
-    return build_reference_stack([record.get("layer_stack") for record in (records or [])])
+def generate_dynamic_reference_stack(
+    records: list[dict] | None,
+    fil_width: float = 0.8,
+) -> LayerStack | None:
+    # Snapping the alignment to the fil grid keeps split pieces' scan-grid
+    # phase intact under shared reference motion (exact one-fil seam pitch).
+    return build_reference_stack(
+        [record.get("layer_stack") for record in (records or [])],
+        grid=float(fil_width) if fil_width else None,
+    )
 
 
 def split_selected_shape_for_grid(
     records: list[dict] | None,
     selected: str | None,
     settings_table: Any | None,
-    existing_spacing: Any | None,
-    use_individual_spacing: bool | None,
     columns: float,
     rows: float,
     overlapping_layers: bool,
@@ -2429,7 +2323,6 @@ def split_selected_shape_for_grid(
         return (
             next_records,
             _shape_settings_rows(next_records),
-            _spacing_table_update(next_records, existing_spacing, use_individual_spacing),
             _dropdown_update(next_records, selected_value),
             [record.get("gcode_path") for record in next_records if record.get("gcode_path")],
             _gcode_dropdown_update(next_records),
@@ -2462,6 +2355,9 @@ def split_selected_shape_for_grid(
             rows=split_row_count,
             overlapping_layers=bool(overlapping_layers),
             overlap=float(fil_width) if overlapping_layers else 0.0,
+            # Whole-fil cells (last piece absorbs the remainder): keeps the
+            # required nozzle spacing uniform under shared reference motion.
+            grid=float(fil_width),
         )
     except Exception as exc:
         return _outputs(records, selected, f"Split failed: {exc}")
@@ -2571,9 +2467,13 @@ def generate_dynamic_gcode(
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     messages: list[str] = []
-    if _ensure_records_sliced(records, layer_height, scale_mode, messages):
-        # Anything re-sliced invalidates the previous reference union.
-        ref_layers = generate_dynamic_reference_stack(records)
+    resliced = _ensure_records_sliced(records, layer_height, scale_mode, messages)
+    if use_reference_motion:
+        # Always rebuild with the CURRENT fil width: the reference stack's
+        # alignment snap grid must match the fil the G-code is generated with.
+        ref_layers = generate_dynamic_reference_stack(records, fil_width)
+    elif resliced:
+        ref_layers = generate_dynamic_reference_stack(records, fil_width)
     contour_sources = _contour_tracing_sources(records)
     if contour_sources:
         enabled = ", ".join(f"Shape {source.owner_idx}" for source in contour_sources)
@@ -2602,6 +2502,7 @@ def generate_dynamic_gcode(
                 raster_pattern=raster_pattern,
                 contour_sources=contour_sources,
                 active_contour_owner=int(record.get("idx", 0)),
+                infill=_coerce_float(record.get("infill", 100.0), 100.0) / 100.0,
                 lead_in_enabled=bool(lead_in_enabled),
                 lead_in_length=float(lead_in_length),
                 lead_in_clearance=float(lead_in_clearance),
@@ -2657,44 +2558,26 @@ def _parts_from_records(records: list[dict] | None) -> tuple[list[dict], list[st
     return parts, messages
 
 
-def _spacing_args_from_table(spacing_table: Any, use_individual_spacing: bool | None = False) -> tuple[float, float, float, float, list[float]]:
-    pairs = _spacing_pairs_from_table(spacing_table)
-    if not pairs:
-        pairs = [(5.0, 0.0)]
-    if not use_individual_spacing:
-        pairs = [pairs[0]]
-    while len(pairs) < 2:
-        pairs.append(pairs[0])
-    extra = [value for pair in pairs[2:] for value in pair]
-    return pairs[0][0], pairs[0][1], pairs[1][0], pairs[1][1], extra
-
-
 def render_dynamic_nozzle_spacing(
     records: list[dict] | None,
-    layout_mode: str | None,
     columns: Any,
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
     use_grid_individual_spacing: bool,
     grid_spacing_table: Any,
-    use_individual_spacing: bool,
-    spacing_table: Any,
 ) -> tuple[Any, str]:
     parts, _messages = _parts_from_records(records)
     if not parts:
         return None, "No shape G-code available. Generate G-code first."
-    offsets, spacings = _resolve_layout_from_spacing_controls(
+    offsets, spacings = _resolve_nozzle_grid_layout(
         parts,
-        layout_mode,
         columns,
         rows,
         column_spacing,
         row_spacing,
         use_grid_individual_spacing,
         grid_spacing_table,
-        use_individual_spacing,
-        spacing_table,
     )
     return build_nozzle_spacing_figure(parts, offsets, spacings), _format_nozzle_spacing_status(parts, offsets, spacings)
 
@@ -2765,32 +2648,26 @@ def render_dynamic_parallel(
     travel_opacity: float,
     filament_width: float,
     travel_width: float,
-    layout_mode: str | None,
     columns: Any,
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
     use_grid_individual_spacing: bool,
     grid_spacing_table: Any,
-    use_individual_spacing: bool,
-    spacing_table: Any,
     tube: bool = True,
 ) -> tuple[Any, str]:
     records = _apply_shape_settings(records or [], settings_table)
     parts, messages = _parts_from_records(records)
     if not parts:
         return None, "No shape G-code available. Generate G-code on the Generate G-Code tab first."
-    offsets, spacings = _resolve_layout_from_spacing_controls(
+    offsets, spacings = _resolve_nozzle_grid_layout(
         parts,
-        layout_mode,
         columns,
         rows,
         column_spacing,
         row_spacing,
         use_grid_individual_spacing,
         grid_spacing_table,
-        use_individual_spacing,
-        spacing_table,
     )
     figure = build_parallel_figure(
         parts,
@@ -2824,15 +2701,12 @@ def export_dynamic_parallel_gif(
     records: list[dict] | None,
     settings_table: Any,
     travel_opacity: float,
-    layout_mode: str | None,
     columns: Any,
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
     use_grid_individual_spacing: bool,
     grid_spacing_table: Any,
-    use_individual_spacing: bool,
-    spacing_table: Any,
     duration: float,
     fps: float,
     elev: float,
@@ -2843,17 +2717,14 @@ def export_dynamic_parallel_gif(
     parts, _messages = _parts_from_records(records)
     if not parts:
         return None
-    offsets, _spacings = _resolve_layout_from_spacing_controls(
+    offsets, _spacings = _resolve_nozzle_grid_layout(
         parts,
-        layout_mode,
         columns,
         rows,
         column_spacing,
         row_spacing,
         use_grid_individual_spacing,
         grid_spacing_table,
-        use_individual_spacing,
-        spacing_table,
     )
 
     def report(frame: int, total: int) -> None:
@@ -2986,12 +2857,7 @@ def build_dynamic_demo() -> gr.Blocks:
             gcode_text = gr.Code(label="Selected G-Code", language=None, lines=18, max_lines=18, interactive=False, elem_classes=["gcode-view"])
 
             with gr.Accordion("Nozzle Spacing", open=False, elem_classes=["settings-accordion"]):
-                nozzle_layout_mode = gr.Radio(
-                    label="Spacing Mode",
-                    choices=[NOZZLE_LAYOUT_GRID, NOZZLE_LAYOUT_PAIR_TABLE],
-                    value=NOZZLE_LAYOUT_GRID,
-                )
-                with gr.Group(visible=True) as nozzle_grid_group:
+                with gr.Group():
                     with gr.Row():
                         nozzle_grid_preset = gr.Dropdown(
                             label="Common Layout",
@@ -3005,28 +2871,21 @@ def build_dynamic_demo() -> gr.Blocks:
                         nozzle_grid_row_spacing = gr.Number(label="Row Gap (Y, mm)", value=0.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="Use Different Grid Connection Gaps", value=False)
+                        nozzle_grid_use_individual_spacing = gr.Checkbox(label="Advanced Grid Spacing", value=False)
+                    # Always visible: the "Advanced Grid Spacing" checkbox
+                    # controls whether these per-connection gaps are USED,
+                    # not whether the table shows. Toggling visibility from
+                    # events proved racy (the table wouldn't appear on the
+                    # first Auto Align click).
                     nozzle_grid_spacing_table = gr.Dataframe(
                         headers=ADVANCED_NOZZLE_SPACING_HEADERS,
                         value=[],
                         row_count=(0, "fixed"),
                         column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
                         interactive=True,
-                        label="Advanced Grid Spacing",
-                        visible=False,
+                        label="Advanced Grid Spacing (used when the checkbox is on)",
                         elem_id="nozzle-grid-spacing-table",
                     )
-                with gr.Group(visible=False) as nozzle_custom_group:
-                    nozzle_use_individual_spacing = gr.Checkbox(label="Use Different Values for Each Nozzle Connection", value=False)
-                    nozzle_spacing_table = gr.Dataframe(
-                        headers=NOZZLE_SPACING_HEADERS,
-                        value=[["Same spacing", "All neighboring nozzles", 5.0, 0.0]],
-                        row_count=(1, "fixed"),
-                        column_count=(len(NOZZLE_SPACING_HEADERS), "fixed"),
-                        interactive=True,
-                        label="Custom Spacing",
-                        elem_id="nozzle-spacing-table",
-                    )
                 nozzle_preview_button = gr.Button("Visualize Nozzle Spacing", variant="secondary", elem_id="visualize-nozzle-spacing-button")
                 with gr.Row():
                     with gr.Column(scale=3, min_width=420):
@@ -3120,8 +2979,8 @@ def build_dynamic_demo() -> gr.Blocks:
             nozzle_grid_use_individual_spacing,
         ]
 
-        shape_sync_outputs = [shape_records, shape_settings, nozzle_spacing_table, selected_shape, gcode_text_source, gcode_source, gcode_downloads]
-        stl_upload.change(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=shape_sync_outputs).then(
+        shape_sync_outputs = [shape_records, shape_settings, selected_shape, gcode_text_source, gcode_source, gcode_downloads]
+        stl_upload.change(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings], outputs=shape_sync_outputs).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
@@ -3132,7 +2991,7 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[nozzle_grid_spacing_table],
             queue=False,
         )
-        sync_uploads_button.click(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=shape_sync_outputs).then(
+        sync_uploads_button.click(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings], outputs=shape_sync_outputs).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
@@ -3143,7 +3002,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, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=[stl_upload, *shape_sync_outputs]).then(
+        load_samples_button.click(fn=load_sample_shapes, inputs=[stl_upload, shape_records, shape_settings], outputs=[stl_upload, *shape_sync_outputs]).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
@@ -3156,7 +3015,7 @@ def build_dynamic_demo() -> gr.Blocks:
         )
         shape_settings.select(
             fn=delete_shape_from_settings,
-            inputs=[shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing, last_shape_delete_at],
+            inputs=[shape_records, shape_settings, last_shape_delete_at],
             outputs=[stl_upload, *shape_sync_outputs, last_shape_delete_at],
         ).then(
             fn=lambda records: _dropdown_update(records),
@@ -3172,9 +3031,9 @@ def build_dynamic_demo() -> gr.Blocks:
 
         preview_inputs = [shape_records, selected_shape, shape_settings, model_opacity, scale_mode]
         shape_settings.change(
-            fn=normalize_shape_settings_and_spacing,
-            inputs=[shape_records, shape_settings, scale_mode, nozzle_spacing_table, nozzle_use_individual_spacing],
-            outputs=[shape_records, shape_settings, nozzle_spacing_table],
+            fn=normalize_shape_dimensions_for_mode,
+            inputs=[shape_records, shape_settings, scale_mode],
+            outputs=[shape_records, shape_settings],
             queue=False,
         ).then(
             fn=_grid_spacing_table_update,
@@ -3207,7 +3066,7 @@ def build_dynamic_demo() -> gr.Blocks:
 
         generate_button.click(
             fn=generate_dynamic_layer_stacks,
-            inputs=[shape_records, shape_settings, layer_height, scale_mode],
+            inputs=[shape_records, shape_settings, layer_height, scale_mode, fil_width],
             outputs=[shape_records, slicer_status, ref_layers],
         ).then(
             fn=lambda records: _dropdown_update(records),
@@ -3223,8 +3082,6 @@ def build_dynamic_demo() -> gr.Blocks:
                 shape_records,
                 split_source,
                 shape_settings,
-                nozzle_spacing_table,
-                nozzle_use_individual_spacing,
                 split_columns,
                 split_rows,
                 split_overlapping_layers,
@@ -3235,7 +3092,6 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[
                 shape_records,
                 shape_settings,
-                nozzle_spacing_table,
                 selected_shape,
                 gcode_downloads,
                 gcode_text_source,
@@ -3245,7 +3101,7 @@ def build_dynamic_demo() -> gr.Blocks:
             ],
         ).then(
             fn=generate_dynamic_reference_stack,
-            inputs=[shape_records],
+            inputs=[shape_records, fil_width],
             outputs=[ref_layers],
         ).then(
             fn=_grid_spacing_table_update,
@@ -3286,26 +3142,18 @@ def build_dynamic_demo() -> gr.Blocks:
         )
         gcode_text_source.change(fn=load_selected_gcode_text, inputs=[shape_records, gcode_text_source], outputs=[gcode_text])
         refresh_gcode_text_button.click(fn=load_selected_gcode_text, inputs=[shape_records, gcode_text_source], outputs=[gcode_text])
-        nozzle_layout_mode.change(
-            fn=update_nozzle_spacing_mode,
-            inputs=[nozzle_layout_mode],
-            outputs=[nozzle_grid_group, nozzle_custom_group],
-            queue=False,
-        )
         auto_align_split_parts_button.click(
-            fn=auto_align_split_parts_for_raster,
+            fn=auto_align_split_parts,
             inputs=[
                 shape_records,
                 nozzle_grid_columns,
                 nozzle_grid_rows,
                 nozzle_grid_column_spacing,
                 nozzle_grid_row_spacing,
-                gcode_raster_pattern,
             ],
             outputs=[
-                nozzle_layout_mode,
-                nozzle_grid_group,
-                nozzle_custom_group,
+                nozzle_grid_columns,
+                nozzle_grid_rows,
                 nozzle_grid_column_spacing,
                 nozzle_grid_row_spacing,
                 nozzle_grid_use_individual_spacing,
@@ -3332,26 +3180,27 @@ def build_dynamic_demo() -> gr.Blocks:
             nozzle_grid_row_spacing,
             nozzle_grid_use_individual_spacing,
         ):
-            grid_spacing_control.change(
+            # .input (user edits only), NOT .change: Auto Align sets these
+            # controls programmatically and .change listeners would fire and
+            # rebuild the spacing table, clobbering the aligned gaps it just
+            # wrote. Flows that set them programmatically (preset dropdown,
+            # Auto Align) update the table explicitly themselves.
+            grid_spacing_control.input(
                 fn=_grid_spacing_table_update,
                 inputs=grid_spacing_refresh_inputs,
                 outputs=[nozzle_grid_spacing_table],
                 queue=False,
             )
-        nozzle_use_individual_spacing.change(fn=update_nozzle_spacing_table_mode, inputs=[shape_records, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=[nozzle_spacing_table], queue=False)
         nozzle_preview_button.click(
             fn=render_dynamic_nozzle_spacing,
             inputs=[
                 shape_records,
-                nozzle_layout_mode,
                 nozzle_grid_columns,
                 nozzle_grid_rows,
                 nozzle_grid_column_spacing,
                 nozzle_grid_row_spacing,
                 nozzle_grid_use_individual_spacing,
                 nozzle_grid_spacing_table,
-                nozzle_use_individual_spacing,
-                nozzle_spacing_table,
             ],
             outputs=[nozzle_spacing_plot, nozzle_spacing_status],
         )
@@ -3398,15 +3247,12 @@ def build_dynamic_demo() -> gr.Blocks:
             pp_travel_opacity,
             pp_filament_width,
             pp_travel_width,
-            nozzle_layout_mode,
             nozzle_grid_columns,
             nozzle_grid_rows,
             nozzle_grid_column_spacing,
             nozzle_grid_row_spacing,
             nozzle_grid_use_individual_spacing,
             nozzle_grid_spacing_table,
-            nozzle_use_individual_spacing,
-            nozzle_spacing_table,
         ]
         parallel_outputs = [parallel_plot, parallel_status, parallel_mode, parallel_anim_controls, pp_width_row, pp_export_group]
         parallel_line_button.click(fn=render_dynamic_parallel_lines, inputs=parallel_render_inputs, outputs=parallel_outputs)
@@ -3419,15 +3265,12 @@ def build_dynamic_demo() -> gr.Blocks:
                 shape_records,
                 shape_settings,
                 pp_gif_travel_opacity,
-                nozzle_layout_mode,
                 nozzle_grid_columns,
                 nozzle_grid_rows,
                 nozzle_grid_column_spacing,
                 nozzle_grid_row_spacing,
                 nozzle_grid_use_individual_spacing,
                 nozzle_grid_spacing_table,
-                nozzle_use_individual_spacing,
-                nozzle_spacing_table,
                 pp_gif_duration,
                 pp_gif_fps,
                 pp_elev,

gcode_viewer.py

@@ -21,6 +21,12 @@ _AXIS_RE = re.compile(r"([XYZxyz])\s*([-+]?(?:\d*\.\d+|\d+\.?)(?:e[-+]?\d+)?)")
 # Pneumatic valve toggle: WAGO_ValveCommands(<valve>, <0=close|1=open>). Some
 # generators emit every move as G1 and convey extrusion only through the valve.
 _VALVE_RE = re.compile(r"WAGO_ValveCommands\(\s*(\d+)\s*,\s*(\d+)\s*\)", re.IGNORECASE)
+# World anchor written by this app's generator: the absolute position, in the
+# shape's own coordinate frame, that the relative toolpath starts from.
+_PATH_ORIGIN_RE = re.compile(
+    r"^;\s*PathOrigin\s+X([-+]?[\d.]+(?:e[-+]?\d+)?)\s+Y([-+]?[\d.]+(?:e[-+]?\d+)?)",
+    re.MULTILINE,
+)
 
 
 def parse_gcode_path(gcode_text: str) -> dict:
@@ -143,6 +149,13 @@ def parse_gcode_path(gcode_text: str) -> dict:
             next_print_layer = z_to_layer[round(move["end"][2], 6)]
         move["layer"] = next_print_layer
 
+    origin_match = _PATH_ORIGIN_RE.search(gcode_text)
+    path_origin = (
+        (float(origin_match.group(1)), float(origin_match.group(2)))
+        if origin_match
+        else None
+    )
+
     return {
         "print_segments": print_segments,
         "travel_segments": travel_segments,
@@ -150,6 +163,7 @@ def parse_gcode_path(gcode_text: str) -> dict:
         "layer_count": len(print_z),
         "bounds": bounds,
         "point_count": len(all_x),
+        "path_origin": path_origin,
     }
 
 

stl_slicer.py

@@ -25,6 +25,15 @@ class LayerStack:
     `bounds` is the scaled mesh's axis-aligned bounding box. For grid-split
     pieces it is the piece's nominal cell box, which keeps reference-stack
     centring stable even when the clipped geometry shrinks.
+
+    `scan_frame` is the XY box the raster scan grid is anchored to. Grid-split
+    pieces inherit the parent shape's frame so all pieces raster on one
+    continuous line grid and seams keep an exact one-fil-width pitch.
+
+    `align_center`/`align_grid` are stamped by `build_reference_stack` on the
+    combined reference stack: the common centre shapes were aligned to, and
+    the grid the alignment deltas were snapped to — so later alignment of a
+    shape against the reference reproduces exactly the same translation.
     """
 
     layers: list[MultiPolygon]
@@ -32,6 +41,9 @@ class LayerStack:
     bounds: Bounds3D
     layer_height: float
     name: str = ""
+    scan_frame: tuple[float, float, float, float] | None = None
+    align_center: tuple[float, float] | None = None
+    align_grid: float | None = None
 
 
 def load_mesh(stl_path: str | Path) -> trimesh.Trimesh:

tests/test_nozzle_spacing.py

@@ -6,23 +6,21 @@ from app import (
     ADVANCED_NOZZLE_SPACING_HEADERS,
     SCALE_MODE_UNIFORM_FACTOR,
     SHAPE_SETTINGS_HEADERS,
-    SIMPLE_NOZZLE_SPACING_HEADERS,
-    _auto_align_split_offsets,
     _auto_align_grid_spacing_rows,
     _apply_shape_settings,
     _contour_tracing_sources,
     delete_shape_from_settings,
     _format_nozzle_spacing_status,
     _grid_spacing_rows,
+    _parts_from_records,
     _records_from_files,
     _shape_settings_rows,
-    _spacing_args_from_table,
-    _spacing_table_update,
     normalize_shape_dimensions_for_mode,
     _resolve_nozzle_grid_layout,
-    _resolve_nozzle_layout,
 )
 from vector_toolpath import (
+    RASTER_PATTERN_CIRCLE_SPIRAL,
+    RASTER_PATTERN_RECTANGULAR_SPIRAL,
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_Y_DIRECTION,
 )
@@ -41,145 +39,17 @@ def _part(
     }
 
 
-def test_calculated_nozzle_layout_uses_requested_part_gap() -> None:
-    parts = [
-        _part(1, ((0.0, 0.0, 0.0), (10.0, 20.0, 1.0))),
-        _part(2, ((0.0, 0.0, 0.0), (5.0, 6.0, 1.0))),
-        _part(3, ((-2.0, -1.0, 0.0), (2.0, 3.0, 1.0))),
-    ]
-
-    offsets, spacings = _resolve_nozzle_layout(
-        parts,
-        same_spacing=False,
-        part_gap_12_x=2.5,
-        part_gap_12_y=-1.0,
-        part_gap_23_x=8.0,
-        part_gap_23_y=4.0,
-    )
-
-    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
-    np.testing.assert_allclose(offsets[2], (12.5, -1.0))
-    np.testing.assert_allclose(offsets[3], (27.5, 3.0))
-    assert spacings[0] == {"from": 1, "to": 2, "dx": 12.5, "dy": -1.0}
-    assert spacings[1] == {"from": 2, "to": 3, "dx": 15.0, "dy": 4.0}
-
-
-def test_calculated_nozzle_layout_allows_negative_x_overlap() -> None:
-    parts = [
-        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
-        _part(2, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
-    ]
-
-    offsets, spacings = _resolve_nozzle_layout(
-        parts,
-        same_spacing=True,
-        part_gap_12_x=-2.0,
-        part_gap_12_y=3.0,
-        part_gap_23_x=0.0,
-        part_gap_23_y=0.0,
-    )
-
-    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
-    np.testing.assert_allclose(offsets[2], (8.0, 3.0))
-    assert spacings == [{"from": 1, "to": 2, "dx": 8.0, "dy": 3.0}]
-
-
-def test_nozzle_layout_groups_shapes_that_share_a_nozzle() -> None:
-    parts = [
-        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0)), nozzle=1),
-        _part(2, ((-1.0, -2.0, 0.0), (12.0, 4.0, 1.0)), nozzle=1),
-        _part(3, ((0.0, 0.0, 0.0), (6.0, 5.0, 1.0)), nozzle=2),
-    ]
-
-    offsets, spacings = _resolve_nozzle_layout(
-        parts,
-        same_spacing=True,
-        part_gap_12_x=5.0,
-        part_gap_12_y=1.5,
-        part_gap_23_x=0.0,
-        part_gap_23_y=0.0,
-    )
-
-    assert sorted(offsets) == [1, 2]
-    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
-    np.testing.assert_allclose(offsets[2], (17.0, 1.5))
-    assert spacings == [{"from": 1, "to": 2, "dx": 17.0, "dy": 1.5}]
-
-
-def test_same_spacing_reuses_first_pair_values_for_second_pair() -> None:
-    parts = [
-        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
-        _part(2, ((0.0, 0.0, 0.0), (4.0, 10.0, 1.0))),
-        _part(3, ((0.0, 0.0, 0.0), (6.0, 10.0, 1.0))),
-    ]
-
-    offsets, spacings = _resolve_nozzle_layout(
-        parts,
-        same_spacing=True,
-        part_gap_12_x=3.0,
-        part_gap_12_y=2.0,
-        part_gap_23_x=20.0,
-        part_gap_23_y=10.0,
-    )
-
-    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
-    np.testing.assert_allclose(offsets[2], (13.0, 2.0))
-    np.testing.assert_allclose(offsets[3], (20.0, 4.0))
-    assert spacings[0] == {"from": 1, "to": 2, "dx": 13.0, "dy": 2.0}
-    assert spacings[1] == {"from": 2, "to": 3, "dx": 7.0, "dy": 2.0}
-
-
-def test_individual_spacing_has_no_fixed_shape_limit() -> None:
-    parts = [
-        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
-        _part(2, ((0.0, 0.0, 0.0), (4.0, 10.0, 1.0))),
-        _part(3, ((0.0, 0.0, 0.0), (6.0, 10.0, 1.0))),
-        _part(4, ((0.0, 0.0, 0.0), (2.0, 10.0, 1.0))),
-        _part(5, ((0.0, 0.0, 0.0), (3.0, 10.0, 1.0))),
-        _part(6, ((0.0, 0.0, 0.0), (4.0, 10.0, 1.0))),
-        _part(7, ((0.0, 0.0, 0.0), (5.0, 10.0, 1.0))),
-    ]
-
-    offsets, spacings = _resolve_nozzle_layout(
-        parts,
-        False,
-        1.0,
-        0.0,
-        2.0,
-        3.0,
-        4.0,
-        -1.0,
-        6.0,
-        2.0,
-        1.0,
-        1.0,
-        -3.0,
-        0.5,
-    )
-
-    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
-    np.testing.assert_allclose(offsets[2], (11.0, 0.0))
-    np.testing.assert_allclose(offsets[3], (17.0, 3.0))
-    np.testing.assert_allclose(offsets[4], (27.0, 2.0))
-    np.testing.assert_allclose(offsets[7], (40.0, 5.5))
-    assert spacings[2] == {"from": 3, "to": 4, "dx": 10.0, "dy": -1.0}
-    assert spacings[5] == {"from": 6, "to": 7, "dx": 1.0, "dy": 0.5}
-
-
 def test_spacing_status_lists_all_nozzle_pair_distances() -> None:
     parts = [
         _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
         _part(2, ((0.0, 0.0, 0.0), (4.0, 10.0, 1.0))),
         _part(3, ((0.0, 0.0, 0.0), (6.0, 10.0, 1.0))),
     ]
-    offsets, spacings = _resolve_nozzle_layout(
-        parts,
-        same_spacing=True,
-        part_gap_12_x=3.0,
-        part_gap_12_y=2.0,
-        part_gap_23_x=20.0,
-        part_gap_23_y=10.0,
-    )
+    offsets = {1: (0.0, 0.0), 2: (13.0, 2.0), 3: (20.0, 4.0)}
+    spacings = [
+        {"from": 1, "to": 2, "dx": 13.0, "dy": 2.0},
+        {"from": 2, "to": 3, "dx": 7.0, "dy": 2.0},
+    ]
 
     status = _format_nozzle_spacing_status(parts, offsets, spacings)
 
@@ -255,6 +125,39 @@ def test_shape_settings_round_trip_contour_tracing_column() -> None:
     assert updated[0]["contour_tracing"] is True
 
 
+def test_shape_settings_round_trip_infill_column() -> None:
+    records = [
+        {
+            "idx": 1,
+            "name": "circle",
+            "stl_path": "circle.stl",
+            "target_x": 10.0,
+            "target_y": 11.0,
+            "target_z": 12.0,
+            "pressure": 25.0,
+            "valve": 4,
+            "nozzle": 1,
+            "port": 1,
+            "color": "#111111",
+            "contour_tracing": False,
+        }
+    ]
+
+    rows = _shape_settings_rows(records)
+    infill_pos = SHAPE_SETTINGS_HEADERS.index("Infill %")
+    assert rows[0][infill_pos] == 100.0
+
+    rows[0][infill_pos] = 50
+    updated = _apply_shape_settings(records, rows)
+    assert updated[0]["infill"] == 50.0
+
+    # Out-of-range values clamp to 0..100.
+    rows[0][infill_pos] = 250
+    assert _apply_shape_settings(records, rows)[0]["infill"] == 100.0
+    rows[0][infill_pos] = -10
+    assert _apply_shape_settings(records, rows)[0]["infill"] == 0.0
+
+
 def test_contour_tracing_sources_use_sliced_layer_stacks() -> None:
     from shapely.geometry import MultiPolygon, box
 
@@ -300,105 +203,234 @@ def test_sample_reload_appends_next_nozzle_set() -> None:
     assert [record["nozzle"] for record in second_load] == [1, 2, 3, 4, 5, 6]
 
 
-def test_simple_spacing_table_uses_one_shared_spacing_row() -> None:
-    records = [
-        {"idx": 1, "name": "first"},
-        {"idx": 2, "name": "second"},
-        {"idx": 3, "name": "third"},
+def _split_piece_records(
+    tmp_path,
+    columns: int = 2,
+    rows: int = 2,
+    use_reference_motion: bool = False,
+    overlapping_layers: bool = False,
+    raster_pattern: str | None = None,
+) -> list[dict]:
+    """Split a rectangle stack into grid pieces and generate real G-code."""
+    from shapely.geometry import MultiPolygon, box
+
+    from stl_slicer import LayerStack
+    from vector_gcode import generate_vector_gcode
+    from vector_toolpath import build_reference_stack, split_layer_stack_grid
+
+    layer = MultiPolygon([box(0.0, 0.0, 8.0, 6.0)])
+    stack = LayerStack(
+        layers=[layer, layer],
+        z_values=[0.5, 1.5],
+        bounds=((0.0, 0.0, 0.0), (8.0, 6.0, 2.0)),
+        layer_height=1.0,
+        name="source",
+    )
+    pieces = split_layer_stack_grid(
+        stack,
+        columns=columns,
+        rows=rows,
+        overlapping_layers=overlapping_layers,
+        overlap=1.0 if overlapping_layers else 0.0,
+    )
+    reference = build_reference_stack(pieces) if use_reference_motion else None
+
+    records: list[dict] = []
+    for index, piece in enumerate(pieces):
+        gcode_path = generate_vector_gcode(
+            piece,
+            shape_name=f"piece_{index}",
+            pressure=25,
+            valve=4 + index,
+            port=1,
+            fil_width=1.0,
+            motion=reference,
+            raster_pattern=raster_pattern,
+            output_dir=tmp_path / f"piece_{index}",
+        )
+        records.append(
+            {
+                "idx": index + 1,
+                "name": piece.name,
+                "nozzle": index + 1,
+                "color": "#000000",
+                "gcode_path": str(gcode_path),
+                "split_group_id": "split-a",
+                "split_index": index,
+                "split_row": index // columns + 1,
+                "split_col": index % columns + 1,
+                "split_rows": rows,
+                "split_columns": columns,
+            }
+        )
+    return records
+
+
+def _assert_aligned_offsets_reassemble(records: list[dict], spacing_rows, columns, rows) -> None:
+    """Offsets from the aligned table must equal each piece's world anchor + const."""
+    parts, _messages = _parts_from_records(records)
+    offsets, _spacings = _resolve_nozzle_grid_layout(
+        parts,
+        columns,
+        rows,
+        column_spacing=5.0,
+        row_spacing=5.0,
+        use_individual_spacing=True,
+        spacing_table=spacing_rows,
+    )
+    anchors = {part["nozzle"]: part["parsed"]["path_origin"] for part in parts}
+    constants = [
+        (offsets[nozzle][0] - anchors[nozzle][0], offsets[nozzle][1] - anchors[nozzle][1])
+        for nozzle in sorted(offsets)
     ]
+    for constant in constants[1:]:
+        assert abs(constant[0] - constants[0][0]) < 5e-4
+        assert abs(constant[1] - constants[0][1]) < 5e-4
 
-    update = _spacing_table_update(records, [["Shape 1", "Shape 2", 7.0, -1.5]], False)
-    gap12x, gap12y, gap23x, gap23y, extra = _spacing_args_from_table(update["value"], False)
 
-    assert update["headers"] == SIMPLE_NOZZLE_SPACING_HEADERS
-    assert update["value"] == [["Same spacing", "All neighboring nozzles", 7.0, -1.5]]
-    assert (gap12x, gap12y, gap23x, gap23y, extra) == (7.0, -1.5, 7.0, -1.5, [])
+def test_auto_align_reassembles_grid_split_pieces(tmp_path) -> None:
+    records = _split_piece_records(tmp_path, columns=2, rows=2)
 
+    spacing_rows, column_count, row_count, aligned_count, missing_count = (
+        _auto_align_grid_spacing_rows(records, 2, 2, 5.0, 5.0)
+    )
 
-def test_advanced_spacing_table_uses_named_nozzle_pairs() -> None:
-    records = [
-        {"idx": 1, "name": "first"},
-        {"idx": 2, "name": "second"},
-        {"idx": 3, "name": "third"},
-    ]
+    assert (column_count, row_count) == (2, 2)
+    assert aligned_count == 3
+    assert missing_count == 0
+    _assert_aligned_offsets_reassemble(records, spacing_rows, 2, 2)
 
-    update = _spacing_table_update(
-        records,
-        [["Same spacing", "All neighboring shapes", 4.0, 0.5], ["ignored", "ignored", 8.0, 1.0]],
-        True,
+
+def test_auto_align_handles_reference_motion_and_overlap(tmp_path) -> None:
+    records = _split_piece_records(
+        tmp_path,
+        columns=2,
+        rows=2,
+        use_reference_motion=True,
+        overlapping_layers=True,
     )
-    gap12x, gap12y, gap23x, gap23y, extra = _spacing_args_from_table(update["value"], True)
 
-    assert update["headers"] == ADVANCED_NOZZLE_SPACING_HEADERS
-    assert update["value"][0][:2] == ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2"]
-    assert update["value"][1][:2] == ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3"]
-    assert (gap12x, gap12y, gap23x, gap23y, extra) == (4.0, 0.5, 8.0, 1.0, [])
+    spacing_rows, _cc, _rc, aligned_count, missing_count = _auto_align_grid_spacing_rows(
+        records, 2, 2, 5.0, 5.0
+    )
 
+    assert aligned_count == 3
+    assert missing_count == 0
+    _assert_aligned_offsets_reassemble(records, spacing_rows, 2, 2)
 
-def test_advanced_spacing_table_collapses_duplicate_nozzles() -> None:
-    records = [
-        {"idx": 1, "name": "first", "nozzle": 1},
-        {"idx": 2, "name": "second", "nozzle": 1},
-        {"idx": 3, "name": "third", "nozzle": 2},
-    ]
 
-    update = _spacing_table_update(records, [["ignored", "ignored", 9.0, 2.5]], True)
+def test_auto_align_handles_y_raster_pattern(tmp_path) -> None:
+    records = _split_piece_records(
+        tmp_path,
+        columns=2,
+        rows=1,
+        raster_pattern=RASTER_PATTERN_Y_DIRECTION,
+    )
 
-    assert update["headers"] == ADVANCED_NOZZLE_SPACING_HEADERS
-    assert update["value"] == [["Nozzle 1: Shape 1, Shape 2", "Nozzle 2: Shape 3", 9.0, 2.5]]
+    spacing_rows, _cc, _rc, aligned_count, missing_count = _auto_align_grid_spacing_rows(
+        records, 2, 1, 5.0, 5.0
+    )
 
+    assert aligned_count == 1
+    assert missing_count == 0
+    _assert_aligned_offsets_reassemble(records, spacing_rows, 2, 1)
 
-def test_auto_align_split_offsets_follow_raster_axis() -> None:
-    assert _auto_align_split_offsets(RASTER_PATTERN_SAME_DIRECTION) == (-3.2, -0.8)
-    assert _auto_align_split_offsets(RASTER_PATTERN_Y_DIRECTION) == (-0.8, -3.2)
 
+def test_split_pieces_share_parent_scan_grid_so_column_gaps_equal_fil(tmp_path) -> None:
+    """User scenario: 4-column split + Y raster -> every aligned gap is one fil width.
 
-def test_auto_align_grid_spacing_only_targets_split_siblings() -> None:
-    records = [
-        {"idx": 1, "name": "first", "nozzle": 1, "split_group_id": "split-a", "split_index": 0},
-        {"idx": 2, "name": "second", "nozzle": 2, "split_group_id": "split-a", "split_index": 1},
-        {"idx": 3, "name": "third", "nozzle": 3},
-        {"idx": 4, "name": "fourth", "nozzle": 4, "split_group_id": "split-a", "split_index": 2},
-    ]
+    The parent width (7.9) is deliberately not a multiple of the fil width or
+    the cell width, so per-piece centred grids would drift out of phase at
+    every seam. With the shared parent scan grid the assembled columns run at
+    an exact fil pitch, so the world gap between adjacent pieces' toolpath
+    boxes is exactly one fil width.
+    """
+    from shapely.geometry import MultiPolygon, box
 
-    rows, column_count, row_count, aligned_count = _auto_align_grid_spacing_rows(
-        records,
-        columns=2,
-        rows=2,
-        column_spacing=10.0,
-        row_spacing=3.0,
-        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    from stl_slicer import LayerStack
+    from vector_gcode import generate_vector_gcode
+    from vector_toolpath import RASTER_PATTERN_Y_DIRECTION, split_layer_stack_grid
+
+    fil = 0.8
+    layer = MultiPolygon([box(0.0, 0.0, 7.9, 4.0)])
+    stack = LayerStack(
+        layers=[layer, layer],
+        z_values=[0.5, 1.5],
+        bounds=((0.0, 0.0, 0.0), (7.9, 4.0, 2.0)),
+        layer_height=1.0,
+        name="wide",
+    )
+    pieces = split_layer_stack_grid(stack, columns=4, rows=1)
+    records = []
+    for index, piece in enumerate(pieces):
+        gcode_path = generate_vector_gcode(
+            piece,
+            shape_name=f"col_{index}",
+            pressure=25,
+            valve=4 + index,
+            port=1,
+            fil_width=fil,
+            raster_pattern=RASTER_PATTERN_Y_DIRECTION,
+            output_dir=tmp_path / f"col_{index}",
+        )
+        records.append(
+            {
+                "idx": index + 1,
+                "name": piece.name,
+                "nozzle": index + 1,
+                "color": "#000000",
+                "gcode_path": str(gcode_path),
+                "split_group_id": "split-a",
+                "split_index": index,
+                "split_row": 1,
+                "split_col": index + 1,
+                "split_rows": 1,
+                "split_columns": 4,
+            }
+        )
+
+    spacing_rows, _cc, _rc, aligned_count, missing_count = _auto_align_grid_spacing_rows(
+        records, 4, 1, 5.0, 5.0
     )
 
-    assert column_count == 2
-    assert row_count == 2
-    assert aligned_count == 1
-    assert rows == [
-        ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", -3.2, 0.0],
-        ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", 0.0, 3.0],
-        ["Nozzle 3: Shape 3", "Nozzle 4: Shape 4", 10.0, 0.0],
-    ]
+    assert aligned_count == 3
+    assert missing_count == 0
+    # Adjacent columns continue the parent grid: every gap is exactly one fil.
+    assert [row[2] for row in spacing_rows] == [fil, fil, fil]
+    _assert_aligned_offsets_reassemble(records, spacing_rows, 4, 1)
+
+
+def test_auto_align_handles_spiral_patterns(tmp_path) -> None:
+    for pattern in (RASTER_PATTERN_RECTANGULAR_SPIRAL, RASTER_PATTERN_CIRCLE_SPIRAL):
+        records = _split_piece_records(
+            tmp_path / pattern.replace(" ", "_"),
+            columns=2,
+            rows=1,
+            raster_pattern=pattern,
+        )
+
+        spacing_rows, _cc, _rc, aligned_count, missing_count = (
+            _auto_align_grid_spacing_rows(records, 2, 1, 5.0, 5.0)
+        )
 
+        assert aligned_count == 1, pattern
+        assert missing_count == 0, pattern
+        _assert_aligned_offsets_reassemble(records, spacing_rows, 2, 1)
 
-def test_auto_align_grid_spacing_handles_split_row_transition() -> None:
+
+def test_auto_align_reports_missing_gcode_for_split_siblings(tmp_path) -> None:
     records = [
         {"idx": 1, "name": "first", "nozzle": 1, "split_group_id": "split-a", "split_index": 0},
         {"idx": 2, "name": "second", "nozzle": 2, "split_group_id": "split-a", "split_index": 1},
-        {"idx": 3, "name": "third", "nozzle": 3, "split_group_id": "split-a", "split_index": 2},
     ]
 
-    rows, _column_count, _row_count, aligned_count = _auto_align_grid_spacing_rows(
-        records,
-        columns=2,
-        rows=2,
-        column_spacing=10.0,
-        row_spacing=3.0,
-        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    rows, _column_count, _row_count, aligned_count, missing_count = (
+        _auto_align_grid_spacing_rows(records, 2, 1, 10.0, 3.0)
     )
 
-    assert aligned_count == 2
-    assert rows[0] == ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", -3.2, 0.0]
-    assert rows[1] == ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", 0.0, -0.8]
+    assert aligned_count == 0
+    assert missing_count == 1
+    assert rows == [["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 10.0, 0.0]]
 
 
 def test_auto_align_grid_spacing_skips_unsplit_records() -> None:
@@ -407,16 +439,12 @@ def test_auto_align_grid_spacing_skips_unsplit_records() -> None:
         {"idx": 2, "name": "second", "nozzle": 2},
     ]
 
-    rows, _column_count, _row_count, aligned_count = _auto_align_grid_spacing_rows(
-        records,
-        columns=2,
-        rows=1,
-        column_spacing=10.0,
-        row_spacing=3.0,
-        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    rows, _column_count, _row_count, aligned_count, missing_count = (
+        _auto_align_grid_spacing_rows(records, 2, 1, 10.0, 3.0)
     )
 
     assert aligned_count == 0
+    assert missing_count == 0
     assert rows == [["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 10.0, 0.0]]
 
 
@@ -530,7 +558,7 @@ def test_delete_shape_reindexes_without_losing_shape_data() -> None:
         {"idx": 3, "name": "last", "stl_path": "last.stl", "target_x": 30.0, "target_y": 31.0, "target_z": 32.0, "pressure": 35, "valve": 6, "port": 3, "color": "#333333"},
     ]
 
-    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), None, False, 0.0, Event())
+    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
     updated_records = outputs[1]
     updated_settings = outputs[2]
 
@@ -552,12 +580,10 @@ def test_delete_shape_cooldown_blocks_immediate_second_delete() -> None:
         {"idx": 3, "name": "last", "stl_path": "last.stl", "target_x": 30.0, "target_y": 31.0, "target_z": 32.0, "pressure": 35, "valve": 6, "port": 3, "color": "#333333"},
     ]
 
-    first_outputs = delete_shape_from_settings(records, _shape_settings_rows(records), None, False, 0.0, Event())
+    first_outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
     second_outputs = delete_shape_from_settings(
         first_outputs[1],
         first_outputs[2],
-        None,
-        False,
         first_outputs[-1],
         Event(),
     )

tests/test_vector_gcode.py

@@ -192,11 +192,13 @@ def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> No
     ]
 
     assert lines[0] == "G91"
-    assert lines[1] == "{aux_command}WAGO_ValveCommands(7, 0)"
-    assert lines[2] == "serialPort3.write(eval(setpress(25)))"
-    assert lines[3] == "serialPort3.write(eval(togglepress()))"
-    assert lines[4].startswith("{aux_command}WAGO_ValveCommands(")
+    # World anchor of the relative toolpath (origin at sweep start (-1, 0.5)).
+    assert lines[1] == "; PathOrigin X-1.0 Y0.5"
+    assert lines[2] == "{aux_command}WAGO_ValveCommands(7, 0)"
+    assert lines[3] == "serialPort3.write(eval(setpress(25)))"
+    assert lines[4] == "serialPort3.write(eval(togglepress()))"
     assert lines[5].startswith("{aux_command}WAGO_ValveCommands(")
+    assert lines[6].startswith("{aux_command}WAGO_ValveCommands(")
 
 
 def test_gcode_lead_in_runs_once_before_first_layer(tmp_path) -> None:
@@ -515,6 +517,109 @@ def test_circle_spiral_raster_reverses_between_layers(tmp_path) -> None:
     assert end_z == 1.0
 
 
+def _total_length(moves: list[dict]) -> float:
+    return sum(math.dist(move["start"][:2], move["end"][:2]) for move in moves)
+
+
+def _print_length(moves: list[dict]) -> float:
+    return sum(
+        math.dist(move["start"][:2], move["end"][:2])
+        for move in moves
+        if move["color"] == 255
+    )
+
+
+def test_half_infill_skips_alternate_lines_but_keeps_the_same_path(tmp_path) -> None:
+    layer = box(0.0, 0.0, 4.0, 4.0)
+    stack = _stack(layer, layer)
+
+    def _generate(infill: float, label: str):
+        path = generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            layer_height=1.0,
+            infill=infill,
+            output_dir=tmp_path / label,
+        )
+        return _moves_with_colors(path.read_text())
+
+    full = _generate(1.0, "full")
+    half = _generate(0.5, "half")
+
+    # Identical motion: same final position and same total traversed length.
+    assert full[-1]["end"] == half[-1]["end"]
+    assert abs(_total_length(full) - _total_length(half)) < 1e-6
+
+    # Half the lines dispense: 2 of the 4 sweeps per layer print.
+    assert abs(_print_length(half) - _print_length(full) / 2) < 1e-6
+
+    # The printing sweeps sit on alternating scanlines (one fil apart x2).
+    half_print_rows = sorted({round(m["start"][1], 6) for m in half if m["color"] == 255 and m["start"][2] == 0.0})
+    assert len(half_print_rows) == 2
+    assert abs((half_print_rows[1] - half_print_rows[0]) - 2.0) < 1e-9
+
+
+def test_infill_selection_is_shared_across_reference_motion(tmp_path) -> None:
+    small = _stack(box(0.0, 0.0, 2.0, 2.0), name="small")
+    big = _stack(box(0.0, 0.0, 4.0, 4.0), name="big")
+    reference = build_reference_stack([small, big])
+
+    def _generate(stack: LayerStack, infill: float, label: str):
+        path = generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            motion=reference,
+            infill=infill,
+            output_dir=tmp_path / label,
+        )
+        return _moves_with_colors(path.read_text())
+
+    sparse = _generate(small, 0.5, "sparse")
+    dense = _generate(big, 1.0, "dense")
+
+    # Different infill per shape, one shared motion path.
+    assert sparse[-1]["end"] == dense[-1]["end"]
+    assert abs(_total_length(sparse) - _total_length(dense)) < 1e-6
+    assert 0 < _print_length(sparse) < _print_length(dense)
+
+
+def test_spiral_infill_skips_rings_and_keeps_the_path(tmp_path) -> None:
+    layer = box(0.0, 0.0, 6.0, 6.0)
+    stack = _stack(layer)
+
+    def _generate(pattern: str, infill: float, label: str):
+        path = generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            raster_pattern=pattern,
+            infill=infill,
+            output_dir=tmp_path / label,
+        )
+        return _moves_with_colors(path.read_text())
+
+    for pattern in (RASTER_PATTERN_RECTANGULAR_SPIRAL, RASTER_PATTERN_CIRCLE_SPIRAL):
+        full = _generate(pattern, 1.0, f"{pattern}-full".replace(" ", "_"))
+        half = _generate(pattern, 0.5, f"{pattern}-half".replace(" ", "_"))
+        # Identical path within the writer's micron-level delta rounding
+        # (segment split points differ, so the rounding accumulates
+        # differently by up to ~1 um over tens of thousands of moves).
+        assert math.dist(full[-1]["end"], half[-1]["end"]) < 1e-4, pattern
+        assert abs(_total_length(full) - _total_length(half)) < 1e-3, pattern
+        assert 0 < _print_length(half) < _print_length(full), pattern
+
+
 def test_layer_contour_loops_follow_polygon_rings() -> None:
     hollow = MultiPolygon(
         [
@@ -753,6 +858,92 @@ def test_reference_motion_shares_path_and_gates_valve_per_shape(tmp_path) -> Non
     assert _print_length(small_moves) < _print_length(big_moves) / 2 + 4.0
 
 
+def test_reference_motion_contours_share_path_and_gate_valve_per_shape(tmp_path) -> None:
+    small = _stack(box(0.0, 0.0, 2.0, 2.0), name="small")
+    big = _stack(box(0.0, 0.0, 4.0, 4.0), name="big")
+    reference = build_reference_stack([small, big])
+    assert reference is not None
+    contour_sources = [
+        ContourSource(owner_idx=1, stack=small),
+        ContourSource(owner_idx=2, stack=big),
+    ]
+
+    def _generate(stack: LayerStack, owner: int, label: str):
+        path = generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            motion=reference,
+            contour_sources=contour_sources,
+            active_contour_owner=owner,
+            output_dir=tmp_path / label,
+        )
+        return _moves_with_colors(path.read_text())
+
+    small_moves = _generate(small, 1, "small")
+    big_moves = _generate(big, 2, "big")
+
+    # The motion including EVERY shape's contour tour is identical: same final
+    # position and same total traversed length for both heads.
+    assert small_moves[-1]["end"] == big_moves[-1]["end"]
+
+    def _total_length(moves: list[dict]) -> float:
+        return sum(math.dist(move["start"][:2], move["end"][:2]) for move in moves)
+
+    assert abs(_total_length(small_moves) - _total_length(big_moves)) < 1e-6
+
+    # In the shared frame (origin at the motion sweep start (-2, -0.5); big is
+    # re-centred to (-1,-1)..(3,3), small stays (0,0)..(2,2)):
+    small_corners = {(2.0, 0.5), (4.0, 0.5), (4.0, 2.5), (2.0, 2.5)}
+    big_corners = {(1.0, -0.5), (5.0, -0.5), (5.0, 3.5), (1.0, 3.5)}
+
+    def _endpoints(moves: list[dict], color: int) -> set[tuple[float, float]]:
+        return {
+            (round(move["end"][0], 6), round(move["end"][1], 6))
+            for move in moves
+            if move["color"] == color
+        }
+
+    # Each shape PRINTS its own outline and TRAVELS the other shape's outline.
+    assert small_corners <= _endpoints(small_moves, 255)
+    assert big_corners <= _endpoints(small_moves, 0)
+    assert big_corners <= _endpoints(big_moves, 255)
+    assert small_corners <= _endpoints(big_moves, 0)
+
+
+def test_solo_contours_still_trace_only_own_shape(tmp_path) -> None:
+    small = _stack(box(0.0, 0.0, 2.0, 2.0), name="small")
+    big = _stack(box(0.0, 0.0, 4.0, 4.0), name="big")
+    contour_sources = [
+        ContourSource(owner_idx=1, stack=small),
+        ContourSource(owner_idx=2, stack=big),
+    ]
+
+    gcode_path = generate_vector_gcode(
+        small,
+        shape_name="solo",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        contour_sources=contour_sources,
+        active_contour_owner=1,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    # Without reference motion the other shape's contour must NOT be traced:
+    # nothing ever moves outside the small shape's buffered footprint
+    # (origin at world (-1, 0.5), so relative x spans [0, 4], y [-0.5, 1.5];
+    # the big shape's contour would reach (5.0, 3.5)).
+    for move in moves:
+        assert -0.5 <= move["end"][0] <= 4.2
+        assert -1.0 <= move["end"][1] <= 2.0
+
+
 def test_build_reference_stack_unions_center_aligned_layers() -> None:
     first = _stack(box(0.0, 0.0, 2.0, 2.0), name="first")
     second = _stack(box(10.0, 10.0, 14.0, 14.0), name="second")
@@ -798,6 +989,76 @@ def test_split_layer_stack_grid_orders_rows_top_down() -> None:
     assert all(piece.layers[0].area == 4.0 for piece in pieces)
 
 
+def test_grid_split_pads_equal_whole_fil_cells() -> None:
+    # 20.0 / 4 = 5.0 mm cells, which is 6.25 fil widths — not representable.
+    # With `grid`, every cell rounds UP to 7 fils (5.6 mm) and the 2.4 mm
+    # leftover becomes blank margin split evenly outside the outer edges.
+    layer = box(0.0, 0.0, 20.0, 4.0)
+    stack = _stack(layer, name="wide")
+
+    pieces = split_layer_stack_grid(stack, columns=4, rows=1, grid=0.8)
+
+    widths = {round(piece.bounds[1][0] - piece.bounds[0][0], 6) for piece in pieces}
+    assert widths == {5.6}
+    # Padding is centred: 1.2 mm of blank space beyond each outer edge.
+    assert round(pieces[0].bounds[0][0], 6) == -1.2
+    assert round(pieces[-1].bounds[1][0], 6) == 21.2
+    # No material is lost or duplicated by the padded cells.
+    total_area = sum(piece.layers[0].area for piece in pieces)
+    assert abs(total_area - layer.area) < 1e-9
+
+
+def test_grid_split_reference_deltas_are_uniform() -> None:
+    from vector_toolpath import _centering_delta
+
+    layer = box(0.0, 0.0, 20.0, 4.0)
+    stack = _stack(layer, name="wide")
+    pieces = split_layer_stack_grid(stack, columns=4, rows=1, grid=0.8)
+    reference = build_reference_stack(pieces, grid=0.8)
+    assert reference is not None
+
+    deltas = [_centering_delta(piece, reference)[0] for piece in pieces]
+    diffs = {round(a - b, 6) for a, b in zip(deltas, deltas[1:])}
+    # Uniform spacing between every consecutive pair (one cell = 7 fils),
+    # so the physical nozzle offsets are the same for every connection.
+    assert diffs == {5.6}
+
+
+def test_split_overlap_seam_raster_distance_is_equal_on_both_sides() -> None:
+    from vector_toolpath import _axis_raster_segments
+
+    # 7.5 mm is deliberately not a multiple of the 1 mm fil width, so raster
+    # quantization leaves slack. The slack must be split evenly: both pieces'
+    # lines sit the same distance from the (shifted) cut on every layer.
+    layer = MultiPolygon([box(0.0, 0.0, 7.5, 4.0)])
+    stack = LayerStack(
+        layers=[layer, layer],
+        z_values=[0.5, 1.5],
+        bounds=((0.0, 0.0, 0.0), (7.5, 4.0, 2.0)),
+        layer_height=1.0,
+        name="seam",
+    )
+    left, right = split_layer_stack_grid(
+        stack, columns=2, rows=1, overlapping_layers=True, overlap=0.5
+    )
+
+    for layer_number in range(2):
+        left_columns = sorted(
+            {seg[0] for seg in _axis_raster_segments(
+                left.layers[layer_number], left.layers[layer_number], 1.0, "Y"
+            ) if seg[4] == 255}
+        )
+        right_columns = sorted(
+            {seg[0] for seg in _axis_raster_segments(
+                right.layers[layer_number], right.layers[layer_number], 1.0, "Y"
+            ) if seg[4] == 255}
+        )
+        seam = left.layers[layer_number].bounds[2]
+        left_distance = seam - left_columns[-1]
+        right_distance = right_columns[0] - seam
+        assert abs(left_distance - right_distance) < 1e-9
+
+
 def test_split_layer_stack_grid_overlap_alternates_between_layers() -> None:
     layer = box(0.0, 0.0, 4.0, 2.0)
     stack = _stack(layer, layer, name="interlock")

vector_gcode.py

@@ -22,8 +22,10 @@ from vector_toolpath import (
     RASTER_PATTERN_WOODPILE,
     RASTER_PATTERN_Y_DIRECTION,
     ContourSource,
+    _centering_delta,
     _lead_in_moves,
     _normalize_raster_pattern,
+    _scan_anchor,
     align_stack_to,
     build_contour_layers,
     plan_layer_moves,
@@ -107,6 +109,7 @@ def write_gcode_file(
     increase_pressure_per_layer: float,
     pressure_ramp_enabled: bool,
     all_g1: bool,
+    path_origin: tuple[float, float] | None = None,
 ) -> None:
     off_color = 0
     com_port = f"serialPort{port}"
@@ -120,6 +123,13 @@ def write_gcode_file(
 
     with open(gcode_path, "w") as f:
         f.write("G91\n")
+        if path_origin is not None:
+            # World anchor of the relative toolpath: absolute position (in the
+            # shape's own coordinate frame) of the point the moves start from.
+            # Lets tools place parallel parts so split pieces reassemble.
+            f.write(
+                f"; PathOrigin X{_coord(path_origin[0])} Y{_coord(path_origin[1])}\n"
+            )
         f.write(_valve_cmd(valve, 0))
         for line in setpress_lines:
             f.write(f"{line}\n")
@@ -186,6 +196,7 @@ def generate_vector_gcode(
     motion: LayerStack | None = None,
     contour_sources: list[ContourSource] | None = None,
     active_contour_owner: int | None = None,
+    infill: float = 1.0,
     increase_pressure_per_layer: float = 0.1,
     pressure_ramp_enabled: bool = True,
     all_g1: bool = False,
@@ -229,7 +240,20 @@ def generate_vector_gcode(
         reference=contour_reference,
     )
 
-    gcode_list = plan_layer_moves(
+    # Anchor the raster scan grid to the motion stack's frame (a split
+    # piece's frame is its parent shape's bounds) so lines stack across
+    # layers and stay on one continuous grid across split pieces.
+    frame_stack = motion if motion is not None else shape
+    if frame_stack.scan_frame is not None:
+        frame_x_min, frame_y_min, frame_x_max, frame_y_max = frame_stack.scan_frame
+    else:
+        (frame_x_min, frame_y_min, _fz), (frame_x_max, frame_y_max, _fz2) = frame_stack.bounds
+    scan_anchors = (
+        _scan_anchor(frame_x_min, frame_x_max, fil_width),
+        _scan_anchor(frame_y_min, frame_y_max, fil_width),
+    )
+
+    gcode_list, toolpath_origin = plan_layer_moves(
         motion_layers,
         valve_layers,
         fil_width,
@@ -237,8 +261,20 @@ def generate_vector_gcode(
         raster_pattern,
         contour_layers,
         active_contour_owner,
+        shared_motion=motion is not None,
+        scan_anchors=scan_anchors,
+        infill_fraction=max(0.0, min(1.0, float(infill))),
     )
 
+    # World anchor: the toolpath origin expressed in the shape's own frame.
+    # With reference motion the geometry was translated by the centering
+    # delta, so subtract it to get back to the shape's coordinates.
+    if motion is not None:
+        delta_x, delta_y = _centering_delta(shape, motion)
+    else:
+        delta_x = delta_y = 0.0
+    path_origin = (toolpath_origin[0] - delta_x, toolpath_origin[1] - delta_y)
+
     lead_in = _lead_in_moves(
         lead_in_enabled,
         lead_in_length,
@@ -267,5 +303,6 @@ def generate_vector_gcode(
         increase_pressure_per_layer=float(increase_pressure_per_layer),
         pressure_ramp_enabled=bool(pressure_ramp_enabled),
         all_g1=bool(all_g1),
+        path_origin=path_origin,
     )
     return gcode_path

vector_toolpath.py

@@ -227,12 +227,15 @@ def _classify_polyline(
     points: list[tuple[float, float]],
     valve: MultiPolygon,
     eps: float = EPS,
+    keep_point=None,
 ) -> list[Seg]:
     """Split a motion polyline at valve-boundary crossings and color the pieces.
 
     Preserves path order (a whole-polyline shapely intersection would not).
     Pieces on the boundary count as printing (`covers`), matching the raster
-    convention that boundary-grazing sweeps dispense.
+    convention that boundary-grazing sweeps dispense. `keep_point(x, y)` can
+    additionally veto dispensing for a piece (evaluated at its midpoint) —
+    used for partial infill; the motion is unaffected.
     """
     segments: list[Seg] = []
     has_valve = valve is not None and not valve.is_empty
@@ -270,7 +273,10 @@ def _classify_polyline(
             if (t1 - t0) * seg_len <= eps:
                 continue
             mid_x, mid_y = _point_along((t0 + t1) / 2.0, x0, y0, x1, y1)
-            color = 255 if valve.covers(Point(mid_x, mid_y)) else 0
+            dispensing = valve.covers(Point(mid_x, mid_y))
+            if dispensing and keep_point is not None:
+                dispensing = keep_point(mid_x, mid_y)
+            color = 255 if dispensing else 0
             start = _point_along(t0, x0, y0, x1, y1)
             end = _point_along(t1, x0, y0, x1, y1)
             _append_colored_segment(segments, *start, *end, color)
@@ -278,18 +284,68 @@ def _classify_polyline(
     return segments
 
 
-def _scan_coords(lo: float, hi: float, fil_width: float) -> list[float]:
-    """Scanline positions at half-fil_width offsets; always at least one line."""
-    if hi - lo < fil_width:
-        return [(lo + hi) / 2.0]
+def _infill_line_keep(fraction: float):
+    """Line-selection gate for partial infill; None means print every line.
 
-    coords: list[float] = []
-    value = lo + fil_width / 2.0
-    limit = hi - fil_width / 2.0 + 1e-9
-    while value <= limit:
-        coords.append(value)
-        value += fil_width
-    return coords
+    Uses a Bresenham-style distribution so kept lines spread evenly: line k
+    dispenses iff floor((k+1)*f) > floor(k*f). At f=0.5 every other line
+    prints; at f=1 all do; at f=0 none. `k` is a global grid index, so the
+    same lines are selected across layers, across split pieces sharing a
+    parent frame, and across shapes sharing reference motion — the motion
+    path itself is never affected.
+    """
+    if fraction >= 1.0:
+        return None
+    fraction = max(0.0, float(fraction))
+
+    def keep(line_index: int) -> bool:
+        return math.floor((line_index + 1) * fraction) - math.floor(line_index * fraction) >= 1
+
+    return keep
+
+
+def _scan_anchor(lo: float, hi: float, fil_width: float) -> float:
+    """First scanline position of the centred grid spanning [lo, hi].
+
+    The grid is centred: when the extent is not an exact multiple of
+    fil_width, the leftover slack is split evenly between both edges.
+    """
+    extent = hi - lo
+    if extent < fil_width:
+        return (lo + hi) / 2.0
+    count = int(math.floor(extent / fil_width + 1e-9))
+    slack = max(0.0, extent - count * fil_width)
+    return lo + slack / 2.0 + fil_width / 2.0
+
+
+def _scan_coords(
+    lo: float,
+    hi: float,
+    fil_width: float,
+    anchor: float | None = None,
+) -> list[float]:
+    """Scanline positions in [lo, hi], fil_width apart; at least one line.
+
+    Without `anchor` the set is centred in [lo, hi] (always at least one
+    line). With `anchor` the lines lie on the global grid
+    {anchor + k*fil_width}: grid-split pieces anchored to their parent's
+    frame then raster on one continuous line grid, so the assembled seams
+    keep an exact one-fil-width pitch instead of drifting by each piece's own
+    quantization slack. The interval is half-open at `hi` so a line exactly
+    on a cut belongs to exactly one piece, and a sliver too thin to contain a
+    grid line gets none — the neighbouring grid line (at most one fil away)
+    covers it with filament width.
+    """
+    if anchor is None:
+        anchor = _scan_anchor(lo, hi, fil_width)
+        if hi - lo < fil_width:
+            return [anchor]
+        count = int(math.floor((hi - lo) / fil_width + 1e-9))
+        return [anchor + index * fil_width for index in range(count)]
+
+    k_lo = math.ceil((lo - anchor) / fil_width - 1e-9)
+    k_hi = math.floor((hi - anchor) / fil_width - 1e-9)
+    return [anchor + k * fil_width for k in range(int(k_lo), int(k_hi) + 1)]
 
 
 def _axis_raster_segments(
@@ -299,13 +355,18 @@ def _axis_raster_segments(
     axis: str,
     reverse_order: bool = False,
     start_forward: bool = True,
+    scan_anchor: float | None = None,
+    infill_keep=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.
+    valve-settle travel buffer before and after. `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, just with the valve closed, so the motion never changes.
     """
     if motion is None or motion.is_empty:
         return []
@@ -316,10 +377,16 @@ def _axis_raster_segments(
     else:
         scan_lo, scan_hi = min_y, max_y
 
-    coords = _scan_coords(scan_lo, scan_hi, fil_width)
+    coords = _scan_coords(scan_lo, scan_hi, fil_width, anchor=scan_anchor)
     if reverse_order:
         coords = coords[::-1]
 
+    # Grid index base: orientation-independent, and shared across pieces when
+    # anchored to a common frame, so infill line selection lines up at seams.
+    index_base = scan_anchor if scan_anchor is not None else _scan_anchor(
+        scan_lo, scan_hi, fil_width
+    )
+
     segments: list[Seg] = []
     sweep_number = 0
     for coord in coords:
@@ -329,12 +396,17 @@ def _axis_raster_segments(
 
         sweep_lo = motion_runs[0][0]
         sweep_hi = motion_runs[-1][1]
-        valve_runs = []
-        for lo, hi in _chord_runs(valve, axis, coord):
-            lo = max(lo, sweep_lo)
-            hi = min(hi, sweep_hi)
-            if hi - lo > EPS:
-                valve_runs.append((lo, hi))
+        if infill_keep is not None and not infill_keep(
+            int(round((coord - index_base) / fil_width))
+        ):
+            valve_runs: list[tuple[float, float]] = []
+        else:
+            valve_runs = []
+            for lo, hi in _chord_runs(valve, axis, coord):
+                lo = max(lo, sweep_lo)
+                hi = min(hi, sweep_hi)
+                if hi - lo > EPS:
+                    valve_runs.append((lo, hi))
 
         def emit(a: float, b: float, color: int) -> None:
             if axis == "Y":
@@ -387,9 +459,13 @@ def _oriented_axis_raster_segments(
     current_x: float,
     current_y: float,
     prefer_default: bool = False,
+    scan_anchor: float | None = None,
+    infill_keep=None,
 ) -> list[Seg]:
     """Pick the raster orientation whose start is nearest the current position."""
-    default_segments = _axis_raster_segments(motion, valve, fil_width, axis)
+    default_segments = _axis_raster_segments(
+        motion, valve, fil_width, axis, scan_anchor=scan_anchor, infill_keep=infill_keep
+    )
     if prefer_default or not default_segments:
         return default_segments
 
@@ -403,6 +479,8 @@ def _oriented_axis_raster_segments(
                 axis,
                 reverse_order=reverse_order,
                 start_forward=start_forward,
+                scan_anchor=scan_anchor,
+                infill_keep=infill_keep,
             )
             if segments and segments not in candidates:
                 candidates.append(segments)
@@ -691,6 +769,29 @@ def _last_print_reference(output_list: list[dict]) -> tuple[float, float, float,
     return last_x, last_y, last_dx, last_dy
 
 
+def _last_motion_reference(output_list: list[dict]) -> tuple[float, float, float, float]:
+    """Endpoint and direction of the last XY move, regardless of valve state.
+
+    Used instead of `_last_print_reference` when shapes share a reference
+    motion path: anchoring contours off the valve state would give every
+    shape a different contour tour, breaking the shared path.
+    """
+    x = y = 0.0
+    last_x = last_y = 0.0
+    last_dx = last_dy = 0.0
+    for move in output_list:
+        dx = float(move.get("X", 0.0))
+        dy = float(move.get("Y", 0.0))
+        x += dx
+        y += dy
+        if "Z" not in move and (dx != 0.0 or dy != 0.0):
+            last_x = x
+            last_y = y
+            last_dx = dx
+            last_dy = dy
+    return last_x, last_y, last_dx, last_dy
+
+
 def _rewind_trailing_travel(
     output_list: list[dict],
     current_x: float,
@@ -763,39 +864,55 @@ def _append_layer_contours(
     active_owner_idx: int | None,
     origin_x: float = 0.0,
     origin_y: float = 0.0,
+    shared_motion: bool = False,
 ) -> tuple[float, float]:
     # `origin_x/origin_y` is the world position of the move list's start:
     # _last_print_reference sums relative moves from zero, so its result must
     # be shifted back into the world frame the contours live in.
+    #
+    # With `shared_motion` (reference-stack printing) every shape must trace
+    # EVERY source's contours in the same order so all parallel heads follow
+    # one identical path; the valve opens only on the active owner's contours.
+    # Anchoring then uses the last motion move instead of the last print, and
+    # the trailing-travel rewind is skipped — both depend on how the raster
+    # moves were split at valve boundaries, which differs per shape and would
+    # desynchronise the shared path.
     if layer_number >= len(contour_layers):
         return current_x, current_y
 
     active_sources = [
         source
         for source in contour_layers[layer_number]
-        if source.get("owner_idx") == active_owner_idx
+        if (shared_motion or source.get("owner_idx") == active_owner_idx)
         and any(len(contour) >= 2 for contour in source.get("contours", []))
     ]
     if not active_sources:
         return current_x, current_y
 
-    current_x, current_y = _rewind_trailing_travel(
-        output_list,
-        current_x,
-        current_y,
-    )
+    if not shared_motion:
+        current_x, current_y = _rewind_trailing_travel(
+            output_list,
+            current_x,
+            current_y,
+        )
 
     use_infill_reference = True
 
     for source in active_sources:
-        color = 255
+        if shared_motion and source.get("owner_idx") != active_owner_idx:
+            color = 0
+        else:
+            color = 255
         for contour in source.get("contours", []):
             if len(contour) < 2:
                 continue
             if use_infill_reference:
-                nearest_x, nearest_y, approach_dx, approach_dy = _last_print_reference(
-                    output_list
+                reference = (
+                    _last_motion_reference(output_list)
+                    if shared_motion
+                    else _last_print_reference(output_list)
                 )
+                nearest_x, nearest_y, approach_dx, approach_dy = reference
                 nearest_x += origin_x
                 nearest_y += origin_y
             else:
@@ -882,9 +999,25 @@ def plan_layer_moves(
     raster_pattern: str,
     contour_layers: list[list[dict]] | None = None,
     active_contour_owner: int | None = None,
-) -> list[dict]:
-    """Assemble per-layer segments into a relative move list for all patterns."""
+    shared_motion: bool = False,
+    scan_anchors: tuple[float, float] | None = None,
+    infill_fraction: float = 1.0,
+) -> tuple[list[dict], tuple[float, float]]:
+    """Assemble per-layer segments into a relative move list for all patterns.
+
+    `scan_anchors` = (x_anchor, y_anchor) pins the axis rasters' scanlines to
+    a global grid so lines stack across layers and across split pieces.
+
+    `infill_fraction` < 1 skips dispensing on evenly-distributed lines (grid
+    lines for axis rasters, rings/revolutions for spirals) while the motion
+    path stays exactly the same as at 100% infill.
+
+    Returns the move list and the toolpath origin — the world position the
+    relative moves start from (the first segment start of the first non-empty
+    layer). Callers need it to map relative G-code back into world space.
+    """
     raster_pattern = _normalize_raster_pattern(raster_pattern)
+    infill_keep = _infill_line_keep(infill_fraction)
     gcode_list: list[dict] = []
     current_x = 0.0
     current_y = 0.0
@@ -902,16 +1035,58 @@ def plan_layer_moves(
                 fil_width,
                 reverse=layer_number % 2 == 1,
             )
-            segments = _classify_polyline(points, valve)
+            keep_point = None
+            if infill_keep is not None:
+                # A spiral "line" is one revolution: revolution k lies at
+                # radius outer - k*fil from the bbox-circumscribed circle.
+                min_x, min_y, max_x, max_y = motion.bounds
+                center_x = (min_x + max_x) / 2.0
+                center_y = (min_y + max_y) / 2.0
+                outer_radius = max(
+                    math.hypot(cx - center_x, cy - center_y)
+                    for cx, cy in (
+                        (min_x, min_y),
+                        (max_x, min_y),
+                        (max_x, max_y),
+                        (min_x, max_y),
+                    )
+                )
+
+                def keep_point(x: float, y: float) -> bool:
+                    radius = math.hypot(x - center_x, y - center_y)
+                    return infill_keep(
+                        max(0, int(round((outer_radius - radius) / fil_width)))
+                    )
+
+            segments = _classify_polyline(points, valve, keep_point=keep_point)
         elif raster_pattern == RASTER_PATTERN_RECTANGULAR_SPIRAL:
             points = _rectangular_spiral_polyline(
                 motion.bounds,
                 fil_width,
                 reverse=layer_number % 2 == 1,
             )
-            segments = _classify_polyline(points, valve)
+            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
+                half = fil_width / 2.0
+                left, right = min_x + half, max_x - half
+                bottom, top = min_y + half, max_y - half
+
+                def keep_point(x: float, y: float) -> bool:
+                    inset = min(x - left, right - x, y - bottom, top - y)
+                    return infill_keep(max(0, int(round(inset / fil_width))))
+
+            segments = _classify_polyline(points, valve, keep_point=keep_point)
         else:
             raster_axis = _raster_axis_for_pattern(raster_pattern, layer_number)
+            if scan_anchors is None:
+                axis_anchor = None
+            else:
+                # Axis "X" sweeps along X with rows stacked in Y, so its
+                # scanlines use the Y anchor (and vice versa).
+                axis_anchor = scan_anchors[0] if raster_axis == "Y" else scan_anchors[1]
             segments = _oriented_axis_raster_segments(
                 motion,
                 valve,
@@ -920,6 +1095,8 @@ def plan_layer_moves(
                 current_x,
                 current_y,
                 prefer_default=not raster_origin_initialized,
+                scan_anchor=axis_anchor,
+                infill_keep=infill_keep,
             )
 
         if not segments:
@@ -935,6 +1112,7 @@ def plan_layer_moves(
                 active_contour_owner,
                 origin_x,
                 origin_y,
+                shared_motion,
             )
             current_x, current_y = _append_relative_move(
                 gcode_list,
@@ -1009,6 +1187,7 @@ def plan_layer_moves(
             active_contour_owner,
             origin_x,
             origin_y,
+            shared_motion,
         )
         current_x, current_y = _append_relative_move(
             gcode_list,
@@ -1019,7 +1198,7 @@ def plan_layer_moves(
             0,
         )
 
-    return gcode_list
+    return gcode_list, (origin_x, origin_y)
 
 
 def _stack_center(stack: LayerStack) -> tuple[float, float]:
@@ -1027,10 +1206,58 @@ def _stack_center(stack: LayerStack) -> tuple[float, float]:
     return ((x_min + x_max) / 2.0, (y_min + y_max) / 2.0)
 
 
+def _snap_to_grid(value: float, grid: float | None) -> float:
+    if not grid or grid <= 0.0:
+        return value
+    # Half-up, not Python's banker's rounding: values that differ by exact
+    # grid multiples must snap to results that differ by the same multiples
+    # (banker's rounds exact halves toward even, breaking that translation
+    # invariance and with it uniform split-piece spacing).
+    return math.floor(value / grid + 0.5 + 1e-9) * grid
+
+
 def _centering_delta(stack: LayerStack, reference: LayerStack) -> tuple[float, float]:
-    reference_x, reference_y = _stack_center(reference)
+    """Translation that aligns `stack` into `reference`'s shared frame.
+
+    Uses the alignment target and snap grid stamped on the reference by
+    `build_reference_stack`, so re-deriving the delta later reproduces the
+    exact translation the reference was built with. Snapping the delta to the
+    fil grid keeps every shape's world scan-grid phase intact, so split
+    pieces printed with shared reference motion still tile at an exact
+    one-fil-width line pitch.
+
+    Split siblings (stacks sharing the reference's scan frame) are aligned by
+    their cell corner within that frame instead of their centre: with cells
+    sized in whole grid multiples the deltas — and with them the required
+    nozzle spacing — come out uniform across all pieces, whereas snapping the
+    centres would wobble by up to one fil where the last cell's width (and so
+    its centre phase) differs.
+    """
+    grid = reference.align_grid
+    if (
+        grid
+        and stack.scan_frame is not None
+        and stack.scan_frame == reference.scan_frame
+    ):
+        (stack_min_x, stack_min_y, _sz), _stack_max = (
+            stack.bounds[0],
+            stack.bounds[1],
+        )
+        frame_min_x, frame_min_y = stack.scan_frame[0], stack.scan_frame[1]
+        return (
+            _snap_to_grid(frame_min_x - stack_min_x, grid),
+            _snap_to_grid(frame_min_y - stack_min_y, grid),
+        )
+
+    if reference.align_center is not None:
+        reference_x, reference_y = reference.align_center
+    else:
+        reference_x, reference_y = _stack_center(reference)
     center_x, center_y = _stack_center(stack)
-    return reference_x - center_x, reference_y - center_y
+    return (
+        _snap_to_grid(reference_x - center_x, grid),
+        _snap_to_grid(reference_y - center_y, grid),
+    )
 
 
 def align_stack_to(
@@ -1053,12 +1280,21 @@ def align_stack_to(
     return layers
 
 
-def build_reference_stack(stacks: list[LayerStack | None]) -> LayerStack | None:
+def build_reference_stack(
+    stacks: list[LayerStack | None],
+    grid: float | None = None,
+) -> LayerStack | None:
     """Union all shapes into one shared motion stack, bbox-centres aligned.
 
     Vector analog of the old centered "black wins" TIFF merge: every stack is
     translated so its XY bbox centre lands on the first stack's centre, then
     each layer is the union of the translated layers.
+
+    `grid` (the fil width) snaps each translation to grid multiples so every
+    shape's world scan-grid phase survives the alignment — required for split
+    pieces to keep an exact one-fil line pitch under shared reference motion.
+    The alignment target and grid are stamped on the result so later
+    `_centering_delta` calls reproduce the exact same translations.
     """
     valid = [stack for stack in stacks if stack is not None and stack.layers]
     if not valid:
@@ -1066,15 +1302,22 @@ def build_reference_stack(stacks: list[LayerStack | None]) -> LayerStack | None:
 
     n_layers = max(len(stack.layers) for stack in valid)
     reference_x, reference_y = _stack_center(valid[0])
+    target = LayerStack(
+        layers=[],
+        z_values=[],
+        bounds=((0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
+        layer_height=valid[0].layer_height,
+        scan_frame=valid[0].scan_frame,
+        align_center=(reference_x, reference_y),
+        align_grid=grid,
+    )
 
     layer_parts: list[list[MultiPolygon]] = [[] for _ in range(n_layers)]
     x_min = y_min = z_min = math.inf
     x_max = y_max = z_max = -math.inf
 
     for stack in valid:
-        center_x, center_y = _stack_center(stack)
-        delta_x = reference_x - center_x
-        delta_y = reference_y - center_y
+        delta_x, delta_y = _centering_delta(stack, target)
 
         (sx_min, sy_min, sz_min), (sx_max, sy_max, sz_max) = stack.bounds
         x_min = min(x_min, sx_min + delta_x)
@@ -1103,26 +1346,54 @@ def build_reference_stack(stacks: list[LayerStack | None]) -> LayerStack | None:
                 break
         z_values.append(z_value)
 
+    # The first stack's delta is zero (snap(0) == 0), so its scan frame is
+    # already in the shared frame and anchors the reference's scan grid.
     return LayerStack(
         layers=layers,
         z_values=z_values,
         bounds=((x_min, y_min, z_min), (x_max, y_max, z_max)),
         layer_height=valid[0].layer_height,
         name="reference",
+        scan_frame=valid[0].scan_frame,
+        align_center=(reference_x, reference_y),
+        align_grid=grid,
     )
 
 
-def _split_boundaries(
+def _base_split_edges(
     lo: float,
     hi: float,
     count: int,
+    grid: float | None = None,
+) -> list[float]:
+    """Cell edges for one axis: equal cells, padded to whole grid multiples.
+
+    With `grid` (the fil width), every cell gets the SAME width — the extent
+    divided by `count`, rounded UP to a whole number of grid units — and the
+    leftover becomes blank margin split evenly outside the shape's outer
+    edges. This is the vector analog of the old pixel splitter's padded
+    canvas: identical piece sizes, so the required nozzle spacing is one cell
+    everywhere, including under shared reference motion.
+    """
+    extent = hi - lo
+    if grid and grid > 0.0 and count > 1 and extent > 0.0:
+        units = max(1, math.ceil(extent / (count * grid) - 1e-9))
+        cell = units * grid
+        pad = cell * count - extent
+        start = lo - pad / 2.0
+        return [start + index * cell for index in range(count + 1)]
+    return [lo + index * extent / count for index in range(count + 1)]
+
+
+def _shifted_split_edges(
+    edges: list[float],
     layer_index: int,
     overlap: float,
 ) -> list[float]:
-    """Cell boundaries for one axis; interior ones alternate by ±overlap per layer."""
-    edges = [lo + index * (hi - lo) / count for index in range(count + 1)]
+    """Per-layer cell edges; interior ones alternate by ±overlap per layer."""
+    count = len(edges) - 1
     if overlap <= 0.0 or count <= 1:
-        return edges
+        return list(edges)
 
     adjusted = list(edges)
     for boundary_index in range(1, count):
@@ -1144,13 +1415,16 @@ def split_layer_stack_grid(
     rows: int,
     overlapping_layers: bool = False,
     overlap: float = 0.0,
+    grid: float | None = None,
 ) -> list[LayerStack]:
     """Split a sliced shape into a rows x columns grid of piece stacks.
 
     Pieces are returned row-major with row 1 the top strip (max-Y side),
     matching the legacy image-grid ordering. With `overlapping_layers`, the
     interior cut lines alternate by ±overlap between layers so neighbouring
-    pieces interlock. Piece `bounds` are the nominal (un-shifted) cell boxes.
+    pieces interlock. `grid` (the fil width) sizes the cells in whole grid
+    multiples (see `_base_split_edges`). Piece `bounds` are the nominal
+    (un-shifted) cell boxes.
     """
     columns = max(1, int(columns))
     rows = max(1, int(rows))
@@ -1159,17 +1433,22 @@ def split_layer_stack_grid(
     overlap_x = overlap if (overlapping_layers and columns > 1) else 0.0
     overlap_y = overlap if (overlapping_layers and rows > 1) else 0.0
 
-    base_x_edges = _split_boundaries(x_min, x_max, columns, 0, 0.0)
-    base_y_edges = _split_boundaries(y_min, y_max, rows, 0, 0.0)
+    base_x_edges = _base_split_edges(x_min, x_max, columns, grid)
+    base_y_edges = _base_split_edges(y_min, y_max, rows, grid)
     layer_x_edges = [
-        _split_boundaries(x_min, x_max, columns, index, overlap_x)
+        _shifted_split_edges(base_x_edges, index, overlap_x)
         for index in range(len(stack.layers))
     ]
     layer_y_edges = [
-        _split_boundaries(y_min, y_max, rows, index, overlap_y)
+        _shifted_split_edges(base_y_edges, index, overlap_y)
         for index in range(len(stack.layers))
     ]
 
+    # Pieces inherit the parent's scan frame so they all raster on ONE
+    # continuous line grid: the assembled seams then keep an exact
+    # one-fil-width pitch instead of each piece re-centring its own lines.
+    scan_frame = stack.scan_frame or (x_min, y_min, x_max, y_max)
+
     base_name = stack.name or "shape"
     pieces: list[LayerStack] = []
     for row_index in range(1, rows + 1):
@@ -1203,6 +1482,7 @@ def split_layer_stack_grid(
                     ),
                     layer_height=stack.layer_height,
                     name=f"{base_name}_r{row_index:02d}_c{col_index:02d}",
+                    scan_frame=scan_frame,
                 )
             )