@pixerate/editor 0.113.0 → 0.115.0

package/dist/image-editor/index.js

@@ -1,40 +1,7 @@
 import {
-  loadDocument
-} from "../chunk-U5HZSFCS.js";
-import {
-  createCaptureTool
-} from "../chunk-REOJJIY3.js";
-import {
-  DEFAULT_RETOUCH,
-  RETOUCH_SAMPLES,
-  RegionPixelSource,
-  RetouchDabStroke,
-  SPOT_HEAL_TYPES,
-  TONE_RANGES,
-  TilePixelSource,
-  applyRetouchToTile,
-  bestOffset,
-  dilateMask,
-  dodgeBurn,
-  dodgeBurnCurve,
-  healPixels,
-  luma,
-  maskBounds,
-  membraneFill,
-  normalizeRetouch,
-  perDabStrength,
-  readSourceRegion,
-  rgbaViewOfGrey,
-  saturationOf,
-  seamlessClone,
-  smudgeEffect,
-  solveMembrane,
-  sponge,
-  spongeEffect,
-  spotHealPixels,
-  spotHealWindow,
-  toneOf
-} from "../chunk-LPYOIVLA.js";
+  loadOpenTypeFont,
+  parseOpenTypeFont
+} from "../chunk-3UFGNHSP.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -47,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,
@@ -102,6 +67,7 @@ import {
   annotationOfShape,
   annotationOfType,
   applyAdjustmentLayers,
+  applyAdjustmentLayersFloat,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
@@ -121,12 +87,12 @@ import {
   buildToneLut,
   calculateCropDrag,
   canvasToImagePoint,
-  caretAt,
   clampCropToImage,
   colorBalanceChannel,
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
+  compositeDeep,
   computeSelectionBounds,
   contentsBox,
   contentsSurface,
@@ -140,6 +106,7 @@ import {
   createShapeLayer,
   createTypeLayer,
   curveLutFromLevels,
+  decodeDeepSurface,
   decodeLayerChannel,
   decodeLayerMask,
   decodeMergedImage,
@@ -162,6 +129,7 @@ import {
   distanceTransform,
   documentContents,
   duplicateLayer,
+  encodeDeepSurface,
   encodeRle,
   encodeSelectionRle,
   encodeSurface,
@@ -170,11 +138,8 @@ import {
   exportPsd,
   featherCoverage,
   filterMaskCoverage,
-  fitParagraphRuns,
-  fitRuns,
   flattenPath,
   flipCorners,
-  fontOf,
   fullSelection,
   geometryHomography,
   getAnnotationBounds,
@@ -225,7 +190,6 @@ import {
   layerTree,
   layerTypeLabel,
   layersFromLegacy,
-  layoutText,
   legacyAdjustmentLayer,
   legacyMaskOf,
   legacyView,
@@ -262,7 +226,6 @@ import {
   offsetLayer,
   offsetShape,
   offsetSmartObject,
-  paragraphRanges,
   parseAdjustmentBlock,
   parseBlend,
   parseCssColor,
@@ -317,7 +280,6 @@ import {
   rerenderText,
   resizeSelection,
   resolveExternalAssets,
-  restyleRange,
   rgbToGray,
   rgbToHsl,
   runLayerFilters,
@@ -353,12 +315,9 @@ import {
   smartContentsFile,
   smartObjectLayers,
   smoothCoverage,
-  spliceRuns,
   srgbToLinear,
-  styleAt,
   tempTintToXy,
   temperatureToKelvin,
-  textIndexAt,
   textMatrix,
   textOutlines,
   textRange,
@@ -399,8 +358,15 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-CZOXTEMN.js";
+} from "../chunk-XICA4PVO.js";
+import {
+  loadDocument
+} from "../chunk-U5HZSFCS.js";
 import {
+  createCaptureTool
+} from "../chunk-REOJJIY3.js";
+import {
+  BIT_DEPTHS,
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
   INTERPOLATIONS,
@@ -411,8 +377,6 @@ import {
   PatternPlacement,
   PatternTile,
   TransformTooLargeError,
-  ZlibError,
-  adler32,
   base64ToBytes,
   blendTile,
   builtinPattern,
@@ -420,12 +384,14 @@ import {
   bytesToBase64,
   changedTiles,
   compositeSurfaceOver,
+  convertSurfaceDepth,
   curveLut,
   decodePng,
+  deepBytes,
+  deepTile,
   defaultEffectGradient,
   defaultLayerEffect,
-  deflate,
-  deflateRaw,
+  depthOf,
   effectColorHex,
   effectReach,
   effectsFingerprint,
@@ -437,9 +403,8 @@ import {
   gaussianBlur,
   hasActiveEffects,
   hashNoise,
-  inflate,
-  inflateRaw,
   insertLayer,
+  isBitDepth,
   isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
@@ -454,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,
@@ -473,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,
@@ -512,7 +525,7 @@ import {
   tipReach,
   tipShape,
   walkDabs
-} from "../chunk-Z4BC6M74.js";
+} from "../chunk-UBIXVXPR.js";
 import {
   BLEND_MODES,
   PAINTERLY_BLEND_MODES,
@@ -566,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,
@@ -588,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";
@@ -943,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;
@@ -1012,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;
@@ -1369,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);
   }
   /**
@@ -1411,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");
@@ -2548,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 pick3 = (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 } = pick3(font);
-      return { family: entry.family, available };
-    },
-    metrics(font) {
-      const { face } = pick3(font).entry;
-      const k = font.size / face.unitsPerEm;
-      return { ascent: face.ascender * k, descent: -face.descender * k };
-    },
-    measure(text, font) {
-      const { face } = pick3(font).entry;
-      const out = [0];
-      for (let i = 1; i <= text.length; i++) out.push(face.getAdvanceWidth(text.slice(0, i), font.size, { kerning: true }));
-      return out;
-    },
-    outline(text, font, x, y) {
-      return toPath(pick3(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) => {
@@ -3181,6 +3096,179 @@ var FreeTransformSession = class {
   }
 };
 
+// src/image-editor/color-management.ts
+var DEFAULT_PROOF = { intent: "relative", bpc: true, simulatePaper: false, gamutWarning: false };
+function serializeColorMode(m) {
+  return m.mode === "cmyk" ? { mode: "cmyk", profile: serializeColorProfile(m.profile), intent: m.intent } : { mode: "lab" };
+}
+function deserializeColorMode(raw, problems) {
+  const r = raw;
+  if (!r || typeof r !== "object") return null;
+  if (r.mode === "lab") return { mode: "lab" };
+  if (r.mode !== "cmyk") return null;
+  const profile = r.profile && deserializeColorProfile(r.profile, problems) || documentProfile("coated-cmyk");
+  const intent = ["perceptual", "relative", "saturation", "absolute"].includes(r.intent) ? r.intent : "relative";
+  return { mode: "cmyk", profile, intent };
+}
+function effectiveProof(proof, mode) {
+  if (proof) return proof;
+  if (mode?.mode === "cmyk") return { ...DEFAULT_PROOF, profile: mode.profile, intent: mode.intent };
+  return null;
+}
+function colorModePlanes(doc, mode) {
+  const src = resolveProfile(doc);
+  if (mode.mode === "cmyk") {
+    const t2 = Transform.create(src, resolveProfile(mode.profile), { intent: mode.intent, bpc: true });
+    return (rgba, n) => {
+      const ink = new Uint8Array(n * 4);
+      t2.convert8(rgba, 4, ink, 4, false);
+      const planes = [0, 1, 2, 3].map(() => new Uint8Array(n));
+      for (let i = 0; i < n; i++) for (let c = 0; c < 4; c++) planes[c][i] = 255 - ink[i * 4 + c];
+      return planes;
+    };
+  }
+  const t = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
+  return (rgba, n) => {
+    const lab = new Uint8Array(n * 4);
+    t.convert8(rgba, 4, lab, 4, false);
+    const planes = [0, 1, 2].map(() => new Uint8Array(n));
+    for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = lab[i * 4 + c];
+    return planes;
+  };
+}
+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"];
@@ -3593,10 +3681,24 @@ 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, mode and Proof Setup. */
+  syncDisplay() {
+    const s = this.state;
+    const d = this.displayFor;
+    if (d && d[0] === s.colorProfile && d[1] === s.proofSetup && d[2] === s.colorMode) return;
+    this.displayFor = [s.colorProfile, s.proofSetup, s.colorMode];
+    try {
+      this.renderer.setDisplayTransform(displayTransform(s.colorProfile, effectiveProof(s.proofSetup, s.colorMode)));
+    } catch {
+      this.renderer.setDisplayTransform(null);
+    }
+  }
   /** Recomputes the compatibility views (`adjustments`, `depthMask`, `annotations`) when the stack changed. */
   syncViews() {
     const s = this.state;
@@ -3634,6 +3736,9 @@ 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.colorMode) entry.colorMode = s.colorMode;
+    if (s.bitDepth && s.bitDepth !== 8) entry.bitDepth = s.bitDepth;
     return entry;
   }
   restoreHistoryEntry(entry) {
@@ -3650,6 +3755,12 @@ 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;
+    if (entry.colorMode) s.colorMode = entry.colorMode;
+    else delete s.colorMode;
     s.selection = entry.selection;
     if (this.imageElement !== entry.source.element && !this.samplePixelsOverride) this.samplePixels = null;
     this.imageElement = entry.source.element;
@@ -4933,9 +5044,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;
@@ -6138,16 +6268,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 {
@@ -6160,7 +6311,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);
         }
@@ -6680,6 +6831,206 @@ var ImageEditorController = class {
     return id;
   }
   // --- PSD ---
+  // --- Colour management ---
+  /** The document's colour profile: its name, built-in id (or `null` for an embedded profile), colour space, and Image › Mode. */
+  getColorProfile() {
+    const doc = this.state.colorProfile;
+    const p = resolveProfile(doc);
+    const m = this.state.colorMode;
+    const out = { name: doc?.name ?? p.description, builtin: doc ? doc.builtin ?? null : "srgb", colorSpace: p.colorSpace, srgb: isSrgb(doc), mode: m?.mode ?? "rgb" };
+    if (m?.mode === "cmyk") out.cmykProfile = { name: m.profile.name, builtin: m.profile.builtin ?? null, intent: m.intent };
+    return out;
+  }
+  /**
+   * Image › Mode (one undo step): `rgb`, `cmyk` (with a CMYK `profile`, default the coated
+   * CMYK, and the `intent` RGB is separated with) or `lab`. The pixels stay RGB in the working
+   * space; a CMYK document is soft-proofed through its profile in the viewport, and PSD export
+   * writes CMYK or Lab channels. Returns the profile summary.
+   */
+  setColorMode(mode, options = {}) {
+    let next;
+    if (mode === "rgb") {
+      if (options.profile !== void 0) throw new LayerOperationError("An RGB document takes no CMYK profile; use assign_profile for its working space.");
+      next = null;
+    } else if (mode === "lab") next = { mode: "lab" };
+    else if (mode === "cmyk") {
+      let doc;
+      try {
+        doc = documentProfile(options.profile ?? "coated-cmyk");
+      } catch (e) {
+        throw new LayerOperationError(e instanceof Error ? e.message : String(e));
+      }
+      const cs = resolveProfile(doc).colorSpace;
+      if (cs !== "cmyk") throw new LayerOperationError(`CMYK mode needs a CMYK profile; "${doc.name}" is ${cs.toUpperCase()}.`);
+      const intent = options.intent ?? "relative";
+      if (!INTENTS.includes(intent)) throw new LayerOperationError(`Unknown rendering intent "${String(intent)}"; use ${INTENTS.join(", ")}.`);
+      next = { mode: "cmyk", profile: doc, intent };
+    } else throw new LayerOperationError(`Unknown colour mode "${String(mode)}"; use rgb, cmyk or lab.`);
+    this.recordHistory();
+    if (next) this.state.colorMode = next;
+    else delete this.state.colorMode;
+    this.notify();
+    return this.getColorProfile();
+  }
+  /** 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 };
+  }
+  /** How `toPsd` writes colour: RGB with the working space, or CMYK / Lab channels for those modes. */
+  psdColorOptions(warnings) {
+    const m = this.state.colorMode;
+    if (!m) return { iccProfile: profileBytes(this.state.colorProfile) };
+    if (flattenLayers(this.state.layers).some((l) => l.type === "adjustment" && l.visible)) {
+      warnings.push(`Adjustment layers were written with their RGB settings; in a ${m.mode.toUpperCase()} file Photoshop applies them to its own channels, so they may look different there.`);
+    }
+    const planes = colorModePlanes(this.state.colorProfile, m);
+    return m.mode === "cmyk" ? { colorMode: "cmyk", colorPlanes: planes, iccProfile: profileBytes(m.profile) } : { colorMode: "lab", colorPlanes: planes };
+  }
   /** Pixels per inch of the last opened PSD (written back by `toPsd`). */
   psdResolution;
   /**
@@ -6712,6 +7063,23 @@ 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;
+    delete s.colorMode;
+    if (result.sourceMode?.mode === "cmyk") s.colorMode = { mode: "cmyk", profile: result.sourceMode.profile, intent: "relative" };
+    else if (result.sourceMode?.mode === "lab") s.colorMode = { mode: "lab" };
+    else 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 read as sRGB.`);
+      } 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 {
@@ -6747,7 +7115,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.
@@ -6873,7 +7241,11 @@ 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 color = this.psdColorOptions(warnings);
+    if (color.colorMode && this.bitDepth !== 8) warnings.push(`${color.colorMode.toUpperCase()} files are written at 8 bits per channel; the ${this.bitDepth}-bit samples were rounded.`);
+    const depth = color.colorMode ? 8 : this.bitDepth;
+    const mergedDeep = depth === 8 ? void 0 : workingToSamples(compositeDeep(prepared, canvas, sources, depth), depth);
+    const result = exportPsd({ width, height, layers: prepared, merged, mergedDeep, resolution: this.psdResolution, patterns: this.state.patterns, globalLight: this.state.globalLight, depth, ...color });
     warnings.push(...result.warnings);
     return { bytes: result.bytes, warnings, psb: result.psb, width, height };
   }
@@ -7019,6 +7391,14 @@ 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;
+      const cmode = data.colorMode ? deserializeColorMode(data.colorMode, problems) : null;
+      if (cmode) s.colorMode = cmode;
+      else delete s.colorMode;
       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 };
       }
@@ -7034,6 +7414,9 @@ var ImageEditorController = class {
       s.activeLayerId = null;
       delete s.globalLight;
       delete s.patterns;
+      delete s.bitDepth;
+      delete s.colorProfile;
+      delete s.colorMode;
     }
     s.activeTarget = "pixels";
     this.viewKey = [];
@@ -7043,7 +7426,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 && !this.state.colorMode) {
       return {
         // States without adjustment layers keep schema 1, so they round-trip unchanged.
         version: view.adjustments.layers?.length ? 2 : 1,
@@ -7073,6 +7456,9 @@ 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);
+    if (this.state.colorMode) out.colorMode = serializeColorMode(this.state.colorMode);
     return out;
   }
 };
@@ -8281,10 +8667,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",
@@ -8460,7 +8859,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
@@ -9775,8 +10174,155 @@ function createImagePaintTools(controller) {
   return [paintStroke, fill, clear, getMixer, loadMixerTool, cleanMixerTool];
 }
 
-// src/image-editor/retouch-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, mode rgb / cmyk / lab and, for cmyk, cmykProfile), 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
+      })
+    })
+  };
+  const setMode = {
+    name: "set_color_mode",
+    title: "Set the colour mode",
+    description: "Image \u203A Mode: rgb, cmyk (for print: give the press `profile`, default coated-cmyk, and the `intent` RGB is separated with) or lab. The document is still edited as RGB in its working space; a CMYK document is soft-proofed through its profile in the viewport (unless set_proof_setup says otherwise), and export_psd writes CMYK or Lab channels with the profile. Changes no pixels. One undo step. Returns the profile summary with mode and cmykProfile.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mode: { type: "string", enum: ["rgb", "cmyk", "lab"], description: "The colour mode." },
+        profile: { ...PROFILE, description: `CMYK mode only: the CMYK profile (default coated-cmyk). ${PROFILE.description}` },
+        intent: INTENT
+      },
+      required: ["mode"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set the colour mode", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: (args) => {
+      if (args.mode !== "cmyk" && (args.profile !== void 0 || args.intent !== void 0)) throw new LayerOperationError("profile and intent apply to CMYK mode only.");
+      return controller.setColorMode(args.mode, {
+        ...args.profile !== void 0 ? { profile: profileArg(args.profile) } : {},
+        ...args.intent !== void 0 ? { intent: args.intent } : {}
+      });
+    }
+  };
+  return [getProfile, assign, convert, proof, convertColors, setMode];
+}
+
+// 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",
@@ -9980,7 +10526,7 @@ function createImageRetouchTools(controller) {
     title: "Get retouch options",
     description: "Reads the retouching tools' options (aligned, sample, spotType, range, exposure, protectTones, spongeMode, vibrance, strength) and the clone source ({x, y, offset} or null; offset is the aligned offset the last clone or heal stroke fixed). Call it before clone_stamp or heal_brush without a source to see where they will sample.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Get retouch options", ...READ5 },
+    annotations: { title: "Get retouch options", ...READ6 },
     handler: () => {
       const { retouch, cloneSource } = controller.getState().paint;
       return { options: { ...retouch }, cloneSource: cloneSource ? { ...cloneSource } : null };
@@ -10040,7 +10586,7 @@ function pick(args, keys) {
 }
 
 // src/image-editor/psd-tools.ts
-var READ6 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var DATA = {
   type: "string",
@@ -10061,7 +10607,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", ...READ6 },
+    annotations: { title: "Inspect a PSD", ...READ7 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -10096,9 +10642,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", ...READ6 },
+    annotations: { title: "Export the document as a PSD", ...READ7 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -10116,7 +10662,7 @@ function createImagePsdTools(controller) {
 }
 
 // src/image-editor/transform-tools.ts
-var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, 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) });
@@ -10216,7 +10762,7 @@ function createImageTransformTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Get the Free Transform frame", ...READ7 },
+    annotations: { title: "Get the Free Transform frame", ...READ8 },
     handler: (args) => {
       const init = targetFrom(args);
       if (init.content === "selection-copy") init.content = "selection";
@@ -10359,7 +10905,7 @@ function createImageTransformTools(controller) {
 }
 
 // src/image-editor/smart-tools.ts
-var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, 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 };
@@ -10418,7 +10964,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", ...READ8 },
+    annotations: { title: "Read a smart object", ...READ9 },
     handler: ({ layerId }) => info(smartId(layerId))
   };
   const convert = {
@@ -10552,7 +11098,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", ...READ8 },
+    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) };
@@ -10719,7 +11265,7 @@ function createImageSmartObjectTools(controller) {
 }
 
 // src/image-editor/shape-tools.ts
-var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, 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 };
@@ -10973,7 +11519,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", ...READ9 },
+    annotations: { title: "Read a shape layer", ...READ10 },
     handler: ({ layerId }) => controller.getShapeLayer(shapeId(layerId))
   };
   const add2 = {
@@ -11122,7 +11668,7 @@ function createImageShapeTools(controller) {
 }
 
 // src/image-editor/type-tools.ts
-var READ10 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, 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 };
@@ -11173,7 +11719,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", ...READ10 },
+    annotations: { title: "List fonts", ...READ11 },
     handler: () => ({ families: controller.listFonts(), shaper: controller.getTextShaper()?.id ?? null })
   };
   const get = {
@@ -11181,7 +11727,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", ...READ10 },
+    annotations: { title: "Read a type layer", ...READ11 },
     handler: ({ layerId }) => controller.getTextLayer(typeId(layerId))
   };
   const add2 = {
@@ -11534,6 +12080,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageTypeTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
+      ...createImageColorTools(controller),
       ...createImageRetouchTools(controller),
       ...createPigmentTools(),
       ...createImagePsdTools(controller)
@@ -12529,6 +13076,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) {
@@ -12703,6 +13255,32 @@ 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)" }
+];
+var COLOR_MODE_OPTIONS = [
+  { id: "rgb", label: "RGB", title: "Edit and export RGB in the working space" },
+  { id: "cmyk", label: "CMYK", title: "For print: proof through the CMYK profile and export CMYK" },
+  { id: "lab", label: "Lab", title: "Export Lab channels" }
+];
+function colorPanelView(controller) {
+  const profile = controller.getColorProfile();
+  const proof = controller.getState().proofSetup ?? null;
+  return {
+    profileName: profile.name,
+    workingSpace: profile.builtin,
+    mode: profile.mode,
+    cmykProfileName: profile.cmykProfile?.name ?? null,
+    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) {
@@ -13315,9 +13893,13 @@ 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,
+  COLOR_MODE_OPTIONS,
   CoverageMap,
   D50,
   D65,
@@ -13329,6 +13911,7 @@ export {
   DEFAULT_GLOBAL_LIGHT,
   DEFAULT_MITER_LIMIT,
   DEFAULT_MIXER,
+  DEFAULT_PROOF,
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_RETOUCH,
   DEFAULT_SELECTION_TOOL_OPTIONS,
@@ -13358,6 +13941,8 @@ export {
   IMAGE_EDITOR_SCHEMA_VERSION,
   IMAGE_EDITOR_STATE_VERSION,
   IMAGE_FILTER_PRESETS,
+  INTENTS,
+  INTENT_OPTIONS,
   INTERPOLATIONS,
   ImageEditorController,
   ImageEditorRenderer,
@@ -13391,6 +13976,7 @@ export {
   PIGMENT_LAMBDA_MIN,
   PIGMENT_LAMBDA_STEP,
   PIGMENT_WAVELENGTHS,
+  PROOF_PROFILE_OPTIONS,
   PSD_BLEND_KEYS,
   PSD_FILE_ACCEPT,
   PaintExchange,
@@ -13444,6 +14030,7 @@ export {
   WARP_STYLES,
   WARP_STYLE_LABELS,
   WARP_STYLE_OPTIONS,
+  WORKING_SPACE_OPTIONS,
   XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
@@ -13465,6 +14052,7 @@ export {
   annotationOfShape,
   annotationOfType,
   applyAdjustmentLayers,
+  applyAdjustmentLayersFloat,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
@@ -13517,10 +14105,13 @@ export {
   cloneSourceLabel,
   collectTiles,
   colorBalanceChannel,
+  colorModePlanes,
+  colorPanelView,
   colorRange,
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
+  compositeDeep,
   compositeSurfaceOver,
   computeHistogram,
   computeSelectionBounds,
@@ -13530,6 +14121,9 @@ export {
   contractCoverage,
   controlPosition,
   controlTrackBackground,
+  convertHex,
+  convertSurfaceColors,
+  convertSurfaceDepth,
   convertToSmartObject,
   copySmartObject,
   cornersFromMatrix,
@@ -13540,6 +14134,7 @@ export {
   createBlenderScratch,
   createCanvasTextShaper,
   createImageCaptureSurface,
+  createImageColorTools,
   createImageEditTools,
   createImageEditorToolProvider,
   createImageEffectTools,
@@ -13552,6 +14147,7 @@ export {
   createImageSmartObjectTools,
   createImageTransformTools,
   createImageTypeTools,
+  createMetricTextShaper,
   createOutlineTextShaper,
   createPigment,
   createPigmentTools,
@@ -13566,6 +14162,7 @@ export {
   curveSvgPath,
   dabCoverage,
   dabRect,
+  decodeDeepSurface,
   decodeLayerChannel,
   decodeLayerMask,
   decodeMergedImage,
@@ -13573,6 +14170,8 @@ export {
   decodePng,
   decodePngDataUrl,
   decodeSelectionRle,
+  deepBytes,
+  deepTile,
   defaultAdjustmentParams,
   defaultEffectGradient,
   defaultLayerEffect,
@@ -13580,11 +14179,14 @@ export {
   deflate,
   deflateRaw,
   depthMaskAlpha,
+  depthOf,
   depthRasterMask,
   describeLayer,
   describeLayerEffects,
   describeSelection,
   describeTransform,
+  deserializeColorMode,
+  deserializeColorProfile,
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
@@ -13594,8 +14196,10 @@ export {
   developFromAdjustments,
   developTarget,
   dilateMask,
+  displayTransform,
   distanceTransform,
   documentContents,
+  documentProfile,
   dodgeBurn,
   dodgeBurnCurve,
   downloadPsd,
@@ -13607,6 +14211,7 @@ export {
   effectColorHex,
   effectControlChange,
   effectReach,
+  effectiveProof,
   effectsFingerprint,
   effectsMargin,
   effectsScale,
@@ -13614,6 +14219,7 @@ export {
   ellipseSelection,
   emptyHistogram,
   emptySurface,
+  encodeDeepSurface,
   encodePng,
   encodeRle,
   encodeSelectionRle,
@@ -13689,6 +14295,7 @@ export {
   invertSelection,
   isActiveFilter,
   isAdjustmentKind,
+  isBitDepth,
   isBlendMode,
   isContentsDecoded,
   isDefaultDepthMask,
@@ -13709,6 +14316,7 @@ export {
   isSelectionMode,
   isSeparableBlendMode,
   isSpatialFilter,
+  isSrgb,
   isTransformAnchor,
   isValidWarp,
   kelvinToTemperature,
@@ -13746,6 +14354,7 @@ export {
   liveShapeSubpaths,
   loadImageEditorDocument,
   loadMixer,
+  loadOpenTypeFont,
   luma,
   magicWand,
   mapCropHandle,
@@ -13812,6 +14421,7 @@ export {
   parseEffectColor,
   parseLfx2,
   parseLrfx,
+  parseOpenTypeFont,
   parsePatternBlock,
   parseSelectionMode,
   parseVersionedDescriptor,
@@ -13834,10 +14444,12 @@ export {
   posterizeValue,
   presetWarp,
   previewStep,
+  profileBytes,
   projectImagePoint,
   projectImageRect,
   projectMaskCoverage,
   projectQuarterTurn,
+  proxyOf,
   psdBytesFromBase64,
   psdFileName,
   psdPatternToEffectPattern,
@@ -13851,6 +14463,7 @@ export {
   rasterizeDab,
   rasterizeSmartObject,
   readAdjustmentControls,
+  readDeepRegion,
   readPixel,
   readPsd,
   readRegion,
@@ -13891,6 +14504,7 @@ export {
   resizeWarpMesh,
   resolveExternalAssets,
   resolveMosaicRegionBounds,
+  resolveProfile,
   restyleRange,
   rgbToGray,
   rgbToHsl,
@@ -13912,6 +14526,8 @@ export {
   selectionToCoverage,
   selectionToPixels,
   selectionValueAt,
+  serializeColorMode,
+  serializeColorProfile,
   serializeContents,
   serializeEffects,
   serializeLayer,
@@ -13951,11 +14567,15 @@ export {
   spotHealPixels,
   spotHealWindow,
   srgb8ToLab,
+  srgbDecode,
+  srgbEncode,
   srgbToLinear,
   standardBlendMode,
   styleAt,
   sumHistograms,
   surfaceBytes,
+  surfaceDepth,
+  surfaceFromDeepPixels,
   surfaceFromPixels,
   surfacesEqual,
   tempTintToXy,
@@ -13967,10 +14587,19 @@ export {
   tileCoord,
   tileKey,
   tileRect,
+  tileSamples,
+  tileSamples16,
+  tileSamples32,
   tilesInRect,
   tipFalloff,
   tipReach,
   tipShape,
+  to16From32,
+  to16From8,
+  to32From16,
+  to32From8,
+  to8From16,
+  to8From32,
   toHex,
   toTextSpace,
   toneCurve,
@@ -14020,6 +14649,7 @@ export {
   withFilterMaskSurface,
   withNewIds,
   writeAdjustmentBlock,
+  writeDeepRegion,
   writeLfx2,
   writePatternBlock,
   writePsd,