Sync multi-material assemblies in the table, add Flip Z, fix split seam gaps

Shape Settings table:
- Dimension edits on a multi-material group member (shapes sharing a
nozzle) propagate the per-axis scale factor (target/original) to every
member in both scaling modes, so assemblies scale as one unit; members
are scaled about the group's shared corner so parts stay assembled
- Moving a shape onto another nozzle makes it adopt that group's scale
- New Flip Z checkbox column prints a shape the other way up (mirrored
about its Z midplane); any assembly member's Flip Z flips the whole
group about the shared midplane - for models authored face-down, like
the Maryland flag whose arms otherwise print first instead of last
- Keep Proportions fixed: Dataframe emits no .input for cell edits, so
the normalizer is back on .change with a server-side idempotence guard
(converges in two rounds instead of a minute-long re-anchoring storm);
anchoring now comes from the row's own ratios (odd factor out), which
is immune to stale event echoes that used to revert the first edit
- Split pieces are exempt from proportion normalization (their targets
are cell sizes; a table echo used to reset them to parent dimensions)
- Cell clicks outside the Delete column no longer echo the table (the
queued echo raced normalize and re-rendered the table mid-typing)
- Header select-all checkboxes are handled by the backend via a hidden
relay: Gradio's own implementation sometimes toggled nothing or bled a
stray value into the neighbouring column's first row

Split seams:
- A split cut landing exactly on a scan-grid line lost its boundary
scanline to float noise (epsilon too small in the grid-line selection,
and the chord probe grazing the material edge from outside by ulps),
printing a one-fil gap at every assembled seam - the flag's 2x2 split
Y seam. Both are fixed; seams reassemble at exact one-fil bead pitch

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

README.md

@@ -83,7 +83,8 @@ For a multi-material object exported as separate STLs (one per material), give e
 - **Contour Tracing** on assembly parts outlines only the assembly's true outer surface: edges where one material meets (or nearly meets, within half a bead — fit tolerances included) another material are internal interfaces and are skipped, exactly like the cut seams of grid-split pieces.
 - Combine with **Use combined reference outline for motion** so all heads share one synchronized path while each dispenses only its own part.
 - Nozzle renumbering in the table takes effect on the next slice or G-code generation — groups are re-detected automatically.
-- Leave assembly parts' target dimensions at their defaults (or scale every part identically); parts are scaled about their own corners, so unequal scaling would misalign an assembly.
+- **Dimension edits scale the whole assembly**: changing a dimension of one group member applies the same scale factor (target ÷ original, per axis) to every shape on that nozzle, in both scaling modes — in Keep Proportions one edit rescales every member proportionally; in Independent X/Y/Z the edited axis's factor propagates to the group. Factors (not absolute values) keep differently-sized parts proportional to each other, and group members are scaled about the assembly's shared corner so the parts stay assembled at any size.
+- **Flip Z** (per-shape checkbox) prints a shape the other way up by mirroring it about its Z midplane. Checking it on any assembly member flips the **whole group** about the group's shared midplane, so the assembly stays together — useful when a multi-material model is authored with its display face down (e.g. the detail layer would otherwise print first instead of last).
 
 ### Multi-Nozzle Split
 

app.py

