@pixerate/editor 0.198.0 → 0.200.0

package/dist/image-editor/index.js

@@ -3049,8 +3049,9 @@ var GridGraph = class {
 var WORK_SIZE = 512;
 var workCache = /* @__PURE__ */ new WeakMap();
 function workImage(pixels, maxSide = WORK_SIZE) {
-  const cached = workCache.get(pixels.data);
-  if (cached && cached.maxSide === maxSide && cached.work.sourceWidth === pixels.width && cached.work.sourceHeight === pixels.height) return cached.work;
+  const sizes = workCache.get(pixels.data);
+  const cached = sizes?.get(maxSide);
+  if (cached && cached.sourceWidth === pixels.width && cached.sourceHeight === pixels.height) return cached;
   const { width: W, height: H, data } = pixels;
   const scale = Math.min(1, maxSide / Math.max(W, H));
   const w = Math.max(1, Math.round(W * scale));
@@ -3079,7 +3080,8 @@ function workImage(pixels, maxSide = WORK_SIZE) {
     rgb[i * 3 + 2] = sum[i * 3 + 2] / c;
   }
   const work = { sourceWidth: W, sourceHeight: H, width: w, height: h, scale: w / W, rgb };
-  workCache.set(pixels.data, { maxSide, work });
+  if (sizes) sizes.set(maxSide, work);
+  else workCache.set(pixels.data, /* @__PURE__ */ new Map([[maxSide, work]]));
   return work;
 }
 var GAMMA = 50;
@@ -3672,6 +3674,545 @@ function selectObjectIn(pixels, target, options = {}) {
   }
 }
 
