Pressure cap + tenths, recency port sync, ghost-row hiding, Enter commits cell edits

- Clamp pressure to 0-100 psi (MAX_PRESSURE_PSI) and round to tenths in the
table, port sync, presets, and the per-layer ramp; warn when a ramp would
hit the ceiling mid-print.
- Port-pressure sync now follows the most recently edited member (edit
stamps), matching how Keep Proportions follows the latest dimension edit.
- Hide stale duplicate table rows left over by Gradio's double render so
group/port summaries never count ghosts.
- Fix Enter in a table cell not applying the edit: Gradio's Enter handler
reads the editor from its els registry, which the duplicate table copy
clobbers, so the typed value was dropped until a click outside. Intercept
Enter in capture phase and commit through the blur path instead, then
close the cell with a synthetic Escape.

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

README.md

@@ -118,6 +118,7 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - 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 commands are written **once per port**: when shapes share a serial port, only the first shape's file carries the preset, toggle, and per-layer ramp — the print host compiles every file onto one timeline, and duplicated toggles would flip the regulator on/off/on at start. Valve commands stay per shape in every file.
 - Pressure increases by `0.1` psi per layer by default.
+- Pressures are bounded to the regulator's range: table values clamp to 0–100 psi and snap to the tenths place (the serial protocol encodes `pressure × 10`), the per-layer ramp never climbs past 100 psi in the files, and the generation status warns when a ramp would hit the ceiling before the last layer.
 - Every movement line is emitted as `G1` at one constant speed (no `G0` rapid travel); the WAGO valve commands mark where material is dispensed vs where the head just travels.
 - **Lead In**: enabled per shape via the **Lead In** column in Shape Settings; the Lead In Options accordion sets the patch geometry. Prints a purge patch before layer 1: **Lead In Position** (Left/Right/Up/Down) picks which side of the shape it sits on, **Lead In Clearance** how far away, and **Lead In Line Direction** which way the purge strokes run — Auto points them at the shape (the historical behavior), or force Horizontal/Vertical (e.g. a patch below the shape with horizontal strokes). When strokes run across the approach, lines step further away from the shape. The return route exits the patch laterally and comes home through the clearance lane, so the primed nozzle never drags back across the wet purge lines. For grid-split pieces the clearance is automatically extended by the assembly's remaining extent along the purge axis (reported in the G-code status), so under shared reference motion every nozzle's purge patch lands clear of the whole assembled part instead of on a neighbor's print area. The **Lead In** column in Shape Settings controls dispensing per shape: an opted-out head still travels the shared patch (keeping parallel heads in sync) but keeps its valve shut, and skips the lead-in moves entirely when printing without shared motion.
 - **Combined reference outline for motion** (always on): every shape's *motion* is taken from the combined reference layer union while each shape's *valve/dispensing* comes from its own layer polygons — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference union is rebuilt automatically whenever shapes are sliced or G-code is generated. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.

app.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import itertools
 import json
 import math
 import tempfile
@@ -38,7 +39,7 @@ from stl_slicer import (
     scale_mesh,
     slice_stl_to_layers,
 )
-from vector_gcode import generate_vector_gcode
+from vector_gcode import MAX_PRESSURE_PSI, generate_vector_gcode
 from vector_toolpath import (
     LEAD_IN_DIRECTION_CHOICES,
     LEAD_IN_DIRECTION_LEFT,
@@ -532,6 +533,28 @@ APP_HEAD = """
             }
         });
     }
+    function commitCellEditOnEnter(event) {
+        // Gradio's own Enter handler loses the edit: it reads the editor via
+        // its els registry, which the duplicate table copy has clobbered, so
+        // the typed value is dropped and no change event reaches the server.
+        // The click-out path works because the editor's real blur event
+        // carries the textarea itself. So on Enter: suppress Gradio's
+        // handler and commit through the blur path, then send a synthetic
+        // Escape so the cell exits edit mode like a normal commit.
+        if (event.key !== 'Enter' || event.shiftKey) return;
+        var el = event.target;
+        if (!el || el.tagName !== 'TEXTAREA' || !el.closest) return;
+        if (!el.closest('#shape-settings-table, #nozzle-grid-spacing-table')) return;
+        if (el.closest('th')) return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        el.blur();
+        el.dispatchEvent(new KeyboardEvent('keydown', {
+            key: 'Escape',
+            bubbles: true,
+            cancelable: true,
+        }));
+    }
     function suppressDeleteCellEditor(event) {
         var cell = event.target && event.target.closest ? event.target.closest('#shape-settings-table td:last-child, #shape-settings-table [role="gridcell"]:nth-child(12n)') : null;
         if (!cell) return;
@@ -556,6 +579,8 @@ APP_HEAD = """
     }
     function start() {
         enableUndoButtons();
+        // Capture phase: must beat the dataframe's own keydown handlers.
+        document.addEventListener('keydown', commitCellEditOnEnter, true);
         document.addEventListener('focusin', suppressDeleteCellEditor);
         document.addEventListener('pointerdown', isolateColorCell, true);
         document.addEventListener('mousedown', isolateColorCell, true);
@@ -622,6 +647,7 @@ APP_HEAD = """
         var entries = [];
         Array.prototype.slice.call(container.querySelectorAll('table tbody tr')).forEach(function (tr) {
             var tds = tr.querySelectorAll('td');
+            tr.style.display = '';
             for (var i = 0; i < tds.length; i++) {
                 tds[i].style.background = '';
                 if (i === 0 || i === PRESSURE_COL || i === PORT_COL) tds[i].style.boxShadow = '';
@@ -652,7 +678,17 @@ APP_HEAD = """
                 entry.pressure = cellName(tds[PRESSURE_COL]);
                 entry.fromLive = true;
             }