@@ -404,6 +404,39 @@ APP_HEAD = """
         event.stopPropagation();
         relayColorChoice(idxMatch[1], '#' + hexMatch[1].toLowerCase());
     }, true);
+    // Header "select all" checkboxes: Gradio's own implementation is buggy
+    // (sometimes toggles nothing server-side, sometimes bleeds a stray value
+    // into the neighbouring column's first row). Hijack the click and set
+    // the whole column through the backend instead.
+    function relayBulkBool(columnIndex, value) {
+        var sink = document.querySelector('#pp-bulk-sink textarea, #pp-bulk-sink input');
+        var apply = document.querySelector('#pp-bulk-apply button, button#pp-bulk-apply, #pp-bulk-apply');
+        if (!sink || !apply) return;
+        sink.value = columnIndex + '|' + value;
+        sink.dispatchEvent(new Event('input', { bubbles: true }));
+        if (apply.tagName !== 'BUTTON') { apply = apply.querySelector('button') || apply; }
+        apply.click();
+    }
+    document.addEventListener('click', function (event) {
+        var el = event.target;
+        if (!el || !el.closest) return;
+        if (!el.closest('#shape-settings-table thead')) return;
+        var wrap = el.closest('label') || el;
+        var cb = (wrap.matches && wrap.matches('input[type=checkbox]'))
+            ? wrap
+            : (wrap.querySelector ? wrap.querySelector('input[type=checkbox]') : null);
+        if (!cb) return;
+        event.preventDefault();
+        event.stopPropagation();
+        var row = cb.closest('tr');
+        var cell = cb.closest('th, td');
+        if (!row || !cell) return;
+        var col = Array.prototype.indexOf.call(row.children, cell);
+        // Checkbox pre-click activation: by the time click handlers run the
+        // box has ALREADY toggled (preventDefault rolls it back visually),
+        // so cb.checked is the state the user is asking for.
+        relayBulkBool(col, cb.checked ? 1 : 0);
+    }, true);
     function enableUndoButtons(root) {
         (root || document).querySelectorAll('.model3D button[aria-label="Undo"]').forEach(function (btn) {
             if (btn.disabled) {
@@ -1553,6 +1586,7 @@ SHAPE_SETTINGS_HEADERS = [
     "Infill %",
     "Contour Tracing",
     "Lead In",
+    "Flip Z",
     "Delete",
 ]
 SHAPE_SETTINGS_DATATYPES = [
@@ -1569,6 +1603,7 @@ SHAPE_SETTINGS_DATATYPES = [
     "number",
     "bool",
     "bool",
+    "bool",
     "str",
 ]
 ADVANCED_NOZZLE_SPACING_HEADERS = [
@@ -1750,6 +1785,7 @@ def _shape_settings_rows(records: list[dict]) -> list[list[Any]]:
             _coerce_float(record.get("infill", 100.0), 100.0),
             bool(record.get("contour_tracing", False)),
             bool(record.get("lead_in", False)),
+            bool(record.get("flip_z", False)),
             "Delete",
         ]
         for record in records
@@ -1825,6 +1861,13 @@ def _apply_shape_settings(records: list[dict], settings_table: Any) -> list[dict
                 copy["lead_in"] = _coerce_bool(row[lead_in_pos], bool(copy.get("lead_in", False)))
             except IndexError:
                 copy["lead_in"] = bool(copy.get("lead_in", False))
+            flip_pos = lead_in_pos + 1
+            # Parse only when the Flip Z column is present (Delete follows it);
+            # an old-format row would otherwise coerce the "Delete" cell.
+            if len(row) > flip_pos + 1:
+                copy["flip_z"] = _coerce_bool(row[flip_pos], bool(copy.get("flip_z", False)))
+            else:
+                copy["flip_z"] = bool(copy.get("flip_z", False))
         updated.append(copy)
     return updated
 
@@ -2275,6 +2318,15 @@ def _shape_delete_outputs(
     )
 
 
+def _shape_select_noop() -> tuple:
+    """Skip every output: a cell click that is not a Delete click must not
+    touch anything. This handler fires on EVERY cell selection (queued, so it
+    lands late); echoing records/rows here raced the dimension normalizer's
+    write-back — the stale echo clobbered the recomputed proportions on the
+    first Keep Proportions edit and re-rendered the table mid-typing."""
+    return tuple(gr.skip() for _ in range(8))
+
+
 def delete_shape_from_settings(
     records: list[dict] | None,
     settings_table: Any | None,
@@ -2284,20 +2336,20 @@ def delete_shape_from_settings(
     now = time.monotonic()
     rows = _normalise_rows(settings_table)
     selected = getattr(evt, "index", None)
-    current_records = _apply_shape_settings(records or [], settings_table)
     if not isinstance(selected, (list, tuple)) or len(selected) < 2:
-        return _shape_delete_outputs(current_records, last_delete_at)
+        return _shape_select_noop()
 
     try:
         row_index, column_index = int(selected[0]), int(selected[1])
     except (TypeError, ValueError):
-        return _shape_delete_outputs(current_records, last_delete_at)
+        return _shape_select_noop()
     delete_column_index = len(SHAPE_SETTINGS_HEADERS) - 1
     if column_index != delete_column_index or row_index < 0 or row_index >= len(rows):
-        return _shape_delete_outputs(current_records, last_delete_at)
+        return _shape_select_noop()
     if last_delete_at and now - float(last_delete_at) < DELETE_SHAPE_COOLDOWN_SECONDS:
-        return _shape_delete_outputs(current_records, last_delete_at)
+        return _shape_select_noop()
 
+    current_records = _apply_shape_settings(records or [], settings_table)
     try:
         delete_idx = int(float(rows[row_index][0]))
     except (IndexError, TypeError, ValueError):
@@ -2335,23 +2387,228 @@ def reset_shape_dimensions(records: list[dict] | None, settings_table: Any | Non
     return reset_records, _shape_settings_rows(reset_records)
 
 
+BULK_BOOL_COLUMNS = {
+    "Contour Tracing": "contour_tracing",
+    "Lead In": "lead_in",
+    "Flip Z": "flip_z",
+}
+
+
+def apply_bulk_bool_selection(
+    records: list[dict] | None,
+    settings_table: Any,
+    payload: str | None,
+) -> tuple[list[dict], list[list[Any]]]:
+    """Set a checkbox column for ALL shapes ("columnIndex|0/1" from the sink).
+
+    Backs the header select-all checkboxes: Gradio's own implementation is
+    unreliable (see the head-script hijack), so the whole column is set here
+    and the table re-rendered canonically.
+    """
+    records = _apply_shape_settings(records or [], settings_table)
+    parts = str(payload or "").split("|")
+    if len(parts) >= 2:
+        try:
+            column_index = int(parts[0])
+            value = bool(int(parts[1]))
+        except (TypeError, ValueError):
+            column_index = -1
+            value = False
+        if 0 <= column_index < len(SHAPE_SETTINGS_HEADERS):
+            key = BULK_BOOL_COLUMNS.get(SHAPE_SETTINGS_HEADERS[column_index])
+            if key:
+                records = [dict(record, **{key: value}) for record in records]
+    return records, _shape_settings_rows(records)
+
+
+def _bool_cells_need_rewrite(settings_table: Any) -> bool:
+    """True when the checkbox columns carry non-boolean cell values.
+
+    Gradio's header "select all" writes the STRING "true"/"false" into the
+    column's cells (and leaves some rendered as plain text or stale
+    checkboxes in neighbouring columns) instead of booleans. Detecting that
+    lets the normalizer answer with a canonical re-render, which restores
+    real checkboxes and stomps any visual strays within one round-trip.
+    """
+    rows = _normalise_rows(settings_table)
+    contour_pos = SHAPE_SETTINGS_HEADERS.index("Contour Tracing")
+    bool_positions = (contour_pos, contour_pos + 1, contour_pos + 2)
+    for row in rows:
+        if len(row) < len(SHAPE_SETTINGS_HEADERS):
+            continue
+        for pos in bool_positions:
+            if not isinstance(row[pos], bool):
+                return True
+    return False
+
+
+def _last_edited_nozzles(records: list[dict] | None, settings_table: Any) -> set[int]:
+    """Record idx whose Nozzle cell differs from the record — i.e. shapes the
+    user just moved onto a (possibly new) nozzle via the table."""
+    rows = _normalise_rows(settings_table)
+    previous_by_idx: dict[int, dict] = {}
+    for record in records or []:
+        try:
+            previous_by_idx[int(record.get("idx", 0))] = record
+        except (TypeError, ValueError):
+            continue
+
+    nozzle_pos = SHAPE_SETTINGS_HEADERS.index("Nozzle")
+    changed: set[int] = set()
+    for row in rows:
+        try:
+            idx = int(float(row[0]))
+        except (IndexError, TypeError, ValueError):
+            continue
+        previous = previous_by_idx.get(idx)
+        if not previous or len(row) <= nozzle_pos:
+            continue
+        old_nozzle = _record_nozzle_number(previous, idx)
+        new_nozzle = _coerce_int(row[nozzle_pos], old_nozzle)
+        if new_nozzle > 0 and new_nozzle != old_nozzle:
+            changed.add(idx)
+    return changed
+
+
+def _record_scale_factors(record: dict) -> tuple[float, float, float] | None:
+    """Per-axis target/original factors, or None when they can't be computed."""
+    try:
+        originals = [float(record.get(f"original_{axis}")) for axis in ("x", "y", "z")]
+        targets = [float(record.get(f"target_{axis}")) for axis in ("x", "y", "z")]
+    except (TypeError, ValueError):
+        return None
+    if any(not math.isfinite(v) or v <= 0 for v in originals + targets):
+        return None
+    return tuple(target / original for target, original in zip(targets, originals))
+
+
+def _propagate_group_scale_factors(
+    records: list[dict],
+    edited_axes: dict[int, str],
+    recomputed_idx: set[int],
+    joined_idx: set[int] | None = None,
+) -> list[dict]:
+    """Sync each multi-material group's scale factors from the edited member.
+
+    Shapes sharing a nozzle are one assembly, so a dimension edit on one
+    part scales EVERY part by the same per-axis factor (target/original) —
+    absolute values would distort assemblies whose parts differ in size.
+    The source member must be unambiguous: the one whose row was actually
+    recomputed this round (Keep Proportions), the single member the user
+    edited, or — when a shape just JOINED the group by a nozzle edit — the
+    incumbent members' shared factors, which the newcomer adopts. Groups
+    already in sync, or with no clear source (e.g. stale .change echoes that
+    flag several members at once), are left untouched, so the event storm
+    converges instead of ping-ponging.
+    """
+    joined_idx = joined_idx or set()
+
+    def _triples_close(a: tuple, b: tuple) -> bool:
+        return all(
+            math.isclose(fa, fb, rel_tol=1e-6, abs_tol=1e-9) for fa, fb in zip(a, b)
+        )
+
+    for members in _multi_material_groups(records).values():
+        factors = {id(member): _record_scale_factors(member) for member in members}
+        if any(value is None for value in factors.values()):
+            continue
+        triples = list(factors.values())
+        if all(_triples_close(triples[0], triple) for triple in triples[1:]):
+            continue  # group already in sync
+
+        recomputed_members = [
+            member for member in members if int(member.get("idx", 0)) in recomputed_idx
+        ]
+        edited_members = [
+            member for member in members if int(member.get("idx", 0)) in edited_axes
+        ]
+        newcomers = [
+            member for member in members if int(member.get("idx", 0)) in joined_idx
+        ]
+        incumbents = [
+            member for member in members if int(member.get("idx", 0)) not in joined_idx
+        ]
+        if len(recomputed_members) == 1:
+            source = recomputed_members[0]
+        elif len(edited_members) == 1:
+            source = edited_members[0]
+        elif newcomers and incumbents and all(
+            _triples_close(factors[id(incumbents[0])], factors[id(member)])
+            for member in incumbents[1:]
+        ):
+            # Nozzle edit pulled newcomers into the group: they adopt the
+            # incumbents' shared scale factors.
+            source = incumbents[0]
+        else:
+            continue  # ambiguous (stale echo): do not guess
+
+        source_factors = factors[id(source)]
+        for member in members:
+            if member is source:
+                continue
+            for axis, factor in zip(("x", "y", "z"), source_factors):
+                member[f"target_{axis}"] = round(
+                    float(member[f"original_{axis}"]) * factor, 6
+                )
+            member["last_scaled_axis"] = source.get(
+                "last_scaled_axis", member.get("last_scaled_axis")
+            )
+    return records
+
+
 def normalize_shape_dimensions_for_mode(
     records: list[dict] | None,
     settings_table: Any | None,
     scale_mode: str | None,
 ) -> tuple:
