@pixerate/editor 0.111.0 → 0.113.0

package/dist/image-editor/index.js

@@ -4,7 +4,37 @@ import {
 import {
   createCaptureTool
 } from "../chunk-REOJJIY3.js";
-import "../chunk-VKK5VS2T.js";
+import {
+  DEFAULT_RETOUCH,
+  RETOUCH_SAMPLES,
+  RegionPixelSource,
+  RetouchDabStroke,
+  SPOT_HEAL_TYPES,
+  TONE_RANGES,
+  TilePixelSource,
+  applyRetouchToTile,
+  bestOffset,
+  dilateMask,
+  dodgeBurn,
+  dodgeBurnCurve,
+  healPixels,
+  luma,
+  maskBounds,
+  membraneFill,
+  normalizeRetouch,
+  perDabStrength,
+  readSourceRegion,
+  rgbaViewOfGrey,
+  saturationOf,
+  seamlessClone,
+  smudgeEffect,
+  solveMembrane,
+  sponge,
+  spongeEffect,
+  spotHealPixels,
+  spotHealWindow,
+  toneOf
+} from "../chunk-LPYOIVLA.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -369,7 +399,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-HHZ6ZJTW.js";
+} from "../chunk-CZOXTEMN.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
@@ -1065,6 +1095,45 @@ var ImageEditorRenderer = class {
       }
       ctx.restore();
     }
+    if (options.textEdit) {
+      const t = options.textEdit;
+      ctx.save();
+      try {
+        const scr = (p) => projectImagePoint(p, projection);
+        const poly = (pts) => {
+          ctx.beginPath();
+          pts.map(scr).forEach((p, i) => i ? ctx.lineTo(p.x, p.y) : ctx.moveTo(p.x, p.y));
+          ctx.closePath();
+        };
+        if (t.frame) {
+          poly(t.frame);
+          ctx.setLineDash([4, 3]);
+          ctx.lineWidth = 1;
+          ctx.strokeStyle = "rgba(99,102,241,0.9)";
+          ctx.stroke();
+          ctx.setLineDash([]);
+        }
+        ctx.fillStyle = "rgba(99,102,241,0.35)";
+        for (const q of t.selection) {
+          poly(q);
+          ctx.fill();
+        }
+        if (t.caret) {
+          const [a, b] = t.caret.map(scr);
+          ctx.beginPath();
+          ctx.moveTo(a.x, a.y);
+          ctx.lineTo(b.x, b.y);
+          ctx.lineWidth = 3;
+          ctx.strokeStyle = "#ffffff";
+          ctx.stroke();
+          ctx.lineWidth = 1.5;
+          ctx.strokeStyle = "#111827";
+          ctx.stroke();
+        }
+      } catch {
+      }
+      ctx.restore();
+    }
     if (options.freeTransform) {
       const t = options.freeTransform;
       ctx.save();
@@ -2581,7 +2650,7 @@ function createOutlineTextShaper(fonts, options = {}) {
     return { face: e.face, family, key: family.toLowerCase(), weight, italic, postScript };
   });
   const fallbackKey = (options.fallback ?? entries[0].family).toLowerCase();
-  const pick2 = (font) => {
+  const pick3 = (font) => {
     if (font.postScriptName) {
       const exact = entries.find((e) => e.postScript === font.postScriptName);
       if (exact) return { entry: exact, available: true };
@@ -2609,22 +2678,22 @@ function createOutlineTextShaper(fonts, options = {}) {
   return {
     id: options.id ?? `outline:${entries.map((e) => `${e.family}/${e.weight}${e.italic ? "i" : ""}`).join(",")}`,
     resolve(font) {
-      const { entry, available } = pick2(font);
+      const { entry, available } = pick3(font);
       return { family: entry.family, available };
     },
     metrics(font) {
-      const { face } = pick2(font).entry;
+      const { face } = pick3(font).entry;
       const k = font.size / face.unitsPerEm;
       return { ascent: face.ascender * k, descent: -face.descender * k };
     },
     measure(text, font) {
-      const { face } = pick2(font).entry;
+      const { face } = pick3(font).entry;
       const out = [0];
       for (let i = 1; i <= text.length; i++) out.push(face.getAdvanceWidth(text.slice(0, i), font.size, { kerning: true }));
       return out;
     },
     outline(text, font, x, y) {
-      return toPath(pick2(font).entry.face.getPath(text, x, y, font.size, { kerning: true }).commands);
+      return toPath(pick3(font).entry.face.getPath(text, x, y, font.size, { kerning: true }).commands);
     },
     families() {
       return [...new Set(entries.map((e) => e.family))];
@@ -3114,6 +3183,9 @@ var FreeTransformSession = class {
 
 // src/image-editor/controller.ts
 var IMAGE_EDITOR_SCHEMA_VERSION = LAYERED_SCHEMA_VERSION;
+var RETOUCH_TOOLS = ["clone", "heal", "spot-heal", "smudge", "dodge", "burn", "sponge"];
+var isRetouchTool = (tool) => RETOUCH_TOOLS.includes(tool);
+var STROKE_TOOLS = ["brush", "eraser", "mixer", ...RETOUCH_TOOLS];
 function paintCoverageInto(base, coverage, apply, rects) {
   const tiles = new Map(base.tiles);
   const done = /* @__PURE__ */ new Set();
@@ -3147,6 +3219,18 @@ var PaintStrokeSession = class {
     if (stroke instanceof StrokeCoverage) {
       this.stroke = stroke;
       this.mixer = null;
+    } else if ("kind" in stroke && stroke.kind === "coverage") {
+      this.stroke = stroke.coverage;
+      this.mixer = null;
+      this.retouch = stroke;
+    } else if ("kind" in stroke) {
+      this.stroke = null;
+      this.retouch = stroke;
+      if (this.base.channels === 1) {
+        const view = rgbaViewOfGrey(this.mixerPixels());
+        this.mixer = stroke.create(view.target);
+        this.flushView = view.flush;
+      } else this.mixer = stroke.create(this.mixerPixels());
     } else {
       this.stroke = null;
       this.mixer = stroke.create(this.mixerPixels());
@@ -3163,10 +3247,20 @@ var PaintStrokeSession = class {
   stroke;
   mixer;
   mixerInit = null;
+  retouch = null;
+  /** Writes a mask's RGBA view back (sequential retouching on a mask). */
+  flushView = null;
+  started = false;
   /** Mixer tiles written since the last update: they get new tile objects so the compositor sees them change. */
   fresh = /* @__PURE__ */ new Set();
   last = null;
   closed = false;
+  /** The new tile of a coverage stroke over the pre-stroke tile `src`. */
+  compositeTile(src, tx, ty, options = {}, paint) {
+    const r = this.retouch;
+    if (r && r.kind === "coverage") return applyRetouchToTile(this.stroke.coverage, src, this.base.channels, tx, ty, paint ?? r.paint(), r.apply, options);
+    return applyStrokeToTile(this.stroke.coverage, src, this.base.channels, tx, ty, this.apply, options);
+  }
   /** The live pixels a mixer stroke reads and writes; base tiles are copied on first write. */
   mixerPixels() {
     const a = this.apply;
@@ -3193,8 +3287,14 @@ var PaintStrokeSession = class {
   /** Adds input points (document pixels); the stack shows the stroke so far. */
   push(points) {
     if (this.closed || !points.length) return;
+    if (!this.started) {
+      this.started = true;
+      if (this.retouch?.kind === "coverage") this.retouch.start(points[0]);
+    }
     this.last = points[points.length - 1];
-    this.update(this.mixer ? this.mixer.push(points) : this.stroke.push(points));
+    const rects = this.mixer ? this.mixer.push(points) : this.stroke.push(points);
+    this.flushView?.();
+    this.update(rects);
   }
   update(rects) {
     if (!rects.length) return;
@@ -3218,7 +3318,7 @@ var PaintStrokeSession = class {
       const src = this.base.tiles.get(key)?.data ?? defaultTile(this.base);
       const prev = this.touched.has(key) ? this.live.get(key)?.data : void 0;
       this.touched.add(key);
-      const data = applyStrokeToTile(stroke.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
+      const data = this.compositeTile(src, tx, ty, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
     }
     this.controller._strokeUpdate(this.target.id, this.target.channel, new TiledSurface(ch, new Map(this.live), this.base.defaultValue), rects);
@@ -3227,9 +3327,22 @@ var PaintStrokeSession = class {
   end() {
     if (this.closed) throw new LayerOperationError("This stroke has already ended.");
     const last = this.last ?? void 0;
-    this.update(this.mixer ? this.mixer.finish(last) : this.stroke.finish(last));
+    const rects = this.mixer ? this.mixer.finish(last) : this.stroke.finish(last);
+    this.flushView?.();
+    this.update(rects);
     this.closed = true;
     const ch = this.base.channels;
+    const r = this.retouch;
+    if (r?.kind === "coverage" && r.finalPaint) {
+      const final = r.finalPaint(this.stroke.coverage);
+      if (final) {
+        for (const key of this.touched) {
+          const { tx, ty } = tileCoord(key);
+          const src = this.base.tiles.get(key)?.data ?? defaultTile(this.base);
+          this.live.set(key, { data: this.compositeTile(src, tx, ty, {}, final), uniform: null });
+        }
+      }
+    }
     const tiles = new Map(this.base.tiles);
     let changed = false;
     for (const key of this.touched) {
@@ -3241,11 +3354,12 @@ var PaintStrokeSession = class {
       if (!sameTile(prev, tile)) changed = true;
     }
     const surface = changed ? new TiledSurface(ch, tiles, this.base.defaultValue) : null;
-    const mixerLoad = this.mixer ? this.mixerInit.end(this.mixer.load) : void 0;
+    const mixerLoad = this.mixerInit ? this.mixerInit.end(this.mixer.load) : void 0;
     this.controller._strokeCommit(this.before, this.target.id, this.target.channel, surface);
     const b = this.mixer ? this.mixer.bounds : this.stroke.coverage.bounds;
     const result = { layerId: this.target.id, channel: this.target.channel, bounds: changed ? b : null, dabs: (this.mixer ?? this.stroke).dabCount };
     if (mixerLoad) result.mixerLoad = mixerLoad;
+    if (r?.result) Object.assign(result, r.result());
     return result;
   }
   /** Abandons the stroke and restores the layer. */
@@ -3384,7 +3498,7 @@ var ImageEditorController = class {
       activeLayerId: null,
       activeTarget: "pixels",
       outputOpacity: 1,
-      paint: { brush: { ...DEFAULT_BRUSH }, foreground: "#000000", background: "#ffffff", mixer: { ...DEFAULT_MIXER }, mixerLoad: EMPTY_MIXER_LOAD },
+      paint: { brush: { ...DEFAULT_BRUSH }, foreground: "#000000", background: "#ffffff", mixer: { ...DEFAULT_MIXER }, mixerLoad: EMPTY_MIXER_LOAD, retouch: { ...DEFAULT_RETOUCH }, cloneSource: null },
       fit: options.fit ?? "margin"
     };
     if (options.image instanceof Object && "width" in options.image) {
@@ -4979,12 +5093,16 @@ var ImageEditorController = class {
   /** Brush settings, colours and tool options of the paint tools (view state, no undo). */
   setPaintOptions(options) {
     const cur = this.state.paint;
+    const retouch = options.retouch ? normalizeRetouch(options.retouch, cur.retouch) : cur.retouch;
+    const cloneSource = cur.cloneSource && retouch.aligned !== cur.retouch.aligned ? { ...cur.cloneSource, offset: null } : cur.cloneSource;
     const next = {
       brush: options.brush ? normalizeBrush({ ...cur.brush, ...options.brush }) : cur.brush,
       foreground: options.foreground !== void 0 ? toHex(parseColor(options.foreground)) : cur.foreground,
       background: options.background !== void 0 ? toHex(parseColor(options.background)) : cur.background,
       mixer: options.mixer ? normalizeMixer({ ...cur.mixer, ...options.mixer }) : cur.mixer,
-      mixerLoad: cur.mixerLoad
+      mixerLoad: cur.mixerLoad,
+      retouch,
+      cloneSource
     };
     this.state.paint = next;
     this.notify();
@@ -5014,6 +5132,17 @@ var ImageEditorController = class {
     this.notify();
     return EMPTY_MIXER_LOAD;
   }
+  /**
+   * Sets (Alt-click) or clears the Clone Stamp and Healing Brush source point, in document
+   * pixels. The next stroke fixes the offset from its first point. View state, no undo.
+   */
+  setCloneSource(point) {
+    if (point && (!Number.isFinite(point.x) || !Number.isFinite(point.y))) throw new LayerOperationError("The clone source needs finite x and y (document pixels).");
+    const source = point ? { x: Math.round(point.x), y: Math.round(point.y), offset: null } : null;
+    this.state.paint = { ...this.state.paint, cloneSource: source };
+    this.notify();
+    return source;
+  }
   /** D: black foreground, white background. */
   resetPaintColors() {
     this.setPaintOptions({ foreground: "#000000", background: "#ffffff" });
@@ -5068,8 +5197,8 @@ var ImageEditorController = class {
    */
   beginStroke(init = {}) {
     const tool = init.tool ?? "brush";
-    if (tool !== "brush" && tool !== "eraser" && tool !== "mixer") throw new LayerOperationError(`Unknown paint tool "${String(tool)}"; use brush, eraser or mixer.`);
-    const target = this.paintTarget(init.layerId, init.channel, tool === "eraser" ? "erase" : "paint");
+    if (!STROKE_TOOLS.includes(tool)) throw new LayerOperationError(`Unknown paint tool "${String(tool)}"; use one of ${STROKE_TOOLS.join(", ")}.`);
+    const target = this.paintTarget(init.layerId, init.channel, tool === "eraser" ? "erase" : isRetouchTool(tool) ? "retouch" : "paint");
     if (tool === "mixer" && target.channel !== "pixels") {
       throw new LayerOperationError("The Mixer Brush paints colour on pixels, not on masks; target pixels (channel pixels), or paint the mask with the brush.");
     }
@@ -5091,8 +5220,101 @@ var ImageEditorController = class {
       offset: target.offset
     };
     if (tool === "mixer") return new PaintStrokeSession(this, target, this.mixerStroke(init, brush), apply);
+    if (isRetouchTool(tool)) return new PaintStrokeSession(this, target, this.retouchStroke(tool, init, brush, target, apply), apply);
     return new PaintStrokeSession(this, target, new StrokeCoverage(brush), apply);
   }
+  /** A retouching stroke's start: its settings, what it samples and how it composites. */
+  retouchStroke(tool, init, brush, target, apply) {
+    const settings = normalizeRetouch(init.retouch ?? {}, this.state.paint.retouch);
+    const mask = target.channel !== "pixels";
+    if (tool === "sponge" && mask) throw new LayerOperationError("The Sponge changes saturation, and a mask has none; target pixels (channel pixels), or use dodge or burn on the mask.");
+    if (tool === "smudge") return { kind: "dabs", create: (pixels) => new RetouchDabStroke(brush, pixels, smudgeEffect(brush, settings.strength)) };
+    if (tool === "sponge") return { kind: "dabs", create: (pixels) => new RetouchDabStroke(brush, pixels, spongeEffect(brush, settings.spongeMode === "saturate", settings.vibrance)) };
+    const retouchApply = {
+      opacity: tool === "clone" || tool === "heal" ? brush.opacity : 1,
+      blend: tool === "clone" && !mask ? brush.blend : "normal",
+      lockTransparency: target.lockTransparency,
+      selection: apply.selection,
+      offset: target.offset
+    };
+    const coverage = new StrokeCoverage(brush);
+    if (tool === "dodge" || tool === "burn") {
+      const paint2 = { kind: "tone", tone: toneOf(tool, settings) };
+      return { kind: "coverage", coverage, apply: retouchApply, start: () => {
+      }, paint: () => paint2 };
+    }
+    const sample = mask ? "current" : settings.sample;
+    const own = this.surfaceSource(target.surface, target.offset);
+    const source = sample === "current" ? own : this.compositeSource(sample === "all" ? null : target.id);
+    const pad = (r, m) => ({ x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m });
+    const covered = (cov, r) => {
+      const m = new Uint8Array(r.width * r.height);
+      for (let y = 0; y < r.height; y++) for (let x = 0; x < r.width; x++) m[y * r.width + x] = cov.get(r.x + x, r.y + y) > 0 ? 1 : 0;
+      return m;
+    };
+    if (tool === "spot-heal") {
+      const { width, height } = this.naturalSize;
+      let patch = null;
+      const trail = { kind: "color", color: [0, 0, 0, 96] };
+      return {
+        kind: "coverage",
+        coverage,
+        apply: retouchApply,
+        start: () => {
+        },
+        paint: () => trail,
+        finalPaint: (cov) => {
+          if (!cov.bounds) return null;
+          const win = spotHealWindow(cov.bounds, { width, height });
+          if (win.width <= 0 || win.height <= 0) return null;
+          const img = readSourceRegion(source, win);
+          const hole = covered(cov, win);
+          const healed = spotHealPixels(win.width, win.height, img, hole, brush.size, settings.spotType, (off) => {
+            patch = off ? { x: off[0], y: off[1] } : null;
+          });
+          return { kind: "source", source: new RegionPixelSource(win, healed), dx: 0, dy: 0 };
+        },
+        result: () => ({ spotHeal: { offset: patch } })
+      };
+    }
+    if (init.source) this.setCloneSource(init.source);
+    const cs = this.state.paint.cloneSource;
+    if (!cs) throw new LayerOperationError(`The ${tool === "clone" ? "Clone Stamp" : "Healing Brush"} needs a source point; Alt-click the canvas, call set_clone_source, or pass source { x, y }.`);
+    let offset = { x: 0, y: 0 };
+    let first = { x: 0, y: 0 };
+    const paint = () => ({ kind: "source", source, dx: offset.x, dy: offset.y });
+    return {
+      kind: "coverage",
+      coverage,
+      apply: retouchApply,
+      start: (p) => {
+        first = { x: Math.round(p.x), y: Math.round(p.y) };
+        offset = settings.aligned && cs.offset ? { ...cs.offset } : { x: cs.x - first.x, y: cs.y - first.y };
+        if (settings.aligned) this.state.paint = { ...this.state.paint, cloneSource: { x: cs.x, y: cs.y, offset: { ...offset } } };
+      },
+      paint,
+      finalPaint: tool === "heal" ? (cov) => {
+        if (!cov.bounds) return null;
+        const g = pad(cov.bounds, 2);
+        const src = readSourceRegion(source, g, offset.x, offset.y);
+        const dst = readSourceRegion(source, g);
+        return { kind: "source", source: new RegionPixelSource(g, healPixels(g.width, g.height, src, dst, covered(cov, g))), dx: 0, dy: 0 };
+      } : void 0,
+      result: () => ({ clone: { offset: { ...offset }, source: { x: first.x + offset.x, y: first.y + offset.y }, aligned: settings.aligned } })
+    };
+  }
+  /** A pixel source over a surface (layer pixels or a mask) in layer space at `offset`. */
+  surfaceSource(surface, offset) {
+    return new TilePixelSource((tx, ty) => surface.tiles.get(tileKey(tx, ty))?.data ?? (surface.defaultValue ? defaultTile(surface) : null), surface.channels, offset);
+  }
+  /** A pixel source over the composite of the current layers (through `throughId` and below, or all of them), as it is now. */
+  compositeSource(throughId) {
+    const stack = withoutAnnotations(this.state.layers);
+    const layers = throughId ? layersThrough(stack, throughId) : stack;
+    const compositor = new LayerCompositor();
+    const sources = this.compositorSources();
+    return new TilePixelSource((tx, ty) => compositor.tile(layers, tx, ty, sources), 4);
+  }
   /** A Mixer Brush stroke's start: the settings, and the load (refilled when asked or set to). */
   mixerStroke(init, brush) {
     const settings = normalizeMixer({ ...this.state.paint.mixer, ...init.mixer ?? {} });
@@ -6475,7 +6697,7 @@ var ImageEditorController = class {
     s.sourceUrl = null;
     s.imageDimensions = { width: result.width, height: result.height };
     if (!this.samplePixelsOverride) this.samplePixels = null;
-    s.layers = result.layers;
+    s.layers = this.checkPsdFonts(result);
     s.crop = null;
     s.transform = { ...DEFAULT_TRANSFORM_VALUES };
     s.outputOpacity = 1;
@@ -6500,6 +6722,30 @@ var ImageEditorController = class {
       summary: result.summary
     };
   }
+  /**
+   * Type layers whose fonts the shaper lacks: they keep Photoshop's pixels, are marked with their
+   * `missingFonts`, and a warning names them (an edit draws them with a fallback).
+   */
+  checkPsdFonts(result) {
+    const shaper = this.getTextShaper();
+    const types = flattenLayers(result.layers).filter((l) => l.type === "type");
+    if (!types.length) return result.layers;
+    let layers = result.layers;
+    const missing = /* @__PURE__ */ new Map();
+    for (const l of types) {
+      const fonts = shaper ? layoutText(l, shaper).missingFonts : [...new Set(l.runs.map((r) => r.style.fontFamily))];
+      if (!fonts.length) continue;
+      layers = mapLayer(layers, l.id, () => ({ ...l, missingFonts: fonts }));
+      for (const f of fonts) missing.set(f, [...missing.get(f) ?? [], l.name]);
+    }
+    for (const [font, names] of missing) {
+      result.warnings.push(
+        shaper ? `The font "${font}" is missing here: the type shows Photoshop's pixels until it is edited, then a fallback font (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).` : `Type layers show Photoshop's pixels; nothing here can draw text, so they cannot be edited (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).`
+      );
+      if (!shaper) break;
+    }
+    return layers;
+  }
   /**
    * The document as an 8-bit RGB PSD (PSB above 30 000 px) with real layers, groups, adjustment
    * layers and masks, in the source frame. Layer filters and parametric (depth) masks are baked
@@ -6578,8 +6824,8 @@ var ImageEditorController = class {
         return out2;
       }
       if (layer.type === "shape" || layer.type === "type") {
-        add2(layer.type === "shape" ? "Shape layers were written as pixel layers" : "Type layers were written as pixel layers", layer.name);
-        const out2 = layer.type === "shape" ? shapeAsPixelLayer(layer) : typeAsPixelLayer(layer);
+        if (layer.type === "type" && layer.missingFonts?.length) add2(`Type layers drawn with a fallback for missing fonts (${layer.missingFonts.join(", ")}) keep the font names, so Photoshop may draw them differently`, layer.name);
+        const out2 = { ...layer };
         const mask2 = bakeMask(layer);
         if (mask2) out2.mask = mask2;
         else delete out2.mask;
@@ -6970,6 +7216,27 @@ function collectStateTiles(layers, into) {
     }
   }
 }
+function layersThrough(layers, id) {
+  const walk = (list) => {
+    const out = [];
+    for (const l of list) {
+      if (l.id === id) {
+        out.push(l);
+        return { out, found: true };
+      }
+      if (l.type === "group") {
+        const sub2 = walk(l.children);
+        if (sub2.found) {
+          out.push({ ...l, children: sub2.out });
+          return { out, found: true };
+        }
+      }
+      out.push(l);
+    }
+    return { out, found: false };
+  };
+  return walk(layers).out;
+}
 function pixelsOnly(layers) {
   const out = [];
   for (const l of layers) {
@@ -8992,7 +9259,7 @@ function createImageEffectTools(controller) {
   const add2 = {
     name: "add_layer_effect",
     title: "Add a layer effect",
-    description: "Adds a live effect to a pixel, annotation or group layer with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). One undo step. Returns the new effect's id and the layer's effects.",
+    description: "Adds a live effect to a pixel, shape, type, smart object, annotation or group layer with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). One undo step. Returns the new effect's id and the layer's effects.",
     inputSchema: {
       type: "object",
       $defs: DEFS,
@@ -9112,9 +9379,73 @@ var PAINT_TOOLS = [
   { id: "move", label: "Move", shortcut: "V" },
   { id: "brush", label: "Brush", shortcut: "B" },
   { id: "mixer", label: "Mixer", shortcut: "Shift+B" },
-  { id: "eraser", label: "Eraser", shortcut: "E" }
+  { id: "eraser", label: "Eraser", shortcut: "E" },
+  { id: "clone", label: "Clone", shortcut: "S" },
+  { id: "heal", label: "Heal", shortcut: "Shift+J" },
+  { id: "spot-heal", label: "Spot Heal", shortcut: "J" },
+  { id: "smudge", label: "Smudge", shortcut: "" },
+  { id: "dodge", label: "Dodge", shortcut: "O" },
+  { id: "burn", label: "Burn", shortcut: "Shift+O" },
+  { id: "sponge", label: "Sponge", shortcut: "Shift+O" }
+];
+var isPaintTool = (tool) => PAINT_TOOLS.some((t) => t.id === tool);
+var isRetouchPaintTool = (tool) => tool === "clone" || tool === "heal" || tool === "spot-heal" || tool === "smudge" || tool === "dodge" || tool === "burn" || tool === "sponge";
+var RETOUCH_OPTION_CONTROLS = [
+  { id: "exposure", label: "Exposure", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%", tools: ["dodge", "burn"] },
+  { id: "strength", label: "Strength", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%", tools: ["smudge"] }
 ];
-var isPaintTool = (tool) => tool === "move" || tool === "brush" || tool === "mixer" || tool === "eraser";
+var RETOUCH_CHOICES = [
+  {
+    id: "sample",
+    label: "Sample",
+    tools: ["clone", "heal", "spot-heal"],
+    options: [
+      { id: "current", label: "Current", title: "Sample the layer being retouched" },
+      { id: "current-below", label: "Current & Below", title: "Sample this layer and the layers under it" },
+      { id: "all", label: "All", title: "Sample every layer (retouch onto an empty layer)" }
+    ]
+  },
+  {
+    id: "spotType",
+    label: "Type",
+    tools: ["spot-heal"],
+    options: [
+      { id: "proximity-match", label: "Proximity Match", title: "Copy the best matching patch nearby" },
+      { id: "smooth", label: "Smooth", title: "Fill smoothly from the edges" }
+    ]
+  },
+  {
+    id: "range",
+    label: "Range",
+    tools: ["dodge", "burn"],
+    options: [
+      { id: "shadows", label: "Shadows", title: "Change the dark tones most" },
+      { id: "midtones", label: "Midtones", title: "Change the middle tones most" },
+      { id: "highlights", label: "Highlights", title: "Change the light tones most" }
+    ]
+  },
+  {
+    id: "spongeMode",
+    label: "Mode",
+    tools: ["sponge"],
+    options: [
+      { id: "desaturate", label: "Desaturate", title: "Take colour out" },
+      { id: "saturate", label: "Saturate", title: "Add colour" }
+    ]
+  }
+];
+var RETOUCH_TOGGLES = [
+  { id: "aligned", label: "Aligned", tools: ["clone", "heal"] },
+  { id: "protectTones", label: "Protect tones", tools: ["dodge", "burn"] },
+  { id: "vibrance", label: "Vibrance", tools: ["sponge"] }
+];
+function setRetouchChoice(controller, id, value) {
+  controller.setPaintOptions({ retouch: { [id]: value } });
+}
+function cloneSourceLabel(controller) {
+  const cs = controller.getState().paint.cloneSource;
+  return cs ? `Source ${cs.x}, ${cs.y}${cs.offset ? ` (offset ${cs.offset.x}, ${cs.offset.y})` : ""}` : "Alt-click to set the source";
+}
 function rgbUnitToHex(c) {
   return `#${c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("")}`;
 }
@@ -9140,6 +9471,18 @@ function handlePaintShortcut(controller, e) {
     case "v":
       controller.setTool("move");
       return true;
+    case "s":
+      controller.setTool("clone");
+      return true;
+    case "j":
+      controller.setTool(e.shiftKey || key === "J" ? controller.getState().activeTool === "heal" ? "spot-heal" : "heal" : "spot-heal");
+      return true;
+    case "o": {
+      const cur = controller.getState().activeTool;
+      const next = e.shiftKey || key === "O" ? cur === "dodge" ? "burn" : cur === "burn" ? "sponge" : "dodge" : "dodge";
+      controller.setTool(next);
+      return true;
+    }
     case "d":
       controller.resetPaintColors();
       return true;
@@ -9195,9 +9538,13 @@ var PaintGesture = class {
         this.move = { id: layer.id, start: { x: sample.x, y: sample.y }, origin, moved: false };
         return null;
       }
-      if (tool === "brush" || tool === "eraser" || tool === "mixer") {
+      if ((tool === "clone" || tool === "heal") && sample.altKey) {
+        this.controller.setCloneSource({ x: sample.x, y: sample.y });
+        return null;
+      }
+      if (isPaintTool(tool)) {
         this.stroke = this.controller.beginStroke({ tool });
-        this.stroke.push([sample]);
+        this.stroke.push([{ x: sample.x, y: sample.y, pressure: sample.pressure }]);
         return null;
       }
     } catch (err) {
@@ -9428,8 +9775,272 @@ function createImagePaintTools(controller) {
   return [paintStroke, fill, clear, getMixer, loadMixerTool, cleanMixerTool];
 }
 
-// src/image-editor/psd-tools.ts
+// src/image-editor/retouch-tools.ts
 var READ5 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var POINTS = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1e4,
+  description: "The stroke path in document pixels; one point is one dab.",
+  items: {
+    type: "object",
+    properties: {
+      x: { type: "number", description: "Document x in px." },
+      y: { type: "number", description: "Document y in px." },
+      pressure: { type: "number", minimum: 0, maximum: 1, description: "Pen pressure (default 1)." }
+    },
+    required: ["x", "y"],
+    additionalProperties: false
+  }
+};
+var BRUSH2 = {
+  type: "object",
+  description: "Brush tip; missing fields use the current paint options (default round, hard, 20 px).",
+  properties: {
+    size: { type: "number", minimum: 1, maximum: MAX_BRUSH_SIZE, description: "Diameter in px (default 20)." },
+    hardness: { type: "number", minimum: 0, maximum: 1, description: "Edge hardness 0 (soft) .. 1 (hard, default). Retouching usually wants a soft tip (0..0.5)." },
+    spacing: { type: "number", minimum: 0.01, maximum: 10, description: "Dab spacing as a fraction of the diameter (default 0.1)." },
+    opacity: { type: "number", minimum: 0, maximum: 1, description: "Stroke opacity (Clone Stamp and Healing Brush only; default 1)." },
+    flow: { type: "number", minimum: 0, maximum: 1, description: "Build-up per dab (default 1). For the Sponge, how strongly each pass moves saturation." },
+    smoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Point smoothing 0..0.95 (default 0)." },
+    pressureSize: { type: "boolean", description: "Point pressure scales the size (default true)." },
+    pressureOpacity: { type: "boolean", description: "Point pressure scales the opacity (default false)." }
+  },
+  additionalProperties: false
+};
+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."
+  }
+};
+var SAMPLE = {
+  type: "string",
+  enum: [...RETOUCH_SAMPLES],
+  description: "What is sampled: current (default: the target layer), current-below (the composite of this layer and everything under it), or all (the composite of every layer). Sample current-below or all to retouch onto an empty layer above the image."
+};
+function readTarget2(args) {
+  return { layerId: args.layerId, channel: args.channel };
+}
+function checkSource(controller, source) {
+  if (source === void 0) return void 0;
+  const p = source;
+  const { width, height } = controller.getState().imageDimensions;
+  if (!(p.x >= 0 && p.y >= 0 && p.x < width && p.y < height)) {
+    throw new LayerOperationError(`source (${p.x}, ${p.y}) is outside the ${width} \xD7 ${height} canvas; pick a point on the image to sample.`);
+  }
+  return p;
+}
+var SOURCE = {
+  type: "object",
+  description: "Source point in document pixels (an Alt-click). Given, it replaces the clone source and the offset starts afresh at this stroke; missing, the current clone source is used (set_clone_source).",
+  properties: { x: { type: "number", description: "Source x in px." }, y: { type: "number", description: "Source y in px." } },
+  required: ["x", "y"],
+  additionalProperties: false
+};
+function createImageRetouchTools(controller) {
+  const stroke = (tool, args, retouch) => controller.paintStroke({
+    tool,
+    points: args.points,
+    brush: args.brush,
+    retouch,
+    source: checkSource(controller, args.source),
+    ...readTarget2(args)
+  });
+  const cloneStamp = {
+    name: "clone_stamp",
+    title: "Clone Stamp stroke",
+    description: "Copies pixels from the clone source along a stroke (Photoshop's Clone Stamp): each point paints what lies at point + offset, where the offset is source \u2212 the stroke's first point. With aligned on, later strokes keep that offset; off, every stroke starts again at the source point. Samples the layer, the layers up to it, or all layers, from before the stroke. The selection limits it; a transparency-locked layer keeps its alpha. One undo step. Returns the layerId, channel, changed bounds, dab count and clone {offset, source, aligned}.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: POINTS,
+        source: SOURCE,
+        aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
+        sample: SAMPLE,
+        brush: BRUSH2,
+        ...TARGET2
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: { title: "Clone Stamp stroke", ...WRITE5 },
+    handler: (args) => stroke("clone", args, pick(args, ["aligned", "sample"]))
+  };
+  const healBrush = {
+    name: "heal_brush",
+    title: "Healing Brush stroke",
+    description: "Heals along a stroke from the clone source (Photoshop's Healing Brush): the source's texture is cloned, then blended so its colour and light match the pixels around the stroke (Poisson seamless cloning, applied when the stroke ends). Use it for blemishes and dust where the area around them is the right tone; use clone_stamp to copy exactly. Same source, offset and aligned rules as clone_stamp. One undo step. Returns the layerId, channel, changed bounds, dab count and clone {offset, source, aligned}.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: POINTS,
+        source: SOURCE,
+        aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
+        sample: SAMPLE,
+        brush: BRUSH2,
+        ...TARGET2
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: { title: "Healing Brush stroke", ...WRITE5 },
+    handler: (args) => stroke("heal", args, pick(args, ["aligned", "sample"]))
+  };
+  const spotHeal = {
+    name: "spot_heal",
+    title: "Spot Healing stroke",
+    description: "Removes what a stroke covers without a source point (Photoshop's Spot Healing Brush): proximity-match copies the best matching patch nearby and blends it in; smooth fills from the edges inwards (for spots on smooth areas). Paint just over the spot with a brush a little larger than it. One undo step. Returns the layerId, channel, changed bounds, dab count and spotHeal {offset} (the patch offset copied, or null for a smooth fill).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: POINTS,
+        type: { type: "string", enum: [...SPOT_HEAL_TYPES], description: "proximity-match (default) or smooth." },
+        sample: SAMPLE,
+        brush: BRUSH2,
+        ...TARGET2
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: { title: "Spot Healing stroke", ...WRITE5 },
+    handler: (args) => stroke("spot-heal", args, { ...pick(args, ["sample"]), ...args.type !== void 0 ? { spotType: args.type } : {} })
+  };
+  const smudge = {
+    name: "smudge",
+    title: "Smudge stroke",
+    description: "Drags pixels along a stroke like a finger through wet paint (Photoshop's Smudge): each dab lays what the finger carries and picks up what was under it, so colour is pulled in the stroke's direction and fades with distance. One undo step. Returns the layerId, channel, changed bounds and dab count.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: POINTS,
+        strength: { type: "number", minimum: 0, maximum: 1, description: "How far colour is dragged, 0..1 (default the current option, 0.5)." },
+        brush: BRUSH2,
+        ...TARGET2
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: { title: "Smudge stroke", ...WRITE5 },
+    handler: (args) => stroke("smudge", args, pick(args, ["strength"]))
+  };
+  const toneSchema = (verb) => ({
+    type: "object",
+    properties: {
+      points: POINTS,
+      range: { type: "string", enum: [...TONE_RANGES], description: `Which tones to ${verb} most: shadows, midtones (default the current option, midtones) or highlights.` },
+      exposure: { type: "number", minimum: 0, maximum: 1, description: "Strength 0..1 (default the current option, 0.5). Overlapping dabs in one stroke never go past it; another stroke builds on it." },
+      protectTones: { type: "boolean", description: "Change luma only, keeping hue and saturation (default true)." },
+      brush: BRUSH2,
+      ...TARGET2
+    },
+    required: ["points"],
+    additionalProperties: false
+  });
+  const dodge = {
+    name: "dodge",
+    title: "Dodge stroke",
+    description: "Lightens the pixels a stroke covers (Photoshop's Dodge), most in the chosen tonal range. Alpha is kept. One undo step. Returns the layerId, channel, changed bounds and dab count. Inspect the result with capture_view or get_histogram; several light strokes look more natural than one strong one.",
+    inputSchema: toneSchema("lighten"),
+    annotations: { title: "Dodge stroke", ...WRITE5 },
+    handler: (args) => stroke("dodge", args, pick(args, ["range", "exposure", "protectTones"]))
+  };
+  const burn = {
+    name: "burn",
+    title: "Burn stroke",
+    description: "Darkens the pixels a stroke covers (Photoshop's Burn), most in the chosen tonal range. Alpha is kept. One undo step. Returns the layerId, channel, changed bounds and dab count.",
+    inputSchema: toneSchema("darken"),
+    annotations: { title: "Burn stroke", ...WRITE5 },
+    handler: (args) => stroke("burn", args, pick(args, ["range", "exposure", "protectTones"]))
+  };
+  const spongeTool = {
+    name: "sponge",
+    title: "Sponge stroke",
+    description: "Saturates or desaturates the pixels a stroke covers (Photoshop's Sponge); passes compound, and brush.flow sets how much each moves. Pixels only (a mask has no colour). One undo step. Returns the layerId, channel, changed bounds and dab count.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: POINTS,
+        mode: { type: "string", enum: ["desaturate", "saturate"], description: "desaturate (default the current option, desaturate) or saturate." },
+        vibrance: { type: "boolean", description: "Damp the change where colours would clip or collapse to grey (default true)." },
+        brush: BRUSH2,
+        layerId: TARGET2.layerId
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: { title: "Sponge stroke", ...WRITE5 },
+    handler: (args) => stroke("sponge", { ...args, channel: "pixels" }, { ...pick(args, ["vibrance"]), ...args.mode !== void 0 ? { spongeMode: args.mode } : {} })
+  };
+  const getOptions = {
+    name: "get_retouch_options",
+    title: "Get retouch options",
+    description: "Reads the retouching tools' options (aligned, sample, spotType, range, exposure, protectTones, spongeMode, vibrance, strength) and the clone source ({x, y, offset} or null; offset is the aligned offset the last clone or heal stroke fixed). Call it before clone_stamp or heal_brush without a source to see where they will sample.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Get retouch options", ...READ5 },
+    handler: () => {
+      const { retouch, cloneSource } = controller.getState().paint;
+      return { options: { ...retouch }, cloneSource: cloneSource ? { ...cloneSource } : null };
+    }
+  };
+  const setOptions = {
+    name: "set_retouch_options",
+    title: "Set retouch options",
+    description: "Sets the retouching tools' defaults (view state, not an undo step); each stroke tool can also override them per call. Changing aligned clears the aligned offset. Returns the options after the change.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        aligned: { type: "boolean", description: "Clone / heal: keep the offset from stroke to stroke (default true)." },
+        sample: SAMPLE,
+        spotType: { type: "string", enum: [...SPOT_HEAL_TYPES], description: "Spot heal: proximity-match (default) or smooth." },
+        range: { type: "string", enum: [...TONE_RANGES], description: "Dodge / burn: shadows, midtones (default) or highlights." },
+        exposure: { type: "number", minimum: 0, maximum: 1, description: "Dodge / burn strength 0..1 (default 0.5)." },
+        protectTones: { type: "boolean", description: "Dodge / burn: keep hue and saturation (default true)." },
+        spongeMode: { type: "string", enum: ["desaturate", "saturate"], description: "Sponge: desaturate (default) or saturate." },
+        vibrance: { type: "boolean", description: "Sponge: damp clipping (default true)." },
+        strength: { type: "number", minimum: 0, maximum: 1, description: "Smudge strength 0..1 (default 0.5)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Set retouch options", ...WRITE5, idempotentHint: true },
+    handler: (args) => ({ ...controller.setPaintOptions({ retouch: args }).retouch })
+  };
+  const setSource = {
+    name: "set_clone_source",
+    title: "Set the clone source",
+    description: "Sets the Clone Stamp and Healing Brush source point (Photoshop's Alt-click), in document pixels, or clears it with clear true. The next clone_stamp or heal_brush stroke fixes the offset from its first point. View state, not an undo step. Returns the clone source {x, y, offset} (or null).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        x: { type: "number", description: "Source x in px (required unless clear)." },
+        y: { type: "number", description: "Source y in px (required unless clear)." },
+        clear: { type: "boolean", description: "Remove the source point instead (default false)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Set the clone source", ...WRITE5, idempotentHint: true },
+    handler: (args) => {
+      if (args.clear === true) {
+        if (args.x !== void 0 || args.y !== void 0) throw new LayerOperationError("Give either clear true or x and y, not both.");
+        return controller.setCloneSource(null);
+      }
+      if (typeof args.x !== "number" || typeof args.y !== "number") throw new LayerOperationError("Pass x and y (document pixels) for the source point, or clear true to remove it.");
+      return controller.setCloneSource(checkSource(controller, { x: args.x, y: args.y }));
+    }
+  };
+  return [cloneStamp, healBrush, spotHeal, smudge, dodge, burn, spongeTool, getOptions, setOptions, setSource];
+}
+function pick(args, keys) {
+  const out = {};
+  for (const k of keys) if (args[k] !== void 0) out[k] = args[k];
+  return out;
+}
+
+// src/image-editor/psd-tools.ts
+var READ6 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var DATA = {
   type: "string",
@@ -9450,7 +10061,7 @@ function createImagePsdTools(controller) {
     title: "Inspect a PSD",
     description: "Reads a PSD / PSB without opening it: size, bit depth, colour mode, resolution, and every layer (bottom first, a group before its children) with its PSD kind, the layer type it would become and its status (mapped, approximated or dropped, with notes), plus the import warnings. Changes nothing. Call before import_psd to see what would be lost.",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
-    annotations: { title: "Inspect a PSD", ...READ5 },
+    annotations: { title: "Inspect a PSD", ...READ6 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -9466,7 +10077,7 @@ function createImagePsdTools(controller) {
   const open = {
     name: "import_psd",
     title: "Open a PSD as the document",
-    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility, locks, layer effects (with the patterns and global light of the file) map directly; smart objects come in as smart objects (embedded contents, placement and warp, smart filters: Box Blur is drawn, other Photoshop filters are kept but not drawn, filter mask; linked contents as their stored pixels); type, fill and shape layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
+    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility, locks, layer effects (with the patterns and global light of the file) map directly; smart objects come in as smart objects (embedded contents, placement and warp, smart filters: Box Blur is drawn, other Photoshop filters are kept but not drawn, filter mask; linked contents as their stored pixels); shape layers come in as live shapes (paths, path operations, fill, stroke, live rectangles, ellipses and lines); type layers come in as live text (runs, paragraphs, frame, transform) showing Photoshop\u2019s pixels until edited, with a warning for fonts missing here; fill layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
     annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE4 },
     handler: ({ data }) => {
@@ -9485,9 +10096,9 @@ function createImagePsdTools(controller) {
   const save = {
     name: "export_psd",
     title: "Export the document as a PSD",
-    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers, masks and layer effects (an effects block opened from a PSD is written back unchanged while its effects are; the patterns effects use are embedded), in the source frame (crop and rotation are not applied). Smart objects are written as Photoshop smart objects (contents embedded once per linked set, placement, warp, smart filters and filter mask; a Develop smart filter has no Photoshop filter and is left out of the list). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
+    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers, masks and layer effects (an effects block opened from a PSD is written back unchanged while its effects are; the patterns effects use are embedded), in the source frame (crop and rotation are not applied). Smart objects are written as Photoshop smart objects (contents embedded once per linked set, placement, warp, smart filters and filter mask; a Develop smart filter has no Photoshop filter and is left out of the list). Shape layers are written as Photoshop shape layers (path, fill, stroke, live shapes) and type layers as Photoshop type layers (text, runs, paragraphs, frame; blocks opened from a PSD are written back unchanged while the layer is). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Export the document as a PSD", ...READ5 },
+    annotations: { title: "Export the document as a PSD", ...READ6 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -9505,8 +10116,8 @@ function createImagePsdTools(controller) {
 }
 
 // src/image-editor/transform-tools.ts
-var READ6 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var round4 = (n, digits = 3) => Math.round(n * 10 ** digits) / 10 ** digits;
 var roundPoint = (p) => ({ x: round4(p.x), y: round4(p.y) });
 var POINT = {
@@ -9515,7 +10126,7 @@ var POINT = {
   required: ["x", "y"],
   additionalProperties: false
 };
-var TARGET2 = {
+var TARGET3 = {
   layerId: { type: "string", description: "Layer to transform (from list_layers; default the active layer)." },
   content: {
     type: "string",
@@ -9597,15 +10208,15 @@ function createImageTransformTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: TARGET2.layerId,
-        content: { type: "string", enum: FREE_TRANSFORM_CONTENTS, description: `${TARGET2.content.description} selection-outline frames the selection outline alone.` },
-        channel: TARGET2.channel,
+        layerId: TARGET3.layerId,
+        content: { type: "string", enum: FREE_TRANSFORM_CONTENTS, description: `${TARGET3.content.description} selection-outline frames the selection outline alone.` },
+        channel: TARGET3.channel,
         meshColumns: { type: "integer", minimum: 1, maximum: 16, description: "Patch columns of an identity warp mesh to return (omit for none)." },
         meshRows: { type: "integer", minimum: 1, maximum: 16, description: "Patch rows of an identity warp mesh to return (default meshColumns)." }
       },
       additionalProperties: false
     },
-    annotations: { title: "Get the Free Transform frame", ...READ6 },
+    annotations: { title: "Get the Free Transform frame", ...READ7 },
     handler: (args) => {
       const init = targetFrom(args);
       if (init.content === "selection-copy") init.content = "selection";
@@ -9635,10 +10246,10 @@ function createImageTransformTools(controller) {
     description: "Edit \u203A Free Transform: scales, rotates, skews, moves, distorts or puts in perspective a pixel layer (with its linked mask), the selected pixels, a copy of them on a new layer, or an unlinked mask. Give the transform one way: the numeric fields (as Photoshop\u2019s options bar, about a reference point), a matrix, or the frame\u2019s new corners (distort / perspective; read the frame with get_transform_frame). Resamples once, tile by tile; one undo step. Returns layerId (the new layer for selection-copy), what moved, the frame, the corners and the new document bounds.",
     inputSchema: {
       type: "object",
-      properties: { ...TARGET2, ...GEOMETRY },
+      properties: { ...TARGET3, ...GEOMETRY },
       additionalProperties: false
     },
-    annotations: { title: "Free Transform a layer", ...WRITE5 },
+    annotations: { title: "Free Transform a layer", ...WRITE6 },
     handler: (args) => summary2(controller.transformLayer({ ...targetFrom(args), ...geometryFrom(args) }))
   };
   const warpLayer = {
@@ -9648,7 +10259,7 @@ function createImageTransformTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        ...TARGET2,
+        ...TARGET3,
         style: { type: "string", enum: WARP_STYLES, description: "Preset warp (Photoshop\u2019s menu): arc, arcLower, arcUpper, arch, bulge, shellLower, shellUpper, flag, wave, fish, rise, fisheye, inflate, squeeze, twist." },
         bend: { type: "number", minimum: -100, maximum: 100, description: "Preset bend in percent, \u2212100..100 (default 50)." },
         horizontal: { type: "number", minimum: -100, maximum: 100, description: "Preset horizontal distortion in percent, \u2212100..100 (default 0)." },
@@ -9668,7 +10279,7 @@ function createImageTransformTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Warp a layer", ...WRITE5 },
+    annotations: { title: "Warp a layer", ...WRITE6 },
     handler: (args) => {
       const hasPreset = ["style", "bend", "horizontal", "vertical", "orientation"].some((k) => args[k] !== void 0);
       if (hasPreset && args.mesh !== void 0) throw new LayerOperationError("Give a preset (style, bend, horizontal, vertical, orientation) or a mesh, not both.");
@@ -9699,10 +10310,10 @@ function createImageTransformTools(controller) {
     description: "Select \u203A Transform Selection: scales, rotates, skews, moves or distorts only the selection outline; no pixels change. Give the transform one way: the numeric fields (about a reference point of the selection\u2019s bounds), a matrix, or the new corners of its bounds. Needs a selection. One undo step. Returns the new selection bounds.",
     inputSchema: {
       type: "object",
-      properties: { interpolation: { ...TARGET2.interpolation, description: "Resampling of soft edges: nearest, bilinear or bicubic (default)." }, ...GEOMETRY },
+      properties: { interpolation: { ...TARGET3.interpolation, description: "Resampling of soft edges: nearest, bilinear or bicubic (default)." }, ...GEOMETRY },
       additionalProperties: false
     },
-    annotations: { title: "Transform the selection outline", ...WRITE5 },
+    annotations: { title: "Transform the selection outline", ...WRITE6 },
     handler: (args) => {
       const res = controller.transformLayer({ content: "selection-outline", interpolation: args.interpolation, ...geometryFrom(args) });
       return { changed: res.changed, frame: { ...res.box }, corners: res.corners.map(roundPoint), bounds: res.bounds };
@@ -9716,14 +10327,14 @@ function createImageTransformTools(controller) {
       type: "object",
       properties: {
         axis: { type: "string", enum: ["horizontal", "vertical"], description: "horizontal mirrors left \u2194 right, vertical top \u2194 bottom." },
-        layerId: TARGET2.layerId,
-        content: TARGET2.content,
-        channel: TARGET2.channel
+        layerId: TARGET3.layerId,
+        content: TARGET3.content,
+        channel: TARGET3.channel
       },
       required: ["axis"],
       additionalProperties: false
     },
-    annotations: { title: "Flip a layer", ...WRITE5 },
+    annotations: { title: "Flip a layer", ...WRITE6 },
     handler: (args) => summary2(controller.flipLayer(args.axis, targetFrom(args)))
   };
   const rotate90 = {
@@ -9734,22 +10345,22 @@ function createImageTransformTools(controller) {
       type: "object",
       properties: {
         turn: { type: "integer", enum: [90, -90, 180], description: "Degrees: 90 clockwise, -90 counter-clockwise, or 180." },
-        layerId: TARGET2.layerId,
-        content: TARGET2.content,
-        channel: TARGET2.channel
+        layerId: TARGET3.layerId,
+        content: TARGET3.content,
+        channel: TARGET3.channel
       },
       required: ["turn"],
       additionalProperties: false
     },
-    annotations: { title: "Rotate a layer by quarter turns", ...WRITE5 },
+    annotations: { title: "Rotate a layer by quarter turns", ...WRITE6 },
     handler: (args) => summary2(controller.rotateLayer90(args.turn, targetFrom(args)))
   };
   return [getFrame, transformLayer, warpLayer, transformSelection, flipLayer, rotate90];
 }
 
 // src/image-editor/smart-tools.ts
-var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE7 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var WRITE_IDEMPOTENT4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE5 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var round5 = (n, digits = 3) => Math.round(n * 10 ** digits) / 10 ** digits;
@@ -9807,7 +10418,7 @@ function createImageSmartObjectTools(controller) {
     title: "Read a smart object",
     description: "Returns a smart object\u2019s contents (id shared by linked instances, name, kind raster or document, pixel size, the file type it came from, the instances placed from it), its placement (corners in document pixels, warp mesh in contents pixels, interpolation, and scale / rotate / skew in percent and degrees of the contents\u2019 own size when affine), its smart filters bottom to top (ids, kind, settings, enabled, blend, opacity; kind psd marks a Photoshop filter kept but not drawn) with the filter mask, and the rendered bounds. Changes nothing.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a smart object", ...READ7 },
+    annotations: { title: "Read a smart object", ...READ8 },
     handler: ({ layerId }) => info(smartId(layerId))
   };
   const convert = {
@@ -9822,7 +10433,7 @@ function createImageSmartObjectTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Convert to Smart Object", ...WRITE6 },
+    annotations: { title: "Convert to Smart Object", ...WRITE7 },
     handler: ({ layerIds, name }) => {
       for (const id2 of layerIds ?? []) requireLayer(controller.getLayers(), id2);
       const id = controller.convertToSmartObject(layerIds, { name });
@@ -9941,7 +10552,7 @@ function createImageSmartObjectTools(controller) {
     title: "Export a smart object\u2019s contents",
     description: "Layer \u203A Smart Objects \u203A Export Contents: the contents as a file, base64: the file they came from while unedited (a PSB, PNG, JPEG\u2026), else a PNG for raster contents or a PSD / PSB of a nested document. Returns name, mimeType, byteLength and base64. Changes nothing.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Export a smart object\u2019s contents", ...READ7 },
+    annotations: { title: "Export a smart object\u2019s contents", ...READ8 },
     handler: ({ layerId }) => {
       const f = controller.exportSmartObjectContents(smartId(layerId));
       return { name: f.name, mimeType: f.mimeType, byteLength: f.bytes.length, base64: bytesToBase64(f.bytes) };
@@ -9961,7 +10572,7 @@ function createImageSmartObjectTools(controller) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Copy a smart object", ...WRITE6 },
+    annotations: { title: "Copy a smart object", ...WRITE7 },
     handler: ({ layerId, linked, name }) => {
       const id = controller.copySmartObject(smartId(layerId), linked === true, name);
       return { layer: layerSummary(id), contentsId: controller.getSmartObject(id).contents.id };
@@ -9972,7 +10583,7 @@ function createImageSmartObjectTools(controller) {
     title: "Edit a smart object\u2019s contents",
     description: 'Layer \u203A Smart Objects \u203A Edit Contents: opens the contents as a document of their own (a layer document, or raster contents as one pixel layer "Layer 0") with their own undo history. Every other tool (list_layers, paint, adjustments\u2026) then works inside the contents until close_smart_object_contents saves them back. Contents can nest. Returns the contents\u2019 size and layers.',
     inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Edit a smart object\u2019s contents", ...WRITE6 },
+    annotations: { title: "Edit a smart object\u2019s contents", ...WRITE7 },
     handler: ({ layerId }) => {
       const res = controller.editSmartObjectContents(smartId(layerId));
       const s = controller.getState();
@@ -9988,7 +10599,7 @@ function createImageSmartObjectTools(controller) {
       properties: { save: { type: "boolean", description: "true (default) saves the edits into the smart object; false discards them." } },
       additionalProperties: false
     },
-    annotations: { title: "Close a smart object\u2019s contents", ...WRITE6 },
+    annotations: { title: "Close a smart object\u2019s contents", ...WRITE7 },
     handler: ({ save }) => ({ ...controller.closeSmartObjectContents(save !== false), editing: controller.getEditingContents() })
   };
   const addFilter = {
@@ -10006,7 +10617,7 @@ function createImageSmartObjectTools(controller) {
       required: ["layerId", "kind"],
       additionalProperties: false
     },
-    annotations: { title: "Add a smart filter", ...WRITE6 },
+    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);
@@ -10095,7 +10706,7 @@ function createImageSmartObjectTools(controller) {
       required: ["layerId", "from"],
       additionalProperties: false
     },
-    annotations: { title: "Set the smart filter mask", ...WRITE6 },
+    annotations: { title: "Set the smart filter mask", ...WRITE7 },
     handler: (args) => {
       const id = smartId(args.layerId);
       const props = {};
@@ -10108,8 +10719,8 @@ function createImageSmartObjectTools(controller) {
 }
 
 // src/image-editor/shape-tools.ts
-var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE7 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE8 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var WRITE_IDEMPOTENT5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE6 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var LAYER_ID5 = { type: "string", description: "Shape layer id from list_layers (type shape) or add_shape_layer." };
@@ -10362,7 +10973,7 @@ function createImageShapeTools(controller) {
     title: "Read a shape layer",
     description: "Returns a shape layer\u2019s components bottom to top (index, path operation, the live shape it was drawn as or null, its subpaths with absolute anchors and handles, bounds), the fill rule, fill and stroke paints and settings, the path bounds and the rendered bounds (stroke included). Changes nothing.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID5 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a shape layer", ...READ8 },
+    annotations: { title: "Read a shape layer", ...READ9 },
     handler: ({ layerId }) => controller.getShapeLayer(shapeId(layerId))
   };
   const add2 = {
@@ -10393,7 +11004,7 @@ function createImageShapeTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Add a shape layer", ...WRITE7 },
+    annotations: { title: "Add a shape layer", ...WRITE8 },
     handler: (args) => {
       const init = { ...geometry(args) };
       if (args.components !== void 0) init.components = args.components.map(geometry);
@@ -10488,7 +11099,7 @@ function createImageShapeTools(controller) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Add a shape component", ...WRITE7 },
+    annotations: { title: "Add a shape component", ...WRITE8 },
     handler: ({ layerId, index, ...rest }) => controller.addShapeComponent(shapeId(layerId), geometry(rest), index)
   };
   const removeComponent = {
@@ -10511,8 +11122,8 @@ function createImageShapeTools(controller) {
 }
 
 // src/image-editor/type-tools.ts
-var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE8 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ10 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE9 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var WRITE_IDEMPOTENT6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE7 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var LAYER_ID6 = { type: "string", description: "Type layer id from list_layers (type type) or add_text_layer." };
@@ -10540,7 +11151,7 @@ var PARAGRAPH = {
   spaceBefore: { type: ["number", "null"], description: "Space above the paragraph in pixels (not before the first)." },
   spaceAfter: { type: ["number", "null"], description: "Space below the paragraph in pixels." }
 };
-function pick(args, keys) {
+function pick2(args, keys) {
   const out = {};
   for (const k of keys) if (args[k] !== void 0) out[k] = args[k];
   return out;
@@ -10562,7 +11173,7 @@ function createImageTypeTools(controller) {
     title: "List fonts",
     description: "Returns the font families type layers can use here (generic families such as sans-serif always work). Changes nothing.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "List fonts", ...READ9 },
+    annotations: { title: "List fonts", ...READ10 },
     handler: () => ({ families: controller.listFonts(), shaper: controller.getTextShaper()?.id ?? null })
   };
   const get = {
@@ -10570,7 +11181,7 @@ function createImageTypeTools(controller) {
     title: "Read a type layer",
     description: "Returns a type layer\u2019s text, its character runs and paragraphs as [start, end) ranges in UTF-16 code units with their styles, the frame (point text, or a paragraph box with its size), the text-to-document transform, the laid-out lines (range, baseline, width), the rendered bounds, missing fonts and whether the pixels are live or stored from a file. Call before editing text you did not write, to get the ranges. Changes nothing.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID6 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a type layer", ...READ9 },
+    annotations: { title: "Read a type layer", ...READ10 },
     handler: ({ layerId }) => controller.getTextLayer(typeId(layerId))
   };
   const add2 = {
@@ -10604,9 +11215,9 @@ function createImageTypeTools(controller) {
       required: ["text", "x", "y"],
       additionalProperties: false
     },
-    annotations: { title: "Add a type layer", ...WRITE8 },
+    annotations: { title: "Add a type layer", ...WRITE9 },
     handler: (args) => {
-      const init = pick(args, ["text", "x", "y", "box", "style", "paragraph", "rotation", "name", "opacity", "blend", "aboveId", "belowId", "parentId", "index"]);
+      const init = pick2(args, ["text", "x", "y", "box", "style", "paragraph", "rotation", "name", "opacity", "blend", "aboveId", "belowId", "parentId", "index"]);
       if (init.blend !== void 0) init.blend = init.blend;
       const id = controller.addTextLayer(init);
       return { layer: layerSummary(id), text: controller.getTextLayer(id) };
@@ -10617,7 +11228,7 @@ function createImageTypeTools(controller) {
     title: "Edit text",
     description: "Replaces the text in [start, end) (default all of it) with text; inserted text takes the style of the character at start. Use start = end to insert. Returns the text layer with its new runs.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID6, text: { type: "string", description: "Replacement text (\\n starts a paragraph; empty deletes the range)." }, start: START, end: END }, required: ["layerId", "text"], additionalProperties: false },
-    annotations: { title: "Edit text", ...WRITE8 },
+    annotations: { title: "Edit text", ...WRITE9 },
     handler: (args) => controller.setText(typeId(args.layerId), args.text, range(args))
   };
   const setStyle = {
@@ -10627,7 +11238,7 @@ function createImageTypeTools(controller) {
     inputSchema: { type: "object", properties: { layerId: LAYER_ID6, start: START, end: END, ...STYLE }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "Style a range of text", ...WRITE_IDEMPOTENT6 },
     handler: (args) => {
-      const style = pick(args, Object.keys(STYLE));
+      const style = pick2(args, Object.keys(STYLE));
       if (!Object.keys(style).length) throw new LayerOperationError(`Give at least one style field: ${Object.keys(STYLE).join(", ")}.`);
       return controller.setTextStyle(typeId(args.layerId), style, range(args));
     }
@@ -10639,7 +11250,7 @@ function createImageTypeTools(controller) {
     inputSchema: { type: "object", properties: { layerId: LAYER_ID6, start: START, end: END, ...PARAGRAPH }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "Style paragraphs", ...WRITE_IDEMPOTENT6 },
     handler: (args) => {
-      const style = pick(args, Object.keys(PARAGRAPH));
+      const style = pick2(args, Object.keys(PARAGRAPH));
       if (!Object.keys(style).length) throw new LayerOperationError(`Give at least one paragraph field: ${Object.keys(PARAGRAPH).join(", ")}.`);
       return controller.setParagraphStyle(typeId(args.layerId), style, range(args));
     }
@@ -10923,6 +11534,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageTypeTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
+      ...createImageRetouchTools(controller),
       ...createPigmentTools(),
       ...createImagePsdTools(controller)
     ]
@@ -11223,6 +11835,470 @@ function applyRegionBlur(imageData, regions, radius = 10) {
   return imageData;
 }
 
+// src/image-editor/layers/shape-type-ui.ts
+var DEFAULT_SHAPE_TOOL_OPTIONS = {
+  kind: "rect",
+  fill: "#4f46e5",
+  stroke: null,
+  strokeWidth: 2,
+  radius: 0,
+  sides: 6,
+  points: 5,
+  innerRatio: 0.5,
+  weight: 4,
+  arrow: false
+};
+var SHAPE_KIND_LABELS = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
+var DEFAULT_TYPE_TOOL_OPTIONS = { fontFamily: "sans-serif", fontSize: 32, fontWeight: 400, italic: false, color: "#111827", align: "left" };
+function liveShapeForDrag(o, a, b, mods = {}) {
+  if (o.kind === "line") {
+    let x2 = b.x;
+    let y2 = b.y;
+    if (mods.shift) {
+      const ang = Math.round(Math.atan2(b.y - a.y, b.x - a.x) / (Math.PI / 4)) * (Math.PI / 4);
+      const len = Math.hypot(b.x - a.x, b.y - a.y);
+      x2 = a.x + Math.cos(ang) * len;
+      y2 = a.y + Math.sin(ang) * len;
+    }
+    if (Math.hypot(x2 - a.x, y2 - a.y) < 1) return null;
+    const head = o.arrow ? { endArrow: { width: o.weight * 4, length: o.weight * 4 } } : {};
+    return { kind: "line", x1: a.x, y1: a.y, x2, y2, weight: o.weight, ...head };
+  }
+  let w = b.x - a.x;
+  let h = b.y - a.y;
+  if (mods.shift) {
+    const s = Math.max(Math.abs(w), Math.abs(h));
+    w = Math.sign(w || 1) * s;
+    h = Math.sign(h || 1) * s;
+  }
+  let x = a.x;
+  let y = a.y;
+  if (mods.alt) {
+    x = a.x - w;
+    y = a.y - h;
+    w *= 2;
+    h *= 2;
+  }
+  const box = { x: Math.min(x, x + w), y: Math.min(y, y + h), width: Math.abs(w), height: Math.abs(h) };
+  if (box.width < 1 || box.height < 1) return null;
+  switch (o.kind) {
+    case "rect":
+      return { kind: "rect", ...box, ...o.radius > 0 ? { radius: o.radius } : {} };
+    case "ellipse":
+      return { kind: "ellipse", ...box };
+    case "polygon":
+      return { kind: "polygon", ...box, sides: o.sides };
+    case "star":
+      return { kind: "star", ...box, points: o.points, innerRatio: o.innerRatio };
+  }
+  return null;
+}
+var ShapeDrawGesture = class {
+  constructor(controller, options) {
+    this.controller = controller;
+    this.options = options;
+  }
+  controller;
+  options;
+  start = null;
+  layerId = null;
+  error = null;
+  get active() {
+    return this.start !== null;
+  }
+  /** The shape layer drawn by the last drag (until the next one starts). */
+  get drawnLayerId() {
+    return this.layerId;
+  }
+  down(p) {
+    this.error = null;
+    this.start = { x: p.x, y: p.y };
+    this.layerId = null;
+  }
+  move(p, mods = {}) {
+    if (!this.start) return;
+    const o = this.options();
+    const shape = liveShapeForDrag(o, this.start, p, mods);
+    if (!shape) return;
+    try {
+      if (!this.layerId) {
+        const isLine = o.kind === "line";
+        this.layerId = this.controller.addShapeLayer({
+          shape,
+          fill: isLine ? o.stroke ?? o.fill ?? "#000000" : o.fill,
+          stroke: !isLine && o.stroke ? { width: o.strokeWidth, paint: o.stroke } : null
+        });
+      } else this.controller.setShapeComponent(this.layerId, 0, { shape }, false);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+      this.start = null;
+    }
+  }
+  up() {
+    this.start = null;
+    return this.layerId;
+  }
+  cancel() {
+    this.start = null;
+  }
+};
+function applyShapeOptions(controller, layerId, change) {
+  const info = controller.getShapeLayer(layerId);
+  const style = {};
+  if ("fill" in change) style.fill = change.fill ?? null;
+  if ("stroke" in change || "strokeWidth" in change) {
+    const color = "stroke" in change ? change.stroke : info.stroke?.paint.type === "color" ? info.stroke.paint.color : null;
+    style.stroke = color ? { width: change.strokeWidth ?? info.stroke?.width ?? 2, paint: color } : null;
+  }
+  if (Object.keys(style).length) controller.setShapeStyle(layerId, style);
+  const live = info.components[0]?.live;
+  if (!live) return;
+  const shape = {};
+  if (live.kind === "rect" && change.radius !== void 0) shape.radius = change.radius;
+  if (live.kind === "polygon" && change.sides !== void 0) shape.sides = change.sides;
+  if (live.kind === "star" && change.points !== void 0) shape.points = change.points;
+  if (live.kind === "star" && change.innerRatio !== void 0) shape.innerRatio = change.innerRatio;
+  if (live.kind === "line" && change.weight !== void 0) shape.weight = change.weight;
+  if (live.kind === "line" && change.arrow !== void 0) shape.endArrow = change.arrow ? { width: (live.weight || 1) * 4, length: (live.weight || 1) * 4 } : null;
+  if (Object.keys(shape).length) controller.setShapeComponent(layerId, 0, { shape });
+}
+var TextEditSession = class {
+  constructor(controller, layerId, index) {
+    this.controller = controller;
+    this.layerId = layerId;
+    const n = this.text.length;
+    this.anchor = this.focus = Math.max(0, Math.min(n, index ?? n));
+  }
+  controller;
+  layerId;
+  anchor;
+  focus;
+  changed = false;
+  listeners = /* @__PURE__ */ new Set();
+  error = null;
+  get layer() {
+    const l = findLayer(this.controller.getLayers(), this.layerId)?.layer;
+    if (!l || l.type !== "type") throw new Error("The type layer being edited is gone.");
+    return l;
+  }
+  get text() {
+    return this.layer.text;
+  }
+  get start() {
+    return Math.min(this.anchor, this.focus);
+  }
+  get end() {
+    return Math.max(this.anchor, this.focus);
+  }
+  /** Whether the layer still exists (it can be deleted or undone away while editing). */
+  get alive() {
+    return findLayer(this.controller.getLayers(), this.layerId)?.layer.type === "type";
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  emit() {
+    for (const l of this.listeners) l();
+  }
+  layout() {
+    return this.controller.getTextLayout(this.layerId);
+  }
+  run(fn) {
+    this.error = null;
+    try {
+      const out = fn(!this.changed);
+      this.changed = true;
+      return out;
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+      return void 0;
+    } finally {
+      this.emit();
+    }
+  }
+  /** Replaces the selection with `text` (typing and pasting). */
+  insert(text) {
+    if (!text) return;
+    const s = this.start;
+    const e = this.end;
+    const done = this.run((commit) => this.controller.setText(this.layerId, text, { start: s, end: e }, commit));
+    if (done) this.anchor = this.focus = s + text.replace(/\r\n?/g, "\n").length;
+  }
+  /** Backspace: the selection, else the character before the caret. */
+  deleteBackward() {
+    if (this.start === this.end && this.start === 0) return;
+    const s = this.start === this.end ? Math.max(0, this.start - this.surrogate(this.start - 1, -1)) : this.start;
+    const e = this.end;
+    if (this.run((commit) => this.controller.setText(this.layerId, "", { start: s, end: e }, commit))) this.anchor = this.focus = s;
+  }
+  /** Delete: the selection, else the character after the caret. */
+  deleteForward() {
+    const n = this.text.length;
+    if (this.start === this.end && this.end >= n) return;
+    const s = this.start;
+    const e = this.start === this.end ? Math.min(n, this.end + this.surrogate(this.end, 1)) : this.end;
+    if (this.run((commit) => this.controller.setText(this.layerId, "", { start: s, end: e }, commit))) this.anchor = this.focus = s;
+  }
+  /** 2 when the code unit at `i` is half of a surrogate pair (moving `dir`), else 1. */
+  surrogate(i, dir) {
+    const t = this.text;
+    const c = t.charCodeAt(i);
+    if (dir < 0 && c >= 56320 && c <= 57343 && i > 0) return 2;
+    if (dir > 0 && c >= 55296 && c <= 56319 && i + 1 < t.length) return 2;
+    return 1;
+  }
+  /** Moves the caret (Shift extends the selection). */
+  move(to, extend = false) {
+    const n = this.text.length;
+    let f = this.focus;
+    const collapsedJump = !extend && this.start !== this.end;
+    if (to === "left") f = collapsedJump ? this.start : Math.max(0, f - this.surrogate(f - 1, -1));
+    else if (to === "right") f = collapsedJump ? this.end : Math.min(n, f + this.surrogate(f, 1));
+    else if (to === "start") f = 0;
+    else if (to === "finish") f = n;
+    else {
+      const layout = this.layout();
+      if (layout && layout.lines.length) {
+        const c = caretAt(layout, f);
+        const line = layout.lines[c.line];
+        if (to === "home") f = line.start;
+        else if (to === "end") {
+          const last = line.chars[line.chars.length - 1];
+          f = last ? Math.min(n, last.index + 1) : line.start;
+          if (last && this.text[last.index] === " " && c.line < layout.lines.length - 1) f = last.index;
+        } else {
+          const target = layout.lines[c.line + (to === "up" ? -1 : 1)];
+          if (!target) f = to === "up" ? 0 : n;
+          else {
+            const hit = target.chars.find((ch) => c.x < ch.x + ch.advance / 2);
+            const last = target.chars[target.chars.length - 1];
+            f = hit ? hit.index : last ? last.index + 1 : target.start;
+          }
+        }
+      }
+    }
+    this.focus = f;
+    if (!extend) this.anchor = f;
+    this.emit();
+  }
+  selectAll() {
+    this.anchor = 0;
+    this.focus = this.text.length;
+    this.emit();
+  }
+  /** Places the caret at a document point (Shift-click extends). */
+  pointAt(p, extend = false) {
+    this.focus = this.controller.textIndexAt(this.layerId, p);
+    if (!extend) this.anchor = this.focus;
+    this.emit();
+  }
+  /** Handles a key; returns `true` when it was the session's (the caller then prevents the default). */
+  handleKey(e) {
+    const mod2 = e.metaKey || e.ctrlKey;
+    if (mod2 && e.key.toLowerCase() === "a") {
+      this.selectAll();
+      return true;
+    }
+    switch (e.key) {
+      case "Backspace":
+        this.deleteBackward();
+        return true;
+      case "Delete":
+        this.deleteForward();
+        return true;
+      case "Enter":
+        this.insert("\n");
+        return true;
+      case "ArrowLeft":
+        this.move(mod2 ? "home" : "left", e.shiftKey);
+        return true;
+      case "ArrowRight":
+        this.move(mod2 ? "end" : "right", e.shiftKey);
+        return true;
+      case "ArrowUp":
+        this.move(mod2 ? "start" : "up", e.shiftKey);
+        return true;
+      case "ArrowDown":
+        this.move(mod2 ? "finish" : "down", e.shiftKey);
+        return true;
+      case "Home":
+        this.move("home", e.shiftKey);
+        return true;
+      case "End":
+        this.move("end", e.shiftKey);
+        return true;
+      case "Tab":
+        this.insert("	");
+        return true;
+    }
+    if (!mod2 && !e.altKey && e.key.length >= 1 && [...e.key].length === 1) {
+      this.insert(e.key);
+      return true;
+    }
+    return false;
+  }
+  /** Sets character style fields on the selection, or on the whole text when nothing is selected. */
+  setStyle(style) {
+    const s = this.start;
+    const e = this.end;
+    const range = s === e ? {} : { start: s, end: e };
+    this.run((commit) => this.controller.setTextStyle(this.layerId, style, range, commit));
+  }
+  /** Sets paragraph fields on the paragraphs the selection touches. */
+  setParagraph(style) {
+    const s = this.start;
+    const e = this.end;
+    this.run((commit) => this.controller.setParagraphStyle(this.layerId, style, { start: s, end: e }, commit));
+  }
+  /** The style at the caret (or the selection's start), for the options bar. */
+  styleHere() {
+    const layer = this.layer;
+    const at = this.start > 0 && this.start === this.end ? this.start - 1 : this.start;
+    return styleAt(layer.runs, at, DEFAULT_TEXT_STYLE);
+  }
+  info() {
+    return this.controller.getTextLayer(this.layerId);
+  }
+  /** The caret, the selection and the frame in natural pixels, for `RenderOptions.textEdit`. */
+  overlay() {
+    const layer = this.layer;
+    const layout = this.layout();
+    const m = textMatrix(layer);
+    const at = (x, y) => applyMatrix(m, { x, y });
+    let frame = null;
+    if (layer.frame.kind === "box") frame = [at(0, 0), at(layer.frame.width, 0), at(layer.frame.width, layer.frame.height), at(0, layer.frame.height)];
+    else if (layout) {
+      const b = layout.bounds;
+      frame = [at(b.x, b.y), at(b.x + b.width, b.y), at(b.x + b.width, b.y + b.height), at(b.x, b.y + b.height)];
+    }
+    if (!layout) return { caret: null, selection: [], frame };
+    const selection = [];
+    if (this.start !== this.end) {
+      for (const l of layout.lines) {
+        const chars = l.chars.filter((c2) => c2.index >= this.start && c2.index < this.end);
+        if (!chars.length) continue;
+        const x0 = chars[0].x;
+        const x1 = chars[chars.length - 1].x + chars[chars.length - 1].advance;
+        const top = l.baseline - l.ascent;
+        const bottom = l.baseline + l.descent;
+        selection.push([at(x0, top), at(x1, top), at(x1, bottom), at(x0, bottom)]);
+      }
+    }
+    const c = caretAt(layout, this.focus);
+    return { caret: [at(c.x, c.top), at(c.x, c.bottom)], selection, frame };
+  }
+  /** Ends editing: an empty layer made for this session is deleted (as Photoshop does). Returns whether the layer remains. */
+  close() {
+    if (!this.alive) return false;
+    if (!this.text.trim().length) {
+      try {
+        this.controller.removeLayer(this.layerId);
+      } catch {
+      }
+      return false;
+    }
+    if (this.layer.name === "Text" && this.changed) {
+      try {
+        this.controller.setLayerProperties(this.layerId, { name: typeLayerName(this.text) }, false);
+      } catch {
+      }
+    }
+    return true;
+  }
+};
+function typeLayerAt(controller, p, slop = 4) {
+  const layers = [...flattenTypeLayers(controller.getLayers())].reverse();
+  for (const l of layers) {
+    if (!l.visible) continue;
+    const inv = invert(textMatrix(l));
+    const q = applyMatrix(inv, p);
+    let b = null;
+    if (l.frame.kind === "box") b = { x: 0, y: 0, width: l.frame.width, height: l.frame.height };
+    else {
+      const layout = controller.getTextLayout(l.id);
+      if (layout) b = layout.bounds;
+    }
+    if (b && q.x >= b.x - slop && q.x <= b.x + b.width + slop && q.y >= b.y - slop && q.y <= b.y + b.height + slop) return l.id;
+  }
+  return null;
+}
+function flattenTypeLayers(layers) {
+  const out = [];
+  const walk = (list) => {
+    for (const l of list) {
+      if (l.type === "type") out.push(l);
+      else if (l.type === "group") walk(l.children);
+    }
+  };
+  walk(layers);
+  return out;
+}
+function invert(m) {
+  const [a, b, c, d, e, f] = m;
+  const det = a * d - b * c || 1;
+  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+}
+var TypeToolGesture = class {
+  constructor(controller, options) {
+    this.controller = controller;
+    this.options = options;
+  }
+  controller;
+  options;
+  session = null;
+  dragStart = null;
+  error = null;
+  down(p, mods = {}) {
+    this.error = null;
+    const hit = typeLayerAt(this.controller, p);
+    if (this.session && this.session.alive && hit === this.session.layerId) {
+      this.session.pointAt(p, mods.shift);
+      this.dragStart = null;
+      return;
+    }
+    this.finish();
+    if (hit) {
+      this.controller.setActiveLayer(hit);
+      this.session = new TextEditSession(this.controller, hit, this.controller.textIndexAt(hit, p));
+      this.dragStart = null;
+      return;
+    }
+    this.dragStart = { x: p.x, y: p.y };
+  }
+  /** Releases a click or drag that did not land on type: adds a new text layer (point text, or a box for a drag). */
+  up(p) {
+    const start = this.dragStart;
+    this.dragStart = null;
+    if (!start) return this.session;
+    const o = this.options();
+    const w = Math.abs(p.x - start.x);
+    const h = Math.abs(p.y - start.y);
+    try {
+      const box = w >= 8 && h >= 8 ? { width: w, height: h } : void 0;
+      const id = this.controller.addTextLayer({
+        text: "",
+        x: box ? Math.min(start.x, p.x) : start.x,
+        y: box ? Math.min(start.y, p.y) : start.y,
+        ...box ? { box } : {},
+        style: { fontFamily: o.fontFamily, fontSize: o.fontSize, fontWeight: o.fontWeight, italic: o.italic, color: o.color },
+        paragraph: o.align !== "left" ? { align: o.align } : {},
+        name: "Text"
+      });
+      this.session = new TextEditSession(this.controller, id, 0);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+    }
+    return this.session;
+  }
+  /** Ends the open session (an empty new layer is removed). */
+  finish() {
+    const s = this.session;
+    this.session = null;
+    s?.close();
+  }
+};
+
 // src/image-editor/layers/panel.ts
 function layerPanelRows(layers, activeId) {
   const rows = [];
@@ -11267,6 +12343,15 @@ function layerBadge(layer) {
       return "T";
   }
 }
+function layerHasThumbnail(layer) {
+  return layer.type === "pixel" || layer.type === "shape" || layer.type === "type";
+}
+function layerWarning(layer) {
+  if (layer.type === "type" && layer.missingFonts?.length) {
+    return `Missing ${layer.missingFonts.length === 1 ? "font" : "fonts"}: ${layer.missingFonts.join(", ")}. ${layer.rendering === "stored" ? "Showing the saved pixels until the text is edited." : "Drawn with a fallback font."}`;
+  }
+  return null;
+}
 function dropZone(fraction, isGroup) {
   if (isGroup && fraction > 0.3 && fraction < 0.7) return "inside";
   return fraction < 0.5 ? "above" : "below";
@@ -12245,10 +13330,13 @@ export {
   DEFAULT_MITER_LIMIT,
   DEFAULT_MIXER,
   DEFAULT_REFINE_EDGE_PARAMS,
+  DEFAULT_RETOUCH,
   DEFAULT_SELECTION_TOOL_OPTIONS,
+  DEFAULT_SHAPE_TOOL_OPTIONS,
   DEFAULT_SMUDGE,
   DEFAULT_TEXT_STYLE,
   DEFAULT_TRANSFORM,
+  DEFAULT_TYPE_TOOL_OPTIONS,
   DEPTH_MASK_CONTROLS,
   DEVELOP_FILTER_ID,
   DIRECT_GAUSSIAN_MAX_SIGMA,
@@ -12312,16 +13400,26 @@ export {
   PatternTile,
   PsdError,
   REFINE_EDGE_CONTROLS,
+  RETOUCH_CHOICES,
+  RETOUCH_OPTION_CONTROLS,
+  RETOUCH_SAMPLES,
+  RETOUCH_TOGGLES,
+  RETOUCH_TOOLS,
+  RegionPixelSource,
+  RetouchDabStroke,
   SELECTION_MODES,
   SELECTION_MODE_LABELS,
   SELECTION_MODIFY_OPS,
   SELECTION_TOOLS,
   SHADOW_AMBIENT,
+  SHAPE_KIND_LABELS,
   SHAPE_OPERATIONS,
   SHAPE_RENDER_MARGIN,
   SMART_RENDER_MARGIN,
+  SPOT_HEAL_TYPES,
   SUPPORTED_ADJUSTMENT_KEYS,
   SelectionGesture,
+  ShapeDrawGesture,
   SmudgeTip,
   StrokeCoverage,
   SurfaceDraft,
@@ -12332,11 +13430,15 @@ export {
   TILE_SHIFT,
   TINT_SCALE,
   TONE_LUT_SIZE,
+  TONE_RANGES,
   TONE_RANGE_PRESETS,
   TRANSFORM_ANCHORS,
+  TextEditSession,
   TileMedium,
+  TilePixelSource,
   TiledSurface,
   TransformTooLargeError,
+  TypeToolGesture,
   VIBRANCE_GREY,
   WARP_GRID_OPTIONS,
   WARP_STYLES,
@@ -12375,11 +13477,14 @@ export {
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
+  applyRetouchToTile,
+  applyShapeOptions,
   applySmartFilters,
   applyStrokeToTile,
   backgroundLayer,
   base64ToBytes,
   baseProjection,
+  bestOffset,
   blackWhiteGray,
   blendChannel,
   blendImageData,
@@ -12409,6 +13514,7 @@ export {
   clampControlValue,
   clampCropToImage,
   cleanMixer,
+  cloneSourceLabel,
   collectTiles,
   colorBalanceChannel,
   colorRange,
@@ -12440,6 +13546,7 @@ export {
   createImageLayerTools,
   createImagePaintTools,
   createImagePsdTools,
+  createImageRetouchTools,
   createImageSelectionTools,
   createImageShapeTools,
   createImageSmartObjectTools,
@@ -12486,8 +13593,11 @@ export {
   developFilter,
   developFromAdjustments,
   developTarget,
+  dilateMask,
   distanceTransform,
   documentContents,
+  dodgeBurn,
+  dodgeBurnCurve,
   downloadPsd,
   dragWarpMeshPoint,
   dropPlacement,
@@ -12549,6 +13659,7 @@ export {
   hasWarp,
   hashMaskContent,
   hashNoise,
+  healPixels,
   hexToRgb,
   histogramPath,
   hitTestAnnotation,
@@ -12592,6 +13703,8 @@ export {
   isQuarterTurn,
   isQuarterTurnSwapped,
   isRenderedLayer,
+  isRetouchPaintTool,
+  isRetouchTool,
   isSelectionEmpty,
   isSelectionMode,
   isSeparableBlendMode,
@@ -12607,6 +13720,7 @@ export {
   layerEffectsBadge,
   layerEffectsOf,
   layerEffectsPanel,
+  layerHasThumbnail,
   layerLabel,
   layerMaskCoverage,
   layerMaskFromSelection,
@@ -12616,6 +13730,7 @@ export {
   layerPanelRows,
   layerTree,
   layerTypeLabel,
+  layerWarning,
   layersFromLegacy,
   layoutText,
   legacyAdjustmentLayer,
@@ -12627,16 +13742,20 @@ export {
   linearSrgbToXy,
   linearToSrgb,
   liveComponent,
+  liveShapeForDrag,
   liveShapeSubpaths,
   loadImageEditorDocument,
   loadMixer,
+  luma,
   magicWand,
   mapCropHandle,
   mapLayer,
   mapSubpaths,
+  maskBounds,
   maskSummary,
   matrixFromCorners,
   matrixFromParams,
+  membraneFill,
   mergeLayerEffect,
   mergeShapeComponents,
   migrateSerializedImageEditorState,
@@ -12671,6 +13790,7 @@ export {
   normalizeProcessVersion,
   normalizeRect,
   normalizeRefineEdgeParams,
+  normalizeRetouch,
   normalizeShapePaint,
   normalizeShapeStroke,
   normalizeSmartFilter,
@@ -12697,6 +13817,7 @@ export {
   parseVersionedDescriptor,
   patchParagraphStyle,
   patchTextStyle,
+  perDabStrength,
   photoFilterMatrix,
   pigment8,
   pixelLayerBounds,
@@ -12733,6 +13854,7 @@ export {
   readPixel,
   readPsd,
   readRegion,
+  readSourceRegion,
   rectSelection,
   rectToQuad,
   reduceSurface,
@@ -12774,11 +13896,14 @@ export {
   rgbToHsl,
   rgbToReflectance,
   rgbUnitToHex,
+  rgbaViewOfGrey,
   runLayerFilters,
   runLayerMenuAction,
   sampleLut,
   sampleToneLut,
+  saturationOf,
   scaleLayerEffect,
+  seamlessClone,
   selectionArea,
   selectionFromCoverage,
   selectionFromPixels,
@@ -12801,6 +13926,7 @@ export {
   setLayerProperties,
   setLum,
   setPigmentColor,
+  setRetouchChoice,
   setSmartFilterMask,
   setSmartFiltersEnabled,
   setSmartPlacement,
@@ -12815,9 +13941,15 @@ export {
   smartObjectLayers,
   smoothCoverage,
   smoothPoints,
+  smudgeEffect,
   solidSurface,
+  solveMembrane,
   spliceRuns,
   splitOverlayAnnotations,
+  sponge,
+  spongeEffect,
+  spotHealPixels,
+  spotHealWindow,
   srgb8ToLab,
   srgbToLinear,
   standardBlendMode,
@@ -12843,6 +13975,7 @@ export {
   toTextSpace,
   toneCurve,
   toneLuts,
+  toneOf,
   toneRange,
   transformHomography,
   transformMap,
@@ -12856,6 +13989,7 @@ export {
   typeAsPixelLayer,
   typeFrame,
   typeFromAnnotation,
+  typeLayerAt,
   typeLayerName,
   ungroupLayer,
   uniformTile,