Add vector G-code pipeline

README.md

@@ -5,12 +5,12 @@ sdk_version: 6.10.0
 python_version: "3.12"
 app_file: app.py
 fullWidth: true
-short_description: Upload STLs, export TIFF stacks, and generate G-code.
+short_description: Upload STLs, slice to vector outlines, and generate G-code.
 ---
 
 # STL to G-Code Gradio App
 
-This project provides a Gradio app that takes any number of uploaded STL files, shows a selected-shape 3D viewer, slices each model along the Z axis, saves slices as TIFF images, generates G-code from those TIFF stacks, previews the resulting tool path (a fast line plot or an animated 3D tube plot), and can visualize the shapes printing in parallel and export that animation as a GIF.
+This project provides a Gradio app that takes any number of uploaded STL files, shows a selected-shape 3D viewer, slices each model along the Z axis into per-layer vector outlines (shapely polygons), generates parallel-nozzle G-code directly from those outlines, previews the resulting tool path (a fast line plot or an animated 3D tube plot), and can visualize the shapes printing in parallel and export that animation as a GIF.
 
 ## Prerequisites
 
@@ -33,7 +33,7 @@ uv run gradio app.py
 
 When `app.py` changes, Gradio will automatically rerun the file and refresh the demo.
 
-Then open the local Gradio URL in your browser, upload STL files or load the bundled samples, and generate the TIFF stacks.
+Then open the local Gradio URL in your browser, upload STL files or load the bundled samples, and slice the shapes.
 
 ## What the app does
 
@@ -43,17 +43,14 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Shows an interactive selected-shape 3D viewer for rotating each model
 - Shows model extents, face count, vertex count, and watertight status
 - Scales loaded STLs from editable target X/Y/Z dimensions in the Shape Settings table; new rows default to the STL's original dimensions, **Reset Dimensions** restores them, and **Keep Proportions** updates the other target sides from the edited side
-- Keeps optional shape, TIFF, reference-stack, and nozzle-spacing previews in closed accordions to reduce clutter
-- Lets you choose layer height and XY pixel size
-- Produces one `.tif` image per slice
-- Encodes material as black (`0`) and empty space as white (`255`) in each TIFF slice
-- Lets you step through the slice stack in the browser
-- Exports a ZIP containing the generated TIFF images
-- Automatically combines generated stacks into a reference TIFF stack when TIFF stacks are generated
-- Splits one generated TIFF stack into an editable row/column grid for multi-nozzle printing of one large shape
-- Converts generated TIFF ZIPs into G-code files with pressure, valve, nozzle, and port settings per shape from the Shape Settings table
-- Appends a shape-optimized outer contour after each enabled shape layer by tracing that layer's active row envelope
-- Offers G-code generation options for raster pattern, **Use G1 for all moves** (no rapid travel command), and **Use Reference Stack for motion** (all shapes share one nozzle path; each dispenses only its own geometry)
+- Lets you choose layer height and filament/line width
+- 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
+- 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
 - 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
@@ -62,40 +59,42 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 
 ## Behavior and Implementation Notes
 
-### Reference TIFF Stack Alignment
+### Vector Slicing
 
-When you click **Generate TIFF Stacks**, the app automatically combines available TIFF stacks layer-by-layer into the Reference TIFF Stack. The **Generate Reference TIFF Stack** button can still rebuild it manually from the current shape stacks.
+Slicing uses `trimesh` cross-sections composed into shapely polygons (`slice_stl_to_layers` in `stl_slicer.py`). Each layer is a `MultiPolygon` in world-XY millimetres; the whole shape is a `LayerStack` (layers, z-values, bounds, layer height) held in the Gradio session state — no files are written until G-code is generated.
 
-- If source TIFFs have different dimensions, each layer is placed on a canvas using the largest width and height.
-- Layers are centered in X and Y before merging.
-- Pixel merge uses a black-wins rule: a pixel is black in the reference if any source has black at that pixel.
-- Alignment is centered image placement, not bottom-left anchoring.
-- If image-size differences are odd, centering may produce a one-pixel shift due to integer rounding.
+### Reference Layer Union
+
+When you click **Slice Shapes**, the app automatically unions the sliced shapes layer-by-layer into a combined reference layer set (used for shared-motion G-code).
+
+- Shapes are aligned by centering each shape's XY bounding box on a common center before the union.
+- Alignment is centered placement (in exact millimetres), not bottom-left anchoring.
 
 ### Multi-Nozzle Split
 
-The **Multi-Nozzle Split** accordion on the **STL to TIFF Slicer** tab can split one generated shape stack into a grid of print-ready stacks. Choose a source shape that already has TIFF slices, set the number of columns and rows, choose the starting nozzle and valve numbers, then click **Split Selected Shape into Grid Pieces**.
+The **Multi-Nozzle Split** accordion on the **Shapes & Slicing** tab can split one sliced shape into a grid of print-ready piece stacks. Choose a source shape that has been sliced, set the number of columns and rows, choose the starting nozzle and valve numbers, then click **Split Selected Shape into Grid Pieces**.
 
-- Each slice is padded with white pixels as needed, then split into equal-width columns and equal-height rows so every generated piece in the grid has a matching TIFF canvas.
+- Each layer's geometry is clipped against equal-size grid cells, so every piece keeps exact vector outlines.
 - The selected shape is replaced in Shape Settings by one generated record per grid cell, named by row and column.
-- Nozzle and valve numbers are assigned sequentially from the starting values, and the existing **TIFF Slices to GCode** tab can generate separate G-code for each piece.
+- Nozzle and valve numbers are assigned sequentially from the starting values, and the **Generate G-Code** tab can generate separate G-code for each piece.
+- **Overlapping Layers** alternates the interior cut lines by one filament width per layer so neighbouring pieces interlock.
 
 ### G-code XY Step Size
 
-- G-code generation uses the slicer's `Pixel Size/Fill Width` for XY step distance by passing `fil_width=pixel_size` into `generate_snake_path_gcode()`.
+- G-code generation uses the slicer tab's `Filament/Line Width` as the raster line spacing by passing `fil_width` into `generate_vector_gcode()`.
 
 ### G-code Output
 
 - Generated G-code starts in relative coordinate mode (`G91`).
 - `G0` is travel and `G1` is print/feed.
-- The app generates print/feed moves from material pixels and travel moves between material regions.
+- The app generates print/feed moves where the tool path is inside a shape's layer polygons and travel moves elsewhere.
 - Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port; the nozzle number controls layout/spacing assignment.
 - Pressure increases by `0.1` psi per layer by default.
 - **Use G1 for all moves**: when enabled, every movement line is emitted as `G1` (no `G0` rapid travel); the WAGO valve still marks where material is dispensed. Applies to all shapes.
-- **Use Reference Stack for motion**: when enabled, every shape's snake-path *motion* is taken from the combined Reference TIFF Stack while each shape's *valve/dispensing* comes from its own slices — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference stack is generated automatically with TIFF stacks; shapes are skipped with a message if it is missing.
-- **Raster Pattern**: `X-direction raster` keeps the existing X-direction back-and-forth raster on every layer. `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.
+- **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.
+- **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.
-- **Contour Tracing**: enabled per row in Shape Settings. The app uses the shape-optimized row-envelope tracer, travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer.
+- **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
 
@@ -115,7 +114,7 @@ The G-code visualization tab renders generated shape G-code or an uploaded `.txt
 
 ### Parallel Printing Visualization
 
-The fourth tab plots the generated shapes' G-code at once using the nozzle spacing configured on the TIFF-to-G-code tab, each in its own color. Shape Settings maps each STL to a nozzle number, so multiple shapes can share one nozzle offset while valves remain independent. Like the visualization tab it has a fast **Line Plot** and an animated **Tube Plot**; the animation advances all parts on a shared cumulative-path-length timeline, so a shorter part finishes first.
+The fourth tab plots the generated shapes' G-code at once using the nozzle spacing configured on the Generate G-Code tab, each in its own color. Shape Settings maps each STL to a nozzle number, so multiple shapes can share one nozzle offset while valves remain independent. Like the visualization tab it has a fast **Line Plot** and an animated **Tube Plot**; the animation advances all parts on a shared cumulative-path-length timeline, so a shorter part finishes first.
 
 It can also **export the animation as a GIF**, rendered server-side with Matplotlib (the `Agg` CPU backend — no WebGL, no headless browser, and no `ffmpeg`, so it works locally and on Hugging Face). The GIF is line-style with faint grey travel and white, black-outlined nozzle markers drawn on top; controls cover duration, frames per second, elevation/azimuth viewing angle, and travel opacity (0 hides travel).
 

app.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-import tempfile
 import math
+import tempfile
 import time
 import warnings
-import zipfile
 from pathlib import Path
 from typing import Any
 
