@pixerate/editor 0.214.0 → 0.216.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,
@@ -2602,27 +2609,7 @@ function inspectMaskEdge(mask, image, options = {}) {
     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 gradient = createGradientSampler(image, W);
   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();
@@ -2777,7 +2764,7 @@ function inspectMaskEdge(mask, image, options = {}) {
   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.`);
+    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).`);
@@ -2799,6 +2786,30 @@ function inspectMaskEdge(mask, image, options = {}) {
     issues
   };
 }
+function createGradientSampler(image, W) {
+  const img = image.data;
+  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 cache = /* @__PURE__ */ new Map();
+  return (x, y) => {
+    const k = y * W + x;
+    const hit = cache.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);
+    }
+    cache.set(k, best);
+    return best;
+  };
+}
 function traceLoops(a, W, H, rx0, ry0, rx1, ry1) {
   const w = rx1 - rx0;
   const h = ry1 - ry0;
@@ -2983,6 +2994,135 @@ function regions(a, W, H, b, minArea) {
   };
 }
 
+// src/image-editor/selection/uncertainty.ts
+var BACKED = 0.2;
+function selectionUncertainty(mask, image, options = {}) {
+  const W = mask.width;
+  const H = mask.height;
+  const empty = () => ({ unknown: createSelectionMask(W, H), regions: [], count: 0, confidence: 1 });
+  const b = mask.bounds;
+  if (!b) return empty();
+  const band = Math.max(1, Math.round(options.band ?? Math.max(2, Math.min(W, H) / 200)));
+  const minArea = Math.max(1, options.minArea ?? 16);
+  const maxRegions = Math.max(1, options.maxRegions ?? 20);
+  const a = mask.data;
+  const gradient = createGradientSampler(image, W);
+  const x0 = Math.max(0, b.x - band - 1);
+  const y0 = Math.max(0, b.y - band - 1);
+  const x1 = Math.min(W, b.x + b.width + band + 1);
+  const y1 = Math.min(H, b.y + b.height + band + 1);
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const evidence = new Float32Array(w * h).fill(NaN);
+  const seeds = new Uint8Array(w * h);
+  let sum = 0;
+  let n = 0;
+  const on = (x, y) => a[y * W + x] >= 128;
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      const v = on(x, y);
+      const differs = (nx, ny) => nx >= 0 && ny >= 0 && nx < W && ny < H && on(nx, ny) !== v;
+      if (!(differs(x - 1, y) || differs(x + 1, y) || differs(x, y - 1) || differs(x, y + 1))) continue;
+      let g = 0;
+      for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (nx >= 0 && ny >= 0 && nx < W && ny < H) g = Math.max(g, gradient(nx, ny));
+        }
+      }
+      const e = Math.min(1, g / BACKED);
+      const k = (y - y0) * w + (x - x0);
+      evidence[k] = e;
+      sum += e;
+      n++;
+      if (e < 0.5) seeds[k] = 1;
+    }
+  }
+  if (!n) return empty();
+  const rows = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    let last = -Infinity;
+    for (let x = 0; x < w; x++) {
+      if (seeds[y * w + x]) last = x;
+      if (x - last <= band) rows[y * w + x] = 1;
+    }
+    last = Infinity;
+    for (let x = w - 1; x >= 0; x--) {
+      if (seeds[y * w + x]) last = x;
+      if (last - x <= band) rows[y * w + x] = 1;
+    }
+  }
+  const grown = new Uint8Array(w * h);
+  for (let x = 0; x < w; x++) {
+    let last = -Infinity;
+    for (let y = 0; y < h; y++) {
+      if (rows[y * w + x]) last = y;
+      if (y - last <= band) grown[y * w + x] = 1;
+    }
+    last = Infinity;
+    for (let y = h - 1; y >= 0; y--) {
+      if (rows[y * w + x]) last = y;
+      if (last - y <= band) grown[y * w + x] = 1;
+    }
+  }
+  const label = new Int32Array(w * h);
+  const stack = new Int32Array(w * h);
+  const found = [];
+  for (let start = 0; start < w * h; start++) {
+    if (!grown[start] || label[start]) continue;
+    const r = { area: 0, e: 0, en: 0, bx0: w, by0: h, bx1: -1, by1: -1 };
+    const id = found.length + 1;
+    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 (!Number.isNaN(evidence[k])) {
+        r.e += evidence[k];
+        r.en++;
+      }
+      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;
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          const ni = i + dx;
+          const nj = j + dy;
+          if (ni < 0 || nj < 0 || ni >= w || nj >= h) continue;
+          const nk = nj * w + ni;
+          if (!grown[nk] || label[nk]) continue;
+          label[nk] = id;
+          stack[top++] = nk;
+        }
+      }
+    }
+    found.push(r);
+  }
+  const unknownData = new Uint8Array(W * H);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const id = label[y * w + x];
+      if (id && found[id - 1].area >= minArea) unknownData[(y + y0) * W + x + x0] = 255;
+    }
+  }
+  const kept = found.filter((r) => r.area >= minArea).map((r) => ({
+    bounds: { x: x0 + r.bx0, y: y0 + r.by0, width: r.bx1 - r.bx0 + 1, height: r.by1 - r.by0 + 1 },
+    area: r.area,
+    confidence: Math.round((r.en ? r.e / r.en : 0) * 1e3) / 1e3
+  })).sort((p, q) => p.confidence - q.confidence || q.area - p.area);
+  return {
+    unknown: createSelectionMask(W, H, unknownData),
+    regions: kept.slice(0, maxRegions),
+    count: kept.length,
+    confidence: Math.round(sum / n * 1e3) / 1e3
+  };
+}
+
 // src/image-editor/selection/path.ts
 function selectionToSubpaths(mask, options = {}) {
   const b = mask.bounds;
@@ -6822,6 +6962,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.
@@ -9644,6 +9863,7 @@ var ImageEditorController = class {
    */
   async refineSelectionTo(params, output = "selection", options = {}) {
     const edits = options.edits ?? [];
+    const regions2 = this.checkRegions(options.regions);
     const refineMode = options.refineMode ?? "color";
     if (!this.state.selection?.bounds && !edits.length) throw new Error("Nothing is selected; select first, or pass edits that paint a selection.");
     if (refineMode === "object" && !this.segmentation) {
@@ -9678,7 +9898,14 @@ var ImageEditorController = class {
       if (!clipped?.bounds) throw new Error("The segmentation model found no object in the selection; use refineMode color.");
       sel = clipped;
     }
-    const refined = refineSelection(pixels, sel, params, edited.refineBrush);
+    let refined = refineSelection(pixels, sel, params, edited.refineBrush);
+    if (regions2) {
+      const data = Uint8Array.from(sel.data);
+      for (const r of regions2) {
+        for (let y = r.y; y < r.y + r.height; y++) data.set(refined.data.subarray(y * width + r.x, y * width + r.x + r.width), y * width + r.x);
+      }
+      refined = createSelectionMask(width, height, data);
+    }
     if (!refined.bounds) throw new Error("Refining left nothing selected; use a smaller shiftEdge or contrast.");
     if (toDocument) {
       const document2 = this.documentFromSelection({ layerId, withMask: output === "new-document-with-mask", selection: refined, decontaminate: amount * 100, radius: params.radius });
@@ -10123,6 +10350,37 @@ var ImageEditorController = class {
     const report = inspectMaskEdge(mask, image, options);
     return { target, ...layer ? { layerId: layer.id } : {}, ...report };
   }
+  /** Whole-pixel rectangles inside the canvas, or a useful error; undefined stays undefined. */
+  checkRegions(regions2) {
+    if (regions2 === void 0) return void 0;
+    const { width, height } = this.naturalSize;
+    if (!Array.isArray(regions2) || !regions2.length) throw new Error("regions must be a non-empty list of { x, y, width, height } (e.g. the uncertainRegions bounds); leave it out to refine everywhere.");
+    return regions2.map((r, i) => {
+      const x = Math.max(0, Math.floor(r?.x));
+      const y = Math.max(0, Math.floor(r?.y));
+      const x1 = Math.min(width, Math.ceil(r?.x + r?.width));
+      const y1 = Math.min(height, Math.ceil(r?.y + r?.height));
+      if (![x, y, x1, y1].every(Number.isFinite) || x1 <= x || y1 <= y) throw new Error(`regions[${i}] must overlap the image (0..${width} \xD7 0..${height}), got ${JSON.stringify(r)}.`);
+      return { x, y, width: x1 - x, height: y1 - y };
+    });
+  }
+  /**
+   * Where the selection is unsure of itself: the stretches of its edge with no image edge under
+   * them, widened into a band (a trimap's unknown), as a mask and regions with bounds and
+   * confidence, least confident first. Measured against the composite. Read-only; an empty
+   * selection has none.
+   */
+  selectionUncertainty(options = {}) {
+    const { width, height } = this.naturalSize;
+    const sel = this.getSelection();
+    if (!sel?.bounds) return selectionUncertainty(createSelectionMask(width, height), { x: 0, y: 0, width: 0, height: 0, data: new Uint8ClampedArray(0) }, options);
+    const b = sel.bounds;
+    const m = Math.max(8, Math.ceil(options.band ?? Math.max(2, Math.min(width, height) / 200)) + 4);
+    const x = Math.max(0, b.x - m);
+    const y = Math.max(0, b.y - m);
+    const region = { x, y, width: Math.min(width, b.x + b.width + m) - x, height: Math.min(height, b.y + b.height + m) - y };
+    return selectionUncertainty(sel, { ...this.compositePixels(region), x, y }, options);
+  }
   /** 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);
@@ -11372,7 +11630,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;
     };
@@ -11448,6 +11708,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;
@@ -12825,6 +13093,10 @@ function rectOf(args) {
   if (rect2.width <= 0 || rect2.height <= 0) throw new Error("width and height must be greater than 0.");
   return rect2;
 }
+function uncertainty(controller) {
+  const u = controller.selectionUncertainty();
+  return { uncertainRegions: u.regions, uncertainCount: u.count, edgeConfidence: u.confidence };
+}
 function summary(controller) {
   const sel = controller.getSelection();
   const { width, height } = controller.getState().imageDimensions;
@@ -13049,7 +13321,14 @@ function createImageSelectionTools(controller) {
             additionalProperties: false
           }
         },
-        refineMode: { type: "string", enum: ["color", "object"], description: "color (default): refine from the image colours; object: from a host segmentation model's outline of the object (needs a model)." }
+        refineMode: { type: "string", enum: ["color", "object"], description: "color (default): refine from the image colours; object: from a host segmentation model's outline of the object (needs a model)." },
+        regions: {
+          type: "array",
+          minItems: 1,
+          maxItems: 50,
+          items: rectSchemaStrict,
+          description: "Refine only inside these rectangles (natural image pixels), e.g. the uncertainRegions bounds a smart selection returned; the rest of the selection stays as it is. Default: everywhere."
+        }
       },
       additionalProperties: false
     },
@@ -13080,7 +13359,8 @@ function createImageSelectionTools(controller) {
           layerId: typeof params.layerId === "string" ? params.layerId : void 0,
           decontaminate: num2(params.decontaminate, 0),
           edits,
-          refineMode: params.refineMode === "object" ? "object" : "color"
+          refineMode: params.refineMode === "object" ? "object" : "color",
+          ...params.regions !== void 0 ? { regions: params.regions } : {}
         }
       );
       return { ...summary(controller), ...result };
@@ -13236,7 +13516,7 @@ function createImageSelectionTools(controller) {
   const quickSelectTool = {
     name: "quick_select",
     title: "Quick Selection",
-    description: "Quick Selection: paints brush strokes (paths in natural image pixels) that each grow into the region they are painted on, out to its edges (a graph cut on colour and edges), combined with the selection by mode. With replace (default) the first stroke replaces the selection and later ones add, as the brush does; use mode subtract to take an area back out. Best for a subject or area that differs from its surroundings: paint inside it, away from the edge, then check with get_selection and capture_view and add or subtract strokes where it leaked or fell short. All strokes are one undoable step. Returns the selection.",
+    description: "Quick Selection: paints brush strokes (paths in natural image pixels) that each grow into the region they are painted on, out to its edges (a graph cut on colour and edges), combined with the selection by mode. With replace (default) the first stroke replaces the selection and later ones add, as the brush does; use mode subtract to take an area back out. Best for a subject or area that differs from its surroundings: paint inside it, away from the edge, then check with get_selection and capture_view and add or subtract strokes where it leaked or fell short. All strokes are one undoable step. Returns the selection. Also returns uncertainRegions (bounds, area, confidence 0-1; up to 20, least confident first), uncertainCount and edgeConfidence: where the edge has no image edge under it. Look at those with capture_view and fix only them (refine_selection with regions).",
     inputSchema: {
       type: "object",
       properties: {
@@ -13267,13 +13547,13 @@ function createImageSelectionTools(controller) {
         enhanceEdge: args.enhanceEdge,
         signal: context?.signal
       });
-      return summary(controller);
+      return { ...summary(controller), ...uncertainty(controller) };
     }
   };
   const selectObjectTool = {
     name: "select_object",
     title: "Object Selection",
-    description: 'Object Selection: selects the object inside rect (a box drawn loosely around it, natural image pixels; what lies outside the box is treated as background) or the object under point. With a host segmentation model it asks the model (falling back if nothing it returns fits); otherwise it finds the object from the colours of object and background and the edges between them (GrabCut). Combined with the selection by mode. A box is more reliable than a point: make it a little larger than the object on every side. Check with get_selection and capture_view, then fix with quick_select strokes or select_object with mode add / subtract. One undoable step. Returns the selection and method ("model" or "grabcut").',
+    description: 'Object Selection: selects the object inside rect (a box drawn loosely around it, natural image pixels; what lies outside the box is treated as background) or the object under point. With a host segmentation model it asks the model (falling back if nothing it returns fits); otherwise it finds the object from the colours of object and background and the edges between them (GrabCut). Combined with the selection by mode. A box is more reliable than a point: make it a little larger than the object on every side. Check with get_selection and capture_view, then fix with quick_select strokes or select_object with mode add / subtract. One undoable step. Returns the selection and method ("model" or "grabcut"). Also returns uncertainRegions (bounds, area, confidence 0-1; up to 20, least confident first), uncertainCount and edgeConfidence: where the edge has no image edge under it. Look at those with capture_view and fix only them (refine_selection with regions).',
     inputSchema: {
       type: "object",
       properties: {
@@ -13306,7 +13586,7 @@ function createImageSelectionTools(controller) {
         signal: context?.signal
       };
       const { method } = rect2 ? await controller.selectObject({ rect: { x: num2(rect2.x, NaN), y: num2(rect2.y, NaN), width: num2(rect2.width, NaN), height: num2(rect2.height, NaN) } }, options) : await controller.selectObject({ point: { x: num2(point.x, NaN), y: num2(point.y, NaN) } }, options);
-      return { ...summary(controller), method };
+      return { ...summary(controller), method, ...uncertainty(controller) };
     }
   };
   const selectFocusAreaTool = {
@@ -13340,7 +13620,7 @@ function createImageSelectionTools(controller) {
   const selectSkyTool = {
     name: "select_sky",
     title: "Select the sky",
-    description: 'Select \u203A Sky: selects the sky, combined with the selection by mode. With a host segmentation model it asks the model; otherwise it finds it classically (blue, or bright and grey when overcast, smooth, reaching down from the top of the image, including patches seen through branches or gaps) with the edge fitted to the skyline. Use it to replace or recolour a sky or to adjust the land without it (invert_selection). Raise threshold to take in haze or a sunset glow, lower it if bright buildings come in. One undoable step. Returns the selection, method ("model" or "classical"; threshold and softness apply to classical), and a note when no sky was found (the selection is then unchanged).',
+    description: 'Select \u203A Sky: selects the sky, combined with the selection by mode. With a host segmentation model it asks the model; otherwise it finds it classically (blue, or bright and grey when overcast, smooth, reaching down from the top of the image, including patches seen through branches or gaps) with the edge fitted to the skyline. Use it to replace or recolour a sky or to adjust the land without it (invert_selection). Raise threshold to take in haze or a sunset glow, lower it if bright buildings come in. One undoable step. Returns the selection, method ("model" or "classical"; threshold and softness apply to classical), and a note when no sky was found (the selection is then unchanged). Also returns uncertainRegions (bounds, area, confidence 0-1; up to 20, least confident first), uncertainCount and edgeConfidence: where the edge has no image edge under it. Look at those with capture_view and fix only them (refine_selection with regions).',
     inputSchema: {
       type: "object",
       properties: {
@@ -13362,7 +13642,7 @@ function createImageSelectionTools(controller) {
         useModel: args.useModel,
         signal: context?.signal
       });
-      return { ...summary(controller), method, ...note ? { note } : {} };
+      return { ...summary(controller), method, ...note ? { note } : {}, ...uncertainty(controller) };
     }
   };
   const magicWandTool = {
@@ -13967,7 +14247,7 @@ function createImageSubjectSelectionTool(controller) {
   return {
     name: "select_subject",
     title: "Select a subject",
-    description: 'Select \u203A Subject: selects the main subject of the flattened image, combined with the selection by mode. With a segmentation model set by the host, target (a description such as "the dog" or "the house") chooses which objects; describe one object precisely to get only that one. Without a model, the subject that stands out most from the background is found classically (superpixel saliency and GrabCut): target cannot choose it, and method "saliency" and a note say so. Then check it with capture_view and fix it with quick_select or select_object. One undoable step. Returns the selection, the objects found (label, bounds), method ("model" or "saliency") and any note; none found leaves the selection unchanged.',
+    description: 'Select \u203A Subject: selects the main subject of the flattened image, combined with the selection by mode. With a segmentation model set by the host, target (a description such as "the dog" or "the house") chooses which objects; describe one object precisely to get only that one. Without a model, the subject that stands out most from the background is found classically (superpixel saliency and GrabCut): target cannot choose it, and method "saliency" and a note say so. Then check it with capture_view and fix it with quick_select or select_object. One undoable step. Returns the selection, the objects found (label, bounds), method ("model" or "saliency") and any note; none found leaves the selection unchanged. Also returns uncertainRegions (bounds, area, confidence 0-1; up to 20, least confident first), uncertainCount and edgeConfidence: where the edge has no image edge under it. Look at those with capture_view and fix only them (refine_selection with regions).',
     inputSchema: {
       type: "object",
       properties: {
@@ -13998,7 +14278,7 @@ function createImageSubjectSelectionTool(controller) {
         // Under playback the cursor traces what the model found, as a lasso, before it is selected.
         beforeApply: perform ? (outlines) => perform(planOutlineTrace(outlines)) : void 0
       });
-      return { ...summary(controller), found: segments, method, ...note ? { note } : {} };
+      return { ...summary(controller), found: segments, method, ...note ? { note } : {}, ...uncertainty(controller) };
     }
   };
 }
@@ -14809,6 +15089,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",
@@ -14951,6 +15274,10 @@ function createImageLayerTools(controller) {
     removeMask,
     maskView,
     maskProps,
+    getEdge,
+    setDecontaminate,
+    setDespill,
+    setAmbient,
     viaCopy,
     rasterize,
     addFilter,
@@ -21578,6 +21905,7 @@ export {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   DRY_EPS,
   DabWalker,
+  EDGE_COLOR_RADIUS,
   EFFECT_LAYER_USES,
   EMPTY_DISTANCE,
   EMPTY_MIXER_LOAD,
@@ -21820,6 +22148,7 @@ export {
   applyBoxBlur,
   applyBoxBlurFloat,
   applyDepthMask,
+  applyEdgeUnmix,
   applyHomography,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
@@ -21925,6 +22254,7 @@ export {
   createAdjustmentLayer,
   createBlenderScratch,
   createCanvasTextShaper,
+  createGradientSampler,
   createImageCaptureSurface,
   createImageColorTools,
   createImageEditTools,
@@ -21995,6 +22325,7 @@ export {
   deserializeMask,
   deserializePatterns,
   deserializeSelection,
+  despillEdge,
   developFilter,
   developFromAdjustments,
   developTarget,
@@ -22090,8 +22421,10 @@ export {
   handleQuickMaskKey,
   handleSelectionShortcut,
   hasActiveEffects,
+  hasEdgeUnmix,
   hasLayersBelow,
   hasResampledLegacyMask,
+  hasSoftBand,
   hasSurface,
   hasWarp,
   hash2,
@@ -22221,6 +22554,7 @@ export {
   mapLayer,
   mapSubpaths,
   maskBounds,
+  maskCoverageOverCanvas,
   maskFileName,
   maskNameFromFile,
   maskSummary,
@@ -22363,6 +22697,7 @@ export {
   rasterizeSmartObject,
   readAdjustmentControls,
   readDeepRegion,
+  readEdgeColor,
   readPaintSource,
   readPaths,
   readPixel,
@@ -22447,6 +22782,7 @@ export {
   selectionToCoverage,
   selectionToPixels,
   selectionToSubpaths,
+  selectionUncertainty,
   selectionValueAt,
   serializeChannels,
   serializeColorMode,