@pixerate/editor 0.93.0 → 0.95.0

package/dist/image-editor/index.js

@@ -5,17 +5,25 @@ import {
   createCaptureTool
 } from "../chunk-REOJJIY3.js";
 import {
+  DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
+  LAYER_EFFECT_KINDS,
+  LayerEffectError,
   RasterCompositor,
   ZlibError,
   adler32,
   base64ToBytes,
   blendTile,
+  builtinPattern,
+  builtinPatternIds,
   bytesToBase64,
   changedTiles,
+  curveLut,
   decodePng,
+  defaultLayerEffect,
   deflate,
   deflateRaw,
+  effectsMargin,
   encodePng,
   findLayer,
   flattenLayers,
@@ -23,44 +31,52 @@ import {
   inflate,
   inflateRaw,
   insertLayer,
+  isLayerEffectKind,
   isLayerLocked,
   isPng,
+  layerEffectLabel,
   mapLayer,
+  mergeLayerEffect,
+  newEffectId,
+  normalizeLayerEffects,
   parseDataUrl,
-  pngDataUrl
-} from "../chunk-P5TPUNBZ.js";
+  pngDataUrl,
+  validateLayerEffects
+} from "../chunk-E2ILRYTJ.js";
 import {
   CoverageMap,
   DEFAULT_BRUSH,
+  DEFAULT_MIXER,
   DabWalker,
+  EMPTY_MIXER_LOAD,
   MAX_BRUSH_SIZE,
-  PIGMENT_BANDS,
-  PIGMENT_LAMBDA_MIN,
-  PIGMENT_LAMBDA_STEP,
-  PIGMENT_WAVELENGTHS,
+  MIXER_DRAIN,
+  MIXER_PICKUP_RATE,
+  MIXING_MODELS,
+  MixerStroke,
   StrokeCoverage,
   applyStrokeToTile,
+  cleanMixer,
   coverageTileCoord,
-  createPigment,
   createPigmentTools,
   dabCoverage,
   dabRect,
-  lerpPigment,
-  lerpPigmentInto,
-  mixPigments,
+  loadMixer,
   normalizeBrush,
+  normalizeMixer,
   rasterizeDab,
-  reflectanceToRgb,
-  rgbToReflectance,
-  setPigmentColor,
   smoothPoints,
   tipFalloff,
   tipReach,
   tipShape,
   walkDabs
-} from "../chunk-ISDCJHTO.js";
+} from "../chunk-IB53LVGV.js";
 import {
   BLEND_MODES,
+  PIGMENT_BANDS,
+  PIGMENT_LAMBDA_MIN,
+  PIGMENT_LAMBDA_STEP,
+  PIGMENT_WAVELENGTHS,
   SurfaceDraft,
   TILE,
   TILE_SHIFT,
@@ -73,16 +89,25 @@ import {
   canvasCompositeOperation,
   collectTiles,
   contentBounds,
+  createPigment,
   emptySurface,
   fillRect,
   finishTile,
   isBlendMode,
   isSeparableBlendMode,
+  lerpPigment,
+  lerpPigmentInto,
+  mixPigment8,
+  mixPigmentRgb,
+  mixPigments,
   normalizeBlendMode,
   packRgba,
   readPixel,
   readRegion,
+  reflectanceToRgb,
+  rgbToReflectance,
   setLum,
+  setPigmentColor,
   solidSurface,
   surfaceBytes,
   surfaceFromPixels,
@@ -94,7 +119,7 @@ import {
   translateSurface,
   uniformTile,
   writeRegion
-} from "../chunk-D4ZCU72J.js";
+} from "../chunk-HEW6KDNI.js";
 
 // src/image-editor/color.ts
 var LEGACY_PROCESS_VERSION = 1;
@@ -1496,59 +1521,6 @@ function normalizeAdjustmentLayers(raw) {
   }
   return out;
 }
-function curveLut(points, size = ADJUSTMENT_LUT_SIZE) {
-  const pts = points.filter((p) => Number.isFinite(p.input) && Number.isFinite(p.output)).map((p) => [p.input, p.output]).sort((a, b) => a[0] - b[0]);
-  const dedup = [];
-  for (const p of pts) {
-    if (dedup.length && Math.abs(dedup[dedup.length - 1][0] - p[0]) < 1e-6) continue;
-    dedup.push(p);
-  }
-  const out = new Float32Array(size);
-  const n = dedup.length;
-  if (n < 2) {
-    for (let k = 0; k < size; k++) out[k] = k / (size - 1);
-    return out;
-  }
-  const x = dedup.map((p) => p[0]);
-  const y = dedup.map((p) => p[1]);
-  const m2 = new Float64Array(n);
-  if (n > 2) {
-    const c = new Float64Array(n);
-    const d = new Float64Array(n);
-    for (let i = 1; i < n - 1; i++) {
-      const h0 = x[i] - x[i - 1];
-      const h1 = x[i + 1] - x[i];
-      const a = h0 / 6;
-      const b = (h0 + h1) / 3;
-      const cc = h1 / 6;
-      const r = (y[i + 1] - y[i]) / h1 - (y[i] - y[i - 1]) / h0;
-      const denom = b - a * c[i - 1];
-      c[i] = cc / denom;
-      d[i] = (r - a * d[i - 1]) / denom;
-    }
-    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
-  }
-  let seg = 0;
-  for (let k = 0; k < size; k++) {
-    const xv = k / (size - 1);
-    if (xv <= x[0]) {
-      out[k] = clamp01(y[0]);
-      continue;
-    }
-    if (xv >= x[n - 1]) {
-      out[k] = clamp01(y[n - 1]);
-      continue;
-    }
-    while (seg < n - 2 && xv > x[seg + 1]) seg++;
-    const x0 = x[seg], x1 = x[seg + 1];
-    const h = x1 - x0;
-    const a = (x1 - xv) / h;
-    const b = (xv - x0) / h;
-    const v = a * y[seg] + b * y[seg + 1] + ((a * a * a - a) * m2[seg] + (b * b * b - b) * m2[seg + 1]) * (h * h) / 6;
-    out[k] = clamp01(v);
-  }
-  return out;
-}
 function curveLutFromLevels(points) {
   return curveLut(points.map((p) => ({ input: p.input / 255, output: p.output / 255 })));
 }
@@ -1958,6 +1930,10 @@ function applyLayer(c, layer, op, coverage = 1) {
   }
   const cb0 = c[0], cb1 = c[1], cb2 = c[2];
   op(c);
+  if (blend === "pigment") {
+    mixPigmentRgb([clamp01(cb0), clamp01(cb1), clamp01(cb2)], [clamp01(c[0]), clamp01(c[1]), clamp01(c[2])], alpha, c);
+    return;
+  }
   const b = blend === "normal" ? c : blendRgb(blend, [cb0, cb1, cb2], c);
   c[0] = (1 - alpha) * cb0 + alpha * b[0];
   c[1] = (1 - alpha) * cb1 + alpha * b[1];
@@ -2700,7 +2676,7 @@ function developTarget(layers, activeLayerId) {
   }
   return pixels.find((l) => l.source === "document") ?? pixels.find((l) => l.id === BACKGROUND_LAYER_ID) ?? pixels[0] ?? null;
 }
