@pixerate/editor 0.213.0 → 0.214.0

package/dist/image-editor/index.js

@@ -2566,6 +2566,423 @@ function hexRgb(hex) {
   return [v >> 16 & 255, v >> 8 & 255, v & 255];
 }
 
+// src/image-editor/selection/inspect.ts
+var MASK_EDGE_THRESHOLDS = { halo: 0.35, alignment: 0.5, jaggedness: 15, soft: 0.9 };
+var STRONG_EDGE = 0.1;
+function toLab(r, g, b) {
+  const lin = (v) => {
+    v /= 255;
+    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  };
+  const R = lin(r);
+  const G = lin(g);
+  const B = lin(b);
+  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
+  const x = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047);
+  const y = f(0.2126 * R + 0.7152 * G + 0.0722 * B);
+  const z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
+  return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
+}
+var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var r3 = (v) => Math.round(v * 1e3) / 1e3;
+function inspectMaskEdge(mask, image, options = {}) {
+  const b = mask.bounds;
+  if (!b) throw new Error("The mask is empty: there is no edge to inspect.");
+  const minArea = Math.max(1, options.minArea ?? 16);
+  const W = mask.width;
+  const H = mask.height;
+  const a = mask.data;
+  const alpha = (x, y) => x < 0 || y < 0 || x >= W || y >= H ? 0 : a[y * W + x];
+  const img = image.data;
+  const rgb = (x, y) => {
+    const ix = x - image.x;
+    const iy = y - image.y;
+    if (ix < 0 || iy < 0 || ix >= image.width || iy >= image.height) return null;
+    const i = (iy * image.width + ix) * 4;
+    if (img[i + 3] < 128) return null;
+    return [img[i], img[i + 1], img[i + 2]];
+  };
+  const premul = (x, y, c) => {
+    const ix = Math.min(image.width - 1, Math.max(0, x - image.x));
+    const iy = Math.min(image.height - 1, Math.max(0, y - image.y));
+    const i = (iy * image.width + ix) * 4;
+    return img[i + c] * img[i + 3] / 255;
+  };
+  const gradCache = /* @__PURE__ */ new Map();
+  const gradient = (x, y) => {
+    const k = y * W + x;
+    const hit = gradCache.get(k);
+    if (hit !== void 0) return hit;
+    let best = 0;
+    for (let c = 0; c < 3; c++) {
+      const p = (dx, dy) => premul(x + dx, y + dy, c);
+      const gx = p(1, -1) + 2 * p(1, 0) + p(1, 1) - p(-1, -1) - 2 * p(-1, 0) - p(-1, 1);
+      const gy = p(-1, 1) + 2 * p(0, 1) + p(1, 1) - p(-1, -1) - 2 * p(0, -1) - p(1, -1);
+      best = Math.max(best, Math.hypot(gx, gy) / 1020);
+    }
+    gradCache.set(k, best);
+    return best;
+  };
+  const B = Math.min(256, Math.max(24, Math.round(Math.max(W, H) / 12)));
+  const BW = Math.ceil(W / B);
+  const blocks = /* @__PURE__ */ new Map();
+  const block = (x, y) => {
+    const k = Math.floor(y / B) * BW + Math.floor(x / B);
+    let blk = blocks.get(k);
+    if (!blk) blocks.set(k, blk = { edge: 0, aligned: 0, halo: 0, haloN: 0, turn: 0, len: 0, x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity });
+    return blk;
+  };
+  const grow = (blk, x, y) => {
+    blk.x0 = Math.min(blk.x0, x);
+    blk.y0 = Math.min(blk.y0, y);
+    blk.x1 = Math.max(blk.x1, x);
+    blk.y1 = Math.max(blk.y1, y);
+  };
+  const x0 = Math.max(0, b.x - 1);
+  const y0 = Math.max(0, b.y - 1);
+  const x1 = Math.min(W, b.x + b.width + 1);
+  const y1 = Math.min(H, b.y + b.height + 1);
+  let area = 0;
+  let edgeLength = 0;
+  let aligned = 0;
+  let haloSum = 0;
+  let haloN = 0;
+  let band = 0;
+  let soft = 0;
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      const v = a[y * W + x];
+      if (v >= 128) area++;
+      let lo = false;
+      let hi = false;
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+          if (a[ny * W + nx] >= 128) hi = true;
+          else lo = true;
+        }
+      }
+      const partial = v > 0 && v < 255;
+      if (hi && lo || partial) {
+        band++;
+        if (partial) soft++;
+      }
+      if (v < 128) continue;
+      const inCanvasLow = (nx, ny) => nx >= 0 && ny >= 0 && nx < W && ny < H && a[ny * W + nx] < 128;
+      if (!(inCanvasLow(x - 1, y) || inCanvasLow(x + 1, y) || inCanvasLow(x, y - 1) || inCanvasLow(x, y + 1))) continue;
+      edgeLength++;
+      const blk = block(x, y);
+      blk.edge++;
+      grow(blk, x, y);
+      let strong = false;
+      for (let dy = -2; dy <= 2 && !strong; dy++) {
+        for (let dx = -2; dx <= 2 && !strong; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (nx >= 0 && ny >= 0 && nx < W && ny < H && gradient(nx, ny) >= STRONG_EDGE) strong = true;
+        }
+      }
+      if (strong) {
+        aligned++;
+        blk.aligned++;
+      }
+      const s = (dx, dy) => alpha(Math.min(W - 1, Math.max(0, x + dx)), Math.min(H - 1, Math.max(0, y + dy)));
+      const gx = s(1, -1) + 2 * s(1, 0) + s(1, 1) - s(-1, -1) - 2 * s(-1, 0) - s(-1, 1);
+      const gy = s(-1, 1) + 2 * s(0, 1) + s(1, 1) - s(-1, -1) - 2 * s(0, -1) - s(1, -1);
+      const len = Math.hypot(gx, gy);
+      if (len < 1e-6) continue;
+      const ux = gx / len;
+      const uy = gy / len;
+      const at = (d) => rgb(Math.round(x + ux * d), Math.round(y + uy * d));
+      const ring = at(1.5);
+      const deep = at(5);
+      const out = at(-3);
+      if (!ring || !deep || !out) continue;
+      const labOut = toLab(...out);
+      const span = dist(toLab(...deep), labOut);
+      if (span < 10) continue;
+      const h = Math.min(1, Math.max(0, 1 - dist(toLab(...ring), labOut) / span));
+      haloSum += h;
+      haloN++;
+      blk.halo += h;
+      blk.haloN++;
+    }
+  }
+  let turnExcess = 0;
+  let outline = 0;
+  for (const loop of traceLoops(a, W, H, x0 - 1, y0 - 1, x1 + 1, y1 + 1)) {
+    const pts = resample(loop, 2);
+    const n = pts.length;
+    if (n < 6) continue;
+    const L = n * 2;
+    let total = 0;
+    let net = 0;
+    const turns = [];
+    for (let i = 0; i < n; i++) {
+      const p0 = pts[(i + n - 1) % n];
+      const p1 = pts[i];
+      const p2 = pts[(i + 1) % n];
+      let d = Math.atan2(p2[1] - p1[1], p2[0] - p1[0]) - Math.atan2(p1[1] - p0[1], p1[0] - p0[0]);
+      while (d > Math.PI) d -= 2 * Math.PI;
+      while (d <= -Math.PI) d += 2 * Math.PI;
+      turns.push(d);
+      total += Math.abs(d);
+      net += d;
+    }
+    const closure = Math.abs(net);
+    turnExcess += Math.max(0, total - closure);
+    outline += L;
+    for (let i = 0; i < n; i++) {
+      const [px2, py] = pts[i];
+      if (px2 < 0 || py < 0 || px2 >= W || py >= H) continue;
+      const blk = block(Math.floor(px2), Math.floor(py));
+      blk.turn += Math.abs(turns[i]) - closure / n;
+      blk.len += 2;
+    }
+  }
+  const jaggedness = outline ? 100 * turnExcess / outline : 0;
+  const { holes, islands } = regions(a, W, H, b, minArea);
+  const haloScore = haloN ? haloSum / haloN : 0;
+  const edgeAlignment = edgeLength ? aligned / edgeLength : 0;
+  const softFraction = band ? soft / band : 0;
+  const T2 = MASK_EDGE_THRESHOLDS;
+  const candidates = [];
+  const pad = (r) => {
+    const px0 = Math.max(0, r.x - 8);
+    const py0 = Math.max(0, r.y - 8);
+    return { x: px0, y: py0, width: Math.min(W, r.x + r.width + 8) - px0, height: Math.min(H, r.y + r.height + 8) - py0 };
+  };
+  for (const blk of blocks.values()) {
+    if (blk.edge < 8) continue;
+    const bounds = pad({ x: blk.x0, y: blk.y0, width: blk.x1 - blk.x0 + 1, height: blk.y1 - blk.y0 + 1 });
+    const opts = [];
+    if (blk.haloN >= 8) {
+      const h = blk.halo / blk.haloN;
+      if (h >= T2.halo) opts.push({ severity: h, reason: `halo ${r3(h)}: the colour just inside the edge matches the background` });
+    }
+    const al = blk.aligned / blk.edge;
+    if (al < T2.alignment) opts.push({ severity: (1 - al) * 0.9, reason: `alignment ${r3(al)}: the edge is off the image's edges` });
+    if (blk.len >= 16) {
+      const j = 100 * Math.max(0, blk.turn) / blk.len;
+      if (j >= T2.jaggedness) opts.push({ severity: Math.min(1, j / (4 * T2.jaggedness)), reason: `jaggedness ${r3(j)}: the outline zigzags` });
+    }
+    const top = opts.sort((p, q) => q.severity - p.severity)[0];
+    if (top) candidates.push({ ...top, bounds });
+  }
+  const imageArea = W * H;
+  for (const r of holes.largest) candidates.push({ severity: Math.min(0.95, 0.5 + r.area / (0.01 * imageArea)), bounds: pad(r.bounds), reason: `hole of ${r.area} px inside the selection` });
+  for (const r of islands.largest) candidates.push({ severity: Math.min(0.95, 0.5 + r.area / (0.01 * imageArea)), bounds: pad(r.bounds), reason: `island of ${r.area} px apart from the main selection` });
+  const worst = candidates.sort((p, q) => q.severity - p.severity).slice(0, 5).map(({ bounds, reason }) => ({ bounds, reason }));
+  const issues = [];
+  if (haloScore >= T2.halo)
+    issues.push(`Halo (haloScore ${r3(haloScore)} \u2265 ${T2.halo}): background colour is left inside the edge. Contract the edge (modify_selection contract 1\u20132 px, or refine_selection shiftEdge -20 to -40), or decontaminate on a new-layer output.`);
+  if (edgeLength >= 16 && edgeAlignment < T2.alignment)
+    issues.push(`Off the image's edges (edgeAlignment ${r3(edgeAlignment)} < ${T2.alignment}): much of the edge does not follow edges in the image. Rebuild it with select_subject, select_object or quick_select, or refine_selection with a larger radius.`);
+  if (jaggedness >= T2.jaggedness) issues.push(`Jagged (jaggedness ${r3(jaggedness)} \u2265 ${T2.jaggedness}): the outline zigzags. Smooth it (refine_selection smooth 20\u201340, or modify_selection smooth).`);
+  if (softFraction >= T2.soft && edgeAlignment >= T2.alignment)
+    issues.push(`Very soft (softFraction ${r3(softFraction)} \u2265 ${T2.soft}): almost the whole edge is partly selected. If the subject has hard edges, raise refine_selection contrast or lower feather.`);
+  if (holes.count) issues.push(`${holes.count} hole(s) (${holes.totalArea} px) inside the selection. If they belong to the subject, fill them (quick_select or select_polygon with mode add).`);
+  if (islands.count) issues.push(`${islands.count} island(s) (${islands.totalArea} px) apart from the main selection. If they are stray, remove them (select_polygon or quick_select with mode subtract).`);
+  return {
+    area,
+    bounds: { ...b },
+    edgeLength,
+    haloScore: r3(haloScore),
+    edgeAlignment: r3(edgeAlignment),
+    jaggedness: r3(jaggedness),
+    softFraction: r3(softFraction),
+    holes,
+    islands,
+    worst,
+    issues
+  };
+}
+function traceLoops(a, W, H, rx0, ry0, rx1, ry1) {
+  const w = rx1 - rx0;
+  const h = ry1 - ry0;
+  const f = (i, j) => {
+    const x = rx0 + i;
+    const y = ry0 + j;
+    return x < 0 || y < 0 || x >= W || y >= H ? 0 : a[y * W + x];
+  };
+  const on = (i, j) => f(i, j) >= 128;
+  const V = w * h;
+  const point = (id) => {
+    const vertical = id >= V;
+    const k = vertical ? id - V : id;
+    const i = k % w;
+    const j = (k - i) / w;
+    const p = f(i, j);
+    const q = vertical ? f(i, j + 1) : f(i + 1, j);
+    const t = q === p ? 0.5 : Math.min(1, Math.max(0, (127.5 - p) / (q - p)));
+    return vertical ? [rx0 + i, ry0 + j + t] : [rx0 + i + t, ry0 + j];
+  };
+  const segs = [];
+  const touch = /* @__PURE__ */ new Map();
+  const add2 = (e1, e2) => {
+    const s = segs.length / 2;
+    segs.push(e1, e2);
+    for (const e of [e1, e2]) {
+      const list = touch.get(e);
+      if (list) list.push(s);
+      else touch.set(e, [s]);
+    }
+  };
+  for (let j = 0; j < h - 1; j++) {
+    for (let i = 0; i < w - 1; i++) {
+      const c = (on(i, j) ? 1 : 0) | (on(i + 1, j) ? 2 : 0) | (on(i + 1, j + 1) ? 4 : 0) | (on(i, j + 1) ? 8 : 0);
+      if (c === 0 || c === 15) continue;
+      const top = j * w + i;
+      const bottom = (j + 1) * w + i;
+      const left = V + j * w + i;
+      const right = V + j * w + i + 1;
+      const centre = (f(i, j) + f(i + 1, j) + f(i + 1, j + 1) + f(i, j + 1)) / 4 >= 128;
+      switch (c) {
+        case 1:
+        case 14:
+          add2(left, top);
+          break;
+        case 2:
+        case 13:
+          add2(top, right);
+          break;
+        case 3:
+        case 12:
+          add2(left, right);
+          break;
+        case 4:
+        case 11:
+          add2(right, bottom);
+          break;
+        case 6:
+        case 9:
+          add2(top, bottom);
+          break;
+        case 7:
+        case 8:
+          add2(left, bottom);
+          break;
+        case 5:
+          if (centre) {
+            add2(top, right);
+            add2(left, bottom);
+          } else {
+            add2(left, top);
+            add2(right, bottom);
+          }
+          break;
+        case 10:
+          if (centre) {
+            add2(left, top);
+            add2(right, bottom);
+          } else {
+            add2(top, right);
+            add2(left, bottom);
+          }
+          break;
+      }
+    }
+  }
+  const used = new Uint8Array(segs.length / 2);
+  const loops = [];
+  for (let s0 = 0; s0 < used.length; s0++) {
+    if (used[s0]) continue;
+    const loop = [];
+    let s = s0;
+    let from = segs[s * 2];
+    while (!used[s]) {
+      used[s] = 1;
+      loop.push(point(from));
+      const to = segs[s * 2] === from ? segs[s * 2 + 1] : segs[s * 2];
+      const next = touch.get(to).find((t) => !used[t]);
+      from = to;
+      if (next === void 0) break;
+      s = next;
+    }
+    loops.push(loop);
+  }
+  return loops;
+}
+function resample(loop, step) {
+  const n = loop.length;
+  if (n < 2) return [];
+  const out = [loop[0]];
+  let carry = 0;
+  for (let i = 0; i < n; i++) {
+    const [ax, ay] = loop[i];
+    const [bx, by] = loop[(i + 1) % n];
+    const seg = Math.hypot(bx - ax, by - ay);
+    let t = step - carry;
+    while (t <= seg) {
+      out.push([ax + (bx - ax) * t / seg, ay + (by - ay) * t / seg]);
+      t += step;
+    }
+    carry = seg - (t - step);
+  }
+  if (out.length > 1 && Math.hypot(out[out.length - 1][0] - out[0][0], out[out.length - 1][1] - out[0][1]) < step / 2) out.pop();
+  return out;
+}
+function regions(a, W, H, b, minArea) {
+  const x0 = b.x - 1;
+  const y0 = b.y - 1;
+  const w = b.width + 2;
+  const h = b.height + 2;
+  const on = (i, j) => {
+    const x = x0 + i;
+    const y = y0 + j;
+    return x >= 0 && y >= 0 && x < W && y < H && a[y * W + x] >= 128;
+  };
+  const label = new Int32Array(w * h);
+  const stack = new Int32Array(w * h);
+  const found = [];
+  const N4 = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+  const N8 = [...N4, [1, 1], [1, -1], [-1, 1], [-1, -1]];
+  for (let start = 0; start < w * h; start++) {
+    if (label[start]) continue;
+    const si = start % w;
+    const sj = (start - si) / w;
+    const fg = on(si, sj);
+    const id = found.length + 1;
+    const r = { fg, area: 0, bx0: si, by0: sj, bx1: si, by1: sj, outer: false };
+    let top = 0;
+    stack[top++] = start;
+    label[start] = id;
+    while (top) {
+      const k = stack[--top];
+      const i = k % w;
+      const j = (k - i) / w;
+      r.area++;
+      if (i < r.bx0) r.bx0 = i;
+      if (i > r.bx1) r.bx1 = i;
+      if (j < r.by0) r.by0 = j;
+      if (j > r.by1) r.by1 = j;
+      if (i === 0 || j === 0 || i === w - 1 || j === h - 1) r.outer = true;
+      for (const [dx, dy] of fg ? N8 : N4) {
+        const ni = i + dx;
+        const nj = j + dy;
+        if (ni < 0 || nj < 0 || ni >= w || nj >= h) continue;
+        const nk = nj * w + ni;
+        if (label[nk] || on(ni, nj) !== fg) continue;
+        label[nk] = id;
+        stack[top++] = nk;
+      }
+    }
+    found.push(r);
+  }
+  const box = (r) => ({ x: x0 + r.bx0, y: y0 + r.by0, width: r.bx1 - r.bx0 + 1, height: r.by1 - r.by0 + 1 });
+  const summarize = (list) => {
+    const kept = list.filter((r) => r.area >= minArea).sort((p, q) => q.area - p.area);
+    return { count: kept.length, totalArea: kept.reduce((s, r) => s + r.area, 0), largest: kept.slice(0, 10).map((r) => ({ area: r.area, bounds: box(r) })) };
+  };
+  const pieces = found.filter((r) => r.fg).sort((p, q) => q.area - p.area);
+  return {
+    holes: summarize(found.filter((r) => !r.fg && !r.outer)),
+    islands: summarize(pieces.slice(1))
+  };
+}
+
 // src/image-editor/selection/path.ts
 function selectionToSubpaths(mask, options = {}) {
   const b = mask.bounds;
@@ -2854,19 +3271,19 @@ function liveWire(map, from, to, band) {
     }
   }
   const scale = maxStrength > 0 ? 1 / maxStrength : 0;
