@pixerate/editor 0.115.0 → 0.116.0

package/dist/chunk-HOCPSFGA.cjs

@@ -0,0 +1,3262 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _chunkTFOPHZ3Ucjs = require('./chunk-TFOPHZ3U.cjs');
+
+// src/paint/brush.ts
+var DEFAULT_BRUSH = {
+  size: 20,
+  hardness: 1,
+  spacing: 0.1,
+  angle: 0,
+  roundness: 1,
+  opacity: 1,
+  flow: 1,
+  smoothing: 0,
+  pressureSize: true,
+  pressureOpacity: false,
+  blend: "normal"
+};
+var MAX_BRUSH_SIZE = 2500;
+function normalizeBrush(raw = {}) {
+  const num = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
+  return {
+    size: num(raw.size, 1, MAX_BRUSH_SIZE, DEFAULT_BRUSH.size),
+    hardness: num(raw.hardness, 0, 1, DEFAULT_BRUSH.hardness),
+    spacing: num(raw.spacing, 0.01, 10, DEFAULT_BRUSH.spacing),
+    angle: num(raw.angle, -360, 360, DEFAULT_BRUSH.angle),
+    roundness: num(raw.roundness, 0.01, 1, DEFAULT_BRUSH.roundness),
+    opacity: num(raw.opacity, 0, 1, DEFAULT_BRUSH.opacity),
+    flow: num(raw.flow, 0, 1, DEFAULT_BRUSH.flow),
+    smoothing: num(raw.smoothing, 0, 0.95, DEFAULT_BRUSH.smoothing),
+    pressureSize: typeof raw.pressureSize === "boolean" ? raw.pressureSize : DEFAULT_BRUSH.pressureSize,
+    pressureOpacity: typeof raw.pressureOpacity === "boolean" ? raw.pressureOpacity : DEFAULT_BRUSH.pressureOpacity,
+    blend: _nullishCoalesce(raw.blend, () => ( "normal"))
+  };
+}
+var TIP_SHAPE = [
+  [0, 0.664],
+  [0.14, 0.58],
+  [0.28, 0.5],
+  [0.4, 0.44],
+  [0.52, 0.36],
+  [0.63, 0.29],
+  [0.7, 0.24],
+  [0.78, 0.19],
+  [0.84, 0.15],
+  [0.89, 0.11],
+  [1, 0]
+];
+var TIP_EDGE_PX = 1.2;
+var SMALL_TIP_RADIUS = 3;
+var SUBPIXEL = [-0.375, -0.125, 0.125, 0.375];
+function tipShape(radius, hardness) {
+  const h = (Number.isNaN(hardness) ? 0 : Math.min(1, Math.max(0, hardness))) * 10;
+  const i = Math.min(9, Math.floor(h));
+  const t = h - i;
+  const a = TIP_SHAPE[i];
+  const b = TIP_SHAPE[i + 1];
+  const r0 = a[0] + (b[0] - a[0]) * t;
+  const s = a[1] + (b[1] - a[1]) * t;
+  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
+  const edge = Math.max(0.25, Math.min(TIP_EDGE_PX, 0.3 * r));
+  return [Math.max(0, Math.min(r0 * r, r - edge)), Math.max(1e-3, s * r, edge)];
+}
+function softExp(u) {
+  let g = Math.min(1, Math.max(0, 1 - u / 64));
+  for (let k = 0; k < 6; k++) g *= g;
+  return g;
+}
+function tipFalloff(d, radius, hardness) {
+  const [r0, s] = tipShape(radius, hardness);
+  if (d <= r0) return 1;
+  const x = (d - r0) / s;
+  return softExp(x * x);
+}
+function tipReach(radius, hardness) {
+  const [r0, s] = tipShape(radius, hardness);
+  return r0 + 2.6 * s;
+}
+function dabCoverage(d, radius, hardness) {
+  if (Number.isNaN(d) || d >= tipReach(radius, hardness) + 0.5) return 0;
+  return tipFalloff(d, radius, hardness);
+}
+function smoothPoints(points, amount) {
+  const a = 1 - Math.min(0.95, Math.max(0, amount));
+  if (a >= 1 || points.length < 3) return points.slice();
+  const out = [];
+  let cur = null;
+  for (const p of points) {
+    const n = cur ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
+    out.push(n);
+    cur = n;
+  }
+  out[out.length - 1] = points[points.length - 1];
+  return out;
+}
+var pressureOf = (p) => typeof p.pressure === "number" && Number.isFinite(p.pressure) ? Math.min(1, Math.max(0, p.pressure)) : 1;
+var DabWalker = (_class = class {
+  constructor(brush) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.brush = brush;
+  }
+  
+  __init() {this.last = null}
+  __init2() {this.nextAt = 0}
+  __init3() {this.pendingFirst = null}
+  diameter(p) {
+    return this.brush.pressureSize ? this.brush.size * pressureOf(p) : this.brush.size;
+  }
+  stepLen(p) {
+    return Math.max(0.5, Math.max(1, this.diameter(p)) * Math.max(0.01, this.brush.spacing));
+  }
+  dab(p) {
+    const b = this.brush;
+    return {
+      x: p.x,
+      y: p.y,
+      radius: Math.max(0.5, this.diameter(p) / 2),
+      alpha: Math.min(1, Math.max(0, b.flow)),
+      opacity: b.pressureOpacity ? pressureOf(p) : 1,
+      angle: b.angle * Math.PI / 180,
+      roundness: Math.min(1, Math.max(0.01, b.roundness))
+    };
+  }
+  push(p, out) {
+    const a = this.last;
+    if (!a) {
+      this.last = p;
+      this.pendingFirst = p;
+      this.nextAt = this.stepLen(p);
+      return;
+    }
+    if (this.pendingFirst) {
+      out.push(this.dab(this.pendingFirst));
+      this.pendingFirst = null;
+    }
+    const dx = p.x - a.x;
+    const dy = p.y - a.y;
+    const len = Math.hypot(dx, dy);
+    if (len > 1e-9) {
+      while (this.nextAt <= len + 1e-9) {
+        const f = Math.min(1, this.nextAt / len);
+        const q = {
+          x: a.x + dx * f,
+          y: a.y + dy * f,
+          pressure: pressureOf(a) + (pressureOf(p) - pressureOf(a)) * f
+        };
+        out.push(this.dab(q));
+        this.nextAt += this.stepLen(q);
+      }
+      this.nextAt -= len;
+    }
+    this.last = p;
+  }
+  finish(out) {
+    if (this.pendingFirst) {
+      out.push(this.dab(this.pendingFirst));
+      this.pendingFirst = null;
+    }
+  }
+}, _class);
+function walkDabs(points, brush) {
+  const w = new DabWalker(brush);
+  const out = [];
+  for (const p of smoothPoints(points, brush.smoothing)) w.push(p, out);
+  w.finish(out);
+  return out;
+}
+function dabRect(d, hardness) {
+  const ro = Math.min(1, Math.max(0.5 / d.radius, d.roundness));
+  const rm = Math.max(0.5, d.radius * ro);
+  const r = Math.max(rm, tipReach(rm, hardness)) / ro + 1.5;
+  const x0 = Math.floor(d.x - r);
+  const y0 = Math.floor(d.y - r);
+  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };
+}
+function rasterizeDab(d, hardness, rect, out) {
+  const w = rect.width;
+  const h = rect.height;
+  out.fill(0, 0, w * h);
+  const r = d.radius;
+  const ro = Math.min(1, Math.max(0.5 / r, d.roundness));
+  const rm = Math.max(0.5, r * ro);
+  const reach = Math.max(rm, tipReach(rm, hardness));
+  const sn = Math.sin(d.angle);
+  const cs = Math.cos(d.angle);
+  const toTip = (dx, dy) => {
+    const ux = dx;
+    const uy = -dy;
+    return [ux * cs + uy * sn, -ux * sn + uy * cs];
+  };
+  const small = rm < SMALL_TIP_RADIUS;
+  const reach2 = (reach + (small ? 0.75 : 0.5)) ** 2;
+  for (let yy = 0; yy < h; yy++) {
+    const dy = rect.y + yy + 0.5 - d.y;
+    for (let xx = 0; xx < w; xx++) {
+      const dx = rect.x + xx + 0.5 - d.x;
+      const [u, v] = toTip(dx, dy);
+      const d2 = (u * ro) ** 2 + v * v;
+      if (d2 >= reach2) continue;
+      let val;
+      if (small) {
+        let sum = 0;
+        for (const sy of SUBPIXEL) {
+          for (const sx of SUBPIXEL) {
+            const [su, sv] = toTip(dx + sx, dy + sy);
+            sum += tipFalloff(Math.sqrt((su * ro) ** 2 + sv * sv), rm, hardness);
+          }
+        }
+        val = sum / 16;
+      } else {
+        val = dabCoverage(Math.sqrt(d2), rm, hardness);
+      }
+      if (val > 0) out[yy * w + xx] = val * d.alpha;
+    }
+  }
+}
+var TILE_PIXELS = _chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE;
+var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this); }
+  __init4() {this.tiles = /* @__PURE__ */ new Map()}
+  __init5() {this.bounds = null}
+  __init6() {this.dirty = /* @__PURE__ */ new Set()}
+  get(x, y) {
+    const tx = Math.floor(x / _chunkTFOPHZ3Ucjs.TILE);
+    const ty = Math.floor(y / _chunkTFOPHZ3Ucjs.TILE);
+    const t = this.tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty));
+    return t ? t[(y - ty * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE + (x - tx * _chunkTFOPHZ3Ucjs.TILE)] : 0;
+  }
+  /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */
+  accumulate(rect, vals, ceil) {
+    if (rect.width <= 0 || rect.height <= 0) return;
+    const w = rect.width;
+    const tx0 = Math.floor(rect.x / _chunkTFOPHZ3Ucjs.TILE);
+    const ty0 = Math.floor(rect.y / _chunkTFOPHZ3Ucjs.TILE);
+    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkTFOPHZ3Ucjs.TILE);
+    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkTFOPHZ3Ucjs.TILE);
+    let touched = false;
+    for (let ty = ty0; ty <= ty1; ty++) {
+      for (let tx = tx0; tx <= tx1; tx++) {
+        const x0 = Math.max(rect.x, tx * _chunkTFOPHZ3Ucjs.TILE);
+        const y0 = Math.max(rect.y, ty * _chunkTFOPHZ3Ucjs.TILE);
+        const x1 = Math.min(rect.x + rect.width, tx * _chunkTFOPHZ3Ucjs.TILE + _chunkTFOPHZ3Ucjs.TILE);
+        const y1 = Math.min(rect.y + rect.height, ty * _chunkTFOPHZ3Ucjs.TILE + _chunkTFOPHZ3Ucjs.TILE);
+        let tile;
+        for (let y = y0; y < y1; y++) {
+          const row = (y - rect.y) * w;
+          const trow = (y - ty * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE;
+          for (let x = x0; x < x1; x++) {
+            const v = vals[row + (x - rect.x)];
+            if (v <= 0) continue;
+            if (!tile) {
+              const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
+              tile = this.tiles.get(key);
+              if (!tile) {
+                tile = new Float32Array(TILE_PIXELS);
+                this.tiles.set(key, tile);
+              }
+              this.dirty.add(key);
+              touched = true;
+            }
+            const ti = trow + (x - tx * _chunkTFOPHZ3Ucjs.TILE);
+            const c = tile[ti];
+            if (ceil > c) tile[ti] = c + v * (ceil - c);
+          }
+        }
+      }
+    }
+    if (touched) this.bounds = unionRect(this.bounds, rect);
+  }
+  /** Tiles changed since the last call. */
+  takeDirty() {
+    const out = [...this.dirty];
+    this.dirty.clear();
+    return out;
+  }
+}, _class2);
+function unionRect(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  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 StrokeCoverage = (_class3 = class {
+  constructor(brush) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
+    this.brush = brush;
+    this.walker = new DabWalker(brush);
+    this.smoothing = brush.smoothing;
+  }
+  
+  __init7() {this.coverage = new CoverageMap()}
+  
+  
+  __init8() {this.smoothPos = null}
+  __init9() {this.buf = new Float32Array(0)}
+  __init10() {this.dabCount = 0}
+  /** Feeds input points; returns the document rectangles the new dabs touched. */
+  push(points) {
+    const dabs = [];
+    for (const p of points) this.walker.push(this.smooth(p), dabs);
+    return this.paint(dabs);
+  }
+  /** Ends the stroke (a single click still paints one dab). */
+  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.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 vals = this.buf.subarray(0, n);
+      rasterizeDab(d, this.brush.hardness, rect, vals);
+      this.coverage.accumulate(rect, vals, d.opacity);
+      rects.push(rect);
+      this.dabCount++;
+    }
+    return rects;
+  }
+}, _class3);
+function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}) {
+  const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
+  const ox = tx * _chunkTFOPHZ3Ucjs.TILE + s.offset.x;
+  const oy = ty * _chunkTFOPHZ3Ucjs.TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = _chunkTFOPHZ3Ucjs.TILE;
+  let y1 = _chunkTFOPHZ3Ucjs.TILE;
+  if (options.region) {
+    const r = options.region;
+    x0 = Math.max(0, Math.floor(r.x) - ox);
+    y0 = Math.max(0, Math.floor(r.y) - oy);
+    x1 = Math.min(_chunkTFOPHZ3Ucjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunkTFOPHZ3Ucjs.TILE, Math.ceil(r.y + r.height) - oy);
+    if (x1 <= x0 || y1 <= y0) return out;
+    if (options.into) {
+      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * _chunkTFOPHZ3Ucjs.TILE + x0) * channels, (y * _chunkTFOPHZ3Ucjs.TILE + x1) * channels), (y * _chunkTFOPHZ3Ucjs.TILE + x0) * channels);
+    }
+  }
+  const sel = s.selection;
+  const cb = [0, 0, 0, 0];
+  const cs = [s.color[0] / 255, s.color[1] / 255, s.color[2] / 255, s.color[3] / 255];
+  const bg = [s.background[0] / 255, s.background[1] / 255, s.background[2] / 255, s.background[3] / 255];
+  const aligned = s.offset.x % _chunkTFOPHZ3Ucjs.TILE === 0 && s.offset.y % _chunkTFOPHZ3Ucjs.TILE === 0;
+  const covTile = aligned ? coverage.tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, Math.floor(ox / _chunkTFOPHZ3Ucjs.TILE), Math.floor(oy / _chunkTFOPHZ3Ucjs.TILE))) : void 0;
+  if (aligned && !covTile) return out;
+  for (let y = y0; y < y1; y++) {
+    const dy = oy + y;
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const c = covTile ? covTile[y * _chunkTFOPHZ3Ucjs.TILE + x] : coverage.get(dx, dy);
+      if (c <= 0) continue;
+      let k = c * s.opacity;
+      if (sel) {
+        if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
+        k *= sel.data[dy * sel.width + dx] / 255;
+      }
+      if (k > 1) k = 1;
+      if (k <= 0) continue;
+      const p = y * _chunkTFOPHZ3Ucjs.TILE + x;
+      if (channels === 1) {
+        const target = s.mode === "erase" ? s.background[0] : s.color[0];
+        out[p] = Math.round(out[p] + (target - out[p]) * k);
+        continue;
+      }
+      const i = p * 4;
+      if (s.mode === "erase" && !s.lockTransparency) {
+        out[i + 3] = Math.round(out[i + 3] * (1 - k));
+        continue;
+      }
+      if (s.lockTransparency && out[i + 3] === 0) continue;
+      const src = s.mode === "erase" ? bg : cs;
+      if (s.blend === "pigment") {
+        const bytes = s.mode === "erase" ? s.background : s.color;
+        const as = src[3] * k;
+        if (!(as > 0)) continue;
+        const ao = as + out[i + 3] / 255 * (1 - as);
+        _chunkTFOPHZ3Ucjs.mixPigment8.call(void 0, out[i], out[i + 1], out[i + 2], bytes[0], bytes[1], bytes[2], as / ao, cb);
+        out[i] = Math.round(cb[0] * 255);
+        out[i + 1] = Math.round(cb[1] * 255);
+        out[i + 2] = Math.round(cb[2] * 255);
+        if (!s.lockTransparency) out[i + 3] = Math.round(ao * 255);
+        continue;
+      }
+      for (let ch = 0; ch < 4; ch++) cb[ch] = out[i + ch] / 255;
+      const o = _chunkTFOPHZ3Ucjs.blendPixel.call(void 0, s.blend, cb, src, k);
+      out[i] = Math.round(o[0] * 255);
+      out[i + 1] = Math.round(o[1] * 255);
+      out[i + 2] = Math.round(o[2] * 255);
+      if (!s.lockTransparency) out[i + 3] = Math.round(o[3] * 255);
+    }
+  }
+  return out;
+}
+function coverageTileCoord(key) {
+  return _chunkTFOPHZ3Ucjs.tileCoord.call(void 0, key);
+}
+
+// src/paint/exchange.ts
+var MIXING_MODELS = ["rgb", "pigment"];
+var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
+var MIXER_PICKUP_RATE = 0.25;
+var MIXER_DRAIN = 0.08;
+function exchangeRates(pickup, mix, load, mixing) {
+  return { pickup: MIXER_PICKUP_RATE * pickup, mix: mix * pickup, drain: MIXER_DRAIN * (1 - load), mixing };
+}
+var PaintExchange = (_class4 = class {
+  constructor(rates, load) {;_class4.prototype.__init11.call(this);
+    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.well = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
+    this.pig = rates.mixing === "pigment" ? { res: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, _nullishCoalesce(this.reservoir, () => ( [0, 0, 0]))), well: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, _nullishCoalesce(this.well, () => ( [0, 0, 0]))), paint: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0]), canvas: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0]) } : null;
+  }
+  
+  
+  
+  
+  
+  __init11() {this.out = [0, 0, 0]}
+  /** What the brush carries now. */
+  get load() {
+    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.well ? [...this.well] : null };
+  }
+  /** The colour picked up so far, or `null`. */
+  get pickup() {
+    return this.well;
+  }
+  /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
+  get paintPigment() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _ => _.pig, 'optionalAccess', _2 => _2.paint]), () => ( null));
+  }
+  /** 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) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, 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) {
+    const o = this.out;
+    if (pa && pb) _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, pa, pb, t, o, 0);
+    else for (let c = 0; c < 3; c++) o[c] = a[c] + (b[c] - a[c]) * t;
+    return o;
+  }
+  /** `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) {
+      _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.pig.canvas, a[0], a[1], a[2]);
+      _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.pig.paint, b[0], b[1], b[2]);
+      _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, 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) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, pig.canvas, sample.rgb[0], sample.rgb[1], sample.rgb[2]);
+      const o = this.mix(this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _3 => _3.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _4 => _4.canvas]), () => ( null)), this.rates.pickup * sample.contact);
+      this.well = [o[0], o[1], o[2]];
+    }
+    if (pig) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, 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, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _5 => _5.res]), () => ( null)), this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _6 => _6.well]), () => ( null)), wp / total);
+      out[0] = m[0];
+      out[1] = m[1];
+      out[2] = m[2];
+    } else {
+      const c = _nullishCoalesce(res, () => ( this.well));
+      out[0] = c[0];
+      out[1] = c[1];
+      out[2] = c[2];
+    }
+    if (pig) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, pig.paint, out[0], out[1], out[2]);
+    return total;
+  }
+  /** 3. The reservoir drains. */
+  drain() {
+    this.amount *= 1 - this.rates.drain;
+  }
+}, _class4);
+var TileMedium = (_class5 = class {
+  constructor(target, options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);
+    this.target = target;
+    this.options = options;
+  }
+  
+  
+  // The tile last looked up by `locate` (and whether it came from `writeTile`).
+  __init12() {this.tx = NaN}
+  __init13() {this.ty = NaN}
+  __init14() {this.tile = null}
+  __init15() {this.writable = false}
+  __init16() {this.canvasPig = _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0])}
+  __init17() {this.paintPig = _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0])}
+  __init18() {this.paintKey = -1}
+  __init19() {this.cb = [0, 0, 0, 0]}
+  __init20() {this.src = [0, 0, 0, 1]}
+  __init21() {this.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;
+    const ly = dy - t.offset.y;
+    const tx = Math.floor(lx / _chunkTFOPHZ3Ucjs.TILE);
+    const ty = Math.floor(ly / _chunkTFOPHZ3Ucjs.TILE);
+    if (tx !== this.tx || ty !== this.ty || write && !this.writable) {
+      this.tx = tx;
+      this.ty = ty;
+      this.tile = write ? t.writeTile(tx, ty) : t.readTile(tx, ty);
+      this.writable = write;
+    }
+    return this.tile ? ((ly - ty * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE + (lx - tx * _chunkTFOPHZ3Ucjs.TILE)) * 4 : -1;
+  }
+  /** 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;
+    let ag = 0;
+    let ab = 0;
+    let wsum = 0;
+    let asum = 0;
+    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;
+        wsum += k;
+        const i = this.locate(rect.x + xx, rect.y + yy, false);
+        if (i < 0) continue;
+        const px = this.tile;
+        const al = px[i + 3] / 255;
+        if (al <= 0) continue;
+        const ka = k * al;
+        ar += px[i] / 255 * ka;
+        ag += px[i + 1] / 255 * ka;
+        ab += px[i + 2] / 255 * ka;
+        asum += ka;
+      }
+    }
+    if (!(asum > 1e-6)) return null;
+    return { rgb: [ar / asum, ag / asum, ab / asum], contact: asum / Math.max(1e-6, wsum) };
+  }
+  deposit(rect, cov, dep, paint, paintPigment, field = null) {
+    const t = this.target;
+    const sel = t.selection;
+    const w = rect.width;
+    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++) {
+        const p = yy * w + xx;
+        let k = cov[p] * dep;
+        if (k <= 0) continue;
+        const dx = rect.x + xx;
+        if (sel) {
+          if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
+          k *= sel.data[dy * sel.width + dx] / 255;
+          if (k <= 0) continue;
+        }
+        if (k > 1) k = 1;
+        if (t.lockTransparency) {
+          const ri = this.locate(dx, dy, false);
+          if (ri < 0 || this.tile[ri + 3] === 0) continue;
+        }
+        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 = _chunkTFOPHZ3Ucjs.blendPixel.call(void 0, 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] = pr;
+          o[1] = pg;
+          o[2] = pb;
+        } else if (pigment && field) {
+          _chunkTFOPHZ3Ucjs.mixPigment8.call(void 0, 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) {
+            _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.canvasPig, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
+            lastKey = key;
+          }
+          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) {
+              _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.paintPig, pr, pg, pb);
+              this.paintKey = pkey;
+            }
+            pp = this.paintPig;
+          }
+          _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, this.canvasPig, pp, share, o, 0);
+        } else {
+          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);
+        px[i + 2] = Math.round(o[2] * 255);
+        px[i + 3] = Math.round(na * 255);
+      }
+    }
+  }
+}, _class5);
+
+// 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 unit3 = (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: unit3(raw.wet, DEFAULT_MIXER.wet),
+    load: unit3(raw.load, DEFAULT_MIXER.load),
+    mix: unit3(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 = (_class6 = class {
+  constructor(brush, settings, load, target) {;_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);
+    this.brush = brush;
+    this.walker = new DabWalker(brush);
+    this.exchange = new PaintExchange(mixerRates(normalizeMixer(settings)), load);
+    this.medium = new TileMedium(target);
+  }
+  
+  __init22() {this.dabCount = 0}
+  __init23() {this.bounds = null}
+  
+  __init24() {this.smoothPos = null}
+  __init25() {this.buf = new Float32Array(0)}
+  
+  
+  __init26() {this.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();
+  }
+}, _class6);
+function union(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  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 };
+}
+
+// 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(_chunkTFOPHZ3Ucjs.PIGMENT_BANDS), scatter: 1 }, out: [0, 0, 0] };
+}
+var N = _chunkTFOPHZ3Ucjs.PIGMENT_BANDS;
+function blenderDab(medium, rect, cov, opacity, radius, settings, scratch2) {
+  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 (scratch2.sums.length < size) scratch2.sums = new Float64Array(size);
+  const I = scratch2.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 = _chunkTFOPHZ3Ucjs.pigment8.call(void 0, 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 = scratch2.mix;
+  const out = scratch2.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) _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, mixPig, mixPig, 0, out, 0);
+        else _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, _chunkTFOPHZ3Ucjs.pigment8.call(void 0, 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 = (_class7 = class {
+  constructor(settings, diameter) {;_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);
+    this.settings = settings;
+    this.size = Math.max(2, Math.min(512, Math.ceil(diameter)));
+    this.patch = new Float32Array(this.size * this.size * 4);
+  }
+  
+  
+  
+  __init27() {this.loaded = false}
+  __init28() {this.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") {
+      _chunkTFOPHZ3Ucjs.mixPigment8.call(void 0, 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;
+        }
+      }
+    }
+  }
+}, _class7);
+
+// src/paint/pigment-tools.ts
+var HEX = /^#?([0-9a-f]{6})$/i;
+function parseHex(value, index) {
+  const m = typeof value === "string" ? HEX.exec(value.trim()) : null;
+  if (!m) throw new Error(`colors[${index}].color is ${JSON.stringify(value)}; use #rrggbb, e.g. "#1e40af".`);
+  const n = parseInt(m[1], 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function toHex(rgb) {
+  return "#" + rgb.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("");
+}
+function createPigmentTools() {
+  const mixColors = {
+    name: "mix_colors",
+    title: "Mix colours like paint",
+    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: {
+        colors: {
+          type: "array",
+          minItems: 1,
+          maxItems: 16,
+          description: "The paints to mix (1 to 16).",
+          items: {
+            type: "object",
+            properties: {
+              color: { type: "string", description: "Paint colour #rrggbb." },
+              weight: { type: "number", minimum: 0, description: "Parts of this paint, any scale (e.g. 1 and 3 for a 1:3 mix). At least one weight must be above 0." },
+              strength: {
+                type: "number",
+                exclusiveMinimum: 0,
+                maximum: 100,
+                description: "Tinting strength (default 1): each part counts as this many, so a strong dark paint (e.g. 4) tints a lot of white."
+              }
+            },
+            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"],
+      additionalProperties: false
+    },
+    annotations: { title: "Mix colours like paint", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: (args) => {
+      const items = args.colors;
+      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((rgb2, i) => _chunkTFOPHZ3Ucjs.createPigment.call(void 0, rgb2, { strength: items[i].strength }));
+      const mixed = _chunkTFOPHZ3Ucjs.mixPigments.call(void 0, pigments, items.map((item) => item.weight));
+      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(rgb ? lerp : mixed),
+        rgbLerp: toHex(lerp),
+        pigment: toHex(mixed),
+        weights: items.map((item) => item.weight / total),
+        model: rgb ? "rgb" : "kubelka-munk"
+      };
+    }
+  };
+  return [mixColors];
+}
+
+// src/paint/wet/model.ts
+var WET_TILE = 256;
+var SLOT_SIDE = 258;
+var PLANE = SLOT_SIDE * SLOT_SIDE;
+var PLANE_BYTES = PLANE * 4;
+var SET_PLANES = 18;
+var P_RHO = 9;
+var P_UX = 10;
+var P_UY = 11;
+var P_SW = 12;
+var P_P0 = 13;
+var P_EDGE = 17;
+var P_D0 = 2 * SET_PLANES;
+var P_H = P_D0 + 4;
+var P_FX = P_H + 1;
+var P_FY = P_H + 2;
+var SLOT_PLANES = P_FY + 1;
+var SLOT_BYTES = SLOT_PLANES * PLANE_BYTES;
+var PIGMENT_CHANNELS = 4;
+var EX = [0, 1, 0, -1, 0, 1, -1, -1, 1];
+var EY = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+var OPP = [0, 3, 4, 1, 2, 7, 8, 5, 6];
+var W9 = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+var DRY_EPS = 1e-3;
+var U_MAX = 0.25;
+var STRIP = 64;
+var MAX_BATCH = 32;
+var FREE_INTERVAL = 32;
+var FLAG_ALIVE = 1;
+var FLAG_LEFT = 2;
+var FLAG_RIGHT = 4;
+var FLAG_TOP = 8;
+var FLAG_BOTTOM = 16;
+var FLAG_WET = 32;
+var PARAM_FLOATS = 32;
+var PARAM = {
+  omega: 0,
+  tau: 1,
+  evap: 2,
+  edgeEvap: 3,
+  // times the edge field
+  mobility: 4,
+  // half the pigment mobility (the face flux uses the sum of two velocities)
+  depRate: 5,
+  pickup: 6,
+  absorption: 7,
+  invCap: 8,
+  blockScale: 9,
+  rough: 10,
+  pinT: 11,
+  gx: 12,
+  gy: 13,
+  flowK: 14,
+  granulation: 15,
+  edgeDep: 16,
+  // times the edge field
+  bloom: 17,
+  paperEvap: 18,
+  hasFlow: 19,
+  bleed: 20
+};
+var DEFAULT_WET_PARAMS = {
+  viscosity: 0.3,
+  evaporation: 0.45,
+  edgeDarkening: 0.5,
+  pigmentWeight: 0.3,
+  granulation: 0.4,
+  pickup: 0.2,
+  fixture: 0.2,
+  bloom: 0.4,
+  bleed: 0.3
+};
+var WET_PARAM_KEYS = Object.keys(DEFAULT_WET_PARAMS);
+var DEFAULT_WET_PAPER = { absorption: 0.7, permeability: 0.5, roughness: 0.6 };
+var FLAT = { angle: 0, direction: 0 };
+var unit2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+function normalizeWetParams(raw = {}, base = DEFAULT_WET_PARAMS) {
+  const out = {};
+  for (const k of WET_PARAM_KEYS) out[k] = unit2(raw[k], base[k]);
+  return out;
+}
+function normalizeTilt(raw = {}, base = FLAT) {
+  const angle = typeof raw.angle === "number" && Number.isFinite(raw.angle) ? Math.min(90, Math.max(0, raw.angle)) : base.angle;
+  let direction = typeof raw.direction === "number" && Number.isFinite(raw.direction) ? raw.direction : base.direction;
+  direction = (direction % 360 + 360) % 360;
+  return { angle, direction };
+}
+function latticeViscosity(v) {
+  return 0.02 * Math.pow(75, v);
+}
+var PAPER_CAPACITY = 0.08;
+var MAX_TILT_ACCEL = 0.025;
+function packWetParams(params, paper, tilt, flowStrength, out = new Float32Array(PARAM_FLOATS)) {
+  const nu = latticeViscosity(params.viscosity);
+  const tau = 3 * nu + 0.5;
+  const g = MAX_TILT_ACCEL * Math.sin(tilt.angle * Math.PI / 180);
+  const dir = tilt.direction * Math.PI / 180;
+  out.fill(0);
+  out[PARAM.omega] = 1 / tau;
+  out[PARAM.tau] = tau;
+  out[PARAM.evap] = 1e-3 * params.evaporation * params.evaporation;
+  out[PARAM.edgeEvap] = params.edgeDarkening * 12;
+  out[PARAM.mobility] = 0.5 * (1 - 0.5 * params.pigmentWeight);
+  out[PARAM.depRate] = 0.019 * params.fixture * (0.5 + params.pigmentWeight);
+  out[PARAM.pickup] = 0.01 * params.pickup;
+  out[PARAM.absorption] = 15e-4 * paper.absorption;
+  out[PARAM.invCap] = 1 / PAPER_CAPACITY;
+  out[PARAM.blockScale] = 0.05 * (1 - paper.permeability);
+  out[PARAM.rough] = 0.15 * paper.roughness;
+  out[PARAM.pinT] = 0.2;
+  out[PARAM.gx] = -g * Math.sin(dir);
+  out[PARAM.gy] = g * Math.cos(dir);
+  out[PARAM.flowK] = flowStrength;
+  out[PARAM.granulation] = 1.2 * params.granulation * paper.roughness;
+  out[PARAM.edgeDep] = params.edgeDarkening * 3;
+  out[PARAM.bloom] = 60 * params.bloom;
+  out[PARAM.paperEvap] = 5e-4 * params.evaporation * params.evaporation;
+  out[PARAM.hasFlow] = flowStrength !== 0 ? 1 : 0;
+  out[PARAM.bleed] = 0.05 * params.bleed;
+  return out;
+}
+function edgeBits(lx, ly) {
+  let b = 0;
+  if (lx < STRIP) b |= FLAG_LEFT;
+  if (lx >= WET_TILE - STRIP) b |= FLAG_RIGHT;
+  if (ly < STRIP) b |= FLAG_TOP;
+  if (ly >= WET_TILE - STRIP) b |= FLAG_BOTTOM;
+  return b;
+}
+
+// src/paint/wet/film.ts
+var PIGMENT_UNIT = 0.25;
+var HIDE = 1.5;
+var BODY_SCATTER = 3;
+var R_MIN = 1e-3;
+var f64 = new Float64Array(1);
+var u32 = new Uint32Array(f64.buffer);
+var LITTLE = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+var HI = LITTLE ? 1 : 0;
+var LN2 = 0.6931471805599453;
+function pow2(k) {
+  u32[HI] = k + 1023 << 20;
+  u32[1 - HI] = 0;
+  return f64[0];
+}
+function dexp(x) {
+  if (!(x > -700)) return x !== x ? x : 0;
+  if (x > 700) return Infinity;
+  const k = Math.round(x / LN2);
+  const r = x - k * LN2;
+  let p = 1 / 39916800;
+  p = p * r + 1 / 3628800;
+  p = p * r + 1 / 362880;
+  p = p * r + 1 / 40320;
+  p = p * r + 1 / 5040;
+  p = p * r + 1 / 720;
+  p = p * r + 1 / 120;
+  p = p * r + 1 / 24;
+  p = p * r + 1 / 6;
+  p = p * r + 0.5;
+  p = p * r + 1;
+  p = p * r + 1;
+  return p * pow2(k);
+}
+function dlog(x) {
+  if (!(x > 0)) return x === 0 ? -Infinity : NaN;
+  f64[0] = x;
+  let e = (u32[HI] >>> 20 & 2047) - 1023;
+  if (e === -1023) {
+    return dlog(x * 18014398509481984) - 54 * LN2;
+  }
+  u32[HI] = u32[HI] & 2148532223 | 1023 << 20;
+  let m = f64[0];
+  if (m > 1.4142135623730951) {
+    m /= 2;
+    e += 1;
+  }
+  const s = (m - 1) / (m + 1);
+  const s2 = s * s;
+  let t = s2;
+  let sum = 1;
+  for (let i = 3; i < 40; i += 2) {
+    sum += t / i;
+    t *= s2;
+  }
+  return 2 * s * sum + e * LN2;
+}
+function dpow(x, y) {
+  if (x <= 0) return 0;
+  return dexp(y * dlog(x));
+}
+var SRGB_TO_LINEAR = new Float64Array(256);
+for (let i = 0; i < 256; i++) {
+  const v = i / 255;
+  SRGB_TO_LINEAR[i] = v <= 0.04045 ? v / 12.92 : dpow((v + 0.055) / 1.055, 2.4);
+}
+function srgbByteToLinear(v) {
+  if (!(v > 0)) return 0;
+  if (v >= 255) return 1;
+  const i = Math.floor(v);
+  return SRGB_TO_LINEAR[i] + (SRGB_TO_LINEAR[i + 1] - SRGB_TO_LINEAR[i]) * (v - i);
+}
+var ENC_STEPS = 16384;
+var ENCODE = new Uint8Array(ENC_STEPS + 1);
+for (let i = 0; i <= ENC_STEPS; i++) {
+  const v = i / ENC_STEPS;
+  const e = v <= 31308e-7 ? 12.92 * v : 1.055 * dpow(v, 1 / 2.4) - 0.055;
+  ENCODE[i] = Math.min(255, Math.max(0, Math.round(e * 255)));
+}
+function linearToSrgb8(v) {
+  if (!(v > 0)) return 0;
+  if (v >= 1) return 255;
+  return ENCODE[Math.round(v * ENC_STEPS)];
+}
+function pigmentOf(rgb, body, out = new Float64Array(4)) {
+  const b = Math.min(1, Math.max(0, body));
+  const s = b * BODY_SCATTER / PIGMENT_UNIT;
+  for (let c = 0; c < 3; c++) {
+    const v = Math.min(255, Math.max(0, Math.round(rgb[c] * 255)));
+    const r = Math.max(R_MIN, SRGB_TO_LINEAR[v]);
+    const kt = -dlog(r) / 2 / PIGMENT_UNIT;
+    const ko = (1 - r) * (1 - r) / (2 * r) * s;
+    out[c] = (1 - b) * kt + b * ko;
+  }
+  out[3] = s;
+  return out;
+}
+var EXP_RES = 256;
+var EXP_MAX = 24;
+var EXP_TABLE = new Float64Array(EXP_MAX * EXP_RES + 2);
+for (let i = 0; i < EXP_TABLE.length; i++) EXP_TABLE[i] = dexp(-i / EXP_RES);
+function expNeg(x) {
+  if (!(x > 0)) return 1;
+  if (x >= EXP_MAX) return 0;
+  const t = x * EXP_RES;
+  const i = Math.floor(t);
+  const fr = t - i;
+  return EXP_TABLE[i] + (EXP_TABLE[i + 1] - EXP_TABLE[i]) * fr;
+}
+function filmReflectance(k0, k1, k2, s, b0, b1, b2, out) {
+  const hide = s > 0 ? 1 - expNeg(HIDE * s) : 0;
+  const keep = 1 - hide;
+  const inv = s > 1e-9 ? 1 / s : 0;
+  out[0] = (hide > 0 ? hide * rinf(k0 * inv) : 0) + keep * expNeg(2 * k0) * b0;
+  out[1] = (hide > 0 ? hide * rinf(k1 * inv) : 0) + keep * expNeg(2 * k1) * b1;
+  out[2] = (hide > 0 ? hide * rinf(k2 * inv) : 0) + keep * expNeg(2 * k2) * b2;
+}
+function rinf(ks) {
+  return 1 + ks - Math.sqrt(ks * ks + 2 * ks);
+}
+function pigmentColor(k0, k1, k2, s, out = [0, 0, 0]) {
+  const lin = [0, 0, 0];
+  filmReflectance(k0, k1, k2, s, 1, 1, 1, lin);
+  for (let c = 0; c < 3; c++) out[c] = linearToSrgb8(lin[c]) / 255;
+  return out;
+}
+var scratch = new Float64Array(3);
+function filmPixel(k0, k1, k2, s, px, i, paper, wet, out, o) {
+  const pa = px[i + 3];
+  if (!(k0 > 1e-7 || k1 > 1e-7 || k2 > 1e-7 || s > 1e-7) && wet <= 0) {
+    out[o] = px[i];
+    out[o + 1] = px[i + 1];
+    out[o + 2] = px[i + 2];
+    out[o + 3] = pa;
+    return;
+  }
+  const a = pa / 255;
+  const p0 = paper[0];
+  const p1 = paper[1];
+  const p2 = paper[2];
+  const b0 = srgbByteToLinear(a * px[i] + (1 - a) * p0);
+  const b1 = srgbByteToLinear(a * px[i + 1] + (1 - a) * p1);
+  const b2 = srgbByteToLinear(a * px[i + 2] + (1 - a) * p2);
+  filmReflectance(k0, k1, k2, s, b0, b1, b2, scratch);
+  const dark = 1 - 0.07 * wet;
+  const e0 = linearToSrgb8(scratch[0] * dark);
+  const e1 = linearToSrgb8(scratch[1] * dark);
+  const e2 = linearToSrgb8(scratch[2] * dark);
+  let alpha = a;
+  alpha = needAlpha(e0, p0, alpha);
+  alpha = needAlpha(e1, p1, alpha);
+  alpha = needAlpha(e2, p2, alpha);
+  if (alpha <= 0) {
+    out[o] = px[i];
+    out[o + 1] = px[i + 1];
+    out[o + 2] = px[i + 2];
+    out[o + 3] = 0;
+    return;
+  }
+  const a8 = Math.max(Math.round(Math.min(1, alpha) * 255), pa);
+  const al = a8 / 255;
+  const inv = 1 / al;
+  const k = 1 - al;
+  out[o] = Math.round(Math.min(255, Math.max(0, (e0 - k * p0) * inv)));
+  out[o + 1] = Math.round(Math.min(255, Math.max(0, (e1 - k * p1) * inv)));
+  out[o + 2] = Math.round(Math.min(255, Math.max(0, (e2 - k * p2) * inv)));
+  out[o + 3] = a8;
+}
+function needAlpha(e, p, alpha) {
+  if (e < p) return Math.max(alpha, 1 - e / p);
+  if (e > p) return Math.max(alpha, (e - p) / (255 - p));
+  return alpha;
+}
+function pixelPigment(px, i, paper, out) {
+  const a = px[i + 3] / 255;
+  for (let c = 0; c < 3; c++) {
+    const p = Math.max(R_MIN, SRGB_TO_LINEAR[paper[c]]);
+    const below = Math.max(R_MIN, srgbByteToLinear(a * px[i + c] + (1 - a) * paper[c]));
+    out[c] = below < p ? -dlog(below / p) / 2 : 0;
+  }
+  out[3] = 0;
+}
+function shadeTile(f, plane, side, d, p, rho, sw, src, out, w, h, paper) {
+  const p0 = paper[0];
+  const p1 = paper[1];
+  const p2 = paper[2];
+  const lp0 = SRGB_TO_LINEAR[p0];
+  const lp1 = SRGB_TO_LINEAR[p1];
+  const lp2 = SRGB_TO_LINEAR[p2];
+  const tab = EXP_TABLE;
+  const enc = ENCODE;
+  let any = false;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const c = (y + 1) * side + x + 1;
+      let k0 = f[d + c];
+      let k1 = f[d + plane + c];
+      let k2 = f[d + 2 * plane + c];
+      let s = f[d + 3 * plane + c];
+      if (p >= 0) {
+        k0 += f[p + c];
+        k1 += f[p + plane + c];
+        k2 += f[p + 2 * plane + c];
+        s += f[p + 3 * plane + c];
+      }
+      let wet = 0;
+      if (rho >= 0) {
+        wet = f[rho + c] * 4 + f[sw + c];
+        if (wet > 1) wet = 1;
+      }
+      if (!(k0 > 1e-7 || k1 > 1e-7 || k2 > 1e-7 || s > 1e-7) && wet <= 0) continue;
+      any = true;
+      const i = (y * 256 + x) * 4;
+      const pa = src ? src[i + 3] : 0;
+      const a = pa / 255;
+      const na = 1 - a;
+      const b0 = src ? srgbByteToLinear(a * src[i] + na * p0) : lp0;
+      const b1 = src ? srgbByteToLinear(a * src[i + 1] + na * p1) : lp1;
+      const b2 = src ? srgbByteToLinear(a * src[i + 2] + na * p2) : lp2;
+      let hide = 0;
+      let x0;
+      if (s > 0) {
+        x0 = HIDE * s;
+        hide = 1 - (x0 >= EXP_MAX ? 0 : interp(tab, x0 * EXP_RES));
+      }
+      const keep = 1 - hide;
+      const inv = s > 1e-9 ? 1 / s : 0;
+      let r0 = keep * expT(tab, 2 * k0) * b0;
+      let r1 = keep * expT(tab, 2 * k1) * b1;
+      let r2 = keep * expT(tab, 2 * k2) * b2;
+      if (hide > 0) {
+        r0 += hide * rinf(k0 * inv);
+        r1 += hide * rinf(k1 * inv);
+        r2 += hide * rinf(k2 * inv);
+      }
+      const dark = 1 - 0.07 * wet;
+      const e0 = encode(enc, r0 * dark);
+      const e1 = encode(enc, r1 * dark);
+      const e2 = encode(enc, r2 * dark);
+      let alpha = a;
+      alpha = needAlpha(e0, p0, alpha);
+      alpha = needAlpha(e1, p1, alpha);
+      alpha = needAlpha(e2, p2, alpha);
+      if (alpha <= 0) {
+        out[i + 3] = 0;
+        continue;
+      }
+      const a8 = Math.max(Math.round(Math.min(1, alpha) * 255), pa);
+      const al = a8 / 255;
+      const ia = 1 / al;
+      const k = 1 - al;
+      out[i] = Math.round(Math.min(255, Math.max(0, (e0 - k * p0) * ia)));
+      out[i + 1] = Math.round(Math.min(255, Math.max(0, (e1 - k * p1) * ia)));
+      out[i + 2] = Math.round(Math.min(255, Math.max(0, (e2 - k * p2) * ia)));
+      out[i + 3] = a8;
+    }
+  }
+  return any;
+}
+function interp(tab, t) {
+  const i = Math.floor(t);
+  return tab[i] + (tab[i + 1] - tab[i]) * (t - i);
+}
+function expT(tab, x) {
+  if (!(x > 0)) return 1;
+  if (x >= EXP_MAX) return 0;
+  return interp(tab, x * EXP_RES);
+}
+function encode(enc, v) {
+  if (!(v > 0)) return 0;
+  if (v >= 1) return 255;
+  return enc[Math.round(v * ENC_STEPS)];
+}
+
+// src/paint/wet/kernel.ts
+var F = Math.fround;
+var S = SLOT_SIDE;
+var EPS = F(DRY_EPS);
+var UMAX2 = F(U_MAX * U_MAX);
+var UMAXF = F(U_MAX);
+var W0 = F(4 / 9);
+var W1 = F(1 / 9);
+var W2 = F(1 / 36);
+var TINY = F(1e-9);
+var DECAY = F(0.99);
+var NB = [0, -1, -S, 1, S, -S - 1, -S + 1, S + 1, S - 1];
+var OPP2 = [0, 3, 4, 1, 2, 7, 8, 5, 6];
+var fin = new Float32Array(9);
+var pNew = new Float32Array(4);
+function stepSlotTs(f, base, parity, prm) {
+  const src = base + parity * SET_PLANES * PLANE;
+  const dst = base + (1 - parity) * SET_PLANES * PLANE;
+  const hP = base + P_H * PLANE;
+  const dP = base + P_D0 * PLANE;
+  const rhoS = src + P_RHO * PLANE;
+  const uxS = src + P_UX * PLANE;
+  const uyS = src + P_UY * PLANE;
+  const swS = src + P_SW * PLANE;
+  const pS = src + P_P0 * PLANE;
+  const eS = src + P_EDGE * PLANE;
+  const omega = prm[PARAM.omega];
+  const tau = prm[PARAM.tau];
+  const evap = prm[PARAM.evap];
+  const edgeEvap = prm[PARAM.edgeEvap];
+  const mobility = prm[PARAM.mobility];
+  const depRate = prm[PARAM.depRate];
+  const pickup = prm[PARAM.pickup];
+  const absorption = prm[PARAM.absorption];
+  const invCap = prm[PARAM.invCap];
+  const blockScale = prm[PARAM.blockScale];
+  const rough = prm[PARAM.rough];
+  const pinT = prm[PARAM.pinT];
+  const gx0 = prm[PARAM.gx];
+  const gy0 = prm[PARAM.gy];
+  const flowK = prm[PARAM.flowK];
+  const gran = prm[PARAM.granulation];
+  const edgeDep = prm[PARAM.edgeDep];
+  const bloom = prm[PARAM.bloom];
+  const paperEvap = prm[PARAM.paperEvap];
+  const hasFlow = prm[PARAM.hasFlow] !== 0;
+  const bleed = prm[PARAM.bleed];
+  let flags = 0;
+  for (let y = 1; y <= 256; y++) {
+    for (let x = 1; x <= 256; x++) {
+      const c = y * S + x;
+      const hx = f[hP + c];
+      const kx = F(blockScale * hx);
+      const rx = f[rhoS + c];
+      const sx = f[swS + c];
+      const damp = Math.max(0, F(1 - F(sx * invCap)));
+      const pinX = F(F(pinT + F(rough * hx)) * damp);
+      const rxDry = rx < EPS;
+      const xWall = hx < 0;
+      fin[0] = f[src + c];
+      let dryNb = 0;
+      for (let k = 1; k <= 8; k++) {
+        const n = c + NB[k];
+        const hn = f[hP + n];
+        const rn = f[rhoS + n];
+        const sn = f[swS + n];
+        const wall = hn < 0;
+        const rnDry = rn < EPS;
+        const dampN = Math.max(0, F(1 - F(sn * invCap)));
+        if (rnDry && !wall) dryNb = F(dryNb + dampN);
+        let b = Math.max(kx, F(blockScale * hn));
+        const pinN = F(F(pinT + F(rough * hn)) * dampN);
+        if (wall || xWall || rxDry && rn < pinX || rnDry && rx < pinN) b = 1;
+        fin[k] = F(F(F(1 - b) * f[src + k * PLANE + n]) + F(b * f[src + OPP2[k] * PLANE + c]));
+      }
+      const rho = F(F(F(F(F(F(F(F(fin[0] + fin[1]) + fin[2]) + fin[3]) + fin[4]) + fin[5]) + fin[6]) + fin[7]) + fin[8]);
+      const mx = F(F(F(F(F(fin[1] - fin[3]) + fin[5]) - fin[6]) - fin[7]) + fin[8]);
+      const my = F(F(F(F(F(fin[2] - fin[4]) + fin[5]) + fin[6]) - fin[7]) - fin[8]);
+      let gx = gx0;
+      let gy = gy0;
+      if (hasFlow) {
+        gx = F(gx + F(flowK * f[base + P_FX * PLANE + c]));
+        gy = F(gy + F(flowK * f[base + P_FY * PLANE + c]));
+      }
+      let ux = 0;
+      let uy = 0;
+      if (rho > EPS) {
+        ux = F(F(mx / rho) + F(tau * gx));
+        uy = F(F(my / rho) + F(tau * gy));
+      }
+      const sp2 = F(F(ux * ux) + F(uy * uy));
+      if (sp2 > UMAX2) {
+        const sc = F(UMAXF / F(Math.sqrt(sp2)));
+        ux = F(ux * sc);
+        uy = F(uy * sc);
+      }
+      const absorbed = Math.min(rho, F(F(F(absorption * F(1 - F(0.5 * hx))) * rho) * damp));
+      const ex = f[eS + c];
+      const ev = rho > 0 ? F(evap * F(1 + F(edgeEvap * ex))) : 0;
+      const rhoNew = Math.max(0, F(F(rho - absorbed) - ev));
+      const scale = rho > TINY ? F(rhoNew / rho) : 0;
+      const sNew = Math.max(0, F(F(sx + absorbed) - (sx > 0 ? paperEvap : 0)));
+      f[dst + P_SW * PLANE + c] = sNew;
+      const usq = F(1.5 * F(F(ux * ux) + F(uy * uy)));
+      const wr0 = F(W0 * rho);
+      const wr1 = F(W1 * rho);
+      const wr2 = F(W2 * rho);
+      let feq = F(wr0 * F(1 - usq));
+      f[dst + c] = F(F(fin[0] + F(omega * F(feq - fin[0]))) * scale);
+      for (let k = 1; k <= 8; k++) {
+        let eu;
+        let wr = wr1;
+        switch (k) {
+          case 1:
+            eu = ux;
+            break;
+          case 2:
+            eu = uy;
+            break;
+          case 3:
+            eu = -ux;
+            break;
+          case 4:
+            eu = -uy;
+            break;
+          case 5:
+            eu = F(ux + uy);
+            wr = wr2;
+            break;
+          case 6:
+            eu = F(uy - ux);
+            wr = wr2;
+            break;
+          case 7:
+            eu = -F(ux + uy);
+            wr = wr2;
+            break;
+          default:
+            eu = F(ux - uy);
+            wr = wr2;
+            break;
+        }
+        feq = F(wr * F(F(F(1 + F(3 * eu)) + F(F(4.5 * eu) * eu)) - usq));
+        f[dst + k * PLANE + c] = F(F(fin[k] + F(omega * F(feq - fin[k]))) * scale);
+      }
+      const rxWet = !rxDry;
+      const uxc = f[uxS + c];
+      const uyc = f[uyS + c];
+      for (let q = 0; q < 4; q++) pNew[q] = f[pS + q * PLANE + c];
+      for (let face = 0; face < 4; face++) {
+        const nb = c + (face === 0 ? 1 : face === 1 ? -1 : face === 2 ? S : -S);
+        const open = rxWet && f[rhoS + nb] >= EPS;
+        const uf = face === 0 ? F(mobility * F(uxc + f[uxS + nb])) : face === 1 ? F(mobility * F(f[uxS + nb] + uxc)) : face === 2 ? F(mobility * F(uyc + f[uyS + nb])) : F(mobility * F(f[uyS + nb] + uyc));
+        const out = face === 0 || face === 2;
+        for (let q = 0; q < 4; q++) {
+          const pc = f[pS + q * PLANE + c];
+          const pn = f[pS + q * PLANE + nb];
+          const flux = out ? uf > 0 ? F(uf * pc) : F(uf * pn) : uf > 0 ? F(uf * pn) : F(uf * pc);
+          const diff = F(bleed * F(pn - pc));
+          const v = out ? F(F(pNew[q] - flux) + diff) : F(F(pNew[q] + flux) + diff);
+          pNew[q] = open ? v : pNew[q];
+        }
+      }
+      const dryNow = rhoNew < EPS;
+      const rate = F(F(depRate * F(1 + F(gran * F(1 - hx)))) * F(1 + F(edgeDep * ex)));
+      const lift = dryNow ? 0 : F(F(pickup * Math.min(rhoNew, 1)) * F(1 + F(bloom * Math.max(0, F(rhoNew - rx)))));
+      for (let q = 0; q < 4; q++) {
+        const pq = Math.max(0, pNew[q]);
+        const dq = f[dP + q * PLANE + c];
+        const dep = dryNow ? pq : Math.min(pq, F(pq * rate));
+        const lq = F(dq * lift);
+        f[dst + (P_P0 + q) * PLANE + c] = F(F(pq - dep) + lq);
+        f[dP + q * PLANE + c] = F(F(dq + dep) - lq);
+      }
+      const mean4 = F(F(F(F(f[eS + c + 1] + f[eS + c - 1]) + f[eS + c + S]) + f[eS + c - S]) * 0.25);
+      const eNew = Math.min(1, Math.max(Math.min(1, F(dryNb * 0.25)), F(DECAY * mean4)));
+      f[dst + P_EDGE * PLANE + c] = dryNow ? 0 : eNew;
+      f[dst + P_RHO * PLANE + c] = rhoNew;
+      f[dst + P_UX * PLANE + c] = dryNow ? 0 : ux;
+      f[dst + P_UY * PLANE + c] = dryNow ? 0 : uy;
+      const alive = rhoNew > 0 || sNew > 0;
+      if (alive) flags |= FLAG_ALIVE | edgeBits(x - 1, y - 1);
+      if (!dryNow) flags |= FLAG_WET;
+    }
+  }
+  return flags;
+}
+
+// src/paint/wet/wasm.ts
+var modules = {};
+function decode(base64) {
+  const g = globalThis;
+  if (g.Buffer) return new Uint8Array(g.Buffer.from(base64, "base64"));
+  const bin = g.atob(base64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function loadWetKernel(shared) {
+  const key = shared ? "shared" : "single";
+  let p = modules[key];
+  if (!p) {
+    p = Promise.resolve().then(() => _interopRequireWildcard(require("./kernel-wasm-YPVAEMVN.cjs"))).then((m) => WebAssembly.compile(decode(shared ? m.WET_KERNEL_SHARED : m.WET_KERNEL_SINGLE)));
+    p.catch(() => {
+      modules = { ...modules, [key]: void 0 };
+    });
+    modules[key] = p;
+  }
+  return p;
+}
+function canShareMemory() {
+  const g = globalThis;
+  if (typeof g.SharedArrayBuffer !== "function") return false;
+  if (g.crossOriginIsolated === false) return false;
+  try {
+    new WebAssembly.Memory({ initial: 1, maximum: 1, shared: true });
+    return true;
+  } catch (e3) {
+    return false;
+  }
+}
+var simdCache = null;
+async function wetSimdSupported() {
+  if (simdCache !== null) return simdCache;
+  if (typeof WebAssembly === "undefined") return simdCache = false;
+  try {
+    await loadWetKernel(false);
+    simdCache = true;
+  } catch (e4) {
+    simdCache = false;
+  }
+  return simdCache;
+}
+function wetSupport(simd = _nullishCoalesce(simdCache, () => ( typeof WebAssembly !== "undefined"))) {
+  const g = globalThis;
+  const sharedMemory = canShareMemory();
+  const workers = typeof g.Worker === "function" && typeof Blob === "function" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function";
+  const cores = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([g, 'access', _7 => _7.navigator, 'optionalAccess', _8 => _8.hardwareConcurrency]), () => ( 1))));
+  let message = null;
+  if (!simd) message = "This browser has no WebAssembly SIMD, so wet paint runs in plain JavaScript: it flows much more slowly (the results are the same).";
+  else if (workers && !sharedMemory)
+    message = 'Wet paint runs on one thread because this page is not cross-origin isolated, so it flows more slowly. Serve the page with "Cross-Origin-Opener-Policy: same-origin" and "Cross-Origin-Embedder-Policy: require-corp" (or "credentialless") to use every core.';
+  return { simd, sharedMemory, workers, cores, message };
+}
+function wetWorkerMain() {
+  const scope = self;
+  let exports = null;
+  let memory = null;
+  let L = null;
+  let id = 0;
+  function barrier(ctl, n) {
+    const gen = Atomics.load(ctl, 1);
+    if (Atomics.add(ctl, 0, 1) === n - 1) {
+      Atomics.store(ctl, 0, 0);
+      Atomics.add(ctl, 1, 1);
+      Atomics.notify(ctl, 1);
+    } else {
+      while (Atomics.load(ctl, 1) === gen) Atomics.wait(ctl, 1, gen);
+    }
+  }
+  function run(steps, n) {
+    const ex = exports;
+    const l = L;
+    const buf = memory.buffer;
+    const ctl = new Int32Array(buf, l.ctl, 16);
+    const table = new Int32Array(buf, l.table, l.keys);
+    const list = new Int32Array(buf, l.list, l.keys);
+    const flags = new Uint32Array(buf, l.flags, l.keys);
+    const last = new Uint32Array(buf, l.last, l.keys);
+    const count = ctl[4];
+    let parity = ctl[5];
+    for (let s = 0; s < steps; s++) {
+      for (; ; ) {
+        const a = Atomics.add(ctl, 2, 1);
+        if (a >= count) break;
+        const key = list[a];
+        const lane = key / l.perLane | 0;
+        const f = ex.step(l.slots + table[key] * l.slotBytes, parity, l.params + lane * 128);
+        flags[key] |= f;
+        last[key] = f;
+      }
+      if (id === 0) Atomics.store(ctl, 3, 0);
+      barrier(ctl, n);
+      for (; ; ) {
+        const a = Atomics.add(ctl, 3, 1);
+        if (a >= count) break;
+        ex.halo(l.table, l.slots, list[a], l.perLane, l.tilesX, l.tilesY, 1 - parity);
+      }
+      if (id === 0) Atomics.store(ctl, 2, 0);
+      barrier(ctl, n);
+      parity = 1 - parity;
+    }
+  }
+  scope.onmessage = (e) => {
+    const m = e.data;
+    if (m.type === "init") {
+      memory = m.memory;
+      L = m.layout;
+      id = m.id;
+      WebAssembly.instantiate(m.module, { env: { memory } }).then(
+        (inst) => {
+          exports = inst.exports;
+          scope.postMessage({ type: "ready", id });
+        },
+        (err) => scope.postMessage({ type: "error", id, message: String(err) })
+      );
+    } else if (m.type === "layout") {
+      L = m.layout;
+    } else if (m.type === "run") {
+      try {
+        run(m.steps, m.workers);
+        scope.postMessage({ type: "done", id });
+      } catch (err) {
+        scope.postMessage({ type: "error", id, message: String(err) });
+      }
+    }
+  };
+}
+var WetWorkerPool = class _WetWorkerPool {
+  constructor(workers, url) {
+    this.workers = workers;
+    this.url = url;
+  }
+  
+  
+  get size() {
+    return this.workers.length;
+  }
+  /** Starts `count` workers on `memory` (shared) with the shared kernel. Rejects if any fails. */
+  static async create(count, module, memory, layout) {
+    const source = `(${wetWorkerMain.toString()})();`;
+    const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+    const workers = [];
+    try {
+      const ready = [];
+      for (let i = 0; i < count; i++) {
+        const w = new Worker(url);
+        workers.push(w);
+        ready.push(
+          new Promise((resolve, reject) => {
+            w.onmessage = (e) => {
+              if (_optionalChain([e, 'access', _9 => _9.data, 'optionalAccess', _10 => _10.type]) === "ready") resolve();
+              else if (_optionalChain([e, 'access', _11 => _11.data, 'optionalAccess', _12 => _12.type]) === "error") reject(new Error(e.data.message));
+            };
+            w.onerror = (e) => reject(new Error(e.message || "The wet-media worker failed to start."));
+          })
+        );
+        w.postMessage({ type: "init", module, memory, layout, id: i });
+      }
+      await Promise.all(ready);
+    } catch (e) {
+      for (const w of workers) w.terminate();
+      URL.revokeObjectURL(url);
+      throw e;
+    }
+    return new _WetWorkerPool(workers, url);
+  }
+  /** Runs `steps` steps over the active list in shared memory; resolves when every worker is done. */
+  run(steps) {
+    const n = this.workers.length;
+    return Promise.all(
+      this.workers.map(
+        (w, i) => new Promise((resolve, reject) => {
+          w.onmessage = (e) => {
+            if (_optionalChain([e, 'access', _13 => _13.data, 'optionalAccess', _14 => _14.type]) === "done") resolve();
+            else if (_optionalChain([e, 'access', _15 => _15.data, 'optionalAccess', _16 => _16.type]) === "error") reject(new Error(e.data.message));
+          };
+          w.postMessage({ type: "run", steps, workers: n, id: i });
+        })
+      )
+    ).then(() => void 0);
+  }
+  destroy() {
+    for (const w of this.workers) w.terminate();
+    URL.revokeObjectURL(this.url);
+  }
+};
+
+// src/paint/wet/world.ts
+var MAX_WET_LANES = 8;
+var MAX_WET_SLOTS = 352;
+var SLOT_FLOATS = SLOT_PLANES * PLANE;
+var S2 = SLOT_SIDE;
+var SNAP_PLANES = SET_PLANES + 4;
+var WetWorldError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WetWorldError";
+  }
+};
+function makeLayout(width, height) {
+  const tilesX = Math.ceil(width / WET_TILE);
+  const tilesY = Math.ceil(height / WET_TILE);
+  const perLane = tilesX * tilesY;
+  const keys = perLane * MAX_WET_LANES;
+  const ctl = 0;
+  const params = 1024;
+  const table = params + MAX_WET_LANES * PARAM_FLOATS * 4;
+  const list = table + keys * 4;
+  const flags = list + keys * 4;
+  const last = flags + keys * 4;
+  const slots = Math.ceil((last + keys * 4) / 65536) * 65536;
+  return { width, height, tilesX, tilesY, perLane, keys, ctl, params, table, list, flags, last, slots, slotBytes: SLOT_BYTES };
+}
+function quantizeHeight(v) {
+  return Math.round(Math.min(1, Math.max(0, v)) * 65536) / 65536;
+}
+var WetWorld = (_class8 = class {
+  
+  
+  
+  /** Steps simulated so far. */
+  __init29() {this.clock = 0}
+  /** Messages for the user (slots ran out, a backend failed). */
+  __init30() {this.warnings = []}
+  
+  
+  
+  
+  
+  __init31() {this.slotCount = 0}
+  __init32() {this.freeSlots = []}
+  __init33() {this.active = []}
+  __init34() {this.parity = 0}
+  __init35() {this.lanes = new Array(MAX_WET_LANES).fill(null)}
+  __init36() {this.tilt = { ...FLAT }}
+  
+  __init37() {this.paperBytes = new Uint8Array(3)}
+  __init38() {this.kind = "typescript"}
+  __init39() {this.wasm = null}
+  __init40() {this.pool = null}
+  __init41() {this.busyFlag = false}
+  __init42() {this.destroyed = false}
+  
+  __init43() {this.prm = new Float32Array(PARAM_FLOATS)}
+  /** Resolves when the fastest available kernel is running (it may stay `typescript`). */
+  
+  constructor(width, height, paper, options = {}) {;_class8.prototype.__init29.call(this);_class8.prototype.__init30.call(this);_class8.prototype.__init31.call(this);_class8.prototype.__init32.call(this);_class8.prototype.__init33.call(this);_class8.prototype.__init34.call(this);_class8.prototype.__init35.call(this);_class8.prototype.__init36.call(this);_class8.prototype.__init37.call(this);_class8.prototype.__init38.call(this);_class8.prototype.__init39.call(this);_class8.prototype.__init40.call(this);_class8.prototype.__init41.call(this);_class8.prototype.__init42.call(this);_class8.prototype.__init43.call(this);
+    if (!(width >= 1 && height >= 1 && width <= 16384 && height <= 16384)) throw new WetWorldError(`A wet canvas must be 1..16384 pixels per side, not ${width}\xD7${height}.`);
+    this.width = Math.round(width);
+    this.height = Math.round(height);
+    this.paper = paper;
+    this.paperBytes.set(paper.color);
+    this.layout = makeLayout(this.width, this.height);
+    const wantKernel = _nullishCoalesce(options.kernel, () => ( "auto"));
+    const threads = _nullishCoalesce(options.threads, () => ( "auto"));
+    this.shared = wantKernel === "auto" && threads !== 0 && canShareMemory();
+    const pages = this.layout.slots / 65536 + Math.ceil(2 * SLOT_BYTES / 65536);
+    const maxPages = Math.min(65536, Math.ceil((this.layout.slots + MAX_WET_SLOTS * SLOT_BYTES) / 65536));
+    this.memory = this.shared ? new WebAssembly.Memory({ initial: pages, maximum: maxPages, shared: true }) : new WebAssembly.Memory({ initial: pages });
+    this.views();
+    new Int32Array(this.memory.buffer, this.layout.table, this.layout.keys).fill(-1);
+    this.support = wetSupport(true);
+    this.ready = wantKernel === "typescript" ? Promise.resolve(this.backend()) : this.start(threads);
+  }
+  // --- Backends ------------------------------------------------------------------
+  views() {
+    const buf = this.memory.buffer;
+    this.f32 = new Float32Array(buf);
+    this.i32 = new Int32Array(buf);
+    this.u32 = new Uint32Array(buf);
+  }
+  async start(threads) {
+    try {
+      const simd = await wetSimdSupported();
+      this.support = wetSupport(simd);
+      if (!simd || this.destroyed) return this.backend();
+      const module = await loadWetKernel(this.shared);
+      const inst = await WebAssembly.instantiate(module, { env: { memory: this.memory } });
+      if (this.destroyed) return this.backend();
+      this.wasm = inst.exports;
+      this.kind = "wasm";
+      const n = threads === "auto" ? Math.max(1, Math.min(10, this.support.cores - 1)) : Math.max(0, Math.floor(threads));
+      if (this.shared && this.support.workers && n >= 2) {
+        try {
+          const pool = await WetWorkerPool.create(n, module, this.memory, this.layout);
+          if (this.destroyed) pool.destroy();
+          else {
+            this.pool = pool;
+            this.kind = "wasm-threads";
+          }
+        } catch (e) {
+          this.warnings.push(`Wet paint could not start its worker threads (${e.message}); it runs on one thread.`);
+        }
+      }
+    } catch (e) {
+      this.warnings.push(`The WebAssembly wet-media kernel did not load (${e.message}); wet paint runs in plain JavaScript.`);
+    }
+    return this.backend();
+  }
+  /** The kernel in use and why it is not faster. */
+  backend() {
+    const threads = _nullishCoalesce(_optionalChain([this, 'access', _17 => _17.pool, 'optionalAccess', _18 => _18.size]), () => ( 1));
+    let message = this.support.message;
+    if (this.kind === "typescript" && !message) message = this.wasm ? null : "Wet paint runs in plain JavaScript until the WebAssembly kernel has loaded.";
+    if (this.kind === "wasm-threads") message = null;
+    return { kind: this.kind, threads, message };
+  }
+  /** Whether a batch is running (edits throw until it ends). */
+  get busy() {
+    return this.busyFlag;
+  }
+  destroy() {
+    this.destroyed = true;
+    _optionalChain([this, 'access', _19 => _19.pool, 'optionalAccess', _20 => _20.destroy, 'call', _21 => _21()]);
+    this.pool = null;
+  }
+  // --- Lanes ---------------------------------------------------------------------
+  laneOf(id) {
+    const l = this.lanes.find((x) => _optionalChain([x, 'optionalAccess', _22 => _22.id]) === id);
+    if (!l) throw new WetWorldError(`There is no wet layer "${id}".`);
+    return l;
+  }
+  hasLane(id) {
+    return this.lanes.some((x) => _optionalChain([x, 'optionalAccess', _23 => _23.id]) === id);
+  }
+  laneIds() {
+    return this.lanes.filter((l) => Boolean(l)).map((l) => l.id);
+  }
+  /** Adds a wet layer (or returns it). Throws when `MAX_WET_LANES` are in use. */
+  ensureLane(id, options = {}) {
+    this.requireIdle();
+    const existing = this.lanes.find((x) => _optionalChain([x, 'optionalAccess', _24 => _24.id]) === id);
+    if (existing) {
+      if (options.params) this.setParams(id, options.params);
+      if (options.base) this.setBase(id, options.base);
+      return;
+    }
+    const index = this.lanes.indexOf(null);
+    if (index < 0) throw new WetWorldError(`At most ${MAX_WET_LANES} layers can hold wet paint at once; dry one (dry_paint) first.`);
+    this.lanes[index] = {
+      id,
+      index,
+      params: normalizeWetParams(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS),
+      flow: _nullishCoalesce(options.flow, () => ( null)),
+      flowStrength: options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0,
+      base: _nullishCoalesce(options.base, () => ( new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(4, /* @__PURE__ */ new Map(), 0))),
+      shaded: /* @__PURE__ */ new Map(),
+      urgent: /* @__PURE__ */ new Set(),
+      stamp: 1,
+      display: null,
+      shadedVersion: 0,
+      displayKey: ""
+    };
+    this.pack(this.lanes[index]);
+  }
+  /** Drops a wet layer and its wet paint (nothing is baked). */
+  removeLane(id) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    for (const key of [...this.active]) if (this.laneIndexOf(key) === lane.index) this.free(key);
+    this.lanes[lane.index] = null;
+  }
+  getParams(id) {
+    return { ...this.laneOf(id).params };
+  }
+  setParams(id, params) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    lane.params = normalizeWetParams(params, lane.params);
+    this.pack(lane);
+    return { ...lane.params };
+  }
+  getTilt() {
+    return { ...this.tilt };
+  }
+  setTilt(tilt) {
+    this.requireIdle();
+    this.tilt = normalizeTilt(tilt, this.tilt);
+    for (const l of this.lanes) if (l) this.pack(l);
+    return { ...this.tilt };
+  }
+  /** Changes the paper: heights of live tiles are refilled, rates repacked. */
+  setPaper(paper) {
+    this.requireIdle();
+    this.paper = paper;
+    this.paperBytes.set(paper.color);
+    for (const key of this.active) this.fillPaper(key);
+    for (const l of this.lanes) {
+      if (!l) continue;
+      this.pack(l);
+      this.touchAll(l);
+    }
+    this.refreshHalos();
+  }
+  /** Sets a layer's flow map (`null` removes it). */
+  setFlow(id, flow, strength = 1) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    lane.flow = flow;
+    lane.flowStrength = flow ? strength : 0;
+    this.pack(lane);
+    for (const key of this.active) if (this.laneIndexOf(key) === lane.index) this.fillFlow(key);
+  }
+  hasFlow(id) {
+    return Boolean(this.laneOf(id).flow);
+  }
+  /** The pixels under a layer's wet paint. */
+  getBase(id) {
+    return this.laneOf(id).base;
+  }
+  /** Replaces the pixels under a layer's wet paint. */
+  setBase(id, base) {
+    const lane = this.laneOf(id);
+    if (base === lane.base) return;
+    lane.base = base;
+    lane.shaded.clear();
+    lane.shadedVersion++;
+    lane.stamp++;
+  }
+  pack(lane) {
+    packWetParams(lane.params, _nullishCoalesce(this.paper, () => ( DEFAULT_WET_PAPER)), this.tilt, lane.flowStrength, this.prm);
+    this.f32.set(this.prm, this.layout.params + lane.index * PARAM_FLOATS * 4 >> 2);
+  }
+  touchAll(lane) {
+    lane.stamp++;
+  }
+  // --- Slots ---------------------------------------------------------------------
+  laneIndexOf(key) {
+    return Math.floor(key / this.layout.perLane);
+  }
+  slotOf(key) {
+    return this.i32[(this.layout.table >> 2) + key];
+  }
+  slotBase(slot) {
+    return (this.layout.slots >> 2) + slot * SLOT_FLOATS;
+  }
+  requireIdle() {
+    if (this.busyFlag) throw new WetWorldError("The wet simulation is mid-step; wait for it (whenIdle) before changing it.");
+  }
+  /** Writes the active list into memory for the kernels. */
+  syncList() {
+    const base = this.layout.list >> 2;
+    this.active.sort((a, b) => a - b);
+    for (let i = 0; i < this.active.length; i++) this.i32[base + i] = this.active[i];
+    this.i32[(this.layout.ctl >> 2) + 4] = this.active.length;
+  }
+  grow(slots) {
+    const need = this.layout.slots + slots * SLOT_BYTES;
+    const have = this.memory.buffer.byteLength;
+    if (need <= have) return true;
+    try {
+      this.memory.grow(Math.ceil((need - have) / 65536));
+    } catch (e5) {
+      return false;
+    }
+    this.views();
+    return true;
+  }
+  /** Activates a tile of a lane. Returns false when no slot can be had. */
+  activate(key) {
+    if (this.slotOf(key) >= 0) return true;
+    let slot = this.freeSlots.pop();
+    if (slot === void 0) {
+      if (this.slotCount >= MAX_WET_SLOTS || !this.grow(this.slotCount + 1)) {
+        const msg = `Wet paint reached its memory limit (${MAX_WET_SLOTS} tiles of 256 px); water spreading further is lost. Dry some paint (dry_paint) to free memory.`;
+        if (!this.warnings.includes(msg)) this.warnings.push(msg);
+        return false;
+      }
+      slot = this.slotCount++;
+    }
+    const base = this.slotBase(slot);
+    this.f32.fill(0, base, base + SLOT_FLOATS);
+    this.i32[(this.layout.table >> 2) + key] = slot;
+    this.u32[(this.layout.flags >> 2) + key] = 0;
+    this.u32[(this.layout.last >> 2) + key] = 0;
+    this.active.push(key);
+    this.fillPaper(key);
+    this.fillFlow(key);
+    return true;
+  }
+  free(key) {
+    const slot = this.slotOf(key);
+    if (slot < 0) return;
+    this.i32[(this.layout.table >> 2) + key] = -1;
+    this.freeSlots.push(slot);
+    const i = this.active.indexOf(key);
+    if (i >= 0) this.active.splice(i, 1);
+    const lane = this.lanes[this.laneIndexOf(key)];
+    if (lane) {
+      if (lane.shaded.delete(this.tileKeyOf(key))) lane.shadedVersion++;
+      lane.stamp++;
+    }
+  }
+  tileXY(key) {
+    const t = key % this.layout.perLane;
+    return [t % this.layout.tilesX, Math.floor(t / this.layout.tilesX)];
+  }
+  tileKeyOf(key) {
+    const [tx, ty] = this.tileXY(key);
+    return _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
+  }
+  fillPaper(key) {
+    const [tx, ty] = this.tileXY(key);
+    const h = this.slotBase(this.slotOf(key)) + P_H * PLANE;
+    const { width, height } = this;
+    for (let y = 0; y < S2; y++) {
+      const gy = ty * WET_TILE + y - 1;
+      for (let x = 0; x < S2; x++) {
+        const gx = tx * WET_TILE + x - 1;
+        this.f32[h + y * S2 + x] = gx < 0 || gy < 0 || gx >= width || gy >= height ? -1 : quantizeHeight(this.paper.heightAt(gx + 0.5, gy + 0.5));
+      }
+    }
+  }
+  fillFlow(key) {
+    const lane = this.lanes[this.laneIndexOf(key)];
+    const [tx, ty] = this.tileXY(key);
+    const b = this.slotBase(this.slotOf(key));
+    const fx = b + P_FX * PLANE;
+    const fy = b + P_FY * PLANE;
+    for (let y = 1; y <= WET_TILE; y++) {
+      for (let x = 1; x <= WET_TILE; x++) {
+        const v = lane.flow ? lane.flow(tx * WET_TILE + x - 1 + 0.5, ty * WET_TILE + y - 1 + 0.5) : null;
+        this.f32[fx + y * S2 + x] = v ? Math.fround(v[0]) : 0;
+        this.f32[fy + y * S2 + x] = v ? Math.fround(v[1]) : 0;
+      }
+    }
+  }
+  /** Activates every tile of a lane within `STRIP` cells of a document rectangle. */
+  wake(lane, x0, y0, x1, y1) {
+    const { tilesX, tilesY, perLane } = this.layout;
+    const tx0 = Math.max(0, Math.floor((x0 - STRIP) / WET_TILE));
+    const ty0 = Math.max(0, Math.floor((y0 - STRIP) / WET_TILE));
+    const tx1 = Math.min(tilesX - 1, Math.floor((x1 + STRIP) / WET_TILE));
+    const ty1 = Math.min(tilesY - 1, Math.floor((y1 + STRIP) / WET_TILE));
+    let added = false;
+    for (let ty = ty0; ty <= ty1; ty++) for (let tx = tx0; tx <= tx1; tx++) added = this.activate(lane.index * perLane + ty * tilesX + tx) || added;
+    if (added) this.syncList();
+  }
+  /** Fills one slot's halo in the current set from its neighbours (TypeScript). */
+  haloTs(key, set) {
+    const { tilesX, tilesY, perLane } = this.layout;
+    const laneBase = this.laneIndexOf(key) * perLane;
+    const [tx, ty] = this.tileXY(key);
+    const f = this.f32;
+    const nb = (dx, dy) => {
+      const x = tx + dx;
+      const y = ty + dy;
+      if (x < 0 || y < 0 || x >= tilesX || y >= tilesY) return -1;
+      return this.slotOf(laneBase + y * tilesX + x);
+    };
+    const me = this.slotBase(this.slotOf(key)) + set * SET_PLANES * PLANE;
+    const n = nb(0, -1);
+    const s = nb(0, 1);
+    const w = nb(-1, 0);
+    const e = nb(1, 0);
+    const nw = nb(-1, -1);
+    const ne = nb(1, -1);
+    const sw = nb(-1, 1);
+    const se = nb(1, 1);
+    const off = set * SET_PLANES * PLANE;
+    for (let k = 0; k < SET_PLANES; k++) {
+      const mp = me + k * PLANE;
+      const o = off + k * PLANE;
+      if (n >= 0) f.copyWithin(mp + 1, this.slotBase(n) + o + 256 * S2 + 1, this.slotBase(n) + o + 256 * S2 + 257);
+      if (s >= 0) f.copyWithin(mp + 257 * S2 + 1, this.slotBase(s) + o + S2 + 1, this.slotBase(s) + o + S2 + 257);
+      if (w >= 0) for (let y = 1; y <= 256; y++) f[mp + y * S2] = f[this.slotBase(w) + o + y * S2 + 256];
+      if (e >= 0) for (let y = 1; y <= 256; y++) f[mp + y * S2 + 257] = f[this.slotBase(e) + o + y * S2 + 1];
+      if (nw >= 0) f[mp] = f[this.slotBase(nw) + o + 256 * S2 + 256];
+      if (ne >= 0) f[mp + 257] = f[this.slotBase(ne) + o + 256 * S2 + 1];
+      if (sw >= 0) f[mp + 257 * S2] = f[this.slotBase(sw) + o + S2 + 256];
+      if (se >= 0) f[mp + 257 * S2 + 257] = f[this.slotBase(se) + o + S2 + 1];
+    }
+  }
+  halo(key, set) {
+    if (this.wasm) {
+      const l = this.layout;
+      this.wasm.halo(l.table, l.slots, key, l.perLane, l.tilesX, l.tilesY, set);
+    } else this.haloTs(key, set);
+  }
+  /** Refills every live slot's halo in the current set (after edits or wake-ups). */
+  refreshHalos() {
+    for (const key of this.active) this.halo(key, this.parity);
+  }
+  // --- Stepping ------------------------------------------------------------------
+  /** Whether anything is being simulated (in `id`, or any layer). */
+  isActive(id) {
+    if (id === void 0) return this.active.length > 0;
+    const lane = this.laneOf(id);
+    return this.active.some((k) => this.laneIndexOf(k) === lane.index);
+  }
+  /** Steps until the next batch boundary: at most `want`, `MAX_BATCH`, and the next free check. */
+  batchSize(want) {
+    const toFree = FREE_INTERVAL - this.clock % FREE_INTERVAL;
+    return Math.max(1, Math.min(want, MAX_BATCH, toFree));
+  }
+  /** Runs `n` steps on this thread (TypeScript or wasm kernel). */
+  runHere(n) {
+    const l = this.layout;
+    const flagsBase = l.flags >> 2;
+    const lastBase = l.last >> 2;
+    const prmBase = l.params >> 2;
+    for (let s = 0; s < n; s++) {
+      for (const key of this.active) {
+        const slot = this.slotOf(key);
+        const lane = this.laneIndexOf(key);
+        let fl;
+        if (this.wasm) fl = this.wasm.step(l.slots + slot * SLOT_BYTES, this.parity, l.params + lane * PARAM_FLOATS * 4);
+        else fl = stepSlotTs(this.f32, this.slotBase(slot), this.parity, this.f32.subarray(prmBase + lane * PARAM_FLOATS, prmBase + (lane + 1) * PARAM_FLOATS));
+        this.u32[flagsBase + key] |= fl;
+        this.u32[lastBase + key] = fl;
+      }
+      for (const key of this.active) this.halo(key, 1 - this.parity);
+      this.parity = 1 - this.parity;
+    }
+  }
+  /** After a batch: wake neighbours from the flags, free dead tiles on a free step, restamp. */
+  afterBatch(n) {
+    this.clock += n;
+    const l = this.layout;
+    const flagsBase = l.flags >> 2;
+    const lastBase = l.last >> 2;
+    const { tilesX, tilesY, perLane } = l;
+    const wakeups = [];
+    for (const key of this.active) {
+      const fl = this.u32[flagsBase + key];
+      this.u32[flagsBase + key] = 0;
+      if (!(fl & FLAG_ALIVE)) continue;
+      const laneBase = this.laneIndexOf(key) * perLane;
+      const [tx, ty] = this.tileXY(key);
+      const L = fl & FLAG_LEFT;
+      const R = fl & FLAG_RIGHT;
+      const T = fl & FLAG_TOP;
+      const B = fl & FLAG_BOTTOM;
+      const push = (x, y) => {
+        if (x >= 0 && y >= 0 && x < tilesX && y < tilesY && this.slotOf(laneBase + y * tilesX + x) < 0) wakeups.push(laneBase + y * tilesX + x);
+      };
+      if (L) push(tx - 1, ty);
+      if (R) push(tx + 1, ty);
+      if (T) push(tx, ty - 1);
+      if (B) push(tx, ty + 1);
+      if (L && T) push(tx - 1, ty - 1);
+      if (R && T) push(tx + 1, ty - 1);
+      if (L && B) push(tx - 1, ty + 1);
+      if (R && B) push(tx + 1, ty + 1);
+    }
+    let woke = false;
+    for (const key of wakeups) woke = this.activate(key) || woke;
+    if (this.clock % FREE_INTERVAL === 0) {
+      const dead = this.active.filter((key) => {
+        if (this.u32[lastBase + key] & FLAG_ALIVE) return false;
+        const laneBase = this.laneIndexOf(key) * perLane;
+        const [tx, ty] = this.tileXY(key);
+        for (let dy = -1; dy <= 1; dy++)
+          for (let dx = -1; dx <= 1; dx++) {
+            const x = tx + dx;
+            const y = ty + dy;
+            if ((dx || dy) && x >= 0 && y >= 0 && x < tilesX && y < tilesY) {
+              const nk = laneBase + y * tilesX + x;
+              if (this.slotOf(nk) >= 0 && this.u32[lastBase + nk] & FLAG_ALIVE) return false;
+            }
+          }
+        return true;
+      });
+      for (const key of dead) {
+        this.bakeKey(key, false);
+        this.free(key);
+      }
+      if (dead.length) woke = true;
+    }
+    if (woke) {
+      this.syncList();
+      this.refreshHalos();
+    }
+    for (const lane of this.lanes) if (lane) lane.stamp++;
+  }
+  /**
+   * Steps the simulation `steps` times on this thread (the TypeScript or single-thread wasm
+   * kernel). Throws while worker threads are in use; use `step` there.
+   */
+  stepSync(steps) {
+    this.requireIdle();
+    if (this.pool) throw new WetWorldError("This wet world steps in worker threads; call step (async) instead.");
+    let left = Math.max(0, Math.floor(steps));
+    while (left > 0) {
+      if (!this.active.length) {
+        this.clock += left;
+        break;
+      }
+      const n = this.batchSize(left);
+      this.runHere(n);
+      this.afterBatch(n);
+      left -= n;
+    }
+    return this.clock;
+  }
+  /** Steps the simulation `steps` times (in worker threads when there are any). */
+  async step(steps) {
+    this.requireIdle();
+    if (!this.pool) return this.stepSync(steps);
+    let left = Math.max(0, Math.floor(steps));
+    while (left > 0) {
+      if (!this.active.length) {
+        this.clock += left;
+        break;
+      }
+      const n = this.batchSize(left);
+      const ctl = this.layout.ctl >> 2;
+      this.i32[ctl + 2] = 0;
+      this.i32[ctl + 3] = 0;
+      this.i32[ctl + 5] = this.parity;
+      this.busyFlag = true;
+      try {
+        await this.pool.run(n);
+      } finally {
+        this.busyFlag = false;
+      }
+      this.parity = (this.parity + n) % 2;
+      this.afterBatch(n);
+      left -= n;
+    }
+    return this.clock;
+  }
+  /** Steps until nothing is wet or `maxSteps` have run. Returns the steps run. */
+  async stepUntilDry(maxSteps) {
+    const start = this.clock;
+    while (this.active.length && this.clock - start < maxSteps) await this.step(Math.min(FREE_INTERVAL, maxSteps - (this.clock - start)));
+    return this.clock - start;
+  }
+  // --- Edits ---------------------------------------------------------------------
+  /** Float index of a cell's plane-0 value in the current set, or −1 (inactive / off the canvas). */
+  cell(lane, x, y) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return -1;
+    const { tilesX, perLane } = this.layout;
+    const slot = this.slotOf(lane.index * perLane + (y >> 8) * tilesX + (x >> 8));
+    if (slot < 0) return -1;
+    return this.slotBase(slot) + this.parity * SET_PLANES * PLANE + ((y & 255) + 1) * S2 + (x & 255) + 1;
+  }
+  /** Index of the same cell in the single (deposit, height, flow) planes, given `cell`. */
+  single(c) {
+    return c - this.parity * SET_PLANES * PLANE;
+  }
+  /**
+   * Runs `fn` for every cell of a footprint (`cov` over `rect`, document cells) on a lane, waking
+   * the tiles around it first, then refreshes halos. `fn` gets the cell index and its coverage.
+   */
+  footprint(id, rect, cov, fn, wake = true) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    const x0 = Math.max(0, rect.x);
+    const y0 = Math.max(0, rect.y);
+    const x1 = Math.min(this.width, rect.x + rect.width);
+    const y1 = Math.min(this.height, rect.y + rect.height);
+    if (x1 <= x0 || y1 <= y0) return;
+    if (wake) this.wake(lane, x0, y0, x1 - 1, y1 - 1);
+    for (let y = y0; y < y1; y++) {
+      for (let x = x0; x < x1; x++) {
+        const w = cov ? cov[(y - rect.y) * rect.width + (x - rect.x)] : 1;
+        if (!(w > 0)) continue;
+        const c = this.cell(lane, x, y);
+        if (c >= 0) fn(c, w, x, y);
+      }
+    }
+    this.markEdited(lane, x0, y0, x1, y1);
+    this.refreshHalos();
+  }
+  markEdited(lane, x0, y0, x1, y1) {
+    for (let ty = y0 >> 8; ty <= y1 - 1 >> 8; ty++) for (let tx = x0 >> 8; tx <= x1 - 1 >> 8; tx++) lane.urgent.add(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty));
+    lane.stamp++;
+  }
+  /** Adds water (depth units) at rest. */
+  addWaterAt(c, dw) {
+    const f = this.f32;
+    for (let k = 0; k < 9; k++) f[c + k * PLANE] += W9[k] * dw;
+    f[c + P_RHO * PLANE] += dw;
+  }
+  /**
+   * Lays paint: `water` depth and pigment mass `pigment` (K r, g, b, S) per unit of coverage, or
+   * per pixel from `field` (4 values per pixel of `rect`). Pigment without water lands straight in
+   * the paper (settled).
+   */
+  paint(id, rect, cov, water, pigment, field = null) {
+    if (!(water >= 0)) throw new WetWorldError(`water ${water} must be 0 or more.`);
+    this.footprint(id, rect, cov, (c, w, x, y) => {
+      const dw = Math.fround(water * w);
+      if (dw > 0) this.addWaterAt(c, dw);
+      const into = dw > 0 ? c + P_P0 * PLANE : this.single(c) + P_D0 * PLANE;
+      if (field) {
+        const o = ((y - rect.y) * rect.width + (x - rect.x)) * 4;
+        for (let q = 0; q < 4; q++) this.f32[into + q * PLANE] += field[o + q] * w;
+      } else if (pigment) for (let q = 0; q < 4; q++) this.f32[into + q * PLANE] += pigment[q] * w;
+    });
+  }
+  /** Damp paper: fills the paper's water towards its capacity by `amount` (0..1) × coverage, plus a thin film of surface water. */
+  wetPaper(id, rect, cov, amount) {
+    const capacity = PAPER_CAPACITY;
+    this.footprint(id, rect, cov, (c, w) => {
+      const a = Math.min(1, Math.max(0, amount * w));
+      const s = c + P_SW * PLANE;
+      this.f32[s] = Math.max(this.f32[s], Math.fround(capacity * a));
+      this.addWaterAt(c, Math.fround(0.03 * a));
+    });
+  }
+  /**
+   * Takes water (and suspended pigment, and settled pigment) away: `water`, `suspended`,
+   * `settled` are fractions 0..1 × coverage. A hair dryer takes water only (the pigment stays and
+   * settles); blotting takes all three.
+   */
+  remove(id, rect, cov, water, suspended, settled, paperWater = water) {
+    this.footprint(
+      id,
+      rect,
+      cov,
+      (c, w) => {
+        const f = this.f32;
+        const kw = 1 - Math.min(1, Math.max(0, water * w));
+        const kp = 1 - Math.min(1, Math.max(0, suspended * w));
+        const kd = 1 - Math.min(1, Math.max(0, settled * w));
+        const ks = 1 - Math.min(1, Math.max(0, paperWater * w));
+        if (kw < 1) {
+          for (let k = 0; k < 9; k++) f[c + k * PLANE] *= kw;
+          f[c + P_RHO * PLANE] *= kw;
+        }
+        if (ks < 1) f[c + P_SW * PLANE] *= ks;
+        if (kp < 1) for (let q = 0; q < 4; q++) f[c + (P_P0 + q) * PLANE] *= kp;
+        if (kd < 1) {
+          const d = this.single(c) + P_D0 * PLANE;
+          for (let q = 0; q < 4; q++) f[d + q * PLANE] *= kd;
+        }
+      },
+      false
+    );
+  }
+  /** Pushes the water: adds velocity (`ux`, `uy` cells per step, each at most 0.1) × coverage. */
+  push(id, rect, cov, ux, uy) {
+    const cap = 0.1;
+    const sp = Math.hypot(ux, uy);
+    if (sp > cap) {
+      ux *= cap / sp;
+      uy *= cap / sp;
+    }
+    this.footprint(
+      id,
+      rect,
+      cov,
+      (c, w) => {
+        const f = this.f32;
+        const rho = f[c + P_RHO * PLANE];
+        if (!(rho >= DRY_EPS)) return;
+        for (let k = 1; k < 9; k++) {
+          const eu = EX[k] * ux * w + EY[k] * uy * w;
+          f[c + k * PLANE] = Math.max(0, f[c + k * PLANE] + 3 * W9[k] * rho * eu);
+        }
+      },
+      false
+    );
+  }
+  /** Blends wet paint: each wet cell's suspended pigment moves `strength` × coverage towards the footprint's mean. */
+  blend(id, rect, cov, strength) {
+    const lane = this.laneOf(id);
+    const sums = [0, 0, 0, 0];
+    let wsum = 0;
+    const cells = [];
+    this.footprint(
+      id,
+      rect,
+      cov,
+      (c, w) => {
+        if (!(this.f32[c + P_RHO * PLANE] >= DRY_EPS)) return;
+        cells.push([c, w]);
+        wsum += w;
+        for (let q = 0; q < 4; q++) sums[q] += this.f32[c + (P_P0 + q) * PLANE] * w;
+      },
+      false
+    );
+    if (!(wsum > 0)) return;
+    const k = Math.min(1, Math.max(0, strength));
+    for (const [c, w] of cells) for (let q = 0; q < 4; q++) {
+      const i = c + (P_P0 + q) * PLANE;
+      this.f32[i] += k * w * (sums[q] / wsum - this.f32[i]);
+    }
+    lane.stamp++;
+    this.refreshHalos();
+  }
+  /**
+   * Drags wet paint by (`dx`, `dy`) cells: each footprint cell takes `strength` × coverage of the
+   * water and suspended pigment of the cell it came from (a smudge through wet paint).
+   */
+  drag(id, rect, cov, dx, dy, strength) {
+    const lane = this.laneOf(id);
+    const sx = Math.round(dx);
+    const sy = Math.round(dy);
+    if (!sx && !sy) return;
+    const moves = [];
+    this.footprint(
+      id,
+      rect,
+      cov,
+      (c, w, x, y) => {
+        const from = this.cell(lane, x - sx, y - sy);
+        if (from < 0) return;
+        moves.push([from, c, Math.min(1, Math.max(0, strength * w))]);
+      },
+      true
+    );
+    const f = this.f32;
+    const taken = moves.map(([from, , a]) => {
+      const t = new Float32Array(14);
+      for (let k = 0; k < 9; k++) {
+        t[k] = f[from + k * PLANE] * a;
+        f[from + k * PLANE] -= t[k];
+      }
+      t[9] = f[from + P_RHO * PLANE] * a;
+      f[from + P_RHO * PLANE] -= t[9];
+      for (let q = 0; q < 4; q++) {
+        t[10 + q] = f[from + (P_P0 + q) * PLANE] * a;
+        f[from + (P_P0 + q) * PLANE] -= t[10 + q];
+      }
+      return t;
+    });
+    moves.forEach(([, to], i) => {
+      const t = taken[i];
+      for (let k = 0; k < 9; k++) f[to + k * PLANE] += t[k];
+      f[to + P_RHO * PLANE] += t[9];
+      for (let q = 0; q < 4; q++) f[to + (P_P0 + q) * PLANE] += t[10 + q];
+    });
+    this.refreshHalos();
+  }
+  /**
+   * Re-wetting: lifts `amount` × coverage of the dried paint in the layer's pixels (`base`) back into
+   * the paper as settled pigment, so water can move it again. Only where there is surface water.
+   */
+  rewet(id, rect, cov, amount, paper) {
+    const lane = this.laneOf(id);
+    const pig = [0, 0, 0, 0];
+    const tiles = new Map(lane.base.tiles);
+    const written = /* @__PURE__ */ new Set();
+    const scratch2 = new Uint8ClampedArray(4);
+    this.footprint(
+      id,
+      rect,
+      cov,
+      (c, w, x, y) => {
+        if (!(this.f32[c + P_RHO * PLANE] >= DRY_EPS)) return;
+        const a = Math.min(1, Math.max(0, amount * w));
+        if (!(a > 0)) return;
+        const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, x >> 8, y >> 8);
+        let tile = tiles.get(key);
+        if (!tile) return;
+        if (!written.has(key)) {
+          tile = { data: new Uint8ClampedArray(tile.data), uniform: null };
+          tiles.set(key, tile);
+          written.add(key);
+        }
+        const i = ((y & 255) * _chunkTFOPHZ3Ucjs.TILE + (x & 255)) * 4;
+        if (tile.data[i + 3] === 0) return;
+        pixelPigment(tile.data, i, paper, pig);
+        if (!(pig[0] > 0 || pig[1] > 0 || pig[2] > 0)) return;
+        const clear = new Uint8ClampedArray([0, 0, 0, 0]);
+        filmPixel(pig[0] * (1 - a), pig[1] * (1 - a), pig[2] * (1 - a), 0, clear, 0, paper, 0, scratch2, 0);
+        tile.data.set(scratch2, i);
+        const d = this.single(c) + P_D0 * PLANE;
+        for (let q = 0; q < 3; q++) this.f32[d + q * PLANE] += Math.fround(pig[q] * a);
+      },
+      false
+    );
+    if (written.size) {
+      for (const key of written) {
+        const t = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, tiles.get(key).data, 4, 0);
+        if (t) tiles.set(key, t);
+        else tiles.delete(key);
+      }
+      this.setBase(id, new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(4, tiles, 0));
+    }
+  }
+  /**
+   * Dries wet paint at once (everything settles where it is, the water goes): in `rect`, or the
+   * whole layer. Whole tiles that end up dry are baked into the base and freed. Returns the
+   * document rectangle that changed, or `null`.
+   */
+  dry(id, rect) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
+    if (!keys.length) return null;
+    let bounds = null;
+    const area = _nullishCoalesce(rect, () => ( { x: 0, y: 0, width: this.width, height: this.height }));
+    for (const key of keys) {
+      const [tx, ty] = this.tileXY(key);
+      const tr = { x: tx * WET_TILE, y: ty * WET_TILE, width: WET_TILE, height: WET_TILE };
+      const x0 = Math.max(area.x, tr.x);
+      const y0 = Math.max(area.y, tr.y);
+      const x1 = Math.min(area.x + area.width, tr.x + tr.width, this.width);
+      const y1 = Math.min(area.y + area.height, tr.y + tr.height, this.height);
+      if (x1 <= x0 || y1 <= y0) continue;
+      const whole = x0 === tr.x && y0 === tr.y && x1 >= Math.min(tr.x + WET_TILE, this.width) && y1 >= Math.min(tr.y + WET_TILE, this.height);
+      if (whole) {
+        if (this.bakeKey(key, true)) bounds = unionRect2(bounds, { x: tr.x, y: tr.y, width: Math.min(WET_TILE, this.width - tr.x), height: Math.min(WET_TILE, this.height - tr.y) });
+        this.free(key);
+        continue;
+      }
+      const f = this.f32;
+      for (let y = y0; y < y1; y++) {
+        for (let x = x0; x < x1; x++) {
+          const c = this.cell(lane, x, y);
+          const d = this.single(c) + P_D0 * PLANE;
+          for (let q = 0; q < 4; q++) {
+            f[d + q * PLANE] += f[c + (P_P0 + q) * PLANE];
+            f[c + (P_P0 + q) * PLANE] = 0;
+          }
+          for (let k = 0; k < 9; k++) f[c + k * PLANE] = 0;
+          f[c + P_RHO * PLANE] = 0;
+          f[c + P_UX * PLANE] = 0;
+          f[c + P_UY * PLANE] = 0;
+          f[c + P_SW * PLANE] = 0;
+        }
+      }
+      bounds = unionRect2(bounds, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
+      this.markEdited(lane, x0, y0, x1, y1);
+    }
+    this.syncList();
+    this.refreshHalos();
+    lane.stamp++;
+    return bounds;
+  }
+  /**
+   * Bakes a slot's pigment into its lane's base (settling suspended pigment too when `all`).
+   * Returns whether any pixel changed.
+   */
+  bakeKey(key, all) {
+    const lane = this.lanes[this.laneIndexOf(key)];
+    const [tx, ty] = this.tileXY(key);
+    const tk = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
+    const src = _nullishCoalesce(_optionalChain([lane, 'access', _25 => _25.base, 'access', _26 => _26.tiles, 'access', _27 => _27.get, 'call', _28 => _28(tk), 'optionalAccess', _29 => _29.data]), () => ( null));
+    const out = this.shadeSlot(key, src, all ? "bake-all" : "bake");
+    if (!out) return false;
+    const tiles = new Map(lane.base.tiles);
+    const t = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, out, 4, 0);
+    if (t) tiles.set(tk, t);
+    else tiles.delete(tk);
+    this.setBase(lane.id, new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(4, tiles, 0));
+    return true;
+  }
+  /**
+   * Shades one slot over a base tile. `display`: the wet look (suspended + settled, wet paper a
+   * little darker); `bake`: settled pigment only; `bake-all`: suspended and settled (dry now).
+   * Returns `null` when nothing would change the base.
+   */
+  shadeSlot(key, src, mode) {
+    const [tx, ty] = this.tileXY(key);
+    const b = this.slotBase(this.slotOf(key));
+    const cur = b + this.parity * SET_PLANES * PLANE;
+    const out = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE * 4);
+    const w = Math.min(WET_TILE, this.width - tx * WET_TILE);
+    const h = Math.min(WET_TILE, this.height - ty * WET_TILE);
+    const changed = shadeTile(
+      this.f32,
+      PLANE,
+      S2,
+      b + P_D0 * PLANE,
+      mode === "bake" ? -1 : cur + P_P0 * PLANE,
+      mode === "display" ? cur + P_RHO * PLANE : -1,
+      cur + P_SW * PLANE,
+      src,
+      out,
+      w,
+      h,
+      this.paperBytes
+    );
+    return changed ? out : null;
+  }
+  /** The layer's pixels with all its wet paint dried where it is (the bake of "dry on save"); changes nothing. */
+  bakedSurface(id) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    const tiles = new Map(lane.base.tiles);
+    for (const key of this.active) {
+      if (this.laneIndexOf(key) !== lane.index) continue;
+      const tk = this.tileKeyOf(key);
+      const out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _30 => _30.base, 'access', _31 => _31.tiles, 'access', _32 => _32.get, 'call', _33 => _33(tk), 'optionalAccess', _34 => _34.data]), () => ( null)), "bake-all");
+      if (!out) continue;
+      const t = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, out, 4, 0);
+      if (t) tiles.set(tk, t);
+      else tiles.delete(tk);
+    }
+    return new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(4, tiles, 0);
+  }
+  // --- Reading -------------------------------------------------------------------
+  /**
+   * Sums over a footprint of a lane, weighted by coverage: `weight` (coverage), `water` (surface
+   * depth), `wet` (coverage of wet cells), `pigment` (suspended, 4 channels), `settled` (4 channels).
+   */
+  sample(id, rect, cov) {
+    const lane = this.laneOf(id);
+    const r = { weight: 0, water: 0, wet: 0, pigment: [0, 0, 0, 0], settled: [0, 0, 0, 0] };
+    const x0 = Math.max(0, rect.x);
+    const y0 = Math.max(0, rect.y);
+    const x1 = Math.min(this.width, rect.x + rect.width);
+    const y1 = Math.min(this.height, rect.y + rect.height);
+    for (let y = y0; y < y1; y++) {
+      for (let x = x0; x < x1; x++) {
+        const w = cov ? cov[(y - rect.y) * rect.width + (x - rect.x)] : 1;
+        if (!(w > 0)) continue;
+        r.weight += w;
+        const c = this.cell(lane, x, y);
+        if (c < 0) continue;
+        const rho = this.f32[c + P_RHO * PLANE];
+        r.water += rho * w;
+        if (rho >= DRY_EPS) r.wet += w;
+        const d = this.single(c) + P_D0 * PLANE;
+        for (let q = 0; q < 4; q++) {
+          r.pigment[q] += this.f32[c + (P_P0 + q) * PLANE] * w;
+          r.settled[q] += this.f32[d + q * PLANE] * w;
+        }
+      }
+    }
+    return r;
+  }
+  /** Surface water depth at a document cell (0 where nothing is simulated). */
+  waterAt(id, x, y) {
+    const c = this.cell(this.laneOf(id), Math.floor(x), Math.floor(y));
+    return c < 0 ? 0 : this.f32[c + P_RHO * PLANE];
+  }
+  /** Totals for a layer (scans its live tiles). */
+  stats(id) {
+    const lane = this.laneOf(id);
+    const out = { activeTiles: 0, wetCells: 0, water: 0, pigment: 0, wetBounds: null };
+    let bx0 = Infinity;
+    let by0 = Infinity;
+    let bx1 = -Infinity;
+    let by1 = -Infinity;
+    const f = this.f32;
+    for (const key of this.active) {
+      if (this.laneIndexOf(key) !== lane.index) continue;
+      out.activeTiles++;
+      const [tx, ty] = this.tileXY(key);
+      const b = this.slotBase(this.slotOf(key));
+      const cur = b + this.parity * SET_PLANES * PLANE;
+      for (let y = 1; y <= 256; y++) {
+        for (let x = 1; x <= 256; x++) {
+          const c = y * S2 + x;
+          const rho = f[cur + P_RHO * PLANE + c];
+          out.water += rho + f[cur + P_SW * PLANE + c];
+          for (let q = 0; q < 4; q++) out.pigment += f[cur + (P_P0 + q) * PLANE + c] + f[b + (P_D0 + q) * PLANE + c];
+          if (rho >= DRY_EPS) {
+            out.wetCells++;
+            const gx = tx * WET_TILE + x - 1;
+            const gy = ty * WET_TILE + y - 1;
+            if (gx < bx0) bx0 = gx;
+            if (gy < by0) by0 = gy;
+            if (gx > bx1) bx1 = gx;
+            if (gy > by1) by1 = gy;
+          }
+        }
+      }
+    }
+    if (out.wetCells) out.wetBounds = { x: bx0, y: by0, width: bx1 - bx0 + 1, height: by1 - by0 + 1 };
+    return out;
+  }
+  /** Whether a layer (or any) has surface water anywhere. */
+  isWet(id) {
+    const ids = id === void 0 ? this.laneIds() : [id];
+    return ids.some((x) => this.isActive(x));
+  }
+  /** Document rectangles of a layer's live tiles. */
+  activeRects(id) {
+    const lane = this.laneOf(id);
+    return this.active.filter((k) => this.laneIndexOf(k) === lane.index).map((k) => {
+      const [tx, ty] = this.tileXY(k);
+      return { x: tx * WET_TILE, y: ty * WET_TILE, width: Math.min(WET_TILE, this.width - tx * WET_TILE), height: Math.min(WET_TILE, this.height - ty * WET_TILE) };
+    });
+  }
+  // --- Display -------------------------------------------------------------------
+  /** A number that changes whenever a layer's display may have changed. */
+  stamp(id) {
+    return this.laneOf(id).stamp;
+  }
+  /**
+   * The layer's pixels with its wet paint shaded in: the base with each live tile shaded over it.
+   * At most `maxTiles` stale tiles are reshaded per call (edited tiles first); the rest keep their
+   * last shading until the next call. Returns the surface and the tiles reshaded.
+   */
+  display(id, maxTiles = Infinity) {
+    const lane = this.laneOf(id);
+    const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
+    const stale = keys.filter((k) => _optionalChain([lane, 'access', _35 => _35.shaded, 'access', _36 => _36.get, 'call', _37 => _37(this.tileKeyOf(k)), 'optionalAccess', _38 => _38.stamp]) !== lane.stamp);
+    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _39 => _39.shaded, 'access', _40 => _40.get, 'call', _41 => _41(this.tileKeyOf(a)), 'optionalAccess', _42 => _42.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _43 => _43.shaded, 'access', _44 => _44.get, 'call', _45 => _45(this.tileKeyOf(b)), 'optionalAccess', _46 => _46.stamp]), () => ( 0))));
+    const changed = [];
+    let done = 0;
+    for (const key of stale) {
+      if (done >= maxTiles) break;
+      const tk = this.tileKeyOf(key);
+      const src = _nullishCoalesce(_optionalChain([lane, 'access', _47 => _47.base, 'access', _48 => _48.tiles, 'access', _49 => _49.get, 'call', _50 => _50(tk), 'optionalAccess', _51 => _51.data]), () => ( null));
+      const out = this.shadeSlot(key, src, "display");
+      const tile = out ? _chunkTFOPHZ3Ucjs.finishTile.call(void 0, out, 4, 0) : _nullishCoalesce(lane.base.tiles.get(tk), () => ( null));
+      lane.shaded.set(tk, { stamp: lane.stamp, tile: _nullishCoalesce(tile, () => ( { data: new Uint8ClampedArray(0), uniform: 0 })) });
+      lane.shadedVersion++;
+      lane.urgent.delete(tk);
+      const [tx, ty] = this.tileXY(key);
+      changed.push({ x: tx * WET_TILE, y: ty * WET_TILE, width: WET_TILE, height: WET_TILE });
+      done++;
+    }
+    const live = new Set(keys.map((k) => this.tileKeyOf(k)));
+    for (const tk of [...lane.shaded.keys()]) if (!live.has(tk) && lane.shaded.delete(tk)) lane.shadedVersion++;
+    const displayKey = `${lane.base.id}:${lane.shadedVersion}`;
+    if (lane.display && lane.displayKey === displayKey) return { surface: lane.display, changed, pending: stale.length - done };
+    const tiles = new Map(lane.base.tiles);
+    for (const [tk, { tile }] of lane.shaded) {
+      if (tile.data.length === 0) tiles.delete(tk);
+      else tiles.set(tk, tile);
+    }
+    lane.display = new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(4, tiles, 0);
+    lane.displayKey = displayKey;
+    return { surface: lane.display, changed, pending: stale.length - done };
+  }
+  /**
+   * The water as an overlay tile (RGBA, blue, alpha from surface depth and damp paper) for a
+   * document tile, or `null` where nothing is wet.
+   */
+  waterOverlay(id, tx, ty) {
+    const lane = this.laneOf(id);
+    const { tilesX, tilesY, perLane } = this.layout;
+    if (tx < 0 || ty < 0 || tx >= tilesX || ty >= tilesY) return null;
+    const slot = this.slotOf(lane.index * perLane + ty * tilesX + tx);
+    if (slot < 0) return null;
+    const cur = this.slotBase(slot) + this.parity * SET_PLANES * PLANE;
+    const out = new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE * 4);
+    let any = false;
+    for (let y = 0; y < WET_TILE; y++) {
+      for (let x = 0; x < WET_TILE; x++) {
+        const c = (y + 1) * S2 + x + 1;
+        const rho = this.f32[cur + P_RHO * PLANE + c];
+        const sw = this.f32[cur + P_SW * PLANE + c];
+        const a = Math.min(1, rho * 2.5) * 0.7 + Math.min(1, sw * 4) * 0.2;
+        if (a <= 4e-3) continue;
+        const i = (y * _chunkTFOPHZ3Ucjs.TILE + x) * 4;
+        out[i] = 40;
+        out[i + 1] = 120;
+        out[i + 2] = 255;
+        out[i + 3] = Math.round(a * 255);
+        any = true;
+      }
+    }
+    return any ? out : null;
+  }
+  // --- Snapshots -----------------------------------------------------------------
+  /** A copy of everything (for undo): live slots, layers, clock and tilt. */
+  snapshot() {
+    this.requireIdle();
+    const slots = /* @__PURE__ */ new Map();
+    let bytes = 0;
+    for (const key of this.active) {
+      const b = this.slotBase(this.slotOf(key));
+      const planes = new Float32Array(SNAP_PLANES * PLANE);
+      planes.set(this.f32.subarray(b + this.parity * SET_PLANES * PLANE, b + (this.parity + 1) * SET_PLANES * PLANE), 0);
+      planes.set(this.f32.subarray(b + P_D0 * PLANE, b + (P_D0 + 4) * PLANE), SET_PLANES * PLANE);
+      slots.set(key, { planes, last: this.u32[(this.layout.last >> 2) + key] });
+      bytes += planes.byteLength;
+    }
+    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => ({ id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base }));
+    return { clock: this.clock, tilt: { ...this.tilt }, lanes, slots, bytes };
+  }
+  /** Puts a snapshot back exactly (the simulation then continues as it would have). */
+  restore(snap) {
+    this.requireIdle();
+    for (const key of [...this.active]) this.free(key);
+    this.lanes.fill(null);
+    this.tilt = { ...snap.tilt };
+    for (const l of snap.lanes) {
+      this.lanes[l.index] = { id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, shaded: /* @__PURE__ */ new Map(), urgent: /* @__PURE__ */ new Set(), stamp: 1, display: null, shadedVersion: 0, displayKey: "" };
+      this.pack(this.lanes[l.index]);
+    }
+    for (const [key, { planes, last }] of snap.slots) {
+      if (!this.activate(key)) continue;
+      const b = this.slotBase(this.slotOf(key));
+      this.f32.set(planes.subarray(0, SET_PLANES * PLANE), b + this.parity * SET_PLANES * PLANE);
+      this.f32.set(planes.subarray(SET_PLANES * PLANE), b + P_D0 * PLANE);
+      this.u32[(this.layout.last >> 2) + key] = last;
+    }
+    this.clock = snap.clock;
+    this.syncList();
+    this.refreshHalos();
+  }
+  /** Bytes of wasm memory held. */
+  memoryBytes() {
+    return this.memory.buffer.byteLength;
+  }
+  /** Live tiles across all layers. */
+  activeTiles() {
+    return this.active.length;
+  }
+  /** Memory for tests and tools: the raw f32 view (read only, please). */
+  get rawFloats() {
+    return this.f32;
+  }
+  /** The current set's parity (tests). */
+  get currentParity() {
+    return this.parity;
+  }
+  /** Float index of a slot's first plane (tests). */
+  slotIndex(id, tx, ty) {
+    const lane = this.laneOf(id);
+    const slot = this.slotOf(lane.index * this.layout.perLane + ty * this.layout.tilesX + tx);
+    return slot < 0 ? -1 : this.slotBase(slot);
+  }
+}, _class8);
+function unionRect2(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  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 };
+}
+
+// src/paint/wet/flow.ts
+var WET_FLOW_KINDS = ["none", "linear", "swirl", "radial", "turbulent"];
+var DEFAULT_FLOW = { kind: "none", strength: 0.5, angle: 0, clockwise: true, scale: 120, seed: 1 };
+var FLOW_ACCEL = 0.01;
+function dsincos(a) {
+  const twoPi = 6.283185307179586;
+  let x = a - Math.round(a / twoPi) * twoPi;
+  const q = Math.round(x / (twoPi / 4));
+  x -= q * (twoPi / 4);
+  const x2 = x * x;
+  let s = x;
+  let c = 1;
+  let ts = x;
+  let tc = 1;
+  for (let i = 1; i < 12; i++) {
+    ts *= -x2 / (2 * i * (2 * i + 1));
+    tc *= -x2 / ((2 * i - 1) * (2 * i));
+    s += ts;
+    c += tc;
+  }
+  switch ((q % 4 + 4) % 4) {
+    case 0:
+      return [s, c];
+    case 1:
+      return [c, -s];
+    case 2:
+      return [-s, -c];
+    default:
+      return [-c, s];
+  }
+}
+function hash(x, y, seed) {
+  let h = Math.imul(x | 0, 374761393) + Math.imul(y | 0, 668265263) + Math.imul(seed | 0, 1442695041) | 0;
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+}
+function valueNoise(x, y, seed) {
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const fx = x - x0;
+  const fy = y - y0;
+  const sx = fx * fx * (3 - 2 * fx);
+  const sy = fy * fy * (3 - 2 * fy);
+  const a = hash(x0, y0, seed);
+  const b = hash(x0 + 1, y0, seed);
+  const c = hash(x0, y0 + 1, seed);
+  const d = hash(x0 + 1, y0 + 1, seed);
+  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;
+}
+function normalizeFlow(raw = {}, base = DEFAULT_FLOW) {
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+  const kind = WET_FLOW_KINDS.includes(raw.kind) ? raw.kind : base.kind;
+  const center = raw.center && Number.isFinite(raw.center.x) && Number.isFinite(raw.center.y) ? { x: raw.center.x, y: raw.center.y } : base.center;
+  return {
+    kind,
+    strength: Math.min(1, Math.max(0, num(raw.strength, base.strength))),
+    angle: (num(raw.angle, base.angle) % 360 + 360) % 360,
+    ...center ? { center } : {},
+    clockwise: typeof raw.clockwise === "boolean" ? raw.clockwise : base.clockwise,
+    scale: Math.min(1024, Math.max(8, num(raw.scale, base.scale))),
+    seed: Math.abs(Math.round(num(raw.seed, base.seed))) % 2147483647
+  };
+}
+function flowField(spec, width, height) {
+  const k = FLOW_ACCEL;
+  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _52 => _52.center, 'optionalAccess', _53 => _53.x]), () => ( width / 2));
+  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _54 => _54.center, 'optionalAccess', _55 => _55.y]), () => ( height / 2));
+  const r0 = Math.max(width, height) / 2;
+  switch (spec.kind) {
+    case "none":
+      return null;
+    case "linear": {
+      const [s, c] = dsincos(spec.angle * Math.PI / 180);
+      const v = [-s * k, c * k];
+      return () => v;
+    }
+    case "swirl": {
+      const sign = spec.clockwise ? 1 : -1;
+      return (x, y) => [-(y - cy) / r0 * k * sign, (x - cx) / r0 * k * sign];
+    }
+    case "radial":
+      return (x, y) => [(x - cx) / r0 * k, (y - cy) / r0 * k];
+    case "turbulent": {
+      const sc = spec.scale;
+      const e = 0.5;
+      return (x, y) => {
+        const u = x / sc;
+        const v = y / sc;
+        const dndy = (valueNoise(u, v + e / sc, spec.seed) - valueNoise(u, v - e / sc, spec.seed)) * sc;
+        const dndx = (valueNoise(u + e / sc, v, spec.seed) - valueNoise(u - e / sc, v, spec.seed)) * sc;
+        return [dndy * k * 0.5, -dndx * k * 0.5];
+      };
+    }
+  }
+}
+
+// src/paint/wet/medium.ts
+var SAMPLE_K = 3;
+var WetMedium = (_class9 = class {
+  constructor(world, laneId, options) {;_class9.prototype.__init44.call(this);
+    this.world = world;
+    this.laneId = laneId;
+    this.options = options;
+  }
+  
+  
+  
+  __init44() {this.pig = new Float64Array(4)}
+  sample(rect, cov) {
+    const s = this.world.sample(this.laneId, rect, cov);
+    if (!(s.wet > 0) || !(s.weight > 0)) return null;
+    const k = s.pigment;
+    const kmax = Math.max(k[0], k[1], k[2]);
+    if (!(kmax > 1e-9)) return null;
+    const f = SAMPLE_K / kmax;
+    const rgb = pigmentColor(k[0] * f, k[1] * f, k[2] * f, k[3] * f);
+    const density = Math.min(1, (k[0] + k[1] + k[2]) / s.wet / 0.06);
+    return { rgb, contact: s.wet / s.weight * density };
+  }
+  deposit(rect, cov, dep, paint, _pigment, field = null) {
+    const { water, mass, body } = this.options;
+    if (field) {
+      const n = rect.width * rect.height;
+      const out = new Float32Array(n * 4);
+      const one = this.pig;
+      for (let p = 0; p < n; p++) {
+        pigmentOf([field[p * 3], field[p * 3 + 1], field[p * 3 + 2]], body, one);
+        for (let q = 0; q < 4; q++) out[p * 4 + q] = one[q] * mass * dep;
+      }
+      this.world.paint(this.laneId, rect, cov, water * dep, null, out);
+      return;
+    }
+    pigmentOf(paint, body, this.pig);
+    const pig = [0, 1, 2, 3].map((q) => this.pig[q] * mass * dep);
+    this.world.paint(this.laneId, rect, cov, water * dep, mass > 0 ? pig : null);
+  }
+}, _class9);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_BRUSH = DEFAULT_BRUSH; exports.MAX_BRUSH_SIZE = MAX_BRUSH_SIZE; exports.normalizeBrush = normalizeBrush; exports.tipShape = tipShape; exports.tipFalloff = tipFalloff; exports.tipReach = tipReach; exports.dabCoverage = dabCoverage; exports.smoothPoints = smoothPoints; exports.DabWalker = DabWalker; exports.walkDabs = walkDabs; exports.dabRect = dabRect; exports.rasterizeDab = rasterizeDab; exports.CoverageMap = CoverageMap; exports.StrokeCoverage = StrokeCoverage; exports.applyStrokeToTile = applyStrokeToTile; exports.coverageTileCoord = coverageTileCoord; exports.MIXING_MODELS = MIXING_MODELS; exports.EMPTY_MIXER_LOAD = EMPTY_MIXER_LOAD; exports.MIXER_PICKUP_RATE = MIXER_PICKUP_RATE; exports.MIXER_DRAIN = MIXER_DRAIN; exports.exchangeRates = exchangeRates; exports.PaintExchange = PaintExchange; exports.TileMedium = TileMedium; exports.DEFAULT_MIXER = DEFAULT_MIXER; exports.normalizeMixer = normalizeMixer; exports.mixerRates = mixerRates; exports.loadMixer = loadMixer; exports.cleanMixer = cleanMixer; exports.MixerStroke = MixerStroke; exports.DEFAULT_BLENDER = DEFAULT_BLENDER; exports.DEFAULT_SMUDGE = DEFAULT_SMUDGE; exports.normalizeBlender = normalizeBlender; exports.normalizeSmudge = normalizeSmudge; exports.blendRadius = blendRadius; exports.createBlenderScratch = createBlenderScratch; exports.blenderDab = blenderDab; exports.SmudgeTip = SmudgeTip; exports.createPigmentTools = createPigmentTools; exports.WET_TILE = WET_TILE; exports.SLOT_SIDE = SLOT_SIDE; exports.PLANE = PLANE; exports.PLANE_BYTES = PLANE_BYTES; exports.SET_PLANES = SET_PLANES; exports.P_RHO = P_RHO; exports.P_UX = P_UX; exports.P_UY = P_UY; exports.P_SW = P_SW; exports.P_P0 = P_P0; exports.P_EDGE = P_EDGE; exports.P_D0 = P_D0; exports.P_H = P_H; exports.P_FX = P_FX; exports.P_FY = P_FY; exports.SLOT_PLANES = SLOT_PLANES; exports.SLOT_BYTES = SLOT_BYTES; exports.PIGMENT_CHANNELS = PIGMENT_CHANNELS; exports.EX = EX; exports.EY = EY; exports.OPP = OPP; exports.W9 = W9; exports.DRY_EPS = DRY_EPS; exports.U_MAX = U_MAX; exports.STRIP = STRIP; exports.MAX_BATCH = MAX_BATCH; exports.FREE_INTERVAL = FREE_INTERVAL; exports.FLAG_ALIVE = FLAG_ALIVE; exports.FLAG_LEFT = FLAG_LEFT; exports.FLAG_RIGHT = FLAG_RIGHT; exports.FLAG_TOP = FLAG_TOP; exports.FLAG_BOTTOM = FLAG_BOTTOM; exports.FLAG_WET = FLAG_WET; exports.PARAM_FLOATS = PARAM_FLOATS; exports.PARAM = PARAM; exports.DEFAULT_WET_PARAMS = DEFAULT_WET_PARAMS; exports.WET_PARAM_KEYS = WET_PARAM_KEYS; exports.DEFAULT_WET_PAPER = DEFAULT_WET_PAPER; exports.FLAT = FLAT; exports.normalizeWetParams = normalizeWetParams; exports.normalizeTilt = normalizeTilt; exports.latticeViscosity = latticeViscosity; exports.PAPER_CAPACITY = PAPER_CAPACITY; exports.MAX_TILT_ACCEL = MAX_TILT_ACCEL; exports.packWetParams = packWetParams; exports.edgeBits = edgeBits; exports.PIGMENT_UNIT = PIGMENT_UNIT; exports.HIDE = HIDE; exports.BODY_SCATTER = BODY_SCATTER; exports.dexp = dexp; exports.dlog = dlog; exports.dpow = dpow; exports.SRGB_TO_LINEAR = SRGB_TO_LINEAR; exports.srgbByteToLinear = srgbByteToLinear; exports.linearToSrgb8 = linearToSrgb8; exports.pigmentOf = pigmentOf; exports.expNeg = expNeg; exports.filmReflectance = filmReflectance; exports.pigmentColor = pigmentColor; exports.filmPixel = filmPixel; exports.pixelPigment = pixelPigment; exports.shadeTile = shadeTile; exports.stepSlotTs = stepSlotTs; exports.loadWetKernel = loadWetKernel; exports.canShareMemory = canShareMemory; exports.wetSimdSupported = wetSimdSupported; exports.wetSupport = wetSupport; exports.WetWorkerPool = WetWorkerPool; exports.MAX_WET_LANES = MAX_WET_LANES; exports.MAX_WET_SLOTS = MAX_WET_SLOTS; exports.WetWorldError = WetWorldError; exports.WetWorld = WetWorld; exports.WET_FLOW_KINDS = WET_FLOW_KINDS; exports.DEFAULT_FLOW = DEFAULT_FLOW; exports.dsincos = dsincos; exports.normalizeFlow = normalizeFlow; exports.flowField = flowField; exports.WetMedium = WetMedium;
+//# sourceMappingURL=chunk-HOCPSFGA.cjs.map