@pixerate/editor 0.109.0 → 0.110.0

package/dist/paint-editor/index.cjs

@@ -1,10 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12;
 
 
 
 
 
-var _chunkD37BX2ZAcjs = require('../chunk-D37BX2ZA.cjs');
+var _chunkMGL4U5WAcjs = require('../chunk-MGL4U5WA.cjs');
 
 
 
@@ -17,7 +17,9 @@ var _chunkD37BX2ZAcjs = require('../chunk-D37BX2ZA.cjs');
 
 
 
-var _chunkAZTZRLDIcjs = require('../chunk-AZTZRLDI.cjs');
+
+
+var _chunkPOGBUYWEcjs = require('../chunk-POGBUYWE.cjs');
 require('../chunk-MUUXNRU4.cjs');
 
 
@@ -35,11 +37,18 @@ require('../chunk-MUUXNRU4.cjs');
 
 
 
-var _chunkHUFQD4CBcjs = require('../chunk-HUFQD4CB.cjs');
 
 
 
 
+
+
+
+
+
+
+var _chunk7VOHOPLWcjs = require('../chunk-7VOHOPLW.cjs');
+
 
 
 
@@ -53,7 +62,13 @@ var _chunkHUFQD4CBcjs = require('../chunk-HUFQD4CB.cjs');
 
 
 
-var _chunkSZ6KMZNMcjs = require('../chunk-SZ6KMZNM.cjs');
+
+
+
+
+
+
+var _chunkXIOMMGPDcjs = require('../chunk-XIOMMGPD.cjs');
 
 
 
