@pixerate/editor 0.197.0 → 0.199.0

package/dist/image-editor/index.js

@@ -3045,7 +3045,7 @@ var GridGraph = class {
   }
 };
 
-// src/image-editor/selection/segment/quick.ts
+// src/image-editor/selection/segment/work.ts
 var WORK_SIZE = 512;
 var workCache = /* @__PURE__ */ new WeakMap();
 function workImage(pixels, maxSide = WORK_SIZE) {
@@ -3082,6 +3082,155 @@ function workImage(pixels, maxSide = WORK_SIZE) {
   workCache.set(pixels.data, { maxSide, work });
   return work;
 }
+var GAMMA = 50;
+var UNITS = 64;
+function smoothnessWeights(work, roi) {
+  const { width: w, rgb } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const right = new Float64Array(rw * rh);
+  const down = new Float64Array(rw * rh);
+  let sumSq = 0;
+  let pairs = 0;
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const p = y * rw + x;
+      const c = ((ry + y) * w + rx + x) * 3;
+      if (x + 1 < rw) {
+        right[p] = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
+        sumSq += right[p];
+        pairs++;
+      }
+      if (y + 1 < rh) {
+        const k = c + w * 3;
+        down[p] = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
+        sumSq += down[p];
+        pairs++;
+      }
+    }
+  }
+  const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+  for (let p = 0; p < right.length; p++) {
+    right[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * right[p]));
+    down[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * down[p]));
+  }
+  return { right, down };
+}
+function boxBlur(src, w, h, passes) {
+  let a = src;
+  for (let k = 0; k < passes; k++) {
+    const b = new Float32Array(a.length);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        let s = 0;
+        let c = 0;
+        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
+          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
+            s += a[j * w + i];
+            c++;
+          }
+        }
+        b[y * w + x] = s / c;
+      }
+    }
+    a = b;
+  }
+  return a;
+}
+function upscaleRegion(work, pixels, roi, label, enhance) {
+  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  let soft = Float32Array.from(label);
+  if (enhance) {
+    soft = boxBlur(soft, rw, rh, 2);
+    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
+  }
+  const X0 = Math.max(0, Math.floor(rx / scale));
+  const Y0 = Math.max(0, Math.floor(ry / scale));
+  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
+  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
+  const RW = X1 - X0;
+  const RH = Y1 - Y0;
+  const out = new Uint8Array(RW * RH);
+  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
+  const data = pixels.data;
+  const colOf = new Int32Array(RW);
+  const fxOf = new Float32Array(RW);
+  for (let X = 0; X < RW; X++) {
+    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
+    colOf[X] = Math.floor(u);
+    fxOf[X] = u - colOf[X];
+  }
+  const cellState = (i, j) => {
+    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
+    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
+    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
+    return 2;
+  };
+  for (let Y = 0; Y < RH; Y++) {
+    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
+    const j = Math.floor(v);
+    const fy = v - j;
+    for (let X = 0; X < RW; X++) {
+      const i = colOf[X];
+      const state = cellState(i, j);
+      if (state !== 2) {
+        let end = X + 1;
+        while (end < RW && colOf[end] === i) end++;
+        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
+        X = end - 1;
+        continue;
+      }
+      const fx = fxOf[X];
+      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
+      if (m <= 1e-3 || m >= 0.999) {
+        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
+        continue;
+      }
+      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
+      for (let jj = j - 1; jj <= j + 2; jj++) {
+        for (let ii = i - 1; ii <= i + 2; ii++) {
+          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
+          const k = ((ry + jj) * ww + rx + ii) * 3;
+          if (soft[jj * rw + ii] >= 0.5) {
+            fr += rgb[k];
+            fg += rgb[k + 1];
+            fb += rgb[k + 2];
+            fn++;
+          } else {
+            br += rgb[k];
+            bg += rgb[k + 1];
+            bb += rgb[k + 2];
+            bn++;
+          }
+        }
+      }
+      let alpha = m;
+      if (fn && bn) {
+        fr /= fn;
+        fg /= fn;
+        fb /= fn;
+        br /= bn;
+        bg /= bn;
+        bb /= bn;
+        const dr = fr - br, dg = fg - bg, db = fb - bb;
+        const len2 = dr * dr + dg * dg + db * db;
+        if (len2 > 400) {
+          const p = ((Y0 + Y) * W + X0 + X) * 4;
+          const a = data[p + 3] / 255;
+          const cr = data[p] * a + 255 * (1 - a) - br;
+          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
+          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
+          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
+          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
+        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
+      }
+      out[Y * RW + X] = Math.round(alpha * 255);
+    }
+  }
+  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
+}
+
+// src/image-editor/selection/segment/quick.ts
 var BINS = 16;
 var binOf = (rgb, i) => (Math.min(BINS - 1, rgb[i * 3] >> 4) * BINS + Math.min(BINS - 1, rgb[i * 3 + 1] >> 4)) * BINS + Math.min(BINS - 1, rgb[i * 3 + 2] >> 4);
 function costTable(hist, total) {
@@ -3102,8 +3251,6 @@ function costTable(hist, total) {
   for (let i = 0; i < a.length; i++) out[i] = -Math.log((a[i] + floor * Math.max(1, total)) / denom);
   return out;
 }
-var GAMMA = 50;
-var UNITS = 64;
 function strokePixels(points, r, w, h) {
   const mask = new Uint8Array(w * h);
   const list = [];
@@ -3161,23 +3308,7 @@ function segmentStroke(work, stroke, grown, start) {
     }
     const fgCost = costTable(fgHist, fgN);
     const bgCost = costTable(bgHist, bgN);
-    let sumSq = 0;
-    let pairs = 0;
-    for (let y = 0; y < rh; y++) {
-      for (let x = 0; x < rw; x++) {
-        const g = ((ry + y) * w + rx + x) * 3;
-        if (x + 1 < rw) {
-          sumSq += (rgb[g] - rgb[g + 3]) ** 2 + (rgb[g + 1] - rgb[g + 4]) ** 2 + (rgb[g + 2] - rgb[g + 5]) ** 2;
-          pairs++;
-        }
-        if (y + 1 < rh) {
-          const k = g + w * 3;
-          sumSq += (rgb[g] - rgb[k]) ** 2 + (rgb[g + 1] - rgb[k + 1]) ** 2 + (rgb[g + 2] - rgb[k + 2]) ** 2;
-          pairs++;
-        }
-      }
-    }
-    const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+    const { right, down } = smoothnessWeights(work, roi);
     const graph = new GridGraph(rw, rh);
     const HARD = 1e9;
     for (let y = 0; y < rh; y++) {
@@ -3189,16 +3320,8 @@ function segmentStroke(work, stroke, grown, start) {
           const bin = binOf(rgb, g);
           graph.addTerminal(p, Math.round(bgCost[bin] * UNITS), Math.round(fgCost[bin] * UNITS));
         }
-        const c = g * 3;
-        if (x + 1 < rw) {
-          const d = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
-          graph.setEdge(p, 0, Math.round(GAMMA * UNITS * Math.exp(-beta * d)));
-        }
-        if (y + 1 < rh) {
-          const k = c + w * 3;
-          const d = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
-          graph.setEdge(p, 1, Math.round(GAMMA * UNITS * Math.exp(-beta * d)));
-        }
+        if (x + 1 < rw) graph.setEdge(p, 0, right[p]);
+        if (y + 1 < rh) graph.setEdge(p, 1, down[p]);
       }
     }
     graph.maxflow();
@@ -3239,120 +3362,6 @@ function segmentStroke(work, stroke, grown, start) {
     if (roi.width * roi.height * 2.5 > w * h) roi = { x: 0, y: 0, width: w, height: h };
   }
 }
-function boxBlur(src, w, h, passes) {
-  let a = src;
-  for (let k = 0; k < passes; k++) {
-    const b = new Float32Array(a.length);
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        let s = 0;
-        let c = 0;
-        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
-          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
-            s += a[j * w + i];
-            c++;
-          }
-        }
-        b[y * w + x] = s / c;
-      }
-    }
-    a = b;
-  }
-  return a;
-}
-function upscaleRegion(work, pixels, roi, label, enhance) {
-  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
-  const { x: rx, y: ry, width: rw, height: rh } = roi;
-  let soft = Float32Array.from(label);
-  if (enhance) {
-    soft = boxBlur(soft, rw, rh, 2);
-    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
-  }
-  const X0 = Math.max(0, Math.floor(rx / scale));
-  const Y0 = Math.max(0, Math.floor(ry / scale));
-  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
-  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
-  const RW = X1 - X0;
-  const RH = Y1 - Y0;
-  const out = new Uint8Array(RW * RH);
-  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
-  const data = pixels.data;
-  const colOf = new Int32Array(RW);
-  const fxOf = new Float32Array(RW);
-  for (let X = 0; X < RW; X++) {
-    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
-    colOf[X] = Math.floor(u);
-    fxOf[X] = u - colOf[X];
-  }
-  const cellState = (i, j) => {
-    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
-    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
-    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
-    return 2;
-  };
-  for (let Y = 0; Y < RH; Y++) {
-    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
-    const j = Math.floor(v);
-    const fy = v - j;
-    for (let X = 0; X < RW; X++) {
-      const i = colOf[X];
-      const state = cellState(i, j);
-      if (state !== 2) {
-        let end = X + 1;
-        while (end < RW && colOf[end] === i) end++;
-        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
-        X = end - 1;
-        continue;
-      }
-      const fx = fxOf[X];
-      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
-      if (m <= 1e-3 || m >= 0.999) {
-        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
-        continue;
-      }
-      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
-      for (let jj = j - 1; jj <= j + 2; jj++) {
-        for (let ii = i - 1; ii <= i + 2; ii++) {
-          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
-          const k = ((ry + jj) * ww + rx + ii) * 3;
-          if (soft[jj * rw + ii] >= 0.5) {
-            fr += rgb[k];
-            fg += rgb[k + 1];
-            fb += rgb[k + 2];
-            fn++;
-          } else {
-            br += rgb[k];
-            bg += rgb[k + 1];
-            bb += rgb[k + 2];
-            bn++;
-          }
-        }
-      }
-      let alpha = m;
-      if (fn && bn) {
-        fr /= fn;
-        fg /= fn;
-        fb /= fn;
-        br /= bn;
-        bg /= bn;
-        bb /= bn;
-        const dr = fr - br, dg = fg - bg, db = fb - bb;
-        const len2 = dr * dr + dg * dg + db * db;
-        if (len2 > 400) {
-          const p = ((Y0 + Y) * W + X0 + X) * 4;
-          const a = data[p + 3] / 255;
-          const cr = data[p] * a + 255 * (1 - a) - br;
-          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
-          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
-          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
-          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
-        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
-      }
-      out[Y * RW + X] = Math.round(alpha * 255);
-    }
-  }
-  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
-}
 function quickSelectStroke(pixels, stroke, options = {}) {
   if (!stroke.length) throw new Error("A stroke needs at least one point.");
   const work = workImage(pixels);
@@ -3386,6 +3395,486 @@ function quickSelectStroke(pixels, stroke, options = {}) {
   return upscaleRegion(work, pixels, done, label, options.enhanceEdge ?? false);
 }
 
+// src/image-editor/selection/segment/grabcut.ts
+var K = 5;
+var ColorGmm = class {
+  logWeight = new Float64Array(K);
+  mean = new Float64Array(K * 3);
+  /** Inverse covariances, row-major 3 × 3. */
+  inv = new Float64Array(K * 9);
+  /** ln(weight) − ½ ln((2π)³ |Σ|) per component; −∞ for an empty one. */
+  logNorm = new Float64Array(K).fill(-Infinity);
+  /** Fits the components to the pixels `ids` of `rgb`, each in component `comp[id]`. */
+  fit(rgb, ids, comp) {
+    const n = new Float64Array(K);
+    const sum = new Float64Array(K * 3);
+    const prod = new Float64Array(K * 9);
+    for (let t = 0; t < ids.length; t++) {
+      const i = ids[t];
+      const k = comp[i];
+      const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+      n[k]++;
+      for (let a = 0; a < 3; a++) {
+        sum[k * 3 + a] += c[a];
+        for (let b = 0; b < 3; b++) prod[k * 9 + a * 3 + b] += c[a] * c[b];
+      }
+    }
+    const total = ids.length || 1;
+    for (let k = 0; k < K; k++) {
+      if (!n[k]) {
+        this.logNorm[k] = -Infinity;
+        continue;
+      }
+      const m = [sum[k * 3] / n[k], sum[k * 3 + 1] / n[k], sum[k * 3 + 2] / n[k]];
+      const cov = new Float64Array(9);
+      for (let a = 0; a < 3; a++) {
+        for (let b = 0; b < 3; b++) cov[a * 3 + b] = prod[k * 9 + a * 3 + b] / n[k] - m[a] * m[b];
+        cov[a * 4] += 4;
+      }
+      const det = cov[0] * (cov[4] * cov[8] - cov[5] * cov[7]) - cov[1] * (cov[3] * cov[8] - cov[5] * cov[6]) + cov[2] * (cov[3] * cov[7] - cov[4] * cov[6]);
+      const d = Math.max(det, 1e-6);
+      const inv = [
+        (cov[4] * cov[8] - cov[5] * cov[7]) / d,
+        (cov[2] * cov[7] - cov[1] * cov[8]) / d,
+        (cov[1] * cov[5] - cov[2] * cov[4]) / d,
+        (cov[5] * cov[6] - cov[3] * cov[8]) / d,
+        (cov[0] * cov[8] - cov[2] * cov[6]) / d,
+        (cov[2] * cov[3] - cov[0] * cov[5]) / d,
+        (cov[3] * cov[7] - cov[4] * cov[6]) / d,
+        (cov[1] * cov[6] - cov[0] * cov[7]) / d,
+        (cov[0] * cov[4] - cov[1] * cov[3]) / d
+      ];
+      this.mean.set(m, k * 3);
+      this.inv.set(inv, k * 9);
+      this.logWeight[k] = Math.log(n[k] / total);
+      this.logNorm[k] = this.logWeight[k] - 0.5 * Math.log(Math.pow(2 * Math.PI, 3) * d);
+    }
+  }
+  /** ln p(colour | component k), up to the shared constant. */
+  componentLog(k, r, g, b) {
+    const ln = this.logNorm[k];
+    if (ln === -Infinity) return -Infinity;
+    const dr = r - this.mean[k * 3];
+    const dg = g - this.mean[k * 3 + 1];
+    const db = b - this.mean[k * 3 + 2];
+    const v = this.inv;
+    const o = k * 9;
+    const q = dr * (v[o] * dr + v[o + 1] * dg + v[o + 2] * db) + dg * (v[o + 3] * dr + v[o + 4] * dg + v[o + 5] * db) + db * (v[o + 6] * dr + v[o + 7] * dg + v[o + 8] * db);
+    return ln - 0.5 * q;
+  }
+  /** −ln p(colour) under the mixture (large for colours the model hasn't seen). */
+  cost(r, g, b) {
+    let best = -Infinity;
+    const logs = new Array(K);
+    for (let k = 0; k < K; k++) {
+      logs[k] = this.componentLog(k, r, g, b);
+      if (logs[k] > best) best = logs[k];
+    }
+    if (best === -Infinity) return 50;
+    let s = 0;
+    for (let k = 0; k < K; k++) if (logs[k] > -Infinity) s += Math.exp(logs[k] - best);
+    return Math.min(50, -(best + Math.log(s)));
+  }
+  /** The component most likely to have produced the colour. */
+  nearest(r, g, b) {
+    let best = 0;
+    let bestLog = -Infinity;
+    for (let k = 0; k < K; k++) {
+      const l = this.componentLog(k, r, g, b);
+      if (l > bestLog) {
+        bestLog = l;
+        best = k;
+      }
+    }
+    return best;
+  }
+};
+function initialComponents(rgb, ids, comp) {
+  if (!ids.length) return;
+  const step = Math.max(1, Math.floor(ids.length / 6e3));
+  const sample = [];
+  for (let t = 0; t < ids.length; t += step) sample.push(ids[t]);
+  const centres = [];
+  const dist2 = (i, c) => (rgb[i * 3] - c[0]) ** 2 + (rgb[i * 3 + 1] - c[1]) ** 2 + (rgb[i * 3 + 2] - c[2]) ** 2;
+  centres.push([rgb[sample[0] * 3], rgb[sample[0] * 3 + 1], rgb[sample[0] * 3 + 2]]);
+  const near = sample.map((i) => dist2(i, centres[0]));
+  while (centres.length < K) {
+    let far = 0;
+    for (let t = 1; t < sample.length; t++) if (near[t] > near[far]) far = t;
+    const i = sample[far];
+    const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+    centres.push(c);
+    for (let t = 0; t < sample.length; t++) near[t] = Math.min(near[t], dist2(sample[t], c));
+  }
+  const closest = (i) => {
+    let best = 0;
+    for (let k = 1; k < K; k++) if (dist2(i, centres[k]) < dist2(i, centres[best])) best = k;
+    return best;
+  };
+  for (let round6 = 0; round6 < 6; round6++) {
+    const sum = Array.from({ length: K }, () => [0, 0, 0, 0]);
+    for (const i of sample) {
+      const s = sum[closest(i)];
+      s[0] += rgb[i * 3];
+      s[1] += rgb[i * 3 + 1];
+      s[2] += rgb[i * 3 + 2];
+      s[3]++;
+    }
+    for (let k = 0; k < K; k++) if (sum[k][3]) centres[k] = [sum[k][0] / sum[k][3], sum[k][1] / sum[k][3], sum[k][2] / sum[k][3]];
+  }
+  for (const i of ids) comp[i] = closest(i);
+}
+function grabCutLabels(work, setup, iterations) {
+  const { width: w, rgb } = work;
+  const { roi, hardBg, hardFg } = setup;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const n = rw * rh;
+  const label = setup.initial.slice();
+  const global = new Int32Array(n);
+  for (let y = 0; y < rh; y++) for (let x = 0; x < rw; x++) global[y * rw + x] = (ry + y) * w + rx + x;
+  const comp = new Uint8Array(w * work.height);
+  const fg = new ColorGmm();
+  const bg = new ColorGmm();
+  const { right, down } = smoothnessWeights(work, roi);
+  const HARD = 1e9;
+  for (let iter = 0; iter < iterations; iter++) {
+    const fgIds = [];
+    const bgIds = [];
+    for (let p = 0; p < n; p++) (label[p] ? fgIds : bgIds).push(global[p]);
+    if (!fgIds.length) return label;
+    if (iter === 0) {
+      initialComponents(rgb, fgIds, comp);
+      initialComponents(rgb, bgIds, comp);
+    } else {
+      for (const i of fgIds) comp[i] = fg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+      for (const i of bgIds) comp[i] = bg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+    }
+    fg.fit(rgb, fgIds, comp);
+    bg.fit(rgb, bgIds, comp);
+    const graph = new GridGraph(rw, rh);
+    for (let p = 0; p < n; p++) {
+      if (hardBg[p]) graph.addTerminal(p, 0, HARD);
+      else if (hardFg?.[p]) graph.addTerminal(p, HARD, 0);
+      else {
+        const i = global[p] * 3;
+        graph.addTerminal(p, Math.round(bg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS), Math.round(fg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS));
+      }
+      if (p % rw + 1 < rw) graph.setEdge(p, 0, right[p]);
+      if (p + rw < n) graph.setEdge(p, 1, down[p]);
+    }
+    graph.maxflow();
+    let changed = 0;
+    for (let p = 0; p < n; p++) {
+      const v = graph.inSource(p) ? 1 : 0;
+      if (v !== label[p]) changed++;
+      label[p] = v;
+    }
+    if (changed <= n * 1e-3) break;
+  }
+  return label;
+}
+function keepMainPieces(label, rw, rh, seed) {
+  const n = rw * rh;
+  const piece = new Int32Array(n).fill(-1);
+  const sizes = [];
+  const stack = [];
+  for (let s = 0; s < n; s++) {
+    if (!label[s] || piece[s] >= 0) continue;
+    const id = sizes.length;
+    let size = 0;
+    piece[s] = id;
+    stack.push(s);
+    while (stack.length) {
+      const p = stack.pop();
+      size++;
+      const x = p % rw;
+      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
+        if (q >= 0 && label[q] && piece[q] < 0) {
+          piece[q] = id;
+          stack.push(q);
+        }
+      }
+    }
+    sizes.push(size);
+  }
+  if (!sizes.length) return;
+  const largest = Math.max(...sizes);
+  const keep = (id) => seed !== null && piece[seed] >= 0 ? id === piece[seed] : sizes[id] * 5 >= largest;
+  for (let p = 0; p < n; p++) if (label[p] && !keep(piece[p])) label[p] = 0;
+}
+function selectObjectIn(pixels, target, options = {}) {
+  const work = workImage(pixels);
+  const { width: w, height: h, scale } = work;
+  const iterations = Math.max(1, Math.round(options.iterations ?? 5));
+  const enhance = options.enhanceEdge ?? false;
+  if ("rect" in target) {
+    const r = target.rect;
+    const bx0 = Math.max(0, Math.floor(r.x * scale));
+    const by0 = Math.max(0, Math.floor(r.y * scale));
+    const bx1 = Math.min(w, Math.ceil((r.x + r.width) * scale));
+    const by1 = Math.min(h, Math.ceil((r.y + r.height) * scale));
+    if (bx1 - bx0 < 2 || by1 - by0 < 2) return createSelectionMask(pixels.width, pixels.height);
+    const m = Math.max(8, Math.round(0.25 * Math.max(bx1 - bx0, by1 - by0)));
+    const rx = Math.max(0, bx0 - m);
+    const ry = Math.max(0, by0 - m);
+    const roi = { x: rx, y: ry, width: Math.min(w, bx1 + m) - rx, height: Math.min(h, by1 + m) - ry };
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const gx = rx + x;
+        const gy = ry + y;
+        const inside = gx >= bx0 && gx < bx1 && gy >= by0 && gy < by1;
+        initial[y * roi.width + x] = inside ? 1 : 0;
+        hardBg[y * roi.width + x] = inside ? 0 : 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg: null }, iterations);
+    keepMainPieces(label, roi.width, roi.height, null);
+    return upscaleRegion(work, pixels, roi, label, enhance);
+  }
+  const px2 = Math.min(w - 1, Math.max(0, Math.floor(target.point.x * scale)));
+  const py = Math.min(h - 1, Math.max(0, Math.floor(target.point.y * scale)));
+  let half = Math.max(24, Math.round(0.3 * Math.max(w, h)));
+  for (; ; ) {
+    const rx = Math.max(0, px2 - half);
+    const ry = Math.max(0, py - half);
+    const roi = { x: rx, y: ry, width: Math.min(w, px2 + half + 1) - rx, height: Math.min(h, py + half + 1) - ry };
+    const whole = roi.width === w && roi.height === h;
+    const band = Math.max(4, Math.round(0.15 * half));
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    const hardFg = new Uint8Array(n);
+    const inBand = (x, y) => rx > 0 && x < band || ry > 0 && y < band || rx + roi.width < w && x >= roi.width - band || ry + roi.height < h && y >= roi.height - band;
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const p = y * roi.width + x;
+        if (inBand(x, y)) hardBg[p] = 1;
+        else initial[p] = 1;
+        if (Math.hypot(rx + x - px2, ry + y - py) <= 1.5) hardFg[p] = 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, iterations);
+    keepMainPieces(label, roi.width, roi.height, (py - ry) * roi.width + (px2 - rx));
+    let touches = false;
+    for (let y = 0; y < roi.height && !touches; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        if (label[y * roi.width + x] && (inBand(x - 1, y) || inBand(x + 1, y) || inBand(x, y - 1) || inBand(x, y + 1))) {
+          touches = true;
+          break;
+        }
+      }
+    }
+    if (!touches || whole) return upscaleRegion(work, pixels, roi, label, enhance);
+    half = Math.round(half * 1.6);
+  }
+}
+
+// src/image-editor/selection/segment/subject.ts
+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)];
+}
+function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
+  const { width: w, height: h, rgb } = work;
+  const n = w * h;
+  const lab = new Float32Array(n * 3);
+  for (let i = 0; i < n; i++) lab.set(toLab(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]), i * 3);
+  const S = Math.max(2, Math.round(Math.sqrt(n / target)));
+  const seeds = [];
+  for (let y = Math.floor(S / 2); y < h; y += S) {
+    for (let x = Math.floor(S / 2); x < w; x += S) {
+      const i = y * w + x;
+      seeds.push([lab[i * 3], lab[i * 3 + 1], lab[i * 3 + 2], x, y]);
+    }
+  }
+  const k = seeds.length;
+  const label = new Int32Array(n).fill(-1);
+  const best = new Float64Array(n);
+  const m2 = (compactness / S) ** 2;
+  for (let round6 = 0; round6 < rounds; round6++) {
+    best.fill(Infinity);
+    for (let c = 0; c < k; c++) {
+      const [L, A, B, cx, cy] = seeds[c];
+      const x0 = Math.max(0, Math.floor(cx - S));
+      const x1 = Math.min(w - 1, Math.ceil(cx + S));
+      const y0 = Math.max(0, Math.floor(cy - S));
+      const y1 = Math.min(h - 1, Math.ceil(cy + S));
+      for (let y = y0; y <= y1; y++) {
+        for (let x = x0; x <= x1; x++) {
+          const i = y * w + x;
+          const d = (lab[i * 3] - L) ** 2 + (lab[i * 3 + 1] - A) ** 2 + (lab[i * 3 + 2] - B) ** 2 + m2 * ((x - cx) ** 2 + (y - cy) ** 2);
+          if (d < best[i]) {
+            best[i] = d;
+            label[i] = c;
+          }
+        }
+      }
+    }
+    const sum = new Float64Array(k * 6);
+    for (let i = 0; i < n; i++) {
+      const c = label[i];
+      sum[c * 6] += lab[i * 3];
+      sum[c * 6 + 1] += lab[i * 3 + 1];
+      sum[c * 6 + 2] += lab[i * 3 + 2];
+      sum[c * 6 + 3] += i % w;
+      sum[c * 6 + 4] += Math.floor(i / w);
+      sum[c * 6 + 5]++;
+    }
+    for (let c = 0; c < k; c++) {
+      const s = sum[c * 6 + 5];
+      if (s) seeds[c] = [sum[c * 6] / s, sum[c * 6 + 1] / s, sum[c * 6 + 2] / s, sum[c * 6 + 3] / s, sum[c * 6 + 4] / s];
+    }
+  }
+  const remap = new Int32Array(k).fill(-1);
+  let count = 0;
+  for (let i = 0; i < n; i++) if (remap[label[i]] < 0) remap[label[i]] = count++;
+  const meanLab = new Float64Array(count * 3);
+  const centre = new Float64Array(count * 2);
+  const size = new Int32Array(count);
+  for (let i = 0; i < n; i++) {
+    const c = label[i] = remap[label[i]];
+    meanLab[c * 3] += lab[i * 3];
+    meanLab[c * 3 + 1] += lab[i * 3 + 1];
+    meanLab[c * 3 + 2] += lab[i * 3 + 2];
+    centre[c * 2] += i % w;
+    centre[c * 2 + 1] += Math.floor(i / w);
+    size[c]++;
+  }
+  for (let c = 0; c < count; c++) {
+    for (let j = 0; j < 3; j++) meanLab[c * 3 + j] /= size[c];
+    centre[c * 2] /= size[c];
+    centre[c * 2 + 1] /= size[c];
+  }
+  return { label, count, lab: meanLab, centre, size };
+}
+function superpixelSaliency(sp, width, height) {
+  const { count, lab, centre, size, label } = sp;
+  const dist = (a, b) => Math.hypot(lab[a * 3] - lab[b * 3], lab[a * 3 + 1] - lab[b * 3 + 1], lab[a * 3 + 2] - lab[b * 3 + 2]);
+  const onBorder = new Uint8Array(count);
+  for (let x = 0; x < width; x++) {
+    onBorder[label[x]] = 1;
+    onBorder[label[(height - 1) * width + x]] = 1;
+  }
+  for (let y = 0; y < height; y++) {
+    onBorder[label[y * width]] = 1;
+    onBorder[label[y * width + width - 1]] = 1;
+  }
+  const border = [];
+  for (let c = 0; c < count; c++) if (onBorder[c]) border.push(c);
+  const diag = Math.hypot(width, height);
+  const unlikeBorder = new Float64Array(count);
+  const contrast = new Float64Array(count);
+  const centreBias = new Float64Array(count);
+  for (let i = 0; i < count; i++) {
+    const ds = border.map((j) => dist(i, j)).sort((a, b) => a - b);
+    unlikeBorder[i] = ds.length ? ds[Math.floor(ds.length * 0.25)] : 0;
+    let s = 0;
+    let wsum = 0;
+    for (let j = 0; j < count; j++) {
+      if (j === i) continue;
+      const dx = (centre[i * 2] - centre[j * 2]) / diag;
+      const dy = (centre[i * 2 + 1] - centre[j * 2 + 1]) / diag;
+      const wgt = size[j] * Math.exp(-(dx * dx + dy * dy) / (2 * 0.25 * 0.25));
+      s += wgt * dist(i, j);
+      wsum += wgt;
+    }
+    contrast[i] = wsum ? s / wsum : 0;
+    const cx = centre[i * 2] / width - 0.5;
+    const cy = centre[i * 2 + 1] / height - 0.5;
+    centreBias[i] = 0.4 + 0.6 * Math.exp(-(cx * cx + cy * cy) / (2 * 0.3 * 0.3));
+  }
+  let farthest = 0;
+  for (const v of unlikeBorder) farthest = Math.max(farthest, v);
+  if (farthest < 6) return new Float64Array(count);
+  const norm = (a) => {
+    let max = 0;
+    for (const v of a) max = Math.max(max, v);
+    if (max > 0) for (let i = 0; i < a.length; i++) a[i] /= max;
+  };
+  norm(unlikeBorder);
+  norm(contrast);
+  const out = new Float64Array(count);
+  for (let i = 0; i < count; i++) out[i] = unlikeBorder[i] * (0.3 + 0.7 * contrast[i]) * centreBias[i];
+  norm(out);
+  return out;
+}
+function otsuThreshold(values, weights) {
+  const BINS2 = 64;
+  const hist = new Float64Array(BINS2);
+  let total = 0;
+  for (let i = 0; i < values.length; i++) {
+    hist[Math.min(BINS2 - 1, Math.floor(values[i] * BINS2))] += weights[i];
+    total += weights[i];
+  }
+  let sumAll = 0;
+  for (let b = 0; b < BINS2; b++) sumAll += b * hist[b];
+  let wB = 0;
+  let sumB = 0;
+  let best = 0;
+  let bestT = 0.5;
+  for (let b = 0; b < BINS2 - 1; b++) {
+    wB += hist[b];
+    if (!wB) continue;
+    const wF = total - wB;
+    if (!wF) break;
+    sumB += b * hist[b];
+    const between = wB * wF * (sumB / wB - (sumAll - sumB) / wF) ** 2;
+    if (between > best) {
+      best = between;
+      bestT = (b + 1) / BINS2;
+    }
+  }
+  return bestT;
+}
+function findSubject(pixels, options = {}) {
+  const work = workImage(pixels);
+  const { width: w, height: h } = work;
+  const sp = slicSuperpixels(work);
+  const sal = superpixelSaliency(sp, w, h);
+  const t = otsuThreshold(sal, sp.size);
+  const n = w * h;
+  const initial = new Uint8Array(n);
+  const hardBg = new Uint8Array(n);
+  const hardFg = new Uint8Array(n);
+  const strong = t + 0.6 * (1 - t);
+  for (let i = 0; i < n; i++) {
+    const s = sal[sp.label[i]];
+    if (s >= t) initial[i] = 1;
+    if (s >= strong) hardFg[i] = 1;
+  }
+  for (let x = 0; x < w; x++) {
+    for (const y of [0, h - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
+  }
+  for (let y = 0; y < h; y++) {
+    for (const x of [0, w - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
+  }
+  const empty = (reason) => ({ selection: createSelectionMask(pixels.width, pixels.height), reason });
+  let guessed = 0;
+  for (let i = 0; i < n; i++) guessed += initial[i];
+  if (!guessed || guessed > n * 0.95) return empty("Nothing stands out from the background.");
+  const roi = { x: 0, y: 0, width: w, height: h };
+  const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, 5);
+  keepMainPieces(label, w, h, null);
+  let kept = 0;
+  for (let i = 0; i < n; i++) kept += label[i];
+  if (kept < n * 2e-3) return empty("Nothing stands out from the background.");
+  if (kept > n * 0.97) return empty("The whole image looks like one subject; select it with select_all instead.");
+  return { selection: upscaleRegion(work, pixels, roi, label, options.enhanceEdge ?? false) };
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -6173,7 +6662,7 @@ var ImageEditorController = class {
     this.state.layers = next;
     this.notify();
   }
-  /** The registered segmentation provider, or `null` (then `selectSubject` is unavailable). */
+  /** The registered segmentation provider, or `null` (then `selectSubject` finds the most salient subject without a model). */
   get segmentationProvider() {
     return this.segmentation;
   }
@@ -9355,6 +9844,28 @@ var ImageEditorController = class {
     this.setSelection(sel, "replace");
     return this.state.selection ?? null;
   }
+  /**
+   * Object Selection: the object inside `target.rect` (natural pixels; what is outside the box is
+   * background) or under `target.point`, found by GrabCut (colour models of object and background
+   * plus a graph cut along edges), combined with the selection by `mode` as one undo step.
+   * Resolves to the resulting selection.
+   */
+  async selectObject(target, options = {}) {
+    const { width, height } = this.naturalSize;
+    if ("rect" in target) {
+      const r = target.rect;
+      if (!(r.width > 0 && r.height > 0)) throw new Error("The box needs a positive width and height.");
+      if (r.x >= width || r.y >= height || r.x + r.width <= 0 || r.y + r.height <= 0) {
+        throw new Error(`The box lies outside the image (0..${width}, 0..${height}); draw it around the object.`);
+      }
+    } else if (!(target.point.x >= 0 && target.point.y >= 0 && target.point.x < width && target.point.y < height)) {
+      throw new Error(`(${target.point.x}, ${target.point.y}) is outside the image (0..${width - 1}, 0..${height - 1}); click on the object.`);
+    }
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const region = selectObjectIn(pixels, target, { enhanceEdge: options.enhanceEdge });
+    this.setSelection(region, options.mode ?? "replace");
+    return this.state.selection ?? null;
+  }
   /**
    * Supplies the pixels the selection tools sample (natural size RGBA), e.g. decoded in a worker
    * or in a test; `null` goes back to reading the source image. Without a canvas (Node, workers)
@@ -9523,11 +10034,24 @@ var ImageEditorController = class {
    * Select › Subject: asks the segmentation provider for the objects matching `target` ("the
    * dog", "the sky") in the flattened image and selects their shapes, combined with the
    * selection by `mode`, as one undo step. Returns what was found (labels and bounds in natural
-   * pixels); an empty list leaves the selection as it was. Throws without a provider.
+   * pixels); an empty list leaves the selection as it was. Without a provider, the subject that
+   * stands out most is found classically (superpixels, saliency, Otsu, GrabCut): `target` can't
+   * choose it, and `method: 'saliency'` and a `note` say so.
    */
-  async selectSubject(target, options = {}) {
+  async selectSubject(target = "", options = {}) {
     const provider = this.segmentation;
-    if (!provider) throw new Error("Select Subject needs a segmentation provider (setSegmentationProvider).");
+    if (!provider) {
+      const pixels = await this.requirePixels({});
+      options.signal?.throwIfAborted();
+      const { selection, reason } = findSubject(pixels, { enhanceEdge: options.enhanceEdge });
+      if (selection.bounds) this.shapeCommand(selection, options);
+      const unused = target.trim() ? ` "${target.trim()}" was not used to choose it.` : "";
+      return {
+        segments: selection.bounds ? [{ label: "subject", bounds: selection.bounds }] : [],
+        method: "saliency",
+        note: reason ?? `No segmentation model is set, so the subject that stands out most was selected.${unused}`
+      };
+    }
     const description = target.trim();
     if (!description) throw new Error("Describe the subject to select.");
     const { width, height } = this.naturalSize;
@@ -9553,7 +10077,7 @@ var ImageEditorController = class {
       options.signal?.throwIfAborted();
     }
     if (mask) this.shapeCommand(mask, options);
-    return { segments: segments.filter((s) => s.bounds) };
+    return { segments: segments.filter((s) => s.bounds), method: "model" };
   }
   /** Quick Mask view (tints the unselected area). View state: no undo step. */
   setQuickMask(on) {
@@ -10848,7 +11372,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.`);
@@ -10858,7 +11382,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("")}`;
@@ -12242,7 +12766,7 @@ var DEPTH_MASK_CONTROLS = [
 // src/image-editor/playback.ts
 var IMAGE_PLAYBACK_KIND = "layer";
 var PAINT = /^(paint_stroke|clone_stamp|heal_brush|spot_heal|dodge|burn|sponge|smudge|blur_stroke|sharpen_stroke|history_brush|set_clone_source|set_clone_transform|fill_pixels|clear_pixels|set_paint|set_retouch_options|load_mixer_brush|clean_mixer_brush)$/;
-var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection|select_text_shape)$/;
+var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_object|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection|select_text_shape)$/;
 var ANNOTATE = /^(add_shape_layer|update_shape|add_shape_component|set_shape_component|remove_shape_component|merge_shape_components|add_text_layer|set_text|set_text_style|set_paragraph_style|set_text_frame|set_text_orientation|convert_text_to_shape)$/;
 var CROP = /^(set_crop|crop_to_selection|reset_crop|set_rotation|flip_image|transform_layer|warp_layer|flip_layer|offset_layer)$/;
 var ADJUST = /^(set_adjustments|add_adjustment_layer|update_adjustment_layer|remove_adjustment_layer|move_adjustment_layer)$/;
@@ -12365,6 +12889,7 @@ var SELECTION_TOOLS = [
   { id: "polygon", label: "Polygonal Lasso" },
   { id: "magnetic", label: "Magnetic Lasso" },
   { id: "quick", label: "Quick Selection" },
+  { id: "object", label: "Object Selection" },
   { id: "range", label: "Color Range" },
   { id: "type", label: "Type Mask" },
   { id: "type-vertical", label: "Vertical Type Mask" }
@@ -12405,6 +12930,8 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   quickSize: 30,
   quickSampleAll: true,
   quickEnhance: false,
+  objectSampleAll: true,
+  objectEnhance: false,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -12840,6 +13367,39 @@ function createImageSelectionTools(controller) {
       return summary(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, found 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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rect: {
+          type: "object",
+          properties: rectProperties,
+          required: ["x", "y", "width", "height"],
+          additionalProperties: false,
+          description: "A box around the object (x, y, width, height in natural image pixels). Pass this or point."
+        },
+        point: { ...pointSchema, description: "A point on the object (natural image pixels). Pass this or rect." },
+        mode: modeSchema,
+        sampleAllLayers: { type: "boolean", description: "Read every layer (default true); false reads only the active pixel layer." },
+        enhanceEdge: { type: "boolean", description: "Smoother, less blocky edges (Auto-Enhance; default false)." }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Object Selection"),
+    handler: async (args) => {
+      const rect = args.rect;
+      const point = args.point;
+      if (!rect && !point) throw new Error("Pass rect (a box around the object) or point (a point on it).");
+      if (rect && point) throw new Error("Pass rect or point, not both.");
+      const options = { mode: parseSelectionMode(args.mode), sampleAllLayers: args.sampleAllLayers, enhanceEdge: args.enhanceEdge };
+      if (rect) await controller.selectObject({ rect: { x: num2(rect.x, NaN), y: num2(rect.y, NaN), width: num2(rect.width, NaN), height: num2(rect.height, NaN) } }, options);
+      else await controller.selectObject({ point: { x: num2(point.x, NaN), y: num2(point.y, NaN) } }, options);
+      return summary(controller);
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -13393,6 +13953,8 @@ function createImageSelectionTools(controller) {
     selectEllipse,
     selectPolygonTool,
     quickSelectTool,
+    selectObjectTool,
+    createImageSubjectSelectionTool(controller),
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -13429,49 +13991,50 @@ function createImageSubjectSelectionTool(controller) {
   return {
     name: "select_subject",
     title: "Select a subject",
-    description: 'Select \u203A Subject: an AI segmentation model finds the objects matching target (a description such as "the dog", "the house", "the sky") in the flattened image and selects their outlines, combined with the selection by mode. Use it to cut a subject out by its contour (then layer_via_copy for a layer of just that subject); describe one object precisely to get only that one. One undoable step. Returns the selection and the objects found (label, bounds); 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.',
     inputSchema: {
       type: "object",
       properties: {
-        target: { type: "string", minLength: 1, description: "What to select, in words." },
+        target: { type: "string", description: "What to select, in words. Needed with a model; ignored without one." },
         maxSegments: {
           type: "integer",
           minimum: 1,
           maximum: 32,
-          description: "Select at most this many matching objects (default the model\u2019s; 1 for a single subject)."
+          description: "With a model: select at most this many matching objects (default the model\u2019s; 1 for a single subject)."
         },
         mode: modeSchema,
-        feather: { type: "number", minimum: 0, description: "Feather radius in pixels (default 0)." }
+        feather: { type: "number", minimum: 0, description: "Feather radius in pixels (default 0)." },
+        enhanceEdge: { type: "boolean", description: "Without a model: smoother, less blocky edges (Auto-Enhance; default false)." }
       },
-      required: ["target"],
       additionalProperties: false
     },
     annotations: { ...writeAnnotations("Select a subject"), openWorldHint: true },
-    handler: async ({ target, maxSegments, mode, feather }, context) => {
-      if (typeof target !== "string" || !target.trim()) throw new Error("target must describe what to select.");
+    handler: async ({ target, maxSegments, mode, feather, enhanceEdge }, context) => {
+      if (target !== void 0 && typeof target !== "string") throw new Error("target must be a description in words.");
+      if (controller.segmentationProvider && !String(target ?? "").trim()) throw new Error("target must describe what to select (a model is set, and it selects by description).");
       const perform = context?.perform;
-      const { segments } = await controller.selectSubject(target, {
+      const { segments, method, note } = await controller.selectSubject(String(target ?? ""), {
         mode: parseSelectionMode(mode),
         feather: num2(feather, 0),
         maxSegments: typeof maxSegments === "number" ? Math.max(1, Math.round(maxSegments)) : void 0,
+        enhanceEdge: enhanceEdge === true,
         signal: context?.signal,
         // 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 };
+      return { ...summary(controller), found: segments, method, ...note ? { note } : {} };
     }
   };
 }
 function createImageSegmentationToolProvider(controller, options = {}) {
-  const tool = createImageSubjectSelectionTool(controller);
   return withImagePlayback(
     {
       id: options.id ?? "image-segmentation",
       namespace: options.namespace,
       title: "Image segmentation",
-      description: "Select \u203A Subject: select objects in the image by description through an AI segmentation model.",
+      description: "Deprecated: select_subject is in the image editor tool provider.",
       skill: "pixerate-image-editor",
-      tools: () => controller.segmentationProvider ? [tool] : []
+      tools: () => []
     },
     options.playbackSurface
   );
@@ -14784,7 +15347,7 @@ var SelectionGesture = class {
   get active() {
     return this.start !== null || this.polygon !== null || this.magnetic !== null;
   }
-  /** Resolves once a Quick Selection stroke has been applied. */
+  /** Resolves once a Quick Selection stroke or an Object Selection has been applied. */
   get settled() {
     return this.pending;
   }
@@ -14954,6 +15517,20 @@ var SelectionGesture = class {
     if (point) this.move(point);
     const options = this.getOptions();
     const mode = selectionModeFromModifiers(modifiers ?? this.modifiers, options.mode);
+    if (options.tool === "object") {
+      const rect2 = normalizeRect({ x: this.start.x, y: this.start.y, width: this.current.x - this.start.x, height: this.current.y - this.start.y });
+      this.start = null;
+      this.current = null;
+      this.points = [];
+      const target = rect2.width >= 4 && rect2.height >= 4 ? { rect: rect2 } : { point: { x: rect2.x + rect2.width / 2, y: rect2.y + rect2.height / 2 } };
+      this.pending = this.controller.selectObject(target, { mode, sampleAllLayers: options.objectSampleAll ?? true, enhanceEdge: options.objectEnhance ?? false }).then(
+        () => void 0,
+        (err) => {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      );
+      return false;
+    }
     if (options.tool === "quick") {
       const stroke = this.points;
       this.start = null;
@@ -19600,6 +20177,7 @@ export {
   COLOR_MODE_OPTIONS,
   COLOR_RANGE_PRESETS,
   COLOR_RANGE_PRESET_LABELS,
+  ColorGmm,
   CoverageMap,
   D50,
   D65,
@@ -19652,6 +20230,7 @@ export {
   FREE_TRANSFORM_MODE_OPTIONS,
   FreeTransformSession,
   FreeTransformTool,
+  GAMMA,
   GRAIN_PATTERNS,
   GRAIN_TILE,
   GUIDED_FILTER_EPS,
@@ -19810,6 +20389,7 @@ export {
   TransformTooLargeError,
   TransformedPixelSource,
   TypeToolGesture,
+  UNITS,
   U_MAX,
   VIBRANCE_GREY,
   W9,
@@ -19893,6 +20473,7 @@ export {
   blenderDab,
   blurFilter,
   borderCoverage,
+  boxBlur,
   boxBlurPixels,
   boxFrameHit,
   boxFrameOverlay,
@@ -20087,6 +20668,7 @@ export {
   findAdjustmentControl,
   findLayer,
   findLayerControl,
+  findSubject,
   findWebGpu,
   finishTile,
   fitParagraphRuns,
@@ -20108,6 +20690,7 @@ export {
   getViewportMetrics,
   getViewportProjection,
   globalImageCache,
+  grabCutLabels,
   gradientDabColor,
   grainCatch,
   grainHeights,
@@ -20199,6 +20782,7 @@ export {
   isTransformAnchor,
   isValidWarp,
   keepDeepSamples,
+  keepMainPieces,
   kelvinToTemperature,
   keysWeight,
   latticeViscosity,
@@ -20311,6 +20895,7 @@ export {
   offsetVectorMask,
   openMaskFile,
   openPsdFile,
+  otsuThreshold,
   packRgba,
   packWetParams,
   paintGradientMappingFor,
@@ -20454,6 +21039,7 @@ export {
   segmentToSelection,
   segmentationOutlines,
   segmentsToSelection,
+  selectObjectIn,
   selectSimilar,
   selectionArea,
   selectionFromCoverage,
@@ -20499,10 +21085,12 @@ export {
   shiftCoverage,
   simplifyPixelPath,
   skinToneRange,
+  slicSuperpixels,
   smartFilterRows,
   smartObjectLayers,
   smoothCoverage,
   smoothPoints,
+  smoothnessWeights,
   smudgeEffect,
   snapPolygonToEdges,
   snapTo45,
@@ -20528,6 +21116,7 @@ export {
   styleAt,
   subpathsToSvgPath,
   sumHistograms,
+  superpixelSaliency,
   surfaceBytes,
   surfaceDepth,
   surfaceFromDeepPixels,
@@ -20589,6 +21178,7 @@ export {
   updateShapeLayer,
   updateSmartFilter,
   updateTypeLayer,
+  upscaleRegion,
   userErrorMessage,
   uvToXy,
   validateEffectGradient,