+    """Apply table edits to the records; in Keep Proportions, rescale each
+    shape's other dimensions from the edited axis. In BOTH modes, a
+    dimension edit on a multi-material group member (shapes sharing a
+    nozzle) propagates its scale factors to the whole group, so assemblies
+    stay proportional as one unit.
+
+    Wired to the table's .change event, WHICH ALSO FIRES FOR OUR OWN
+    WRITE-BACK (Gradio's Dataframe does not emit .input for cell edits at
+    all). The cascade is broken server-side: the table output is skipped
+    whenever normalization did not change any dimension — so a user edit
+    costs exactly two rounds (recompute + converged no-op), and programmatic
+    table updates cost one no-op round instead of looping.
+    """
     edited_axes = _last_edited_target_axes(records, settings_table)
+    joined_idx = _last_edited_nozzles(records, settings_table)
     records = _apply_shape_settings(records or [], settings_table)
     if _normalize_scale_mode(scale_mode) != SCALE_MODE_UNIFORM_FACTOR:
-        for record in records:
+        normalized = [dict(record) for record in records]
+        for record in normalized:
             idx = int(record.get("idx", 0))
             if idx in edited_axes:
                 record["last_scaled_axis"] = edited_axes[idx]
-        return records, _shape_settings_rows(records)
+        normalized = _propagate_group_scale_factors(normalized, edited_axes, set(), joined_idx)
+        changed = any(
+            not math.isclose(
+                float(before.get(key) or 0.0),
+                float(after.get(key) or 0.0),
+                rel_tol=0.0,
+                abs_tol=1e-9,
+            )
+            for before, after in zip(records, normalized)
+            for key in TARGET_DIMENSION_KEYS
+        )
+        if not changed and not _bool_cells_need_rewrite(settings_table):
+            return normalized, gr.skip()
+        return normalized, _shape_settings_rows(normalized)
 
+    recomputed_idx: set[int] = set()
     normalized: list[dict] = []
     for record in records:
         copy = dict(record)
