@pixerate/editor 0.199.0 → 0.201.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;
@@ -3690,14 +3692,14 @@ function toLab(r, g, b) {
 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 lab2 = new Float32Array(n * 3);
+  for (let i = 0; i < n; i++) lab2.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]);
+      seeds.push([lab2[i * 3], lab2[i * 3 + 1], lab2[i * 3 + 2], x, y]);
     }
   }
   const k = seeds.length;
@@ -3715,7 +3717,7 @@ function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
       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);
+          const d = (lab2[i * 3] - L) ** 2 + (lab2[i * 3 + 1] - A) ** 2 + (lab2[i * 3 + 2] - B) ** 2 + m2 * ((x - cx) ** 2 + (y - cy) ** 2);
           if (d < best[i]) {
             best[i] = d;
             label[i] = c;
@@ -3726,9 +3728,9 @@ function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
     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] += lab2[i * 3];
+      sum[c * 6 + 1] += lab2[i * 3 + 1];
+      sum[c * 6 + 2] += lab2[i * 3 + 2];
       sum[c * 6 + 3] += i % w;
       sum[c * 6 + 4] += Math.floor(i / w);
       sum[c * 6 + 5]++;
@@ -3746,9 +3748,9 @@ function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
   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];
+    meanLab[c * 3] += lab2[i * 3];
+    meanLab[c * 3 + 1] += lab2[i * 3 + 1];
+    meanLab[c * 3 + 2] += lab2[i * 3 + 2];
     centre[c * 2] += i % w;
     centre[c * 2 + 1] += Math.floor(i / w);
     size[c]++;
@@ -3761,8 +3763,8 @@ function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
   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 { count, lab: lab2, centre, size, label } = sp;
+  const dist = (a, b) => Math.hypot(lab2[a * 3] - lab2[b * 3], lab2[a * 3 + 1] - lab2[b * 3 + 1], lab2[a * 3 + 2] - lab2[b * 3 + 2]);
   const onBorder = new Uint8Array(count);
   for (let x = 0; x < width; x++) {
     onBorder[label[x]] = 1;
@@ -3875,102 +3877,559 @@ function findSubject(pixels, options = {}) {
   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",
-  fill: "#4f46e5",
-  stroke: null,
-  strokeWidth: 2,
+// src/image-editor/selection/refine.ts
+var DEFAULT_REFINE_EDGE_PARAMS = {
   radius: 0,
-  sides: 6,
-  points: 5,
-  innerRatio: 0.5,
-  weight: 4,
-  arrow: false
+  smartRadius: false,
+  smooth: 0,
+  feather: 0,
+  contrast: 0,
+  shiftEdge: 0
 };
-var SHAPE_KIND_LABELS = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
-var DEFAULT_TYPE_TOOL_OPTIONS = { fontFamily: "sans-serif", fontSize: 32, fontWeight: 400, italic: false, color: "#111827", align: "left" };
-function liveShapeForDrag(o, a, b, mods = {}) {
-  if (o.kind === "line") {
-    let x2 = b.x;
-    let y2 = b.y;
-    if (mods.shift) {
-      const ang = Math.round(Math.atan2(b.y - a.y, b.x - a.x) / (Math.PI / 4)) * (Math.PI / 4);
-      const len = Math.hypot(b.x - a.x, b.y - a.y);
-      x2 = a.x + Math.cos(ang) * len;
-      y2 = a.y + Math.sin(ang) * len;
+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);
     }
-    if (Math.hypot(x2 - a.x, y2 - a.y) < 1) return null;
-    const head = o.arrow ? { endArrow: { width: o.weight * 4, length: o.weight * 4 } } : {};
-    return { kind: "line", x1: a.x, y1: a.y, x2, y2, weight: o.weight, ...head };
-  }
-  let w = b.x - a.x;
-  let h = b.y - a.y;
-  if (mods.shift) {
-    const s = Math.max(Math.abs(w), Math.abs(h));
-    w = Math.sign(w || 1) * s;
-    h = Math.sign(h || 1) * s;
   }
-  let x = a.x;
-  let y = a.y;
-  if (mods.alt) {
-    x = a.x - w;
-    y = a.y - h;
-    w *= 2;
-    h *= 2;
+  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);
+    }
   }
-  const box = { x: Math.min(x, x + w), y: Math.min(y, y + h), width: Math.abs(w), height: Math.abs(h) };
-  if (box.width < 1 || box.height < 1) return null;
-  switch (o.kind) {
-    case "rect":
-      return { kind: "rect", ...box, ...o.radius > 0 ? { radius: o.radius } : {} };
-    case "ellipse":
-      return { kind: "ellipse", ...box };
-    case "polygon":
-      return { kind: "polygon", ...box, sides: o.sides };
-    case "star":
-      return { kind: "star", ...box, points: o.points, innerRatio: o.innerRatio };
+  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;
   }
-  return null;
+  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;
 }
-var ShapeDrawGesture = class {
-  constructor(controller, options) {
-    this.controller = controller;
-    this.options = options;
+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);
+    }
   }
-  controller;
-  options;
-  start = null;
-  layerId = null;
-  error = null;
-  get active() {
-    return this.start !== null;
+  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;
+        }
+      }
+    }
   }
-  /** The shape layer drawn by the last drag (until the next one starts). */
-  get drawnLayerId() {
-    return this.layerId;
+  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));
   }
-  down(p) {
-    this.error = null;
-    this.start = { x: p.x, y: p.y };
-    this.layerId = null;
+  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));
   }