+// 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/selection/refine.ts
+var DEFAULT_REFINE_EDGE_PARAMS = {
+  radius: 0,
+  smartRadius: false,
+  smooth: 0,
+  feather: 0,
+  contrast: 0,
+  shiftEdge: 0
+};
+var GUIDED_FILTER_EPS = 1e-4;
+var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function normalizeRefineEdgeParams(p = {}) {
+  return {
+    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
+    smartRadius: p.smartRadius === true,
+    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
+    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
+    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
+    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
+  };
+}
+var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
+var smoothSigma = (p) => p.smooth / 100 * 4;
+var featherSigma = (p) => p.feather / 2;
+function shiftAmount(p) {
+  const px2 = p.shiftEdge / 100 * Math.max(p.radius, 4);
+  return Number.isFinite(px2) ? Math.min(64, Math.max(-64, px2)) : 0;
+}
+function refineEdgeHalo(params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  const g = gfRadius(p);
+  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
+  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
+}
+function boxMean(src, w, h, r) {
+  const tmp = new Float32Array(w * h);
+  const pre = new Float64Array(Math.max(w, h) + 1);
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
+    for (let x = 0; x < w; x++) {
+      const lo = Math.max(0, x - r);
+      const hi = Math.min(w, x + r + 1);
+      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  const out = new Float32Array(w * h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
+    for (let y = 0; y < h; y++) {
+      const lo = Math.max(0, y - r);
+      const hi = Math.min(h, y + r + 1);
+      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  return out;
+}
+function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
+  const n = w * h;
+  const [c0, c1, c2] = guide;
+  const prod = (a, b2) => {
+    const o = new Float32Array(n);
+    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
+    return o;
+  };
+  const m0 = boxMean(c0, w, h, r);
+  const m1 = boxMean(c1, w, h, r);
+  const m2 = boxMean(c2, w, h, r);
+  const mp = boxMean(p, w, h, r);
+  const mip0 = boxMean(prod(c0, p), w, h, r);
+  const mip1 = boxMean(prod(c1, p), w, h, r);
+  const mip2 = boxMean(prod(c2, p), w, h, r);
+  const s00 = boxMean(prod(c0, c0), w, h, r);
+  const s01 = boxMean(prod(c0, c1), w, h, r);
+  const s02 = boxMean(prod(c0, c2), w, h, r);
+  const s11 = boxMean(prod(c1, c1), w, h, r);
+  const s12 = boxMean(prod(c1, c2), w, h, r);
+  const s22 = boxMean(prod(c2, c2), w, h, r);
+  const a0 = new Float32Array(n);
+  const a1 = new Float32Array(n);
+  const a2 = new Float32Array(n);
+  const b = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
+    const rr = s00[i] - u0 * u0 + eps;
+    const rg = s01[i] - u0 * u1;
+    const rb = s02[i] - u0 * u2;
+    const gg = s11[i] - u1 * u1 + eps;
+    const gb = s12[i] - u1 * u2;
+    const bb = s22[i] - u2 * u2 + eps;
+    const v0 = mip0[i] - u0 * up;
+    const v1 = mip1[i] - u1 * up;
+    const v2 = mip2[i] - u2 * up;
+    const i00 = gg * bb - gb * gb;
+    const i01 = gb * rb - rg * bb;
+    const i02 = rg * gb - gg * rb;
+    const i11 = rr * bb - rb * rb;
+    const i12 = rb * rg - rr * gb;
+    const i22 = rr * gg - rg * rg;
+    const det = rr * i00 + rg * i01 + rb * i02;
+    let x0 = 0, x1 = 0, x2 = 0;
+    if (Math.abs(det) >= 1e-30) {
+      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
+      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
+      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
+    }
+    a0[i] = x0;
+    a1[i] = x1;
+    a2[i] = x2;
+    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
+  }
+  const ma0 = boxMean(a0, w, h, r);
+  const ma1 = boxMean(a1, w, h, r);
+  const ma2 = boxMean(a2, w, h, r);
+  const mb = boxMean(b, w, h, r);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
+  return out;
+}
+function edgeWidth(guide, w, h, r) {
+  const n = w * h;
+  const y = new Float32Array(n);
+  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
+  const g = new Float32Array(n);
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
+      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
+      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
+    }
+  }
+  const gm = greyMorphology(g, w, h, r, true);
+  const hi = greyMorphology(y, w, h, r, true);
+  const lo = greyMorphology(y, w, h, r, false);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
+  return out;
+}
+function refineCoverage(guide, m, w, h, params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  let a = Float32Array.from(m);
+  if (p.radius > 0 && guide) {
+    const n = w * h;
+    const boundary = new Uint8Array(n);
+    let any = false;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const i = y * w + x;
+        const v = m[i] >= 0.5;
+        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
+        if (diff) {
+          boundary[i] = 1;
+          any = true;
+        }
+      }
+    }
+    if (any) {
+      const dist = distanceTransform(boundary, w, h);
+      const r = gfRadius(p);
+      const q = guidedFilterColor(guide, m, w, h, r);
+      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
+      for (let i = 0; i < n; i++) {
+        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
+        const wgt = Math.min(1, Math.max(0, reff + 1 - dist[i]));
+        if (wgt > 0) {
+          const qi = Math.min(1, Math.max(0, q[i]));
+          a[i] = m[i] + (qi - m[i]) * wgt;
+        }
+      }
+    }
+  }
+  const ss = smoothSigma(p);
+  if (ss >= 0.3) {
+    a = gaussianBlur(a, w, h, ss, "clamp");
+    const gain = 1 + ss;
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
+  if (p.contrast > 0) {
+    const gain = 1 / (1 - 0.99 * p.contrast / 100);
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  const amount = shiftAmount(p);
+  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
+  return a;
+}
+function guidePlanes(pixels, win) {
+  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
+  const n = box.width * box.height;
+  const r = new Float32Array(n);
+  const g = new Float32Array(n);
+  const b = new Float32Array(n);
+  const d = pixels.data;
+  for (let y = 0; y < box.height; y++) {
+    for (let x = 0; x < box.width; x++) {
+      const i = y * box.width + x;
+      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
+      r[i] = d[p] / 255;
+      g[i] = d[p + 1] / 255;
+      b[i] = d[p + 2] / 255;
+    }
+  }
+  return [r, g, b];
+}
+function refineSelection(pixels, mask, params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
+    throw new Error("Refine Edge needs pixels the size of the selection");
+  }
+  if (!mask.bounds) return mask;
+  const halo = refineEdgeHalo(p);
+  const x0 = Math.max(0, mask.bounds.x - halo);
+  const y0 = Math.max(0, mask.bounds.y - halo);
+  const x1 = Math.min(mask.width, mask.bounds.x + mask.bounds.width + halo);
+  const y1 = Math.min(mask.height, mask.bounds.y + mask.bounds.height + halo);
+  const ww = x1 - x0;
+  const wh = y1 - y0;
+  const m = new Float32Array(ww * wh);
+  for (let y = 0; y < wh; y++) {
+    const src = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
+  }
+  const guide = pixels && p.radius > 0 ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
+  const refined = refineCoverage(guide, m, ww, wh, p);
+  const out = new Uint8Array(mask.width * mask.height);
+  for (let y = 0; y < wh; y++) {
+    const dst = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
+  }
+  return createSelectionMask(mask.width, mask.height, out);
+}
+
+// src/image-editor/selection/segment/guided.ts
+function workPlanes(work) {
+  const n = work.width * work.height;
+  const planes = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
+  for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = work.rgb[i * 3 + c] / 255;
+  return planes;
+}
+function workLuma(work) {
+  const n = work.width * work.height;
+  const out = new Float32Array(n);
+  const { rgb } = work;
+  for (let i = 0; i < n; i++) out[i] = (0.299 * rgb[i * 3] + 0.587 * rgb[i * 3 + 1] + 0.114 * rgb[i * 3 + 2]) / 255;
+  return out;
+}
+function softMaskToSelection(work, mask) {
+  const { sourceWidth: W, sourceHeight: H, width: w, height: h, scale } = work;
+  const out = new Uint8Array(W * H);
+  const col = new Int32Array(W);
+  const fx = new Float32Array(W);
+  for (let X = 0; X < W; X++) {
+    const u = Math.min(w - 1, Math.max(0, (X + 0.5) * scale - 0.5));
+    col[X] = Math.min(w - 2, Math.floor(u));
+    fx[X] = u - col[X];
+    if (w === 1) {
+      col[X] = 0;
+      fx[X] = 0;
+    }
+  }
+  for (let Y = 0; Y < H; Y++) {
+    const v = Math.min(h - 1, Math.max(0, (Y + 0.5) * scale - 0.5));
+    const j = h === 1 ? 0 : Math.min(h - 2, Math.floor(v));
+    const fy = h === 1 ? 0 : v - j;
+    const r0 = j * w;
+    const r1 = h === 1 ? r0 : r0 + w;
+    for (let X = 0; X < W; X++) {
+      const i = col[X];
+      const i1 = w === 1 ? i : i + 1;
+      const t = fx[X];
+      const m = (mask[r0 + i] * (1 - t) + mask[r0 + i1] * t) * (1 - fy) + (mask[r1 + i] * (1 - t) + mask[r1 + i1] * t) * fy;
+      out[Y * W + X] = Math.round(Math.min(1, Math.max(0, m)) * 255);
+    }
+  }
+  return selectionFromRegion(W, H, { x: 0, y: 0, width: W, height: H }, out);
+}
+
+// src/image-editor/selection/segment/focus.ts
+var FOCUS_SIZE = 1024;
+function estimateNoise(luma2, w, h) {
+  if (w < 3 || h < 3) return 0;
+  let sum = 0;
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const v = luma2[i - w - 1] - 2 * luma2[i - w] + luma2[i - w + 1] - 2 * luma2[i - 1] + 4 * luma2[i] - 2 * luma2[i + 1] + luma2[i + w - 1] - 2 * luma2[i + w] + luma2[i + w + 1];
+      sum += Math.abs(v);
+    }
+  }
+  return Math.sqrt(Math.PI / 2) * sum / (6 * (w - 2) * (h - 2));
+}
+function focusArea(pixels, options = {}) {
+  const work = workImage(pixels, FOCUS_SIZE);
+  const { width: w, height: h, scale } = work;
+  const n = w * h;
+  const luma2 = workLuma(work);
+  const sigma = estimateNoise(luma2, w, h);
+  const noise = Math.min(100, Math.max(0, options.noise ?? 0));
+  const floor = 2 * sigma * (1 + noise / 25);
+  const detail = new Float32Array(n);
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const lap = Math.abs(4 * luma2[i] - luma2[i - 1] - luma2[i + 1] - luma2[i - w] - luma2[i + w]);
+      const d = Math.max(0, lap - floor);
+      detail[i] = d * d;
+    }
+  }
+  const r = Math.max(2, Math.round(0.012 * Math.max(w, h)));
+  const energy = boxMean(detail, w, h, r);
+  const sharp = new Float32Array(n);
+  for (let i = 0; i < n; i++) sharp[i] = Math.log1p(Math.sqrt(energy[i]) * 400);
+  const sorted = Float32Array.from(sharp).sort();
+  const top = sorted[Math.floor(n * 0.995)] || 1;
+  for (let i = 0; i < n; i++) sharp[i] = Math.min(1, sharp[i] / top);
+  const ones = new Float32Array(n).fill(1);
+  const otsu = otsuThreshold(sharp, ones);
+  const range = Math.min(100, Math.max(0, options.range ?? 50));
+  const t = Math.min(0.98, otsu * Math.pow(2, (50 - range) / 25));
+  let mask = new Float32Array(n);
+  for (let i = 0; i < n; i++) mask[i] = sharp[i] >= t ? 1 : 0;
+  const c = 2 * r;
+  const grown = boxMean(mask, w, h, c);
+  for (let i = 0; i < n; i++) grown[i] = grown[i] > 1e-3 ? 1 : 0;
+  const shrunk = boxMean(grown, w, h, c);
+  for (let i = 0; i < n; i++) mask[i] = shrunk[i] >= 0.999 ? 1 : 0;
+  const pulled = boxMean(mask, w, h, Math.max(1, Math.round(r / 2)));
+  for (let i = 0; i < n; i++) mask[i] = pulled[i] >= 0.999 ? 1 : 0;
+  const softness = Math.max(0, options.softness ?? 4) * scale;
+  if (softness > 0) {
+    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
+    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
+  }
+  return { selection: softMaskToSelection(work, mask), noiseLevel: Math.round(sigma * 255 * 10) / 10 };
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -4597,238 +5138,6 @@ function segmentsToSelection(width, height, results) {
   return out;
 }
 
