@pixerate/editor 0.183.0 → 0.186.0

package/dist/image-editor/index.js

@@ -370,7 +370,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-Y46OMERN.js";
+} from "../chunk-FW7N64XK.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
@@ -939,12 +939,13 @@ function selectionOutline(mask, threshold = 128) {
 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 selected = style.indicates === "selected";
   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);
+    out[p + 3] = Math.round((selected ? mask.data[i] : 255 - mask.data[i]) * k);
   }
   return out;
 }
@@ -1362,15 +1363,31 @@ var ImageEditorRenderer = class {
       }
       ctx.restore();
     }
-    const display = options.selectionDisplay ?? (state.quickMask ? "quickMask" : "ants");
-    if (state.selection?.bounds && display !== "none" || options.draftSelectionPath?.length) {
+    const display = options.selectionDisplay ?? state.selectionDisplay ?? (state.quickMask ? "quickMask" : "ants");
+    const shownChannels = (state.channels ?? []).filter((c) => c.visible);
+    if (shownChannels.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);
+        for (const c of shownChannels) this.drawMaskOverlay(ctx, c.mask, { color: hexRgb(c.color), opacity: c.opacity, indicates: c.indicates });
+      } catch {
+      }
+      ctx.restore();
+    }
+    const { width: iw, height: ih } = state.imageDimensions;
+    const quickMaskSel = display === "quickMask" && state.quickMaskEditing && !state.selection?.bounds ? this.emptyMask(Math.round(iw), Math.round(ih)) : null;
+    if (state.selection?.bounds && display !== "none" || quickMaskSel || options.draftSelectionPath?.length) {
+      ctx.save();
+      try {
+        applyImageProjectionToContext(ctx, projection);
+        ctx.beginPath();
+        ctx.rect(region.x, region.y, region.width, region.height);
+        ctx.clip();
+        if (quickMaskSel) this.drawQuickMask(ctx, quickMaskSel);
+        else 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 / u, options.antsOffset ?? 0);
         if (options.draftSelectionPath?.length) this.drawDraftPath(ctx, options.draftSelectionPath, projection.scale / u);
       } catch {
@@ -1776,6 +1793,31 @@ var ImageEditorRenderer = class {
   }
   quickMaskCache = /* @__PURE__ */ new WeakMap();
   outlineCache = /* @__PURE__ */ new WeakMap();
+  emptyMaskCache = null;
+  /** An empty selection of the image's size (Quick Mask mode with nothing selected). */
+  emptyMask(width, height) {
+    const m = this.emptyMaskCache;
+    if (m && m.width === width && m.height === height) return m;
+    this.emptyMaskCache = createSelectionMask(Math.max(1, width), Math.max(1, height));
+    return this.emptyMaskCache;
+  }
+  overlayCache = /* @__PURE__ */ new WeakMap();
+  /** A channel's tint (colour, opacity, masked or selected area), drawn in natural image space. */
+  drawMaskOverlay(ctx, mask, style) {
+    const key = `${style.color?.join(",")}|${style.opacity}|${style.indicates}`;
+    let cached = this.overlayCache.get(mask);
+    if (!cached || cached.key !== key) {
+      const canvas = this.createCanvas(mask.width, mask.height);
+      const mctx = canvas.getContext("2d");
+      if (!mctx || typeof mctx.createImageData !== "function") return;
+      const img = mctx.createImageData(mask.width, mask.height);
+      img.data.set(quickMaskPixels(mask, style));
+      mctx.putImageData(img, 0, 0);
+      cached = { key, canvas };
+      this.overlayCache.set(mask, cached);
+    }
+    ctx.drawImage(cached.canvas, 0, 0, mask.width, mask.height);
+  }
   /** Rubylith over the unselected area, drawn in natural image space. */
   drawQuickMask(ctx, selection) {
     let canvas = this.quickMaskCache.get(selection);
@@ -2320,6 +2362,12 @@ function removeAnnotationLayers(layers) {
   }
   return out;
 }
+function hexRgb(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex);
+  if (!m) return [255, 0, 0];
+  const v = parseInt(m[1], 16);
+  return [v >> 16 & 255, v >> 8 & 255, v & 255];
+}
 
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
@@ -3065,7 +3113,7 @@ var TONE_RANGE_PRESETS = {
 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 ramp2 = Math.max(1e-3, falloff);
   const out = new Uint8Array(n);
   const d = pixels.data;
   for (let i = 0; i < n; i++) {
@@ -3073,7 +3121,7 @@ function toneRange(pixels, range, falloff = 20) {
     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);
+    out[i] = coverageToByte(1 - outside / ramp2);
   }
   return createSelectionMask(pixels.width, pixels.height, out);
 }
@@ -3102,6 +3150,111 @@ function hueRange(pixels, center) {
   }
   return createSelectionMask(pixels.width, pixels.height, out);
 }
+var HUE_RANGE_PRESETS = { reds: 0, yellows: 60, greens: 120, cyans: 180, blues: 240, magentas: 300 };
+var COLOR_RANGE_PRESETS = [
+  ...Object.keys(HUE_RANGE_PRESETS),
+  "highlights",
+  "midtones",
+  "shadows",
+  "skinTones"
+];
+function isColorRangePreset(v) {
+  return typeof v === "string" && COLOR_RANGE_PRESETS.includes(v);
+}
+var ramp = (v, lo, hi, soft) => v < lo ? Math.max(0, 1 - (lo - v) / soft) : v > hi ? Math.max(0, 1 - (v - hi) / soft) : 1;
+function skinToneRange(pixels) {
+  const n = checkPixels(pixels);
+  const out = new Uint8Array(n);
+  const d = pixels.data;
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (d[p + 3] <= 0) continue;
+    const r = d[p] / 255;
+    const g = d[p + 1] / 255;
+    const b = d[p + 2] / 255;
+    const mx = Math.max(r, g, b);
+    const mn = Math.min(r, g, b);
+    const chroma = mx - mn;
+    if (chroma <= 0 || mx <= 0) continue;
+    let hue;
+    if (mx === r) hue = ((g - b) / chroma % 6 + 6) % 6;
+    else if (mx === g) hue = (b - r) / chroma + 2;
+    else hue = (r - g) / chroma + 4;
+    hue *= 60;
+    if (hue > 180) hue -= 360;
+    const k = ramp(hue, 5, 40, 20) * ramp(chroma / mx, 0.12, 0.8, 0.1) * ramp(mx, 0.3, 1, 0.15);
+    out[i] = coverageToByte(k);
+  }
+  return createSelectionMask(pixels.width, pixels.height, out);
+}
+function colorRangePreset(pixels, preset, options = {}) {
+  if (preset === "skinTones") return skinToneRange(pixels);
+  if (preset === "highlights" || preset === "midtones" || preset === "shadows") return toneRange(pixels, preset, options.falloff ?? 20);
+  if (preset in HUE_RANGE_PRESETS) return hueRange(pixels, HUE_RANGE_PRESETS[preset]);
+  throw new Error(`Unknown Color Range preset "${String(preset)}". Use one of ${COLOR_RANGE_PRESETS.join(", ")}.`);
+}
+function selectedColorBins(pixels, sel, tolerance) {
+  const S = 64;
+  let bins = new Uint8Array(S * S * S);
+  const d = pixels.data;
+  const n = pixels.width * pixels.height;
+  for (let i = 0; i < n; i++) {
+    if (sel.data[i] < 128 || d[i * 4 + 3] === 0) continue;
+    bins[((d[i * 4] >> 2) * S + (d[i * 4 + 1] >> 2)) * S + (d[i * 4 + 2] >> 2)] = 1;
+  }
+  const r = Math.round(Math.max(0, tolerance) / 4);
+  if (r === 0) return bins;
+  for (const stride of [1, S, S * S]) {
+    const out = new Uint8Array(bins.length);
+    for (let i = 0; i < bins.length; i++) {
+      if (!bins[i]) continue;
+      const c = Math.floor(i / stride) % S;
+      const lo = Math.max(0, c - r);
+      const hi = Math.min(S - 1, c + r);
+      const base = i - c * stride;
+      for (let k = lo; k <= hi; k++) out[base + k * stride] = 1;
+    }
+    bins = out;
+  }
+  return bins;
+}
+function matcher(pixels, sel, options) {
+  if (sel.width !== pixels.width || sel.height !== pixels.height) throw new Error("The selection and the pixels differ in size");
+  const bins = selectedColorBins(pixels, sel, options.tolerance ?? 32);
+  const d = pixels.data;
+  return (i) => d[i * 4 + 3] > 0 && bins[((d[i * 4] >> 2 << 6) + (d[i * 4 + 1] >> 2)) * 64 + (d[i * 4 + 2] >> 2)] === 1;
+}
+function growSelection(pixels, sel, options = {}) {
+  checkPixels(pixels);
+  const match = matcher(pixels, sel, options);
+  const { width: w, height: h } = pixels;
+  const out = new Uint8Array(sel.data);
+  const stack = [];
+  for (let i = 0; i < out.length; i++) if (out[i] >= 128) stack.push(i);
+  while (stack.length) {
+    const i = stack.pop();
+    const x = i % w;
+    const y = (i - x) / w;
+    const visit = (j) => {
+      if (out[j] < 255 && match(j)) {
+        out[j] = 255;
+        stack.push(j);
+      }
+    };
+    if (x > 0) visit(i - 1);
+    if (x < w - 1) visit(i + 1);
+    if (y > 0) visit(i - w);
+    if (y < h - 1) visit(i + w);
+  }
+  return createSelectionMask(w, h, out);
+}
+function selectSimilar(pixels, sel, options = {}) {
+  const n = checkPixels(pixels);
+  const match = matcher(pixels, sel, options);
+  const out = new Uint8Array(sel.data);
+  for (let i = 0; i < n; i++) if (match(i)) out[i] = 255;
+  return createSelectionMask(pixels.width, pixels.height, out);
+}
 
 // src/image-editor/selection/segmentation.ts
 var isPoint = (p) => !!p && typeof p === "object" && Number.isFinite(p.x) && Number.isFinite(p.y);
@@ -3364,6 +3517,67 @@ function refineSelection(pixels, mask, params = {}) {
   return createSelectionMask(mask.width, mask.height, out);
 }
 
