@pixerate/editor 0.213.0 → 0.215.0

package/dist/image-editor/index.js

@@ -7,9 +7,7 @@ import {
 } from "../chunk-DJBYJOHM.js";
 import {
   ColorGmm,
-  DEFAULT_REFINE_EDGE_PARAMS,
   GAMMA,
-  GUIDED_FILTER_EPS,
   GridGraph,
   REFINE_EDIT_KINDS,
   SelectionWorkerClient,
@@ -17,31 +15,22 @@ import {
   WORK_SIZE,
   applyRefineEdits,
   boxBlur,
-  boxMean,
   brushStrokeMask,
-  decontaminateColors,
   deserializeMask,
-  edgeWidth,
   ellipsePoints,
   ellipseSelection,
   findSky,
   findSubject,
   focusArea,
   grabCutLabels,
-  guidePlanes,
-  guidedFilterColor,
   keepMainPieces,
   normalizeRect,
-  normalizeRefineEdgeParams,
   otsuThreshold,
   polygonCoverage,
   polygonCoverageBox,
   polygonSelection,
   quickSelectStroke,
   rectSelection,
-  refineCoverage,
-  refineEdgeHalo,
-  refineSelection,
   runSelectionJob,
   selectObjectIn,
   serializeMask,
@@ -54,7 +43,7 @@ import {
   workImage,
   workLuma,
   workPlanes
-} from "../chunk-LQ5SALHK.js";
+} from "../chunk-U7C655AM.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -72,6 +61,7 @@ import {
   DEFAULT_MITER_LIMIT,
   DEFAULT_TRANSFORM_VALUES,
   DEVELOP_FILTER_ID,
+  EDGE_COLOR_RADIUS,
   FREE_TRANSFORM_MODES,
   HUE_RANGE_LABELS,
   IDENTITY_MATRIX3,
@@ -127,6 +117,7 @@ import {
   applyBoxBlur,
   applyBoxBlurFloat,
   applyDepthMask,
+  applyEdgeUnmix,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
   applyLegacyFloat,
@@ -175,6 +166,7 @@ import {
   deserializeLayer,
   deserializeLayers,
   deserializePatterns,
+  despillEdge,
   developFilter,
   developFromAdjustments,
   developTarget,
@@ -197,7 +189,9 @@ import {
   getViewportMetrics,
   getViewportProjection,
   groupLayers,
+  hasEdgeUnmix,
   hasResampledLegacyMask,
+  hasSoftBand,
   hasSurface,
   hasWarp,
   hexToRgb,
@@ -248,6 +242,7 @@ import {
   liveShapeSubpaths,
   mapCropHandle,
   mapSubpaths,
+  maskCoverageOverCanvas,
   matrixFromCorners,
   matrixFromParams,
   mergeShapeComponents,
@@ -302,6 +297,7 @@ import {
   rasterMaskFromLegacy,
   rasterizeCoverage,
   rasterizeSmartObject,
+  readEdgeColor,
   readPsd,
   readShapeComponents,
   referencePoint,
@@ -404,34 +400,45 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-W3TOZTL7.js";
+} from "../chunk-F7Z2MKY2.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
 import {
+  DEFAULT_REFINE_EDGE_PARAMS,
   EMPTY_DISTANCE,
+  GUIDED_FILTER_EPS,
   SELECTION_MODES,
   SELECTION_MODIFY_OPS,
   borderCoverage,
+  boxMean,
   combineSelections,
   computeSelectionBounds,
   contractCoverage,
   coverageToByte,
   createSelectionMask,
   decodeSelectionRle,
+  decontaminateColors,
   deserializeSelection,
   distanceTransform,
+  edgeWidth,
   encodeSelectionRle,
   expandCoverage,
   featherCoverage,
   fullSelection,
   greyMorphology,
+  guidePlanes,
+  guidedFilterColor,
   hashMaskContent,
   invertSelection,
   isSelectionEmpty,
   isSelectionMode,
   modifySelection,
+  normalizeRefineEdgeParams,
   parseSelectionMode,
+  refineCoverage,
+  refineEdgeHalo,
+  refineSelection,
   resizeSelection,
   selectionArea,
   selectionFromCoverage,
@@ -444,7 +451,7 @@ import {
   serializeSelection,
   shiftCoverage,
   smoothCoverage
-} from "../chunk-L3G23N5Y.js";
+} from "../chunk-ZNA3IQZF.js";
 import {
   EffectRendererPool
 } from "../chunk-EHLOCVWB.js";
@@ -500,7 +507,7 @@ import {
   validateLayerEffects,
   warpSurface,
   workingToSamples
-} from "../chunk-YBJXCQTR.js";
+} from "../chunk-QXY4YTRI.js";
 import {
   applyHomography,
   boxQuad,
@@ -2566,6 +2573,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 on a masked cutout set_edge_decontamination 80\u2013100.`);
+  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 +3278,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 +3311,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 +4028,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 +5390,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;
@@ -6405,6 +6829,85 @@ var ImageEditorController = class {
     this.commitLayers(next);
     return { parentId: loc.parent?.id ?? null, index: loc.index };
   }
+  /** A layer's edge colour as percentages (see `setEdgeColor`). */
+  getEdgeColor(id) {
+    const layer = this.requireEdgeLayer(id);
+    const e = layer.edge ?? {};
+    const pct2 = (v) => Math.round((v ?? 0) * 1e3) / 10;
+    const hex = (c) => "#" + c.map((v) => v.toString(16).padStart(2, "0")).join("");
+    return { layerId: layer.id, decontaminate: pct2(e.decontaminate), despill: pct2(e.despill), ambient: pct2(e.ambient), ambientSource: e.ambientColor ? hex(e.ambientColor) : "auto" };
+  }
+  requireEdgeLayer(id) {
+    const layer = this.getLayer(id);
+    if (!layer) throw new LayerOperationError(`There is no layer "${id}" (see list_layers).`);
+    if (layer.type === "group" || layer.type === "adjustment" || layer.type === "annotation")
+      throw new LayerOperationError(`Edge colour works on pixel, shape, type and smart object layers; "${layer.name || id}" is a ${layer.type} layer.`);
+    return layer;
+  }
+  /** Whether the layer's mask (painted and vector, with feather) has a soft band. */
+  maskHasSoftBand(layer) {
+    const { width, height } = this.naturalSize;
+    const mask = effectiveLayerMask(layer, width, height);
+    if (!mask || mask.enabled === false || mask.source) return false;
+    const ox = layer.type === "pixel" ? layer.offset.x : 0;
+    const oy = layer.type === "pixel" ? layer.offset.y : 0;
+    return hasSoftBand(maskCoverageOverCanvas(mask, ox, oy, width, height));
+  }
+  /**
+   * Edge colour on a layer's soft edge, applied when compositing (nothing is baked); amounts in
+   * percent, 0 turns one off. `decontaminate` unmixes the old background (the pixels the mask
+   * hides) from the edge and `despill` limits its hue there: both need a pixel layer whose mask
+   * (painted or vector) has a soft band. `ambient` pulls the edge toward what is behind the layer
+   * (`ambientColor` null: sampled live) or a fixed `#rrggbb`; it needs a soft mask or soft
+   * pixels at the edge. Validates everything before changing anything; one undo step (none with
+   * `commitToHistory` false, for the later moves of a slider drag). Returns the effective settings.
+   */
+  setEdgeColor(id, change, commitToHistory = true) {
+    const layer = this.requireEdgeLayer(id);
+    const name = layer.name || id;
+    const next = { ...layer.edge ?? {} };
+    for (const k of ["decontaminate", "despill", "ambient"]) {
+      const v = change[k];
+      if (v === void 0) continue;
+      if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 100) throw new LayerOperationError(`${k} must be a percentage from 0 to 100, got ${String(v)}.`);
+      if (v > 0) next[k] = v / 100;
+      else delete next[k];
+    }
+    if (change.ambientColor !== void 0) {
+      if (change.ambientColor === null || change.ambientColor === "auto") delete next.ambientColor;
+      else {
+        const m = /^#([0-9a-f]{6})$/i.exec(String(change.ambientColor));
+        if (!m) throw new LayerOperationError(`ambient colour must be "auto" or #rrggbb, got "${String(change.ambientColor)}".`);
+        const n = parseInt(m[1], 16);
+        next.ambientColor = [n >> 16 & 255, n >> 8 & 255, n & 255];
+      }
+    }
+    const unmix = (next.decontaminate ?? 0) > 0 || (next.despill ?? 0) > 0;
+    const turningOn = (k) => (change[k] ?? 0) > 0;
+    if (unmix && (turningOn("decontaminate") || turningOn("despill"))) {
+      if (layer.type !== "pixel") throw new LayerOperationError(`Decontamination and despill need a pixel layer with a soft-edged mask; "${name}" is a ${layer.type} layer (rasterize it, or use ambient).`);
+      if (!this.maskHasSoftBand(layer))
+        throw new LayerOperationError(`"${name}" has no mask with a soft edge: decontamination and despill work in the partly hidden band of a layer mask. Add one with add_layer_mask from a refined selection (refine_selection), or feather the mask (set_layer_mask_properties feather).`);
+    }
+    if (turningOn("ambient") && !this.maskHasSoftBand(layer) && layer.type === "pixel") {
+      const px2 = this.getLayerPixels(layer.id);
+      let soft = false;
+      if (px2) for (let i = 3; i < px2.data.length && !soft; i += 4) soft = px2.data[i] > 5 && px2.data[i] < 250;
+      if (!soft) throw new LayerOperationError(`"${name}" has no soft edge (no soft-edged mask and no partly transparent pixels) for the edge cast to work on.`);
+    }
+    const edge = next.decontaminate || next.despill || next.ambient || next.ambientColor ? next : void 0;
+    this.commitLayers(
+      mapLayer(this.state.layers, layer.id, (l) => {
+        const out = { ...l };
+        if (edge) out.edge = edge;
+        else delete out.edge;
+        return out;
+      }),
+      void 0,
+      commitToHistory
+    );
+    return this.getEdgeColor(layer.id);
+  }
   /**
    * Changes name, visibility, opacity, fill, blend, clipping, locks or (groups) collapsed state, as
    * one undo step (`commitToHistory = false` for the moves of a slider drag). Returns the layer.
@@ -9668,6 +10171,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 +11258,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 +11268,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("")}`;
@@ -10917,7 +11458,9 @@ var ImageEditorController = class {
       return baked;
     };
     const prepare = async (layer) => {
+      if (layer.edge?.ambient) add2("The live edge cast (set_edge_ambient) has no PSD equivalent and was left out", layer.name);
       const p = await prepareLayer(layer);
+      if (p?.edge) delete p.edge;
       if (p?.blend === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
       return p;
     };
@@ -10993,6 +11536,14 @@ var ImageEditorController = class {
       }
       if (layer.filters?.some((f) => !f.enabled)) add2("Disabled layer filters were left out", layer.name);
       delete out.filters;
+      const unmixMask = hasEdgeUnmix(layer.edge) ? effectiveLayerMask(layer, width, height) : void 0;
+      if (unmixMask && !unmixMask.source && unmixMask.enabled !== false) {
+        add2("Edge decontamination and despill were baked into the pixels", layer.name);
+        const { x: ox, y: oy } = layer.offset;
+        const data = readRegion(out.surface, { x: -ox, y: -oy, width, height });
+        applyEdgeUnmix(data, maskCoverageOverCanvas(unmixMask, ox, oy, width, height), width, height, layer.edge);
+        out = { ...out, surface: surfaceFromPixels({ width, height, data }, 4, -ox, -oy) };
+      }
       const mask = bakeMask(layer);
       if (mask) out.mask = mask;
       else delete out.mask;
@@ -12399,6 +12950,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 +14015,7 @@ function createImageSelectionTools(controller) {
   };
   return [
     getSelection,
+    inspectEdge,
     selectAll,
     deselect,
     invert2,
@@ -14333,6 +14905,49 @@ function createImageLayerTools(controller) {
       return { view: shown?.mode ?? "off", layerId: shown?.layerId ?? null };
     }
   };
+  const AMOUNT = (what) => ({ type: "number", minimum: 0, maximum: 100, description: `${what}, in percent 0-100; 0 turns it off.` });
+  const EDGE_RETURNS = "Returns the layer's effective edge colour: { layerId, decontaminate, despill, ambient (percent), ambientSource }.";
+  const getEdge = {
+    name: "get_edge_color",
+    title: "Read edge colour",
+    description: `A layer's edge colour settings, applied when compositing: decontaminate, despill and ambient (percent) and ambientSource (auto or #rrggbb). ${EDGE_RETURNS}`,
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read edge colour", ...READ2 },
+    handler: ({ layerId }) => controller.getEdgeColor(String(layerId))
+  };
+  const setDecontaminate = {
+    name: "set_edge_decontamination",
+    title: "Decontaminate edge colour",
+    description: `Removes the old background's colour from a cutout's soft edge at composite time (nothing is baked; change or turn it off any time): each partly hidden edge pixel is unmixed from the background next to it (the pixels the layer's mask hides). Needs a pixel layer whose mask (painted or vector) has a soft band, e.g. add_layer_mask from a refined selection. Check with inspect_mask_edge (haloScore) and capture_view. One undo step. ${EDGE_RETURNS}`,
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2, amount: AMOUNT("How much to replace edge colour with the subject's own (80-100 typical)") }, required: ["layerId", "amount"], additionalProperties: false },
+    annotations: { title: "Decontaminate edge colour", ...WRITE_IDEMPOTENT2 },
+    handler: ({ layerId, amount }) => controller.setEdgeColor(String(layerId), { decontaminate: amount })
+  };
+  const setDespill = {
+    name: "set_edge_despill",
+    title: "Despill edge colour",
+    description: `Limits how much of the old background's hue a cutout's soft edge carries (a green-screen or coloured-wall fringe), at composite time: the edge colour's component toward the background's hue is taken out, luminance kept, most at the outer edge. A heuristic: it does not remove light that bounced onto the subject itself. Needs a pixel layer whose mask has a soft band. Pixels fully inside the mask never change. One undo step. ${EDGE_RETURNS}`,
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2, amount: AMOUNT("How much of the background hue to take out (50-100 typical)") }, required: ["layerId", "amount"], additionalProperties: false },
+    annotations: { title: "Despill edge colour", ...WRITE_IDEMPOTENT2 },
+    handler: ({ layerId, amount }) => controller.setEdgeColor(String(layerId), { despill: amount })
+  };
+  const setAmbient = {
+    name: "set_edge_ambient",
+    title: "Cast the scene onto an edge",
+    description: `Tints a cutout's soft edge with what is behind it now, live at composite time, so a subject moved onto a new background picks up its colour at the edge (more where the edge is more transparent). source auto samples the layers below as they change; #rrggbb uses a fixed colour. Works on soft-edged masks or partly transparent pixels (pixel, shape, type and smart object layers). One undo step. ${EDGE_RETURNS}`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID2,
+        amount: AMOUNT("How far edge colour moves toward the background (20-50 typical)"),
+        source: { type: "string", pattern: "^(auto|#[0-9a-fA-F]{6})$", description: "auto (default): what is behind the layer, sampled live; or a fixed #rrggbb." }
+      },
+      required: ["layerId", "amount"],
+      additionalProperties: false
+    },
+    annotations: { title: "Cast the scene onto an edge", ...WRITE_IDEMPOTENT2 },
+    handler: ({ layerId, amount, source }) => controller.setEdgeColor(String(layerId), { ambient: amount, ambientColor: source ?? "auto" })
+  };
   const maskProps = {
     name: "set_layer_mask_properties",
     title: "Set layer mask properties",
@@ -14475,6 +15090,10 @@ function createImageLayerTools(controller) {
     removeMask,
     maskView,
     maskProps,
+    getEdge,
+    setDecontaminate,
+    setDespill,
+    setAmbient,
     viaCopy,
     rasterize,
     addFilter,
@@ -18677,10 +19296,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 +19341,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;
@@ -21102,6 +21721,7 @@ export {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   DRY_EPS,
   DabWalker,
+  EDGE_COLOR_RADIUS,
   EFFECT_LAYER_USES,
   EMPTY_DISTANCE,
   EMPTY_MIXER_LOAD,
@@ -21159,6 +21779,7 @@ export {
   LayerEffectError,
   LayerOperationError,
   MARCHING_ANTS_STEP_MS,
+  MASK_EDGE_THRESHOLDS,
   MASK_FILE_ACCEPT,
   MAX_BATCH,
   MAX_BRUSH_SIZE,
@@ -21343,6 +21964,7 @@ export {
   applyBoxBlur,
   applyBoxBlurFloat,
   applyDepthMask,
+  applyEdgeUnmix,
   applyHomography,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
@@ -21518,6 +22140,7 @@ export {
   deserializeMask,
   deserializePatterns,
   deserializeSelection,
+  despillEdge,
   developFilter,
   developFromAdjustments,
   developTarget,
@@ -21613,8 +22236,10 @@ export {
   handleQuickMaskKey,
   handleSelectionShortcut,
   hasActiveEffects,
+  hasEdgeUnmix,
   hasLayersBelow,
   hasResampledLegacyMask,
+  hasSoftBand,
   hasSurface,
   hasWarp,
   hash2,
@@ -21653,6 +22278,7 @@ export {
   inflateRaw,
   insertCurvePoint,
   insertLayer,
+  inspectMaskEdge,
   instancesOf,
   invertHomography,
   invertMatrix3,
@@ -21743,6 +22369,7 @@ export {
   mapLayer,
   mapSubpaths,
   maskBounds,
+  maskCoverageOverCanvas,
   maskFileName,
   maskNameFromFile,
   maskSummary,
@@ -21885,6 +22512,7 @@ export {
   rasterizeSmartObject,
   readAdjustmentControls,
   readDeepRegion,
+  readEdgeColor,
   readPaintSource,
   readPaths,
   readPixel,