@pixerate/editor 0.94.0 → 0.95.0

package/dist/image-editor/index.js

@@ -42,39 +42,41 @@ import {
   parseDataUrl,
   pngDataUrl,
   validateLayerEffects
-} from "../chunk-747CGOT2.js";
+} 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,
@@ -87,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,
@@ -108,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;
@@ -1919,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];
@@ -7184,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;
   }
@@ -7207,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 })) {
@@ -7224,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);
@@ -7232,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);
@@ -7246,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() {
@@ -7384,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) {
@@ -8375,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" });
@@ -8425,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);
@@ -8443,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));
@@ -8468,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) {
@@ -9477,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) {
@@ -11764,7 +11874,160 @@ function createImageEffectTools(controller) {
   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 = {
@@ -11785,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 };
 }
@@ -11796,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,
@@ -11817,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", ...WRITE4 },
-    handler: (args) => controller.paintStroke({
-      tool: args.tool,
-      points: args.points,
-      color: args.color,
-      brush: args.brush,
-      ...readTarget(args)
-    })
+    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",
@@ -11842,7 +12170,7 @@ 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
       },
@@ -11873,11 +12201,11 @@ function createImagePaintTools(controller) {
     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 READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, 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",
@@ -11898,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", ...READ4 },
+    annotations: { title: "Inspect a PSD", ...READ5 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -11935,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", ...READ4 },
+    annotations: { title: "Export the document as a PSD", ...READ5 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -12633,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) {
@@ -12822,6 +13011,7 @@ export {
   DEFAULT_ADJUSTMENTS,
   DEFAULT_BRUSH,
   DEFAULT_DEPTH_MASK,
+  DEFAULT_MIXER,
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_SELECTION_TOOL_OPTIONS,
   DEFAULT_TRANSFORM,
@@ -12829,6 +13019,7 @@ export {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   DabWalker,
   EMPTY_DISTANCE,
+  EMPTY_MIXER_LOAD,
   GUIDED_FILTER_EPS,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
@@ -12848,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,
@@ -12923,6 +13120,7 @@ export {
   changedTiles,
   clampControlValue,
   clampCropToImage,
+  cleanMixer,
   collectTiles,
   colorBalanceChannel,
   colorRange,
@@ -13075,13 +13273,17 @@ export {
   linearSrgbToXy,
   linearToSrgb,
   loadImageEditorDocument,
+  loadMixer,
   magicWand,
   mapCropHandle,
   mapLayer,
   maskSummary,
   migrateSerializedImageEditorState,
   migrateToLayeredState,
+  mixPigment8,
+  mixPigmentRgb,
   mixPigments,
+  mixerLoadResult,
   modifySelection,
   moveCurvePoint,
   moveLayer,
@@ -13096,6 +13298,7 @@ export {
   normalizeBrush,
   normalizeFilter,
   normalizeLayerMask,
+  normalizeMixer,
   normalizeProcessVersion,
   normalizeRect,
   normalizeRefineEdgeParams,
@@ -13153,6 +13356,7 @@ export {
   rgbToGray,
   rgbToHsl,
   rgbToReflectance,
+  rgbUnitToHex,
   runLayerMenuAction,
   sampleLut,
   sampleToneLut,