@pixerate/editor 0.109.0 → 0.110.0

package/dist/{chunk-3PHA3UKI.js → chunk-Z4BC6M74.js}

@@ -1,14 +1,16 @@
 import {
+  PIGMENT_BANDS,
   TILE,
   blendPixel,
   createPigment,
   lerpPigmentInto,
   mixPigment8,
   mixPigments,
+  pigment8,
   setPigmentColor,
   tileCoord,
   tileKey
-} from "./chunk-WMBIJCHA.js";
+} from "./chunk-HNS7UHCM.js";
 
 // src/paint/brush.ts
 var DEFAULT_BRUSH = {
@@ -412,83 +414,51 @@ function coverageTileCoord(key) {
   return tileCoord(key);
 }
 
-// src/paint/mixer.ts
+// src/paint/exchange.ts
 var MIXING_MODELS = ["rgb", "pigment"];
-var DEFAULT_MIXER = {
-  wet: 0.5,
-  load: 0.5,
-  mix: 0.5,
-  loadEachStroke: true,
-  cleanEachStroke: true,
-  mixing: "rgb"
-};
+var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
 var MIXER_PICKUP_RATE = 0.25;
 var MIXER_DRAIN = 0.08;
-function normalizeMixer(raw = {}) {
-  const unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
-  const bool = (v, d) => typeof v === "boolean" ? v : d;
-  return {
-    wet: unit(raw.wet, DEFAULT_MIXER.wet),
-    load: unit(raw.load, DEFAULT_MIXER.load),
-    mix: unit(raw.mix, DEFAULT_MIXER.mix),
-    loadEachStroke: bool(raw.loadEachStroke, DEFAULT_MIXER.loadEachStroke),
-    cleanEachStroke: bool(raw.cleanEachStroke, DEFAULT_MIXER.cleanEachStroke),
-    mixing: raw.mixing === "pigment" ? "pigment" : "rgb"
-  };
-}
-var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
-function loadMixer(load, color) {
-  const c = (v) => Math.min(1, Math.max(0, Number.isFinite(v) ? v : 0));
-  return { reservoir: [c(color[0]), c(color[1]), c(color[2])], amount: 1, pickup: load.pickup };
+function exchangeRates(pickup, mix, load, mixing) {
+  return { pickup: MIXER_PICKUP_RATE * pickup, mix: mix * pickup, drain: MIXER_DRAIN * (1 - load), mixing };
 }
-function cleanMixer(load) {
-  return { reservoir: load.reservoir, amount: load.amount, pickup: null };
-}
-var MixerStroke = class {
-  constructor(brush, settings, load, target) {
-    this.brush = brush;
-    this.target = target;
-    this.settings = normalizeMixer(settings);
-    this.walker = new DabWalker(brush);
+var PaintExchange = class {
+  constructor(rates, load) {
+    this.rates = rates;
     this.reservoir = load.reservoir ? [load.reservoir[0], load.reservoir[1], load.reservoir[2]] : null;
     this.amount = this.reservoir ? Math.min(1, Math.max(0, load.amount)) : 0;
-    this.pickup = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
-    this.pig = this.settings.mixing === "pigment" ? { res: createPigment(this.reservoir ?? [0, 0, 0]), pick: createPigment(this.pickup ?? [0, 0, 0]), paint: createPigment([0, 0, 0]), canvas: createPigment([0, 0, 0]) } : null;
+    this.well = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
+    this.pig = rates.mixing === "pigment" ? { res: createPigment(this.reservoir ?? [0, 0, 0]), well: createPigment(this.well ?? [0, 0, 0]), paint: createPigment([0, 0, 0]), canvas: createPigment([0, 0, 0]) } : null;
   }
-  brush;
-  target;
-  dabCount = 0;
-  bounds = null;
-  walker;
-  smoothPos = null;
-  buf = new Float32Array(0);
-  settings;
+  rates;
   reservoir;
   amount;
-  pickup;
+  well;
   pig;
   out = [0, 0, 0];
-  /** The brush load after the dabs so far. */
+  /** What the brush carries now. */
   get load() {
-    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.pickup ? [...this.pickup] : null };
+    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.well ? [...this.well] : null };
   }
-  push(points) {
-    const dabs = [];
-    for (const p of points) this.walker.push(this.smooth(p), dabs);
-    return this.paint(dabs);
+  /** The colour picked up so far, or `null`. */
+  get pickup() {
+    return this.well;
   }
-  finish(last) {
-    const dabs = [];
-    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);
-    this.walker.finish(dabs);
-    return this.paint(dabs);
+  /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
+  get paintPigment() {
+    return this.pig?.paint ?? null;
   }
-  smooth(p) {
-    const a = 1 - Math.min(0.95, Math.max(0, this.brush.smoothing));
-    const cur = this.smoothPos;
-    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
-    this.smoothPos = n;
-    return n;
+  /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
+  setReservoirColor(r, g, b) {
+    if (!this.reservoir) {
+      this.reservoir = [r, g, b];
+      this.amount = 1;
+    } else {
+      this.reservoir[0] = r;
+      this.reservoir[1] = g;
+      this.reservoir[2] = b;
+    }
+    if (this.pig) setPigmentColor(this.pig.res, r, g, b);
   }
   /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
   mix(a, pa, b, pb, t) {
@@ -497,27 +467,84 @@ var MixerStroke = class {
     else for (let c = 0; c < 3; c++) o[c] = a[c] + (b[c] - a[c]) * t;
     return o;
   }
-  paint(dabs) {
-    const rects = [];
-    for (const d of dabs) {
-      const rect = dabRect(d, this.brush.hardness);
-      const n = rect.width * rect.height;
-      if (this.buf.length < n) this.buf = new Float32Array(n);
-      const cov = this.buf.subarray(0, n);
-      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);
-      this.dab(d, rect, cov);
-      rects.push(rect);
-      this.bounds = union(this.bounds, rect);
-      this.dabCount++;
+  /** `a` mixed `t` of the way to `b` (sRGB 0..1) by the mixing model, into `out`. */
+  mixColors(a, b, t, out) {
+    if (this.pig) {
+      setPigmentColor(this.pig.canvas, a[0], a[1], a[2]);
+      setPigmentColor(this.pig.paint, b[0], b[1], b[2]);
+      lerpPigmentInto(this.pig.canvas, this.pig.paint, t, out, 0);
+    } else for (let c = 0; c < 3; c++) out[c] = a[c] + (b[c] - a[c]) * t;
+    return out;
+  }
+  /** 1. Pick-up: the well moves towards the sampled colour (or takes it, when clean). */
+  pickUp(sample) {
+    if (!sample || !(this.rates.pickup > 0)) return;
+    const pig = this.pig;
+    if (!this.well) this.well = [sample.rgb[0], sample.rgb[1], sample.rgb[2]];
+    else {
+      if (pig) setPigmentColor(pig.canvas, sample.rgb[0], sample.rgb[1], sample.rgb[2]);
+      const o = this.mix(this.well, pig?.well ?? null, sample.rgb, pig?.canvas ?? null, this.rates.pickup * sample.contact);
+      this.well = [o[0], o[1], o[2]];
     }
-    return rects;
+    if (pig) setPigmentColor(pig.well, this.well[0], this.well[1], this.well[2]);
   }
+  /**
+   * 2. The dab's paint: the reservoir mixed with the well, written to `out`. Returns the total
+   * weight (≤ 0: nothing to lay down); deposit `min(1, weight)` of it. With pigment mixing,
+   * `paintPigment` is the result's pigment afterwards.
+   */
+  paint(out) {
+    const res = this.reservoir;
+    const wr = res ? this.amount * (1 - this.rates.mix) : 0;
+    const wp = this.well ? this.rates.mix : 0;
+    const total = wr + wp;
+    if (!(total > 1e-6)) return 0;
+    const pig = this.pig;
+    if (res && this.well) {
+      const m = this.mix(res, pig?.res ?? null, this.well, pig?.well ?? null, wp / total);
+      out[0] = m[0];
+      out[1] = m[1];
+      out[2] = m[2];
+    } else {
+      const c = res ?? this.well;
+      out[0] = c[0];
+      out[1] = c[1];
+      out[2] = c[2];
+    }
+    if (pig) setPigmentColor(pig.paint, out[0], out[1], out[2]);
+    return total;
+  }
+  /** 3. The reservoir drains. */
+  drain() {
+    this.amount *= 1 - this.rates.drain;
+  }
+};
+var TileMedium = class {
+  constructor(target, options = {}) {
+    this.target = target;
+    this.options = options;
+  }
+  target;
+  options;
   // The tile last looked up by `locate` (and whether it came from `writeTile`).
   tx = NaN;
   ty = NaN;
   tile = null;
   writable = false;
-  /** Index of document pixel (dx, dy) in `this.tile`, or -1 when reading an empty tile. */
+  canvasPig = createPigment([0, 0, 0]);
+  paintPig = createPigment([0, 0, 0]);
+  paintKey = -1;
+  cb = [0, 0, 0, 0];
+  src = [0, 0, 0, 1];
+  o = [0, 0, 0];
+  /** Forgets the cached tile (call when another writer may have replaced tiles). */
+  reset() {
+    this.tx = NaN;
+  }
+  /**
+   * The tile holding document pixel (dx, dy) (`pixels`) and the pixel's byte index in it, or -1
+   * when reading an empty tile.
+   */
   locate(dx, dy, write) {
     const t = this.target;
     const lx = dx - t.offset.x;
@@ -532,9 +559,18 @@ var MixerStroke = class {
     }
     return this.tile ? ((ly - ty * TILE) * TILE + (lx - tx * TILE)) * 4 : -1;
   }
-  dab(d, rect, cov) {
-    const { wet, mix, load } = this.settings;
-    const pig = this.pig;
+  /** The tile `locate` last found. */
+  get pixels() {
+    return this.tile;
+  }
+  /** Selection coverage at a document pixel, 0..1 (1 without a selection). */
+  selectionAt(dx, dy) {
+    const sel = this.target.selection;
+    if (!sel) return 1;
+    if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) return 0;
+    return sel.data[dy * sel.width + dx] / 255;
+  }
+  sample(rect, cov) {
     const w = rect.width;
     this.tx = NaN;
     let ar = 0;
@@ -559,40 +595,24 @@ var MixerStroke = class {
         asum += ka;
       }
     }
-    if (asum > 1e-6 && wet > 0) {
-      const canvas = [ar / asum, ag / asum, ab / asum];
-      if (!this.pickup) this.pickup = canvas;
-      else {
-        if (pig) setPigmentColor(pig.canvas, canvas[0], canvas[1], canvas[2]);
-        const o = this.mix(this.pickup, pig?.pick ?? null, canvas, pig?.canvas ?? null, MIXER_PICKUP_RATE * wet * (asum / Math.max(1e-6, wsum)));
-        this.pickup = [o[0], o[1], o[2]];
-      }
-      if (pig) setPigmentColor(pig.pick, this.pickup[0], this.pickup[1], this.pickup[2]);
-    }
-    const res = this.reservoir;
-    const wr = res ? this.amount * (1 - mix * wet) : 0;
-    const wp = this.pickup ? mix * wet : 0;
-    const total = wr + wp;
-    if (total > 1e-6) {
-      const paint = res && this.pickup ? [...this.mix(res, pig?.res ?? null, this.pickup, pig?.pick ?? null, wp / total)] : [...res ?? this.pickup];
-      if (pig) setPigmentColor(pig.paint, paint[0], paint[1], paint[2]);
-      const dep = Math.min(1, total) * this.brush.flow * this.brush.opacity * d.opacity;
-      if (dep > 0) this.deposit(rect, cov, paint, dep);
-    }
-    this.amount *= 1 - MIXER_DRAIN * (1 - load);
+    if (!(asum > 1e-6)) return null;
+    return { rgb: [ar / asum, ag / asum, ab / asum], contact: asum / Math.max(1e-6, wsum) };
   }
-  /** Lays `paint` over the pixels under the dab at `dep` × coverage (× selection). */
-  deposit(rect, cov, paint, dep) {
+  deposit(rect, cov, dep, paint, paintPigment, field = null) {
     const t = this.target;
     const sel = t.selection;
-    const pig = this.pig;
     const w = rect.width;
-    const o = this.out;
+    const o = this.o;
+    const blend = this.options.blend;
+    const pigment = blend === void 0 ? paintPigment !== null : blend === "pigment";
+    const general = blend !== void 0 && blend !== "normal" && blend !== "pigment";
     let lastKey = -1;
+    this.tx = NaN;
     for (let yy = 0; yy < rect.height; yy++) {
       const dy = rect.y + yy;
       for (let xx = 0; xx < w; xx++) {
-        let k = cov[yy * w + xx] * dep;
+        const p = yy * w + xx;
+        let k = cov[p] * dep;
         if (k <= 0) continue;
         const dx = rect.x + xx;
         if (sel) {
@@ -607,22 +627,52 @@ var MixerStroke = class {
         }
         const i = this.locate(dx, dy, true);
         const px = this.tile;
+        const pr = field ? field[p * 3] : paint[0];
+        const pg = field ? field[p * 3 + 1] : paint[1];
+        const pb = field ? field[p * 3 + 2] : paint[2];
+        if (general) {
+          const cb = this.cb;
+          for (let c = 0; c < 4; c++) cb[c] = px[i + c] / 255;
+          const src = this.src;
+          src[0] = pr;
+          src[1] = pg;
+          src[2] = pb;
+          const r = blendPixel(blend, cb, src, k);
+          px[i] = Math.round(r[0] * 255);
+          px[i + 1] = Math.round(r[1] * 255);
+          px[i + 2] = Math.round(r[2] * 255);
+          if (!t.lockTransparency) px[i + 3] = Math.round(r[3] * 255);
+          continue;
+        }
         const a = px[i + 3] / 255;
         const na = t.lockTransparency ? a : a + (1 - a) * k;
         const share = t.lockTransparency ? k : na > 0 ? k / na : 1;
         if (a <= 0 || share >= 1) {
-          o[0] = paint[0];
-          o[1] = paint[1];
-          o[2] = paint[2];
-        } else if (pig) {
+          o[0] = pr;
+          o[1] = pg;
+          o[2] = pb;
+        } else if (pigment && field) {
+          mixPigment8(px[i], px[i + 1], px[i + 2], Math.round(pr * 255), Math.round(pg * 255), Math.round(pb * 255), share, o);
+        } else if (pigment) {
           const key = px[i] << 16 | px[i + 1] << 8 | px[i + 2];
           if (key !== lastKey) {
-            setPigmentColor(pig.canvas, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
+            setPigmentColor(this.canvasPig, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
             lastKey = key;
           }
-          lerpPigmentInto(pig.canvas, pig.paint, share, o, 0);
+          let pp = paintPigment;
+          if (!pp) {
+            const pkey = Math.round(pr * 255) << 16 | Math.round(pg * 255) << 8 | Math.round(pb * 255);
+            if (pkey !== this.paintKey) {
+              setPigmentColor(this.paintPig, pr, pg, pb);
+              this.paintKey = pkey;
+            }
+            pp = this.paintPig;
+          }
+          lerpPigmentInto(this.canvasPig, pp, share, o, 0);
         } else {
-          for (let c = 0; c < 3; c++) o[c] = px[i + c] / 255 + (paint[c] - px[i + c] / 255) * share;
+          o[0] = px[i] / 255 + (pr - px[i] / 255) * share;
+          o[1] = px[i + 1] / 255 + (pg - px[i + 1] / 255) * share;
+          o[2] = px[i + 2] / 255 + (pb - px[i + 2] / 255) * share;
         }
         px[i] = Math.round(o[0] * 255);
         px[i + 1] = Math.round(o[1] * 255);
@@ -632,6 +682,102 @@ var MixerStroke = class {
     }
   }
 };
+
+// src/paint/mixer.ts
+var DEFAULT_MIXER = {
+  wet: 0.5,
+  load: 0.5,
+  mix: 0.5,
+  loadEachStroke: true,
+  cleanEachStroke: true,
+  mixing: "rgb"
+};
+function normalizeMixer(raw = {}) {
+  const unit2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+  const bool = (v, d) => typeof v === "boolean" ? v : d;
+  return {
+    wet: unit2(raw.wet, DEFAULT_MIXER.wet),
+    load: unit2(raw.load, DEFAULT_MIXER.load),
+    mix: unit2(raw.mix, DEFAULT_MIXER.mix),
+    loadEachStroke: bool(raw.loadEachStroke, DEFAULT_MIXER.loadEachStroke),
+    cleanEachStroke: bool(raw.cleanEachStroke, DEFAULT_MIXER.cleanEachStroke),
+    mixing: raw.mixing === "pigment" ? "pigment" : "rgb"
+  };
+}
+function mixerRates(settings) {
+  return exchangeRates(settings.wet, settings.mix, settings.load, settings.mixing);
+}
+function loadMixer(load, color) {
+  const c = (v) => Math.min(1, Math.max(0, Number.isFinite(v) ? v : 0));
+  return { reservoir: [c(color[0]), c(color[1]), c(color[2])], amount: 1, pickup: load.pickup };
+}
+function cleanMixer(load) {
+  return { reservoir: load.reservoir, amount: load.amount, pickup: null };
+}
+var MixerStroke = class {
+  constructor(brush, settings, load, target) {
+    this.brush = brush;
+    this.walker = new DabWalker(brush);
+    this.exchange = new PaintExchange(mixerRates(normalizeMixer(settings)), load);
+    this.medium = new TileMedium(target);
+  }
+  brush;
+  dabCount = 0;
+  bounds = null;
+  walker;
+  smoothPos = null;
+  buf = new Float32Array(0);
+  exchange;
+  medium;
+  paintColor = [0, 0, 0];
+  /** The brush load after the dabs so far. */
+  get load() {
+    return this.exchange.load;
+  }
+  push(points) {
+    const dabs = [];
+    for (const p of points) this.walker.push(this.smooth(p), dabs);
+    return this.paint(dabs);
+  }
+  finish(last) {
+    const dabs = [];
+    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);
+    this.walker.finish(dabs);
+    return this.paint(dabs);
+  }
+  smooth(p) {
+    const a = 1 - Math.min(0.95, Math.max(0, this.brush.smoothing));
+    const cur = this.smoothPos;
+    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
+    this.smoothPos = n;
+    return n;
+  }
+  paint(dabs) {
+    const rects = [];
+    for (const d of dabs) {
+      const rect = dabRect(d, this.brush.hardness);
+      const n = rect.width * rect.height;
+      if (this.buf.length < n) this.buf = new Float32Array(n);
+      const cov = this.buf.subarray(0, n);
+      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);
+      this.dab(d, rect, cov);
+      rects.push(rect);
+      this.bounds = union(this.bounds, rect);
+      this.dabCount++;
+    }
+    return rects;
+  }
+  dab(d, rect, cov) {
+    const ex = this.exchange;
+    ex.pickUp(this.medium.sample(rect, cov));
+    const total = ex.paint(this.paintColor);
+    if (total > 0) {
+      const dep = Math.min(1, total) * this.brush.flow * this.brush.opacity * d.opacity;
+      if (dep > 0) this.medium.deposit(rect, cov, dep, this.paintColor, ex.paintPigment);
+    }
+    ex.drain();
+  }
+};
 function union(a, b) {
   if (!a) return { ...b };
   const x = Math.min(a.x, b.x);
@@ -639,6 +785,243 @@ function union(a, b) {
   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 };
 }
 
+// src/paint/blending.ts
+var DEFAULT_BLENDER = { strength: 0.5, distance: 0.35, mixing: "pigment" };
+var DEFAULT_SMUDGE = { strength: 0.7, length: 0.85, mixing: "rgb" };
+var unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+function normalizeBlender(raw = {}, base = DEFAULT_BLENDER) {
+  return { strength: unit(raw.strength, base.strength), distance: unit(raw.distance, base.distance), mixing: raw.mixing === "rgb" || raw.mixing === "pigment" ? raw.mixing : base.mixing };
+}
+function normalizeSmudge(raw = {}, base = DEFAULT_SMUDGE) {
+  return { strength: unit(raw.strength, base.strength), length: unit(raw.length, base.length), mixing: raw.mixing === "rgb" || raw.mixing === "pigment" ? raw.mixing : base.mixing };
+}
+function blendRadius(settings, radius) {
+  return Math.max(1, Math.round(settings.distance * 2 * radius));
+}
+function createBlenderScratch() {
+  return { sums: new Float64Array(0), mix: { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(PIGMENT_BANDS), scatter: 1 }, out: [0, 0, 0] };
+}
+var N = PIGMENT_BANDS;
+function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
+  const R = blendRadius(settings, radius);
+  const W = rect.width + 2 * R;
+  const H = rect.height + 2 * R;
+  const pigment = settings.mixing === "pigment";
+  const C = pigment ? N + 2 : 4;
+  const stride = (W + 1) * C;
+  const size = stride * (H + 1);
+  if (scratch.sums.length < size) scratch.sums = new Float64Array(size);
+  const I = scratch.sums;
+  I.fill(0, 0, size);
+  medium.reset();
+  const row = new Float64Array(C);
+  for (let y = 0; y < H; y++) {
+    row.fill(0);
+    const dy = rect.y - R + y;
+    for (let x = 0; x < W; x++) {
+      const dx = rect.x - R + x;
+      const i = medium.locate(dx, dy, false);
+      if (i >= 0) {
+        const px = medium.pixels;
+        const a = px[i + 3] / 255;
+        if (a > 0) {
+          if (pigment) {
+            const p = pigment8(px[i], px[i + 1], px[i + 2]);
+            const sa = p.scatter * p.strength * a;
+            for (let k = 0; k < N; k++) row[k] += sa * p.ks[k];
+            row[N] += sa;
+            row[N + 1] += a;
+          } else {
+            row[0] += px[i] / 255 * a;
+            row[1] += px[i + 1] / 255 * a;
+            row[2] += px[i + 2] / 255 * a;
+            row[3] += a;
+          }
+        }
+      }
+      const o = (y + 1) * stride + (x + 1) * C;
+      const up = y * stride + (x + 1) * C;
+      for (let c = 0; c < C; c++) I[o + c] = I[up + c] + row[c];
+    }
+  }
+  const area = (2 * R + 1) * (2 * R + 1);
+  const strength = settings.strength * opacity;
+  const lock = medium.target.lockTransparency;
+  const mixPig = scratch.mix;
+  const out = scratch.out;
+  const sum = (c, x1, y1, x2, y2) => I[y2 * stride + x2 * C + c] - I[y1 * stride + x2 * C + c] - I[y2 * stride + x1 * C + c] + I[y1 * stride + x1 * C + c];
+  const w = rect.width;
+  medium.reset();
+  for (let yy = 0; yy < rect.height; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const k = cov[yy * w + xx];
+      if (k <= 0) continue;
+      const dx = rect.x + xx;
+      const dy = rect.y + yy;
+      let t = strength * k * medium.selectionAt(dx, dy);
+      if (t <= 0) continue;
+      if (t > 1) t = 1;
+      const x1 = xx;
+      const y1 = yy;
+      const x2 = xx + 2 * R + 1;
+      const y2 = yy + 2 * R + 1;
+      const asum = sum(pigment ? N + 1 : 3, x1, y1, x2, y2);
+      const ri = medium.locate(dx, dy, false);
+      const a = ri < 0 ? 0 : medium.pixels[ri + 3] / 255;
+      if (lock && a <= 0) continue;
+      const avgA = asum / area;
+      const na = lock ? a : (1 - t) * a + t * avgA;
+      if (asum <= 1e-9) {
+        if (lock || a <= 0) continue;
+        const i2 = medium.locate(dx, dy, true);
+        medium.pixels[i2 + 3] = Math.round(na * 255);
+        continue;
+      }
+      const share = lock ? t : na > 0 ? t * avgA / na : 1;
+      const i = medium.locate(dx, dy, true);
+      const px = medium.pixels;
+      if (pigment) {
+        const sa = sum(N, x1, y1, x2, y2);
+        for (let c = 0; c < N; c++) mixPig.ks[c] = sum(c, x1, y1, x2, y2) / sa;
+        mixPig.scatter = sa / asum;
+        if (a <= 0 || share >= 1) lerpPigmentInto(mixPig, mixPig, 0, out, 0);
+        else lerpPigmentInto(pigment8(px[i], px[i + 1], px[i + 2]), mixPig, share, out, 0);
+      } else {
+        for (let c = 0; c < 3; c++) {
+          const m = sum(c, x1, y1, x2, y2) / asum;
+          out[c] = a <= 0 || share >= 1 ? m : px[i + c] / 255 + (m - px[i + c] / 255) * share;
+        }
+      }
+      px[i] = Math.round(out[0] * 255);
+      px[i + 1] = Math.round(out[1] * 255);
+      px[i + 2] = Math.round(out[2] * 255);
+      if (!lock) px[i + 3] = Math.round(na * 255);
+    }
+  }
+}
+var SmudgeTip = class {
+  constructor(settings, diameter) {
+    this.settings = settings;
+    this.size = Math.max(2, Math.min(512, Math.ceil(diameter)));
+    this.patch = new Float32Array(this.size * this.size * 4);
+  }
+  settings;
+  size;
+  patch;
+  loaded = false;
+  out = [0, 0, 0];
+  cell(d, px, py) {
+    const s = this.size;
+    const r = Math.max(0.5, d.radius);
+    const bx = Math.min(s - 1, Math.max(0, Math.floor(((px - d.x) / r + 1) / 2 * s)));
+    const by = Math.min(s - 1, Math.max(0, Math.floor(((py - d.y) / r + 1) / 2 * s)));
+    return (by * s + bx) * 4;
+  }
+  /** Fills the patch from the pixels under the dab. */
+  load(medium, d) {
+    const s = this.size;
+    const r = Math.max(0.5, d.radius);
+    medium.reset();
+    for (let by = 0; by < s; by++) {
+      for (let bx = 0; bx < s; bx++) {
+        const dx = Math.floor(d.x + ((bx + 0.5) / s * 2 - 1) * r);
+        const dy = Math.floor(d.y + ((by + 0.5) / s * 2 - 1) * r);
+        const i = medium.locate(dx, dy, false);
+        const c = (by * s + bx) * 4;
+        if (i < 0) {
+          this.patch.fill(0, c, c + 4);
+          continue;
+        }
+        const px = medium.pixels;
+        this.patch[c] = px[i] / 255;
+        this.patch[c + 1] = px[i + 1] / 255;
+        this.patch[c + 2] = px[i + 2] / 255;
+        this.patch[c + 3] = px[i + 3] / 255;
+      }
+    }
+    this.loaded = true;
+  }
+  /** `a` mixed `t` of the way to `b` (both 0..1) into `out`. */
+  mix(a0, a1, a2, b0, b1, b2, t) {
+    const o = this.out;
+    if (this.settings.mixing === "pigment") {
+      mixPigment8(Math.round(a0 * 255), Math.round(a1 * 255), Math.round(a2 * 255), Math.round(b0 * 255), Math.round(b1 * 255), Math.round(b2 * 255), t, o);
+    } else {
+      o[0] = a0 + (b0 - a0) * t;
+      o[1] = a1 + (b1 - a1) * t;
+      o[2] = a2 + (b2 - a2) * t;
+    }
+    return o;
+  }
+  /** One dab: lays the carried patch over the tip's footprint (`cov` over `rect`), then picks up. */
+  dab(medium, d, rect, cov) {
+    if (!this.loaded) {
+      this.load(medium, d);
+      return;
+    }
+    const { strength, length } = this.settings;
+    const lock = medium.target.lockTransparency;
+    const patch = this.patch;
+    const w = rect.width;
+    medium.reset();
+    for (let yy = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < w; xx++) {
+        const cv = cov[yy * w + xx];
+        if (cv <= 0) continue;
+        const dx = rect.x + xx;
+        const dy = rect.y + yy;
+        let k = strength * cv * d.opacity * medium.selectionAt(dx, dy);
+        if (k <= 0) continue;
+        if (k > 1) k = 1;
+        const c = this.cell(d, dx + 0.5, dy + 0.5);
+        const ba = patch[c + 3];
+        const ri = medium.locate(dx, dy, false);
+        const a = ri < 0 ? 0 : medium.pixels[ri + 3] / 255;
+        if (lock && a <= 0) continue;
+        const px0 = ri >= 0 ? medium.pixels : null;
+        const o0 = px0 ? px0[ri] / 255 : 0;
+        const o1 = px0 ? px0[ri + 1] / 255 : 0;
+        const o2 = px0 ? px0[ri + 2] / 255 : 0;
+        if (a > 0 || ba > 0) {
+          const na = lock ? a : a + (ba - a) * k;
+          const share = lock ? k * ba : na > 0 ? k * ba / na : 0;
+          let r = o0;
+          let g = o1;
+          let b = o2;
+          if (a <= 0 || share >= 1) {
+            r = patch[c];
+            g = patch[c + 1];
+            b = patch[c + 2];
+          } else if (share > 0) {
+            const m = this.mix(o0, o1, o2, patch[c], patch[c + 1], patch[c + 2], share);
+            r = m[0];
+            g = m[1];
+            b = m[2];
+          }
+          const i = medium.locate(dx, dy, true);
+          const out = medium.pixels;
+          out[i] = Math.round(r * 255);
+          out[i + 1] = Math.round(g * 255);
+          out[i + 2] = Math.round(b * 255);
+          out[i + 3] = Math.round(na * 255);
+        }
+        const pick = (1 - length) * Math.min(1, cv * d.opacity);
+        if (pick > 0) {
+          const pa = ba + (a - ba) * pick;
+          const s = pa > 0 ? a * pick / pa : 0;
+          if (s > 0) {
+            const m = ba <= 0 || s >= 1 ? [o0, o1, o2] : this.mix(patch[c], patch[c + 1], patch[c + 2], o0, o1, o2, s);
+            patch[c] = m[0];
+            patch[c + 1] = m[1];
+            patch[c + 2] = m[2];
+          }
+          patch[c + 3] = pa;
+        }
+      }
+    }
+  }
+};
+
 // src/paint/pigment-tools.ts
 var HEX = /^#?([0-9a-f]{6})$/i;
 function parseHex(value, index) {
@@ -654,7 +1037,7 @@ function createPigmentTools() {
   const mixColors = {
     name: "mix_colors",
     title: "Mix colours like paint",
-    description: "Mixes colours as paint would (Kubelka-Munk pigment mixing over reflectance spectra), so blue and yellow make green and white lightens a colour into a tint instead of greying it. Changes nothing. Returns the mixed colour as #rrggbb, the plain RGB average (rgbLerp) for comparison, and the normalised weights.",
+    description: "Mixes colours as paint would (model pigment, the default: Kubelka-Munk mixing over reflectance spectra, so blue and yellow make green and white lightens a colour into a tint instead of greying it), or as light on screen (model rgb: the weighted RGB average). Changes nothing. Returns mixed (#rrggbb, by the chosen model), the other model's result for comparison (rgbLerp and pigment), the normalised weights and the model.",
     inputSchema: {
       type: "object",
       properties: {
@@ -678,6 +1061,11 @@ function createPigmentTools() {
             required: ["color", "weight"],
             additionalProperties: false
           }
+        },
+        model: {
+          type: "string",
+          enum: ["pigment", "rgb"],
+          description: "pigment (default): mix like paint (Kubelka-Munk), as the pigment blend mode, Mixer Brush and mixing pad do; rgb: average the RGB values, as normal blending and rgb mixing brushes do (strength is ignored)."
         }
       },
       required: ["colors"],
@@ -689,14 +1077,16 @@ function createPigmentTools() {
       const rgbs = items.map((item, i) => parseHex(item.color, i));
       const total = items.reduce((sum, item) => sum + item.weight, 0);
       if (!(total > 0)) throw new Error("Every weight is 0; give at least one colour a weight above 0.");
-      const pigments = rgbs.map((rgb, i) => createPigment(rgb, { strength: items[i].strength }));
+      const pigments = rgbs.map((rgb2, i) => createPigment(rgb2, { strength: items[i].strength }));
       const mixed = mixPigments(pigments, items.map((item) => item.weight));
-      const lerp = [0, 1, 2].map((c) => rgbs.reduce((sum, rgb, i) => sum + rgb[c] * items[i].weight, 0) / total);
+      const lerp = [0, 1, 2].map((c) => rgbs.reduce((sum, rgb2, i) => sum + rgb2[c] * items[i].weight, 0) / total);
+      const rgb = args.model === "rgb";
       return {
-        mixed: toHex(mixed),
+        mixed: toHex(rgb ? lerp : mixed),
         rgbLerp: toHex(lerp),
+        pigment: toHex(mixed),
         weights: items.map((item) => item.weight / total),
-        model: "kubelka-munk"
+        model: rgb ? "rgb" : "kubelka-munk"
       };
     }
   };
@@ -721,14 +1111,26 @@ export {
   applyStrokeToTile,
   coverageTileCoord,
   MIXING_MODELS,
-  DEFAULT_MIXER,
+  EMPTY_MIXER_LOAD,
   MIXER_PICKUP_RATE,
   MIXER_DRAIN,
+  exchangeRates,
+  PaintExchange,
+  TileMedium,
+  DEFAULT_MIXER,
   normalizeMixer,
-  EMPTY_MIXER_LOAD,
+  mixerRates,
   loadMixer,
   cleanMixer,
   MixerStroke,
+  DEFAULT_BLENDER,
+  DEFAULT_SMUDGE,
+  normalizeBlender,
+  normalizeSmudge,
+  blendRadius,
+  createBlenderScratch,
+  blenderDab,
+  SmudgeTip,
   createPigmentTools
 };
-//# sourceMappingURL=chunk-3PHA3UKI.js.map
+//# sourceMappingURL=chunk-Z4BC6M74.js.map