-  move(p, mods = {}) {
-    if (!this.start) return;
-    const o = this.options();
-    const shape = liveShapeForDrag(o, this.start, p, mods);
-    if (!shape) return;
-    try {
-      if (!this.layerId) {
-        const isLine = o.kind === "line";
-        this.layerId = this.controller.addShapeLayer({
-          shape,
-          fill: isLine ? o.stroke ?? o.fill ?? "#000000" : o.fill,
-          stroke: !isLine && o.stroke ? { width: o.strokeWidth, paint: o.stroke } : null
-        });
-      } else this.controller.setShapeComponent(this.layerId, 0, { shape }, false);
-    } catch (e) {
-      this.error = e instanceof Error ? e.message : String(e);
+  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/selection/segment/sky.ts
+var SKY_SIZE = 768;
+function lab(r, g, b) {
+  const lin = (v) => {
+    v /= 255;
+    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  };
+  const R = lin(r);
+  const G = lin(g);
+  const B = lin(b);
+  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
+  const x = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047);
+  const y = f(0.2126 * R + 0.7152 * G + 0.0722 * B);
+  const z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
+  return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
+}
+var sigmoid = (v) => 1 / (1 + Math.exp(-v));
+function findSky(pixels, options = {}) {
+  const work = workImage(pixels, SKY_SIZE);
+  const { width: w, height: h, rgb, scale } = work;
+  const n = w * h;
+  const L = new Float32Array(n);
+  const A = new Float32Array(n);
+  const B = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const [l, a, b] = lab(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+    L[i] = l;
+    A[i] = a;
+    B[i] = b;
+  }
+  const luma2 = boxMean(workLuma(work), w, h, 1);
+  const grad = new Float32Array(n);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      const gx = x + 1 < w ? luma2[i + 1] - luma2[i] : 0;
+      const gy = y + 1 < h ? luma2[i + w] - luma2[i] : 0;
+      grad[i] = Math.hypot(gx, gy);
+    }
+  }
+  const roughR = Math.max(1, Math.round(6e-3 * Math.max(w, h)));
+  const rough = boxMean(grad, w, h, roughR);
+  const score = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const chroma = Math.hypot(A[i], B[i]);
+    const blue = sigmoid((-B[i] - 6) / 4) * sigmoid((L[i] - 35) / 6);
+    const grey = sigmoid((L[i] - 68) / 5) * sigmoid((18 - chroma) / 4);
+    const smooth = Math.exp(-rough[i] / 0.02);
+    const y = Math.floor(i / w) / h;
+    const high = 1 - 0.35 * y;
+    score[i] = Math.max(blue, grey) * smooth * high;
+  }
+  const threshold = Math.min(100, Math.max(0, options.threshold ?? 50));
+  const t = 0.55 - (threshold - 50) * 6e-3;
+  const sky = new Uint8Array(n);
+  const stack = [];
+  const seedRows = Math.max(1, Math.round(h * 0.04));
+  for (let y = 0; y < seedRows; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      if (score[i] >= t) {
+        sky[i] = 1;
+        stack.push(i);
+      }
+    }
+  }
+  if (!stack.length) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
+  const low = t * 0.7;
+  while (stack.length) {
+    const p = stack.pop();
+    const x = p % w;
+    for (const q of [x + 1 < w ? p + 1 : -1, x > 0 ? p - 1 : -1, p + w < n ? p + w : -1, p - w]) {
+      if (q < 0 || sky[q] || score[q] < low) continue;
+      if (Math.hypot(L[q] - L[p], A[q] - A[p], B[q] - B[p]) > 6) continue;
+      sky[q] = 1;
+      stack.push(q);
+    }
+  }
+  let count = 0;
+  const mean = [0, 0, 0];
+  for (let i = 0; i < n; i++) {
+    if (!sky[i]) continue;
+    mean[0] += L[i];
+    mean[1] += A[i];
+    mean[2] += B[i];
+    count++;
+  }
+  for (let k = 0; k < 3; k++) mean[k] /= count;
+  let spread = 0;
+  for (let i = 0; i < n; i++) if (sky[i]) spread += (L[i] - mean[0]) ** 2 + (A[i] - mean[1]) ** 2 + (B[i] - mean[2]) ** 2;
+  const limit = Math.max(8, 2.5 * Math.sqrt(spread / count));
+  for (let i = 0; i < n; i++) {
+    if (sky[i] || score[i] < t) continue;
+    if (Math.hypot(L[i] - mean[0], A[i] - mean[1], B[i] - mean[2]) <= limit) sky[i] = 1;
+  }
+  let front = [];
+  for (let i = 0; i < n; i++) if (sky[i]) front.push(i);
+  for (let step = 0; step <= roughR + 1 && front.length; step++) {
+    const next = [];
+    for (const p of front) {
+      const x = p % w;
+      for (const q of [x + 1 < w ? p + 1 : -1, x > 0 ? p - 1 : -1, p + w < n ? p + w : -1, p - w]) {
+        if (q < 0 || sky[q]) continue;
+        if (Math.hypot(L[q] - mean[0], A[q] - mean[1], B[q] - mean[2]) > limit) continue;
+        sky[q] = 1;
+        next.push(q);
+      }
+    }
+    front = next;
+  }
+  if (count < n * 5e-3) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
+  let mask = Float32Array.from(sky);
+  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);
+    mask = new Float32Array(n);
+    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
+  }
+  return { selection: softMaskToSelection(work, mask) };
+}
+
+// src/image-editor/layers/shape-type-ui.ts
+var DEFAULT_SHAPE_TOOL_OPTIONS = {
+  kind: "rect",
+  fill: "#4f46e5",
+  stroke: null,
+  strokeWidth: 2,
+  radius: 0,
+  sides: 6,
+  points: 5,
+  innerRatio: 0.5,
+  weight: 4,
+  arrow: false
+};
+var SHAPE_KIND_LABELS = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
+var DEFAULT_TYPE_TOOL_OPTIONS = { fontFamily: "sans-serif", fontSize: 32, fontWeight: 400, italic: false, color: "#111827", align: "left" };
+function liveShapeForDrag(o, a, b, mods = {}) {
+  if (o.kind === "line") {
+    let x2 = b.x;
+    let y2 = b.y;
+    if (mods.shift) {
+      const ang = Math.round(Math.atan2(b.y - a.y, b.x - a.x) / (Math.PI / 4)) * (Math.PI / 4);
+      const len = Math.hypot(b.x - a.x, b.y - a.y);
+      x2 = a.x + Math.cos(ang) * len;
+      y2 = a.y + Math.sin(ang) * len;
+    }
+    if (Math.hypot(x2 - a.x, y2 - a.y) < 1) return null;
+    const head = o.arrow ? { endArrow: { width: o.weight * 4, length: o.weight * 4 } } : {};
+    return { kind: "line", x1: a.x, y1: a.y, x2, y2, weight: o.weight, ...head };
+  }
+  let w = b.x - a.x;
+  let h = b.y - a.y;
+  if (mods.shift) {
+    const s = Math.max(Math.abs(w), Math.abs(h));
+    w = Math.sign(w || 1) * s;
+    h = Math.sign(h || 1) * s;
+  }
+  let x = a.x;
+  let y = a.y;
+  if (mods.alt) {
+    x = a.x - w;
+    y = a.y - h;
+    w *= 2;
+    h *= 2;
+  }
+  const box = { x: Math.min(x, x + w), y: Math.min(y, y + h), width: Math.abs(w), height: Math.abs(h) };
+  if (box.width < 1 || box.height < 1) return null;
+  switch (o.kind) {
+    case "rect":
+      return { kind: "rect", ...box, ...o.radius > 0 ? { radius: o.radius } : {} };
+    case "ellipse":
+      return { kind: "ellipse", ...box };
+    case "polygon":
+      return { kind: "polygon", ...box, sides: o.sides };
+    case "star":
+      return { kind: "star", ...box, points: o.points, innerRatio: o.innerRatio };
+  }
+  return null;
+}
+var ShapeDrawGesture = class {
+  constructor(controller, options) {
+    this.controller = controller;
+    this.options = options;
+  }
+  controller;
+  options;
+  start = null;
+  layerId = null;
+  error = null;
+  get active() {
+    return this.start !== null;
+  }
+  /** The shape layer drawn by the last drag (until the next one starts). */
+  get drawnLayerId() {
+    return this.layerId;
+  }
+  down(p) {
+    this.error = null;
+    this.start = { x: p.x, y: p.y };
+    this.layerId = null;
+  }
+  move(p, mods = {}) {
+    if (!this.start) return;
+    const o = this.options();
+    const shape = liveShapeForDrag(o, this.start, p, mods);
+    if (!shape) return;
+    try {
+      if (!this.layerId) {
+        const isLine = o.kind === "line";
+        this.layerId = this.controller.addShapeLayer({
+          shape,
+          fill: isLine ? o.stroke ?? o.fill ?? "#000000" : o.fill,
+          stroke: !isLine && o.stroke ? { width: o.strokeWidth, paint: o.stroke } : null
+        });
+      } else this.controller.setShapeComponent(this.layerId, 0, { shape }, false);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
       this.start = null;
     }
   }
@@ -4160,876 +4619,644 @@ var TextEditSession = class {
       case "Home":
         this.move("home", e.shiftKey);
         return true;
-      case "End":
-        this.move("end", e.shiftKey);
-        return true;
-      case "Tab":
-        this.insert("	");
-        return true;
-    }
-    if (!mod2 && !e.altKey && e.key.length >= 1 && [...e.key].length === 1) {
-      this.insert(e.key);
-      return true;
-    }
-    return false;
-  }
-  /** Sets character style fields on the selection, or on the whole text when nothing is selected. */
-  setStyle(style) {
-    const s = this.start;
-    const e = this.end;
-    const range = s === e ? {} : { start: s, end: e };
-    this.run((commit) => this.controller.setTextStyle(this.layerId, style, range, commit));
-  }
-  /** Sets paragraph fields on the paragraphs the selection touches. */
-  setParagraph(style) {
-    const s = this.start;
-    const e = this.end;
-    this.run((commit) => this.controller.setParagraphStyle(this.layerId, style, { start: s, end: e }, commit));
-  }
-  /** The style at the caret (or the selection's start), for the options bar. */
-  styleHere() {
-    const layer = this.layer;
-    const at = this.start > 0 && this.start === this.end ? this.start - 1 : this.start;
-    return styleAt(layer.runs, at, DEFAULT_TEXT_STYLE);
-  }
-  info() {
-    return this.controller.getTextLayer(this.layerId);
-  }
-  /** The caret, the selection and the frame in natural pixels, for `RenderOptions.textEdit`. */
-  overlay() {
-    const layer = this.layer;
-    const layout = this.layout();
-    const m = textMatrix(layer);
-    const at = (x, y) => applyMatrix(m, { x, y });
-    let frame = null;
-    if (layer.frame.kind === "box") frame = [at(0, 0), at(layer.frame.width, 0), at(layer.frame.width, layer.frame.height), at(0, layer.frame.height)];
-    else if (layout) {
-      const b = layout.bounds;
-      frame = [at(b.x, b.y), at(b.x + b.width, b.y), at(b.x + b.width, b.y + b.height), at(b.x, b.y + b.height)];
-    }
-    if (!layout) return { caret: null, selection: [], frame };
-    const selection = textSelectionQuads(layout, this.start, this.end).map((q) => q.map((p) => at(p.x, p.y)));
-    const c = caretAt(layout, this.focus);
-    return { caret: [at(c.from.x, c.from.y), at(c.to.x, c.to.y)], selection, frame };
-  }
-  /** Ends editing: an empty layer made for this session is deleted (as Photoshop does). Returns whether the layer remains. */
-  close() {
-    if (!this.alive) return false;
-    if (!this.text.trim().length) {
-      try {
-        this.controller.removeLayer(this.layerId);
-      } catch {
-      }
-      return false;
-    }
-    if (this.layer.name === "Text" && this.changed) {
-      try {
-        this.controller.setLayerProperties(this.layerId, { name: typeLayerName(this.text) }, false);
-      } catch {
-      }
-    }
-    return true;
-  }
-};
-function typeLayerAt(controller, p, slop = 4) {
-  const layers = [...flattenTypeLayers(controller.getLayers())].reverse();
-  for (const l of layers) {
-    if (!l.visible) continue;
-    const inv = invert(textMatrix(l));
-    const q = applyMatrix(inv, p);
-    let b = null;
-    if (l.frame.kind === "box") b = { x: 0, y: 0, width: l.frame.width, height: l.frame.height };
-    else {
-      const layout = controller.getTextLayout(l.id);
-      if (layout) b = layout.bounds;
-    }
-    if (b && q.x >= b.x - slop && q.x <= b.x + b.width + slop && q.y >= b.y - slop && q.y <= b.y + b.height + slop) return l.id;
-  }
-  return null;
-}
-function flattenTypeLayers(layers) {
-  const out = [];
-  const walk = (list) => {
-    for (const l of list) {
-      if (l.type === "type") out.push(l);
-      else if (l.type === "group") walk(l.children);
-    }
-  };
-  walk(layers);
-  return out;
-}
-function invert(m) {
-  const [a, b, c, d, e, f] = m;
-  const det = a * d - b * c || 1;
-  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
-}
-var TypeToolGesture = class {
-  constructor(controller, options) {
-    this.controller = controller;
-    this.options = options;
-  }
-  controller;
-  options;
-  session = null;
-  dragStart = null;
-  error = null;
-  down(p, mods = {}) {
-    this.error = null;
-    const hit = typeLayerAt(this.controller, p);
-    if (this.session && this.session.alive && hit === this.session.layerId) {
-      this.session.pointAt(p, mods.shift);
-      this.dragStart = null;
-      return;
-    }
-    this.finish();
-    if (hit) {
-      this.controller.setActiveLayer(hit);
-      this.session = new TextEditSession(this.controller, hit, this.controller.textIndexAt(hit, p));
-      this.dragStart = null;
-      return;
-    }
-    this.dragStart = { x: p.x, y: p.y };
-  }
-  /** Releases a click or drag that did not land on type: adds a new text layer (point text, or a box for a drag). */
-  up(p) {
-    const start = this.dragStart;
-    this.dragStart = null;
-    if (!start) return this.session;
-    const o = this.options();
-    const w = Math.abs(p.x - start.x);
-    const h = Math.abs(p.y - start.y);
-    try {
-      const box = w >= 8 && h >= 8 ? { width: w, height: h } : void 0;
-      const id = this.controller.addTextLayer({
-        text: "",
-        x: box ? Math.min(start.x, p.x) : start.x,
-        y: box ? Math.min(start.y, p.y) : start.y,
-        ...box ? { box } : {},
-        style: { fontFamily: o.fontFamily, fontSize: o.fontSize, fontWeight: o.fontWeight, italic: o.italic, color: o.color },
-        paragraph: o.align !== "left" ? { align: o.align } : {},
-        ...o.orientation === "vertical" ? { orientation: "vertical" } : {},
-        name: "Text"
-      });
-      this.session = new TextEditSession(this.controller, id, 0);
-    } catch (e) {
-      this.error = e instanceof Error ? e.message : String(e);
-    }
-    return this.session;
-  }
-  /** Ends the open session (an empty new layer is removed). */
-  finish() {
-    const s = this.session;
-    this.session = null;
-    s?.close();
-  }
-};
-
-// src/image-editor/selection/shapes.ts
-function polygonCoverage(points, width, height, antiAlias = true) {
-  const { box, coverage } = polygonCoverageBox(points, width, height, antiAlias);
-  if (!box || box.width === width && box.height === height) return box ? coverage : new Float32Array(width * height);
-  const m = new Float32Array(width * height);
-  for (let y = 0; y < box.height; y++) m.set(coverage.subarray(y * box.width, (y + 1) * box.width), (box.y + y) * width + box.x);
-  return m;
-}
-function polygonCoverageBox(points, width, height, antiAlias = true) {
-  const none = { box: null, coverage: new Float32Array(0) };
-  if (points.length < 3 || width <= 0 || height <= 0) return none;
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const p of points) {
-    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) continue;
-    minX = Math.min(minX, p.x);
-    minY = Math.min(minY, p.y);
-    maxX = Math.max(maxX, p.x);
-    maxY = Math.max(maxY, p.y);
-  }
-  const bx0 = Math.max(0, Math.floor(minX));
-  const by0 = Math.max(0, Math.floor(minY));
-  const bx1 = Math.min(width, Math.ceil(maxX));
-  const by1 = Math.min(height, Math.ceil(maxY));
-  if (!(bx1 > bx0 && by1 > by0)) return none;
-  const bw = bx1 - bx0;
-  const m = new Float32Array(bw * (by1 - by0));
-  const sub2 = antiAlias ? 4 : 1;
-  const edges = [];
-  for (let i = 0; i < points.length; i++) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    if (![a.x, a.y, b.x, b.y].every(Number.isFinite)) continue;
-    if (a.y < b.y) edges.push({ top: a.y, bottom: b.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
-    else if (b.y < a.y) edges.push({ top: b.y, bottom: a.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
-  }
-  edges.sort((p, q) => p.top - q.top);
-  let next = 0;
-  let active = [];
-  const xs = [];
-  for (let py = by0; py < by1; py++) {
-    const row = (py - by0) * bw - bx0;
-    for (let s = 0; s < sub2; s++) {
-      const y = py + (s + 0.5) / sub2;
-      while (next < edges.length && edges[next].top <= y) active.push(edges[next++]);
-      if (active.length) active = active.filter((e) => e.bottom > y);
-      if (!active.length) continue;
-      xs.length = 0;
-      for (const e of active) {
-        if (e.top <= y) xs.push(e.ax + (y - e.ay) / (e.by - e.ay) * (e.bx - e.ax));
-      }
-      xs.sort((a, b) => a - b);
-      for (let k = 0; k + 1 < xs.length; k += 2) {
-        const x0 = Math.max(0, xs[k]);
-        const x1 = Math.min(width, xs[k + 1]);
-        if (x1 <= x0) continue;
-        const c0 = Math.floor(x0);
-        const c1 = Math.min(width, Math.ceil(x1));
-        for (let cx = c0; cx < c1; cx++) {
-          let cov;
-          if (antiAlias) cov = Math.min(cx + 1, x1) - Math.max(cx, x0);
-          else {
-            const c = cx + 0.5;
-            cov = c >= x0 && c < x1 ? 1 : 0;
-          }
-          if (cov > 0) m[row + cx] += cov / sub2;
-        }
-      }
-    }
-  }
-  for (let i = 0; i < m.length; i++) if (m[i] > 1) m[i] = 1;
-  return { box: { x: bx0, y: by0, width: bw, height: by1 - by0 }, coverage: m };
-}
-function polygonSelection(width, height, points, options = {}) {
-  const { box, coverage } = polygonCoverageBox(points, width, height, options.antiAlias ?? true);
-  if (!box) return createSelectionMask(width, height);
-  const out = new Uint8Array(coverage.length);
-  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
-  return selectionFromRegion(width, height, box, out);
-}
-function normalizeRect(rect) {
-  const x = rect.width < 0 ? rect.x + rect.width : rect.x;
-  const y = rect.height < 0 ? rect.y + rect.height : rect.y;
-  return { x, y, width: Math.abs(rect.width), height: Math.abs(rect.height) };
-}
-function rectSelection(width, height, rect, options = {}) {
-  const r = normalizeRect(rect);
-  const pts = [
-    { x: r.x, y: r.y },
-    { x: r.x + r.width, y: r.y },
-    { x: r.x + r.width, y: r.y + r.height },
-    { x: r.x, y: r.y + r.height }
-  ];
-  return polygonSelection(width, height, pts, options);
-}
-function ellipsePoints(rect) {
-  const r = normalizeRect(rect);
-  const rx = r.width / 2;
-  const ry = r.height / 2;
-  const cx = r.x + rx;
-  const cy = r.y + ry;
-  const rmax = Math.max(rx, ry, 0.5);
-  const step = Math.sqrt(0.4 / rmax);
-  const n = Math.min(4096, Math.max(16, Math.ceil(2 * Math.PI / step)));
-  const pts = [];
-  for (let i = 0; i < n; i++) {
-    const t = i / n * 2 * Math.PI;
-    pts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });
-  }
-  return pts;
-}
-function ellipseSelection(width, height, rect, options = {}) {
-  return polygonSelection(width, height, ellipsePoints(rect), options);
-}
-
-// src/image-editor/selection/wand.ts
-function checkPixels(p) {
-  const n = p.width * p.height;
-  if (!Number.isInteger(p.width) || !Number.isInteger(p.height) || p.width < 1 || p.height < 1) {
-    throw new Error("Invalid pixel buffer size");
-  }
-  if (p.data.length < n * 4) throw new Error("Pixel data is shorter than width \xD7 height \xD7 4");
-  return n;
-}
-var SRGB_TO_LINEAR2 = (() => {
-  const t = new Float32Array(256);
-  for (let i = 0; i < 256; i++) {
-    const v = i / 255;
-    t[i] = v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-  }
-  return t;
-})();
-var labF = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
-function srgb8ToLab(r, g, b) {
-  const rl = SRGB_TO_LINEAR2[r & 255];
-  const gl = SRGB_TO_LINEAR2[g & 255];
-  const bl = SRGB_TO_LINEAR2[b & 255];
-  const x = (0.4124564 * rl + 0.3575761 * gl + 0.1804375 * bl) / 0.95047;
-  const y = 0.2126729 * rl + 0.7151522 * gl + 0.072175 * bl;
-  const z = (0.0193339 * rl + 0.119192 * gl + 0.9503041 * bl) / 1.08883;
-  const fx = labF(x);
-  const fy = labF(y);
-  const fz = labF(z);
-  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
-}
-function similarity(pixels, seed, tolerance, distance) {
-  const d = pixels.data;
-  const tr = d[seed * 4];
-  const tg = d[seed * 4 + 1];
-  const tb = d[seed * 4 + 2];
-  const ta = d[seed * 4 + 3];
-  const tol = Math.max(0, Math.floor(tolerance + 1e-3));
-  if (distance === "perceptual") {
-    const [tl, taa, tbb] = srgb8ToLab(tr, tg, tb);
-    const de = Math.max(0, tolerance) * 100 / 255;
-    const de2 = de * de + 1e-6;
-    return (i) => {
-      const p = i * 4;
-      const a = d[p + 3];
-      if (ta === 0 && a === 0) return true;
-      if (Math.abs(a - ta) > tol) return false;
-      const [l, aa, bb] = srgb8ToLab(d[p], d[p + 1], d[p + 2]);
-      return (l - tl) ** 2 + (aa - taa) ** 2 + (bb - tbb) ** 2 <= de2;
-    };
-  }
-  return (i) => {
-    const p = i * 4;
-    const a = d[p + 3];
-    if (ta === 0 && a === 0) return true;
-    return Math.abs(d[p] - tr) <= tol && Math.abs(d[p + 1] - tg) <= tol && Math.abs(d[p + 2] - tb) <= tol && Math.abs(a - ta) <= tol;
-  };
-}
-function antialiasMarks(marks, w, h, x0, y0, x1, y1) {
-  const out = marks.slice();
-  for (let y = y0; y < y1; y++) {
-    for (let x = x0; x < x1; x++) {
-      const i = y * w + x;
-      const v = marks[i];
-      let sum = 0;
-      let edge = false;
-      for (let dy = -1; dy <= 1; dy++) {
-        const ny = y + dy;
-        for (let dx = -1; dx <= 1; dx++) {
-          const nx = x + dx;
-          const n = nx < 0 || ny < 0 || nx >= w || ny >= h ? v : marks[ny * w + nx];
-          if (n !== v) edge = true;
-          sum += n;
-        }
-      }
-      if (edge) {
-        const avg = sum / (9 * 255);
-        out[i] = Math.round((v > 127 ? 0.5 + 0.5 * avg : 0.5 * avg) * 255);
-      }
-    }
-  }
-  return out;
-}
-function magicWand(pixels, seed, options = {}) {
-  const n = checkPixels(pixels);
-  const { width: w, height: h } = pixels;
-  const sx = Math.floor(seed.x);
-  const sy = Math.floor(seed.y);
-  if (!(sx >= 0 && sy >= 0 && sx < w && sy < h)) return createSelectionMask(w, h);
-  const similar = similarity(pixels, sy * w + sx, options.tolerance ?? 32, options.distance ?? "rgb");
-  const marks = new Uint8Array(n);
-  let bx0 = w;
-  let by0 = h;
-  let bx1 = -1;
-  let by1 = -1;
-  if (options.contiguous ?? true) {
-    const stack = [sy * w + sx];
-    while (stack.length) {
-      const idx = stack.pop();
-      if (marks[idx]) continue;
-      const y = idx / w | 0;
-      const row = y * w;
-      let l = idx - row;
-      let r = l;
-      while (l > 0 && !marks[row + l - 1] && similar(row + l - 1)) l--;
-      while (r + 1 < w && !marks[row + r + 1] && similar(row + r + 1)) r++;
-      marks.fill(255, row + l, row + r + 1);
-      if (l < bx0) bx0 = l;
-      if (r > bx1) bx1 = r;
-      if (y < by0) by0 = y;
-      if (y > by1) by1 = y;
-      for (const ny of [y - 1, y + 1]) {
-        if (ny < 0 || ny >= h) continue;
-        const nrow = ny * w;
-        let inRun = false;
-        for (let nx = l; nx <= r; nx++) {
-          const ok = !marks[nrow + nx] && similar(nrow + nx);
-          if (ok && !inRun) stack.push(nrow + nx);
-          inRun = ok;
-        }
-      }
-    }
-  } else {
-    for (let y = 0; y < h; y++) {
-      const row = y * w;
-      for (let x = 0; x < w; x++) {
-        if (similar(row + x)) {
-          marks[row + x] = 255;
-          if (x < bx0) bx0 = x;
-          if (x > bx1) bx1 = x;
-          if (y < by0) by0 = y;
-          if (y > by1) by1 = y;
-        }
-      }
+      case "End":
+        this.move("end", e.shiftKey);
+        return true;
+      case "Tab":
+        this.insert("	");
+        return true;
+    }
+    if (!mod2 && !e.altKey && e.key.length >= 1 && [...e.key].length === 1) {
+      this.insert(e.key);
+      return true;
     }
+    return false;
   }
-  if (bx1 < 0) return createSelectionMask(w, h);
-  if (!(options.antiAlias ?? true)) return createSelectionMask(w, h, marks);
-  return createSelectionMask(
-    w,
-    h,
-    antialiasMarks(marks, w, h, Math.max(0, bx0 - 1), Math.max(0, by0 - 1), Math.min(w, bx1 + 2), Math.min(h, by1 + 2))
-  );
-}
-function sampleColor(c) {
-  if (typeof c === "string") {
-    const m = /^#?([0-9a-f]{6})$/i.exec(c.trim());
-    if (!m) throw new Error(`Invalid colour "${c}"`);
-    const v = parseInt(m[1], 16);
-    return [v >> 16 & 255, v >> 8 & 255, v & 255];
+  /** Sets character style fields on the selection, or on the whole text when nothing is selected. */
+  setStyle(style) {
+    const s = this.start;
+    const e = this.end;
+    const range = s === e ? {} : { start: s, end: e };
+    this.run((commit) => this.controller.setTextStyle(this.layerId, style, range, commit));
   }
-  return [c[0], c[1], c[2]];
-}
-function colorRange(pixels, samples, options = {}) {
-  const n = checkPixels(pixels);
-  const { width: w, height: h, data } = pixels;
-  const f = Math.max(0, options.fuzziness ?? 40) + 1;
-  const parsed = samples.map((s) => ({ c: sampleColor(s.color), at: s.at }));
-  const radius = options.localized !== void 0 ? Math.max(1, options.localized) : void 0;
-  const out = new Uint8Array(n);
-  if (!parsed.length) return createSelectionMask(w, h, out);
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    if (data[p + 3] <= 0) continue;
-    const x = i % w;
-    const y = (i - x) / w;
-    let best = 0;
-    for (const s of parsed) {
-      const d = Math.max(Math.abs(data[p] - s.c[0]), Math.abs(data[p + 1] - s.c[1]), Math.abs(data[p + 2] - s.c[2]));
-      let k = Math.min(1, Math.max(0, 1 - d / f));
-      if (k > 0 && radius !== void 0 && s.at) {
-        const dist = Math.hypot(x - s.at.x, y - s.at.y);
-        k *= Math.min(1, Math.max(0, 1 - dist / radius));
+  /** Sets paragraph fields on the paragraphs the selection touches. */
+  setParagraph(style) {
+    const s = this.start;
+    const e = this.end;
+    this.run((commit) => this.controller.setParagraphStyle(this.layerId, style, { start: s, end: e }, commit));
+  }
+  /** The style at the caret (or the selection's start), for the options bar. */
+  styleHere() {
+    const layer = this.layer;
+    const at = this.start > 0 && this.start === this.end ? this.start - 1 : this.start;
+    return styleAt(layer.runs, at, DEFAULT_TEXT_STYLE);
+  }
+  info() {
+    return this.controller.getTextLayer(this.layerId);
+  }
+  /** The caret, the selection and the frame in natural pixels, for `RenderOptions.textEdit`. */
+  overlay() {
+    const layer = this.layer;
+    const layout = this.layout();
+    const m = textMatrix(layer);
+    const at = (x, y) => applyMatrix(m, { x, y });
+    let frame = null;
+    if (layer.frame.kind === "box") frame = [at(0, 0), at(layer.frame.width, 0), at(layer.frame.width, layer.frame.height), at(0, layer.frame.height)];
+    else if (layout) {
+      const b = layout.bounds;
+      frame = [at(b.x, b.y), at(b.x + b.width, b.y), at(b.x + b.width, b.y + b.height), at(b.x, b.y + b.height)];
+    }
+    if (!layout) return { caret: null, selection: [], frame };
+    const selection = textSelectionQuads(layout, this.start, this.end).map((q) => q.map((p) => at(p.x, p.y)));
+    const c = caretAt(layout, this.focus);
+    return { caret: [at(c.from.x, c.from.y), at(c.to.x, c.to.y)], selection, frame };
+  }
+  /** Ends editing: an empty layer made for this session is deleted (as Photoshop does). Returns whether the layer remains. */
+  close() {
+    if (!this.alive) return false;
+    if (!this.text.trim().length) {
+      try {
+        this.controller.removeLayer(this.layerId);
+      } catch {
       }
-      if (k > best) best = k;
+      return false;
     }
-    out[i] = coverageToByte(best);
+    if (this.layer.name === "Text" && this.changed) {
+      try {
+        this.controller.setLayerProperties(this.layerId, { name: typeLayerName(this.text) }, false);
+      } catch {
+      }
+    }
+    return true;
   }
-  return createSelectionMask(w, h, out);
-}
-var TONE_RANGE_PRESETS = {
-  shadows: [0, 65],
-  midtones: [105, 150],
-  highlights: [190, 255]
 };
-function toneRange(pixels, range, falloff = 20) {
-  const n = checkPixels(pixels);
-  const [lo, hi] = typeof range === "string" ? TONE_RANGE_PRESETS[range] : range;
-  const ramp2 = Math.max(1e-3, falloff);
-  const out = new Uint8Array(n);
-  const d = pixels.data;
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    if (d[p + 3] <= 0) continue;
-    const l = Math.min(255, Math.max(0, 0.299 * d[p] + 0.587 * d[p + 1] + 0.114 * d[p + 2]));
-    const outside = l < lo ? lo - l : l > hi ? l - hi : 0;
-    out[i] = coverageToByte(1 - outside / ramp2);
-  }
-  return createSelectionMask(pixels.width, pixels.height, out);
-}
-function hueRange(pixels, center) {
-  const n = checkPixels(pixels);
-  const out = new Uint8Array(n);
-  const d = pixels.data;
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    if (d[p + 3] <= 0) continue;
-    const r = d[p] / 255;
-    const g = d[p + 1] / 255;
-    const b = d[p + 2] / 255;
-    const mx = Math.max(r, g, b);
-    const mn = Math.min(r, g, b);
-    const chroma = mx - mn;
-    if (chroma <= 0) continue;
-    let hue;
-    if (mx === r) hue = ((g - b) / chroma % 6 + 6) % 6;
-    else if (mx === g) hue = (b - r) / chroma + 2;
-    else hue = (r - g) / chroma + 4;
-    hue *= 60;
-    let dh = ((hue - center) % 360 + 360) % 360;
-    dh = Math.min(dh, 360 - dh);
-    out[i] = coverageToByte(Math.min(1, Math.max(0, 1 - dh / 60)) * chroma * (2 - mx));
+function typeLayerAt(controller, p, slop = 4) {
+  const layers = [...flattenTypeLayers(controller.getLayers())].reverse();
+  for (const l of layers) {
+    if (!l.visible) continue;
+    const inv = invert(textMatrix(l));
+    const q = applyMatrix(inv, p);
+    let b = null;
+    if (l.frame.kind === "box") b = { x: 0, y: 0, width: l.frame.width, height: l.frame.height };
+    else {
+      const layout = controller.getTextLayout(l.id);
+      if (layout) b = layout.bounds;
+    }
+    if (b && q.x >= b.x - slop && q.x <= b.x + b.width + slop && q.y >= b.y - slop && q.y <= b.y + b.height + slop) return l.id;
   }
-  return createSelectionMask(pixels.width, pixels.height, out);
-}
-var HUE_RANGE_PRESETS = { reds: 0, yellows: 60, greens: 120, cyans: 180, blues: 240, magentas: 300 };
-var COLOR_RANGE_PRESETS = [
-  ...Object.keys(HUE_RANGE_PRESETS),
-  "highlights",
-  "midtones",
-  "shadows",
-  "skinTones"
-];
-function isColorRangePreset(v) {
-  return typeof v === "string" && COLOR_RANGE_PRESETS.includes(v);
+  return null;
 }
-var ramp = (v, lo, hi, soft) => v < lo ? Math.max(0, 1 - (lo - v) / soft) : v > hi ? Math.max(0, 1 - (v - hi) / soft) : 1;
-function skinToneRange(pixels) {
-  const n = checkPixels(pixels);
-  const out = new Uint8Array(n);
-  const d = pixels.data;
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    if (d[p + 3] <= 0) continue;
-    const r = d[p] / 255;
-    const g = d[p + 1] / 255;
-    const b = d[p + 2] / 255;
-    const mx = Math.max(r, g, b);
-    const mn = Math.min(r, g, b);
-    const chroma = mx - mn;
-    if (chroma <= 0 || mx <= 0) continue;
-    let hue;
-    if (mx === r) hue = ((g - b) / chroma % 6 + 6) % 6;
-    else if (mx === g) hue = (b - r) / chroma + 2;
-    else hue = (r - g) / chroma + 4;
-    hue *= 60;
-    if (hue > 180) hue -= 360;
-    const k = ramp(hue, 5, 40, 20) * ramp(chroma / mx, 0.12, 0.8, 0.1) * ramp(mx, 0.3, 1, 0.15);
-    out[i] = coverageToByte(k);
-  }
-  return createSelectionMask(pixels.width, pixels.height, out);
+function flattenTypeLayers(layers) {
+  const out = [];
+  const walk = (list) => {
+    for (const l of list) {
+      if (l.type === "type") out.push(l);
+      else if (l.type === "group") walk(l.children);
+    }
+  };
+  walk(layers);
+  return out;
 }
-function colorRangePreset(pixels, preset, options = {}) {
-  if (preset === "skinTones") return skinToneRange(pixels);
-  if (preset === "highlights" || preset === "midtones" || preset === "shadows") return toneRange(pixels, preset, options.falloff ?? 20);
-  if (preset in HUE_RANGE_PRESETS) return hueRange(pixels, HUE_RANGE_PRESETS[preset]);
-  throw new Error(`Unknown Color Range preset "${String(preset)}". Use one of ${COLOR_RANGE_PRESETS.join(", ")}.`);
+function invert(m) {
+  const [a, b, c, d, e, f] = m;
+  const det = a * d - b * c || 1;
+  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
 }
-function selectedColorBins(pixels, sel, tolerance) {
-  const S = 64;
-  let bins = new Uint8Array(S * S * S);
-  const d = pixels.data;
-  const n = pixels.width * pixels.height;
-  for (let i = 0; i < n; i++) {
-    if (sel.data[i] < 128 || d[i * 4 + 3] === 0) continue;
-    bins[((d[i * 4] >> 2) * S + (d[i * 4 + 1] >> 2)) * S + (d[i * 4 + 2] >> 2)] = 1;
+var TypeToolGesture = class {
+  constructor(controller, options) {
+    this.controller = controller;
+    this.options = options;
   }
-  const r = Math.round(Math.max(0, tolerance) / 4);
-  if (r === 0) return bins;
-  for (const stride of [1, S, S * S]) {
-    const out = new Uint8Array(bins.length);
-    for (let i = 0; i < bins.length; i++) {
-      if (!bins[i]) continue;
-      const c = Math.floor(i / stride) % S;
-      const lo = Math.max(0, c - r);
-      const hi = Math.min(S - 1, c + r);
-      const base = i - c * stride;
-      for (let k = lo; k <= hi; k++) out[base + k * stride] = 1;
+  controller;
+  options;
+  session = null;
+  dragStart = null;
+  error = null;
+  down(p, mods = {}) {
+    this.error = null;
+    const hit = typeLayerAt(this.controller, p);
+    if (this.session && this.session.alive && hit === this.session.layerId) {
+      this.session.pointAt(p, mods.shift);
+      this.dragStart = null;
+      return;
+    }
+    this.finish();
+    if (hit) {
+      this.controller.setActiveLayer(hit);
+      this.session = new TextEditSession(this.controller, hit, this.controller.textIndexAt(hit, p));
+      this.dragStart = null;
+      return;
     }
-    bins = out;
+    this.dragStart = { x: p.x, y: p.y };
   }
-  return bins;
-}
-function matcher(pixels, sel, options) {
-  if (sel.width !== pixels.width || sel.height !== pixels.height) throw new Error("The selection and the pixels differ in size");
-  const bins = selectedColorBins(pixels, sel, options.tolerance ?? 32);
-  const d = pixels.data;
-  return (i) => d[i * 4 + 3] > 0 && bins[((d[i * 4] >> 2 << 6) + (d[i * 4 + 1] >> 2)) * 64 + (d[i * 4 + 2] >> 2)] === 1;
-}
-function growSelection(pixels, sel, options = {}) {
-  checkPixels(pixels);
-  const match = matcher(pixels, sel, options);
-  const { width: w, height: h } = pixels;
-  const out = new Uint8Array(sel.data);
-  const stack = [];
-  for (let i = 0; i < out.length; i++) if (out[i] >= 128) stack.push(i);
-  while (stack.length) {
-    const i = stack.pop();
-    const x = i % w;
-    const y = (i - x) / w;
-    const visit = (j) => {
-      if (out[j] < 255 && match(j)) {
-        out[j] = 255;
-        stack.push(j);
-      }
-    };
-    if (x > 0) visit(i - 1);
-    if (x < w - 1) visit(i + 1);
-    if (y > 0) visit(i - w);
-    if (y < h - 1) visit(i + w);
+  /** Releases a click or drag that did not land on type: adds a new text layer (point text, or a box for a drag). */
+  up(p) {
+    const start = this.dragStart;
+    this.dragStart = null;
+    if (!start) return this.session;
+    const o = this.options();
+    const w = Math.abs(p.x - start.x);
+    const h = Math.abs(p.y - start.y);
+    try {
+      const box = w >= 8 && h >= 8 ? { width: w, height: h } : void 0;
+      const id = this.controller.addTextLayer({
+        text: "",
+        x: box ? Math.min(start.x, p.x) : start.x,
+        y: box ? Math.min(start.y, p.y) : start.y,
+        ...box ? { box } : {},
+        style: { fontFamily: o.fontFamily, fontSize: o.fontSize, fontWeight: o.fontWeight, italic: o.italic, color: o.color },
+        paragraph: o.align !== "left" ? { align: o.align } : {},
+        ...o.orientation === "vertical" ? { orientation: "vertical" } : {},
+        name: "Text"
+      });
+      this.session = new TextEditSession(this.controller, id, 0);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+    }
+    return this.session;
   }
-  return createSelectionMask(w, h, out);
-}
-function selectSimilar(pixels, sel, options = {}) {
-  const n = checkPixels(pixels);
-  const match = matcher(pixels, sel, options);
-  const out = new Uint8Array(sel.data);
-  for (let i = 0; i < n; i++) if (match(i)) out[i] = 255;
-  return createSelectionMask(pixels.width, pixels.height, out);
-}
+  /** Ends the open session (an empty new layer is removed). */
+  finish() {
+    const s = this.session;
+    this.session = null;
+    s?.close();
+  }
+};
 
-// src/image-editor/selection/segmentation.ts
-var isPoint = (p) => !!p && typeof p === "object" && Number.isFinite(p.x) && Number.isFinite(p.y);
-function segmentationOutlines(result) {
-  const p = result.polygon;
-  if (!Array.isArray(p) || !p.length) return [];
-  const rings = Array.isArray(p[0]) ? p : [p];
-  return rings.map((ring) => Array.isArray(ring) ? ring.filter(isPoint) : []).filter((ring) => ring.length >= 3);
+// src/image-editor/selection/shapes.ts
+function polygonCoverage(points, width, height, antiAlias = true) {
+  const { box, coverage } = polygonCoverageBox(points, width, height, antiAlias);
+  if (!box || box.width === width && box.height === height) return box ? coverage : new Float32Array(width * height);
+  const m = new Float32Array(width * height);
+  for (let y = 0; y < box.height; y++) m.set(coverage.subarray(y * box.width, (y + 1) * box.width), (box.y + y) * width + box.x);
+  return m;
 }
-function segmentToSelection(width, height, result) {
-  let out = null;
-  for (const ring of segmentationOutlines(result)) {
-    out = combineSelections(out, polygonSelection(width, height, ring), "add");
+function polygonCoverageBox(points, width, height, antiAlias = true) {
+  const none = { box: null, coverage: new Float32Array(0) };
+  if (points.length < 3 || width <= 0 || height <= 0) return none;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of points) {
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) continue;
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
   }
-  if (result.mask && result.mask.width > 0 && result.mask.height > 0) {
-    const raw = selectionFromPixels(result.mask, { channel: "luminance" });
-    const sized = raw.width === width && raw.height === height ? raw : resizeSelection(raw, width, height);
-    out = combineSelections(out, sized, "add");
+  const bx0 = Math.max(0, Math.floor(minX));
+  const by0 = Math.max(0, Math.floor(minY));
+  const bx1 = Math.min(width, Math.ceil(maxX));
+  const by1 = Math.min(height, Math.ceil(maxY));
+  if (!(bx1 > bx0 && by1 > by0)) return none;
+  const bw = bx1 - bx0;
+  const m = new Float32Array(bw * (by1 - by0));
+  const sub2 = antiAlias ? 4 : 1;
+  const edges = [];
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    if (![a.x, a.y, b.x, b.y].every(Number.isFinite)) continue;
+    if (a.y < b.y) edges.push({ top: a.y, bottom: b.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
+    else if (b.y < a.y) edges.push({ top: b.y, bottom: a.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
   }
-  return out?.bounds ? out : null;
-}
-function segmentsToSelection(width, height, results) {
-  let out = null;
-  for (const r of results) {
-    const sel = segmentToSelection(width, height, r);
-    if (sel) out = combineSelections(out, sel, "add");
+  edges.sort((p, q) => p.top - q.top);
+  let next = 0;
+  let active = [];
+  const xs = [];
+  for (let py = by0; py < by1; py++) {
+    const row = (py - by0) * bw - bx0;
+    for (let s = 0; s < sub2; s++) {
+      const y = py + (s + 0.5) / sub2;
+      while (next < edges.length && edges[next].top <= y) active.push(edges[next++]);
+      if (active.length) active = active.filter((e) => e.bottom > y);
+      if (!active.length) continue;
+      xs.length = 0;
+      for (const e of active) {
+        if (e.top <= y) xs.push(e.ax + (y - e.ay) / (e.by - e.ay) * (e.bx - e.ax));
+      }
+      xs.sort((a, b) => a - b);
+      for (let k = 0; k + 1 < xs.length; k += 2) {
+        const x0 = Math.max(0, xs[k]);
+        const x1 = Math.min(width, xs[k + 1]);
+        if (x1 <= x0) continue;
+        const c0 = Math.floor(x0);
+        const c1 = Math.min(width, Math.ceil(x1));
+        for (let cx = c0; cx < c1; cx++) {
+          let cov;
+          if (antiAlias) cov = Math.min(cx + 1, x1) - Math.max(cx, x0);
+          else {
+            const c = cx + 0.5;
+            cov = c >= x0 && c < x1 ? 1 : 0;
+          }
+          if (cov > 0) m[row + cx] += cov / sub2;
+        }
+      }
+    }
   }
-  return out;
+  for (let i = 0; i < m.length; i++) if (m[i] > 1) m[i] = 1;
+  return { box: { x: bx0, y: by0, width: bw, height: by1 - by0 }, coverage: m };
 }
-
-// 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)))
-  };
+function polygonSelection(width, height, points, options = {}) {
+  const { box, coverage } = polygonCoverageBox(points, width, height, options.antiAlias ?? true);
+  if (!box) return createSelectionMask(width, height);
+  const out = new Uint8Array(coverage.length);
+  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
+  return selectionFromRegion(width, height, box, out);
 }
-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 normalizeRect(rect) {
+  const x = rect.width < 0 ? rect.x + rect.width : rect.x;
+  const y = rect.height < 0 ? rect.y + rect.height : rect.y;
+  return { x, y, width: Math.abs(rect.width), height: Math.abs(rect.height) };
 }
-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 rectSelection(width, height, rect, options = {}) {
+  const r = normalizeRect(rect);
+  const pts = [
+    { x: r.x, y: r.y },
+    { x: r.x + r.width, y: r.y },
+    { x: r.x + r.width, y: r.y + r.height },
+    { x: r.x, y: r.y + r.height }
+  ];
+  return polygonSelection(width, height, pts, options);
 }
-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);
-    }
+function ellipsePoints(rect) {
+  const r = normalizeRect(rect);
+  const rx = r.width / 2;
+  const ry = r.height / 2;
+  const cx = r.x + rx;
+  const cy = r.y + ry;
+  const rmax = Math.max(rx, ry, 0.5);
+  const step = Math.sqrt(0.4 / rmax);
+  const n = Math.min(4096, Math.max(16, Math.ceil(2 * Math.PI / step)));
+  const pts = [];
+  for (let i = 0; i < n; i++) {
+    const t = i / n * 2 * Math.PI;
+    pts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });
   }
-  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 pts;
+}
+function ellipseSelection(width, height, rect, options = {}) {
+  return polygonSelection(width, height, ellipsePoints(rect), options);
+}
+
+// src/image-editor/selection/wand.ts
+function checkPixels(p) {
+  const n = p.width * p.height;
+  if (!Number.isInteger(p.width) || !Number.isInteger(p.height) || p.width < 1 || p.height < 1) {
+    throw new Error("Invalid pixel buffer size");
   }
-  return out;
+  if (p.data.length < n * 4) throw new Error("Pixel data is shorter than width \xD7 height \xD7 4");
+  return n;
 }
-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;
+var SRGB_TO_LINEAR2 = (() => {
+  const t = new Float32Array(256);
+  for (let i = 0; i < 256; i++) {
+    const v = i / 255;
+    t[i] = v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
   }
-  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;
+  return t;
+})();
+var labF = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
+function srgb8ToLab(r, g, b) {
+  const rl = SRGB_TO_LINEAR2[r & 255];
+  const gl = SRGB_TO_LINEAR2[g & 255];
+  const bl = SRGB_TO_LINEAR2[b & 255];
+  const x = (0.4124564 * rl + 0.3575761 * gl + 0.1804375 * bl) / 0.95047;
+  const y = 0.2126729 * rl + 0.7151522 * gl + 0.072175 * bl;
+  const z = (0.0193339 * rl + 0.119192 * gl + 0.9503041 * bl) / 1.08883;
+  const fx = labF(x);
+  const fy = labF(y);
+  const fz = labF(z);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
 }
-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);
+function similarity(pixels, seed, tolerance, distance) {
+  const d = pixels.data;
+  const tr = d[seed * 4];
+  const tg = d[seed * 4 + 1];
+  const tb = d[seed * 4 + 2];
+  const ta = d[seed * 4 + 3];
+  const tol = Math.max(0, Math.floor(tolerance + 1e-3));
+  if (distance === "perceptual") {
+    const [tl, taa, tbb] = srgb8ToLab(tr, tg, tb);
+    const de = Math.max(0, tolerance) * 100 / 255;
+    const de2 = de * de + 1e-6;
+    return (i) => {
+      const p = i * 4;
+      const a = d[p + 3];
+      if (ta === 0 && a === 0) return true;
+      if (Math.abs(a - ta) > tol) return false;
+      const [l, aa, bb] = srgb8ToLab(d[p], d[p + 1], d[p + 2]);
+      return (l - tl) ** 2 + (aa - taa) ** 2 + (bb - tbb) ** 2 <= de2;
+    };
+  }
+  return (i) => {
+    const p = i * 4;
+    const a = d[p + 3];
+    if (ta === 0 && a === 0) return true;
+    return Math.abs(d[p] - tr) <= tol && Math.abs(d[p + 1] - tg) <= tol && Math.abs(d[p + 2] - tb) <= tol && Math.abs(a - ta) <= tol;
+  };
+}
+function antialiasMarks(marks, w, h, x0, y0, x1, y1) {
+  const out = marks.slice();
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      const i = y * w + x;
+      const v = marks[i];
+      let sum = 0;
+      let edge = false;
+      for (let dy = -1; dy <= 1; dy++) {
+        const ny = y + dy;
+        for (let dx = -1; dx <= 1; dx++) {
+          const nx = x + dx;
+          const n = nx < 0 || ny < 0 || nx >= w || ny >= h ? v : marks[ny * w + nx];
+          if (n !== v) edge = true;
+          sum += n;
+        }
+      }
+      if (edge) {
+        const avg = sum / (9 * 255);
+        out[i] = Math.round((v > 127 ? 0.5 + 0.5 * avg : 0.5 * avg) * 255);
+      }
     }
   }
-  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;
+function magicWand(pixels, seed, options = {}) {
+  const n = checkPixels(pixels);
+  const { width: w, height: h } = pixels;
+  const sx = Math.floor(seed.x);
+  const sy = Math.floor(seed.y);
+  if (!(sx >= 0 && sy >= 0 && sx < w && sy < h)) return createSelectionMask(w, h);
+  const similar = similarity(pixels, sy * w + sx, options.tolerance ?? 32, options.distance ?? "rgb");
+  const marks = new Uint8Array(n);
+  let bx0 = w;
+  let by0 = h;
+  let bx1 = -1;
+  let by1 = -1;
+  if (options.contiguous ?? true) {
+    const stack = [sy * w + sx];
+    while (stack.length) {
+      const idx = stack.pop();
+      if (marks[idx]) continue;
+      const y = idx / w | 0;
+      const row = y * w;
+      let l = idx - row;
+      let r = l;
+      while (l > 0 && !marks[row + l - 1] && similar(row + l - 1)) l--;
+      while (r + 1 < w && !marks[row + r + 1] && similar(row + r + 1)) r++;
+      marks.fill(255, row + l, row + r + 1);
+      if (l < bx0) bx0 = l;
+      if (r > bx1) bx1 = r;
+      if (y < by0) by0 = y;
+      if (y > by1) by1 = y;
+      for (const ny of [y - 1, y + 1]) {
+        if (ny < 0 || ny >= h) continue;
+        const nrow = ny * w;
+        let inRun = false;
+        for (let nx = l; nx <= r; nx++) {
+          const ok = !marks[nrow + nx] && similar(nrow + nx);
+          if (ok && !inRun) stack.push(nrow + nx);
+          inRun = ok;
+        }
+      }
+    }
+  } else {
     for (let y = 0; y < h; y++) {
+      const row = y * w;
       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 (similar(row + x)) {
+          marks[row + x] = 255;
+          if (x < bx0) bx0 = x;
+          if (x > bx1) bx1 = x;
+          if (y < by0) by0 = y;
+          if (y > by1) by1 = y;
         }
       }
     }
-    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;
-        }
+  }
+  if (bx1 < 0) return createSelectionMask(w, h);
+  if (!(options.antiAlias ?? true)) return createSelectionMask(w, h, marks);
+  return createSelectionMask(
+    w,
+    h,
+    antialiasMarks(marks, w, h, Math.max(0, bx0 - 1), Math.max(0, by0 - 1), Math.min(w, bx1 + 2), Math.min(h, by1 + 2))
+  );
+}
+function sampleColor(c) {
+  if (typeof c === "string") {
+    const m = /^#?([0-9a-f]{6})$/i.exec(c.trim());
+    if (!m) throw new Error(`Invalid colour "${c}"`);
+    const v = parseInt(m[1], 16);
+    return [v >> 16 & 255, v >> 8 & 255, v & 255];
+  }
+  return [c[0], c[1], c[2]];
+}
+function colorRange(pixels, samples, options = {}) {
+  const n = checkPixels(pixels);
+  const { width: w, height: h, data } = pixels;
+  const f = Math.max(0, options.fuzziness ?? 40) + 1;
+  const parsed = samples.map((s) => ({ c: sampleColor(s.color), at: s.at }));
+  const radius = options.localized !== void 0 ? Math.max(1, options.localized) : void 0;
+  const out = new Uint8Array(n);
+  if (!parsed.length) return createSelectionMask(w, h, out);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (data[p + 3] <= 0) continue;
+    const x = i % w;
+    const y = (i - x) / w;
+    let best = 0;
+    for (const s of parsed) {
+      const d = Math.max(Math.abs(data[p] - s.c[0]), Math.abs(data[p + 1] - s.c[1]), Math.abs(data[p + 2] - s.c[2]));
+      let k = Math.min(1, Math.max(0, 1 - d / f));
+      if (k > 0 && radius !== void 0 && s.at) {
+        const dist = Math.hypot(x - s.at.x, y - s.at.y);
+        k *= Math.min(1, Math.max(0, 1 - dist / radius));
       }
+      if (k > best) best = k;
     }
+    out[i] = coverageToByte(best);
   }
-  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));
+  return createSelectionMask(w, h, out);
+}
+var TONE_RANGE_PRESETS = {
+  shadows: [0, 65],
+  midtones: [105, 150],
+  highlights: [190, 255]
+};
+function toneRange(pixels, range, falloff = 20) {
+  const n = checkPixels(pixels);
+  const [lo, hi] = typeof range === "string" ? TONE_RANGE_PRESETS[range] : range;
+  const ramp2 = Math.max(1e-3, falloff);
+  const out = new Uint8Array(n);
+  const d = pixels.data;
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (d[p + 3] <= 0) continue;
+    const l = Math.min(255, Math.max(0, 0.299 * d[p] + 0.587 * d[p + 1] + 0.114 * d[p + 2]));
+    const outside = l < lo ? lo - l : l > hi ? l - hi : 0;
+    out[i] = coverageToByte(1 - outside / ramp2);
   }
-  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));
+  return createSelectionMask(pixels.width, pixels.height, out);
+}
+function hueRange(pixels, center) {
+  const n = checkPixels(pixels);
+  const out = new Uint8Array(n);
+  const d = pixels.data;
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (d[p + 3] <= 0) continue;
+    const r = d[p] / 255;
+    const g = d[p + 1] / 255;
+    const b = d[p + 2] / 255;
+    const mx = Math.max(r, g, b);
+    const mn = Math.min(r, g, b);
+    const chroma = mx - mn;
+    if (chroma <= 0) continue;
+    let hue;
+    if (mx === r) hue = ((g - b) / chroma % 6 + 6) % 6;
+    else if (mx === g) hue = (b - r) / chroma + 2;
+    else hue = (r - g) / chroma + 4;
+    hue *= 60;
+    let dh = ((hue - center) % 360 + 360) % 360;
+    dh = Math.min(dh, 360 - dh);
+    out[i] = coverageToByte(Math.min(1, Math.max(0, 1 - dh / 60)) * chroma * (2 - mx));
   }