+// src/image-editor/selection/stroke.ts
+function selectionRing(sel, width, location) {
+  const half = location === "center" ? width / 2 : width;
+  const outer = location === "inside" ? sel : modifySelection(sel, "expand", half);
+  const inner = location === "outside" ? sel : modifySelection(sel, "contract", half);
+  const out = new Uint8Array(sel.data.length);
+  for (let i = 0; i < out.length; i++) out[i] = Math.max(0, outer.data[i] - inner.data[i]);
+  return createSelectionMask(sel.width, sel.height, out);
+}
+
+// src/image-editor/selection/channels.ts
+var DEFAULT_CHANNEL_COLOR = "#ff0000";
+function describeChannel(channel) {
+  const { mask, ...rest } = channel;
+  let sum = 0;
+  for (let i = 0; i < mask.data.length; i++) sum += mask.data[i];
+  const percent = Math.round(sum / 255 / Math.max(1, mask.data.length) * 1e4) / 100;
+  return { ...rest, bounds: mask.bounds, percent };
+}
+function serializeChannels(channels) {
+  return channels.map((c) => ({ ...c, mask: serializeSelection(c.mask) }));
+}
+function deserializeChannels(value, size, problems = []) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const raw of value) {
+    const v = raw;
+    try {
+      const mask = deserializeSelection(v.mask);
+      if (mask.width !== size.width || mask.height !== size.height) throw new Error("the channel is a different size from the canvas");
+      out.push({
+        id: typeof v.id === "string" && v.id ? v.id : `ch_${out.length + 1}`,
+        name: typeof v.name === "string" && v.name.trim() ? v.name : `Alpha ${out.length + 1}`,
+        mask,
+        color: typeof v.color === "string" && /^#[0-9a-f]{6}$/i.test(v.color) ? v.color : DEFAULT_CHANNEL_COLOR,
+        opacity: typeof v.opacity === "number" && v.opacity >= 0 && v.opacity <= 1 ? v.opacity : 0.5,
+        indicates: v.indicates === "selected" ? "selected" : "masked",
+        visible: v.visible === true
+      });
+    } catch (err) {
+      problems.push(`Alpha channel "${String(v?.name ?? "?")}" could not be read: ${err instanceof Error ? err.message : String(err)}.`);
+    }
+  }
+  return out;
+}
+function channelThumbnail(channel, maxSide = 64) {
+  const { width: w, height: h, data } = channel.mask;
+  const k = Math.min(1, maxSide / Math.max(w, h));
+  const tw = Math.max(1, Math.round(w * k));
+  const th = Math.max(1, Math.round(h * k));
+  const out = new Uint8ClampedArray(tw * th * 4);
+  for (let y = 0; y < th; y++) {
+    const sy = Math.min(h - 1, Math.floor((y + 0.5) / k));
+    for (let x = 0; x < tw; x++) {
+      const v = data[sy * w + Math.min(w - 1, Math.floor((x + 0.5) / k))];
+      out.set([v, v, v, 255], (y * tw + x) * 4);
+    }
+  }
+  return { width: tw, height: th, data: out };
+}
+
 // src/image-editor/effect-layers.ts
 function hasLayersBelow(layers, id) {
   const all = flattenLayers(layers);
@@ -4274,6 +4488,8 @@ var IMAGE_EDITOR_SCHEMA_VERSION = LAYERED_SCHEMA_VERSION;
 var RETOUCH_TOOLS = ["clone", "heal", "spot-heal", "smudge", "dodge", "burn", "sponge", "blur", "sharpen", "history"];
 var isRetouchTool = (tool) => RETOUCH_TOOLS.includes(tool);
 var STROKE_TOOLS = ["brush", "eraser", "mixer", ...RETOUCH_TOOLS];
+var QUICK_MASK_TARGET = "quick-mask";
+var PASTE_MODES = ["new-layer", "in-place", "into", "outside"];
 function paintCoverageInto(base, coverage, apply, rects, depth = null) {
   const tiles = new Map(base.tiles);
   const done = /* @__PURE__ */ new Set();
@@ -4783,6 +4999,10 @@ var ImageEditorController = class {
       } catch {
       }
     }
+    if (options.initialState?.channels) {
+      const channels = deserializeChannels(options.initialState.channels, this.naturalSize, this.lastLoadProblems);
+      if (channels.length) this.state.channels = channels;
+    }
     this.initialSnapshot = this.captureHistoryEntry();
     if (typeof options.image === "string") {
       this.loadImage(options.image);
@@ -4974,8 +5194,11 @@ var ImageEditorController = class {
     }
     const filter = normalizeSmartFilter({ kind: "effect", effect: d.id, provider: this.effects.require().id, name: d.name, values, enabled: options.enabled !== false, blend: options.blend, opacity: options.opacity });
     const res = addSmartFilter(layers, id, filter, this.canvasSize, options.index);
-    this.commitLayers(res.layers);
-    return { layerId: id, filter: res.filter, converted };
+    const masked = this.asOneStep(() => {
+      this.commitLayers(res.layers);
+      return this.maskFiltersWithSelection(id, options.useSelection);
+    });
+    return { layerId: id, filter: res.filter, converted, masked };
   }
   /**
    * Changes an effect smart filter: `values` merged over its own (`null` resets a control to the
@@ -5160,6 +5383,7 @@ var ImageEditorController = class {
       transform: { ...s.transform },
       outputOpacity: s.outputOpacity,
       selection: s.selection ?? null,
+      ...s.channels?.length ? { channels: s.channels } : {},
       source: {
         sourceUrl: s.sourceUrl,
         element: this.imageElement,
@@ -5195,6 +5419,8 @@ var ImageEditorController = class {
     if (entry.colorMode) s.colorMode = entry.colorMode;
     else delete s.colorMode;
     s.selection = entry.selection;
+    if (entry.channels?.length) s.channels = entry.channels;
+    else delete s.channels;
     if (this.imageElement !== entry.source.element && !this.samplePixelsOverride) this.samplePixels = null;
     this.imageElement = entry.source.element;
     s.sourceUrl = entry.source.sourceUrl;
@@ -5204,8 +5430,38 @@ var ImageEditorController = class {
       s.selectedAnnotationId = null;
     }
   }
+  /** Set while `asOneStep` runs: the step is already recorded, so nested commands add none. */
+  historyGrouped = false;
+  /**
+   * Runs `fn` as one undo step: history is recorded once, before it, and the commands it calls
+   * record none. If `fn` throws, the step is dropped and the state goes back to before it, so a
+   * failure never leaves half a change.
+   */
+  asOneStep(fn) {
+    if (this.historyGrouped || this.isApplyingHistory) return fn();
+    this.recordHistory();
+    const entry = this.undoStack[this.undoStack.length - 1];
+    this.historyGrouped = true;
+    try {
+      return fn();
+    } catch (err) {
+      if (this.undoStack[this.undoStack.length - 1] === entry) {
+        this.undoStack.pop();
+        this.isApplyingHistory = true;
+        try {
+          this.restoreHistoryEntry(entry);
+        } finally {
+          this.isApplyingHistory = false;
+        }
+        this.notify();
+      }
+      throw err;
+    } finally {
+      this.historyGrouped = false;
+    }
+  }
   recordHistory() {
-    if (this.isApplyingHistory) return;
+    if (this.isApplyingHistory || this.historyGrouped) return;
     this.docRevision++;
     this.undoStack.push(this.captureHistoryEntry());
     if (this.undoStack.length > this.maxHistoryDepth) {
@@ -5851,16 +6107,23 @@ var ImageEditorController = class {
     return { offset: { x: Math.round(x), y: Math.round(y) }, bounds: this.getLayerBounds(id) };
   }
   /**
-   * Adds a mask to a layer (one undo step): `reveal-all` (white), `hide-all` (black) or
-   * `selection` (the selection's coverage). Replaces an existing mask. Makes the mask the paint
+   * Adds a mask to a layer (one undo step): `reveal-all` (white), `hide-all` (black),
+   * `selection` (the selection's coverage), `hide-selection` (its inverse) or `transparency`
+   * (the layer's own alpha, so the pixels can then be made opaque and edited). Replaces an existing mask. Makes the mask the paint
    * target when the layer is active.
    */
   addLayerMask(id, from = "reveal-all", props = {}) {
     const layer = requireLayer(this.state.layers, id).layer;
     let mask;
-    if (from === "selection") {
-      const sel = this.state.selection;
-      if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select first, or use reveal-all / hide-all.");
+    if (from === "selection" || from === "hide-selection" || from === "transparency") {
+      let sel;
+      if (from === "transparency") {
+        sel = this.layerTransparency(id);
+      } else {
+        const current = this.state.selection;
+        if (!current?.bounds) throw new LayerOperationError("Nothing is selected; select first, or use reveal-all / hide-all / transparency.");
+        sel = from === "hide-selection" ? invertSelection(current) : current;
+      }
       mask = this.maskFromSelection(sel, props);
       if (layer.type === "pixel" && (layer.offset.x || layer.offset.y)) {
         mask = { ...mask, surface: translateSurface(mask.surface, -layer.offset.x, -layer.offset.y) };
@@ -6314,10 +6577,22 @@ var ImageEditorController = class {
     return res.layer.id;
   }
   /** Adds a smart filter (`develop` or `blur`, with `blend` and `opacity`) at `index` (default the top), as one undo step. */
-  addSmartFilter(id, filter, index) {
+  addSmartFilter(id, filter, index, options = {}) {
     const res = addSmartFilter(this.state.layers, id, normalizeSmartFilter(filter), this.canvasSize, index);
-    this.commitLayers(res.layers);
-    return res.filter;
+    return this.asOneStep(() => {
+      this.commitLayers(res.layers);
+      this.maskFiltersWithSelection(id, options.useSelection);
+      return res.filter;
+    });
+  }
+  /**
+   * After adding a smart filter: with `useSelection` and a selection, sets the filter mask from
+   * it in the same undo step (Photoshop limits a filter to the selection). Returns whether it did.
+   */
+  maskFiltersWithSelection(id, useSelection) {
+    if (!useSelection || !this.state.selection?.bounds) return false;
+    this.setSmartFilterMask(id, "selection", {}, false);
+    return true;
   }
   /** Changes one smart filter (one undo step, or none with `commitToHistory = false` during a drag). */
   updateSmartFilter(id, filterId, changes, commitToHistory = true) {
@@ -6857,6 +7132,12 @@ var ImageEditorController = class {
   }
   /** Resolves and validates what a stroke, fill or clear paints into. */
   paintTarget(layerId, channel, action) {
+    if (channel === "quick-mask" || channel === void 0 && layerId === void 0 && this.state.quickMaskEditing) {
+      if (!this.state.quickMaskEditing) {
+        throw new LayerOperationError(`Quick Mask is off; turn it on (set_quick_mask) to ${action} on the selection, or target a layer.`, `Turn on Quick Mask (Q) to ${action} on the selection.`);
+      }
+      return { id: QUICK_MASK_TARGET, layer: null, channel: "quick-mask", offset: { x: 0, y: 0 }, surface: this.quickMaskSurface(), lockTransparency: false };
+    }
     const id = layerId ?? this.state.activeLayerId;
     if (!id) throw new LayerOperationError(`No layer given and none is active; pass layerId (see list_layers) to ${action}.`, `Pick a layer to ${action} on in the Layers panel.`);
     const layer = requireLayer(this.state.layers, id).layer;
@@ -6925,10 +7206,11 @@ var ImageEditorController = class {
       opacity: brush.opacity,
       blend: target.channel !== "pixels" ? "normal" : brush.blend,
       lockTransparency: target.lockTransparency,
-      selection: this.state.selection?.bounds ? this.state.selection : null,
+      // In Quick Mask mode the selection is what is painted, so it does not limit the stroke.
+      selection: target.channel !== "quick-mask" && this.state.selection?.bounds ? this.state.selection : null,
       offset: target.offset
     };
-    const depth = target.channel !== "filter-mask" && this.bitDepth !== 8 ? this.bitDepth : null;
+    const depth = target.channel !== "filter-mask" && target.channel !== "quick-mask" && this.bitDepth !== 8 ? this.bitDepth : null;
     if (tool === "mixer") return new PaintStrokeSession(this, target, this.mixerStroke(init, brush), apply, depth);
     if (isRetouchTool(tool)) return new PaintStrokeSession(this, target, this.retouchStroke(tool, init, brush, target, apply), apply, depth);
     const gradient = tool === "brush" && strokePaint?.type === "gradient" ? resolvePaintGradient(strokePaint, { paint: toHex(color), secondary: toHex(background) }) : null;
@@ -7093,12 +7375,19 @@ var ImageEditorController = class {
   }
   /** @internal Shows a stroke's live surface (no history). */
   _strokeUpdate(layerId, channel, surface, rects) {
+    if (channel === "quick-mask") {
+      this.state.selection = this.selectionFromSurface(surface, this.state.selection ?? null, rects);
+      this.notify();
+      return;
+    }
     this.state.layers = mapLayer(this.state.layers, layerId, (l) => this.withSurface(l, channel, surface));
     this.notify(channel === "filter-mask" ? void 0 : rects);
   }
   /** @internal Commits a finished stroke as one undo step (`before` is the pre-stroke state). */
   _strokeCommit(before, layerId, channel, surface) {
-    if (surface) {
+    if (channel === "quick-mask") {
+      this.state.selection = surface ? this.selectionFromSurface(surface) : before.selection;
+    } else if (surface) {
       const prev = before.layers;
       this.state.layers = mapLayer(this.state.layers, layerId, (l) => this.withSurface(l, channel, surface));
       if (this.bitDepth !== 8) this.state.layers = keepDeepLayers(prev, this.state.layers);
@@ -7145,13 +7434,177 @@ var ImageEditorController = class {
   clearPixels(options = {}) {
     return this.fillOrClear(options, "erase");
   }
-  fillOrClear(options, mode) {
-    const target = this.paintTarget(options.layerId, options.channel, mode === "paint" ? "fill" : "clear");
+  /**
+   * Edit › Stroke: paints a band `width` px wide along the selection's edge, `inside` it, on the
+   * `center` of the edge or `outside` it (default), with `color` (default the foreground),
+   * `opacity` and `blend`, on a layer's pixels or mask. One undo step. Returns the changed bounds.
+   */
+  strokeSelection(options) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select first, then stroke the selection.");
+    const width = options.width;
+    if (!(width > 0 && width <= 250)) throw new LayerOperationError("width must be greater than 0 and at most 250 px.");
+    const location = options.location ?? "outside";
+    if (location !== "inside" && location !== "center" && location !== "outside") {
+      throw new LayerOperationError(`Unknown location "${String(location)}"; use inside, center or outside.`);
+    }
+    const ring = selectionRing(sel, width, location);
+    if (!ring.bounds) return { layerId: options.layerId ?? this.state.activeLayerId ?? "", channel: "pixels", bounds: null, dabs: 0 };
+    return this.fillOrClear(options, "paint", ring);
+  }
+  /**
+   * Image › Crop to the selection's bounds (one undo step). Returns the crop box (natural
+   * pixels). Throws without a selection.
+   */
+  cropToSelection() {
+    const sel = this.state.selection;
+    if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select the area to keep, then crop to it.");
+    const crop = { ...sel.bounds };
+    this.setCrop(crop);
+    return crop;
+  }
+  /**
+   * Edit › Content-Aware Fill: fills the selection with texture synthesised from around it
+   * (PatchMatch, as the Spot Healing Brush's content-aware mode), blended by the selection's
+   * coverage. `output` `current` paints into the layer; `new-layer` puts the fill on a new layer
+   * above it. Samples within `sampleRadius` px of the selection (default its larger side, at
+   * least 32). Deterministic for a `seed`. One undo step. 8-bit documents only for now.
+   */
+  contentAwareFill(options = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select what to remove, then fill it.");
+    if (this.bitDepth !== 8) throw new LayerOperationError("Content-Aware Fill works on 8-bit documents for now; set_bit_depth 8 first, or use spot_heal.");
+    const output = options.output ?? "current";
+    if (output !== "current" && output !== "new-layer") throw new LayerOperationError(`Unknown output "${String(output)}"; use current or new-layer.`);
+    const target = this.paintTarget(options.layerId, "pixels", "fill");
+    const { width, height } = this.naturalSize;
+    const b = sel.bounds;
+    const margin = Math.max(32, Math.round(options.sampleRadius ?? Math.max(b.width, b.height)));
+    const x0 = Math.max(0, b.x - margin);
+    const y0 = Math.max(0, b.y - margin);
+    const win = { x: x0, y: y0, width: Math.min(width, b.x + b.width + margin) - x0, height: Math.min(height, b.y + b.height + margin) - y0 };
+    if (win.width * win.height > 16e6) throw new LayerOperationError("The area to fill and sample is too large (over 16 MP); fill a smaller selection or lower sampleRadius.");
+    const layerRect = { x: win.x - target.offset.x, y: win.y - target.offset.y, width: win.width, height: win.height };
+    const before = readRegion(target.surface, layerRect);
+    const img = new Float32Array(before.length);
+    for (let i = 0; i < before.length; i++) img[i] = before[i];
+    const coverage = new Float32Array(win.width * win.height);
+    const hole = new Uint8Array(win.width * win.height);
+    for (let y = 0; y < win.height; y++) {
+      for (let x = 0; x < win.width; x++) {
+        const c = sel.data[(win.y + y) * sel.width + win.x + x] / 255;
+        coverage[y * win.width + x] = c;
+        hole[y * win.width + x] = c > 0 ? 1 : 0;
+      }
+    }
+    const filled = contentAwareFill(win.width, win.height, 4, img, hole, { seed: options.seed ?? 0 });
+    const out = new Uint8ClampedArray(before.length);
+    for (let i = 0; i < coverage.length; i++) {
+      const k = coverage[i];
+      for (let c = 0; c < 4; c++) {
+        const p = i * 4 + c;
+        out[p] = output === "new-layer" ? c === 3 ? Math.round(filled[p] * k) : filled[p] : before[p] + (filled[p] - before[p]) * k;
+      }
+    }
+    if (output === "new-layer") {
+      const crop = { x: b.x - win.x, y: b.y - win.y, width: b.width, height: b.height };
+      const data = new Uint8ClampedArray(b.width * b.height * 4);
+      for (let y = 0; y < b.height; y++) data.set(out.subarray(((crop.y + y) * win.width + crop.x) * 4, ((crop.y + y) * win.width + crop.x + b.width) * 4), y * b.width * 4);
+      const id = this.addPixelLayer({ name: "Content-Aware Fill", pixels: { width: b.width, height: b.height, data }, x: b.x, y: b.y, aboveId: target.id });
+      return { layerId: id, bounds: { ...b }, output };
+    }
+    const surface = writeRegion(target.surface, layerRect, out);
+    this.commitLayers(mapLayer(this.state.layers, target.id, (l) => this.withSurface(l, "pixels", surface)));
+    return { layerId: target.id, bounds: { ...b }, output };
+  }
+  /** The pixel clipboard (Copy / Cut), or null. */
+  clipboard = null;
+  /** What Copy or Cut last put on the editor's clipboard, or null. */
+  getClipboard() {
+    return this.clipboard;
+  }
+  /** Puts pixels on the editor's clipboard (e.g. an image pasted from the system clipboard). */
+  setClipboard(image) {
+    if (image && (image.data.length !== image.width * image.height * 4 || image.width < 1 || image.height < 1)) {
+      throw new LayerOperationError("Clipboard pixels must be RGBA with width \xD7 height \xD7 4 bytes.");
+    }
+    this.clipboard = image;
+  }
+  /**
+   * Edit › Copy (or Copy Merged with `merged`): the selected pixels of a pixel layer (default the
+   * active one) or of the whole visible image, cropped to the selection's bounds, with the
+   * selection's soft edge in their alpha. Without a selection, the whole canvas. Not an undo step.
+   */
+  copyPixels(options = {}) {
+    const { width, height } = this.naturalSize;
+    const sel = this.state.selection?.bounds ? this.state.selection : null;
+    const rect = sel?.bounds ?? { x: 0, y: 0, width, height };
+    let data;
+    if (options.merged) {
+      data = new Uint8ClampedArray(this.compositePixels(rect).data);
+    } else {
+      const id = options.layerId ?? this.state.activeLayerId;
+      if (!id) throw new LayerOperationError("No layer given and none is active; pass layerId, or merged: true to copy the visible image.");
+      const layer = requireLayer(this.state.layers, id).layer;
+      if (layer.type !== "pixel") throw new LayerOperationError(`Layer "${layer.name || id}" is not a pixel layer; copy merged, or rasterize it first.`);
+      data = readRegion(this.surfaceOf(layer), { x: rect.x - layer.offset.x, y: rect.y - layer.offset.y, width: rect.width, height: rect.height });
+    }
+    if (sel) {
+      for (let y = 0; y < rect.height; y++) {
+        for (let x = 0; x < rect.width; x++) {
+          const k = sel.data[(rect.y + y) * sel.width + rect.x + x];
+          const p = (y * rect.width + x) * 4 + 3;
+          data[p] = Math.round(data[p] * k / 255);
+        }
+      }
+    }
+    this.clipboard = { width: rect.width, height: rect.height, x: rect.x, y: rect.y, data };
+    return this.clipboard;
+  }
+  /** Edit › Cut: Copy, then clear the selected pixels, as one undo step. */
+  cutPixels(options = {}) {
+    return this.asOneStep(() => {
+      const clip = this.copyPixels({ layerId: options.layerId });
+      this.clearPixels({ layerId: options.layerId, channel: "pixels" });
+      return clip;
+    });
+  }
+  /**
+   * Edit › Paste as a new pixel layer above the active one (one undo step): `new-layer` centred
+   * on the selection (or the canvas), `in-place` where it was copied, `into` centred in the
+   * selection with the selection as its mask (Paste Into), or `outside` with the inverse
+   * (Paste Outside). Returns the new layer id and where it went.
+   */
+  pastePixels(mode = "new-layer", image = this.clipboard) {
+    if (!image) throw new LayerOperationError("The clipboard is empty; copy_pixels first.");
+    if (!PASTE_MODES.includes(mode)) throw new LayerOperationError(`Unknown paste mode "${String(mode)}"; use ${PASTE_MODES.join(", ")}.`);
+    const sel = this.state.selection?.bounds ? this.state.selection : null;
+    if ((mode === "into" || mode === "outside") && !sel) throw new LayerOperationError(`Paste ${mode === "into" ? "Into" : "Outside"} needs a selection; select where it goes first.`);
+    const { width, height } = this.naturalSize;
+    let x;
+    let y;
+    if (mode === "in-place" && image.x !== void 0 && image.y !== void 0) {
+      x = image.x;
+      y = image.y;
+    } else {
+      const frame = sel?.bounds ?? { x: 0, y: 0, width, height };
+      x = Math.round(frame.x + (frame.width - image.width) / 2);
+      y = Math.round(frame.y + (frame.height - image.height) / 2);
+    }
+    return this.asOneStep(() => {
+      const id = this.addPixelLayer({ name: "Pasted", pixels: { width: image.width, height: image.height, data: new Uint8ClampedArray(image.data) }, x, y });
+      if (mode === "into" || mode === "outside") this.addLayerMask(id, mode === "into" ? "selection" : "hide-selection");
+      return { layerId: id, bounds: { x, y, width: image.width, height: image.height }, masked: mode === "into" || mode === "outside" };
+    });
+  }
+  fillOrClear(options, mode, coverageMask) {
+    const target = this.paintTarget(options.layerId, options.channel, mode === "paint" ? coverageMask ? "stroke" : "fill" : "clear");
     const { width, height } = this.naturalSize;
     const opacity = options.opacity ?? 1;
     if (!(opacity >= 0 && opacity <= 1)) throw new LayerOperationError("opacity must be from 0 to 1.");
     const blend = parseBlend(options.blend) ?? "normal";
-    const sel = options.useSelection !== false && this.state.selection?.bounds ? this.state.selection : null;
+    const quickMask = target.channel === "quick-mask";
+    const sel = coverageMask ?? (!quickMask && options.useSelection !== false && this.state.selection?.bounds ? this.state.selection : null);
     const region = sel?.bounds ?? { x: 0, y: 0, width, height };
     const coverage = new CoverageMap();
     const ones = new Float32Array(region.width * region.height);
@@ -7177,8 +7630,14 @@ var ImageEditorController = class {
       selection: null,
       offset: target.offset
     };
-    const depth = target.channel !== "filter-mask" && this.bitDepth !== 8 ? this.bitDepth : null;
+    const depth = target.channel !== "filter-mask" && target.channel !== "quick-mask" && this.bitDepth !== 8 ? this.bitDepth : null;
     const surface = paintCoverageInto(target.surface, coverage, apply, [region], depth);
+    if (quickMask) {
+      this.recordHistory();
+      this.state.selection = this.selectionFromSurface(surface);
+      this.notify();
+      return { layerId: target.id, channel: target.channel, bounds: region, dabs: 0 };
+    }
     const next = mapLayer(this.state.layers, target.id, (l) => this.withSurface(l, target.channel, surface));
     this.commitLayers(next);
     return { layerId: target.id, channel: target.channel, bounds: region, dabs: 0 };
@@ -7325,7 +7784,7 @@ var ImageEditorController = class {
       enabled: spec.enabled,
       opacity: spec.opacity,
       blend: spec.blend,
-      mask: spec.mask ?? void 0
+      mask: spec.mask ?? (spec.useSelection && this.state.selection?.bounds ? layerMaskFromSelection(this.state.selection) : void 0)
     });
     while (ids.has(layer.id)) layer.id = newLayerId("adj");
     const { width, height } = this.naturalSize;
@@ -7535,6 +7994,7 @@ var ImageEditorController = class {
     const prev = normalizeSelection(this.state.selection ?? null);
     if (prev === next || prev && next && sameSelection(prev, next)) return false;
     this.recordHistory();
+    if (!next && prev?.bounds) this.lastSelection = prev;
     this.state.selection = next;
     this.notify();
     return true;
@@ -7548,6 +8008,74 @@ var ImageEditorController = class {
   deselect() {
     return this.setSelection(null);
   }
+  /** The selection a Deselect cleared, for `reselect` (not saved, not part of history). */
+  lastSelection = null;
+  /** Whether `reselect` has a selection to bring back. */
+  canReselect() {
+    const { width, height } = this.naturalSize;
+    return Boolean(this.lastSelection && this.lastSelection.width === width && this.lastSelection.height === height);
+  }
+  /** Select › Reselect: brings back the last selection a Deselect cleared, as one undo step. */
+  reselect() {
+    if (!this.canReselect()) return false;
+    return this.setSelection(this.lastSelection);
+  }
+  /**
+   * Single Row / Single Column Marquee: a 1 px line across the whole image at `position`
+   * (natural pixels; y for a row, x for a column).
+   */
+  selectLine(orientation, position, options = {}) {
+    const { width, height } = this.naturalSize;
+    const max = orientation === "row" ? height : width;
+    const at = Math.floor(position);
+    if (!Number.isFinite(position) || at < 0 || at >= max) {
+      throw new RangeError(`${orientation === "row" ? "y" : "x"} ${position} is outside the image (0..${max - 1}).`);
+    }
+    const rect = orientation === "row" ? { x: 0, y: at, width, height: 1 } : { x: at, y: 0, width: 1, height };
+    return this.shapeCommand(rectSelection(width, height, rect, { antiAlias: false }), options);
+  }
+  /** Select › Grow: adds connected pixels within `tolerance` of a selected colour (one undo step). */
+  async growSelection(options = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) return false;
+    const pixels = await this.requirePixels(options);
+    return this.setSelection(growSelection(pixels, sel, options));
+  }
+  /** Select › Similar: adds every pixel within `tolerance` of a selected colour (one undo step). */
+  async selectSimilar(options = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) return false;
+    const pixels = await this.requirePixels(options);
+    return this.setSelection(selectSimilar(pixels, sel, options));
+  }
+  /**
+   * Load Selection from a layer's transparency (Ctrl/⌘-click its thumbnail): its alpha in
+   * document space, combined by `mode`. Works on pixel, shape, type and smart object layers.
+   */
+  selectLayerTransparency(id, options = {}) {
+    const mask = this.layerTransparency(id);
+    return this.shapeCommand(mask, options);
+  }
+  layerTransparency(id) {
+    const layer = requireLayer(this.state.layers, id).layer;
+    if (!hasSurface(layer)) {
+      throw new LayerOperationError(`Layer "${layer.name || id}" has no pixels of its own; only pixel, shape, type and smart object layers do.`);
+    }
+    const { width, height } = this.naturalSize;
+    const out = new Uint8Array(width * height);
+    const pixels = this.getLayerPixels(id);
+    if (!pixels) return createSelectionMask(width, height, out);
+    for (let y = 0; y < pixels.height; y++) {
+      const dy = y + pixels.y;
+      if (dy < 0 || dy >= height) continue;
+      for (let x = 0; x < pixels.width; x++) {
+        const dx = x + pixels.x;
+        if (dx < 0 || dx >= width) continue;
+        out[dy * width + dx] = pixels.data[(y * pixels.width + x) * 4 + 3];
+      }
+    }
+    return createSelectionMask(width, height, out);
+  }
   /** Select › Inverse (with nothing selected, selects everything). */
   invertSelection() {
     const { width, height } = this.naturalSize;
@@ -7555,7 +8083,8 @@ var ImageEditorController = class {
     return this.setSelection(invertSelection(current));
   }
   shapeCommand(mask, options) {
-    const shaped = options.feather && options.feather > 0 ? modifySelection(mask, "feather", options.feather) : mask;
+    const feathered = options.feather && options.feather > 0 ? modifySelection(mask, "feather", options.feather) : mask;
+    const shaped = options.invert ? invertSelection(feathered) : feathered;
     return this.setSelection(shaped, options.mode ?? "replace");
   }
   /** Rectangular marquee in natural image pixels. */
@@ -7657,6 +8186,15 @@ var ImageEditorController = class {
     this.shapeCommand(colorRange(pixels, samples, options), options);
     return this.getSelection();
   }
+  /**
+   * Select › Color Range with a preset: `reds` … `magentas`, `highlights` / `midtones` /
+   * `shadows` (with `falloff` levels, default 20) or `skinTones`. One undo step.
+   */
+  async selectColorRangePreset(preset, options = {}) {
+    const pixels = await this.requirePixels(options);
+    this.shapeCommand(colorRangePreset(pixels, preset, 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;
@@ -7733,10 +8271,175 @@ var ImageEditorController = class {
   }
   /** 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.setSelectionDisplay(on ? "quickMask" : "ants");
+  }
+  /** How the canvas shows the selection (`state.selectionDisplay`). */
+  getSelectionDisplay() {
+    return this.state.selectionDisplay ?? (this.state.quickMask ? "quickMask" : "ants");
+  }
+  /**
+   * Shows the selection as marching ants, as a Quick Mask tint over the unselected area, or hides
+   * it (the selection still applies). View state: no undo step, not saved.
+   */
+  setSelectionDisplay(display) {
+    if (display !== "ants" && display !== "quickMask" && display !== "none") {
+      throw new Error(`Unknown selection display "${String(display)}". Use ants, quickMask or none.`);
+    }
+    if (this.getSelectionDisplay() === display) return;
+    if (display !== "quickMask") delete this.state.quickMaskEditing;
+    this.state.selectionDisplay = display;
+    this.state.quickMask = display === "quickMask";
+    this.notify();
+  }
+  // --- Alpha channels ---
+  /** The alpha channels (saved selections), in panel order. */
+  getChannels() {
+    return this.state.channels ?? [];
+  }
+  getChannel(id) {
+    return this.state.channels?.find((c) => c.id === id) ?? null;
+  }
+  requireChannel(id) {
+    const channel = this.getChannel(id);
+    if (!channel) {
+      const ids = this.getChannels().map((c) => `${c.id} (${c.name})`);
+      throw new LayerOperationError(`There is no alpha channel "${id}"; the channels are ${ids.join(", ") || "none (save a selection first)"}.`);
+    }
+    return channel;
+  }
+  setChannels(next, commitToHistory = true) {
+    if (commitToHistory) this.recordHistory();
+    if (next.length) this.state.channels = next;
+    else delete this.state.channels;
+    this.notify();
+  }
+  newChannelId() {
+    const ids = new Set(this.getChannels().map((c) => c.id));
+    let n = this.getChannels().length + 1;
+    while (ids.has(`ch_${n}`)) n++;
+    return `ch_${n}`;
+  }
+  /**
+   * Select › Save Selection: a new alpha channel (`name`, default "Alpha n") holding the
+   * selection, or with `channelId` the selection combined into that channel by `mode` (replace,
+   * add, subtract, intersect). One undo step. Throws without a selection.
+   */
+  saveSelection(options = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select first, then save the selection to a channel.");
+    const { width, height } = this.naturalSize;
+    const sized = sel.width === width && sel.height === height ? sel : resizeSelection(sel, width, height);
+    const channels = [...this.getChannels()];
+    if (options.channelId !== void 0) {
+      const existing = this.requireChannel(options.channelId);
+      const mask = combineSelections(existing.mask.bounds ? existing.mask : null, sized, options.mode ?? "replace") ?? createSelectionMask(width, height);
+      const next = { ...existing, mask, ...options.name?.trim() ? { name: options.name.trim() } : {} };
+      this.setChannels(channels.map((c) => c.id === existing.id ? next : c));
+      return next;
+    }
+    const channel = {
+      id: this.newChannelId(),
+      name: options.name?.trim() || `Alpha ${channels.length + 1}`,
+      mask: sized,
+      color: DEFAULT_CHANNEL_COLOR,
+      opacity: 0.5,
+      indicates: "masked",
+      visible: false
+    };
+    this.setChannels([...channels, channel]);
+    return channel;
+  }
+  /**
+   * Select › Load Selection from an alpha channel (inverted with `invert`), combined with the
+   * selection by `mode`. One undo step.
+   */
+  loadSelectionFromChannel(id, options = {}) {
+    const channel = this.requireChannel(id);
+    const mask = options.invert ? invertSelection(channel.mask) : channel.mask;
+    return this.setSelection(mask.bounds ? mask : null, options.mode ?? "replace");
+  }
+  /** Changes a channel's name, overlay colour, opacity, what it indicates or visibility (one undo step). */
+  setChannelProperties(id, props) {
+    const channel = this.requireChannel(id);
+    if (props.name !== void 0 && !props.name.trim()) throw new LayerOperationError("A channel name cannot be empty.");
+    if (props.color !== void 0 && !/^#[0-9a-f]{6}$/i.test(props.color)) throw new LayerOperationError("color must be #rrggbb.");
+    if (props.opacity !== void 0 && !(props.opacity >= 0 && props.opacity <= 1)) throw new LayerOperationError("opacity must be from 0 to 1.");
+    if (props.indicates !== void 0 && props.indicates !== "masked" && props.indicates !== "selected") throw new LayerOperationError("indicates must be masked or selected.");
+    const next = {
+      ...channel,
+      ...props.name !== void 0 ? { name: props.name.trim() } : {},
+      ...props.color !== void 0 ? { color: props.color.toLowerCase() } : {},
+      ...props.opacity !== void 0 ? { opacity: props.opacity } : {},
+      ...props.indicates !== void 0 ? { indicates: props.indicates } : {},
+      ...props.visible !== void 0 ? { visible: props.visible } : {}
+    };
+    this.setChannels(this.getChannels().map((c) => c.id === id ? next : c));
+    return next;
+  }
+  /** Deletes an alpha channel (one undo step). */
+  deleteChannel(id) {
+    this.requireChannel(id);
+    this.setChannels(this.getChannels().filter((c) => c.id !== id));
+  }
+  /** Duplicates an alpha channel just after it (one undo step). Returns the copy. */
+  duplicateChannel(id, name) {
+    const channel = this.requireChannel(id);
+    const copy = { ...channel, id: this.newChannelId(), name: name?.trim() || `${channel.name} copy` };
+    const channels = [...this.getChannels()];
+    channels.splice(channels.findIndex((c) => c.id === id) + 1, 0, copy);
+    this.setChannels(channels);
+    return copy;
+  }
+  /** Channel summaries (no pixels) for panels and agents. */
+  describeChannels() {
+    return this.getChannels().map(describeChannel);
+  }
+  // --- Quick Mask mode ---
+  /** Whether Quick Mask mode is on (painting edits the selection). */
+  get quickMaskEditing() {
+    return Boolean(this.state.quickMaskEditing);
+  }
+  /**
+   * Quick Mask mode (Q): on, the selection shows as a tint and painting, fills and strokes that
+   * name no layer edit the selection itself (white selects, black deselects, grey partly);
+   * off, it shows as marching ants again. View state: no undo step (the edits are).
+   */
+  setQuickMaskMode(on) {
+    if (this.quickMaskEditing === on) return;
+    if (on) this.state.quickMaskEditing = true;
+    else delete this.state.quickMaskEditing;
+    this.setSelectionDisplay(on ? "quickMask" : "ants");
     this.notify();
   }
+  /** The selection as a 1-channel surface to paint in Quick Mask mode. */
+  quickMaskSurface() {
+    const { width, height } = this.naturalSize;
+    const sel = this.state.selection;
+    if (!sel?.bounds) return emptySurface(1, 0);
+    const sized = sel.width === width && sel.height === height ? sel : resizeSelection(sel, width, height);
+    return surfaceFromPixels({ width, height, data: sized.data }, 1, 0, 0, 0);
+  }
+  /** The selection a painted Quick Mask surface stands for (`rects` changed since `base`). */
+  selectionFromSurface(surface, base = null, rects) {
+    const { width, height } = this.naturalSize;
+    let data;
+    if (base && rects && base.width === width && base.height === height) {
+      data = new Uint8Array(base.data);
+      for (const r of rects) {
+        const x0 = Math.max(0, Math.floor(r.x));
+        const y0 = Math.max(0, Math.floor(r.y));
+        const x1 = Math.min(width, Math.ceil(r.x + r.width));
+        const y1 = Math.min(height, Math.ceil(r.y + r.height));
+        if (x1 <= x0 || y1 <= y0) continue;
+        const part = readRegion(surface, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
+        for (let y = y0; y < y1; y++) data.set(part.subarray((y - y0) * (x1 - x0), (y - y0 + 1) * (x1 - x0)), y * width + x0);
+      }
+    } else {
+      const all = readRegion(surface, { x: 0, y: 0, width, height });
+      data = new Uint8Array(all.buffer, all.byteOffset, all.length);
+    }
+    return normalizeSelection(createSelectionMask(width, height, data));
+  }
   // --- Layer masks ---
   maskFromSelection(sel, props = {}) {
     const { width, height } = this.naturalSize;
@@ -7778,8 +8481,11 @@ var ImageEditorController = class {
     if (!layer || layer.type !== "adjustment" || !layer.mask) return false;
     return this.setLayerMask(layerId, withMaskProps(layer.mask, props), commitToHistory);
   }
-  /** Load Selection from a layer mask (its pixels; density and feather are not applied). */
-  selectionFromLayerMask(layerId, mode = "replace") {
+  /**
+   * Load Selection from a layer mask (its pixels; density and feather are not applied), inverted
+   * with `invert`. False without a painted mask (a depth mask is computed, not painted).
+   */
+  selectionFromLayerMask(layerId, mode = "replace", invert2 = false) {
     const layer = this.getLayer(layerId);
     if (!layer?.mask || layer.mask.source) return false;
     const { width, height } = this.naturalSize;
@@ -7787,7 +8493,7 @@ var ImageEditorController = class {
     const oy = layer.type === "pixel" ? layer.offset.y : 0;
     const data = readRegion(layer.mask.surface, { x: -ox, y: -oy, width, height });
     const sel = createSelectionMask(width, height, new Uint8Array(data.buffer, data.byteOffset, data.length));
-    return this.setSelection(sel, mode);
+    return this.setSelection(invert2 ? invertSelection(sel) : sel, mode);
   }
   // --- Histogram ---
   /**
@@ -8847,6 +9553,17 @@ var ImageEditorController = class {
     s.outputOpacity = 1;
     delete s.legacyOutputBlur;
     s.selection = null;
+    const psdChannels = (result.alphaChannels ?? []).map((c, k) => ({
+      id: `ch_${k + 1}`,
+      name: c.name,
+      mask: createSelectionMask(result.width, result.height, c.data),
+      color: c.color,
+      opacity: c.opacity,
+      indicates: c.indicates,
+      visible: false
+    }));
+    if (psdChannels.length) s.channels = psdChannels;
+    else delete s.channels;
     s.selectedAnnotationId = null;
     s.activeLayerId = defaultActiveLayerId(s.layers);
     s.activeTarget = "pixels";
@@ -9037,7 +9754,14 @@ var ImageEditorController = class {
     if (color.colorMode && this.bitDepth === 32) warnings.push(`${color.colorMode.toUpperCase()} files are written at 16 bits per channel at most; the 32-bit samples were converted (colour above 1 clipped).`);
     const depth = color.colorMode && this.bitDepth === 32 ? 16 : this.bitDepth;
     const mergedDeep = depth === 8 ? void 0 : workingToSamples(compositeDeep(prepared, canvas, sources, depth), depth);
-    const result = exportPsd({ width, height, layers: prepared, merged, mergedDeep, resolution: this.psdResolution, patterns: this.state.patterns, globalLight: this.state.globalLight, depth, ...color });
+    const alphaChannels = this.getChannels().map((c) => ({
+      name: c.name,
+      data: c.mask.width === width && c.mask.height === height ? c.mask.data : resizeSelection(c.mask, width, height).data,
+      color: c.color,
+      opacity: c.opacity,
+      indicates: c.indicates
+    }));
+    const result = exportPsd({ width, height, layers: prepared, merged, mergedDeep, resolution: this.psdResolution, patterns: this.state.patterns, globalLight: this.state.globalLight, depth, alphaChannels, ...color });
     warnings.push(...result.warnings);
     return { bytes: result.bytes, warnings, psb: result.psb, width, height };
   }
@@ -9110,6 +9834,7 @@ var ImageEditorController = class {
     try {
       out = this.serializeState();
       if (this.state.selection?.bounds) out.selection = serializeSelection(this.state.selection);
+      if (this.state.channels?.length) out.channels = serializeChannels(this.state.channels);
     } finally {
       if (root) {
         this.state = current;
@@ -9150,6 +9875,11 @@ var ImageEditorController = class {
     }
     this.state.selection = selection;
     this.dropMismatchedSelection();
+    const problems = [];
+    const channels = deserializeChannels(data.channels, this.naturalSize, problems);
+    if (channels.length) this.state.channels = channels;
+    else delete this.state.channels;
+    if (problems.length) this.lastLoadProblems = [...this.lastLoadProblems, ...problems];
     this.notify();
   }
   /** Problems found by the last `loadJSON` / `initialState` of a v3 document (unreadable layers or assets). */
@@ -10121,9 +10851,9 @@ var DEPTH_MASK_CONTROLS = [
 // src/image-editor/playback.ts
 var IMAGE_PLAYBACK_KIND = "layer";
 var PAINT = /^(paint_stroke|clone_stamp|heal_brush|spot_heal|dodge|burn|sponge|smudge|blur_stroke|sharpen_stroke|history_brush|set_clone_source|set_clone_transform|fill_pixels|clear_pixels|set_paint|set_retouch_options|load_mixer_brush|clean_mixer_brush)$/;
-var SELECT = /^(select_region|select_subject|select_by_color|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy)$/;
+var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|set_quick_mask)$/;
 var ANNOTATE = /^(add_shape_layer|update_shape|add_shape_component|set_shape_component|remove_shape_component|merge_shape_components|add_text_layer|set_text|set_text_style|set_paragraph_style|set_text_frame|convert_text_to_shape)$/;
-var CROP = /^(set_crop|reset_crop|set_rotation|flip_image|transform_layer|warp_layer|flip_layer|offset_layer)$/;
+var CROP = /^(set_crop|crop_to_selection|reset_crop|set_rotation|flip_image|transform_layer|warp_layer|flip_layer|offset_layer)$/;
 var ADJUST = /^(set_adjustments|add_adjustment_layer|update_adjustment_layer|remove_adjustment_layer|move_adjustment_layer)$/;
 function imagePlaybackPanel(tool) {
   if (ADJUST.test(tool)) return "adjust";
@@ -10238,8 +10968,24 @@ var SELECTION_TOOLS = [
   { id: "wand", label: "Magic Wand" },
   { id: "rect", label: "Rectangle" },
   { id: "ellipse", label: "Ellipse" },
-  { id: "lasso", label: "Lasso" }
+  { id: "row", label: "Single Row" },
+  { id: "column", label: "Single Column" },
+  { id: "lasso", label: "Lasso" },
+  { id: "polygon", label: "Polygonal Lasso" },
+  { id: "range", label: "Color Range" }
 ];
+var COLOR_RANGE_PRESET_LABELS = {
+  reds: "Reds",
+  yellows: "Yellows",
+  greens: "Greens",
+  cyans: "Cyans",
+  blues: "Blues",
+  magentas: "Magentas",
+  highlights: "Highlights",
+  midtones: "Midtones",
+  shadows: "Shadows",
+  skinTones: "Skin Tones"
+};
 var SELECTION_MODE_LABELS = {
   replace: "New",
   add: "Add",
@@ -10253,7 +10999,11 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   contiguous: true,
   antiAlias: true,
   sampleMerged: false,
-  distance: "rgb"
+  distance: "rgb",
+  feather: 0,
+  fuzziness: 40,
+  localized: 0,
+  rangeInvert: false
 };
 function selectionModeFromModifiers(modifiers, fallback) {
   if (modifiers.shiftKey && modifiers.altKey) return "intersect";
@@ -10284,6 +11034,41 @@ var modeSchema = {
   description: "How the result combines with the current selection (default replace)."
 };
 var num2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+var featherSchema = { type: "number", minimum: 0, maximum: 1e3, description: "Feather the new shape by this many pixels before combining (default 0)." };
+var antiAliasSchema = { type: "boolean", description: "Soft one-pixel edge (default true)." };
+var sampleMergedSchema = { type: "boolean", description: "Sample the adjusted image (adjustment layers and filters applied) rather than the pixels as painted (default false)." };
+var sampleSchema = {
+  type: "string",
+  enum: ["composite", "active-layer"],
+  description: "composite (default): all layers; active-layer: only the active pixel layer (see set_active_layer)."
+};
+var pointSchema = {
+  type: "object",
+  properties: { x: { type: "number", description: "x in natural image pixels." }, y: { type: "number", description: "y in natural image pixels." } },
+  required: ["x", "y"],
+  additionalProperties: false
+};
+var rectProperties = {
+  x: { type: "number", description: "Left edge in natural image pixels." },
+  y: { type: "number", description: "Top edge in natural image pixels." },
+  width: { type: "number", exclusiveMinimum: 0, description: "Width in natural image pixels." },
+  height: { type: "number", exclusiveMinimum: 0, description: "Height in natural image pixels." }
+};
+function shapeOptions(args) {
+  return { mode: parseSelectionMode(args.mode), feather: num2(args.feather, 0), antiAlias: args.antiAlias !== false };
+}
+function sampleOptions(args) {
+  if (args.sample !== void 0 && args.sample !== "composite" && args.sample !== "active-layer") {
+    throw new Error(`Unknown sample "${String(args.sample)}". Use composite or active-layer.`);
+  }
+  return { sampleMerged: args.sampleMerged === true, sample: args.sample ?? "composite" };
+}
+function rectOf(args) {
+  const rect = { x: num2(args.x, NaN), y: num2(args.y, NaN), width: num2(args.width, NaN), height: num2(args.height, NaN) };
+  if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite)) throw new Error("Pass numeric x, y, width and height in natural image pixels.");
+  if (rect.width <= 0 || rect.height <= 0) throw new Error("width and height must be greater than 0.");
+  return rect;
+}
 function summary(controller) {
   const sel = controller.getSelection();
   const { width, height } = controller.getState().imageDimensions;
@@ -10316,7 +11101,7 @@ function createImageSelectionTools(controller) {
   const selectRegion = {
     name: "select_region",
     title: "Select a region",
-    description: 'Selects a rectangle or ellipse (x, y, width, height in natural image pixels), a polygon (the lasso: points along an outline, closed automatically), everything ("all"), nothing ("none") or the inverse of the current selection ("invert"). To cut out a subject, trace its contour with polygon (then refine_selection for soft edges such as fur or foliage) rather than selecting its bounding box. One undoable step.',
+    description: 'Deprecated: use select_rect, select_ellipse, select_polygon, select_all, deselect or invert_selection (this alias goes in the next minor release). Selects a rectangle or ellipse (x, y, width, height in natural image pixels), a polygon (the lasso: points along an outline, closed automatically), everything ("all"), nothing ("none") or the inverse of the current selection ("invert"). To cut out a subject, trace its contour with polygon (then refine_selection for soft edges such as fur or foliage) rather than selecting its bounding box. One undoable step.',
     inputSchema: {
       type: "object",
       properties: {
@@ -10382,7 +11167,7 @@ function createImageSelectionTools(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.',
+    description: 'Deprecated: use magic_wand or select_color_range (this alias goes in the next minor release). 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: {
@@ -10422,7 +11207,7 @@ function createImageSelectionTools(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.",
+    description: "Select \u203A Modify: expand, contract, feather, border or smooth the selection by radius pixels (grow and shrink are older names for expand and contract). Expand and contract move the edge by distance; to add pixels of similar colour use grow_selection or select_similar. One undoable step.",
     inputSchema: {
       type: "object",
       properties: {
@@ -10512,27 +11297,633 @@ function createImageSelectionTools(controller) {
       return { layerId: id, kind: layer.kind, mask, selection: summary(controller) };
     }
   };
-  return [getSelection, selectRegion, selectByColor, modify, refine, applyMask];
-}
-function createImageSubjectSelectionTool(controller) {
-  return {
-    name: "select_subject",
-    title: "Select a subject",
-    description: 'Select \u203A Subject: an AI segmentation model finds the objects matching target (a description such as "the dog", "the house", "the sky") in the flattened image and selects their outlines, combined with the selection by mode. Use it to cut a subject out by its contour (then layer_via_copy for a layer of just that subject); describe one object precisely to get only that one. One undoable step. Returns the selection and the objects found (label, bounds); none found leaves the selection unchanged.',
-    inputSchema: {
-      type: "object",
-      properties: {
-        target: { type: "string", minLength: 1, description: "What to select, in words." },
-        maxSegments: {
-          type: "integer",
-          minimum: 1,
-          maximum: 32,
-          description: "Select at most this many matching objects (default the model\u2019s; 1 for a single subject)."
-        },
-        mode: modeSchema,
-        feather: { type: "number", minimum: 0, description: "Feather radius in pixels (default 0)." }
-      },
-      required: ["target"],
+  const selectAll = {
+    name: "select_all",
+    title: "Select all",
+    description: "Select \u203A All: selects the whole image. One undoable step. Returns the selection.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: writeAnnotations("Select all", true),
+    handler: () => {
+      controller.selectAll();
+      return summary(controller);
+    }
+  };
+  const deselect = {
+    name: "deselect",
+    title: "Deselect",
+    description: "Select \u203A Deselect: clears the selection, so later edits apply to the whole layer. One undoable step. Returns the (empty) selection.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: writeAnnotations("Deselect", true),
+    handler: () => {
+      controller.deselect();
+      return summary(controller);
+    }
+  };
+  const invert2 = {
+    name: "invert_selection",
+    title: "Invert the selection",
+    description: "Select \u203A Inverse: selects what was not selected (soft edges stay soft). With nothing selected, selects everything. One undoable step. Returns the selection.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: writeAnnotations("Invert the selection"),
+    handler: () => {
+      controller.invertSelection();
+      return summary(controller);
+    }
+  };
+  const selectRect = {
+    name: "select_rect",
+    title: "Select a rectangle",
+    description: "Rectangular Marquee: selects x, y, width, height (natural image pixels), combined with the selection by mode. Use it for geometric areas (a frame, a screen, a strip along an edge); for a subject, trace its outline with select_polygon or use select_subject. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: { ...rectProperties, mode: modeSchema, feather: featherSchema, antiAlias: antiAliasSchema },
+      required: ["x", "y", "width", "height"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select a rectangle", true),
+    handler: (args) => {
+      controller.selectRect(rectOf(args), shapeOptions(args));
+      return summary(controller);
+    }
+  };
+  const selectEllipse = {
+    name: "select_ellipse",
+    title: "Select an ellipse",
+    description: "Elliptical Marquee: selects the ellipse inscribed in x, y, width, height (natural image pixels), combined by mode. Use feather for a vignette. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: { ...rectProperties, mode: modeSchema, feather: featherSchema, antiAlias: antiAliasSchema },
+      required: ["x", "y", "width", "height"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select an ellipse", true),
+    handler: (args) => {
+      controller.selectEllipse(rectOf(args), shapeOptions(args));
+      return summary(controller);
+    }
+  };
+  const selectPolygonTool = {
+    name: "select_polygon",
+    title: "Select a polygon (lasso)",
+    description: "Lasso: selects the polygon through points (natural image pixels, in order along the outline, closed automatically), combined by mode. To cut out a subject, follow its contour closely (more points give a tighter edge), then refine_selection for hair or foliage. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: { type: "array", minItems: 3, items: pointSchema, description: "At least 3 vertices along the outline, in order, in natural image pixels." },
+        mode: modeSchema,
+        feather: featherSchema,
+        antiAlias: antiAliasSchema
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select a polygon (lasso)", true),
+    handler: (args) => {
+      const list = Array.isArray(args.points) ? args.points.map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) : [];
+      if (list.length < 3 || !list.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) {
+        throw new Error("points needs at least 3 { x, y } vertices in natural image pixels.");
+      }
+      controller.selectPolygon(list, shapeOptions(args));
+      return summary(controller);
+    }
+  };
+  const magicWandTool = {
+    name: "magic_wand",
+    title: "Magic wand",
+    description: "Magic Wand: selects pixels similar in colour to the one at (x, y). tolerance 0..255 (default 32) is the largest channel difference (rgb) or \u0394E scaled so 255 \u2248 \u0394E 100 (perceptual, closer to how colours look); contiguous (default true) keeps only the region connected to the seed. Best on flat backdrops and solid colours; check percent with get_selection before using it. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        x: { type: "number", description: "Seed x in natural image pixels." },
+        y: { type: "number", description: "Seed y in natural image pixels." },
+        tolerance: { type: "number", minimum: 0, maximum: 255, description: "Colour tolerance 0..255 (default 32)." },
+        contiguous: { type: "boolean", description: "Only the region connected to the seed (default true); false selects every similar pixel." },
+        distance: { type: "string", enum: ["rgb", "perceptual"], description: "How colour difference is measured: rgb (default, as Photoshop) or perceptual (CIE \u0394E)." },
+        antiAlias: antiAliasSchema,
+        sampleMerged: sampleMergedSchema,
+        sample: sampleSchema,
+        mode: modeSchema,
+        feather: featherSchema
+      },
+      required: ["x", "y"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Magic wand", true),
+    handler: async (args) => {
+      const x = num2(args.x, NaN);
+      const y = num2(args.y, NaN);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error("Pass the seed point x and y in natural image pixels.");
+      const { width, height } = controller.getState().imageDimensions;
+      if (x < 0 || y < 0 || x >= width || y >= height) throw new Error(`(${x}, ${y}) is outside the image (0..${width - 1}, 0..${height - 1}).`);
+      if (args.distance !== void 0 && args.distance !== "rgb" && args.distance !== "perceptual") {
+        throw new Error(`Unknown distance "${String(args.distance)}". Use rgb or perceptual.`);
+      }
+      await controller.magicWand(
+        { x, y },
+        {
+          ...shapeOptions(args),
+          ...sampleOptions(args),
+          tolerance: Math.min(255, Math.max(0, num2(args.tolerance, 32))),
+          contiguous: args.contiguous !== false,
+          distance: args.distance ?? "rgb"
+        }
+      );
+      return summary(controller);
+    }
+  };
+  const colorRangeTool = {
+    name: "select_color_range",
+    title: "Select a colour range",
+    description: "Select \u203A Color Range: selects every pixel matching samples (colours, each optionally at the x, y where it was picked) or a preset (reds \u2026 magentas, highlights, midtones, shadows, skinTones), softly: coverage falls off with colour distance over fuzziness levels. localized limits each positioned sample to a radius. invert selects everything else. Pass samples or preset, not both. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        samples: {
+          type: "array",
+          minItems: 1,
+          maxItems: 32,
+          items: {
+            type: "object",
+            properties: {
+              color: { type: "string", pattern: "^#?[0-9a-fA-F]{6}$", description: "The sampled colour, #rrggbb." },
+              x: { type: "number", description: "Where it was picked (natural image pixels), for localized." },
+              y: { type: "number", description: "Where it was picked (natural image pixels), for localized." }
+            },
+            required: ["color"],
+            additionalProperties: false
+          },
+          description: "Colours to select (the + eyedropper adds one). Read colours from capture_view or a seed pixel."
+        },
+        preset: { type: "string", enum: [...COLOR_RANGE_PRESETS], description: "A preset range instead of samples." },
+        fuzziness: {
+          type: "number",
+          minimum: 0,
+          maximum: 200,
+          description: "Colour samples: levels over which coverage fades to 0 (default 40). Tone presets: falloff in levels around the range (default 20). Ignored by colour and skin presets."
+        },
+        localized: { type: "number", exclusiveMinimum: 0, description: "Localized Color Clusters: positioned samples fade to 0 at this many pixels from where they were picked (default off)." },
+        invert: { type: "boolean", description: "Select everything except the range (default false)." },
+        sampleMerged: sampleMergedSchema,
+        sample: sampleSchema,
+        mode: modeSchema,
+        feather: featherSchema
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select a colour range", true),
+    handler: async (args) => {
+      const hasSamples = Array.isArray(args.samples) && args.samples.length > 0;
+      if (hasSamples === (args.preset !== void 0)) throw new Error("Pass samples (colours to match) or preset, not both.");
+      const common = { ...sampleOptions(args), mode: parseSelectionMode(args.mode), feather: num2(args.feather, 0), invert: args.invert === true };
+      if (!hasSamples) {
+        if (!isColorRangePreset(args.preset)) throw new Error(`Unknown preset "${String(args.preset)}". Use one of ${COLOR_RANGE_PRESETS.join(", ")}.`);
+        await controller.selectColorRangePreset(args.preset, { ...common, falloff: num2(args.fuzziness, 20) });
+      } else {
+        const samples = args.samples.map((s, i) => {
+          if (typeof s?.color !== "string" || !/^#?[0-9a-f]{6}$/i.test(s.color.trim())) throw new Error(`samples[${i}].color must be #rrggbb.`);
+          const at = typeof s.x === "number" && typeof s.y === "number" ? { x: s.x, y: s.y } : void 0;
+          return at ? { color: s.color, at } : { color: s.color };
+        });
+        const localized = typeof args.localized === "number" && args.localized > 0 ? args.localized : void 0;
+        await controller.selectColorRange(samples, { ...common, fuzziness: num2(args.fuzziness, 40), localized });
+      }
+      return summary(controller);
+    }
+  };
+  const loadFromImage = {
+    name: "load_selection_from_image",
+    title: "Load a selection from a mask image",
+    description: "Loads a selection from a mask image (an AI segmentation, a saved matte): white = selected by luminance, or one channel. Any size; it is resampled to the image. threshold (0..255) makes it hard-edged; leave it unset to keep soft edges. Follow with refine_selection for a coarse mask. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        image: { type: "string", minLength: 1, description: "The mask as a data URL (data:image/png;base64,\u2026) or an image URL." },
+        channel: { type: "string", enum: ["luminance", "alpha", "red", "green", "blue"], description: "What to read as coverage (default luminance; alpha for a cutout PNG)." },
+        threshold: { type: "number", minimum: 0, maximum: 255, description: "Values at or above this are selected, the rest not (default: keep soft values)." },
+        invert: { type: "boolean", description: "Black = selected instead (default false)." },
+        mode: modeSchema
+      },
+      required: ["image"],
+      additionalProperties: false
+    },
+    annotations: { ...writeAnnotations("Load a selection from a mask image", true), openWorldHint: true },
+    handler: async (args) => {
+      if (typeof args.image !== "string" || !args.image.trim()) throw new Error("image must be a data URL or image URL.");
+      const channel = args.channel ?? "luminance";
+      if (!["luminance", "alpha", "red", "green", "blue"].includes(channel)) throw new Error(`Unknown channel "${String(channel)}". Use luminance, alpha, red, green or blue.`);
+      await controller.loadSelectionFromImage(args.image, {
+        channel,
+        invert: args.invert === true,
+        threshold: typeof args.threshold === "number" ? Math.min(255, Math.max(0, args.threshold)) : void 0,
+        mode: parseSelectionMode(args.mode)
+      });
+      return summary(controller);
+    }
+  };
+  const loadFromMask = {
+    name: "load_selection_from_mask",
+    title: "Load a selection from a layer mask",
+    description: "Load Selection from a layer's mask (Ctrl/\u2318-click its mask thumbnail): the mask's pixels become the selection, combined by mode (density and feather are not applied). Use it to reuse a mask on another layer or to edit it as a selection. Fails when the layer has no painted mask. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: { type: "string", minLength: 1, description: "The layer whose mask to load (see list_layers)." },
+        invert: { type: "boolean", description: "Select what the mask hides instead (default false)." },
+        mode: modeSchema
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Load a selection from a layer mask", true),
+    handler: (args) => {
+      const id = String(args.layerId ?? "");
+      const layer = controller.getLayer(id);
+      if (!layer) throw new Error(`No layer "${id}". Call list_layers for ids.`);
+      if (!layer.mask) throw new Error(`Layer "${id}" has no mask. Add one with add_layer_mask, or pick a layer with a mask.`);
+      if (layer.mask.source) throw new Error(`Layer "${id}" has a computed (depth) mask, not a painted one, so it cannot be loaded as a selection.`);
+      controller.selectionFromLayerMask(id, parseSelectionMode(args.mode), args.invert === true);
+      return summary(controller);
+    }
+  };
+  const display = {
+    name: "set_selection_display",
+    title: "Show or hide the selection",
+    description: "How the canvas shows the selection: ants (marching ants), quickMask (a red tint over what is not selected, to judge soft edges and feather) or none (hidden; it still limits edits). View state only: no undo step, not saved. Returns the display and the selection.",
+    inputSchema: {
+      type: "object",
+      properties: { display: { type: "string", enum: ["ants", "quickMask", "none"], description: "ants, quickMask or none." } },
+      required: ["display"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Show or hide the selection", true),
+    handler: (args) => {
+      controller.setSelectionDisplay(args.display);
+      return { display: controller.getSelectionDisplay(), selection: summary(controller) };
+    }
+  };
+  const sampleTolerance = {
+    tolerance: { type: "number", minimum: 0, maximum: 255, description: "Largest per-channel difference from a selected colour, 0..255 (default 32, as magic_wand)." },
+    sampleMerged: sampleMergedSchema,
+    sample: sampleSchema
+  };
+  const growTool = {
+    name: "grow_selection",
+    title: "Grow the selection by colour",
+    description: "Select \u203A Grow: adds the pixels connected to the selection whose colour is within tolerance of a selected colour (to the nearest 4 levels). Use it after a magic_wand click that missed shades of the same area. Unlike modify_selection expand, it follows colour, not distance. Fails when nothing is selected. One undoable step. Returns the selection.",
+    inputSchema: { type: "object", properties: sampleTolerance, additionalProperties: false },
+    annotations: writeAnnotations("Grow the selection by colour"),
+    handler: async (args) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select part of the area first (magic_wand, select_rect).");
+      await controller.growSelection({ ...sampleOptions(args), tolerance: Math.min(255, Math.max(0, num2(args.tolerance, 32))) });
+      return summary(controller);
+    }
+  };
+  const similarTool = {
+    name: "select_similar",
+    title: "Select similar colours",
+    description: "Select \u203A Similar: adds every pixel in the image whose colour is within tolerance of a selected colour, connected or not. Fails when nothing is selected. One undoable step. Returns the selection.",
+    inputSchema: { type: "object", properties: sampleTolerance, additionalProperties: false },
+    annotations: writeAnnotations("Select similar colours"),
+    handler: async (args) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select a sample of the colour first.");
+      await controller.selectSimilar({ ...sampleOptions(args), tolerance: Math.min(255, Math.max(0, num2(args.tolerance, 32))) });
+      return summary(controller);
+    }
+  };
+  const lineTool = {
+    name: "select_line",
+    title: "Select a single row or column",
+    description: "Single Row / Single Column Marquee: selects a 1 px line across the whole image, a row at y = position or a column at x = position (natural image pixels). Use it to fix a dead row or column of pixels, or to stretch an edge line. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        orientation: { type: "string", enum: ["row", "column"], description: "row (horizontal, at y) or column (vertical, at x)." },
+        position: { type: "number", minimum: 0, description: "y of the row or x of the column, in natural image pixels." },
+        mode: modeSchema
+      },
+      required: ["orientation", "position"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select a single row or column", true),
+    handler: (args) => {
+      if (args.orientation !== "row" && args.orientation !== "column") throw new Error("orientation must be row or column.");
+      controller.selectLine(args.orientation, num2(args.position, NaN), { mode: parseSelectionMode(args.mode) });
+      return summary(controller);
+    }
+  };
+  const reselectTool = {
+    name: "reselect",
+    title: "Reselect",
+    description: "Select \u203A Reselect: brings back the last selection that deselect (or select_region none) cleared. Fails when there is none (for example after reopening the document). One undoable step. Returns the selection.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: writeAnnotations("Reselect", true),
+    handler: () => {
+      if (!controller.canReselect()) throw new Error("There is no cleared selection to bring back.");
+      controller.reselect();
+      return summary(controller);
+    }
+  };
+  const transparencyTool = {
+    name: "select_layer_transparency",
+    title: "Select a layer's pixels",
+    description: "Load Selection from a layer's transparency (Ctrl/\u2318-click its thumbnail): selects where the layer has pixels, soft where it is partly transparent, combined by mode. Use it to select a cutout, a shape or text exactly. Pixel, shape, type and smart object layers. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: { type: "string", minLength: 1, description: "The layer whose pixels to select (see list_layers)." },
+        mode: modeSchema,
+        feather: featherSchema
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select a layer's pixels", true),
+    handler: (args) => {
+      const id = String(args.layerId ?? "");
+      if (!controller.getLayer(id)) throw new Error(`No layer "${id}". Call list_layers for ids.`);
+      controller.selectLayerTransparency(id, { mode: parseSelectionMode(args.mode), feather: num2(args.feather, 0) });
+      return summary(controller);
+    }
+  };
+  const colorSchema = { type: "string", pattern: "^#?[0-9a-fA-F]{6}$", description: "Colour #rrggbb (default the foreground colour)." };
+  const layerIdSchema = { type: "string", minLength: 1, description: "The layer (see list_layers; default the active layer)." };
+  const requireLayerId = (v) => {
+    if (v === void 0) return void 0;
+    const id = String(v);
+    if (!controller.getLayer(id)) throw new Error(`No layer "${id}". Call list_layers for ids.`);
+    return id;
+  };
+  const strokeTool = {
+    name: "stroke_selection",
+    title: "Stroke the selection",
+    description: "Edit \u203A Stroke: paints a band width px wide along the selection edge, outside it (default), inside it or centred on it, with color, opacity and blend, on a layer's pixels or mask (channel). Use it for outlines, frames and borders that follow a shape. Fails when nothing is selected. One undo step. Returns the layer, channel and changed bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        width: { type: "number", exclusiveMinimum: 0, maximum: 250, description: "Band width in pixels." },
+        location: { type: "string", enum: ["outside", "inside", "center"], description: "Where the band lies against the edge (default outside)." },
+        color: colorSchema,
+        opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0..1 (default 1)." },
+        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal)." },
+        layerId: layerIdSchema,
+        channel: { type: "string", enum: ["pixels", "mask"], description: "Paint the pixels (default) or the layer mask." }
+      },
+      required: ["width"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Stroke the selection"),
+    handler: (args) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select the shape to outline first.");
+      return controller.strokeSelection({
+        width: num2(args.width, NaN),
+        location: args.location,
+        color: args.color,
+        opacity: args.opacity,
+        blend: args.blend,
+        layerId: requireLayerId(args.layerId),
+        channel: args.channel
+      });
+    }
+  };
+  const cropTool = {
+    name: "crop_to_selection",
+    title: "Crop to the selection",
+    description: "Image \u203A Crop to the selection: sets the crop box to the selection's bounds (non-destructive; reset_crop undoes it). Fails when nothing is selected. One undo step. Returns the crop box in natural image pixels.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: writeAnnotations("Crop to the selection", true),
+    handler: () => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select the area to keep first.");
+      return { crop: controller.cropToSelection() };
+    }
+  };
+  const fillTool = {
+    name: "content_aware_fill",
+    title: "Content-Aware Fill",
+    description: "Edit \u203A Content-Aware Fill: removes what is selected by filling it with texture and edges synthesised from around it (on a pixel layer, default the active one). Select the object with a small margin (expand 2\u20134 px) first. output current paints into the layer; new-layer puts the fill on its own layer above it, so it can be masked or removed (recommended). sampleRadius limits where it samples from. Deterministic for a seed. 8-bit documents. One undo step. Returns the layer id and filled bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        output: { type: "string", enum: ["new-layer", "current"], description: "new-layer or current (default current)." },
+        sampleRadius: { type: "number", minimum: 32, maximum: 4e3, description: "Sample within this many pixels of the selection (default its larger side)." },
+        seed: { type: "integer", minimum: 0, description: "Random seed; another seed gives another fill to choose from (default 0)." },
+        layerId: layerIdSchema
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Content-Aware Fill"),
+    handler: (args) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select what to remove first.");
+      return controller.contentAwareFill({
+        output: args.output,
+        sampleRadius: args.sampleRadius,
+        seed: args.seed,
+        layerId: requireLayerId(args.layerId)
+      });
+    }
+  };
+  const copyTool = {
+    name: "copy_pixels",
+    title: "Copy pixels",
+    description: "Edit \u203A Copy: puts the selected pixels of a pixel layer (default the active one), or with merged everything visible (Copy Merged), on the editor clipboard, cropped to the selection with its soft edge as alpha. Without a selection, the whole canvas. The document does not change. Returns the copied size and where it came from; then paste_pixels.",
+    inputSchema: {
+      type: "object",
+      properties: { layerId: layerIdSchema, merged: { type: "boolean", description: "Copy the visible image of all layers (default false)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Copy pixels", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: (args) => {
+      const { width, height, x, y } = controller.copyPixels({ layerId: requireLayerId(args.layerId), merged: args.merged === true });
+      return { width, height, x, y };
+    }
+  };
+  const cutTool = {
+    name: "cut_pixels",
+    title: "Cut pixels",
+    description: "Edit \u203A Cut: copies the selected pixels of a pixel layer (default the active one) to the editor clipboard and clears them from the layer (transparent, or the background colour on a transparency-locked layer). One undo step. Returns the copied size and position; then paste_pixels.",
+    inputSchema: { type: "object", properties: { layerId: layerIdSchema }, additionalProperties: false },
+    annotations: { title: "Cut pixels", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: (args) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select what to cut first (cutting everything would empty the layer).");
+      const { width, height, x, y } = controller.cutPixels({ layerId: requireLayerId(args.layerId) });
+      return { width, height, x, y };
+    }
+  };
+  const pasteTool = {
+    name: "paste_pixels",
+    title: "Paste pixels",
+    description: "Edit \u203A Paste the editor clipboard (from copy_pixels or cut_pixels) as a new pixel layer above the active one: new-layer (default, centred on the selection or the canvas), in-place (where it was copied), into (centred in the selection, masked by it: Paste Into) or outside (masked by its inverse). One undo step. Returns the new layerId, its bounds and whether it is masked.",
+    inputSchema: {
+      type: "object",
+      properties: { mode: { type: "string", enum: ["new-layer", "in-place", "into", "outside"], description: "Where and how to paste (default new-layer)." } },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Paste pixels"),
+    handler: (args) => controller.pastePixels(args.mode ?? "new-layer")
+  };
+  const channelIdSchema = { type: "string", minLength: 1, description: "The alpha channel (see list_channels)." };
+  const channelResult = (id) => controller.describeChannels().find((c) => c.id === id);
+  const listChannels = {
+    name: "list_channels",
+    title: "List alpha channels",
+    description: "Lists the alpha channels (saved selections kept with the document): id, name, bounds, percent of the image covered, overlay color, opacity, what the tint indicates and whether it is visible. Also whether Quick Mask mode is on.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "List alpha channels", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: () => ({ channels: controller.describeChannels(), quickMask: controller.quickMaskEditing })
+  };
+  const saveSelectionTool = {
+    name: "save_selection",
+    title: "Save the selection to a channel",
+    description: 'Select \u203A Save Selection: stores the selection in a new alpha channel (name, default "Alpha n"), or with channelId combines it into that channel by mode (replace, add, subtract, intersect). Save any selection that took work, so it can be loaded again with load_selection_from_channel. Fails when nothing is selected. One undo step. Returns the channel.',
+    inputSchema: {
+      type: "object",
+      properties: { channelId: channelIdSchema, name: { type: "string", minLength: 1, description: "Name of a new channel, or a new name for channelId." }, mode: modeSchema },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Save the selection to a channel"),
+    handler: (args) => {
+      if (!controller.getSelection()) throw new Error("Nothing is selected; select first, then save it.");
+      const c = controller.saveSelection({ channelId: args.channelId, name: args.name, mode: parseSelectionMode(args.mode) });
+      return { channel: channelResult(c.id) };
+    }
+  };
+  const loadChannelTool = {
+    name: "load_selection_from_channel",
+    title: "Load a selection from a channel",
+    description: "Select \u203A Load Selection from an alpha channel (invert for its inverse), combined with the current selection by mode. One undo step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: { channelId: channelIdSchema, invert: { type: "boolean", description: "Load the inverse (default false)." }, mode: modeSchema },
+      required: ["channelId"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Load a selection from a channel", true),
+    handler: (args) => {
+      controller.loadSelectionFromChannel(String(args.channelId), { mode: parseSelectionMode(args.mode), invert: args.invert === true });
+      return summary(controller);
+    }
+  };
+  const channelPropsTool = {
+    name: "set_channel_properties",
+    title: "Change an alpha channel",
+    description: "Renames an alpha channel or changes its overlay: color (#rrggbb), opacity (0..1), indicates (masked: tint the unselected area, or selected) and visible (show the tint on the canvas). Pixels do not change. One undo step. Returns the channel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channelId: channelIdSchema,
+        name: { type: "string", minLength: 1, description: "New name." },
+        color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "Overlay colour #rrggbb." },
+        opacity: { type: "number", minimum: 0, maximum: 1, description: "Overlay opacity 0..1." },
+        indicates: { type: "string", enum: ["masked", "selected"], description: "Which area the tint covers." },
+        visible: { type: "boolean", description: "Show the channel as a tint on the canvas." }
+      },
+      required: ["channelId"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Change an alpha channel", true),
+    handler: (args) => {
+      const { channelId, ...props } = args;
+      const c = controller.setChannelProperties(String(channelId), props);
+      return { channel: channelResult(c.id) };
+    }
+  };
+  const duplicateChannelTool = {
+    name: "duplicate_channel",
+    title: "Duplicate an alpha channel",
+    description: 'Copies an alpha channel (name, default "<name> copy") just after it, to keep a version before changing it. One undo step. Returns the copy.',
+    inputSchema: {
+      type: "object",
+      properties: { channelId: channelIdSchema, name: { type: "string", minLength: 1, description: "Name of the copy." } },
+      required: ["channelId"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Duplicate an alpha channel"),
+    handler: (args) => ({ channel: channelResult(controller.duplicateChannel(String(args.channelId), args.name).id) })
+  };
+  const deleteChannelTool = {
+    name: "delete_channel",
+    title: "Delete an alpha channel",
+    description: "Deletes an alpha channel (undo_image brings it back). Returns the remaining channels.",
+    inputSchema: { type: "object", properties: { channelId: channelIdSchema }, required: ["channelId"], additionalProperties: false },
+    annotations: { title: "Delete an alpha channel", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: (args) => {
+      controller.deleteChannel(String(args.channelId));
+      return { channels: controller.describeChannels() };
+    }
+  };
+  const quickMaskTool = {
+    name: "set_quick_mask",
+    title: "Quick Mask mode",
+    description: "Turns Quick Mask mode on or off (Q). On, the selection shows as a red tint and paint_stroke, fill_pixels, clear_pixels, stroke_selection and the retouch tools called without layerId edit the selection itself: white selects, black deselects, grey selects partly, and blur_stroke softens its edge. Each edit is one undo step. Turn it off before painting layers again. Returns the mode and the selection.",
+    inputSchema: {
+      type: "object",
+      properties: { enabled: { type: "boolean", description: "true to enter Quick Mask mode, false to leave it." } },
+      required: ["enabled"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Quick Mask mode", true),
+    handler: (args) => {
+      if (typeof args.enabled !== "boolean") throw new Error("enabled must be true or false.");
+      controller.setQuickMaskMode(args.enabled);
+      return { quickMask: controller.quickMaskEditing, selection: summary(controller) };
+    }
+  };
+  return [
+    getSelection,
+    selectAll,
+    deselect,
+    invert2,
+    selectRect,
+    selectEllipse,
+    selectPolygonTool,
+    lineTool,
+    magicWandTool,
+    colorRangeTool,
+    loadFromImage,
+    loadFromMask,
+    transparencyTool,
+    growTool,
+    similarTool,
+    reselectTool,
+    display,
+    selectRegion,
+    selectByColor,
+    modify,
+    refine,
+    applyMask,
+    strokeTool,
+    cropTool,
+    fillTool,
+    copyTool,
+    cutTool,
+    pasteTool,
+    listChannels,
+    saveSelectionTool,
+    loadChannelTool,
+    channelPropsTool,
+    duplicateChannelTool,
+    deleteChannelTool,
+    quickMaskTool
+  ];
+}
+function createImageSubjectSelectionTool(controller) {
+  return {
+    name: "select_subject",
+    title: "Select a subject",
+    description: 'Select \u203A Subject: an AI segmentation model finds the objects matching target (a description such as "the dog", "the house", "the sky") in the flattened image and selects their outlines, combined with the selection by mode. Use it to cut a subject out by its contour (then layer_via_copy for a layer of just that subject); describe one object precisely to get only that one. One undoable step. Returns the selection and the objects found (label, bounds); none found leaves the selection unchanged.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", minLength: 1, description: "What to select, in words." },
+        maxSegments: {
+          type: "integer",
+          minimum: 1,
+          maximum: 32,
+          description: "Select at most this many matching objects (default the model\u2019s; 1 for a single subject)."
+        },
+        mode: modeSchema,
+        feather: { type: "number", minimum: 0, description: "Feather radius in pixels (default 0)." }
+      },
+      required: ["target"],
       additionalProperties: false
     },
     annotations: { ...writeAnnotations("Select a subject"), openWorldHint: true },
@@ -11272,12 +12663,12 @@ function createImageLayerTools(controller) {
   const addMask = {
     name: "add_layer_mask",
     title: "Add a layer mask",
-    description: "Adds a mask to any layer, replacing an existing one: from reveal-all (white, paint black to hide), hide-all (black, paint white to reveal) or selection (the selection's coverage). density 0..1 and feather px soften it non-destructively. One undo step. Returns the mask summary.",
+    description: "Adds a mask to any layer, replacing an existing one: from reveal-all (white, paint black to hide), hide-all (black, paint white to reveal), selection (Reveal Selection: the selection's coverage), hide-selection (its inverse) or transparency (the layer's own alpha, for pixel, shape, type and smart object layers). density 0..1 and feather px soften it non-destructively. One undo step. Returns the mask summary.",
     inputSchema: {
       type: "object",
       properties: {
         layerId: LAYER_ID2,
-        from: { type: "string", enum: ["reveal-all", "hide-all", "selection"], description: "What the mask starts as (default reveal-all)." },
+        from: { type: "string", enum: ["reveal-all", "hide-all", "selection", "hide-selection", "transparency"], description: "What the mask starts as (default reveal-all)." },
         density: { type: "number", minimum: 0, maximum: 1, description: "Mask density 0..1 (default 1)." },
         feather: { type: "number", minimum: 0, maximum: 1e3, description: "Feather \u03C3 in px (default 0)." }
       },
@@ -11932,6 +13323,9 @@ function handlePaintShortcut(controller, e) {
   const set = (b) => controller.setPaintOptions({ brush: b });
   const key = e.key;
   switch (key.toLowerCase()) {
+    case "q":
+      controller.setQuickMaskMode(!controller.quickMaskEditing);
+      return true;
     case "b":
       controller.setTool(e.shiftKey || key === "B" ? "mixer" : "brush");
       return true;
@@ -12071,8 +13465,8 @@ var TARGET = {
   layerId: { type: "string", description: "Layer to paint (default the active layer; see list_layers)." },
   channel: {
     type: "string",
-    enum: ["pixels", "mask", "filter-mask"],
-    description: "pixels (default for a pixel layer), the layer's mask, or a smart object's smart filter mask (filter-mask): black hides, white reveals."
+    enum: ["pixels", "mask", "filter-mask", "quick-mask"],
+    description: "pixels (default for a pixel layer), the layer's mask, or a smart object's smart filter mask (filter-mask): black hides, white reveals. In Quick Mask mode (set_quick_mask), quick-mask (the default when no layerId is given) paints the selection: white selects, black deselects."
   }
 };
 var BRUSH = {
@@ -12460,8 +13854,8 @@ var TARGET2 = {
   layerId: { type: "string", description: "Layer to retouch (default the active layer; see list_layers)." },
   channel: {
     type: "string",
-    enum: ["pixels", "mask", "filter-mask"],
-    description: "pixels (default for a pixel layer), the layer's mask, or a smart object's filter mask. Masks are grey values and sample only themselves."
+    enum: ["pixels", "mask", "filter-mask", "quick-mask"],
+    description: "pixels (default for a pixel layer), the layer's mask, or a smart object's filter mask. Masks are grey values and sample only themselves. In Quick Mask mode (set_quick_mask), quick-mask (the default when no layerId is given) paints the selection: white selects, black deselects."
   }
 };
 var SAMPLE = {
@@ -13331,13 +14725,14 @@ function createImageSmartObjectTools(controller) {
   const addFilter = {
     name: "add_smart_filter",
     title: "Add a smart filter",
-    description: "Adds a smart filter to a smart object: develop (brightness, contrast, saturation, exposure, temperature, tint) or blur (radius px), with its own blend mode and opacity over the result below it. Filters run bottom to top on the placed contents, then the filter mask mixes in the unfiltered contents. Unlike layer filters, a kind can repeat. One undo step. Returns the filter (with its id) and the stack.",
+    description: "Adds a smart filter to a smart object: develop (brightness, contrast, saturation, exposure, temperature, tint) or blur (radius px), with its own blend mode and opacity over the result below it. Filters run bottom to top on the placed contents, then the filter mask mixes in the unfiltered contents. Unlike layer filters, a kind can repeat. With a selection (and useSelection, default true), the filter mask is set from it in the same step. One undo step. Returns the filter (with its id), the stack and masked.",
     inputSchema: {
       type: "object",
       properties: {
         layerId: LAYER_ID4,
         kind: { type: "string", enum: ["develop", "blur"], description: "Filter kind." },
         index: { type: "integer", minimum: 0, description: "Position in the stack, 0 = bottom, applied first (default the top)." },
+        useSelection: { type: "boolean", description: "With a selection, set the filter mask from it so the filter only changes the selected area (default true)." },
         ...FILTER_SETTINGS
       },
       required: ["layerId", "kind"],
@@ -13346,8 +14741,9 @@ function createImageSmartObjectTools(controller) {
     annotations: { title: "Add a smart filter", ...WRITE7 },
     handler: (args) => {
       const id = smartId(args.layerId);
-      const filter = controller.addSmartFilter(id, { kind: args.kind, ...settingsFrom(args) }, args.index);
-      return { layerId: id, filter, smartFilters: info(id).smartFilters };
+      const masked = args.useSelection !== false && controller.hasSelection;
+      const filter = controller.addSmartFilter(id, { kind: args.kind, ...settingsFrom(args) }, args.index, { useSelection: args.useSelection !== false });
+      return { layerId: id, filter, smartFilters: info(id).smartFilters, masked };
     }
   };
   const updateFilter = {
@@ -14160,7 +15556,7 @@ function createImageEditorToolProvider(controller, options = {}) {
   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.",
+    description: "Adds a non-destructive adjustment layer on top of the stack (one undoable step) and returns it; with a selection it is masked by it (useSelection, default true; masked in the result says so). Kinds: " + ADJUSTMENT_KINDS.map((k) => k.kind).join(", ") + ". Omitted params are neutral.",
     inputSchema: {
       type: "object",
       properties: {
@@ -14170,7 +15566,8 @@ function createImageEditorToolProvider(controller, options = {}) {
         blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal)." },
         name: { type: "string", description: "Layer name shown in the layers panel." },
         aboveId: { type: "string", description: "Put the layer directly above this layer (from list_layers). Default: above the other adjustment layers, below annotations." },
-        parentId: { type: "string", description: "Put the layer at the top of this group (from list_layers)." }
+        parentId: { type: "string", description: "Put the layer at the top of this group (from list_layers)." },
+        useSelection: { type: "boolean", description: "With a selection, mask the new layer with it so the adjustment only affects the selected area (default true; false for a global layer)." }
       },
       required: ["kind"],
       additionalProperties: false
@@ -14182,7 +15579,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       idempotentHint: false,
       openWorldHint: false
     },
-    handler: ({ kind, params, opacity, blend, name, aboveId, parentId }) => {
+    handler: ({ kind, params, opacity, blend, name, aboveId, parentId, useSelection }) => {
       if (!isAdjustmentKind(kind)) throw new Error(`Unknown adjustment kind "${kind}".`);
       if (blend !== void 0 && !isBlendMode(blend)) throw new Error(`Unknown blend mode "${blend}".`);
       if (aboveId !== void 0 && parentId !== void 0) throw new Error("Give aboveId or parentId, not both.");
@@ -14190,9 +15587,9 @@ function createImageEditorToolProvider(controller, options = {}) {
         if (ref !== void 0 && !controller.getLayer(ref)) throw new Error(`Unknown layer "${ref}". Call list_layers for ids.`);
       }
       if (parentId !== void 0 && controller.getLayer(parentId)?.type !== "group") throw new Error(`Layer "${parentId}" is not a group.`);
-      const id = controller.addAdjustmentLayer({ kind, params, opacity, blend, name, aboveId, parentId });
+      const id = controller.addAdjustmentLayer({ kind, params, opacity, blend, name, aboveId, parentId, useSelection: useSelection !== false });
       const layer = controller.getAdjustmentLayer(id);
-      return { layer: JSON.parse(JSON.stringify(layer)), index: controller.getAdjustmentLayers().findIndex((l) => l.id === id) };
+      return { layer: JSON.parse(JSON.stringify(layer)), index: controller.getAdjustmentLayers().findIndex((l) => l.id === id), masked: Boolean(layer.mask) };
     }
   };
   const renderPreview = {
@@ -14326,6 +15723,14 @@ function removeCurvePoint(points, index) {
 var round22 = (v) => Math.round(v * 100) / 100;
 
 // src/image-editor/selection/gesture.ts
+function snapTo45(from, point) {
+  const dx = point.x - from.x;
+  const dy = point.y - from.y;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return point;
+  const a = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
+  return { x: from.x + Math.cos(a) * len, y: from.y + Math.sin(a) * len };
+}
 var SelectionGesture = class {
   constructor(controller, getOptions) {
     this.controller = controller;
@@ -14337,13 +15742,20 @@ var SelectionGesture = class {
   points = [];
   current = null;
   modifiers = {};
+  /** Polygonal lasso corners while one is being drawn. */
+  polygon = null;
+  pressedAt = null;
+  freehand = false;
+  /** A click this close to the first corner (natural pixels) closes a polygonal lasso. */
+  closeRadius = 8;
   /** The last error (e.g. pixels unavailable for the wand), for the UI to show. */
   error = null;
   get active() {
-    return this.start !== null;
+    return this.start !== null || this.polygon !== null;
   }
   /** The outline of the shape being drawn, or `null`. */
   get draftPath() {
+    if (this.polygon) return this.current ? [...this.polygon, this.current] : this.polygon.slice();
     if (!this.start || !this.current) return null;
     const { tool } = this.getOptions();
     if (tool === "lasso") return this.points.length > 1 ? this.points.slice() : null;
@@ -14366,18 +15778,71 @@ var SelectionGesture = class {
   async begin(point, modifiers = {}) {
     const options = this.getOptions();
     this.error = null;
+    if (this.polygon && options.tool !== "polygon") this.cancel();
+    if (options.tool === "polygon") {
+      this.pressedAt = point;
+      this.freehand = false;
+      if (!this.polygon) {
+        this.modifiers = modifiers;
+        this.polygon = [point];
+        this.current = point;
+        return;
+      }
+      const last = this.polygon[this.polygon.length - 1];
+      const p = modifiers.shiftKey ? snapTo45(last, point) : point;
+      const first = this.polygon[0];
+      if (this.polygon.length >= 3 && Math.hypot(p.x - first.x, p.y - first.y) <= this.closeRadius) {
+        this.close();
+        return;
+      }
+      if (Math.hypot(p.x - last.x, p.y - last.y) >= 0.5) this.polygon.push(p);
+      this.current = p;
+      if ((modifiers.detail ?? 1) >= 2) this.close();
+      return;
+    }
     this.modifiers = modifiers;
-    if (options.tool === "wand") {
+    if (options.tool === "row" || options.tool === "column") {
       this.start = null;
       try {
+        this.controller.selectLine(options.tool, options.tool === "row" ? point.y : point.x, {
+          mode: selectionModeFromModifiers(modifiers, options.mode),
+          feather: options.feather ?? 0
+        });
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      return;
+    }
+    if (options.tool === "wand" || options.tool === "range") {
+      this.start = null;
+      const common = {
+        sampleMerged: options.sampleMerged,
+        sample: options.sample,
+        feather: options.feather ?? 0,
+        mode: selectionModeFromModifiers(modifiers, options.mode)
+      };
+      try {
+        if (options.tool === "range") {
+          const pixels = await this.controller.getSamplePixels(common);
+          if (!pixels) throw new Error("The image pixels are not available to sample.");
+          const x = Math.min(pixels.width - 1, Math.max(0, Math.floor(point.x)));
+          const y = Math.min(pixels.height - 1, Math.max(0, Math.floor(point.y)));
+          const p = (y * pixels.width + x) * 4;
+          const color = [pixels.data[p], pixels.data[p + 1], pixels.data[p + 2]];
+          await this.controller.selectColorRange([{ color, at: point }], {
+            ...common,
+            fuzziness: options.fuzziness ?? 40,
+            localized: options.localized ? options.localized : void 0,
+            invert: options.rangeInvert ?? false
+          });
+          return;
+        }
         await this.controller.magicWand(point, {
+          ...common,
           tolerance: options.tolerance,
           contiguous: options.contiguous,
           antiAlias: options.antiAlias,
-          distance: options.distance,
-          sampleMerged: options.sampleMerged,
-          sample: options.sample,
-          mode: selectionModeFromModifiers(modifiers, options.mode)
+          distance: options.distance
         });
       } catch (err) {
         this.error = err instanceof Error ? err.message : String(err);
@@ -14389,7 +15854,18 @@ var SelectionGesture = class {
     this.points = [point];
   }
   /** Pointer move; returns true when the draft changed (re-render). */
-  move(point) {
+  move(point, modifiers = {}) {
+    if (this.polygon) {
+      const last = this.polygon[this.polygon.length - 1];
+      if (this.pressedAt && (this.freehand || Math.hypot(point.x - this.pressedAt.x, point.y - this.pressedAt.y) >= 3)) {
+        this.freehand = true;
+        if (Math.hypot(point.x - last.x, point.y - last.y) >= 0.5) this.polygon.push(point);
+        this.current = null;
+        return true;
+      }
+      this.current = modifiers.shiftKey ? snapTo45(last, point) : point;
+      return true;
+    }
     if (!this.start) return false;
     this.current = point;
     if (this.getOptions().tool === "lasso") {
@@ -14401,6 +15877,12 @@ var SelectionGesture = class {
   }
   /** Pointer up: commits the shape. Returns true when the selection changed. */
   end(point, modifiers) {
+    if (this.polygon) {
+      if (point && this.freehand) this.move(point);
+      this.pressedAt = null;
+      this.freehand = false;
+      return false;
+    }
     if (!this.start) return false;
     if (point) this.move(point);
     const options = this.getOptions();
@@ -14416,17 +15898,70 @@ var SelectionGesture = class {
     this.current = null;
     this.points = [];
     if (!path) return mode === "replace" ? this.controller.deselect() : false;
-    const opts = { mode, antiAlias: options.antiAlias };
+    const opts = { mode, antiAlias: options.antiAlias, feather: options.feather ?? 0 };
     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. */
+  /** Closes a polygonal lasso and selects it. Returns true when the selection changed. */
+  close() {
+    const polygon = this.polygon;
+    if (!polygon) return false;
+    const options = this.getOptions();
+    this.cancel();
+    if (polygon.length < 3) return false;
+    return this.controller.selectPolygon(polygon, {
+      mode: selectionModeFromModifiers(this.modifiers, options.mode),
+      antiAlias: options.antiAlias,
+      feather: options.feather ?? 0
+    });
+  }
+  /**
+   * Keys for a polygonal lasso being drawn: Enter closes it, Escape cancels, Backspace / Delete
+   * removes the last corner. Returns true when the key was used (the host prevents its default).
+   */
+  key(key) {
+    if (!this.polygon) return false;
+    if (key === "Enter") this.close();
+    else if (key === "Escape") this.cancel();
+    else if (key === "Backspace" || key === "Delete") {
+      this.polygon.pop();
+      if (!this.polygon.length) this.cancel();
+    } else return false;
+    return true;
+  }
+  /** Abandons a drag (or a polygonal lasso) without changing the selection. */
   cancel() {
     this.start = null;
     this.current = null;
     this.points = [];
+    this.polygon = null;
+    this.pressedAt = null;
+    this.freehand = false;
   }
 };
+function handleSelectionShortcut(controller, e, onError) {
+  if (!(e.ctrlKey || e.metaKey)) return false;
+  const key = e.key.toLowerCase();
+  const run = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      onError?.(err instanceof Error ? err.message : String(err));
+    }
+    return true;
+  };
+  if (key === "c") return run(() => controller.copyPixels({ merged: Boolean(e.shiftKey) }));
+  if (key === "x" && !e.shiftKey) return run(() => controller.cutPixels());
+  if (key === "v") return run(() => controller.pastePixels(e.shiftKey && e.altKey ? "into" : e.shiftKey ? "in-place" : "new-layer"));
+  if (key === "d") return run(() => e.shiftKey ? controller.reselect() : controller.deselect());
+  if (key === "i" && e.shiftKey) return run(() => controller.invertSelection());
+  return false;
+}
+function handleQuickMaskKey(controller, e) {
+  if (e.ctrlKey || e.metaKey || e.altKey || e.key.toLowerCase() !== "q") return false;
+  controller.setQuickMaskMode(!controller.quickMaskEditing);
+  return true;
+}
 
 // src/image-editor/mosaic-filter.ts
 function resolveMosaicRegionBounds(region, imgWidth, imgHeight) {
@@ -14566,6 +16101,21 @@ function applyRegionBlur(imageData, regions, radius = 10) {
 }
 
 // src/image-editor/layers/panel.ts
+function maskThumbnailClick(controller, layer, e) {
+  if (!layer.mask) return;
+  if (e.ctrlKey || e.metaKey) {
+    controller.selectionFromLayerMask(layer.id, selectionModeFromModifiers(e, "replace"));
+  } else if (e.shiftKey) {
+    controller.setLayerMaskProps(layer.id, { enabled: layer.mask.enabled === false });
+  } else {
+    controller.setActiveLayer(layer.id, "mask");
+  }
+}
+function layerThumbnailClick(controller, layer, e) {
+  if (!(e.ctrlKey || e.metaKey)) return false;
+  controller.selectLayerTransparency(layer.id, { mode: selectionModeFromModifiers(e, "replace") });
+  return true;
+}
 function layerPanelRows(layers, activeId) {
   const rows = [];
   const walk = (list, depth, parentId) => {
@@ -14637,6 +16187,7 @@ function layerMenu(controller) {
   const below = loc ? siblings[loc.index - 1] : void 0;
   const hasSel = controller.hasSelection;
   const isPixel = active?.type === "pixel";
+  const hasOwnPixels = active?.type === "pixel" || active?.type === "shape" || active?.type === "type" || active?.type === "smart";
   return [
     { action: "new-layer", label: "New Layer", enabled: true },
     { action: "new-group", label: "New Group", enabled: true },
@@ -14651,6 +16202,9 @@ function layerMenu(controller) {
     { action: "via-cut", label: "Layer via Cut", enabled: isPixel && hasSel },
     { action: "add-mask", label: "Add Layer Mask", enabled: Boolean(active) },
     { action: "add-mask-selection", label: "Add Mask from Selection", enabled: Boolean(active) && hasSel },
+    { action: "add-mask-hide-selection", label: "Add Mask Hiding Selection", enabled: Boolean(active) && hasSel },
+    { action: "add-mask-transparency", label: "Add Mask from Transparency", enabled: hasOwnPixels },
+    { action: "select-transparency", label: "Select Layer Pixels", enabled: hasOwnPixels },
     { action: "apply-mask", label: "Apply Layer Mask", enabled: isPixel && Boolean(active?.mask) },
     { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask", label: active?.mask?.enabled === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(active?.mask) },
@@ -14702,6 +16256,15 @@ async function runLayerMenuAction(controller, action) {
       case "add-mask":
         if (id) controller.addLayerMask(id, "reveal-all");
         break;
+      case "add-mask-hide-selection":
+        if (id) controller.addLayerMask(id, "hide-selection");
+        break;
+      case "add-mask-transparency":
+        if (id) controller.addLayerMask(id, "transparency");
+        break;
+      case "select-transparency":
+        if (id) controller.selectLayerTransparency(id);
+        break;
       case "add-mask-selection":
         if (id) controller.addLayerMask(id, "selection");
         break;
@@ -14886,6 +16449,7 @@ async function addLayerOfKind(controller, id, init) {
     if (isAdjustmentKind(kind)) {
       return controller.addAdjustmentLayer({
         kind,
+        useSelection: true,
         ...init
       });
     }
@@ -15834,7 +17398,7 @@ function createImageEffectsToolProvider(controller, options = {}) {
     skill: "pixerate-image-editor",
     target: { noun: "layer", id: "A layer id from list_layers." },
     applyUses: ["filter"],
-    applyDetails: "The effect becomes a smart filter: it runs on the layer's pixels after the smart filters below it, with its own blend and opacity, under the smart filter mask, and can be changed or removed later. A pixel, shape or type layer (or a group) is converted to a smart object first, in the same undo step (one layer keeps its id; the result says converted). Generators and overlays go on their own layer through add_effect_layer.",
+    applyDetails: "The effect becomes a smart filter: it runs on the layer's pixels after the smart filters below it, with its own blend and opacity, under the smart filter mask, and can be changed or removed later. A pixel, shape or type layer (or a group) is converted to a smart object first, in the same undo step (one layer keeps its id; the result says converted). With a selection, the filter mask is set from it in the same step, so the filter only changes the selected area (the result says masked); deselect first to filter the whole layer. Generators and overlays go on their own layer through add_effect_layer.",
     provider: () => controller.effectsProvider,
     readOnlyReason,
     list: (target) => {
@@ -15842,8 +17406,8 @@ function createImageEffectsToolProvider(controller, options = {}) {
       return layers.map((l) => ({ target: l.id, ...l.name ? { name: l.name } : {}, effects: imageLayerAppliedEffects(l) })).filter((t) => target || t.effects.length);
     },
     apply: async (target, effect, args) => {
-      const r = await controller.applyEffectFilter(target, effect, { values: plainValues(args.values), index: args.index, enabled: args.enabled, opacity: args.opacity });
-      return result(r.layerId, r.filter.id, { converted: r.converted });
+      const r = await controller.applyEffectFilter(target, effect, { values: plainValues(args.values), index: args.index, enabled: args.enabled, opacity: args.opacity, useSelection: true });
+      return result(r.layerId, r.filter.id, { converted: r.converted, masked: r.masked });
     },
     update: async (target, instance, changes) => {
       const layer = layerOf(target);
@@ -15974,6 +17538,8 @@ export {
   CANVAS_SIZE_PRESETS,
   CLONE_TRANSFORM_CONTROLS,
   COLOR_MODE_OPTIONS,
+  COLOR_RANGE_PRESETS,
+  COLOR_RANGE_PRESET_LABELS,
   CoverageMap,
   D50,
   D65,
@@ -15982,6 +17548,7 @@ export {
   DEFAULT_BLENDER,
   DEFAULT_BRUSH,
   DEFAULT_CANVAS_VIEWPORT,
+  DEFAULT_CHANNEL_COLOR,
   DEFAULT_DEPTH_MASK,
   DEFAULT_FLOW,
   DEFAULT_GLOBAL_LIGHT,
@@ -16030,6 +17597,7 @@ export {
   HIDE,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
+  HUE_RANGE_PRESETS,
   IDENTITY_CLONE_TRANSFORM,
   IDENTITY_MATRIX3,
   IMAGE_ADJUSTMENT_CONTROLS,
@@ -16093,6 +17661,7 @@ export {
   PARAGRAPH_STYLE_FIELDS,
   PARAM,
   PARAM_FLOATS,
+  PASTE_MODES,
   PATTERN_BLOCK_KEYS,
   PIGMENT_BANDS,
   PIGMENT_CHANNELS,
@@ -16124,6 +17693,7 @@ export {
   PatternPlacement,
   PatternTile,
   PsdError,
+  QUICK_MASK_TARGET,
   REFINE_EDGE_CONTROLS,
   RETOUCH_CHOICES,
   RETOUCH_OPTION_CONTROLS,
@@ -16281,6 +17851,7 @@ export {
   canvasToImagePoint,
   caretAt,
   changedTiles,
+  channelThumbnail,
   checkEffectAnimation,
   checkEffectTime,
   checkImageEffectPlace,
@@ -16296,6 +17867,7 @@ export {
   colorModePlanes16,
   colorPanelView,
   colorRange,
+  colorRangePreset,
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
@@ -16378,10 +17950,12 @@ export {
   depthMaskAlpha,
   depthOf,
   depthRasterMask,
+  describeChannel,
   describeLayer,
   describeLayerEffects,
   describeSelection,
   describeTransform,
+  deserializeChannels,
   deserializeColorMode,
   deserializeColorProfile,
   deserializeEffects,
@@ -16468,9 +18042,12 @@ export {
   grainHeights,
   greyMorphology,
   groupLayers,
+  growSelection,
   guidePlanes,
   guidedFilterColor,
   handlePaintShortcut,
+  handleQuickMaskKey,
+  handleSelectionShortcut,
   hasActiveEffects,
   hasLayersBelow,
   hasResampledLegacyMask,
@@ -16515,6 +18092,7 @@ export {
   isBitDepth,
   isBlendMode,
   isBrushstrokeBrush,
+  isColorRangePreset,
   isContentsDecoded,
   isDefaultDepthMask,
   isGradientPaint,
@@ -16561,6 +18139,7 @@ export {
   layerName,
   layerPanelRows,
   layerPanels,
+  layerThumbnailClick,
   layerTree,
   layerTypeLabel,
   layerWarning,
@@ -16589,6 +18168,7 @@ export {
   mapSubpaths,
   maskBounds,
   maskSummary,
+  maskThumbnailClick,
   matrixFromCorners,
   matrixFromParams,
   measureCanvasViewport,
@@ -16784,14 +18364,17 @@ export {
   segmentToSelection,
   segmentationOutlines,
   segmentsToSelection,
+  selectSimilar,
   selectionArea,
   selectionFromCoverage,
   selectionFromPixels,
   selectionModeFromModifiers,
   selectionOutline,
+  selectionRing,
   selectionToCoverage,
   selectionToPixels,
   selectionValueAt,
+  serializeChannels,
   serializeColorMode,
   serializeColorProfile,
   serializeContents,
@@ -16821,11 +18404,13 @@ export {
   shapeOutline,
   shapeRenderClip,
   shiftCoverage,
+  skinToneRange,
   smartFilterRows,
   smartObjectLayers,
   smoothCoverage,
   smoothPoints,
   smudgeEffect,
+  snapTo45,
   solidPaint,
   solidSurface,
   solveMembrane,