embedded3 PERF-3 P1-4 (steps 1–3 + d): the band-persistent operator — CutGeometry marks re-evaluated corners; Mask::changed_cells (touched by either build, dilated by one); Level::patch re-derives the changed rows with the constructor's formulas on the kept level; the fine export patched likewise with the parent map as a parallel per-cell map; components plane by plane with a small union across planes; Problem::link_map (sparse) replaces the per-cell link lists on the per-step path; RTX_E3_BAND_CHECK=1 compares against full rebuilds (passed on the slab) — slab CSV byte-identical at every step, device moving/cg green; ny 124 rebuild block 2,569 → 2,119 ms per step

Co-Authored-By: Claude Fable 5.1 <[email protected]>

crates/specialized/rtx-cfd/src/solvers/incompressible/embedded3/cutwall.rs

@@ -211,6 +211,7 @@ impl Mask {
             wall_advancing: false,
             exchange_convection_off: false,
             wall_exchange_axis: false,
+            changed_cells: None,
             cv_sides_exact: false,
             wall_order2_centroid: false,
             wall_exchange_foot: false,
@@ -318,7 +319,37 @@ impl Mask {
             .collect();
         self.step_open = Some((open(&au), open(&av), open(&aw), active));
         self.step_apertures = Some((au, av, aw));
+        // P1-4: the changed set — cells touched by either build (this step's
+        // apertures average the two geometries), dilated by one.
+        let t_new = cut.touched_cells();
+        let t_old = old_cut.touched_cells();
         self.compute_merging(Some(old));
+        {
+            use rayon::prelude::*;
+            let g = self.grid;
+            let (nx, ny, nz) = (g.nx, g.ny, g.nz);
+            let nxy = nx * ny;
+            let periodic = self.periodic_z;
+            let changed: Vec<usize> = (0..g.cells())
+                .into_par_iter()
+                .filter(|&idx| {
+                    let (k, j, i) = (idx / nxy, (idx % nxy) / nx, idx % nx);
+                    let t = |q: usize| t_new[q] || t_old[q];
+                    if t(idx) {
+                        return true;
+                    }
+                    (i + 1 < nx && t(idx + 1))
+                        || (i > 0 && t(idx - 1))
+                        || (j + 1 < ny && t(idx + nx))
+                        || (j > 0 && t(idx - nx))
+                        || (k + 1 < nz && t(idx + nxy))
+                        || (k > 0 && t(idx - nxy))
+                        || (periodic && nz > 1 && k + 1 == nz && t(idx - (nz - 1) * nxy))
+                        || (periodic && nz > 1 && k == 0 && t(idx + (nz - 1) * nxy))
+                })
+                .collect();
+            self.changed_cells = Some(changed);
+        }
     }
 
     pub(super) fn lattice(&self) -> Lattice {