-  const amount = shiftAmount(p);
-  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
-  return a;
+  return createSelectionMask(pixels.width, pixels.height, out);
 }
-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);
+var HUE_RANGE_PRESETS = { reds: 0, yellows: 60, greens: 120, cyans: 180, blues: 240, magentas: 300 };
+var COLOR_RANGE_PRESETS = [
+  ...Object.keys(HUE_RANGE_PRESETS),
+  "highlights",
+  "midtones",
+  "shadows",
+  "skinTones"
+];
+function isColorRangePreset(v) {
+  return typeof v === "string" && COLOR_RANGE_PRESETS.includes(v);
+}
+var ramp = (v, lo, hi, soft) => v < lo ? Math.max(0, 1 - (lo - v) / soft) : v > hi ? Math.max(0, 1 - (v - hi) / soft) : 1;
+function skinToneRange(pixels) {
+  const n = checkPixels(pixels);
+  const out = new Uint8Array(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;
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (d[p + 3] <= 0) continue;
+    const r = d[p] / 255;
+    const g = d[p + 1] / 255;
+    const b = d[p + 2] / 255;
+    const mx = Math.max(r, g, b);
+    const mn = Math.min(r, g, b);
+    const chroma = mx - mn;
+    if (chroma <= 0 || mx <= 0) continue;
+    let hue;
+    if (mx === r) hue = ((g - b) / chroma % 6 + 6) % 6;
+    else if (mx === g) hue = (b - r) / chroma + 2;
+    else hue = (r - g) / chroma + 4;
+    hue *= 60;
+    if (hue > 180) hue -= 360;
+    const k = ramp(hue, 5, 40, 20) * ramp(chroma / mx, 0.12, 0.8, 0.1) * ramp(mx, 0.3, 1, 0.15);
+    out[i] = coverageToByte(k);
+  }
+  return createSelectionMask(pixels.width, pixels.height, out);
+}
+function colorRangePreset(pixels, preset, options = {}) {
+  if (preset === "skinTones") return skinToneRange(pixels);
+  if (preset === "highlights" || preset === "midtones" || preset === "shadows") return toneRange(pixels, preset, options.falloff ?? 20);
+  if (preset in HUE_RANGE_PRESETS) return hueRange(pixels, HUE_RANGE_PRESETS[preset]);
+  throw new Error(`Unknown Color Range preset "${String(preset)}". Use one of ${COLOR_RANGE_PRESETS.join(", ")}.`);
+}
+function selectedColorBins(pixels, sel, tolerance) {
+  const S = 64;
+  let bins = new Uint8Array(S * S * S);
+  const d = pixels.data;
+  const n = pixels.width * pixels.height;
+  for (let i = 0; i < n; i++) {
+    if (sel.data[i] < 128 || d[i * 4 + 3] === 0) continue;
+    bins[((d[i * 4] >> 2) * S + (d[i * 4 + 1] >> 2)) * S + (d[i * 4 + 2] >> 2)] = 1;
+  }
+  const r = Math.round(Math.max(0, tolerance) / 4);
+  if (r === 0) return bins;
+  for (const stride of [1, S, S * S]) {
+    const out = new Uint8Array(bins.length);
+    for (let i = 0; i < bins.length; i++) {
+      if (!bins[i]) continue;
+      const c = Math.floor(i / stride) % S;
+      const lo = Math.max(0, c - r);
+      const hi = Math.min(S - 1, c + r);
+      const base = i - c * stride;
+      for (let k = lo; k <= hi; k++) out[base + k * stride] = 1;
     }
+    bins = out;
   }
-  return [r, g, b];
+  return bins;
 }