-var isPlain = (l) => l.visible && l.opacity === 1 && l.blend === "normal" && !l.clipped && !l.mask && !l.locks;
+var isPlain = (l) => l.visible && l.opacity === 1 && l.blend === "normal" && !l.clipped && !l.mask && !l.locks && !l.effects;
 function legacyView(stack, width, height, activeLayerId = null) {
   const { layers } = stack;
   const target = developTarget(layers, activeLayerId);
@@ -2740,7 +2716,7 @@ function isLegacyShape(stack) {
   const bg = layers[0];
   if (!bg || bg.type !== "pixel" || bg.source !== "document") return false;
   if (bg.id !== BACKGROUND_LAYER_ID || bg.name !== BACKGROUND_LAYER_NAME) return false;
-  if (!bg.visible || bg.opacity !== 1 || bg.blend !== "normal" || bg.clipped || bg.locks) return false;
+  if (!bg.visible || bg.opacity !== 1 || bg.blend !== "normal" || bg.clipped || bg.locks || bg.effects) return false;
   if ((bg.fillOpacity ?? 1) !== 1 || bg.offset.x !== 0 || bg.offset.y !== 0) return false;
   const filters = bg.filters ?? [];
   if (filters.length < 1 || filters.length > 2) return false;
@@ -2756,7 +2732,7 @@ function isLegacyShape(stack) {
   let adjustments = 0;
   for (; i < layers.length && layers[i].type === "adjustment"; i++) {
     const l = layers[i];
-    if (l.clipped || l.locks || l.mask?.source) return false;
+    if (l.clipped || l.locks || l.mask?.source || l.effects) return false;
     adjustments++;
   }
   for (; i < layers.length; i++) {
@@ -3262,7 +3238,9 @@ var ImageEditorRenderer = class {
         return this.depthMaps.get(`${source.maskSource}|${width}x${height}`) ?? null;
       },
       rasterizeAnnotation: (annotation, rect) => this.rasterizeAnnotation(annotation, rect),
-      version: `${host?.version() ?? ""}:${this.assetVersion}`
+      version: `${host?.version() ?? ""}:${this.assetVersion}`,
+      globalLight: host?.globalLight?.(),
+      pattern: host?.pattern ? (id) => host.pattern(id) : void 0
     };
   }
   /** Loads what the compositor reads synchronously: depth maps (at canvas size) and annotation images. */
@@ -4535,8 +4513,29 @@ function baseFields(layer, ctx) {
   if (layer.clipped) out.clipped = true;
   if (layer.mask) out.mask = serializeMask(layer.mask, `${layer.id}-mask`, ctx);
   if (layer.locks && Object.values(layer.locks).some(Boolean)) out.locks = { ...layer.locks };
+  if (layer.effects) out.effects = serializeEffects(layer.effects);
   return out;
 }
+function serializeEffects(effects) {
+  const out = { enabled: effects.enabled, items: JSON.parse(JSON.stringify(effects.items)) };
+  if (effects.scale !== void 0 && effects.scale !== 1) out.scale = effects.scale;
+  if (effects.psd) out.psd = { key: effects.psd.key, data: bytesToBase64(effects.psd.data) };
+  return out;
+}
+function deserializeEffects(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  let psd;
+  const p = r.psd;
+  if (p && typeof p.key === "string" && typeof p.data === "string") {
+    try {
+      psd = { key: p.key, data: base64ToBytes(p.data) };
+    } catch {
+      psd = void 0;
+    }
+  }
+  return normalizeLayerEffects({ ...r, psd });
+}
 function serializeMask(mask, hint, ctx) {
   const out = { defaultValue: mask.defaultValue };
   if (!mask.source) {
@@ -4739,6 +4738,8 @@ function deserializeLayer(raw, ctx) {
     for (const k of ["pixels", "transparency", "position", "all"]) if (r.locks[k] === true) locks[k] = true;
     if (Object.keys(locks).length) base.locks = locks;
   }
+  const effects = deserializeEffects(r.effects);
+  if (effects && r.type !== "adjustment") base.effects = effects;
   switch (r.type) {
     case "pixel": {
       const layer = {
@@ -5021,6 +5022,77 @@ function removeLayerFilter(layers, id, filterId) {
   else delete next.filters;
   return mapLayer(layers, id, () => next);
 }
+function requireEffectLayer(layers, id, action) {
+  const layer = requireLayer(layers, id).layer;
+  if (layer.type === "adjustment") fail(`Layer "${layer.name || id}" is an adjustment layer; effects go on pixel, annotation and group layers.`);
+  requireUnlocked(layer, "all", action);
+  return layer;
+}
+function layerEffectsOf(layer) {
+  return layer.effects ?? { enabled: true, items: [] };
+}
+function guard(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    if (e instanceof LayerEffectError) fail(e.message);
+    throw e;
+  }
+}
+function setLayerEffects(layers, id, effects) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  const next = { ...layer };
+  if (effects && (effects.items.length || effects.psd || effects.scale !== void 0 || !effects.enabled)) {
+    guard(() => validateLayerEffects(effects));
+    next.effects = effects;
+  } else delete next.effects;
+  return mapLayer(layers, id, () => next);
+}
+function addLayerEffect(layers, id, kind, params = {}, index) {
+  if (!isLayerEffectKind(kind)) fail(`Unknown effect kind "${String(kind)}". Kinds: ${LAYER_EFFECT_KINDS.join(", ")}.`);
+  const layer = requireEffectLayer(layers, id, "add effects");
+  const current = layerEffectsOf(layer);
+  const ids = new Set(current.items.map((e) => e.id));
+  let effectId = newEffectId();
+  while (ids.has(effectId)) effectId = newEffectId();
+  const { id: _ignored, kind: _kind, ...rest } = params;
+  const effect = guard(() => mergeLayerEffect(defaultLayerEffect(kind, effectId), rest));
+  const items = [...current.items];
+  const at = index === void 0 ? items.length : Math.max(0, Math.min(items.length, Math.floor(index)));
+  items.splice(at, 0, effect);
+  return { layers: setLayerEffects(layers, id, { ...current, items }), effect };
+}
+function requireEffect(layer, effectId) {
+  const items = layer.effects?.items ?? [];
+  const i = items.findIndex((e) => e.id === effectId);
+  if (i === -1) fail(`Layer "${layer.name || layer.id}" has no effect "${effectId}". Effects: ${items.map((e) => `${e.id} (${e.kind})`).join(", ") || "none"}; call list_layer_effects.`);
+  return i;
+}
+function updateLayerEffect(layers, id, effectId, changes) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  const i = requireEffect(layer, effectId);
+  const current = layer.effects;
+  const items = [...current.items];
+  items[i] = guard(() => mergeLayerEffect(items[i], changes));
+  return setLayerEffects(layers, id, { ...current, items });
+}
+function removeLayerEffect(layers, id, effectId) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  requireEffect(layer, effectId);
+  const current = layer.effects;
+  return setLayerEffects(layers, id, { ...current, items: current.items.filter((e) => e.id !== effectId) });
+}
+function setLayerEffectsEnabled(layers, id, enabled, scale) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  if (scale !== void 0 && !(Number.isFinite(scale) && scale >= 0.01 && scale <= 10)) fail(`scale must be from 0.01 to 10 (1 = 100 %), got ${scale}.`);
+  const current = layerEffectsOf(layer);
+  const next = { ...current, enabled };
+  if (scale !== void 0) {
+    if (scale === 1) delete next.scale;
+    else next.scale = scale;
+  }
+  return setLayerEffects(layers, id, next);
+}
 function parseBlend(value, allowPassThrough = false) {
   if (value === void 0) return void 0;
   if (value === "pass-through" && allowPassThrough) return value;
@@ -7127,22 +7199,53 @@ var PaintStrokeSession = class {
   constructor(controller, target, stroke, apply) {
     this.controller = controller;
     this.target = target;
-    this.stroke = stroke;
     this.apply = apply;
     this.before = controller._captureForStroke();
     this.base = target.surface;
     this.live = new Map(this.base.tiles);
+    if (stroke instanceof StrokeCoverage) {
+      this.stroke = stroke;
+      this.mixer = null;
+    } else {
+      this.stroke = null;
+      this.mixer = stroke.create(this.mixerPixels());
+      this.mixerInit = stroke;
+    }
   }
   controller;
   target;
-  stroke;
   apply;
   before;
   base;
   live;
   touched = /* @__PURE__ */ new Set();
+  stroke;
+  mixer;
+  mixerInit = null;
+  /** 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 live pixels a mixer stroke reads and writes; base tiles are copied on first write. */
+  mixerPixels() {
+    const a = this.apply;
+    return {
+      offset: a.offset,
+      lockTransparency: a.lockTransparency,
+      selection: a.selection,
+      readTile: (tx, ty) => this.live.get(tileKey(tx, ty))?.data ?? (this.base.defaultValue ? defaultTile(this.base) : null),
+      writeTile: (tx, ty) => {
+        const key = tileKey(tx, ty);
+        if (!this.touched.has(key)) {
+          const src = this.base.tiles.get(key)?.data ?? defaultTile(this.base);
+          this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
+          this.touched.add(key);
+        }
+        this.fresh.add(key);
+        return this.live.get(key).data;
+      }
+    };
+  }
   get layerId() {
     return this.target.id;
   }
@@ -7150,11 +7253,18 @@ var PaintStrokeSession = class {
   push(points) {
     if (this.closed || !points.length) return;
     this.last = points[points.length - 1];
-    this.update(this.stroke.push(points));
+    this.update(this.mixer ? this.mixer.push(points) : this.stroke.push(points));
   }
   update(rects) {
     if (!rects.length) return;
     const ch = this.base.channels;
+    if (this.mixer) {
+      for (const key of this.fresh) this.live.set(key, { data: this.live.get(key).data, uniform: null });
+      this.fresh.clear();
+      this.controller._strokeUpdate(this.target.id, this.target.channel, new TiledSurface(ch, new Map(this.live), this.base.defaultValue), rects);
+      return;
+    }
+    const stroke = this.stroke;
     const regions = /* @__PURE__ */ new Map();
     for (const r of rects) {
       for (const t of tilesInRect({ x: r.x - this.apply.offset.x, y: r.y - this.apply.offset.y, width: r.width, height: r.height })) {
@@ -7167,7 +7277,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(this.stroke.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
+      const data = applyStrokeToTile(stroke.coverage, src, ch, tx, ty, this.apply, 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);
@@ -7175,7 +7285,8 @@ var PaintStrokeSession = class {
   /** Finishes the stroke (one undo step) and returns what changed. */
   end() {
     if (this.closed) throw new LayerOperationError("This stroke has already ended.");
-    this.update(this.stroke.finish(this.last ?? void 0));
+    const last = this.last ?? void 0;
+    this.update(this.mixer ? this.mixer.finish(last) : this.stroke.finish(last));
     this.closed = true;
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
@@ -7189,9 +7300,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;
     this.controller._strokeCommit(this.before, this.target.id, this.target.channel, surface);
-    const b = this.stroke.coverage.bounds;
-    return { layerId: this.target.id, channel: this.target.channel, bounds: changed ? b : null, dabs: this.stroke.dabCount };
+    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;
+    return result;
   }
   /** Abandons the stroke and restores the layer. */
   cancel() {
@@ -7305,7 +7419,8 @@ var ImageEditorController = class {
     this.renderer.layerSources = {
       surfaceOf: (layer) => this.surfaceOf(layer),
       sourceIsOpaque: () => this.sourceIsOpaque(),
-      version: () => this.sourceVersion()
+      version: () => this.sourceVersion(),
+      globalLight: () => this.state.globalLight
     };
     this.state = {
       sourceUrl: typeof options.image === "string" ? options.image : null,
@@ -7326,7 +7441,7 @@ var ImageEditorController = class {
       activeLayerId: null,
       activeTarget: "pixels",
       outputOpacity: 1,
-      paint: { brush: { ...DEFAULT_BRUSH }, foreground: "#000000", background: "#ffffff" },
+      paint: { brush: { ...DEFAULT_BRUSH }, foreground: "#000000", background: "#ffffff", mixer: { ...DEFAULT_MIXER }, mixerLoad: EMPTY_MIXER_LOAD },
       fit: options.fit ?? "margin"
     };
     if (options.image instanceof Object && "width" in options.image) {
@@ -7459,6 +7574,7 @@ var ImageEditorController = class {
       }
     };
     if (s.legacyOutputBlur !== void 0) entry.legacyOutputBlur = s.legacyOutputBlur;
+    if (s.globalLight) entry.globalLight = { ...s.globalLight };
     return entry;
   }
   restoreHistoryEntry(entry) {
@@ -7471,6 +7587,8 @@ var ImageEditorController = class {
     s.outputOpacity = entry.outputOpacity;
     if (entry.legacyOutputBlur !== void 0) s.legacyOutputBlur = entry.legacyOutputBlur;
     else delete s.legacyOutputBlur;
+    if (entry.globalLight) s.globalLight = { ...entry.globalLight };
+    else delete s.globalLight;
     s.selection = entry.selection;
     if (this.imageElement !== entry.source.element && !this.samplePixelsOverride) this.samplePixels = null;
     this.imageElement = entry.source.element;
@@ -7692,7 +7810,7 @@ var ImageEditorController = class {
   }
   compositorSources() {
     const { width, height } = this.naturalSize;
-    return { width, height, surfaceOf: (l) => this.surfaceOf(l), version: this.sourceVersion() };
+    return { width, height, surfaceOf: (l) => this.surfaceOf(l), version: this.sourceVersion(), globalLight: this.state.globalLight };
   }
   sourceIds = /* @__PURE__ */ new WeakMap();
   nextSourceId = 1;
@@ -8104,6 +8222,55 @@ var ImageEditorController = class {
     this.commitLayers(next);
     return findLayer(next, id).layer.filters ?? [];
   }
+  // --- Layer effects ---
+  /** A layer's effects (an empty, enabled list when it has none). */
+  getLayerEffects(id) {
+    return layerEffectsOf(requireLayer(this.state.layers, id).layer);
+  }
+  /**
+   * Adds an effect of `kind` with Photoshop's defaults and `params` applied (one undo step), at
+   * `index` in the layer's effect list (default the end). Returns the new effect and the effects.
+   */
+  addLayerEffect(id, kind, params = {}, index) {
+    const res = addLayerEffect(this.state.layers, id, kind, params, index);
+    this.commitLayers(res.layers);
+    return { effect: res.effect, effects: this.getLayerEffects(id) };
+  }
+  /** Changes one effect (one undo step, or none with `commitToHistory = false` during a drag). Returns the effects. */
+  updateLayerEffect(id, effectId, changes, commitToHistory = true) {
+    this.commitLayers(updateLayerEffect(this.state.layers, id, effectId, changes), void 0, commitToHistory);
+    return this.getLayerEffects(id);
+  }
+  /** Removes one effect (one undo step). Returns the remaining effects. */
+  removeLayerEffect(id, effectId) {
+    this.commitLayers(removeLayerEffect(this.state.layers, id, effectId));
+    return this.getLayerEffects(id);
+  }
+  /** Turns a layer's effects on or off as a whole and, when given, sets Scale Effects (one undo step). */
+  setLayerEffectsEnabled(id, enabled, scale, commitToHistory = true) {
+    this.commitLayers(setLayerEffectsEnabled(this.state.layers, id, enabled, scale), void 0, commitToHistory);
+    return this.getLayerEffects(id);
+  }
+  /** Replaces a layer's effects (one undo step; `null` removes them). Returns the effects. */
+  setLayerEffects(id, effects, commitToHistory = true) {
+    this.commitLayers(setLayerEffects(this.state.layers, id, effects), void 0, commitToHistory);
+    return this.getLayerEffects(id);
+  }
+  /** The light effects with "use global light" follow. */
+  getGlobalLight() {
+    return { ...this.state.globalLight ?? DEFAULT_GLOBAL_LIGHT };
+  }
+  /** Sets the global light (one undo step). `angle` -360..360°, `altitude` 0..90°. Returns it. */
+  setGlobalLight(light, commitToHistory = true) {
+    const next = { ...this.getGlobalLight(), ...light };
+    if (!(Number.isFinite(next.angle) && next.angle >= -360 && next.angle <= 360)) throw new LayerOperationError(`angle must be from -360 to 360 degrees, got ${next.angle}.`);
+    if (!(Number.isFinite(next.altitude) && next.altitude >= 0 && next.altitude <= 90)) throw new LayerOperationError(`altitude must be from 0 to 90 degrees, got ${next.altitude}.`);
+    if (commitToHistory) this.recordHistory();
+    if (next.angle === DEFAULT_GLOBAL_LIGHT.angle && next.altitude === DEFAULT_GLOBAL_LIGHT.altitude) delete this.state.globalLight;
+    else this.state.globalLight = next;
+    this.notify();
+    return this.getGlobalLight();
+  }
   /** Composites `layers` (in isolation) over `rect` into a surface, loading depth maps first. */
   async compositeToSurface(layers, rect) {
     const { width, height } = this.naturalSize;
@@ -8133,7 +8300,8 @@ var ImageEditorController = class {
   }
   /**
    * Merge Down: composites a layer onto the pixel layer directly below it (which keeps its name,
-   * opacity and blend; masks, fill and filters are baked), as one undo step. Returns the merged id.
+   * opacity and blend; masks, fill, filters and both layers' effects are baked), as one undo step.
+   * Returns the merged id.
    */
   async mergeDown(id) {
     const loc = requireLayer(this.state.layers, id);
@@ -8145,7 +8313,9 @@ var ImageEditorController = class {
     if (!upper.visible) throw new LayerOperationError(`Layer "${upper.name || id}" is hidden; show it or delete it instead of merging.`);
     requireUnlocked(upper, "all", "merge it");
     requireUnlocked(lower, "pixels", "merge into it");
-    const rect = unionRect(this.paintBounds(lower), upper.type === "adjustment" ? null : this.paintBounds(upper)) ?? { x: 0, y: 0, width: 1, height: 1 };
+    let rect = unionRect(this.paintBounds(lower), upper.type === "adjustment" ? null : this.paintBounds(upper)) ?? { x: 0, y: 0, width: 1, height: 1 };
+    const reach = Math.max(effectsMargin(lower.effects), upper.type === "adjustment" ? 0 : effectsMargin(upper.effects));
+    if (reach) rect = { x: rect.x - reach, y: rect.y - reach, width: rect.width + 2 * reach, height: rect.height + 2 * reach };
     const base = { ...lower, blend: "normal", opacity: 1 };
     delete base.clipped;
     const surface = await this.compositeToSurface([base, upper], rect);
@@ -8154,6 +8324,7 @@ var ImageEditorController = class {
     delete merged.fillOpacity;
     delete merged.filters;
     delete merged.source;
+    delete merged.effects;
     let next = mapLayer(this.state.layers, id, () => null);
     next = mapLayer(next, lower.id, () => merged);
     this.commitLayers(next, () => {
@@ -8261,12 +8432,38 @@ var ImageEditorController = class {
     const next = {
       brush: options.brush ? normalizeBrush({ ...cur.brush, ...options.brush }) : cur.brush,
       foreground: options.foreground !== void 0 ? toHex2(parseColor(options.foreground)) : cur.foreground,
-      background: options.background !== void 0 ? toHex2(parseColor(options.background)) : cur.background
+      background: options.background !== void 0 ? toHex2(parseColor(options.background)) : cur.background,
+      mixer: options.mixer ? normalizeMixer({ ...cur.mixer, ...options.mixer }) : cur.mixer,
+      mixerLoad: cur.mixerLoad
     };
     this.state.paint = next;
     this.notify();
     return next;
   }
+  /**
+   * Loads the Mixer Brush's reservoir full with `color` (default the foreground); the picked-up
+   * colour is kept. View state, no undo. Returns the brush load.
+   */
+  loadMixerBrush(color) {
+    const c = parseColor(color ?? this.state.paint.foreground);
+    const load = loadMixer(this.state.paint.mixerLoad, [c[0] / 255, c[1] / 255, c[2] / 255]);
+    this.state.paint = { ...this.state.paint, mixerLoad: load };
+    this.notify();
+    return load;
+  }
+  /** Cleans the Mixer Brush: empties the pickup well (the reservoir is kept). Returns the brush load. */
+  cleanMixerBrush() {
+    const load = cleanMixer(this.state.paint.mixerLoad);
+    this.state.paint = { ...this.state.paint, mixerLoad: load };
+    this.notify();
+    return load;
+  }
+  /** Empties the Mixer Brush entirely (no reservoir, nothing picked up). Returns the brush load. */
+  emptyMixerBrush() {
+    this.state.paint = { ...this.state.paint, mixerLoad: EMPTY_MIXER_LOAD };
+    this.notify();
+    return EMPTY_MIXER_LOAD;
+  }
   /** D: black foreground, white background. */
   resetPaintColors() {
     this.setPaintOptions({ foreground: "#000000", background: "#ffffff" });
@@ -8311,7 +8508,11 @@ 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 (tool === "mixer" && target.channel === "mask") {
+      throw new LayerOperationError("The Mixer Brush paints colour on pixels, not on masks; target pixels (channel pixels), or paint the mask with the brush.");
+    }
     const brush = normalizeBrush({ ...this.state.paint.brush, ...init.brush ?? {} });
     const color = parseColor(init.color ?? this.state.paint.foreground);
     const background = parseColor(init.background ?? this.state.paint.background);
@@ -8329,8 +8530,26 @@ var ImageEditorController = class {
       selection: this.state.selection?.bounds ? this.state.selection : null,
       offset: target.offset
     };
+    if (tool === "mixer") return new PaintStrokeSession(this, target, this.mixerStroke(init, brush), apply);
     return new PaintStrokeSession(this, target, new StrokeCoverage(brush), apply);
   }
+  /** 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 ?? {} });
+    let load = this.state.paint.mixerLoad;
+    if (init.color !== void 0 || settings.loadEachStroke) {
+      const c = parseColor(init.color ?? this.state.paint.foreground);
+      load = loadMixer(load, [c[0] / 255, c[1] / 255, c[2] / 255]);
+    }
+    return {
+      create: (pixels) => new MixerStroke(brush, settings, load, pixels),
+      end: (after) => {
+        const next = settings.cleanEachStroke ? cleanMixer(after) : after;
+        this.state.paint = { ...this.state.paint, mixerLoad: next };
+        return next;
+      }
+    };
+  }
   /** @internal Shows a stroke's live surface (no history). */
   _strokeUpdate(layerId, channel, surface, rects) {
     this.state.layers = mapLayer(this.state.layers, layerId, (l) => this.withSurface(l, channel, surface));
@@ -8354,7 +8573,7 @@ var ImageEditorController = class {
   }
   /**
    * Paints a whole stroke in one call (agents, replays): `points` in document pixels with optional
-   * pressure, through the brush or eraser. One undo step. Returns the layer, channel, the changed
+   * pressure, through the brush, eraser or Mixer Brush. One undo step. Returns the layer, channel, the changed
    * document bounds and the number of dabs.
    */
   paintStroke(init) {
@@ -9363,6 +9582,11 @@ var ImageEditorController = class {
       return baked;
     };
     const prepare = async (layer) => {
+      const p = await prepareLayer(layer);
+      if (p?.blend === "pigment") add("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
+      return p;
+    };
+    const prepareLayer = async (layer) => {
       if (layer.type === "group") {
         const children = [];
         for (const c of layer.children) {
@@ -9534,6 +9758,9 @@ var ImageEditorController = class {
       if (typeof data.legacyOutputBlur === "number" && data.legacyOutputBlur >= 0) s.legacyOutputBlur = data.legacyOutputBlur;
       else delete s.legacyOutputBlur;
       s.activeLayerId = data.activeLayerId && findLayer(s.layers, data.activeLayerId) ? data.activeLayerId : null;
+      const light = data.globalLight;
+      if (light && Number.isFinite(light.angle) && Number.isFinite(light.altitude)) s.globalLight = { angle: light.angle, altitude: Math.min(90, Math.max(0, light.altitude)) };
+      else delete s.globalLight;
       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 };
       }
@@ -9547,6 +9774,7 @@ var ImageEditorController = class {
       s.crop = data.crop ? { ...data.crop } : null;
       s.transform = { ...data.transform };
       s.activeLayerId = null;
+      delete s.globalLight;
     }
     s.activeTarget = "pixels";
     this.viewKey = [];
@@ -9556,7 +9784,7 @@ var ImageEditorController = class {
   serializeState() {
     const { width, height } = this.naturalSize;
     const view = legacyView(this.stack(), width, height, null);
-    if (view.exact) {
+    if (view.exact && !this.state.globalLight) {
       return {
         // States without adjustment layers keep schema 1, so they round-trip unchanged.
         version: view.adjustments.layers?.length ? 2 : 1,
@@ -9583,6 +9811,7 @@ var ImageEditorController = class {
       opacity: this.state.outputOpacity
     };
     if (this.state.legacyOutputBlur !== void 0) out.legacyOutputBlur = this.state.legacyOutputBlur;
+    if (this.state.globalLight) out.globalLight = { ...this.state.globalLight };
     return out;
   }
 };
@@ -10820,6 +11049,7 @@ function describeLayer(layer, activeId, boundsOf) {
     clipped: Boolean(layer.clipped),
     locks: layer.locks ? { ...layer.locks } : {},
     mask: maskSummary(layer.mask),
+    effects: layer.effects ? { enabled: layer.effects.enabled, scale: layer.effects.scale ?? 1, items: layer.effects.items.map((e) => ({ id: e.id, kind: e.kind, enabled: e.enabled })) } : null,
     active: layer.id === activeId
   };
   switch (layer.type) {
@@ -10879,7 +11109,7 @@ function createImageLayerTools(controller) {
   const listLayers = {
     name: "list_layers",
     title: "List image layers",
-    description: "Returns the layer stack bottom to top as a tree: id, type (pixel, adjustment, group, annotation), name, document bounds (pixel layers), visible, opacity, fillOpacity, blend, clipped, locks, a mask summary, filters (pixel layers), kind and params (adjustment layers), children (groups) and which layer is active. Also returns the active layer id and target (pixels or mask) and the canvas size.",
+    description: "Returns the layer stack bottom to top as a tree: id, type (pixel, adjustment, group, annotation), name, document bounds (pixel layers), visible, opacity, fillOpacity, blend, clipped, locks, a mask summary, an effects summary (master switch, scale, effect ids and kinds; details from list_layer_effects), filters (pixel layers), kind and params (adjustment layers), children (groups) and which layer is active. Also returns the active layer id and target (pixels or mask) and the canvas size.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     annotations: { title: "List image layers", ...READ2 },
     handler: () => {
@@ -11315,9 +11545,491 @@ function createImageLayerTools(controller) {
   ];
 }
 
-// src/image-editor/paint-tools.ts
+// src/image-editor/effect-tools.ts
+var READ3 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE2 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var LAYER_ID3 = { type: "string", description: "Layer id from list_layers (a pixel, annotation or group layer)." };
+var EFFECT_ID = { type: "string", description: "Effect id from list_layer_effects or add_layer_effect." };
+var BLEND_IDS = BLEND_MODES.map((m) => m.id);
+var DEFS = {
+  color: { type: "string", pattern: "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$", description: "Colour as #rrggbb." },
+  contour: {
+    type: "object",
+    description: "A transfer curve over the effect coverage: points { input, output } from 0 to 1 (at least 2), sorted by input. Linear is [{0,0},{1,1}].",
+    properties: {
+      name: { type: "string", description: 'Display name (e.g. "Cone", "Gaussian").' },
+      points: {
+        type: "array",
+        minItems: 2,
+        description: "Curve points.",
+        items: {
+          type: "object",
+          properties: {
+            input: { type: "number", minimum: 0, maximum: 1, description: "Coverage in (0..1)." },
+            output: { type: "number", minimum: 0, maximum: 1, description: "Coverage out (0..1)." },
+            corner: { type: "boolean", description: "Sharp corner instead of a smooth point (default false)." }
+          },
+          required: ["input", "output"],
+          additionalProperties: false
+        }
+      }
+    },
+    required: ["name", "points"],
+    additionalProperties: false
+  },
+  gradient: {
+    type: "object",
+    description: "A gradient: colour stops, optional opacity stops and its layout.",
+    properties: {
+      stops: {
+        type: "array",
+        minItems: 1,
+        description: "Colour stops { position 0..1, color #rrggbb }.",
+        items: {
+          type: "object",
+          properties: { position: { type: "number", minimum: 0, maximum: 1, description: "0..1 along the gradient." }, color: { $ref: "#/$defs/color" } },
+          required: ["position", "color"],
+          additionalProperties: false
+        }
+      },
+      opacityStops: {
+        type: "array",
+        description: "Opacity stops { position 0..1, opacity 0..1 } (default opaque).",
+        items: {
+          type: "object",
+          properties: {
+            position: { type: "number", minimum: 0, maximum: 1, description: "0..1 along the gradient." },
+            opacity: { type: "number", minimum: 0, maximum: 1, description: "0..1." }
+          },
+          required: ["position", "opacity"],
+          additionalProperties: false
+        }
+      },
+      style: { type: "string", enum: ["linear", "radial", "angle", "reflected", "diamond"], description: "Geometry." },
+      angle: { type: "number", minimum: -360, maximum: 360, description: "Degrees, 90 = bottom to top." },
+      scale: { type: "number", minimum: 0.1, maximum: 1.5, description: "1 = 100 %." },
+      reverse: { type: "boolean", description: "Swap the ends." },
+      align: { type: "boolean", description: "Lay out over the layer bounds (true) or the canvas." },
+      offset: {
+        type: "object",
+        description: "Centre offset as fractions of the bounds.",
+        properties: { x: { type: "number", minimum: -1, maximum: 1, description: "Fraction of the width." }, y: { type: "number", minimum: -1, maximum: 1, description: "Fraction of the height." } },
+        required: ["x", "y"],
+        additionalProperties: false
+      }
+    },
+    required: ["stops", "style", "angle", "scale", "reverse", "align", "offset"],
+    additionalProperties: false
+  },
+  phase: {
+    type: "object",
+    description: "Pattern origin offset in px.",
+    properties: { x: { type: "number", description: "px." }, y: { type: "number", description: "px." } },
+    required: ["x", "y"],
+    additionalProperties: false
+  },
+  fill: {
+    description: "What a stroke or glow paints with. Glows take color or gradient only.",
+    anyOf: [
+      {
+        type: "object",
+        properties: { type: { const: "color", description: "Solid colour." }, color: { $ref: "#/$defs/color" } },
+        required: ["type", "color"],
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        properties: { type: { const: "gradient", description: "Gradient." }, gradient: { $ref: "#/$defs/gradient" } },
+        required: ["type", "gradient"],
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        properties: {
+          type: { const: "pattern", description: "Pattern (strokes only)." },
+          patternId: { type: "string", description: "Pattern id from list_layer_effects.patterns." },
+          name: { type: "string", description: "Display name." },
+          scale: { type: "number", minimum: 0.01, maximum: 10, description: "1 = 100 %." },
+          angle: { type: "number", minimum: -360, maximum: 360, description: "Rotation in degrees (default 0)." },
+          link: { type: "boolean", description: "Tile from the layer (default true) or the canvas origin." },
+          phase: { $ref: "#/$defs/phase" }
+        },
+        required: ["type", "patternId", "scale"],
+        additionalProperties: false
+      }
+    ]
+  }
+};
+var nullable = (schema, description) => ({ anyOf: [schema, { type: "null" }], description });
+function settingsSchema(forUpdate) {
+  const opt = (schema, description) => forUpdate ? nullable(schema, `${description} null removes it.`) : { ...schema, description };
+  return {
+    type: "object",
+    description: forUpdate ? "Settings to change (only these; nested objects are replaced whole). Which settings a kind takes: see add_layer_effect." : "Settings to change from Photoshop's defaults (all optional). Unknown settings for the kind are refused with the list of its settings.",
+    properties: {
+      enabled: { type: "boolean", description: "All kinds: false keeps the effect but hides it (default true)." },
+      blend: { type: "string", enum: BLEND_IDS, description: "All but bevel-emboss: blend mode (shadows multiply, glows screen, others normal)." },
+      opacity: { type: "number", minimum: 0, maximum: 1, description: "All but bevel-emboss: 0..1 (shadows / glows 0.75, satin 0.5, others 1)." },
+      color: { $ref: "#/$defs/color", description: "drop-shadow, inner-shadow, satin, color-overlay: #rrggbb." },
+      angle: { type: "number", minimum: -360, maximum: 360, description: "Shadows, satin, bevel-emboss: light direction in degrees, counter-clockwise from 3 o'clock (default 120; satin 19)." },
+      useGlobalLight: { type: "boolean", description: "Shadows, bevel-emboss: follow the document global light instead of angle (default true)." },
+      distance: { type: "number", minimum: 0, maximum: 3e4, description: "Shadows, satin: offset in px (default 5; satin 11)." },
+      spread: { type: "number", minimum: 0, maximum: 1, description: "drop-shadow, outer-glow: 0..1 of the size made solid (default 0)." },
+      choke: { type: "number", minimum: 0, maximum: 1, description: "inner-shadow, inner-glow: 0..1 of the size made solid (default 0)." },
+      size: { type: "number", minimum: 0, maximum: 250, description: "Shadows, glows, satin, bevel-emboss: blur / size in px (default 5; satin 14); stroke: width in px (default 3)." },
+      contour: opt({ $ref: "#/$defs/contour" }, "Shadows, glows, satin: coverage contour (default linear)."),
+      antiAlias: { type: "boolean", description: "Shadows, glows, satin: smooth the contour (default false; satin true)." },
+      noise: { type: "number", minimum: 0, maximum: 1, description: "Shadows, glows: speckle 0..1 (default 0)." },
+      knocksOut: { type: "boolean", description: "drop-shadow: the layer hides the shadow beneath its see-through fill (default true)." },
+      fill: { $ref: "#/$defs/fill", description: "outer-glow, inner-glow (color or gradient), stroke (color, gradient or pattern)." },
+      technique: { type: "string", enum: ["softer", "precise", "smooth", "chisel-hard", "chisel-soft"], description: "Glows: softer | precise (default softer); bevel-emboss: smooth | chisel-hard | chisel-soft (default smooth)." },
+      range: { type: "number", minimum: 0.01, maximum: 1, description: "Glows: the part of the glow the contour spans (default 0.5)." },
+      jitter: { type: "number", minimum: 0, maximum: 1, description: "Glows: gradient jitter 0..1 (stored, not rendered; default 0)." },
+      source: { type: "string", enum: ["edge", "center"], description: "inner-glow: glow from the edge (default) or the centre." },
+      style: { type: "string", enum: ["inner-bevel", "outer-bevel", "emboss", "pillow-emboss", "stroke-emboss"], description: "bevel-emboss: style (default inner-bevel)." },
+      depth: { type: "number", minimum: 0, maximum: 10, description: "bevel-emboss: depth, 1 = 100 % (default 1)." },
+      direction: { type: "string", enum: ["up", "down"], description: "bevel-emboss: raised (up, default) or sunk (down)." },
+      soften: { type: "number", minimum: 0, maximum: 16, description: "bevel-emboss: blur of the height in px (default 0)." },
+      altitude: { type: "number", minimum: 0, maximum: 90, description: "bevel-emboss: light altitude in degrees (default 30)." },
+      glossContour: opt({ $ref: "#/$defs/contour" }, "bevel-emboss: gloss contour over the shading (default linear)."),
+      highlightColor: { $ref: "#/$defs/color", description: "bevel-emboss: highlight colour (default #ffffff)." },
+      highlightBlend: { type: "string", enum: BLEND_IDS, description: "bevel-emboss: highlight mode (default screen)." },
+      highlightOpacity: { type: "number", minimum: 0, maximum: 1, description: "bevel-emboss: highlight opacity (default 0.75)." },
+      shadowColor: { $ref: "#/$defs/color", description: "bevel-emboss: shadow colour (default #000000)." },
+      shadowBlend: { type: "string", enum: BLEND_IDS, description: "bevel-emboss: shadow mode (default multiply)." },
+      shadowOpacity: { type: "number", minimum: 0, maximum: 1, description: "bevel-emboss: shadow opacity (default 0.75)." },
+      contourElement: opt(
+        {
+          type: "object",
+          properties: {
+            contour: { $ref: "#/$defs/contour" },
+            range: { type: "number", minimum: 0, maximum: 1, description: "Stored range (default 0.5)." },
+            antiAlias: { type: "boolean", description: "Smooth the contour." }
+          },
+          required: ["contour", "range", "antiAlias"],
+          additionalProperties: false
+        },
+        "bevel-emboss: the Contour element, shaping the bevel's height profile (default off)."
+      ),
+      texture: opt(
+        {
+          type: "object",
+          properties: {
+            patternId: { type: "string", description: "Pattern id from list_layer_effects.patterns." },
+            name: { type: "string", description: "Display name." },
+            scale: { type: "number", minimum: 0.01, maximum: 10, description: "1 = 100 %." },
+            depth: { type: "number", minimum: -10, maximum: 10, description: "1 = +100 %; negative carves the pattern in." },
+            invert: { type: "boolean", description: "Invert the pattern." },
+            link: { type: "boolean", description: "Tile from the layer (default true)." },
+            phase: { $ref: "#/$defs/phase" }
+          },
+          required: ["patternId", "scale", "depth", "invert"],
+          additionalProperties: false
+        },
+        "bevel-emboss: the Texture element, a pattern's luminance as extra height (default off)."
+      ),
+      invert: { type: "boolean", description: "satin: invert (default true)." },
+      gradient: { $ref: "#/$defs/gradient", description: "gradient-overlay: the gradient (default black to white, 90\xB0)." },
+      dither: { type: "boolean", description: "gradient-overlay: dither (stored; default false)." },
+      patternId: { type: "string", description: "pattern-overlay: pattern id from list_layer_effects.patterns (default checker)." },
+      name: { type: "string", description: "pattern-overlay: pattern display name." },
+      scale: { type: "number", minimum: 0.01, maximum: 10, description: "pattern-overlay: 1 = 100 % (default 1)." },
+      link: { type: "boolean", description: "pattern-overlay: tile from the layer (default true) or the canvas origin." },
+      phase: { $ref: "#/$defs/phase", description: "pattern-overlay: origin offset in px (default 0, 0)." },
+      position: { type: "string", enum: ["outside", "inside", "center"], description: "stroke: where the stroke sits on the edge (default outside)." }
+    },
+    additionalProperties: false
+  };
+}
+function patternList() {
+  return builtinPatternIds().map((id) => {
+    const p = builtinPattern(id);
+    return { id, name: p.name, width: p.width, height: p.height, builtin: true };
+  });
+}
+function describeLayerEffects(effects) {
+  return {
+    enabled: effects.enabled,
+    scale: effects.scale ?? 1,
+    margin: effectsMargin(effects),
+    fromPsd: Boolean(effects.psd),
+    effects: effects.items.map((e) => ({ ...JSON.parse(JSON.stringify(e)), label: layerEffectLabel(e.kind) }))
+  };
+}
+function createImageEffectTools(controller) {
+  const layerArg = (id) => {
+    if (typeof id !== "string" || !id) throw new LayerOperationError("layerId is required (a layer id from list_layers).");
+    requireLayer(controller.getLayers(), id);
+    return id;
+  };
+  const result = (layerId, extra = {}) => ({ layerId, ...extra, ...describeLayerEffects(controller.getLayerEffects(layerId)) });
+  const list = {
+    name: "list_layer_effects",
+    title: "List layer effects",
+    description: "Returns a layer's effects: the master switch (enabled), Scale Effects (scale, 1 = 100 %), margin (px the effects reach beyond the shape), whether they came from a PSD, and every effect with its id, kind, label and all settings. Also returns the document global light and the pattern ids pattern effects can use.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "List layer effects", ...READ3 },
+    handler: ({ layerId }) => result(layerArg(layerId), { globalLight: controller.getGlobalLight(), patterns: patternList(), kinds: [...LAYER_EFFECT_KINDS] })
+  };
+  const add = {
+    name: "add_layer_effect",
+    title: "Add a layer effect",
+    description: "Adds a live effect to a pixel, annotation or group layer with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). One undo step. Returns the new effect's id and the layer's effects.",
+    inputSchema: {
+      type: "object",
+      $defs: DEFS,
+      properties: {
+        layerId: LAYER_ID3,
+        kind: { type: "string", enum: [...LAYER_EFFECT_KINDS], description: "Effect kind." },
+        settings: settingsSchema(false),
+        index: { type: "integer", minimum: 0, description: "Position in the layer's effect list (default the end)." }
+      },
+      required: ["layerId", "kind"],
+      additionalProperties: false
+    },
+    annotations: { title: "Add a layer effect", ...WRITE3 },
+    handler: ({ layerId, kind, settings, index }) => {
+      const id = layerArg(layerId);
+      if (!isLayerEffectKind(kind)) throw new LayerOperationError(`kind must be one of ${LAYER_EFFECT_KINDS.join(", ")}.`);
+      const { effect } = controller.addLayerEffect(id, kind, settings ?? {}, index);
+      return result(id, { effectId: effect.id });
+    }
+  };
+  const update = {
+    name: "update_layer_effect",
+    title: "Change a layer effect",
+    description: "Changes settings of one effect (only the given ones; fill, gradient, contour and texture objects are replaced whole, null removes an optional contour or texture). The kind cannot change. Validates everything before changing anything. One undo step. Returns the layer's effects.",
+    inputSchema: {
+      type: "object",
+      $defs: DEFS,
+      properties: { layerId: LAYER_ID3, effectId: EFFECT_ID, settings: settingsSchema(true) },
+      required: ["layerId", "effectId", "settings"],
+      additionalProperties: false
+    },
+    annotations: { title: "Change a layer effect", ...WRITE_IDEMPOTENT3 },
+    handler: ({ layerId, effectId, settings }) => {
+      const id = layerArg(layerId);
+      const changes = settings ?? {};
+      if (!Object.keys(changes).length) throw new LayerOperationError("Give at least one setting to change.");
+      controller.updateLayerEffect(id, effectId, changes);
+      return result(id);
+    }
+  };
+  const remove = {
+    name: "remove_layer_effect",
+    title: "Remove a layer effect",
+    description: "Removes one effect from a layer (to hide it but keep its settings, set enabled false with update_layer_effect instead). One undo step. Returns the layer's remaining effects.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3, effectId: EFFECT_ID }, required: ["layerId", "effectId"], additionalProperties: false },
+    annotations: { title: "Remove a layer effect", ...DESTRUCTIVE2 },
+    handler: ({ layerId, effectId }) => {
+      const id = layerArg(layerId);
+      controller.removeLayerEffect(id, effectId);
+      return result(id);
+    }
+  };
+  const setEnabled = {
+    name: "set_layer_effects_enabled",
+    title: "Switch layer effects on or off",
+    description: "Turns all of a layer's effects on or off at once (the master switch; each effect keeps its own enabled flag) and optionally sets Scale Effects, which multiplies every size, distance and pattern scale. One undo step. Returns the layer's effects.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID3,
+        enabled: { type: "boolean", description: "true renders the enabled effects; false hides them all." },
+        scale: { type: "number", minimum: 0.01, maximum: 10, description: "Scale Effects, 1 = 100 % (unchanged when left out)." }
+      },
+      required: ["layerId", "enabled"],
+      additionalProperties: false
+    },
+    annotations: { title: "Switch layer effects on or off", ...WRITE_IDEMPOTENT3 },
+    handler: ({ layerId, enabled, scale }) => {
+      const id = layerArg(layerId);
+      controller.setLayerEffectsEnabled(id, enabled, scale);
+      return result(id);
+    }
+  };
+  const light = {
+    name: "set_global_light",
+    title: "Set the global light",
+    description: "Sets the document global light that shadows and bevels with useGlobalLight follow (Photoshop default: angle 120\xB0, altitude 30\xB0). One undo step. Returns the light.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        angle: { type: "number", minimum: -360, maximum: 360, description: "Degrees, counter-clockwise from 3 o'clock: where the light comes from (unchanged when left out)." },
+        altitude: { type: "number", minimum: 0, maximum: 90, description: "Degrees above the canvas, for bevels (unchanged when left out)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Set the global light", ...WRITE_IDEMPOTENT3 },
+    handler: ({ angle, altitude }) => {
+      if (angle === void 0 && altitude === void 0) throw new LayerOperationError("Give angle, altitude or both.");
+      const next = {};
+      if (angle !== void 0) next.angle = angle;
+      if (altitude !== void 0) next.altitude = altitude;
+      return { globalLight: controller.setGlobalLight(next) };
+    }
+  };
+  return [list, add, update, remove, setEnabled, light];
+}
+
+// src/image-editor/layers/paint-ui.ts
+var plain2 = { kind: "plain" };
+var BRUSH_OPTION_CONTROLS = [
+  { id: "size", label: "Size", section: "layer", min: 1, max: 500, step: 1, default: 20, decimals: 0, track: plain2, unit: "px" },
+  { id: "hardness", label: "Hardness", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "opacity", label: "Opacity", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "flow", label: "Flow", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "smoothing", label: "Smoothing", section: "layer", min: 0, max: 0.95, step: 0.01, default: 0, decimals: 0, track: plain2, displayScale: 100, unit: "%" }
+];
+var MIXER_OPTION_CONTROLS = [
+  { id: "wet", label: "Wet", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "load", label: "Load", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "mix", label: "Mix", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" }
+];
+var MIXER_MIXING_OPTIONS = [
+  { id: "rgb", label: "RGB", title: "Mix colours as RGB averages" },
+  { id: "pigment", label: "Pigment", title: "Mix colours like paint: blue and yellow make green" }
+];
+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" }
+];
+var isPaintTool = (tool) => tool === "move" || tool === "brush" || tool === "mixer" || tool === "eraser";
+function rgbUnitToHex(c) {
+  return `#${c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+function sizeStep(size) {
+  return size < 10 ? 1 : size < 50 ? 5 : size < 100 ? 10 : size < 200 ? 25 : size < 500 ? 50 : 100;
+}
+var isTyping = (t) => {
+  const el = t;
+  return Boolean(el && (el.isContentEditable || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT"));
+};
+function handlePaintShortcut(controller, e) {
+  if (e.ctrlKey || e.metaKey || e.altKey || isTyping(e.target)) return false;
+  const brush = controller.getState().paint.brush;
+  const set = (b) => controller.setPaintOptions({ brush: b });
+  const key = e.key;
+  switch (key.toLowerCase()) {
+    case "b":
+      controller.setTool(e.shiftKey || key === "B" ? "mixer" : "brush");
+      return true;
+    case "e":
+      controller.setTool("eraser");
+      return true;
+    case "v":
+      controller.setTool("move");
+      return true;
+    case "d":
+      controller.resetPaintColors();
+      return true;
+    case "x":
+      controller.swapPaintColors();
+      return true;
+  }
+  if (key === "[" || key === "{") {
+    if (e.shiftKey || key === "{") set({ hardness: Math.max(0, Math.round((brush.hardness - 0.25) * 4) / 4) });
+    else set({ size: Math.max(1, brush.size - sizeStep(brush.size - 1)) });
+    return true;
+  }
+  if (key === "]" || key === "}") {
+    if (e.shiftKey || key === "}") set({ hardness: Math.min(1, Math.round((brush.hardness + 0.25) * 4) / 4) });
+    else set({ size: Math.min(MAX_BRUSH_SIZE, brush.size + sizeStep(brush.size)) });
+    return true;
+  }
+  if (/^[0-9]$/.test(key) && isPaintTool(controller.getState().activeTool)) {
+    set({ opacity: key === "0" ? 1 : Number(key) / 10 });
+    return true;
+  }
+  return false;
+}
+function pointerPressure(e) {
+  if (e.pointerType === "pen" && typeof e.pressure === "number" && e.pressure > 0) return Math.min(1, e.pressure);
+  return 1;
+}
+var PaintGesture = class {
+  constructor(controller) {
+    this.controller = controller;
+  }
+  controller;
+  stroke = null;
+  move = null;
+  /** The last refusal (e.g. "layer is locked"), for the editor to show. */
+  error = null;
+  get active() {
+    return Boolean(this.stroke || this.move);
+  }
+  down(sample) {
+    this.error = null;
+    const tool = this.controller.getState().activeTool;
+    try {
+      if (tool === "move") {
+        const layer = this.controller.getActiveLayer();
+        if (!layer) throw new Error("Select a layer to move in the Layers panel.");
+        if (layer.type !== "pixel") throw new Error(`Only pixel layers move; "${layer.name}" is a ${layer.type} layer.`);
+        if (layer.locks?.all || layer.locks?.position) throw new Error(`Layer "${layer.name}" has its position locked.`);
+        this.move = { id: layer.id, start: { x: sample.x, y: sample.y }, origin: { ...layer.offset }, moved: false };
+        return null;
+      }
+      if (tool === "brush" || tool === "eraser" || tool === "mixer") {
+        this.stroke = this.controller.beginStroke({ tool });
+        this.stroke.push([sample]);
+        return null;
+      }
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+      this.stroke = null;
+      this.move = null;
+    }
+    return this.error;
+  }
+  /** Feeds pointer samples (all coalesced events of one move, in order). */
+  moveTo(samples) {
+    if (!samples.length) return;
+    if (this.stroke) {
+      this.stroke.push(samples);
+      return;
+    }
+    const m = this.move;
+    if (m) {
+      const last = samples[samples.length - 1];
+      const x = m.origin.x + Math.round(last.x - m.start.x);
+      const y = m.origin.y + Math.round(last.y - m.start.y);
+      try {
+        this.controller.offsetLayer(m.id, { x, y }, !m.moved);
+        m.moved = true;
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+        this.move = null;
+      }
+    }
+  }
+  up() {
+    if (this.stroke) {
+      try {
+        this.stroke.end();
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+    }
+    this.stroke = null;
+    this.move = null;
+  }
+  cancel() {
+    this.stroke?.cancel();
+    this.stroke = null;
+    this.move = null;
+  }
+};
+
+// src/image-editor/paint-tools.ts
+var READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var TARGET = {
   layerId: { type: "string", description: "Layer to paint (default the active layer; see list_layers)." },
   channel: { type: "string", enum: ["pixels", "mask"], description: "pixels (default for a pixel layer) or the layer's mask: black hides, white reveals." }
@@ -11336,10 +12048,30 @@ var BRUSH = {
     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)." },
-    blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "How paint combines with the layer (default normal)." }
+    blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "How paint combines with the layer (default normal). pigment mixes it in like real paint (blue into yellow gives green) instead of laying it over." }
   },
   additionalProperties: false
 };
+var MIXER = {
+  type: "object",
+  description: "Mixer Brush settings (tool mixer only); missing fields use the current mixer options (wet 0.5, load 0.5, mix 0.5, loadEachStroke true, cleanEachStroke true, mixing rgb).",
+  properties: {
+    wet: { type: "number", minimum: 0, maximum: 1, description: "How much canvas colour each dab picks up, 0 (dry: paints only the reservoir) .. 1 (default 0.5)." },
+    load: { type: "number", minimum: 0, maximum: 1, description: "How much paint the reservoir holds, 0 .. 1 (default 0.5); below 1 it drains per dab, so long strokes run dry." },
+    mix: { type: "number", minimum: 0, maximum: 1, description: "How far each dab's paint moves from the reservoir towards the picked-up colour, 0 .. 1 (default 0.5)." },
+    loadEachStroke: { type: "boolean", description: "Refill the reservoir with `color` (or the foreground) before the stroke (default true). Off, the brush keeps what is left of its last load." },
+    cleanEachStroke: { type: "boolean", description: "Empty the pickup well after the stroke (default true). Off, the next stroke starts with the colour this one picked up." },
+    mixing: { type: "string", enum: [...MIXING_MODELS], description: "rgb (default): RGB averages. pigment: mixes like paint (Kubelka-Munk), so blue dragged through yellow makes green." }
+  },
+  additionalProperties: false
+};
+function mixerLoadResult(load) {
+  return {
+    reservoir: load.reservoir ? rgbUnitToHex(load.reservoir) : null,
+    amount: Math.round(load.amount * 1e3) / 1e3,
+    pickup: load.pickup ? rgbUnitToHex(load.pickup) : null
+  };
+}
 function readTarget(args) {
   return { layerId: args.layerId, channel: args.channel };
 }
@@ -11347,11 +12079,11 @@ function createImagePaintTools(controller) {
   const paintStroke = {
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke with the brush (or removes pixels with the eraser) through points in document pixels (optional pressure 0..1 each) on a pixel layer or a layer mask. The selection limits the paint; a transparency-locked layer keeps its alpha (the eraser then paints the background colour). One undo step. Returns the layerId, channel, changed bounds and dab count.",
+    description: "Paints one stroke with the brush, smears and blends paint with the Mixer Brush (tool mixer: its reservoir mixes with colour picked up from the layer under each dab, in RGB or pigment mixing), or removes pixels with the eraser, through points in document pixels (optional pressure 0..1 each) on a pixel layer or a layer mask (the mixer paints pixels only). The selection limits the paint; a transparency-locked layer keeps its alpha (the eraser then paints the background colour). One undo step. Returns the layerId, channel, changed bounds and dab count, and for the mixer its mixerLoad after the stroke ({reservoir, amount, pickup}).",
     inputSchema: {
       type: "object",
       properties: {
-        tool: { type: "string", enum: ["brush", "eraser"], description: "brush (default) or eraser." },
+        tool: { type: "string", enum: ["brush", "eraser", "mixer"], description: "brush (default), eraser, or mixer (the Mixer Brush: picks up and blends the layer colour under each dab)." },
         points: {
           type: "array",
           minItems: 1,
@@ -11368,21 +12100,66 @@ function createImagePaintTools(controller) {
             additionalProperties: false
           }
         },
-        color: { type: "string", description: "Paint colour #rrggbb (default the foreground). On a mask its grey value: #000000 hides, #ffffff reveals." },
+        color: {
+          type: "string",
+          description: "Paint colour #rrggbb (default the foreground). On a mask its grey value: #000000 hides, #ffffff reveals. For the mixer, the colour its reservoir is loaded with before the stroke (given, it loads even with loadEachStroke false)."
+        },
         brush: BRUSH,
+        mixer: MIXER,
         ...TARGET
       },
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Paint a brush stroke", ...WRITE3 },
-    handler: (args) => controller.paintStroke({
-      tool: args.tool,
-      points: args.points,
-      color: args.color,
-      brush: args.brush,
-      ...readTarget(args)
-    })
+    annotations: { title: "Paint a brush stroke", ...WRITE4 },
+    handler: (args) => {
+      const tool = args.tool;
+      if (args.mixer !== void 0 && tool !== "mixer") throw new LayerOperationError('mixer settings apply to the Mixer Brush only; pass tool "mixer", or drop mixer.');
+      const result = controller.paintStroke({
+        tool,
+        points: args.points,
+        color: args.color,
+        brush: args.brush,
+        mixer: args.mixer,
+        ...readTarget(args)
+      });
+      return result.mixerLoad ? { ...result, mixerLoad: mixerLoadResult(result.mixerLoad) } : result;
+    }
+  };
+  const getMixer = {
+    name: "get_mixer_brush",
+    title: "Get the Mixer Brush",
+    description: "Reads the Mixer Brush: its settings (wet, load, mix, loadEachStroke, cleanEachStroke, mixing) and what it carries now (reservoir #rrggbb or null, amount 0..1 left, pickup #rrggbb or null). Call it before a paint_stroke with tool mixer and loadEachStroke false, to know the brush's starting paint.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Get the Mixer Brush", ...READ4 },
+    handler: () => {
+      const { mixer, mixerLoad } = controller.getState().paint;
+      return { settings: { ...mixer }, load: mixerLoadResult(mixerLoad) };
+    }
+  };
+  const loadMixerTool = {
+    name: "load_mixer_brush",
+    title: "Load the Mixer Brush",
+    description: "Fills the Mixer Brush reservoir with a colour (amount 1); the picked-up colour is kept. View state, not an undo step. Use it with loadEachStroke false to carry one load across several paint_stroke calls. Returns the load {reservoir, amount, pickup}.",
+    inputSchema: {
+      type: "object",
+      properties: { color: { type: "string", description: "Paint colour #rrggbb (default the foreground)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Load the Mixer Brush", ...WRITE4, idempotentHint: true },
+    handler: (args) => mixerLoadResult(controller.loadMixerBrush(args.color))
+  };
+  const cleanMixerTool = {
+    name: "clean_mixer_brush",
+    title: "Clean the Mixer Brush",
+    description: "Cleans the Mixer Brush: empties the pickup well so the next stroke starts without canvas colour; with emptyReservoir also drops the loaded paint (the brush then only smears). View state, not an undo step. Returns the load {reservoir, amount, pickup}.",
+    inputSchema: {
+      type: "object",
+      properties: { emptyReservoir: { type: "boolean", description: "Also drop the reservoir (default false)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Clean the Mixer Brush", ...WRITE4, idempotentHint: true },
+    handler: (args) => mixerLoadResult(args.emptyReservoir === true ? controller.emptyMixerBrush() : controller.cleanMixerBrush())
   };
   const fill = {
     name: "fill_pixels",
@@ -11393,13 +12170,13 @@ function createImagePaintTools(controller) {
       properties: {
         color: { type: "string", description: "Fill colour #rrggbb or #rrggbbaa (default the foreground)." },
         opacity: { type: "number", minimum: 0, maximum: 1, description: "Fill opacity 0..1 (default 1)." },
-        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal)." },
+        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal). pigment mixes the colour into the pixels like paint, opacity being the share of new paint." },
         useSelection: { type: "boolean", description: "Limit to the selection when there is one (default true)." },
         ...TARGET
       },
       additionalProperties: false
     },
-    annotations: { title: "Fill pixels", ...WRITE3 },
+    annotations: { title: "Fill pixels", ...WRITE4 },
     handler: (args) => controller.fillPixels({
       color: args.color,
       opacity: args.opacity,
@@ -11421,15 +12198,15 @@ function createImagePaintTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Clear pixels", ...DESTRUCTIVE2 },
+    annotations: { title: "Clear pixels", ...DESTRUCTIVE3 },
     handler: (args) => controller.clearPixels({ opacity: args.opacity, useSelection: args.useSelection, ...readTarget(args) })
   };
-  return [paintStroke, fill, clear];
+  return [paintStroke, fill, clear, getMixer, loadMixerTool, cleanMixerTool];
 }
 
 // src/image-editor/psd-tools.ts
-var READ3 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var READ5 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var DATA = {
   type: "string",
   minLength: 1,
@@ -11449,7 +12226,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", ...READ3 },
+    annotations: { title: "Inspect a PSD", ...READ5 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -11467,7 +12244,7 @@ function createImagePsdTools(controller) {
     title: "Open a PSD as the document",
     description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility and locks map directly; type, smart-object, fill and shape layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
-    annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE3 },
+    annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE4 },
     handler: ({ data }) => {
       const res = controller.loadPsd(psdBytesFromBase64(data));
       const s = controller.getState();
@@ -11486,7 +12263,7 @@ function createImagePsdTools(controller) {
     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 and masks, in the source frame (crop and rotation are not applied). 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", ...READ3 },
+    annotations: { title: "Export the document as a PSD", ...READ5 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -11740,6 +12517,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageSelectionTools(controller),
       ...createImageEditTools(controller),
       ...createImageLayerTools(controller),
+      ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
       ...createPigmentTools(),
       ...createImagePsdTools(controller)
@@ -12183,145 +12961,6 @@ async function runLayerMenuAction(controller, action) {
   }
 }
 
-// src/image-editor/layers/paint-ui.ts
-var plain2 = { kind: "plain" };
-var BRUSH_OPTION_CONTROLS = [
-  { id: "size", label: "Size", section: "layer", min: 1, max: 500, step: 1, default: 20, decimals: 0, track: plain2, unit: "px" },
-  { id: "hardness", label: "Hardness", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "opacity", label: "Opacity", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "flow", label: "Flow", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "smoothing", label: "Smoothing", section: "layer", min: 0, max: 0.95, step: 0.01, default: 0, decimals: 0, track: plain2, displayScale: 100, unit: "%" }
-];
-var PAINT_TOOLS = [
-  { id: "move", label: "Move", shortcut: "V" },
-  { id: "brush", label: "Brush", shortcut: "B" },
-  { id: "eraser", label: "Eraser", shortcut: "E" }
-];
-var isPaintTool = (tool) => tool === "move" || tool === "brush" || tool === "eraser";
-function sizeStep(size) {
-  return size < 10 ? 1 : size < 50 ? 5 : size < 100 ? 10 : size < 200 ? 25 : size < 500 ? 50 : 100;
-}
-var isTyping = (t) => {
-  const el = t;
-  return Boolean(el && (el.isContentEditable || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT"));
-};
-function handlePaintShortcut(controller, e) {
-  if (e.ctrlKey || e.metaKey || e.altKey || isTyping(e.target)) return false;
-  const brush = controller.getState().paint.brush;
-  const set = (b) => controller.setPaintOptions({ brush: b });
-  const key = e.key;
-  switch (key.toLowerCase()) {
-    case "b":
-      controller.setTool("brush");
-      return true;
-    case "e":
-      controller.setTool("eraser");
-      return true;
-    case "v":
-      controller.setTool("move");
-      return true;
-    case "d":
-      controller.resetPaintColors();
-      return true;
-    case "x":
-      controller.swapPaintColors();
-      return true;
-  }
-  if (key === "[" || key === "{") {
-    if (e.shiftKey || key === "{") set({ hardness: Math.max(0, Math.round((brush.hardness - 0.25) * 4) / 4) });
-    else set({ size: Math.max(1, brush.size - sizeStep(brush.size - 1)) });
-    return true;
-  }
-  if (key === "]" || key === "}") {
-    if (e.shiftKey || key === "}") set({ hardness: Math.min(1, Math.round((brush.hardness + 0.25) * 4) / 4) });
-    else set({ size: Math.min(MAX_BRUSH_SIZE, brush.size + sizeStep(brush.size)) });
-    return true;
-  }
-  if (/^[0-9]$/.test(key) && isPaintTool(controller.getState().activeTool)) {
-    set({ opacity: key === "0" ? 1 : Number(key) / 10 });
-    return true;
-  }
-  return false;
-}
-function pointerPressure(e) {
-  if (e.pointerType === "pen" && typeof e.pressure === "number" && e.pressure > 0) return Math.min(1, e.pressure);
-  return 1;
-}
-var PaintGesture = class {
-  constructor(controller) {
-    this.controller = controller;
-  }
-  controller;
-  stroke = null;
-  move = null;
-  /** The last refusal (e.g. "layer is locked"), for the editor to show. */
-  error = null;
-  get active() {
-    return Boolean(this.stroke || this.move);
-  }
-  down(sample) {
-    this.error = null;
-    const tool = this.controller.getState().activeTool;
-    try {
-      if (tool === "move") {
-        const layer = this.controller.getActiveLayer();
-        if (!layer) throw new Error("Select a layer to move in the Layers panel.");
-        if (layer.type !== "pixel") throw new Error(`Only pixel layers move; "${layer.name}" is a ${layer.type} layer.`);
-        if (layer.locks?.all || layer.locks?.position) throw new Error(`Layer "${layer.name}" has its position locked.`);
-        this.move = { id: layer.id, start: { x: sample.x, y: sample.y }, origin: { ...layer.offset }, moved: false };
-        return null;
-      }
-      if (tool === "brush" || tool === "eraser") {
-        this.stroke = this.controller.beginStroke({ tool });
-        this.stroke.push([sample]);
-        return null;
-      }
-    } catch (err) {
-      this.error = err instanceof Error ? err.message : String(err);
-      this.stroke = null;
-      this.move = null;
-    }
-    return this.error;
-  }
-  /** Feeds pointer samples (all coalesced events of one move, in order). */
-  moveTo(samples) {
-    if (!samples.length) return;
-    if (this.stroke) {
-      this.stroke.push(samples);
-      return;
-    }
-    const m = this.move;
-    if (m) {
-      const last = samples[samples.length - 1];
-      const x = m.origin.x + Math.round(last.x - m.start.x);
-      const y = m.origin.y + Math.round(last.y - m.start.y);
-      try {
-        this.controller.offsetLayer(m.id, { x, y }, !m.moved);
-        m.moved = true;
-      } catch (err) {
-        this.error = err instanceof Error ? err.message : String(err);
-        this.move = null;
-      }
-    }
-  }
-  up() {
-    if (this.stroke) {
-      try {
-        this.stroke.end();
-      } catch (err) {
-        this.error = err instanceof Error ? err.message : String(err);
-      }
-    }
-    this.stroke = null;
-    this.move = null;
-  }
-  cancel() {
-    this.stroke?.cancel();
-    this.stroke = null;
-    this.move = null;
-  }
-};
-
 // src/image-editor/psd/ui.ts
 var PSD_FILE_ACCEPT = ".psd,.psb,image/vnd.adobe.photoshop,application/x-photoshop";
 function blobBytes(file) {
@@ -12372,6 +13011,7 @@ export {
   DEFAULT_ADJUSTMENTS,
   DEFAULT_BRUSH,
   DEFAULT_DEPTH_MASK,
+  DEFAULT_MIXER,
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_SELECTION_TOOL_OPTIONS,
   DEFAULT_TRANSFORM,
@@ -12379,6 +13019,7 @@ export {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   DabWalker,
   EMPTY_DISTANCE,
+  EMPTY_MIXER_LOAD,
   GUIDED_FILTER_EPS,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
@@ -12398,6 +13039,12 @@ export {
   MAX_KELVIN,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
+  MIXER_DRAIN,
+  MIXER_MIXING_OPTIONS,
+  MIXER_OPTION_CONTROLS,
+  MIXER_PICKUP_RATE,
+  MIXING_MODELS,
+  MixerStroke,
   PAINT_TOOLS,
   PIGMENT_BANDS,
   PIGMENT_LAMBDA_MIN,
@@ -12427,6 +13074,7 @@ export {
   XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
+  addLayerEffect,
   addLayerFilter,
   addToHistogram,
   adjustmentKindLabel,
@@ -12472,6 +13120,7 @@ export {
   changedTiles,
   clampControlValue,
   clampCropToImage,
+  cleanMixer,
   collectTiles,
   colorBalanceChannel,
   colorRange,
@@ -12490,6 +13139,7 @@ export {
   createImageCaptureSurface,
   createImageEditTools,
   createImageEditorToolProvider,
+  createImageEffectTools,
   createImageLayerTools,
   createImagePaintTools,
   createImagePsdTools,
@@ -12516,7 +13166,9 @@ export {
   depthMaskAlpha,
   depthRasterMask,
   describeLayer,
+  describeLayerEffects,
   describeSelection,
+  deserializeEffects,
   deserializeLayer,
   deserializeLayers,
   deserializeSelection,
@@ -12601,6 +13253,7 @@ export {
   isSpatialFilter,
   kelvinToTemperature,
   layerBadge,
+  layerEffectsOf,
   layerLabel,
   layerMaskCoverage,
   layerMaskFromSelection,
@@ -12620,13 +13273,17 @@ export {
   linearSrgbToXy,
   linearToSrgb,
   loadImageEditorDocument,
+  loadMixer,
   magicWand,
   mapCropHandle,
   mapLayer,
   maskSummary,
   migrateSerializedImageEditorState,
   migrateToLayeredState,
+  mixPigment8,
+  mixPigmentRgb,
   mixPigments,
+  mixerLoadResult,
   modifySelection,
   moveCurvePoint,
   moveLayer,
@@ -12641,6 +13298,7 @@ export {
   normalizeBrush,
   normalizeFilter,
   normalizeLayerMask,
+  normalizeMixer,
   normalizeProcessVersion,
   normalizeRect,
   normalizeRefineEdgeParams,
@@ -12686,6 +13344,7 @@ export {
   removeAlpha,
   removeCurvePoint,
   removeLayer,
+  removeLayerEffect,
   removeLayerFilter,
   renderLayeredBase,
   requireLayer,
@@ -12697,6 +13356,7 @@ export {
   rgbToGray,
   rgbToHsl,
   rgbToReflectance,
+  rgbUnitToHex,
   runLayerMenuAction,
   sampleLut,
   sampleToneLut,
@@ -12708,11 +13368,14 @@ export {
   selectionToCoverage,
   selectionToPixels,
   selectionValueAt,
+  serializeEffects,
   serializeLayer,
   serializeLayers,
   serializeLayersExternal,
   serializeSelection,
   setControlPath,
+  setLayerEffects,
+  setLayerEffectsEnabled,
   setLayerMask,
   setLayerProperties,
   setLum,
@@ -12746,6 +13409,7 @@ export {
   uniformTile,
   unionRect,
   unprojectCanvasPoint,
+  updateLayerEffect,
   updateLayerFilter,
   updateLayerMaskProps,
   uvToXy,