-  const dist = new Float64Array(n).fill(Infinity);
+  const dist2 = new Float64Array(n).fill(Infinity);
   const prev = new Int32Array(n).fill(-1);
   const done = new Uint8Array(n);
   const start = (ay - ry0) * w + (ax - rx0);
   const goal = (by - ry0) * w + (bx - rx0);
-  dist[start] = 0;
+  dist2[start] = 0;
   const heap = new Heap();
   heap.push(start, 0);
   while (heap.size) {
     const p = heap.topId;
     const d = heap.topKey;
     heap.pop();
-    if (done[p] || d > dist[p]) continue;
+    if (done[p] || d > dist2[p]) continue;
     done[p] = 1;
     if (p === goal) break;
     const x = p % w;
@@ -2887,8 +3304,8 @@ function liveWire(map, from, to, band) {
       const fZ = 1 - zero[q];
       const cost = (W_ZERO * fZ + W_GRADIENT * fG + W_DIRECTION * fD + 0.01) * step;
       const nd = d + cost;
-      if (nd < dist[q]) {
-        dist[q] = nd;
+      if (nd < dist2[q]) {
+        dist2[q] = nd;
         prev[q] = p;
         heap.push(q, nd);
       }
@@ -3604,8 +4021,8 @@ function colorRange(pixels, samples, options = {}) {
       const d = Math.max(Math.abs(data[p] - s.c[0]), Math.abs(data[p + 1] - s.c[1]), Math.abs(data[p + 2] - s.c[2]));
       let k = Math.min(1, Math.max(0, 1 - d / f));
       if (k > 0 && radius !== void 0 && s.at) {
-        const dist = Math.hypot(x - s.at.x, y - s.at.y);
-        k *= Math.min(1, Math.max(0, 1 - dist / radius));
+        const dist2 = Math.hypot(x - s.at.x, y - s.at.y);
+        k *= Math.min(1, Math.max(0, 1 - dist2 / radius));
       }
       if (k > best) best = k;
     }
@@ -4966,15 +5383,15 @@ var PaintStrokeSession = class {
       return;
     }
     const stroke = this.stroke;
-    const regions = /* @__PURE__ */ new Map();
+    const regions2 = /* @__PURE__ */ new Map();
     for (const r of rects) {
       for (const t of tilesInRect({ x: r.x - this.apply.offset.x, y: r.y - this.apply.offset.y, width: r.width, height: r.height })) {
         const key2 = tileKey(t.tx, t.ty);
-        const cur = regions.get(key2);
-        regions.set(key2, { tx: t.tx, ty: t.ty, r: cur ? unionRect(cur.r, r) : r });
+        const cur = regions2.get(key2);
+        regions2.set(key2, { tx: t.tx, ty: t.ty, r: cur ? unionRect(cur.r, r) : r });
       }
     }
-    for (const [key2, { tx, ty, r }] of regions) {
+    for (const [key2, { tx, ty, r }] of regions2) {
       if (this.deep) {
         const rt = this.retouch;
         const paint = rt?.kind === "coverage" ? rt.paint() : null;
@@ -9668,6 +10085,44 @@ var ImageEditorController = class {
     if (!sel) return false;
     return this.setSelection(invert2 ? invertSelection(sel) : sel, mode);
   }
+  /**
+   * A measured report on a mask's edge (`inspect_mask_edge`): the selection (default), a layer's
+   * painted mask or its vector mask (its path, without density or feather). Halo and alignment are
+   * measured against the layer's own pixels for a pixel layer's masks, else the composite.
+   * Read-only. Throws for an empty selection or a layer without that mask.
+   */
+  inspectMaskEdge(target = "selection", options = {}) {
+    const { width, height } = this.naturalSize;
+    let mask;
+    let layer;
+    if (target === "selection") {
+      mask = this.getSelection();
+      if (!mask?.bounds) throw new LayerOperationError("Nothing is selected: make a selection first, or inspect a layer-mask or vector-mask with layerId.");
+    } else if (target === "layer-mask" || target === "vector-mask") {
+      if (!options.layerId) throw new LayerOperationError(`A ${target} needs layerId (see list_layers).`);
+      layer = this.getLayer(options.layerId);
+      if (!layer) throw new LayerOperationError(`There is no layer "${options.layerId}" (see list_layers).`);
+      if (target === "layer-mask") {
+        mask = this.layerMaskCoverage(layer.id);
+        if (!mask) throw new LayerOperationError(`Layer "${layer.name || layer.id}" has no painted mask; add one with add_layer_mask, or inspect its vector-mask.`);
+      } else {
+        const { vm } = this.requireVectorMask(layer.id);
+        mask = pathToSelection(vm.components, width, height, { fillRule: vm.fillRule });
+        if (vm.inverted) mask = invertSelection(mask);
+      }
+      if (!mask.bounds) throw new LayerOperationError(`The ${target} of "${layer.name || layer.id}" hides everything: there is no edge to inspect.`);
+    } else {
+      throw new LayerOperationError(`Unknown target "${String(target)}". Use selection, layer-mask or vector-mask.`);
+    }
+    const b = mask.bounds;
+    const x = Math.max(0, b.x - 8);
+    const y = Math.max(0, b.y - 8);
+    const region = { x, y, width: Math.min(width, b.x + b.width + 8) - x, height: Math.min(height, b.y + b.height + 8) - y };
+    const own = layer?.type === "pixel" ? this.getLayerPixels(layer.id) : null;
+    const image = own ?? { ...this.compositePixels(region), x: region.x, y: region.y };
+    const report = inspectMaskEdge(mask, image, options);
+    return { target, ...layer ? { layerId: layer.id } : {}, ...report };
+  }
   /** A layer's painted mask over the canvas as a selection mask; null without one (or for a depth mask). */
   layerMaskCoverage(layerId) {
     const layer = this.getLayer(layerId);
@@ -10717,7 +11172,7 @@ var ImageEditorController = class {
     }
     if (src.colorSpace !== "rgb") throw new LayerOperationError("Colours are given as #rrggbb, so the source profile must be RGB.");
     const t = Transform.create(src, dst, { intent: options.intent ?? "relative", bpc: options.bpc ?? true });
-    const toLab = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
+    const toLab2 = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
     return colors.map((input) => {
       const m = /^#?([0-9a-f]{6})$/i.exec(input.trim());
       if (!m) throw new LayerOperationError(`Invalid colour "${input}"; use #rrggbb.`);
@@ -10727,7 +11182,7 @@ var ImageEditorController = class {
       t.eval(rgb, out);
       const values = Array.from(out.subarray(0, t.outputs), (v) => Math.round(Math.min(1, Math.max(0, v)) * 1e4) / 1e4);
       const l = new Float32Array(3);
-      toLab.eval(rgb, l);
+      toLab2.eval(rgb, l);
       const lab = [Math.round(l[0] * 1e4) / 100, Math.round((l[1] * 255 - 128) * 100) / 100, Math.round((l[2] * 255 - 128) * 100) / 100];
       const res = { input, values, lab };
       if (dst.colorSpace === "rgb") res.hex = `#${values.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("")}`;
@@ -12399,6 +12854,26 @@ function createImageSelectionTools(controller) {
     annotations: { title: "Read the selection", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     handler: () => summary(controller)
   };
+  const inspectEdge = {
+    name: "inspect_mask_edge",
+    title: "Inspect a mask edge",
+    description: "Measures the edge of the selection (default), a layer's painted mask (layer-mask) or its vector mask (vector-mask), so you can check it without looking. Returns haloScore 0-1 (background colour left just inside the edge; worse above 0.35), edgeAlignment 0-1 (share of the edge on strong image edges; worse below 0.5), jaggedness (outline turning in radians per 100 px beyond what closing it needs; smooth outlines score under 3, worse above 15), softFraction 0-1 (share of edge pixels partly selected), holes and islands (count, total area, the 10 largest with bounds), worst (up to 5 regions with a reason, ready for capture_view rect) and issues (findings with a suggested fix; empty when clean). Measures a pixel layer's masks against its own pixels, otherwise the composite. Read-only: inspect, fix the issues, inspect again.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", enum: ["selection", "layer-mask", "vector-mask"], description: "What to inspect (default selection). layer-mask and vector-mask need layerId." },
+        layerId: { type: "string", description: "The layer whose mask to inspect (see list_layers); only with layer-mask or vector-mask." },
+        minArea: { type: "number", minimum: 1, maximum: 1e6, description: "Holes and islands smaller than this many pixels are left out (default 16)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Inspect a mask edge", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: ({ target, layerId, minArea }) => {
+      const t = target ?? "selection";
+      if (t === "selection" && layerId !== void 0) throw new Error("layerId is only for target layer-mask or vector-mask; leave it out to inspect the selection.");
+      return controller.inspectMaskEdge(t, { layerId, minArea });
+    }
+  };
   const selectRegion = {
     name: "select_region",
     title: "Select a region",
@@ -13444,6 +13919,7 @@ function createImageSelectionTools(controller) {
   };
   return [
     getSelection,
+    inspectEdge,
     selectAll,
     deselect,
     invert2,
@@ -18677,10 +19153,10 @@ function resolveMosaicRegionBounds(region, imgWidth, imgHeight) {
   if (x1 <= x0 || y1 <= y0) return null;
   return { x0, y0, x1, y1 };
 }
-function applyRegionMosaic(imageData, regions, blockSize = 12) {
+function applyRegionMosaic(imageData, regions2, blockSize = 12) {
   const { data, width, height } = imageData;
   const step = Math.max(2, Math.round(blockSize));
-  for (const region of regions) {
+  for (const region of regions2) {
     const bounds = resolveMosaicRegionBounds(region, width, height);
     if (!bounds) continue;
     const { x0, y0, x1, y1 } = bounds;
@@ -18722,10 +19198,10 @@ function applyRegionMosaic(imageData, regions, blockSize = 12) {
   }
   return imageData;
 }
-function applyRegionBlur(imageData, regions, radius = 10) {
+function applyRegionBlur(imageData, regions2, radius = 10) {
   const { data, width, height } = imageData;
   const rad = Math.max(1, Math.min(64, Math.round(radius)));
-  for (const region of regions) {
+  for (const region of regions2) {
     const bounds = resolveMosaicRegionBounds(region, width, height);
     if (!bounds) continue;
     const { x0, y0, x1, y1 } = bounds;
@@ -21159,6 +21635,7 @@ export {
   LayerEffectError,
   LayerOperationError,
   MARCHING_ANTS_STEP_MS,
+  MASK_EDGE_THRESHOLDS,
   MASK_FILE_ACCEPT,
   MAX_BATCH,
   MAX_BRUSH_SIZE,
@@ -21653,6 +22130,7 @@ export {
   inflateRaw,
   insertCurvePoint,
   insertLayer,
+  inspectMaskEdge,
   instancesOf,
   invertHomography,
   invertMatrix3,

package/dist/image-editor/selection/index.d.cts

@@ -17,3 +17,4 @@ export * from './segment/index.cjs';
 export * from './refine-edits.cjs';
 export * from './select-and-mask.cjs';
 export * from './worker.cjs';
+export * from './inspect.cjs';

package/dist/image-editor/selection/index.d.ts

@@ -17,3 +17,4 @@ export * from './segment/index.js';
 export * from './refine-edits.js';
 export * from './select-and-mask.js';
 export * from './worker.js';
+export * from './inspect.js';