-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");
+function matcher(pixels, sel, options) {
+  if (sel.width !== pixels.width || sel.height !== pixels.height) throw new Error("The selection and the pixels differ in size");
+  const bins = selectedColorBins(pixels, sel, options.tolerance ?? 32);
+  const d = pixels.data;
+  return (i) => d[i * 4 + 3] > 0 && bins[((d[i * 4] >> 2 << 6) + (d[i * 4 + 1] >> 2)) * 64 + (d[i * 4 + 2] >> 2)] === 1;
+}
+function growSelection(pixels, sel, options = {}) {
+  checkPixels(pixels);
+  const match = matcher(pixels, sel, options);
+  const { width: w, height: h } = pixels;
+  const out = new Uint8Array(sel.data);
+  const stack = [];
+  for (let i = 0; i < out.length; i++) if (out[i] >= 128) stack.push(i);
+  while (stack.length) {
+    const i = stack.pop();
+    const x = i % w;
+    const y = (i - x) / w;
+    const visit = (j) => {
+      if (out[j] < 255 && match(j)) {
+        out[j] = 255;
+        stack.push(j);
+      }
+    };
+    if (x > 0) visit(i - 1);
+    if (x < w - 1) visit(i + 1);
+    if (y > 0) visit(i - w);
+    if (y < h - 1) visit(i + w);
   }
-  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;
+  return createSelectionMask(w, h, out);
+}
+function selectSimilar(pixels, sel, options = {}) {
+  const n = checkPixels(pixels);
+  const match = matcher(pixels, sel, options);
+  const out = new Uint8Array(sel.data);
+  for (let i = 0; i < n; i++) if (match(i)) out[i] = 255;
+  return createSelectionMask(pixels.width, pixels.height, out);
+}
+
+// src/image-editor/selection/segmentation.ts
+var isPoint = (p) => !!p && typeof p === "object" && Number.isFinite(p.x) && Number.isFinite(p.y);
+function segmentationOutlines(result) {
+  const p = result.polygon;
+  if (!Array.isArray(p) || !p.length) return [];
+  const rings = Array.isArray(p[0]) ? p : [p];
+  return rings.map((ring) => Array.isArray(ring) ? ring.filter(isPoint) : []).filter((ring) => ring.length >= 3);
+}
+function segmentToSelection(width, height, result) {
+  let out = null;
+  for (const ring of segmentationOutlines(result)) {
+    out = combineSelections(out, polygonSelection(width, height, ring), "add");
   }
-  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]);
+  if (result.mask && result.mask.width > 0 && result.mask.height > 0) {
+    const raw = selectionFromPixels(result.mask, { channel: "luminance" });
+    const sized = raw.width === width && raw.height === height ? raw : resizeSelection(raw, width, height);
+    out = combineSelections(out, sized, "add");
   }
-  return createSelectionMask(mask.width, mask.height, out);
+  return out?.bounds ? out : null;
+}
+function segmentsToSelection(width, height, results) {
+  let out = null;
+  for (const r of results) {
+    const sel = segmentToSelection(width, height, r);
+    if (sel) out = combineSelections(out, sel, "add");
+  }
+  return out;
 }
 
 // src/image-editor/selection/stroke.ts
@@ -5836,10 +6063,10 @@ function colorModePlanes(doc, mode) {
   }
   const t = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
   return (rgba, n) => {
-    const lab = new Uint8Array(n * 4);
-    t.convert8(rgba, 4, lab, 4, false);
+    const lab2 = new Uint8Array(n * 4);
+    t.convert8(rgba, 4, lab2, 4, false);
     const planes = [0, 1, 2].map(() => new Uint8Array(n));
-    for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = lab[i * 4 + c];
+    for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = lab2[i * 4 + c];
     return planes;
   };
 }
@@ -9866,6 +10093,30 @@ 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 };
+  }
+  /**
+   * Select › Sky: selects the sky (blue, or bright and grey when overcast; smooth; grown down from
+   * the top of the image, with patches seen through gaps), fitted to its edges, combined with the
+   * selection by `mode` as one undo step. Resolves to the selection and, when no sky was found
+   * (the selection is then unchanged), why.
+   */
+  async selectSky(options = {}) {
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const { selection, reason } = findSky(pixels, options);
+    if (!selection.bounds) return { selection: this.state.selection ?? null, note: reason };
+    this.setSelection(selection, options.mode ?? "replace");
+    return { selection: 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)
@@ -11383,8 +11634,8 @@ var ImageEditorController = class {
       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);
       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 };
