@pixerate/editor 0.23.0 → 0.25.0

package/dist/image-editor/index.js

@@ -1,3 +1,7 @@
+import {
+  loadDocument
+} from "../chunk-U5HZSFCS.js";
+
 // src/image-editor/color.ts
 var LEGACY_PROCESS_VERSION = 1;
 var LATEST_PROCESS_VERSION = 2;
@@ -231,284 +235,232 @@ function sampleToneLut(lut, headroom, y) {
   return lut[i] + (lut[i + 1] - lut[i]) * (f - i);
 }
 
-// src/image-editor/filters.ts
-function clamp(value, min = 0, max = 255) {
-  return Math.max(min, Math.min(max, value));
+// src/image-editor/blend.ts
+var BLEND_MODES = [
+  { id: "normal", label: "Normal", canvas: "source-over" },
+  { id: "darken", label: "Darken", canvas: "darken" },
+  { id: "multiply", label: "Multiply", canvas: "multiply" },
+  { id: "color-burn", label: "Color Burn", canvas: "color-burn" },
+  { id: "linear-burn", label: "Linear Burn", canvas: null },
+  { id: "darker-color", label: "Darker Color", canvas: null },
+  { id: "lighten", label: "Lighten", canvas: "lighten" },
+  { id: "screen", label: "Screen", canvas: "screen" },
+  { id: "color-dodge", label: "Color Dodge", canvas: "color-dodge" },
+  { id: "linear-dodge", label: "Linear Dodge (Add)", canvas: null },
+  { id: "lighter-color", label: "Lighter Color", canvas: null },
+  { id: "overlay", label: "Overlay", canvas: "overlay" },
+  // Canvas soft-light is the W3C formula, not Photoshop's: use the scalar path.
+  { id: "soft-light", label: "Soft Light", canvas: null },
+  { id: "hard-light", label: "Hard Light", canvas: "hard-light" },
+  { id: "vivid-light", label: "Vivid Light", canvas: null },
+  { id: "linear-light", label: "Linear Light", canvas: null },
+  { id: "pin-light", label: "Pin Light", canvas: null },
+  { id: "hard-mix", label: "Hard Mix", canvas: null },
+  { id: "difference", label: "Difference", canvas: "difference" },
+  { id: "exclusion", label: "Exclusion", canvas: "exclusion" },
+  { id: "subtract", label: "Subtract", canvas: null },
+  { id: "divide", label: "Divide", canvas: null },
+  { id: "hue", label: "Hue", canvas: "hue" },
+  { id: "saturation", label: "Saturation", canvas: "saturation" },
+  { id: "color", label: "Color", canvas: "color" },
+  { id: "luminosity", label: "Luminosity", canvas: "luminosity" }
+];
+var BLEND_INFO = new Map(BLEND_MODES.map((m) => [m.id, m]));
+function isBlendMode(value) {
+  return typeof value === "string" && BLEND_INFO.has(value);
 }
-function applyAdjustments(imageData, adjustments) {
-  if (normalizeProcessVersion(adjustments.process) === LATEST_PROCESS_VERSION) {
-    applyProcess2Adjustments(imageData, adjustments);
-  } else {
-    applyLegacyAdjustments(imageData, adjustments);
+function normalizeBlendMode(value) {
+  return isBlendMode(value) ? value : "normal";
+}
+function canvasCompositeOperation(mode) {
+  return BLEND_INFO.get(mode ?? "normal")?.canvas ?? null;
+}
+function isSeparableBlendMode(mode) {
+  return !(mode === "hue" || mode === "saturation" || mode === "color" || mode === "luminosity" || mode === "darker-color" || mode === "lighter-color");
+}
+function colorBurn(cb, cs) {
+  if (cb >= 1) return 1;
+  if (cs <= 0) return 0;
+  return 1 - Math.min(1, (1 - cb) / cs);
+}
+function colorDodge(cb, cs) {
+  if (cb <= 0) return 0;
+  if (cs >= 1) return 1;
+  return Math.min(1, cb / (1 - cs));
+}
+function hardLight(cb, cs) {
+  if (cs <= 0.5) return cb * 2 * cs;
+  const s = 2 * cs - 1;
+  return cb + s - cb * s;
+}
+function softLight(cb, cs) {
+  return cs <= 0.5 ? 2 * cb * cs + cb * cb * (1 - 2 * cs) : 2 * cb * (1 - cs) + Math.sqrt(Math.max(0, cb)) * (2 * cs - 1);
+}
+function vividLightHardMix(cb, cs) {
+  const EDGE = 1e-4;
+  if (cs <= 0.5) {
+    if (cb >= 1 - EDGE) return 1;
+    if (cs <= 0) return 0;
+    return 1 - Math.min(1, (1 - cb) / (2 * cs));
   }
-  if (adjustments.blur > 0) {
-    applyFastBoxBlur(imageData, Math.min(Math.round(adjustments.blur), 40));
+  if (cb <= EDGE) return 0;
+  if (cs >= 1) return 1;
+  return Math.min(1, cb / (2 * (1 - cs)));
+}
+function blendChannel(mode, cb, cs) {
+  switch (mode) {
+    case "normal":
+      return cs;
+    case "darken":
+      return Math.min(cb, cs);
+    case "multiply":
+      return cb * cs;
+    case "color-burn":
+      return colorBurn(cb, cs);
+    case "linear-burn":
+      return Math.max(0, cb + cs - 1);
+    case "lighten":
+      return Math.max(cb, cs);
+    case "screen":
+      return cb + cs - cb * cs;
+    case "color-dodge":
+      return colorDodge(cb, cs);
+    case "linear-dodge":
+      return Math.min(1, cb + cs);
+    case "overlay":
+      return hardLight(cs, cb);
+    case "soft-light":
+      return softLight(cb, cs);
+    case "hard-light":
+      return hardLight(cb, cs);
+    case "vivid-light":
+      if (cs <= 0) return 0;
+      if (cs >= 1) return 1;
+      return cs <= 0.5 ? colorBurn(cb, 2 * cs) : colorDodge(cb, 2 * (cs - 0.5));
+    case "linear-light":
+      return Math.min(1, Math.max(0, cb + 2 * cs - 1));
+    case "pin-light":
+      return cs <= 0.5 ? Math.min(cb, 2 * cs) : Math.max(cb, 2 * cs - 1);
+    case "hard-mix":
+      return vividLightHardMix(cb, cs) >= 0.5 - 1e-6 ? 1 : 0;
+    case "difference":
+      return Math.abs(cb - cs);
+    case "exclusion":
+      return cb + cs - 2 * cb * cs;
+    case "subtract":
+      return Math.max(0, cb - cs);
+    case "divide":
+      if (cs <= 0) return cb <= 0 ? 0 : 1;
+      return Math.min(1, cb / cs);
+    default:
+      return cs;
   }
 }
-function applyLegacyAdjustments(imageData, adjustments) {
-  const { brightness, contrast, saturation, exposure, temperature, opacity } = adjustments;
-  const data = imageData.data;
-  const len = data.length;
-  const hasBrightness = brightness !== 0;
-  const hasContrast = contrast !== 0;
-  const hasSaturation = saturation !== 0;
-  const hasExposure = exposure !== 0;
-  const hasTemperature = temperature !== 0;
-  const hasOpacity = opacity < 1;
-  const contrastFactor = hasContrast ? 259 * (contrast + 255) / (255 * (259 - contrast)) : 1;
-  const exposureMultiplier = hasExposure ? Math.pow(2, exposure / 50) : 1;
-  const satMultiplier = hasSaturation ? 1 + saturation / 100 : 1;
-  const tempOffset = hasTemperature ? temperature * 0.8 : 0;
-  if (hasBrightness || hasContrast || hasSaturation || hasExposure || hasTemperature || hasOpacity) {
-    for (let i = 0; i < len; i += 4) {
-      let r = data[i];
-      let g = data[i + 1];
-      let b = data[i + 2];
-      let a = data[i + 3];
-      if (hasExposure) {
-        r = clamp(r * exposureMultiplier);
-        g = clamp(g * exposureMultiplier);
-        b = clamp(b * exposureMultiplier);
-      }
-      if (hasBrightness) {
-        const bOffset = brightness * 2.55;
-        r = clamp(r + bOffset);
-        g = clamp(g + bOffset);
-        b = clamp(b + bOffset);
-      }
-      if (hasContrast) {
-        r = clamp(contrastFactor * (r - 128) + 128);
-        g = clamp(contrastFactor * (g - 128) + 128);
-        b = clamp(contrastFactor * (b - 128) + 128);
-      }
-      if (hasSaturation) {
-        const luminance = 0.2989 * r + 0.587 * g + 0.114 * b;
-        r = clamp(luminance + (r - luminance) * satMultiplier);
-        g = clamp(luminance + (g - luminance) * satMultiplier);
-        b = clamp(luminance + (b - luminance) * satMultiplier);
-      }
-      if (hasTemperature) {
-        r = clamp(r + tempOffset);
-        b = clamp(b - tempOffset);
-      }
-      if (hasOpacity) {
-        a = clamp(a * opacity);
-      }
-      data[i] = r;
-      data[i + 1] = g;
-      data[i + 2] = b;
-      data[i + 3] = a;
-    }
+function blendLum(c) {
+  return 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2];
+}
+function clipColor(c) {
+  const l = blendLum(c);
+  const n = Math.min(c[0], c[1], c[2]);
+  const x = Math.max(c[0], c[1], c[2]);
+  let out = [c[0], c[1], c[2]];
+  if (n < 0) {
+    const d = l - n;
+    out = out.map((v) => l > 0 && d > 0 ? l + (v - l) * l / d : l);
   }
+  if (x > 1) {
+    const d = x - l;
+    out = out.map((v) => l < 1 && d > 0 ? l + (v - l) * (1 - l) / d : l);
+  }
+  return out;
 }
-var DECODE_LUT = (() => {
-  const lut = new Float32Array(256);
-  for (let i = 0; i < 256; i++) lut[i] = srgbToLinear(i / 255);
-  return lut;
-})();
-var ENCODE_LUT_SIZE = 65535;
-var encodeLut = null;
-function getEncodeLut() {
-  if (!encodeLut) {
-    encodeLut = new Uint8Array(ENCODE_LUT_SIZE + 1);
-    for (let i = 0; i <= ENCODE_LUT_SIZE; i++) {
-      encodeLut[i] = Math.round(linearToSrgb(i / ENCODE_LUT_SIZE) * 255);
-    }
+function setLum(c, l) {
+  const d = l - blendLum(c);
+  return clipColor([c[0] + d, c[1] + d, c[2] + d]);
+}
+function sat(c) {
+  return Math.max(c[0], c[1], c[2]) - Math.min(c[0], c[1], c[2]);
+}
+function setSat(c, s) {
+  const idx = [0, 1, 2].sort((a, b) => c[a] - c[b]);
+  const [imin, imid, imax] = idx;
+  const out = [0, 0, 0];
+  if (c[imax] > c[imin]) {
+    out[imid] = (c[imid] - c[imin]) * s / (c[imax] - c[imin]);
+    out[imax] = s;
   }
-  return encodeLut;
+  out[imin] = 0;
+  return out;
 }
-var cachedPlan = null;
-function getProcess2Plan(adjustments) {
-  const exposure = adjustments.exposure || 0;
-  const temperature = adjustments.temperature || 0;
-  const tint = adjustments.tint || 0;
-  const contrast = adjustments.contrast || 0;
-  const brightness = adjustments.brightness || 0;
-  const saturation = 1 + (adjustments.saturation || 0) / 100;
-  const key = `${exposure},${temperature},${tint},${contrast},${brightness},${saturation}`;
-  if (cachedPlan && cachedPlan.key === key) return cachedPlan;
-  const gain = Math.pow(2, exposure / 50);
-  const wb = whiteBalanceMatrix(temperature, tint);
-  const m = new Float64Array(9);
-  for (let i = 0; i < 9; i++) m[i] = wb[i] * gain;
-  const luts = [];
-  const scale = [0, 0, 0];
-  for (let c = 0; c < 3; c++) {
-    let reach = 0;
-    for (let k = 0; k < 3; k++) reach += Math.max(0, m[c * 3 + k]);
-    const headroom = Math.max(1, reach);
-    luts[c] = buildToneLut(contrast, brightness, headroom);
-    scale[c] = TONE_LUT_SIZE / headroom;
+function blendRgb(mode, cb, cs) {
+  switch (mode) {
+    case "hue":
+      return setLum(setSat(cs, sat(cb)), blendLum(cb));
+    case "saturation":
+      return setLum(setSat(cb, sat(cs)), blendLum(cb));
+    case "color":
+      return setLum(cs, blendLum(cb));
+    case "luminosity":
+      return setLum(cb, blendLum(cs));
+    case "darker-color":
+      return blendLum(cs) < blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];
+    case "lighter-color":
+      return blendLum(cs) > blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];
+    default:
+      return [blendChannel(mode, cb[0], cs[0]), blendChannel(mode, cb[1], cs[1]), blendChannel(mode, cb[2], cs[2])];
   }
-  cachedPlan = { key, m, luts, scale, saturation };
-  return cachedPlan;
 }
-function applyProcess2Adjustments(imageData, adjustments) {
-  const data = imageData.data;
-  const len = data.length;
-  const opacity = adjustments.opacity ?? 1;
-  const hasOpacity = opacity < 1;
-  const hasColor = !!adjustments.brightness || !!adjustments.contrast || !!adjustments.saturation || !!adjustments.exposure || !!adjustments.temperature || !!adjustments.tint;
-  if (!hasColor) {
-    if (hasOpacity) {
-      for (let i = 3; i < len; i += 4) data[i] = clamp(data[i] * opacity);
-    }
-    return;
+function blendPixel(mode, backdrop, source, alpha = 1) {
+  const ab = backdrop[3] ?? 1;
+  const as = (source[3] ?? 1) * alpha;
+  if (!(as > 0)) return [backdrop[0], backdrop[1], backdrop[2], ab];
+  const b = blendRgb(mode, backdrop, source);
+  const ao = as + ab * (1 - as);
+  if (ao <= 0) return [0, 0, 0, 0];
+  const out = [0, 0, 0, ao];
+  for (let i = 0; i < 3; i++) {
+    out[i] = ((1 - as) * ab * backdrop[i] + (1 - ab) * as * source[i] + as * ab * b[i]) / ao;
   }
-  const plan = getProcess2Plan(adjustments);
-  const dec = DECODE_LUT;
-  const enc = getEncodeLut();
-  const { m, luts, scale, saturation } = plan;
-  const m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7], m8 = m[8];
-  const lutR = luts[0], lutG = luts[1], lutB = luts[2];
-  const sR = scale[0], sG = scale[1], sB = scale[2];
-  const N = TONE_LUT_SIZE;
-  const hasSaturation = saturation !== 1;
-  const wr = LUMA_709[0], wg = LUMA_709[1], wb = LUMA_709[2];
+  return out;
+}
+function blendImageData(backdrop, source, mode, alpha = 1) {
+  const d = backdrop.data;
+  const s = source.data;
+  const len = Math.min(d.length, s.length);
+  const cb = [0, 0, 0, 0];
+  const cs = [0, 0, 0, 0];
   for (let i = 0; i < len; i += 4) {
-    const r0 = dec[data[i]];
-    const g0 = dec[data[i + 1]];
-    const b0 = dec[data[i + 2]];
-    let r = m0 * r0 + m1 * g0 + m2 * b0;
-    let g = m3 * r0 + m4 * g0 + m5 * b0;
-    let b = m6 * r0 + m7 * g0 + m8 * b0;
-    let f;
-    let k;
-    if (r <= 0) r = lutR[0];
-    else if ((f = r * sR) >= N) r = lutR[N];
-    else {
-      k = f | 0;
-      r = lutR[k] + (lutR[k + 1] - lutR[k]) * (f - k);
-    }
-    if (g <= 0) g = lutG[0];
-    else if ((f = g * sG) >= N) g = lutG[N];
-    else {
-      k = f | 0;
-      g = lutG[k] + (lutG[k + 1] - lutG[k]) * (f - k);
+    if (s[i + 3] === 0) continue;
+    for (let k = 0; k < 4; k++) {
+      cb[k] = d[i + k] / 255;
+      cs[k] = s[i + k] / 255;
     }
-    if (b <= 0) b = lutB[0];
-    else if ((f = b * sB) >= N) b = lutB[N];
-    else {
-      k = f | 0;
-      b = lutB[k] + (lutB[k + 1] - lutB[k]) * (f - k);
-    }
-    if (hasSaturation) {
-      const y = wr * r + wg * g + wb * b;
-      r = y + (r - y) * saturation;
-      g = y + (g - y) * saturation;
-      b = y + (b - y) * saturation;
-    }
-    data[i] = enc[r <= 0 ? 0 : r >= 1 ? ENCODE_LUT_SIZE : r * ENCODE_LUT_SIZE + 0.5 | 0];
-    data[i + 1] = enc[g <= 0 ? 0 : g >= 1 ? ENCODE_LUT_SIZE : g * ENCODE_LUT_SIZE + 0.5 | 0];
-    data[i + 2] = enc[b <= 0 ? 0 : b >= 1 ? ENCODE_LUT_SIZE : b * ENCODE_LUT_SIZE + 0.5 | 0];
-    if (hasOpacity) data[i + 3] = clamp(data[i + 3] * opacity);
+    const o = blendPixel(mode, cb, cs, alpha);
+    d[i] = Math.round(o[0] * 255);
+    d[i + 1] = Math.round(o[1] * 255);
+    d[i + 2] = Math.round(o[2] * 255);
+    d[i + 3] = Math.round(o[3] * 255);
   }
 }
-function applyFastBoxBlur(imageData, radius) {
-  if (radius < 1) return;
-  const w = imageData.width;
-  const h = imageData.height;
-  const src = imageData.data;
-  const temp = new Uint8ClampedArray(src.length);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      let r = 0, g = 0, b = 0, a = 0;
-      let count = 0;
-      for (let k = -radius; k <= radius; k++) {
-        const px = Math.min(w - 1, Math.max(0, x + k));
-        const idx = (y * w + px) * 4;
-        r += src[idx];
-        g += src[idx + 1];
-        b += src[idx + 2];
-        a += src[idx + 3];
-        count++;
-      }
-      const dstIdx = (y * w + x) * 4;
-      temp[dstIdx] = Math.round(r / count);
-      temp[dstIdx + 1] = Math.round(g / count);
-      temp[dstIdx + 2] = Math.round(b / count);
-      temp[dstIdx + 3] = Math.round(a / count);
-    }
-  }
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) {
-      let r = 0, g = 0, b = 0, a = 0;
-      let count = 0;
-      for (let k = -radius; k <= radius; k++) {
-        const py = Math.min(h - 1, Math.max(0, y + k));
-        const idx = (py * w + x) * 4;
-        r += temp[idx];
-        g += temp[idx + 1];
-        b += temp[idx + 2];
-        a += temp[idx + 3];
-        count++;
-      }
-      const dstIdx = (y * w + x) * 4;
-      src[dstIdx] = Math.round(r / count);
-      src[dstIdx + 1] = Math.round(g / count);
-      src[dstIdx + 2] = Math.round(b / count);
-      src[dstIdx + 3] = Math.round(a / count);
-    }
-  }
-}
-function applyDepthMask(mainImageData, maskImageData, options) {
-  const { mode, depthRange, softness, invert } = options;
-  const mainData = mainImageData.data;
-  const maskData = maskImageData.data;
-  const len = Math.min(mainData.length, maskData.length);
-  const effectiveSoftness = Math.max(1, softness || 10);
-  const minDepth = depthRange[0];
-  const maxDepth = depthRange[1];
-  for (let i = 0; i < len; i += 4) {
-    let maskValue = maskData[i];
-    if (invert) {
-      maskValue = 255 - maskValue;
-    }
-    let alphaValue;
-    if (mode === "threshold") {
-      if (maskValue >= maxDepth + effectiveSoftness) {
-        alphaValue = 0;
-      } else if (maskValue > maxDepth) {
-        alphaValue = Math.round((maxDepth + effectiveSoftness - maskValue) / effectiveSoftness * 255);
-      } else if (maskValue >= minDepth) {
-        alphaValue = 255;
-      } else if (maskValue < minDepth - effectiveSoftness) {
-        alphaValue = 0;
-      } else {
-        alphaValue = Math.round((maskValue - (minDepth - effectiveSoftness)) / effectiveSoftness * 255);
-      }
-    } else {
-      alphaValue = clamp(maskValue + minDepth);
-    }
-    mainData[i + 3] = clamp(mainData[i + 3] * alphaValue / 255);
-  }
-}
-function removeAlpha(imageData) {
-  const data = imageData.data;
-  const len = data.length;
-  for (let i = 3; i < len; i += 4) {
-    data[i] = 255;
-  }
-}
-
-// src/image-editor/geometry.ts
-function normalizeAngle(degrees) {
-  const a = (degrees % 360 + 360) % 360;
-  return a === 360 ? 0 : a;
-}
-function cosSin(angle) {
-  switch (angle) {
-    case 0:
-      return [1, 0];
-    case 90:
-      return [0, 1];
-    case 180:
-      return [-1, 0];
-    case 270:
-      return [0, -1];
-    default: {
-      const rad = angle * Math.PI / 180;
-      return [Math.cos(rad), Math.sin(rad)];
+
+// src/image-editor/geometry.ts
+function normalizeAngle(degrees) {
+  const a = (degrees % 360 + 360) % 360;
+  return a === 360 ? 0 : a;
+}
+function cosSin(angle) {
+  switch (angle) {
+    case 0:
+      return [1, 0];
+    case 90:
+      return [0, 1];
+    case 180:
+      return [-1, 0];
+    case 270:
+      return [0, -1];
+    default: {
+      const rad = angle * Math.PI / 180;
+      return [Math.cos(rad), Math.sin(rad)];
     }
   }
 }
@@ -735,103 +687,1890 @@ function calculateCropDrag(startCrop, handle, startImgPt, currentImgPt, imgWidth
       height: startCrop.height
     };
   }
-  let left = startCrop.x;
-  let top = startCrop.y;
-  let right = startCrop.x + startCrop.width;
-  let bottom = startCrop.y + startCrop.height;
-  const minSize = 20;
-  if (handle === "e" || handle === "ne" || handle === "se") {
-    right = Math.min(imgWidth, Math.max(left + minSize, startCrop.x + startCrop.width + dx));
+  let left = startCrop.x;
+  let top = startCrop.y;
+  let right = startCrop.x + startCrop.width;
+  let bottom = startCrop.y + startCrop.height;
+  const minSize = 20;
+  if (handle === "e" || handle === "ne" || handle === "se") {
+    right = Math.min(imgWidth, Math.max(left + minSize, startCrop.x + startCrop.width + dx));
+  }
+  if (handle === "w" || handle === "nw" || handle === "sw") {
+    left = Math.max(0, Math.min(right - minSize, startCrop.x + dx));
+  }
+  if (handle === "s" || handle === "se" || handle === "sw") {
+    bottom = Math.min(imgHeight, Math.max(top + minSize, startCrop.y + startCrop.height + dy));
+  }
+  if (handle === "n" || handle === "nw" || handle === "ne") {
+    top = Math.max(0, Math.min(bottom - minSize, startCrop.y + dy));
+  }
+  if (aspectRatio && aspectRatio > 0) {
+    let currentW = right - left;
+    let currentH = bottom - top;
+    if (handle === "e" || handle === "w") {
+      currentH = Math.min(imgHeight, currentW / aspectRatio);
+      bottom = Math.min(imgHeight, top + currentH);
+    } else if (handle === "n" || handle === "s") {
+      currentW = Math.min(imgWidth, currentH * aspectRatio);
+      right = Math.min(imgWidth, left + currentW);
+    } else {
+      const targetH = currentW / aspectRatio;
+      if (top + targetH <= imgHeight) {
+        bottom = top + targetH;
+      } else {
+        const targetW = currentH * aspectRatio;
+        right = Math.min(imgWidth, left + targetW);
+      }
+    }
+  }
+  return {
+    x: Math.round(left),
+    y: Math.round(top),
+    width: Math.round(Math.max(minSize, right - left)),
+    height: Math.round(Math.max(minSize, bottom - top))
+  };
+}
+function getAnnotationBounds(ann) {
+  switch (ann.type) {
+    case "rect":
+    case "image":
+      return {
+        x: Math.min(ann.x, ann.x + ann.width),
+        y: Math.min(ann.y, ann.y + ann.height),
+        width: Math.abs(ann.width),
+        height: Math.abs(ann.height)
+      };
+    case "circle":
+      return {
+        x: ann.x - Math.abs(ann.radiusX),
+        y: ann.y - Math.abs(ann.radiusY),
+        width: Math.abs(ann.radiusX) * 2,
+        height: Math.abs(ann.radiusY) * 2
+      };
+    case "arrow":
+    case "line": {
+      const minX = Math.min(ann.x, ann.endX);
+      const minY = Math.min(ann.y, ann.endY);
+      return {
+        x: minX,
+        y: minY,
+        width: Math.max(Math.abs(ann.endX - ann.x), 10),
+        height: Math.max(Math.abs(ann.endY - ann.y), 10)
+      };
+    }
+    case "pen": {
+      if (!ann.points.length) return { x: ann.x, y: ann.y, width: 0, height: 0 };
+      let minX = ann.points[0].x;
+      let maxX = ann.points[0].x;
+      let minY = ann.points[0].y;
+      let maxY = ann.points[0].y;
+      for (const pt of ann.points) {
+        if (pt.x < minX) minX = pt.x;
+        if (pt.x > maxX) maxX = pt.x;
+        if (pt.y < minY) minY = pt.y;
+        if (pt.y > maxY) maxY = pt.y;
+      }
+      return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+    }
+    case "text":
+      return {
+        x: ann.x,
+        y: ann.y,
+        width: ann.text.length * ann.fontSize * 0.6,
+        height: ann.fontSize * 1.2
+      };
+  }
+}
+function hitTestAnnotation(imgPt, ann, padding = 10) {
+  const b = getAnnotationBounds(ann);
+  return imgPt.x >= b.x - padding && imgPt.x <= b.x + b.width + padding && imgPt.y >= b.y - padding && imgPt.y <= b.y + b.height + padding;
+}
+
+// src/image-editor/selection/mask.ts
+var SELECTION_MODES = ["replace", "add", "subtract", "intersect"];
+function isSelectionMode(value) {
+  return typeof value === "string" && SELECTION_MODES.includes(value);
+}
+function parseSelectionMode(value) {
+  return isSelectionMode(value) ? value : "replace";
+}
+var MAX_SIDE = 1 << 15;
+function checkSize(width, height) {
+  if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > MAX_SIDE || height > MAX_SIDE) {
+    throw new Error(`Invalid selection size ${width}\xD7${height}`);
+  }
+}
+function computeSelectionBounds(width, height, data) {
+  let x0 = width;
+  let x1 = -1;
+  let y0 = -1;
+  let y1 = -1;
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    let first = -1;
+    for (let x = 0; x < width; x++) {
+      if (data[row + x] !== 0) {
+        first = x;
+        break;
+      }
+    }
+    if (first < 0) continue;
+    let last = first;
+    for (let x = width - 1; x > first; x--) {
+      if (data[row + x] !== 0) {
+        last = x;
+        break;
+      }
+    }
+    if (y0 < 0) y0 = y;
+    y1 = y;
+    if (first < x0) x0 = first;
+    if (last > x1) x1 = last;
+  }
+  if (y0 < 0) return null;
+  return { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
+function createSelectionMask(width, height, data) {
+  checkSize(width, height);
+  const bytes = data ?? new Uint8Array(width * height);
+  if (bytes.length !== width * height) throw new Error("Selection data does not match its size");
+  return { width, height, data: bytes, bounds: data ? computeSelectionBounds(width, height, bytes) : null };
+}
+function fullSelection(width, height) {
+  checkSize(width, height);
+  return { width, height, data: new Uint8Array(width * height).fill(255), bounds: { x: 0, y: 0, width, height } };
+}
+function isSelectionEmpty(mask) {
+  return !mask || mask.bounds === null;
+}
+function selectionValueAt(mask, x, y) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  if (xi < 0 || yi < 0 || xi >= mask.width || yi >= mask.height) return 0;
+  return mask.data[yi * mask.width + xi] / 255;
+}
+function coverageToByte(v) {
+  if (!(v > 0)) return 0;
+  if (v >= 1) return 255;
+  return Math.floor(v * 255 + 0.5);
+}
+function selectionFromCoverage(width, height, coverage) {
+  const n = width * height;
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) out[i] = coverageToByte(coverage[i]);
+  return createSelectionMask(width, height, out);
+}
+function selectionToCoverage(mask) {
+  const out = new Float32Array(mask.data.length);
+  for (let i = 0; i < out.length; i++) out[i] = mask.data[i] / 255;
+  return out;
+}
+function selectionArea(mask) {
+  if (!mask || !mask.bounds) return 0;
+  let sum = 0;
+  const { x, y, width, height } = mask.bounds;
+  for (let yy = y; yy < y + height; yy++) {
+    const row = yy * mask.width;
+    for (let xx = x; xx < x + width; xx++) sum += mask.data[row + xx];
+  }
+  return sum / 255;
+}
+function combineSelections(prev, next, mode) {
+  let result;
+  if (mode === "replace" || !prev && mode === "add") {
+    result = next;
+  } else if (!prev) {
+    return null;
+  } else {
+    if (prev.width !== next.width || prev.height !== next.height) throw new Error("Selections differ in size");
+    const a = prev.data;
+    const b = next.data;
+    const out = new Uint8Array(a.length);
+    if (mode === "add") for (let i = 0; i < a.length; i++) out[i] = a[i] > b[i] ? a[i] : b[i];
+    else if (mode === "subtract") for (let i = 0; i < a.length; i++) out[i] = a[i] > b[i] ? a[i] - b[i] : 0;
+    else for (let i = 0; i < a.length; i++) out[i] = a[i] < b[i] ? a[i] : b[i];
+    result = createSelectionMask(prev.width, prev.height, out);
+  }
+  return result.bounds ? result : null;
+}
+function invertSelection(mask) {
+  const out = new Uint8Array(mask.data.length);
+  for (let i = 0; i < out.length; i++) out[i] = 255 - mask.data[i];
+  return createSelectionMask(mask.width, mask.height, out);
+}
+function resizeSelection(mask, width, height) {
+  if (mask.width === width && mask.height === height) return mask;
+  checkSize(width, height);
+  const out = new Uint8Array(width * height);
+  const sx = mask.width / width;
+  const sy = mask.height / height;
+  const src = mask.data;
+  const mw = mask.width;
+  for (let y = 0; y < height; y++) {
+    const fy = Math.min(mask.height - 1, Math.max(0, (y + 0.5) * sy - 0.5));
+    const y0 = Math.floor(fy);
+    const y1 = Math.min(mask.height - 1, y0 + 1);
+    const ty = fy - y0;
+    for (let x = 0; x < width; x++) {
+      const fx = Math.min(mw - 1, Math.max(0, (x + 0.5) * sx - 0.5));
+      const x0 = Math.floor(fx);
+      const x1 = Math.min(mw - 1, x0 + 1);
+      const tx = fx - x0;
+      const top = src[y0 * mw + x0] * (1 - tx) + src[y0 * mw + x1] * tx;
+      const bot = src[y1 * mw + x0] * (1 - tx) + src[y1 * mw + x1] * tx;
+      out[y * width + x] = Math.round(top * (1 - ty) + bot * ty);
+    }
+  }
+  return createSelectionMask(width, height, out);
+}
+function selectionFromPixels(pixels, options = {}) {
+  const { width, height, data } = pixels;
+  checkSize(width, height);
+  if (data.length < width * height * 4) throw new Error("Pixel data is shorter than width \xD7 height \xD7 4");
+  const channel = options.channel ?? "luminance";
+  const out = new Uint8Array(width * height);
+  const threshold = options.threshold;
+  for (let i = 0, p = 0; i < out.length; i++, p += 4) {
+    let v;
+    switch (channel) {
+      case "alpha":
+        v = data[p + 3];
+        break;
+      case "red":
+        v = data[p];
+        break;
+      case "green":
+        v = data[p + 1];
+        break;
+      case "blue":
+        v = data[p + 2];
+        break;
+      default:
+        v = Math.round((0.2126 * data[p] + 0.7152 * data[p + 1] + 0.0722 * data[p + 2]) * data[p + 3] / 255);
+    }
+    if (options.invert) v = 255 - v;
+    if (threshold !== void 0) v = v >= threshold ? 255 : 0;
+    out[i] = v;
+  }
+  return createSelectionMask(width, height, out);
+}
+function selectionToPixels(mask, as = "gray") {
+  const out = new Uint8ClampedArray(mask.data.length * 4);
+  for (let i = 0, p = 0; i < mask.data.length; i++, p += 4) {
+    const v = mask.data[i];
+    if (as === "gray") {
+      out[p] = out[p + 1] = out[p + 2] = v;
+      out[p + 3] = 255;
+    } else {
+      out[p] = out[p + 1] = out[p + 2] = 255;
+      out[p + 3] = v;
+    }
+  }
+  return { width: mask.width, height: mask.height, data: out };
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var B64_INDEX = (() => {
+  const t = new Int16Array(128).fill(-1);
+  for (let i = 0; i < B64.length; i++) t[B64.charCodeAt(i)] = i;
+  return t;
+})();
+function toBase64(bytes, length) {
+  const parts = [];
+  let chunk = "";
+  for (let i = 0; i < length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < length ? bytes[i + 1] : 0;
+    const c = i + 2 < length ? bytes[i + 2] : 0;
+    chunk += B64[a >> 2] + B64[(a & 3) << 4 | b >> 4];
+    chunk += i + 1 < length ? B64[(b & 15) << 2 | c >> 6] : "=";
+    chunk += i + 2 < length ? B64[c & 63] : "=";
+    if (chunk.length >= 8192) {
+      parts.push(chunk);
+      chunk = "";
+    }
+  }
+  parts.push(chunk);
+  return parts.join("");
+}
+function fromBase64(text) {
+  if (text.length % 4 !== 0) throw new Error("Invalid base64 length");
+  let pad = 0;
+  if (text.endsWith("==")) pad = 2;
+  else if (text.endsWith("=")) pad = 1;
+  const out = new Uint8Array(text.length / 4 * 3 - pad);
+  let o = 0;
+  const digit = (i, k) => {
+    const ch = text.charCodeAt(i + k);
+    if (ch === 61 && i + 4 === text.length && k >= 4 - pad) return 0;
+    const idx = ch < 128 ? B64_INDEX[ch] : -1;
+    if (idx < 0) throw new Error("Invalid base64 character");
+    return idx;
+  };
+  for (let i = 0; i < text.length; i += 4) {
+    const n = digit(i, 0) << 18 | digit(i, 1) << 12 | digit(i, 2) << 6 | digit(i, 3);
+    if (o < out.length) out[o++] = n >> 16 & 255;
+    if (o < out.length) out[o++] = n >> 8 & 255;
+    if (o < out.length) out[o++] = n & 255;
+  }
+  return out;
+}
+function encodeSelectionRle(data) {
+  let buf = new Uint8Array(64);
+  let len = 0;
+  const push = (b) => {
+    if (len === buf.length) {
+      const next = new Uint8Array(buf.length * 2);
+      next.set(buf);
+      buf = next;
+    }
+    buf[len++] = b;
+  };
+  let i = 0;
+  while (i < data.length) {
+    const v = data[i];
+    let j = i + 1;
+    while (j < data.length && data[j] === v) j++;
+    push(v);
+    let run = j - i;
+    while (run >= 128) {
+      push(run & 127 | 128);
+      run = Math.floor(run / 128);
+    }
+    push(run);
+    i = j;
+  }
+  return "r1:" + toBase64(buf, len);
+}
+function decodeSelectionRle(rle, length) {
+  if (typeof rle !== "string" || !rle.startsWith("r1:")) throw new Error("Unknown selection encoding");
+  const bytes = fromBase64(rle.slice(3));
+  const out = new Uint8Array(length);
+  let o = 0;
+  let i = 0;
+  while (i < bytes.length) {
+    const v = bytes[i++];
+    let run = 0;
+    let scale = 1;
+    for (; ; ) {
+      if (i >= bytes.length) throw new Error("Truncated selection run");
+      const b = bytes[i++];
+      run += (b & 127) * scale;
+      if (b < 128) break;
+      scale *= 128;
+      if (scale > 2 ** 35) throw new Error("Selection run too long");
+    }
+    if (run === 0 || o + run > length) throw new Error("Selection runs do not match its size");
+    if (v !== 0) out.fill(v, o, o + run);
+    o += run;
+  }
+  if (o !== length) throw new Error("Selection runs do not match its size");
+  return out;
+}
+function serializeSelection(mask) {
+  return { width: mask.width, height: mask.height, rle: encodeSelectionRle(mask.data) };
+}
+function deserializeSelection(value) {
+  if (!value || typeof value !== "object") throw new Error("selection must be an object");
+  const v = value;
+  const width = v.width;
+  const height = v.height;
+  checkSize(width, height);
+  return createSelectionMask(width, height, decodeSelectionRle(v.rle, width * height));
+}
+function hashMaskContent(content) {
+  let h = 2166136261;
+  if (typeof content === "string") {
+    for (let i = 0; i < content.length; i++) {
+      h ^= content.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+  } else {
+    for (let i = 0; i < content.length; i++) {
+      h ^= content[i];
+      h = Math.imul(h, 16777619);
+    }
+  }
+  return `${(h >>> 0).toString(16)}:${content.length}`;
+}
+
+// src/image-editor/selection/modify.ts
+var EMPTY_DISTANCE = 1e10;
+function distanceTransform(inside, width, height) {
+  const n = width * height;
+  const out = new Float32Array(n);
+  let any = false;
+  let all = true;
+  for (let i = 0; i < n; i++) {
+    if (inside[i]) any = true;
+    else all = false;
+  }
+  if (!any) return out.fill(EMPTY_DISTANCE);
+  if (all) return out;
+  const NONE = 4294967295;
+  const vertical = new Uint32Array(n).fill(NONE);
+  for (let x = 0; x < width; x++) {
+    let nearest = -1;
+    for (let y = 0; y < height; y++) {
+      const i = y * width + x;
+      if (inside[i]) nearest = y;
+      if (nearest >= 0) vertical[i] = y - nearest;
+    }
+    nearest = -1;
+    for (let y = height - 1; y >= 0; y--) {
+      const i = y * width + x;
+      if (vertical[i] === 0) nearest = y;
+      if (nearest >= 0) vertical[i] = Math.min(vertical[i], nearest - y);
+    }
+  }
+  const sites = new Int32Array(width);
+  const starts = new Float64Array(width);
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    let count = 0;
+    for (let q = 0; q < width; q++) {
+      const dq = vertical[row + q];
+      if (dq === NONE) continue;
+      const fq = dq * dq;
+      let start = -Infinity;
+      while (count > 0) {
+        const p = sites[count - 1];
+        const dp = vertical[row + p];
+        start = (fq - dp * dp) / (2 * (q - p)) + (q + p) * 0.5;
+        if (start > starts[count - 1]) break;
+        count--;
+      }
+      if (count === 0) start = -Infinity;
+      sites[count] = q;
+      starts[count] = start;
+      count++;
+    }
+    if (count === 0) {
+      out.fill(EMPTY_DISTANCE, row, row + width);
+      continue;
+    }
+    let k = 0;
+    for (let x = 0; x < width; x++) {
+      while (k + 1 < count && starts[k + 1] < x) k++;
+      const site = sites[k];
+      const dx = x - site;
+      const dv = vertical[row + site];
+      out[row + x] = Math.sqrt(dx * dx + dv * dv);
+    }
+  }
+  return out;
+}
+function thresholdInside(m, threshold = 0.5) {
+  const out = new Uint8Array(m.length);
+  for (let i = 0; i < m.length; i++) out[i] = m[i] >= threshold ? 1 : 0;
+  return out;
+}
+function expandCoverage(m, w, h, r) {
+  const d = distanceTransform(thresholdInside(m), w, h);
+  const out = new Float32Array(m.length);
+  for (let i = 0; i < out.length; i++) out[i] = Math.max(m[i], Math.min(1, Math.max(0, r + 1 - d[i])));
+  return out;
+}
+function contractCoverage(m, w, h, r) {
+  const inv = new Float32Array(m.length);
+  for (let i = 0; i < inv.length; i++) inv[i] = 1 - m[i];
+  const e = expandCoverage(inv, w, h, r);
+  for (let i = 0; i < e.length; i++) e[i] = 1 - e[i];
+  return e;
+}
+function borderCoverage(m, w, h, r) {
+  const inside = thresholdInside(m);
+  const outside = new Uint8Array(inside.length);
+  for (let i = 0; i < inside.length; i++) outside[i] = inside[i] ? 0 : 1;
+  const out = new Float32Array(m.length);
+  if (!(r > 0)) return out;
+  const toInside = distanceTransform(inside, w, h);
+  const toOutside = distanceTransform(outside, w, h);
+  for (let i = 0; i < out.length; i++) {
+    const d = inside[i] ? toOutside[i] : toInside[i];
+    out[i] = Math.min(1, Math.max(0, 1 - (d - 1) / r));
+  }
+  return out;
+}
+function boxLineReplicate(src, srcOff, stride, len, r, dst) {
+  const at = (i) => src[srcOff + Math.min(len - 1, Math.max(0, i)) * stride];
+  let sum = 0;
+  for (let i = -r; i <= r; i++) sum += at(i);
+  const k = 2 * r + 1;
+  for (let i = 0; i < len; i++) {
+    dst[i] = sum / k;
+    sum += at(i + r + 1) - at(i - r);
+  }
+}
+function smoothCoverage(m, w, h, r) {
+  const rr = Number.isFinite(r) ? Math.max(0, Math.round(r)) : 0;
+  const src = Float32Array.from(m);
+  const tmp = new Float32Array(src.length);
+  const line = new Float32Array(Math.max(w, h));
+  if (rr > 0) {
+    for (let y = 0; y < h; y++) {
+      boxLineReplicate(src, y * w, 1, w, rr, line);
+      tmp.set(line.subarray(0, w), y * w);
+    }
+    for (let x = 0; x < w; x++) {
+      boxLineReplicate(tmp, x, w, h, rr, line);
+      for (let y = 0; y < h; y++) src[y * w + x] = line[y];
+    }
+  }
+  for (let i = 0; i < src.length; i++) src[i] = src[i] >= 0.5 ? 1 : 0;
+  return src;
+}
+function gaussianKernel(sigma) {
+  const r = Math.ceil(sigma * 3);
+  const k = new Float32Array(2 * r + 1);
+  let s = 0;
+  for (let i = -r; i <= r; i++) {
+    const v = Math.exp(-(i * i) / (2 * sigma * sigma));
+    k[i + r] = v;
+    s += v;
+  }
+  for (let i = 0; i < k.length; i++) k[i] /= s;
+  return k;
+}
+var DIRECT_GAUSSIAN_MAX_SIGMA = 8;
+function boxRadii(sigma) {
+  const n = 3;
+  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
+  let wl = Math.floor(wIdeal);
+  if (wl % 2 === 0) wl--;
+  const wu = wl + 2;
+  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
+  const m = Math.round(mIdeal);
+  const sizes = [0, 1, 2].map((i) => i < m ? wl : wu);
+  return sizes.map((s) => (s - 1) / 2);
+}
+function convolveLine(src, off, stride, len, k, edge, dst) {
+  const r = (k.length - 1) / 2;
+  for (let i = 0; i < len; i++) {
+    let a = 0;
+    const lo = i - r;
+    for (let j = 0; j < k.length; j++) {
+      let x = lo + j;
+      if (x < 0 || x >= len) {
+        if (edge === "zero") continue;
+        x = x < 0 ? 0 : len - 1;
+      }
+      a += src[off + x * stride] * k[j];
+    }
+    dst[i] = a;
+  }
+}
+function boxesLine(src, off, stride, len, radii, edge, a, b, dst) {
+  const pad = radii.reduce((s, r) => s + r, 0);
+  const plen = len + 2 * pad;
+  for (let i = 0; i < plen; i++) {
+    const j = i - pad;
+    a[i] = j < 0 ? edge === "zero" ? 0 : src[off] : j >= len ? edge === "zero" ? 0 : src[off + (len - 1) * stride] : src[off + j * stride];
+  }
+  let from = a;
+  let to = b;
+  for (const r of radii) {
+    let sum = 0;
+    for (let i = 0; i <= Math.min(r, plen - 1); i++) sum += from[i];
+    const k = 2 * r + 1;
+    for (let i = 0; i < plen; i++) {
+      to[i] = sum / k;
+      const add = i + r + 1;
+      const drop = i - r;
+      if (add < plen) sum += from[add];
+      if (drop >= 0) sum -= from[drop];
+    }
+    const t = from;
+    from = to;
+    to = t;
+  }
+  for (let i = 0; i < len; i++) dst[i] = from[i + pad];
+}
+function gaussianBlur(src, w, h, sigma, edge = "zero") {
+  const out = Float32Array.from(src);
+  if (!(sigma >= 0.1) || w <= 0 || h <= 0) return out;
+  const s = Math.min(sigma, 4 * Math.max(w, h));
+  const line = new Float32Array(Math.max(w, h));
+  const passes = [];
+  if (s <= DIRECT_GAUSSIAN_MAX_SIGMA) {
+    const k = gaussianKernel(s);
+    passes.push((buf, off, stride, len) => convolveLine(buf, off, stride, len, k, edge, line));
+  } else {
+    const radii = boxRadii(s);
+    const plen = Math.max(w, h) + 2 * radii.reduce((a2, r) => a2 + r, 0);
+    const a = new Float32Array(plen);
+    const b = new Float32Array(plen);
+    passes.push((buf, off, stride, len) => boxesLine(buf, off, stride, len, radii, edge, a, b, line));
+  }
+  for (const pass of passes) {
+    for (let y = 0; y < h; y++) {
+      pass(out, y * w, 1, w);
+      out.set(line.subarray(0, w), y * w);
+    }
+  }
+  for (const pass of passes) {
+    for (let x = 0; x < w; x++) {
+      pass(out, x, w, h);
+      for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+    }
+  }
+  return out;
+}
+function featherCoverage(m, w, h, radius) {
+  const out = gaussianBlur(m, w, h, Number.isFinite(radius) ? Math.max(0, radius) : 0, "zero");
+  for (let i = 0; i < out.length; i++) if (Math.abs(out[i]) < 1e-7) out[i] = 0;
+  return out;
+}
+function runningExtreme(src, off, stride, len, r, max, g, hb, dst) {
+  const k = 2 * r + 1;
+  const pick = max ? (a, b) => a > b ? a : b : (a, b) => a < b ? a : b;
+  const fill = max ? -Infinity : Infinity;
+  const plen = len + 2 * r;
+  const at = (i) => i < r || i >= r + len ? fill : src[off + (i - r) * stride];
+  for (let start = 0; start < plen; start += k) {
+    const end = Math.min(plen, start + k);
+    g[start] = at(start);
+    for (let i = start + 1; i < end; i++) g[i] = pick(g[i - 1], at(i));
+    hb[end - 1] = at(end - 1);
+    for (let i = end - 2; i >= start; i--) hb[i] = pick(hb[i + 1], at(i));
+  }
+  for (let i = 0; i < len; i++) {
+    const a = hb[i];
+    const b = g[i + 2 * r];
+    dst[i] = pick(a, b);
+  }
+}
+function greyMorphology(src, w, h, r, grow) {
+  const out = Float32Array.from(src);
+  if (r <= 0) return out;
+  const n = Math.max(w, h);
+  const g = new Float32Array(n + 2 * r);
+  const hb = new Float32Array(n + 2 * r);
+  const line = new Float32Array(n);
+  for (let y = 0; y < h; y++) {
+    runningExtreme(out, y * w, 1, w, r, grow, g, hb, line);
+    out.set(line.subarray(0, w), y * w);
+  }
+  for (let x = 0; x < w; x++) {
+    runningExtreme(out, x, w, h, r, grow, g, hb, line);
+    for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+  }
+  return out;
+}
+function shiftCoverage(src, w, h, amount) {
+  const mag = Math.abs(amount);
+  if (!Number.isFinite(mag) || mag < 1e-4) return Float32Array.from(src);
+  const grow = amount > 0;
+  const whole = Math.floor(mag);
+  const frac = mag - whole;
+  if (frac < 1e-4) return greyMorphology(src, w, h, whole, grow);
+  const lo = whole === 0 ? Float32Array.from(src) : greyMorphology(src, w, h, whole, grow);
+  const hi = greyMorphology(src, w, h, whole + 1, grow);
+  for (let i = 0; i < lo.length; i++) lo[i] += (hi[i] - lo[i]) * frac;
+  return lo;
+}
+var SELECTION_MODIFY_OPS = ["grow", "shrink", "feather", "border", "smooth"];
+function wrap(mask, coverage) {
+  const out = new Uint8Array(coverage.length);
+  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
+  return createSelectionMask(mask.width, mask.height, out);
+}
+function modifySelection(mask, op, radius) {
+  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
+  if (r === 0 && op !== "border") return mask;
+  const m = selectionToCoverage(mask);
+  const { width: w, height: h } = mask;
+  switch (op) {
+    case "grow":
+      return wrap(mask, expandCoverage(m, w, h, r));
+    case "shrink":
+      return wrap(mask, contractCoverage(m, w, h, r));
+    case "feather":
+      return wrap(mask, featherCoverage(m, w, h, r));
+    case "border":
+      return wrap(mask, borderCoverage(m, w, h, r));
+    case "smooth":
+      return wrap(mask, smoothCoverage(m, w, h, r));
+    default:
+      throw new Error(`Unknown selection modification "${op}"`);
+  }
+}
+
+// src/image-editor/selection/layer-mask.ts
+var MAX_SIDE2 = 1 << 15;
+function normalizeLayerMask(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const { width, height, rle } = r;
+  if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > MAX_SIDE2 || height > MAX_SIDE2 || typeof rle !== "string" || !rle.startsWith("r1:")) {
+    return null;
+  }
+  const out = { width, height, rle };
+  if (typeof r.density === "number" && Number.isFinite(r.density)) {
+    const d = Math.min(1, Math.max(0, r.density));
+    if (d !== 1) out.density = d;
+  }
+  if (typeof r.feather === "number" && Number.isFinite(r.feather)) {
+    const f = Math.min(1e3, Math.max(0, r.feather));
+    if (f !== 0) out.feather = f;
+  }
+  if (r.enabled === false) out.enabled = false;
+  return out;
+}
+function layerMaskFromSelection(selection, props = {}) {
+  return normalizeLayerMask({ width: selection.width, height: selection.height, rle: encodeSelectionRle(selection.data), ...props });
+}
+function updateLayerMaskProps(mask, props) {
+  return normalizeLayerMask({
+    ...mask,
+    ...props.density !== void 0 ? { density: props.density } : {},
+    ...props.feather !== void 0 ? { feather: props.feather } : {},
+    ...props.enabled !== void 0 ? { enabled: props.enabled } : {}
+  });
+}
+var DECODE_LIMIT = 8;
+var decoded = /* @__PURE__ */ new Map();
+var coverageCache = /* @__PURE__ */ new Map();
+function lru(cache, key, make) {
+  if (cache.has(key)) {
+    const v2 = cache.get(key);
+    cache.delete(key);
+    cache.set(key, v2);
+    return v2;
+  }
+  const v = make();
+  cache.set(key, v);
+  if (cache.size > DECODE_LIMIT) cache.delete(cache.keys().next().value);
+  return v;
+}
+function decodeLayerMask(mask) {
+  const key = `${mask.width}x${mask.height}:${mask.rle}`;
+  return lru(decoded, key, () => {
+    try {
+      return createSelectionMask(mask.width, mask.height, decodeSelectionRle(mask.rle, mask.width * mask.height));
+    } catch {
+      return null;
+    }
+  });
+}
+function layerMaskKey(mask) {
+  if (!mask) return "";
+  return `${mask.width}x${mask.height}:${hashMaskContent(mask.rle)}:${mask.density ?? 1}:${mask.feather ?? 0}:${mask.enabled !== false}`;
+}
+function layerMaskCoverage(mask) {
+  if (mask.enabled === false) return null;
+  return lru(coverageCache, layerMaskKey(mask), () => {
+    const sel = decodeLayerMask(mask);
+    if (!sel) return null;
+    let v = new Float32Array(sel.data.length);
+    for (let i = 0; i < v.length; i++) v[i] = sel.data[i] / 255;
+    const feather = mask.feather ?? 0;
+    if (feather > 0) v = gaussianBlur(v, mask.width, mask.height, feather, "clamp");
+    const density = mask.density ?? 1;
+    if (density !== 1) for (let i = 0; i < v.length; i++) v[i] = 1 - density * (1 - v[i]);
+    return v;
+  });
+}
+function projectMaskCoverage(coverage, maskWidth, maskHeight, naturalWidth, naturalHeight, projection, targetWidth, targetHeight) {
+  const out = new Float32Array(targetWidth * targetHeight);
+  const o = unprojectCanvasPoint({ x: 0.5, y: 0.5 }, projection);
+  const ox = unprojectCanvasPoint({ x: 1.5, y: 0.5 }, projection);
+  const oy = unprojectCanvasPoint({ x: 0.5, y: 1.5 }, projection);
+  const kx = maskWidth / naturalWidth;
+  const ky = maskHeight / naturalHeight;
+  const ux = (ox.x - o.x) * kx;
+  const vx = (ox.y - o.y) * ky;
+  const uy = (oy.x - o.x) * kx;
+  const vy = (oy.y - o.y) * ky;
+  const u0 = o.x * kx - 0.5;
+  const v0 = o.y * ky - 0.5;
+  const mw1 = maskWidth - 1;
+  const mh1 = maskHeight - 1;
+  for (let y = 0; y < targetHeight; y++) {
+    let u = u0 + y * uy;
+    let v = v0 + y * vy;
+    const row = y * targetWidth;
+    for (let x = 0; x < targetWidth; x++, u += ux, v += vx) {
+      const fu = u < 0 ? 0 : u > mw1 ? mw1 : u;
+      const fv = v < 0 ? 0 : v > mh1 ? mh1 : v;
+      const x0 = fu | 0;
+      const y0 = fv | 0;
+      const x1 = x0 < mw1 ? x0 + 1 : x0;
+      const y1 = y0 < mh1 ? y0 + 1 : y0;
+      const tx = fu - x0;
+      const ty = fv - y0;
+      const a = coverage[y0 * maskWidth + x0] * (1 - tx) + coverage[y0 * maskWidth + x1] * tx;
+      const b = coverage[y1 * maskWidth + x0] * (1 - tx) + coverage[y1 * maskWidth + x1] * tx;
+      out[row + x] = a * (1 - ty) + b * ty;
+    }
+  }
+  return out;
+}
+function buildLayerMaskPlanes(layers, naturalWidth, naturalHeight, projection, targetWidth, targetHeight) {
+  if (!layers?.some((l) => l.mask && l.mask.enabled !== false)) return void 0;
+  const planes = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    if (!layer.mask) continue;
+    const coverage = layerMaskCoverage(layer.mask);
+    if (!coverage) continue;
+    planes.set(
+      layer.id,
+      projectMaskCoverage(coverage, layer.mask.width, layer.mask.height, naturalWidth, naturalHeight, projection, targetWidth, targetHeight)
+    );
+  }
+  return planes.size ? planes : void 0;
+}
+
+// src/image-editor/adjustment-layers.ts
+var ADJUSTMENT_LUT_SIZE = 4096;
+var clamp01 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
+var finite = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+var clampTo = (v, lo, hi, fallback) => Math.min(hi, Math.max(lo, finite(v, fallback)));
+var remEuclid = (a, b) => (a % b + b) % b;
+function sampleLut(table, v) {
+  const n = table.length - 1;
+  const x = clamp01(v) * n;
+  const i = Math.floor(x);
+  const j = Math.min(i + 1, n);
+  const f = x - i;
+  return table[i] * (1 - f) + table[j] * f;
+}
+var ADJUSTMENT_KINDS = [
+  { kind: "curves", label: "Curves" },
+  { kind: "levels", label: "Levels" },
+  { kind: "hueSaturation", label: "Hue/Saturation" },
+  { kind: "vibrance", label: "Vibrance" },
+  { kind: "colorBalance", label: "Color Balance" },
+  { kind: "blackWhite", label: "Black & White" },
+  { kind: "photoFilter", label: "Photo Filter" },
+  { kind: "invert", label: "Invert" },
+  { kind: "posterize", label: "Posterize" },
+  { kind: "threshold", label: "Threshold" }
+];
+var KIND_LABELS = new Map(ADJUSTMENT_KINDS.map((k) => [k.kind, k.label]));
+function isAdjustmentKind(value) {
+  return typeof value === "string" && KIND_LABELS.has(value);
+}
+function adjustmentKindLabel(kind) {
+  return KIND_LABELS.get(kind) ?? kind;
+}
+var HUE_RANGE_LABELS = ["Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"];
+function neutralHueRange(i) {
+  const c = 60 * i;
+  return { hue: 0, saturation: 0, lightness: 0, bounds: [c - 45, c - 15, c + 15, c + 45] };
+}
+var identityCurve = () => [
+  { input: 0, output: 0 },
+  { input: 255, output: 255 }
+];
+var identityLevels = () => ({ inBlack: 0, inWhite: 255, gamma: 1, outBlack: 0, outWhite: 255 });
+function defaultAdjustmentParams(kind) {
+  const defaults = {
+    curves: () => ({ master: identityCurve(), red: identityCurve(), green: identityCurve(), blue: identityCurve() }),
+    levels: () => ({ master: identityLevels(), red: identityLevels(), green: identityLevels(), blue: identityLevels() }),
+    hueSaturation: () => ({
+      hue: 0,
+      saturation: 0,
+      lightness: 0,
+      colorize: false,
+      ranges: [0, 1, 2, 3, 4, 5].map(neutralHueRange)
+    }),
+    vibrance: () => ({ vibrance: 0, saturation: 0 }),
+    colorBalance: () => ({ shadows: [0, 0, 0], midtones: [0, 0, 0], highlights: [0, 0, 0], preserveLuminosity: true }),
+    blackWhite: () => ({ reds: 40, yellows: 60, greens: 40, cyans: 60, blues: 20, magentas: 80, tint: null }),
+    invert: () => ({}),
+    posterize: () => ({ levels: 4 }),
+    threshold: () => ({ level: 128 }),
+    photoFilter: () => ({ color: "#ec8a00", density: 25, preserveLuminosity: true })
+  };
+  return defaults[kind]();
+}
+var layerCounter = 0;
+function createAdjustmentLayer(kind, options = {}) {
+  const raw = {
+    id: options.id ?? `adj_${Date.now().toString(36)}_${(++layerCounter).toString(36)}`,
+    kind,
+    name: options.name,
+    params: { ...defaultAdjustmentParams(kind), ...options.params ?? {} },
+    enabled: options.enabled ?? true,
+    opacity: options.opacity ?? 1,
+    blend: options.blend ?? "normal",
+    mask: options.mask
+  };
+  return normalizeAdjustmentLayer(raw);
+}
+var HEX = /^#[0-9a-f]{6}$/i;
+function normCurve(points) {
+  if (!Array.isArray(points)) return identityCurve();
+  const out = points.filter((p) => p && typeof p === "object").map((p) => ({ input: clampTo(p.input, 0, 255, 0), output: clampTo(p.output, 0, 255, 0) })).sort((a, b) => a.input - b.input);
+  return out.length >= 2 ? out : identityCurve();
+}
+function normLevels(ch) {
+  const c = ch && typeof ch === "object" ? ch : {};
+  return {
+    inBlack: clampTo(c.inBlack, 0, 254, 0),
+    inWhite: clampTo(c.inWhite, 1, 255, 255),
+    gamma: clampTo(c.gamma, 0.1, 9.99, 1),
+    outBlack: clampTo(c.outBlack, 0, 255, 0),
+    outWhite: clampTo(c.outWhite, 0, 255, 255)
+  };
+}
+function normTone(t) {
+  const a = Array.isArray(t) ? t : [];
+  return [clampTo(a[0], -100, 100, 0), clampTo(a[1], -100, 100, 0), clampTo(a[2], -100, 100, 0)];
+}
+function normParams(kind, raw) {
+  const p = raw && typeof raw === "object" ? raw : {};
+  const d = defaultAdjustmentParams(kind);
+  switch (kind) {
+    case "curves":
+      return { master: normCurve(p.master), red: normCurve(p.red), green: normCurve(p.green), blue: normCurve(p.blue) };
+    case "levels":
+      return { master: normLevels(p.master), red: normLevels(p.red), green: normLevels(p.green), blue: normLevels(p.blue) };
+    case "hueSaturation": {
+      const ranges = [0, 1, 2, 3, 4, 5].map((i) => {
+        const r = Array.isArray(p.ranges) && p.ranges[i] && typeof p.ranges[i] === "object" ? p.ranges[i] : {};
+        const n = neutralHueRange(i);
+        const b = Array.isArray(r.bounds) && r.bounds.length === 4 && r.bounds.every((v) => Number.isFinite(v)) ? r.bounds : n.bounds;
+        return {
+          hue: clampTo(r.hue, -180, 180, 0),
+          saturation: clampTo(r.saturation, -100, 100, 0),
+          lightness: clampTo(r.lightness, -100, 100, 0),
+          bounds: [b[0], b[1], b[2], b[3]]
+        };
+      });
+      const colorize = p.colorize === true;
+      return {
+        hue: colorize ? clampTo(p.hue, 0, 360, 0) : clampTo(p.hue, -180, 180, 0),
+        saturation: clampTo(p.saturation, -100, 100, 0),
+        lightness: clampTo(p.lightness, -100, 100, 0),
+        colorize,
+        ranges
+      };
+    }
+    case "vibrance":
+      return { vibrance: clampTo(p.vibrance, -100, 100, 0), saturation: clampTo(p.saturation, -100, 100, 0) };
+    case "colorBalance":
+      return {
+        shadows: normTone(p.shadows),
+        midtones: normTone(p.midtones),
+        highlights: normTone(p.highlights),
+        preserveLuminosity: p.preserveLuminosity !== false
+      };
+    case "blackWhite": {
+      const out = {};
+      for (const k of ["reds", "yellows", "greens", "cyans", "blues", "magentas"]) out[k] = clampTo(p[k], -200, 300, d[k]);
+      out.tint = typeof p.tint === "string" && HEX.test(p.tint) ? p.tint.toLowerCase() : null;
+      return out;
+    }
+    case "photoFilter":
+      return {
+        color: typeof p.color === "string" && HEX.test(p.color) ? p.color.toLowerCase() : d.color,
+        density: clampTo(p.density, 0, 100, d.density),
+        preserveLuminosity: p.preserveLuminosity !== false
+      };
+    case "posterize":
+      return { levels: Math.round(clampTo(p.levels, 2, 255, 4)) };
+    case "threshold":
+      return { level: Math.round(clampTo(p.level, 1, 255, 128)) };
+    case "invert":
+      return {};
+  }
+}
+function normalizeAdjustmentLayer(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (!isAdjustmentKind(r.kind)) return null;
+  const layer = {
+    id: typeof r.id === "string" && r.id ? r.id : `adj_${Date.now().toString(36)}_${(++layerCounter).toString(36)}`,
+    kind: r.kind,
+    enabled: r.enabled !== false,
+    opacity: clampTo(r.opacity, 0, 1, 1),
+    blend: normalizeBlendMode(r.blend),
+    params: normParams(r.kind, r.params)
+  };
+  if (typeof r.name === "string" && r.name) layer.name = r.name;
+  const mask = normalizeLayerMask(r.mask);
+  if (mask) layer.mask = mask;
+  return layer;
+}
+function normalizeAdjustmentLayers(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of raw) {
+    const layer = normalizeAdjustmentLayer(item);
+    if (!layer) continue;
+    while (seen.has(layer.id)) layer.id = `${layer.id}_${(++layerCounter).toString(36)}`;
+    seen.add(layer.id);
+    out.push(layer);
+  }
+  return out;
+}
+function curveLut(points, size = ADJUSTMENT_LUT_SIZE) {
+  const pts = points.filter((p) => Number.isFinite(p.input) && Number.isFinite(p.output)).map((p) => [p.input, p.output]).sort((a, b) => a[0] - b[0]);
+  const dedup = [];
+  for (const p of pts) {
+    if (dedup.length && Math.abs(dedup[dedup.length - 1][0] - p[0]) < 1e-6) continue;
+    dedup.push(p);
+  }
+  const out = new Float32Array(size);
+  const n = dedup.length;
+  if (n < 2) {
+    for (let k = 0; k < size; k++) out[k] = k / (size - 1);
+    return out;
+  }
+  const x = dedup.map((p) => p[0]);
+  const y = dedup.map((p) => p[1]);
+  const m2 = new Float64Array(n);
+  if (n > 2) {
+    const c = new Float64Array(n);
+    const d = new Float64Array(n);
+    for (let i = 1; i < n - 1; i++) {
+      const h0 = x[i] - x[i - 1];
+      const h1 = x[i + 1] - x[i];
+      const a = h0 / 6;
+      const b = (h0 + h1) / 3;
+      const cc = h1 / 6;
+      const r = (y[i + 1] - y[i]) / h1 - (y[i] - y[i - 1]) / h0;
+      const denom = b - a * c[i - 1];
+      c[i] = cc / denom;
+      d[i] = (r - a * d[i - 1]) / denom;
+    }
+    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
+  }
+  let seg = 0;
+  for (let k = 0; k < size; k++) {
+    const xv = k / (size - 1);
+    if (xv <= x[0]) {
+      out[k] = clamp01(y[0]);
+      continue;
+    }
+    if (xv >= x[n - 1]) {
+      out[k] = clamp01(y[n - 1]);
+      continue;
+    }
+    while (seg < n - 2 && xv > x[seg + 1]) seg++;
+    const x0 = x[seg], x1 = x[seg + 1];
+    const h = x1 - x0;
+    const a = (x1 - xv) / h;
+    const b = (xv - x0) / h;
+    const v = a * y[seg] + b * y[seg + 1] + ((a * a * a - a) * m2[seg] + (b * b * b - b) * m2[seg + 1]) * (h * h) / 6;
+    out[k] = clamp01(v);
+  }
+  return out;
+}
+function curveLutFromLevels(points) {
+  return curveLut(points.map((p) => ({ input: p.input / 255, output: p.output / 255 })));
+}
+var toUnitLevels = (c) => ({
+  inBlack: c.inBlack / 255,
+  inWhite: c.inWhite / 255,
+  gamma: c.gamma,
+  outBlack: c.outBlack / 255,
+  outWhite: c.outWhite / 255
+});
+function levelsValue(ch, v, quantum) {
+  const range = Math.max(1e-6, ch.inWhite - ch.inBlack);
+  let u;
+  if (quantum !== void 0 && Number.isFinite(quantum) && quantum >= 1) {
+    const q = quantum;
+    const vq = Math.round(v * q) / q;
+    u = Math.floor(clamp01((vq - ch.inBlack) / range) * q + 0.5 + 1e-3) / q;
+  } else {
+    u = clamp01((v - ch.inBlack) / range);
+  }
+  const g = Math.max(0.01, ch.gamma);
+  let t;
+  if (g > 1) {
+    const power = Math.pow(u, 1 / g);
+    const line = 0.93 * Math.pow(2, g) * u;
+    if (power <= 1e-6 || line <= 1e-6) t = Math.min(power, line);
+    else {
+      const p = 10;
+      t = Math.pow(Math.pow(power, -p) + Math.pow(line, -p), -1 / p);
+    }
+  } else {
+    t = Math.pow(u, 1 / g);
+  }
+  return ch.outBlack + t * (ch.outWhite - ch.outBlack);
+}
+function rgbToHsl(c) {
+  const max = Math.max(c[0], c[1], c[2]);
+  const min = Math.min(c[0], c[1], c[2]);
+  const l = (max + min) / 2;
+  if (Math.abs(max - min) < 1e-7) return [0, 0, l];
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === c[0]) h = remEuclid((c[1] - c[2]) / d, 6);
+  else if (max === c[1]) h = (c[2] - c[0]) / d + 2;
+  else h = (c[0] - c[1]) / d + 4;
+  return [h / 6, s, l];
+}
+function hslToRgb(h, s, l) {
+  if (s <= 0) return [l, l, l];
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const f = (t) => {
+    t = remEuclid(t, 1);
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 0.5) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  };
+  return [f(h + 1 / 3), f(h), f(h - 1 / 3)];
+}
+function hueRangeWeight(range, deg) {
+  const [a, b0, c0, d0] = range.bounds;
+  const rel = (x) => Number.isFinite(x) && Number.isFinite(a) ? remEuclid(x - a, 360) : 0;
+  const b = rel(b0);
+  const c = Math.max(rel(c0), b);
+  const d = Math.max(rel(d0), c);
+  const h = rel(deg);
+  if (h <= b) return b <= 0 ? 1 : h / b;
+  if (h <= c) return 1;
+  if (h <= d) return d <= c ? 1 : (d - h) / (d - c);
+  return 0;
+}
+var isNeutralRange = (r) => r.hue === 0 && r.saturation === 0 && r.lightness === 0;
+function hueRangeTables(ranges) {
+  const n = ADJUSTMENT_LUT_SIZE;
+  const t = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
+  const active = ranges.filter((r) => !isNeutralRange(r));
+  for (let k = 0; k < n; k++) {
+    const deg = k / (n - 1) * 360;
+    for (const r of active) {
+      const w = hueRangeWeight(r, deg);
+      t[0][k] += w * r.hue;
+      t[1][k] += w * r.saturation / 100;
+      t[2][k] += w * r.lightness / 100;
+    }
+  }
+  return t;
+}
+function hueSaturation(c, hue, s, l, colorize) {
+  const lighten = (v) => l > 0 ? v + (1 - v) * l : v * (1 + l);
+  if (colorize) {
+    const ll2 = rgbToHsl(c)[2];
+    return hslToRgb(remEuclid(hue, 360) / 360, Math.min(1, Math.abs(s)), lighten(ll2));
+  }
+  const [hh0, ss0, ll] = rgbToHsl([lighten(c[0]), lighten(c[1]), lighten(c[2])]);
+  const hh = remEuclid(hh0 + hue / 360, 1);
+  const ss = Math.min(1, Math.max(0, s > 0 ? ss0 / Math.max(1 / 512, 1 - s) : ss0 * (1 + s)));
+  return hslToRgb(hh, ss, ll);
+}
+function rangeLightness(c, l) {
+  const k = Math.min(1, Math.max(-1, l));
+  const target = k > 0 ? Math.max(c[0], c[1], c[2]) : Math.min(c[0], c[1], c[2]);
+  const a = Math.abs(k);
+  return [c[0] + (target - c[0]) * a, c[1] + (target - c[1]) * a, c[2] + (target - c[2]) * a];
+}
+var VIBRANCE_GREY = [0.288, 0.712];
+var VIBRANCE_BOOST = [0.5001, 0.0887, 0.4374, 0.7573, -0.8113, 0.5154, 2.8026];
+function vibranceSkin(h) {
+  if (h <= 30) return 1;
+  if (h < 45) return (45 - h) / 15;
+  if (h < 300) return 0;
+  return (h - 300) / 60;
+}
+function hsvHue(c, mx, mn) {
+  const d = mx - mn;
+  let h;
+  if (mx === c[0]) h = remEuclid((c[1] - c[2]) / d, 6);
+  else if (mx === c[1]) h = (c[2] - c[0]) / d + 2;
+  else h = (c[0] - c[1]) / d + 4;
+  return h * 60;
+}
+function vibranceLinear(c, v) {
+  const mx = Math.max(c[0], c[1], c[2]);
+  const mn = Math.min(c[0], c[1], c[2]);
+  if (mx <= 0 || mx - mn <= 1e-9) return c;
+  const t = 1 - mn / mx;
+  const shape = t * (1 - t) * (2 - t + t * t) * mx * Math.max(0, 1 - mx);
+  let t2, v2;
+  if (v < 0) {
+    const a = -v;
+    t2 = t * (1 - a / 4) * (1 - a + a * t * (1 + t) / 2);
+    v2 = mx - a * shape;
+  } else {
+    const [c0, c1, p, q, r0, ra, rt] = VIBRANCE_BOOST;
+    const w = vibranceSkin(hsvHue(c, mx, mn));
+    const a = v * (1 - w) + 0.64 * Math.pow(v, 1.6) * w;
+    const boost = (c0 * a + c1 * a * a) * Math.pow(t, p) * Math.pow(1 - t, q) * Math.exp((r0 + ra * a + rt * (1 - t)) * Math.max(0, 1 - mx));
+    t2 = Math.min(1, t * (1 + boost));
+    v2 = mx + v / 4 * shape;
+  }
+  const m2 = v2 * (1 - t2);
+  const k = (v2 - m2) / (mx - mn);
+  return [m2 + (c[0] - mn) * k, m2 + (c[1] - mn) * k, m2 + (c[2] - mn) * k];
+}
+function vibrancePixel(c, v, s) {
+  let l = [srgbToLinear(Math.max(0, c[0])), srgbToLinear(Math.max(0, c[1])), srgbToLinear(Math.max(0, c[2]))];
+  if (v !== 0) l = vibranceLinear(l, v);
+  if (s !== 0) {
+    const g = VIBRANCE_GREY[0] * l[0] + VIBRANCE_GREY[1] * l[1];
+    l = l.map((x) => Math.min(1, Math.max(0, g + (1 + s) * (x - g))));
+  }
+  return l.map((x) => linearToSrgb(clamp01(x)));
+}
+var BALANCE_LEVELS = 0.39;
+function colorBalanceChannel(tones, preserveLuminosity, ch, v) {
+  const [shadows, midtones, highlights] = tones;
+  const black = (x, b) => Math.max(0, (x - b) / (1 - b));
+  const white = (x, w) => Math.min(1, x / w);
+  let out = clamp01(v);
+  for (const [tone2, sliders] of [
+    [2, highlights],
+    [0, shadows],
+    [1, midtones]
+  ]) {
+    const a = [0, 1, 2].map((i) => Math.min(1, Math.max(-1, sliders[i] / 100)));
+    if (preserveLuminosity) {
+      const own = a[ch] ?? 0;
+      const lo = Math.min(a[0], a[1], a[2]);
+      const hi = Math.max(a[0], a[1], a[2]);
+      if (tone2 === 0) out = black(out, BALANCE_LEVELS * (hi - own));
+      else if (tone2 === 1) out = Math.pow(out, Math.pow(2, (hi + lo) / 2 - own));
+      else out = white(out, 1 - BALANCE_LEVELS * (own - lo));
+      continue;
+    }
+    const s = a[ch];
+    if (s === 0) continue;
+    if (tone2 === 1) out = Math.pow(out, Math.pow(2, -s));
+    else if (tone2 === 0 && s < 0) out = Math.pow(black(out, BALANCE_LEVELS * -s), Math.pow(2, -s / 2));
+    else if (tone2 === 2 && s > 0) out = Math.pow(white(out, 1 - BALANCE_LEVELS * s), Math.pow(2, -s / 2));
+    else out = Math.pow(out, Math.pow(2, -s / 2));
+  }
+  return out;
+}
+function blackWhiteGray(c, weights) {
+  const [r, g, b] = c;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const mid = r + g + b - max - min;
+  const primary = r >= g && r >= b ? 0 : g >= b ? 2 : 4;
+  const secondary = b <= r && b <= g ? 1 : r <= g ? 3 : 5;
+  return clamp01(min + (mid - min) * weights[secondary] / 100 + (max - mid) * weights[primary] / 100);
+}
+var D50 = [0.96422, 1, 0.82521];
+var SRGB_TO_XYZ_D50 = [
+  [0.436074, 0.385064, 0.14308],
+  [0.222504, 0.716878, 0.060618],
+  [0.013932, 0.097104, 0.714173]
+];
+var XYZ_D50_TO_SRGB = [
+  [3.133856, -1.616867, -0.490615],
+  [-0.978768, 1.916142, 0.033454],
+  [0.071945, -0.228991, 1.405243]
+];
+function photoFilterMatrix(color, density, normalizeY = false) {
+  const d = Number.isFinite(density) ? clamp01(density) : 0;
+  const lin = [0, 1, 2].map((i) => srgbToLinear(clamp01(color[i])));
+  const xyz = SRGB_TO_XYZ_D50.map((r) => r[0] * lin[0] + r[1] * lin[1] + r[2] * lin[2]);
+  let s = [0, 1, 2].map((i) => 1 - d + d * xyz[i] / D50[i]);
+  if (normalizeY && s[1] > 1e-6) {
+    const y = s[1];
+    s = s.map((v) => v / y);
+  }
+  return [0, 1, 2].map(
+    (r) => [0, 1, 2].map((c) => XYZ_D50_TO_SRGB[r][0] * s[0] * SRGB_TO_XYZ_D50[0][c] + XYZ_D50_TO_SRGB[r][1] * s[1] * SRGB_TO_XYZ_D50[1][c] + XYZ_D50_TO_SRGB[r][2] * s[2] * SRGB_TO_XYZ_D50[2][c])
+  );
+}
+function posterizeValue(v, levels) {
+  const n = Math.min(255, Math.max(2, Math.round(levels)));
+  const x = Math.round(clamp01(v) * 255);
+  const bin = Math.min(n - 1, Math.floor(x * n / 256));
+  return Math.floor(bin * 255 / (n - 1)) / 255;
+}
+var rgbToGray = (c) => 0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2];
+function hexToRgb(hex) {
+  if (!HEX.test(hex)) return [0, 0, 0];
+  const n = parseInt(hex.slice(1), 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function lutOp(luts) {
+  const [lr, lg, lb] = luts;
+  return (c) => {
+    c[0] = sampleLut(lr, c[0]);
+    c[1] = sampleLut(lg, c[1]);
+    c[2] = sampleLut(lb, c[2]);
+  };
+}
+var isIdentityCurve = (pts) => pts.length === 2 && pts[0].input === 0 && pts[0].output === 0 && pts[1].input === 255 && pts[1].output === 255;
+var isIdentityLevels = (c) => c.inBlack === 0 && c.inWhite === 255 && c.gamma === 1 && c.outBlack === 0 && c.outWhite === 255;
+var LEVELS_QUANTUM = 255;
+function toneLuts(layer) {
+  const n = ADJUSTMENT_LUT_SIZE;
+  if (layer.kind === "curves") {
+    const m = curveLutFromLevels(layer.params.master);
+    return [layer.params.red, layer.params.green, layer.params.blue].map((pts) => {
+      const ch = curveLutFromLevels(pts);
+      for (let k = 0; k < n; k++) ch[k] = sampleLut(m, ch[k]);
+      return ch;
+    });
+  }
+  if (layer.kind === "levels") {
+    const m = toUnitLevels(layer.params.master);
+    return [layer.params.red, layer.params.green, layer.params.blue].map((rec) => {
+      const c = toUnitLevels(rec);
+      const out = new Float32Array(n);
+      for (let k = 0; k < n; k++) out[k] = levelsValue(m, levelsValue(c, k / (n - 1), LEVELS_QUANTUM), LEVELS_QUANTUM);
+      return out;
+    });
+  }
+  return null;
+}
+function compileAdjustmentLayer(layer) {
+  switch (layer.kind) {
+    case "curves": {
+      const p = layer.params;
+      if ([p.master, p.red, p.green, p.blue].every(isIdentityCurve)) return null;
+      return lutOp(toneLuts(layer));
+    }
+    case "levels": {
+      const p = layer.params;
+      if ([p.master, p.red, p.green, p.blue].every(isIdentityLevels)) return null;
+      return lutOp(toneLuts(layer));
+    }
+    case "hueSaturation": {
+      const p = layer.params;
+      const rangesActive = !p.colorize && p.ranges.some((r) => !isNeutralRange(r));
+      if (!p.colorize && !rangesActive && p.hue === 0 && p.saturation === 0 && p.lightness === 0) return null;
+      const tables = rangesActive ? hueRangeTables(p.ranges) : null;
+      const sat2 = p.saturation / 100;
+      const light = Math.min(1, Math.max(-1, p.lightness / 100));
+      return (c) => {
+        let dh = 0, ds = 0, dl = 0;
+        if (tables) {
+          const h0 = rgbToHsl(c)[0];
+          dh = sampleLut(tables[0], h0);
+          ds = sampleLut(tables[1], h0);
+          dl = sampleLut(tables[2], h0);
+        }
+        const out = rangeLightness(hueSaturation(c, p.hue + dh, Math.min(1, Math.max(-1, sat2 + ds)), light, p.colorize), dl);
+        c[0] = out[0];
+        c[1] = out[1];
+        c[2] = out[2];
+      };
+    }
+    case "vibrance": {
+      const v = layer.params.vibrance / 100;
+      const s = layer.params.saturation / 100;
+      if (v === 0 && s === 0) return null;
+      return (c) => {
+        const out = vibrancePixel(c, v, s);
+        c[0] = out[0];
+        c[1] = out[1];
+        c[2] = out[2];
+      };
+    }
+    case "colorBalance": {
+      const p = layer.params;
+      const tones = [p.shadows, p.midtones, p.highlights];
+      if (tones.every((t) => t[0] === 0 && t[1] === 0 && t[2] === 0)) return null;
+      const n = ADJUSTMENT_LUT_SIZE;
+      const luts = [0, 1, 2].map((ch) => {
+        const out = new Float32Array(n);
+        for (let k = 0; k < n; k++) out[k] = colorBalanceChannel(tones, p.preserveLuminosity, ch, k / (n - 1));
+        return out;
+      });
+      return lutOp(luts);
+    }
+    case "blackWhite": {
+      const p = layer.params;
+      const weights = [p.reds, p.yellows, p.greens, p.cyans, p.blues, p.magentas];
+      const tint = p.tint ? hexToRgb(p.tint) : null;
+      return (c) => {
+        const g = blackWhiteGray(c, weights);
+        if (tint) {
+          const t = setLum(tint, g);
+          c[0] = clamp01(t[0]);
+          c[1] = clamp01(t[1]);
+          c[2] = clamp01(t[2]);
+        } else {
+          c[0] = c[1] = c[2] = g;
+        }
+      };
+    }
+    case "photoFilter": {
+      const p = layer.params;
+      if (p.density <= 0) return null;
+      const m = photoFilterMatrix(hexToRgb(p.color), p.density / 100, false);
+      const preserve = p.preserveLuminosity;
+      return (c) => {
+        const l = [srgbToLinear(Math.max(0, c[0])), srgbToLinear(Math.max(0, c[1])), srgbToLinear(Math.max(0, c[2]))];
+        let f = [0, 1, 2].map((r) => linearToSrgb(Math.max(0, m[r][0] * l[0] + m[r][1] * l[1] + m[r][2] * l[2])));
+        if (preserve) {
+          const target = 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2];
+          f = setLum(f, target);
+        }
+        c[0] = clamp01(f[0]);
+        c[1] = clamp01(f[1]);
+        c[2] = clamp01(f[2]);
+      };
+    }
+    case "invert":
+      return (c) => {
+        c[0] = 1 - c[0];
+        c[1] = 1 - c[1];
+        c[2] = 1 - c[2];
+      };
+    case "posterize": {
+      const levels = layer.params.levels;
+      return (c) => {
+        c[0] = posterizeValue(c[0], levels);
+        c[1] = posterizeValue(c[1], levels);
+        c[2] = posterizeValue(c[2], levels);
+      };
+    }
+    case "threshold": {
+      const t = Math.round(layer.params.level);
+      return (c) => {
+        const v = Math.round(rgbToGray(c) * 255) >= t ? 1 : 0;
+        c[0] = c[1] = c[2] = v;
+      };
+    }
+  }
+  return null;
+}
+var COMPILE_CACHE_LIMIT = 64;
+var compileCache = /* @__PURE__ */ new Map();
+function compiledFor(layer) {
+  const key = `${layer.kind}:${JSON.stringify(layer.params)}`;
+  if (compileCache.has(key)) {
+    const op2 = compileCache.get(key);
+    compileCache.delete(key);
+    compileCache.set(key, op2);
+    return op2;
+  }
+  const op = compileAdjustmentLayer(layer);
+  compileCache.set(key, op);
+  if (compileCache.size > COMPILE_CACHE_LIMIT) compileCache.delete(compileCache.keys().next().value);
+  return op;
+}
+function activeAdjustmentLayers(layers) {
+  if (!layers?.length) return [];
+  return layers.filter((l) => l.enabled !== false && (l.opacity ?? 1) > 0 && compiledFor(l) !== null);
+}
+function evaluateAdjustmentLayers(color, layers) {
+  const c = [color[0], color[1], color[2]];
+  for (const layer of layers) applyLayer(c, layer, compiledFor(layer));
+  return c;
+}
+function applyLayer(c, layer, op, coverage = 1) {
+  if (!op || layer.enabled === false) return;
+  const alpha = Math.min(1, Math.max(0, layer.opacity ?? 1)) * coverage;
+  if (alpha <= 0) return;
+  const blend = layer.blend ?? "normal";
+  if (blend === "normal" && alpha >= 1) {
+    op(c);
+    return;
+  }
+  const cb0 = c[0], cb1 = c[1], cb2 = c[2];
+  op(c);
+  const b = blend === "normal" ? c : blendRgb(blend, [cb0, cb1, cb2], c);
+  c[0] = (1 - alpha) * cb0 + alpha * b[0];
+  c[1] = (1 - alpha) * cb1 + alpha * b[1];
+  c[2] = (1 - alpha) * cb2 + alpha * b[2];
+}
+function applyAdjustmentLayers(imageData, layers, masks) {
+  const active = activeAdjustmentLayers(layers);
+  if (!active.length) return;
+  const ops = active.map((l) => compiledFor(l));
+  const planes = active.map((l) => masks?.get(l.id));
+  const data = imageData.data;
+  const len = data.length;
+  const c = [0, 0, 0];
+  for (let i = 0; i < len; i += 4) {
+    if (data[i + 3] === 0) continue;
+    c[0] = data[i] / 255;
+    c[1] = data[i + 1] / 255;
+    c[2] = data[i + 2] / 255;
+    for (let k = 0; k < active.length; k++) {
+      const plane = planes[k];
+      if (plane) {
+        const cov = plane[i >> 2];
+        if (cov > 0) applyLayer(c, active[k], ops[k], cov >= 1 ? 1 : cov);
+      } else {
+        applyLayer(c, active[k], ops[k]);
+      }
+    }
+    data[i] = Math.round(clamp01(c[0]) * 255);
+    data[i + 1] = Math.round(clamp01(c[1]) * 255);
+    data[i + 2] = Math.round(clamp01(c[2]) * 255);
+  }
+}
+function adjustmentLayersKey(layers) {
+  if (!layers?.length) return "";
+  return JSON.stringify(
+    layers.map((l) => {
+      const key = [l.kind, l.enabled !== false, l.opacity ?? 1, l.blend ?? "normal", l.params];
+      if (l.mask) key.push(layerMaskKey(l.mask));
+      return key;
+    })
+  );
+}
+
+// src/image-editor/filters.ts
+function clamp(value, min = 0, max = 255) {
+  return Math.max(min, Math.min(max, value));
+}
+function applyAdjustments(imageData, adjustments, options = {}) {
+  if (normalizeProcessVersion(adjustments.process) === LATEST_PROCESS_VERSION) {
+    applyProcess2Adjustments(imageData, adjustments);
+  } else {
+    applyLegacyAdjustments(imageData, adjustments);
+  }
+  applyAdjustmentLayers(imageData, adjustments.layers, options.layerMasks);
+  if (adjustments.blur > 0) {
+    applyFastBoxBlur(imageData, Math.min(Math.round(adjustments.blur), 40));
+  }
+}
+function applyLegacyAdjustments(imageData, adjustments) {
+  const { brightness, contrast, saturation, exposure, temperature, opacity } = adjustments;
+  const data = imageData.data;
+  const len = data.length;
+  const hasBrightness = brightness !== 0;
+  const hasContrast = contrast !== 0;
+  const hasSaturation = saturation !== 0;
+  const hasExposure = exposure !== 0;
+  const hasTemperature = temperature !== 0;
+  const hasOpacity = opacity < 1;
+  const contrastFactor = hasContrast ? 259 * (contrast + 255) / (255 * (259 - contrast)) : 1;
+  const exposureMultiplier = hasExposure ? Math.pow(2, exposure / 50) : 1;
+  const satMultiplier = hasSaturation ? 1 + saturation / 100 : 1;
+  const tempOffset = hasTemperature ? temperature * 0.8 : 0;
+  if (hasBrightness || hasContrast || hasSaturation || hasExposure || hasTemperature || hasOpacity) {
+    for (let i = 0; i < len; i += 4) {
+      let r = data[i];
+      let g = data[i + 1];
+      let b = data[i + 2];
+      let a = data[i + 3];
+      if (hasExposure) {
+        r = clamp(r * exposureMultiplier);
+        g = clamp(g * exposureMultiplier);
+        b = clamp(b * exposureMultiplier);
+      }
+      if (hasBrightness) {
+        const bOffset = brightness * 2.55;
+        r = clamp(r + bOffset);
+        g = clamp(g + bOffset);
+        b = clamp(b + bOffset);
+      }
+      if (hasContrast) {
+        r = clamp(contrastFactor * (r - 128) + 128);
+        g = clamp(contrastFactor * (g - 128) + 128);
+        b = clamp(contrastFactor * (b - 128) + 128);
+      }
+      if (hasSaturation) {
+        const luminance = 0.2989 * r + 0.587 * g + 0.114 * b;
+        r = clamp(luminance + (r - luminance) * satMultiplier);
+        g = clamp(luminance + (g - luminance) * satMultiplier);
+        b = clamp(luminance + (b - luminance) * satMultiplier);
+      }
+      if (hasTemperature) {
+        r = clamp(r + tempOffset);
+        b = clamp(b - tempOffset);
+      }
+      if (hasOpacity) {
+        a = clamp(a * opacity);
+      }
+      data[i] = r;
+      data[i + 1] = g;
+      data[i + 2] = b;
+      data[i + 3] = a;
+    }
+  }
+}
+var DECODE_LUT = (() => {
+  const lut = new Float32Array(256);
+  for (let i = 0; i < 256; i++) lut[i] = srgbToLinear(i / 255);
+  return lut;
+})();
+var ENCODE_LUT_SIZE = 65535;
+var encodeLut = null;
+function getEncodeLut() {
+  if (!encodeLut) {
+    encodeLut = new Uint8Array(ENCODE_LUT_SIZE + 1);
+    for (let i = 0; i <= ENCODE_LUT_SIZE; i++) {
+      encodeLut[i] = Math.round(linearToSrgb(i / ENCODE_LUT_SIZE) * 255);
+    }
+  }
+  return encodeLut;
+}
+var cachedPlan = null;
+function getProcess2Plan(adjustments) {
+  const exposure = adjustments.exposure || 0;
+  const temperature = adjustments.temperature || 0;
+  const tint = adjustments.tint || 0;
+  const contrast = adjustments.contrast || 0;
+  const brightness = adjustments.brightness || 0;
+  const saturation = 1 + (adjustments.saturation || 0) / 100;
+  const key = `${exposure},${temperature},${tint},${contrast},${brightness},${saturation}`;
+  if (cachedPlan && cachedPlan.key === key) return cachedPlan;
+  const gain = Math.pow(2, exposure / 50);
+  const wb = whiteBalanceMatrix(temperature, tint);
+  const m = new Float64Array(9);
+  for (let i = 0; i < 9; i++) m[i] = wb[i] * gain;
+  const luts = [];
+  const scale = [0, 0, 0];
+  for (let c = 0; c < 3; c++) {
+    let reach = 0;
+    for (let k = 0; k < 3; k++) reach += Math.max(0, m[c * 3 + k]);
+    const headroom = Math.max(1, reach);
+    luts[c] = buildToneLut(contrast, brightness, headroom);
+    scale[c] = TONE_LUT_SIZE / headroom;
+  }
+  cachedPlan = { key, m, luts, scale, saturation };
+  return cachedPlan;
+}
+function applyProcess2Adjustments(imageData, adjustments) {
+  const data = imageData.data;
+  const len = data.length;
+  const opacity = adjustments.opacity ?? 1;
+  const hasOpacity = opacity < 1;
+  const hasColor = !!adjustments.brightness || !!adjustments.contrast || !!adjustments.saturation || !!adjustments.exposure || !!adjustments.temperature || !!adjustments.tint;
+  if (!hasColor) {
+    if (hasOpacity) {
+      for (let i = 3; i < len; i += 4) data[i] = clamp(data[i] * opacity);
+    }
+    return;
+  }
+  const plan = getProcess2Plan(adjustments);
+  const dec = DECODE_LUT;
+  const enc = getEncodeLut();
+  const { m, luts, scale, saturation } = plan;
+  const m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7], m8 = m[8];
+  const lutR = luts[0], lutG = luts[1], lutB = luts[2];
+  const sR = scale[0], sG = scale[1], sB = scale[2];
+  const N = TONE_LUT_SIZE;
+  const hasSaturation = saturation !== 1;
+  const wr = LUMA_709[0], wg = LUMA_709[1], wb = LUMA_709[2];
+  for (let i = 0; i < len; i += 4) {
+    const r0 = dec[data[i]];
+    const g0 = dec[data[i + 1]];
+    const b0 = dec[data[i + 2]];
+    let r = m0 * r0 + m1 * g0 + m2 * b0;
+    let g = m3 * r0 + m4 * g0 + m5 * b0;
+    let b = m6 * r0 + m7 * g0 + m8 * b0;
+    let f;
+    let k;
+    if (r <= 0) r = lutR[0];
+    else if ((f = r * sR) >= N) r = lutR[N];
+    else {
+      k = f | 0;
+      r = lutR[k] + (lutR[k + 1] - lutR[k]) * (f - k);
+    }
+    if (g <= 0) g = lutG[0];
+    else if ((f = g * sG) >= N) g = lutG[N];
+    else {
+      k = f | 0;
+      g = lutG[k] + (lutG[k + 1] - lutG[k]) * (f - k);
+    }
+    if (b <= 0) b = lutB[0];
+    else if ((f = b * sB) >= N) b = lutB[N];
+    else {
+      k = f | 0;
+      b = lutB[k] + (lutB[k + 1] - lutB[k]) * (f - k);
+    }
+    if (hasSaturation) {
+      const y = wr * r + wg * g + wb * b;
+      r = y + (r - y) * saturation;
+      g = y + (g - y) * saturation;
+      b = y + (b - y) * saturation;
+    }
+    data[i] = enc[r <= 0 ? 0 : r >= 1 ? ENCODE_LUT_SIZE : r * ENCODE_LUT_SIZE + 0.5 | 0];
+    data[i + 1] = enc[g <= 0 ? 0 : g >= 1 ? ENCODE_LUT_SIZE : g * ENCODE_LUT_SIZE + 0.5 | 0];
+    data[i + 2] = enc[b <= 0 ? 0 : b >= 1 ? ENCODE_LUT_SIZE : b * ENCODE_LUT_SIZE + 0.5 | 0];
+    if (hasOpacity) data[i + 3] = clamp(data[i + 3] * opacity);
+  }
+}
+function applyFastBoxBlur(imageData, radius) {
+  if (radius < 1) return;
+  const w = imageData.width;
+  const h = imageData.height;
+  const src = imageData.data;
+  const temp = new Uint8ClampedArray(src.length);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      let r = 0, g = 0, b = 0, a = 0;
+      let count = 0;
+      for (let k = -radius; k <= radius; k++) {
+        const px = Math.min(w - 1, Math.max(0, x + k));
+        const idx = (y * w + px) * 4;
+        r += src[idx];
+        g += src[idx + 1];
+        b += src[idx + 2];
+        a += src[idx + 3];
+        count++;
+      }
+      const dstIdx = (y * w + x) * 4;
+      temp[dstIdx] = Math.round(r / count);
+      temp[dstIdx + 1] = Math.round(g / count);
+      temp[dstIdx + 2] = Math.round(b / count);
+      temp[dstIdx + 3] = Math.round(a / count);
+    }
+  }
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) {
+      let r = 0, g = 0, b = 0, a = 0;
+      let count = 0;
+      for (let k = -radius; k <= radius; k++) {
+        const py = Math.min(h - 1, Math.max(0, y + k));
+        const idx = (py * w + x) * 4;
+        r += temp[idx];
+        g += temp[idx + 1];
+        b += temp[idx + 2];
+        a += temp[idx + 3];
+        count++;
+      }
+      const dstIdx = (y * w + x) * 4;
+      src[dstIdx] = Math.round(r / count);
+      src[dstIdx + 1] = Math.round(g / count);
+      src[dstIdx + 2] = Math.round(b / count);
+      src[dstIdx + 3] = Math.round(a / count);
+    }
+  }
+}
+function applyDepthMask(mainImageData, maskImageData, options) {
+  const { mode, depthRange, softness, invert } = options;
+  const mainData = mainImageData.data;
+  const maskData = maskImageData.data;
+  const len = Math.min(mainData.length, maskData.length);
+  const effectiveSoftness = Math.max(1, softness || 10);
+  const minDepth = depthRange[0];
+  const maxDepth = depthRange[1];
+  for (let i = 0; i < len; i += 4) {
+    let maskValue = maskData[i];
+    if (invert) {
+      maskValue = 255 - maskValue;
+    }
+    let alphaValue;
+    if (mode === "threshold") {
+      if (maskValue >= maxDepth + effectiveSoftness) {
+        alphaValue = 0;
+      } else if (maskValue > maxDepth) {
+        alphaValue = Math.round((maxDepth + effectiveSoftness - maskValue) / effectiveSoftness * 255);
+      } else if (maskValue >= minDepth) {
+        alphaValue = 255;
+      } else if (maskValue < minDepth - effectiveSoftness) {
+        alphaValue = 0;
+      } else {
+        alphaValue = Math.round((maskValue - (minDepth - effectiveSoftness)) / effectiveSoftness * 255);
+      }
+    } else {
+      alphaValue = clamp(maskValue + minDepth);
+    }
+    mainData[i + 3] = clamp(mainData[i + 3] * alphaValue / 255);
+  }
+}
+function removeAlpha(imageData) {
+  const data = imageData.data;
+  const len = data.length;
+  for (let i = 3; i < len; i += 4) {
+    data[i] = 255;
   }
-  if (handle === "w" || handle === "nw" || handle === "sw") {
-    left = Math.max(0, Math.min(right - minSize, startCrop.x + dx));
+}
+
+// src/image-editor/histogram.ts
+var HISTOGRAM_BINS = 256;
+function computeHistogram(imageData) {
+  const red = new Uint32Array(HISTOGRAM_BINS);
+  const green = new Uint32Array(HISTOGRAM_BINS);
+  const blue = new Uint32Array(HISTOGRAM_BINS);
+  const luminance = new Uint32Array(HISTOGRAM_BINS);
+  const shadows = [0, 0, 0];
+  const highlights = [0, 0, 0];
+  let samples = 0;
+  let transparent = 0;
+  const data = imageData.data;
+  const len = data.length - data.length % 4;
+  for (let i = 0; i < len; i += 4) {
+    if (!(data[i + 3] > 0)) {
+      transparent++;
+      continue;
+    }
+    samples++;
+    const r = clampByte(data[i]);
+    const g = clampByte(data[i + 1]);
+    const b = clampByte(data[i + 2]);
+    red[r]++;
+    green[g]++;
+    blue[b]++;
+    luminance[Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b)]++;
+    if (r === 0) shadows[0]++;
+    if (g === 0) shadows[1]++;
+    if (b === 0) shadows[2]++;
+    if (r === 255) highlights[0]++;
+    if (g === 255) highlights[1]++;
+    if (b === 255) highlights[2]++;
   }
-  if (handle === "s" || handle === "se" || handle === "sw") {
-    bottom = Math.min(imgHeight, Math.max(top + minSize, startCrop.y + startCrop.height + dy));
+  let max = 0;
+  for (const bins of [red, green, blue, luminance]) {
+    for (let k = 0; k < HISTOGRAM_BINS; k++) if (bins[k] > max) max = bins[k];
   }
-  if (handle === "n" || handle === "nw" || handle === "ne") {
-    top = Math.max(0, Math.min(bottom - minSize, startCrop.y + dy));
+  return { red, green, blue, luminance, samples, transparent, shadows, highlights, max };
+}
+function clampByte(v) {
+  return v <= 0 ? 0 : v >= 255 ? 255 : Math.round(v);
+}
+function histogramPath(histogram, channel, width, height, options = {}) {
+  const bins = histogram[channel];
+  const sqrt = (options.scale ?? "sqrt") === "sqrt";
+  const f = (v) => sqrt ? Math.sqrt(v) : v;
+  const top = f(options.max ?? histogram.max) || 1;
+  const dx = width / (HISTOGRAM_BINS - 1);
+  let d = `M0 ${height}`;
+  for (let k = 0; k < HISTOGRAM_BINS; k++) {
+    const y = height - f(bins[k]) / top * height;
+    d += ` L${round2(k * dx)} ${round2(y)}`;
   }
-  if (aspectRatio && aspectRatio > 0) {
-    let currentW = right - left;
-    let currentH = bottom - top;
-    if (handle === "e" || handle === "w") {
-      currentH = Math.min(imgHeight, currentW / aspectRatio);
-      bottom = Math.min(imgHeight, top + currentH);
-    } else if (handle === "n" || handle === "s") {
-      currentW = Math.min(imgWidth, currentH * aspectRatio);
-      right = Math.min(imgWidth, left + currentW);
-    } else {
-      const targetH = currentW / aspectRatio;
-      if (top + targetH <= imgHeight) {
-        bottom = top + targetH;
-      } else {
-        const targetW = currentH * aspectRatio;
-        right = Math.min(imgWidth, left + targetW);
+  return `${d} L${round2(width)} ${height} Z`;
+}
+var round2 = (v) => Math.round(v * 100) / 100;
+
+// src/image-editor/selection/overlay.ts
+function selectionOutline(mask, threshold = 128) {
+  const { width: w, height: h, data } = mask;
+  const segs = [];
+  if (!mask.bounds) return new Float32Array(0);
+  const b = mask.bounds;
+  const inside = (x, y) => x >= 0 && y >= 0 && x < w && y < h && data[y * w + x] >= threshold;
+  for (let y = b.y; y <= b.y + b.height; y++) {
+    let start = -1;
+    for (let x = b.x; x <= b.x + b.width; x++) {
+      const edge = x < b.x + b.width && inside(x, y - 1) !== inside(x, y);
+      if (edge && start < 0) start = x;
+      else if (!edge && start >= 0) {
+        segs.push(start, y, x, y);
+        start = -1;
       }
     }
   }
-  return {
-    x: Math.round(left),
-    y: Math.round(top),
-    width: Math.round(Math.max(minSize, right - left)),
-    height: Math.round(Math.max(minSize, bottom - top))
-  };
-}
-function getAnnotationBounds(ann) {
-  switch (ann.type) {
-    case "rect":
-    case "image":
-      return {
-        x: Math.min(ann.x, ann.x + ann.width),
-        y: Math.min(ann.y, ann.y + ann.height),
-        width: Math.abs(ann.width),
-        height: Math.abs(ann.height)
-      };
-    case "circle":
-      return {
-        x: ann.x - Math.abs(ann.radiusX),
-        y: ann.y - Math.abs(ann.radiusY),
-        width: Math.abs(ann.radiusX) * 2,
-        height: Math.abs(ann.radiusY) * 2
-      };
-    case "arrow":
-    case "line": {
-      const minX = Math.min(ann.x, ann.endX);
-      const minY = Math.min(ann.y, ann.endY);
-      return {
-        x: minX,
-        y: minY,
-        width: Math.max(Math.abs(ann.endX - ann.x), 10),
-        height: Math.max(Math.abs(ann.endY - ann.y), 10)
-      };
-    }
-    case "pen": {
-      if (!ann.points.length) return { x: ann.x, y: ann.y, width: 0, height: 0 };
-      let minX = ann.points[0].x;
-      let maxX = ann.points[0].x;
-      let minY = ann.points[0].y;
-      let maxY = ann.points[0].y;
-      for (const pt of ann.points) {
-        if (pt.x < minX) minX = pt.x;
-        if (pt.x > maxX) maxX = pt.x;
-        if (pt.y < minY) minY = pt.y;
-        if (pt.y > maxY) maxY = pt.y;
+  for (let x = b.x; x <= b.x + b.width; x++) {
+    let start = -1;
+    for (let y = b.y; y <= b.y + b.height; y++) {
+      const edge = y < b.y + b.height && inside(x - 1, y) !== inside(x, y);
+      if (edge && start < 0) start = y;
+      else if (!edge && start >= 0) {
+        segs.push(x, start, x, y);
+        start = -1;
       }
-      return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
     }
-    case "text":
-      return {
-        x: ann.x,
-        y: ann.y,
-        width: ann.text.length * ann.fontSize * 0.6,
-        height: ann.fontSize * 1.2
-      };
   }
+  return Float32Array.from(segs);
 }
-function hitTestAnnotation(imgPt, ann, padding = 10) {
-  const b = getAnnotationBounds(ann);
-  return imgPt.x >= b.x - padding && imgPt.x <= b.x + b.width + padding && imgPt.y >= b.y - padding && imgPt.y <= b.y + b.height + padding;
+function quickMaskPixels(mask, style = {}) {
+  const [r, g, b] = style.color ?? [255, 0, 0];
+  const k = Math.min(1, Math.max(0, style.opacity ?? 0.5));
+  const out = new Uint8ClampedArray(mask.data.length * 4);
+  for (let i = 0, p = 0; i < mask.data.length; i++, p += 4) {
+    out[p] = r;
+    out[p + 1] = g;
+    out[p + 2] = b;
+    out[p + 3] = Math.round((255 - mask.data[i]) * k);
+  }
+  return out;
 }
 
 // src/image-editor/renderer.ts
@@ -881,6 +2620,13 @@ var ImageEditorRenderer = class {
   imageCache = globalImageCache;
   cachedBaseCanvas = null;
   cachedBaseKey = "";
+  /**
+   * Histogram of the last viewport base render (after adjustments and layers, before
+   * annotations); `null` until a render with pixel access has happened.
+   */
+  previewHistogram = null;
+  /** Called whenever the viewport base image is re-rendered with the new histogram. */
+  onPreviewHistogram;
   sourceIds = /* @__PURE__ */ new WeakMap();
   nextSourceId = 0;
   /**
@@ -937,13 +2683,19 @@ var ImageEditorRenderer = class {
       `${region.x},${region.y},${region.width},${region.height}`,
       `${projection.angle},${transform.flipH},${transform.flipV}`,
       `${adjustments.brightness},${adjustments.contrast},${adjustments.saturation},${adjustments.exposure},${adjustments.temperature},${adjustments.tint ?? 0},${adjustments.blur},${adjustments.opacity},p${normalizeProcessVersion(adjustments.process)}`,
+      adjustmentLayersKey(adjustments.layers),
       `${depthMask.enabled},${depthMask.maskSource},${depthMask.depthRange?.[0]}-${depthMask.depthRange?.[1]},${depthMask.softness},${depthMask.invert},${depthMask.mode}`
     ].join("|");
     let baseCanvas = this.cachedBaseCanvas;
     if (!baseCanvas || this.cachedBaseKey !== baseKey) {
-      baseCanvas = await this.renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state);
+      let histogram = null;
+      baseCanvas = await this.renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state, (pixels) => {
+        histogram = computeHistogram(pixels);
+      });
       this.cachedBaseCanvas = baseCanvas;
       this.cachedBaseKey = baseKey;
+      this.previewHistogram = histogram;
+      this.onPreviewHistogram?.(histogram);
     }
     const drawW = rotated.width * projection.scale;
     const drawH = rotated.height * projection.scale;
@@ -965,6 +2717,21 @@ var ImageEditorRenderer = class {
       }
       ctx.restore();
     }
+    const display = options.selectionDisplay ?? (state.quickMask ? "quickMask" : "ants");
+    if (state.selection?.bounds && display !== "none" || options.draftSelectionPath?.length) {
+      ctx.save();
+      try {
+        applyImageProjectionToContext(ctx, projection);
+        ctx.beginPath();
+        ctx.rect(region.x, region.y, region.width, region.height);
+        ctx.clip();
+        if (state.selection?.bounds && display === "quickMask") this.drawQuickMask(ctx, state.selection);
+        else if (state.selection?.bounds && display === "ants") this.drawAnts(ctx, state.selection, projection.scale, options.antsOffset ?? 0);
+        if (options.draftSelectionPath?.length) this.drawDraftPath(ctx, options.draftSelectionPath, projection.scale);
+      } catch {
+      }
+      ctx.restore();
+    }
     if (isActivelyCropping) {
       const activeCrop = options.draftCrop !== void 0 && options.draftCrop !== null ? options.draftCrop : crop ?? { x: 0, y: 0, width: naturalWidth, height: naturalHeight };
       this.drawCropOverlay(ctx, getViewportMetrics(geoState, vpWidth, vpHeight, true, activeCrop));
@@ -974,7 +2741,7 @@ var ImageEditorRenderer = class {
    * Draws `region` of the source image with rotation/flip applied, then pixel adjustments
    * and the depth mask (which receives the identical transform so it stays aligned).
    */
-  async renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state) {
+  async renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state, onPixels) {
     const { adjustments, depthMask } = state;
     const rotated = getRotatedSize(region.width, region.height, transform);
     const baseW = Math.max(1, Math.round(rotated.width));
@@ -999,7 +2766,8 @@ var ImageEditorRenderer = class {
     baseCtx.restore();
     const imageData = baseCtx.getImageData(0, 0, baseW, baseH);
     if (imageData) {
-      applyAdjustments(imageData, adjustments);
+      const layerMasks = buildLayerMaskPlanes(adjustments.layers, naturalWidth, naturalHeight, projection, baseW, baseH);
+      applyAdjustments(imageData, adjustments, layerMasks ? { layerMasks } : {});
       if (depthMask.enabled && depthMask.maskSource) {
         try {
           const maskImg = await this.imageCache.get(depthMask.maskSource);
@@ -1031,10 +2799,65 @@ var ImageEditorRenderer = class {
         } catch {
         }
       }
+      onPixels?.(imageData);
       baseCtx.putImageData(imageData, 0, 0);
     }
     return baseCanvas;
   }
+  quickMaskCache = /* @__PURE__ */ new WeakMap();
+  outlineCache = /* @__PURE__ */ new WeakMap();
+  /** Rubylith over the unselected area, drawn in natural image space. */
+  drawQuickMask(ctx, selection) {
+    let canvas = this.quickMaskCache.get(selection);
+    if (!canvas) {
+      canvas = this.createCanvas(selection.width, selection.height);
+      const mctx = canvas.getContext("2d");
+      if (!mctx || typeof mctx.createImageData !== "function") return;
+      const img = mctx.createImageData(selection.width, selection.height);
+      img.data.set(quickMaskPixels(selection));
+      mctx.putImageData(img, 0, 0);
+      this.quickMaskCache.set(selection, canvas);
+    }
+    ctx.drawImage(canvas, 0, 0, selection.width, selection.height);
+  }
+  /** Marching ants: a white line under a black dashed one, one screen pixel wide. */
+  drawAnts(ctx, selection, scale, offset) {
+    let segs = this.outlineCache.get(selection);
+    if (!segs) {
+      segs = selectionOutline(selection);
+      this.outlineCache.set(selection, segs);
+    }
+    if (!segs.length) return;
+    const px = 1 / (scale || 1);
+    ctx.beginPath();
+    for (let i = 0; i < segs.length; i += 4) {
+      ctx.moveTo(segs[i], segs[i + 1]);
+      ctx.lineTo(segs[i + 2], segs[i + 3]);
+    }
+    ctx.lineWidth = px;
+    ctx.strokeStyle = "#ffffff";
+    ctx.stroke();
+    if (typeof ctx.setLineDash === "function") {
+      ctx.setLineDash([4 * px, 4 * px]);
+      ctx.lineDashOffset = -offset * px;
+    }
+    ctx.strokeStyle = "#000000";
+    ctx.stroke();
+    if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
+  }
+  drawDraftPath(ctx, points, scale) {
+    const px = 1 / (scale || 1);
+    ctx.beginPath();
+    points.forEach((p, i) => i === 0 ? ctx.moveTo(p.x, p.y) : ctx.lineTo(p.x, p.y));
+    ctx.closePath();
+    ctx.lineWidth = px;
+    ctx.strokeStyle = "#ffffff";
+    ctx.stroke();
+    if (typeof ctx.setLineDash === "function") ctx.setLineDash([4 * px, 4 * px]);
+    ctx.strokeStyle = "#000000";
+    ctx.stroke();
+    if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
+  }
   getSourceId(img) {
     const key = img;
     let id = this.sourceIds.get(key);
@@ -1048,6 +2871,59 @@ var ImageEditorRenderer = class {
    * Draws an individual annotation onto the canvas.
    */
   async drawAnnotation(ctx, ann) {
+    const blend = normalizeBlendMode(ann.blend);
+    if (blend === "normal") {
+      await this.drawAnnotationContent(ctx, ann);
+      return;
+    }
+    const op = canvasCompositeOperation(blend);
+    if (op) {
+      ctx.save();
+      ctx.globalCompositeOperation = op;
+      await this.drawAnnotationContent(ctx, ann);
+      ctx.restore();
+      return;
+    }
+    if (!await this.drawAnnotationBlended(ctx, ann)) {
+      await this.drawAnnotationContent(ctx, ann);
+    }
+  }
+  /**
+   * Scalar fallback for blend modes the canvas cannot composite (Photoshop soft light, linear /
+   * vivid / pin light, hard mix, subtract, divide, darker / lighter colour, linear burn / dodge):
+   * draws the annotation on a same-size layer with the same transform, blends it into a copy of
+   * the target's pixels with `blendImageData`, and copies the result back inside the current clip.
+   */
+  async drawAnnotationBlended(ctx, ann) {
+    const canvas = ctx.canvas;
+    if (!canvas || typeof ctx.getTransform !== "function" || typeof ctx.getImageData !== "function") return false;
+    const w = canvas.width;
+    const h = canvas.height;
+    const layer = this.createCanvas(w, h);
+    const lctx = layer.getContext("2d");
+    if (!lctx) return false;
+    try {
+      lctx.setTransform(ctx.getTransform());
+      lctx.globalAlpha = ctx.globalAlpha;
+      await this.drawAnnotationContent(lctx, ann);
+      const backdrop = ctx.getImageData(0, 0, w, h);
+      const source = lctx.getImageData(0, 0, w, h);
+      if (!backdrop || !source) return false;
+      blendImageData(backdrop, source, normalizeBlendMode(ann.blend));
+      lctx.setTransform(1, 0, 0, 1, 0, 0);
+      lctx.putImageData(backdrop, 0, 0);
+    } catch {
+      return false;
+    }
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.globalAlpha = 1;
+    ctx.globalCompositeOperation = "copy";
+    ctx.drawImage(layer, 0, 0);
+    ctx.restore();
+    return true;
+  }
+  async drawAnnotationContent(ctx, ann) {
     ctx.save();
     if (ann.opacity !== void 0) {
       ctx.globalAlpha = ann.opacity;
@@ -1315,10 +3191,11 @@ var ImageEditorRenderer = class {
       }
     }
     const imageData = ctx.getImageData?.(0, 0, naturalWidth, naturalHeight);
+    const selection = (options?.useSelection ?? true) && state.selection?.bounds && state.selection.width === naturalWidth && state.selection.height === naturalHeight ? state.selection : null;
     if (imageData) {
       const d = imageData.data;
       for (let i = 0; i < d.length; i += 4) {
-        const v = d[i] >= 128 ? 255 : 0;
+        const v = d[i] >= 128 || selection !== null && selection.data[i >> 2] >= 128 ? 255 : 0;
         d[i] = v;
         d[i + 1] = v;
         d[i + 2] = v;
@@ -1388,19 +3265,570 @@ function getSourceSize(img, fallbackW = 800, fallbackH = 600) {
     height: anyImg.naturalHeight || anyImg.videoHeight || anyImg.height || fallbackH
   };
 }
-function getBaseProjection(region, transform, baseW, baseH) {
-  return {
-    region,
-    angle: normalizeAngle(transform.rotate),
-    flipH: transform.flipH,
-    flipV: transform.flipV,
-    scale: 1,
-    originX: baseW / 2,
-    originY: baseH / 2
-  };
+function getBaseProjection(region, transform, baseW, baseH) {
+  return {
+    region,
+    angle: normalizeAngle(transform.rotate),
+    flipH: transform.flipH,
+    flipV: transform.flipV,
+    scale: 1,
+    originX: baseW / 2,
+    originY: baseH / 2
+  };
+}
+
+// src/image-editor/selection/shapes.ts
+function polygonCoverage(points, width, height, antiAlias = true) {
+  const m = new Float32Array(width * height);
+  if (points.length < 3 || width <= 0 || height <= 0) return m;
+  const sub = 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 = 0; py < height; py++) {
+    const row = py * width;
+    for (let s = 0; s < sub; s++) {
+      const y = py + (s + 0.5) / sub;
+      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 / sub;
+        }
+      }
+    }
+  }
+  for (let i = 0; i < m.length; i++) if (m[i] > 1) m[i] = 1;
+  return m;
+}
+function toMask(width, height, coverage) {
+  const out = new Uint8Array(coverage.length);
+  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
+  return createSelectionMask(width, height, out);
+}
+function polygonSelection(width, height, points, options = {}) {
+  return toMask(width, height, polygonCoverage(points, width, height, options.antiAlias ?? true));
+}
+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_LINEAR = (() => {
+  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_LINEAR[r & 255];
+  const gl = SRGB_TO_LINEAR[g & 255];
+  const bl = SRGB_TO_LINEAR[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;
+        }
+      }
+    }
+  }
+  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);
+  }
+  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 ramp = 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 / ramp);
+  }
+  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));
+  }
+  return createSelectionMask(pixels.width, pixels.height, out);
+}
+
+// src/image-editor/selection/refine.ts
+var DEFAULT_REFINE_EDGE_PARAMS = {
+  radius: 0,
+  smartRadius: false,
+  smooth: 0,
+  feather: 0,
+  contrast: 0,
+  shiftEdge: 0
+};
+var GUIDED_FILTER_EPS = 1e-4;
+var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function normalizeRefineEdgeParams(p = {}) {
+  return {
+    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
+    smartRadius: p.smartRadius === true,
+    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
+    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
+    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
+    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
+  };
+}
+var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
+var smoothSigma = (p) => p.smooth / 100 * 4;
+var featherSigma = (p) => p.feather / 2;
+function shiftAmount(p) {
+  const px = p.shiftEdge / 100 * Math.max(p.radius, 4);
+  return Number.isFinite(px) ? Math.min(64, Math.max(-64, px)) : 0;
+}
+function refineEdgeHalo(params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  const g = gfRadius(p);
+  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
+  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
+}
+function boxMean(src, w, h, r) {
+  const tmp = new Float32Array(w * h);
+  const pre = new Float64Array(Math.max(w, h) + 1);
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
+    for (let x = 0; x < w; x++) {
+      const lo = Math.max(0, x - r);
+      const hi = Math.min(w, x + r + 1);
+      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  const out = new Float32Array(w * h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
+    for (let y = 0; y < h; y++) {
+      const lo = Math.max(0, y - r);
+      const hi = Math.min(h, y + r + 1);
+      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  return out;
+}
+function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
+  const n = w * h;
+  const [c0, c1, c2] = guide;
+  const prod = (a, b2) => {
+    const o = new Float32Array(n);
+    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
+    return o;
+  };
+  const m0 = boxMean(c0, w, h, r);
+  const m1 = boxMean(c1, w, h, r);
+  const m2 = boxMean(c2, w, h, r);
+  const mp = boxMean(p, w, h, r);
+  const mip0 = boxMean(prod(c0, p), w, h, r);
+  const mip1 = boxMean(prod(c1, p), w, h, r);
+  const mip2 = boxMean(prod(c2, p), w, h, r);
+  const s00 = boxMean(prod(c0, c0), w, h, r);
+  const s01 = boxMean(prod(c0, c1), w, h, r);
+  const s02 = boxMean(prod(c0, c2), w, h, r);
+  const s11 = boxMean(prod(c1, c1), w, h, r);
+  const s12 = boxMean(prod(c1, c2), w, h, r);
+  const s22 = boxMean(prod(c2, c2), w, h, r);
+  const a0 = new Float32Array(n);
+  const a1 = new Float32Array(n);
+  const a2 = new Float32Array(n);
+  const b = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
+    const rr = s00[i] - u0 * u0 + eps;
+    const rg = s01[i] - u0 * u1;
+    const rb = s02[i] - u0 * u2;
+    const gg = s11[i] - u1 * u1 + eps;
+    const gb = s12[i] - u1 * u2;
+    const bb = s22[i] - u2 * u2 + eps;
+    const v0 = mip0[i] - u0 * up;
+    const v1 = mip1[i] - u1 * up;
+    const v2 = mip2[i] - u2 * up;
+    const i00 = gg * bb - gb * gb;
+    const i01 = gb * rb - rg * bb;
+    const i02 = rg * gb - gg * rb;
+    const i11 = rr * bb - rb * rb;
+    const i12 = rb * rg - rr * gb;
+    const i22 = rr * gg - rg * rg;
+    const det = rr * i00 + rg * i01 + rb * i02;
+    let x0 = 0, x1 = 0, x2 = 0;
+    if (Math.abs(det) >= 1e-30) {
+      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
+      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
+      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
+    }
+    a0[i] = x0;
+    a1[i] = x1;
+    a2[i] = x2;
+    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
+  }
+  const ma0 = boxMean(a0, w, h, r);
+  const ma1 = boxMean(a1, w, h, r);
+  const ma2 = boxMean(a2, w, h, r);
+  const mb = boxMean(b, w, h, r);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
+  return out;
+}
+function edgeWidth(guide, w, h, r) {
+  const n = w * h;
+  const y = new Float32Array(n);
+  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
+  const g = new Float32Array(n);
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
+      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
+      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
+    }
+  }
+  const gm = greyMorphology(g, w, h, r, true);
+  const hi = greyMorphology(y, w, h, r, true);
+  const lo = greyMorphology(y, w, h, r, false);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
+  return out;
+}
+function refineCoverage(guide, m, w, h, params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  let a = Float32Array.from(m);
+  if (p.radius > 0 && guide) {
+    const n = w * h;
+    const boundary = new Uint8Array(n);
+    let any = false;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const i = y * w + x;
+        const v = m[i] >= 0.5;
+        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
+        if (diff) {
+          boundary[i] = 1;
+          any = true;
+        }
+      }
+    }
+    if (any) {
+      const dist = distanceTransform(boundary, w, h);
+      const r = gfRadius(p);
+      const q = guidedFilterColor(guide, m, w, h, r);
+      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
+      for (let i = 0; i < n; i++) {
+        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
+        const wgt = Math.min(1, Math.max(0, reff + 1 - dist[i]));
+        if (wgt > 0) {
+          const qi = Math.min(1, Math.max(0, q[i]));
+          a[i] = m[i] + (qi - m[i]) * wgt;
+        }
+      }
+    }
+  }
+  const ss = smoothSigma(p);
+  if (ss >= 0.3) {
+    a = gaussianBlur(a, w, h, ss, "clamp");
+    const gain = 1 + ss;
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
+  if (p.contrast > 0) {
+    const gain = 1 / (1 - 0.99 * p.contrast / 100);
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  const amount = shiftAmount(p);
+  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
+  return a;
+}
+function guidePlanes(pixels, win) {
+  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
+  const n = box.width * box.height;
+  const r = new Float32Array(n);
+  const g = new Float32Array(n);
+  const b = new Float32Array(n);
+  const d = pixels.data;
+  for (let y = 0; y < box.height; y++) {
+    for (let x = 0; x < box.width; x++) {
+      const i = y * box.width + x;
+      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
+      r[i] = d[p] / 255;
+      g[i] = d[p + 1] / 255;
+      b[i] = d[p + 2] / 255;
+    }
+  }
+  return [r, g, b];
+}
+function refineSelection(pixels, mask, params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
+    throw new Error("Refine Edge needs pixels the size of the selection");
+  }
+  if (!mask.bounds) return mask;
+  const halo = refineEdgeHalo(p);
+  const x0 = Math.max(0, mask.bounds.x - halo);
+  const y0 = Math.max(0, mask.bounds.y - halo);
+  const x1 = Math.min(mask.width, mask.bounds.x + mask.bounds.width + halo);
+  const y1 = Math.min(mask.height, mask.bounds.y + mask.bounds.height + halo);
+  const ww = x1 - x0;
+  const wh = y1 - y0;
+  const m = new Float32Array(ww * wh);
+  for (let y = 0; y < wh; y++) {
+    const src = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
+  }
+  const guide = pixels && p.radius > 0 ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
+  const refined = refineCoverage(guide, m, ww, wh, p);
+  const out = new Uint8Array(mask.width * mask.height);
+  for (let y = 0; y < wh; y++) {
+    const dst = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
+  }
+  return createSelectionMask(mask.width, mask.height, out);
 }
 
 // src/image-editor/controller.ts
+var IMAGE_EDITOR_SCHEMA_VERSION = 2;
 var DEFAULT_ADJUSTMENTS = {
   brightness: 0,
   contrast: 0,
@@ -1414,11 +3842,31 @@ var DEFAULT_ADJUSTMENTS = {
 };
 function normalizeStoredAdjustments(stored) {
   if (!stored) return { ...DEFAULT_ADJUSTMENTS };
-  return {
+  const out = {
     ...DEFAULT_ADJUSTMENTS,
     ...stored,
     process: normalizeProcessVersion(stored.process)
   };
+  const layers = normalizeAdjustmentLayers(stored.layers);
+  if (layers.length) out.layers = layers;
+  else delete out.layers;
+  return out;
+}
+function migrateSerializedImageEditorState(data) {
+  const adjustments = normalizeStoredAdjustments(data.adjustments);
+  return {
+    version: adjustments.layers?.length ? IMAGE_EDITOR_SCHEMA_VERSION : 1,
+    crop: data.crop ? { ...data.crop } : null,
+    transform: { ...DEFAULT_TRANSFORM, ...data.transform },
+    adjustments: serializeAdjustments(adjustments),
+    depthMask: {
+      ...DEFAULT_DEPTH_MASK,
+      ...data.depthMask,
+      depthRange: [...data.depthMask?.depthRange ?? DEFAULT_DEPTH_MASK.depthRange]
+    },
+    annotations: JSON.parse(JSON.stringify(data.annotations ?? [])),
+    ...data.selection ? { selection: { ...data.selection } } : {}
+  };
 }
 var DEFAULT_TRANSFORM = {
   rotate: 0,
@@ -1438,6 +3886,7 @@ var ImageEditorController = class {
   renderer;
   imageElement = null;
   listeners = /* @__PURE__ */ new Set();
+  histogramListeners = /* @__PURE__ */ new Set();
   onStateChange;
   // History stacks
   undoStack = [];
@@ -1445,10 +3894,16 @@ var ImageEditorController = class {
   maxHistoryDepth;
   isApplyingHistory = false;
   initialSnapshot;
+  /** Pixels the selection tools sample (host-provided or read back from the source). */
+  samplePixels = null;
+  samplePixelsOverride = false;
   constructor(options = {}) {
     this.maxHistoryDepth = options.maxHistoryDepth ?? 50;
     this.onStateChange = options.onStateChange;
     this.renderer = new ImageEditorRenderer();
+    this.renderer.onPreviewHistogram = (histogram) => {
+      this.histogramListeners.forEach((l) => l(histogram));
+    };
     const initialAdjustments = normalizeStoredAdjustments(options.initialState?.adjustments);
     const initialTransform = {
       ...DEFAULT_TRANSFORM,
@@ -1470,8 +3925,16 @@ var ImageEditorController = class {
       activeTool: "select",
       zoom: 1,
       pan: { x: 0, y: 0 },
-      isOriginalCompared: false
+      isOriginalCompared: false,
+      selection: null,
+      quickMask: false
     };
+    if (options.initialState?.selection) {
+      try {
+        this.state.selection = normalizeSelection(deserializeSelection(options.initialState.selection));
+      } catch {
+      }
+    }
     if (options.image instanceof Object && "width" in options.image) {
       this.imageElement = options.image;
       this.state.sourceUrl = options.image.src || null;
@@ -1497,6 +3960,8 @@ var ImageEditorController = class {
     this.imageElement = source.element;
     this.state.sourceUrl = source.sourceUrl;
     this.state.imageDimensions = source.dimensions;
+    this.samplePixels = null;
+    this.dropMismatchedSelection();
     this.initialSnapshot = this.captureHistoryEntry();
     this.notify();
   }
@@ -1552,11 +4017,14 @@ var ImageEditorController = class {
         sourceUrl: this.state.sourceUrl,
         element: this.imageElement,
         dimensions: { ...this.state.imageDimensions }
-      }
+      },
+      selection: this.state.selection ?? null
     };
   }
   restoreHistoryEntry(entry) {
     this.applySerializedState(entry.state);
+    this.state.selection = entry.selection;
+    if (this.imageElement !== entry.source.element) this.samplePixels = null;
     this.imageElement = entry.source.element;
     this.state.sourceUrl = entry.source.sourceUrl;
     this.state.imageDimensions = { ...entry.source.dimensions };
@@ -1690,10 +4158,16 @@ var ImageEditorController = class {
     if (commitToHistory) {
       this.recordHistory();
     }
-    this.state.adjustments = {
+    const next = {
       ...this.state.adjustments,
       ...partial
     };
+    if ("layers" in partial) {
+      const layers = normalizeAdjustmentLayers(partial.layers);
+      if (layers.length) next.layers = layers;
+      else delete next.layers;
+    }
+    this.state.adjustments = next;
     this.notify();
   }
   /** True when the adjustments use an older rendering process than {@link LATEST_PROCESS_VERSION}. */
@@ -1709,11 +4183,338 @@ var ImageEditorController = class {
     this.setAdjustments({ process: LATEST_PROCESS_VERSION });
     return true;
   }
+  /** Resets the base sliders (latest process). Adjustment layers are kept; see `clearAdjustmentLayers`. */
   resetAdjustments() {
     this.recordHistory();
+    const layers = this.state.adjustments.layers;
     this.state.adjustments = { ...DEFAULT_ADJUSTMENTS };
+    if (layers?.length) this.state.adjustments.layers = layers;
+    this.notify();
+  }
+  // --- Adjustment layers ---
+  /** The adjustment layers, bottom (first) to top (last). */
+  getAdjustmentLayers() {
+    return this.state.adjustments.layers ?? [];
+  }
+  getAdjustmentLayer(id) {
+    return this.getAdjustmentLayers().find((l) => l.id === id);
+  }
+  setLayers(layers) {
+    const next = { ...this.state.adjustments };
+    if (layers.length) next.layers = layers;
+    else delete next.layers;
+    this.state.adjustments = next;
+  }
+  /**
+   * Adds an adjustment layer on top (or at `index`, 0 = bottom) as one undo step and returns
+   * its id. `kind` alone gives neutral parameters.
+   */
+  addAdjustmentLayer(init, index) {
+    const spec = typeof init === "string" ? { kind: init } : init;
+    const layers = [...this.getAdjustmentLayers()];
+    const layer = createAdjustmentLayer(spec.kind, {
+      id: spec.id && !layers.some((l) => l.id === spec.id) ? spec.id : void 0,
+      name: spec.name,
+      params: spec.params,
+      enabled: spec.enabled,
+      opacity: spec.opacity,
+      blend: spec.blend,
+      mask: spec.mask ?? void 0
+    });
+    this.recordHistory();
+    const at = index === void 0 ? layers.length : Math.max(0, Math.min(layers.length, Math.round(index)));
+    layers.splice(at, 0, layer);
+    this.setLayers(layers);
+    this.notify();
+    return layer.id;
+  }
+  /**
+   * Updates a layer (`params` merged into the current ones, then normalised). Pass
+   * `commitToHistory = false` for the moves of a drag after recording its start once.
+   * Returns false for an unknown id.
+   */
+  updateAdjustmentLayer(id, update, commitToHistory = true) {
+    const layers = this.getAdjustmentLayers();
+    const index = layers.findIndex((l) => l.id === id);
+    if (index === -1) return false;
+    const current = layers[index];
+    const merged = normalizeAdjustmentLayer({
+      ...current,
+      ...update.enabled !== void 0 ? { enabled: update.enabled } : {},
+      ...update.opacity !== void 0 ? { opacity: update.opacity } : {},
+      ...update.blend !== void 0 ? { blend: update.blend } : {},
+      ...update.name !== void 0 ? { name: update.name } : {},
+      ...update.mask !== void 0 ? { mask: update.mask ?? void 0 } : {},
+      params: { ...current.params, ...update.params ?? {} }
+    });
+    if (!merged) return false;
+    if (commitToHistory) this.recordHistory();
+    const next = [...layers];
+    next[index] = merged;
+    this.setLayers(next);
+    this.notify();
+    return true;
+  }
+  /** Removes a layer as one undo step. Returns false for an unknown id. */
+  removeAdjustmentLayer(id) {
+    const layers = this.getAdjustmentLayers();
+    if (!layers.some((l) => l.id === id)) return false;
+    this.recordHistory();
+    this.setLayers(layers.filter((l) => l.id !== id));
+    this.notify();
+    return true;
+  }
+  /** Moves a layer to `toIndex` (0 = bottom) as one undo step. Returns false if nothing moved. */
+  moveAdjustmentLayer(id, toIndex) {
+    const layers = [...this.getAdjustmentLayers()];
+    const from = layers.findIndex((l) => l.id === id);
+    if (from === -1) return false;
+    const to = Math.max(0, Math.min(layers.length - 1, Math.round(toIndex)));
+    if (to === from) return false;
+    this.recordHistory();
+    const [layer] = layers.splice(from, 1);
+    layers.splice(to, 0, layer);
+    this.setLayers(layers);
+    this.notify();
+    return true;
+  }
+  /** Shows or hides a layer (flips it without `enabled`) as one undo step. */
+  toggleAdjustmentLayer(id, enabled) {
+    const layer = this.getAdjustmentLayer(id);
+    if (!layer) return false;
+    const next = enabled ?? !layer.enabled;
+    if (next === layer.enabled) return false;
+    return this.updateAdjustmentLayer(id, { enabled: next });
+  }
+  /** Removes every adjustment layer as one undo step. */
+  clearAdjustmentLayers() {
+    if (!this.getAdjustmentLayers().length) return;
+    this.recordHistory();
+    this.setLayers([]);
+    this.notify();
+  }
+  // --- Selection ---
+  /** The active selection, or `null`. */
+  getSelection() {
+    return this.state.selection ?? null;
+  }
+  get hasSelection() {
+    return Boolean(this.state.selection?.bounds);
+  }
+  get naturalSize() {
+    return {
+      width: Math.max(1, Math.round(this.state.imageDimensions.width)),
+      height: Math.max(1, Math.round(this.state.imageDimensions.height))
+    };
+  }
+  dropMismatchedSelection() {
+    const sel = this.state.selection;
+    if (!sel) return;
+    const { width, height } = this.naturalSize;
+    if (sel.width !== width || sel.height !== height) this.state.selection = null;
+  }
+  /**
+   * Replaces the selection, or combines `mask` with it by `mode`, as one undo step. A mask of a
+   * different size (e.g. an AI segmentation at another resolution) is resampled to the image.
+   * Returns false when nothing changed.
+   */
+  setSelection(mask, mode = "replace") {
+    const { width, height } = this.naturalSize;
+    let next = null;
+    if (mask) {
+      const sized = mask.width === width && mask.height === height ? mask : resizeSelection(mask, width, height);
+      next = combineSelections(this.state.selection, sized, mode);
+    } else if (mode !== "replace") {
+      return false;
+    }
+    const prev = normalizeSelection(this.state.selection ?? null);
+    if (prev === next || prev && next && sameSelection(prev, next)) return false;
+    this.recordHistory();
+    this.state.selection = next;
+    this.notify();
+    return true;
+  }
+  /** Select › All. */
+  selectAll() {
+    const { width, height } = this.naturalSize;
+    return this.setSelection(fullSelection(width, height));
+  }
+  /** Select › Deselect. */
+  deselect() {
+    return this.setSelection(null);
+  }
+  /** Select › Inverse (with nothing selected, selects everything). */
+  invertSelection() {
+    const { width, height } = this.naturalSize;
+    const current = this.state.selection ?? createSelectionMask(width, height);
+    return this.setSelection(invertSelection(current));
+  }
+  shapeCommand(mask, options) {
+    const shaped = options.feather && options.feather > 0 ? modifySelection(mask, "feather", options.feather) : mask;
+    return this.setSelection(shaped, options.mode ?? "replace");
+  }
+  /** Rectangular marquee in natural image pixels. */
+  selectRect(rect, options = {}) {
+    const { width, height } = this.naturalSize;
+    return this.shapeCommand(rectSelection(width, height, rect, options), options);
+  }
+  /** Elliptical marquee inscribed in `rect`. */
+  selectEllipse(rect, options = {}) {
+    const { width, height } = this.naturalSize;
+    return this.shapeCommand(ellipseSelection(width, height, rect, options), options);
+  }
+  /** Lasso / polygonal lasso. */
+  selectPolygon(points, options = {}) {
+    const { width, height } = this.naturalSize;
+    return this.shapeCommand(polygonSelection(width, height, points, options), options);
+  }
+  /**
+   * 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. A new source image clears it.
+   */
+  setSamplePixels(pixels) {
+    this.samplePixels = pixels;
+    this.samplePixelsOverride = pixels !== null;
+  }
+  /**
+   * The pixels the selection tools sample: the source image at natural size, or with
+   * `sampleMerged` the source after the base adjustments and adjustment layers (no crop,
+   * rotation or annotations). `null` without pixel access (no DOM, tainted canvas).
+   */
+  async getSamplePixels(options = {}) {
+    const { width, height } = this.naturalSize;
+    let base = options.pixels ?? this.samplePixels;
+    if (!base) {
+      try {
+        const canvas = await this.renderSource();
+        const ctx = canvas.getContext("2d");
+        const data = ctx?.getImageData?.(0, 0, width, height);
+        if (data && data.data && data.data.length >= width * height * 4) {
+          base = { width, height, data: data.data };
+          this.samplePixels = base;
+          this.samplePixelsOverride = false;
+        }
+      } catch {
+        base = null;
+      }
+    }
+    if (!base) return null;
+    if (base.width !== width || base.height !== height) {
+      if (!this.samplePixelsOverride && !options.pixels) this.samplePixels = null;
+      return null;
+    }
+    if (!options.sampleMerged) return base;
+    const copy = { width: base.width, height: base.height, data: new Uint8ClampedArray(base.data) };
+    applyAdjustments(copy, this.state.adjustments);
+    return copy;
+  }
+  async requirePixels(options) {
+    const pixels = await this.getSamplePixels(options);
+    if (!pixels) throw new Error("The image pixels are not available (no canvas access); pass `pixels`.");
+    return pixels;
+  }
+  /**
+   * Magic wand at `point` (natural image pixels). Resolves to the resulting selection (null when
+   * nothing is selected).
+   */
+  async magicWand(point, options = {}) {
+    const pixels = await this.requirePixels(options);
+    this.shapeCommand(magicWand(pixels, point, options), options);
+    return this.getSelection();
+  }
+  /** Select › Color Range with colour samples (`#rrggbb` or `[r, g, b]`, optionally where they were picked). */
+  async selectColorRange(samples, options = {}) {
+    const pixels = await this.requirePixels(options);
+    this.shapeCommand(colorRange(pixels, samples, options), options);
+    return this.getSelection();
+  }
+  /** Select › Modify: grow, shrink, feather, border or smooth by `radius` pixels (one undo step). */
+  modifySelection(op, radius) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) return false;
+    return this.setSelection(modifySelection(sel, op, radius));
+  }
+  /**
+   * Refine Edge: snaps the selection (e.g. a coarse AI mask loaded with `loadSelectionFromImage`)
+   * to the image's edges with a guided filter, then smooth / feather / contrast / shift edge.
+   */
+  async refineSelection(params, options = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) return false;
+    const pixels = (params.radius ?? 0) > 0 ? await this.requirePixels(options) : null;
+    return this.setSelection(refineSelection(pixels, sel, params));
+  }
+  /**
+   * Loads a selection from a mask image (an AI segmentation, a saved mask): a data URL / URL or
+   * RGBA pixels, by luminance (white = selected) or a channel. Any size; it is resampled.
+   */
+  async loadSelectionFromImage(source, options = {}) {
+    let pixels;
+    if (typeof source === "string") {
+      const img = await this.renderer.imageCache.get(source);
+      const w = img.naturalWidth || img.width;
+      const h = img.naturalHeight || img.height;
+      const canvas = this.renderer.createCanvas(w, h);
+      const ctx = canvas.getContext("2d");
+      if (ctx) ctx.drawImage(img, 0, 0, w, h);
+      const data = ctx?.getImageData?.(0, 0, w, h);
+      if (!data) throw new Error("The mask image pixels are not available (no canvas access); pass pixels.");
+      pixels = { width: w, height: h, data: data.data };
+    } else {
+      pixels = source;
+    }
+    this.setSelection(selectionFromPixels(pixels, options), options.mode ?? "replace");
+    return this.getSelection();
+  }
+  /** Quick Mask view (tints the unselected area). View state: no undo step. */
+  setQuickMask(on) {
+    if (Boolean(this.state.quickMask) === on) return;
+    this.state.quickMask = on;
     this.notify();
   }
+  // --- Layer masks ---
+  /**
+   * Adds the selection as the layer's mask (Reveal Selection), replacing any mask, as one undo
+   * step. Without a selection, returns false.
+   */
+  applySelectionAsLayerMask(layerId, props = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds || !this.getAdjustmentLayer(layerId)) return false;
+    return this.updateAdjustmentLayer(layerId, { mask: layerMaskFromSelection(sel, props) });
+  }
+  /** Sets (from a selection-shaped mask) or removes (`null`) a layer's mask as one undo step. */
+  setAdjustmentLayerMask(layerId, mask, props = {}) {
+    return this.updateAdjustmentLayer(layerId, { mask: mask ? layerMaskFromSelection(mask, props) : null });
+  }
+  /** Changes a layer mask's density (0..1), feather (px) or enabled flag; the mask pixels are kept. */
+  setAdjustmentLayerMaskProps(layerId, props, commitToHistory = true) {
+    const layer = this.getAdjustmentLayer(layerId);
+    if (!layer?.mask) return false;
+    return this.updateAdjustmentLayer(layerId, { mask: updateLayerMaskProps(layer.mask, props) }, commitToHistory);
+  }
+  /** Load Selection from a layer mask (its pixels; density and feather are not applied). */
+  selectionFromLayerMask(layerId, mode = "replace") {
+    const layer = this.getAdjustmentLayer(layerId);
+    const sel = layer?.mask ? decodeLayerMask(layer.mask) : null;
+    if (!sel) return false;
+    return this.setSelection(sel, mode);
+  }
+  // --- Histogram ---
+  /**
+   * Histogram of the last rendered preview (after adjustments and layers, before annotations),
+   * or `null` before the first render or without canvas pixel access.
+   */
+  getHistogram() {
+    return this.renderer.previewHistogram;
+  }
+  /** Calls `listener` now and whenever a render produces a new preview histogram. */
+  subscribeHistogram(listener) {
+    this.histogramListeners.add(listener);
+    listener(this.renderer.previewHistogram);
+    return () => {
+      this.histogramListeners.delete(listener);
+    };
+  }
   // --- Depth Masking (Gleamforge) ---
   setDepthMask(partial) {
     this.recordHistory();
@@ -1892,6 +4693,12 @@ var ImageEditorController = class {
     this.imageElement = next.element;
     this.state.sourceUrl = next.sourceUrl;
     this.state.imageDimensions = next.dimensions;
+    this.samplePixels = null;
+    if (this.state.selection && (sx !== 1 || sy !== 1)) {
+      this.state.selection = normalizeSelection(
+        resizeSelection(this.state.selection, Math.round(next.dimensions.width), Math.round(next.dimensions.height))
+      );
+    }
     if (sx !== 1 || sy !== 1) {
       if (this.state.crop) {
         this.state.crop = clampCropToImage(
@@ -1914,17 +4721,31 @@ var ImageEditorController = class {
     this.notify();
   }
   // --- Serialization ---
+  /** The serializable state; `selection` is included (run-length encoded) only when something is selected. */
   toJSON() {
-    return this.serializeState();
+    const out = this.serializeState();
+    if (this.state.selection?.bounds) out.selection = serializeSelection(this.state.selection);
+    return out;
   }
   loadJSON(data) {
     this.recordHistory();
-    this.applySerializedState(data);
+    this.applySerializedState(migrateSerializedImageEditorState(data));
+    let selection = null;
+    if (data.selection) {
+      try {
+        selection = normalizeSelection(deserializeSelection(data.selection));
+      } catch {
+        selection = null;
+      }
+    }
+    this.state.selection = selection;
+    this.dropMismatchedSelection();
     this.notify();
   }
   serializeState() {
     return {
-      version: 1,
+      // States without adjustment layers keep schema 1, so they round-trip unchanged.
+      version: this.state.adjustments.layers?.length ? IMAGE_EDITOR_SCHEMA_VERSION : 1,
       crop: this.state.crop ? { ...this.state.crop } : null,
       transform: { ...this.state.transform },
       adjustments: serializeAdjustments(this.state.adjustments),
@@ -1948,12 +4769,24 @@ var ImageEditorController = class {
 };
 function serializeAdjustments(adjustments) {
   const out = { ...adjustments };
+  if (out.layers?.length) out.layers = JSON.parse(JSON.stringify(out.layers));
+  else delete out.layers;
   if (normalizeProcessVersion(out.process) === LEGACY_PROCESS_VERSION) {
     delete out.process;
     if (!out.tint) delete out.tint;
   }
   return out;
 }
+function normalizeSelection(mask) {
+  return mask?.bounds ? mask : null;
+}
+function sameSelection(a, b) {
+  if (a.width !== b.width || a.height !== b.height) return false;
+  const x = a.data;
+  const y = b.data;
+  for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;
+  return true;
+}
 function scaleAnnotation(ann, sx, sy) {
   const k = Math.sqrt(Math.abs(sx * sy));
   const base = { ...ann, x: ann.x * sx, y: ann.y * sy };
@@ -1973,13 +4806,955 @@ function scaleAnnotation(ann, sx, sy) {
       return { ...base, fontSize: base.fontSize * k };
   }
 }
+
+// src/image-editor/document.ts
+var IMAGE_EDITOR_STATE_VERSION = 1;
+var imageEditorStateMigrations = {};
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+function expectObject(value, what) {
+  if (!isObject(value)) throw new Error(`${what} must be an object`);
+  return value;
+}
+function checkFields(value, types, what) {
+  for (const [field, ok] of Object.entries(types)) {
+    if (field in value && value[field] !== void 0 && !ok(value[field])) {
+      throw new Error(`${what}.${field} has an invalid value`);
+    }
+  }
+}
+var isBoolean = (v) => typeof v === "boolean";
+function parseCrop(value) {
+  if (value === null) return null;
+  const crop = expectObject(value, "crop");
+  for (const field of ["x", "y", "width", "height"]) {
+    if (!isNumber(crop[field])) throw new Error(`crop.${field} must be a number`);
+  }
+  return { ...crop };
+}
+function parseTransform(value) {
+  const transform = expectObject(value, "transform");
+  checkFields(transform, { rotate: isNumber, flipH: isBoolean, flipV: isBoolean }, "transform");
+  return { ...DEFAULT_TRANSFORM, ...transform };
+}
+var ADJUSTMENT_NUMBERS = [
+  "brightness",
+  "contrast",
+  "saturation",
+  "exposure",
+  "temperature",
+  "tint",
+  "blur",
+  "opacity"
+];
+function parseAdjustments(value) {
+  const adjustments = expectObject(value, "adjustments");
+  checkFields(
+    adjustments,
+    {
+      ...Object.fromEntries(ADJUSTMENT_NUMBERS.map((k) => [k, isNumber])),
+      process: (v) => v === 1 || v === 2
+    },
+    "adjustments"
+  );
+  return { ...adjustments };
+}
+function parseDepthMask(value) {
+  const mask = expectObject(value, "depthMask");
+  checkFields(
+    mask,
+    {
+      enabled: isBoolean,
+      maskSource: (v) => v === null || typeof v === "string",
+      mode: (v) => v === "threshold" || v === "brightness",
+      depthRange: (v) => Array.isArray(v) && v.length === 2 && v.every(isNumber),
+      softness: isNumber,
+      invert: isBoolean
+    },
+    "depthMask"
+  );
+  const merged = { ...DEFAULT_DEPTH_MASK, ...mask };
+  return { ...merged, depthRange: [...merged.depthRange] };
+}
+var ANNOTATION_TYPES = /* @__PURE__ */ new Set(["pen", "rect", "circle", "arrow", "line", "text", "image"]);
+var isAnnotation = (value) => isObject(value) && typeof value.id === "string" && typeof value.type === "string" && ANNOTATION_TYPES.has(value.type) && isNumber(value.x) && isNumber(value.y);
+function loadImageEditorDocument(input) {
+  let dropped = 0;
+  const result = loadDocument(
+    input,
+    {
+      crop: { parse: parseCrop, defaults: null },
+      transform: { parse: parseTransform, defaults: () => ({ ...DEFAULT_TRANSFORM }) },
+      adjustments: {
+        parse: parseAdjustments,
+        // Same as what `loadJSON` derives from missing adjustments.
+        defaults: () => normalizeStoredAdjustments(void 0)
+      },
+      depthMask: {
+        parse: parseDepthMask,
+        defaults: () => ({ ...DEFAULT_DEPTH_MASK, depthRange: [...DEFAULT_DEPTH_MASK.depthRange] })
+      },
+      annotations: {
+        parse: (value) => {
+          if (!Array.isArray(value)) throw new Error("annotations must be an array");
+          const kept = value.filter(isAnnotation);
+          dropped = value.length - kept.length;
+          return JSON.parse(JSON.stringify(kept));
+        },
+        defaults: () => []
+      },
+      // Optional: only present when something was selected when saving.
+      selection: {
+        parse: (value) => {
+          const mask = deserializeSelection(value);
+          const v = value;
+          return { width: mask.width, height: mask.height, rle: v.rle };
+        },
+        defaults: void 0
+      }
+    },
+    {
+      currentVersion: IMAGE_EDITOR_STATE_VERSION,
+      steps: imageEditorStateMigrations
+    }
+  );
+  if (dropped > 0) {
+    result.report.problems.push({
+      section: "annotations",
+      message: `${dropped} invalid annotation${dropped === 1 ? "" : "s"} dropped`
+    });
+  }
+  const state = { version: 1, ...result.value };
+  if (state.selection === void 0) delete state.selection;
+  return { state, report: result.report, unknown: result.unknown };
+}
+
+// src/image-editor/controls.ts
+var plain = { kind: "plain" };
+var centered = { kind: "centered" };
+var IMAGE_ADJUSTMENT_CONTROLS = [
+  { id: "brightness", label: "Brightness", section: "light", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+  { id: "contrast", label: "Contrast", section: "light", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+  {
+    id: "saturation",
+    label: "Saturation",
+    section: "color",
+    min: -100,
+    max: 100,
+    step: 1,
+    default: 0,
+    decimals: 0,
+    track: { kind: "gradient", from: "#7a7a7a", to: "#e04a3a" }
+  },
+  { id: "exposure", label: "Exposure", section: "light", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+  { id: "temperature", label: "Warmth / Temperature", section: "color", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "temp" } },
+  { id: "tint", label: "Tint", section: "color", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "tint" }, requiresProcess: 2 },
+  { id: "blur", label: "Blur", section: "effects", min: 0, max: 30, step: 1, default: 0, decimals: 0, track: plain, unit: "px" },
+  { id: "opacity", label: "Opacity", section: "effects", min: 0, max: 1, step: 0.05, default: 1, decimals: 0, track: plain, displayScale: 100, unit: "%" }
+];
+var tone = (prefix, label) => [
+  ["0", "Cyan \u2013 Red", "#00b7c7", "#e0343a"],
+  ["1", "Magenta \u2013 Green", "#d23ad2", "#2fb34a"],
+  ["2", "Yellow \u2013 Blue", "#e0c63a", "#3a5be0"]
+].map(([i, l, from, to]) => ({
+  id: `${prefix}.${i}`,
+  label: `${label} ${l}`,
+  section: "layer",
+  min: -100,
+  max: 100,
+  step: 1,
+  default: 0,
+  decimals: 0,
+  track: { kind: "gradient", from, to }
+}));
+var levelsRecord = (ch, label) => [
+  { id: `${ch}.inBlack`, label: `${label} input black`, section: "layer", min: 0, max: 253, step: 1, default: 0, decimals: 0, track: plain },
+  { id: `${ch}.gamma`, label: `${label} gamma`, section: "layer", min: 0.1, max: 9.99, step: 0.01, default: 1, decimals: 2, track: plain },
+  { id: `${ch}.inWhite`, label: `${label} input white`, section: "layer", min: 2, max: 255, step: 1, default: 255, decimals: 0, track: plain },
+  { id: `${ch}.outBlack`, label: `${label} output black`, section: "layer", min: 0, max: 255, step: 1, default: 0, decimals: 0, track: plain },
+  { id: `${ch}.outWhite`, label: `${label} output white`, section: "layer", min: 0, max: 255, step: 1, default: 255, decimals: 0, track: plain }
+];
+var RANGE_NAMES = ["Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"];
+var ADJUSTMENT_LAYER_CONTROLS = {
+  curves: [],
+  levels: [
+    ...levelsRecord("master", "RGB"),
+    ...levelsRecord("red", "Red"),
+    ...levelsRecord("green", "Green"),
+    ...levelsRecord("blue", "Blue")
+  ],
+  hueSaturation: [
+    { id: "hue", label: "Hue", section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: { kind: "rainbow" }, unit: "\xB0" },
+    { id: "saturation", label: "Saturation", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#7a7a7a", to: "#e04a3a" } },
+    { id: "lightness", label: "Lightness", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#000000", to: "#ffffff" } },
+    ...RANGE_NAMES.flatMap((name, i) => [
+      { id: `ranges.${i}.hue`, label: `${name} hue`, section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: { kind: "rainbow" }, unit: "\xB0" },
+      { id: `ranges.${i}.saturation`, label: `${name} saturation`, section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+      { id: `ranges.${i}.lightness`, label: `${name} lightness`, section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered }
+    ])
+  ],
+  vibrance: [
+    { id: "vibrance", label: "Vibrance", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#7a7a7a", to: "#d8406a" } },
+    { id: "saturation", label: "Saturation", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#7a7a7a", to: "#e04a3a" } }
+  ],
+  colorBalance: [...tone("shadows", "Shadows"), ...tone("midtones", "Midtones"), ...tone("highlights", "Highlights")],
+  blackWhite: [
+    ["reds", "Reds", 40, "#e0343a"],
+    ["yellows", "Yellows", 60, "#e0c63a"],
+    ["greens", "Greens", 40, "#2fb34a"],
+    ["cyans", "Cyans", 60, "#00b7c7"],
+    ["blues", "Blues", 20, "#3a5be0"],
+    ["magentas", "Magentas", 80, "#d23ad2"]
+  ].map(([id, label, def, to]) => ({
+    id,
+    label,
+    section: "layer",
+    min: -200,
+    max: 300,
+    step: 1,
+    default: def,
+    decimals: 0,
+    track: { kind: "gradient", from: "#000000", to },
+    unit: "%"
+  })),
+  invert: [],
+  posterize: [{ id: "levels", label: "Levels", section: "layer", min: 2, max: 255, step: 1, default: 4, decimals: 0, track: plain }],
+  threshold: [{ id: "level", label: "Threshold level", section: "layer", min: 1, max: 255, step: 1, default: 128, decimals: 0, track: { kind: "gradient", from: "#000000", to: "#ffffff" } }],
+  photoFilter: [{ id: "density", label: "Density", section: "layer", min: 0, max: 100, step: 1, default: 25, decimals: 0, track: plain, unit: "%" }]
+};
+var ADJUSTMENT_LAYER_OPACITY_CONTROL = {
+  id: "opacity",
+  label: "Opacity",
+  section: "layer",
+  min: 0,
+  max: 1,
+  step: 0.01,
+  default: 1,
+  decimals: 0,
+  track: plain,
+  displayScale: 100,
+  unit: "%"
+};
+var BASE_BY_ID = new Map(IMAGE_ADJUSTMENT_CONTROLS.map((c) => [c.id, c]));
+function findAdjustmentControl(id) {
+  return BASE_BY_ID.get(id);
+}
+function findLayerControl(kind, id) {
+  if (id === "opacity") return ADJUSTMENT_LAYER_OPACITY_CONTROL;
+  return ADJUSTMENT_LAYER_CONTROLS[kind]?.find((c) => c.id === id);
+}
+function clampControlValue(spec, v) {
+  if (typeof v !== "number" || !Number.isFinite(v)) return spec.default;
+  const clamped = Math.min(spec.max, Math.max(spec.min, v));
+  const steps = Math.round((clamped - spec.min) / spec.step);
+  const snapped = spec.min + steps * spec.step;
+  return Math.min(spec.max, Number(snapped.toFixed(6)));
+}
+function formatControlValue(spec, v) {
+  const shown = (Number.isFinite(v) ? v : spec.default) * (spec.displayScale ?? 1);
+  const s = shown.toFixed(spec.decimals);
+  return `${s}${spec.unit ?? ""}`;
+}
+function controlPosition(spec, v) {
+  const p = (clampControlValue(spec, v) - spec.min) / (spec.max - spec.min || 1);
+  return Math.min(1, Math.max(0, p));
+}
+function controlTrackBackground(spec) {
+  const t = spec.track;
+  switch (t.kind) {
+    case "temp":
+      return "linear-gradient(to right, #3a7bd5, #d8d8d8, #f2c94c)";
+    case "tint":
+      return "linear-gradient(to right, #3fbf4f, #d8d8d8, #d23ad2)";
+    case "gradient":
+      return `linear-gradient(to right, ${t.from}, ${t.to})`;
+    case "rainbow":
+      return "linear-gradient(to right, #00ffff, #0000ff, #ff00ff, #ff0000, #ffff00, #00ff00, #00ffff)";
+    default:
+      return void 0;
+  }
+}
+function getControlPath(obj, path) {
+  let cur = obj;
+  for (const part of path.split(".")) {
+    if (cur === null || cur === void 0) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setControlPath(obj, path, value) {
+  const parts = path.split(".");
+  const root = Array.isArray(obj) ? [...obj] : { ...obj };
+  let cur = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const next = cur[parts[i]];
+    cur[parts[i]] = Array.isArray(next) ? [...next] : next && typeof next === "object" ? { ...next } : {};
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+  return root;
+}
+function readAdjustmentControls(adjustments) {
+  const out = {};
+  for (const c of IMAGE_ADJUSTMENT_CONTROLS) {
+    const v = adjustments[c.id];
+    out[c.id] = typeof v === "number" && Number.isFinite(v) ? v : c.default;
+  }
+  return out;
+}
+
+// src/image-editor/selection/tool-options.ts
+var SELECTION_TOOLS = [
+  { id: "wand", label: "Magic Wand" },
+  { id: "rect", label: "Rectangle" },
+  { id: "ellipse", label: "Ellipse" },
+  { id: "lasso", label: "Lasso" }
+];
+var SELECTION_MODE_LABELS = {
+  replace: "New",
+  add: "Add",
+  subtract: "Subtract",
+  intersect: "Intersect"
+};
+var DEFAULT_SELECTION_TOOL_OPTIONS = {
+  tool: "wand",
+  mode: "replace",
+  tolerance: 32,
+  contiguous: true,
+  antiAlias: true,
+  sampleMerged: false,
+  distance: "rgb"
+};
+function selectionModeFromModifiers(modifiers, fallback) {
+  if (modifiers.shiftKey && modifiers.altKey) return "intersect";
+  if (modifiers.shiftKey) return "add";
+  if (modifiers.altKey) return "subtract";
+  return fallback;
+}
+var REFINE_EDGE_CONTROLS = [
+  { id: "radius", label: "Radius", min: 0, max: 64, step: 1, unit: "px" },
+  { id: "smooth", label: "Smooth", min: 0, max: 100, step: 1, unit: "" },
+  { id: "feather", label: "Feather", min: 0, max: 50, step: 0.5, unit: "px" },
+  { id: "contrast", label: "Contrast", min: 0, max: 100, step: 1, unit: "%" },
+  { id: "shiftEdge", label: "Shift Edge", min: -100, max: 100, step: 1, unit: "%" }
+];
+function describeSelection(mask) {
+  if (!mask || !mask.bounds) return "No selection";
+  let sum = 0;
+  for (let i = 0; i < mask.data.length; i++) sum += mask.data[i];
+  const pct = sum / 255 / mask.data.length * 100;
+  const shown = pct >= 10 ? Math.round(pct) : Math.round(pct * 10) / 10;
+  return `${mask.bounds.width} \xD7 ${mask.bounds.height} px selected (${shown}% of the image)`;
+}
+
+// src/image-editor/selection-tools.ts
+var modeSchema = {
+  type: "string",
+  enum: [...SELECTION_MODES],
+  description: "How the result combines with the current selection (default replace)."
+};
+var num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function summary(controller) {
+  const sel = controller.getSelection();
+  const { width, height } = controller.getState().imageDimensions;
+  const area = selectionArea(sel);
+  return {
+    empty: !sel,
+    bounds: sel?.bounds ?? null,
+    /** Σ coverage in pixels. */
+    area: Math.round(area),
+    percent: Math.round(area / Math.max(1, width * height) * 1e4) / 100,
+    description: describeSelection(sel)
+  };
+}
+var writeAnnotations = (title, idempotent = false) => ({
+  title,
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: idempotent,
+  openWorldHint: false
+});
+function createImageSelectionTools(controller) {
+  const getSelection = {
+    name: "get_selection",
+    title: "Read the selection",
+    description: "Returns the active selection: whether it is empty, its bounds (natural image pixels), its area in pixels and percent of the image.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Read the selection", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: () => summary(controller)
+  };
+  const selectRegion = {
+    name: "select_region",
+    title: "Select a region",
+    description: 'Selects a rectangle or ellipse (x, y, width, height in natural image pixels), everything ("all"), nothing ("none") or the inverse of the current selection ("invert"). One undoable step.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        shape: { type: "string", enum: ["rect", "ellipse", "all", "none", "invert"] },
+        x: { type: "number" },
+        y: { type: "number" },
+        width: { type: "number" },
+        height: { type: "number" },
+        mode: modeSchema,
+        feather: { type: "number", minimum: 0, description: "Feather radius in pixels (default 0)." }
+      },
+      required: ["shape"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select a region", true),
+    handler: ({ shape, x, y, width, height, mode, feather }) => {
+      const opts = { mode: parseSelectionMode(mode), feather: num(feather, 0) };
+      switch (shape) {
+        case "all":
+          controller.selectAll();
+          break;
+        case "none":
+          controller.deselect();
+          break;
+        case "invert":
+          controller.invertSelection();
+          break;
+        case "rect":
+        case "ellipse": {
+          const rect = { x: num(x, NaN), y: num(y, NaN), width: num(width, NaN), height: num(height, NaN) };
+          if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite)) {
+            throw new Error("rect and ellipse need numeric x, y, width and height.");
+          }
+          if (shape === "rect") controller.selectRect(rect, opts);
+          else controller.selectEllipse(rect, opts);
+          break;
+        }
+        default:
+          throw new Error(`Unknown shape "${String(shape)}". Use rect, ellipse, all, none or invert.`);
+      }
+      return summary(controller);
+    }
+  };
+  const selectByColor = {
+    name: "select_by_color",
+    title: "Select by colour",
+    description: 'Magic wand at (x, y) with tolerance (0-255) and contiguous, or with "color" ("#rrggbb") every pixel of a similar colour (Color Range, fuzziness 0-200). One undoable step.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        x: { type: "number" },
+        y: { type: "number" },
+        color: { type: "string", description: "#rrggbb: select this colour everywhere instead of a seed point." },
+        tolerance: { type: "number", minimum: 0, maximum: 255, description: "Magic wand tolerance (default 32)." },
+        contiguous: { type: "boolean", description: "Only the connected region around (x, y) (default true)." },
+        fuzziness: { type: "number", minimum: 0, maximum: 200, description: "Color Range fuzziness (default 40)." },
+        sampleMerged: { type: "boolean", description: "Sample the adjusted image rather than the source." },
+        mode: modeSchema
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select by colour", true),
+    handler: async ({ x, y, color, tolerance, contiguous, fuzziness, sampleMerged, mode }) => {
+      const common = { mode: parseSelectionMode(mode), sampleMerged: sampleMerged === true };
+      if (typeof color === "string") {
+        await controller.selectColorRange([{ color }], { ...common, fuzziness: num(fuzziness, 40) });
+      } else if (typeof x === "number" && typeof y === "number") {
+        await controller.magicWand({ x, y }, { ...common, tolerance: num(tolerance, 32), contiguous: contiguous !== false });
+      } else {
+        throw new Error("Pass x and y (magic wand) or color (#rrggbb).");
+      }
+      return summary(controller);
+    }
+  };
+  const modify = {
+    name: "modify_selection",
+    title: "Modify the selection",
+    description: "Select \u203A Modify: grow, shrink, feather, border or smooth the selection by radius pixels. One undoable step.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        op: { type: "string", enum: [...SELECTION_MODIFY_OPS] },
+        radius: { type: "number", minimum: 0, maximum: 500 }
+      },
+      required: ["op", "radius"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Modify the selection"),
+    handler: ({ op, radius }) => {
+      if (!SELECTION_MODIFY_OPS.includes(op)) throw new Error(`Unknown op "${String(op)}".`);
+      if (!controller.getSelection()) throw new Error("Nothing is selected.");
+      controller.modifySelection(op, Math.min(500, Math.max(0, num(radius, 0))));
+      return summary(controller);
+    }
+  };
+  const refine = {
+    name: "refine_selection",
+    title: "Refine the selection edge",
+    description: "Refine Edge: snaps the selection edge to the image within radius pixels (edge-aware guided filter), then smooth (0-100), feather (px), contrast (0-100) and shiftEdge (-100..100 %). Use it after loading a coarse AI mask. One undoable step.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        radius: { type: "number", minimum: 0, maximum: 64 },
+        smartRadius: { type: "boolean" },
+        smooth: { type: "number", minimum: 0, maximum: 100 },
+        feather: { type: "number", minimum: 0, maximum: 250 },
+        contrast: { type: "number", minimum: 0, maximum: 100 },
+        shiftEdge: { type: "number", minimum: -100, maximum: 100 }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Refine the selection edge"),
+    handler: async (params) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected.");
+      await controller.refineSelection({
+        radius: num(params.radius, 8),
+        smartRadius: params.smartRadius === true,
+        smooth: num(params.smooth, 0),
+        feather: num(params.feather, 0),
+        contrast: num(params.contrast, 0),
+        shiftEdge: num(params.shiftEdge, 0)
+      });
+      return summary(controller);
+    }
+  };
+  const applyMask = {
+    name: "apply_selection_as_mask",
+    title: "Mask a layer with the selection",
+    description: "Uses the selection as an adjustment layer mask: on layerId, or on a new layer of kind (with optional params), so the adjustment only affects the selected area. density (0-1) and feather (px) soften the mask non-destructively. One undoable step.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: { type: "string" },
+        kind: { type: "string", enum: ADJUSTMENT_KINDS.map((k) => k.kind) },
+        params: { type: "object" },
+        density: { type: "number", minimum: 0, maximum: 1 },
+        feather: { type: "number", minimum: 0, maximum: 1e3 }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Mask a layer with the selection"),
+    handler: ({ layerId, kind, params, density, feather }) => {
+      const sel = controller.getSelection();
+      if (!sel) throw new Error("Nothing is selected.");
+      const props = {
+        ...typeof density === "number" ? { density } : {},
+        ...typeof feather === "number" ? { feather } : {}
+      };
+      let id;
+      if (typeof layerId === "string") {
+        if (!controller.getAdjustmentLayer(layerId)) throw new Error(`No adjustment layer "${layerId}".`);
+        controller.applySelectionAsLayerMask(layerId, props);
+        id = layerId;
+      } else if (isAdjustmentKind(kind)) {
+        id = controller.addAdjustmentLayer({
+          kind,
+          params,
+          mask: layerMaskFromSelection(sel, props)
+        });
+      } else {
+        throw new Error("Pass layerId (an existing layer) or kind (a new adjustment layer).");
+      }
+      const layer = controller.getAdjustmentLayer(id);
+      const { rle: _rle, ...mask } = layer.mask;
+      return { layerId: id, kind: layer.kind, mask, selection: summary(controller) };
+    }
+  };
+  return [getSelection, selectRegion, selectByColor, modify, refine, applyMask];
+}
+
+// src/image-editor/tools.ts
+var LAYER_PATH = /^layers\.([^.]+)\.(.+)$/;
+function adjustmentsSummary(adjustments) {
+  return {
+    process: normalizeProcessVersion(adjustments.process),
+    values: readAdjustmentControls(adjustments),
+    layers: (adjustments.layers ?? []).map((l) => JSON.parse(JSON.stringify(l)))
+  };
+}
+function createImageEditorToolProvider(controller, options = {}) {
+  const getAdjustments = {
+    name: "get_adjustments",
+    title: "Read image adjustments",
+    description: "Returns the image editor adjustment values by control id, the rendering process version and the adjustment layers (bottom to top).",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: {
+      title: "Read image adjustments",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: () => adjustmentsSummary(controller.getState().adjustments)
+  };
+  const listControls = {
+    name: "list_controls",
+    title: "List adjustment controls",
+    description: "Lists every adjustment control (id, label, section, min, max, step, default), the parameters of each adjustment-layer kind, and the blend modes.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: {
+      title: "List adjustment controls",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: () => ({
+      controls: IMAGE_ADJUSTMENT_CONTROLS.map(({ id, label, section, min, max, step, default: def, requiresProcess }) => ({
+        id,
+        label,
+        section,
+        min,
+        max,
+        step,
+        default: def,
+        ...requiresProcess ? { requiresProcess } : {}
+      })),
+      layerKinds: ADJUSTMENT_KINDS.map(({ kind, label }) => ({
+        kind,
+        label,
+        controls: [...ADJUSTMENT_LAYER_CONTROLS[kind], ADJUSTMENT_LAYER_OPACITY_CONTROL].map(({ id, label: l, min, max, step, default: def }) => ({
+          id,
+          label: l,
+          min,
+          max,
+          step,
+          default: def
+        }))
+      })),
+      blendModes: BLEND_MODES.map((m) => m.id),
+      layerPathFormat: "layers.<layerId>.<controlId>"
+    })
+  };
+  const setAdjustments = {
+    name: "set_adjustments",
+    title: "Set image adjustments",
+    description: 'Sets adjustment values by control id in one undoable step. Base controls use their id (e.g. "exposure"); layer parameters use "layers.<layerId>.<controlId>" (e.g. "layers.adj_1.vibrance"). Values are clamped to each control range; the applied values are returned.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        values: {
+          type: "object",
+          description: "Map of control id to number. See list_controls for ids and ranges.",
+          additionalProperties: { type: "number" }
+        },
+        label: { type: "string", description: "Short description of the change (echoed back)." }
+      },
+      required: ["values"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Set image adjustments",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: ({ values, label }) => {
+      const entries = Object.entries(values ?? {});
+      if (!entries.length) throw new Error('No values given. Pass {"values": {"<control id>": number}}.');
+      const state = controller.getState();
+      const base = {};
+      const layers = (state.adjustments.layers ?? []).map((l) => ({ ...l }));
+      const applied = {};
+      const clamped = [];
+      const unknown = [];
+      for (const [id, raw] of entries) {
+        const m = LAYER_PATH.exec(id);
+        if (m) {
+          const layer = layers.find((l) => l.id === m[1]);
+          const spec2 = layer ? findLayerControl(layer.kind, m[2]) : void 0;
+          if (!layer || !spec2) {
+            unknown.push(id);
+            continue;
+          }
+          const v2 = clampControlValue(spec2, raw);
+          if (v2 !== raw) clamped.push(id);
+          if (spec2.id === "opacity") layer.opacity = v2;
+          else layer.params = setControlPath(layer.params, spec2.id, v2);
+          applied[id] = v2;
+          continue;
+        }
+        const spec = findAdjustmentControl(id);
+        if (!spec) {
+          unknown.push(id);
+          continue;
+        }
+        const v = clampControlValue(spec, raw);
+        if (v !== raw) clamped.push(id);
+        base[id] = v;
+        applied[id] = v;
+      }
+      if (unknown.length) {
+        const accepted = IMAGE_ADJUSTMENT_CONTROLS.map((c) => c.id).join(", ");
+        throw new Error(
+          `Unknown control id(s): ${unknown.join(", ")}. Accepted: ${accepted}, or layers.<layerId>.<controlId> for an existing layer.`
+        );
+      }
+      const changedLayers = Object.keys(applied).some((id) => id.startsWith("layers."));
+      controller.setAdjustments(changedLayers ? { ...base, layers } : base);
+      const result = { applied, clamped };
+      if (typeof label === "string" && label) result.label = label;
+      const notes = [];
+      if ("tint" in applied && normalizeProcessVersion(controller.getState().adjustments.process) < 2) {
+        notes.push("Tint has no effect on process 1 edits.");
+      }
+      if (notes.length) result.notes = notes;
+      return result;
+    }
+  };
+  const addLayer = {
+    name: "add_adjustment_layer",
+    title: "Add an adjustment layer",
+    description: "Adds a non-destructive adjustment layer on top of the stack (one undoable step) and returns it. Kinds: " + ADJUSTMENT_KINDS.map((k) => k.kind).join(", ") + ". Omitted params are neutral.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ADJUSTMENT_KINDS.map((k) => k.kind) },
+        params: { type: "object", description: "Initial parameters (see list_controls); merged with neutral defaults." },
+        opacity: { type: "number", minimum: 0, maximum: 1 },
+        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id) },
+        name: { type: "string" }
+      },
+      required: ["kind"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Add an adjustment layer",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    handler: ({ kind, params, opacity, blend, name }) => {
+      if (!isAdjustmentKind(kind)) throw new Error(`Unknown adjustment kind "${kind}".`);
+      if (blend !== void 0 && !isBlendMode(blend)) throw new Error(`Unknown blend mode "${blend}".`);
+      const id = controller.addAdjustmentLayer({ kind, params, opacity, blend, name });
+      const layer = controller.getAdjustmentLayer(id);
+      return { layer: JSON.parse(JSON.stringify(layer)), index: controller.getAdjustmentLayers().length - 1 };
+    }
+  };
+  const renderPreview = {
+    name: "render_preview",
+    title: "Render a preview",
+    description: "Renders the edited image (crop, adjustments, layers, annotations) as a PNG whose longest side is at most maxSide pixels.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        maxSide: { type: "integer", minimum: 16, maximum: 2048, description: "Longest side in pixels (default 512)." }
+      },
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Render a preview",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: async ({ maxSide }) => {
+      const side = Math.max(16, Math.min(2048, Math.round(typeof maxSide === "number" ? maxSide : 512)));
+      const state = controller.getState();
+      const crop = state.crop ?? { x: 0, y: 0, ...state.imageDimensions };
+      const quarter = Math.abs(Math.round(state.transform.rotate % 180 / 90)) % 2 === 1;
+      const w = quarter ? crop.height : crop.width;
+      const h = quarter ? crop.width : crop.height;
+      const k = Math.min(1, side / Math.max(w, h, 1));
+      const dataUrl = await controller.toDataURL({
+        format: "image/png",
+        width: Math.max(1, Math.round(w * k)),
+        height: Math.max(1, Math.round(h * k))
+      });
+      const comma = dataUrl.indexOf(",");
+      if (!dataUrl.startsWith("data:image/png") || comma < 0 || comma === dataUrl.length - 1) {
+        throw new Error("Rendering is not available in this environment.");
+      }
+      return {
+        content: [
+          { type: "image", data: dataUrl.slice(comma + 1), mimeType: "image/png" },
+          { type: "text", text: `Preview ${Math.round(w * k)}\xD7${Math.round(h * k)}` }
+        ]
+      };
+    }
+  };
+  return {
+    id: options.id ?? "image-editor",
+    namespace: options.namespace,
+    tools: [getAdjustments, listControls, setAdjustments, addLayer, renderPreview, ...createImageSelectionTools(controller)]
+  };
+}
+
+// src/image-editor/curve-editing.ts
+var clampLevel = (v) => Math.min(255, Math.max(0, Math.round(v)));
+function curvePointToBox(p, width, height) {
+  return { x: p.input / 255 * width, y: height - p.output / 255 * height };
+}
+function boxToCurvePoint(x, y, width, height) {
+  return { input: clampLevel(x / (width || 1) * 255), output: clampLevel((height - y) / (height || 1) * 255) };
+}
+function curveSvgPath(points, width, height, samples = 64) {
+  const lut = curveLutFromLevels(points);
+  const n = lut.length - 1;
+  let d = "";
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const y = lut[Math.round(t * n)];
+    d += `${i === 0 ? "M" : " L"}${round22(t * width)} ${round22(height - y * height)}`;
+  }
+  return d;
+}
+function hitTestCurvePoint(points, x, y, width, height, radius = 8) {
+  let best = -1;
+  let bestD = radius * radius;
+  points.forEach((p, i) => {
+    const b = curvePointToBox(p, width, height);
+    const d = (b.x - x) ** 2 + (b.y - y) ** 2;
+    if (d <= bestD) {
+      best = i;
+      bestD = d;
+    }
+  });
+  return best;
+}
+function insertCurvePoint(points, p) {
+  const point = { input: clampLevel(p.input), output: clampLevel(p.output) };
+  const out = points.filter((q) => q.input !== point.input).map((q) => ({ ...q }));
+  let index = out.findIndex((q) => q.input > point.input);
+  if (index === -1) index = out.length;
+  out.splice(index, 0, point);
+  return { points: out, index };
+}
+function moveCurvePoint(points, index, p) {
+  const out = points.map((q) => ({ ...q }));
+  if (index < 0 || index >= out.length) return out;
+  const lo = index > 0 ? out[index - 1].input + 1 : 0;
+  const hi = index < out.length - 1 ? out[index + 1].input - 1 : 255;
+  out[index] = { input: Math.min(hi, Math.max(lo, clampLevel(p.input))), output: clampLevel(p.output) };
+  return out;
+}
+function removeCurvePoint(points, index) {
+  if (points.length <= 2 || index < 0 || index >= points.length) return points.map((q) => ({ ...q }));
+  return points.filter((_, i) => i !== index).map((q) => ({ ...q }));
+}
+var round22 = (v) => Math.round(v * 100) / 100;
+
+// src/image-editor/selection/gesture.ts
+var SelectionGesture = class {
+  constructor(controller, getOptions) {
+    this.controller = controller;
+    this.getOptions = getOptions;
+  }
+  controller;
+  getOptions;
+  start = null;
+  points = [];
+  current = null;
+  modifiers = {};
+  /** The last error (e.g. pixels unavailable for the wand), for the UI to show. */
+  error = null;
+  get active() {
+    return this.start !== null;
+  }
+  /** The outline of the shape being drawn, or `null`. */
+  get draftPath() {
+    if (!this.start || !this.current) return null;
+    const { tool } = this.getOptions();
+    if (tool === "lasso") return this.points.length > 1 ? this.points.slice() : null;
+    const rect = normalizeRect({
+      x: this.start.x,
+      y: this.start.y,
+      width: this.current.x - this.start.x,
+      height: this.current.y - this.start.y
+    });
+    if (rect.width < 1 && rect.height < 1) return null;
+    if (tool === "ellipse") return ellipsePoints(rect);
+    return [
+      { x: rect.x, y: rect.y },
+      { x: rect.x + rect.width, y: rect.y },
+      { x: rect.x + rect.width, y: rect.y + rect.height },
+      { x: rect.x, y: rect.y + rect.height }
+    ];
+  }
+  /** Pointer down. Resolves once a wand click has been applied. */
+  async begin(point, modifiers = {}) {
+    const options = this.getOptions();
+    this.error = null;
+    this.modifiers = modifiers;
+    if (options.tool === "wand") {
+      this.start = null;
+      try {
+        await this.controller.magicWand(point, {
+          tolerance: options.tolerance,
+          contiguous: options.contiguous,
+          antiAlias: options.antiAlias,
+          distance: options.distance,
+          sampleMerged: options.sampleMerged,
+          mode: selectionModeFromModifiers(modifiers, options.mode)
+        });
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      return;
+    }
+    this.start = point;
+    this.current = point;
+    this.points = [point];
+  }
+  /** Pointer move; returns true when the draft changed (re-render). */
+  move(point) {
+    if (!this.start) return false;
+    this.current = point;
+    if (this.getOptions().tool === "lasso") {
+      const last = this.points[this.points.length - 1];
+      if (Math.hypot(point.x - last.x, point.y - last.y) < 0.5) return false;
+      this.points.push(point);
+    }
+    return true;
+  }
+  /** Pointer up: commits the shape. Returns true when the selection changed. */
+  end(point, modifiers) {
+    if (!this.start) return false;
+    if (point) this.move(point);
+    const options = this.getOptions();
+    const mode = selectionModeFromModifiers(modifiers ?? this.modifiers, options.mode);
+    const path = this.draftPath;
+    const rect = normalizeRect({
+      x: this.start.x,
+      y: this.start.y,
+      width: this.current.x - this.start.x,
+      height: this.current.y - this.start.y
+    });
+    this.start = null;
+    this.current = null;
+    this.points = [];
+    if (!path) return mode === "replace" ? this.controller.deselect() : false;
+    const opts = { mode, antiAlias: options.antiAlias };
+    if (options.tool === "lasso") return path.length >= 3 ? this.controller.selectPolygon(path, opts) : false;
+    return options.tool === "ellipse" ? this.controller.selectEllipse(rect, opts) : this.controller.selectRect(rect, opts);
+  }
+  /** Abandons a drag without changing the selection. */
+  cancel() {
+    this.start = null;
+    this.current = null;
+    this.points = [];
+  }
+};
 export {
+  ADJUSTMENT_KINDS,
+  ADJUSTMENT_LAYER_CONTROLS,
+  ADJUSTMENT_LAYER_OPACITY_CONTROL,
+  ADJUSTMENT_LUT_SIZE,
   AS_SHOT_KELVIN,
+  BLEND_MODES,
   D65,
   DEFAULT_ADJUSTMENTS,
   DEFAULT_DEPTH_MASK,
+  DEFAULT_REFINE_EDGE_PARAMS,
+  DEFAULT_SELECTION_TOOL_OPTIONS,
   DEFAULT_TRANSFORM,
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  EMPTY_DISTANCE,
+  GUIDED_FILTER_EPS,
+  HISTOGRAM_BINS,
+  HUE_RANGE_LABELS,
   IDENTITY_MATRIX3,
+  IMAGE_ADJUSTMENT_CONTROLS,
+  IMAGE_EDITOR_SCHEMA_VERSION,
+  IMAGE_EDITOR_STATE_VERSION,
   ImageEditorController,
   ImageEditorRenderer,
   LATEST_PROCESS_VERSION,
@@ -1988,48 +5763,184 @@ export {
   MAX_KELVIN,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
+  REFINE_EDGE_CONTROLS,
+  SELECTION_MODES,
+  SELECTION_MODE_LABELS,
+  SELECTION_MODIFY_OPS,
+  SELECTION_TOOLS,
+  SelectionGesture,
   TINT_SCALE,
   TONE_LUT_SIZE,
+  TONE_RANGE_PRESETS,
+  VIBRANCE_GREY,
+  activeAdjustmentLayers,
+  adjustmentKindLabel,
+  adjustmentLayersKey,
+  applyAdjustmentLayers,
   applyAdjustments,
   applyDepthMask,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
   applyMatrix3,
   applyProcess2Adjustments,
+  blackWhiteGray,
+  blendChannel,
+  blendImageData,
+  blendLum,
+  blendPixel,
+  blendRgb,
+  borderCoverage,
+  boxMean,
+  boxToCurvePoint,
   bradfordAdaptation,
+  buildLayerMaskPlanes,
   buildToneLut,
   calculateCropDrag,
+  canvasCompositeOperation,
   canvasToImagePoint,
+  clampControlValue,
   clampCropToImage,
+  colorBalanceChannel,
+  colorRange,
+  combineSelections,
+  compileAdjustmentLayer,
+  computeHistogram,
+  computeSelectionBounds,
+  contractCoverage,
+  controlPosition,
+  controlTrackBackground,
+  coverageToByte,
+  createAdjustmentLayer,
+  createImageEditorToolProvider,
+  createImageSelectionTools,
+  createSelectionMask,
+  curveLut,
+  curveLutFromLevels,
+  curvePointToBox,
+  curveSvgPath,
+  decodeLayerMask,
+  decodeSelectionRle,
+  defaultAdjustmentParams,
+  describeSelection,
+  deserializeSelection,
+  distanceTransform,
+  edgeWidth,
+  ellipsePoints,
+  ellipseSelection,
+  encodeSelectionRle,
+  evaluateAdjustmentLayers,
+  expandCoverage,
+  featherCoverage,
+  findAdjustmentControl,
+  findLayerControl,
+  formatControlValue,
+  fullSelection,
+  gaussianBlur,
   getAnnotationBounds,
+  getControlPath,
   getCropCursor,
   getRotatedSize,
   getViewportMetrics,
   getViewportProjection,
   globalImageCache,
+  greyMorphology,
+  guidePlanes,
+  guidedFilterColor,
+  hashMaskContent,
+  hexToRgb,
+  histogramPath,
   hitTestAnnotation,
   hitTestCrop,
+  hitTestCurvePoint,
+  hslToRgb,
+  hueRange,
+  hueRangeTables,
+  hueRangeWeight,
+  hueSaturation,
+  identityCurve,
+  identityLevels,
+  imageEditorStateMigrations,
   imageToCanvasPoint,
+  insertCurvePoint,
   invertMatrix3,
+  invertSelection,
+  isAdjustmentKind,
+  isBlendMode,
   isQuarterTurnSwapped,
+  isSelectionEmpty,
+  isSelectionMode,
+  isSeparableBlendMode,
   kelvinToTemperature,
+  layerMaskCoverage,
+  layerMaskFromSelection,
+  layerMaskKey,
+  levelsValue,
   linearSrgbToXy,
   linearToSrgb,
+  loadImageEditorDocument,
+  magicWand,
   mapCropHandle,
+  migrateSerializedImageEditorState,
+  modifySelection,
+  moveCurvePoint,
   mulMatrix3,
+  neutralHueRange,
+  normalizeAdjustmentLayer,
+  normalizeAdjustmentLayers,
   normalizeAngle,
+  normalizeBlendMode,
+  normalizeLayerMask,
   normalizeProcessVersion,
+  normalizeRect,
+  normalizeRefineEdgeParams,
   normalizeStoredAdjustments,
+  parseSelectionMode,
+  photoFilterMatrix,
+  polygonCoverage,
+  polygonSelection,
+  posterizeValue,
   projectImagePoint,
   projectImageRect,
+  projectMaskCoverage,
+  quickMaskPixels,
+  rangeLightness,
+  readAdjustmentControls,
+  rectSelection,
+  refineCoverage,
+  refineEdgeHalo,
+  refineSelection,
   removeAlpha,
+  removeCurvePoint,
+  resizeSelection,
+  rgbToGray,
+  rgbToHsl,
+  sampleLut,
   sampleToneLut,
+  selectionArea,
+  selectionFromCoverage,
+  selectionFromPixels,
+  selectionModeFromModifiers,
+  selectionOutline,
+  selectionToCoverage,
+  selectionToPixels,
+  selectionValueAt,
+  serializeSelection,
+  setControlPath,
+  setLum,
+  shiftCoverage,
+  smoothCoverage,
+  srgb8ToLab,
   srgbToLinear,
   tempTintToXy,
   temperatureToKelvin,
   toneCurve,
+  toneLuts,
+  toneRange,
   unprojectCanvasPoint,
+  updateLayerMaskProps,
   uvToXy,
+  vibranceLinear,
+  vibrancePixel,
   wbMatrix,
   whiteBalanceFromSample,
   whiteBalanceMatrix,