@@ -20,7 +19,6 @@ warnings.filterwarnings(
 
 import gradio as gr
 import numpy as np
-from PIL import Image, ImageDraw, ImageFont
 import trimesh
 
 from gcode_viewer import (
@@ -31,22 +29,23 @@ from gcode_viewer import (
     parse_gcode_path,
 )
 from stl_slicer import (
-    SliceStack,
+    LayerStack,
     load_mesh,
     scale_factors_for_target_extents,
     scale_mesh,
-    slice_stl_to_tiffs,
+    slice_stl_to_layers,
 )
-from tiff_to_gcode import (
-    CONTOUR_MODE_ROW_ENVELOPE,
+from vector_gcode import generate_vector_gcode
+from vector_toolpath import (
     RASTER_PATTERN_CHOICES,
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_Y_DIRECTION,
-    generate_snake_path_gcode,
+    ContourSource,
+    build_reference_stack,
+    split_layer_stack_grid,
 )
 
 
-ViewerState = dict[str, Any]
 SAMPLE_STL_FILENAMES = ("Hollow_Pyramid.stl", "Rounded_Cube_Through_Holes.stl", "halfsphere.stl")
 SAMPLE_STL_DIR = Path(__file__).resolve().parent / "sample_stls"
 DEFAULT_TARGET_EXTENTS = (20.0, 20.0, 20.0)
@@ -783,54 +782,6 @@ PARALLEL_CONTROLS_HTML = """
 """
 
 
-def _read_slice_preview(path: str) -> Image.Image:
-    with Image.open(path) as image:
-        preview = image.copy()
-
-    # Upscale low-resolution TIFF previews so they fill the viewer area better.
-    min_display_side = 480
-    width, height = preview.size
-    max_dim = max(width, height)
-    if max_dim > 0 and max_dim < min_display_side:
-        scale = min_display_side / max_dim
-        new_size = (
-            max(1, int(round(width * scale))),
-            max(1, int(round(height * scale))),
-        )
-        preview = preview.resize(new_size, resample=Image.Resampling.NEAREST)
-
-    return preview
-
-
-def _empty_state() -> ViewerState:
-    return {
-        "tiff_paths": [],
-        "z_values": [],
-        "pixel_size": 0.0,
-        "x_min": 0.0,
-        "y_min": 0.0,
-        "image_width": 0,
-        "image_height": 0,
-    }
-
-
-def _reset_slider() -> dict[str, Any]:
-    return gr.update(minimum=0, maximum=0, value=0, step=1, interactive=False)
-
-
-def _stack_to_state(stack: SliceStack) -> ViewerState:
-    (x_min, y_min, _z_min), (_x_max, _y_max, _z_max) = stack.bounds
-    return {
-        "tiff_paths": [str(path) for path in stack.tiff_paths],
-        "z_values": stack.z_values,
-        "pixel_size": stack.pixel_size,
-        "x_min": x_min,
-        "y_min": y_min,
-        "image_width": stack.image_size[0],
-        "image_height": stack.image_size[1],
-    }
-
-
 def _format_model_details(
     source_name: str,
     mesh,
@@ -865,190 +816,6 @@ def _format_model_details(
     return "\n".join(lines)
 
 
-def _slice_label(state: ViewerState, index: int) -> str:
-    path = Path(state["tiff_paths"][index]).name
-    z_value = state["z_values"][index]
-    total = len(state["tiff_paths"])
-    return f"Slice {index + 1} / {total} | z = {z_value:.4f} | {path}"
-
-
-def _annotate_preview(
-    image: Image.Image,
-    pixel_size: float,
-    x_min: float,
-    y_min: float,
-    orig_width: int,
-    orig_height: int,
-) -> Image.Image:
-    """Draw a blue origin crosshair with axis labels and a scale bar."""
-    rgb = image.convert("RGB")
-    draw = ImageDraw.Draw(rgb)
-
-    preview_w, preview_h = rgb.size
-    scale_x = preview_w / orig_width if orig_width else 1.0
-    scale_y = preview_h / orig_height if orig_height else 1.0
-
-    BLUE = (50, 120, 255)
-
-    try:
-        font = ImageFont.load_default(size=14)
-    except TypeError:
-        font = ImageFont.load_default()
-    try:
-        small_font = ImageFont.load_default(size=12)
-    except TypeError:
-        small_font = font
-
-    # --- Origin crosshair & axis indicators ---
-    origin_px = (0.0 - x_min) / pixel_size
-    origin_py_from_bottom = (0.0 - y_min) / pixel_size
-    origin_img_y = orig_height - 1 - origin_py_from_bottom
-
-    ox = int(round(origin_px * scale_x))
-    oy = int(round(origin_img_y * scale_y))
-
-    arm = 20
-    margin_edge = 8  # inset from image border for off-screen indicators
-    on_screen = 0 <= ox < preview_w and 0 <= oy < preview_h
-
-    if on_screen:
-        # +X axis (rightward)
-        x_start = max(0, ox)
-        x_end = min(preview_w - 1, ox + arm)
-        if x_end > x_start:
-            draw.line([(x_start, oy), (x_end, oy)], fill=BLUE, width=2)
-            draw.polygon(
-                [(x_end, oy), (x_end - 5, oy - 4), (x_end - 5, oy + 4)],
-                fill=BLUE,
-            )
-            if x_end + 4 < preview_w:
-                draw.text((x_end + 4, oy - 7), "X", fill=BLUE, font=small_font)
-
-        # +Y axis (upward in world = upward in image)
-        y_end = max(0, oy - arm)
-        y_start = min(preview_h - 1, oy)
-        if y_start > y_end:
-            draw.line([(ox, y_start), (ox, y_end)], fill=BLUE, width=2)
-            draw.polygon(
-                [(ox, y_end), (ox - 4, y_end + 5), (ox + 4, y_end + 5)],
-                fill=BLUE,
-            )
-            if y_end - 16 >= 0:
-                draw.text((ox + 5, y_end - 16), "Y", fill=BLUE, font=small_font)
-
-        # -X stub (leftward from origin)
-        stub = min(8, max(0, ox))
-        if stub > 0:
-            draw.line([(ox - stub, oy), (ox, oy)], fill=BLUE, width=2)
-
-        # -Y stub (downward from origin in image)
-        stub_y = min(8, max(0, preview_h - 1 - oy))
-        if stub_y > 0:
-            draw.line([(ox, oy), (ox, oy + stub_y)], fill=BLUE, width=2)
-
-        # Origin label
-        lx = ox + arm + 4 if ox + arm + 40 < preview_w else ox - 45
-        ly = oy + 6
-        if 0 <= ly < preview_h:
-            draw.text((max(0, lx), ly), "(0, 0)", fill=BLUE, font=small_font)
-
-    else:
-        # Origin is off-screen — draw edge indicator(s) pointing toward it.
-        arrow_len = 14
-        arrow_half = 5
-
-        # Compute direction label text showing approximate origin coordinates
-        origin_x_mm = x_min
-        origin_y_mm = y_min
-        coord_text = f"Origin ({-origin_x_mm:+.1f}, {-origin_y_mm:+.1f})"
-
-        if ox < 0:
-            # Origin is to the LEFT — draw left-pointing arrow on left edge
-            ay = max(margin_edge + arrow_half, min(preview_h - margin_edge - arrow_half, oy))
-            draw.polygon(
-                [(margin_edge, ay), (margin_edge + arrow_len, ay - arrow_half), (margin_edge + arrow_len, ay + arrow_half)],
-                fill=BLUE,
-            )
-            draw.text((margin_edge + arrow_len + 4, ay - 7), coord_text, fill=BLUE, font=small_font)
-        elif ox >= preview_w:
-            # Origin is to the RIGHT
-            ay = max(margin_edge + arrow_half, min(preview_h - margin_edge - arrow_half, oy))
-            rx = preview_w - margin_edge
-            draw.polygon(
-                [(rx, ay), (rx - arrow_len, ay - arrow_half), (rx - arrow_len, ay + arrow_half)],
-                fill=BLUE,
-            )
-            tw = len(coord_text) * 7
-            draw.text((max(0, rx - arrow_len - tw - 4), ay - 7), coord_text, fill=BLUE, font=small_font)
-
-        if oy < 0:
-            # Origin is ABOVE — draw upward-pointing arrow on top edge
-            ax = max(margin_edge + arrow_half, min(preview_w - margin_edge - arrow_half, ox))
-            draw.polygon(
-                [(ax, margin_edge), (ax - arrow_half, margin_edge + arrow_len), (ax + arrow_half, margin_edge + arrow_len)],
-                fill=BLUE,
-            )
-        elif oy >= preview_h:
-            # Origin is BELOW — draw downward-pointing arrow on bottom edge
-            ax = max(margin_edge + arrow_half, min(preview_w - margin_edge - arrow_half, ox))
-            by = preview_h - margin_edge
-            draw.polygon(
-                [(ax, by), (ax - arrow_half, by - arrow_len), (ax + arrow_half, by - arrow_len)],
-                fill=BLUE,
-            )
-            # If we didn't already draw a left/right label, label here
-            if 0 <= ox < preview_w:
-                draw.text((ax + arrow_half + 4, by - arrow_len - 2), coord_text, fill=BLUE, font=small_font)
-
-    # --- Scale bar (bottom-left) ---
-    image_width_mm = orig_width * pixel_size
-    target_bar_mm = image_width_mm * 0.2
-    nice = [0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500]
-    bar_mm = min(nice, key=lambda v: abs(v - target_bar_mm))
-
-    bar_px = (bar_mm / pixel_size) * scale_x
-    margin = 12
-    bar_y = preview_h - margin
-    bar_x0 = margin
-    bar_x1 = bar_x0 + bar_px
-    cap = 5
-
-    draw.line([(int(bar_x0), int(bar_y)), (int(bar_x1), int(bar_y))], fill=BLUE, width=3)
-    draw.line([(int(bar_x0), int(bar_y - cap)), (int(bar_x0), int(bar_y + cap))], fill=BLUE, width=2)
-    draw.line([(int(bar_x1), int(bar_y - cap)), (int(bar_x1), int(bar_y + cap))], fill=BLUE, width=2)
-
-    bar_label = f"{bar_mm:g} mm"
-    draw.text((int(bar_x0), int(bar_y - 20)), bar_label, fill=BLUE, font=font)
-
-    return rgb
-
-
-def _render_selected_slice(state: ViewerState, index: int) -> tuple[str, Image.Image | None]:
-    tiff_paths = state.get("tiff_paths", [])
-    if not tiff_paths:
-        return "No slice stack loaded yet.", None
-
-    bounded_index = max(0, min(int(index), len(tiff_paths) - 1))
-    selected_path = tiff_paths[bounded_index]
-    preview = _read_slice_preview(selected_path)
-
-    pixel_size = state.get("pixel_size", 0.0)
-    if pixel_size and pixel_size > 0:
-        preview = _annotate_preview(
-            preview,
-            pixel_size=pixel_size,
-            x_min=state.get("x_min", 0.0),
-            y_min=state.get("y_min", 0.0),
-            orig_width=state.get("image_width", 0) or preview.size[0],
-            orig_height=state.get("image_height", 0) or preview.size[1],
-        )
-
-    return (
-        _slice_label(state, bounded_index),
-        preview,
-    )
-
-
 def _opacity_to_alpha(opacity: float) -> int:
     bounded = max(0.05, min(float(opacity), 1.0))
     return int(round(255 * bounded))
@@ -1383,10 +1150,6 @@ def load_single_model(
     return _viewer_update(glb_path), _format_model_details(Path(stl_file).name, mesh, scale_factors)
 
 
-def jump_to_slice(state: ViewerState, index: float) -> tuple[str, Image.Image | None]:
-    return _render_selected_slice(state, int(index))
-
-
 GCODE_SOURCE_UPLOAD = "Upload G-Code file"
 
 
@@ -1718,342 +1481,6 @@ def _format_nozzle_spacing_status(
     return "  \n".join(lines)
 
 
-def shift_slice(state: ViewerState, index: float, delta: int) -> tuple[int, str, Image.Image | None]:
-    tiff_paths = state.get("tiff_paths", [])
-    if not tiff_paths:
-        return 0, "No slice stack loaded yet.", None
-
-    new_index = max(0, min(int(index) + delta, len(tiff_paths) - 1))
-    label, preview = _render_selected_slice(state, new_index)
-    return new_index, label, preview
-
-
-def generate_reference_stack(
-    *states: ViewerState,
-    progress: gr.Progress = gr.Progress(),
-) -> tuple:
-    """Combine all available TIFF stacks into a single reference stack.
-
-    For each pixel in each layer the result is black (0) when *any* source
-    stack has a black pixel at that position, and white (255) only when *all*
-    sources are white.  Images of different sizes are centred on a canvas
-    sized to the largest dimensions.
-    """
-    active_states = [s for s in states if s.get("tiff_paths")]
-
-    if not active_states:
-        return (
-            _empty_state(),
-            _reset_slider(),
-            "No TIFF stacks available. Generate TIFF stacks first.",
-            None,
-        )
-
-    max_layers = max(len(s["tiff_paths"]) for s in active_states)
-
-    # Determine the largest image dimensions across all stacks.
-    max_width = 0
-    max_height = 0
-    source_sizes: list[tuple[int, int]] = []
-    for state in active_states:
-        w = state.get("image_width", 0)
-        h = state.get("image_height", 0)
-        if not w or not h:
-            with Image.open(state["tiff_paths"][0]) as img:
-                w, h = img.size
-        source_sizes.append((w, h))
-        max_width = max(max_width, w)
-        max_height = max(max_height, h)
-
-    # Compute annotation metadata from the first active state, accounting for
-    # the centering offset applied to its image on the larger canvas.
-    first = active_states[0]
-    first_w, first_h = source_sizes[0]
-    ref_pixel_size = first.get("pixel_size", 0.0)
-    x_off_first = (max_width - first_w) // 2
-    y_off_first = (max_height - first_h) // 2
-    ref_x_min = first.get("x_min", 0.0) - x_off_first * ref_pixel_size
-    ref_y_min = first.get("y_min", 0.0) - y_off_first * ref_pixel_size
-
-    output_dir = Path(tempfile.mkdtemp(prefix="reference_stack_"))
-    slices_dir = output_dir / "tiff_slices"
-    slices_dir.mkdir(parents=True, exist_ok=True)
-
-    tiff_paths: list[Path] = []
-    z_values: list[float] = []
-
-    for layer_idx in range(max_layers):
-        progress(
-            layer_idx / max_layers,
-            desc=f"Compositing reference layer {layer_idx + 1}/{max_layers}",
-        )
-
-        # Start with an all-white canvas.
-        ref_array = np.full((max_height, max_width), 255, dtype=np.uint8)
-
-        for state in active_states:
-            paths = state["tiff_paths"]
-            if layer_idx >= len(paths):
-                continue  # Stack exhausted – contributes white.
-
-            with Image.open(paths[layer_idx]) as img:
-                arr = np.asarray(img)
-
-            h, w = arr.shape[:2]
-            y_off = (max_height - h) // 2
-            x_off = (max_width - w) // 2
-
-            # Black (0) wins: pixel-wise minimum keeps any black pixel.
-            region = ref_array[y_off : y_off + h, x_off : x_off + w]
-            ref_array[y_off : y_off + h, x_off : x_off + w] = np.minimum(region, arr)
-
-        ref_image = Image.fromarray(ref_array, mode="L")
-        tiff_path = slices_dir / f"ref_slice_{layer_idx:04d}.tif"
-        ref_image.save(tiff_path, compression="tiff_deflate")
-        tiff_paths.append(tiff_path)
-
-        # Use z-value from the first active state that covers this layer.
-        z_val = 0.0
-        for state in active_states:
-            if layer_idx < len(state["z_values"]):
-                z_val = state["z_values"][layer_idx]
-                break
-        z_values.append(z_val)
-
-    ref_state: ViewerState = {
-        "tiff_paths": [str(p) for p in tiff_paths],
-        "z_values": z_values,
-        "pixel_size": ref_pixel_size,
-        "x_min": ref_x_min,
-        "y_min": ref_y_min,
-        "image_width": max_width,
-        "image_height": max_height,
-    }
-
-    label, preview = _render_selected_slice(ref_state, 0)
-    slider = gr.update(
-        minimum=0,
-        maximum=max(0, len(tiff_paths) - 1),
-        value=0,
-        step=1,
-        interactive=len(tiff_paths) > 1,
-    )
-
-    return ref_state, slider, label, preview
-
-
-def _zip_tiff_paths(tiff_paths: list[Path], zip_path: Path) -> None:
-    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
-        for tiff_path in tiff_paths:
-            archive.write(tiff_path, arcname=tiff_path.name)
-
-
-def _partition_length(length: int, count: int) -> list[tuple[int, int]]:
-    base = length // count
-    remainder = length % count
-    spans: list[tuple[int, int]] = []
-    start = 0
-    for index in range(count):
-        size = base + (1 if index < remainder else 0)
-        end = start + size
-        spans.append((start, end))
-        start = end
-    return spans
-
-
-def _padded_grid_axis(length: int, count: int) -> dict[str, Any]:
-    cell_size = max(1, math.ceil(length / count))
-    padded_length = cell_size * count
-    total_pad = padded_length - length
-    leading_pad = total_pad // 2
-    trailing_pad = total_pad - leading_pad
-    spans = [
-        (index * cell_size, (index + 1) * cell_size)
-        for index in range(count)
-    ]
-    return {
-        "cell_size": cell_size,
-        "padded_length": padded_length,
-        "leading_pad": leading_pad,
-        "trailing_pad": trailing_pad,
-        "spans": spans,
-    }
-
-
-def _layer_split_spans(length: int, count: int, layer_index: int, overlap_pixels: int) -> list[tuple[int, int]]:
-    base_spans = _partition_length(length, count)
-    if overlap_pixels <= 0 or count <= 1:
-        return base_spans
-
-    boundaries = [base_spans[0][0], *[end for _start, end in base_spans]]
-    adjusted = list(boundaries)
-    for boundary_index in range(1, len(boundaries) - 1):
-        direction = 1 if (layer_index + boundary_index) % 2 == 1 else -1
-        lower = adjusted[boundary_index - 1] + 1
-        upper = boundaries[boundary_index + 1] - 1
-        adjusted[boundary_index] = max(lower, min(upper, boundaries[boundary_index] + direction * overlap_pixels))
-    return [(adjusted[index], adjusted[index + 1]) for index in range(count)]
-
-
-def split_tiff_stack_grid(
-    state: ViewerState,
-    base_name: str = "split_shape",
-    columns: float = 2,
-    rows: float = 1,
-    overlapping_layers: bool | None = False,
-    progress: gr.Progress = gr.Progress(),
-) -> list[dict[str, Any]]:
-    tiff_paths = [Path(path) for path in state.get("tiff_paths", [])]
-    if not tiff_paths:
-        raise ValueError("Generate a TIFF stack for the selected shape before splitting it.")
-
-    with Image.open(tiff_paths[0]) as first_image:
-        width, height = first_image.size
-    column_count = max(1, _coerce_int(columns, 2))
-    row_count = max(1, _coerce_int(rows, 1))
-    if column_count > width:
-        raise ValueError(f"Cannot split {width}-pixel-wide TIFF slices into {column_count} columns.")
-    if row_count > height:
-        raise ValueError(f"Cannot split {height}-pixel-tall TIFF slices into {row_count} rows.")
-
-    safe_name = "".join(ch if ch.isalnum() or ch in {"-", "_"} else "_" for ch in base_name).strip("_") or "split_shape"
-    output_dir = Path(tempfile.mkdtemp(prefix=f"{safe_name}_split_"))
-    x_axis = _padded_grid_axis(width, column_count)
-    y_axis = _padded_grid_axis(height, row_count)
-    x_spans = x_axis["spans"]
-    y_spans = y_axis["spans"]
-    overlap_pixels = 1 if overlapping_layers else 0
-    overlap_x = overlap_pixels if column_count > 1 else 0
-    overlap_y = overlap_pixels if row_count > 1 else 0
-    padded_width = int(x_axis["padded_length"])
-    padded_height = int(y_axis["padded_length"])
-    working_width = padded_width + (2 * overlap_x)
-    working_height = padded_height + (2 * overlap_y)
-    source_x = int(x_axis["leading_pad"]) + overlap_x
-    source_y = int(y_axis["leading_pad"]) + overlap_y
-    working_x_min = base_x_min = float(state.get("x_min", 0.0) or 0.0)
-    working_y_min = base_y_min = float(state.get("y_min", 0.0) or 0.0)
-    pixel_size = float(state.get("pixel_size", 0.0) or 0.0)
-    working_x_min = base_x_min - (source_x * pixel_size)
-    working_y_min = base_y_min - ((int(y_axis["trailing_pad"]) + overlap_y) * pixel_size)
-    pieces: list[dict[str, Any]] = []
-    for row_index, (y_start, y_end) in enumerate(y_spans, start=1):
-        for col_index, (x_start, x_end) in enumerate(x_spans, start=1):
-            piece_dir = output_dir / f"r{row_index:02d}_c{col_index:02d}_tiff_slices"
-            piece_dir.mkdir(parents=True, exist_ok=True)
-            pieces.append({
-                "row": row_index,
-                "col": col_index,
-                "x_start": x_start,
-                "x_end": x_end,
-                "y_start": y_start,
-                "y_end": y_end,
-                "tiff_dir": piece_dir,
-                "tiff_paths": [],
-            })
-
-    for index, source_path in enumerate(tiff_paths):
-        progress(index / max(len(tiff_paths), 1), desc=f"Splitting layer {index + 1}/{len(tiff_paths)}")
-        with Image.open(source_path) as image:
-            layer = image.convert("L")
-            if layer.size != (width, height):
-                raise ValueError("All TIFF slices must have the same dimensions to split the stack.")
-
-            padded_layer = Image.new("L", (working_width, working_height), 255)
-            padded_layer.paste(layer, (source_x, source_y))
-            layer_x_spans = [
-                (x_start + overlap_x, x_end + overlap_x)
-                for x_start, x_end in _layer_split_spans(
-                    padded_width,
-                    column_count,
-                    index,
-                    overlap_x,
-                )
-            ]
-            layer_y_spans = [
-                (y_start + overlap_y, y_end + overlap_y)
-                for y_start, y_end in _layer_split_spans(
-                    padded_height,
-                    row_count,
-                    index,
-                    overlap_y,
-                )
-            ]
-            for piece in pieces:
-                canvas_x_start = piece["x_start"]
-                canvas_x_end = piece["x_end"]
-                canvas_y_start = piece["y_start"]
-                canvas_y_end = piece["y_end"]
-                if overlapping_layers:
-                    canvas_x_start -= overlap_x
-                    canvas_x_end += overlap_x
-                    canvas_y_start -= overlap_y
-                    canvas_y_end += overlap_y
-                canvas_x_start += overlap_x
-                canvas_x_end += overlap_x
-                canvas_y_start += overlap_y
-                canvas_y_end += overlap_y
-                x_start, x_end = layer_x_spans[piece["col"] - 1]
-                y_start, y_end = layer_y_spans[piece["row"] - 1]
-                if overlapping_layers:
-                    piece_image = Image.new("L", (canvas_x_end - canvas_x_start, canvas_y_end - canvas_y_start), 255)
-                    piece_image.paste(
-                        padded_layer.crop((x_start, y_start, x_end, y_end)),
-                        (x_start - canvas_x_start, y_start - canvas_y_start),
-                    )
-                else:
-                    piece_image = padded_layer.crop((x_start, y_start, x_end, y_end))
-                piece_path = piece["tiff_dir"] / f"slice_{index:04d}.tif"
-                piece_image.save(piece_path, compression="tiff_deflate")
-                piece["tiff_paths"].append(piece_path)
-
-    z_values = list(state.get("z_values", []))
-    if len(z_values) < len(tiff_paths):
-        z_values.extend([0.0] * (len(tiff_paths) - len(z_values)))
-
-    for piece in pieces:
-        canvas_x_start = piece["x_start"]
-        canvas_x_end = piece["x_end"]
-        canvas_y_start = piece["y_start"]
-        canvas_y_end = piece["y_end"]
-        if overlapping_layers:
-            canvas_x_start -= overlap_x
-            canvas_x_end += overlap_x
-            canvas_y_start -= overlap_y
-            canvas_y_end += overlap_y
-        canvas_x_start += overlap_x
-        canvas_x_end += overlap_x
-        canvas_y_start += overlap_y
-        canvas_y_end += overlap_y
-        piece_width = canvas_x_end - canvas_x_start
-        piece_height = canvas_y_end - canvas_y_start
-        zip_path = output_dir / f"{safe_name}_r{piece['row']:02d}_c{piece['col']:02d}_tiff_slices.zip"
-        _zip_tiff_paths(piece["tiff_paths"], zip_path)
-        piece_state: ViewerState = {
-            "tiff_paths": [str(path) for path in piece["tiff_paths"]],
-            "z_values": z_values[: len(piece["tiff_paths"])],
-            "pixel_size": pixel_size,
-            "x_min": working_x_min + (canvas_x_start * pixel_size),
-            "y_min": working_y_min + ((working_height - canvas_y_end) * pixel_size),
-            "image_width": piece_width,
-            "image_height": piece_height,
-            "zip_path": str(zip_path),
-            "overlapping_layers": bool(overlapping_layers),
-        }
-        piece["state"] = piece_state
-        piece["zip_path"] = zip_path
-    return pieces
-
-
-def split_tiff_stack_left_right(
-    state: ViewerState,
-    base_name: str = "split_shape",
-    progress: gr.Progress = gr.Progress(),
-) -> tuple[ViewerState, ViewerState, Path, Path]:
-    pieces = split_tiff_stack_grid(state, base_name=base_name, columns=2, rows=1, progress=progress)
-    return pieces[0]["state"], pieces[1]["state"], pieces[0]["zip_path"], pieces[1]["zip_path"]
-
-
 SHAPE_SETTINGS_HEADERS = [
     "Shape",
     "STL",
@@ -2234,8 +1661,8 @@ def _records_from_files(files: Any, previous_records: list[dict] | None = None)
             "port": previous.get("port", 1),
             "color": previous.get("color", _default_color(index)),
             "contour_tracing": previous.get("contour_tracing", False),
-            "tiff_state": previous.get("tiff_state", _empty_state()),
-            "zip_path": previous.get("zip_path"),
+            "layer_stack": previous.get("layer_stack"),
+            "slice_params": previous.get("slice_params"),
             "gcode_path": previous.get("gcode_path"),
         })
     return records
@@ -2697,7 +2124,6 @@ def sync_uploaded_shapes(
         _dropdown_update(next_records),
         _gcode_dropdown_update(next_records),
         _gcode_dropdown_update(next_records, include_upload=True),
-        [record.get("zip_path") for record in next_records if record.get("zip_path")],
         [record.get("gcode_path") for record in next_records if record.get("gcode_path")],
     )
 
@@ -2741,7 +2167,6 @@ def _shape_delete_outputs(
         _dropdown_update(records),
         _gcode_dropdown_update(records),
         _gcode_dropdown_update(records, include_upload=True),
-        [record.get("zip_path") for record in records if record.get("zip_path")],
         [record.get("gcode_path") for record in records if record.get("gcode_path")],
         float(last_delete_at or 0.0),
     )
@@ -2889,9 +2314,9 @@ def show_selected_model(
     records = _apply_shape_settings(records or [], settings_table)
     pos = _selected_record_index(records, selected)
     if pos < 0:
-        return _viewer_update(None), "No model loaded.", _reset_slider(), "No slice stack loaded yet.", None
+        return _viewer_update(None), "No model loaded."
     record = records[pos]
-    viewer, details = load_single_model(
+    return load_single_model(
         record.get("stl_path"),
         opacity,
         True,
@@ -2900,185 +2325,89 @@ def show_selected_model(
         record.get("target_y"),
         record.get("target_z"),
     )
-    state = record.get("tiff_state") or _empty_state()
-    label, preview = _render_selected_slice(state, 0)
-    slider = gr.update(
-        minimum=0,
-        maximum=max(0, len(state.get("tiff_paths", [])) - 1),
-        value=0,
-        step=1,
-        interactive=len(state.get("tiff_paths", [])) > 1,
-    )
-    return viewer, details, slider, label, preview
 
 
-def jump_to_selected_slice(records: list[dict] | None, selected: str | None, index: float) -> tuple[str, Image.Image | None]:
-    pos = _selected_record_index(records or [], selected)
-    if pos < 0:
-        return "No slice stack loaded yet.", None
-    return _render_selected_slice((records or [])[pos].get("tiff_state") or _empty_state(), int(index))
+def _slice_params_snapshot(record: dict, layer_height: float, scale_mode: str | None) -> dict:
+    return {
+        "layer_height": float(layer_height),
+        "scale_mode": _normalize_scale_mode(scale_mode),
+        "target_x": record.get("target_x"),
+        "target_y": record.get("target_y"),
+        "target_z": record.get("target_z"),
+    }
 
 
-def shift_selected_slice(records: list[dict] | None, selected: str | None, index: float, delta: int) -> tuple:
-    pos = _selected_record_index(records or [], selected)
-    if pos < 0:
-        return gr.update(value=0), "No slice stack loaded yet.", None
-    state = (records or [])[pos].get("tiff_state") or _empty_state()
-    paths = state.get("tiff_paths", [])
-    if not paths:
-        return gr.update(value=0), "No slice stack loaded yet.", None
-    next_index = max(0, min(int(index) + delta, len(paths) - 1))
-    label, preview = _render_selected_slice(state, next_index)
-    return gr.update(value=next_index), label, preview
-
-
-def _tiff_preview_update(records: list[dict], selected: str | None = None) -> tuple[dict[str, Any], dict[str, Any], str, Image.Image | None]:
-    dropdown = _dropdown_update(records, selected)
-    selected_value = dropdown.get("value") if isinstance(dropdown, dict) else selected
-    pos = _selected_record_index(records, selected_value)
-    state = (records[pos].get("tiff_state") if pos >= 0 else None) or _empty_state()
-    label, preview = _render_selected_slice(state, 0)
-    slider = gr.update(
-        minimum=0,
-        maximum=max(0, len(state.get("tiff_paths", [])) - 1),
-        value=0,
-        step=1,
-        interactive=len(state.get("tiff_paths", [])) > 1,
+def _slice_record(
+    record: dict,
+    layer_height: float,
+    scale_mode: str | None,
+    progress_callback=None,
+) -> LayerStack:
+    stl_path = record["stl_path"]
+    mesh = load_mesh(stl_path)
+    scale_factors = _resolve_mesh_scale_factors(
+        mesh,
+        True,
+        scale_mode,
+        record.get("target_x"),
+        record.get("target_y"),
+        record.get("target_z"),
+    )
+    stack = slice_stl_to_layers(
+        stl_path,
+        layer_height=float(layer_height),
+        progress_callback=progress_callback,
+        scale_factors=scale_factors,
+        name=str(record.get("name") or Path(stl_path).stem),
     )
-    return dropdown, slider, label, preview
+    record["layer_stack"] = stack
+    record["slice_params"] = _slice_params_snapshot(record, layer_height, scale_mode)
+    return stack
 
 
-def generate_dynamic_stacks(
+def generate_dynamic_layer_stacks(
     records: list[dict] | None,
     settings_table: Any,
     layer_height: float,
-    pixel_size: float,
     scale_mode: str | None,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     if not records:
-        return (
-            records,
-            [],
-            "Upload at least one STL first.",
-            _dropdown_update(records),
-            _reset_slider(),
-            "No slice stack loaded yet.",
-            None,
-            _empty_state(),
-            _reset_slider(),
-            "No reference stack generated yet.",
-            None,
-        )
+        return records, "Upload at least one STL first.", None
     total = len(records)
     messages: list[str] = []
     for pos, record in enumerate(records):
         stl_path = record.get("stl_path")
         if not stl_path:
-            messages.append(f"Shape {record['idx']}: skipped (no STL file).")
+            if record.get("layer_stack") is not None:
+                messages.append(f"Shape {record['idx']}: kept existing split-piece slices.")
+            else:
+                messages.append(f"Shape {record['idx']}: skipped (no STL file).")
             continue
 
         def report_progress(cur: int, tot: int, offset: int = pos) -> None:
             progress((offset + cur / tot) / total, desc=f"Slicing shape {offset + 1} of {total}...")
 
-        mesh = load_mesh(stl_path)
-        scale_factors = _resolve_mesh_scale_factors(
-            mesh,
-            True,
-            scale_mode,
-            record.get("target_x"),
-            record.get("target_y"),
-            record.get("target_z"),
-        )
         try:
-            stack = slice_stl_to_tiffs(
-                stl_path,
-                layer_height=float(layer_height),
-                pixel_size=float(pixel_size),
-                progress_callback=report_progress,
-                scale_factors=scale_factors,
+            stack = _slice_record(record, layer_height, scale_mode, report_progress)
+            (x_min, y_min, _z_min), (x_max, y_max, _z_max) = stack.bounds
+            messages.append(
+                f"Shape {record['idx']}: sliced {len(stack.layers)} layers "
+                f"(footprint {x_max - x_min:.2f} x {y_max - y_min:.2f} mm)."
             )
-            record["tiff_state"] = _stack_to_state(stack)
-            record["zip_path"] = str(stack.zip_path)
-            messages.append(f"Shape {record['idx']}: wrote `{stack.zip_path.name}`.")
         except Exception as exc:
             messages.append(f"Shape {record['idx']}: failed ({exc}).")
-    ref_state, ref_slider, ref_label, ref_preview = generate_dynamic_reference_stack(records, progress=progress)
-    if (ref_state or {}).get("tiff_paths"):
-        messages.append("Reference TIFF Stack: updated automatically.")
+    ref_layers = generate_dynamic_reference_stack(records)
+    if ref_layers is not None:
+        messages.append("Reference layers: updated automatically.")
     else:
-        messages.append("Reference TIFF Stack: skipped (no generated shape slices available).")
-    selected_update, slider, label, preview = _tiff_preview_update(records)
-    return (
-        records,
-        [record.get("zip_path") for record in records if record.get("zip_path")],
-        "\n".join(messages),
-        selected_update,
-        slider,
-        label,
-        preview,
-        ref_state,
-        ref_slider,
-        ref_label,
-        ref_preview,
-    )
-
-
-def generate_dynamic_reference_stack(records: list[dict] | None, progress: gr.Progress = gr.Progress()) -> tuple:
-    states = [record.get("tiff_state") or _empty_state() for record in (records or [])]
-    return generate_reference_stack(*states, progress=progress)
-
+        messages.append("Reference layers: skipped (no sliced shapes available).")
+    return records, "\n".join(messages), ref_layers
 
-def _split_piece_choice(piece: dict[str, Any]) -> str:
-    return f"R{piece['row']} C{piece['col']}"
 
-
-def _split_piece_dropdown_update(pieces: list[dict[str, Any]], selected: str | None = None) -> dict[str, Any]:
-    choices = [_split_piece_choice(piece) for piece in pieces]
-    value = selected if selected in choices else (choices[0] if choices else None)
-    return gr.update(choices=choices, value=value)
-
-
-def _selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None) -> dict[str, Any] | None:
-    if not pieces:
-        return None
-    for piece in pieces:
-        if _split_piece_choice(piece) == selected:
-            return piece
-    return pieces[0]
-
-
-def preview_selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None) -> tuple:
-    piece = _selected_split_piece(pieces, selected)
-    if not piece:
-        return _reset_slider(), "No split stack generated yet.", None
-    state = piece.get("state") or _empty_state()
-    label, preview = _render_selected_slice(state, 0)
-    slider = gr.update(
-        minimum=0,
-        maximum=max(0, len(state.get("tiff_paths", [])) - 1),
-        value=0,
-        step=1,
-        interactive=len(state.get("tiff_paths", [])) > 1,
-    )
-    return slider, label, preview
-
-
-def jump_to_selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None, index: float) -> tuple:
-    piece = _selected_split_piece(pieces, selected)
-    if not piece:
-        return "No split stack generated yet.", None
-    return _render_selected_slice(piece.get("state") or _empty_state(), int(index))
-
-
-def shift_selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None, index: float, delta: int) -> tuple:
-    piece = _selected_split_piece(pieces, selected)
-    if not piece:
-        return gr.update(value=0), "No split stack generated yet.", None
-    state = piece.get("state") or _empty_state()
-    new_index, label, preview = shift_slice(state, index, delta)
-    return gr.update(value=new_index), label, preview
+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 split_selected_shape_for_grid(
@@ -3092,153 +2421,138 @@ def split_selected_shape_for_grid(
     overlapping_layers: bool,
     starting_nozzle: float,
     starting_valve: float,
-    progress: gr.Progress = gr.Progress(),
+    fil_width: float,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
-    if not records:
-        empty = _empty_state()
+
+    def _outputs(next_records: list[dict], selected_value: str | None, status: str) -> tuple:
         return (
-            records,
-            _shape_settings_rows(records),
-            _spacing_table_update(records, existing_spacing, use_individual_spacing),
-            _dropdown_update(records),
-            _reset_slider(),
-            "No slice stack loaded yet.",
-            None,
-            [],
-            [],
-            _gcode_dropdown_update(records),
-            _gcode_dropdown_update(records, include_upload=True),
-            _dropdown_update(records),
-            [],
-            [],
-            _split_piece_dropdown_update([]),
-            _reset_slider(),
-            "No split stack generated yet.",
-            None,
-            "Generate TIFF stacks for a shape before splitting it.",
+            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),
+            _gcode_dropdown_update(next_records, include_upload=True),
+            _dropdown_update(next_records, selected_value),
+            status,
         )
 
+    if not records:
+        return _outputs(records, None, "Slice a shape before splitting it.")
+
     pos = _selected_record_index(records, selected)
     if pos < 0:
         pos = 0
     source = records[pos]
-    state = source.get("tiff_state") or _empty_state()
+    stack = source.get("layer_stack")
+    if stack is None or not getattr(stack, "layers", None):
+        return _outputs(
+            records,
+            selected,
+            f"Split failed: Shape {source.get('idx', pos + 1)} has no sliced layers yet - press Slice Shapes first.",
+        )
+
+    split_column_count = max(1, _coerce_int(columns, 2))
+    split_row_count = max(1, _coerce_int(rows, 1))
     try:
-        pieces = split_tiff_stack_grid(
-            state,
-            base_name=str(source.get("name") or f"shape_{source.get('idx', pos + 1)}"),
-            columns=columns,
-            rows=rows,
-            overlapping_layers=overlapping_layers,
-            progress=progress,
+        pieces = split_layer_stack_grid(
+            stack,
+            columns=split_column_count,
+            rows=split_row_count,
+            overlapping_layers=bool(overlapping_layers),
+            overlap=float(fil_width) if overlapping_layers else 0.0,
         )
     except Exception as exc:
-        empty = _empty_state()
-        return (
-            records,
-            _shape_settings_rows(records),
-            _spacing_table_update(records, existing_spacing, use_individual_spacing),
-            _dropdown_update(records, selected),
-            _reset_slider(),
-            "No slice stack loaded yet.",
-            None,
-            [record.get("zip_path") for record in records if record.get("zip_path")],
-            [record.get("gcode_path") for record in records if record.get("gcode_path")],
-            _gcode_dropdown_update(records),
-            _gcode_dropdown_update(records, include_upload=True),
-            _dropdown_update(records, selected),
-            [],
-            [],
-            _split_piece_dropdown_update([]),
-            _reset_slider(),
-            "No split stack generated yet.",
-            None,
-            f"Split failed: {exc}",
-        )
+        return _outputs(records, selected, f"Split failed: {exc}")
 
     base_name = str(source.get("name") or f"Shape {source.get('idx', pos + 1)}")
     first_nozzle = max(1, _coerce_int(starting_nozzle, 1))
     first_valve = max(1, _coerce_int(starting_valve, _coerce_int(source.get("valve", 4), 4)))
-    split_column_count = max(1, _coerce_int(columns, 2))
-    split_row_count = max(1, _coerce_int(rows, 1))
     split_group_id = f"split-{int(time.time() * 1_000_000)}-{source.get('idx', pos + 1)}"
     split_records: list[dict] = []
     for index, piece in enumerate(pieces):
-        piece_state = piece["state"]
-        piece_width_mm = float(piece_state.get("image_width", 0) or 0) * float(piece_state.get("pixel_size", 0.0) or 0.0)
-        piece_height_mm = float(piece_state.get("image_height", 0) or 0) * float(piece_state.get("pixel_size", 0.0) or 0.0)
+        row_index = index // split_column_count + 1
+        col_index = index % split_column_count + 1
+        (piece_x_min, piece_y_min, _z_min), (piece_x_max, piece_y_max, _z_max) = piece.bounds
         piece_record = dict(source)
         piece_record.update({
-            "name": f"{base_name} - R{piece['row']}C{piece['col']}",
+            "name": f"{base_name} - R{row_index}C{col_index}",
             "stl_path": None,
-            "target_x": piece_width_mm or source.get("target_x", DEFAULT_TARGET_EXTENTS[0]),
-            "target_y": piece_height_mm or source.get("target_y", DEFAULT_TARGET_EXTENTS[1]),
+            "target_x": (piece_x_max - piece_x_min) or source.get("target_x", DEFAULT_TARGET_EXTENTS[0]),
+            "target_y": (piece_y_max - piece_y_min) or source.get("target_y", DEFAULT_TARGET_EXTENTS[1]),
             "nozzle": first_nozzle + index,
             "valve": first_valve + index,
             "split_group_id": split_group_id,
             "split_index": index,
-            "split_row": int(piece["row"]),
-            "split_col": int(piece["col"]),
+            "split_row": row_index,
+            "split_col": col_index,
             "split_rows": split_row_count,
             "split_columns": split_column_count,
-            "tiff_state": piece_state,
-            "zip_path": str(piece["zip_path"]),
+            "layer_stack": piece,
+            "slice_params": source.get("slice_params"),
             "gcode_path": None,
         })
         split_records.append(piece_record)
     next_records = _reindex_shape_records([*records[:pos], *split_records, *records[pos + 1:]])
     split_selected = _shape_choice(next_records[pos]) if pos < len(next_records) else None
-    selected_update, main_slider, main_label, main_preview = _tiff_preview_update(next_records, split_selected)
-    slider, label, preview = preview_selected_split_piece(pieces, None)
     status = (
-        f"Split Shape {source.get('idx', pos + 1)} into {len(pieces)} print-ready stacks "
-        f"({max(1, _coerce_int(columns, 2))} columns x {max(1, _coerce_int(rows, 1))} rows).  \n"
+        f"Split Shape {source.get('idx', pos + 1)} into {len(pieces)} print-ready piece stacks "
+        f"({split_column_count} columns x {split_row_count} rows).  \n"
         f"Nozzles {first_nozzle}-{first_nozzle + len(pieces) - 1}; valves {first_valve}-{first_valve + len(pieces) - 1}."
     )
     if overlapping_layers:
-        status += "  \nOverlapping Layers is enabled: split boundaries alternate by 1 pixel per layer with small blank margins for alignment."
-    return (
-        next_records,
-        _shape_settings_rows(next_records),
-        _spacing_table_update(next_records, existing_spacing, use_individual_spacing),
-        selected_update,
-        main_slider,
-        main_label,
-        main_preview,
-        [record.get("zip_path") for record in next_records if record.get("zip_path")],
-        [record.get("gcode_path") for record in next_records if record.get("gcode_path")],
-        _gcode_dropdown_update(next_records),
-        _gcode_dropdown_update(next_records, include_upload=True),
-        _dropdown_update(next_records),
-        [str(piece["zip_path"]) for piece in pieces],
-        pieces,
-        _split_piece_dropdown_update(pieces),
-        slider,
-        label,
-        preview,
-        status,
-    )
+        status += (
+            "  \nOverlapping Layers is enabled: split boundaries alternate by one "
+            "filament width per layer so neighbouring pieces interlock."
+        )
+    return _outputs(next_records, split_selected, status)
 
 
-def _contour_tracing_sources(records: list[dict]) -> list[dict]:
-    sources: list[dict] = []
+def _contour_tracing_sources(records: list[dict]) -> list[ContourSource]:
+    sources: list[ContourSource] = []
     for record in records:
         if not record.get("contour_tracing"):
             continue
-        state = record.get("tiff_state") or {}
-        tiff_paths = state.get("tiff_paths") or []
-        source = {
-            "owner_idx": int(record.get("idx", len(sources) + 1)),
-            "contour_mode": CONTOUR_MODE_ROW_ENVELOPE,
-            "tiff_paths": list(tiff_paths),
-            "zip_path": record.get("zip_path"),
-        }
-        if source["tiff_paths"] or source["zip_path"]:
-            sources.append(source)
+        stack = record.get("layer_stack")
+        if stack is None or not getattr(stack, "layers", None):
+            continue
+        sources.append(
+            ContourSource(
+                owner_idx=int(record.get("idx", len(sources) + 1)),
+                stack=stack,
+            )
+        )
     return sources
 
 
+def _ensure_records_sliced(
+    records: list[dict],
+    layer_height: float,
+    scale_mode: str | None,
+    messages: list[str],
+) -> bool:
+    """Re-slice records whose layers are missing or stale for the current settings."""
+    resliced = False
+    for record in records:
+        stl_path = record.get("stl_path")
+        if not stl_path:
+            continue  # Split pieces carry their clipped layers; nothing to re-slice.
+        current = _slice_params_snapshot(record, layer_height, scale_mode)
+        if record.get("layer_stack") is not None and record.get("slice_params") == current:
+            continue
+        try:
+            stack = _slice_record(record, layer_height, scale_mode)
+            messages.append(
+                f"Shape {record['idx']}: sliced automatically ({len(stack.layers)} layers)."
+            )
+        except Exception as exc:
+            record["layer_stack"] = None
+            messages.append(f"Shape {record['idx']}: slicing failed ({exc}).")
+        resliced = True
+    return resliced
+
+
 def generate_dynamic_gcode(
     records: list[dict] | None,
     settings_table: Any,
@@ -3250,40 +2564,43 @@ def generate_dynamic_gcode(
     lead_in_length: float,
     lead_in_clearance: float,
     lead_in_lines: float,
-    ref_state: ViewerState | None,
+    ref_layers: LayerStack | None,
     layer_height: float,
-    pixel_size: float,
+    fil_width: float,
+    scale_mode: str | None,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
-    motion_tiffs = (ref_state or {}).get("tiff_paths") if use_reference_motion else None
-    contour_sources = _contour_tracing_sources(records)
     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)
+    contour_sources = _contour_tracing_sources(records)
     if contour_sources:
-        enabled = ", ".join(f"Shape {source['owner_idx']}" for source in contour_sources)
-        messages.append(f"Shape-optimized contour tracing enabled for {enabled}.")
+        enabled = ", ".join(f"Shape {source.owner_idx}" for source in contour_sources)
+        messages.append(f"Contour tracing enabled for {enabled}.")
     for record in records:
-        zip_path = record.get("zip_path")
-        if not zip_path:
-            messages.append(f"Shape {record['idx']}: skipped (no TIFF ZIP available).")
+        stack = record.get("layer_stack")
+        if stack is None or not getattr(stack, "layers", None):
+            messages.append(f"Shape {record['idx']}: skipped (no sliced layers).")
             continue
-        if use_reference_motion and not motion_tiffs:
-            messages.append(f"Shape {record['idx']}: skipped (Reference motion selected, but no Reference TIFF Stack exists).")
+        if use_reference_motion and ref_layers is None:
+            messages.append(f"Shape {record['idx']}: skipped (Reference motion selected, but no shapes are sliced).")
             continue
-        shape_name = str(record.get("name") or Path(zip_path).stem).replace(" ", "_")
+        shape_name = str(record.get("name") or stack.name or f"shape_{record['idx']}").replace(" ", "_")
         try:
-            gcode_path = generate_snake_path_gcode(
-                zip_path=zip_path,
+            gcode_path = generate_vector_gcode(
+                stack,
                 shape_name=shape_name,
                 pressure=float(record.get("pressure", 25.0)),
                 valve=int(record.get("valve", 4)),
                 port=int(record.get("port", 1)),
                 layer_height=float(layer_height),
-                fil_width=float(pixel_size),
+                fil_width=float(fil_width),
                 pressure_ramp_enabled=bool(pressure_ramp_enabled),
                 all_g1=bool(all_g1),
-                motion_tiffs=motion_tiffs,
+                motion=ref_layers if use_reference_motion else None,
                 raster_pattern=raster_pattern,
-                contour_tiff_sets=contour_sources,
+                contour_sources=contour_sources,
                 active_contour_owner=int(record.get("idx", 0)),
                 lead_in_enabled=bool(lead_in_enabled),
                 lead_in_length=float(lead_in_length),
@@ -3296,6 +2613,7 @@ def generate_dynamic_gcode(
             messages.append(f"Shape {record['idx']}: failed ({exc}).")
     return (
         records,
+        ref_layers,
         [record.get("gcode_path") for record in records if record.get("gcode_path")],
         "\n".join(messages),
         _gcode_dropdown_update(records),
@@ -3323,7 +2641,7 @@ def _parts_from_records(records: list[dict] | None) -> tuple[list[dict], list[st
         path = record.get("gcode_path")
         idx = int(record.get("idx", len(parts) + 1))
         if not path:
-            messages.append(f"Shape {idx}: no G-code (generate it on the TIFF Slices to GCode tab).")
+            messages.append(f"Shape {idx}: no G-code (generate it on the Generate G-Code tab).")
             continue
         try:
             parsed = parse_gcode_path(Path(path).read_text())
@@ -3461,7 +2779,7 @@ def render_dynamic_parallel(
     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 TIFF Slices to GCode tab first."
+        return None, "No shape G-code available. Generate G-code on the Generate G-Code tab first."
     offsets, spacings = _resolve_layout_from_spacing_controls(
         parts,
         layout_mode,
@@ -3556,17 +2874,16 @@ def export_dynamic_parallel_gif(
     return str(result) if result else None
 
 def build_dynamic_demo() -> gr.Blocks:
-    with gr.Blocks(title="STL TIFF Slicer", css=APP_CSS, head=APP_HEAD + TOOLPATH_ANIM_HEAD + PARALLEL_ANIM_HEAD) as demo:
+    with gr.Blocks(title="ParallelPrint: STL to G-Code", css=APP_CSS, head=APP_HEAD + TOOLPATH_ANIM_HEAD + PARALLEL_ANIM_HEAD) as demo:
         shape_records = gr.State([])
         last_shape_delete_at = gr.State(0.0)
-        ref_state = gr.State(_empty_state())
-        split_piece_states = gr.State([])
+        ref_layers = gr.State(None)
 
-        with gr.Tab("STL to TIFF Slicer"):
+        with gr.Tab("Shapes & Slicing"):
             gr.Markdown(
                 """
-                # STL to TIFF Slicer
-                Upload any number of STL files, edit per-shape dimensions and print settings in the table, then generate TIFF stacks.
+                # Shapes & Slicing
+                Upload any number of STL files, edit per-shape dimensions and print settings in the table, then slice each shape into per-layer outlines.
                 """
             )
             with gr.Row():
@@ -3600,8 +2917,8 @@ def build_dynamic_demo() -> gr.Blocks:
             )
             with gr.Row():
                 layer_height = gr.Number(label="Layer Height (mm)", value=0.8, minimum=0.0001, step=0.01)
-                pixel_size = gr.Number(label="Pixel Size/Fill Width (mm)", value=0.8, minimum=0.0001, step=0.01)
-                generate_button = gr.Button("Generate TIFF Stacks", variant="primary")
+                fil_width = gr.Number(label="Filament/Line Width (mm)", value=0.8, minimum=0.0001, step=0.01)
+                generate_button = gr.Button("Slice Shapes", variant="primary")
 
             with gr.Accordion("Multi-Nozzle Split", open=False, elem_classes=["settings-accordion"]):
                 with gr.Row():
@@ -3614,18 +2931,7 @@ def build_dynamic_demo() -> gr.Blocks:
                     split_start_valve = gr.Number(label="Starting Valve", value=4, minimum=1, step=1)
                 split_overlapping_layers = gr.Checkbox(label="Overlapping Layers", value=False)
                 split_button = gr.Button("Split Selected Shape into Grid Pieces", variant="primary")
-                split_status = gr.Markdown("Generate a TIFF stack, then split it for multi-nozzle printing.")
-                split_downloads = gr.File(label="Download Split TIFF ZIPs", file_count="multiple", interactive=False)
-                with gr.Row():
-                    with gr.Column(scale=1, min_width=260):
-                        split_piece_source = gr.Dropdown(label="Preview Generated Piece", choices=[], value=None, allow_custom_value=False)
-                        with gr.Row():
-                            split_piece_prev = gr.Button("Prev", scale=1, min_width=90, size="sm")
-                            split_piece_next = gr.Button("Next", scale=1, min_width=90, size="sm")
-                        split_piece_slider = gr.Slider(label="Piece Slice Index", minimum=0, maximum=0, value=0, step=1, interactive=False)
-                        split_piece_label = gr.Markdown("No split stack generated yet.")
-                    with gr.Column(scale=2, min_width=420):
-                        split_piece_preview = gr.Image(label="Generated Piece Preview", type="pil", image_mode="RGB", height=330)
+                split_status = gr.Markdown("Slice a shape, then split it for multi-nozzle printing.")
 
             with gr.Accordion("Selected Shape Preview", open=False, elem_classes=["settings-accordion"]):
                 with gr.Row():
@@ -3644,40 +2950,17 @@ def build_dynamic_demo() -> gr.Blocks:
                     with gr.Column(scale=1, min_width=300):
                         model_details = gr.Markdown("No model loaded.")
 
-                with gr.Row():
-                    with gr.Column(scale=2, min_width=420):
-                        slice_preview = gr.Image(label="Selected Slice Preview", type="pil", image_mode="RGB", height=320)
-                    with gr.Column(scale=1, min_width=300):
-                        slice_label = gr.Markdown("No slice stack loaded yet.")
-                        with gr.Row():
-                            prev_button = gr.Button("Prev", scale=1, min_width=90, size="sm")
-                            next_button = gr.Button("Next", scale=1, min_width=90, size="sm")
-                        slice_slider = gr.Slider(label="Slice Index", minimum=0, maximum=0, value=0, step=1, interactive=False)
-
-            tiff_downloads = gr.File(label="Download TIFF ZIPs", file_count="multiple", interactive=False)
             slicer_status = gr.Markdown("")
 
-            with gr.Accordion("Reference TIFF Stack Preview", open=False, elem_classes=["settings-accordion"]):
-                with gr.Row():
-                    with gr.Column(scale=1, min_width=200):
-                        ref_generate_button = gr.Button("Generate Reference TIFF Stack", variant="primary")
-                    with gr.Column(scale=3, min_width=250):
-                        ref_slice_label = gr.Markdown("No reference stack generated yet.")
-                        ref_slice_preview = gr.Image(label="Reference Slice Preview", type="pil", image_mode="RGB", height=270)
-                        with gr.Row():
-                            ref_prev_button = gr.Button("Prev", scale=1, min_width=90, size="sm")
-                            ref_next_button = gr.Button("Next", scale=1, min_width=90, size="sm")
-                        ref_slice_slider = gr.Slider(label="Slice Index", minimum=0, maximum=0, value=0, step=1, interactive=False)
-
-        with gr.Tab("TIFF Slices to GCode"):
+        with gr.Tab("Generate G-Code"):
             gr.Markdown(
                 """
-                # TIFF Slices to GCode
-                Generate G-code for every shape with a TIFF stack. Pressure, valve, nozzle, port, and color come from the Shape Settings table.
+                # Generate G-Code
+                Generate G-code for every sliced shape. Pressure, valve, nozzle, port, and color come from the Shape Settings table.
                 """
             )
             gcode_use_ref_motion = gr.Checkbox(
-                label="Use Reference Stack for motion (all shapes share one nozzle path; each dispenses only its own geometry).",
+                label="Use combined reference outline for motion (all shapes share one nozzle path; each dispenses only its own geometry).",
                 value=True,
             )
             gcode_all_g1 = gr.Checkbox(label="Move at one constant speed (no fast travel moves)", value=True)
@@ -3798,7 +3081,7 @@ def build_dynamic_demo() -> gr.Blocks:
         with gr.Tab("Parallel Printing Visualization"):
             gr.Markdown(
                 "### Parallel Printing Visualization\n"
-                "Plots all generated shapes using the nozzle spacing configured on the TIFF Slices to GCode tab."
+                "Plots all generated shapes using the nozzle spacing configured on the Generate G-Code tab."
             )
             with gr.Row():
                 with gr.Column(scale=1, min_width=340):
@@ -3837,7 +3120,7 @@ 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, tiff_downloads, gcode_downloads]
+        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(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
@@ -3899,9 +3182,9 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[nozzle_grid_spacing_table],
             queue=False,
         )
-        selected_shape.change(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview])
-        refresh_preview_button.click(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview])
-        model_opacity.change(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview])
+        selected_shape.change(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details])
+        refresh_preview_button.click(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details])
+        model_opacity.change(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details])
         scale_mode.change(
             fn=normalize_shape_dimensions_for_mode,
             inputs=[shape_records, shape_settings, scale_mode],
@@ -3910,7 +3193,7 @@ def build_dynamic_demo() -> gr.Blocks:
         ).then(
             fn=show_selected_model,
             inputs=preview_inputs,
-            outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview],
+            outputs=[model_viewer, model_details],
         )
         reset_dimensions_button.click(
             fn=reset_shape_dimensions,
@@ -3919,39 +3202,19 @@ def build_dynamic_demo() -> gr.Blocks:
         ).then(
             fn=show_selected_model,
             inputs=preview_inputs,
-            outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview],
+            outputs=[model_viewer, model_details],
         )
 
-        slice_slider.release(fn=jump_to_selected_slice, inputs=[shape_records, selected_shape, slice_slider], outputs=[slice_label, slice_preview], queue=False)
-        prev_button.click(fn=lambda records, selected, idx: shift_selected_slice(records, selected, idx, -1), inputs=[shape_records, selected_shape, slice_slider], outputs=[slice_slider, slice_label, slice_preview], queue=False)
-        next_button.click(fn=lambda records, selected, idx: shift_selected_slice(records, selected, idx, 1), inputs=[shape_records, selected_shape, slice_slider], outputs=[slice_slider, slice_label, slice_preview], queue=False)
-
         generate_button.click(
-            fn=generate_dynamic_stacks,
-            inputs=[shape_records, shape_settings, layer_height, pixel_size, scale_mode],
-            outputs=[
-                shape_records,
-                tiff_downloads,
-                slicer_status,
-                selected_shape,
-                slice_slider,
-                slice_label,
-                slice_preview,
-                ref_state,
-                ref_slice_slider,
-                ref_slice_label,
-                ref_slice_preview,
-            ],
+            fn=generate_dynamic_layer_stacks,
+            inputs=[shape_records, shape_settings, layer_height, scale_mode],
+            outputs=[shape_records, slicer_status, ref_layers],
         ).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
             queue=False,
         )
-        ref_generate_button.click(fn=generate_dynamic_reference_stack, inputs=[shape_records], outputs=[ref_state, ref_slice_slider, ref_slice_label, ref_slice_preview])
-        ref_slice_slider.release(fn=jump_to_slice, inputs=[ref_state, ref_slice_slider], outputs=[ref_slice_label, ref_slice_preview], queue=False)
-        ref_prev_button.click(fn=lambda sv, idx: shift_slice(sv, idx, -1), inputs=[ref_state, ref_slice_slider], outputs=[ref_slice_slider, ref_slice_label, ref_slice_preview], queue=False)
-        ref_next_button.click(fn=lambda sv, idx: shift_slice(sv, idx, 1), inputs=[ref_state, ref_slice_slider], outputs=[ref_slice_slider, ref_slice_label, ref_slice_preview], queue=False)
 
         split_refresh_sources.click(fn=lambda records: _dropdown_update(records), inputs=[shape_records], outputs=[split_source], queue=False)
         split_button.click(
@@ -3967,42 +3230,29 @@ def build_dynamic_demo() -> gr.Blocks:
                 split_overlapping_layers,
                 split_start_nozzle,
                 split_start_valve,
+                fil_width,
             ],
             outputs=[
                 shape_records,
                 shape_settings,
                 nozzle_spacing_table,
                 selected_shape,
-                slice_slider,
-                slice_label,
-                slice_preview,
-                tiff_downloads,
                 gcode_downloads,
                 gcode_text_source,
                 gcode_source,
                 split_source,
-                split_downloads,
-                split_piece_states,
-                split_piece_source,
-                split_piece_slider,
-                split_piece_label,
-                split_piece_preview,
                 split_status,
             ],
         ).then(
             fn=generate_dynamic_reference_stack,
             inputs=[shape_records],
-            outputs=[ref_state, ref_slice_slider, ref_slice_label, ref_slice_preview],
+            outputs=[ref_layers],
         ).then(
             fn=_grid_spacing_table_update,
             inputs=grid_spacing_refresh_inputs,
             outputs=[nozzle_grid_spacing_table],
             queue=False,
         )
-        split_piece_source.change(fn=preview_selected_split_piece, inputs=[split_piece_states, split_piece_source], outputs=[split_piece_slider, split_piece_label, split_piece_preview], queue=False)
-        split_piece_slider.release(fn=jump_to_selected_split_piece, inputs=[split_piece_states, split_piece_source, split_piece_slider], outputs=[split_piece_label, split_piece_preview], queue=False)
-        split_piece_prev.click(fn=lambda pieces, selected, idx: shift_selected_split_piece(pieces, selected, idx, -1), inputs=[split_piece_states, split_piece_source, split_piece_slider], outputs=[split_piece_slider, split_piece_label, split_piece_preview], queue=False)
-        split_piece_next.click(fn=lambda pieces, selected, idx: shift_selected_split_piece(pieces, selected, idx, 1), inputs=[split_piece_states, split_piece_source, split_piece_slider], outputs=[split_piece_slider, split_piece_label, split_piece_preview], queue=False)
 
         gcode_button.click(
             fn=generate_dynamic_gcode,
@@ -4017,11 +3267,12 @@ def build_dynamic_demo() -> gr.Blocks:
                 gcode_lead_in_length,
                 gcode_lead_in_clearance,
                 gcode_lead_in_lines,
-                ref_state,
+                ref_layers,
                 layer_height,
-                pixel_size,
+                fil_width,
+                scale_mode,
             ],
-            outputs=[shape_records, gcode_downloads, gcode_status, gcode_text_source, gcode_source],
+            outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source],
         ).then(
             fn=load_selected_gcode_text,
             inputs=[shape_records, gcode_text_source],

gcode_viewer.py

@@ -13,7 +13,11 @@ import plotly.graph_objects as go
 # the axes named on a line change. This matches standard slicer/firmware G-code
 # as well as this app's own always-paired "X Y" output.
 _CMD_RE = re.compile(r"^G0*([01])(?![0-9])", re.IGNORECASE)
-_AXIS_RE = re.compile(r"([XYZ])\s*([-+]?(?:\d*\.\d+|\d+\.?))", re.IGNORECASE)
+# The value accepts a lowercase scientific exponent ("X-5.1e-08") so
+# Python-formatted floats never get truncated to their mantissa ("X-5.1").
+# Uppercase "E" is deliberately NOT treated as an exponent: in compact G-code
+# it starts the extrusion token ("X1.2E3" means X=1.2, E=3).
+_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)

stl_slicer.py

@@ -1,33 +1,37 @@
 from __future__ import annotations
 
 import math
-import tempfile
-import uuid
-import zipfile
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Callable, Sequence
 
 import numpy as np
-from PIL import Image, ImageDraw
 from shapely.geometry import GeometryCollection, MultiPolygon, Polygon
+from shapely.validation import make_valid
 import trimesh
 
 
 ProgressCallback = Callable[[int, int], None] | None
 ScaleFactors = tuple[float, float, float]
+Bounds3D = tuple[tuple[float, float, float], tuple[float, float, float]]
+
+MIN_POLYGON_AREA = 1e-9
 
 
 @dataclass(slots=True)
-class SliceStack:
-    output_dir: Path
-    zip_path: Path
-    tiff_paths: list[Path]
+class LayerStack:
+    """A sliced shape as per-layer vector outlines in world-XY millimetres.
+
+    `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.
+    """
+
+    layers: list[MultiPolygon]
     z_values: list[float]
-    image_size: tuple[int, int]
-    bounds: tuple[tuple[float, float, float], tuple[float, float, float]]
+    bounds: Bounds3D
     layer_height: float
-    pixel_size: float
+    name: str = ""
 
 
 def load_mesh(stl_path: str | Path) -> trimesh.Trimesh:
@@ -110,21 +114,6 @@ def calculate_z_levels(z_min: float, z_max: float, layer_height: float) -> list[
     ]
 
 
-def _to_pixel_ring(
-    coords: np.ndarray,
-    x_min: float,
-    y_min: float,
-    pixel_size: float,
-    image_height: int,
-) -> list[tuple[int, int]]:
-    pixels: list[tuple[int, int]] = []
-    for x_value, y_value in coords:
-        x_pixel = int(round((float(x_value) - x_min) / pixel_size))
-        y_pixel = int(round((float(y_value) - y_min) / pixel_size))
-        pixels.append((x_pixel, image_height - 1 - y_pixel))
-    return pixels
-
-
 def _ring_to_world_xy(ring_coords: object, to_3d: np.ndarray) -> np.ndarray:
     planar = np.asarray(ring_coords, dtype=float)
     if planar.ndim != 2 or planar.shape[1] < 2:
@@ -171,102 +160,75 @@ def _extract_world_polygons(section: trimesh.path.Path3D) -> list[tuple[np.ndarr
     return polygons
 
 
-def _render_slice(
-    section: trimesh.path.Path3D | None,
-    x_min: float,
-    y_min: float,
-    image_size: tuple[int, int],
-    pixel_size: float,
-) -> Image.Image:
-    image = Image.new("L", image_size, 255)
+def _as_multipolygon(geometry: object, min_area: float = MIN_POLYGON_AREA) -> MultiPolygon:
+    """Flatten any shapely result into a MultiPolygon, dropping slivers.
 
-    if section is None:
-        return image
+    Single choke point for shapely's habit of returning mixed geometry types
+    from overlay operations (Polygon / MultiPolygon / GeometryCollection /
+    lines / points / empties).
+    """
+    polygons: list[Polygon] = []
 
-    polygons = _extract_world_polygons(section)
-    if not polygons:
-        return image
+    def collect(geom: object) -> None:
+        if geom is None or getattr(geom, "is_empty", True):
+            return
+        if isinstance(geom, Polygon):
+            if geom.area > min_area:
+                polygons.append(geom)
+        elif isinstance(geom, (MultiPolygon, GeometryCollection)):
+            for part in geom.geoms:
+                collect(part)
 
-    draw = ImageDraw.Draw(image)
-    for exterior, holes in polygons:
-        draw.polygon(
-            _to_pixel_ring(exterior, x_min, y_min, pixel_size, image.height),
-            fill=0,
-        )
-        for hole in holes:
-            draw.polygon(
-                _to_pixel_ring(hole, x_min, y_min, pixel_size, image.height),
-                fill=255,
-            )
+    collect(geometry)
+    return MultiPolygon(polygons)
 
-    return image
 
+def _section_to_multipolygon(section: trimesh.path.Path3D | None) -> MultiPolygon:
+    if section is None:
+        return MultiPolygon()
 
-def _make_output_paths(stl_path: Path, output_root: str | Path | None) -> tuple[Path, Path]:
-    root = Path(output_root) if output_root else Path(tempfile.mkdtemp(prefix="stl_slices_"))
-    stem = stl_path.stem or "mesh"
-    job_dir = root / f"{stem}_{uuid.uuid4().hex[:8]}"
-    slices_dir = job_dir / "tiff_slices"
-    slices_dir.mkdir(parents=True, exist_ok=True)
-    zip_path = job_dir / f"{stem}_tiff_slices.zip"
-    return slices_dir, zip_path
-
+    polygons = [
+        Polygon(exterior, holes)
+        for exterior, holes in _extract_world_polygons(section)
+    ]
+    if not polygons:
+        return MultiPolygon()
 
-def _zip_tiffs(tiff_paths: list[Path], zip_path: Path) -> None:
-    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
-        for tiff_path in tiff_paths:
-            archive.write(tiff_path, arcname=tiff_path.name)
+    return _as_multipolygon(make_valid(MultiPolygon(polygons)))
 
 
-def slice_stl_to_tiffs(
+def slice_stl_to_layers(
     stl_path: str | Path,
     layer_height: float,
-    pixel_size: float,
-    output_root: str | Path | None = None,
     progress_callback: ProgressCallback = None,
     scale_factors: Sequence[float] | None = None,
-) -> SliceStack:
-    if pixel_size <= 0:
-        raise ValueError("Pixel size must be greater than zero.")
-
+    name: str | None = None,
+) -> LayerStack:
+    """Slice an STL into per-layer vector outlines (world-XY millimetres)."""
     stl_path = Path(stl_path)
     mesh = scale_mesh(load_mesh(stl_path), scale_factors)
-    bounds = mesh.bounds
-    (x_min, y_min, z_min), (x_max, y_max, z_max) = bounds
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = mesh.bounds
 
     z_values = calculate_z_levels(float(z_min), float(z_max), layer_height)
-    width = max(1, math.ceil((float(x_max) - float(x_min)) / pixel_size) + 1)
-    height = max(1, math.ceil((float(y_max) - float(y_min)) / pixel_size) + 1)
-    image_size = (width, height)
-
-    output_dir, zip_path = _make_output_paths(stl_path, output_root)
-    tiff_paths: list[Path] = []
 
+    layers: list[MultiPolygon] = []
     for index, z_value in enumerate(z_values):
         section = mesh.section(
             plane_origin=np.array([0.0, 0.0, z_value], dtype=float),
             plane_normal=np.array([0.0, 0.0, 1.0], dtype=float),
         )
-        image = _render_slice(section, float(x_min), float(y_min), image_size, pixel_size)
-        tiff_path = output_dir / f"slice_{index:04d}.tif"
-        image.save(tiff_path, compression="tiff_deflate")
-        tiff_paths.append(tiff_path)
+        layers.append(_section_to_multipolygon(section))
 
         if progress_callback is not None:
             progress_callback(index + 1, len(z_values))
 
-    _zip_tiffs(tiff_paths, zip_path)
-
-    return SliceStack(
-        output_dir=output_dir,
-        zip_path=zip_path,
-        tiff_paths=tiff_paths,
+    return LayerStack(
+        layers=layers,
         z_values=z_values,
-        image_size=image_size,
         bounds=(
             (float(x_min), float(y_min), float(z_min)),
             (float(x_max), float(y_max), float(z_max)),
         ),
         layer_height=layer_height,
-        pixel_size=pixel_size,
+        name=name if name is not None else (stl_path.stem or "mesh"),
     )

tests/test_app_scaling.py

@@ -2,14 +2,11 @@ from __future__ import annotations
 
 import numpy as np
 import trimesh
-from PIL import Image
 
 from app import (
     SCALE_MODE_TARGET_DIMENSIONS,
     SCALE_MODE_UNIFORM_FACTOR,
-    generate_dynamic_stacks,
-    split_tiff_stack_grid,
-    split_tiff_stack_left_right,
+    generate_dynamic_layer_stacks,
     _resolve_mesh_scale_factors,
     _uniform_target_extents_from_anchor,
 )
@@ -59,163 +56,46 @@ def test_uniform_target_extents_update_from_changed_side() -> None:
     np.testing.assert_allclose(target_extents, (6.0, 12.0, 24.0))
 
 
-def test_generate_dynamic_stacks_empty_input_resets_reference_stack() -> None:
-    outputs = generate_dynamic_stacks([], [], 0.8, 0.8, SCALE_MODE_TARGET_DIMENSIONS)
-
-    assert len(outputs) == 11
-    assert outputs[0] == []
-    assert outputs[2] == "Upload at least one STL first."
-    assert outputs[7]["tiff_paths"] == []
-    assert outputs[9] == "No reference stack generated yet."
+def test_generate_dynamic_layer_stacks_empty_input_resets_reference() -> None:
+    records, status, ref_layers = generate_dynamic_layer_stacks(
+        [],
+        [],
+        0.8,
+        SCALE_MODE_TARGET_DIMENSIONS,
+    )
 
+    assert records == []
+    assert status == "Upload at least one STL first."
+    assert ref_layers is None
+
+
+def test_generate_dynamic_layer_stacks_slices_shapes_and_builds_reference(tmp_path) -> None:
+    mesh = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
+    stl_path = tmp_path / "cube.stl"
+    mesh.export(stl_path)
+    records = [
+        {
+            "idx": 1,
+            "name": "cube",
+            "stl_path": str(stl_path),
+            "target_x": 2.0,
+            "target_y": 2.0,
+            "target_z": 2.0,
+        }
+    ]
 
-def test_split_tiff_stack_left_right_preserves_pixels_and_metadata(tmp_path) -> None:
-    pixels = np.array(
-        [
-            [0, 255, 0, 255, 0],
-            [255, 0, 255, 0, 255],
-        ],
-        dtype=np.uint8,
+    next_records, status, ref_layers = generate_dynamic_layer_stacks(
+        records,
+        None,
+        0.5,
+        SCALE_MODE_TARGET_DIMENSIONS,
     )
-    tiff_path = tmp_path / "slice_0000.tif"
-    Image.fromarray(pixels, mode="L").save(tiff_path)
-    state = {
-        "tiff_paths": [str(tiff_path)],
-        "z_values": [1.25],
-        "pixel_size": 0.5,
-        "x_min": 10.0,
-        "y_min": -2.0,
-        "image_width": 5,
-        "image_height": 2,
-    }
-
-    left_state, right_state, left_zip, right_zip = split_tiff_stack_left_right(state, "wide-part")
-
-    assert left_zip.exists()
-    assert right_zip.exists()
-    assert left_state["image_width"] == 3
-    assert right_state["image_width"] == 3
-    assert left_state["x_min"] == 10.0
-    assert right_state["x_min"] == 11.5
-    assert left_state["z_values"] == [1.25]
-    assert right_state["z_values"] == [1.25]
-
-    with Image.open(left_state["tiff_paths"][0]) as left_image:
-        np.testing.assert_array_equal(np.asarray(left_image), pixels[:, :3])
-    with Image.open(right_state["tiff_paths"][0]) as right_image:
-        expected = np.full((2, 3), 255, dtype=np.uint8)
-        expected[:, :2] = pixels[:, 3:]
-        np.testing.assert_array_equal(np.asarray(right_image), expected)
-
-
-def test_split_tiff_stack_grid_preserves_pixels_and_offsets(tmp_path) -> None:
-    pixels = np.arange(20, dtype=np.uint8).reshape((4, 5))
-    tiff_path = tmp_path / "slice_0000.tif"
-    Image.fromarray(pixels, mode="L").save(tiff_path)
-    state = {
-        "tiff_paths": [str(tiff_path)],
-        "z_values": [2.0],
-        "pixel_size": 0.25,
-        "x_min": 4.0,
-        "y_min": 10.0,
-        "image_width": 5,
-        "image_height": 4,
-    }
-
-    pieces = split_tiff_stack_grid(state, "grid-part", columns=2, rows=2)
-
-    assert [(piece["row"], piece["col"]) for piece in pieces] == [(1, 1), (1, 2), (2, 1), (2, 2)]
-    assert [piece["state"]["image_width"] for piece in pieces] == [3, 3, 3, 3]
-    assert [piece["state"]["image_height"] for piece in pieces] == [2, 2, 2, 2]
-    assert [piece["state"]["x_min"] for piece in pieces] == [4.0, 4.75, 4.0, 4.75]
-    assert [piece["state"]["y_min"] for piece in pieces] == [10.5, 10.5, 10.0, 10.0]
-    assert all(piece["zip_path"].exists() for piece in pieces)
-
-    right_top = np.full((2, 3), 255, dtype=np.uint8)
-    right_top[:, :2] = pixels[:2, 3:]
-    right_bottom = np.full((2, 3), 255, dtype=np.uint8)
-    right_bottom[:, :2] = pixels[2:, 3:]
-    expected = [
-        pixels[:2, :3],
-        right_top,
-        pixels[2:, :3],
-        right_bottom,
-    ]
-    for piece, expected_pixels in zip(pieces, expected):
-        with Image.open(piece["state"]["tiff_paths"][0]) as image:
-            np.testing.assert_array_equal(np.asarray(image), expected_pixels)
-
-
-def test_split_tiff_stack_grid_pads_more_than_three_columns_to_equal_widths(tmp_path) -> None:
-    pixels = np.arange(20, dtype=np.uint8).reshape((2, 10))
-    tiff_path = tmp_path / "slice_0000.tif"
-    Image.fromarray(pixels, mode="L").save(tiff_path)
-    state = {
-        "tiff_paths": [str(tiff_path)],
-        "z_values": [0.0],
-        "pixel_size": 1.0,
-        "x_min": 100.0,
-        "y_min": 0.0,
-        "image_width": 10,
-        "image_height": 2,
-    }
-
-    pieces = split_tiff_stack_grid(state, "four-way", columns=4, rows=1)
-
-    assert [piece["state"]["image_width"] for piece in pieces] == [3, 3, 3, 3]
-    assert [piece["state"]["x_min"] for piece in pieces] == [99.0, 102.0, 105.0, 108.0]
-
-    first_expected = np.full((2, 3), 255, dtype=np.uint8)
-    first_expected[:, 1:] = pixels[:, :2]
-    last_expected = np.full((2, 3), 255, dtype=np.uint8)
-    last_expected[:, :2] = pixels[:, 8:]
-    expected = [
-        first_expected,
-        pixels[:, 2:5],
-        pixels[:, 5:8],
-        last_expected,
-    ]
-    for piece, expected_pixels in zip(pieces, expected):
-        with Image.open(piece["state"]["tiff_paths"][0]) as image:
-            np.testing.assert_array_equal(np.asarray(image), expected_pixels)
-
-
-def test_split_tiff_stack_grid_overlapping_layers_keep_small_alignment_margin(tmp_path) -> None:
-    layer0 = np.zeros((2, 6), dtype=np.uint8)
-    layer1 = np.zeros((2, 6), dtype=np.uint8)
-    layer0_path = tmp_path / "slice_0000.tif"
-    layer1_path = tmp_path / "slice_0001.tif"
-    Image.fromarray(layer0, mode="L").save(layer0_path)
-    Image.fromarray(layer1, mode="L").save(layer1_path)
-    state = {
-        "tiff_paths": [str(layer0_path), str(layer1_path)],
-        "z_values": [0.0, 1.0],
-        "pixel_size": 0.5,
-        "x_min": 10.0,
-        "y_min": -2.0,
-        "image_width": 6,
-        "image_height": 2,
-    }
-
-    left, right = split_tiff_stack_grid(state, "overlap-part", columns=2, rows=1, overlapping_layers=True)
-
-    assert left["state"]["image_width"] == 5
-    assert right["state"]["image_width"] == 5
-    assert left["state"]["x_min"] == 9.5
-    assert right["state"]["x_min"] == 11.0
-    with Image.open(left["state"]["tiff_paths"][0]) as left_layer0:
-        expected = np.full((2, 5), 255, dtype=np.uint8)
-        expected[:, 1:] = 0
-        np.testing.assert_array_equal(np.asarray(left_layer0), expected)
-    with Image.open(right["state"]["tiff_paths"][0]) as right_layer0:
-        expected = np.full((2, 5), 255, dtype=np.uint8)
-        expected[:, 2:4] = 0
-        np.testing.assert_array_equal(np.asarray(right_layer0), expected)
-    with Image.open(left["state"]["tiff_paths"][1]) as left_layer1:
-        expected = np.full((2, 5), 255, dtype=np.uint8)
-        expected[:, 1:3] = 0
-        np.testing.assert_array_equal(np.asarray(left_layer1), expected)
-    with Image.open(right["state"]["tiff_paths"][1]) as right_layer1:
-        expected = np.full((2, 5), 255, dtype=np.uint8)
-        expected[:, :4] = 0
-        np.testing.assert_array_equal(np.asarray(right_layer1), expected)
+
+    stack = next_records[0]["layer_stack"]
+    assert stack is not None
+    assert len(stack.layers) == 4
+    assert next_records[0]["slice_params"]["layer_height"] == 0.5
+    assert "sliced 4 layers" in status
+    assert ref_layers is not None
+    assert len(ref_layers.layers) == 4
+    assert ref_layers.layers[0].area == stack.layers[0].area

tests/test_gcode_viewer.py

@@ -16,3 +16,35 @@ def test_parse_gcode_classifies_g0_as_travel_and_g1_as_print() -> None:
 
     assert len(parsed["travel_segments"]) == 1
     assert len(parsed["print_segments"]) == 1
+
+
+def test_parse_gcode_reads_scientific_notation_instead_of_mantissa() -> None:
+    parsed = parse_gcode_path(
+        "\n".join(
+            [
+                "G91",
+                "G0 X-5.1e-08 Y0.8 ; tiny float-noise travel",
+                "G1 X4.0 Y0.0 ; print",
+            ]
+        )
+    )
+
+    (segment,) = parsed["print_segments"]
+    start, end = segment[0], segment[-1]
+    # "X-5.1e-08" must move the head by ~0, not by -5.1.
+    assert abs(start[0]) < 1e-6
+    assert abs(end[0] - 4.0) < 1e-6
+
+
+def test_parse_gcode_keeps_uppercase_extrusion_token_out_of_x_axis() -> None:
+    parsed = parse_gcode_path(
+        "\n".join(
+            [
+                "G91",
+                "G1 X1.2E3 Y0.5",  # compact G-code: X=1.2, E=3 (not X=1200)
+            ]
+        )
+    )
+
+    (segment,) = parsed["print_segments"]
+    assert abs(segment[-1][0] - 1.2) < 1e-9

tests/test_nozzle_spacing.py

@@ -22,8 +22,7 @@ from app import (
     _resolve_nozzle_grid_layout,
     _resolve_nozzle_layout,
 )
-from tiff_to_gcode import (
-    CONTOUR_MODE_ROW_ENVELOPE,
+from vector_toolpath import (
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_Y_DIRECTION,
 )
@@ -256,25 +255,29 @@ def test_shape_settings_round_trip_contour_tracing_column() -> None:
     assert updated[0]["contour_tracing"] is True
 
 
-def test_contour_tracing_sources_request_shape_optimized_mode() -> None:
+def test_contour_tracing_sources_use_sliced_layer_stacks() -> None:
+    from shapely.geometry import MultiPolygon, box
+
+    from stl_slicer import LayerStack
+
+    stack = LayerStack(
+        layers=[MultiPolygon([box(0.0, 0.0, 1.0, 1.0)])],
+        z_values=[0.5],
+        bounds=((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)),
+        layer_height=1.0,
+        name="traced",
+    )
     sources = _contour_tracing_sources(
         [
-            {
-                "idx": 2,
-                "contour_tracing": True,
-                "tiff_state": {"tiff_paths": ["slice_0000.tif"]},
-            }
+            {"idx": 1, "contour_tracing": False, "layer_stack": stack},
+            {"idx": 2, "contour_tracing": True, "layer_stack": stack},
+            {"idx": 3, "contour_tracing": True, "layer_stack": None},
         ]
     )
 
-    assert sources == [
-        {
-            "owner_idx": 2,
-            "contour_mode": CONTOUR_MODE_ROW_ENVELOPE,
-            "tiff_paths": ["slice_0000.tif"],
-            "zip_path": None,
-        }
-    ]
+    assert len(sources) == 1
+    assert sources[0].owner_idx == 2
+    assert sources[0].stack is stack
 
 
 def test_repeated_sample_path_gets_next_unused_nozzle() -> None:

tests/test_stl_slicer.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
 import numpy as np
-from PIL import Image
 from shapely.geometry import Polygon
 import trimesh
 
+import pytest
+
 from stl_slicer import (
     _compose_even_odd_polygons,
     calculate_z_levels,
     scale_factors_for_target_extents,
     scale_mesh,
-    slice_stl_to_tiffs,
+    slice_stl_to_layers,
 )
 
 
@@ -21,26 +22,43 @@ def test_calculate_z_levels_creates_single_layer_for_thin_mesh() -> None:
     assert 0.0 <= z_values[0] < 0.01
 
 
-def test_slice_stl_to_tiffs_creates_non_empty_tiffs(tmp_path) -> None:
+def test_slice_stl_to_layers_creates_layer_polygons(tmp_path) -> None:
     mesh = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
     stl_path = tmp_path / "cube.stl"
     mesh.export(stl_path)
 
-    stack = slice_stl_to_tiffs(
-        stl_path,
-        layer_height=0.5,
-        pixel_size=0.25,
-        output_root=tmp_path / "generated",
+    stack = slice_stl_to_layers(stl_path, layer_height=0.5)
+
+    assert len(stack.layers) == 4
+    assert len(stack.z_values) == 4
+    assert all(
+        later > earlier
+        for earlier, later in zip(stack.z_values, stack.z_values[1:])
     )
+    for layer in stack.layers:
+        assert layer.area == pytest.approx(4.0)
 
-    assert len(stack.tiff_paths) == 4
-    assert stack.zip_path.exists()
-    assert all(path.exists() for path in stack.tiff_paths)
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = stack.bounds
+    assert (x_max - x_min, y_max - y_min, z_max - z_min) == pytest.approx((2.0, 2.0, 2.0))
+    assert stack.name == "cube"
+    assert stack.layer_height == 0.5
+
+
+def test_slice_stl_to_layers_applies_scale_factors(tmp_path) -> None:
+    mesh = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
+    stl_path = tmp_path / "cube.stl"
+    mesh.export(stl_path)
 
-    with Image.open(stack.tiff_paths[0]) as first_image:
-        pixels = np.array(first_image)
+    stack = slice_stl_to_layers(
+        stl_path,
+        layer_height=0.5,
+        scale_factors=(2.0, 1.0, 0.5),
+    )
 
-    assert np.any(pixels == 0)
+    bounds = np.array(stack.bounds)
+    np.testing.assert_allclose(bounds[1] - bounds[0], (4.0, 2.0, 1.0))
+    assert len(stack.layers) == 2
+    assert stack.layers[0].area == pytest.approx(8.0)
 
 
 def test_scale_mesh_matches_target_extents_and_preserves_min_corner() -> None:
@@ -55,25 +73,6 @@ def test_scale_mesh_matches_target_extents_and_preserves_min_corner() -> None:
     np.testing.assert_allclose(scaled.bounds[0], mesh.bounds[0])
 
 
-def test_slice_stl_to_tiffs_applies_scale_factors(tmp_path) -> None:
-    mesh = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
-    stl_path = tmp_path / "cube.stl"
-    mesh.export(stl_path)
-
-    stack = slice_stl_to_tiffs(
-        stl_path,
-        layer_height=0.5,
-        pixel_size=0.25,
-        output_root=tmp_path / "scaled",
-        scale_factors=(2.0, 1.0, 0.5),
-    )
-
-    bounds = np.array(stack.bounds)
-    np.testing.assert_allclose(bounds[1] - bounds[0], (4.0, 2.0, 1.0))
-    assert stack.image_size == (17, 9)
-    assert len(stack.tiff_paths) == 2
-
-
 def test_compose_even_odd_polygons_preserves_holes() -> None:
     outer = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
     inner = Polygon([(3, 3), (7, 3), (7, 7), (3, 7)])

tests/test_vector_gcode.py

@@ -0,0 +1,823 @@
+from __future__ import annotations
+
+import math
+
+from shapely.geometry import MultiPolygon, Polygon, box
+
+from stl_slicer import LayerStack
+from vector_gcode import generate_vector_gcode
+from vector_toolpath import (
+    RASTER_PATTERN_CIRCLE_SPIRAL,
+    RASTER_PATTERN_RECTANGULAR_SPIRAL,
+    RASTER_PATTERN_WOODPILE,
+    RASTER_PATTERN_Y_DIRECTION,
+    ContourSource,
+    _append_layer_contours,
+    _circle_spiral_points,
+    _layer_contour_loops,
+    _rectangular_spiral_polyline,
+    build_reference_stack,
+    split_layer_stack_grid,
+)
+
+
+def _stack(
+    *layers: Polygon | MultiPolygon | None,
+    layer_height: float = 1.0,
+    name: str = "shape",
+) -> LayerStack:
+    multipolygons: list[MultiPolygon] = []
+    for layer in layers:
+        if layer is None:
+            multipolygons.append(MultiPolygon())
+        elif isinstance(layer, MultiPolygon):
+            multipolygons.append(layer)
+        else:
+            multipolygons.append(MultiPolygon([layer]))
+
+    bounds_list = [layer.bounds for layer in multipolygons if not layer.is_empty]
+    if bounds_list:
+        x_min = min(b[0] for b in bounds_list)
+        y_min = min(b[1] for b in bounds_list)
+        x_max = max(b[2] for b in bounds_list)
+        y_max = max(b[3] for b in bounds_list)
+    else:
+        x_min = y_min = x_max = y_max = 0.0
+
+    return LayerStack(
+        layers=multipolygons,
+        z_values=[(index + 0.5) * layer_height for index in range(len(multipolygons))],
+        bounds=((x_min, y_min, 0.0), (x_max, y_max, len(multipolygons) * layer_height)),
+        layer_height=layer_height,
+        name=name,
+    )
+
+
+def _move_signature(gcode_text: str) -> list[tuple[float | None, float | None, float | None]]:
+    signature: list[tuple[float | None, float | None, float | None]] = []
+    for line in gcode_text.splitlines():
+        if not line.startswith(("G0", "G1")):
+            continue
+        axes: dict[str, float] = {}
+        for token in line.split():
+            if token[:1] in {"X", "Y", "Z"}:
+                axes[token[0]] = float(token[1:])
+        signature.append((axes.get("X"), axes.get("Y"), axes.get("Z")))
+    return signature
+
+
+def _move_endpoints_for_color(gcode_text: str, color: int) -> list[tuple[float, float]]:
+    x = y = 0.0
+    endpoints: list[tuple[float, float]] = []
+    for line in gcode_text.splitlines():
+        if not line.startswith(("G0", "G1")):
+            continue
+        start = (x, y)
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+        if f"; Color {color}" in line:
+            endpoints.extend([start, (x, y)])
+    return endpoints
+
+
+def _moves_with_colors(gcode_text: str) -> list[dict]:
+    x = y = z = 0.0
+    moves: list[dict] = []
+    for line in gcode_text.splitlines():
+        if not line.startswith(("G0", "G1")):
+            continue
+        start = (x, y, z)
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+            if token.startswith("Z"):
+                z += float(token[1:])
+        color = None
+        if "; Color " in line:
+            color = int(line.rsplit("; Color ", 1)[1])
+        moves.append({"start": start, "end": (x, y, z), "color": color})
+    return moves
+
+
+def _pressure_set_count(gcode_text: str) -> int:
+    return gcode_text.count("\\x30\\x38\\x50\\x53") + gcode_text.count("setpress(")
+
+
+def test_gcode_writes_fixed_point_coordinates_never_scientific(tmp_path) -> None:
+    from vector_gcode import write_gcode_file
+
+    gcode_path = tmp_path / "noise.txt"
+    write_gcode_file(
+        gcode_path,
+        [
+            {"X": -5.1e-08, "Y": 0.8, "Color": 0},
+            {"X": 1.2e-05, "Y": 0.0, "Color": 255},
+            {"X": 4.0, "Y": -0.0, "Color": 0},
+        ],
+        pressure=25,
+        valve=7,
+        port=3,
+        increase_pressure_per_layer=0.1,
+        pressure_ramp_enabled=True,
+        all_g1=False,
+    )
+
+    move_lines = [
+        line for line in gcode_path.read_text().splitlines() if line.startswith(("G0", "G1"))
+    ]
+    assert move_lines == [
+        "G0 X0.0 Y0.8 ; Color 0",
+        "G1 X0.000012 Y0.0 ; Color 255",
+        "G0 X4.0 Y0.0 ; Color 0",
+    ]
+
+
+def test_slanted_shape_gcode_round_trips_through_the_viewer(tmp_path) -> None:
+    from gcode_viewer import parse_gcode_path
+
+    # Slanted edges produce float-noise sweep bounds that differ between rows
+    # (the pyramid failure mode); the parsed positions must stay inside the
+    # material footprint on every layer.
+    layers = [
+        Polygon(
+            [
+                (inset, inset),
+                (20.0 - inset, inset),
+                (20.0 - inset, 20.0 - inset),
+                (inset, 20.0 - inset),
+            ]
+        )
+        for inset in (0.0, 0.57735026918962, 1.15470053837925, 1.73205080756887)
+    ]
+    gcode_path = generate_vector_gcode(
+        _stack(*layers),
+        shape_name="slanted",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=0.8,
+        layer_height=1.0,
+        output_dir=tmp_path,
+    )
+
+    parsed = parse_gcode_path(gcode_path.read_text())
+    for segment in parsed["print_segments"]:
+        for x, y, _z in segment:
+            # Origin sits one fil_width left of the layer-0 sweep start; all
+            # print positions stay within the 20 mm footprint plus buffers.
+            assert -1.0 <= x <= 21.0
+            assert -1.0 <= y <= 21.0
+
+
+def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> None:
+    gcode_path = generate_vector_gcode(
+        _stack(box(0.0, 0.0, 1.0, 1.0)),
+        shape_name="header_order",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        output_dir=tmp_path,
+    )
+
+    lines = [
+        line.strip()
+        for line in gcode_path.read_text().splitlines()
+        if line.strip()
+    ]
+
+    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(")
+    assert lines[5].startswith("{aux_command}WAGO_ValveCommands(")
+
+
+def test_gcode_lead_in_runs_once_before_first_layer(tmp_path) -> None:
+    gcode_path = generate_vector_gcode(
+        _stack(box(0.0, 0.0, 0.5, 0.5), box(0.0, 0.0, 0.5, 0.5)),
+        shape_name="lead_in",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=0.5,
+        layer_height=1.0,
+        lead_in_enabled=True,
+        lead_in_length=3.0,
+        lead_in_clearance=4.0,
+        lead_in_lines=3,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+
+    assert moves[:7] == [
+        {"start": (0.0, 0.0, 0.0), "end": (-7.0, 0.0, 0.0), "color": 0},
+        {"start": (-7.0, 0.0, 0.0), "end": (-4.0, 0.0, 0.0), "color": 255},
+        {"start": (-4.0, 0.0, 0.0), "end": (-4.0, 0.5, 0.0), "color": 0},
+        {"start": (-4.0, 0.5, 0.0), "end": (-7.0, 0.5, 0.0), "color": 255},
+        {"start": (-7.0, 0.5, 0.0), "end": (-7.0, 1.0, 0.0), "color": 0},
+        {"start": (-7.0, 1.0, 0.0), "end": (-4.0, 1.0, 0.0), "color": 255},
+        {"start": (-4.0, 1.0, 0.0), "end": (0.0, 0.0, 0.0), "color": 0},
+    ]
+    assert all(move["end"][2] == 0.0 for move in moves[:7])
+
+    first_z_index = next(index for index, move in enumerate(moves) if move["end"][2] > 0.0)
+    assert first_z_index > 7
+    assert not any(
+        move["start"][0] < -3.0 or move["end"][0] < -3.0
+        for move in moves[first_z_index:]
+    )
+
+
+def test_gcode_pressure_ramp_can_be_disabled(tmp_path) -> None:
+    stack = _stack(box(0.0, 0.0, 1.0, 1.0), box(0.0, 0.0, 1.0, 1.0))
+
+    ramped_path = generate_vector_gcode(
+        stack,
+        shape_name="pressure_ramped",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        pressure_ramp_enabled=True,
+        output_dir=tmp_path / "ramped",
+    )
+    fixed_path = generate_vector_gcode(
+        stack,
+        shape_name="pressure_fixed",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        pressure_ramp_enabled=False,
+        output_dir=tmp_path / "fixed",
+    )
+
+    assert _pressure_set_count(ramped_path.read_text()) > 1
+    assert _pressure_set_count(fixed_path.read_text()) == 1
+
+
+def test_gcode_uses_g1_for_print_and_g0_for_travel(tmp_path) -> None:
+    gcode_path = generate_vector_gcode(
+        _stack(box(0.0, 0.0, 1.0, 1.0)),
+        shape_name="move_types",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        output_dir=tmp_path,
+    )
+
+    move_lines = [
+        line.strip()
+        for line in gcode_path.read_text().splitlines()
+        if line.startswith(("G0", "G1"))
+    ]
+
+    assert any(line.startswith("G1") and "; Color 255" in line for line in move_lines)
+    assert all(not line.startswith("G0") for line in move_lines if "; Color 255" in line)
+    assert all(not line.startswith("G1") for line in move_lines if "; Color 0" in line)
+
+
+def test_woodpile_raster_switches_print_axis_between_layers(tmp_path) -> None:
+    layer = box(0.0, 0.0, 3.0, 2.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer, layer, layer),
+        shape_name="woodpile",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        raster_pattern=RASTER_PATTERN_WOODPILE,
+        output_dir=tmp_path,
+    )
+
+    gcode_text = gcode_path.read_text()
+    move_lines = [
+        line.strip()
+        for line in gcode_text.splitlines()
+        if line.startswith(("G0", "G1"))
+    ]
+    z_move_index = next(i for i, line in enumerate(move_lines) if " Z" in line)
+    first_layer_prints = [
+        line
+        for line in move_lines[:z_move_index]
+        if line.startswith("G1") and "; Color 255" in line
+    ]
+    second_layer_end = next(
+        (i for i, line in enumerate(move_lines[z_move_index + 1 :], start=z_move_index + 1) if " Z" in line),
+        len(move_lines),
+    )
+    second_layer_prints = [
+        line
+        for line in move_lines[z_move_index + 1 : second_layer_end]
+        if line.startswith("G1") and "; Color 255" in line
+    ]
+
+    assert move_lines[0] == "G0 X1.0 Y0.0 ; Color 0"
+    # Layer 0 prints sweep along X, layer 1 prints sweep along Y.
+    assert first_layer_prints
+    assert all("Y0.0" in line for line in first_layer_prints)
+    assert second_layer_prints
+    assert all("X0.0" in line for line in second_layer_prints)
+
+    x = y = 0.0
+    x_positions = [x]
+    y_positions = [y]
+    for line in move_lines:
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+        x_positions.append(x)
+        y_positions.append(y)
+    assert min(x_positions) == 0.0
+    assert max(x_positions) == 5.0
+    assert min(y_positions) == -1.5
+    assert max(y_positions) == 2.5
+
+    # Each layer restarts at the sweep-start candidate nearest the previous
+    # layer's endpoint. Candidates are the four buffered sweep corners, here
+    # in cumulative coordinates (origin = layer 0's start at world (-1, 0.5)).
+    y_axis_candidates = [(1.5, -1.5), (1.5, 2.5), (3.5, -1.5), (3.5, 2.5)]
+    x_axis_candidates = [(0.0, 0.0), (0.0, 1.0), (5.0, 0.0), (5.0, 1.0)]
+    moves = _moves_with_colors(gcode_text)
+    layer_changes = [move for move in moves if move["end"][2] > move["start"][2]]
+    assert len(layer_changes) == 3
+    for layer_number, layer_change in enumerate(layer_changes, start=1):
+        candidates = y_axis_candidates if layer_number % 2 == 1 else x_axis_candidates
+        start = layer_change["start"][:2]
+        end = layer_change["end"][:2]
+        assert end in candidates
+        best = min(math.dist(start, candidate) for candidate in candidates)
+        assert math.dist(start, end) <= best + 1e-9
+
+
+def test_y_direction_raster_prints_each_layer_along_y_axis(tmp_path) -> None:
+    layer = box(0.0, 0.0, 3.0, 2.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer),
+        shape_name="y_direction",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        raster_pattern=RASTER_PATTERN_Y_DIRECTION,
+        output_dir=tmp_path,
+    )
+
+    gcode_text = gcode_path.read_text()
+    move_lines = [
+        line.strip()
+        for line in gcode_text.splitlines()
+        if line.startswith(("G0", "G1"))
+    ]
+    print_lines = [
+        line
+        for line in move_lines
+        if line.startswith("G1") and "; Color 255" in line
+    ]
+    assert print_lines
+    assert move_lines[0] == "G0 X0.0 Y1.0 ; Color 0"
+    assert all("X0.0" in line and "Y0.0" not in line for line in print_lines)
+
+    x = y = 0.0
+    x_positions = [x]
+    y_positions = [y]
+    for line in move_lines:
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+        x_positions.append(x)
+        y_positions.append(y)
+    assert min(x_positions) == 0.0
+    assert max(x_positions) == 2.0
+    assert min(y_positions) == 0.0
+    assert max(y_positions) == 4.0
+
+    moves = _moves_with_colors(gcode_text)
+    first_layer_change = next(
+        move for move in moves if move["end"][2] > move["start"][2]
+    )
+    assert first_layer_change["start"][:2] == first_layer_change["end"][:2]
+
+
+def test_raster_crosses_interior_holes_with_valve_off(tmp_path) -> None:
+    hollow = Polygon(
+        box(0.0, 0.0, 6.0, 6.0).exterior.coords,
+        [list(box(2.0, 2.0, 4.0, 4.0).exterior.coords)],
+    )
+    gcode_path = generate_vector_gcode(
+        _stack(hollow),
+        shape_name="hollow",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    print_moves = [move for move in moves if move["color"] == 255]
+    travel_moves = [move for move in moves if move["color"] == 0]
+
+    # Middle sweeps must split into two print runs around the hole.
+    assert len(print_moves) == 4 + 4  # 4 full-width rows + 2 rows split in two
+    # Some interior travel (crossing the hole) exists besides the buffers.
+    assert any(
+        0.0 < move["start"][0] < 7.0 and 0.0 < move["end"][0] < 7.0
+        for move in travel_moves
+    )
+
+
+def test_rectangular_spiral_polyline_reverses_center_to_edge() -> None:
+    inward = _rectangular_spiral_polyline((0.0, 0.0, 3.0, 3.0), 1.0)
+    outward = _rectangular_spiral_polyline((0.0, 0.0, 3.0, 3.0), 1.0, reverse=True)
+
+    assert inward[0] != inward[-1]
+    assert outward[0] == inward[-1]
+    assert outward[-1] == inward[0]
+
+
+def test_rectangular_spiral_raster_reverses_between_layers(tmp_path) -> None:
+    layer = box(0.0, 0.0, 3.0, 3.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer),
+        shape_name="rectangular_spiral",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_RECTANGULAR_SPIRAL,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    first_layer_change = next(
+        move for move in moves if move["end"][2] > move["start"][2]
+    )
+
+    assert first_layer_change["start"][:2] == first_layer_change["end"][:2]
+    end_x, end_y, end_z = moves[-1]["end"]
+    assert abs(end_x) < 1e-9
+    assert abs(end_y) < 1e-9
+    assert end_z == 1.0
+
+
+def test_circle_spiral_points_decrease_radius_to_center() -> None:
+    points = _circle_spiral_points(2.0, 3.0, outer_radius=4.0, pitch=1.0)
+    radii = [math.hypot(x - 2.0, y - 3.0) for x, y in points]
+
+    assert radii[0] == 4.0
+    assert radii[-1] == 0.0
+    assert all(
+        current <= previous + 1e-9
+        for previous, current in zip(radii, radii[1:])
+    )
+
+
+def test_circle_spiral_raster_reverses_between_layers(tmp_path) -> None:
+    layer = box(0.0, 0.0, 5.0, 5.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer),
+        shape_name="circle_spiral",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_CIRCLE_SPIRAL,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    first_layer_change = next(
+        move for move in moves if move["end"][2] > move["start"][2]
+    )
+
+    assert first_layer_change["start"][:2] == first_layer_change["end"][:2]
+    end_x, end_y, end_z = moves[-1]["end"]
+    assert abs(end_x) < 1e-9
+    assert abs(end_y) < 1e-9
+    assert end_z == 1.0
+
+
+def test_layer_contour_loops_follow_polygon_rings() -> None:
+    hollow = MultiPolygon(
+        [
+            Polygon(
+                box(0.0, 0.0, 4.0, 4.0).exterior.coords,
+                [list(box(1.0, 1.0, 2.0, 2.0).exterior.coords)],
+            )
+        ]
+    )
+
+    loops = _layer_contour_loops(hollow)
+
+    assert len(loops) == 2
+    # Largest loop (the exterior) sorts first.
+    assert set(loops[0]) == {(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0)}
+    assert set(loops[1]) == {(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0)}
+    assert loops[0][0] == loops[0][-1]
+    assert loops[1][0] == loops[1][-1]
+
+
+def test_contour_tracing_travels_to_nearest_border_after_infill(tmp_path) -> None:
+    layer = box(0.0, 0.0, 1.0, 1.0)
+    stack = _stack(layer)
+    gcode_path = generate_vector_gcode(
+        stack,
+        shape_name="nearest_border_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_sources=[ContourSource(owner_idx=1, stack=stack)],
+        active_contour_owner=1,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+
+    # Move 0 is the valve-settle approach, move 1 the single infill sweep.
+    assert moves[1]["color"] == 255
+    infill_end = moves[1]["end"]
+    # The contour starts printing from the point nearest the infill end,
+    # with no travel in between (the trailing buffer is rewound).
+    assert moves[2]["color"] == 255
+    assert moves[2]["start"] == infill_end
+
+
+def test_contour_tracing_closes_loop_and_restores_raster_endpoint(tmp_path) -> None:
+    layer = box(0.0, 0.0, 2.0, 2.0)
+    stack = _stack(layer, layer)
+    gcode_path = generate_vector_gcode(
+        stack,
+        shape_name="contour_loop",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        all_g1=True,
+        contour_sources=[ContourSource(owner_idx=1, stack=stack)],
+        active_contour_owner=1,
+        output_dir=tmp_path,
+    )
+
+    all_moves = _moves_with_colors(gcode_path.read_text())
+    for layer_z in (0.0, 1.0):
+        layer_moves = [
+            move
+            for move in all_moves
+            if move["start"][2] == layer_z and move["end"][2] == layer_z
+        ]
+        layer_prints = [move for move in layer_moves if move["color"] == 255]
+        assert layer_prints
+
+        # The contour is a closed loop: the last print returns to where the
+        # contour started.
+        contour_prints = layer_prints[2:]
+        assert contour_prints
+        assert contour_prints[-1]["end"] == contour_prints[0]["start"]
+
+        # After the contour, a travel move restores the raster endpoint.
+        last_print_index = max(
+            idx for idx, move in enumerate(layer_moves) if move["color"] == 255
+        )
+        trailing = layer_moves[last_print_index + 1 :]
+        assert trailing
+        assert all(move["color"] == 0 for move in trailing)
+
+
+def test_contour_tracing_keeps_hollow_rings_separate() -> None:
+    output = [{"X": 0.0, "Y": 0.0, "Color": 255}]
+    contour_layers = [
+        [
+            {
+                "owner_idx": 1,
+                "contours": [
+                    [(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0), (0.0, 0.0)],
+                    [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)],
+                ],
+            }
+        ]
+    ]
+
+    current_x, current_y = _append_layer_contours(
+        output,
+        0.0,
+        0.0,
+        contour_layers,
+        layer_number=0,
+        active_owner_idx=1,
+    )
+
+    contour_print_moves = [move for move in output[1:] if move["Color"] == 255]
+
+    assert len(contour_print_moves) == 8
+    assert (current_x, current_y) == (1.0, 1.0)
+
+
+def test_contour_tracing_skips_inactive_nozzle_outline(tmp_path) -> None:
+    blank_stack = _stack(None)
+    contour_stack = _stack(box(0.0, 0.0, 1.0, 1.0))
+    contour_sources = [ContourSource(owner_idx=1, stack=contour_stack)]
+
+    active_path = generate_vector_gcode(
+        blank_stack,
+        shape_name="active_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_sources=contour_sources,
+        active_contour_owner=1,
+        output_dir=tmp_path / "active",
+    )
+    inactive_path = generate_vector_gcode(
+        blank_stack,
+        shape_name="inactive_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_sources=contour_sources,
+        active_contour_owner=2,
+        output_dir=tmp_path / "inactive",
+    )
+
+    active_text = active_path.read_text()
+    inactive_text = inactive_path.read_text()
+
+    assert _move_signature(active_text)
+    assert _move_signature(inactive_text) == []
+    assert any(
+        line.startswith("G1") and "; Color 255" in line
+        for line in active_text.splitlines()
+    )
+    assert not any("; Color 255" in line for line in inactive_text.splitlines())
+
+
+def test_inactive_contour_tracing_preserves_original_raster_moves(tmp_path) -> None:
+    layer = box(1.0, 1.0, 3.0, 2.0)
+    stack = _stack(layer, layer)
+
+    original_path = generate_vector_gcode(
+        stack,
+        shape_name="original_raster",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        output_dir=tmp_path / "original",
+    )
+    inactive_path = generate_vector_gcode(
+        stack,
+        shape_name="inactive_contour_raster",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_sources=[ContourSource(owner_idx=2, stack=stack)],
+        active_contour_owner=1,
+        output_dir=tmp_path / "inactive",
+    )
+
+    assert _move_signature(inactive_path.read_text()) == _move_signature(
+        original_path.read_text()
+    )
+
+
+def test_reference_motion_shares_path_and_gates_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
+
+    def _generate(stack: LayerStack, label: str):
+        return generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            motion=reference,
+            output_dir=tmp_path / label,
+        )
+
+    small_moves = _moves_with_colors(_generate(small, "small").read_text())
+    big_moves = _moves_with_colors(_generate(big, "big").read_text())
+
+    # Both shapes follow the same shared motion path: identical final position
+    # and identical total path length (the moves split at different valve
+    # boundaries, but the traversed polyline is the same).
+    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
+
+    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
+        )
+
+    # The big shape dispenses over more of the shared path than the small one.
+    assert _print_length(small_moves) > 0
+    assert _print_length(big_moves) > _print_length(small_moves)
+    # The small shape's total print length matches its own area coverage:
+    # 2mm-wide rows on the shared 4-row sweep -> only rows inside the small box.
+    assert _print_length(small_moves) < _print_length(big_moves) / 2 + 4.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")
+
+    reference = build_reference_stack([first, second])
+
+    assert reference is not None
+    # The second stack is re-centred onto the first stack's bbox centre (1, 1).
+    assert reference.bounds == ((-1.0, -1.0, 0.0), (3.0, 3.0, 1.0))
+    assert reference.layers[0].area == 16.0
+    assert len(reference.layers) == 1
+    assert reference.z_values == [0.5]
+
+
+def test_split_layer_stack_grid_produces_row_major_cells() -> None:
+    layer = box(10.0, -2.0, 12.5, -1.0)
+    stack = _stack(layer, name="strip")
+
+    pieces = split_layer_stack_grid(stack, columns=2, rows=1)
+
+    assert [piece.name for piece in pieces] == ["strip_r01_c01", "strip_r01_c02"]
+    assert pieces[0].bounds[0][0] == 10.0
+    assert pieces[1].bounds[0][0] == 11.25
+    total_area = sum(piece.layers[0].area for piece in pieces)
+    assert abs(total_area - layer.area) < 1e-9
+
+
+def test_split_layer_stack_grid_orders_rows_top_down() -> None:
+    layer = box(0.0, 0.0, 4.0, 4.0)
+    stack = _stack(layer, name="grid")
+
+    pieces = split_layer_stack_grid(stack, columns=2, rows=2)
+
+    assert [piece.name for piece in pieces] == [
+        "grid_r01_c01",
+        "grid_r01_c02",
+        "grid_r02_c01",
+        "grid_r02_c02",
+    ]
+    # Row 1 is the top strip (max-Y side).
+    assert pieces[0].bounds == ((0.0, 2.0, 0.0), (2.0, 4.0, 1.0))
+    assert pieces[3].bounds == ((2.0, 0.0, 0.0), (4.0, 2.0, 1.0))
+    assert all(piece.layers[0].area == 4.0 for piece in pieces)
+
+
+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")
+
+    pieces = split_layer_stack_grid(
+        stack,
+        columns=2,
+        rows=1,
+        overlapping_layers=True,
+        overlap=0.5,
+    )
+
+    left, right = pieces
+    # The cut line alternates by +/- overlap between layers, so each piece's
+    # area differs between layer 0 and layer 1 while the totals stay constant.
+    assert left.layers[0].area != left.layers[1].area
+    assert abs(left.layers[0].area - left.layers[1].area) == 2.0  # 2*(0.5*2)
+    for index in range(2):
+        combined = left.layers[index].area + right.layers[index].area
+        assert abs(combined - layer.area) < 1e-9
+    # Nominal bounds stay the un-shifted cells.
+    assert left.bounds == ((0.0, 0.0, 0.0), (2.0, 2.0, 2.0))
+    assert right.bounds == ((2.0, 0.0, 0.0), (4.0, 2.0, 2.0))

vector_gcode.py

@@ -0,0 +1,271 @@
+"""G-code emission for vector layer stacks.
+
+Writes the same machine dialect as the old TIFF pipeline: G91 relative moves,
+G0 travel / G1 print (or all-G1), WAGO valve commands on every valve-state
+change, and serial pressure preset/toggle commands with an optional per-layer
+pressure ramp.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from codecs import encode
+from pathlib import Path
+from textwrap import wrap
+
+from stl_slicer import LayerStack
+from vector_toolpath import (
+    RASTER_PATTERN_CHOICES,
+    RASTER_PATTERN_CIRCLE_SPIRAL,
+    RASTER_PATTERN_RECTANGULAR_SPIRAL,
+    RASTER_PATTERN_SAME_DIRECTION,
+    RASTER_PATTERN_WOODPILE,
+    RASTER_PATTERN_Y_DIRECTION,
+    ContourSource,
+    _lead_in_moves,
+    _normalize_raster_pattern,
+    align_stack_to,
+    build_contour_layers,
+    plan_layer_moves,
+)
+
+__all__ = [
+    "RASTER_PATTERN_CHOICES",
+    "RASTER_PATTERN_CIRCLE_SPIRAL",
+    "RASTER_PATTERN_RECTANGULAR_SPIRAL",
+    "RASTER_PATTERN_SAME_DIRECTION",
+    "RASTER_PATTERN_WOODPILE",
+    "RASTER_PATTERN_Y_DIRECTION",
+    "ContourSource",
+    "generate_vector_gcode",
+    "write_gcode_file",
+]
+
+
+def _setpress(pressure: float) -> str:
+    pressure_str = str(int(pressure * 10)).zfill(4)
+    command_bytes = bytes("08PS  " + pressure_str, "utf-8")
+    hex_command = encode(command_bytes, "hex").decode("utf-8")
+    format_command = "\\x" + "\\x".join(
+        hex_command[i : i + 2] for i in range(0, len(hex_command), 2)
+    )
+
+    hex_pairs = wrap(hex_command, 2)
+    decimal_sum = sum(int(pair, 16) for pair in hex_pairs)
+    checksum_bin = bin(decimal_sum % 256)[2:].zfill(8)
+    inverted = int("".join("1" if c == "0" else "0" for c in checksum_bin), 2) + 1
+    checksum_hex = hex(inverted)[2:].upper()
+    format_checksum = "\\x" + "\\x".join(
+        checksum_hex[i : i + 2] for i in range(0, len(checksum_hex), 2)
+    )
+
+    return "b'" + "\\x05\\x02" + format_command + format_checksum + "\\x03" + "'"
+
+
+def _togglepress() -> str:
+    return "b'\\x05\\x02\\x30\\x34\\x44\\x49\\x20\\x20\\x43\\x46\\x03'"
+
+
+def _setpress_cmd(port: str, pressure: float, start: bool) -> str:
+    if start:
+        return f"\n\r{port}.write(eval(setpress({pressure:g})))"
+    insert = ""
+    return f"\n\r{insert}{port}.write({_setpress(pressure)})"
+
+
+def _toggle_cmd(port: str, start: bool) -> str:
+    if start:
+        return f"\n\r{port}.write(eval(togglepress()))"
+    insert = ""
+    return f"\n\r{insert}{port}.write({_togglepress()})"
+
+
+def _valve_cmd(valve: int, command: int) -> str:
+    return f"\n{{aux_command}}WAGO_ValveCommands({valve}, {command})\n"
+
+
+def _coord(value: float) -> str:
+    """Format a coordinate in fixed-point notation, never scientific.
+
+    Python's repr writes small floats as e.g. "-5.1e-08", which G-code axis
+    parsers (including this project's viewer) misread as "-5.1".
+    """
+    text = f"{float(value):.6f}".rstrip("0")
+    if text.endswith("."):
+        text += "0"
+    if text in ("-0.0", "-0"):
+        return "0.0"
+    return text
+
+
+def write_gcode_file(
+    gcode_path: Path,
+    gcode_list: list[dict],
+    pressure: float,
+    valve: int,
+    port: int,
+    increase_pressure_per_layer: float,
+    pressure_ramp_enabled: bool,
+    all_g1: bool,
+) -> None:
+    off_color = 0
+    com_port = f"serialPort{port}"
+    color_dict: dict[int, int] = {0: 100, 255: valve}
+
+    setpress_lines = [_setpress_cmd(com_port, pressure, start=True)]
+    pressure_on_lines = [_toggle_cmd(com_port, start=True)]
+    pressure_off_lines = [_toggle_cmd(com_port, start=False)]
+
+    pressure_cur = float(pressure)
+
+    with open(gcode_path, "w") as f:
+        f.write("G91\n")
+        f.write(_valve_cmd(valve, 0))
+        for line in setpress_lines:
+            f.write(f"{line}\n")
+        for line in pressure_on_lines:
+            f.write(f"{line}\n")
+        for color in color_dict:
+            f.write(_valve_cmd(color_dict[color], 0))
+
+        pressure_next: str | None = None
+        for i, move in enumerate(gcode_list):
+            prev_color = gcode_list[i - 1]["Color"] if i > 0 else 0
+            cur_color = move["Color"]
+            if prev_color != cur_color:
+                if cur_color == off_color:
+                    f.write(_valve_cmd(color_dict[prev_color], 0))
+                else:
+                    if prev_color == off_color:
+                        f.write(_valve_cmd(color_dict[cur_color], 1))
+                    else:
+                        f.write(_valve_cmd(color_dict[cur_color], 1))
+                        f.write(_valve_cmd(color_dict[prev_color], 0))
+
+            # When all_g1 is set, every move is emitted as G1 regardless of
+            # valve state; the valve commands still mark print vs travel.
+            move_type = "G1" if (all_g1 or cur_color != off_color) else "G0"
+            if "Z" in move:
+                line = (
+                    f"{move_type} X{_coord(move['X'])} Y{_coord(move['Y'])} "
+                    f"Z{_coord(move['Z'])} ; Color {move['Color']}"
+                )
+                if pressure_ramp_enabled:
+                    pressure_cur += increase_pressure_per_layer
+                    pressure_next = _setpress_cmd(com_port, pressure_cur, start=False)
+                else:
+                    pressure_next = None
+            else:
+                line = (
+                    f"{move_type} X{_coord(move['X'])} Y{_coord(move['Y'])} "
+                    f"; Color {move['Color']}"
+                )
+                pressure_next = None
+
+            f.write(f"{line}\n")
+            if pressure_next is not None:
+                f.write(f"{pressure_next}\n")
+                pressure_next = None
+
+        for color in color_dict:
+            f.write(_valve_cmd(color_dict[color], 0))
+        for line in pressure_off_lines:
+            f.write(f"{line}\n")
+
+
+def generate_vector_gcode(
+    shape: LayerStack,
+    *,
+    shape_name: str,
+    pressure: float,
+    valve: int,
+    port: int,
+    fil_width: float,
+    layer_height: float | None = None,
+    raster_pattern: str | None = RASTER_PATTERN_SAME_DIRECTION,
+    motion: LayerStack | None = None,
+    contour_sources: list[ContourSource] | None = None,
+    active_contour_owner: int | None = None,
+    increase_pressure_per_layer: float = 0.1,
+    pressure_ramp_enabled: bool = True,
+    all_g1: bool = False,
+    lead_in_enabled: bool = False,
+    lead_in_length: float = 5.0,
+    lead_in_clearance: float = 5.0,
+    lead_in_lines: int = 3,
+    output_dir: str | Path | None = None,
+) -> Path:
+    """Generate G-code for one sliced shape.
+
+    Without `motion`, the shape's own layers drive both the nozzle path and
+    the valve. With `motion` (the combined reference stack), the nozzle
+    follows the shared reference path while the valve opens only inside this
+    shape's own geometry, aligned into the reference frame — so parallel
+    heads share one motion but each dispenses only its own shape.
+    """
+    if shape is None or not shape.layers:
+        raise ValueError("The shape has no sliced layers to generate G-code from.")
+    if fil_width <= 0:
+        raise ValueError("Filament width must be greater than zero.")
+
+    raster_pattern = _normalize_raster_pattern(raster_pattern)
+    if layer_height is None:
+        layer_height = shape.layer_height
+
+    if motion is not None:
+        if not motion.layers:
+            raise ValueError("The reference stack has no layers for motion.")
+        motion_layers = motion.layers
+        valve_layers = align_stack_to(shape, motion, len(motion.layers))
+        contour_reference = motion
+    else:
+        motion_layers = shape.layers
+        valve_layers = shape.layers
+        contour_reference = None
+
+    contour_layers = build_contour_layers(
+        contour_sources,
+        len(motion_layers),
+        reference=contour_reference,
+    )
+
+    gcode_list = plan_layer_moves(
+        motion_layers,
+        valve_layers,
+        fil_width,
+        float(layer_height),
+        raster_pattern,
+        contour_layers,
+        active_contour_owner,
+    )
+
+    lead_in = _lead_in_moves(
+        lead_in_enabled,
+        lead_in_length,
+        lead_in_clearance,
+        lead_in_lines,
+        fil_width,
+        255,
+        0,
+    )
+    if lead_in:
+        gcode_list = [*lead_in, *gcode_list]
+
+    if output_dir is None:
+        output_dir = Path(tempfile.mkdtemp(prefix="vector_gcode_"))
+    else:
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+    gcode_path = output_dir / f"{shape_name}_SnakePath_gcode.txt"
+    write_gcode_file(
+        gcode_path,
+        gcode_list,
+        pressure=float(pressure),
+        valve=int(valve),
+        port=int(port),
+        increase_pressure_per_layer=float(increase_pressure_per_layer),
+        pressure_ramp_enabled=bool(pressure_ramp_enabled),
+        all_g1=bool(all_g1),
+    )
+    return gcode_path

vector_toolpath.py

@@ -0,0 +1,1209 @@
+"""Vector toolpath generation: shapely layer polygons -> printable move lists.
+
+Replaces the pixel-raster core of the old TIFF pipeline. All geometry lives in
+world-XY millimetres; every motion segment is a 5-tuple
+``(x0, y0, x1, y1, color)`` where color 255 means the dispensing valve is open
+and 0 means travel. `fil_width` is both the raster line spacing and the
+filament width.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from shapely import prepare
+from shapely.affinity import translate
+from shapely.geometry import LineString, MultiPolygon, Point, box
+from shapely.geometry.polygon import orient
+from shapely.ops import unary_union
+
+from stl_slicer import LayerStack, _as_multipolygon
+
+
+EPS = 1e-6
+
+RASTER_PATTERN_SAME_DIRECTION = "X-direction raster"
+RASTER_PATTERN_Y_DIRECTION = "Y-direction raster"
+RASTER_PATTERN_WOODPILE = "Woodpile raster"
+RASTER_PATTERN_RECTANGULAR_SPIRAL = "Rectangular Spiral raster"
+RASTER_PATTERN_CIRCLE_SPIRAL = "Circle Spiral raster"
+RASTER_PATTERN_CHOICES = (
+    RASTER_PATTERN_SAME_DIRECTION,
+    RASTER_PATTERN_Y_DIRECTION,
+    RASTER_PATTERN_WOODPILE,
+    RASTER_PATTERN_RECTANGULAR_SPIRAL,
+    RASTER_PATTERN_CIRCLE_SPIRAL,
+)
+
+Seg = tuple[float, float, float, float, int]
+
+
+@dataclass(slots=True)
+class ContourSource:
+    owner_idx: int
+    stack: LayerStack
+
+
+def _normalize_raster_pattern(pattern: str | None) -> str:
+    if pattern in RASTER_PATTERN_CHOICES:
+        return pattern
+    return RASTER_PATTERN_SAME_DIRECTION
+
+
+def _raster_axis_for_pattern(pattern: str, layer_number: int) -> str:
+    if pattern == RASTER_PATTERN_Y_DIRECTION:
+        return "Y"
+    if pattern == RASTER_PATTERN_WOODPILE and layer_number % 2 == 1:
+        return "Y"
+    return "X"
+
+
+def _iter_linestrings(geometry: object):
+    if geometry is None or getattr(geometry, "is_empty", True):
+        return
+    geom_type = geometry.geom_type
+    if geom_type == "LineString":
+        yield geometry
+    elif geom_type in ("MultiLineString", "GeometryCollection"):
+        for part in geometry.geoms:
+            yield from _iter_linestrings(part)
+
+
+def _iter_coords(geometry: object):
+    if geometry is None or getattr(geometry, "is_empty", True):
+        return
+    geom_type = geometry.geom_type
+    if geom_type == "Point":
+        yield geometry.x, geometry.y
+    elif geom_type == "LineString":
+        for coord in geometry.coords:
+            yield coord[0], coord[1]
+    elif geom_type in ("MultiPoint", "MultiLineString", "GeometryCollection"):
+        for part in geometry.geoms:
+            yield from _iter_coords(part)
+
+
+def _point_distance_sq(ax: float, ay: float, bx: float, by: float) -> float:
+    return (ax - bx) ** 2 + (ay - by) ** 2
+
+
+def _closest_point_on_segment(
+    px: float,
+    py: float,
+    ax: float,
+    ay: float,
+    bx: float,
+    by: float,
+) -> tuple[float, float, float]:
+    dx = bx - ax
+    dy = by - ay
+    length_sq = dx * dx + dy * dy
+    if length_sq == 0:
+        return ax, ay, 0.0
+    t = ((px - ax) * dx + (py - ay) * dy) / length_sq
+    t = max(0.0, min(1.0, t))
+    return ax + t * dx, ay + t * dy, t
+
+
+def _append_colored_segment(
+    segments: list[Seg],
+    start_x: float,
+    start_y: float,
+    end_x: float,
+    end_y: float,
+    color: int,
+) -> None:
+    if start_x == end_x and start_y == end_y:
+        return
+
+    if segments:
+        prev_start_x, prev_start_y, prev_end_x, prev_end_y, prev_color = segments[-1]
+        if (
+            prev_color == color
+            and prev_end_x == start_x
+            and prev_end_y == start_y
+        ):
+            prev_dx = prev_end_x - prev_start_x
+            prev_dy = prev_end_y - prev_start_y
+            next_dx = end_x - start_x
+            next_dy = end_y - start_y
+            if abs((prev_dx * next_dy) - (prev_dy * next_dx)) < 1e-9:
+                segments[-1] = (
+                    prev_start_x,
+                    prev_start_y,
+                    end_x,
+                    end_y,
+                    color,
+                )
+                return
+
+    segments.append((start_x, start_y, end_x, end_y, color))
+
+
+def _append_relative_move(
+    output_list: list[dict],
+    current_x: float,
+    current_y: float,
+    target_x: float,
+    target_y: float,
+    color: int,
+    z_step: float | None = None,
+) -> tuple[float, float]:
+    # Round away GEOS float noise (sub-micron residues, -0.0) so the emitted
+    # G-code stays clean; position tracking keeps the exact targets. Six
+    # decimals (1 nm) is far below any printable resolution, and rounding here
+    # also guarantees the writer can format every delta without scientific
+    # notation (which G-code parsers misread: "X-5.1e-08" parses as X-5.1).
+    dx = round(target_x - current_x, 6) + 0.0
+    dy = round(target_y - current_y, 6) + 0.0
+    if dx == 0 and dy == 0 and z_step is None:
+        return current_x, current_y
+    move = {"X": dx, "Y": dy, "Color": color}
+    if z_step is not None:
+        move["Z"] = z_step
+    output_list.append(move)
+    return target_x, target_y
+
+
+def _chord_runs(
+    region: MultiPolygon,
+    axis: str,
+    coord: float,
+    eps: float = EPS,
+) -> list[tuple[float, float]]:
+    """Sorted, merged (lo, hi) intervals where an axis-aligned scanline is inside `region`.
+
+    Axis "X": horizontal scanline at y=coord, runs measured along X.
+    Axis "Y": vertical scanline at x=coord, runs measured along Y.
+    """
+    if region is None or region.is_empty:
+        return []
+
+    min_x, min_y, max_x, max_y = region.bounds
+    if axis == "Y":
+        if coord < min_x - eps or coord > max_x + eps:
+            return []
+        line = LineString([(coord, min_y - 1.0), (coord, max_y + 1.0)])
+        index = 1
+    else:
+        if coord < min_y - eps or coord > max_y + eps:
+            return []
+        line = LineString([(min_x - 1.0, coord), (max_x + 1.0, coord)])
+        index = 0
+
+    runs: list[tuple[float, float]] = []
+    for piece in _iter_linestrings(region.intersection(line)):
+        if piece.length <= eps:
+            continue
+        values = [coords[index] for coords in piece.coords]
+        runs.append((min(values), max(values)))
+
+    runs.sort()
+    merged: list[tuple[float, float]] = []
+    for lo, hi in runs:
+        if merged and lo <= merged[-1][1] + eps:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], hi))
+        else:
+            merged.append((lo, hi))
+    return merged
+
+
+def _point_along(
+    t: float,
+    x0: float,
+    y0: float,
+    x1: float,
+    y1: float,
+) -> tuple[float, float]:
+    if t <= 0.0:
+        return x0, y0
+    if t >= 1.0:
+        return x1, y1
+    return x0 + (x1 - x0) * t, y0 + (y1 - y0) * t
+
+
+def _classify_polyline(
+    points: list[tuple[float, float]],
+    valve: MultiPolygon,
+    eps: float = EPS,
+) -> 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.
+    """
+    segments: list[Seg] = []
+    has_valve = valve is not None and not valve.is_empty
+    if has_valve:
+        prepare(valve)
+        boundary = valve.boundary
+
+    for (x0, y0), (x1, y1) in zip(points, points[1:]):
+        dx = x1 - x0
+        dy = y1 - y0
+        seg_len = math.hypot(dx, dy)
+        if seg_len <= eps:
+            continue
+
+        if not has_valve:
+            _append_colored_segment(segments, x0, y0, x1, y1, 0)
+            continue
+
+        ts = {0.0, 1.0}
+        crossings = LineString([(x0, y0), (x1, y1)]).intersection(boundary)
+        for cx, cy in _iter_coords(crossings):
+            t = ((cx - x0) * dx + (cy - y0) * dy) / (seg_len * seg_len)
+            ts.add(max(0.0, min(1.0, t)))
+
+        t_eps = eps / seg_len
+        ordered = sorted(ts)
+        deduped = [ordered[0]]
+        for t in ordered[1:]:
+            if t - deduped[-1] > t_eps:
+                deduped.append(t)
+            else:
+                deduped[-1] = max(deduped[-1], t)
+
+        for t0, t1 in zip(deduped, deduped[1:]):
+            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
+            start = _point_along(t0, x0, y0, x1, y1)
+            end = _point_along(t1, x0, y0, x1, y1)
+            _append_colored_segment(segments, *start, *end, color)
+
+    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]
+
+    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
+
+
+def _axis_raster_segments(
+    motion: MultiPolygon,
+    valve: MultiPolygon,
+    fil_width: float,
+    axis: str,
+    reverse_order: bool = False,
+    start_forward: bool = True,
+) -> 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.
+    """
+    if motion is None or motion.is_empty:
+        return []
+
+    min_x, min_y, max_x, max_y = motion.bounds
+    if axis == "Y":
+        scan_lo, scan_hi = min_x, max_x
+    else:
+        scan_lo, scan_hi = min_y, max_y
+
+    coords = _scan_coords(scan_lo, scan_hi, fil_width)
+    if reverse_order:
+        coords = coords[::-1]
+
+    segments: list[Seg] = []
+    sweep_number = 0
+    for coord in coords:
+        motion_runs = _chord_runs(motion, axis, coord)
+        if not motion_runs:
+            continue
+
+        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))
+
+        def emit(a: float, b: float, color: int) -> None:
+            if axis == "Y":
+                _append_colored_segment(segments, coord, a, coord, b, color)
+            else:
+                _append_colored_segment(segments, a, coord, b, coord, color)
+
+        forward = (sweep_number % 2 == 0) == start_forward
+        sweep_number += 1
+
+        if forward:
+            emit(sweep_lo - fil_width, sweep_lo, 0)
+            current = sweep_lo
+            for lo, hi in valve_runs:
+                if lo - current > EPS:
+                    emit(current, lo, 0)
+                    current = lo
+                start = max(lo, current)
+                if hi - start > EPS:
+                    emit(start, hi, 255)
+                    current = hi
+            if sweep_hi - current > EPS:
+                emit(current, sweep_hi, 0)
+                current = sweep_hi
+            emit(current, current + fil_width, 0)
+        else:
+            emit(sweep_hi + fil_width, sweep_hi, 0)
+            current = sweep_hi
+            for lo, hi in reversed(valve_runs):
+                if current - hi > EPS:
+                    emit(current, hi, 0)
+                    current = hi
+                start = min(hi, current)
+                if start - lo > EPS:
+                    emit(start, lo, 255)
+                    current = lo
+            if current - sweep_lo > EPS:
+                emit(current, sweep_lo, 0)
+                current = sweep_lo
+            emit(current, current - fil_width, 0)
+
+    return segments
+
+
+def _oriented_axis_raster_segments(
+    motion: MultiPolygon,
+    valve: MultiPolygon,
+    fil_width: float,
+    axis: str,
+    current_x: float,
+    current_y: float,
+    prefer_default: bool = False,
+) -> list[Seg]:
+    """Pick the raster orientation whose start is nearest the current position."""
+    default_segments = _axis_raster_segments(motion, valve, fil_width, axis)
+    if prefer_default or not default_segments:
+        return default_segments
+
+    candidates: list[list[Seg]] = [default_segments]
+    for reverse_order in (False, True):
+        for start_forward in (False, True):
+            segments = _axis_raster_segments(
+                motion,
+                valve,
+                fil_width,
+                axis,
+                reverse_order=reverse_order,
+                start_forward=start_forward,
+            )
+            if segments and segments not in candidates:
+                candidates.append(segments)
+
+    return min(
+        candidates,
+        key=lambda segments: _point_distance_sq(
+            current_x,
+            current_y,
+            segments[0][0],
+            segments[0][1],
+        ),
+    )
+
+
+def _extend_polyline_ends(
+    points: list[tuple[float, float]],
+    length: float,
+) -> list[tuple[float, float]]:
+    """Extend both polyline ends by `length` along their local directions."""
+    if len(points) < 2:
+        return points
+
+    (x0, y0), (x1, y1) = points[0], points[1]
+    distance = math.hypot(x1 - x0, y1 - y0)
+    if distance > 0:
+        points = [
+            (x0 - (x1 - x0) / distance * length, y0 - (y1 - y0) / distance * length),
+            *points,
+        ]
+
+    (xa, ya), (xb, yb) = points[-2], points[-1]
+    distance = math.hypot(xb - xa, yb - ya)
+    if distance > 0:
+        points = [
+            *points,
+            (xb + (xb - xa) / distance * length, yb + (yb - ya) / distance * length),
+        ]
+    return points
+
+
+def _rectangular_spiral_polyline(
+    bounds: tuple[float, float, float, float],
+    fil_width: float,
+    reverse: bool = False,
+) -> list[tuple[float, float]]:
+    """Corner polyline spiralling from the bounds inward (or outward if reversed)."""
+    min_x, min_y, max_x, max_y = bounds
+    half = fil_width / 2.0
+    left = min_x + half
+    right = max_x - half
+    bottom = min_y + half
+    top = max_y - half
+    if right < left:
+        left = right = (min_x + max_x) / 2.0
+    if top < bottom:
+        bottom = top = (min_y + max_y) / 2.0
+
+    eps = 1e-9
+    points: list[tuple[float, float]] = []
+
+    def add(x: float, y: float) -> None:
+        if not points or _point_distance_sq(points[-1][0], points[-1][1], x, y) > eps:
+            points.append((x, y))
+
+    while left <= right + eps and bottom <= top + eps:
+        add(left, top)
+        add(right, top)
+        top -= fil_width
+
+        if bottom <= top + eps:
+            add(right, bottom)
+        right -= fil_width
+
+        if bottom <= top + eps:
+            add(left, bottom)
+            bottom += fil_width
+
+        if left <= right + eps:
+            if bottom <= top + eps:
+                add(left, top)
+            left += fil_width
+
+    if len(points) == 1:
+        center_x, center_y = points[0]
+        points = [(center_x - half, center_y), (center_x + half, center_y)]
+        if reverse:
+            points.reverse()
+        return points
+
+    if reverse:
+        points.reverse()
+    return _extend_polyline_ends(points, half)
+
+
+def _circle_spiral_points(
+    center_x: float,
+    center_y: float,
+    outer_radius: float,
+    pitch: float,
+) -> list[tuple[float, float]]:
+    if outer_radius <= 0.0:
+        return [(center_x, center_y)]
+
+    pitch = max(float(pitch), 1e-9)
+    sample_spacing = pitch
+    theta_max = (outer_radius / pitch) * 2.0 * math.pi
+    theta = 0.0
+    points = [(center_x + outer_radius, center_y)]
+
+    while theta < theta_max:
+        radius = max(outer_radius - (pitch * theta / (2.0 * math.pi)), 0.0)
+        d_theta = min(math.pi / 10.0, sample_spacing / max(radius, pitch))
+        theta = min(theta + d_theta, theta_max)
+        radius = max(outer_radius - (pitch * theta / (2.0 * math.pi)), 0.0)
+        points.append(
+            (
+                center_x + (radius * math.cos(theta)),
+                center_y + (radius * math.sin(theta)),
+            )
+        )
+
+    if points[-1] != (center_x, center_y):
+        points.append((center_x, center_y))
+    return points
+
+
+def _circle_spiral_polyline(
+    bounds: tuple[float, float, float, float],
+    fil_width: float,
+    reverse: bool = False,
+) -> list[tuple[float, float]]:
+    min_x, min_y, max_x, max_y = bounds
+    center_x = (min_x + max_x) / 2.0
+    center_y = (min_y + max_y) / 2.0
+    outer_radius = max(
+        math.hypot(corner_x - center_x, corner_y - center_y)
+        for corner_x, corner_y in (
+            (min_x, min_y),
+            (max_x, min_y),
+            (max_x, max_y),
+            (min_x, max_y),
+        )
+    )
+
+    points = _circle_spiral_points(center_x, center_y, outer_radius, fil_width)
+    if reverse:
+        points.reverse()
+    return points
+
+
+def _contour_area2(points: list[tuple[float, float]]) -> float:
+    return sum(
+        x0 * y1 - x1 * y0
+        for (x0, y0), (x1, y1) in zip(points, points[1:])
+    )
+
+
+def _contour_sort_key(points: list[tuple[float, float]]) -> tuple[float, float, float]:
+    xs = [point[0] for point in points]
+    ys = [point[1] for point in points]
+    return (-abs(_contour_area2(points)), min(ys), min(xs))
+
+
+def _layer_contour_loops(layer: MultiPolygon) -> list[list[tuple[float, float]]]:
+    """Closed contour loops of a layer: exterior rings first, holes after."""
+    loops: list[list[tuple[float, float]]] = []
+    for polygon in layer.geoms:
+        oriented = orient(polygon)
+        for ring in (oriented.exterior, *oriented.interiors):
+            simplified = ring.simplify(0)
+            coords = [(float(x), float(y)) for x, y in simplified.coords]
+            if len(coords) >= 4:
+                loops.append(coords)
+
+    loops.sort(key=_contour_sort_key)
+    return loops
+
+
+def _rotate_closed_contour_to_nearest_border(
+    contour: list[tuple[float, float]],
+    current_x: float,
+    current_y: float,
+    approach_dx: float = 0.0,
+    approach_dy: float = 0.0,
+) -> list[tuple[float, float]]:
+    if len(contour) < 3:
+        return contour
+
+    ring = contour[:-1] if contour[0] == contour[-1] else contour
+    if len(ring) < 2:
+        return contour
+
+    best_idx = 0
+    best_t = 0.0
+    best_point = ring[0]
+    best_dist = float("inf")
+    for idx, (ax, ay) in enumerate(ring):
+        bx, by = ring[(idx + 1) % len(ring)]
+        point_x, point_y, t = _closest_point_on_segment(
+            current_x,
+            current_y,
+            ax,
+            ay,
+            bx,
+            by,
+        )
+        distance = _point_distance_sq(current_x, current_y, point_x, point_y)
+        if distance < best_dist:
+            best_dist = distance
+            best_idx = idx
+            best_t = t
+            best_point = (point_x, point_y)
+
+    eps = 1e-9
+
+    def choose_direction(
+        forward: list[tuple[float, float]],
+        reverse: list[tuple[float, float]],
+    ) -> list[tuple[float, float]]:
+        if (
+            len(forward) < 2
+            or len(reverse) < 2
+            or (approach_dx == 0 and approach_dy == 0)
+        ):
+            return forward
+
+        def score(candidate: list[tuple[float, float]]) -> float:
+            tx = candidate[1][0] - candidate[0][0]
+            ty = candidate[1][1] - candidate[0][1]
+            # Positive when the shape interior, opposite the approach vector,
+            # is to the left of the contour's first move.
+            return (ty * approach_dx) - (tx * approach_dy)
+
+        return reverse if score(reverse) > score(forward) else forward
+
+    if best_t <= eps:
+        forward = ring[best_idx:] + ring[:best_idx] + [ring[best_idx]]
+        reverse_ring = list(reversed(ring))
+        reverse_idx = reverse_ring.index(ring[best_idx])
+        reverse = (
+            reverse_ring[reverse_idx:]
+            + reverse_ring[:reverse_idx]
+            + [reverse_ring[reverse_idx]]
+        )
+        return choose_direction(forward, reverse)
+
+    next_idx = (best_idx + 1) % len(ring)
+    if best_t >= 1.0 - eps:
+        forward = ring[next_idx:] + ring[:next_idx] + [ring[next_idx]]
+        reverse_ring = list(reversed(ring))
+        reverse_idx = reverse_ring.index(ring[next_idx])
+        reverse = (
+            reverse_ring[reverse_idx:]
+            + reverse_ring[:reverse_idx]
+            + [reverse_ring[reverse_idx]]
+        )
+        return choose_direction(forward, reverse)
+
+    forward = [best_point]
+    for step in range(1, len(ring) + 1):
+        forward.append(ring[(best_idx + step) % len(ring)])
+    forward.append(best_point)
+
+    reverse = [best_point]
+    for step in range(0, len(ring)):
+        reverse.append(ring[(best_idx - step) % len(ring)])
+    reverse.append(best_point)
+    return choose_direction(forward, reverse)
+
+
+def _last_print_reference(output_list: list[dict]) -> tuple[float, float, float, float]:
+    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 move.get("Color") == 255 and "Z" not in move:
+            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,
+    current_y: float,
+) -> tuple[float, float]:
+    if not output_list:
+        return current_x, current_y
+
+    last_move = output_list[-1]
+    if last_move.get("Color") != 0 or "Z" in last_move:
+        return current_x, current_y
+
+    has_layer_print = any(
+        move.get("Color") == 255 and "Z" not in move
+        for move in reversed(output_list[:-1])
+    )
+    if not has_layer_print:
+        return current_x, current_y
+
+    output_list.pop()
+    return (
+        current_x - float(last_move.get("X", 0.0)),
+        current_y - float(last_move.get("Y", 0.0)),
+    )
+
+
+def build_contour_layers(
+    sources: list[ContourSource] | None,
+    n_layers: int,
+    reference: LayerStack | None = None,
+) -> list[list[dict]]:
+    """Per-layer contour loops per owning shape.
+
+    When `reference` is given (reference-motion mode) each source stack is
+    translated by its centering delta so contours land in the shared frame.
+    """
+    contour_layers: list[list[dict]] = [[] for _ in range(n_layers)]
+    for source in sources or []:
+        stack = source.stack
+        if stack is None or not stack.layers:
+            continue
+
+        if reference is not None:
+            layers = align_stack_to(stack, reference, n_layers)
+        else:
+            layers = stack.layers
+
+        for layer_number in range(min(n_layers, len(layers))):
+            layer = layers[layer_number]
+            if layer is None or layer.is_empty:
+                continue
+            contours = _layer_contour_loops(layer)
+            if contours:
+                contour_layers[layer_number].append(
+                    {
+                        "owner_idx": source.owner_idx,
+                        "contours": contours,
+                    }
+                )
+
+    return contour_layers
+
+
+def _append_layer_contours(
+    output_list: list[dict],
+    current_x: float,
+    current_y: float,
+    contour_layers: list[list[dict]],
+    layer_number: int,
+    active_owner_idx: int | None,
+    origin_x: float = 0.0,
+    origin_y: float = 0.0,
+) -> 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.
+    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
+        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,
+    )
+
+    use_infill_reference = True
+
+    for source in active_sources:
+        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
+                )
+                nearest_x += origin_x
+                nearest_y += origin_y
+            else:
+                nearest_x, nearest_y = current_x, current_y
+                approach_dx, approach_dy = 0.0, 0.0
+            contour = _rotate_closed_contour_to_nearest_border(
+                contour,
+                nearest_x,
+                nearest_y,
+                approach_dx,
+                approach_dy,
+            )
+            if contour[0] != contour[-1]:
+                contour = [*contour, contour[0]]
+            start_x, start_y = contour[0]
+            use_infill_reference = False
+            current_x, current_y = _append_relative_move(
+                output_list,
+                current_x,
+                current_y,
+                start_x,
+                start_y,
+                0,
+            )
+            for target_x, target_y in contour[1:]:
+                current_x, current_y = _append_relative_move(
+                    output_list,
+                    current_x,
+                    current_y,
+                    target_x,
+                    target_y,
+                    color,
+                )
+
+    return current_x, current_y
+
+
+def _lead_in_moves(
+    enabled: bool,
+    length: float,
+    clearance: float,
+    line_count: int,
+    line_spacing: float,
+    print_color: int,
+    off_color: int,
+) -> list[dict]:
+    if not enabled:
+        return []
+    lead_length = max(0.0, float(length))
+    if lead_length <= 0.0:
+        return []
+    lead_clearance = max(0.0, float(clearance))
+    pass_count = max(1, int(line_count))
+    spacing = max(0.0, float(line_spacing))
+
+    moves: list[dict] = []
+    current_x = 0.0
+    current_y = 0.0
+
+    def append_move(dx: float, dy: float, color: int) -> None:
+        nonlocal current_x, current_y
+        if dx == 0.0 and dy == 0.0:
+            return
+        moves.append({"X": dx, "Y": dy, "Color": color})
+        current_x += dx
+        current_y += dy
+
+    append_move(-(lead_clearance + lead_length), 0.0, off_color)
+    direction = 1.0
+    for pass_index in range(pass_count):
+        append_move(direction * lead_length, 0.0, print_color)
+        direction *= -1.0
+        if pass_index < pass_count - 1:
+            append_move(0.0, spacing, off_color)
+    append_move(-current_x, -current_y, off_color)
+    return moves
+
+
+def plan_layer_moves(
+    motion_layers: list[MultiPolygon],
+    valve_layers: list[MultiPolygon],
+    fil_width: float,
+    layer_height: float,
+    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."""
+    raster_pattern = _normalize_raster_pattern(raster_pattern)
+    gcode_list: list[dict] = []
+    current_x = 0.0
+    current_y = 0.0
+    origin_x = 0.0
+    origin_y = 0.0
+    raster_origin_initialized = False
+    contour_layers = contour_layers or []
+
+    for layer_number, (motion, valve) in enumerate(zip(motion_layers, valve_layers)):
+        if motion is None or motion.is_empty:
+            segments: list[Seg] = []
+        elif raster_pattern == RASTER_PATTERN_CIRCLE_SPIRAL:
+            points = _circle_spiral_polyline(
+                motion.bounds,
+                fil_width,
+                reverse=layer_number % 2 == 1,
+            )
+            segments = _classify_polyline(points, valve)
+        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)
+        else:
+            raster_axis = _raster_axis_for_pattern(raster_pattern, layer_number)
+            segments = _oriented_axis_raster_segments(
+                motion,
+                valve,
+                fil_width,
+                raster_axis,
+                current_x,
+                current_y,
+                prefer_default=not raster_origin_initialized,
+            )
+
+        if not segments:
+            if layer_number > 0:
+                gcode_list.append({"X": 0.0, "Y": 0.0, "Z": layer_height, "Color": 0})
+            layer_end_x, layer_end_y = current_x, current_y
+            current_x, current_y = _append_layer_contours(
+                gcode_list,
+                current_x,
+                current_y,
+                contour_layers,
+                layer_number,
+                active_contour_owner,
+                origin_x,
+                origin_y,
+            )
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                layer_end_x,
+                layer_end_y,
+                0,
+            )
+            continue
+
+        first_x, first_y = segments[0][0], segments[0][1]
+        if not raster_origin_initialized:
+            if layer_number > 0:
+                current_x, current_y = _append_relative_move(
+                    gcode_list,
+                    current_x,
+                    current_y,
+                    current_x,
+                    current_y,
+                    0,
+                    z_step=layer_height,
+                )
+            current_x, current_y = first_x, first_y
+            origin_x, origin_y = first_x, first_y
+            raster_origin_initialized = True
+        elif layer_number > 0:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                first_x,
+                first_y,
+                0,
+                z_step=layer_height,
+            )
+        else:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                first_x,
+                first_y,
+                0,
+            )
+
+        for start_x, start_y, end_x, end_y, color in segments:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                start_x,
+                start_y,
+                0,
+            )
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                end_x,
+                end_y,
+                color,
+            )
+
+        layer_end_x, layer_end_y = current_x, current_y
+        current_x, current_y = _append_layer_contours(
+            gcode_list,
+            current_x,
+            current_y,
+            contour_layers,
+            layer_number,
+            active_contour_owner,
+            origin_x,
+            origin_y,
+        )
+        current_x, current_y = _append_relative_move(
+            gcode_list,
+            current_x,
+            current_y,
+            layer_end_x,
+            layer_end_y,
+            0,
+        )
+
+    return gcode_list
+
+
+def _stack_center(stack: LayerStack) -> tuple[float, float]:
+    (x_min, y_min, _z_min), (x_max, y_max, _z_max) = stack.bounds
+    return ((x_min + x_max) / 2.0, (y_min + y_max) / 2.0)
+
+
+def _centering_delta(stack: LayerStack, reference: LayerStack) -> tuple[float, float]:
+    reference_x, reference_y = _stack_center(reference)
+    center_x, center_y = _stack_center(stack)
+    return reference_x - center_x, reference_y - center_y
+
+
+def align_stack_to(
+    stack: LayerStack,
+    reference: LayerStack,
+    n_layers: int,
+) -> list[MultiPolygon]:
+    """Translate a stack's layers into the reference frame, padded with empties."""
+    delta_x, delta_y = _centering_delta(stack, reference)
+    layers: list[MultiPolygon] = []
+    for index in range(n_layers):
+        if index < len(stack.layers) and not stack.layers[index].is_empty:
+            layers.append(
+                _as_multipolygon(
+                    translate(stack.layers[index], xoff=delta_x, yoff=delta_y)
+                )
+            )
+        else:
+            layers.append(MultiPolygon())
+    return layers
+
+
+def build_reference_stack(stacks: list[LayerStack | 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.
+    """
+    valid = [stack for stack in stacks if stack is not None and stack.layers]
+    if not valid:
+        return None
+
+    n_layers = max(len(stack.layers) for stack in valid)
+    reference_x, reference_y = _stack_center(valid[0])
+
+    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
+
+        (sx_min, sy_min, sz_min), (sx_max, sy_max, sz_max) = stack.bounds
+        x_min = min(x_min, sx_min + delta_x)
+        x_max = max(x_max, sx_max + delta_x)
+        y_min = min(y_min, sy_min + delta_y)
+        y_max = max(y_max, sy_max + delta_y)
+        z_min = min(z_min, sz_min)
+        z_max = max(z_max, sz_max)
+
+        for index, layer in enumerate(stack.layers):
+            if layer is None or layer.is_empty:
+                continue
+            layer_parts[index].append(translate(layer, xoff=delta_x, yoff=delta_y))
+
+    layers = [
+        _as_multipolygon(unary_union(parts)) if parts else MultiPolygon()
+        for parts in layer_parts
+    ]
+
+    z_values: list[float] = []
+    for index in range(n_layers):
+        z_value = 0.0
+        for stack in valid:
+            if index < len(stack.z_values):
+                z_value = stack.z_values[index]
+                break
+        z_values.append(z_value)
+
+    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",
+    )
+
+
+def _split_boundaries(
+    lo: float,
+    hi: float,
+    count: int,
+    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)]
+    if overlap <= 0.0 or count <= 1:
+        return edges
+
+    adjusted = list(edges)
+    for boundary_index in range(1, count):
+        direction = 1 if (layer_index + boundary_index) % 2 == 1 else -1
+        lower = adjusted[boundary_index - 1] + overlap
+        upper = edges[boundary_index + 1] - overlap
+        shifted = edges[boundary_index] + direction * overlap
+        if lower <= upper:
+            shifted = max(lower, min(upper, shifted))
+        else:
+            shifted = edges[boundary_index]
+        adjusted[boundary_index] = shifted
+    return adjusted
+
+
+def split_layer_stack_grid(
+    stack: LayerStack,
+    columns: int,
+    rows: int,
+    overlapping_layers: bool = False,
+    overlap: float = 0.0,
+) -> 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.
+    """
+    columns = max(1, int(columns))
+    rows = max(1, int(rows))
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = stack.bounds
+
+    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)
+    layer_x_edges = [
+        _split_boundaries(x_min, x_max, columns, index, overlap_x)
+        for index in range(len(stack.layers))
+    ]
+    layer_y_edges = [
+        _split_boundaries(y_min, y_max, rows, index, overlap_y)
+        for index in range(len(stack.layers))
+    ]
+
+    base_name = stack.name or "shape"
+    pieces: list[LayerStack] = []
+    for row_index in range(1, rows + 1):
+        # Row 1 is the top strip: count y-cells down from the max edge.
+        y_cell = rows - row_index
+        for col_index in range(1, columns + 1):
+            x_cell = col_index - 1
+
+            layers: list[MultiPolygon] = []
+            for layer_number, layer in enumerate(stack.layers):
+                if layer is None or layer.is_empty:
+                    layers.append(MultiPolygon())
+                    continue
+                x_edges = layer_x_edges[layer_number]
+                y_edges = layer_y_edges[layer_number]
+                cell = box(
+                    x_edges[x_cell],
+                    y_edges[y_cell],
+                    x_edges[x_cell + 1],
+                    y_edges[y_cell + 1],
+                )
+                layers.append(_as_multipolygon(layer.intersection(cell)))
+
+            pieces.append(
+                LayerStack(
+                    layers=layers,
+                    z_values=list(stack.z_values),
+                    bounds=(
+                        (base_x_edges[x_cell], base_y_edges[y_cell], z_min),
+                        (base_x_edges[x_cell + 1], base_y_edges[y_cell + 1], z_max),
+                    ),
+                    layer_height=stack.layer_height,
+                    name=f"{base_name}_r{row_index:02d}_c{col_index:02d}",
+                )
+            )
+
+    return pieces