@@ -412,7 +427,7 @@ function newPaintLayerId() {
   return `pl${Date.now().toString(36)}${(nextId++).toString(36)}`;
 }
 function createPaintLayer(name, id = newPaintLayerId()) {
-  return { type: "pixel", id, name, visible: true, opacity: 1, blend: "normal", surface: _chunkSZ6KMZNMcjs.emptySurface.call(void 0, 4), offset: { x: 0, y: 0 } };
+  return { type: "pixel", id, name, visible: true, opacity: 1, blend: "normal", surface: _chunkXIOMMGPDcjs.emptySurface.call(void 0, 4), offset: { x: 0, y: 0 } };
 }
 var PaintDocumentError = class extends Error {
   constructor(message) {
@@ -438,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,
@@ -472,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(_nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(raw.behavior, () => ( {}));
+  const mixerIn = { ...b.mixer, ..._nullishCoalesce(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 = _chunk7VOHOPLWcjs.normalizeMixer.call(void 0, 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,
-    tip: _chunkHUFQD4CBcjs.normalizeBrush.call(void 0, { ...b.tip, ..._nullishCoalesce(raw.tip, () => ( {})) }),
+    engine,
+    tip: _chunk7VOHOPLWcjs.normalizeBrush.call(void 0, { ...b.tip, ..._nullishCoalesce(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(_nullishCoalesce(raw.dynamics, () => ( {})), b.dynamics),
-    mixer: _chunkHUFQD4CBcjs.normalizeMixer.call(void 0, { ...b.mixer, ..._nullishCoalesce(raw.mixer, () => ( {})) }),
+    mixer,
     loadsColor: typeof raw.loadsColor === "boolean" ? raw.loadsColor : b.loadsColor,
+    behavior,
+    blender: _chunk7VOHOPLWcjs.normalizeBlender.call(void 0, _nullishCoalesce(raw.blender, () => ( {})), b.blender),
+    smudge: _chunk7VOHOPLWcjs.normalizeSmudge.call(void 0, _nullishCoalesce(raw.smudge, () => ( {})), b.smudge),
     ...raw.builtin ? { builtin: true } : {}
   };
 }
@@ -495,13 +554,16 @@ var BASE_BRUSH = {
   name: "Round",
   category: "custom",
   engine: "dab",
-  tip: { ..._chunkHUFQD4CBcjs.DEFAULT_BRUSH },
+  tip: { ..._chunk7VOHOPLWcjs.DEFAULT_BRUSH },
   grain: 0,
   pressureSmoothing: 0,
   rotation: "fixed",
   dynamics: { ...DEFAULT_DYNAMICS },
-  mixer: { ..._chunkHUFQD4CBcjs.DEFAULT_MIXER },
-  loadsColor: true
+  mixer: { ..._chunk7VOHOPLWcjs.DEFAULT_MIXER },
+  loadsColor: true,
+  behavior: { ...DEFAULT_BEHAVIOR, multicolor: { ...DEFAULT_MULTI_COLOR, colors: [] } },
+  blender: { ..._chunk7VOHOPLWcjs.DEFAULT_BLENDER },
+  smudge: { ..._chunk7VOHOPLWcjs.DEFAULT_SMUDGE }
 };
 var builtin = (init) => ({ ...normalizePaintBrush(init), builtin: true });
 var BUILTIN_BRUSHES = [
@@ -615,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",
@@ -807,7 +904,9 @@ var PenDabWalker = (_class4 = 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) {
@@ -877,7 +976,7 @@ var DryStroke = (_class5 = class {
   }
   
   
-  __init12() {this.coverage = new (0, _chunkHUFQD4CBcjs.CoverageMap)()}
+  __init12() {this.coverage = new (0, _chunk7VOHOPLWcjs.CoverageMap)()}
   __init13() {this.dabCount = 0}
   
   
@@ -911,11 +1010,11 @@ var DryStroke = (_class5 = class {
     const hardness = this.brush.tip.hardness;
     const grain = this.options.grain;
     for (const d of dabs) {
-      const rect = _chunkHUFQD4CBcjs.dabRect.call(void 0, d, hardness);
+      const rect = _chunk7VOHOPLWcjs.dabRect.call(void 0, d, hardness);
       const n = rect.width * rect.height;
       if (this.buf.length < n) this.buf = new Float32Array(n);
       const vals = this.buf.subarray(0, n);
-      _chunkHUFQD4CBcjs.rasterizeDab.call(void 0, d, hardness, rect, vals);
+      _chunk7VOHOPLWcjs.rasterizeDab.call(void 0, d, hardness, rect, vals);
       if (this.depth > 0 && grain) {
         for (let yy = 0, k = 0; yy < rect.height; yy++) {
           const y = rect.y + yy + 0.5;
@@ -938,9 +1037,251 @@ 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);
+    _chunkXIOMMGPDcjs.mixPigment8.call(void 0, 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 = (_class6 = class {
+  constructor(brush, options) {;_class6.prototype.__init17.call(this);_class6.prototype.__init18.call(this);_class6.prototype.__init19.call(this);_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);
+    this.brush = brush;
+    this.options = options;
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = _optionalChain([options, 'access', _4 => _4.copies, 'optionalAccess', _5 => _5.length]) ? options.copies : [IDENTITY_COPY];
+    const exchanging = brush.engine === "mixer" || brush.engine === "dab";
+    const rates = brush.engine === "mixer" ? _chunk7VOHOPLWcjs.mixerRates.call(void 0, brush.mixer) : _chunk7VOHOPLWcjs.exchangeRates.call(void 0, 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, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear),
+      exchange: exchanging ? new (0, _chunk7VOHOPLWcjs.PaintExchange)(rates, options.load) : null,
+      smudge: brush.engine === "smudge" ? new (0, _chunk7VOHOPLWcjs.SmudgeTip)(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
+    }));
+    this.medium = new (0, _chunk7VOHOPLWcjs.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 (0, _chunk7VOHOPLWcjs.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" ? _chunk7VOHOPLWcjs.createBlenderScratch.call(void 0, ) : null;
+  }
+  
+  
+  __init17() {this.dabCount = 0}
+  
+  
+  
+  
+  
+  
+  
+  
+  __init18() {this.fieldLut = []}
+  
+  
+  __init19() {this.tip = new Float32Array(0)}
+  __init20() {this.cov = new Float32Array(0)}
+  __init21() {this.field = new Float32Array(0)}
+  __init22() {this.paint = [0, 0, 0]}
+  __init23() {this.lastRaw = null}
+  __init24() {this.lastFed = null}
+  /** What copy 0's brush carries after the dabs so far (mixer and wet-capable dab brushes). */
+  get load() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _6 => _6.states, 'access', _7 => _7[0], 'access', _8 => _8.exchange, 'optionalAccess', _9 => _9.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 = _chunk7VOHOPLWcjs.dabRect.call(void 0, 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);
+    _chunk7VOHOPLWcjs.rasterizeDab.call(void 0, { ...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") {
+      _chunk7VOHOPLWcjs.blenderDab.call(void 0, 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, _nullishCoalesce(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 = _nullishCoalesce(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);
+  }
+}, _class6);
+
 // src/paint-editor/stroke.ts
 function defaultTile(surface) {
-  const data = new Uint8ClampedArray(_chunkSZ6KMZNMcjs.TILE * _chunkSZ6KMZNMcjs.TILE * surface.channels);
+  const data = new Uint8ClampedArray(_chunkXIOMMGPDcjs.TILE * _chunkXIOMMGPDcjs.TILE * surface.channels);
   if (surface.defaultValue) data.fill(surface.defaultValue);
   return data;
 }
@@ -957,8 +1298,8 @@ function union(a, b) {
   const y = Math.min(a.y, b.y);
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
-var PaintStrokeSession = (_class6 = class {
-  constructor(host, init) {;_class6.prototype.__init17.call(this);_class6.prototype.__init18.call(this);_class6.prototype.__init19.call(this);_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);
+var PaintStrokeSession = (_class7 = class {
+  constructor(host, init) {;_class7.prototype.__init25.call(this);_class7.prototype.__init26.call(this);_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);_class7.prototype.__init29.call(this);_class7.prototype.__init30.call(this);_class7.prototype.__init31.call(this);_class7.prototype.__init32.call(this);_class7.prototype.__init33.call(this);
     this.host = host;
     this.init = init;
     this.layerId = init.layerId;
@@ -976,10 +1317,18 @@ var PaintStrokeSession = (_class6 = 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 (0, _chunkHUFQD4CBcjs.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(_nullishCoalesce(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 });
     }
@@ -988,30 +1337,29 @@ var PaintStrokeSession = (_class6 = class {
   
   
   /** The raw input so far (what a replay feeds back in). */
-  __init17() {this.points = []}
+  __init25() {this.points = []}
   
   
-  __init18() {this.touched = /* @__PURE__ */ new Set()}
-  __init19() {this.fresh = /* @__PURE__ */ new Set()}
-  __init20() {this.dry = null}
-  __init21() {this.mixers = []}
-  __init22() {this.mixerSmoother = null}
+  __init26() {this.touched = /* @__PURE__ */ new Set()}
+  __init27() {this.fresh = /* @__PURE__ */ new Set()}
+  __init28() {this.dry = null}
+  __init29() {this.wet = null}
   
   
-  __init23() {this.bounds = null}
-  __init24() {this.lastRaw = null}
-  __init25() {this.closed = false}
-  __init26() {this.result = null}
-  mixerTarget() {
+  __init30() {this.bounds = null}
+  __init31() {this.lastRaw = null}
+  __init32() {this.closed = false}
+  __init33() {this.result = null}
+  tileTarget() {
     return {
       offset: this.init.offset,
       lockTransparency: this.init.lockTransparency,
       selection: null,
-      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _4 => _4.live, 'access', _5 => _5.get, 'call', _6 => _6(_chunkSZ6KMZNMcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _7 => _7.data]), () => ( null)),
+      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _10 => _10.live, 'access', _11 => _11.get, 'call', _12 => _12(_chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _13 => _13.data]), () => ( null)),
       writeTile: (tx, ty) => {
-        const key = _chunkSZ6KMZNMcjs.tileKey.call(void 0, tx, ty);
+        const key = _chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty);
         if (!this.touched.has(key)) {
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _8 => _8.base, 'access', _9 => _9.tiles, 'access', _10 => _10.get, 'call', _11 => _11(key), 'optionalAccess', _12 => _12.data]), () => ( defaultTile(this.base)));
+          const src = _nullishCoalesce(_optionalChain([this, 'access', _14 => _14.base, 'access', _15 => _15.tiles, 'access', _16 => _16.get, 'call', _17 => _17(key), 'optionalAccess', _18 => _18.data]), () => ( defaultTile(this.base)));
           this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
           this.touched.add(key);
         }
@@ -1030,15 +1378,7 @@ var PaintStrokeSession = (_class6 = 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;
@@ -1047,57 +1387,47 @@ var PaintStrokeSession = (_class6 = class {
     if (!this.dry) {
       for (const key of this.fresh) this.live.set(key, { data: this.live.get(key).data, uniform: null });
       this.fresh.clear();
-      this.host.update(this.layerId, new (0, _chunkSZ6KMZNMcjs.TiledSurface)(ch, new Map(this.live), this.base.defaultValue), rects);
+      this.host.update(this.layerId, new (0, _chunkXIOMMGPDcjs.TiledSurface)(ch, new Map(this.live), this.base.defaultValue), rects);
       return;
     }
     const off = this.init.offset;
     const regions = /* @__PURE__ */ new Map();
     for (const r of rects) {
-      for (const t of _chunkSZ6KMZNMcjs.tilesInRect.call(void 0, { x: r.x - off.x, y: r.y - off.y, width: r.width, height: r.height })) {
-        const key = _chunkSZ6KMZNMcjs.tileKey.call(void 0, t.tx, t.ty);
+      for (const t of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, { x: r.x - off.x, y: r.y - off.y, width: r.width, height: r.height })) {
+        const key = _chunkXIOMMGPDcjs.tileKey.call(void 0, t.tx, t.ty);
         const cur = regions.get(key);
         regions.set(key, { tx: t.tx, ty: t.ty, r: cur ? union(cur.r, r) : r });
       }
     }
     for (const [key, { tx, ty, r }] of regions) {
-      const src = _nullishCoalesce(_optionalChain([this, 'access', _13 => _13.base, 'access', _14 => _14.tiles, 'access', _15 => _15.get, 'call', _16 => _16(key), 'optionalAccess', _17 => _17.data]), () => ( defaultTile(this.base)));
-      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _18 => _18.live, 'access', _19 => _19.get, 'call', _20 => _20(key), 'optionalAccess', _21 => _21.data]) : void 0;
+      const src = _nullishCoalesce(_optionalChain([this, 'access', _19 => _19.base, 'access', _20 => _20.tiles, 'access', _21 => _21.get, 'call', _22 => _22(key), 'optionalAccess', _23 => _23.data]), () => ( defaultTile(this.base)));
+      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _24 => _24.live, 'access', _25 => _25.get, 'call', _26 => _26(key), 'optionalAccess', _27 => _27.data]) : void 0;
       this.touched.add(key);
-      const data = _chunkHUFQD4CBcjs.applyStrokeToTile.call(void 0, this.dry.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
+      const data = _chunk7VOHOPLWcjs.applyStrokeToTile.call(void 0, this.dry.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
     }
-    this.host.update(this.layerId, new (0, _chunkSZ6KMZNMcjs.TiledSurface)(ch, new Map(this.live), this.base.defaultValue), rects);
+    this.host.update(this.layerId, new (0, _chunkXIOMMGPDcjs.TiledSurface)(ch, new Map(this.live), this.base.defaultValue), rects);
   }
   /** 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);
     let changed = false;
     for (const key of this.touched) {
-      const tile = _chunkSZ6KMZNMcjs.finishTile.call(void 0, this.live.get(key).data, ch, this.base.defaultValue);
+      const tile = _chunkXIOMMGPDcjs.finishTile.call(void 0, this.live.get(key).data, ch, this.base.defaultValue);
       const prev = this.base.tiles.get(key);
       if (tile) tiles.set(key, tile);
       else tiles.delete(key);
       if (!sameTile(prev, tile)) changed = true;
     }
-    const surface = changed ? new (0, _chunkSZ6KMZNMcjs.TiledSurface)(ch, tiles, this.base.defaultValue) : null;
-    const dabs = this.dry ? this.dry.dabCount : this.mixers.reduce((n, m) => n + m.dabCount, 0);
+    const surface = changed ? new (0, _chunkXIOMMGPDcjs.TiledSurface)(ch, tiles, this.base.defaultValue) : null;
+    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 = _chunkHUFQD4CBcjs.cleanMixer.call(void 0, load);
-      this.result.mixerLoad = load;
-    }
+    const carried = _optionalChain([this, 'access', _28 => _28.wet, 'optionalAccess', _29 => _29.load]);
+    if (carried) this.result.mixerLoad = this.init.brush.behavior.dirty ? carried : _chunk7VOHOPLWcjs.cleanMixer.call(void 0, carried);
     this.host.commit(this, surface, false);
     return this.result;
   }
@@ -1107,12 +1437,17 @@ var PaintStrokeSession = (_class6 = class {
     this.closed = true;
     this.host.commit(this, null, true);
   }
-}, _class6);
+}, _class7);
 function mixerLoadForStroke(brush, current, color) {
   if (!brush.loadsColor) return { reservoir: null, amount: 0, pickup: brush.mixer.cleanEachStroke ? null : current.pickup };
-  if (brush.mixer.loadEachStroke || !current.reservoir) return _chunkHUFQD4CBcjs.loadMixer.call(void 0, current, color);
+  if (brush.mixer.loadEachStroke || !current.reservoir) return _chunk7VOHOPLWcjs.loadMixer.call(void 0, 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 _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD;
+}
 
 // src/paint-editor/strokes.ts
 var IDENTITY_AFFINE = [1, 0, 0, 1, 0, 0];
@@ -1158,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;
@@ -1174,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) {
@@ -1210,7 +1558,7 @@ function varyStroke(stroke, m, v) {
   });
   const brush = s !== 1 ? normalizePaintBrush({ ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
   const out = { ...stroke, brush, points };
-  if (_optionalChain([stroke, 'access', _22 => _22.copies, 'optionalAccess', _23 => _23.length])) {
+  if (_optionalChain([stroke, 'access', _30 => _30.copies, 'optionalAccess', _31 => _31.length])) {
     const inv = invertAffine(m);
     out.copies = stroke.copies.map((c) => composeAffine(m, composeAffine(c, inv)));
   }
@@ -1277,7 +1625,7 @@ var PROFILE = {
   }
 };
 function createPaintCompositor() {
-  return new (0, _chunkAZTZRLDIcjs.RasterCompositor)(PROFILE);
+  return new (0, _chunkPOGBUYWEcjs.RasterCompositor)(PROFILE);
 }
 function downsampleRgba(data, width, height, tw, th) {
   tw = Math.max(1, Math.round(tw));
@@ -1325,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;
@@ -1345,14 +1693,15 @@ 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 = {}) {
-  const { layers, assets } = _chunkD37BX2ZAcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkMGL4U5WAcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkD37BX2ZAcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkMGL4U5WAcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1360,7 +1709,7 @@ function paintLayersOnly(layers, problems) {
   for (const l of layers) {
     if (l.type === "pixel") {
       const { filters, source, ...rest } = l;
-      if (_optionalChain([filters, 'optionalAccess', _24 => _24.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
+      if (_optionalChain([filters, 'optionalAccess', _32 => _32.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
       if (source) problems.push(`Layer "${l.name}" refers to an image editor source image; it loads empty.`);
       out.push(rest);
     } else if (l.type === "group") out.push({ ...l, children: paintLayersOnly(l.children, problems) });
@@ -1389,16 +1738,16 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = normalizePaper(_nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkD37BX2ZAcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkMGL4U5WAcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
-  const activeLayerId = wanted && _chunkAZTZRLDIcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkAZTZRLDIcjs.flattenLayers.call(void 0, layers), 'access', _25 => _25.filter, 'call', _26 => _26((l) => l.type === "pixel"), 'access', _27 => _27.pop, 'call', _28 => _28(), 'optionalAccess', _29 => _29.id]), () => ( null));
-  return { state: { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) }, extensions: documentExtensions(r), guides: r.guides, swatches: r.swatches, problems };
+  const activeLayerId = wanted && _chunkPOGBUYWEcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkPOGBUYWEcjs.flattenLayers.call(void 0, layers), 'access', _33 => _33.filter, 'call', _34 => _34((l) => l.type === "pixel"), 'access', _35 => _35.pop, 'call', _36 => _36(), 'optionalAccess', _37 => _37.id]), () => ( null));
+  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.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkD37BX2ZAcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkMGL4U5WAcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -1530,7 +1879,7 @@ async function decodeImageBlob(blob) {
   if (!ctx) throw new Error("No 2D context to decode with.");
   ctx.drawImage(bitmap, 0, 0);
   const data = new Uint8ClampedArray(ctx.getImageData(0, 0, bitmap.width, bitmap.height).data);
-  _optionalChain([bitmap, 'access', _30 => _30.close, 'optionalCall', _31 => _31()]);
+  _optionalChain([bitmap, 'access', _38 => _38.close, 'optionalCall', _39 => _39()]);
   return { width: bitmap.width, height: bitmap.height, data };
 }
 function downloadBytes(bytes, fileName, mimeType) {
@@ -1577,7 +1926,7 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       colorHex: color,
       affineCopies: [],
       copies: [IDENTITY_COPY],
-      mixerLoad: brush.engine === "mixer" ? mixerLoadForStroke(brush, _chunkHUFQD4CBcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]) : _chunkHUFQD4CBcjs.EMPTY_MIXER_LOAD
+      mixerLoad: brushLoadForStroke(brush, _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
     }
   );
   session.push(thumbnailStroke(width, height));
@@ -1590,13 +1939,13 @@ function renderBrushThumbnail(brush, options) {
   const maxSize = height * 0.42;
   const b = brush.tip.size > maxSize ? normalizePaintBrush({ tip: { ...brush.tip, size: maxSize } }, brush) : brush;
   const rgba = [...hexToRgb8(options.color), 255];
-  let surface = _chunkSZ6KMZNMcjs.emptySurface.call(void 0, 4);
+  let surface = _chunkXIOMMGPDcjs.emptySurface.call(void 0, 4);
   if (b.engine === "eraser") {
-    surface = _chunkSZ6KMZNMcjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height }, rgba);
-  } else if (b.engine === "mixer" && !b.loadsColor) {
+    surface = _chunkXIOMMGPDcjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height }, rgba);
+  } else if (b.engine === "blender" || b.engine === "smudge" || b.engine === "mixer" && !b.loadsColor || b.behavior.pickup > 0) {
     const half = Math.ceil(height / 2);
-    surface = _chunkSZ6KMZNMcjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height: half }, rgba);
-    surface = _chunkSZ6KMZNMcjs.fillRect.call(void 0, surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
+    surface = _chunkXIOMMGPDcjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height: half }, rgba);
+    surface = _chunkXIOMMGPDcjs.fillRect.call(void 0, surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
   }
   surface = paintTestStroke(surface, b, options.paper, options.color, width, height);
   const layer = { type: "pixel", id: "thumbnail", name: "thumbnail", visible: true, opacity: 1, blend: "normal", surface, offset: { x: 0, y: 0 } };
@@ -1728,13 +2077,13 @@ function perspectiveDirections(g, p) {
   return out;
 }
 var SNAP_DECIDE_DISTANCE = 6;
-var PerspectiveSnapper = (_class7 = class {
-  constructor(guide) {;_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);
+var PerspectiveSnapper = (_class8 = class {
+  constructor(guide) {;_class8.prototype.__init34.call(this);_class8.prototype.__init35.call(this);
     this.guide = guide;
   }
   
-  __init27() {this.start = null}
-  __init28() {this.dir = null}
+  __init34() {this.start = null}
+  __init35() {this.dir = null}
   /** The line the stroke follows, once chosen. */
   get line() {
     return this.start && this.dir ? { from: this.start, direction: this.dir } : null;
@@ -1767,7 +2116,7 @@ var PerspectiveSnapper = (_class7 = class {
     const t = (p.x - s.x) * d.x + (p.y - s.y) * d.y;
     return { ...p, x: s.x + d.x * t, y: s.y + d.y * t };
   }
-}, _class7);
+}, _class8);
 function perspectiveGuideLines(g, size, count = 12) {
   const out = [];
   const far = Math.hypot(size.width, size.height) * 4;
@@ -1786,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];
@@ -1916,17 +2265,25 @@ 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 = (_class8 = class {constructor() { _class8.prototype.__init29.call(this);_class8.prototype.__init30.call(this);_class8.prototype.__init31.call(this);_class8.prototype.__init32.call(this); }
-  __init29() {this.width = MIXING_PAD_WIDTH}
-  __init30() {this.height = MIXING_PAD_HEIGHT}
-  __init31() {this.surface = _chunkSZ6KMZNMcjs.emptySurface.call(void 0, 4)}
+var MixingPad = (_class9 = class {constructor() { _class9.prototype.__init36.call(this);_class9.prototype.__init37.call(this);_class9.prototype.__init38.call(this);_class9.prototype.__init39.call(this); }
+  __init36() {this.width = MIXING_PAD_WIDTH}
+  __init37() {this.height = MIXING_PAD_HEIGHT}
+  __init38() {this.surface = _chunkXIOMMGPDcjs.emptySurface.call(void 0, 4)}
   /** Increments on every change (for redrawing). */
-  __init32() {this.version = 0}
+  __init39() {this.version = 0}
   /** Paints (`paint`, with `color`) or smears (`knife`) through `points` in pad pixels. */
   stroke(points, options) {
     if (!points.length) throw new Error("points is empty; give at least one {x, y} in pad pixels.");
@@ -1937,7 +2294,11 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init29.cal
     }
     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: () => {
@@ -1953,10 +2314,10 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init29.cal
         grain: null,
         paperDepth: 0,
         seed: 1,
-        colorHex: options.color,
+        colorHex: color,
         affineCopies: [],
         copies: [IDENTITY_COPY],
-        mixerLoad: mixerLoadForStroke(brush, _chunkHUFQD4CBcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
+        mixerLoad: brushLoadForStroke(brush, _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
       }
     );
     session.push(points);
@@ -1975,7 +2336,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init29.cal
     const y0 = Math.max(0, Math.floor(y) - r);
     const x1 = Math.min(this.width, Math.floor(x) + r + 1);
     const y1 = Math.min(this.height, Math.floor(y) + r + 1);
-    const px = _chunkSZ6KMZNMcjs.readRegion.call(void 0, this.surface, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
+    const px = _chunkXIOMMGPDcjs.readRegion.call(void 0, this.surface, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
     let R = 0;
     let G = 0;
     let B = 0;
@@ -1992,12 +2353,88 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init29.cal
     return `#${hex(R)}${hex(G)}${hex(B)}`;
   }
   clear() {
-    this.surface = _chunkSZ6KMZNMcjs.emptySurface.call(void 0, 4);
+    this.surface = _chunkXIOMMGPDcjs.emptySurface.call(void 0, 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 = _nullishCoalesce(options.radius, () => ( 40));
+    if (!(R >= 12 && R <= 100)) throw new Error(`radius ${R} is out of range; use 12..100 pad px.`);
+    const passes = _nullishCoalesce(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 = _nullishCoalesce(options.x, () => ( this.width / 2));
+    const cy = _nullishCoalesce(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 = _chunkXIOMMGPDcjs.writeRegion.call(void 0, 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 = _chunkXIOMMGPDcjs.mixPigments.call(void 0, 
+      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 _chunkPOGBUYWEcjs.pngDataUrl.call(void 0, this.width, this.height, _chunkXIOMMGPDcjs.readRegion.call(void 0, 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:") ? _optionalChain([_chunkPOGBUYWEcjs.parseDataUrl.call(void 0, png), 'optionalAccess', _40 => _40.bytes]) : _chunkPOGBUYWEcjs.base64ToBytes.call(void 0, png);
+    if (!bytes || !_chunkPOGBUYWEcjs.isPng.call(void 0, bytes)) throw new Error("The pad image is not a PNG data URL or base64 PNG.");
+    const img = _chunkPOGBUYWEcjs.decodePng.call(void 0, 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 = _chunkXIOMMGPDcjs.surfaceFromPixels.call(void 0, { 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 = _chunkSZ6KMZNMcjs.readRegion.call(void 0, this.surface, { x: 0, y: 0, width: this.width, height: this.height });
+    const px = _chunkXIOMMGPDcjs.readRegion.call(void 0, this.surface, { x: 0, y: 0, width: this.width, height: this.height });
     for (let i = 0; i < px.length; i += 4) {
       const a = px[i + 3] / 255;
       px[i] = Math.round(px[i] * a + 255 * (1 - a));
@@ -2007,7 +2444,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init29.cal
     }
     return px;
   }
-}, _class8);
+}, _class9);
 
 // src/paint-editor/controller.ts
 var PaintEditorError = class extends Error {
@@ -2016,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) {
@@ -2035,40 +2472,44 @@ function unionRect(a, b) {
   const y = Math.min(a.y, b.y);
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
-var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _32 => _32.type]) === "pixel";
-var PaintEditorController = (_class9 = class {
+var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _41 => _41.type]) === "pixel";
+var PaintEditorController = (_class10 = class {
   
-  __init33() {this.extensions = {}}
-  __init34() {this.undoStack = []}
-  __init35() {this.redoStack = []}
+  __init40() {this.extensions = {}}
+  __init41() {this.undoStack = []}
+  __init42() {this.redoStack = []}
   
   
   
+  /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
+  __init43() {this.library = null}
   
-  __init36() {this.secondaryColor = "#ffffff"}
-  __init37() {this.mixerLoad = _chunkHUFQD4CBcjs.EMPTY_MIXER_LOAD}
-  __init38() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  __init44() {this.secondaryColor = "#ffffff"}
+  __init45() {this.mixerLoad = _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD}
+  __init46() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
   
   
-  __init39() {this.listeners = /* @__PURE__ */ new Set()}
-  __init40() {this.version = 0}
-  __init41() {this.cached = null}
-  __init42() {this.session = null}
-  __init43() {this.live = null}
-  __init44() {this.liveLayers = null}
-  __init45() {this.dirty = "all"}
-  __init46() {this.seedCounter = 1}
-  __init47() {this.strokeCounter = 1}
+  __init47() {this.listeners = /* @__PURE__ */ new Set()}
+  __init48() {this.version = 0}
+  __init49() {this.cached = null}
+  __init50() {this.session = null}
+  __init51() {this.live = null}
+  __init52() {this.liveLayers = null}
+  __init53() {this.dirty = "all"}
+  __init54() {this.seedCounter = 1}
+  __init55() {this.strokeCounter = 1}
   
-  __init48() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init49() {this.pad = new MixingPad()}
-  __init50() {this.tracingVersion = 1}
-  __init51() {this.tracingCache = null}
-  __init52() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init53() {this.nextReferenceId = 1}
-  __init54() {this.viewCompositor = createPaintCompositor()}
-  __init55() {this.exportCompositor = createPaintCompositor()}
-  constructor(options = {}) {;_class9.prototype.__init33.call(this);_class9.prototype.__init34.call(this);_class9.prototype.__init35.call(this);_class9.prototype.__init36.call(this);_class9.prototype.__init37.call(this);_class9.prototype.__init38.call(this);_class9.prototype.__init39.call(this);_class9.prototype.__init40.call(this);_class9.prototype.__init41.call(this);_class9.prototype.__init42.call(this);_class9.prototype.__init43.call(this);_class9.prototype.__init44.call(this);_class9.prototype.__init45.call(this);_class9.prototype.__init46.call(this);_class9.prototype.__init47.call(this);_class9.prototype.__init48.call(this);_class9.prototype.__init49.call(this);_class9.prototype.__init50.call(this);_class9.prototype.__init51.call(this);_class9.prototype.__init52.call(this);_class9.prototype.__init53.call(this);_class9.prototype.__init54.call(this);_class9.prototype.__init55.call(this);
+  __init56() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init57() {this.pad = new MixingPad()}
+  __init58() {this.savedPads = []}
+  __init59() {this.nextPadId = 1}
+  __init60() {this.tracingVersion = 1}
+  __init61() {this.tracingCache = null}
+  __init62() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init63() {this.nextReferenceId = 1}
+  __init64() {this.viewCompositor = createPaintCompositor()}
+  __init65() {this.exportCompositor = createPaintCompositor()}
+  constructor(options = {}) {;_class10.prototype.__init40.call(this);_class10.prototype.__init41.call(this);_class10.prototype.__init42.call(this);_class10.prototype.__init43.call(this);_class10.prototype.__init44.call(this);_class10.prototype.__init45.call(this);_class10.prototype.__init46.call(this);_class10.prototype.__init47.call(this);_class10.prototype.__init48.call(this);_class10.prototype.__init49.call(this);_class10.prototype.__init50.call(this);_class10.prototype.__init51.call(this);_class10.prototype.__init52.call(this);_class10.prototype.__init53.call(this);_class10.prototype.__init54.call(this);_class10.prototype.__init55.call(this);_class10.prototype.__init56.call(this);_class10.prototype.__init57.call(this);_class10.prototype.__init58.call(this);_class10.prototype.__init59.call(this);_class10.prototype.__init60.call(this);_class10.prototype.__init61.call(this);_class10.prototype.__init62.call(this);_class10.prototype.__init63.call(this);_class10.prototype.__init64.call(this);_class10.prototype.__init65.call(this);
     this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
     this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => normalizePaintBrush({ ...b, builtin: false }));
@@ -2099,7 +2540,7 @@ var PaintEditorController = (_class9 = 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,
@@ -2107,11 +2548,12 @@ var PaintEditorController = (_class9 = class {
       hand: this.hand,
       canUndo: this.undoStack.length > 0 && !this.session,
       canRedo: this.redoStack.length > 0 && !this.session,
-      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _33 => _33.label]), () => ( null)),
-      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _34 => _34.label]), () => ( null)),
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _42 => _42.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _43 => _43.label]), () => ( null)),
       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
     };
@@ -2216,7 +2658,7 @@ var PaintEditorController = (_class9 = class {
   }
   // --- Layers --------------------------------------------------------------------
   getLayer(id) {
-    return _optionalChain([_chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _35 => _35.layer]);
+    return _optionalChain([_chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _44 => _44.layer]);
   }
   /** The active pixel layer (or `undefined`). */
   getActiveLayer() {
@@ -2235,12 +2677,12 @@ var PaintEditorController = (_class9 = class {
     walk(this.doc.layers, null, 0);
     return out;
   }
-  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _36 => _36.parent, 'optionalAccess', _37 => _37.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _38 => _38.path, 'access', _39 => _39.length]), () => ( 0))) {
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _45 => _45.parent, 'optionalAccess', _46 => _46.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _47 => _47.path, 'access', _48 => _48.length]), () => ( 0))) {
     let bounds = null;
     if (l.type === "pixel") {
-      const b = _chunkSZ6KMZNMcjs.contentBounds.call(void 0, l.surface);
+      const b = _chunkXIOMMGPDcjs.contentBounds.call(void 0, l.surface);
       bounds = b ? { ...b, x: b.x + l.offset.x, y: b.y + l.offset.y } : null;
-    } else for (const c of _chunkAZTZRLDIcjs.flattenLayers.call(void 0, l.children)) if (c.type === "pixel") bounds = unionRect(bounds, this.describeLayer(c, l.id, depth + 1).bounds);
+    } else for (const c of _chunkPOGBUYWEcjs.flattenLayers.call(void 0, l.children)) if (c.type === "pixel") bounds = unionRect(bounds, this.describeLayer(c, l.id, depth + 1).bounds);
     return {
       id: l.id,
       name: l.name,
@@ -2267,7 +2709,7 @@ var PaintEditorController = (_class9 = class {
     if (!id) throw new PaintEditorError(`There is no active layer to ${what}; add one with add_layer.`);
     const l = this.requireLayer(id);
     if (!isPixelLayer(l)) throw new PaintEditorError(`Layer "${l.name}" is a group; ${what} a pixel layer inside it.`);
-    if (_chunkAZTZRLDIcjs.isLayerLocked.call(void 0, l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it (update_layer locks) before you ${what} it.`);
+    if (_chunkPOGBUYWEcjs.isLayerLocked.call(void 0, l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it (update_layer locks) before you ${what} it.`);
     if (!l.visible) throw new PaintEditorError(`Layer "${l.name}" is hidden; show it (update_layer visible true) before you ${what} it.`);
     return l;
   }
@@ -2280,9 +2722,9 @@ var PaintEditorController = (_class9 = class {
   /** Adds an empty pixel layer or group above `aboveId` (default: the active layer) and makes it active. */
   addLayer(options = {}) {
     this.requireIdle("adding a layer");
-    const count = _chunkAZTZRLDIcjs.flattenLayers.call(void 0, this.doc.layers).length;
+    const count = _chunkPOGBUYWEcjs.flattenLayers.call(void 0, this.doc.layers).length;
     const type = _nullishCoalesce(options.type, () => ( "pixel"));
-    const name = _optionalChain([options, 'access', _40 => _40.name, 'optionalAccess', _41 => _41.trim, 'call', _42 => _42()]) || (type === "group" ? `Group ${count + 1}` : `Layer ${count + 1}`);
+    const name = _optionalChain([options, 'access', _49 => _49.name, 'optionalAccess', _50 => _50.trim, 'call', _51 => _51()]) || (type === "group" ? `Group ${count + 1}` : `Layer ${count + 1}`);
     const layer = type === "group" ? { type: "group", id: newPaintLayerId(), name, visible: true, opacity: 1, blend: "pass-through", children: [] } : createPaintLayer(name);
     let parentId = null;
     let index;
@@ -2292,21 +2734,21 @@ var PaintEditorController = (_class9 = class {
       if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
       parentId = g.id;
     } else if (above) {
-      const loc = _chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, above);
+      const loc = _chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, above);
       if (!loc) throw new PaintEditorError(`Unknown layer "${above}". Call list_layers for the ids.`);
-      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _43 => _43.parent, 'optionalAccess', _44 => _44.id]), () => ( null));
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _52 => _52.parent, 'optionalAccess', _53 => _53.id]), () => ( null));
       index = loc.index + 1;
     }
-    const layers = _chunkAZTZRLDIcjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
+    const layers = _chunkPOGBUYWEcjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
     this.commit(type === "group" ? "Add group" : "Add layer", { ...this.doc, layers, activeLayerId: layer.id });
     return this.describeLayer(layer);
   }
   updateLayer(id, update) {
     this.requireIdle("changing a layer");
     const l = this.requireLayer(id);
-    if (_chunkAZTZRLDIcjs.isLayerLocked.call(void 0, l, "all") && Object.keys(update).some((k) => k !== "locks")) throw new PaintEditorError(`Layer "${l.name}" is fully locked; unlock it first (locks {all: false}).`);
+    if (_chunkPOGBUYWEcjs.isLayerLocked.call(void 0, l, "all") && Object.keys(update).some((k) => k !== "locks")) throw new PaintEditorError(`Layer "${l.name}" is fully locked; unlock it first (locks {all: false}).`);
     if (update.opacity !== void 0 && !(update.opacity >= 0 && update.opacity <= 1)) throw new PaintEditorError(`opacity ${update.opacity} is out of range; use 0..1.`);
-    if (update.blend !== void 0 && !_chunkSZ6KMZNMcjs.isBlendMode.call(void 0, update.blend) && !(l.type === "group" && update.blend === "pass-through")) {
+    if (update.blend !== void 0 && !_chunkXIOMMGPDcjs.isBlendMode.call(void 0, update.blend) && !(l.type === "group" && update.blend === "pass-through")) {
       throw new PaintEditorError(`Unknown blend mode "${update.blend}". Call get_canvas_info for the blend modes.`);
     }
     if (update.name !== void 0 && !update.name.trim()) throw new PaintEditorError("name is empty; give the layer a name.");
@@ -2320,66 +2762,66 @@ var PaintEditorController = (_class9 = class {
       const locks = { ..._nullishCoalesce(l.locks, () => ( {})), ...update.locks };
       next.locks = Object.values(locks).some(Boolean) ? locks : void 0;
     }
-    this.commit("Layer properties", { ...this.doc, layers: _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, id, () => next) });
+    this.commit("Layer properties", { ...this.doc, layers: _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, id, () => next) });
     return this.describeLayer(next);
   }
   removeLayer(id) {
     this.requireIdle("removing a layer");
     const l = this.requireLayer(id);
-    if (_chunkAZTZRLDIcjs.isLayerLocked.call(void 0, l, "all")) throw new PaintEditorError(`Layer "${l.name}" is fully locked; unlock it before removing it.`);
-    const layers = _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
+    if (_chunkPOGBUYWEcjs.isLayerLocked.call(void 0, l, "all")) throw new PaintEditorError(`Layer "${l.name}" is fully locked; unlock it before removing it.`);
+    const layers = _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
-    if (active && !_chunkAZTZRLDIcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkAZTZRLDIcjs.flattenLayers.call(void 0, layers), 'access', _45 => _45.filter, 'call', _46 => _46((x) => x.type === "pixel"), 'access', _47 => _47.pop, 'call', _48 => _48(), 'optionalAccess', _49 => _49.id]), () => ( null));
+    if (active && !_chunkPOGBUYWEcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkPOGBUYWEcjs.flattenLayers.call(void 0, layers), 'access', _54 => _54.filter, 'call', _55 => _55((x) => x.type === "pixel"), 'access', _56 => _56.pop, 'call', _57 => _57(), 'optionalAccess', _58 => _58.id]), () => ( null));
     this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active });
     return { removed: id, activeLayerId: active };
   }
   duplicateLayer(id) {
     this.requireIdle("duplicating a layer");
-    const loc = _chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, id);
+    const loc = _chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
     const copy = (l) => l.type === "group" ? { ...l, id: newPaintLayerId(), children: l.children.map(copy) } : { ...l, id: newPaintLayerId() };
     const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
-    const layers = _chunkAZTZRLDIcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _50 => _50.parent, 'optionalAccess', _51 => _51.id]), () => ( null)), loc.index + 1);
+    const layers = _chunkPOGBUYWEcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _59 => _59.parent, 'optionalAccess', _60 => _60.id]), () => ( null)), loc.index + 1);
     this.commit("Duplicate layer", { ...this.doc, layers, activeLayerId: dup.id });
     return this.describeLayer(dup);
   }
   /** Moves a layer to `index` (0 = bottom) within `parentId` (default its own parent; `null` = top level). */
   moveLayer(id, index, parentId) {
     this.requireIdle("moving a layer");
-    const loc = _chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, id);
+    const loc = _chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
-    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _52 => _52.parent, 'optionalAccess', _53 => _53.id]), () => ( null)) : parentId;
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _61 => _61.parent, 'optionalAccess', _62 => _62.id]), () => ( null)) : parentId;
     if (target) {
       const g = this.requireLayer(target);
       if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
-      if (target === id || loc.layer.type === "group" && _chunkAZTZRLDIcjs.findLayer.call(void 0, loc.layer.children, target)) throw new PaintEditorError("A group cannot move into itself.");
+      if (target === id || loc.layer.type === "group" && _chunkPOGBUYWEcjs.findLayer.call(void 0, loc.layer.children, target)) throw new PaintEditorError("A group cannot move into itself.");
     }