-// src/image-editor/selection/refine.ts
-var DEFAULT_REFINE_EDGE_PARAMS = {
-  radius: 0,
-  smartRadius: false,
-  smooth: 0,
-  feather: 0,
-  contrast: 0,
-  shiftEdge: 0
-};
-var GUIDED_FILTER_EPS = 1e-4;
-var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
-function normalizeRefineEdgeParams(p = {}) {
-  return {
-    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
-    smartRadius: p.smartRadius === true,
-    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
-    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
-    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
-    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
-  };
-}
-var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
-var smoothSigma = (p) => p.smooth / 100 * 4;
-var featherSigma = (p) => p.feather / 2;
-function shiftAmount(p) {
-  const px2 = p.shiftEdge / 100 * Math.max(p.radius, 4);
-  return Number.isFinite(px2) ? Math.min(64, Math.max(-64, px2)) : 0;
-}
-function refineEdgeHalo(params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  const g = gfRadius(p);
-  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
-  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
-}
-function boxMean(src, w, h, r) {
-  const tmp = new Float32Array(w * h);
-  const pre = new Float64Array(Math.max(w, h) + 1);
-  for (let y = 0; y < h; y++) {
-    const row = y * w;
-    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
-    for (let x = 0; x < w; x++) {
-      const lo = Math.max(0, x - r);
-      const hi = Math.min(w, x + r + 1);
-      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
-    }
-  }
-  const out = new Float32Array(w * h);
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
-    for (let y = 0; y < h; y++) {
-      const lo = Math.max(0, y - r);
-      const hi = Math.min(h, y + r + 1);
-      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
-    }
-  }
-  return out;
-}
-function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
-  const n = w * h;
-  const [c0, c1, c2] = guide;
-  const prod = (a, b2) => {
-    const o = new Float32Array(n);
-    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
-    return o;
-  };
-  const m0 = boxMean(c0, w, h, r);
-  const m1 = boxMean(c1, w, h, r);
-  const m2 = boxMean(c2, w, h, r);
-  const mp = boxMean(p, w, h, r);
-  const mip0 = boxMean(prod(c0, p), w, h, r);
-  const mip1 = boxMean(prod(c1, p), w, h, r);
-  const mip2 = boxMean(prod(c2, p), w, h, r);
-  const s00 = boxMean(prod(c0, c0), w, h, r);
-  const s01 = boxMean(prod(c0, c1), w, h, r);
-  const s02 = boxMean(prod(c0, c2), w, h, r);
-  const s11 = boxMean(prod(c1, c1), w, h, r);
-  const s12 = boxMean(prod(c1, c2), w, h, r);
-  const s22 = boxMean(prod(c2, c2), w, h, r);
-  const a0 = new Float32Array(n);
-  const a1 = new Float32Array(n);
-  const a2 = new Float32Array(n);
-  const b = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
-    const rr = s00[i] - u0 * u0 + eps;
-    const rg = s01[i] - u0 * u1;
-    const rb = s02[i] - u0 * u2;
-    const gg = s11[i] - u1 * u1 + eps;
-    const gb = s12[i] - u1 * u2;
-    const bb = s22[i] - u2 * u2 + eps;
-    const v0 = mip0[i] - u0 * up;
-    const v1 = mip1[i] - u1 * up;
-    const v2 = mip2[i] - u2 * up;
-    const i00 = gg * bb - gb * gb;
-    const i01 = gb * rb - rg * bb;
-    const i02 = rg * gb - gg * rb;
-    const i11 = rr * bb - rb * rb;
-    const i12 = rb * rg - rr * gb;
-    const i22 = rr * gg - rg * rg;
-    const det = rr * i00 + rg * i01 + rb * i02;
-    let x0 = 0, x1 = 0, x2 = 0;
-    if (Math.abs(det) >= 1e-30) {
-      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
-      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
-      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
-    }
-    a0[i] = x0;
-    a1[i] = x1;
-    a2[i] = x2;
-    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
-  }
-  const ma0 = boxMean(a0, w, h, r);
-  const ma1 = boxMean(a1, w, h, r);
-  const ma2 = boxMean(a2, w, h, r);
-  const mb = boxMean(b, w, h, r);
-  const out = new Float32Array(n);
-  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
-  return out;
-}
-function edgeWidth(guide, w, h, r) {
-  const n = w * h;
-  const y = new Float32Array(n);
-  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
-  const g = new Float32Array(n);
-  for (let yy = 0; yy < h; yy++) {
-    for (let xx = 0; xx < w; xx++) {
-      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
-      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
-      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
-    }
-  }
-  const gm = greyMorphology(g, w, h, r, true);
-  const hi = greyMorphology(y, w, h, r, true);
-  const lo = greyMorphology(y, w, h, r, false);
-  const out = new Float32Array(n);
-  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
-  return out;
-}
-function refineCoverage(guide, m, w, h, params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  let a = Float32Array.from(m);
-  if (p.radius > 0 && guide) {
-    const n = w * h;
-    const boundary = new Uint8Array(n);
-    let any = false;
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        const i = y * w + x;
-        const v = m[i] >= 0.5;
-        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
-        if (diff) {
-          boundary[i] = 1;
-          any = true;
-        }
-      }
-    }
-    if (any) {
-      const dist = distanceTransform(boundary, w, h);
-      const r = gfRadius(p);
-      const q = guidedFilterColor(guide, m, w, h, r);
-      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
-      for (let i = 0; i < n; i++) {
-        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
-        const wgt = Math.min(1, Math.max(0, reff + 1 - dist[i]));
-        if (wgt > 0) {
-          const qi = Math.min(1, Math.max(0, q[i]));
-          a[i] = m[i] + (qi - m[i]) * wgt;
-        }
-      }
-    }
-  }
-  const ss = smoothSigma(p);
-  if (ss >= 0.3) {
-    a = gaussianBlur(a, w, h, ss, "clamp");
-    const gain = 1 + ss;
-    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
-  }
-  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
-  if (p.contrast > 0) {
-    const gain = 1 / (1 - 0.99 * p.contrast / 100);
-    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
-  }
-  const amount = shiftAmount(p);
-  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
-  return a;
-}
-function guidePlanes(pixels, win) {
-  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
-  const n = box.width * box.height;
-  const r = new Float32Array(n);
-  const g = new Float32Array(n);
-  const b = new Float32Array(n);
-  const d = pixels.data;
-  for (let y = 0; y < box.height; y++) {
-    for (let x = 0; x < box.width; x++) {
-      const i = y * box.width + x;
-      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
-      r[i] = d[p] / 255;
-      g[i] = d[p + 1] / 255;
-      b[i] = d[p + 2] / 255;
-    }
-  }
-  return [r, g, b];
-}
-function refineSelection(pixels, mask, params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
-    throw new Error("Refine Edge needs pixels the size of the selection");
-  }
-  if (!mask.bounds) return mask;
-  const halo = refineEdgeHalo(p);
-  const x0 = Math.max(0, mask.bounds.x - halo);
-  const y0 = Math.max(0, mask.bounds.y - halo);
-  const x1 = Math.min(mask.width, mask.bounds.x + mask.bounds.width + halo);
-  const y1 = Math.min(mask.height, mask.bounds.y + mask.bounds.height + halo);
-  const ww = x1 - x0;
-  const wh = y1 - y0;
-  const m = new Float32Array(ww * wh);
-  for (let y = 0; y < wh; y++) {
-    const src = (y0 + y) * mask.width + x0;
-    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
-  }
-  const guide = pixels && p.radius > 0 ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
-  const refined = refineCoverage(guide, m, ww, wh, p);
-  const out = new Uint8Array(mask.width * mask.height);
-  for (let y = 0; y < wh; y++) {
-    const dst = (y0 + y) * mask.width + x0;
-    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
-  }
-  return createSelectionMask(mask.width, mask.height, out);
-}
-
 // src/image-editor/selection/stroke.ts
 function selectionRing(sel, width, location) {
   const half = location === "center" ? width / 2 : width;
@@ -6459,7 +6768,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;
   }