+        if not copy.get("stl_path"):
+            # Split pieces: their targets are CELL sizes while original_* is
+            # inherited from the parent shape, so the ratio logic would
+            # misread them as mid-edit and "restore" the parent dimensions.
+            # Piece dimensions are informational — never rescale them.
+            normalized.append(copy)
+            continue
         originals = np.asarray([
             copy.get("original_x"),
             copy.get("original_y"),
@@ -2373,18 +2630,69 @@ def normalize_shape_dimensions_for_mode(
             normalized.append(copy)
             continue
         idx = int(copy.get("idx", 0))
-        anchor_key = edited_axes.get(idx) or copy.get("last_scaled_axis") or "target_x"
-        try:
-            anchor_index = TARGET_DIMENSION_KEYS.index(str(anchor_key))
-        except ValueError:
-            anchor_index = 0
+
+        # Anchor on the row's own evidence: in a proportional row all three
+        # target/original ratios agree; a user edit makes exactly one ratio
+        # the odd one out. This is ORDER-INDEPENDENT — the .change event
+        # storm delivers stale/echoed tables whose rows are self-consistent,
+        # and those must recompute to themselves (skip) instead of being
+        # diffed against fresher records, mis-anchored, and reverted.
+        ratios = targets / originals
+
+        def _close(a: float, b: float) -> bool:
+            return math.isclose(float(a), float(b), rel_tol=1e-6, abs_tol=1e-9)
+
+        if _close(ratios[0], ratios[1]) and _close(ratios[1], ratios[2]):
+            # Already proportional (a pristine row or an echo of our own
+            # write-back): nothing to recompute.
+            if idx in edited_axes:
+                copy["last_scaled_axis"] = edited_axes[idx]
+            normalized.append(copy)
+            continue
+        # others_agree[i] means the OTHER two ratios agree -> axis i was edited.
+        others_agree = [
+            _close(ratios[1], ratios[2]),
+            _close(ratios[0], ratios[2]),
+            _close(ratios[0], ratios[1]),
+        ]
+        if sum(others_agree) == 1:
+            anchor_index = others_agree.index(True)
+        else:
+            # All three differ (e.g. custom dims from Independent mode):
+            # fall back to the detected edit, then the last anchor.
+            anchor_key = edited_axes.get(idx) or copy.get("last_scaled_axis") or "target_x"
+            try:
+                anchor_index = TARGET_DIMENSION_KEYS.index(str(anchor_key))
+            except ValueError:
+                anchor_index = 0
         scale = float(targets[anchor_index] / originals[anchor_index])
         copy["last_scaled_axis"] = TARGET_DIMENSION_KEYS[anchor_index]
         scaled = originals * scale
         copy["target_x"] = round(float(scaled[0]), 6)
         copy["target_y"] = round(float(scaled[1]), 6)
         copy["target_z"] = round(float(scaled[2]), 6)
+        recomputed_idx.add(idx)
         normalized.append(copy)
+
+    normalized = _propagate_group_scale_factors(
+        normalized, edited_axes, recomputed_idx, joined_idx
+    )
+
+    # Idempotence guard (breaks the .change write-back cascade): only write
+    # the table when a dimension actually changed — or when the checkbox
+    # columns need a canonical re-render after a header "select all".
+    changed = any(
+        not math.isclose(
+            float(before.get(key) or 0.0),
+            float(after.get(key) or 0.0),
+            rel_tol=0.0,
+            abs_tol=1e-9,
+        )
+        for before, after in zip(records, normalized)
+        for key in TARGET_DIMENSION_KEYS
+    )
+    if not changed and not _bool_cells_need_rewrite(settings_table):
+        return normalized, gr.skip()
     return normalized, _shape_settings_rows(normalized)
 
 
@@ -2415,18 +2723,24 @@ def _slice_params_snapshot(
     record: dict,
     layer_height: float,
     scale_mode: str | None,
-    z_levels: list[float] | None = None,
+    slice_plan: tuple[list[float], tuple[float, float, float], float | None] | None = None,
 ) -> dict:
+    z_levels = slice_plan[0] if slice_plan else None
+    anchor = slice_plan[1] if slice_plan else None
+    z_flip_mid = slice_plan[2] if slice_plan else None
     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"),
-        # Multi-material mode: the shared Z grid fingerprint. Adding/removing
-        # an assembly part changes the grid, which correctly marks every
-        # part's slices stale.
+        # Multi-material groups: the shared Z grid + scale anchor
+        # fingerprint. Adding/removing an assembly part changes them, which
+        # correctly marks every part's slices stale.
         "z_grid": (round(z_levels[0], 6), len(z_levels)) if z_levels else None,
+        "scale_anchor": tuple(round(v, 6) for v in anchor) if anchor else None,
+        "flip_z": bool(record.get("flip_z", False)),
+        "z_flip_mid": round(z_flip_mid, 6) if z_flip_mid is not None else None,
     }
 
 
@@ -2491,19 +2805,24 @@ def _stamp_multi_material_frames(records: list[dict], fil_width: float = 0.8) ->
             stack.contour_paths = None
 
 
-def _multi_material_z_levels(
+def _multi_material_slice_plan(
     records: list[dict],
     layer_height: float,
     scale_mode: str | None,
-) -> list[float] | None:
-    """One shared Z grid spanning the given parts' scaled extents.
-
-    Multi-material group members must slice on the SAME planes so a part
-    that starts higher gets empty lower layers instead of having its first
-    material layer treated as layer 0.
+) -> tuple[list[float], tuple[float, float, float], float | None] | None:
+    """(shared Z grid, shared scale anchor, Z-flip midplane) for one group.
+
+    Group members must slice on the SAME planes so a part that starts
+    higher gets empty lower layers instead of having its first material
+    layer treated as layer 0 — and any target-dimension scaling must happen
+    about ONE shared point (the group's combined un-scaled corner), or
+    same-factor scaling would still shift the parts relative to each other.
+    When any member has Flip Z checked, the WHOLE assembly mirrors about
+    the group's combined Z midplane (so it stays assembled, just printed
+    the other way up); the midplane is returned, else None.
     """
-    z_lo = math.inf
-    z_hi = -math.inf
+    loaded: list[tuple[Any, tuple[float, float, float]]] = []
+    corner = [math.inf, math.inf, math.inf]
     for record in records:
         stl_path = record.get("stl_path")
         if not stl_path:
@@ -2518,14 +2837,30 @@ def _multi_material_z_levels(
                 record.get("target_y"),
                 record.get("target_z"),
             )
-            scaled = scale_mesh(mesh, scale_factors)
+        except Exception:
+            continue
+        loaded.append((mesh, scale_factors))
+        for axis in range(3):
+            corner[axis] = min(corner[axis], float(mesh.bounds[0][axis]))
+    if not loaded or not all(math.isfinite(value) for value in corner):
+        return None
+
+    anchor = (corner[0], corner[1], corner[2])
+    z_lo = math.inf
+    z_hi = -math.inf
+    for mesh, scale_factors in loaded:
+        try:
+            scaled = scale_mesh(mesh, scale_factors, anchor=anchor)
         except Exception:
             continue
         z_lo = min(z_lo, float(scaled.bounds[0][2]))
         z_hi = max(z_hi, float(scaled.bounds[1][2]))
     if not math.isfinite(z_lo) or not math.isfinite(z_hi):
         return None
-    return calculate_z_levels(z_lo, z_hi, float(layer_height))
+    # Mirroring about the group midplane preserves the group's Z range, so
+    # the shared grid stays valid for the flipped assembly.
+    z_flip_mid = (z_lo + z_hi) / 2.0 if any(r.get("flip_z") for r in records) else None
+    return calculate_z_levels(z_lo, z_hi, float(layer_height)), anchor, z_flip_mid
 
 
 def _slice_record(
@@ -2533,7 +2868,7 @@ def _slice_record(
     layer_height: float,
     scale_mode: str | None,
     progress_callback=None,
-    z_levels: list[float] | None = None,
+    slice_plan: tuple[list[float], tuple[float, float, float], float | None] | None = None,
 ) -> LayerStack:
     stl_path = record["stl_path"]
     mesh = load_mesh(stl_path)
@@ -2545,16 +2880,23 @@ def _slice_record(
         record.get("target_y"),
         record.get("target_z"),
     )
+    # Group members flip together about the group midplane (any member's
+    # Flip Z flips the whole assembly); solo shapes flip about their own.
+    z_flip_mid = slice_plan[2] if slice_plan else None
+    flip_z = (z_flip_mid is not None) if slice_plan else bool(record.get("flip_z", False))
     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),
-        z_levels=z_levels,
+        z_levels=slice_plan[0] if slice_plan else None,
+        scale_anchor=slice_plan[1] if slice_plan else None,
+        flip_z=flip_z,
+        z_flip_mid=z_flip_mid,
     )
     record["layer_stack"] = stack
-    record["slice_params"] = _slice_params_snapshot(record, layer_height, scale_mode, z_levels)
+    record["slice_params"] = _slice_params_snapshot(record, layer_height, scale_mode, slice_plan)
     return stack
 
 
@@ -2563,22 +2905,27 @@ def _group_z_levels_by_record(
     layer_height: float,
     scale_mode: str | None,
     messages: list[str] | None = None,
-) -> dict[int, list[float]]:
-    """Shared Z grid per multi-material group, keyed by member record id."""
-    z_by_record: dict[int, list[float]] = {}
+) -> dict[int, tuple[list[float], tuple[float, float, float]]]:
+    """Per multi-material group member: (shared Z grid, shared scale anchor),
+    keyed by record id."""
+    plan_by_record: dict[int, tuple[list[float], tuple[float, float, float]]] = {}
     for nozzle, members in sorted(_multi_material_groups(records).items()):
-        z_levels = _multi_material_z_levels(members, layer_height, scale_mode)
-        if z_levels is None:
+        plan = _multi_material_slice_plan(members, layer_height, scale_mode)
+        if plan is None:
             continue
+        z_levels = plan[0]
         for member in members:
-            z_by_record[id(member)] = z_levels
+            plan_by_record[id(member)] = plan
         if messages is not None:
             names = ", ".join(str(m.get("name") or f"Shape {m['idx']}") for m in members)
-            messages.append(
+            note = (
                 f"Multi-material group (nozzle {nozzle}): {names} — sliced on one "
                 f"shared Z grid ({len(z_levels)} layers), positions locked together."
             )
-    return z_by_record
+            if plan[2] is not None:
+                note += " Flip Z is set: the whole assembly prints mirrored top-to-bottom."
+            messages.append(note)
+    return plan_by_record
 
 
 def generate_dynamic_layer_stacks(
@@ -2594,7 +2941,7 @@ def generate_dynamic_layer_stacks(
         return records, "Upload at least one STL first.", None
     total = len(records)
     messages: list[str] = []
-    z_by_record = _group_z_levels_by_record(records, layer_height, scale_mode, messages)
+    plan_by_record = _group_z_levels_by_record(records, layer_height, scale_mode, messages)
     for pos, record in enumerate(records):
         stl_path = record.get("stl_path")
         if not stl_path:
@@ -2609,7 +2956,7 @@ def generate_dynamic_layer_stacks(
 
         try:
             stack = _slice_record(
-                record, layer_height, scale_mode, report_progress, z_by_record.get(id(record))
+                record, layer_height, scale_mode, report_progress, plan_by_record.get(id(record))
             )
             (x_min, y_min, _z_min), (x_max, y_max, _z_max) = stack.bounds
             messages.append(
@@ -2960,18 +3307,18 @@ def _ensure_records_sliced(
     messages: list[str],
 ) -> bool:
     """Re-slice records whose layers are missing or stale for the current settings."""
-    z_by_record = _group_z_levels_by_record(records, layer_height, scale_mode)
+    plan_by_record = _group_z_levels_by_record(records, layer_height, scale_mode)
     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.
-        z_levels = z_by_record.get(id(record))
-        current = _slice_params_snapshot(record, layer_height, scale_mode, z_levels)
+        slice_plan = plan_by_record.get(id(record))
+        current = _slice_params_snapshot(record, layer_height, scale_mode, slice_plan)
         if record.get("layer_stack") is not None and record.get("slice_params") == current:
             continue
         try:
-            stack = _slice_record(record, layer_height, scale_mode, None, z_levels)
+            stack = _slice_record(record, layer_height, scale_mode, None, slice_plan)
             messages.append(
                 f"Shape {record['idx']}: sliced automatically ({len(stack.layers)} layers)."
             )
@@ -3369,6 +3716,17 @@ def build_dynamic_demo() -> gr.Blocks:
                 elem_id="pp-color-apply",
                 elem_classes=["pp-visually-hidden"],
             )
+            bulk_sink = gr.Textbox(
+                label="bulk sink",
+                container=False,
+                elem_id="pp-bulk-sink",
+                elem_classes=["pp-visually-hidden"],
+            )
+            bulk_apply = gr.Button(
+                "apply bulk",
+                elem_id="pp-bulk-apply",
+                elem_classes=["pp-visually-hidden"],
+            )
             shape_settings = gr.Dataframe(
                 headers=SHAPE_SETTINGS_HEADERS,
                 value=[],
@@ -3619,10 +3977,17 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[shape_records, shape_settings],
             queue=False,
         )
+        bulk_apply.click(
+            fn=apply_bulk_bool_selection,
+            inputs=[shape_records, shape_settings, bulk_sink],
+            outputs=[shape_records, shape_settings],
+            queue=False,
+        )
         shape_settings.select(
             fn=delete_shape_from_settings,
             inputs=[shape_records, shape_settings, last_shape_delete_at],
             outputs=[stl_upload, *shape_sync_outputs, last_shape_delete_at],
+            queue=False,
         ).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
@@ -3636,6 +4001,11 @@ def build_dynamic_demo() -> gr.Blocks:
         )
 
         preview_inputs = [shape_records, selected_shape, shape_settings, model_opacity, scale_mode]
+        # .change is the ONLY event the Dataframe emits for cell edits (it has
+        # no working .input) — and it also fires for the normalizer's own
+        # write-back. The infinite/minute-long cascade is prevented inside
+        # normalize_shape_dimensions_for_mode: it skips the table output
+        # whenever no dimension actually changed.
         shape_settings.change(
             fn=normalize_shape_dimensions_for_mode,
             inputs=[shape_records, shape_settings, scale_mode],

stl_slicer.py

@@ -88,15 +88,28 @@ def _normalize_scale_factors(scale_factors: Sequence[float] | None) -> ScaleFact
     return (values[0], values[1], values[2])
 
 
-def scale_mesh(mesh: trimesh.Trimesh, scale_factors: Sequence[float] | None = None) -> trimesh.Trimesh:
-    """Return a copy of `mesh` scaled around its minimum XYZ corner."""
+def scale_mesh(
+    mesh: trimesh.Trimesh,
+    scale_factors: Sequence[float] | None = None,
+    anchor: Sequence[float] | None = None,
+) -> trimesh.Trimesh:
+    """Return a copy of `mesh` scaled around `anchor` (its own minimum XYZ
+    corner by default).
+
+    Multi-material assembly parts pass their GROUP's combined corner: parts
+    scaled by the same factors about one shared point stay assembled, while
+    each scaling about its own corner would shift them relative to each
+    other.
+    """
     sx, sy, sz = _normalize_scale_factors(scale_factors)
     scaled = mesh.copy()
 
     if math.isclose(sx, 1.0) and math.isclose(sy, 1.0) and math.isclose(sz, 1.0):
         return scaled
 
-    anchor = np.asarray(mesh.bounds[0], dtype=float)
+    anchor = np.asarray(
+        mesh.bounds[0] if anchor is None else anchor, dtype=float
+    )
     transform = np.eye(4)
     transform[0, 0] = sx
     transform[1, 1] = sy
@@ -285,15 +298,37 @@ def slice_stl_to_layers(
     scale_factors: Sequence[float] | None = None,
     name: str | None = None,
     z_levels: Sequence[float] | None = None,
+    scale_anchor: Sequence[float] | None = None,
+    flip_z: bool = False,
+    z_flip_mid: float | None = None,
 ) -> LayerStack:
     """Slice an STL into per-layer vector outlines (world-XY millimetres).
 
     `z_levels` overrides the per-mesh Z planes with an explicit (world) grid —
     used by multi-material assemblies so every part slices on ONE shared grid
-    and parts that start higher simply get empty lower layers.
+    and parts that start higher simply get empty lower layers. `scale_anchor`
+    is the point target-dimension scaling happens about (assembly parts share
+    their group's corner so they stay assembled when rescaled).
+
+    `flip_z` mirrors the scaled mesh about the horizontal plane at
+    `z_flip_mid` (its own Z midpoint by default) — printing the shape the
+    other way up. Assembly parts pass their GROUP's midplane so the whole
+    assembly flips as one unit.
     """
     stl_path = Path(stl_path)
-    mesh = scale_mesh(load_mesh(stl_path), scale_factors)
+    mesh = scale_mesh(load_mesh(stl_path), scale_factors, anchor=scale_anchor)
+    if flip_z:
+        mid = (
+            float(z_flip_mid)
+            if z_flip_mid is not None
+            else (float(mesh.bounds[0][2]) + float(mesh.bounds[1][2])) / 2.0
+        )
+        mirror = np.eye(4)
+        mirror[2, 2] = -1.0
+        mirror[2, 3] = 2.0 * mid
+        # apply_transform reverses face winding for negative determinants,
+        # so normals stay outward and cavity detection keeps working.
+        mesh.apply_transform(mirror)
     (x_min, y_min, z_min), (x_max, y_max, z_max) = mesh.bounds
 
     if z_levels is not None:

tests/test_nozzle_spacing.py

@@ -111,7 +111,7 @@ def test_shape_settings_round_trip_contour_tracing_column() -> None:
 
     rows = _shape_settings_rows(records)
     assert SHAPE_SETTINGS_HEADERS[6:9] == ["Valve", "Nozzle", "Port"]
-    assert SHAPE_SETTINGS_HEADERS[-3:] == ["Contour Tracing", "Lead In", "Delete"]
+    assert SHAPE_SETTINGS_HEADERS[-4:] == ["Contour Tracing", "Lead In", "Flip Z", "Delete"]
     contour_pos = SHAPE_SETTINGS_HEADERS.index("Contour Tracing")
     lead_in_pos = SHAPE_SETTINGS_HEADERS.index("Lead In")
     assert rows[0][6:9] == [4, 1, 1]
@@ -691,6 +691,8 @@ def test_delete_shape_cooldown_blocks_immediate_second_delete() -> None:
     ]
 
     first_outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
+    assert [record["name"] for record in first_outputs[1]] == ["first", "last"]
+
     second_outputs = delete_shape_from_settings(
         first_outputs[1],
         first_outputs[2],
@@ -698,7 +700,26 @@ def test_delete_shape_cooldown_blocks_immediate_second_delete() -> None:
         Event(),
     )
 
-    assert [record["name"] for record in second_outputs[1]] == ["first", "last"]
+    # Blocked by the cooldown: every output is skipped (nothing rewritten).
+    assert not isinstance(second_outputs[1], list)
+
+
+def test_non_delete_cell_selection_touches_nothing() -> None:
+    # The select handler fires on EVERY cell click; unless the click is on
+    # the Delete column it must skip all outputs — echoing the table here
+    # raced (and clobbered) the Keep Proportions dimension recompute.
+    class Event:
+        index = (0, 3)  # a Target Y cell
+
+    records = [
+        {"idx": 1, "name": "first", "stl_path": "first.stl", "target_x": 10.0, "target_y": 11.0, "target_z": 12.0, "pressure": 25, "valve": 4, "port": 1, "color": "#111111"},
+    ]
+
+    outputs = delete_shape_from_settings(records, _shape_settings_rows(records), 0.0, Event())
+
+    assert len(outputs) == 8
+    assert all(not isinstance(value, list) for value in outputs)
+    assert not isinstance(outputs[1], list)  # records State untouched
 
 
 def test_group_split_splits_all_materials_on_one_shared_grid() -> None:
@@ -816,3 +837,259 @@ def test_describe_split_source_warns_about_group_splits() -> None:
     # No selection defaults to the first shape - which is grouped here.
     assert "whole group as one shape" in describe_split_source(records, None)
     assert describe_split_source([], None) == SPLIT_STATUS_DEFAULT
+
+
+def test_keep_proportions_is_stale_echo_proof() -> None:
+    # The table's .change event delivers stale/echoed tables out of order.
+    # Anchoring must come from the ROW's own ratios (odd one out), never from
+    # diffing against fresher records - that mis-anchored and reverted the
+    # first edit. Self-consistent rows must skip the table write entirely.
+    import gradio as gr
+
+    def _record(**overrides):
+        record = {
+            "idx": 1, "name": "cube", "stl_path": "cube.stl",
+            "original_x": 38.1, "original_y": 38.1, "original_z": 32.99557,
+            "target_x": 38.1, "target_y": 38.1, "target_z": 32.99557,
+            "pressure": 25.0, "valve": 4, "nozzle": 1, "port": 1,
+            "color": "#111111", "last_scaled_axis": "target_x",
+        }
+        record.update(overrides)
+        return record
+
+    # 1) A user edit (odd ratio on Y) rescales everything and writes the table.
+    records = [_record()]
+    rows = _shape_settings_rows(records)
+    rows[0][3] = 50.0
+    updated, table_out = normalize_shape_dimensions_for_mode(records, rows, SCALE_MODE_UNIFORM_FACTOR)
+    assert updated[0]["target_x"] == 50.0
+    assert updated[0]["target_z"] == 43.301273
+    assert isinstance(table_out, list)  # table written
+
+    # 2) A stale PRE-EDIT echo arrives while records already hold the scaled
+    #    dims: the row is self-consistent, so no re-anchor, no revert write.
+    stale_rows = _shape_settings_rows([_record()])
+    updated2, table_out2 = normalize_shape_dimensions_for_mode(updated, stale_rows, SCALE_MODE_UNIFORM_FACTOR)
+    assert not isinstance(table_out2, list)  # table output skipped
+
+    # 3) The echo of our own scaled write-back is also a no-op.
+    scaled_rows = _shape_settings_rows(updated)
+    updated3, table_out3 = normalize_shape_dimensions_for_mode(updated, scaled_rows, SCALE_MODE_UNIFORM_FACTOR)
+    assert not isinstance(table_out3, list)
+    assert updated3[0]["target_x"] == 50.0
+    assert updated3[0]["target_z"] == 43.301273
+
+
+def _mm_member(idx: int, nozzle: int, ox: float, oy: float, oz: float) -> dict:
+    return {
+        "idx": idx, "name": f"part{idx}", "stl_path": f"part{idx}.stl",
+        "original_x": ox, "original_y": oy, "original_z": oz,
+        "target_x": ox, "target_y": oy, "target_z": oz,
+        "pressure": 25.0, "valve": 4, "nozzle": nozzle, "port": 1,
+        "color": "#111111", "last_scaled_axis": "target_x",
+    }
+
+
+def test_group_members_share_scale_factors_in_independent_mode() -> None:
+    from app import SCALE_MODE_TARGET_DIMENSIONS
+
+    # Two assembly parts of DIFFERENT sizes on nozzle 1, a solo on nozzle 2.
+    records = [
+        _mm_member(1, 1, 40.0, 20.0, 10.0),
+        _mm_member(2, 1, 20.0, 20.0, 10.0),
+        _mm_member(3, 2, 30.0, 30.0, 30.0),
+    ]
+    rows = _shape_settings_rows(records)
+    rows[0][2] = 60.0  # X of part 1: factor 1.5
+
+    updated, table_out = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_TARGET_DIMENSIONS
+    )
+
+    # Part 2 gets the same FACTOR (x 20 -> 30), not the same absolute value.
+    assert updated[0]["target_x"] == 60.0
+    assert updated[1]["target_x"] == 30.0
+    # Unedited axes keep factor 1.
+    assert updated[0]["target_y"] == 20.0 and updated[1]["target_y"] == 20.0
+    # Solo shape on its own nozzle is untouched.
+    assert updated[2]["target_x"] == 30.0
+    assert isinstance(table_out, list)  # propagation must be written back
+
+
+def test_group_members_share_scale_factors_in_keep_proportions() -> None:
+    records = [
+        _mm_member(1, 1, 40.0, 20.0, 10.0),
+        _mm_member(2, 1, 20.0, 20.0, 10.0),
+    ]
+    rows = _shape_settings_rows(records)
+    rows[0][3] = 30.0  # Y of part 1: factor 1.5
+
+    updated, table_out = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_UNIFORM_FACTOR
+    )
+
+    # Part 1 rescales proportionally; part 2 follows with the same factor.
+    assert [updated[0][k] for k in ("target_x", "target_y", "target_z")] == [60.0, 30.0, 15.0]
+    assert [updated[1][k] for k in ("target_x", "target_y", "target_z")] == [30.0, 30.0, 15.0]
+    assert isinstance(table_out, list)
+
+    # The echo of that write-back is a converged no-op.
+    echoed_rows = _shape_settings_rows(updated)
+    updated2, table_out2 = normalize_shape_dimensions_for_mode(
+        updated, echoed_rows, SCALE_MODE_UNIFORM_FACTOR
+    )
+    assert not isinstance(table_out2, list)
+    assert updated2[1]["target_x"] == 30.0
+
+
+def test_group_propagation_skips_when_the_source_is_ambiguous() -> None:
+    from app import SCALE_MODE_TARGET_DIMENSIONS
+
+    # A stale echo can make SEVERAL members look edited at once: the
+    # propagation must not guess a source (guessing reverted edits).
+    records = [
+        _mm_member(1, 1, 40.0, 20.0, 10.0),
+        _mm_member(2, 1, 20.0, 20.0, 10.0),
+    ]
+    records[0]["target_x"] = 60.0  # records already hold part 1 scaled...
+    rows = _shape_settings_rows(records)
+    rows[0][2] = 44.0  # ...while the table flags edits on BOTH members
+    rows[1][2] = 24.0
+
+    updated, _table_out = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_TARGET_DIMENSIONS
+    )
+
+    # Both edits applied as-is; no propagation happened (factors differ).
+    assert updated[0]["target_x"] == 44.0
+    assert updated[1]["target_x"] == 24.0
+
+
+def test_joining_a_nozzle_group_adopts_the_group_scale() -> None:
+    from app import SCALE_MODE_TARGET_DIMENSIONS
+
+    # Nozzle-1 group already scaled x1.5; a solo shape moves onto nozzle 1
+    # via the Nozzle column and must adopt the group's factors.
+    member_a = _mm_member(1, 1, 40.0, 20.0, 10.0)
+    member_b = _mm_member(2, 1, 20.0, 20.0, 10.0)
+    for member in (member_a, member_b):
+        for axis in ("x", "y", "z"):
+            member[f"target_{axis}"] = member[f"original_{axis}"] * 1.5
+    solo = _mm_member(3, 2, 30.0, 10.0, 10.0)
+
+    records = [member_a, member_b, solo]
+    rows = _shape_settings_rows(records)
+    nozzle_pos = SHAPE_SETTINGS_HEADERS.index("Nozzle")
+    rows[2][nozzle_pos] = 1  # solo joins the assembly
+
+    updated, table_out = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_TARGET_DIMENSIONS
+    )
+
+    assert [updated[2][k] for k in ("target_x", "target_y", "target_z")] == [45.0, 15.0, 15.0]
+    # Incumbents unchanged.
+    assert updated[0]["target_x"] == 60.0
+    assert isinstance(table_out, list)
+
+    # The echo of that write-back converges (nozzle now matches the record).
+    echoed = _shape_settings_rows(updated)
+    updated2, table_out2 = normalize_shape_dimensions_for_mode(
+        updated, echoed, SCALE_MODE_TARGET_DIMENSIONS
+    )
+    assert not isinstance(table_out2, list)
+    assert updated2[2]["target_x"] == 45.0
+
+
+def test_split_pieces_are_never_rescaled_by_keep_proportions() -> None:
+    # Regression: split pieces inherit the parent's original_* dims while
+    # their targets are the CELL sizes; a table echo in Keep Proportions
+    # used to "restore" the parent dimensions (shapes visibly reset after
+    # e.g. a color change).
+    piece = {
+        "idx": 1, "name": "cube - R1C1", "stl_path": None,
+        "original_x": 30.0, "original_y": 30.0, "original_z": 30.0,
+        "target_x": 15.2, "target_y": 15.2, "target_z": 30.0,
+        "pressure": 25.0, "valve": 4, "nozzle": 1, "port": 1,
+        "color": "#111111", "split_group_id": "split-1", "split_columns": 2,
+        "split_rows": 2, "last_scaled_axis": "target_x",
+    }
+    records = [piece, dict(piece, idx=2, name="cube - R1C2", nozzle=1, valve=5)]
+    rows = _shape_settings_rows(records)
+
+    updated, table_out = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_UNIFORM_FACTOR
+    )
+
+    assert updated[0]["target_x"] == 15.2  # NOT reset to 30
+    assert updated[0]["target_z"] == 30.0
+    assert updated[1]["target_x"] == 15.2
+    assert not isinstance(table_out, list)  # nothing changed, no write-back
+
+
+def test_select_all_string_bools_trigger_a_canonical_rewrite() -> None:
+    # Gradio's header "select all" writes STRING "true"/"false" into the
+    # checkbox columns (rendered as text / stray stale checkboxes). The
+    # normalizer must answer with real rows so the table re-renders with
+    # proper booleans; a clean payload must stay a no-op.
+    from app import SCALE_MODE_TARGET_DIMENSIONS
+
+    records = [
+        _mm_member(1, 1, 10.0, 10.0, 10.0),
+        _mm_member(2, 2, 10.0, 10.0, 10.0),
+    ]
+    rows = _shape_settings_rows(records)
+    lead_in_pos = SHAPE_SETTINGS_HEADERS.index("Lead In")
+    for row in rows:
+        row[lead_in_pos] = "true"  # select-all artifact
+
+    updated, table_out = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_TARGET_DIMENSIONS
+    )
+
+    assert all(record["lead_in"] is True for record in updated)
+    assert isinstance(table_out, list)  # canonical rewrite issued
+    assert all(row[lead_in_pos] is True for row in table_out)  # real booleans
+
+    # The rewrite's echo is clean -> converges to a no-op.
+    updated2, table_out2 = normalize_shape_dimensions_for_mode(
+        updated, table_out, SCALE_MODE_TARGET_DIMENSIONS
+    )
+    assert not isinstance(table_out2, list)
+
+    # Unchecking via select-all ("false" strings) round-trips too.
+    rows_off = _shape_settings_rows(updated2)
+    for row in rows_off:
+        row[lead_in_pos] = "false"
+    updated3, table_out3 = normalize_shape_dimensions_for_mode(
+        updated2, rows_off, SCALE_MODE_TARGET_DIMENSIONS
+    )
+    assert all(record["lead_in"] is False for record in updated3)
+    assert isinstance(table_out3, list)
+
+
+def test_apply_bulk_bool_selection_sets_a_whole_column() -> None:
+    from app import apply_bulk_bool_selection
+
+    records = [
+        _mm_member(1, 1, 10.0, 10.0, 10.0),
+        _mm_member(2, 2, 10.0, 10.0, 10.0),
+        _mm_member(3, 3, 10.0, 10.0, 10.0),
+    ]
+    flip_pos = SHAPE_SETTINGS_HEADERS.index("Flip Z")
+    lead_pos = SHAPE_SETTINGS_HEADERS.index("Lead In")
+
+    updated, rows = apply_bulk_bool_selection(records, None, f"{flip_pos}|1")
+    assert all(record["flip_z"] is True for record in updated)
+    assert all(record.get("lead_in") is not True for record in updated)  # no bleed
+    assert all(row[flip_pos] is True for row in rows)
+    assert all(row[lead_pos] is False for row in rows)
+
+    # Unchecking clears the whole column; junk payloads change nothing.
+    cleared, rows2 = apply_bulk_bool_selection(updated, rows, f"{flip_pos}|0")
+    assert all(record["flip_z"] is False for record in cleared)
+    same, _rows3 = apply_bulk_bool_selection(cleared, rows2, "garbage")
+    assert all(record["flip_z"] is False for record in same)
+    # Non-bool columns are refused.
+    color_pos = SHAPE_SETTINGS_HEADERS.index("Color")
+    refused, _rows4 = apply_bulk_bool_selection(cleared, rows2, f"{color_pos}|1")
+    assert refused[0].get("color") == cleared[0].get("color")

tests/test_stl_slicer.py

@@ -140,3 +140,79 @@ def test_slice_stl_handles_abutting_cells_and_stray_open_quads(tmp_path) -> None
     for layer in stack.layers:
         assert layer.area == pytest.approx(500.0)
         assert layer.bounds == pytest.approx((0.0, 0.0, 30.0, 30.0))
+
+
+def test_scale_mesh_about_an_explicit_anchor() -> None:
+    mesh = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
+    mesh.apply_translation((6.0, 6.0, 6.0))  # spans 5..7 on every axis
+
+    scaled = scale_mesh(mesh, (2.0, 2.0, 2.0), anchor=(0.0, 0.0, 0.0))
+
+    # Scaling about the shared origin: 5..7 becomes 10..14 (own-corner
+    # scaling would give 5..9 and shift the part within an assembly).
+    np.testing.assert_allclose(scaled.bounds[0], (10.0, 10.0, 10.0))
+    np.testing.assert_allclose(scaled.bounds[1], (14.0, 14.0, 14.0))
+
+
+def test_slice_stl_scale_anchor_keeps_assembly_parts_together(tmp_path) -> None:
+    # Two assembly parts side by side; both scaled x2 about the ASSEMBLY
+    # corner must stay adjacent (B's min corner moves from 4 to 8).
+    a = trimesh.creation.box(extents=(4.0, 4.0, 4.0))
+    a.apply_translation((2.0, 2.0, 2.0))  # spans 0..4
+    b = trimesh.creation.box(extents=(4.0, 4.0, 4.0))
+    b.apply_translation((6.0, 2.0, 2.0))  # spans 4..8 in x
+    path_a = tmp_path / "a.stl"
+    path_b = tmp_path / "b.stl"
+    a.export(path_a)
+    b.export(path_b)
+
+    anchor = (0.0, 0.0, 0.0)
+    stack_a = slice_stl_to_layers(path_a, 1.0, scale_factors=(2.0, 2.0, 2.0), scale_anchor=anchor)
+    stack_b = slice_stl_to_layers(path_b, 1.0, scale_factors=(2.0, 2.0, 2.0), scale_anchor=anchor)
+
+    assert stack_a.bounds[0][0] == pytest.approx(0.0)
+    assert stack_a.bounds[1][0] == pytest.approx(8.0)
+    assert stack_b.bounds[0][0] == pytest.approx(8.0)  # still flush against A
+    assert stack_b.bounds[1][0] == pytest.approx(16.0)
+
+
+def test_flip_z_mirrors_the_shape_top_to_bottom(tmp_path) -> None:
+    # Wide slab with a narrow tower on top; flipped, the tower prints first.
+    slab = trimesh.creation.box(extents=(10.0, 10.0, 1.0))
+    slab.apply_translation((5.0, 5.0, 0.5))       # z 0..1
+    tower = trimesh.creation.box(extents=(2.0, 2.0, 1.0))
+    tower.apply_translation((5.0, 5.0, 1.5))      # z 1..2
+    stl_path = tmp_path / "tower.stl"
+    trimesh.util.concatenate([slab, tower]).export(stl_path)
+
+    normal = slice_stl_to_layers(stl_path, layer_height=1.0)
+    flipped = slice_stl_to_layers(stl_path, layer_height=1.0, flip_z=True)
+
+    assert [round(layer.area) for layer in normal.layers] == [100, 4]
+    assert [round(layer.area) for layer in flipped.layers] == [4, 100]
+    # Flip about the own midplane preserves the Z range.
+    assert flipped.bounds[0][2] == pytest.approx(normal.bounds[0][2])
+    assert flipped.bounds[1][2] == pytest.approx(normal.bounds[1][2])
+
+
+def test_flip_z_about_a_group_midplane_flips_the_assembly_as_one(tmp_path) -> None:
+    # Two assembly parts at different heights flip about the SHARED midplane:
+    # the part that was on top lands on the bottom of the shared Z range.
+    low = trimesh.creation.box(extents=(4.0, 4.0, 1.0))
+    low.apply_translation((2.0, 2.0, 0.5))   # z 0..1
+    high = trimesh.creation.box(extents=(4.0, 4.0, 1.0))
+    high.apply_translation((6.0, 2.0, 2.5))  # z 2..3
+    path_low = tmp_path / "low.stl"
+    path_high = tmp_path / "high.stl"
+    low.export(path_low)
+    high.export(path_high)
+
+    group_mid = 1.5  # shared z range 0..3
+    z_levels = [0.5, 1.5, 2.5]
+    stack_low = slice_stl_to_layers(path_low, 1.0, z_levels=z_levels, flip_z=True, z_flip_mid=group_mid)
+    stack_high = slice_stl_to_layers(path_high, 1.0, z_levels=z_levels, flip_z=True, z_flip_mid=group_mid)
+
+    # `low` (was z 0..1) now occupies z 2..3; `high` now z 0..1.
+    assert [layer.is_empty for layer in stack_low.layers] == [True, True, False]
+    assert [layer.is_empty for layer in stack_high.layers] == [False, True, True]
+    assert stack_high.layers[0].area == pytest.approx(16.0)

tests/test_vector_gcode.py

@@ -1619,3 +1619,83 @@ def test_group_contour_paths_exclude_material_interfaces() -> None:
     shell_layer = box(0.0, 0.0, 4.0, 4.0).difference(box(1.0, 1.0, 3.0, 3.0))
     shell = _stack(shell_layer, name="shell")
     assert group_contour_paths(core, [shell], tolerance=0.4) == [[]]
+
+
+def test_scan_coords_keep_a_boundary_line_despite_float_noise() -> None:
+    from vector_toolpath import _scan_coords
+
+    # A split cut can land exactly ON a grid line; the piece above the cut
+    # owns that line (half-open interval), and float noise in the ratio must
+    # not ceil it away. These are the real flag-split numbers.
+    coords = _scan_coords(-15.2, 0.0, 0.8, anchor=-14.4)
+    assert abs(coords[0] - (-15.2)) < 1e-9   # boundary line kept
+    assert abs(coords[-1] - (-0.8)) < 1e-9   # cut line excluded (half-open)
+
+    # Same numbers arriving with adversarial float error.
+    noisy_lo = 0.0 - 19 * 0.8  # -15.200000000000001
+    coords2 = _scan_coords(noisy_lo, 0.0, 0.8, anchor=-14.4)
+    assert abs(coords2[0] - (-15.2)) < 1e-6
+
+
+def test_split_seam_on_a_grid_line_reassembles_at_one_fil_pitch(tmp_path) -> None:
+    # Frame y[-15, 15] with 2 rows puts the cut at y=0 — exactly on a
+    # scanline of the shared grid. The seam line must be printed by exactly
+    # one piece, and the reassembled seam must keep one-fil bead pitch (a
+    # dropped line printed a visible one-pixel gap at every seam).
+    from gcode_viewer import parse_gcode_path
+
+    layer = box(-25.0, -15.0, 25.0, 15.0)
+    stack = _stack(layer, layer, name="flagish")
+    stack = LayerStack(
+        layers=stack.layers,
+        z_values=stack.z_values,
+        bounds=((-25.0, -15.0, 0.0), (25.0, 15.0, 2.0)),
+        layer_height=1.0,
+        name="flagish",
+    )
+    pieces = split_layer_stack_grid(stack, columns=1, rows=2, grid=0.8)
+    reference = build_reference_stack(list(pieces), grid=0.8)
+
+    world_lines: dict[str, list[float]] = {}
+    for piece in pieces:
+        gcode_path = generate_vector_gcode(
+            piece,
+            shape_name=piece.name,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=0.8,
+            layer_height=1.0,
+            motion=reference,
+            output_dir=tmp_path,
+        )
+        parsed = parse_gcode_path(gcode_path.read_text())
+        _ox, oy = parsed["path_origin"]
+        world_lines[piece.name] = sorted(
+            {round(y + oy, 6) for seg in parsed["print_segments"] for _x, y, _z in seg}
+        )
+
+    top = world_lines[pieces[0].name]     # row 1 = top strip
+    bottom = world_lines[pieces[1].name]
+    # The cut line at y=0 belongs to the TOP piece (its material starts there).
+    assert abs(top[0] - 0.0) < 1e-6
+    assert abs(bottom[-1] - (-0.8)) < 1e-6
+    # Seam pitch is exactly one fil; the line is printed exactly once.
+    assert abs((top[0] - bottom[-1]) - 0.8) < 1e-6
+    overlap = set(top) & set(bottom)
+    assert not overlap
+
+
+def test_boundary_grid_line_grazing_from_outside_still_prints() -> None:
+    from vector_toolpath import _axis_raster_segments
+
+    # Real flag-split floats: the grid line computes as -15.200000000000001
+    # while the material's bottom edge is -15.199999999999999 — the line
+    # grazes the material from OUTSIDE by two ulps. The chord probe must
+    # still find the boundary sweep or the assembled seam gets a one-fil gap.
+    material = MultiPolygon([box(-25.0, -15.2, 25.0, 0.0)])
+    segments = _axis_raster_segments(
+        material, material, 0.8, axis="X", scan_anchor=-14.4
+    )
+    print_ys = sorted({y0 for _x0, y0, _x1, _y1, color in segments if color == 255})
+    assert abs(print_ys[0] - (-15.2)) < 1e-6  # boundary sweep printed

vector_toolpath.py

@@ -367,8 +367,13 @@ def _scan_coords(
         count = int(math.floor((hi - lo) / fil_width + 1e-9))
         return [anchor + index * fil_width for index in range(count)]
 
-    k_lo = math.ceil((lo - anchor) / fil_width - 1e-9)
-    k_hi = math.floor((hi - anchor) / fil_width - 1e-9)
+    # The epsilon is in grid-cell units and must swamp float noise from the
+    # anchor/edge arithmetic: a piece whose material starts EXACTLY on a grid
+    # line (a split cut on the line) can compute (lo-anchor)/fil as
+    # -1.0000000000000009, and a 1e-9 epsilon then ceils the boundary line
+    # away — nobody prints it and every assembled seam gets a one-fil gap.
+    k_lo = math.ceil((lo - anchor) / fil_width - 1e-6)
+    k_hi = math.floor((hi - anchor) / fil_width - 1e-6)
     return [anchor + k * fil_width for k in range(int(k_lo), int(k_hi) + 1)]
 
 
@@ -411,10 +416,20 @@ def _axis_raster_segments(
         scan_lo, scan_hi, fil_width
     )
 
+    # A grid line can graze the material boundary from OUTSIDE by float ulps
+    # (split cuts sit exactly on grid lines, and the piece's material edge IS
+    # the cut): probe the chords a hair inside the bounds so the boundary
+    # sweep is still found, while emitting at the true grid coordinate.
+    # A dropped boundary sweep prints a one-fil gap at every assembled seam.
+    probe_eps = fil_width * 1e-6
+    probe_lo = min(scan_lo + probe_eps, (scan_lo + scan_hi) / 2.0)
+    probe_hi = max(scan_hi - probe_eps, (scan_lo + scan_hi) / 2.0)
+
     segments: list[Seg] = []
     sweep_number = 0
     for coord in coords:
-        motion_runs = _chord_runs(motion, axis, coord)
+        probe = min(max(coord, probe_lo), probe_hi)
+        motion_runs = _chord_runs(motion, axis, probe)
         if not motion_runs:
             continue
 
@@ -426,7 +441,7 @@ def _axis_raster_segments(
             valve_runs: list[tuple[float, float]] = []
         else:
             valve_runs = []
-            for lo, hi in _chord_runs(valve, axis, coord):
+            for lo, hi in _chord_runs(valve, axis, probe):
                 lo = max(lo, sweep_lo)
                 hi = min(hi, sweep_hi)
                 if hi - lo > EPS: