@pixerate/editor 0.112.0 → 0.114.0

package/dist/image-editor/index.js

@@ -1,10 +1,7 @@
 import {
-  loadDocument
-} from "../chunk-U5HZSFCS.js";
-import {
-  createCaptureTool
-} from "../chunk-REOJJIY3.js";
-import "../chunk-VKK5VS2T.js";
+  loadOpenTypeFont,
+  parseOpenTypeFont
+} from "../chunk-3UFGNHSP.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -17,10 +14,8 @@ import {
   D50,
   D65,
   DEFAULT_ADJUSTMENTS_VALUES,
-  DEFAULT_AUTO_LEADING,
   DEFAULT_DEPTH_MASK_VALUES,
   DEFAULT_MITER_LIMIT,
-  DEFAULT_TEXT_STYLE,
   DEFAULT_TRANSFORM_VALUES,
   DEVELOP_FILTER_ID,
   EMPTY_DISTANCE,
@@ -72,6 +67,7 @@ import {
   annotationOfShape,
   annotationOfType,
   applyAdjustmentLayers,
+  applyAdjustmentLayersFloat,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
@@ -91,12 +87,12 @@ import {
   buildToneLut,
   calculateCropDrag,
   canvasToImagePoint,
-  caretAt,
   clampCropToImage,
   colorBalanceChannel,
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
+  compositeDeep,
   computeSelectionBounds,
   contentsBox,
   contentsSurface,
@@ -110,6 +106,7 @@ import {
   createShapeLayer,
   createTypeLayer,
   curveLutFromLevels,
+  decodeDeepSurface,
   decodeLayerChannel,
   decodeLayerMask,
   decodeMergedImage,
@@ -132,6 +129,7 @@ import {
   distanceTransform,
   documentContents,
   duplicateLayer,
+  encodeDeepSurface,
   encodeRle,
   encodeSelectionRle,
   encodeSurface,
@@ -140,11 +138,8 @@ import {
   exportPsd,
   featherCoverage,
   filterMaskCoverage,
-  fitParagraphRuns,
-  fitRuns,
   flattenPath,
   flipCorners,
-  fontOf,
   fullSelection,
   geometryHomography,
   getAnnotationBounds,
@@ -195,7 +190,6 @@ import {
   layerTree,
   layerTypeLabel,
   layersFromLegacy,
-  layoutText,
   legacyAdjustmentLayer,
   legacyMaskOf,
   legacyView,
@@ -232,7 +226,6 @@ import {
   offsetLayer,
   offsetShape,
   offsetSmartObject,
-  paragraphRanges,
   parseAdjustmentBlock,
   parseBlend,
   parseCssColor,
@@ -287,7 +280,6 @@ import {
   rerenderText,
   resizeSelection,
   resolveExternalAssets,
-  restyleRange,
   rgbToGray,
   rgbToHsl,
   runLayerFilters,
@@ -323,12 +315,9 @@ import {
   smartContentsFile,
   smartObjectLayers,
   smoothCoverage,
-  spliceRuns,
   srgbToLinear,
-  styleAt,
   tempTintToXy,
   temperatureToKelvin,
-  textIndexAt,
   textMatrix,
   textOutlines,
   textRange,
@@ -369,8 +358,15 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-CZOXTEMN.js";
+} from "../chunk-EUVSQ25B.js";
+import {
+  loadDocument
+} from "../chunk-U5HZSFCS.js";
 import {
+  createCaptureTool
+} from "../chunk-REOJJIY3.js";
+import {
+  BIT_DEPTHS,
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
   INTERPOLATIONS,
@@ -381,8 +377,6 @@ import {
   PatternPlacement,
   PatternTile,
   TransformTooLargeError,
-  ZlibError,
-  adler32,
   base64ToBytes,
   blendTile,
   builtinPattern,
@@ -390,12 +384,14 @@ import {
   bytesToBase64,
   changedTiles,
   compositeSurfaceOver,
+  convertSurfaceDepth,
   curveLut,
   decodePng,
+  deepBytes,
+  deepTile,
   defaultEffectGradient,
   defaultLayerEffect,
-  deflate,
-  deflateRaw,
+  depthOf,
   effectColorHex,
   effectReach,
   effectsFingerprint,
@@ -407,9 +403,8 @@ import {
   gaussianBlur,
   hasActiveEffects,
   hashNoise,
-  inflate,
-  inflateRaw,
   insertLayer,
+  isBitDepth,
   isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
@@ -424,16 +419,33 @@ import {
   parseDataUrl,
   parseEffectColor,
   pngDataUrl,
+  proxyOf,
+  readDeepRegion,
   reduceSurface,
   renderLayerEffects,
   scaleLayerEffect,
+  srgbDecode,
+  srgbEncode,
+  surfaceDepth,
+  surfaceFromDeepPixels,
+  tileSamples,
+  tileSamples16,
+  tileSamples32,
+  to16From32,
+  to16From8,
+  to32From16,
+  to32From8,
+  to8From16,
+  to8From32,
   transformSurface,
   transformedBounds,
   validateEffectGradient,
   validateLayerEffect,
   validateLayerEffects,
-  warpSurface
-} from "../chunk-LQEEDHOP.js";
+  warpSurface,
+  workingToSamples,
+  writeDeepRegion
+} from "../chunk-C6C5PDKU.js";
 import {
   applyHomography,
   boxQuad,
@@ -443,6 +455,37 @@ import {
   multiplyHomographies,
   rectToQuad
 } from "../chunk-GX332W2C.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-LKCYANMW.js";
 import {
   CoverageMap,
   DEFAULT_BLENDER,
@@ -482,7 +525,7 @@ import {
   tipReach,
   tipShape,
   walkDabs
-} from "../chunk-Z4BC6M74.js";
+} from "../chunk-UBIXVXPR.js";
 import {
   BLEND_MODES,
   PAINTERLY_BLEND_MODES,
@@ -536,21 +579,62 @@ import {
   translateSurface,
   uniformTile,
   writeRegion
-} from "../chunk-HNS7UHCM.js";
+} from "../chunk-XK5LZKBD.js";
+import {
+  BUILTIN_PROFILES,
+  CmsError,
+  GamutCheck,
+  INTENTS,
+  Transform,
+  builtinProfile,
+  builtinProfileId,
+  canBeDestination,
+  encodeProfile,
+  parseProfile,
+  sameColors,
+  srgbProfile,
+  writeJpegIcc,
+  writePngIcc
+} from "../chunk-BRLYOPLT.js";
 import {
+  ZlibError,
+  adler32,
+  deflate,
+  deflateRaw,
+  inflate,
+  inflateRaw
+} from "../chunk-6FCKOS2B.js";
+import {
+  DEFAULT_AUTO_LEADING,
+  DEFAULT_TEXT_STYLE,
   WARP_STYLES,
   WARP_STYLE_LABELS,
   applyMatrix,
   bezierToSubpaths,
+  caretAt,
+  createCanvasTextShaper,
+  createMetricTextShaper,
+  createOutlineTextShaper,
+  cssFont,
+  cssFontFamily,
   dragWarpMeshPoint,
   evalWarpMesh,
+  fitParagraphRuns,
+  fitRuns,
+  fontOf,
   identityWarpMesh,
   invertMatrix,
+  layoutText,
   multiplyMatrices,
+  paragraphRanges,
   pullWarpMesh,
   resizeWarpMesh,
+  restyleRange,
   rotateMatrix,
   roundSubpaths,
+  spliceRuns,
+  styleAt,
+  textIndexAt,
   translateMatrix,
   warpMeshColumns,
   warpMeshEditPoints,
@@ -558,7 +642,7 @@ import {
   warpMeshParamAt,
   warpMeshRows,
   warpPresetMesh
-} from "../chunk-BLWCAQCW.js";
+} from "../chunk-VXR7XWMF.js";
 import "../chunk-YCSFS3GK.js";
 import "../chunk-ZRJMJIQU.js";
 import "../chunk-TGD52FEZ.js";
@@ -913,6 +997,17 @@ var ImageEditorRenderer = class {
   /** Which path the last base render took. */
   lastBaseRoute = null;
   comp = null;
+  /** Colour transform from the document to the display (see `color-management`), or none. */
+  display = null;
+  displayKey = 0;
+  /** Sets the viewport's display transform (document profile → sRGB, or a soft proof); `null` for none. */
+  setDisplayTransform(t) {
+    if (t === this.display) return;
+    this.display = t;
+    this.displayKey++;
+    this.comp = null;
+    this.cachedBaseKey = "";
+  }
   depthMaps = /* @__PURE__ */ new Map();
   assetVersion = 0;
   scratch = null;
@@ -982,13 +1077,15 @@ var ImageEditorRenderer = class {
         `${projection.angle},${transform.flipH},${transform.flipV}`,
         `${adjustments.brightness},${adjustments.contrast},${adjustments.saturation},${adjustments.exposure},${adjustments.temperature},${adjustments.tint ?? 0},${adjustments.blur},${adjustments.opacity},p${normalizeProcessVersion(adjustments.process)}`,
         adjustmentLayersKey(adjustments.layers),
-        `${depthMask.enabled},${depthMask.maskSource},${depthMask.depthRange?.[0]}-${depthMask.depthRange?.[1]},${depthMask.softness},${depthMask.invert},${depthMask.mode}`
+        `${depthMask.enabled},${depthMask.maskSource},${depthMask.depthRange?.[0]}-${depthMask.depthRange?.[1]},${depthMask.softness},${depthMask.invert},${depthMask.mode}`,
+        `d${this.displayKey}`
       ].join("|");
       let baseCanvas = this.cachedBaseCanvas;
       if (!baseCanvas || this.cachedBaseKey !== baseKey) {
         let histogram = null;
         baseCanvas = await this.renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state, (pixels) => {
           histogram = computeHistogram(pixels);
+          this.display?.(pixels.data);
         });
         this.cachedBaseCanvas = baseCanvas;
         this.cachedBaseKey = baseKey;
@@ -1339,6 +1436,7 @@ var ImageEditorRenderer = class {
     if (x1 <= x0 || y1 <= y0) return;
     const img = ctx.createImageData(TILE, TILE);
     img.data.set(data);
+    this.display?.(img.data);
     ctx.putImageData(img, ox, oy, x0, y0, x1 - x0, y1 - y0);
   }
   /**
@@ -1381,7 +1479,7 @@ var ImageEditorRenderer = class {
     const rotated = getRotatedSize(region.width, region.height, transform);
     const baseW = Math.max(1, Math.round(rotated.width));
     const baseH = Math.max(1, Math.round(rotated.height));
-    const key = `${comp.version}|${region.x},${region.y},${region.width},${region.height}|${normalizeAngle(transform.rotate)},${transform.flipH},${transform.flipV}|${opacity}|${blur}`;
+    const key = `${this.displayKey}:${comp.version}|${region.x},${region.y},${region.width},${region.height}|${normalizeAngle(transform.rotate)},${transform.flipH},${transform.flipV}|${opacity}|${blur}`;
     if (this.cachedPostCanvas && this.cachedPostKey === key) return { canvas: this.cachedPostCanvas, histogram: this.cachedPostHistogram };
     const canvas = this.cachedPostCanvas && this.cachedPostCanvas.width === baseW && this.cachedPostCanvas.height === baseH ? this.cachedPostCanvas : this.createCanvas(baseW, baseH);
     const ctx = canvas.getContext("2d");
@@ -2518,159 +2616,6 @@ function refineSelection(pixels, mask, params = {}) {
   return createSelectionMask(mask.width, mask.height, out);
 }
 
-// src/image-editor/layers/text-shapers.ts
-var GENERIC = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "math", "emoji", "fangsong"]);
-function cssFontFamily(family) {
-  const f = family.trim();
-  if (GENERIC.has(f.toLowerCase()) || f.includes(",") || /^["']/.test(f)) return f;
-  return /^[A-Za-z_-][\w -]*$/.test(f) && !/\s{2}/.test(f) ? f : `"${f.replace(/"/g, '\\"')}"`;
-}
-function cssFont(font, family = font.family) {
-  return `${font.italic ? "italic " : ""}${font.weight} ${font.size}px ${cssFontFamily(family)}`;
-}
-function createCanvasTextShaper(options = {}) {
-  const make = options.createCanvas ?? ((w, h) => {
-    if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(w, h);
-    if (typeof document !== "undefined") {
-      const c = document.createElement("canvas");
-      c.width = w;
-      c.height = h;
-      return c;
-    }
-    return null;
-  });
-  const canvas = make(1, 1);
-  const ctx = canvas?.getContext("2d");
-  if (!ctx || typeof ctx.measureText !== "function") return null;
-  const fallback = options.fallbackFamily ?? "sans-serif";
-  const available = /* @__PURE__ */ new Map();
-  const widths = /* @__PURE__ */ new Map();
-  const metrics = /* @__PURE__ */ new Map();
-  const probe = "mmmmmmmmmmlli1WQ@#";
-  const width = (font, text) => {
-    ctx.font = font;
-    return ctx.measureText(text).width;
-  };
-  const isAvailable = (family) => {
-    const f = family.trim();
-    if (GENERIC.has(f.toLowerCase()) || f.includes(",")) return true;
-    let hit = available.get(f);
-    if (hit === void 0) {
-      const q = cssFontFamily(f);
-      hit = width(`72px ${q}, monospace`, probe) !== width("72px monospace", probe) || width(`72px ${q}, serif`, probe) !== width("72px serif", probe);
-      available.set(f, hit);
-    }
-    return hit;
-  };
-  return {
-    id: "canvas",
-    resolve(font) {
-      const ok = isAvailable(font.family);
-      return { family: ok ? font.family : fallback, available: ok };
-    },
-    metrics(font) {
-      const key = cssFont(font);
-      let m = metrics.get(key);
-      if (!m) {
-        ctx.font = key;
-        ctx.textBaseline = "alphabetic";
-        const t = ctx.measureText("Hg");
-        const ascent = t.emHeightAscent ?? t.fontBoundingBoxAscent ?? font.size * 0.8;
-        const descent = t.emHeightDescent ?? t.fontBoundingBoxDescent ?? font.size * 0.2;
-        m = { ascent: Number.isFinite(ascent) ? ascent : font.size * 0.8, descent: Number.isFinite(descent) ? descent : font.size * 0.2 };
-        metrics.set(key, m);
-      }
-      return m;
-    },
-    measure(text, font) {
-      const key = `${cssFont(font)}|${text}`;
-      let w = widths.get(key);
-      if (!w) {
-        ctx.font = cssFont(font);
-        w = [0];
-        for (let i = 1; i <= text.length; i++) w.push(ctx.measureText(text.slice(0, i)).width);
-        if (widths.size > 2e3) widths.clear();
-        widths.set(key, w);
-      }
-      return w;
-    },
-    draw(target, text, font, x, y) {
-      target.font = cssFont(font);
-      target.textBaseline = "alphabetic";
-      target.textAlign = "left";
-      target.fillText(text, x, y);
-    },
-    families() {
-      const out = /* @__PURE__ */ new Set(["sans-serif", "serif", "monospace"]);
-      const fonts = typeof document !== "undefined" ? document.fonts : void 0;
-      if (fonts && typeof fonts.forEach === "function") fonts.forEach((f) => out.add(f.family.replace(/^["']|["']$/g, "")));
-      return [...out];
-    }
-  };
-}
-function createOutlineTextShaper(fonts, options = {}) {
-  if (!fonts.length) throw new Error("createOutlineTextShaper needs at least one font.");
-  const entries = fonts.map((f) => {
-    const e = "face" in f ? f : { face: f };
-    const names = e.face.names;
-    const family = e.family ?? names?.fontFamily?.en ?? Object.values(names?.fontFamily ?? {})[0] ?? "Font";
-    const weight = e.weight ?? e.face.tables?.os2?.usWeightClass ?? 400;
-    const italic = e.italic ?? Boolean((e.face.tables?.os2?.fsSelection ?? 0) & 1);
-    const postScript = names?.postScriptName?.en ?? Object.values(names?.postScriptName ?? {})[0];
-    return { face: e.face, family, key: family.toLowerCase(), weight, italic, postScript };
-  });
-  const fallbackKey = (options.fallback ?? entries[0].family).toLowerCase();
-  const pick2 = (font) => {
-    if (font.postScriptName) {
-      const exact = entries.find((e) => e.postScript === font.postScriptName);
-      if (exact) return { entry: exact, available: true };
-    }
-    const key = font.family.trim().toLowerCase();
-    let pool = entries.filter((e) => e.key === key);
-    const available = pool.length > 0;
-    if (!available) pool = entries.filter((e) => e.key === fallbackKey);
-    if (!pool.length) pool = entries;
-    const styled = pool.filter((e) => e.italic === font.italic);
-    const list = styled.length ? styled : pool;
-    const entry = list.reduce((best, e) => Math.abs(e.weight - font.weight) < Math.abs(best.weight - font.weight) ? e : best);
-    return { entry, available };
-  };
-  const toPath = (cmds) => {
-    const out = [];
-    for (const c of cmds) {
-      if (c.type === "M" || c.type === "L") out.push({ type: c.type, x: c.x, y: c.y });
-      else if (c.type === "C") out.push({ type: "C", x1: c.x1, y1: c.y1, x2: c.x2, y2: c.y2, x: c.x, y: c.y });
-      else if (c.type === "Q") out.push({ type: "Q", x1: c.x1, y1: c.y1, x: c.x, y: c.y });
-      else out.push({ type: "Z" });
-    }
-    return out;
-  };
-  return {
-    id: options.id ?? `outline:${entries.map((e) => `${e.family}/${e.weight}${e.italic ? "i" : ""}`).join(",")}`,
-    resolve(font) {
-      const { entry, available } = pick2(font);
-      return { family: entry.family, available };
-    },
-    metrics(font) {
-      const { face } = pick2(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 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);
-    },
-    families() {
-      return [...new Set(entries.map((e) => e.family))];
-    }
-  };
-}
-
 // src/image-editor/free-transform.ts
 var FREE_TRANSFORM_CONTENTS = ["auto", "layer", "selection", "selection-copy", "selection-outline"];
 var fail = (message) => {
@@ -3151,8 +3096,146 @@ var FreeTransformSession = class {
   }
 };
 
+// src/image-editor/color-management.ts
+var DEFAULT_PROOF = { intent: "relative", bpc: true, simulatePaper: false, gamutWarning: false };
+var resolved = /* @__PURE__ */ new WeakMap();
+var fromBytes = /* @__PURE__ */ new Map();
+function resolveProfile(doc) {
+  if (!doc) return srgbProfile();
+  const hit = resolved.get(doc);
+  if (hit) return hit;
+  let p;
+  if (doc.builtin) p = builtinProfile(doc.builtin);
+  else if (doc.icc) {
+    const key = bytesToBase64(doc.icc);
+    p = fromBytes.get(key) ?? parseProfile(doc.icc);
+    if (fromBytes.size > 32) fromBytes.clear();
+    fromBytes.set(key, p);
+  } else p = srgbProfile();
+  resolved.set(doc, p);
+  return p;
+}
+function profileBytes(doc) {
+  if (doc?.icc) return doc.icc;
+  const p = resolveProfile(doc);
+  return p.bytes ?? encodeProfile(p);
+}
+function documentProfile(input) {
+  if (typeof input === "string") {
+    const id = builtinProfileId(input);
+    if (!id) throw new CmsError(`Unknown colour profile "${input}"; use one of ${BUILTIN_PROFILES.map((b) => b.id).join(", ")}, or ICC bytes.`);
+    return { builtin: id, name: BUILTIN_PROFILES.find((b) => b.id === id).description };
+  }
+  const p = parseProfile(input);
+  return { name: p.description || "Embedded profile", icc: input.slice() };
+}
+function isSrgb(doc) {
+  if (!doc || doc.builtin === "srgb") return true;
+  try {
+    return sameColors(resolveProfile(doc), srgbProfile(), builtinProfile("lab-d50"));
+  } catch {
+    return false;
+  }
+}
+function serializeColorProfile(doc) {
+  return doc.builtin ? { builtin: doc.builtin, name: doc.name } : { name: doc.name, icc: bytesToBase64(doc.icc ?? new Uint8Array(0)) };
+}
+function deserializeColorProfile(raw, problems) {
+  const r = raw;
+  if (!r || typeof r !== "object") return null;
+  try {
+    if (r.builtin) {
+      const id = builtinProfileId(r.builtin);
+      if (!id) throw new CmsError(`unknown built-in profile "${r.builtin}"`);
+      return documentProfile(id);
+    }
+    if (typeof r.icc === "string") {
+      const icc = base64ToBytes(r.icc);
+      parseProfile(icc);
+      return { name: typeof r.name === "string" ? r.name : "Embedded profile", icc };
+    }
+  } catch (e) {
+    problems.push(`The colour profile could not be read (${e instanceof Error ? e.message : String(e)}); the document is treated as sRGB`);
+  }
+  return null;
+}
+function displayTransform(doc, proof) {
+  const src = resolveProfile(doc);
+  const display = srgbProfile();
+  let t = null;
+  let gamut = null;
+  if (proof) {
+    const p = resolveProfile(proof.profile);
+    t = Transform.proof(src, p, display, proof.intent, proof.bpc, proof.simulatePaper);
+    if (proof.gamutWarning) gamut = new GamutCheck(src, p, builtinProfile("lab-d50"));
+  } else if (!isSrgb(doc)) t = Transform.create(src, display, { intent: "relative", bpc: true });
+  if (!t) return null;
+  const tr = t;
+  const g = gamut;
+  return (rgba) => {
+    if (g) {
+      const px2 = [0, 0, 0];
+      const flags = new Uint8Array(rgba.length >> 2);
+      for (let i = 0, p = 0; i < rgba.length; i += 4, p++) {
+        if (rgba[i + 3] === 0) continue;
+        px2[0] = rgba[i] / 255;
+        px2[1] = rgba[i + 1] / 255;
+        px2[2] = rgba[i + 2] / 255;
+        if (g.outOfGamut(px2)) flags[p] = 1;
+      }
+      tr.convert8(rgba, 4, rgba, 4);
+      for (let i = 0, p = 0; i < rgba.length; i += 4, p++) if (flags[p]) rgba[i] = rgba[i + 1] = rgba[i + 2] = 128;
+      return;
+    }
+    tr.convert8(rgba, 4, rgba, 4);
+  };
+}
+function convertHex(hex, from, to, intent = "relative", bpc = true) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return hex;
+  const n = parseInt(m[1], 16);
+  const out = new Float32Array(4);
+  Transform.create(from, to, { intent, bpc }).eval([(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255], out);
+  const c = (v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0");
+  return `#${c(out[0])}${c(out[1])}${c(out[2])}`;
+}
+function convertSurfaceColors(surface, t) {
+  if (surface.channels !== 4 || t.inputs !== 3 || t.outputs !== 3) return surface;
+  const tiles = /* @__PURE__ */ new Map();
+  const memo = /* @__PURE__ */ new Map();
+  for (const [key, tile] of surface.tiles) {
+    let next = memo.get(tile);
+    if (next === void 0) {
+      if (tile.deep instanceof Uint16Array) {
+        const out = new Uint16Array(tile.deep.length);
+        t.convert16(tile.deep, 4, out, 4);
+        next = deepTile(out, 4, surface.defaultValue);
+      } else if (tile.deep instanceof Float32Array) {
+        const enc = new Float32Array(tile.deep.length);
+        for (let i = 0; i < enc.length; i += 4) {
+          for (let c = 0; c < 3; c++) enc[i + c] = srgbEncode(tile.deep[i + c]);
+          enc[i + 3] = tile.deep[i + 3];
+        }
+        t.convertFloat(enc, 4, enc, 4);
+        for (let i = 0; i < enc.length; i += 4) for (let c = 0; c < 3; c++) enc[i + c] = srgbDecode(enc[i + c]);
+        next = deepTile(enc, 4, surface.defaultValue);
+      } else {
+        const out = new Uint8ClampedArray(tile.data.length);
+        t.convert8(tile.data, 4, out, 4);
+        next = finishTile(out, 4, surface.defaultValue);
+      }
+      memo.set(tile, next);
+    }
+    if (next) tiles.set(key, next);
+  }
+  return new TiledSurface(4, tiles, surface.defaultValue);
+}
+
 // 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();
@@ -3186,6 +3269,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());
@@ -3202,10 +3297,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;
@@ -3232,8 +3337,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;
@@ -3257,7 +3368,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);
@@ -3266,9 +3377,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) {
@@ -3280,11 +3404,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. */
@@ -3423,7 +3548,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) {
@@ -3518,10 +3643,23 @@ var ImageEditorController = class {
     if (strokeRects && this.pendingDirty !== "all") this.pendingDirty.push(...strokeRects);
     else if (!strokeRects) this.pendingDirty = "all";
     this.syncViews();
+    this.syncDisplay();
     const currentState = { ...this.state };
     this.onStateChange?.(currentState);
     this.listeners.forEach((l) => l(currentState));
   }
+  displayFor = null;
+  /** Keeps the renderer's display transform in step with the document profile and Proof Setup. */
+  syncDisplay() {
+    const s = this.state;
+    if (this.displayFor && this.displayFor[0] === s.colorProfile && this.displayFor[1] === s.proofSetup) return;
+    this.displayFor = [s.colorProfile, s.proofSetup];
+    try {
+      this.renderer.setDisplayTransform(displayTransform(s.colorProfile, s.proofSetup));
+    } catch {
+      this.renderer.setDisplayTransform(null);
+    }
+  }
   /** Recomputes the compatibility views (`adjustments`, `depthMask`, `annotations`) when the stack changed. */
   syncViews() {
     const s = this.state;
@@ -3559,6 +3697,8 @@ var ImageEditorController = class {
     if (s.legacyOutputBlur !== void 0) entry.legacyOutputBlur = s.legacyOutputBlur;
     if (s.globalLight) entry.globalLight = { ...s.globalLight };
     if (s.patterns) entry.patterns = s.patterns;
+    if (s.colorProfile) entry.colorProfile = s.colorProfile;
+    if (s.bitDepth && s.bitDepth !== 8) entry.bitDepth = s.bitDepth;
     return entry;
   }
   restoreHistoryEntry(entry) {
@@ -3575,6 +3715,10 @@ var ImageEditorController = class {
     else delete s.globalLight;
     if (entry.patterns) s.patterns = entry.patterns;
     else delete s.patterns;
+    if (entry.bitDepth) s.bitDepth = entry.bitDepth;
+    else delete s.bitDepth;
+    if (entry.colorProfile) s.colorProfile = entry.colorProfile;
+    else delete s.colorProfile;
     s.selection = entry.selection;
     if (this.imageElement !== entry.source.element && !this.samplePixelsOverride) this.samplePixels = null;
     this.imageElement = entry.source.element;
@@ -4858,9 +5002,28 @@ var ImageEditorController = class {
       throw new LayerOperationError("Merging annotation layers needs a canvas (a browser); hide or delete them first, or merge in the browser.");
     }
     await this.renderer.prepareLayerAssets(layers, width, height);
-    const data = new LayerCompositor().composite(layers, rect, this.renderer.compositorSources(width, height));
+    const sources = this.renderer.compositorSources(width, height);
+    const depth = this.bitDepth;
+    if (depth !== 8) {
+      const samples = workingToSamples(compositeDeep(layers, rect, sources, depth), depth);
+      return surfaceFromDeepPixels({ width: rect.width, height: rect.height, data: samples }, 4, rect.x, rect.y);
+    }
+    const data = new LayerCompositor().composite(layers, rect, sources);
     return surfaceFromPixels({ width: rect.width, height: rect.height, data }, 4, rect.x, rect.y);
   }
+  /**
+   * The composite of the layer stack at the document's bit depth (as `compositePixels`, no
+   * canvas): 16-bit sRGB samples, or 32-bit linear float, over `rect` (default the canvas). At 8
+   * bits, the 8-bit composite widened to 16 bits.
+   */
+  compositeDeepPixels(rect) {
+    const { width, height } = this.naturalSize;
+    const r = rect ?? { x: 0, y: 0, width, height };
+    const depth = this.bitDepth;
+    if (depth === 8) return { width: r.width, height: r.height, depth: 16, data: to16From8(this.compositePixels(r).data) };
+    const data = workingToSamples(compositeDeep(this.state.layers, r, this.compositorSources(), depth), depth);
+    return { width: r.width, height: r.height, depth, data };
+  }
   /** Document bounds a layer can paint into (pixel content, annotations, or the canvas for the rest). */
   paintBounds(layer) {
     const { width, height } = this.naturalSize;
@@ -5018,12 +5181,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();
@@ -5053,6 +5220,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" });
@@ -5107,8 +5285,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.");
     }
@@ -5130,8 +5308,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 ?? {} });
@@ -5955,16 +6226,37 @@ var ImageEditorController = class {
     const canvas = await this.renderExport(options);
     const format = options.format || "image/png";
     const quality = options.quality ?? 0.92;
-    return canvas.toDataURL(format, quality);
+    const url = canvas.toDataURL(format, quality);
+    if (!this.state.colorProfile) return url;
+    const parsed = parseDataUrl(url);
+    if (!parsed) return url;
+    const bytes = this.withEmbeddedProfile(parsed.bytes, parsed.mime);
+    return bytes === parsed.bytes ? url : `data:${parsed.mime};base64,${bytesToBase64(bytes)}`;
+  }
+  /** PNG or JPEG bytes with the document's ICC profile embedded (other formats unchanged). */
+  withEmbeddedProfile(bytes, mime) {
+    const icc = profileBytes(this.state.colorProfile);
+    try {
+      if (mime === "image/png") return writePngIcc(bytes, icc, this.getColorProfile().name);
+      if (mime === "image/jpeg") return writeJpegIcc(bytes, icc);
+    } catch {
+    }
+    return bytes;
   }
   async toBlob(options = {}) {
     const canvas = await this.renderExport(options);
     const format = options.format || "image/png";
     const quality = options.quality ?? 0.92;
+    const tag = async (blob) => {
+      if (!this.state.colorProfile || typeof blob.arrayBuffer !== "function") return blob;
+      const bytes = new Uint8Array(await blob.arrayBuffer());
+      const out = this.withEmbeddedProfile(bytes, blob.type || format);
+      return out === bytes ? blob : new Blob([out], { type: blob.type || format });
+    };
     return new Promise((resolve, reject) => {
       if (canvas.toBlob) {
         canvas.toBlob((blob) => {
-          if (blob) resolve(blob);
+          if (blob) tag(blob).then(resolve, reject);
           else reject(new Error("Failed to create Blob from canvas"));
         }, format, quality);
       } else {
@@ -5977,7 +6269,7 @@ var ImageEditorController = class {
           for (let i = 0; i < byteStr.length; i++) {
             ia[i] = byteStr.charCodeAt(i);
           }
-          resolve(new Blob([ab], { type: format }));
+          tag(new Blob([ab], { type: format })).then(resolve, reject);
         } catch (err) {
           reject(err);
         }
@@ -6497,6 +6789,162 @@ var ImageEditorController = class {
     return id;
   }
   // --- PSD ---
+  // --- Colour management ---
+  /** The document's colour profile: its name, built-in id (or `null` for an embedded profile) and colour space. */
+  getColorProfile() {
+    const doc = this.state.colorProfile;
+    const p = resolveProfile(doc);
+    return { name: doc?.name ?? p.description, builtin: doc ? doc.builtin ?? null : "srgb", colorSpace: p.colorSpace, srgb: isSrgb(doc) };
+  }
+  /** Resolves a profile argument (built-in id or alias, or ICC bytes) as an RGB document profile. */
+  rgbProfileArg(profile, action) {
+    let doc;
+    try {
+      doc = documentProfile(profile);
+    } catch (e) {
+      throw new LayerOperationError(e instanceof Error ? e.message : String(e));
+    }
+    const cs = resolveProfile(doc).colorSpace;
+    if (cs !== "rgb") throw new LayerOperationError(`${action} needs an RGB profile; "${doc.name}" is ${cs.toUpperCase()}. The document is RGB: soft-proof CMYK with set_proof_setup, or export to it.`);
+    return doc;
+  }
+  /**
+   * Edit › Assign Profile (one undo step): the document's numbers now mean colours in
+   * `profile` (a built-in id such as `display-p3`, or ICC bytes); no pixel changes, so colours
+   * look different unless the profiles match. Returns the new profile.
+   */
+  assignProfile(profile) {
+    const doc = this.rgbProfileArg(profile, "Assign Profile");
+    this.recordHistory();
+    if (doc.builtin === "srgb") delete this.state.colorProfile;
+    else this.state.colorProfile = doc;
+    this.notify();
+    return this.getColorProfile();
+  }
+  /**
+   * Edit › Convert to Profile (one undo step): every pixel layer's numbers are converted so its
+   * colours stay the same in `profile` (with `intent` and black point compensation), and
+   * `profile` becomes the document's. Shape and type layers, layer effects and adjustment layers
+   * keep their numbers (they are listed in `unconvertedLayerIds`). Returns the profile and the
+   * layers changed.
+   */
+  convertToProfile(profile, options = {}) {
+    const doc = this.rgbProfileArg(profile, "Convert to Profile");
+    const intent = options.intent ?? "relative";
+    if (!INTENTS.includes(intent)) throw new LayerOperationError(`Unknown rendering intent "${String(intent)}"; use ${INTENTS.join(", ")}.`);
+    const t = Transform.create(resolveProfile(this.state.colorProfile), resolveProfile(doc), { intent, bpc: options.bpc ?? true });
+    const converted = [];
+    const unconverted = [];
+    const walk = (layers) => layers.map((l) => {
+      if (l.type === "group") return { ...l, children: walk(l.children) };
+      if (l.type === "pixel" && l.source !== "document") {
+        converted.push(l.id);
+        return { ...l, surface: convertSurfaceColors(l.surface, t) };
+      }
+      if (l.type === "pixel" && l.source === "document") {
+        converted.push(l.id);
+        return { ...l, surface: convertSurfaceColors(this.surfaceOf(l), t), source: void 0 };
+      }
+      if (l.type === "shape" || l.type === "type" || l.type === "smart" || l.effects?.items.length) unconverted.push(l.id);
+      return l;
+    });
+    const next = walk(this.state.layers);
+    this.commitLayers(next, () => {
+      if (doc.builtin === "srgb") delete this.state.colorProfile;
+      else this.state.colorProfile = doc;
+    });
+    return { profile: this.getColorProfile(), convertedLayerIds: converted, unconvertedLayerIds: unconverted };
+  }
+  /**
+   * View › Proof Setup (view state, not an undo step): shows the document as `profile` would
+   * reproduce it, or turns proofing off with `null`. Returns the setup.
+   */
+  setProofSetup(setup) {
+    if (!setup) {
+      this.state.proofSetup = null;
+      this.notify();
+      return null;
+    }
+    let doc;
+    try {
+      doc = documentProfile(setup.profile);
+    } catch (e) {
+      throw new LayerOperationError(e instanceof Error ? e.message : String(e));
+    }
+    const intent = setup.intent ?? DEFAULT_PROOF.intent;
+    if (!INTENTS.includes(intent)) throw new LayerOperationError(`Unknown rendering intent "${String(intent)}"; use ${INTENTS.join(", ")}.`);
+    const next = { ...DEFAULT_PROOF, ...setup, intent, profile: doc };
+    if (!canBeDestination(resolveProfile(doc))) throw new LayerOperationError(`"${doc.name}" describes a source only, so colours cannot be proofed through it.`);
+    this.state.proofSetup = next;
+    this.notify();
+    return next;
+  }
+  /**
+   * Converts colours (`#rrggbb`) from one profile to another (default from the document's), with
+   * `intent`. For RGB targets returns hex; for others the channel values 0..1 (CMYK, grey, Lab
+   * encoded as L/100, (a+128)/255, (b+128)/255) and, for Lab, L*a*b*.
+   */
+  convertColors(colors, to, options = {}) {
+    let src;
+    let dst;
+    try {
+      src = options.from !== void 0 ? resolveProfile(documentProfile(options.from)) : resolveProfile(this.state.colorProfile);
+      dst = resolveProfile(documentProfile(to));
+    } catch (e) {
+      throw new LayerOperationError(e instanceof Error ? e.message : String(e));
+    }
+    if (src.colorSpace !== "rgb") throw new LayerOperationError("Colours are given as #rrggbb, so the source profile must be RGB.");
+    const t = Transform.create(src, dst, { intent: options.intent ?? "relative", bpc: options.bpc ?? true });
+    const toLab = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
+    return colors.map((input) => {
+      const m = /^#?([0-9a-f]{6})$/i.exec(input.trim());
+      if (!m) throw new LayerOperationError(`Invalid colour "${input}"; use #rrggbb.`);
+      const n = parseInt(m[1], 16);
+      const rgb = [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+      const out = new Float32Array(16);
+      t.eval(rgb, out);
+      const values = Array.from(out.subarray(0, t.outputs), (v) => Math.round(Math.min(1, Math.max(0, v)) * 1e4) / 1e4);
+      const l = new Float32Array(3);
+      toLab.eval(rgb, l);
+      const lab = [Math.round(l[0] * 1e4) / 100, Math.round((l[1] * 255 - 128) * 100) / 100, Math.round((l[2] * 255 - 128) * 100) / 100];
+      const res = { input, values, lab };
+      if (dst.colorSpace === "rgb") res.hex = `#${values.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("")}`;
+      return res;
+    });
+  }
+  /** The document's bits per channel (8 unless set to 16 or 32). */
+  get bitDepth() {
+    return this.state.bitDepth ?? 8;
+  }
+  /**
+   * Image › Mode › 8 / 16 / 32 Bits/Channel (one undo step). Going up costs nothing: layers keep
+   * their pixels and read them at the new depth, and edits that understand depth keep the extra
+   * precision from then on. Going down rounds every pixel layer's deep samples to the new depth
+   * (8 bits: their 8-bit rendering; 32 → 16: colour above 1 is clipped). Returns the depth and
+   * the ids of the layers whose pixels changed.
+   */
+  setBitDepth(depth) {
+    if (!isBitDepth(depth)) throw new LayerOperationError(`Bit depth must be 8, 16 or 32, not ${String(depth)}.`);
+    const changed = [];
+    const convert = (layers) => layers.map((l) => {
+      if (l.type === "group") {
+        const children = convert(l.children);
+        return children.some((c, i) => c !== l.children[i]) ? { ...l, children } : l;
+      }
+      if (l.type !== "pixel") return l;
+      const surface = convertSurfaceDepth(l.surface, depth);
+      if (surface === l.surface) return l;
+      changed.push(l.id);
+      return { ...l, surface };
+    });
+    if (depth === this.bitDepth) return { bitDepth: depth, changedLayerIds: [] };
+    const next = convert(this.state.layers);
+    this.commitLayers(next, () => {
+      if (depth === 8) delete this.state.bitDepth;
+      else this.state.bitDepth = depth;
+    });
+    return { bitDepth: depth, changedLayerIds: changed };
+  }
   /** Pixels per inch of the last opened PSD (written back by `toPsd`). */
   psdResolution;
   /**
@@ -6529,6 +6977,20 @@ var ImageEditorController = class {
     else delete s.patterns;
     if (result.globalLight) s.globalLight = result.globalLight;
     else delete s.globalLight;
+    if (result.bitDepth !== 8) s.bitDepth = result.bitDepth;
+    else delete s.bitDepth;
+    delete s.colorProfile;
+    if (result.iccProfile) {
+      try {
+        const doc = documentProfile(result.iccProfile);
+        const cs = resolveProfile(doc).colorSpace;
+        if (cs === "rgb") {
+          if (!isSrgb(doc)) s.colorProfile = doc;
+        } else result.warnings.push(`The file's ${cs.toUpperCase()} profile "${doc.name}" was not used; its colours were converted to sRGB numerically.`);
+      } catch (e) {
+        result.warnings.push(`The embedded ICC profile could not be read (${e instanceof Error ? e.message : String(e)}); colours are read as sRGB.`);
+      }
+    }
     this.lastLoadProblems = result.warnings;
     this.notify();
     return {
@@ -6564,7 +7026,7 @@ var ImageEditorController = class {
     return layers;
   }
   /**
-   * The document as an 8-bit RGB PSD (PSB above 30 000 px) with real layers, groups, adjustment
+   * The document as an RGB PSD at its bit depth (8, 16 or 32) (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
    * into pixels and masks, annotation layers are rasterized (in a browser; elsewhere they are left
    * out), and the merged image is our composite. `warnings` lists every such change.
@@ -6690,7 +7152,9 @@ var ImageEditorController = class {
     if (s.legacyOutputBlur) warnings.push("The document-level blur of an old document is not written.");
     for (const [msg, names] of note) warnings.push(`${msg} (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).`);
     const merged = compositor.composite(prepared, canvas, { ...sources, version: `psd:${Date.now()}` });
-    const result = exportPsd({ width, height, layers: prepared, merged, resolution: this.psdResolution, patterns: this.state.patterns, globalLight: this.state.globalLight });
+    const depth = this.bitDepth;
+    const mergedDeep = depth === 8 ? void 0 : workingToSamples(compositeDeep(prepared, canvas, sources, depth), depth);
+    const result = exportPsd({ width, height, layers: prepared, merged, mergedDeep, resolution: this.psdResolution, patterns: this.state.patterns, globalLight: this.state.globalLight, depth, iccProfile: profileBytes(this.state.colorProfile) });
     warnings.push(...result.warnings);
     return { bytes: result.bytes, warnings, psb: result.psb, width, height };
   }
@@ -6836,6 +7300,11 @@ var ImageEditorController = class {
       const patterns = deserializePatterns(data.patterns, problems);
       if (patterns.length) s.patterns = patterns;
       else delete s.patterns;
+      if (data.bitDepth === 16 || data.bitDepth === 32) s.bitDepth = data.bitDepth;
+      else delete s.bitDepth;
+      const profile = data.colorProfile ? deserializeColorProfile(data.colorProfile, problems) : null;
+      if (profile) s.colorProfile = profile;
+      else delete s.colorProfile;
       if (!this.imageElement && typeof data.width === "number" && typeof data.height === "number" && data.width > 0 && data.height > 0) {
         s.imageDimensions = { width: data.width, height: data.height };
       }
@@ -6851,6 +7320,8 @@ var ImageEditorController = class {
       s.activeLayerId = null;
       delete s.globalLight;
       delete s.patterns;
+      delete s.bitDepth;
+      delete s.colorProfile;
     }
     s.activeTarget = "pixels";
     this.viewKey = [];
@@ -6860,7 +7331,7 @@ var ImageEditorController = class {
   serializeState() {
     const { width, height } = this.naturalSize;
     const view = legacyView(this.stack(), width, height, null);
-    if (view.exact && !this.state.globalLight && !this.state.patterns?.length) {
+    if (view.exact && !this.state.globalLight && !this.state.patterns?.length && this.bitDepth === 8 && !this.state.colorProfile) {
       return {
         // States without adjustment layers keep schema 1, so they round-trip unchanged.
         version: view.adjustments.layers?.length ? 2 : 1,
@@ -6890,6 +7361,8 @@ var ImageEditorController = class {
     if (this.state.globalLight) out.globalLight = { ...this.state.globalLight };
     if (this.state.patterns?.length) out.patterns = serializePatterns(this.state.patterns);
     if (smartContents) out.smartContents = smartContents;
+    if (this.state.bitDepth === 16 || this.state.bitDepth === 32) out.bitDepth = this.state.bitDepth;
+    if (this.state.colorProfile) out.colorProfile = serializeColorProfile(this.state.colorProfile);
     return out;
   }
 };
@@ -7033,6 +7506,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) {
@@ -8077,10 +8571,23 @@ function createImageEditTools(controller) {
   const getImageInfo = {
     name: "get_image_info",
     title: "Read image geometry",
-    description: "Returns the source image size in pixels, the crop box (natural image pixels, or null for the whole image), rotation in degrees, flips, the output size after crop and rotation, the number of adjustment layers and whether undo / redo are available.",
+    description: "Returns the source image size in pixels, the crop box (natural image pixels, or null for the whole image), rotation in degrees, flips, the output size after crop and rotation, the bits per channel (bitDepth 8, 16 or 32), the number of adjustment layers and whether undo / redo are available.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     annotations: { title: "Read image geometry", ...READ },
-    handler: () => ({ ...geometry2(), layers: controller.getAdjustmentLayers().length, ...history() })
+    handler: () => ({ ...geometry2(), bitDepth: controller.bitDepth, layers: controller.getAdjustmentLayers().length, ...history() })
+  };
+  const setBitDepth = {
+    name: "set_bit_depth",
+    title: "Set the bit depth",
+    description: "Image \u203A Mode \u203A 8 / 16 / 32 Bits/Channel. 16-bit keeps smooth gradients and survives strong adjustments without banding; 32-bit holds linear-light float values (HDR, colour above 1). Going up costs nothing and changes no pixels; going down rounds every pixel layer's extra precision away (32 \u2192 16 also clips colour above 1). The viewport always shows an 8-bit rendering. One undo step. Returns the bitDepth and changedLayerIds (the layers whose samples were rounded).",
+    inputSchema: {
+      type: "object",
+      properties: { depth: { type: "number", enum: [8, 16, 32], description: "Bits per channel: 8, 16 or 32 (float, linear light)." } },
+      required: ["depth"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set the bit depth", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    handler: (args) => ({ ...controller.setBitDepth(args.depth), ...history() })
   };
   const getHistogram = {
     name: "get_histogram",
@@ -8256,7 +8763,7 @@ function createImageEditTools(controller) {
       return history();
     }
   };
-  return [getImageInfo, getHistogram, updateLayer, removeLayer2, moveLayer2, setCrop, resetCrop, setRotation, flipImage, undo, redo];
+  return [getImageInfo, getHistogram, updateLayer, removeLayer2, moveLayer2, setCrop, resetCrop, setRotation, flipImage, setBitDepth, undo, redo];
 }
 
 // src/image-editor/layer-tools.ts
@@ -9175,9 +9682,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 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"] }
 ];
-var isPaintTool = (tool) => tool === "move" || tool === "brush" || tool === "mixer" || tool === "eraser";
+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("")}`;
 }
@@ -9203,6 +9774,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;
@@ -9258,9 +9841,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) {
@@ -9491,8 +10078,396 @@ function createImagePaintTools(controller) {
   return [paintStroke, fill, clear, getMixer, loadMixerTool, cleanMixerTool];
 }
 
-// src/image-editor/psd-tools.ts
+// src/image-editor/color-tools.ts
 var READ5 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var PROFILE = {
+  type: "string",
+  description: `A built-in profile id (${BUILTIN_PROFILES.map((b) => b.id).join(", ")}; names like "Adobe RGB (1998)" work too), or "icc:<base64>" for ICC profile bytes.`
+};
+var INTENT = {
+  type: "string",
+  enum: [...INTENTS],
+  description: "Rendering intent (default relative): relative (colorimetric, white to white, clips out-of-gamut colours: best for most photos), perceptual (compresses the whole gamut smoothly), saturation (keeps colours vivid, for graphics), absolute (keeps the source white too: for proofing a paper colour)."
+};
+function profileArg(v) {
+  const s = String(v);
+  if (s.startsWith("icc:")) {
+    try {
+      return base64ToBytes(s.slice(4));
+    } catch {
+      throw new LayerOperationError("The icc: value is not valid base64.");
+    }
+  }
+  return s;
+}
+function createImageColorTools(controller) {
+  const getProfile = {
+    name: "get_color_profile",
+    title: "Get the colour profile",
+    description: "Reads the document's colour profile (its working space: name, builtin id or null for an embedded profile, colorSpace, srgb true when it means sRGB), the Proof Setup (profile, intent, bpc, simulatePaper, gamutWarning, or null) and the built-in profiles you can assign, convert to or proof with ({id, description, colorSpace}).",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Get the colour profile", ...READ5 },
+    handler: () => {
+      const proof2 = controller.getState().proofSetup;
+      return {
+        profile: controller.getColorProfile(),
+        proof: proof2 ? { profile: proof2.profile.name, builtin: proof2.profile.builtin ?? null, intent: proof2.intent, bpc: proof2.bpc, simulatePaper: proof2.simulatePaper, gamutWarning: proof2.gamutWarning } : null,
+        builtins: BUILTIN_PROFILES.map((b) => ({ ...b }))
+      };
+    }
+  };
+  const assign = {
+    name: "assign_profile",
+    title: "Assign a colour profile",
+    description: "Edit \u203A Assign Profile: the document's RGB numbers now mean colours in `profile`; no pixel changes, so the image looks different unless the profiles match. Use it when a file was saved without its profile, or with the wrong one. To keep the look and change the numbers, use convert_to_profile. RGB profiles only. One undo step. Returns the new profile.",
+    inputSchema: { type: "object", properties: { profile: PROFILE }, required: ["profile"], additionalProperties: false },
+    annotations: { title: "Assign a colour profile", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: (args) => controller.assignProfile(profileArg(args.profile))
+  };
+  const convert = {
+    name: "convert_to_profile",
+    title: "Convert to a colour profile",
+    description: "Edit \u203A Convert to Profile: converts every pixel layer's numbers so its colours stay the same in `profile`, then makes `profile` the document's. Colours outside the new space are mapped by `intent`. Shape and type layers, layer effects and smart objects keep their numbers and are listed in unconvertedLayerIds. RGB profiles only (proof CMYK with set_proof_setup). One undo step. Returns the profile, convertedLayerIds and unconvertedLayerIds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        profile: PROFILE,
+        intent: INTENT,
+        bpc: { type: "boolean", description: "Black point compensation: map black to black (default true)." }
+      },
+      required: ["profile"],
+      additionalProperties: false
+    },
+    annotations: { title: "Convert to a colour profile", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: (args) => controller.convertToProfile(profileArg(args.profile), { intent: args.intent, bpc: args.bpc })
+  };
+  const proof = {
+    name: "set_proof_setup",
+    title: "Set up soft proofing",
+    description: "View \u203A Proof Setup: shows the document in the viewport as `profile` would reproduce it (for example coated-cmyk for a press), with `intent`; `simulatePaper` shows the paper white and ink black; `gamutWarning` greys out colours the profile cannot reproduce. Pass off true to stop proofing. View state, not an undo step; pixels never change. Check the result with capture_view. Returns the setup (or null).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        profile: PROFILE,
+        intent: INTENT,
+        bpc: { type: "boolean", description: "Black point compensation (default true)." },
+        simulatePaper: { type: "boolean", description: "Simulate paper colour and black ink (default false)." },
+        gamutWarning: { type: "boolean", description: "Grey out out-of-gamut colours (default false)." },
+        off: { type: "boolean", description: "Turn proofing off instead (default false)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Set up soft proofing", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: (args) => {
+      if (args.off === true) {
+        if (args.profile !== void 0) throw new LayerOperationError("Give either off true or a profile, not both.");
+        return controller.setProofSetup(null);
+      }
+      if (args.profile === void 0) throw new LayerOperationError("Pass the profile to proof with (e.g. coated-cmyk), or off true.");
+      const s = controller.setProofSetup({
+        profile: profileArg(args.profile),
+        ...args.intent !== void 0 ? { intent: args.intent } : {},
+        ...args.bpc !== void 0 ? { bpc: args.bpc } : {},
+        ...args.simulatePaper !== void 0 ? { simulatePaper: args.simulatePaper } : {},
+        ...args.gamutWarning !== void 0 ? { gamutWarning: args.gamutWarning } : {}
+      });
+      return { profile: s.profile.name, builtin: s.profile.builtin ?? null, intent: s.intent, bpc: s.bpc, simulatePaper: s.simulatePaper, gamutWarning: s.gamutWarning };
+    }
+  };
+  const convertColors = {
+    name: "convert_colors",
+    title: "Convert colours between profiles",
+    description: 'Converts 1 to 64 #rrggbb colours from the document\'s profile (or `from`) into `to` with `intent`: returns per colour the channel values 0..1 (RGB, CMYK, grey; Lab as L/100, (a+128)/255, (b+128)/255), a hex for RGB targets, and L*a*b* (D50). Use it to answer "what are these CMYK values" or to pick colours that survive printing. Changes nothing.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        colors: { type: "array", minItems: 1, maxItems: 64, items: { type: "string", description: "A colour #rrggbb." }, description: "Colours in the source profile." },
+        to: PROFILE,
+        from: { ...PROFILE, description: `Source profile (default the document's). ${PROFILE.description}` },
+        intent: INTENT,
+        bpc: { type: "boolean", description: "Black point compensation (default true)." }
+      },
+      required: ["colors", "to"],
+      additionalProperties: false
+    },
+    annotations: { title: "Convert colours between profiles", ...READ5 },
+    handler: (args) => ({
+      colors: controller.convertColors(args.colors, profileArg(args.to), {
+        ...args.from !== void 0 ? { from: profileArg(args.from) } : {},
+        intent: args.intent,
+        bpc: args.bpc
+      })
+    })
+  };
+  return [getProfile, assign, convert, proof, convertColors];
+}
+
+// src/image-editor/retouch-tools.ts
+var READ6 = { 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", ...READ6 },
+    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 READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var DATA = {
   type: "string",
@@ -9513,7 +10488,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", ...READ7 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -9548,9 +10523,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). 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.",
+    description: "Writes the document as an RGB PSD at its bit depth (8, 16 or 32; see set_bit_depth; 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", ...READ7 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -9568,8 +10543,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 READ8 = { 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 = {
@@ -9578,7 +10553,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",
@@ -9660,15 +10635,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", ...READ8 },
     handler: (args) => {
       const init = targetFrom(args);
       if (init.content === "selection-copy") init.content = "selection";
@@ -9698,10 +10673,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 = {
@@ -9711,7 +10686,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)." },
@@ -9731,7 +10706,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.");
@@ -9762,10 +10737,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 };
@@ -9779,14 +10754,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 = {
@@ -9797,22 +10772,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 READ9 = { 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;
@@ -9870,7 +10845,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", ...READ9 },
     handler: ({ layerId }) => info(smartId(layerId))
   };
   const convert = {
@@ -9885,7 +10860,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 });
@@ -10004,7 +10979,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", ...READ9 },
     handler: ({ layerId }) => {
       const f = controller.exportSmartObjectContents(smartId(layerId));
       return { name: f.name, mimeType: f.mimeType, byteLength: f.bytes.length, base64: bytesToBase64(f.bytes) };
@@ -10024,7 +10999,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 };
@@ -10035,7 +11010,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();
@@ -10051,7 +11026,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 = {
@@ -10069,7 +11044,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);
@@ -10158,7 +11133,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 = {};
@@ -10171,8 +11146,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 READ10 = { 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." };
@@ -10425,7 +11400,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", ...READ10 },
     handler: ({ layerId }) => controller.getShapeLayer(shapeId(layerId))
   };
   const add2 = {
@@ -10456,7 +11431,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);
@@ -10551,7 +11526,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 = {
@@ -10574,8 +11549,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 READ11 = { 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." };
@@ -10603,7 +11578,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;
@@ -10625,7 +11600,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", ...READ11 },
     handler: () => ({ families: controller.listFonts(), shaper: controller.getTextShaper()?.id ?? null })
   };
   const get = {
@@ -10633,7 +11608,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", ...READ11 },
     handler: ({ layerId }) => controller.getTextLayer(typeId(layerId))
   };
   const add2 = {
@@ -10667,9 +11642,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) };
@@ -10680,7 +11655,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 = {
@@ -10690,7 +11665,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));
     }
@@ -10702,7 +11677,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));
     }
@@ -10986,6 +11961,8 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageTypeTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
+      ...createImageColorTools(controller),
+      ...createImageRetouchTools(controller),
       ...createPigmentTools(),
       ...createImagePsdTools(controller)
     ]
@@ -11980,6 +12957,11 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
     };
   });
 }
+var BIT_DEPTH_OPTIONS = [
+  { depth: 8, label: "8-bit", title: "8 bits per channel" },
+  { depth: 16, label: "16-bit", title: "16 bits per channel: smooth gradients, no banding under strong adjustments" },
+  { depth: 32, label: "32-bit", title: "32-bit float per channel, linear light (HDR)" }
+];
 
 // src/image-editor/layers/effects-ui.ts
 function layerEffectsPanel(layer) {
@@ -12154,6 +13136,25 @@ function effectControlChange(effect, key, value, patterns = []) {
   return { [top]: setPath(getPath(effect, top), rest, value) };
 }
 
+// src/image-editor/layers/color-ui.ts
+var WORKING_SPACE_OPTIONS = BUILTIN_PROFILES.filter((b) => b.colorSpace === "rgb").map((b) => ({ id: b.id, label: b.description }));
+var PROOF_PROFILE_OPTIONS = BUILTIN_PROFILES.map((b) => ({ id: b.id, label: b.description }));
+var INTENT_OPTIONS = [
+  { id: "relative", label: "Relative Colorimetric", title: "Keep in-gamut colours exact, clip the rest (photos)" },
+  { id: "perceptual", label: "Perceptual", title: "Compress the whole gamut smoothly" },
+  { id: "saturation", label: "Saturation", title: "Keep colours vivid (graphics)" },
+  { id: "absolute", label: "Absolute Colorimetric", title: "Keep the source white too (paper proofs)" }
+];
+function colorPanelView(controller) {
+  const profile = controller.getColorProfile();
+  const proof = controller.getState().proofSetup ?? null;
+  return {
+    profileName: profile.name,
+    workingSpace: profile.builtin,
+    proof: proof ? { id: proof.profile.builtin ?? null, name: proof.profile.name, intent: proof.intent, simulatePaper: proof.simulatePaper, gamutWarning: proof.gamutWarning, bpc: proof.bpc } : null
+  };
+}
+
 // src/image-editor/psd/ui.ts
 var PSD_FILE_ACCEPT = ".psd,.psb,image/vnd.adobe.photoshop,application/x-photoshop";
 function blobBytes(file) {
@@ -12766,9 +13767,12 @@ export {
   AS_SHOT_KELVIN,
   BACKGROUND_LAYER_ID,
   BACKGROUND_LAYER_NAME,
+  BIT_DEPTHS,
+  BIT_DEPTH_OPTIONS,
   BLEND_MODES,
   BLUR_FILTER_ID,
   BRUSH_OPTION_CONTROLS,
+  BUILTIN_PROFILES,
   CoverageMap,
   D50,
   D65,
@@ -12780,7 +13784,9 @@ export {
   DEFAULT_GLOBAL_LIGHT,
   DEFAULT_MITER_LIMIT,
   DEFAULT_MIXER,
+  DEFAULT_PROOF,
   DEFAULT_REFINE_EDGE_PARAMS,
+  DEFAULT_RETOUCH,
   DEFAULT_SELECTION_TOOL_OPTIONS,
   DEFAULT_SHAPE_TOOL_OPTIONS,
   DEFAULT_SMUDGE,
@@ -12808,6 +13814,8 @@ export {
   IMAGE_EDITOR_SCHEMA_VERSION,
   IMAGE_EDITOR_STATE_VERSION,
   IMAGE_FILTER_PRESETS,
+  INTENTS,
+  INTENT_OPTIONS,
   INTERPOLATIONS,
   ImageEditorController,
   ImageEditorRenderer,
@@ -12841,6 +13849,7 @@ export {
   PIGMENT_LAMBDA_MIN,
   PIGMENT_LAMBDA_STEP,
   PIGMENT_WAVELENGTHS,
+  PROOF_PROFILE_OPTIONS,
   PSD_BLEND_KEYS,
   PSD_FILE_ACCEPT,
   PaintExchange,
@@ -12850,6 +13859,13 @@ 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,
@@ -12859,6 +13875,7 @@ export {
   SHAPE_OPERATIONS,
   SHAPE_RENDER_MARGIN,
   SMART_RENDER_MARGIN,
+  SPOT_HEAL_TYPES,
   SUPPORTED_ADJUSTMENT_KEYS,
   SelectionGesture,
   ShapeDrawGesture,
@@ -12872,10 +13889,12 @@ export {
   TILE_SHIFT,
   TINT_SCALE,
   TONE_LUT_SIZE,
+  TONE_RANGES,
   TONE_RANGE_PRESETS,
   TRANSFORM_ANCHORS,
   TextEditSession,
   TileMedium,
+  TilePixelSource,
   TiledSurface,
   TransformTooLargeError,
   TypeToolGesture,
@@ -12884,6 +13903,7 @@ export {
   WARP_STYLES,
   WARP_STYLE_LABELS,
   WARP_STYLE_OPTIONS,
+  WORKING_SPACE_OPTIONS,
   XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
@@ -12905,6 +13925,7 @@ export {
   annotationOfShape,
   annotationOfType,
   applyAdjustmentLayers,
+  applyAdjustmentLayersFloat,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
@@ -12917,12 +13938,14 @@ export {
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
+  applyRetouchToTile,
   applyShapeOptions,
   applySmartFilters,
   applyStrokeToTile,
   backgroundLayer,
   base64ToBytes,
   baseProjection,
+  bestOffset,
   blackWhiteGray,
   blendChannel,
   blendImageData,
@@ -12952,12 +13975,15 @@ export {
   clampControlValue,
   clampCropToImage,
   cleanMixer,
+  cloneSourceLabel,
   collectTiles,
   colorBalanceChannel,
+  colorPanelView,
   colorRange,
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
+  compositeDeep,
   compositeSurfaceOver,
   computeHistogram,
   computeSelectionBounds,
@@ -12967,6 +13993,9 @@ export {
   contractCoverage,
   controlPosition,
   controlTrackBackground,
+  convertHex,
+  convertSurfaceColors,
+  convertSurfaceDepth,
   convertToSmartObject,
   copySmartObject,
   cornersFromMatrix,
@@ -12977,17 +14006,20 @@ export {
   createBlenderScratch,
   createCanvasTextShaper,
   createImageCaptureSurface,
+  createImageColorTools,
   createImageEditTools,
   createImageEditorToolProvider,
   createImageEffectTools,
   createImageLayerTools,
   createImagePaintTools,
   createImagePsdTools,
+  createImageRetouchTools,
   createImageSelectionTools,
   createImageShapeTools,
   createImageSmartObjectTools,
   createImageTransformTools,
   createImageTypeTools,
+  createMetricTextShaper,
   createOutlineTextShaper,
   createPigment,
   createPigmentTools,
@@ -13002,6 +14034,7 @@ export {
   curveSvgPath,
   dabCoverage,
   dabRect,
+  decodeDeepSurface,
   decodeLayerChannel,
   decodeLayerMask,
   decodeMergedImage,
@@ -13009,6 +14042,8 @@ export {
   decodePng,
   decodePngDataUrl,
   decodeSelectionRle,
+  deepBytes,
+  deepTile,
   defaultAdjustmentParams,
   defaultEffectGradient,
   defaultLayerEffect,
@@ -13016,11 +14051,13 @@ export {
   deflate,
   deflateRaw,
   depthMaskAlpha,
+  depthOf,
   depthRasterMask,
   describeLayer,
   describeLayerEffects,
   describeSelection,
   describeTransform,
+  deserializeColorProfile,
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
@@ -13029,8 +14066,13 @@ export {
   developFilter,
   developFromAdjustments,
   developTarget,
+  dilateMask,
+  displayTransform,
   distanceTransform,
   documentContents,
+  documentProfile,
+  dodgeBurn,
+  dodgeBurnCurve,
   downloadPsd,
   dragWarpMeshPoint,
   dropPlacement,
@@ -13047,6 +14089,7 @@ export {
   ellipseSelection,
   emptyHistogram,
   emptySurface,
+  encodeDeepSurface,
   encodePng,
   encodeRle,
   encodeSelectionRle,
@@ -13092,6 +14135,7 @@ export {
   hasWarp,
   hashMaskContent,
   hashNoise,
+  healPixels,
   hexToRgb,
   histogramPath,
   hitTestAnnotation,
@@ -13121,6 +14165,7 @@ export {
   invertSelection,
   isActiveFilter,
   isAdjustmentKind,
+  isBitDepth,
   isBlendMode,
   isContentsDecoded,
   isDefaultDepthMask,
@@ -13135,10 +14180,13 @@ export {
   isQuarterTurn,
   isQuarterTurnSwapped,
   isRenderedLayer,
+  isRetouchPaintTool,
+  isRetouchTool,
   isSelectionEmpty,
   isSelectionMode,
   isSeparableBlendMode,
   isSpatialFilter,
+  isSrgb,
   isTransformAnchor,
   isValidWarp,
   kelvinToTemperature,
@@ -13176,13 +14224,17 @@ export {
   liveShapeSubpaths,
   loadImageEditorDocument,
   loadMixer,
+  loadOpenTypeFont,
+  luma,
   magicWand,
   mapCropHandle,
   mapLayer,
   mapSubpaths,
+  maskBounds,
   maskSummary,
   matrixFromCorners,
   matrixFromParams,
+  membraneFill,
   mergeLayerEffect,
   mergeShapeComponents,
   migrateSerializedImageEditorState,
@@ -13217,6 +14269,7 @@ export {
   normalizeProcessVersion,
   normalizeRect,
   normalizeRefineEdgeParams,
+  normalizeRetouch,
   normalizeShapePaint,
   normalizeShapeStroke,
   normalizeSmartFilter,
@@ -13238,11 +14291,13 @@ export {
   parseEffectColor,
   parseLfx2,
   parseLrfx,
+  parseOpenTypeFont,
   parsePatternBlock,
   parseSelectionMode,
   parseVersionedDescriptor,
   patchParagraphStyle,
   patchTextStyle,
+  perDabStrength,
   photoFilterMatrix,
   pigment8,
   pixelLayerBounds,
@@ -13259,10 +14314,12 @@ export {
   posterizeValue,
   presetWarp,
   previewStep,
+  profileBytes,
   projectImagePoint,
   projectImageRect,
   projectMaskCoverage,
   projectQuarterTurn,
+  proxyOf,
   psdBytesFromBase64,
   psdFileName,
   psdPatternToEffectPattern,
@@ -13276,9 +14333,11 @@ export {
   rasterizeDab,
   rasterizeSmartObject,
   readAdjustmentControls,
+  readDeepRegion,
   readPixel,
   readPsd,
   readRegion,
+  readSourceRegion,
   rectSelection,
   rectToQuad,
   reduceSurface,
@@ -13315,16 +14374,20 @@ export {
   resizeWarpMesh,
   resolveExternalAssets,
   resolveMosaicRegionBounds,
+  resolveProfile,
   restyleRange,
   rgbToGray,
   rgbToHsl,
   rgbToReflectance,
   rgbUnitToHex,
+  rgbaViewOfGrey,
   runLayerFilters,
   runLayerMenuAction,
   sampleLut,
   sampleToneLut,
+  saturationOf,
   scaleLayerEffect,
+  seamlessClone,
   selectionArea,
   selectionFromCoverage,
   selectionFromPixels,
@@ -13333,6 +14396,7 @@ export {
   selectionToCoverage,
   selectionToPixels,
   selectionValueAt,
+  serializeColorProfile,
   serializeContents,
   serializeEffects,
   serializeLayer,
@@ -13347,6 +14411,7 @@ export {
   setLayerProperties,
   setLum,
   setPigmentColor,
+  setRetouchChoice,
   setSmartFilterMask,
   setSmartFiltersEnabled,
   setSmartPlacement,
@@ -13361,15 +14426,25 @@ export {
   smartObjectLayers,
   smoothCoverage,
   smoothPoints,
+  smudgeEffect,
   solidSurface,
+  solveMembrane,
   spliceRuns,
   splitOverlayAnnotations,
+  sponge,
+  spongeEffect,
+  spotHealPixels,
+  spotHealWindow,
   srgb8ToLab,
+  srgbDecode,
+  srgbEncode,
   srgbToLinear,
   standardBlendMode,
   styleAt,
   sumHistograms,
   surfaceBytes,
+  surfaceDepth,
+  surfaceFromDeepPixels,
   surfaceFromPixels,
   surfacesEqual,
   tempTintToXy,
@@ -13381,14 +14456,24 @@ export {
   tileCoord,
   tileKey,
   tileRect,
+  tileSamples,
+  tileSamples16,
+  tileSamples32,
   tilesInRect,
   tipFalloff,
   tipReach,
   tipShape,
+  to16From32,
+  to16From8,
+  to32From16,
+  to32From8,
+  to8From16,
+  to8From32,
   toHex,
   toTextSpace,
   toneCurve,
   toneLuts,
+  toneOf,
   toneRange,
   transformHomography,
   transformMap,
@@ -13433,6 +14518,7 @@ export {
   withFilterMaskSurface,
   withNewIds,
   writeAdjustmentBlock,
+  writeDeepRegion,
   writeLfx2,
   writePatternBlock,
   writePsd,