@pixerate/editor 0.108.0 → 0.110.0

package/dist/paint-editor/index.js

@@ -4,9 +4,10 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-SOROZ2BF.js";
+} from "../chunk-DMRSJBJF.js";
 import {
   RasterCompositor,
+  base64ToBytes,
   bytesToBase64,
   decodePng,
   encodePng,
@@ -14,28 +15,39 @@ import {
   flattenLayers,
   insertLayer,
   isLayerLocked,
+  isPng,
   mapLayer,
   parseDataUrl,
   pngDataUrl
-} from "../chunk-G4BIYE6R.js";
+} from "../chunk-LQEEDHOP.js";
 import "../chunk-GX332W2C.js";
 import {
   CoverageMap,
+  DEFAULT_BLENDER,
   DEFAULT_BRUSH,
   DEFAULT_MIXER,
+  DEFAULT_SMUDGE,
   EMPTY_MIXER_LOAD,
   MAX_BRUSH_SIZE,
   MIXING_MODELS,
-  MixerStroke,
+  PaintExchange,
+  SmudgeTip,
+  TileMedium,
   applyStrokeToTile,
+  blenderDab,
   cleanMixer,
+  createBlenderScratch,
   createPigmentTools,
   dabRect,
+  exchangeRates,
   loadMixer,
+  mixerRates,
+  normalizeBlender,
   normalizeBrush,
   normalizeMixer,
+  normalizeSmudge,
   rasterizeDab
-} from "../chunk-3PHA3UKI.js";
+} from "../chunk-Z4BC6M74.js";
 import {
   BLEND_MODES,
   PAINTERLY_BLEND_MODES,
@@ -47,20 +59,26 @@ import {
   finishTile,
   isBlendMode,
   isPainterlyBlendMode,
+  mixPigment8,
+  mixPigments,
   readPixel,
   readRegion,
   standardBlendMode,
   surfaceFromPixels,
   tileKey,
-  tilesInRect
-} from "../chunk-WMBIJCHA.js";
+  tilesInRect,
+  writeRegion
+} from "../chunk-HNS7UHCM.js";
 import {
   PerformanceQueue,
   PresenceStore,
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-B6DSIEXA.js";
-import "../chunk-KKREERP2.js";
+import "../chunk-BLWCAQCW.js";
+import "../chunk-YCSFS3GK.js";
+import "../chunk-ZRJMJIQU.js";
+import "../chunk-TGD52FEZ.js";
 
 // src/paint-editor/noise.ts
 function mix32(h) {
@@ -435,8 +453,11 @@ function createPaintDocument(options = {}) {
 }
 
 // src/paint-editor/brushes.ts
-var PAINT_BRUSH_ENGINES = ["dab", "eraser", "mixer"];
-var PAINT_BRUSH_CATEGORIES = ["pencil", "pastel", "charcoal", "airbrush", "marker", "ink", "eraser", "blender", "smudge", "mixer", "custom"];
+var PAINT_BRUSH_ENGINES = ["dab", "eraser", "mixer", "blender", "smudge"];
+var PAINT_BRUSH_CATEGORIES = ["pencil", "pastel", "charcoal", "airbrush", "marker", "ink", "paint", "eraser", "blender", "smudge", "mixer", "custom"];
+var MULTI_COLOR_MODES = ["off", "tip", "dab"];
+var DEFAULT_MULTI_COLOR = { mode: "off", colors: [], order: "sequence", length: 12, softness: 1 };
+var DEFAULT_BEHAVIOR = { pickup: 0, mix: 0.5, dirty: false, mixing: "pigment", multicolor: DEFAULT_MULTI_COLOR };
 var BRUSH_ROTATIONS = ["fixed", "stroke", "barrel"];
 var DEFAULT_DYNAMICS = {
   minSize: 0,
@@ -469,21 +490,62 @@ function normalizeDynamics(raw = {}, base = DEFAULT_DYNAMICS) {
   };
 }
 var BRUSH_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var HEX2 = /^#[0-9a-f]{6}$/i;
+function normalizeMultiColor(raw = {}, base = DEFAULT_MULTI_COLOR) {
+  const colors = Array.isArray(raw.colors) ? raw.colors.filter((c) => typeof c === "string" && HEX2.test(c.trim())).map((c) => c.trim().toLowerCase()).slice(0, 8) : base.colors;
+  return {
+    mode: MULTI_COLOR_MODES.includes(raw.mode) ? raw.mode : base.mode,
+    colors: [...colors],
+    order: raw.order === "random" || raw.order === "sequence" ? raw.order : base.order,
+    length: typeof raw.length === "number" && Number.isFinite(raw.length) ? Math.min(500, Math.max(1, Math.round(raw.length))) : base.length,
+    softness: unit2(raw.softness, base.softness)
+  };
+}
+function normalizeBehavior(raw = {}, base = DEFAULT_BEHAVIOR) {
+  return {
+    pickup: unit2(raw.pickup, base.pickup),
+    mix: unit2(raw.mix, base.mix),
+    dirty: typeof raw.dirty === "boolean" ? raw.dirty : base.dirty,
+    mixing: raw.mixing === "rgb" || raw.mixing === "pigment" ? raw.mixing : base.mixing,
+    multicolor: normalizeMultiColor(raw.multicolor ?? {}, base.multicolor)
+  };
+}
+function isWetCapable(brush) {
+  return brush.engine === "dab" || brush.engine === "mixer";
+}
+function usesPaintExchange(brush) {
+  return brush.engine === "dab" && (brush.behavior.pickup > 0 || brush.behavior.multicolor.mode !== "off");
+}
 function normalizePaintBrush(raw = {}, base) {
   const b = base ?? BASE_BRUSH;
   const id = typeof raw.id === "string" && BRUSH_ID.test(raw.id) ? raw.id : b.id;
+  const engine = PAINT_BRUSH_ENGINES.includes(raw.engine) ? raw.engine : b.engine;
+  const rb = raw.behavior ?? {};
+  const mixerIn = { ...b.mixer, ...raw.mixer ?? {} };
+  if (engine === "mixer") {
+    if (rb.pickup !== void 0) mixerIn.wet = rb.pickup;
+    if (rb.mix !== void 0) mixerIn.mix = rb.mix;
+    if (rb.dirty !== void 0) mixerIn.cleanEachStroke = !rb.dirty;
+    if (rb.mixing !== void 0) mixerIn.mixing = rb.mixing;
+  }
+  const mixer = normalizeMixer(mixerIn);
+  let behavior = normalizeBehavior(rb, b.behavior);
+  if (engine === "mixer") behavior = { ...behavior, pickup: mixer.wet, mix: mixer.mix, dirty: !mixer.cleanEachStroke, mixing: mixer.mixing };
   return {
     id,
     name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim().slice(0, 80) : b.name,
     category: PAINT_BRUSH_CATEGORIES.includes(raw.category) ? raw.category : b.category,
-    engine: PAINT_BRUSH_ENGINES.includes(raw.engine) ? raw.engine : b.engine,
+    engine,
     tip: normalizeBrush({ ...b.tip, ...raw.tip ?? {} }),
     grain: unit2(raw.grain, b.grain),
     pressureSmoothing: range(raw.pressureSmoothing, 0, 0.95, b.pressureSmoothing),
     rotation: BRUSH_ROTATIONS.includes(raw.rotation) ? raw.rotation : b.rotation,
     dynamics: normalizeDynamics(raw.dynamics ?? {}, b.dynamics),
-    mixer: normalizeMixer({ ...b.mixer, ...raw.mixer ?? {} }),
+    mixer,
     loadsColor: typeof raw.loadsColor === "boolean" ? raw.loadsColor : b.loadsColor,
+    behavior,
+    blender: normalizeBlender(raw.blender ?? {}, b.blender),
+    smudge: normalizeSmudge(raw.smudge ?? {}, b.smudge),
     ...raw.builtin ? { builtin: true } : {}
   };
 }
@@ -498,7 +560,10 @@ var BASE_BRUSH = {
   rotation: "fixed",
   dynamics: { ...DEFAULT_DYNAMICS },
   mixer: { ...DEFAULT_MIXER },
-  loadsColor: true
+  loadsColor: true,
+  behavior: { ...DEFAULT_BEHAVIOR, multicolor: { ...DEFAULT_MULTI_COLOR, colors: [] } },
+  blender: { ...DEFAULT_BLENDER },
+  smudge: { ...DEFAULT_SMUDGE }
 };
 var builtin = (init) => ({ ...normalizePaintBrush(init), builtin: true });
 var BUILTIN_BRUSHES = [
@@ -612,19 +677,54 @@ var BUILTIN_BRUSHES = [
     id: "blender",
     name: "Blender",
     category: "blender",
-    engine: "mixer",
+    engine: "blender",
     loadsColor: false,
-    tip: { size: 34, hardness: 0.4, spacing: 0.08, opacity: 1, flow: 0.35, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
-    mixer: { wet: 0.7, load: 0, mix: 1, loadEachStroke: false, cleanEachStroke: true, mixing: "pigment" }
+    tip: { size: 34, hardness: 0.4, spacing: 0.1, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    blender: { strength: 0.5, distance: 0.35, mixing: "pigment" }
   }),
   builtin({
     id: "smudge",
     name: "Smudge",
     category: "smudge",
-    engine: "mixer",
+    engine: "smudge",
     loadsColor: false,
-    tip: { size: 26, hardness: 0.6, spacing: 0.06, opacity: 1, flow: 0.8, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
-    mixer: { wet: 1, load: 0, mix: 1, loadEachStroke: false, cleanEachStroke: true, mixing: "rgb" }
+    tip: { size: 26, hardness: 0.6, spacing: 0.06, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    smudge: { strength: 0.75, length: 0.85, mixing: "rgb" }
+  }),
+  builtin({
+    id: "wet-smudge",
+    name: "Pigment smudge",
+    category: "smudge",
+    engine: "smudge",
+    loadsColor: false,
+    tip: { size: 30, hardness: 0.5, spacing: 0.06, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    smudge: { strength: 0.7, length: 0.9, mixing: "pigment" },
+    dynamics: { minSize: 0.6 }
+  }),
+  builtin({
+    id: "dirty-round",
+    name: "Dirty round",
+    category: "paint",
+    tip: { size: 22, hardness: 0.65, spacing: 0.06, opacity: 1, flow: 0.7, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    behavior: { pickup: 0.55, mix: 0.6, dirty: true, mixing: "pigment" },
+    dynamics: { minSize: 0.5 }
+  }),
+  builtin({
+    id: "multicolor-flat",
+    name: "Multi-colour flat",
+    category: "paint",
+    rotation: "stroke",
+    tip: { size: 30, hardness: 0.75, spacing: 0.05, angle: 90, roundness: 0.3, opacity: 1, flow: 0.85, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    behavior: { pickup: 0.15, mix: 0.4, mixing: "pigment", multicolor: { mode: "tip", softness: 0.7 } },
+    dynamics: { minSize: 0.6 }
+  }),
+  builtin({
+    id: "palette-dabber",
+    name: "Palette dabber",
+    category: "paint",
+    tip: { size: 18, hardness: 0.7, spacing: 0.35, opacity: 1, flow: 0.9, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    behavior: { multicolor: { mode: "dab", order: "sequence", length: 6, softness: 0.4 } },
+    dynamics: { minSize: 0.5, sizeJitter: 0.15, scatter: 0.3 }
   }),
   builtin({
     id: "mixer-brush",
@@ -804,7 +904,9 @@ var PenDabWalker = class {
       opacity: Math.min(1, Math.max(0, opacity)),
       angle,
       roundness: Math.min(1, Math.max(0.01, tip.roundness * (1 - dyn.tiltRoundness * s.lean * 0.8))),
-      pressure: s.pressure
+      pressure: s.pressure,
+      direction: this.dir,
+      index: i
     };
   }
   push(p, out) {
@@ -935,6 +1037,248 @@ function toStrokePoint(p) {
   return { x: p.x, y: p.y, pressure: pressureOf(p), ...typeof p.t === "number" ? { t: p.t } : {} };
 }
 
+// src/paint-editor/dab-stroke.ts
+var GRADIENT_STEPS = 32;
+function multiColorPalette(mc, color, secondary) {
+  if (mc.colors.length >= 2) {
+    return mc.colors.map((h) => {
+      const n = parseInt(h.slice(1), 16);
+      return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+    });
+  }
+  return [[...color], [...secondary]];
+}
+function soften(f, softness) {
+  if (softness >= 1) return f;
+  const w = Math.max(1e-3, softness);
+  return Math.min(1, Math.max(0, (f - 0.5) / w + 0.5));
+}
+function mixRgb(a, b, t, mixing) {
+  if (t <= 0) return [...a];
+  if (t >= 1) return [...b];
+  if (mixing === "pigment") {
+    const o = [0, 0, 0];
+    const q = (v) => Math.round(Math.min(1, Math.max(0, v)) * 255);
+    mixPigment8(q(a[0]), q(a[1]), q(a[2]), q(b[0]), q(b[1]), q(b[2]), t, o);
+    return [o[0], o[1], o[2]];
+  }
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+}
+function multiColorGradient(palette, softness, mixing) {
+  const n = palette.length;
+  const out = [];
+  for (let j = 0; j < GRADIENT_STEPS; j++) {
+    const f = j / (GRADIENT_STEPS - 1) * (n - 1);
+    const i = Math.min(n - 2, Math.floor(f));
+    out.push(mixRgb(palette[i], palette[i + 1], soften(f - i, softness), mixing));
+  }
+  return out;
+}
+function multiColorForDab(mc, palette, index, seed, mixing) {
+  const n = palette.length;
+  if (mc.order === "random") {
+    const run = Math.floor(index / mc.length);
+    return [...palette[Math.min(n - 1, Math.floor(rand01(seed, run, 11) * n))]];
+  }
+  const f = index / mc.length % n;
+  const i = Math.floor(f);
+  return mixRgb(palette[i], palette[(i + 1) % n], soften(f - i, mc.softness), mixing);
+}
+var PaintDabStroke = class {
+  constructor(brush, options) {
+    this.brush = brush;
+    this.options = options;
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
+    const exchanging = brush.engine === "mixer" || brush.engine === "dab";
+    const rates = brush.engine === "mixer" ? mixerRates(brush.mixer) : exchangeRates(brush.behavior.pickup, brush.behavior.mix, 1, brush.behavior.mixing);
+    this.mixing = brush.engine === "mixer" ? brush.mixer.mixing : brush.behavior.mixing;
+    this.states = this.copies.map((c, i) => ({
+      walker: new PenDabWalker(brush, (options.seed ?? 0) + i * 7919 | 0, c.linear),
+      exchange: exchanging ? new PaintExchange(rates, options.load) : null,
+      smudge: brush.engine === "smudge" ? new SmudgeTip(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
+    }));
+    this.medium = new TileMedium(options.target, brush.engine === "dab" ? { blend: brush.tip.blend } : {});
+    this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
+    this.coverage = brush.engine === "dab" ? new CoverageMap() : null;
+    const mc = brush.behavior.multicolor;
+    this.palette = exchanging && mc.mode !== "off" ? multiColorPalette(mc, options.color, options.secondary) : null;
+    this.gradient = this.palette && mc.mode === "tip" ? multiColorGradient(this.palette, mc.softness, this.mixing) : null;
+    this.scratch = brush.engine === "blender" ? createBlenderScratch() : null;
+  }
+  brush;
+  options;
+  dabCount = 0;
+  smoother;
+  copies;
+  states;
+  medium;
+  depth;
+  coverage;
+  palette;
+  gradient;
+  fieldLut = [];
+  scratch;
+  mixing;
+  tip = new Float32Array(0);
+  cov = new Float32Array(0);
+  field = new Float32Array(0);
+  paint = [0, 0, 0];
+  lastRaw = null;
+  lastFed = null;
+  /** What copy 0's brush carries after the dabs so far (mixer and wet-capable dab brushes). */
+  get load() {
+    return this.states[0].exchange?.load ?? null;
+  }
+  push(points) {
+    const rects = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        this.states[i].walker.push(c.map(p), dabs);
+        this.paintDabs(i, dabs, rects);
+      });
+    }
+    return rects;
+  }
+  /** Ends the stroke: the smoothed path catches up with the last raw sample; a tap paints one dab. */
+  finish() {
+    const rects = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    this.copies.forEach((c, i) => {
+      const dabs = [];
+      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.states[i].walker.push(c.map({ ...raw, pressure: fed.pressure }), dabs);
+      this.states[i].walker.finish(dabs);
+      this.paintDabs(i, dabs, rects);
+    });
+    return rects;
+  }
+  paintDabs(copy, dabs, rects) {
+    for (const d of dabs) {
+      const rect = dabRect(d, this.brush.tip.hardness);
+      if (rect.width <= 0 || rect.height <= 0) continue;
+      this.dab(copy, d, rect);
+      rects.push(rect);
+      this.dabCount++;
+    }
+  }
+  /** The tip's pure coverage (`tip`) and, with grain, what the paper catches of it (`cov`). */
+  rasterize(d, rect) {
+    const n = rect.width * rect.height;
+    if (this.tip.length < n) {
+      this.tip = new Float32Array(n);
+      this.cov = new Float32Array(n);
+    }
+    const tip = this.tip.subarray(0, n);
+    tip.fill(0);
+    rasterizeDab({ ...d, alpha: 1 }, this.brush.tip.hardness, rect, tip);
+    if (!(this.depth > 0 && this.options.grain)) return { tip, cov: tip };
+    const cov = this.cov.subarray(0, n);
+    const grain = this.options.grain;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const y = rect.y + yy + 0.5;
+      for (let xx = 0; xx < rect.width; xx++, k++) cov[k] = tip[k] > 0 ? tip[k] * grainCatch(grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure) : 0;
+    }
+    return { tip, cov };
+  }
+  dab(copy, d, rect) {
+    const brush = this.brush;
+    const { tip, cov } = this.rasterize(d, rect);
+    const st = this.states[copy];
+    if (brush.engine === "blender") {
+      blenderDab(this.medium, rect, cov, d.opacity * d.alpha * brush.tip.opacity, d.radius, brush.blender, this.scratch);
+      return;
+    }
+    if (brush.engine === "smudge") {
+      st.smudge.dab(this.medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha * brush.tip.opacity }, rect, cov);
+      return;
+    }
+    const ex = st.exchange;
+    ex.pickUp(this.medium.sample(rect, tip));
+    const mc = brush.behavior.multicolor;
+    if (this.palette && mc.mode === "dab") {
+      const c = multiColorForDab(mc, this.palette, d.index, this.options.seed ?? 0, this.mixing);
+      ex.setReservoirColor(c[0], c[1], c[2]);
+    }
+    let field = null;
+    let total;
+    if (this.gradient) {
+      total = this.tipField(ex, d, rect);
+      field = this.field;
+    } else total = ex.paint(this.paint);
+    if (total > 0) {
+      if (this.coverage) this.depositWithCeiling(d, rect, cov, field, ex);
+      else {
+        const dep = Math.min(1, total) * d.alpha * brush.tip.opacity * d.opacity;
+        if (dep > 0) this.medium.deposit(rect, cov, dep, this.paint, ex.paintPigment, field);
+      }
+    }
+    ex.drain();
+  }
+  /** Fills `this.field` with the tip gradient (mixed with the carried paint) per pixel; returns the paint weight. */
+  tipField(ex, d, rect) {
+    const g = this.gradient;
+    const lut = this.fieldLut;
+    let total = 0;
+    for (let j = 0; j < g.length; j++) {
+      ex.setReservoirColor(g[j][0], g[j][1], g[j][2]);
+      const out = lut[j] ?? [0, 0, 0];
+      total = ex.paint(out);
+      lut[j] = out;
+    }
+    const n = rect.width * rect.height;
+    if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
+    const f = this.field;
+    const nx = Math.sin(d.direction);
+    const ny = Math.cos(d.direction);
+    const r = Math.max(0.5, d.radius);
+    const last = g.length - 1;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const py = rect.y + yy + 0.5 - d.y;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        const u = ((rect.x + xx + 0.5 - d.x) * nx + py * ny) / r;
+        const j = Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)));
+        f[k * 3] = lut[j][0];
+        f[k * 3 + 1] = lut[j][1];
+        f[k * 3 + 2] = lut[j][2];
+      }
+    }
+    return total;
+  }
+  /** A dab brush's deposit: only what this dab adds to the stroke's coverage, under its opacity ceiling. */
+  depositWithCeiling(d, rect, cov, field, ex) {
+    const map = this.coverage;
+    const n = rect.width * rect.height;
+    const before = new Float32Array(n);
+    const vals = new Float32Array(n);
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (cov[k] <= 0) continue;
+        before[k] = map.get(rect.x + xx, rect.y + yy);
+        vals[k] = cov[k] * d.alpha;
+      }
+    }
+    map.accumulate(rect, vals, d.opacity);
+    const o = this.brush.tip.opacity;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (cov[k] <= 0) {
+          vals[k] = 0;
+          continue;
+        }
+        const c0 = before[k] * o;
+        const c1 = map.get(rect.x + xx, rect.y + yy) * o;
+        vals[k] = c1 > c0 && c0 < 1 ? (c1 - c0) / (1 - c0) : 0;
+      }
+    }
+    this.medium.deposit(rect, vals, 1, this.paint, ex.paintPigment, field);
+  }
+};
+
 // src/paint-editor/stroke.ts
 function defaultTile(surface) {
   const data = new Uint8ClampedArray(TILE * TILE * surface.channels);
@@ -973,10 +1317,18 @@ var PaintStrokeSession = class {
       selection: null,
       offset: init.offset
     };
-    if (brush.engine === "mixer") {
-      this.mixerSmoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-      const load = init.mixerLoad;
-      for (let i = 0; i < this.copies.length; i++) this.mixers.push(new MixerStroke(mixerTip(brush), brush.mixer, load, this.mixerTarget()));
+    if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || usesPaintExchange(brush)) {
+      const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
+      this.wet = new PaintDabStroke(brush, {
+        target: this.tileTarget(),
+        color: rgb(init.color),
+        secondary: rgb(init.secondary ?? init.background),
+        load: init.mixerLoad,
+        grain: init.grain,
+        paperDepth: init.paperDepth,
+        seed: init.seed,
+        copies: this.copies
+      });
     } else {
       this.dry = new DryStroke(brush, { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies });
     }
@@ -991,15 +1343,14 @@ var PaintStrokeSession = class {
   touched = /* @__PURE__ */ new Set();
   fresh = /* @__PURE__ */ new Set();
   dry = null;
-  mixers = [];
-  mixerSmoother = null;
+  wet = null;
   apply;
   copies;
   bounds = null;
   lastRaw = null;
   closed = false;
   result = null;
-  mixerTarget() {
+  tileTarget() {
     return {
       offset: this.init.offset,
       lockTransparency: this.init.lockTransparency,
@@ -1027,15 +1378,7 @@ var PaintStrokeSession = class {
     if (filter) points = points.map(filter);
     for (const p of points) this.points.push(p);
     this.lastRaw = points[points.length - 1];
-    if (this.dry) this.update(this.dry.push(points));
-    else {
-      const rects = [];
-      for (const raw of points) {
-        const p = toStrokePoint(this.mixerSmoother.push(raw));
-        this.copies.forEach((c, i) => rects.push(...this.mixers[i].push([toStrokePoint(c.map(p))])));
-      }
-      this.update(rects);
-    }
+    this.update(this.dry ? this.dry.push(points) : this.wet.push(points));
   }
   update(rects) {
     if (!rects.length) return;
@@ -1068,13 +1411,7 @@ var PaintStrokeSession = class {
   /** Ends the stroke (one undo step) and returns what changed. */
   end() {
     if (this.closed) throw new Error("This stroke has already ended.");
-    if (this.dry) this.update(this.dry.finish());
-    else {
-      const rects = [];
-      const last = this.lastRaw ? toStrokePoint(this.lastRaw) : void 0;
-      this.copies.forEach((c, i) => rects.push(...this.mixers[i].finish(last ? toStrokePoint(c.map(last)) : void 0)));
-      this.update(rects);
-    }
+    this.update(this.dry ? this.dry.finish() : this.wet.finish());
     this.closed = true;
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
@@ -1087,14 +1424,10 @@ var PaintStrokeSession = class {
       if (!sameTile(prev, tile)) changed = true;
     }
     const surface = changed ? new TiledSurface(ch, tiles, this.base.defaultValue) : null;
-    const dabs = this.dry ? this.dry.dabCount : this.mixers.reduce((n, m) => n + m.dabCount, 0);
+    const dabs = this.dry ? this.dry.dabCount : this.wet.dabCount;
     this.result = { layerId: this.layerId, bounds: changed ? this.bounds : null, dabs, strokeId: null };
-    if (this.mixers.length) {
-      const brush = this.init.brush;
-      let load = this.mixers[0].load;
-      if (brush.mixer.cleanEachStroke) load = cleanMixer(load);
-      this.result.mixerLoad = load;
-    }
+    const carried = this.wet?.load;
+    if (carried) this.result.mixerLoad = this.init.brush.behavior.dirty ? carried : cleanMixer(carried);
     this.host.commit(this, surface, false);
     return this.result;
   }
@@ -1110,6 +1443,11 @@ function mixerLoadForStroke(brush, current, color) {
   if (brush.mixer.loadEachStroke || !current.reservoir) return loadMixer(current, color);
   return current;
 }
+function brushLoadForStroke(brush, current, color) {
+  if (brush.engine === "mixer") return mixerLoadForStroke(brush, current, color);
+  if (usesPaintExchange(brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
+  return EMPTY_MIXER_LOAD;
+}
 
 // src/paint-editor/strokes.ts
 var IDENTITY_AFFINE = [1, 0, 0, 1, 0, 0];
@@ -1155,6 +1493,17 @@ function readPoint(raw) {
 function readAffine(raw) {
   return Array.isArray(raw) && raw.length === 6 && raw.every(finite) ? raw : null;
 }
+function readRgb(raw) {
+  return Array.isArray(raw) && raw.length === 3 && raw.every(finite) ? raw.map((v) => Math.min(1, Math.max(0, v))) : null;
+}
+function readLoad(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const reservoir = readRgb(r.reservoir);
+  const pickup = readRgb(r.pickup);
+  if (!reservoir && !pickup) return null;
+  return { reservoir, amount: reservoir && finite(r.amount) ? Math.min(1, Math.max(0, r.amount)) : 0, pickup };
+}
 function normalizeBrushStroke(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
@@ -1171,6 +1520,8 @@ function normalizeBrushStroke(raw) {
   };
   const copies = Array.isArray(r.copies) ? r.copies.map(readAffine).filter((m) => m !== null) : [];
   if (copies.length) out.copies = copies;
+  const load = readLoad(r.load);
+  if (load) out.load = load;
   return out;
 }
 function strokeBounds(points) {
@@ -1322,7 +1673,7 @@ function downsampleRgba(data, width, height, tw, th) {
 // src/paint-editor/serialize.ts
 var PAINT_FORMAT = "pixerate-paint";
 var PAINT_SCHEMA_VERSION = 1;
-var KNOWN = /* @__PURE__ */ new Set(["format", "version", "width", "height", "dpi", "paper", "layers", "assets", "activeLayerId", "strokes", "guides", "swatches"]);
+var KNOWN = /* @__PURE__ */ new Set(["format", "version", "width", "height", "dpi", "paper", "layers", "assets", "activeLayerId", "strokes", "guides", "swatches", "mixingPad"]);
 function documentExtensions(raw) {
   const out = {};
   for (const [k, v] of Object.entries(raw)) if (!KNOWN.has(k)) out[k] = v;
@@ -1342,6 +1693,7 @@ function header(state, options) {
   if (options.strokes !== false && state.strokes.length) out.strokes = JSON.parse(JSON.stringify(state.strokes));
   if (options.guides !== void 0) out.guides = JSON.parse(JSON.stringify(options.guides));
   if (options.swatches !== void 0) out.swatches = JSON.parse(JSON.stringify(options.swatches));
+  if (options.mixingPad !== void 0) out.mixingPad = JSON.parse(JSON.stringify(options.mixingPad));
   return out;
 }
 function serializePaintDocument(state, options = {}) {
@@ -1389,7 +1741,7 @@ function deserializePaintDocument(raw) {
   const layers = paintLayersOnly(deserializeLayers(r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
   const activeLayerId = wanted && findLayer(layers, wanted) ? wanted : flattenLayers(layers).filter((l) => l.type === "pixel").pop()?.id ?? null;
-  return { state: { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) }, extensions: documentExtensions(r), guides: r.guides, swatches: r.swatches, problems };
+  return { state: { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) }, extensions: documentExtensions(r), guides: r.guides, swatches: r.swatches, mixingPad: r.mixingPad, problems };
 }
 async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
@@ -1574,7 +1926,7 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       colorHex: color,
       affineCopies: [],
       copies: [IDENTITY_COPY],
-      mixerLoad: brush.engine === "mixer" ? mixerLoadForStroke(brush, EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]) : EMPTY_MIXER_LOAD
+      mixerLoad: brushLoadForStroke(brush, EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
     }
   );
   session.push(thumbnailStroke(width, height));
@@ -1590,7 +1942,7 @@ function renderBrushThumbnail(brush, options) {
   let surface = emptySurface(4);
   if (b.engine === "eraser") {
     surface = fillRect(surface, { x: 0, y: 0, width, height }, rgba);
-  } else if (b.engine === "mixer" && !b.loadsColor) {
+  } else if (b.engine === "blender" || b.engine === "smudge" || b.engine === "mixer" && !b.loadsColor || b.behavior.pickup > 0) {
     const half = Math.ceil(height / 2);
     surface = fillRect(surface, { x: 0, y: 0, width, height: half }, rgba);
     surface = fillRect(surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
@@ -1783,9 +2135,9 @@ function perspectiveGuideLines(g, size, count = 12) {
 }
 
 // src/paint-editor/color.ts
-var HEX2 = /^#?([0-9a-f]{6})$/i;
+var HEX3 = /^#?([0-9a-f]{6})$/i;
 function parseHexColor(value, what = "color") {
-  const m = typeof value === "string" ? HEX2.exec(value.trim()) : null;
+  const m = typeof value === "string" ? HEX3.exec(value.trim()) : null;
   if (!m) throw new Error(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
   const n = parseInt(m[1], 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
@@ -1913,10 +2265,18 @@ var PAD_KNIFE = normalizePaintBrush({
   id: "pad-knife",
   name: "Palette knife",
   category: "smudge",
-  engine: "mixer",
+  engine: "smudge",
   loadsColor: false,
-  tip: { size: 34, hardness: 0.9, spacing: 0.08, roundness: 0.35, angle: 90, opacity: 1, flow: 0.85, pressureSize: false, pressureOpacity: false },
-  mixer: { wet: 1, load: 0, mix: 1, loadEachStroke: false, cleanEachStroke: true, mixing: "pigment" }
+  tip: { size: 34, hardness: 0.9, spacing: 0.08, roundness: 0.35, angle: 90, opacity: 1, flow: 1, pressureSize: false, pressureOpacity: false },
+  // A knife drags streaks of paint and folds them into each other, mixing them as pigment.
+  smudge: { strength: 0.6, length: 0.8, mixing: "pigment" }
+});
+var PAD_BLOB = normalizePaintBrush({
+  id: "pad-blob",
+  name: "Pad blob",
+  category: "custom",
+  engine: "dab",
+  tip: { size: 20, hardness: 1, spacing: 0.1, opacity: 1, flow: 1, pressureSize: false, pressureOpacity: false }
 });
 var MixingPad = class {
   width = MIXING_PAD_WIDTH;
@@ -1934,7 +2294,11 @@ var MixingPad = class {
     }
     let brush = options.tool === "knife" ? PAD_KNIFE : PAD_PAINT;
     if (options.size !== void 0) brush = normalizePaintBrush({ tip: { ...brush.tip, size: options.size } }, brush);
-    const [r, g, b] = hexToRgb8(options.color);
+    return this.run(brush, points, options.color);
+  }
+  /** Paints `points` with `brush` in `color` on the pad. */
+  run(brush, points, color) {
+    const [r, g, b] = hexToRgb8(color);
     let result = null;
     const session = new PaintStrokeSession(
       { update: () => {
@@ -1950,10 +2314,10 @@ var MixingPad = class {
         grain: null,
         paperDepth: 0,
         seed: 1,
-        colorHex: options.color,
+        colorHex: color,
         affineCopies: [],
         copies: [IDENTITY_COPY],
-        mixerLoad: mixerLoadForStroke(brush, EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
+        mixerLoad: brushLoadForStroke(brush, EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
       }
     );
     session.push(points);
@@ -1992,6 +2356,82 @@ var MixingPad = class {
     this.surface = emptySurface(4);
     this.version++;
   }
+  /**
+   * Mixes paints the way a painter does on a palette: blobs whose areas are in proportion to
+   * their parts, side by side around (x, y), spiral knife passes that fold them together, and then the centre worked until it is fully mixed: a soft-edged core
+   * of the Kubelka-Munk mix of the parts (`mixPigments`), with partly mixed streaks around it.
+   * Returns that colour (picked back from the centre) and the pile's bounds.
+   *
+   * The core is laid, not smeared, because smearing alone drifts: the knife samples in RGB and a
+   * mixed colour's scattering is re-estimated from its luminance, so repeated small mixes favour
+   * the lighter paint (see GOTCHAS).
+   */
+  mix(paints, options = {}) {
+    if (!paints.length || paints.length > 8) throw new Error(`Give 1 to 8 paints to mix; got ${paints.length}.`);
+    const total = paints.reduce((n, p) => n + p.parts, 0);
+    paints.forEach((p, i) => {
+      if (!(Number.isFinite(p.parts) && p.parts >= 0)) throw new Error(`paints[${i}].parts is ${p.parts}; use a number \u2265 0.`);
+    });
+    if (!(total > 0)) throw new Error("Every paint has 0 parts; give at least one paint parts above 0.");
+    const R = options.radius ?? 40;
+    if (!(R >= 12 && R <= 100)) throw new Error(`radius ${R} is out of range; use 12..100 pad px.`);
+    const passes = options.passes ?? 3;
+    if (!(Number.isInteger(passes) && passes >= 1 && passes <= 20)) throw new Error(`passes ${passes} is out of range; use a whole number 1..20.`);
+    const cx = options.x ?? this.width / 2;
+    const cy = options.y ?? this.height / 2;
+    if (!(cx - R >= 0 && cy - R >= 0 && cx + R <= this.width && cy + R <= this.height)) {
+      throw new Error(`A pile of radius ${R} at (${cx}, ${cy}) does not fit on the ${this.width}\xD7${this.height} pad; move it at least ${R} px from every edge or use a smaller radius.`);
+    }
+    const bounds = { x: Math.floor(cx - R), y: Math.floor(cy - R), width: Math.ceil(2 * R), height: Math.ceil(2 * R) };
+    if (options.clear !== false) this.surface = writeRegion(this.surface, bounds, new Uint8ClampedArray(bounds.width * bounds.height * 4));
+    const used = paints.filter((p) => p.parts > 0);
+    const area = Math.PI * (0.7 * R) ** 2;
+    used.forEach((p, i) => {
+      const r = Math.sqrt(area * (p.parts / total) / Math.PI);
+      const a = i / used.length * Math.PI * 2;
+      const off = used.length === 1 ? 0 : 0.45 * R;
+      const x = Math.min(cx + R - r, Math.max(cx - R + r, cx + Math.cos(a) * off));
+      const y = Math.min(cy + R - r, Math.max(cy - R + r, cy + Math.sin(a) * off));
+      const blob = normalizePaintBrush({ tip: { ...PAD_BLOB.tip, size: Math.max(2, 2 * r) } }, PAD_BLOB);
+      this.run(blob, [{ x, y }], p.color.toLowerCase());
+    });
+    const knife = normalizePaintBrush({ tip: { ...PAD_KNIFE.tip, size: Math.max(12, R * 0.5) } }, PAD_KNIFE);
+    for (let k = 0; k < passes; k++) {
+      const stir = [];
+      const turns = 1.6;
+      for (let t = 0; t <= 48; t++) {
+        const a = t / 48 * Math.PI * 2 * turns + k * 1.3;
+        const rr = R * (0.85 - 0.6 * (t / 48));
+        stir.push({ x: cx + Math.cos(a) * rr, y: cy + Math.sin(a) * rr });
+      }
+      this.run(knife, stir, "#000000");
+    }
+    const mixed = mixPigments(
+      paints.map((p) => hexToRgb8(p.color).map((v) => v / 255)),
+      paints.map((p) => p.parts)
+    );
+    const core = normalizePaintBrush({ tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
+    const hex = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
+    this.run(core, [{ x: cx, y: cy }], hex);
+    return { color: this.pick(cx, cy, 2), bounds };
+  }
+  /** The pad's pixels as a PNG data URL (with alpha), for saving. */
+  toPng() {
+    return pngDataUrl(this.width, this.height, readRegion(this.surface, { x: 0, y: 0, width: this.width, height: this.height }));
+  }
+  /** Replaces the pad with a PNG (data URL or base64) of the pad's size, as `toPng` writes. */
+  fromPng(png) {
+    const bytes = png.startsWith("data:") ? parseDataUrl(png)?.bytes : base64ToBytes(png);
+    if (!bytes || !isPng(bytes)) throw new Error("The pad image is not a PNG data URL or base64 PNG.");
+    const img = decodePng(bytes);
+    if (img.width !== this.width || img.height !== this.height) throw new Error(`The pad image is ${img.width}\xD7${img.height}; a mixing pad is ${this.width}\xD7${this.height}.`);
+    this.surface = surfaceFromPixels({ width: img.width, height: img.height, data: img.data }, 4);
+    this.version++;
+  }
+  /** Whether nothing is on the pad. */
+  get empty() {
+    return this.surface.tiles.size === 0;
+  }
   /** The pad over white, `width × height` RGBA. */
   pixels() {
     const px = readRegion(this.surface, { x: 0, y: 0, width: this.width, height: this.height });
@@ -2013,9 +2453,9 @@ var PaintEditorError = class extends Error {
     this.name = "PaintEditorError";
   }
 };
-var HEX3 = /^#[0-9a-f]{6}$/i;
+var HEX4 = /^#[0-9a-f]{6}$/i;
 function parseColor(value, what = "color") {
-  if (typeof value !== "string" || !HEX3.test(value.trim())) throw new PaintEditorError(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
+  if (typeof value !== "string" || !HEX4.test(value.trim())) throw new PaintEditorError(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
   return value.trim().toLowerCase();
 }
 function rgbaOf(hex) {
@@ -2041,6 +2481,8 @@ var PaintEditorController = class {
   historyLimit;
   brush;
   userBrushes;
+  /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
+  library = null;
   color;
   secondaryColor = "#ffffff";
   mixerLoad = EMPTY_MIXER_LOAD;
@@ -2059,6 +2501,8 @@ var PaintEditorController = class {
   guides;
   swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }));
   pad = new MixingPad();
+  savedPads = [];
+  nextPadId = 1;
   tracingVersion = 1;
   tracingCache = null;
   imagePixels = /* @__PURE__ */ new Map();
@@ -2096,7 +2540,7 @@ var PaintEditorController = class {
     this.cached = {
       document: this.doc,
       brush: this.brush,
-      brushes: [...BUILTIN_BRUSHES, ...this.userBrushes],
+      brushes: this.library ??= [...BUILTIN_BRUSHES, ...this.userBrushes],
       color: this.color,
       secondaryColor: this.secondaryColor,
       mixerLoad: this.mixerLoad,
@@ -2109,6 +2553,7 @@ var PaintEditorController = class {
       guides: this.guides,
       swatches: this.swatches,
       mixingPadVersion: this.pad.version,
+      savedMixingPads: this.savedPads.map(({ id, name }) => ({ id, name })),
       stroking: Boolean(this.session),
       version: this.version
     };
@@ -2478,6 +2923,7 @@ var PaintEditorController = class {
     const i = this.userBrushes.findIndex((b) => b.id === options.id);
     if (i >= 0) this.userBrushes[i] = saved;
     else this.userBrushes.push(saved);
+    this.library = null;
     this.emit([]);
     return saved;
   }
@@ -2486,6 +2932,7 @@ var PaintEditorController = class {
     const i = this.userBrushes.findIndex((b) => b.id === id);
     if (i < 0) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
     this.userBrushes.splice(i, 1);
+    this.library = null;
     this.emit([]);
   }
   /** The user's saved brushes. */
@@ -2526,7 +2973,10 @@ var PaintEditorController = class {
       else this.userBrushes.push(b);
       added.push(b.id);
     }
-    if (added.length) this.emit([]);
+    if (added.length) {
+      this.library = null;
+      this.emit([]);
+    }
     return { added, skipped, problems };
   }
   /** A thumbnail of a brush: a test stroke on the current paper. */
@@ -2600,6 +3050,14 @@ var PaintEditorController = class {
     if (init.brush) brush = normalizePaintBrush({ ...init.brush, id: brush.id }, brush);
     return brush;
   }
+  /**
+   * After a stroke: a Mixer Brush that loads colour keeps its whole load; any other dirty brush
+   * keeps only the paint it carries (the reservoir stays the Mixer Brush's).
+   */
+  keepLoad(brush, load) {
+    if (brush.engine === "mixer" && brush.loadsColor) this.mixerLoad = load;
+    else if (brush.behavior.dirty) this.mixerLoad = { ...this.mixerLoad, pickup: load.pickup };
+  }
   /** Extra copies every new stroke paints (the painting guides add mirror and kaleidoscope copies). */
   strokeCopies() {
     return symmetryCopies(this.guides.symmetry);
@@ -2640,7 +3098,8 @@ var PaintEditorController = class {
       affineCopies: copies,
       copies: [IDENTITY_AFFINE, ...copies].map(affineCopy),
       inputFilter: snapper ? (p) => snapper.snap(p) : void 0,
-      mixerLoad: brush.engine === "mixer" ? mixerLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]) : EMPTY_MIXER_LOAD
+      mixerLoad: init.load ?? brushLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]),
+      secondary: rgbaOf(this.secondaryColor)
     });
     return session;
   }
@@ -2655,6 +3114,7 @@ var PaintEditorController = class {
       seed: init.seed
     };
     if (init.affineCopies.length) stroke.copies = init.affineCopies.map((m) => [...m]);
+    if (init.mixerLoad.reservoir || init.mixerLoad.pickup) stroke.load = JSON.parse(JSON.stringify(init.mixerLoad));
     return stroke;
   }
   /**
@@ -2673,7 +3133,7 @@ var PaintEditorController = class {
         this.live = null;
         this.liveLayers = null;
         const brush = s.init.brush;
-        if (!cancelled && s.result?.mixerLoad && brush.loadsColor) this.mixerLoad = s.result.mixerLoad;
+        if (!cancelled && s.result?.mixerLoad) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           this.emit();
           return;
@@ -2717,7 +3177,7 @@ var PaintEditorController = class {
     this.requireIdle("painting");
     const points = this.checkPoints(init.points);
     const { doc, result, brush } = this.runStroke(this.doc, { ...init, start: init.start ?? points[0] }, points);
-    if (result.mixerLoad && brush.loadsColor) this.mixerLoad = result.mixerLoad;
+    if (result.mixerLoad) this.keepLoad(brush, result.mixerLoad);
     if (doc !== this.doc) this.commit(`${brush.name} stroke`, doc);
     else this.emit([]);
     return result;
@@ -2777,7 +3237,12 @@ var PaintEditorController = class {
         }
         const layerId = options.layerId ?? s.layerId;
         if (!findLayer(doc.layers, layerId)) throw new PaintEditorError(`Stroke "${s.id}" was painted on layer "${layerId}", which no longer exists; pass layerId to replay it elsewhere.`);
-        const run = this.runStroke(doc, { layerId, color: options.color ?? s.color, brush, seed: s.seed, copies: v.copies ?? [] }, v.points);
+        let load = s.load;
+        if (load && options.color !== void 0 && load.reservoir) {
+          const [r, g, b] = hexToRgb8(options.color);
+          load = { ...load, reservoir: [r / 255, g / 255, b / 255] };
+        }
+        const run = this.runStroke(doc, { layerId, color: options.color ?? s.color, brush, seed: s.seed, copies: v.copies ?? [], ...load && options.brushId === void 0 ? { load } : {} }, v.points);
         doc = run.doc;
         bounds = unionRect(bounds, run.result.bounds);
         if (run.result.strokeId) ids.push(run.result.strokeId);
@@ -2856,14 +3321,15 @@ var PaintEditorController = class {
   // --- Save, load and export -------------------------------------------------------
   /** The document as JSON with inline PNG assets. */
   toJSON(options = {}) {
-    return serializePaintDocument(this.doc, { strokes: options.strokes, extensions: this.extensions, guides: this.guides, swatches: this.swatches });
+    return serializePaintDocument(this.doc, { strokes: options.strokes, extensions: this.extensions, guides: this.guides, swatches: this.swatches, mixingPad: this.mixingPadJSON() });
   }
   /** The document as JSON with each PNG stored in `store`. */
   toJSONExternal(store, options = {}) {
-    return serializePaintDocumentExternal(this.doc, store, { strokes: options.strokes, extensions: this.extensions, guides: this.guides, swatches: this.swatches });
+    return serializePaintDocumentExternal(this.doc, store, { strokes: options.strokes, extensions: this.extensions, guides: this.guides, swatches: this.swatches, mixingPad: this.mixingPadJSON() });
   }
   adopt(loaded) {
     this.extensions = loaded.extensions;
+    this.readMixingPad(loaded.mixingPad, loaded.problems);
     this.readGuides(loaded.guides, loaded.state, loaded.problems);
     if (Array.isArray(loaded.swatches)) {
       this.swatches = loaded.swatches.filter((x) => Boolean(x) && typeof x.color === "string" && /^#[0-9a-f]{6}$/i.test(x.color)).map((x) => typeof x.name === "string" ? { color: x.color.toLowerCase(), name: x.name } : { color: x.color.toLowerCase() });
@@ -3218,6 +3684,99 @@ var PaintEditorController = class {
     this.pad.clear();
     this.emit([]);
   }
+  /**
+   * Mixes paints on the pad like a painter: blobs in proportion to their `parts`, knife passes,
+   * and a fully mixed core of the Kubelka-Munk mix (see `MixingPad.mix`). With `setColor` the
+   * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
+   */
+  mixOnPad(paints, options = {}) {
+    const parsed = (paints ?? []).map((p, i) => ({ color: parseColor(p?.color, `paints[${i}].color`), parts: p?.parts }));
+    let r;
+    try {
+      r = this.pad.mix(parsed, options);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    const color = r.color ?? parsed[0].color;
+    this.emit([]);
+    if (options.setColor) this.setColor(color);
+    return { color, bounds: r.bounds };
+  }
+  /** The mixing pad as a PNG data URL (with alpha). */
+  mixingPadPng() {
+    return this.pad.toPng();
+  }
+  /** Replaces the mixing pad with a PNG (data URL or base64, 360 × 220). */
+  setMixingPadPng(png) {
+    try {
+      this.pad.fromPng(png);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    this.emit([]);
+  }
+  /** The mixing pads kept by name. */
+  listMixingPads() {
+    return this.savedPads.map(({ id, name }) => ({ id, name }));
+  }
+  /** Keeps the mixing pad as it is now under `name` (saved with the document). Returns its id. */
+  saveMixingPad(name) {
+    if (this.pad.empty) throw new PaintEditorError("The mixing pad is empty; put paint on it (mixing_pad_stroke or mix_on_pad) before saving it.");
+    const label = (typeof name === "string" && name.trim() ? name.trim() : `Pad ${this.nextPadId}`).slice(0, 80);
+    const pad = { id: `pad${this.nextPadId++}`, name: label, png: this.pad.toPng() };
+    this.savedPads.push(pad);
+    this.emit([]);
+    return { id: pad.id, name: pad.name };
+  }
+  requirePad(id) {
+    const p = this.savedPads.find((x) => x.id === id);
+    if (!p) throw new PaintEditorError(`Unknown mixing pad "${id}". Call list_mixing_pads for the ids.`);
+    return p;
+  }
+  /** Puts a kept pad back on the mixing pad (replacing what is there). */
+  loadMixingPad(id) {
+    const p = this.requirePad(id);
+    this.setMixingPadPng(p.png);
+    return { id: p.id, name: p.name };
+  }
+  /** Forgets a kept pad. */
+  removeMixingPad(id) {
+    const p = this.requirePad(id);
+    this.savedPads = this.savedPads.filter((x) => x !== p);
+    this.emit([]);
+    return { id: p.id, name: p.name };
+  }
+  mixingPadJSON() {
+    if (this.pad.empty && !this.savedPads.length) return void 0;
+    return { ...this.pad.empty ? {} : { current: this.pad.toPng() }, saved: this.savedPads.map((p) => ({ ...p })) };
+  }
+  readMixingPad(raw, problems) {
+    this.savedPads = [];
+    this.nextPadId = 1;
+    this.pad.clear();
+    if (raw === void 0 || raw === null) return;
+    const r = raw;
+    if (typeof r.current === "string") {
+      try {
+        this.pad.fromPng(r.current);
+      } catch (e) {
+        problems.push(`The mixing pad could not be read (${e.message}); it starts empty.`);
+      }
+    }
+    if (Array.isArray(r.saved)) {
+      r.saved.forEach((p, i) => {
+        const x = p;
+        if (!x || typeof x.png !== "string" || typeof x.name !== "string") {
+          problems.push(`mixingPad.saved[${i}] is not a saved pad; skipped.`);
+          return;
+        }
+        const id = typeof x.id === "string" && /^pad\d+$/.test(x.id) ? x.id : `pad${this.nextPadId}`;
+        const n = Number(id.slice(3));
+        if (n >= this.nextPadId) this.nextPadId = n + 1;
+        this.savedPads.push({ id, name: x.name, png: x.png });
+      });
+    }
+  }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
     const l = findLayer(this.currentLayers(), id)?.layer;
@@ -3675,7 +4234,7 @@ function createPaintGuideTools(c) {
     {
       name: "mixing_pad_stroke",
       title: "Paint on the mixing pad",
-      description: "Paints on the mixing pad (a 360 \xD7 220 scratch canvas, not the painting): tool paint lays down a colour with a pigment Mixer Brush; tool knife smears what is there like a palette knife, mixing it as paint. Points are pad pixels. Not an undo step. Returns the changed bounds; then pick_mixing_pad_color.",
+      description: "Paints on the mixing pad (a 360 \xD7 220 scratch canvas, not the painting): tool paint lays down a colour with a pigment Mixer Brush; tool knife smears what is there like a palette knife, mixing it as paint. Points are pad pixels. Not an undo step. Returns the changed bounds; then pick_mixing_pad_color. For a measured mix in one call use mix_on_pad.",
       inputSchema: {
         type: "object",
         properties: {
@@ -3730,6 +4289,73 @@ function createPaintGuideTools(c) {
         return { cleared: true };
       }
     },
+    {
+      name: "mix_on_pad",
+      title: "Mix paints on the pad",
+      description: "Mixes paints on the mixing pad as a painter would: blobs whose areas follow their parts, worked with the palette knife, and a fully mixed core of the Kubelka-Munk (pigment) mix, so blue and yellow make green and white tints. One call per mix. Not an undo step (the pad is scratch space). Returns the mixed colour #rrggbb and the pile bounds in pad pixels; with setColor it becomes the paint colour. pick_mixing_pad_color reads the streaks around it.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          paints: {
+            type: "array",
+            minItems: 1,
+            maxItems: 8,
+            description: "The paints, 1 to 8.",
+            items: {
+              type: "object",
+              properties: {
+                color: { ...COLOR, description: "Paint colour #rrggbb." },
+                parts: { type: "number", minimum: 0, description: "Parts of this paint, any scale (1 and 3 for a 1:3 mix); at least one above 0." }
+              },
+              required: ["color", "parts"],
+              additionalProperties: false
+            }
+          },
+          x: { type: "number", minimum: 0, maximum: 360, description: "Centre of the pile, pad x (default 180)." },
+          y: { type: "number", minimum: 0, maximum: 220, description: "Centre of the pile, pad y (default 110)." },
+          radius: { type: "number", minimum: 12, maximum: 100, description: "Radius of the pile in pad pixels (default 40); it must fit on the pad." },
+          passes: { type: "integer", minimum: 1, maximum: 20, description: "Palette-knife passes (default 3; more gives finer streaks around the core)." },
+          clear: { type: "boolean", description: "Wipe the pile's area first (default true); false mixes into the paint already there." },
+          setColor: { type: "boolean", description: "Also make the mix the paint colour (default false)." }
+        },
+        required: ["paints"],
+        additionalProperties: false
+      },
+      annotations: { title: "Mix paints on the pad", ...WRITE },
+      handler: ({ paints, x, y, radius, passes, clear, setColor }) => c.mixOnPad(paints, { x, y, radius, passes, clear, setColor })
+    },
+    {
+      name: "save_mixing_pad",
+      title: "Keep the mixing pad",
+      description: "Keeps the mixing pad as it is now under a name, saved with the document, to come back to with load_mixing_pad. Refused while the pad is empty. Returns the kept pad id and name.",
+      inputSchema: { type: "object", properties: { name: { type: "string", minLength: 1, maxLength: 80, description: 'Name (default "Pad n").' } }, additionalProperties: false },
+      annotations: { title: "Keep the mixing pad", ...WRITE },
+      handler: ({ name }) => c.saveMixingPad(name)
+    },
+    {
+      name: "list_mixing_pads",
+      title: "List kept mixing pads",
+      description: "Lists the mixing pads kept with save_mixing_pad (id, name). Changes nothing.",
+      inputSchema: EMPTY,
+      annotations: { title: "List kept mixing pads", ...READ },
+      handler: () => ({ pads: c.listMixingPads() })
+    },
+    {
+      name: "load_mixing_pad",
+      title: "Load a kept mixing pad",
+      description: "Puts a kept pad (id from list_mixing_pads) back on the mixing pad, replacing what is on it. Returns the pad id and name.",
+      inputSchema: { type: "object", properties: { id: { type: "string", description: "Kept pad id from list_mixing_pads." } }, required: ["id"], additionalProperties: false },
+      annotations: { title: "Load a kept mixing pad", ...DESTRUCTIVE },
+      handler: ({ id }) => c.loadMixingPad(id)
+    },
+    {
+      name: "remove_mixing_pad",
+      title: "Remove a kept mixing pad",
+      description: "Forgets a kept pad (id from list_mixing_pads); the pad on screen is untouched. Returns the removed id and name.",
+      inputSchema: { type: "object", properties: { id: { type: "string", description: "Kept pad id from list_mixing_pads." } }, required: ["id"], additionalProperties: false },
+      annotations: { title: "Remove a kept mixing pad", ...DESTRUCTIVE },
+      handler: ({ id }) => c.removeMixingPad(id)
+    },
     {
       name: "render_mixing_pad",
       title: "Render the mixing pad",
@@ -3799,28 +4425,79 @@ var DYNAMICS = {
 };
 var MIXER = {
   type: "object",
-  description: "Mixer engine settings (Mixer Brush, blender, smudge). Missing fields keep their current values.",
+  description: "Mixer engine settings (the Mixer Brush). Missing fields keep their current values.",
   properties: {
-    wet: { type: "number", minimum: 0, maximum: 1, description: "How much canvas colour each dab picks up, 0 (dry) .. 1." },
+    wet: { type: "number", minimum: 0, maximum: 1, description: "Pick-up ratio: how much canvas colour each dab picks up, 0 (dry) .. 1." },
     load: { type: "number", minimum: 0, maximum: 1, description: "How much paint the reservoir holds; 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." },
+    mix: { type: "number", minimum: 0, maximum: 1, description: "Mix ratio: how far each dab's paint moves from the reservoir towards the picked-up colour." },
     loadEachStroke: { type: "boolean", description: "Refill the reservoir with the colour before each stroke." },
     cleanEachStroke: { type: "boolean", description: "Empty the pickup well after each stroke." },
     mixing: { type: "string", enum: [...MIXING_MODELS], description: "rgb: RGB averages. pigment: mixes like paint (Kubelka-Munk)." }
   },
   additionalProperties: false
 };
+var MIXING = { type: "string", enum: [...MIXING_MODELS], description: "pigment: mixes like paint (Kubelka-Munk, blue and yellow make green); rgb: straight RGB averages." };
+var BEHAVIOR = {
+  type: "object",
+  description: "How the brush handles paint on the canvas (dab and mixer engines; on a mixer brush pickup, mix, dirty and mixing are its mixer wet, mix, !cleanEachStroke and mixing). Missing fields keep their current values.",
+  properties: {
+    pickup: { type: "number", minimum: 0, maximum: 1, description: "Pick-up ratio 0..1: how much of the paint under each dab the brush lifts and carries along (0: none, a dry brush)." },
+    mix: { type: "number", minimum: 0, maximum: 1, description: "Mix ratio 0..1: how much of the carried paint goes into what the brush lays down, against the brush's own colour (scaled by pickup)." },
+    dirty: { type: "boolean", description: "Dirty brush: keep the carried paint after the stroke, so the next stroke starts with the last colour it touched (needs pickup above 0). clean_mixer_brush wipes it." },
+    mixing: MIXING,
+    multicolor: {
+      type: "object",
+      description: "Multi-coloured brush. Missing fields keep their current values.",
+      properties: {
+        mode: { type: "string", enum: [...MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
+        colors: { type: "array", maxItems: 8, items: { ...COLOR2 }, description: "2..8 colours #rrggbb; fewer than 2 uses the paint colour and the secondary colour." },
+        order: { type: "string", enum: ["sequence", "random"], description: "dab mode: sequence runs through the colours in order, blending between them; random picks one per run of dabs (seeded)." },
+        length: { type: "integer", minimum: 1, maximum: 500, description: "dab mode: dabs per colour (default 12)." },
+        softness: { type: "number", minimum: 0, maximum: 1, description: "How softly neighbouring colours blend: 0 hard stripes or steps, 1 a smooth gradient." }
+      },
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false
+};
+var BLENDER = {
+  type: "object",
+  description: "Blender engine settings. Missing fields keep their current values.",
+  properties: {
+    strength: { type: "number", minimum: 0, maximum: 1, description: "How far each pixel under the tip moves towards the mix of the paint near it, per dab." },
+    distance: { type: "number", minimum: 0, maximum: 1, description: "Blend distance: how far away colours are mixed in, as a fraction of the tip diameter (0.35 default; higher blends wider and softer)." },
+    mixing: MIXING
+  },
+  additionalProperties: false
+};
+var SMUDGE = {
+  type: "object",
+  description: "Smudge engine settings. Missing fields keep their current values.",
+  properties: {
+    strength: { type: "number", minimum: 0, maximum: 1, description: "How strongly the dragged paint covers what is under the tip, per dab." },
+    length: { type: "number", minimum: 0, maximum: 1, description: "How far paint is dragged: the share of the carried paint kept from dab to dab (0.85 default; 1 drags it the whole stroke)." },
+    mixing: { ...MIXING, description: "rgb (default): smeared colours average; pigment: they mix like paint." }
+  },
+  additionalProperties: false
+};
 var BRUSH_FIELDS = {
   name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
   category: { type: "string", enum: [...PAINT_BRUSH_CATEGORIES], description: "Library category." },
-  engine: { type: "string", enum: [...PAINT_BRUSH_ENGINES], description: "dab: paints dabs; eraser: removes paint; mixer: picks up and moves paint (Mixer Brush, blender, smudge)." },
+  engine: {
+    type: "string",
+    enum: [...PAINT_BRUSH_ENGINES],
+    description: "dab: paints dabs (with behavior.pickup or multicolor it paints dab by dab, lifting and mixing paint); eraser: removes paint; mixer: the Mixer Brush (a reservoir plus picked-up paint); blender: mixes the colours under and near the tip; smudge: drags paint along the stroke."
+  },
   tip: TIP,
   grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Multiplied by the paper depth." },
   pressureSmoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Pressure smoothing, separate from the tip position smoothing." },
   rotation: { type: "string", enum: [...BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
   dynamics: DYNAMICS,
   mixer: MIXER,
-  loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for blender and smudge, which only move paint)." }
+  loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for a mixer that only moves paint)." },
+  behavior: BEHAVIOR,
+  blender: BLENDER,
+  smudge: SMUDGE
 };
 var POINTS = {
   type: "array",
@@ -3849,7 +4526,20 @@ function loadResult(load) {
   return { reservoir: hex(load.reservoir), amount: Math.round(load.amount * 1e3) / 1e3, pickup: hex(load.pickup) };
 }
 function brushSummary(b) {
-  return { id: b.id, name: b.name, category: b.category, engine: b.engine, size: b.tip.size, grain: b.grain, rotation: b.rotation, builtin: Boolean(b.builtin) };
+  return {
+    id: b.id,
+    name: b.name,
+    category: b.category,
+    engine: b.engine,
+    size: b.tip.size,
+    grain: b.grain,
+    rotation: b.rotation,
+    wetCapable: isWetCapable(b),
+    pickup: b.behavior.pickup,
+    dirty: b.behavior.dirty,
+    multicolor: b.behavior.multicolor.mode,
+    builtin: Boolean(b.builtin)
+  };
 }
 function createPaintEditorToolProvider(controller, options = {}) {
   const c = controller;
@@ -4138,7 +4828,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "list_brushes",
     title: "List brushes",
-    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers, blender, smudge, Mixer Brush) and saved user brushes, with id, name, category, engine, size, grain response and rotation mode, plus the active brush id.",
+    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
     inputSchema: EMPTY2,
     annotations: { title: "List brushes", ...READ2 },
     handler: () => {
@@ -4149,7 +4839,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "get_brush",
     title: "Get a brush",
-    description: "Reads every setting of a brush (tip, grain, pressure smoothing, rotation, dynamics, mixer). Without id, the active brush as edited.",
+    description: "Reads every setting of a brush (tip, grain, pressure smoothing, rotation, dynamics, mixer, behavior: pick-up / mix / dirty / multi-colour, blender, smudge). Without id, the active brush as edited.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes (default the active brush)." } }, additionalProperties: false },
     annotations: { title: "Get a brush", ...READ2 },
     handler: ({ id }) => {
@@ -4284,7 +4974,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "get_mixer_brush",
     title: "Get the Mixer Brush load",
-    description: "Reads what the Mixer Brush carries between strokes: reservoir #rrggbb or null, amount 0..1 left, pickup #rrggbb or null. Call before painting with mixer-brush when its loadEachStroke is false.",
+    description: "Reads what the brush carries between strokes: reservoir #rrggbb or null (the Mixer Brush's loaded paint), amount 0..1 left, pickup #rrggbb or null (paint picked up from the canvas, kept by dirty brushes and a Mixer Brush that does not clean each stroke). Call before painting with mixer-brush when its loadEachStroke is false, or with a dirty brush.",
     inputSchema: EMPTY2,
     annotations: { title: "Get the Mixer Brush load", ...READ2 },
     handler: () => loadResult(c.getState().mixerLoad)
@@ -4300,7 +4990,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "clean_mixer_brush",
     title: "Clean the Mixer Brush",
-    description: "Empties the Mixer Brush pickup well (and with emptyReservoir its paint too). Editor state, not an undo step. Returns the load.",
+    description: "Cleans the brush: empties the picked-up paint a dirty brush or the Mixer Brush carries (and with emptyReservoir the Mixer Brush paint too). Editor state, not an undo step. Returns the load.",
     inputSchema: { type: "object", properties: { emptyReservoir: { type: "boolean", description: "Also drop the loaded paint (default false)." } }, additionalProperties: false },
     annotations: { title: "Clean the Mixer Brush", ...SET2 },
     handler: ({ emptyReservoir }) => loadResult(c.cleanMixerBrush(emptyReservoir === true))
@@ -4308,7 +4998,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer with a library brush or the active one, optionally changed for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush, blender, smudge) picks up and moves paint already on the layer. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes) and, for the mixer, its load after the stroke.",
+    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer with a library brush or the active one, optionally changed for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4815,6 +5505,67 @@ var BLEND_MENU_GROUPS = [
   { label: "Standard", modes: BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
   { label: "Paint", modes: BLEND_MODES.filter((m) => m.painterly || m.id === "pigment") }
 ];
+var PICKUP_SLIDERS = [
+  { path: "behavior.pickup", label: "Pick-up", min: 0, max: 1, step: 0.01 },
+  { path: "behavior.mix", label: "Mix", min: 0, max: 1, step: 0.01 }
+];
+function brushEngineControls(brush) {
+  switch (brush.engine) {
+    case "blender":
+      return {
+        title: "Blender",
+        sliders: [
+          { path: "blender.strength", label: "Strength", min: 0, max: 1, step: 0.01 },
+          { path: "blender.distance", label: "Blend distance", min: 0, max: 1, step: 0.01 }
+        ],
+        mixingPath: "blender.mixing",
+        dirty: false,
+        multicolor: false,
+        load: false
+      };
+    case "smudge":
+      return {
+        title: "Smudge",
+        sliders: [
+          { path: "smudge.strength", label: "Strength", min: 0, max: 1, step: 0.01 },
+          { path: "smudge.length", label: "Length", min: 0, max: 1, step: 0.01 }
+        ],
+        mixingPath: "smudge.mixing",
+        dirty: false,
+        multicolor: false,
+        load: false
+      };
+    case "mixer":
+      return { title: "Mixer Brush", sliders: [...PICKUP_SLIDERS, { path: "mixer.load", label: "Load", min: 0, max: 1, step: 0.01 }], mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
+    case "dab":
+      return { title: "Paint behaviour", sliders: PICKUP_SLIDERS, mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
+    default:
+      return null;
+  }
+}
+function multiColorSliders(mode) {
+  if (mode === "off") return [];
+  const soft = { path: "behavior.multicolor.softness", label: "Colour softness", min: 0, max: 1, step: 0.01 };
+  return mode === "dab" ? [soft, { path: "behavior.multicolor.length", label: "Dabs per colour", min: 1, max: 100, step: 1 }] : [soft];
+}
+function patchBrushValue(brush, path, value) {
+  const set = (obj, keys) => {
+    const [head2, ...rest2] = keys;
+    if (!rest2.length) return { ...obj, [head2]: value };
+    return { ...obj, [head2]: set(obj[head2] ?? {}, rest2) };
+  };
+  const [head, ...rest] = path.split(".");
+  if (!rest.length) return { [head]: value };
+  return { [head]: set({ ...brush[head] ?? {} }, rest) };
+}
+function brushLoadColor(load) {
+  const c = load.pickup ?? load.reservoir;
+  return c ? rgbToHexColor(Math.round(c[0] * 255), Math.round(c[1] * 255), Math.round(c[2] * 255)) : null;
+}
+var PAD_SAMPLE_SIZES = [1, 3, 5, 9, 15];
+function padSampleRadius(size) {
+  return Math.max(0, Math.floor((size - 1) / 2));
+}
 export {
   BLEND_MENU_GROUPS,
   BLEND_MODES,
@@ -4822,9 +5573,11 @@ export {
   BRUSH_ROTATIONS,
   BRUSH_SLIDERS,
   BUILTIN_BRUSHES,
+  DEFAULT_BEHAVIOR,
   DEFAULT_BRUSH_ID,
   DEFAULT_DPI,
   DEFAULT_DYNAMICS,
+  DEFAULT_MULTI_COLOR,
   DEFAULT_PAPER,
   DEFAULT_SWATCHES,
   DEFAULT_VIEW,
@@ -4843,7 +5596,9 @@ export {
   MIN_ZOOM,
   MIXING_PAD_HEIGHT,
   MIXING_PAD_WIDTH,
+  MULTI_COLOR_MODES,
   MixingPad,
+  PAD_SAMPLE_SIZES,
   PAINTERLY_BLEND_MODES,
   PAINT_BRUSH_CATEGORIES,
   PAINT_BRUSH_ENGINES,
@@ -4855,6 +5610,7 @@ export {
   PAPER_NODE_ID,
   PAPER_SLIDERS,
   PaintCanvasPresenter,
+  PaintDabStroke,
   PaintDirector,
   PaintDocumentError,
   PaintEditorController,
@@ -4872,6 +5628,9 @@ export {
   TileableNoise,
   affineCopy,
   applyAffine,
+  brushEngineControls,
+  brushLoadColor,
+  brushLoadForStroke,
   brushToJSON,
   clonePaper,
   colorHarmony,
@@ -4903,26 +5662,35 @@ export {
   isBlendMode,
   isPainterlyBlendMode,
   isPalmTouch,
+  isWetCapable,
   mapPenPoint,
   mix32,
   mixerLoadForStroke,
   mixerTip,
+  multiColorForDab,
+  multiColorGradient,
+  multiColorPalette,
+  multiColorSliders,
   newPaintLayerId,
+  normalizeBehavior,
   normalizeBrushStroke,
   normalizeCanvas,
   normalizeDynamics,
+  normalizeMultiColor,
   normalizePaintBrush,
   normalizePaper,
   normalizePerspective,
   normalizeRotation,
   normalizeSymmetry,
   normalizeView,
+  padSampleRadius,
   paperGrain,
   paperKey,
   paperNode,
   paperPreset,
   parseBrushLibrary,
   parseHexColor,
+  patchBrushValue,
   patchPath,
   penOrientation,
   perspectiveDirections,
@@ -4953,6 +5721,7 @@ export {
   thumbnailStroke,
   tiltToOrientation,
   toStrokePoint,
+  usesPaintExchange,
   variationAffine,
   varyStroke,
   viewCssTransform,