-            entry.copies.push({tr: tr, tds: tds});
+            entry.copies.push({tr: tr, tds: tds, live: fromLive});
+        });
+        // Ghost pass: when a Shape number has a LIVE row, any stale copy of
+        // it in the outer table is a render leftover — hide it entirely.
+        // (Shape numbers with no live row are left alone: hiding on a guess
+        // could blank a legitimately rendered table.)
+        entries.forEach(function (entry) {
+            if (!entry.fromLive) return;
+            entry.copies.forEach(function (copy) {
+                if (!copy.live) copy.tr.style.display = 'none';
+            });
         });
         var byNozzle = {}, byValve = {}, byPort = {};
         entries.forEach(function (entry) {
@@ -2041,6 +2077,7 @@ def _records_from_files(files: Any, previous_records: list[dict] | None = None)
                 if _coerce_int(record.get("port"), 1) == port
             ]
             pressure = port_mates[0].get("pressure", 25.0) if port_mates else 25.0
+        pressure = round(min(max(_coerce_float(pressure, 25.0), 0.0), MAX_PRESSURE_PSI), 1)
         records.append({
             "idx": index,
             "name": name,
@@ -2055,6 +2092,9 @@ def _records_from_files(files: Any, previous_records: list[dict] | None = None)
             "target_z": round(_coerce_float(previous.get("target_z"), default_z), 1),
             "last_scaled_axis": previous.get("last_scaled_axis", "target_x"),
             "pressure": pressure,
+            # When this shape's pressure was last hand-edited (port-group
+            # sync follows the most recent edit); survives re-syncs.
+            "pressure_edited_at": previous.get("pressure_edited_at"),
             "valve": valve,
             "nozzle": nozzle,
             "port": previous.get("port", 1),
@@ -2156,6 +2196,11 @@ def _apply_shape_settings(records: list[dict], settings_table: Any) -> list[dict
                     copy[key] = float(row[pos])
                 except (IndexError, TypeError, ValueError):
                     copy[key] = copy.get(key, default)
+            # The regulator range is 0..MAX_PRESSURE_PSI in tenths: values
+            # outside it (or with more decimals) can't reach the hardware.
+            copy["pressure"] = round(
+                min(max(_coerce_float(copy.get("pressure"), 25.0), 0.0), MAX_PRESSURE_PSI), 1
+            )
             has_nozzle_column = len(row) >= len(SHAPE_SETTINGS_HEADERS)
             nozzle_pos = 7 if has_nozzle_column else None
             port_pos = 8 if has_nozzle_column else 7
@@ -2862,7 +2907,11 @@ def _last_edited_pressures(records: list[dict] | None, settings_table: Any) -> d
         if not previous or len(row) <= pressure_pos:
             continue
         old_pressure = _coerce_float(previous.get("pressure"), 25.0)
-        new_pressure = _coerce_float(row[pressure_pos], old_pressure)
+        # Clamp/round like _apply_shape_settings does, so the value that
+        # propagates through a port group is the one the hardware can take.
+        new_pressure = round(
+            min(max(_coerce_float(row[pressure_pos], old_pressure), 0.0), MAX_PRESSURE_PSI), 1
+        )
         if not math.isclose(new_pressure, old_pressure, rel_tol=0.0, abs_tol=1e-9):
             edited[idx] = new_pressure
     return edited
@@ -2896,6 +2945,9 @@ def _last_edited_ports(records: list[dict] | None, settings_table: Any) -> set[i
     return changed
 
 
+_PRESSURE_EDIT_SEQUENCE = itertools.count(1)
+
+
 def _sync_port_pressures(
     records: list[dict],
     edited_pressures: dict[int, float],
@@ -2904,13 +2956,15 @@ def _sync_port_pressures(
     """Sync pressures across shapes sharing a serial Port.
 
     Pressure is a PORT property — one regulator per serial port — so every
-    shape on a port must carry the same pressure. The source value must be
-    unambiguous: the pressure the user just edited (all edits agreeing), or
-    — when a shape just JOINED the group by a port edit — the incumbent
-    members' shared pressure, which the newcomer adopts. Groups already in
-    sync, or with no clear source (e.g. stale .change echoes that flag
-    conflicting members at once), are left untouched, so the event storm
-    converges instead of ping-ponging.
+    shape on a port must carry the same pressure. The source value, in
+    order of preference: the pressure the user just edited (all edits
+    agreeing); otherwise the member whose pressure was edited MOST RECENTLY
+    (each edit stamps `pressure_edited_at`, mirroring how Keep Proportions
+    follows the most recently changed dimension) — so when a port change
+    merges shapes whose pressures were set at different times, the newest
+    setting wins; otherwise, for stamp-less groups formed by a port edit,
+    the incumbents' shared pressure. Conflicting simultaneous edits (stale
+    .change echoes) are left untouched so the event storm converges.
     """
     joined_idx = joined_idx or set()
     by_port: dict[int, list[dict]] = {}
@@ -2935,9 +2989,22 @@ def _sync_port_pressures(
         newcomers = [
             member for member in members if int(member.get("idx", 0)) in joined_idx
         ]
+        stamped = [
+            member
+            for member in members
+            if _coerce_float(member.get("pressure_edited_at"), 0.0) > 0.0
+        ]
         if len(edited_values) == 1:
             value = next(iter(edited_values))
-        elif not edited_values and newcomers and incumbents:
+        elif edited_values:
+            continue  # conflicting simultaneous edits (stale echo): do not guess
+        elif stamped:
+            # No edit in this event: follow the most recently edited member.
+            source = max(
+                stamped, key=lambda member: _coerce_float(member.get("pressure_edited_at"), 0.0)
+            )
+            value = _coerce_float(source.get("pressure"), 25.0)
+        elif newcomers and incumbents:
             incumbent_pressures = [
                 _coerce_float(member.get("pressure"), 25.0) for member in incumbents
             ]
@@ -2946,11 +3013,11 @@ def _sync_port_pressures(
                 for p in incumbent_pressures[1:]
             ):
                 continue
-            # A port edit pulled newcomers into the group: they adopt the
-            # incumbents' shared pressure.
+            # A port edit pulled newcomers into a never-edited group: they
+            # adopt the incumbents' shared pressure.
             value = incumbent_pressures[0]
         else:
-            continue  # ambiguous (stale echo): do not guess
+            continue  # no clear source: do not guess
 
         for member in members:
             member["pressure"] = value
@@ -3075,6 +3142,8 @@ def normalize_shape_dimensions_for_mode(
                 record["last_scaled_axis"] = edited_axes[idx]
             if record.get("stl_path"):
                 _round_targets_to_tenths(record)
+            if idx in edited_pressures:
+                record["pressure_edited_at"] = next(_PRESSURE_EDIT_SEQUENCE)
         normalized = _propagate_group_scale_factors(normalized, edited_axes, set(), joined_idx)
         normalized = _sync_port_pressures(normalized, edited_pressures, port_joined_idx)
         changed = any(
@@ -3171,6 +3240,10 @@ def normalize_shape_dimensions_for_mode(
     normalized = _propagate_group_scale_factors(
         normalized, edited_axes, recomputed_idx, joined_idx
     )
+    if edited_pressures:
+        for record in normalized:
+            if int(record.get("idx", 0)) in edited_pressures:
+                record["pressure_edited_at"] = next(_PRESSURE_EDIT_SEQUENCE)
     normalized = _sync_port_pressures(normalized, edited_pressures, port_joined_idx)
 
     # Idempotence guard (breaks the .change write-back cascade): only write
@@ -4442,6 +4515,29 @@ def generate_dynamic_gcode(
         except Exception as exc:
             messages.append(f"Shape {record['idx']}: failed ({exc}).")
 
+    # Pressure sanity: the regulator tops out at MAX_PRESSURE_PSI, and the
+    # per-layer ramp climbs 0.1 psi per layer — warn when a print would hit
+    # the ceiling (the files clamp there, so later layers hold the maximum).
+    if pressure_ramp_enabled and ref_layers is not None and getattr(ref_layers, "layers", None):
+        layer_count = len(ref_layers.layers)
+        peak_base = max(
+            (
+                _coerce_float(record.get("pressure"), 25.0)
+                for record in records
+                if record.get("gcode_path")
+            ),
+            default=0.0,
+        )
+        peak = peak_base + 0.1 * max(0, layer_count - 1)
+        if peak > MAX_PRESSURE_PSI + 1e-9:
+            messages.insert(
+                0,
+                f"&#9888;&#65039; The pressure ramp reaches the {MAX_PRESSURE_PSI:g} psi regulator "
+                f"limit before the last layer (base {peak_base:g} psi + 0.1/layer x {layer_count} "
+                "layers); the files hold the maximum from there on. Lower the base pressure or "
+                "disable the ramp if that is not intended.",
+            )
+
     generated_paths = [record.get("gcode_path") for record in records if record.get("gcode_path")]
     if generated_paths:
         # All heads share one motion path, so one file's length is the job's.

tests/test_nozzle_spacing.py

@@ -1226,6 +1226,43 @@ def test_table_dimensions_display_and_store_to_the_tenths_place() -> None:
         assert updated2[0][key] == round(updated2[0][key], 1)
 
 
+def test_pressure_clamps_to_the_regulator_range_and_tenths() -> None:
+    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),
+    ]
+    records[1]["port"] = 2
+    records[2]["port"] = 3
+    rows = _shape_settings_rows(records)
+    pressure_pos = SHAPE_SETTINGS_HEADERS.index("Pressure (psi)")
+    rows[0][pressure_pos] = 150.0    # above the regulator limit
+    rows[1][pressure_pos] = 25.678   # too many decimals
+    rows[2][pressure_pos] = -5.0     # negative
+
+    updated = _apply_shape_settings(records, rows)
+    assert [record["pressure"] for record in updated] == [100.0, 25.7, 0.0]
+
+
+def test_port_sync_propagates_the_clamped_rounded_pressure() -> None:
+    from app import SCALE_MODE_TARGET_DIMENSIONS
+
+    # Both shapes on port 1; the edit is over-limit AND over-precise.
+    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)
+    pressure_pos = SHAPE_SETTINGS_HEADERS.index("Pressure (psi)")
+    rows[0][pressure_pos] = 132.456
+
+    updated, _table = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_TARGET_DIMENSIONS
+    )
+    assert updated[0]["pressure"] == 100.0
+    assert updated[1]["pressure"] == 100.0  # the port-mate gets the CLAMPED value
+
+
 def test_pressure_edit_propagates_to_shapes_sharing_the_port() -> None:
     from app import SCALE_MODE_TARGET_DIMENSIONS
 
@@ -1259,6 +1296,53 @@ def test_pressure_edit_propagates_to_shapes_sharing_the_port() -> None:
     assert updated2[1]["pressure"] == 32.0
 
 
+def test_port_merge_follows_the_most_recently_edited_pressure() -> None:
+    from app import SCALE_MODE_TARGET_DIMENSIONS
+
+    # Shape 1 on port 1 (25 psi), shape 2 on port 2. The user edits shape
+    # 2's pressure (stamping it as most recent), THEN moves it onto port 1:
+    # the merged group follows the most recent edit — 40 psi wins, exactly
+    # like Keep Proportions follows the most recently changed dimension.
+    first = _mm_member(1, 1, 10.0, 10.0, 10.0)
+    second = _mm_member(2, 2, 10.0, 10.0, 10.0)
+    second["port"] = 2
+    records = [first, second]
+
+    rows = _shape_settings_rows(records)
+    pressure_pos = SHAPE_SETTINGS_HEADERS.index("Pressure (psi)")
+    rows[1][pressure_pos] = 40.0
+    records, _table = normalize_shape_dimensions_for_mode(
+        records, rows, SCALE_MODE_TARGET_DIMENSIONS
+    )
+    assert records[1]["pressure"] == 40.0
+    assert records[1].get("pressure_edited_at")  # stamped as the latest edit
+
+    rows2 = _shape_settings_rows(records)
+    port_pos = SHAPE_SETTINGS_HEADERS.index("Port")
+    rows2[1][port_pos] = 1  # merge onto port 1
+    merged, _table2 = normalize_shape_dimensions_for_mode(
+        records, rows2, SCALE_MODE_TARGET_DIMENSIONS
+    )
+    assert merged[0]["pressure"] == 40.0  # the incumbent FOLLOWS the newer edit
+    assert merged[1]["pressure"] == 40.0
+
+    # And the other way around: if the incumbent's pressure was edited more
+    # recently, ITS value wins when the ports merge.
+    third = _mm_member(3, 3, 10.0, 10.0, 10.0)
+    fourth = _mm_member(4, 4, 10.0, 10.0, 10.0)
+    fourth["port"] = 2
+    fourth["pressure"] = 40.0
+    group = [third, fourth]
+    rows3 = _shape_settings_rows(group)
+    rows3[0][pressure_pos] = 33.0  # edit the port-1 incumbent LAST
+    group, _t = normalize_shape_dimensions_for_mode(group, rows3, SCALE_MODE_TARGET_DIMENSIONS)
+    rows4 = _shape_settings_rows(group)
+    rows4[1][port_pos] = 1
+    merged2, _t2 = normalize_shape_dimensions_for_mode(group, rows4, SCALE_MODE_TARGET_DIMENSIONS)
+    assert merged2[0]["pressure"] == 33.0
+    assert merged2[1]["pressure"] == 33.0
+
+
 def test_moving_a_shape_onto_a_port_adopts_that_ports_pressure() -> None:
     from app import SCALE_MODE_TARGET_DIMENSIONS
 

tests/test_vector_gcode.py

@@ -297,6 +297,28 @@ def test_sweep_buffer_is_adjustable_and_can_be_disabled(tmp_path) -> None:
     assert none[0]["start"] == (0.0, 0.0, 0.0)
 
 
+def test_pressure_ramp_clamps_at_the_regulator_limit(tmp_path) -> None:
+    import re
+
+    layer = box(0.0, 0.0, 2.0, 2.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer, layer, layer),  # 3 layer changes -> 3 ramp steps
+        shape_name="ramp_cap",
+        pressure=99.8,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        pressure_ramp_enabled=True,
+        output_dir=tmp_path,
+    )
+    values = [
+        float(match) for match in re.findall(r"setpress\(([\d.]+)\)", gcode_path.read_text())
+    ]
+    # Preset, then the ramp climbing 0.1/layer but never past 100 psi.
+    assert values == [99.8, 99.9, 100.0, 100.0]
+
+
 def test_port_sharing_files_emit_pressure_commands_once(tmp_path) -> None:
     # The pressure regulator is a PORT device: a file generated WITHOUT
     # pressure ownership carries no serial commands at all (no preset, no

vector_gcode.py

@@ -32,9 +32,14 @@ from vector_toolpath import (
     plan_layer_moves,
 )
 
+# The pressure box protocol ("08PS" + pressure*10 over serial) drives a
+# regulator with a 0-100 psi range; values are encoded to the tenths place.
+MAX_PRESSURE_PSI = 100.0
+
 __all__ = [
     "LEAD_IN_DIRECTION_CHOICES",
     "LEAD_IN_DIRECTION_LEFT",
+    "MAX_PRESSURE_PSI",
     "RASTER_PATTERN_CHOICES",
     "RASTER_PATTERN_CIRCLE_SPIRAL",
     "RASTER_PATTERN_DIAGONAL_WOODPILE",
@@ -110,6 +115,9 @@ def write_gcode_file(
     com_port = f"serialPort{port}"
     color_dict: dict[int, int] = {0: 100, 255: valve}
 
+    # The regulator tops out at MAX_PRESSURE_PSI and resolves tenths: clamp
+    # the preset AND the per-layer ramp so no command asks the impossible.
+    pressure = round(min(max(float(pressure), 0.0), MAX_PRESSURE_PSI), 1)
     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)]
@@ -148,7 +156,9 @@ def write_gcode_file(
                     f"Z{_coord(move['Z'])} ; Color {move['Color']}"
                 )
                 if pressure_ramp_enabled and emit_pressure_commands:
-                    pressure_cur += increase_pressure_per_layer
+                    pressure_cur = round(
+                        min(pressure_cur + increase_pressure_per_layer, MAX_PRESSURE_PSI), 1
+                    )
                     pressure_next = _setpress_cmd(com_port, pressure_cur, start=False)
                 else:
                     pressure_next = None