@@ -9663,6 +9972,17 @@ var ImageEditorController = class {
     this.setSelection(region, options.mode ?? "replace");
     return this.state.selection ?? null;
   }
+  /**
+   * Select › Focus Area: selects the parts of the image that are in focus (fine detail above the
+   * image's noise), fitted to its edges, combined with the selection by `mode` as one undo step.
+   * Resolves to the selection and the noise level measured (σ of luminance in levels).
+   */
+  async selectFocusArea(options = {}) {
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const { selection, noiseLevel } = focusArea(pixels, options);
+    this.setSelection(selection, options.mode ?? "replace");
+    return { selection: this.state.selection ?? null, noiseLevel };
+  }
   /**
    * 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)
@@ -9831,11 +10151,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;
@@ -9861,7 +10194,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) {
@@ -11156,7 +11489,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.`);
@@ -11166,7 +11499,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("")}`;
@@ -12550,7 +12883,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_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 SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_object|select_focus_area|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)$/;
@@ -12716,6 +13049,9 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   quickEnhance: false,
   objectSampleAll: true,
   objectEnhance: false,
+  focusRange: 50,
+  focusNoise: 0,
+  focusSoftness: 4,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -13184,6 +13520,33 @@ function createImageSelectionTools(controller) {
       return summary(controller);
     }
   };
+  const selectFocusAreaTool = {
+    name: "select_focus_area",
+    title: "Select the focus area",
+    description: "Select \u203A Focus Area: selects the parts of the image that are in focus (sharp detail, above the image noise), with the edge fitted to the image, combined with the selection by mode. Use it to separate a sharp subject from a blurred background (shallow depth of field), e.g. before blurring or darkening the background. Raise range to take in less sharp areas, raise noise if grain in the background gets selected. One undoable step. Returns the selection and noiseLevel (\u03C3 of the image noise in levels of 255).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        range: { type: "number", minimum: 0, maximum: 100, description: "In-Focus Range 0..100 (default 50): higher takes in less sharp areas too." },
+        noise: { type: "number", minimum: 0, maximum: 100, description: "Image Noise Level 0..100 (default 0): raise it when grain is selected as detail." },
+        softness: { type: "number", minimum: 0, maximum: 100, description: "Soften the edge over this many natural pixels (default 4; 0 for a hard edge)." },
+        mode: modeSchema,
+        sampleAllLayers: { type: "boolean", description: "Read every layer (default true); false reads only the active pixel layer." }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select the focus area", true),
+    handler: async (args) => {
+      const { noiseLevel } = await controller.selectFocusArea({
+        range: args.range === void 0 ? void 0 : num2(args.range, 50),
+        noise: args.noise === void 0 ? void 0 : num2(args.noise, 0),
+        softness: args.softness === void 0 ? void 0 : num2(args.softness, 4),
+        mode: parseSelectionMode(args.mode),
+        sampleAllLayers: args.sampleAllLayers
+      });
+      return { ...summary(controller), noiseLevel };
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -13738,6 +14101,8 @@ function createImageSelectionTools(controller) {
     selectPolygonTool,
     quickSelectTool,
     selectObjectTool,
+    createImageSubjectSelectionTool(controller),
+    selectFocusAreaTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -13774,49 +14139,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
   );
@@ -20450,6 +20816,7 @@ export {
   findAdjustmentControl,
   findLayer,
   findLayerControl,
+  findSubject,
   findWebGpu,
   finishTile,
   fitParagraphRuns,
@@ -20458,6 +20825,7 @@ export {
   flattenPath,
   flipCorners,
   flowField,
+  focusArea,
   followLayerMove,
   fontOf,
   formatControlValue,
@@ -20471,6 +20839,7 @@ export {
   getViewportMetrics,
   getViewportProjection,
   globalImageCache,
+  grabCutLabels,
   gradientDabColor,
   grainCatch,
   grainHeights,
@@ -20562,6 +20931,7 @@ export {
   isTransformAnchor,
   isValidWarp,
   keepDeepSamples,
+  keepMainPieces,
   kelvinToTemperature,
   keysWeight,
   latticeViscosity,
@@ -20674,6 +21044,7 @@ export {
   offsetVectorMask,
   openMaskFile,
   openPsdFile,
+  otsuThreshold,
   packRgba,
   packWetParams,
   paintGradientMappingFor,
@@ -20863,6 +21234,7 @@ export {
   shiftCoverage,
   simplifyPixelPath,
   skinToneRange,
+  slicSuperpixels,
   smartFilterRows,
   smartObjectLayers,
   smoothCoverage,
@@ -20872,6 +21244,7 @@ export {
   snapPolygonToEdges,
   snapTo45,
   snapToEdge,
+  softMaskToSelection,
   solidPaint,
   solidSurface,
   solveMembrane,
@@ -20893,6 +21266,7 @@ export {
   styleAt,
   subpathsToSvgPath,
   sumHistograms,
+  superpixelSaliency,
   surfaceBytes,
   surfaceDepth,
   surfaceFromDeepPixels,
@@ -20985,6 +21359,8 @@ export {
   withImagePlayback,
   withNewIds,
   workImage,
+  workLuma,
+  workPlanes,
   writeAdjustmentBlock,
   writeDeepRegion,
   writeLfx2,