Route stroke dirty mutation through helper

docs/modernization/debt.md

@@ -18,6 +18,10 @@ agent or engineer to remove them without reconstructing context from chat.
 
 ## Recent Reductions
 
+- 2026-06-13: DEBT-0036 was narrowed again. `Canvas::stroke_draw` current and
+  dual stroke dirty-box mutation now routes through the retained stroke
+  execution helper; framebuffer binding, shader uniform timing, sampler/texture
+  binding, and live draw execution remain retained.
 - 2026-06-13: DEBT-0036 was narrowed again. `Canvas::stroke_commit` retained
   commit input texture/sampler binding, erase/composite draw dispatch,
   committed-copy-to-dilate-source, and dilate draw now route through

docs/modernization/roadmap.md

@@ -3100,6 +3100,10 @@ Results:
   the retained stroke execution helper, while framebuffer binding, shader
   uniform timing, dirty-box mutation, sampler/texture binding, and live draw
   execution remain retained.
+- `Canvas::stroke_draw` current and dual stroke dirty-box mutation now shares
+  the retained stroke execution helper, while framebuffer binding, shader
+  uniform timing, sampler/texture binding, and live draw execution remain
+  retained.
 - Remaining simple color, hue, color-quad, grid heightmap, and pen/line
   preview shader setup in UI nodes and canvas modes now shares retained helper
   surfaces, while geometry, texture/sampler binding, blend/depth state,

docs/modernization/tasks.md

@@ -509,6 +509,12 @@ Done Checks:
 
 Progress Notes:
 
+- 2026-06-13: `Canvas::stroke_draw` current and dual stroke dirty-box mutation
+  now routes through `legacy_canvas_stroke_execution_services.h`; framebuffer
+  binding, shader uniform timing, sampler/texture binding, and draw execution
+  remain local to Canvas. Next slice should wrap the retained per-face
+  framebuffer/sample callback ordering without rewriting the new pad-pass or
+  commit executors.
 - 2026-06-13: `Canvas::stroke_commit` now routes retained commit input
   texture/sampler binding, erase/composite draw dispatch, committed-copy, and
   dilate draw through `legacy_canvas_stroke_commit_services.h`; history

src/canvas.cpp

@@ -716,16 +716,16 @@ void Canvas::stroke_draw()
 
             m_tmp[i].unbindFramebuffer();
 
-            const auto dirty_update = pp::panopainter::plan_legacy_canvas_stroke_face_dirty_update(
+            const auto dirty_update = pp::panopainter::apply_legacy_canvas_stroke_face_dirty_update(
                 pp::panopainter::LegacyCanvasStrokeFaceDirtyRequest {
                     .extent = stroke_extent,
                     .previous_accumulated_dirty_box = m_dirty_box[i],
                     .previous_pass_dirty_box = box_face[i],
                     .sample_dirty_box = box_sample,
                     .include_in_committed_dirty_box = true,
-                });
+                },
-            m_dirty_box[i] = dirty_update.accumulated_dirty_box;
+                m_dirty_box[i],
-            box_face[i] = dirty_update.pass_dirty_box;
+                &box_face[i]);
             // TODO: maybe average color?
             pad_color = f.col;
         });
@@ -820,16 +820,17 @@ void Canvas::stroke_draw()
                 m_tmp_dual[i].unbindFramebuffer();
 
                 // this mode overflows the main brush boundries
-                const auto dirty_update = pp::panopainter::plan_legacy_canvas_stroke_face_dirty_update(
+                [[maybe_unused]] const auto dirty_update =
-                    pp::panopainter::LegacyCanvasStrokeFaceDirtyRequest {
+                    pp::panopainter::apply_legacy_canvas_stroke_face_dirty_update(
-                        .extent = stroke_extent,
+                        pp::panopainter::LegacyCanvasStrokeFaceDirtyRequest {
-                        .previous_accumulated_dirty_box = m_dirty_box[i],
+                            .extent = stroke_extent,
-                        .previous_pass_dirty_box = box_sample,
+                            .previous_accumulated_dirty_box = m_dirty_box[i],
-                        .sample_dirty_box = box_sample,
+                            .previous_pass_dirty_box = box_sample,
-                        .include_in_committed_dirty_box =
+                            .sample_dirty_box = box_sample,
-                            stroke_material.composite_pass.dual_blend_mode == 0,
+                            .include_in_committed_dirty_box =
-                    });
+                                stroke_material.composite_pass.dual_blend_mode == 0,
-                m_dirty_box[i] = dirty_update.accumulated_dirty_box;
+                        },
+                        m_dirty_box[i]);
             });
     }
 

src/legacy_canvas_stroke_execution_services.h

@@ -246,6 +246,27 @@ std::size_t execute_legacy_canvas_stroke_frame_faces(
     };
 }
 
+[[nodiscard]] inline LegacyCanvasStrokeFaceDirtyResult apply_legacy_canvas_stroke_face_dirty_update(
+    const LegacyCanvasStrokeFaceDirtyRequest& request,
+    glm::vec4& accumulated_dirty_box,
+    glm::vec4* pass_dirty_box = nullptr,
+    bool* committed_dirty = nullptr,
+    bool* pass_dirty = nullptr) noexcept
+{
+    const auto result = plan_legacy_canvas_stroke_face_dirty_update(request);
+    accumulated_dirty_box = result.accumulated_dirty_box;
+    if (pass_dirty_box) {
+        *pass_dirty_box = result.pass_dirty_box;
+    }
+    if (committed_dirty) {
+        *committed_dirty = result.committed_dirty;
+    }
+    if (pass_dirty) {
+        *pass_dirty = result.pass_dirty;
+    }
+    return result;
+}
+
 [[nodiscard]] inline LegacyCanvasStrokePadExecutionResult execute_legacy_canvas_stroke_pad_faces(
     const LegacyCanvasStrokePadExecutionRequest& request)
 {