-    const without = _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
-    const siblings = target ? _chunkAZTZRLDIcjs.findLayer.call(void 0, without, target).layer.children : without;
+    const without = _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
+    const siblings = target ? _chunkPOGBUYWEcjs.findLayer.call(void 0, without, target).layer.children : without;
     if (!Number.isInteger(index) || index < 0 || index > siblings.length) throw new PaintEditorError(`index ${index} is out of range; use 0..${siblings.length} (0 is the bottom).`);
-    const layers = _chunkAZTZRLDIcjs.insertLayer.call(void 0, without, loc.layer, target, index);
+    const layers = _chunkPOGBUYWEcjs.insertLayer.call(void 0, without, loc.layer, target, index);
     this.commit("Move layer", { ...this.doc, layers });
     return this.describeLayer(loc.layer);
   }
   /** Merges a pixel layer into the pixel layer below it (keeping the lower one's settings). */
   mergeDown(id) {
     this.requireIdle("merging");
-    const loc = _chunkAZTZRLDIcjs.findLayer.call(void 0, this.doc.layers, id);
+    const loc = _chunkPOGBUYWEcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
     const siblings = loc.parent ? loc.parent.children : this.doc.layers;
     const below = siblings[loc.index - 1];
     const upper = loc.layer;
     if (!isPixelLayer(upper) || !isPixelLayer(below)) throw new PaintEditorError("Merge down needs a pixel layer directly above another pixel layer in the same group.");
-    if (_chunkAZTZRLDIcjs.isLayerLocked.call(void 0, below, "pixels")) throw new PaintEditorError(`Layer "${below.name}" has its pixels locked; unlock it to merge into it.`);
+    if (_chunkPOGBUYWEcjs.isLayerLocked.call(void 0, below, "pixels")) throw new PaintEditorError(`Layer "${below.name}" has its pixels locked; unlock it to merge into it.`);
     const rect = unionRect(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
-    let surface = _chunkSZ6KMZNMcjs.emptySurface.call(void 0, 4);
+    let surface = _chunkXIOMMGPDcjs.emptySurface.call(void 0, 4);
     if (rect) {
       const base = { ...below, opacity: 1, blend: "normal", visible: true, clipped: void 0, mask: void 0 };
       const px = createPaintCompositor().composite([base, upper.visible ? upper : { ...upper, opacity: 0 }], rect, this.sources());
-      surface = _chunkSZ6KMZNMcjs.surfaceFromPixels.call(void 0, { width: rect.width, height: rect.height, data: px }, 4, rect.x, rect.y);
+      surface = _chunkXIOMMGPDcjs.surfaceFromPixels.call(void 0, { width: rect.width, height: rect.height, data: px }, 4, rect.x, rect.y);
     }
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
-    const layers = _chunkAZTZRLDIcjs.mapLayer.call(void 0, _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
+    const layers = _chunkPOGBUYWEcjs.mapLayer.call(void 0, _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
     this.commit("Merge down", { ...this.doc, layers, activeLayerId: below.id });
     return this.describeLayer(merged);
   }
@@ -2388,7 +2830,7 @@ var PaintEditorController = (_class9 = class {
     this.requireIdle("clearing");
     const l = this.paintTarget(layerId, "clear");
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", { ...this.doc, layers: _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunkSZ6KMZNMcjs.emptySurface.call(void 0, 4) })) });
+    this.commit("Clear layer", { ...this.doc, layers: _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunkXIOMMGPDcjs.emptySurface.call(void 0, 4) })) });
     return { layerId: l.id, bounds };
   }
   /**
@@ -2405,14 +2847,14 @@ var PaintEditorController = (_class9 = class {
     if (!(grainAmount >= 0 && grainAmount <= 1)) throw new PaintEditorError(`grain ${grainAmount} is out of range; use 0..1.`);
     const pressure = _nullishCoalesce(options.pressure, () => ( 0.5));
     const blend = _nullishCoalesce(options.blend, () => ( "normal"));
-    if (!_chunkSZ6KMZNMcjs.isBlendMode.call(void 0, blend)) throw new PaintEditorError(`Unknown blend mode "${blend}".`);
+    if (!_chunkXIOMMGPDcjs.isBlendMode.call(void 0, blend)) throw new PaintEditorError(`Unknown blend mode "${blend}".`);
     const { width, height } = this.doc.canvas;
     const rect = { x: 0, y: 0, width, height };
-    const coverage = new (0, _chunkHUFQD4CBcjs.CoverageMap)();
+    const coverage = new (0, _chunk7VOHOPLWcjs.CoverageMap)();
     const depth = grainAmount * this.doc.paper.depth;
     const grain = depth > 0 ? paperGrain(this.doc.paper) : null;
-    for (const { tx, ty } of _chunkSZ6KMZNMcjs.tilesInRect.call(void 0, rect)) {
-      const r = { x: tx * _chunkSZ6KMZNMcjs.TILE, y: ty * _chunkSZ6KMZNMcjs.TILE, width: Math.min(_chunkSZ6KMZNMcjs.TILE, width - tx * _chunkSZ6KMZNMcjs.TILE), height: Math.min(_chunkSZ6KMZNMcjs.TILE, height - ty * _chunkSZ6KMZNMcjs.TILE) };
+    for (const { tx, ty } of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, rect)) {
+      const r = { x: tx * _chunkXIOMMGPDcjs.TILE, y: ty * _chunkXIOMMGPDcjs.TILE, width: Math.min(_chunkXIOMMGPDcjs.TILE, width - tx * _chunkXIOMMGPDcjs.TILE), height: Math.min(_chunkXIOMMGPDcjs.TILE, height - ty * _chunkXIOMMGPDcjs.TILE) };
       const vals = new Float32Array(r.width * r.height);
       for (let y = 0, k = 0; y < r.height; y++) for (let x = 0; x < r.width; x++, k++) vals[k] = grain ? grainCatch(grain.at(r.x + x + 0.5, r.y + y + 0.5), depth, pressure) : 1;
       coverage.accumulate(r, vals, 1);
@@ -2423,25 +2865,25 @@ var PaintEditorController = (_class9 = class {
       background: rgbaOf(this.doc.paper.color),
       opacity,
       blend,
-      lockTransparency: _chunkAZTZRLDIcjs.isLayerLocked.call(void 0, l, "transparency"),
+      lockTransparency: _chunkPOGBUYWEcjs.isLayerLocked.call(void 0, l, "transparency"),
       selection: null,
       offset: l.offset
     };
     const surface = this.applyCoverage(l, coverage, rect, apply);
-    this.commit("Fill layer", { ...this.doc, layers: _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })) });
+    this.commit("Fill layer", { ...this.doc, layers: _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })) });
     return { layerId: l.id, bounds: rect };
   }
   applyCoverage(l, coverage, rect, apply) {
     const base = l.surface;
     const tiles = new Map(base.tiles);
-    for (const { tx, ty } of _chunkSZ6KMZNMcjs.tilesInRect.call(void 0, { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height })) {
-      const key = _chunkSZ6KMZNMcjs.tileKey.call(void 0, tx, ty);
-      const src = _nullishCoalesce(_optionalChain([base, 'access', _54 => _54.tiles, 'access', _55 => _55.get, 'call', _56 => _56(key), 'optionalAccess', _57 => _57.data]), () => ( new Uint8ClampedArray(_chunkSZ6KMZNMcjs.TILE * _chunkSZ6KMZNMcjs.TILE * 4)));
-      const tile = _chunkSZ6KMZNMcjs.finishTile.call(void 0, _chunkHUFQD4CBcjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
+    for (const { tx, ty } of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height })) {
+      const key = _chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty);
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _63 => _63.tiles, 'access', _64 => _64.get, 'call', _65 => _65(key), 'optionalAccess', _66 => _66.data]), () => ( new Uint8ClampedArray(_chunkXIOMMGPDcjs.TILE * _chunkXIOMMGPDcjs.TILE * 4)));
+      const tile = _chunkXIOMMGPDcjs.finishTile.call(void 0, _chunk7VOHOPLWcjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
       if (tile) tiles.set(key, tile);
       else tiles.delete(key);
     }
-    return new (0, _chunkSZ6KMZNMcjs.TiledSurface)(4, tiles, 0);
+    return new (0, _chunkXIOMMGPDcjs.TiledSurface)(4, tiles, 0);
   }
   // --- Brushes -------------------------------------------------------------------
   findBrush(id) {
@@ -2481,6 +2923,7 @@ var PaintEditorController = (_class9 = 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;
   }
@@ -2489,6 +2932,7 @@ var PaintEditorController = (_class9 = 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. */
@@ -2529,7 +2973,10 @@ var PaintEditorController = (_class9 = 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. */
@@ -2561,7 +3008,7 @@ var PaintEditorController = (_class9 = class {
     if (options.layerId !== void 0) {
       const l = this.requireLayer(options.layerId);
       if (!isPixelLayer(l)) throw new PaintEditorError(`Layer "${l.name}" is a group; pick from a pixel layer or the composite.`);
-      const [r, g, b, a] = _chunkSZ6KMZNMcjs.readPixel.call(void 0, l.surface, px - l.offset.x, py - l.offset.y);
+      const [r, g, b, a] = _chunkXIOMMGPDcjs.readPixel.call(void 0, l.surface, px - l.offset.x, py - l.offset.y);
       return { color: rgbToHex(r, g, b), alpha: Math.round(a / 255 * 1e3) / 1e3 };
     }
     const d = this.exportCompositor.composite(this.renderLayers({}), { x: px, y: py, width: 1, height: 1 }, this.sources());
@@ -2571,13 +3018,13 @@ var PaintEditorController = (_class9 = class {
   /** Fills the Mixer Brush reservoir with a colour (default the editor colour). */
   loadMixerBrush(color) {
     const [r, g, b] = hexToRgb8(color === void 0 ? this.color : parseColor(color));
-    this.mixerLoad = _chunkHUFQD4CBcjs.loadMixer.call(void 0, this.mixerLoad, [r / 255, g / 255, b / 255]);
+    this.mixerLoad = _chunk7VOHOPLWcjs.loadMixer.call(void 0, this.mixerLoad, [r / 255, g / 255, b / 255]);
     this.emit([]);
     return this.mixerLoad;
   }
   /** Empties the pickup well (and with `emptyReservoir` the loaded paint too). */
   cleanMixerBrush(emptyReservoir = false) {
-    this.mixerLoad = emptyReservoir ? _chunkHUFQD4CBcjs.EMPTY_MIXER_LOAD : _chunkHUFQD4CBcjs.cleanMixer.call(void 0, this.mixerLoad);
+    this.mixerLoad = emptyReservoir ? _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD : _chunk7VOHOPLWcjs.cleanMixer.call(void 0, this.mixerLoad);
     this.emit([]);
     return this.mixerLoad;
   }
@@ -2603,6 +3050,14 @@ var PaintEditorController = (_class9 = 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);
@@ -2611,18 +3066,18 @@ var PaintEditorController = (_class9 = class {
     const layer = (() => {
       const id = _nullishCoalesce(init.layerId, () => ( doc.activeLayerId));
       if (!id) throw new PaintEditorError("There is no active layer to paint on; add one with add_layer.");
-      const loc = _chunkAZTZRLDIcjs.findLayer.call(void 0, doc.layers, id);
+      const loc = _chunkPOGBUYWEcjs.findLayer.call(void 0, doc.layers, id);
       if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
       const l = loc.layer;
       if (!isPixelLayer(l)) throw new PaintEditorError(`Layer "${l.name}" is a group; paint on a pixel layer inside it.`);
-      if (_chunkAZTZRLDIcjs.isLayerLocked.call(void 0, l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it (update_layer locks) to paint on it.`);
+      if (_chunkPOGBUYWEcjs.isLayerLocked.call(void 0, l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it (update_layer locks) to paint on it.`);
       if (!l.visible) throw new PaintEditorError(`Layer "${l.name}" is hidden; show it (update_layer visible true) to paint on it.`);
       return l;
     })();
     const brush = this.strokeBrush(init);
     let color = init.color === void 0 ? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
-    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _58 => _58.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _67 => _67.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
     const perspective = this.guides.perspective;
     const snapper = init.snapToPerspective && perspective.enabled && perspective.snap ? new PerspectiveSnapper(perspective) : null;
     const rgba = rgbaOf(color);
@@ -2632,7 +3087,7 @@ var PaintEditorController = (_class9 = class {
       layerId: layer.id,
       surface: layer.surface,
       offset: layer.offset,
-      lockTransparency: _chunkAZTZRLDIcjs.isLayerLocked.call(void 0, layer, "transparency"),
+      lockTransparency: _chunkPOGBUYWEcjs.isLayerLocked.call(void 0, layer, "transparency"),
       brush,
       color: rgba,
       background: rgbaOf(doc.paper.color),
@@ -2643,7 +3098,8 @@ var PaintEditorController = (_class9 = 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]) : _chunkHUFQD4CBcjs.EMPTY_MIXER_LOAD
+      mixerLoad: _nullishCoalesce(init.load, () => ( brushLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]))),
+      secondary: rgbaOf(this.secondaryColor)
     });
     return session;
   }
@@ -2658,6 +3114,7 @@ var PaintEditorController = (_class9 = 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;
   }
   /**
@@ -2676,7 +3133,7 @@ var PaintEditorController = (_class9 = class {
         this.live = null;
         this.liveLayers = null;
         const brush = s.init.brush;
-        if (!cancelled && _optionalChain([s, 'access', _59 => _59.result, 'optionalAccess', _60 => _60.mixerLoad]) && brush.loadsColor) this.mixerLoad = s.result.mixerLoad;
+        if (!cancelled && _optionalChain([s, 'access', _68 => _68.result, 'optionalAccess', _69 => _69.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           this.emit();
           return;
@@ -2684,7 +3141,7 @@ var PaintEditorController = (_class9 = class {
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
         const l = this.getLayer(s.layerId);
-        this.commit(`${brush.name} stroke`, { ...this.doc, layers: _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke] });
+        this.commit(`${brush.name} stroke`, { ...this.doc, layers: _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke] });
       }
     };
     const session = this.sessionFor(this.doc, { snapToPerspective: true, ...init }, host);
@@ -2706,8 +3163,8 @@ var PaintEditorController = (_class9 = class {
         if (cancelled || !surface) return;
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        const l = _chunkAZTZRLDIcjs.findLayer.call(void 0, out.layers, s.layerId).layer;
-        out = { ...out, layers: _chunkAZTZRLDIcjs.mapLayer.call(void 0, out.layers, l.id, () => ({ ...l, surface })), strokes: [...out.strokes, stroke] };
+        const l = _chunkPOGBUYWEcjs.findLayer.call(void 0, out.layers, s.layerId).layer;
+        out = { ...out, layers: _chunkPOGBUYWEcjs.mapLayer.call(void 0, out.layers, l.id, () => ({ ...l, surface })), strokes: [...out.strokes, stroke] };
       }
     };
     const session = this.sessionFor(doc, init, host);
@@ -2720,7 +3177,7 @@ var PaintEditorController = (_class9 = class {
     this.requireIdle("painting");
     const points = this.checkPoints(init.points);
     const { doc, result, brush } = this.runStroke(this.doc, { ...init, start: _nullishCoalesce(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;
@@ -2746,7 +3203,7 @@ var PaintEditorController = (_class9 = class {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _61 => _61.strokeIds, 'optionalAccess', _62 => _62.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _70 => _70.strokeIds, 'optionalAccess', _71 => _71.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
     const strokes = options.strokeIds.map((id) => {
       const s = this.doc.strokes.find((x) => x.id === id);
       if (!s) throw new PaintEditorError(`Unknown stroke "${id}". Call list_strokes for the ids.`);
@@ -2779,8 +3236,13 @@ var PaintEditorController = (_class9 = class {
           brush = normalizePaintBrush({ tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
         }
         const layerId = _nullishCoalesce(options.layerId, () => ( s.layerId));
-        if (!_chunkAZTZRLDIcjs.findLayer.call(void 0, 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: _nullishCoalesce(options.color, () => ( s.color)), brush, seed: s.seed, copies: _nullishCoalesce(v.copies, () => ( [])) }, v.points);
+        if (!_chunkPOGBUYWEcjs.findLayer.call(void 0, doc.layers, layerId)) throw new PaintEditorError(`Stroke "${s.id}" was painted on layer "${layerId}", which no longer exists; pass layerId to replay it elsewhere.`);
+        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: _nullishCoalesce(options.color, () => ( s.color)), brush, seed: s.seed, copies: _nullishCoalesce(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);
@@ -2798,8 +3260,8 @@ var PaintEditorController = (_class9 = class {
   currentLayers() {
     const live = this.live;
     if (!live) return this.doc.layers;
-    if (_optionalChain([this, 'access', _63 => _63.liveLayers, 'optionalAccess', _64 => _64.key]) === live.surface) return this.liveLayers.layers;
-    const layers = _chunkAZTZRLDIcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
+    if (_optionalChain([this, 'access', _72 => _72.liveLayers, 'optionalAccess', _73 => _73.key]) === live.surface) return this.liveLayers.layers;
+    const layers = _chunkPOGBUYWEcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
   }
@@ -2813,7 +3275,7 @@ var PaintEditorController = (_class9 = class {
   tracingNode(t) {
     const { width, height } = this.doc.canvas;
     const key = this.tracingVersion * 100003 + width * 7 + height;
-    if (_optionalChain([this, 'access', _65 => _65.tracingCache, 'optionalAccess', _66 => _66.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _74 => _74.tracingCache, 'optionalAccess', _75 => _75.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
     const src = _nullishCoalesce(this.imagePixels.get(t.src), () => ( this.decodeImage(t.src)));
     const image = resampleInto(src, t.rect, width, height);
     const node = { type: "image", id: TRACING_NODE_ID, name: "Tracing", visible: true, opacity: t.opacity, blend: "normal", image, version: key + Math.round(t.opacity * 1e3) / 1e4 };
@@ -2838,7 +3300,7 @@ var PaintEditorController = (_class9 = class {
    */
   compositeTiles(rect, onTile, options = {}) {
     const dirty = options.dirty === "all" ? void 0 : options.dirty;
-    this.viewCompositor.compositeTiles(this.renderLayers({}, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _67 => _67.live, 'optionalAccess', _68 => _68.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({}, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _76 => _76.live, 'optionalAccess', _77 => _77.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -2859,20 +3321,21 @@ var PaintEditorController = (_class9 = 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() });
     }
     for (const s of loaded.state.strokes) {
-      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _69 => _69.exec, 'call', _70 => _70(s.id), 'optionalAccess', _71 => _71[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _78 => _78.exec, 'call', _79 => _79(s.id), 'optionalAccess', _80 => _80[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
@@ -2903,7 +3366,7 @@ var PaintEditorController = (_class9 = class {
   /** The canvas as PNG bytes (paper included by default; `scale` below 1 shrinks it). */
   exportPng(options = {}) {
     const img = this.scaled(options);
-    return _chunkAZTZRLDIcjs.encodePng.call(void 0, img.width, img.height, img.data);
+    return _chunkPOGBUYWEcjs.encodePng.call(void 0, img.width, img.height, img.data);
   }
   scaled(options) {
     const full = this.compositePixels(options);
@@ -2945,22 +3408,22 @@ var PaintEditorController = (_class9 = class {
       opacity: 1,
       blend: "normal",
       locks: { all: true },
-      surface: _chunkSZ6KMZNMcjs.surfaceFromPixels.call(void 0, paperPixels, 4),
+      surface: _chunkXIOMMGPDcjs.surfaceFromPixels.call(void 0, paperPixels, 4),
       offset: { x: 0, y: 0 }
     };
     const merged = this.compositePixels({ paper: true }).data;
     const changed = /* @__PURE__ */ new Map();
     const toStandard = (layers2) => layers2.map((l) => {
-      const blend = l.blend === "pass-through" ? l.blend : _chunkSZ6KMZNMcjs.standardBlendMode.call(void 0, l.blend);
+      const blend = l.blend === "pass-through" ? l.blend : _chunkXIOMMGPDcjs.standardBlendMode.call(void 0, l.blend);
       if (blend !== l.blend) changed.set(l.blend, [..._nullishCoalesce(changed.get(l.blend), () => ( [])), l.name]);
       const next = blend === l.blend ? l : { ...l, blend };
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(this.doc.layers);
-    const result = _chunkD37BX2ZAcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkMGL4U5WAcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
-      const label = _nullishCoalesce(_optionalChain([_chunkSZ6KMZNMcjs.BLEND_MODES, 'access', _72 => _72.find, 'call', _73 => _73((m) => m.id === mode), 'optionalAccess', _74 => _74.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunkSZ6KMZNMcjs.BLEND_MODES, 'access', _75 => _75.find, 'call', _76 => _76((m) => m.id === _chunkSZ6KMZNMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _77 => _77.label]), () => ( _chunkSZ6KMZNMcjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunkXIOMMGPDcjs.BLEND_MODES, 'access', _81 => _81.find, 'call', _82 => _82((m) => m.id === mode), 'optionalAccess', _83 => _83.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunkXIOMMGPDcjs.BLEND_MODES, 'access', _84 => _84.find, 'call', _85 => _85((m) => m.id === _chunkXIOMMGPDcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _86 => _86.label]), () => ( _chunkXIOMMGPDcjs.standardBlendMode.call(void 0, mode)));
       const list = names.map((n) => `"${n}"`).join(", ");
       const one = names.length === 1;
       result.warnings.push(`${label} blending has no PSD equivalent; ${list} ${one ? "was" : "were"} written as ${std}, the nearest Photoshop mode, so ${one ? "it looks" : "they look"} different in Photoshop (the merged image is exact).`);
@@ -2970,7 +3433,7 @@ var PaintEditorController = (_class9 = class {
   /** `render_preview` as a base64 PNG. */
   previewPngBase64(options = {}) {
     const img = this.renderPreview(options);
-    return { data: _chunkAZTZRLDIcjs.bytesToBase64.call(void 0, _chunkAZTZRLDIcjs.encodePng.call(void 0, img.width, img.height, img.data)), width: img.width, height: img.height };
+    return { data: _chunkPOGBUYWEcjs.bytesToBase64.call(void 0, _chunkPOGBUYWEcjs.encodePng.call(void 0, img.width, img.height, img.data)), width: img.width, height: img.height };
   }
   // --- Guides --------------------------------------------------------------------
   setGuides(next) {
@@ -3008,17 +3471,17 @@ var PaintEditorController = (_class9 = class {
       pixels = this.decodeImage(input.png.trim().startsWith("data:") ? input.png.trim() : `data:image/png;base64,${input.png.trim()}`, what);
     } else throw new PaintEditorError(`${what}: pass png (a PNG as base64 or a data URL) or pixels.`);
     if (pixels.width > MAX_IMAGE_SIDE || pixels.height > MAX_IMAGE_SIDE) throw new PaintEditorError(`${what} is ${pixels.width}\xD7${pixels.height}; the limit is ${MAX_IMAGE_SIDE} px per side.`);
-    const src = _chunkAZTZRLDIcjs.pngDataUrl.call(void 0, pixels.width, pixels.height, pixels.data);
+    const src = _chunkPOGBUYWEcjs.pngDataUrl.call(void 0, pixels.width, pixels.height, pixels.data);
     this.imagePixels.set(src, pixels);
     return { src, pixels };
   }
   decodeImage(src, what = "Image") {
     const cached = this.imagePixels.get(src);
     if (cached) return cached;
-    const parsed = _chunkAZTZRLDIcjs.parseDataUrl.call(void 0, src);
+    const parsed = _chunkPOGBUYWEcjs.parseDataUrl.call(void 0, src);
     if (!parsed) throw new PaintEditorError(`${what} is not a data URL or base64 PNG.`);
     try {
-      const png = _chunkAZTZRLDIcjs.decodePng.call(void 0, parsed.bytes);
+      const png = _chunkPOGBUYWEcjs.decodePng.call(void 0, parsed.bytes);
       const px = { width: png.width, height: png.height, data: png.data };
       this.imagePixels.set(src, px);
       return px;
@@ -3076,7 +3539,7 @@ var PaintEditorController = (_class9 = class {
     const { src, pixels } = this.importImage(options, "The reference image");
     const ref = {
       id: `ref${this.nextReferenceId++}`,
-      name: _optionalChain([options, 'access', _78 => _78.name, 'optionalAccess', _79 => _79.trim, 'call', _80 => _80()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _87 => _87.name, 'optionalAccess', _88 => _88.trim, 'call', _89 => _89()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -3155,7 +3618,7 @@ var PaintEditorController = (_class9 = class {
         try {
           const px = this.decodeImage(ref.src, `Reference "${ref.name}"`);
           guides.references.push({ id: ref.id, name: String(_nullishCoalesce(ref.name, () => ( ref.id))), src: ref.src, width: px.width, height: px.height, x: Number(ref.x) || 0, y: Number(ref.y) || 0, displayWidth: Number(ref.displayWidth) || 240, visible: ref.visible !== false });
-          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _81 => _81.exec, 'call', _82 => _82(ref.id), 'optionalAccess', _83 => _83[1]]), () => ( 0)));
+          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _90 => _90.exec, 'call', _91 => _91(ref.id), 'optionalAccess', _92 => _92[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -3175,7 +3638,7 @@ var PaintEditorController = (_class9 = class {
   }
   addSwatch(color, name) {
     const c = parseColor(color);
-    this.swatches = [...this.swatches, _optionalChain([name, 'optionalAccess', _84 => _84.trim, 'call', _85 => _85()]) ? { color: c, name: name.trim() } : { color: c }];
+    this.swatches = [...this.swatches, _optionalChain([name, 'optionalAccess', _93 => _93.trim, 'call', _94 => _94()]) ? { color: c, name: name.trim() } : { color: c }];
     this.emit([]);
     return this.swatches;
   }
@@ -3221,12 +3684,105 @@ var PaintEditorController = (_class9 = 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 = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _95 => _95.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _96 => _96.parts]) }));
+    let r;
+    try {
+      r = this.pad.mix(parsed, options);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    const color = _nullishCoalesce(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 = _optionalChain([_chunkAZTZRLDIcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _86 => _86.layer]);
+    const l = _optionalChain([_chunkPOGBUYWEcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _97 => _97.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
-}, _class9);
+}, _class10);
 var MAX_IMAGE_SIDE = 8192;
 function resampleInto(src, rect, width, height) {
   const out = new Uint8ClampedArray(width * height * 4);
@@ -3277,8 +3833,8 @@ function strokeSchedule(points) {
   return total > 0 ? acc.map((d) => d / total) : points.map(() => 1);
 }
 function strokeDuration(points, max = 1800) {
-  const t0 = _optionalChain([points, 'access', _87 => _87[0], 'optionalAccess', _88 => _88.t]);
-  const t1 = _optionalChain([points, 'access', _89 => _89[points.length - 1], 'optionalAccess', _90 => _90.t]);
+  const t0 = _optionalChain([points, 'access', _98 => _98[0], 'optionalAccess', _99 => _99.t]);
+  const t1 = _optionalChain([points, 'access', _100 => _100[points.length - 1], 'optionalAccess', _101 => _101.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -3332,7 +3888,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _91 => _91.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _92 => _92.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _102 => _102.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _103 => _103.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -3379,8 +3935,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _93 => _93.replay, 'access', _94 => _94.strokeIds, 'optionalAccess', _95 => _95.includes, 'call', _96 => _96(s.id)]));
-        const first = _optionalChain([source, 'access', _97 => _97[0], 'optionalAccess', _98 => _98.points, 'access', _99 => _99[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _104 => _104.replay, 'access', _105 => _105.strokeIds, 'optionalAccess', _106 => _106.includes, 'call', _107 => _107(s.id)]));
+        const first = _optionalChain([source, 'access', _108 => _108[0], 'optionalAccess', _109 => _109.points, 'access', _110 => _110[0]]);
         if (first) await this.glide(id, first);
         const result = c.replayStrokes(command.replay);
         if (result.bounds) await this.glide(id, centre(result.bounds), 520);
@@ -3678,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: {
@@ -3733,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",
@@ -3743,7 +4366,7 @@ function createPaintGuideTools(c) {
         const pad = c.mixingPad;
         return {
           content: [
-            { type: "image", data: _chunkAZTZRLDIcjs.bytesToBase64.call(void 0, _chunkAZTZRLDIcjs.encodePng.call(void 0, pad.width, pad.height, pad.pixels())), mimeType: "image/png" },
+            { type: "image", data: _chunkPOGBUYWEcjs.bytesToBase64.call(void 0, _chunkPOGBUYWEcjs.encodePng.call(void 0, pad.width, pad.height, pad.pixels())), mimeType: "image/png" },
             { type: "text", text: `Mixing pad ${pad.width}\xD7${pad.height}` }
           ]
         };
@@ -3764,7 +4387,7 @@ var TIP = {
   type: "object",
   description: "The tip (the shared brush engine). Missing fields keep their current values.",
   properties: {
-    size: { type: "number", minimum: 1, maximum: _chunkHUFQD4CBcjs.MAX_BRUSH_SIZE, description: "Diameter in document pixels." },
+    size: { type: "number", minimum: 1, maximum: _chunk7VOHOPLWcjs.MAX_BRUSH_SIZE, description: "Diameter in document pixels." },
     hardness: { type: "number", minimum: 0, maximum: 1, description: "Edge hardness, 0 (soft) .. 1 (hard)." },
     spacing: { type: "number", minimum: 0.01, maximum: 10, description: "Dab spacing as a fraction of the diameter (0.05 is smooth, 1 is dotted)." },
     angle: { type: "number", minimum: -360, maximum: 360, description: "Tip angle in degrees, counter-clockwise; with rotation stroke or barrel it is added to the stroke direction or pen rotation." },
@@ -3776,7 +4399,7 @@ var TIP = {
     pressureOpacity: { type: "boolean", description: "Pressure scales the opacity." },
     blend: {
       type: "string",
-      enum: _chunkSZ6KMZNMcjs.BLEND_MODES.map((m) => m.id),
+      enum: _chunkXIOMMGPDcjs.BLEND_MODES.map((m) => m.id),
       description: "How paint combines with the layer. pigment mixes it in like real paint (blue into yellow gives green); multiply darkens like marker ink; watercolor glazes like a transparent wash; tint, highlight and shadow recolour, light and shade (see list_blend_modes)."
     }
   },
@@ -3802,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: [..._chunkHUFQD4CBcjs.MIXING_MODELS], description: "rgb: RGB averages. pigment: mixes like paint (Kubelka-Munk)." }
+    mixing: { type: "string", enum: [..._chunk7VOHOPLWcjs.MIXING_MODELS], description: "rgb: RGB averages. pigment: mixes like paint (Kubelka-Munk)." }
+  },
+  additionalProperties: false
+};
+var MIXING = { type: "string", enum: [..._chunk7VOHOPLWcjs.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",
@@ -3852,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;
@@ -3888,7 +4575,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         strokes: d.strokes.length,
         undo: s.undoLabel,
         redo: s.redoLabel,
-        blendModes: _chunkSZ6KMZNMcjs.BLEND_MODES.map((m) => m.id)
+        blendModes: _chunkXIOMMGPDcjs.BLEND_MODES.map((m) => m.id)
       };
     }
   });
@@ -4021,7 +4708,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0..1." },
         blend: {
           type: "string",
-          enum: [..._chunkSZ6KMZNMcjs.BLEND_MODES.map((m) => m.id), "pass-through"],
+          enum: [..._chunkXIOMMGPDcjs.BLEND_MODES.map((m) => m.id), "pass-through"],
           description: "Blend mode (pass-through for groups only). Painterly modes: watercolor (the layer glazes like a transparent wash), tint (recolours keeping lightness), highlight (adds soft coloured light), shadow (shades with ambient fill); see list_blend_modes."
         },
         clipped: { type: "boolean", description: "Clip to the layer below (paint only shows where it has paint)." },
@@ -4050,12 +4737,12 @@ function createPaintEditorToolProvider(controller, options = {}) {
     inputSchema: EMPTY2,
     annotations: { title: "List blend modes", ...READ2 },
     handler: () => ({
-      modes: _chunkSZ6KMZNMcjs.BLEND_MODES.map((m) => ({
+      modes: _chunkXIOMMGPDcjs.BLEND_MODES.map((m) => ({
         id: m.id,
         label: m.label,
         group: m.painterly ? "painterly" : m.id === "pigment" ? "pigment" : "standard",
         ...m.description ? { description: m.description } : {},
-        psd: _chunkSZ6KMZNMcjs.standardBlendMode.call(void 0, m.id)
+        psd: _chunkXIOMMGPDcjs.standardBlendMode.call(void 0, m.id)
       }))
     })
   });
@@ -4123,7 +4810,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0..1 (default 1)." },
         grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response 0..1 (default 0: flat)." },
         pressure: { type: "number", minimum: 0, maximum: 1, description: "With grain: how far into the valleys, 0..1 (default 0.5)." },
-        blend: { type: "string", enum: _chunkSZ6KMZNMcjs.BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal; pigment mixes like paint, watercolor glazes; see list_blend_modes)." }
+        blend: { type: "string", enum: _chunkXIOMMGPDcjs.BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal; pigment mixes like paint, watercolor glazes; see list_blend_modes)." }
       },
       additionalProperties: false
     },
@@ -4141,18 +4828,18 @@ 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: () => {
       const s = c.getState();
-      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _100 => _100.getBrush, 'call', _101 => _101(s.brush.id), 'optionalAccess', _102 => _102.builtin])), brushes: s.brushes.map(brushSummary) };
+      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _111 => _111.getBrush, 'call', _112 => _112(s.brush.id), 'optionalAccess', _113 => _113.builtin])), brushes: s.brushes.map(brushSummary) };
     }
   });
   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 }) => {
@@ -4244,7 +4931,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       const t = c.brushThumbnail(_nullishCoalesce(id, () => ( c.getState().brush.id)), { width, height, color });
       return {
         content: [
-          { type: "image", data: _chunkAZTZRLDIcjs.bytesToBase64.call(void 0, _chunkAZTZRLDIcjs.encodePng.call(void 0, t.width, t.height, t.data)), mimeType: "image/png" },
+          { type: "image", data: _chunkPOGBUYWEcjs.bytesToBase64.call(void 0, _chunkPOGBUYWEcjs.encodePng.call(void 0, t.width, t.height, t.data)), mimeType: "image/png" },
           { type: "text", text: `Brush ${_nullishCoalesce(id, () => ( c.getState().brush.id))} ${t.width}\xD7${t.height}` }
         ]
       };
@@ -4287,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)
@@ -4303,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))
@@ -4311,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: {
@@ -4366,7 +5053,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
             color: s.color,
             points: ids ? s.points : s.points.length,
             seed: s.seed,
-            copies: _nullishCoalesce(_optionalChain([s, 'access', _103 => _103.copies, 'optionalAccess', _104 => _104.length]), () => ( 0)),
+            copies: _nullishCoalesce(_optionalChain([s, 'access', _114 => _114.copies, 'optionalAccess', _115 => _115.length]), () => ( 0)),
             bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
           };
         })
@@ -4499,7 +5186,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "Export the painting", ...READ2 },
     handler: async ({ format, quality, scale, paper }) => {
       const bytes = await c.exportImage({ format, quality, scale, paper });
-      return { mimeType: _nullishCoalesce(format, () => ( "image/png")), bytes: bytes.length, data: _chunkAZTZRLDIcjs.bytesToBase64.call(void 0, bytes) };
+      return { mimeType: _nullishCoalesce(format, () => ( "image/png")), bytes: bytes.length, data: _chunkPOGBUYWEcjs.bytesToBase64.call(void 0, bytes) };
     }
   });
   add({
@@ -4510,7 +5197,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "Export as PSD", ...READ2 },
     handler: () => {
       const r = c.exportPsd();
-      return { data: _chunkAZTZRLDIcjs.bytesToBase64.call(void 0, r.bytes), bytes: r.bytes.length, psb: r.psb, warnings: r.warnings };
+      return { data: _chunkPOGBUYWEcjs.bytesToBase64.call(void 0, r.bytes), bytes: r.bytes.length, psb: r.psb, warnings: r.warnings };
     }
   });
   add({
@@ -4534,7 +5221,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     }
   });
   tools.push(...createPaintGuideTools(c));
-  tools.push(..._chunkHUFQD4CBcjs.createPigmentTools.call(void 0, ));
+  tools.push(..._chunk7VOHOPLWcjs.createPigmentTools.call(void 0, ));
   return { id: _nullishCoalesce(options.id, () => ( "paint-editor")), namespace: options.namespace, tools };
 }
 
@@ -4545,21 +5232,21 @@ var PAINT_TOOLS = [
   { id: "pan", label: "Pan", key: "h" },
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
-var PaintGesture = (_class10 = class {
-  constructor(controller, box) {;_class10.prototype.__init56.call(this);_class10.prototype.__init57.call(this);_class10.prototype.__init58.call(this);_class10.prototype.__init59.call(this);_class10.prototype.__init60.call(this);_class10.prototype.__init61.call(this);
+var PaintGesture = (_class11 = class {
+  constructor(controller, box) {;_class11.prototype.__init66.call(this);_class11.prototype.__init67.call(this);_class11.prototype.__init68.call(this);_class11.prototype.__init69.call(this);_class11.prototype.__init70.call(this);_class11.prototype.__init71.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init56() {this.tool = "brush"}
+  __init66() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init57() {this.error = null}
+  __init67() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init58() {this.predicted = []}
-  __init59() {this.mode = null}
-  __init60() {this.penAt = null}
-  __init61() {this.penDown = false}
+  __init68() {this.predicted = []}
+  __init69() {this.mode = null}
+  __init70() {this.penAt = null}
+  __init71() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -4640,12 +5327,12 @@ var PaintGesture = (_class10 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _105 => _105.controller, 'access', _106 => _106.activeStroke, 'optionalAccess', _107 => _107.end, 'call', _108 => _108()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _116 => _116.controller, 'access', _117 => _117.activeStroke, 'optionalAccess', _118 => _118.end, 'call', _119 => _119()]);
   }
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _109 => _109.mode, 'optionalAccess', _110 => _110.kind]) === "stroke") _optionalChain([this, 'access', _111 => _111.controller, 'access', _112 => _112.activeStroke, 'optionalAccess', _113 => _113.cancel, 'call', _114 => _114()]);
+    if (_optionalChain([this, 'access', _120 => _120.mode, 'optionalAccess', _121 => _121.kind]) === "stroke") _optionalChain([this, 'access', _122 => _122.controller, 'access', _123 => _123.activeStroke, 'optionalAccess', _124 => _124.cancel, 'call', _125 => _125()]);
     this.mode = null;
   }
   get active() {
@@ -4665,7 +5352,7 @@ var PaintGesture = (_class10 = class {
     const py = e.clientY - b.top - b.height / 2;
     this.controller.setView({ zoom, pan: { x: px - (px - s.view.pan.x) * k, y: py - (py - s.view.pan.y) * k } });
   }
-}, _class10);
+}, _class11);
 function handlePaintShortcut(controller, gesture, e) {
   const mod = e.ctrlKey || e.metaKey;
   const key = e.key.toLowerCase();
@@ -4705,14 +5392,14 @@ function handlePaintShortcut(controller, gesture, e) {
   }
   return false;
 }
-var PaintCanvasPresenter = (_class11 = class {
-  constructor(controller) {;_class11.prototype.__init62.call(this);_class11.prototype.__init63.call(this);_class11.prototype.__init64.call(this);
+var PaintCanvasPresenter = (_class12 = class {
+  constructor(controller) {;_class12.prototype.__init72.call(this);_class12.prototype.__init73.call(this);_class12.prototype.__init74.call(this);
     this.controller = controller;
   }
   
-  __init62() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init63() {this.scratch = null}
-  __init64() {this.size = ""}
+  __init72() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init73() {this.scratch = null}
+  __init74() {this.size = ""}
   /** Draws what changed into `ctx` (a canvas the size of the document); returns the tiles drawn. */
   render(ctx) {
     const { width, height } = this.controller.document.canvas;
@@ -4729,16 +5416,16 @@ var PaintCanvasPresenter = (_class11 = class {
       const key = `${tx},${ty}`;
       if (this.uploaded.get(key) === data) return;
       this.uploaded.set(key, data);
-      if (!this.scratch) this.scratch = ctx.createImageData(_chunkSZ6KMZNMcjs.TILE, _chunkSZ6KMZNMcjs.TILE);
+      if (!this.scratch) this.scratch = ctx.createImageData(_chunkXIOMMGPDcjs.TILE, _chunkXIOMMGPDcjs.TILE);
       this.scratch.data.set(data);
-      const ox = tx * _chunkSZ6KMZNMcjs.TILE;
-      const oy = ty * _chunkSZ6KMZNMcjs.TILE;
-      ctx.putImageData(this.scratch, ox, oy, 0, 0, Math.min(_chunkSZ6KMZNMcjs.TILE, width - ox), Math.min(_chunkSZ6KMZNMcjs.TILE, height - oy));
+      const ox = tx * _chunkXIOMMGPDcjs.TILE;
+      const oy = ty * _chunkXIOMMGPDcjs.TILE;
+      ctx.putImageData(this.scratch, ox, oy, 0, 0, Math.min(_chunkXIOMMGPDcjs.TILE, width - ox), Math.min(_chunkXIOMMGPDcjs.TILE, height - oy));
       drawn++;
     }, { dirty });
     return drawn;
   }
-}, _class11);
+}, _class12);
 function guideOverlay(controller) {
   const s = controller.getState();
   const size = s.document.canvas;
@@ -4773,7 +5460,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _115 => _115[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _126 => _126[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -4815,9 +5502,88 @@ function wheelPick(dx, dy, wheel, color) {
   return rgbToHexColor(nr, ng, nb);
 }
 var BLEND_MENU_GROUPS = [
-  { label: "Standard", modes: _chunkSZ6KMZNMcjs.BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
-  { label: "Paint", modes: _chunkSZ6KMZNMcjs.BLEND_MODES.filter((m) => m.painterly || m.id === "pigment") }
+  { label: "Standard", modes: _chunkXIOMMGPDcjs.BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
+  { label: "Paint", modes: _chunkXIOMMGPDcjs.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(_nullishCoalesce(obj[head2], () => ( {})), rest2) };
+  };
+  const [head, ...rest] = path.split(".");
+  if (!rest.length) return { [head]: value };
+  return { [head]: set({ ..._nullishCoalesce(brush[head], () => ( {})) }, rest) };
+}
+function brushLoadColor(load) {
+  const c = _nullishCoalesce(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));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -4965,5 +5731,5 @@ var BLEND_MENU_GROUPS = [
 
 
 
-exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkSZ6KMZNMcjs.BLEND_MODES; exports.BRUSH_ID = BRUSH_ID; exports.BRUSH_ROTATIONS = BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = BUILTIN_BRUSHES; exports.DEFAULT_BRUSH_ID = DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = DEFAULT_DYNAMICS; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DryStroke = DryStroke; exports.GRAIN_PATTERNS = GRAIN_PATTERNS; exports.GRAIN_TILE = GRAIN_TILE; exports.HARMONY_KINDS = HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.MAX_BRUSH_SIZE = _chunkHUFQD4CBcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MixingPad = MixingPad; exports.PAINTERLY_BLEND_MODES = _chunkSZ6KMZNMcjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = PAINT_BRUSH_ENGINES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_FAMILIES = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintGesture = PaintGesture; exports.PaintPresence = PaintPresence; exports.PaintStrokeSession = PaintStrokeSession; exports.PaperGrain = PaperGrain; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.TileableNoise = TileableNoise; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushToJSON = brushToJSON; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony; exports.composeAffine = composeAffine; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintLayer = createPaintLayer; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.fitZoom = fitZoom; exports.grainCatch = grainCatch; exports.grainHeights = grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = hash2; exports.hexToRgb8 = hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkSZ6KMZNMcjs.isBlendMode; exports.isPainterlyBlendMode = _chunkSZ6KMZNMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.mapPenPoint = mapPenPoint; exports.mix32 = mix32; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.newPaintLayerId = newPaintLayerId; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = normalizeDynamics; exports.normalizePaintBrush = normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.patchPath = patchPath; exports.penOrientation = penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.pointerToPenPoint = pointerToPenPoint; exports.rand01 = rand01; exports.randSigned = randSigned; exports.readPath = readPath; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = renderPaper; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.samplePressure = samplePressure; exports.screenToDocument = screenToDocument; exports.seedFromString = seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.standardBlendMode = _chunkSZ6KMZNMcjs.standardBlendMode; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.toStrokePoint = toStrokePoint; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = wheelToHue;
+exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkXIOMMGPDcjs.BLEND_MODES; exports.BRUSH_ID = BRUSH_ID; exports.BRUSH_ROTATIONS = BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = BUILTIN_BRUSHES; exports.DEFAULT_BEHAVIOR = DEFAULT_BEHAVIOR; exports.DEFAULT_BRUSH_ID = DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = DEFAULT_DYNAMICS; exports.DEFAULT_MULTI_COLOR = DEFAULT_MULTI_COLOR; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DryStroke = DryStroke; exports.GRAIN_PATTERNS = GRAIN_PATTERNS; exports.GRAIN_TILE = GRAIN_TILE; exports.HARMONY_KINDS = HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.MAX_BRUSH_SIZE = _chunk7VOHOPLWcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkXIOMMGPDcjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = PAINT_BRUSH_ENGINES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_FAMILIES = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintGesture = PaintGesture; exports.PaintPresence = PaintPresence; exports.PaintStrokeSession = PaintStrokeSession; exports.PaperGrain = PaperGrain; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.TileableNoise = TileableNoise; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushToJSON = brushToJSON; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony; exports.composeAffine = composeAffine; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintLayer = createPaintLayer; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.fitZoom = fitZoom; exports.grainCatch = grainCatch; exports.grainHeights = grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = hash2; exports.hexToRgb8 = hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkXIOMMGPDcjs.isBlendMode; exports.isPainterlyBlendMode = _chunkXIOMMGPDcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetCapable = isWetCapable; exports.mapPenPoint = mapPenPoint; exports.mix32 = mix32; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.newPaintLayerId = newPaintLayerId; exports.normalizeBehavior = normalizeBehavior; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = normalizeDynamics; exports.normalizeMultiColor = normalizeMultiColor; exports.normalizePaintBrush = normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.padSampleRadius = padSampleRadius; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.pointerToPenPoint = pointerToPenPoint; exports.rand01 = rand01; exports.randSigned = randSigned; exports.readPath = readPath; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = renderPaper; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.samplePressure = samplePressure; exports.screenToDocument = screenToDocument; exports.seedFromString = seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.standardBlendMode = _chunkXIOMMGPDcjs.standardBlendMode; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.toStrokePoint = toStrokePoint; exports.usesPaintExchange = usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = wheelToHue;
 //# sourceMappingURL=index.cjs.map