feat(studio): HEAL invents what was under the brush with MI-GAN, and keeps the blurred fill for the machines that cannot run it

The dust brush filled its hole with a blur of the hole's own rim — the light
beside it, carried in. Right for a speck on a wall, and visibly thin over
anything with structure: a stroke across a shirt came back as the average of a
shirt. The fill is now a learned one.

engine/inpaint.ts runs MI-GAN (andraniksargsyan/migan, the same
`migan_pipeline_v2.onnx` inpaint-web ships) through onnxruntime-web on the
visitor's own machine: 27MB of weights in public/models, WebGPU where the graph
fits the provider, the processor otherwise, one warm-up pass so the first repair
is not the one that pays for the kernels. It is handed the masked crop and
nothing else — the model's mask polarity is 255 KEEP / 0 HOLE, the opposite of
the obvious guess, and the other way round repaints the frame and leaves the
hole (measured).

Step 6e of the renderer cuts the crop at the resolution the model will actually
run at (512 on its longest side — the graph is fully convolutional and would
take a whole frame, and ten seconds over one), builds the mask from the brush's
own circles, and draws the answer into the fill surface at its own place in the
box. The composite, the feathered mask and the untouched frame around it are
unchanged, so nothing outside the mask moves — and when the model cannot be had
the blurred fill is still built first and still stands. The preview gets this
for free: renderPhoto was already async and the preview was already debounced.

Node probe: the model + polarity + read/write path run; heal-check.mjs keeps
measuring the fallback and now asserts the wiring and the polarity. Browser:
engine/inpaint.ts in a real Chromium returns a patch (hole moves, kept pixels
within 0.02 of a level), and the built app renders a 42-spot stroke in 4.7s on
single-threaded wasm with no fallback warning — 1.15s and the warning when the
model is taken away.

docker/frontend/src/engine/exportEngine.ts

@@ -54,6 +54,7 @@ import {
   HEAL_MASK_STOPS,
   readHeal,
 } from '../../shared/utils/heal';
+import { inpaintCrop, inpaintCropSize } from './inpaint';
 import { mosaicSkSL, mosaicUniforms, readMosaic } from '../../shared/utils/mosaic';
 import { gradientMaskSkSL, maskUniforms, readMasks, masksHaveSpatial } from '../../shared/utils/gradientMask';
 import {
@@ -1434,6 +1435,100 @@ export async function renderPhoto(input: RenderInput): Promise<RenderResult | nu
         // are the photo exactly, not a blur of it.
         fillCanvas.drawImageRect(cutImage, box, onto, own(Skia.Paint()));
       }
+
+      // The other half of the fill, and the better one where it can be had: the
+      // pixels under the brush invented by MI-GAN from the pixels around them
+      // (engine/inpaint.ts) rather than averaged from the rim. The blur above is
+      // still built first and still covers the whole box — it is drawn over by
+      // this where this reaches, and stands on its own wherever the model cannot
+      // be had (no runtime, no adapter, a load that fails): a soft repair beats
+      // no repair.
+      //
+      // What the model is handed is the mask's own box with a margin of context
+      // around it, read back at the resolution the model will actually run at —
+      // a repair is the mask and a few brush widths of what borders it, and the
+      // pixels outside the mask are never read back out of the answer, so the
+      // crop is cut to the mask and not to the frame. It is drawn into the fill
+      // surface at its own place in the box, 1:1 whenever no downscale happened
+      // and scaled back up when one did.
+      const mx0 = Math.min(...xs) - widest;
+      const my0 = Math.min(...ys) - widest;
+      const mx1 = Math.max(...xs) + widest;
+      const my1 = Math.max(...ys) + widest;
+      const margin = Math.max(16, 0.5 * Math.max(mx1 - mx0, my1 - my0));
+      const srcLeft = Math.max(boxLeft, Math.floor(mx0 - margin));
+      const srcTop = Math.max(boxTop, Math.floor(my0 - margin));
+      const srcRight = Math.min(boxRight, Math.ceil(mx1 + margin));
+      const srcBottom = Math.min(boxBottom, Math.ceil(my1 + margin));
+      const srcW = srcRight - srcLeft;
+      const srcH = srcBottom - srcTop;
+      if (srcW >= 8 && srcH >= 8) {
+        const { w: mw, h: mh } = inpaintCropSize(srcW, srcH);
+        const cropSurface = own(createSurface(mw, mh));
+        if (cropSurface) {
+          cropSurface.getCanvas().drawImageRect(
+            snap,
+            Skia.XYWHRect(srcLeft, srcTop, srcW, srcH),
+            Skia.XYWHRect(0, 0, mw, mh),
+            own(Skia.Paint())
+          );
+          flush(cropSurface);
+          const cropPixels = cropSurface.getCanvas().readPixels(0, 0, {
+            width: mw,
+            height: mh,
+            colorType: Skia.ColorType.RGBA_8888,
+            alphaType: Skia.AlphaType.Unpremul,
+            colorSpace: Skia.ColorSpace.SRGB,
+          });
+          if (cropPixels) {
+            // The brush's circles, at the crop's own resolution: the union of
+            // the spots, hard-edged. Built from the numbers and not read back
+            // out of `maskSurface`, because the two are not the same mask — the
+            // feathered one is the *composite's* weight, and a fade is not
+            // something the model has any use for. What the model wants is a
+            // hole, and it is told about it the way MI-GAN reads it: non-zero
+            // means keep (see inpaint.ts).
+            const kx = mw / srcW;
+            const ky = mh / srcH;
+            const hole = new Uint8Array(mw * mh);
+            for (const s of heal) {
+              const cx = (s.x * width - srcLeft) * kx;
+              const cy = (s.y * height - srcTop) * ky;
+              const rad = s.r * width * kx;
+              const x0 = Math.max(0, Math.floor(cx - rad));
+              const x1 = Math.min(mw - 1, Math.ceil(cx + rad));
+              const y0 = Math.max(0, Math.floor(cy - rad));
+              const y1 = Math.min(mh - 1, Math.ceil(cy + rad));
+              for (let y = y0; y <= y1; y++) {
+                const dy = y - cy;
+                const row = y * mw;
+                for (let x = x0; x <= x1; x++) {
+                  const dx = x - cx;
+                  if (dx * dx + dy * dy <= rad * rad) hole[row + x] = 1;
+                }
+              }
+            }
+            const patch = await inpaintCrop(cropPixels, mw, mh, hole).catch(() => null);
+            if (patch) {
+              const patchSurface = own(createSurface(mw, mh));
+              if (patchSurface && patchSurface.getCanvas().writePixels(patch, mw, mh, 0, 0)) {
+                flush(patchSurface);
+                const patchImage = own(patchSurface.makeImageSnapshot());
+                if (patchImage) {
+                  const patchPaint = own(Skia.Paint());
+                  patchPaint.setAntiAlias(true);
+                  fillCanvas.drawImageRect(
+                    patchImage,
+                    Skia.XYWHRect(0, 0, mw, mh),
+                    Skia.XYWHRect(srcLeft - boxLeft, srcTop - boxTop, srcW, srcH),
+                    patchPaint
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
       flush(fillSurface);
       const fillImage = own(fillSurface.makeImageSnapshot());