+      const lab2 = [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: lab2 };
       if (dst.colorSpace === "rgb") res.hex = `#${values.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("")}`;
       return res;
     });
@@ -12766,7 +13017,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_sky|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)$/;
@@ -12932,6 +13183,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"
@@ -13400,6 +13654,58 @@ 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 selectSkyTool = {
+    name: "select_sky",
+    title: "Select the sky",
+    description: "Select \u203A Sky: selects the sky (blue, or bright and grey when overcast, smooth, reaching down from the top of the image, including patches seen through branches or gaps), with the edge fitted to the skyline, combined with the selection by mode. Use it to replace or recolour a sky or to adjust the land without it (invert_selection). Raise threshold to take in haze or a sunset glow, lower it if bright buildings come in. One undoable step. Returns the selection, and a note when no sky was found (the selection is then unchanged).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        threshold: { type: "number", minimum: 0, maximum: 100, description: "How sky-like a pixel must be, 0..100 (default 50): higher takes in less sky-like pixels." },
+        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 sky", true),
+    handler: async (args) => {
+      const { note } = await controller.selectSky({
+        threshold: args.threshold === void 0 ? void 0 : num2(args.threshold, 50),
+        softness: args.softness === void 0 ? void 0 : num2(args.softness, 4),
+        mode: parseSelectionMode(args.mode),
+        sampleAllLayers: args.sampleAllLayers
+      });
+      return { ...summary(controller), ...note ? { note } : {} };
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -13955,6 +14261,8 @@ function createImageSelectionTools(controller) {
     quickSelectTool,
     selectObjectTool,
     createImageSubjectSelectionTool(controller),
+    selectFocusAreaTool,
+    selectSkyTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -20668,6 +20976,7 @@ export {
   findAdjustmentControl,
   findLayer,
   findLayerControl,
+  findSky,
   findSubject,
   findWebGpu,
   finishTile,
@@ -20677,6 +20986,7 @@ export {
   flattenPath,
   flipCorners,
   flowField,
+  focusArea,
   followLayerMove,
   fontOf,
   formatControlValue,
@@ -21095,6 +21405,7 @@ export {
   snapPolygonToEdges,
   snapTo45,
   snapToEdge,
+  softMaskToSelection,
   solidPaint,
   solidSurface,
   solveMembrane,
@@ -21209,6 +21520,8 @@ export {
   withImagePlayback,
   withNewIds,
   workImage,
+  workLuma,
+  workPlanes,
   writeAdjustmentBlock,
   writeDeepRegion,
   writeLfx2,