@pixerate/editor 0.274.0 → 0.275.0

package/dist/paint-editor/index.js

@@ -7,12 +7,14 @@ import {
   BRUSH_SLIDERS,
   BRUSH_UNSET_PROPERTY,
   GHOST_SLIDERS,
+  IRIDESCENCE_SLIDERS,
+  MUTATION_SLIDERS,
   brushEngineControls,
   createBrushLibraryToolProvider,
   mergeBrushPatch,
   multiColorSliders,
   patchBrushValue
-} from "../chunk-NAHJV3O6.js";
+} from "../chunk-G5TCMKX5.js";
 import {
   createStickerTools,
   describeStickerRef
@@ -20,7 +22,7 @@ import {
 import {
   BRUSH_PREVIEW_DARK_PAPER,
   brushPreviewsOnDark
-} from "../chunk-CLB2I2FU.js";
+} from "../chunk-RJGW3RQS.js";
 import {
   toVideoFfmpeg
 } from "../chunk-S2XPXA47.js";
@@ -40,7 +42,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-5HP2VSAS.js";
+} from "../chunk-MSWLJI4G.js";
 import "../chunk-ADMRNWR7.js";
 import "../chunk-WJ4WQJCC.js";
 import {
@@ -123,7 +125,7 @@ import {
   wetPaperInput,
   wetPigmentOf,
   withStrokePath
-} from "../chunk-ZEI7ZEA4.js";
+} from "../chunk-Y2ISSVPH.js";
 import {
   BRUSH_ID,
   BRUSH_PRESETS,
@@ -135,17 +137,22 @@ import {
   DEFAULT_BRISTLE,
   DEFAULT_BRUSH_ID,
   DEFAULT_DYNAMICS,
+  DEFAULT_FLUORESCENCE,
   DEFAULT_GHOST,
   DEFAULT_IMPASTO,
+  DEFAULT_IRIDESCENCE,
   DEFAULT_LIGHT,
   DEFAULT_MULTI_COLOR,
+  DEFAULT_MUTATION,
   DEFAULT_PARTICLE,
   DEFAULT_SPRAY,
   DEFAULT_STICKER,
+  DEFAULT_THERMOCHROMIC,
   DEFAULT_TIP_GRAIN,
   DEFAULT_WET_BRUSH,
   DOT_ROTATIONS,
   DOT_TEXTURE_ORDERS,
+  GHOST_TRIGGERS,
   IMPASTO_TOOLS,
   MAX_DOT_TEXTURES,
   MAX_STICKER_STAMPS,
@@ -175,20 +182,23 @@ import {
   normalizeBristle,
   normalizeBrushSpec,
   normalizeDynamics,
+  normalizeFluorescence,
   normalizeGhost,
   normalizeImpasto,
   normalizeLight,
   normalizeMultiColor,
+  normalizeMutation,
   normalizePaintBrush,
   normalizeParticle,
   normalizeStickerSettings,
+  normalizeThermochromic,
   normalizeWetBrush,
   paintToMultiColor,
   parseBrushLibrary,
   readBrushSource,
   resolveBrush,
   usesPaintExchange
-} from "../chunk-UXYCY3HP.js";
+} from "../chunk-ZM7IKQ4X.js";
 import {
   STAMP_KINDS,
   StickersSlot,
@@ -238,7 +248,7 @@ import {
   normalizeWetParams,
   pigmentOf,
   wetSupport
-} from "../chunk-N3SKPQEH.js";
+} from "../chunk-LMG57L5A.js";
 import "../chunk-W6JDUXP3.js";
 import {
   CoverageMap,
@@ -408,8 +418,22 @@ function normalizeLighting(raw = {}, base = DEFAULT_LIGHTING) {
     relief: Math.min(1, Math.max(0, num(raw.relief, base.relief)))
   };
 }
+var DEFAULT_VIEW_TILT = { x: 0, y: 0 };
+function normalizeViewTilt(raw = {}, base = DEFAULT_VIEW_TILT) {
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+  return {
+    x: Math.min(1, Math.max(-1, num(raw.x, base.x))),
+    y: Math.min(1, Math.max(-1, num(raw.y, base.y)))
+  };
+}
+function viewTiltKey(v) {
+  return `${v.x.toFixed(3)}|${v.y.toFixed(3)}`;
+}
 function emptyThickChannels() {
-  return { height: new TiledSurface(1, /* @__PURE__ */ new Map(), 0), material: new TiledSurface(4, /* @__PURE__ */ new Map(), 0) };
+  return { height: new TiledSurface(1, /* @__PURE__ */ new Map(), 0), material: new TiledSurface(4, /* @__PURE__ */ new Map(), 0), film: new TiledSurface(4, /* @__PURE__ */ new Map(), 0) };
+}
+function hasThickChannels(ch) {
+  return Boolean(ch && (ch.height.tiles.size > 0 || ch.material.tiles.size > 0 || ch.film.tiles.size > 0));
 }
 var RELIEF_PX = 7;
 var AMBIENT = 0.38;
@@ -418,14 +442,31 @@ function lightVector(l) {
   const el = l.elevation * Math.PI / 180;
   return [Math.cos(el) * Math.sin(az), -Math.cos(el) * Math.cos(az), Math.sin(el)];
 }
+function viewVector(v) {
+  const vx = v.x * 1.25;
+  const vy = v.y * 1.25;
+  const vz = 1;
+  const vl = Math.hypot(vx, vy, vz);
+  return [vx / vl, vy / vl, vz / vl];
+}
+function thinFilmRgb(opd) {
+  const twoPi = Math.PI * 2;
+  return [
+    0.5 - 0.5 * Math.cos(twoPi * opd / 630),
+    0.5 - 0.5 * Math.cos(twoPi * opd / 532),
+    0.5 - 0.5 * Math.cos(twoPi * opd / 465)
+  ];
+}
 function lightingKey(l) {
   return `${l.azimuth.toFixed(2)}|${l.elevation.toFixed(2)}|${l.relief.toFixed(3)}`;
 }
-function lightTile(color, height, heightAround, material, light) {
+function lightTile(color, height, heightAround, material, light, film = null, viewTilt = DEFAULT_VIEW_TILT) {
   const out = new Uint8ClampedArray(color);
-  if (!height || light.relief <= 0) return out;
+  const hasRelief = Boolean(height && light.relief > 0);
+  if (!hasRelief && !film) return out;
   const [lx, ly, lz] = lightVector(light);
-  const hv = [lx, ly, lz + 1];
+  const [vx, vy, vz] = viewVector(viewTilt);
+  const hv = [lx + vx, ly + vy, lz + vz];
   const hl = Math.hypot(hv[0], hv[1], hv[2]);
   const hx = hv[0] / hl;
   const hy = hv[1] / hl;
@@ -433,6 +474,7 @@ function lightTile(color, height, heightAround, material, light) {
   const k = RELIEF_PX / 255 * light.relief * 2;
   const flatDiffuse = AMBIENT + (1 - AMBIENT) * lz;
   const read = (x, y) => {
+    if (!height) return 0;
     if (x >= 0 && y >= 0 && x < TILE && y < TILE) return height[y * TILE + x];
     const dx = x < 0 ? -1 : x >= TILE ? 1 : 0;
     const dy = y < 0 ? -1 : y >= TILE ? 1 : 0;
@@ -445,28 +487,59 @@ function lightTile(color, height, heightAround, material, light) {
       const p = y * TILE + x;
       const i = p * 4;
       if (color[i + 3] === 0) continue;
-      const h = height[p];
-      const gx = (read(x + 1, y) - read(x - 1, y)) * 0.5;
-      const gy = (read(x, y + 1) - read(x, y - 1)) * 0.5;
-      if (h === 0 && gx === 0 && gy === 0) continue;
-      let nx = -gx * k;
-      let ny = -gy * k;
-      const nl = Math.hypot(nx, ny, 1);
-      nx /= nl;
-      ny /= nl;
-      const nz = 1 / nl;
-      const diffuse = Math.max(0, nx * lx + ny * ly + nz * lz);
-      const shade = (AMBIENT + (1 - AMBIENT) * diffuse) / flatDiffuse;
-      const gloss = material ? material[i] / 255 : 0.3;
-      const metal = material ? material[i + 1] / 255 : 0;
-      const shininess = 6 + 90 * gloss;
-      const nh = Math.max(0, nx * hx + ny * hy + nz * hz);
-      const spec = Math.max(0, Math.pow(nh, shininess) - Math.pow(hz, shininess)) * (0.25 + 0.75 * gloss) * light.relief;
+      const fa = film ? film[i + 3] / 255 : 0;
+      const h = hasRelief ? height[p] : 0;
+      const gx = hasRelief ? (read(x + 1, y) - read(x - 1, y)) * 0.5 : 0;
+      const gy = hasRelief ? (read(x, y + 1) - read(x, y - 1)) * 0.5 : 0;
+      const hasSlope = hasRelief && (h !== 0 || gx !== 0 || gy !== 0);
+      if (!hasSlope && fa <= 0) continue;
+      let nx = 0;
+      let ny = 0;
+      let nz = 1;
+      let shade = 1;
+      let gloss = 0.3;
+      let metal = 0;
+      let spec = 0;
+      if (hasSlope) {
+        nx = -gx * k;
+        ny = -gy * k;
+        const nl = Math.hypot(nx, ny, 1);
+        nx /= nl;
+        ny /= nl;
+        nz = 1 / nl;
+        const diffuse = Math.max(0, nx * lx + ny * ly + nz * lz);
+        shade = (AMBIENT + (1 - AMBIENT) * diffuse) / flatDiffuse;
+        gloss = material ? material[i] / 255 : 0.3;
+        metal = material ? material[i + 1] / 255 : 0;
+        const shininess = 6 + 90 * gloss;
+        const nh = Math.max(0, nx * hx + ny * hy + nz * hz);
+        spec = Math.max(0, Math.pow(nh, shininess) - Math.pow(hz, shininess)) * (0.25 + 0.75 * gloss) * light.relief;
+      }
+      let filmRgb = null;
+      if (fa > 0 && film) {
+        const d = 100 + film[i] / 255 * 900;
+        const ior = 1.2 + film[i + 1] / 255 * 0.8;
+        const nh = Math.max(0, nx * hx + ny * hy + nz * hz);
+        const nv = Math.max(0, nx * vx + ny * vy + nz * vz);
+        const cosThetaI = Math.max(0, Math.min(1, nh * nv));
+        const sin2ThetaT = (1 - cosThetaI * cosThetaI) / (ior * ior);
+        const cosThetaT = Math.sqrt(Math.max(0, 1 - sin2ThetaT));
+        const opd = 2 * ior * d * cosThetaT;
+        filmRgb = thinFilmRgb(opd);
+      }
       for (let c = 0; c < 3; c++) {
         const a = SRGB_TO_LINEAR[color[i + c]];
-        const tint = metal * a + (1 - metal);
-        const v = a * shade * (1 - 0.35 * metal) + spec * tint * (1 + metal);
-        out[i + c] = linearToSrgb8(v);
+        const fc = filmRgb ? filmRgb[c] : a;
+        if (hasSlope) {
+          const tint = metal * a + (1 - metal);
+          const diff = fa > 0 ? a * (1 - fa * 0.75) + fc * fa * (0.45 + 0.55 * a) : a;
+          const specTint = fa > 0 ? tint * (1 - fa) + fc * fa : tint;
+          const v = diff * shade * (1 - 0.35 * metal) + spec * specTint * (1 + metal);
+          out[i + c] = linearToSrgb8(v);
+        } else {
+          const v = a * (1 - fa * 0.75) + fc * fa * (0.45 + 0.55 * a);
+          out[i + c] = linearToSrgb8(v);
+        }
       }
     }
   }
@@ -474,10 +547,12 @@ function lightTile(color, height, heightAround, material, light) {
 }
 var LitCache = class {
   tiles = /* @__PURE__ */ new Map();
-  /** The layer's pixels lit (tiles without relief nearby are the colour tiles themselves). */
-  lit(color, ch, light) {
-    if (!ch.height.tiles.size || light.relief <= 0) return color;
-    const lk = lightingKey(light);
+  /** The layer's pixels lit (tiles without relief or film nearby are the colour tiles themselves). */
+  lit(color, ch, light, viewTilt = DEFAULT_VIEW_TILT) {
+    const hasRelief = ch.height.tiles.size > 0 && light.relief > 0;
+    const hasFilm = ch.film.tiles.size > 0;
+    if (!hasRelief && !hasFilm) return color;
+    const lk = `${lightingKey(light)}|${viewTiltKey(viewTilt)}`;
     const out = new Map(color.tiles);
     const keys = /* @__PURE__ */ new Set();
     for (const key of color.tiles.keys()) keys.add(key);
@@ -486,12 +561,15 @@ var LitCache = class {
       const ty = Math.floor(key / 65536) - 32768;
       const around = (dx, dy) => ch.height.tiles.get(tileKey(tx + dx, ty + dy))?.data ?? null;
       let any = false;
-      for (let dy = -1; dy <= 1 && !any; dy++) for (let dx = -1; dx <= 1 && !any; dx++) if (around(dx, dy)) any = true;
-      if (!any) continue;
-      const h = ch.height.tiles.get(key) ?? null;
-      const m = ch.material.tiles.get(key) ?? null;
-      const inputs = [tile, lk, m];
-      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) inputs.push(ch.height.tiles.get(tileKey(tx + dx, ty + dy)) ?? null);
+      if (hasRelief) {
+        for (let dy = -1; dy <= 1 && !any; dy++) for (let dx = -1; dx <= 1 && !any; dx++) if (around(dx, dy)) any = true;
+      }
+      const f = ch.film.tiles.get(key) ?? null;
+      if (!any && !f) continue;
+      const h = hasRelief ? ch.height.tiles.get(key) ?? null : null;
+      const m = hasRelief ? ch.material.tiles.get(key) ?? null : null;
+      const inputs = [tile, lk, m, f];
+      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) inputs.push(hasRelief ? ch.height.tiles.get(tileKey(tx + dx, ty + dy)) ?? null : null);
       const cached = this.tiles.get(key);
       if (cached && cached.inputs.length === inputs.length && cached.inputs.every((v, i) => v === inputs[i])) {
         out.set(key, cached.tile);
@@ -499,10 +577,19 @@ var LitCache = class {
       }
       const hd = h ? expand(h, 1) : null;
       const md = m ? expand(m, 4) : null;
-      const data = lightTile(expand(tile, 4), hd, (dx, dy) => {
-        const t = ch.height.tiles.get(tileKey(tx + dx, ty + dy));
-        return t ? expand(t, 1) : null;
-      }, md, light);
+      const fd = f ? expand(f, 4) : null;
+      const data = lightTile(
+        expand(tile, 4),
+        hd,
+        (dx, dy) => {
+          const t = ch.height.tiles.get(tileKey(tx + dx, ty + dy));
+          return t ? expand(t, 1) : null;
+        },
+        md,
+        light,
+        fd,
+        viewTilt
+      );
       const lit = { data, uniform: null };
       this.tiles.set(key, { inputs, tile: lit });
       out.set(key, lit);
@@ -522,6 +609,122 @@ function expand(t, channels) {
   }
   return out;
 }
+var FilmBuffer = class {
+  constructor(base, offset = { x: 0, y: 0 }, mask = null) {
+    this.base = base;
+    this.offset = offset;
+    this.mask = mask;
+  }
+  base;
+  offset;
+  mask;
+  tiles = /* @__PURE__ */ new Map();
+  maskAt(wx, wy) {
+    const sel = this.mask;
+    if (!sel) return 1;
+    return wx >= 0 && wy >= 0 && wx < sel.width && wy < sel.height ? sel.data[wy * sel.width + wx] / 255 : 0;
+  }
+  tile(tx, ty) {
+    const key = tileKey(tx, ty);
+    let t = this.tiles.get(key);
+    if (!t) {
+      const b = this.base.tiles.get(key);
+      t = b ? new Uint8ClampedArray(expand(b, 4)) : new Uint8ClampedArray(TILE * TILE * 4);
+      this.tiles.set(key, t);
+    }
+    return t;
+  }
+  /** Deposits thin-film iridescence over `rect` with per-pixel `coverage` (0..1) scaled by `strength` (0..1). */
+  deposit(rect, coverage, strength, ir, pressure = 0.5) {
+    if (strength <= 0) return;
+    const nm = Math.max(100, Math.min(1e3, ir.thickness * (1 + ir.pressureToThickness * (pressure - 0.5) * 2)));
+    const rByte = Math.round((nm - 100) / 900 * 255);
+    const gByte = Math.round((ir.ior - 1.2) / 0.8 * 255);
+    const ox = this.offset.x;
+    const oy = this.offset.y;
+    for (let yy = 0, p = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, p++) {
+        const wx = rect.x + xx;
+        const wy = rect.y + yy;
+        const m = this.maskAt(wx, wy);
+        const c = Math.min(1, coverage[p] * strength * m);
+        if (c <= 0) continue;
+        const lx = wx - ox;
+        const ly = wy - oy;
+        const t = this.tile(Math.floor(lx / TILE), Math.floor(ly / TILE));
+        const i = ((ly & 255) * TILE + (lx & 255)) * 4;
+        const prevA = t[i + 3] / 255;
+        const nextA = prevA + c * (1 - prevA);
+        const w = nextA > 0 ? c / nextA : 1;
+        t[i] = Math.round(t[i] + (rByte - t[i]) * w);
+        t[i + 1] = Math.round(t[i + 1] + (gByte - t[i + 1]) * w);
+        t[i + 2] = 0;
+        t[i + 3] = Math.round(nextA * 255);
+      }
+    }
+  }
+  /** Stamps a soft disc of thin-film iridescence at `(cx, cy)` (document pixels) with `radius` and `alpha` (0..1). */
+  stampDisc(cx, cy, radius, alpha, ir, pressure = 0.5) {
+    if (alpha <= 0 || radius <= 0) return;
+    const r = Math.max(0.5, radius);
+    const x0 = Math.floor(cx - r - 1);
+    const y0 = Math.floor(cy - r - 1);
+    const x1 = Math.ceil(cx + r + 1);
+    const y1 = Math.ceil(cy + r + 1);
+    const w = x1 - x0;
+    const h = y1 - y0;
+    if (w <= 0 || h <= 0) return;
+    const cov = new Float32Array(w * h);
+    for (let yy = 0, p = 0; yy < h; yy++) {
+      for (let xx = 0; xx < w; xx++, p++) {
+        const d = Math.hypot(x0 + xx + 0.5 - cx, y0 + yy + 0.5 - cy);
+        if (d < r + 0.5) cov[p] = d <= r - 0.5 ? 1 : Math.max(0, r + 0.5 - d);
+      }
+    }
+    this.deposit({ x: x0, y: y0, width: w, height: h }, cov, Math.min(1, alpha), ir, pressure);
+  }
+  /** Erases thin-film coverage over `rect` by `coverage[p] * strength`. */
+  erase(rect, coverage, strength) {
+    if (strength <= 0) return;
+    const ox = this.offset.x;
+    const oy = this.offset.y;
+    for (let yy = 0, p = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, p++) {
+        const wx = rect.x + xx;
+        const wy = rect.y + yy;
+        const m = this.maskAt(wx, wy);
+        const c = Math.min(1, coverage[p] * strength * m);
+        if (c <= 0) continue;
+        const lx = wx - ox;
+        const ly = wy - oy;
+        const tx = Math.floor(lx / TILE);
+        const ty = Math.floor(ly / TILE);
+        const key = tileKey(tx, ty);
+        if (!this.tiles.has(key) && !this.base.tiles.has(key)) continue;
+        const t = this.tile(tx, ty);
+        const i = ((ly & 255) * TILE + (lx & 255)) * 4;
+        const a = Math.round(t[i + 3] * (1 - c));
+        if (a <= 0) {
+          t[i] = 0;
+          t[i + 1] = 0;
+          t[i + 2] = 0;
+          t[i + 3] = 0;
+        } else {
+          t[i + 3] = a;
+        }
+      }
+    }
+  }
+  surface() {
+    const out = new Map(this.base.tiles);
+    for (const [k, d] of this.tiles) {
+      const t = finishTile(new Uint8ClampedArray(d), 4, 0);
+      if (t) out.set(k, t);
+      else out.delete(k);
+    }
+    return new TiledSurface(4, out, 0);
+  }
+};
 var ThickStrokeDriver = class {
   constructor(init) {
     this.init = init;
@@ -538,6 +741,7 @@ var ThickStrokeDriver = class {
       amount: 1
     }));
     this.medium = new TileMedium(init.target, {});
+    this.film = b.iridescence ? new FilmBuffer(init.channels.film, init.target.offset) : null;
     this.sampler = init.paint ? new PaintGradientSampler(init.paint.map.by === "across-tip" ? { ...init.paint, map: { by: "distance", length: 300, repeat: "mirror" } } : init.paint, init.seed) : null;
   }
   init;
@@ -547,6 +751,7 @@ var ThickStrokeDriver = class {
   medium;
   height = /* @__PURE__ */ new Map();
   material = /* @__PURE__ */ new Map();
+  film;
   paint = [0, 0, 0];
   centre = [0, 0, 0];
   tip = new Float32Array(0);
@@ -575,7 +780,11 @@ var ThickStrokeDriver = class {
       else m.delete(k);
     }
     void this.version;
-    return { height: new TiledSurface(1, h, 0), material: new TiledSurface(4, m, 0) };
+    return {
+      height: new TiledSurface(1, h, 0),
+      material: new TiledSurface(4, m, 0),
+      film: this.film ? this.film.surface() : this.init.channels.film
+    };
   }
   heightTile(tx, ty, write) {
     const key = tileKey(tx, ty);
@@ -671,6 +880,7 @@ var ThickStrokeDriver = class {
       st.smudge.dab(this.medium, { x: d.x, y: d.y, radius: d.radius, opacity: k }, rect, tip);
       this.knifeHeight(st, d, rect, tip, k, im.drag);
       this.paintMaterial(rect, tip, k * 0.6, im.gloss, im.metallic, im.rim, im.clarity);
+      if (this.film && b.iridescence) this.film.deposit(rect, tip, k * 0.6, b.iridescence, d.pressure);
       return;
     }
     const ex = st.exchange;
@@ -738,6 +948,7 @@ var ThickStrokeDriver = class {
       }
     }
     this.paintMaterial(rect, tip, k, im.gloss * (1 - 0.3 * im.thinner), im.metallic, im.rim, im.clarity);
+    if (this.film && b.iridescence) this.film.deposit(rect, tip, k, b.iridescence, d.pressure);
   }
   /** The knife: flattens the relief under it and carries some of it along (a patch, like a smudge). */
   knifeHeight(st, d, rect, tip, k, drag) {
@@ -790,18 +1001,33 @@ var ThickStrokeDriver = class {
     }
   }
 };
+function unionRects(a, b) {
+  if (!a) return b ? { ...b } : null;
+  if (!b) return { ...a };
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, yOf(b));
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+var yOf = (r) => r.y;
 function reliefInfo(ch) {
   let max = 0;
   for (const t of ch.height.tiles.values()) {
     if (t.uniform !== null) max = Math.max(max, t.uniform & 255);
     else for (let i = 0; i < t.data.length; i++) if (t.data[i] > max) max = t.data[i];
   }
-  return { bounds: ch.height.bounds, maxHeight: max, tiles: ch.height.tiles.size };
+  const bounds = unionRects(ch.height.bounds, ch.film.bounds);
+  return { bounds, maxHeight: max, tiles: ch.height.tiles.size || ch.film.tiles.size };
 }
 function thickToJSON(ch) {
-  const b = ch.height.bounds;
+  const b = unionRects(ch.height.bounds, ch.film.bounds);
   if (!b) return null;
-  return { rect: { ...b }, height: pngDataUrl(b.width, b.height, readRegion(ch.height, b), 1), material: pngDataUrl(b.width, b.height, readRegion(ch.material, b), 4) };
+  const out = {
+    rect: { ...b },
+    height: pngDataUrl(b.width, b.height, readRegion(ch.height, b), 1),
+    material: pngDataUrl(b.width, b.height, readRegion(ch.material, b), 4)
+  };
+  if (ch.film.bounds) out.film = pngDataUrl(b.width, b.height, readRegion(ch.film, b), 4);
+  return out;
 }
 function thickFromJSON(raw) {
   const r = raw;
@@ -814,9 +1040,14 @@ function thickFromJSON(raw) {
   const h = decode(r.height, true);
   const m = decode(r.material, false);
   const hd = h.channels === 1 ? h.data : Uint8ClampedArray.from({ length: h.width * h.height }, (_, i) => h.data[i * 4]);
+  const film = typeof r.film === "string" ? (() => {
+    const f = decode(r.film, false);
+    return surfaceFromPixels({ width: f.width, height: f.height, data: f.data }, 4, r.rect.x, r.rect.y);
+  })() : new TiledSurface(4, /* @__PURE__ */ new Map(), 0);
   return {
     height: surfaceFromPixels({ width: h.width, height: h.height, data: hd }, 1, r.rect.x, r.rect.y),
-    material: surfaceFromPixels({ width: m.width, height: m.height, data: m.data }, 4, r.rect.x, r.rect.y)
+    material: surfaceFromPixels({ width: m.width, height: m.height, data: m.data }, 4, r.rect.x, r.rect.y),
+    film
   };
 }
 
@@ -1075,6 +1306,567 @@ function lightFromJSON(raw) {
   return surfaceFromPixels({ width: img.width, height: img.height, data }, 1, r.rect.x, r.rect.y);
 }
 
+// src/paint-editor/heat.ts
+var DEFAULT_UV_LIGHT = { on: false, strength: 1, ambient: 0.15 };
+function normalizeUvLight(raw = {}, base = DEFAULT_UV_LIGHT) {
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+  return {
+    on: typeof raw.on === "boolean" ? raw.on : base.on,
+    strength: Math.min(2, Math.max(0, num(raw.strength, base.strength))),
+    ambient: Math.min(1, Math.max(0, num(raw.ambient, base.ambient)))
+  };
+}
+function uvLightKey(uv) {
+  return `${uv.on ? 1 : 0}|${uv.strength.toFixed(3)}|${uv.ambient.toFixed(3)}`;
+}
+var uvPapers = /* @__PURE__ */ new WeakMap();
+function uvPaper(paper, uv) {
+  if (!uv.on || uv.ambient >= 1) return paper;
+  const cached = uvPapers.get(paper);
+  if (cached && cached.ambient === uv.ambient) return cached.paper;
+  const [r, g, b] = hexToRgb8(paper.color);
+  const toHex = (v) => Math.round(Math.min(255, Math.max(0, v * uv.ambient))).toString(16).padStart(2, "0");
+  const next = { ...paper, color: `#${toHex(r)}${toHex(g)}${toHex(b)}` };
+  uvPapers.set(paper, { ambient: uv.ambient, paper: next });
+  return next;
+}
+function emptyFluor() {
+  return new TiledSurface(4, /* @__PURE__ */ new Map(), 0);
+}
+function emptyThermo() {
+  return new TiledSurface(4, /* @__PURE__ */ new Map(), 0);
+}
+function expand4(t) {
+  if (t.data.length === TILE * TILE * 4) return t.data;
+  const out = new Uint8ClampedArray(TILE * TILE * 4);
+  const u = t.uniform ?? 0;
+  const bytes = [u >>> 24 & 255, u >>> 16 & 255, u >>> 8 & 255, u & 255];
+  for (let i = 0; i < out.length; i += 4) out.set(bytes, i);
+  return out;
+}
+function fluorTwinBrush(brush) {
+  const f = brush.fluorescence.amount;
+  const base = { ...brush, light: { amount: 0, pressure: false }, fluorescence: { amount: 0, invisible: false }, thermochromic: { hotColor: null, threshold: 0.5 }, tip: { ...brush.tip, blend: "normal" } };
+  if (brush.engine === "eraser" || brush.engine === "smudge" || brush.engine === "blender") return base;
+  const move = brush.engine === "impasto" ? brush.impasto.tool === "knife" ? "smudge" : "dab" : brush.engine;
+  if (f > 0) {
+    return normalizePaintBrush(
+      {
+        ...base,
+        engine: move,
+        tip: { ...base.tip, opacity: brush.tip.opacity * f, blend: "normal" }
+      },
+      base
+    );
+  }
+  if (brush.engine === "mixer" || brush.behavior.pickup > 0 || brush.engine === "impasto" && brush.impasto.tool === "knife") {
+    return normalizePaintBrush({ ...base, engine: move }, base);
+  }
+  return normalizePaintBrush(
+    {
+      ...base,
+      engine: "eraser",
+      tip: { ...base.tip, opacity: brush.tip.opacity },
+      paint: null
+    },
+    base
+  );
+}
+function thermoTwinBrush(brush) {
+  const active = brush.thermochromic.hotColor !== null;
+  const base = {
+    ...brush,
+    light: { amount: 0, pressure: false },
+    fluorescence: { amount: 0, invisible: false },
+    thermochromic: { hotColor: null, threshold: 0.5 },
+    paint: null,
+    tip: { ...brush.tip, blend: "normal" }
+  };
+  if (brush.engine === "eraser" || brush.engine === "smudge" || brush.engine === "blender") return base;
+  const move = brush.engine === "impasto" ? brush.impasto.tool === "knife" ? "smudge" : "dab" : brush.engine;
+  if (active) {
+    return normalizePaintBrush({ ...base, engine: move, behavior: { ...base.behavior, pickup: 0 } }, base);
+  }
+  if (brush.engine === "mixer" || brush.behavior.pickup > 0 || brush.engine === "impasto" && brush.impasto.tool === "knife") {
+    return normalizePaintBrush({ ...base, engine: move }, base);
+  }
+  return normalizePaintBrush({ ...base, engine: "eraser", tip: { ...base.tip, opacity: brush.tip.opacity } }, base);
+}
+function finalizeThermoStroke(twinOut, before, hotRgb, threshold) {
+  const thByte = Math.max(1, Math.min(255, Math.round(threshold * 255)));
+  const out = new Map(before.tiles);
+  const keys = /* @__PURE__ */ new Set([...before.tiles.keys(), ...twinOut.tiles.keys()]);
+  for (const key of keys) {
+    const afterTile = twinOut.tiles.get(key);
+    const beforeTile = before.tiles.get(key);
+    if (afterTile === beforeTile) continue;
+    if (!afterTile) {
+      out.delete(key);
+      continue;
+    }
+    const aData = expand4(afterTile);
+    const bData = beforeTile ? expand4(beforeTile) : null;
+    const dst = new Uint8ClampedArray(TILE * TILE * 4);
+    for (let i = 0; i < dst.length; i += 4) {
+      const cov = aData[i + 3] / 255;
+      const prevTh = bData ? bData[i + 3] : 0;
+      if (cov <= 0 && prevTh === 0) continue;
+      if (prevTh === 0) {
+        dst[i] = hotRgb[0];
+        dst[i + 1] = hotRgb[1];
+        dst[i + 2] = hotRgb[2];
+        dst[i + 3] = thByte;
+      } else if (cov <= 0) {
+        dst[i] = bData[i];
+        dst[i + 1] = bData[i + 1];
+        dst[i + 2] = bData[i + 2];
+        dst[i + 3] = prevTh;
+      } else {
+        dst[i] = Math.round(bData[i] * (1 - cov) + hotRgb[0] * cov);
+        dst[i + 1] = Math.round(bData[i + 1] * (1 - cov) + hotRgb[1] * cov);
+        dst[i + 2] = Math.round(bData[i + 2] * (1 - cov) + hotRgb[2] * cov);
+        dst[i + 3] = Math.max(1, Math.round(prevTh * (1 - cov) + thByte * cov));
+      }
+    }
+    const ft = finishTile(dst, 4, 0);
+    if (ft) out.set(key, ft);
+    else out.delete(key);
+  }
+  return new TiledSurface(4, out, 0);
+}
+function scaleFluor(surface, k) {
+  if (k <= 0 || !surface.tiles.size) return emptyFluor();
+  if (k >= 1) return new TiledSurface(4, new Map(surface.tiles), 0);
+  const tiles = /* @__PURE__ */ new Map();
+  for (const [key, tile] of surface.tiles) {
+    const src = expand4(tile);
+    const dst = new Uint8ClampedArray(src);
+    for (let i = 3; i < dst.length; i += 4) dst[i] = Math.round(dst[i] * k);
+    const ft = finishTile(dst, 4, 0);
+    if (ft) tiles.set(key, ft);
+  }
+  return new TiledSurface(4, tiles, 0);
+}
+function mergeFourChannel(below, above) {
+  if (!below?.tiles.size && !above?.tiles.size) return null;
+  if (!below?.tiles.size) return new TiledSurface(4, new Map(above.tiles), 0);
+  if (!above?.tiles.size) return new TiledSurface(4, new Map(below.tiles), 0);
+  const keys = /* @__PURE__ */ new Set([...below.tiles.keys(), ...above.tiles.keys()]);
+  const tiles = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const b = below.tiles.get(key);
+    const a = above.tiles.get(key);
+    if (!a) {
+      tiles.set(key, b);
+      continue;
+    }
+    if (!b) {
+      tiles.set(key, a);
+      continue;
+    }
+    const bd = expand4(b);
+    const ad = expand4(a);
+    const dst = new Uint8ClampedArray(TILE * TILE * 4);
+    for (let i = 0; i < dst.length; i += 4) {
+      const sa = ad[i + 3] / 255;
+      const da = bd[i + 3] / 255;
+      const oa = sa + da * (1 - sa);
+      if (oa <= 0) continue;
+      for (let c = 0; c < 3; c++) dst[i + c] = Math.round((ad[i + c] * sa + bd[i + c] * da * (1 - sa)) / oa);
+      dst[i + 3] = Math.round(oa * 255);
+    }
+    const ft = finishTile(dst, 4, 0);
+    if (ft) tiles.set(key, ft);
+  }
+  return tiles.size ? new TiledSurface(4, tiles, 0) : null;
+}
+function fluorIntensitySurface(fluor) {
+  const tiles = /* @__PURE__ */ new Map();
+  for (const [key, tile] of fluor.tiles) {
+    const src = expand4(tile);
+    const dst = new Uint8ClampedArray(TILE * TILE);
+    for (let p = 0; p < TILE * TILE; p++) dst[p] = src[p * 4 + 3];
+    const ft = finishTile(dst, 1, 0);
+    if (ft) tiles.set(key, ft);
+  }
+  return new TiledSurface(1, tiles, 0);
+}
+function computeUvSpill(fluor, strength) {
+  if (!fluor.tiles.size || strength <= 0) return null;
+  const intensity = fluorIntensitySurface(fluor);
+  if (!intensity.tiles.size) return null;
+  return computeSpill(fluor, intensity, { radius: 20, strength: Math.min(2, 0.9 * strength) });
+}
+var UvCache = class {
+  tiles = /* @__PURE__ */ new Map();
+  spillCache = null;
+  render(color, fluor, uv) {
+    if (!uv.on) return color;
+    const uk = uvLightKey(uv);
+    const keys = /* @__PURE__ */ new Set([...color.tiles.keys(), ...fluor ? fluor.tiles.keys() : []]);
+    const out = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const cTile = color.tiles.get(key) ?? null;
+      const fTile = fluor?.tiles.get(key) ?? null;
+      if (!cTile && (!fTile || uv.strength <= 0)) continue;
+      const inputs = [cTile, fTile, uk];
+      const cached = this.tiles.get(key);
+      if (cached && cached.inputs.length === inputs.length && cached.inputs.every((v, i) => v === inputs[i])) {
+        out.set(key, cached.tile);
+        continue;
+      }
+      const cd = cTile ? expand4(cTile) : null;
+      const fd = fTile && uv.strength > 0 ? expand4(fTile) : null;
+      const dst = new Uint8ClampedArray(TILE * TILE * 4);
+      const amb = uv.ambient;
+      const str = uv.strength;
+      for (let i = 0; i < dst.length; i += 4) {
+        const ca = cd ? cd[i + 3] : 0;
+        const fa = fd ? fd[i + 3] : 0;
+        if (ca === 0 && fa === 0) continue;
+        const fGain = fa / 255 * str;
+        const fCov = Math.min(1, fGain);
+        for (let c = 0; c < 3; c++) {
+          const baseLin = ca > 0 ? SRGB_TO_LINEAR[cd[i + c]] * amb : 0;
+          const emLin = fa > 0 ? SRGB_TO_LINEAR[fd[i + c]] * (1 + 1.15 * fGain) : 0;
+          dst[i + c] = linearToSrgb8(baseLin * (1 - fCov * 0.5) + emLin * fCov);
+        }
+        dst[i + 3] = Math.min(255, Math.max(ca, Math.round(fa * Math.min(1, str))));
+      }
+      const ft = finishTile(dst, 4, 0);
+      if (ft) {
+        this.tiles.set(key, { inputs, tile: ft });
+        out.set(key, ft);
+      }
+    }
+    for (const key of [...this.tiles.keys()]) if (!keys.has(key)) this.tiles.delete(key);
+    return new TiledSurface(4, out, color.defaultValue);
+  }
+  spill(fluor, uv) {
+    if (!uv.on || uv.strength <= 0 || !fluor.tiles.size) return null;
+    if (this.spillCache && this.spillCache.fluor === fluor && this.spillCache.strength === uv.strength) {
+      return this.spillCache.surface;
+    }
+    const surface = computeUvSpill(fluor, uv.strength);
+    this.spillCache = { fluor, strength: uv.strength, surface };
+    return surface;
+  }
+};
+var HEAT_SCALE = 4;
+var HEAT_DIFFUSION = 0.18;
+var HEAT_COOLING = 0.03;
+var HEAT_DRY_THRESHOLD = 0.5;
+function createHeatField(width, height) {
+  const gridWidth = Math.max(1, Math.ceil(width / HEAT_SCALE));
+  const gridHeight = Math.max(1, Math.ceil(height / HEAT_SCALE));
+  return {
+    width,
+    height,
+    gridWidth,
+    gridHeight,
+    cells: new Float64Array(gridWidth * gridHeight),
+    max: 0,
+    revision: 0
+  };
+}
+function cloneHeatField(field) {
+  return {
+    width: field.width,
+    height: field.height,
+    gridWidth: field.gridWidth,
+    gridHeight: field.gridHeight,
+    cells: new Float64Array(field.cells),
+    max: field.max,
+    revision: field.revision
+  };
+}
+function distToSegment(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  if (len2 <= 1e-9) return Math.hypot(px - ax, py - ay);
+  const t = Math.min(1, Math.max(0, ((px - ax) * dx + (py - ay) * dy) / len2));
+  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+var round3 = (n) => Math.round(n * 1e3) / 1e3;
+function heatStats(field) {
+  if (!field) return { max: 0, mean: 0, hotCells: 0, bounds: null };
+  let max = 0;
+  let sum = 0;
+  let hot = 0;
+  const n = field.cells.length;
+  for (let i = 0; i < n; i++) {
+    const v = field.cells[i];
+    if (v > max) max = v;
+    sum += v;
+    if (v >= 0.05) hot++;
+  }
+  field.max = round3(max);
+  return {
+    max: field.max,
+    mean: n > 0 ? round3(sum / n) : 0,
+    hotCells: hot,
+    bounds: hot > 0 ? hotCellsBounds(field, 0.05) : null
+  };
+}
+function hotCellsBounds(field, threshold = HEAT_DRY_THRESHOLD) {
+  let x0 = field.gridWidth;
+  let y0 = field.gridHeight;
+  let x1 = -1;
+  let y1 = -1;
+  for (let cy = 0; cy < field.gridHeight; cy++) {
+    for (let cx = 0; cx < field.gridWidth; cx++) {
+      if (field.cells[cy * field.gridWidth + cx] >= threshold) {
+        if (cx < x0) x0 = cx;
+        if (cy < y0) y0 = cy;
+        if (cx > x1) x1 = cx;
+        if (cy > y1) y1 = cy;
+      }
+    }
+  }
+  if (x1 < x0) return null;
+  const rx = x0 * HEAT_SCALE;
+  const ry = y0 * HEAT_SCALE;
+  const rw = Math.min(field.width - rx, (x1 - x0 + 1) * HEAT_SCALE);
+  const rh = Math.min(field.height - ry, (y1 - y0 + 1) * HEAT_SCALE);
+  return rw > 0 && rh > 0 ? { x: rx, y: ry, width: rw, height: rh } : null;
+}
+function paintHeatField(field, points, radius = 32, temperature = 0.85) {
+  const r = Math.min(512, Math.max(1, radius));
+  const temp = Math.min(1, Math.max(0, temperature));
+  const gw = field.gridWidth;
+  const gh = field.gridHeight;
+  let minCx = gw;
+  let minCy = gh;
+  let maxCx = -1;
+  let maxCy = -1;
+  const segCount = Math.max(1, points.length - 1);
+  for (let s = 0; s < segCount; s++) {
+    const a = points[s];
+    const b = points[Math.min(points.length - 1, s + 1)];
+    const x0 = Math.max(0, Math.floor((Math.min(a.x, b.x) - r) / HEAT_SCALE));
+    const y0 = Math.max(0, Math.floor((Math.min(a.y, b.y) - r) / HEAT_SCALE));
+    const x1 = Math.min(gw - 1, Math.ceil((Math.max(a.x, b.x) + r) / HEAT_SCALE));
+    const y1 = Math.min(gh - 1, Math.ceil((Math.max(a.y, b.y) + r) / HEAT_SCALE));
+    for (let cy = y0; cy <= y1; cy++) {
+      const gy = (cy + 0.5) * HEAT_SCALE;
+      for (let cx = x0; cx <= x1; cx++) {
+        const gx = (cx + 0.5) * HEAT_SCALE;
+        const d = distToSegment(gx, gy, a.x, a.y, b.x, b.y);
+        if (d >= r) continue;
+        const u = 1 - d / r;
+        const w = u * u * (3 - 2 * u);
+        const idx = cy * gw + cx;
+        const cur = field.cells[idx];
+        const next = cur + (temp - cur) * w;
+        field.cells[idx] = next < 1e-4 ? 0 : Math.min(1, Math.max(0, next));
+        if (cx < minCx) minCx = cx;
+        if (cy < minCy) minCy = cy;
+        if (cx > maxCx) maxCx = cx;
+        if (cy > maxCy) maxCy = cy;
+      }
+    }
+  }
+  field.revision++;
+  const bounds = maxCx >= minCx ? {
+    x: minCx * HEAT_SCALE,
+    y: minCy * HEAT_SCALE,
+    width: Math.min(field.width - minCx * HEAT_SCALE, (maxCx - minCx + 1) * HEAT_SCALE),
+    height: Math.min(field.height - minCy * HEAT_SCALE, (maxCy - minCy + 1) * HEAT_SCALE)
+  } : { x: 0, y: 0, width: 0, height: 0 };
+  return { bounds, stats: heatStats(field) };
+}
+function advanceHeatField(field, steps = 10) {
+  const n = Math.min(1e3, Math.max(1, Math.round(steps)));
+  const gw = field.gridWidth;
+  const gh = field.gridHeight;
+  let src = field.cells;
+  let dst = new Float64Array(src.length);
+  const decay = 1 - HEAT_COOLING;
+  for (let s = 0; s < n; s++) {
+    for (let y = 0; y < gh; y++) {
+      const yUp = Math.max(0, y - 1) * gw;
+      const yCur = y * gw;
+      const yDn = Math.min(gh - 1, y + 1) * gw;
+      for (let x = 0; x < gw; x++) {
+        const xL = Math.max(0, x - 1);
+        const xR = Math.min(gw - 1, x + 1);
+        const c = src[yCur + x];
+        const avg = (src[yCur + xL] + src[yCur + xR] + src[yUp + x] + src[yDn + x]) * 0.25;
+        const v = (c + HEAT_DIFFUSION * (avg - c)) * decay;
+        dst[yCur + x] = v < 1e-4 ? 0 : v;
+      }
+    }
+    const tmp = src;
+    src = dst;
+    dst = tmp;
+  }
+  if (src !== field.cells) field.cells.set(src);
+  field.revision++;
+  return heatStats(field);
+}
+function clearHeatField(field) {
+  let had = false;
+  for (let i = 0; i < field.cells.length; i++) {
+    if (field.cells[i] > 0) {
+      had = true;
+      field.cells[i] = 0;
+    }
+  }
+  field.max = 0;
+  if (had) field.revision++;
+  return had;
+}
+function sampleHeatAt(field, x, y) {
+  const gx = x / HEAT_SCALE - 0.5;
+  const gy = y / HEAT_SCALE - 0.5;
+  const gw = field.gridWidth;
+  const gh = field.gridHeight;
+  const x0 = Math.max(0, Math.min(gw - 1, Math.floor(gx)));
+  const y0 = Math.max(0, Math.min(gh - 1, Math.floor(gy)));
+  const x1 = Math.max(0, Math.min(gw - 1, x0 + 1));
+  const y1 = Math.max(0, Math.min(gh - 1, y0 + 1));
+  const fx = Math.min(1, Math.max(0, gx - Math.floor(gx)));
+  const fy = Math.min(1, Math.max(0, gy - Math.floor(gy)));
+  const c00 = field.cells[y0 * gw + x0];
+  const c10 = field.cells[y0 * gw + x1];
+  const c01 = field.cells[y1 * gw + x0];
+  const c11 = field.cells[y1 * gw + x1];
+  const top = c00 * (1 - fx) + c10 * fx;
+  const bot = c01 * (1 - fx) + c11 * fx;
+  return top * (1 - fy) + bot * fy;
+}
+function shiftHeatField(field, dx, dy, newWidth, newHeight) {
+  const next = createHeatField(newWidth, newHeight);
+  for (let cy = 0; cy < next.gridHeight; cy++) {
+    const docY = (cy + 0.5) * HEAT_SCALE - dy;
+    if (docY < 0 || docY >= field.height) continue;
+    for (let cx = 0; cx < next.gridWidth; cx++) {
+      const docX = (cx + 0.5) * HEAT_SCALE - dx;
+      if (docX < 0 || docX >= field.width) continue;
+      next.cells[cy * next.gridWidth + cx] = sampleHeatAt(field, docX, docY);
+    }
+  }
+  next.revision = field.revision + 1;
+  heatStats(next);
+  return next;
+}
+var ThermoCache = class {
+  tiles = /* @__PURE__ */ new Map();
+  render(color, thermo, offset, heat) {
+    if (!thermo?.tiles.size) return color;
+    let anyHeat = false;
+    for (let i = 0; i < heat.cells.length; i++) {
+      if (heat.cells[i] > 0) {
+        anyHeat = true;
+        break;
+      }
+    }
+    if (!anyHeat) return color;
+    const out = new Map(color.tiles);
+    const keys = /* @__PURE__ */ new Set();
+    for (const key of color.tiles.keys()) keys.add(key);
+    for (const [key, cTile] of color.tiles) {
+      const tTile = thermo.tiles.get(key);
+      if (!tTile) continue;
+      const inputs = [cTile, tTile, offset.x, offset.y, heat.revision];
+      const cached = this.tiles.get(key);
+      if (cached && cached.inputs.length === inputs.length && cached.inputs.every((v, i) => v === inputs[i])) {
+        out.set(key, cached.tile);
+        continue;
+      }
+      const tx = key % 65536 - 32768;
+      const ty = Math.floor(key / 65536) - 32768;
+      const cd = expand4(cTile);
+      const td = expand4(tTile);
+      const dst = new Uint8ClampedArray(cd);
+      const band = 0.12;
+      for (let y = 0; y < TILE; y++) {
+        const docY = ty * TILE + y + offset.y + 0.5;
+        for (let x = 0; x < TILE; x++) {
+          const i = (y * TILE + x) * 4;
+          const ca = cd[i + 3];
+          const thByte = td[i + 3];
+          if (ca === 0 || thByte === 0) continue;
+          const docX = tx * TILE + x + offset.x + 0.5;
+          const temp = sampleHeatAt(heat, docX, docY);
+          if (temp <= 0) continue;
+          const threshold = thByte / 255;
+          const u = Math.min(1, Math.max(0, (temp - (threshold - band)) / (2 * band)));
+          const t = u * u * (3 - 2 * u);
+          if (t <= 0) continue;
+          dst[i] = Math.round(cd[i] * (1 - t) + td[i] * t);
+          dst[i + 1] = Math.round(cd[i + 1] * (1 - t) + td[i + 1] * t);
+          dst[i + 2] = Math.round(cd[i + 2] * (1 - t) + td[i + 2] * t);
+        }
+      }
+      const shadedTile = { data: dst, uniform: null };
+      this.tiles.set(key, { inputs, tile: shadedTile });
+      out.set(key, shadedTile);
+    }
+    for (const key of [...this.tiles.keys()]) if (!keys.has(key)) this.tiles.delete(key);
+    return new TiledSurface(4, out, color.defaultValue);
+  }
+};
+function fluorToJSON(fluor) {
+  const b = fluor?.bounds;
+  if (!fluor || !b) return null;
+  return { rect: { ...b }, fluor: pngDataUrl(b.width, b.height, readRegion(fluor, b), 4) };
+}
+function fluorFromJSON(raw) {
+  const r = raw;
+  if (!r || typeof r !== "object" || !r.rect || typeof r.fluor !== "string") throw new Error("not a saved fluorescence channel");
+  const parsed = parseDataUrl(r.fluor);
+  if (!parsed) throw new Error("the fluorescence channel is not a PNG data URL");
+  const img = decodePng(parsed.bytes);
+  return surfaceFromPixels({ width: img.width, height: img.height, data: img.data }, 4, r.rect.x, r.rect.y);
+}
+function thermoToJSON(thermo) {
+  const b = thermo?.bounds;
+  if (!thermo || !b) return null;
+  return { rect: { ...b }, thermo: pngDataUrl(b.width, b.height, readRegion(thermo, b), 4) };
+}
+function thermoFromJSON(raw) {
+  const r = raw;
+  if (!r || typeof r !== "object" || !r.rect || typeof r.thermo !== "string") throw new Error("not a saved thermochromic channel");
+  const parsed = parseDataUrl(r.thermo);
+  if (!parsed) throw new Error("the thermochromic channel is not a PNG data URL");
+  const img = decodePng(parsed.bytes);
+  return surfaceFromPixels({ width: img.width, height: img.height, data: img.data }, 4, r.rect.x, r.rect.y);
+}
+function heatToJSON(field) {
+  if (!field) return null;
+  let any = false;
+  for (let i = 0; i < field.cells.length; i++) {
+    if (field.cells[i] > 0) {
+      any = true;
+      break;
+    }
+  }
+  if (!any) return null;
+  return {
+    gridWidth: field.gridWidth,
+    gridHeight: field.gridHeight,
+    cells: Array.from(field.cells, (v) => Math.round(v * 1e4) / 1e4)
+  };
+}
+function heatFromJSON(raw, width, height) {
+  const r = raw;
+  if (!r || typeof r !== "object" || typeof r.gridWidth !== "number" || typeof r.gridHeight !== "number" || !Array.isArray(r.cells)) {
+    return null;
+  }
+  const field = createHeatField(width, height);
+  if (r.gridWidth === field.gridWidth && r.gridHeight === field.gridHeight && r.cells.length === field.cells.length) {
+    for (let i = 0; i < field.cells.length; i++) {
+      const v = r.cells[i];
+      field.cells[i] = typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 0;
+    }
+    field.revision = 1;
+    heatStats(field);
+  }
+  return field;
+}
+
 // src/paint-editor/procedural.ts
 var STEP_PX = 1.5;
 var MarkStroke = class {
@@ -1223,6 +2015,7 @@ var MarkStroke = class {
       if (color && color.alpha < 1) for (let k = 0; k < n; k++) vals[k] *= color.alpha;
       this.coverage.accumulate(rect, vals, opacity, color ? color.rgb : null);
     }
+    if (this.brush.iridescence && this.options.film) this.options.film.deposit(rect, vals, opacity * this.brush.tip.opacity, this.brush.iridescence, pressure);
     rects.push(rect);
     this.dabCount++;
   }
@@ -2116,8 +2909,11 @@ var PaintStrokeSession = class _PaintStrokeSession {
     this.live = new Map(this.base.tiles);
     this.copies = init.copies.length ? init.copies : [IDENTITY_COPY];
     const brush = init.brush;
+    this.invisibleDaylight = brush.fluorescence.amount > 0 && brush.fluorescence.invisible && brush.engine !== "eraser" && brush.engine !== "blender" && brush.engine !== "smudge";
     if (init.wet) this.wetDriver = init.wet.driver;
     if (init.light && !init.wet && !init.sticker) this.lightTwin = this.makeLightTwin(init.light.surface);
+    if (init.fluor && !init.wet && !init.sticker) this.fluorTwin = this.makeFluorTwin(init.fluor.surface);
+    if (init.thermo && !init.wet && !init.sticker) this.thermoTwin = this.makeThermoTwin(init.thermo.surface);
     this.apply = {
       mode: brush.engine === "eraser" ? "erase" : "paint",
       color: init.color,
@@ -2143,10 +2939,18 @@ var PaintStrokeSession = class _PaintStrokeSession {
   wet = null;
   wetDriver = null;
   thickDriver = null;
+  filmBuffer = null;
   stickerSpray = null;
   /** Light paint: the stroke's twin over the light channel, and what it left there. */
   lightTwin = null;
   lightResult = null;
+  /** UV-fluorescent ink: the stroke's twin over the fluorescence channel, and what it left there. */
+  fluorTwin = null;
+  fluorResult = null;
+  /** Thermochromic ink: the stroke's twin over the thermochromic channel, and what it left there. */
+  thermoTwin = null;
+  thermoResult = null;
+  invisibleDaylight;
   /** A wet stroke that ended while the simulation was mid-batch: it commits when the driver catches up. */
   wetEndPending = false;
   apply;
@@ -2161,30 +2965,36 @@ var PaintStrokeSession = class _PaintStrokeSession {
   build(effect) {
     const init = this.init;
     const brush = init.brush;
-    this.dry = this.wet = this.thickDriver = this.stickerSpray = null;
+    this.dry = this.wet = this.thickDriver = this.stickerSpray = this.filmBuffer = null;
     if (init.sticker) {
       this.stickerSpray = new StickerSpray({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: init.paint ?? null, effect, art: init.sticker.art, variant: init.sticker.variant });
-    } else if (init.thick) {
+    } else if (brush.engine === "impasto" && init.thick) {
       const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
       this.thickDriver = new ThickStrokeDriver({ brush, target: this.tileTarget(), channels: init.thick.channels, color: rgb(init.color), load: init.mixerLoad, seed: init.seed, copies: this.copies, paint: init.paint ?? null, effect });
-    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || usesPaintExchange(brush, Boolean(init.paint))) {
-      const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
-      this.wet = new PaintDabStroke(brush, {
-        target: this.tileTarget(),
-        color: rgb(init.color),
-        secondary: rgb(init.secondary ?? init.background),
-        load: init.mixerLoad,
-        grain: init.grain,
-        paperDepth: init.paperDepth,
-        seed: init.seed,
-        copies: this.copies,
-        paint: init.paint ?? null,
-        effect,
-        stampArt: init.stampArt
-      });
     } else {
-      const opts = { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies, paint: init.paint ?? null, effect, stampArt: init.stampArt };
-      this.dry = brush.engine === "particle" ? new ParticleStroke(brush, opts) : brush.engine === "bristle" ? new BristleStroke(brush, opts) : new DryStroke(brush, opts);
+      if (init.thick && (brush.iridescence || brush.engine === "eraser")) {
+        this.filmBuffer = new FilmBuffer(init.thick.channels.film, init.offset, init.selection ?? null);
+      }
+      if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || usesPaintExchange(brush, Boolean(init.paint))) {
+        const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
+        this.wet = new PaintDabStroke(brush, {
+          target: this.tileTarget(),
+          color: rgb(init.color),
+          secondary: rgb(init.secondary ?? init.background),
+          load: init.mixerLoad,
+          grain: init.grain,
+          paperDepth: init.paperDepth,
+          seed: init.seed,
+          copies: this.copies,
+          paint: init.paint ?? null,
+          effect,
+          stampArt: init.stampArt,
+          film: this.filmBuffer
+        });
+      } else {
+        const opts = { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies, paint: init.paint ?? null, effect, stampArt: init.stampArt, film: this.filmBuffer };
+        this.dry = brush.engine === "particle" ? new ParticleStroke(brush, opts) : brush.engine === "bristle" ? new BristleStroke(brush, opts) : new DryStroke(brush, opts);
+      }
     }
   }
   /**
@@ -2228,16 +3038,83 @@ var PaintStrokeSession = class _PaintStrokeSession {
       secondary: [grey, grey, grey, 255],
       inputFilter: void 0,
       mixerLoad: { reservoir: init.mixerLoad.reservoir ? [g, g, g] : null, amount: init.mixerLoad.amount, pickup: null },
-      thick: init.thick,
+      thick: void 0,
       paint,
       effect,
-      light: null
+      light: null,
+      fluor: null,
+      thermo: null
+    });
+  }
+  /** The stroke's twin over the 4-channel fluorescence surface (see `heat.ts`). */
+  makeFluorTwin(fluor) {
+    const init = this.init;
+    const host = {
+      update: (_id, surface) => {
+        this.fluorResult = surface;
+      },
+      commit: (_s, surface) => {
+        this.fluorResult = surface;
+      }
+    };
+    return new _PaintStrokeSession(host, {
+      ...init,
+      surface: fluor,
+      lockTransparency: false,
+      brush: fluorTwinBrush(init.brush),
+      inputFilter: void 0,
+      light: null,
+      fluor: null,
+      thermo: null
+    });
+  }
+  /** The stroke's twin over the 4-channel thermochromic surface (see `heat.ts`). */
+  makeThermoTwin(thermo) {
+    const init = this.init;
+    const hotHex = init.brush.thermochromic.hotColor;
+    const hotRgb = hotHex ? hexToRgb8(hotHex) : [0, 0, 0];
+    const threshold = init.brush.thermochromic.threshold;
+    const host = {
+      update: (_id, surface) => {
+        this.thermoResult = hotHex ? finalizeThermoStroke(surface, thermo, hotRgb, threshold) : surface;
+      },
+      commit: (_s, surface) => {
+        if (!surface) {
+          this.thermoResult = null;
+          return;
+        }
+        this.thermoResult = hotHex ? finalizeThermoStroke(surface, thermo, hotRgb, threshold) : surface;
+      }
+    };
+    return new _PaintStrokeSession(host, {
+      ...init,
+      surface: hotHex ? emptyThermo() : thermo,
+      lockTransparency: false,
+      brush: thermoTwinBrush(init.brush),
+      color: [hotRgb[0], hotRgb[1], hotRgb[2], 255],
+      colorHex: hotHex ?? "#000000",
+      secondary: [hotRgb[0], hotRgb[1], hotRgb[2], 255],
+      inputFilter: void 0,
+      mixerLoad: hotHex ? { reservoir: [hotRgb[0] / 255, hotRgb[1] / 255, hotRgb[2] / 255], amount: 1, pickup: null } : init.mixerLoad,
+      paint: null,
+      effect: null,
+      light: null,
+      fluor: null,
+      thermo: null
     });
   }
   /** Light paint: the layer's light channel after the stroke, or `null` when the stroke has no twin or left it unchanged. */
   lightChannel() {
     return this.lightResult;
   }
+  /** UV-fluorescent ink: the layer's fluorescence channel after the stroke, or `null` when unchanged. */
+  fluorChannel() {
+    return this.fluorResult;
+  }
+  /** Thermochromic ink: the layer's thermochromic channel after the stroke, or `null` when unchanged. */
+  thermoChannel() {
+    return this.thermoResult;
+  }
   tileTarget() {
     return {
       offset: this.init.offset,
@@ -2268,6 +3145,8 @@ var PaintStrokeSession = class _PaintStrokeSession {
     this.lastRaw = points[points.length - 1];
     this.host.sampled?.(this, points);
     this.lightTwin?.push(points);
+    this.fluorTwin?.push(points);
+    this.thermoTwin?.push(points);
     if (this.wetDriver) {
       this.wetUpdate(this.wetDriver.push(points));
       return;
@@ -2278,9 +3157,12 @@ var PaintStrokeSession = class _PaintStrokeSession {
   stickers() {
     return this.stickerSpray ? this.stickerSpray.stickers.map((s) => ({ ...s })) : null;
   }
-  /** Impasto strokes: the layer's thick-paint channels with the stroke so far. */
+  /** Impasto or iridescent strokes: the layer's thick-paint channels with the stroke so far. */
   thickChannels() {
-    return this.thickDriver?.channels() ?? null;
+    if (this.thickDriver) return this.thickDriver.channels();
+    const f = this.filmBuffer ?? this.wetDriver?.init.film ?? null;
+    if (f && this.init.thick) return { ...this.init.thick.channels, film: f.surface() };
+    return null;
   }
   /** Shows a wet stroke's progress (the wet layer's display). */
   wetUpdate(rects) {
@@ -2299,6 +3181,8 @@ var PaintStrokeSession = class _PaintStrokeSession {
     this.finishWet();
   }
   finishWet() {
+    if (this.fluorTwin?.open) this.fluorTwin.end();
+    if (this.thermoTwin?.open) this.thermoTwin.end();
     const d = this.wetDriver;
     const changed = d.dabCount > 0;
     this.result = { layerId: this.layerId, bounds: changed ? d.bounds : null, dabs: d.dabCount, strokeId: null, wet: true };
@@ -2309,6 +3193,10 @@ var PaintStrokeSession = class _PaintStrokeSession {
   update(rects) {
     if (!rects.length) return;
     for (const r of rects) this.bounds = union(this.bounds, r);
+    if (this.invisibleDaylight) {
+      this.host.update(this.layerId, this.base, rects);
+      return;
+    }
     const ch = this.base.channels;
     if (!this.dry) {
       for (const key of this.fresh) this.live.set(key, { data: this.live.get(key).data, uniform: null });
@@ -2350,18 +3238,24 @@ var PaintStrokeSession = class _PaintStrokeSession {
     this.update(this.dry ? this.dry.finish() : this.thickDriver ? this.thickDriver.finish() : this.stickerSpray ? this.stickerSpray.finish() : this.wet.finish());
     this.closed = true;
     if (this.lightTwin?.open) this.lightTwin.end();
+    if (this.fluorTwin?.open) this.fluorTwin.end();
+    if (this.thermoTwin?.open) this.thermoTwin.end();
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
     let changed = false;
-    for (const key of this.touched) {
-      const tile = finishTile(this.live.get(key).data, ch, this.base.defaultValue);
-      const prev = this.base.tiles.get(key);
-      if (tile) tiles.set(key, tile);
-      else tiles.delete(key);
-      if (!sameTile(prev, tile)) changed = true;
+    if (this.invisibleDaylight) {
+      changed = this.fluorResult !== null || this.thermoResult !== null || this.lightResult !== null;
+    } else {
+      for (const key of this.touched) {
+        const tile = finishTile(this.live.get(key).data, ch, this.base.defaultValue);
+        const prev = this.base.tiles.get(key);
+        if (tile) tiles.set(key, tile);
+        else tiles.delete(key);
+        if (!sameTile(prev, tile)) changed = true;
+      }
     }
     if (this.thickDriver && this.thickDriver.dabCount > 0) changed = true;
-    const surface = changed ? new TiledSurface(ch, tiles, this.base.defaultValue) : null;
+    const surface = changed ? this.invisibleDaylight ? this.base : new TiledSurface(ch, tiles, this.base.defaultValue) : null;
     const dabs = this.dry ? this.dry.dabCount : this.thickDriver ? this.thickDriver.dabCount : this.stickerSpray ? this.stickerSpray.dabCount : this.wet.dabCount;
     this.result = { layerId: this.layerId, bounds: changed ? this.bounds : null, dabs, strokeId: null };
     if (this.stickerSpray?.skipped.size) this.result.skippedStickers = [...this.stickerSpray.skipped];
@@ -2375,7 +3269,11 @@ var PaintStrokeSession = class _PaintStrokeSession {
     if (this.closed) return;
     this.closed = true;
     if (this.lightTwin?.open) this.lightTwin.cancel();
+    if (this.fluorTwin?.open) this.fluorTwin.cancel();
+    if (this.thermoTwin?.open) this.thermoTwin.cancel();
     this.lightResult = null;
+    this.fluorResult = null;
+    this.thermoResult = null;
     this.host.commit(this, null, true);
   }
 };
@@ -3105,6 +4003,7 @@ function paintWetTestStroke(brush, paper, color, width, height) {
     w.paint("thumb", { x: 0, y: 0, width, height: half }, null, 0.4, Array.from(pigmentOf([r / 255, g / 255, b / 255], 0), (v) => v * 0.05));
     w.paint("thumb", { x: 0, y: half, width, height: height - half }, null, 0.4, Array.from(pigmentOf([232 / 255, 196 / 255, 64 / 255], 0), (v) => v * 0.05));
   }
+  const film = brush.iridescence && brush.wet.tool === "paint" ? new FilmBuffer(emptySurface(4, 0)) : null;
   const driver = new WetStrokeDriver({
     world: w,
     laneId: "thumb",
@@ -3115,12 +4014,14 @@ function paintWetTestStroke(brush, paper, color, width, height) {
     paperDepth: paper.depth,
     paperColor: hexToRgb8(paper.color),
     seed: 7,
-    copies: [IDENTITY_COPY]
+    copies: [IDENTITY_COPY],
+    film
   });
   driver.push(thumbnailStroke(width, height));
   driver.finish();
   if (brush.wet.tool === "blow") w.stepSync(4);
-  return w.display("thumb").surface;
+  const surf = w.display("thumb").surface;
+  return film ? new LitCache().lit(surf, { ...emptyThickChannels(), film: film.surface() }, DEFAULT_LIGHTING) : surf;
 }
 function thumbnailStroke(width, height) {
   const pts = [];
@@ -3139,6 +4040,7 @@ function paintTestStroke(surface, brush, paper, color, width, height, stampArt)
   let result = surface;
   let thick = null;
   let light = null;
+  let fluor = null;
   const session = new PaintStrokeSession(
     {
       update: () => {
@@ -3147,6 +4049,7 @@ function paintTestStroke(surface, brush, paper, color, width, height, stampArt)
         result = s ?? result;
         thick = sess.thickChannels();
         light = sess.lightChannel();
+        fluor = sess.fluorChannel();
       }
     },
     {
@@ -3164,16 +4067,19 @@ function paintTestStroke(surface, brush, paper, color, width, height, stampArt)
       affineCopies: [],
       copies: [IDENTITY_COPY],
       mixerLoad: brushLoadForStroke(brush, EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]),
-      thick: brush.engine === "impasto" ? { channels: emptyThickChannels() } : void 0,
+      thick: brush.engine === "impasto" || brush.iridescence ? { channels: emptyThickChannels() } : void 0,
       sticker: brush.engine === "sticker" ? { nextId: 1 } : void 0,
       light: brush.light.amount > 0 && brush.engine !== "wet" && brush.engine !== "sticker" ? { surface: emptyLight() } : null,
+      fluor: brush.fluorescence.amount > 0 && brush.engine !== "wet" && brush.engine !== "sticker" ? { surface: emptyFluor() } : null,
       stampArt
     }
   );
   session.push(thumbnailStroke(width, height));
   session.end();
   const lit = thick ? new LitCache().lit(result, thick, DEFAULT_LIGHTING) : result;
-  return { surface: light || thick ? new LightCache().glow(lit, light ?? void 0, thick ?? void 0) : lit, light };
+  const glowed = light || thick ? new LightCache().glow(lit, light ?? void 0, thick ?? void 0) : lit;
+  const uvLit = fluor ? new UvCache().render(glowed, fluor, { on: true, strength: 1, ambient: 0.15 }) : glowed;
+  return { surface: uvLit, light, fluor };
 }
 function renderBrushThumbnail(brush, options) {
   const width = Math.max(16, Math.min(512, Math.round(options.width ?? 160)));
@@ -3191,11 +4097,12 @@ function renderBrushThumbnail(brush, options) {
     surface = fillRect(surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
   }
   let light = null;
+  let fluor = null;
   if (b.engine === "wet") surface = paintWetTestStroke(b, options.paper, options.color, width, height);
-  else ({ surface, light } = paintTestStroke(surface, b, options.paper, options.color, width, height, options.stampArt));
+  else ({ surface, light, fluor } = paintTestStroke(surface, b, options.paper, options.color, width, height, options.stampArt));
   const layer = { type: "pixel", id: "thumbnail", name: "thumbnail", visible: true, opacity: 1, blend: "normal", surface, offset: { x: 0, y: 0 } };
-  const paper = light && brushPreviewsOnDark(b) ? { ...options.paper, color: BRUSH_PREVIEW_DARK_PAPER } : options.paper;
-  const spill = light ? computeSpill(surface, light, { radius: Math.max(4, height / 6), strength: 1 }) : null;
+  const paper = (light || fluor) && brushPreviewsOnDark(b) ? { ...options.paper, color: BRUSH_PREVIEW_DARK_PAPER } : options.paper;
+  const spill = light ? computeSpill(surface, light, { radius: Math.max(4, height / 6), strength: 1 }) : fluor ? computeUvSpill(fluor, 1) : null;
   const layers = [paperNode(paper), layer];
   if (spill) layers.push({ type: "pixel", id: "thumbnail-light", name: "light", visible: true, opacity: 1, blend: "linear-dodge", surface: spill, offset: { x: 0, y: 0 } });
   const data = createPaintCompositor().composite(layers, { x: 0, y: 0, width, height }, { width, height });
@@ -3725,6 +4632,8 @@ function engineChanges(base, next) {
     return JSON.stringify(a) === JSON.stringify(b) ? void 0 : copyJSON(b);
   };
   const { id: _i, builtin: _b, ...rest } = diff(base, next) ?? {};
+  if (base.iridescence && !next.iridescence) rest.iridescence = null;
+  if (base.tipGrain && !next.tipGrain) rest.tipGrain = null;
   return rest;
 }
 
@@ -3851,7 +4760,10 @@ function liveStrokeRefusal(brush) {
     case "smudge":
       return `The ${brush.name} brush moves the paint under it, so it can't be redrawn on its own; rasterize the layer first (rasterize_stroke_layer) or blend on a pixel layer.`;
   }
+  if (brush.mutation) return `The ${brush.name} brush paints mutation strokes (which fade once an agent reads them), so it goes on a pixel layer (add_layer).`;
   if (brush.light.amount > 0) return `The ${brush.name} brush lays light, which a stroke layer doesn't redraw yet; paint light on a pixel layer (add_layer), or set light.amount to 0 (set_brush).`;
+  if (brush.fluorescence.amount > 0) return `The ${brush.name} brush lays UV-fluorescent ink, which a stroke layer doesn't redraw yet; paint it on a pixel layer (add_layer), or set fluorescence.amount to 0 (set_brush).`;
+  if (brush.thermochromic.hotColor !== null) return `The ${brush.name} brush lays thermochromic ink, which a stroke layer doesn't redraw yet; paint it on a pixel layer (add_layer), or remove thermochromic (set_brush).`;
   if (brush.behavior.pickup > 0) return `The ${brush.name} brush picks up the paint under it (pickup ${brush.behavior.pickup}), so it can't be redrawn on its own; set behavior.pickup to 0 (set_brush) or paint on a pixel layer.`;
   return null;
 }
@@ -4179,6 +5091,15 @@ async function replayPainting(source, target, options = {}) {
             if (e.layerId && target.getLayer(e.layerId)) target.wetPaper({ layerId: e.layerId, rect: sr(d.rect), amount: d.amount });
             break;
           }
+          case "ghost-release": {
+            const d = e.data;
+            if (e.layerId && target.getLayer(e.layerId)) target.wet.releaseGhost(e.layerId, d?.linger);
+            break;
+          }
+          case "ghost-keep": {
+            if (e.layerId && target.getLayer(e.layerId)) target.wet.keepGhost(e.layerId);
+            break;
+          }
         }
       } catch {
       }
@@ -4421,6 +5342,27 @@ function effectLayersToJSON(map, keep) {
   return Object.keys(out).length ? out : void 0;
 }
 
+// src/paint-editor/mutation.ts
+function mutationBrushRefusal(brush) {
+  if (!brush.mutation) return null;
+  if (brush.engine === "eraser" || brush.engine === "blender" || brush.engine === "smudge" || brush.engine === "mixer" || brush.engine === "sticker") {
+    return `Mutation paint adds strokes that fade when an agent reads them; ${brush.engine} brushes cannot use mutation.`;
+  }
+  if ((brush.behavior?.pickup ?? 0) > 0 || brush.behavior?.dirty) {
+    return "Mutation brushes cannot pick up canvas colour (behavior.pickup must be 0 and behavior.dirty false).";
+  }
+  if (brush.engine === "wet") {
+    const tool = brush.wet?.tool ?? "paint";
+    if (tool !== "paint") {
+      return `Wet mutation brushes must use wet.tool: "paint" (got "${tool}").`;
+    }
+    if ((brush.light?.amount ?? 0) > 0) {
+      return "Wet mutation brushes use the wet light channel to track fading paint, so light.amount must be 0.";
+    }
+  }
+  return null;
+}
+
 // src/paint-editor/collaboration.ts
 var LAYER_FIELDS = ["name", "visible", "opacity", "blend"];
 function createPaintChangeFeed(controller, options = {}) {
@@ -5392,9 +6334,17 @@ var PaintEditorController = class _PaintEditorController {
   wetOptions;
   /** Where the light comes from for thick paint (saved with the document, not undo steps). */
   lighting = { ...DEFAULT_LIGHTING };
+  /** Where the viewer looks from for thin-film iridescence and specular highlights (editor state, not saved with the document). */
+  viewTilt = { ...DEFAULT_VIEW_TILT };
   litCaches = /* @__PURE__ */ new Map();
   /** The live impasto stroke's channels. */
   liveThick = null;
+  /** The UV / blacklight setting (saved with the document, not undo steps). */
+  uvLight = { ...DEFAULT_UV_LIGHT };
+  uvCaches = /* @__PURE__ */ new Map();
+  thermoCaches = /* @__PURE__ */ new Map();
+  liveFluor = null;
+  liveThermo = null;
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
   wetOp = null;
   /** The effects provider slot (see `setEffectsProvider`). */
@@ -5409,6 +6359,15 @@ var PaintEditorController = class _PaintEditorController {
   rasterizeSticker;
   effectsRenderer = new PaintEffectsRenderer();
   paperEffectNodeCache = null;
+  mutations = [];
+  nextMutationId = 1;
+  mutationListeners = /* @__PURE__ */ new Set();
+  mutationAgentConnected = false;
+  mutationDirector = null;
+  heldEvaporation = /* @__PURE__ */ new Map();
+  tempLayerTargets = /* @__PURE__ */ new Map();
+  answeringMutation = false;
+  lastMutationTick = null;
   constructor(options = {}) {
     this.historyLimit = Math.max(1, options.historyLimit ?? 200);
     this.rasterizeSticker = options.rasterizeSticker ?? defaultStickerRasterizer;
@@ -5673,6 +6632,7 @@ var PaintEditorController = class _PaintEditorController {
       effectPaintRendering: Boolean(this.effectPaintPending || this.pathStroke),
       mixerLoad: this.mixerLoad,
       view: this.view,
+      viewTilt: { ...this.viewTilt },
       hand: this.hand,
       effectPlayback: { ...this.effectPlaybackState, time: this.effectTime },
       selectedStroke: this.selectedStroke,
@@ -5698,6 +6658,10 @@ var PaintEditorController = class _PaintEditorController {
         gpu: this.wet.gpuMode,
         gpuActive: Boolean(this.wet.world?.gpuActive)
       },
+      uvLight: { ...this.uvLight },
+      heat: heatStats(this.doc.heat),
+      mutations: this.mutations.map((m) => this.toMutationInfo(m)),
+      hasMutationAgent: this.mutationListeners.size > 0 || this.mutationAgentConnected,
       version: this.version
     };
     return this.cached;
@@ -5804,7 +6768,10 @@ var PaintEditorController = class _PaintEditorController {
     const wetIds = ids.filter((id) => this.wet.wetLayerIds().includes(id));
     if (!wetIds.length) return [];
     this.beginWetOp();
-    for (const id of wetIds) this.wet.dry(id);
+    for (const id of wetIds) {
+      this.wet.dry(id);
+      this.finishWetMutationsOnDry(id);
+    }
     this.logWet({ kind: "dry", layerId: wetIds.join(",") });
     return wetIds;
   }
@@ -5840,6 +6807,7 @@ var PaintEditorController = class _PaintEditorController {
       this.wet.restore(e.wet.lost ? null : e.wet.before);
       if (paper !== this.doc.paper) this.wet.paperChanged();
     }
+    this.reconcileMutationsAfterUndo();
     this.notifyCommit({ kind: "undo", label: e.label, origin: this.getOrigin() });
     this.emit();
     return e.label;
@@ -5896,6 +6864,7 @@ var PaintEditorController = class _PaintEditorController {
       this.beginWetOp();
       this.wet.reset();
     }
+    this.resetMutations();
     this.commit("New canvas", next);
     return next;
   }
@@ -5907,11 +6876,13 @@ var PaintEditorController = class _PaintEditorController {
       height: update.height ?? this.doc.canvas.height,
       dpi: update.dpi ?? this.doc.canvas.dpi
     });
-    if (this.wet.world && (canvas.width !== this.doc.canvas.width || canvas.height !== this.doc.canvas.height)) {
+    const resized = canvas.width !== this.doc.canvas.width || canvas.height !== this.doc.canvas.height;
+    if (this.wet.world && resized) {
       this.dryLayersFirst(this.wet.wetLayerIds());
       this.wet.reset();
     }
-    this.commit("Canvas size", this.withWetEvents({ ...this.doc, canvas }));
+    const heat = resized && this.doc.heat ? shiftHeatField(this.doc.heat, canvas.width, canvas.height, 0, 0) : this.doc.heat;
+    this.commit("Canvas size", this.withWetEvents({ ...this.doc, canvas, ...heat ? { heat } : {} }));
     return canvas;
   }
   /**
@@ -5956,9 +6927,30 @@ var PaintEditorController = class _PaintEditorController {
       }
     }
     let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
+    if (next.heat) next = { ...next, heat: shiftHeatField(next.heat, left, top, width, height) };
     for (const id of keptWet) {
       const l = findLayer(next.layers, id)?.layer;
-      if (isPixelLayer(l)) next = { ...next, layers: mapLayer(next.layers, id, () => ({ ...l, surface: translateSurface(l.surface, l.offset.x, l.offset.y), offset: { x: 0, y: 0 } })) };
+      if (isPixelLayer(l)) {
+        const ox = l.offset.x;
+        const oy = l.offset.y;
+        next = { ...next, layers: mapLayer(next.layers, id, () => ({ ...l, surface: translateSurface(l.surface, ox, oy), offset: { x: 0, y: 0 } })) };
+        const tc = next.thick?.[id];
+        if (tc && (ox || oy)) {
+          next = {
+            ...next,
+            thick: {
+              ...next.thick,
+              [id]: {
+                height: translateSurface(tc.height, ox, oy),
+                material: translateSurface(tc.material, ox, oy),
+                film: translateSurface(tc.film, ox, oy)
+              }
+            }
+          };
+        }
+        if (next.fluor?.[id] && (ox || oy)) next = { ...next, fluor: { ...next.fluor, [id]: translateSurface(next.fluor[id], ox, oy) } };
+        if (next.thermo?.[id] && (ox || oy)) next = { ...next, thermo: { ...next.thermo, [id]: translateSurface(next.thermo[id], ox, oy) } };
+      }
     }
     if (this.wet.world) {
       if (keptWet.length) this.wet.extend(width, height, left, top, next.paper);
@@ -6023,7 +7015,7 @@ var PaintEditorController = class _PaintEditorController {
   describeLayer(l, parentId = findLayer(this.doc.layers, l.id)?.parent?.id ?? null, depth = findLayer(this.doc.layers, l.id)?.path.length ?? 0) {
     let bounds = null;
     if (l.type === "pixel") {
-      const b = contentBounds(l.surface);
+      const b = unionRect(contentBounds(l.surface), this.doc.fluor?.[l.id] ? contentBounds(this.doc.fluor[l.id]) : null);
       bounds = b ? { ...b, x: b.x + l.offset.x, y: b.y + l.offset.y } : null;
     } else for (const c of flattenLayers(l.children)) if (c.type === "pixel") bounds = unionRect(bounds, this.describeLayer(c, l.id, depth + 1).bounds);
     return {
@@ -6039,6 +7031,7 @@ var PaintEditorController = class _PaintEditorController {
       bounds,
       ...this.doc.liveStrokes?.[l.id] ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
       ...l.effects?.items.length ? { effects: l.effects.items.length } : {},
+      ...l.type === "pixel" && l.temporary ? { temporary: true } : {},
       parentId,
       depth
     };
@@ -6059,7 +7052,8 @@ var PaintEditorController = class _PaintEditorController {
     return l;
   }
   setActiveLayer(id) {
-    this.requireLayer(id);
+    const l = this.requireLayer(id);
+    if (isPixelLayer(l) && l.temporary) throw new PaintEditorError("Temporary mutation layers fade away on their own; paint on the layer below.");
     if (this.doc.activeLayerId === id) return;
     this.doc = { ...this.doc, activeLayerId: id };
     this.emit();
@@ -6212,7 +7206,18 @@ var PaintEditorController = class _PaintEditorController {
     const layers = mapLayer(this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
     if (active && !findLayer(layers, active)) active = flattenLayers(layers).filter((x) => x.type === "pixel").pop()?.id ?? null;
-    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(flattenLayers([l]).map((x) => x.id)), ...this.stickersWithout(flattenLayers([l]).map((x) => x.id)), ...this.liveStrokesWithout(flattenLayers([l]).map((x) => x.id)), ...this.lightWithout(flattenLayers([l]).map((x) => x.id)) });
+    const removedIds = flattenLayers([l]).map((x) => x.id);
+    this.commit("Remove layer", {
+      ...this.doc,
+      layers,
+      activeLayerId: active,
+      ...this.thickWithout(removedIds),
+      ...this.stickersWithout(removedIds),
+      ...this.liveStrokesWithout(removedIds),
+      ...this.lightWithout(removedIds),
+      ...this.fluorWithout(removedIds),
+      ...this.thermoWithout(removedIds)
+    });
     return { removed: id, activeLayerId: active };
   }
   duplicateLayer(id) {
@@ -6227,10 +7232,14 @@ var PaintEditorController = class _PaintEditorController {
     const stickers = { ...this.doc.stickers ?? {} };
     const liveStrokes = { ...this.doc.liveStrokes ?? {} };
     const light = { ...this.doc.light ?? {} };
+    const fluor = { ...this.doc.fluor ?? {} };
+    const thermo = { ...this.doc.thermo ?? {} };
     const copy = (l) => {
       const id2 = newPaintLayerId();
       if (light[l.id]) light[id2] = light[l.id];
       if (this.lightSpills[l.id]) this.lightSpills[id2] = { ...this.lightSpills[l.id] };
+      if (fluor[l.id]) fluor[id2] = fluor[l.id];
+      if (thermo[l.id]) thermo[id2] = thermo[l.id];
       if (thick[l.id]) thick[id2] = thick[l.id];
       if (stickers[l.id]) stickers[id2] = stickers[l.id].map((x) => ({ ...x }));
       if (liveStrokes[l.id]) liveStrokes[id2] = liveStrokes[l.id].map((x) => ({ ...x, id: `s${this.strokeCounter++}`, layerId: id2 }));
@@ -6238,7 +7247,20 @@ var PaintEditorController = class _PaintEditorController {
     };
     const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
     const layers = insertLayer(this.doc.layers, dup, loc.parent?.id ?? null, loc.index + 1);
-    this.commit("Duplicate layer", this.withWetEvents({ ...this.doc, layers, activeLayerId: dup.id, ...this.doc.thick ? { thick } : {}, ...this.doc.stickers ? { stickers } : {}, ...this.doc.liveStrokes ? { liveStrokes } : {}, ...this.doc.light ? { light } : {} }));
+    this.commit(
+      "Duplicate layer",
+      this.withWetEvents({
+        ...this.doc,
+        layers,
+        activeLayerId: dup.id,
+        ...this.doc.thick ? { thick } : {},
+        ...this.doc.stickers ? { stickers } : {},
+        ...this.doc.liveStrokes ? { liveStrokes } : {},
+        ...this.doc.light ? { light } : {},
+        ...this.doc.fluor ? { fluor } : {},
+        ...this.doc.thermo ? { thermo } : {}
+      })
+    );
     return this.describeLayer(dup);
   }
   /** Moves a layer to `index` (0 = bottom) within `parentId` (default its own parent; `null` = top level). */
@@ -6285,10 +7307,30 @@ var PaintEditorController = class _PaintEditorController {
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = mapLayer(mapLayer(this.doc.layers, upper.id, () => null), below.id, () => merged);
     const toDoc = (t, l) => t ? translateSurface(t, l.offset.x, l.offset.y) : void 0;
-    const mergedLight = this.doc.light?.[upper.id] || this.doc.light?.[below.id] ? mergeLight(toDoc(this.doc.light?.[below.id], below), upper.visible ? toDoc(this.doc.light?.[upper.id], upper) : void 0, translateSurface(upper.surface, upper.offset.x, upper.offset.y)) : void 0;
+    const upperDoc = translateSurface(upper.surface, upper.offset.x, upper.offset.y);
+    const mergedLight = this.doc.light?.[upper.id] || this.doc.light?.[below.id] ? mergeLight(toDoc(this.doc.light?.[below.id], below), upper.visible ? toDoc(this.doc.light?.[upper.id], upper) : void 0, upperDoc) : void 0;
     const lightAfter = this.lightWithout([upper.id, below.id]).light ?? (this.doc.light ? { ...this.doc.light } : void 0);
     const light = mergedLight ? { ...lightAfter ?? {}, [below.id]: mergedLight } : lightAfter;
-    this.commit("Merge down", this.withWetEvents({ ...this.doc, layers, activeLayerId: below.id, ...this.thickWithout([upper.id]), ...this.stickersWithout([upper.id, below.id]), ...this.liveStrokesWithout([upper.id, below.id]), ...light ? { light } : {} }));
+    const mergedFluor = this.doc.fluor?.[upper.id] || this.doc.fluor?.[below.id] ? mergeFourChannel(toDoc(this.doc.fluor?.[below.id], below), upper.visible ? toDoc(this.doc.fluor?.[upper.id], upper) : void 0) : void 0;
+    const fluorAfter = this.fluorWithout([upper.id, below.id]).fluor ?? (this.doc.fluor ? { ...this.doc.fluor } : void 0);
+    const fluor = mergedFluor ? { ...fluorAfter ?? {}, [below.id]: mergedFluor } : fluorAfter;
+    const mergedThermo = this.doc.thermo?.[upper.id] || this.doc.thermo?.[below.id] ? mergeFourChannel(toDoc(this.doc.thermo?.[below.id], below), upper.visible ? toDoc(this.doc.thermo?.[upper.id], upper) : void 0) : void 0;
+    const thermoAfter = this.thermoWithout([upper.id, below.id]).thermo ?? (this.doc.thermo ? { ...this.doc.thermo } : void 0);
+    const thermo = mergedThermo ? { ...thermoAfter ?? {}, [below.id]: mergedThermo } : thermoAfter;
+    this.commit(
+      "Merge down",
+      this.withWetEvents({
+        ...this.doc,
+        layers,
+        activeLayerId: below.id,
+        ...this.thickWithout([upper.id]),
+        ...this.stickersWithout([upper.id, below.id]),
+        ...this.liveStrokesWithout([upper.id, below.id]),
+        ...light ? { light } : {},
+        ...fluor ? { fluor } : {},
+        ...thermo ? { thermo } : {}
+      })
+    );
     return this.describeLayer(merged);
   }
   /** Removes every pixel of a layer. */
@@ -6300,7 +7342,22 @@ var PaintEditorController = class _PaintEditorController {
       this.wet.world.removeLane(l.id);
     }
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface: emptySurface(4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ...this.doc.liveStrokes?.[l.id] ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
+    this.commit(
+      "Clear layer",
+      this.withPaintEvent(
+        {
+          ...this.doc,
+          layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface: emptySurface(4) })),
+          ...this.thickWithout([l.id]),
+          ...this.stickersWithout([l.id]),
+          ...this.doc.liveStrokes?.[l.id] ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {},
+          ...this.lightWithout([l.id]),
+          ...this.fluorWithout([l.id]),
+          ...this.thermoWithout([l.id])
+        },
+        { kind: "clear", layerId: l.id }
+      )
+    );
     return { layerId: l.id, bounds };
   }
   /**
@@ -6346,7 +7403,23 @@ var PaintEditorController = class _PaintEditorController {
     const surface = this.applyCoverage(l, coverage, rect, apply);
     const lit = this.doc.light?.[l.id];
     const light = lit ? withLayerLight(this.doc.light, l.id, scaleLight(lit, 1 - opacity)) : void 0;
-    this.commit("Fill layer", this.withPaintEvent(this.withWetEvents({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })), ...light ? { light } : {} }), { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }));
+    const fl = this.doc.fluor?.[l.id];
+    const fluor = fl ? withLayerLight(this.doc.fluor, l.id, scaleFluor(fl, 1 - opacity)) : void 0;
+    const th = this.doc.thermo?.[l.id];
+    const thermo = th && opacity >= 0.5 ? this.thermoWithout([l.id]).thermo : void 0;
+    this.commit(
+      "Fill layer",
+      this.withPaintEvent(
+        this.withWetEvents({
+          ...this.doc,
+          layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })),
+          ...light ? { light } : {},
+          ...fluor ? { fluor } : {},
+          ...thermo ? { thermo } : {}
+        }),
+        { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }
+      )
+    );
     return { layerId: l.id, bounds: rect };
   }
   /**
@@ -7237,6 +8310,8 @@ var PaintEditorController = class _PaintEditorController {
   }
   useBrush(next, spec, builtin) {
     next = normalizePaintBrush(next, next);
+    const refusal = mutationBrushRefusal(next);
+    if (refusal) throw new PaintEditorError(refusal);
     if (builtin) next.builtin = true;
     else delete next.builtin;
     this.brush = next;
@@ -7485,6 +8560,8 @@ var PaintEditorController = class _PaintEditorController {
       return l;
     })();
     const brush = this.strokeBrush(init);
+    const mutRefusal = mutationBrushRefusal(brush);
+    if (mutRefusal) throw new PaintEditorError(mutRefusal);
     if (this.previewing && isWetBrush(brush)) throw new PaintEditorError(`Wet paint can't be previewed; the ${brush.name} brush paints wet media. Suggest it with a dry brush.`);
     if (brush.ghost) {
       if (brush.light.amount > 0) throw new PaintEditorError(`Ghost paint (${brush.name}) shares the wet light channel and can't emit light; set light.amount to 0 or ghost to null (set_brush).`);
@@ -7508,6 +8585,12 @@ var PaintEditorController = class _PaintEditorController {
         throw new PaintEditorError(`Layer "${layer.name}" has ghost paint fading on it, which uses the wet light channel; paint light on another layer (add_layer), or finish the ghost first (dry_paint).`);
       }
     }
+    if (brush.fluorescence.amount > 0 && brush.engine === "sticker") {
+      throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take fluorescence; paint UV ink with a dab or particle brush (uv-marker; list_brush_presets lists them), or set fluorescence.amount to 0 (set_brush).`);
+    }
+    if (brush.thermochromic.hotColor !== null && brush.engine === "sticker") {
+      throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take thermochromic ink; paint thermochromic ink with a dab or particle brush (thermo-ink; list_brush_presets lists them), or set thermochromic.hotColor to null (set_brush).`);
+    }
     if (doc.liveStrokes?.[layer.id]) {
       const why = liveStrokeRefusal(brush);
       if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
@@ -7529,9 +8612,16 @@ var PaintEditorController = class _PaintEditorController {
     if (isWetBrush(brush)) {
       this.requireWetIdle("painting");
       if (layer.offset.x || layer.offset.y) {
-        const moved = { ...layer, surface: translateSurface(layer.surface, layer.offset.x, layer.offset.y), offset: { x: 0, y: 0 } };
-        this.doc = { ...this.doc, layers: mapLayer(this.doc.layers, layer.id, () => moved) };
-        if (doc !== this.doc) doc = { ...doc, layers: mapLayer(doc.layers, layer.id, () => moved) };
+        const ox = layer.offset.x;
+        const oy = layer.offset.y;
+        const moved = { ...layer, surface: translateSurface(layer.surface, ox, oy), offset: { x: 0, y: 0 } };
+        const moveThick = (t) => {
+          const tc = t?.[layer.id];
+          if (!tc) return t;
+          return { ...t, [layer.id]: { height: translateSurface(tc.height, ox, oy), material: translateSurface(tc.material, ox, oy), film: translateSurface(tc.film, ox, oy) } };
+        };
+        this.doc = { ...this.doc, layers: mapLayer(this.doc.layers, layer.id, () => moved), ...this.doc.thick?.[layer.id] ? { thick: moveThick(this.doc.thick) } : {} };
+        if (doc !== this.doc) doc = { ...doc, layers: mapLayer(doc.layers, layer.id, () => moved), ...doc.thick?.[layer.id] ? { thick: moveThick(doc.thick) } : {} };
         layer = moved;
       }
       if (!this.wet.wetLayerIds().includes(layer.id) && this.wet.wetLayerIds().length >= MAX_WET_LANES) {
@@ -7546,6 +8636,9 @@ var PaintEditorController = class _PaintEditorController {
       const load = init.load ?? brushLoadForStroke(brush, this.mixerLoad, [r / 255, g / 255, b / 255]);
       const seedW = init.seed ?? mix32(this.seedCounter * 2654435761 >>> 0) & 2147483647;
       const copiesW = (init.copies ?? this.strokeCopies()).filter((m) => m.some((v, i) => v !== IDENTITY_AFFINE[i]));
+      const wetMask = init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null;
+      const needWetFilm = Boolean(brush.wet.tool === "paint" && brush.iridescence || brush.wet.tool === "blot" && doc.thick?.[id]?.film.tiles.size);
+      const wetFilm = needWetFilm ? new FilmBuffer((doc.thick?.[id] ?? emptyThickChannels()).film, layer.offset, wetMask) : null;
       const driver = new WetStrokeDriver({
         world,
         laneId: id,
@@ -7557,9 +8650,10 @@ var PaintEditorController = class _PaintEditorController {
         paperColor: hexToRgb8(doc.paper.color),
         seed: seedW,
         copies: [IDENTITY_AFFINE, ...copiesW].map(affineCopy),
-        mask: init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null,
+        mask: wetMask,
         paint: effect ? null : wetGradient,
         effect: effect?.pixels ?? null,
+        film: wetFilm,
         speed: this.wet.speed
       });
       init = { ...init, seed: seedW, load };
@@ -7569,6 +8663,23 @@ var PaintEditorController = class _PaintEditorController {
       const dried = findLayer(this.doc.layers, layer.id).layer;
       layer = dried;
     }
+    if (brush.mutation && !isWetBrush(brush) && !this.answeringMutation && !this.previewing && !this.getOrigin().startsWith("agent:")) {
+      const targetLayer = layer;
+      const existing = this.mutations.find((m) => m.state === "settling" && m.medium === "dry" && m.layerId === targetLayer.id && m.tempLayerId && findLayer(doc.layers, m.tempLayerId));
+      if (existing?.tempLayerId) {
+        layer = findLayer(doc.layers, existing.tempLayerId).layer;
+      } else {
+        const temp = {
+          ...createPaintLayer("Mutation"),
+          clipped: targetLayer.clipped,
+          temporary: true
+        };
+        this.tempLayerTargets.set(temp.id, targetLayer.id);
+        this.doc = { ...this.doc, layers: insertAfter(this.doc.layers, targetLayer.id, temp) };
+        if (doc !== this.doc) doc = { ...doc, layers: insertAfter(doc.layers, targetLayer.id, temp) };
+        layer = temp;
+      }
+    }
     let color = init.color === void 0 ? this.ownColour(init.brushId) ?? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
     if (init.color === void 0 && init.start && tracing?.visible && tracing.sampleColors) color = this.sampleTracingColor(init.start.x, init.start.y) ?? color;
@@ -7585,6 +8696,8 @@ var PaintEditorController = class _PaintEditorController {
     const rgba = rgbaOf(color);
     const seed = init.seed ?? mix32(this.seedCounter++ * 2654435761 >>> 0) & 2147483647;
     const copies = (init.copies ?? this.strokeCopies()).filter((m) => m.some((v, i) => v !== IDENTITY_AFFINE[i]));
+    const hasThick = Boolean(doc.thick?.[layer.id]);
+    const needThick = brush.engine === "impasto" || Boolean(brush.iridescence) || brush.engine === "eraser" && hasThick || Boolean(wet?.driver.init.film);
     const session = new PaintStrokeSession(host, {
       layerId: layer.id,
       surface: layer.surface,
@@ -7604,9 +8717,11 @@ var PaintEditorController = class _PaintEditorController {
       mixerLoad: init.load ?? brushLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]),
       secondary: rgbaOf(this.secondaryColor),
       wet,
-      thick: brush.engine === "impasto" ? { channels: doc.thick?.[layer.id] ?? emptyThickChannels() } : void 0,
+      thick: needThick ? { channels: doc.thick?.[layer.id] ?? emptyThickChannels() } : void 0,
       // Light paint: a twin of the stroke paints the light channel (laying, dimming, moving light).
       light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || doc.light?.[layer.id]) ? { surface: doc.light?.[layer.id] ?? emptyLight() } : null,
+      fluor: brush.engine !== "sticker" && (brush.fluorescence.amount > 0 || doc.fluor?.[layer.id]) ? { surface: doc.fluor?.[layer.id] ?? emptyFluor() } : null,
+      thermo: brush.engine !== "sticker" && (brush.thermochromic.hotColor !== null || doc.thermo?.[layer.id]) ? { surface: doc.thermo?.[layer.id] ?? emptyThermo() } : null,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc), art: this.stickerArt.get, variant: (ref2) => this.stickerArt.variantFor(ref2, this.colorScheme === "dark") } : void 0,
       stampArt: this.stampArt,
       paint: effect ? null : this.strokeGradient(init, brush, color),
@@ -7647,12 +8762,18 @@ var PaintEditorController = class _PaintEditorController {
     const host = {
       update: (layerId, surface, rects) => {
         if (this.session?.init.wet) {
+          const ch2 = this.session.thickChannels();
+          this.liveThick = ch2 ? { layerId, channels: ch2 } : null;
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
         const ch = this.session?.thickChannels();
         this.liveThick = ch ? { layerId, channels: ch } : null;
+        const fl = this.session?.fluorChannel();
+        this.liveFluor = fl ? { layerId, surface: fl } : null;
+        const th = this.session?.thermoChannel();
+        this.liveThermo = th ? { layerId, surface: th } : null;
         this.emit(rects);
       },
       sampled: (s, points) => {
@@ -7671,6 +8792,8 @@ var PaintEditorController = class _PaintEditorController {
         this.live = null;
         this.liveLayers = null;
         this.liveThick = null;
+        this.liveFluor = null;
+        this.liveThermo = null;
         const wetStroke = Boolean(s.init.wet);
         if (wetStroke) this.wet.driver = null;
         const brush = s.init.brush;
@@ -7683,6 +8806,8 @@ var PaintEditorController = class _PaintEditorController {
             if (wetStroke) this.wet.restore(snap);
             this.doc = { ...this.doc, layers: before.layers };
             this.wet.syncDisplays();
+          } else if (this.doc.layers !== before.layers) {
+            this.doc = { ...this.doc, layers: before.layers };
           }
           this.emit();
           this.notifySample(cancelled ? "cancel" : "end", s, [], cancelled ? void 0 : null);
@@ -7698,13 +8823,33 @@ var PaintEditorController = class _PaintEditorController {
           s.result.wet = this.wet.isWet(s.layerId);
         }
         const l = this.getLayer(s.layerId);
-        const ch = s.thickChannels();
-        const thick = ch ? { ...this.doc.thick ?? {}, [l.id]: ch } : this.doc.thick;
+        const thick = withLayerThick(this.doc.thick, l.id, s.thickChannels());
         const sprayed = s.stickers();
         const stickers = sprayed ? { ...this.doc.stickers ?? {}, [l.id]: [...this.doc.stickers?.[l.id] ?? [], ...sprayed] } : this.doc.stickers;
         const wetLight = wetStroke && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null;
         const light = withLayerLight(this.doc.light, l.id, s.lightChannel() ?? wetLight);
-        this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {}, ...light ? { light } : {} }, stroke)), wetStroke ? before : this.doc);
+        const fluor = withLayerLight(this.doc.fluor, l.id, s.fluorChannel());
+        const thermo = withLayerLight(this.doc.thermo, l.id, s.thermoChannel());
+        this.commit(
+          `${brush.name} stroke`,
+          this.withWetEvents(
+            withLiveStroke(
+              {
+                ...this.doc,
+                layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })),
+                strokes: [...this.doc.strokes, stroke],
+                ...thick ? { thick } : {},
+                ...stickers ? { stickers } : {},
+                ...light ? { light } : {},
+                ...fluor ? { fluor } : {},
+                ...thermo ? { thermo } : {}
+              },
+              stroke
+            )
+          ),
+          before
+        );
+        this.recordMutationStroke(stroke, s.result?.bounds ?? null);
         this.notifySample("end", s, [], stroke.id);
       }
     };
@@ -7782,6 +8927,8 @@ var PaintEditorController = class _PaintEditorController {
       this.live = null;
       this.liveLayers = null;
       this.liveThick = null;
+      this.liveFluor = null;
+      this.liveThermo = null;
       const masks = s.init.selection ? (s.maskStencils ?? this.guides.stencils).filter((x) => x.enabled && x.mode === "mask") : [];
       const load = s.init.mixerLoad;
       const result = this.paintStroke({ layerId: s.layerId, points: s.points, color: s.init.colorHex, brush: brushToJSON(s.init.brush), seed: s.init.seed, copies: s.init.affineCopies, ...load.reservoir || load.pickup ? { load } : {}, paint, snapToPerspective: false, stencils: false, maskStencils: masks });
@@ -7800,6 +8947,8 @@ var PaintEditorController = class _PaintEditorController {
       this.live = null;
       this.liveLayers = null;
       this.liveThick = null;
+      this.liveFluor = null;
+      this.liveThermo = null;
       this.emit();
       this.notifySample("cancel", s, []);
       throw e;
@@ -7820,18 +8969,27 @@ var PaintEditorController = class _PaintEditorController {
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
         this.paintedBounds.set(stroke, s.result?.bounds ?? null);
+        const targetId = this.tempLayerTargets.get(s.layerId);
+        if (targetId && !findLayer(out.layers, s.layerId)) {
+          const temp = findLayer(this.doc.layers, s.layerId)?.layer;
+          if (temp) out = { ...out, layers: insertAfter(out.layers, targetId, temp) };
+        }
         const l = findLayer(out.layers, s.layerId).layer;
         const offset = s.init.wet ? { x: 0, y: 0 } : l.offset;
-        const ch = s.thickChannels();
+        const thick = withLayerThick(out.thick, l.id, s.thickChannels());
         const sprayed = s.stickers();
         const lit = s.lightChannel() ?? (s.init.wet && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null);
+        const fl = s.fluorChannel();
+        const th = s.thermoChannel();
         out = withLiveStroke({
           ...out,
           layers: mapLayer(out.layers, l.id, () => ({ ...l, surface, offset })),
           strokes: [...out.strokes, stroke],
-          ...ch ? { thick: { ...out.thick ?? {}, [l.id]: ch } } : {},
+          ...thick ? { thick } : {},
           ...sprayed ? { stickers: { ...out.stickers ?? {}, [l.id]: [...out.stickers?.[l.id] ?? [], ...sprayed] } } : {},
-          ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {}
+          ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {},
+          ...fl ? { fluor: withLayerLight(out.fluor, l.id, fl) } : {},
+          ...th ? { thermo: withLayerLight(out.thermo, l.id, th) } : {}
         }, stroke);
       }
     };
@@ -7864,8 +9022,11 @@ var PaintEditorController = class _PaintEditorController {
     }
     const { doc, result, brush } = run;
     if (result.mixerLoad) this.keepLoad(brush, result.mixerLoad);
-    if (doc !== before || this.wetOp) this.commit(`${brush.name} stroke`, this.withWetEvents(doc), before);
-    else this.emit([]);
+    if (doc !== before || this.wetOp) {
+      this.commit(`${brush.name} stroke`, this.withWetEvents(doc), before);
+      const lastStroke = this.doc.strokes[this.doc.strokes.length - 1];
+      if (lastStroke && lastStroke.id === result.strokeId) this.recordMutationStroke(lastStroke, result.bounds);
+    } else this.emit([]);
     return result;
   }
   /**
@@ -7904,8 +9065,13 @@ var PaintEditorController = class _PaintEditorController {
     }
     const run = last;
     if (run?.result.mixerLoad) this.keepLoad(run.brush, run.result.mixerLoad);
-    if (doc !== before || this.wetOp) this.commit(`${run?.brush.name ?? "Brush"} path stroke`, this.withWetEvents(doc), before);
-    else this.emit([]);
+    if (doc !== before || this.wetOp) {
+      this.commit(`${run?.brush.name ?? "Brush"} path stroke`, this.withWetEvents(doc), before);
+      for (const sid of strokeIds) {
+        const recorded = this.doc.strokes.find((s) => s.id === sid);
+        if (recorded) this.recordMutationStroke(recorded, this.paintedBounds.get(recorded) ?? null);
+      }
+    } else this.emit([]);
     const layerId = run?.result.layerId ?? stroke.layerId ?? this.doc.activeLayerId ?? "";
     return { layerId, bounds, dabs, strokeIds, ...run?.result.mixerLoad ? { mixerLoad: run.result.mixerLoad } : {}, ...run?.result.wet !== void 0 ? { wet: run.result.wet } : {} };
   }
@@ -8029,6 +9195,137 @@ var PaintEditorController = class _PaintEditorController {
     this.commit("Clear light", { ...this.doc, light: t.light });
     return { layerId: l.id, cleared: true };
   }
+  // --- UV blacklight and thermochromic heat ---------------------------------------
+  fluorWithout(ids) {
+    const t = this.doc.fluor;
+    if (!t || !ids.some((id) => t[id])) return {};
+    const out = { ...t };
+    for (const id of ids) delete out[id];
+    return { fluor: out };
+  }
+  thermoWithout(ids) {
+    const t = this.doc.thermo;
+    if (!t || !ids.some((id) => t[id])) return {};
+    const out = { ...t };
+    for (const id of ids) delete out[id];
+    return { thermo: out };
+  }
+  /** The UV / blacklight view setting. */
+  getUvLight() {
+    return { ...this.uvLight };
+  }
+  /** Layers that carry UV-fluorescent ink. */
+  fluorescentLayerIds() {
+    return Object.entries(this.doc.fluor ?? {}).filter(([id, s]) => s.tiles.size > 0 && Boolean(findLayer(this.doc.layers, id))).map(([id]) => id);
+  }
+  /** Layers that carry thermochromic ink. */
+  thermochromicLayerIds() {
+    return Object.entries(this.doc.thermo ?? {}).filter(([id, s]) => s.tiles.size > 0 && Boolean(findLayer(this.doc.layers, id))).map(([id]) => id);
+  }
+  /**
+   * Switches or tunes the virtual UV / blacklight (`on`, `strength` 0..2, `ambient` 0..1). When
+   * `on` is true, the composite dims to `ambient` and fluorescent ink (`brush.fluorescence`) glows
+   * in its stroke colour with a Linear Dodge halo. Saved with the document, not an undo step.
+   */
+  setUvLight(update) {
+    if (update.on !== void 0 && typeof update.on !== "boolean") throw new PaintEditorError("on must be true or false.");
+    if (update.strength !== void 0 && !(typeof update.strength === "number" && Number.isFinite(update.strength) && update.strength >= 0 && update.strength <= 2)) {
+      throw new PaintEditorError(`strength ${update.strength} is out of range; use 0..2.`);
+    }
+    if (update.ambient !== void 0 && !(typeof update.ambient === "number" && Number.isFinite(update.ambient) && update.ambient >= 0 && update.ambient <= 1)) {
+      throw new PaintEditorError(`ambient ${update.ambient} is out of range; use 0..1.`);
+    }
+    this.uvLight = normalizeUvLight(update, this.uvLight);
+    this.emit("all");
+    return { ...this.uvLight };
+  }
+  /**
+   * Reads the document's heat field: its temperature summary (`peak`, `mean`, `hotCells`) and,
+   * when `points` are given (document pixels), the bilinearly sampled temperature (0..1) at each.
+   */
+  getHeat(points = []) {
+    const samples = points.map((p, i) => {
+      if (!p || !Number.isFinite(p.x) || !Number.isFinite(p.y)) throw new PaintEditorError(`points[${i}] needs finite x and y in document pixels.`);
+      return { x: p.x, y: p.y, temperature: this.doc.heat ? Math.round(sampleHeatAt(this.doc.heat, p.x, p.y) * 1e3) / 1e3 : 0 };
+    });
+    return { ...heatStats(this.doc.heat), samples, thermochromicLayerIds: this.thermochromicLayerIds() };
+  }
+  /**
+   * Warms (or with `temperature` 0 cools) the canvas heat field along `points` (document pixels)
+   * with a soft brush of `radius` px (default 28) towards `temperature` 0..1 (default 1). Where
+   * temperature reaches `HEAT_DRY_THRESHOLD` (0.5), any wet paint on those tiles dries at once.
+   * One undo step.
+   */
+  paintHeat(options) {
+    this.requireIdle("painting heat");
+    this.requireWetIdle("painting heat");
+    const points = this.checkPoints(options.points);
+    const radius = options.radius ?? 28;
+    if (!(typeof radius === "number" && Number.isFinite(radius) && radius >= 1 && radius <= 512)) {
+      throw new PaintEditorError(`radius ${options.radius} is out of range; use 1..512 px.`);
+    }
+    const temperature = options.temperature ?? 1;
+    if (!(typeof temperature === "number" && Number.isFinite(temperature) && temperature >= 0 && temperature <= 1)) {
+      throw new PaintEditorError(`temperature ${options.temperature} is out of range; use 0..1 (0 cools back to ambient).`);
+    }
+    const before = this.doc;
+    const { width, height } = this.doc.canvas;
+    const field = this.doc.heat ? cloneHeatField(this.doc.heat) : createHeatField(width, height);
+    const { stats } = paintHeatField(field, points, radius, temperature);
+    const dried = this.dryWetFromHeat(field);
+    const next = { ...this.doc, ...stats.max > 0 ? { heat: field } : {} };
+    if (stats.max === 0) delete next.heat;
+    if (next !== before || this.wetOp) this.commit("Paint heat", this.withWetEvents(next), before);
+    else this.emit([]);
+    return { ...stats, dried };
+  }
+  /**
+   * Advances the heat field by `steps` simulation steps (1..200, default 10): heat diffuses into
+   * neighbouring cells and cools towards 0 by Newtonian cooling. Newly heated tiles above the dry
+   * threshold dry any wet paint on them. Not an undo step (time passing never is).
+   */
+  advanceHeat(stepsOrOptions = 10) {
+    this.requireIdle("advancing heat");
+    this.requireWetIdle("advancing heat");
+    const rawSteps = typeof stepsOrOptions === "number" ? stepsOrOptions : stepsOrOptions?.steps;
+    const steps = rawSteps ?? 10;
+    if (!(Number.isInteger(steps) && steps >= 1 && steps <= 200)) {
+      throw new PaintEditorError(`steps ${rawSteps} is out of range; use a whole number 1..200.`);
+    }
+    if (!this.doc.heat || heatStats(this.doc.heat).max === 0) {
+      return { steps, max: 0, mean: 0, hotCells: 0, bounds: null, dried: [] };
+    }
+    const field = cloneHeatField(this.doc.heat);
+    const stats = advanceHeatField(field, steps);
+    const dried = this.dryWetFromHeat(field);
+    const next = { ...this.doc, ...stats.max > 0 ? { heat: field } : {} };
+    if (stats.max === 0) delete next.heat;
+    this.doc = this.withWetEvents(next);
+    this.docRevision++;
+    this.emit("all");
+    return { steps, ...stats, dried };
+  }
+  /** Cools the whole canvas heat field to 0 at once (one undo step when anything was warm). */
+  clearHeat() {
+    this.requireIdle("clearing heat");
+    if (!this.doc.heat || heatStats(this.doc.heat).max === 0) {
+      return { cleared: false };
+    }
+    const { heat: _gone, ...rest } = this.doc;
+    this.commit("Clear heat", rest);
+    return { cleared: true };
+  }
+  /** Dries any wet paint on tiles where `field` is at or above `HEAT_DRY_THRESHOLD`. */
+  dryWetFromHeat(field) {
+    const ids = this.wet.wetLayerIds();
+    if (!ids.length) return [];
+    const hotRect = hotCellsBounds(field, HEAT_DRY_THRESHOLD);
+    if (!hotRect) return [];
+    this.beginWetOp();
+    const dried = ids.flatMap((id) => this.wet.dry(id, hotRect)).filter((d) => d.bounds !== null);
+    if (dried.length) this.logWet({ kind: "dry", data: hotRect });
+    return dried;
+  }
   // --- Thick paint and light -------------------------------------------------------
   /** The document's `thick` without these layers (as a spread: `{}` when unchanged). */
   thickWithout(ids) {
@@ -8050,13 +9347,29 @@ var PaintEditorController = class _PaintEditorController {
     this.emit("all");
     return { ...this.lighting };
   }
+  /** Where the viewer looks from for thin-film iridescence and specular highlights (-1..1; editor state, not saved with the document). */
+  getViewTilt() {
+    return { ...this.viewTilt };
+  }
+  /** Tilts the view vector for thin-film iridescence and specular highlights (-1..1; editor state, not saved with the document, not an undo step). */
+  setViewTilt(update) {
+    if (update.x !== void 0 && !(Number.isFinite(update.x) && update.x >= -1 && update.x <= 1)) {
+      throw new PaintEditorError(`x ${update.x} is out of range; use -1..1.`);
+    }
+    if (update.y !== void 0 && !(Number.isFinite(update.y) && update.y >= -1 && update.y <= 1)) {
+      throw new PaintEditorError(`y ${update.y} is out of range; use -1..1.`);
+    }
+    this.viewTilt = normalizeViewTilt(update, this.viewTilt);
+    this.emit("all");
+    return { ...this.viewTilt };
+  }
   /** A layer's relief: where it is, its highest point (0..255) and its tiles; `null` when it has none. */
   reliefOf(layerId) {
     const id = layerId ?? this.doc.activeLayerId;
     if (!id) return null;
     this.requireLayer(id);
     const ch = this.doc.thick?.[id];
-    if (!ch) return null;
+    if (!ch || !hasThickChannels(ch)) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
   }
@@ -8087,6 +9400,7 @@ var PaintEditorController = class _PaintEditorController {
     const paper = { ...this.doc.paper, scale: Math.min(8, this.doc.paper.scale * scale) };
     target.adopt({ state: { canvas: target.doc.canvas, paper, layers: emptiedLayers(this.doc.layers), activeLayerId: this.doc.activeLayerId, strokes: [] }, extensions: {}, problems: [] });
     target.lighting = { ...this.lighting };
+    target.uvLight = { ...this.uvLight };
     target.effects.set(this.effects.provider);
     if (w === width && h === height) for (const [key, img] of this.effectPaintPixels) target.effectPaintPixels.set(key, img);
     return target;
@@ -8130,6 +9444,7 @@ var PaintEditorController = class _PaintEditorController {
    * bindings do). Steps at the wet speed unless paused; resolves when the frame's steps are done.
    */
   tickWet(now) {
+    this.tickMutations(now);
     return this.wet.tick(now);
   }
   /** Resolves when the wet kernel is as fast as it will get here (`null` when nothing is wet yet). */
@@ -8204,7 +9519,9 @@ var PaintEditorController = class _PaintEditorController {
   async advanceWet(options) {
     const steps = options.steps ?? Math.round((options.seconds ?? 1) * this.wet.speed);
     if (!(Number.isInteger(steps) && steps >= 0 && steps <= 1e5)) throw new PaintEditorError(`steps ${steps} is out of range; use 0..100000 (or seconds).`);
+    const seconds = options.seconds ?? steps / this.wet.speed;
     const run = await this.wet.advance(steps);
+    if (seconds > 0) this.advanceMutations(seconds);
     this.emit();
     const st = this.wetState();
     return { steps: run, clock: st.clock, stillWet: st.wet, layers: st.layers };
@@ -8223,7 +9540,11 @@ var PaintEditorController = class _PaintEditorController {
     if (!ids.length) return { dried: [], stillWet: this.wet.isWet() };
     const before = this.doc;
     this.beginWetOp();
-    const dried = ids.flatMap((id) => this.wet.dry(id, rect));
+    const dried = ids.flatMap((id) => {
+      const r = this.wet.dry(id, rect);
+      if (!rect) this.finishWetMutationsOnDry(id);
+      return r;
+    });
     this.logWet({ kind: "dry", layerId: options.layerId, data: rect });
     this.commit("Dry paint", this.withWetEvents(this.doc), before);
     return { dried, stillWet: this.wet.isWet() };
@@ -8257,6 +9578,15 @@ var PaintEditorController = class _PaintEditorController {
   setWetParams(layerId, update) {
     const l = this.wetLayer(layerId, "change the wet settings of");
     this.requireWetIdle("changing wet settings");
+    if (this.heldEvaporation.has(l.id)) {
+      const current = this.wet.info(l.id).params;
+      const intended = normalizeWetParams({ ...current, evaporation: this.heldEvaporation.get(l.id), ...update });
+      this.heldEvaporation.set(l.id, intended.evaporation);
+      this.wet.setParams(l.id, { ...update, evaporation: 0 });
+      this.recordWetSetting({ kind: "params", layerId: l.id, data: intended });
+      this.emit([]);
+      return intended;
+    }
     const params = this.wet.setParams(l.id, update);
     this.recordWetSetting({ kind: "params", layerId: l.id, data: params });
     this.emit([]);
@@ -8362,6 +9692,55 @@ var PaintEditorController = class _PaintEditorController {
     }
     return out;
   }
+  /** The layers with thermochromic paint shifted toward its hot colour where the canvas is warm. */
+  thermoLayers(layers) {
+    const thermo = this.doc.thermo;
+    const heat = this.doc.heat;
+    if (!thermo || !heat || heat.max === 0) return layers;
+    let out = layers;
+    for (const [id, th] of Object.entries(thermo)) {
+      const l = findLayer(out, id)?.layer;
+      if (!isPixelLayer(l) || !th.tiles.size) continue;
+      let cache = this.thermoCaches.get(id);
+      if (!cache) this.thermoCaches.set(id, cache = new ThermoCache());
+      const shifted = cache.render(l.surface, th, l.offset, heat);
+      if (shifted !== l.surface) out = mapLayer(out, id, () => ({ ...l, surface: shifted }));
+    }
+    return out;
+  }
+  /**
+   * Under the UV blacklight: every pixel layer's daylight paint dims to `uvLight.ambient`, any
+   * fluorescent ink (`doc.fluor[id]`) glows in its own colour, and each fluorescent layer casts a
+   * Linear Dodge (`::uv`) spill layer directly above it.
+   */
+  uvLayers(layers) {
+    if (!this.uvLight.on) return layers;
+    const fluor = this.doc.fluor ?? {};
+    const visit = (list) => {
+      let out = [];
+      for (const l of list) {
+        if (l.type === "group") {
+          out.push({ ...l, children: visit(l.children) });
+          continue;
+        }
+        if (!isPixelLayer(l)) {
+          out.push(l);
+          continue;
+        }
+        let cache = this.uvCaches.get(l.id);
+        if (!cache) this.uvCaches.set(l.id, cache = new UvCache());
+        const fl = fluor[l.id];
+        const surface = cache.render(l.surface, fl, this.uvLight);
+        out.push(surface !== l.surface ? { ...l, surface } : l);
+        const spill = fl ? cache.spill(fl, this.uvLight) : null;
+        if (spill) {
+          out.push({ type: "pixel", id: `${l.id}${UV_SPILL_SUFFIX}`, name: `${l.name} UV`, visible: l.visible, opacity: l.opacity, blend: "linear-dodge", surface: spill, offset: { ...l.offset } });
+        }
+      }
+      return out;
+    };
+    return visit(layers);
+  }
   /** The layers with thick paint lit (each thick layer's pixels replaced by its lit tiles). */
   litLayers(layers) {
     const thick = this.doc.thick;
@@ -8375,7 +9754,7 @@ var PaintEditorController = class _PaintEditorController {
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
-      const lit = cache.lit(l.surface, ch, this.lighting);
+      const lit = cache.lit(l.surface, ch, this.lighting, this.viewTilt);
       if (lit !== l.surface) out = mapLayer(out, id, () => ({ ...l, surface: lit }));
     }
     return out;
@@ -8433,7 +9812,7 @@ var PaintEditorController = class _PaintEditorController {
   }
   renderLayers(options, view = false) {
     const base = (options.wet ?? "display") === "dried" ? this.driedLayers() : this.currentLayers();
-    let layers = this.lightLayers(this.litLayers(base));
+    let layers = this.lightLayers(this.uvLayers(this.litLayers(this.thermoLayers(base))));
     const backlight = options.paper !== false && !options.layerIds ? this.backlightLayer(base) : null;
     if (backlight) layers = [...layers, backlight];
     if (options.layerIds) {
@@ -8441,7 +9820,7 @@ var PaintEditorController = class _PaintEditorController {
       for (const id of options.layerIds) picked.push(findLayer(layers, id)?.layer ?? this.requireLayer(id));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
-    const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
+    const under = options.paper === false ? [] : [paperNode(uvPaper(this.doc.paper, this.uvLight), this.lighting)];
     if (options.paper !== false && this.doc.paperEffect) under.push(this.paperEffectNode(this.doc.paperEffect));
     if (view) under.push(...this.underlayLayers());
     return [...under, ...layers];
@@ -8476,8 +9855,36 @@ var PaintEditorController = class _PaintEditorController {
   /** The document as JSON with inline PNG assets. */
   /** The document as saved: wet paint dried where it is (deterministically); wet settings as data. */
   savedState() {
-    const layers = this.driedLayers(this.doc.layers);
-    return layers === this.doc.layers ? this.doc : { ...this.doc, layers };
+    let state = this.doc;
+    for (const m of this.mutations) {
+      if (m.medium !== "dry" || !m.tempLayerId || !findLayer(state.layers, m.tempLayerId)) continue;
+      if (m.state === "claimed" || m.state === "answered") {
+        const tempId = m.tempLayerId;
+        state = {
+          ...state,
+          layers: mapLayer(state.layers, tempId, () => null),
+          strokes: state.strokes.filter((s) => s.layerId !== tempId)
+        };
+      } else {
+        state = this.mergeTempLayerIntoTarget(state, m.tempLayerId, m.layerId);
+      }
+    }
+    for (const l of flattenLayers(state.layers)) {
+      if (isPixelLayer(l) && l.temporary) {
+        const targetId = this.tempLayerTargets.get(l.id);
+        if (targetId && findLayer(state.layers, targetId)) {
+          state = this.mergeTempLayerIntoTarget(state, l.id, targetId);
+        } else {
+          state = {
+            ...state,
+            layers: mapLayer(state.layers, l.id, () => null),
+            strokes: state.strokes.filter((s) => s.layerId !== l.id)
+          };
+        }
+      }
+    }
+    const layers = this.driedLayers(state.layers);
+    return layers === state.layers ? state : { ...state, layers };
   }
   /** Wet settings saved with the document (`null` when they are all defaults). */
   wetJSON() {
@@ -8485,7 +9892,10 @@ var PaintEditorController = class _PaintEditorController {
     for (const [id, set] of this.wet.settings) {
       if (!findLayer(this.doc.layers, id)) continue;
       const ghost = this.wet.world?.hasLane(id) ? this.wet.world.getGhost(id) : set.ghost ?? null;
-      layers[id] = { params: { ...set.params }, flow: { ...set.flow }, ...ghost ? { ghost } : {} };
+      const savedGhost = ghost?.trigger === "agent" ? null : ghost;
+      const heldEvap = this.heldEvaporation.get(id);
+      const params = heldEvap !== void 0 ? { ...set.params, evaporation: heldEvap } : { ...set.params };
+      layers[id] = { params, flow: { ...set.flow }, ...savedGhost ? { ghost: savedGhost } : {} };
     }
     const flat = this.wet.tilt.angle === 0;
     if (!Object.keys(layers).length && flat) return void 0;
@@ -8550,13 +9960,37 @@ var PaintEditorController = class _PaintEditorController {
     else delete ext.paperEffect;
     if (this.lighting.azimuth !== DEFAULT_LIGHTING.azimuth || this.lighting.elevation !== DEFAULT_LIGHTING.elevation || this.lighting.relief !== DEFAULT_LIGHTING.relief) ext.lighting = { ...this.lighting };
     else delete ext.lighting;
+    const fluor = {};
+    for (const [id, f] of Object.entries(this.doc.fluor ?? {})) {
+      if (!findLayer(this.doc.layers, id)) continue;
+      const saved = fluorToJSON(f);
+      if (saved) fluor[id] = saved;
+    }
+    if (Object.keys(fluor).length) ext.fluor = fluor;
+    else delete ext.fluor;
+    const thermo = {};
+    for (const [id, th] of Object.entries(this.doc.thermo ?? {})) {
+      if (!findLayer(this.doc.layers, id)) continue;
+      const saved = thermoToJSON(th);
+      if (saved) thermo[id] = saved;
+    }
+    if (Object.keys(thermo).length) ext.thermo = thermo;
+    else delete ext.thermo;
+    const savedHeat = this.doc.heat ? heatToJSON(this.doc.heat) : null;
+    if (savedHeat) ext.heat = savedHeat;
+    else delete ext.heat;
+    if (this.uvLight.on !== DEFAULT_UV_LIGHT.on || this.uvLight.strength !== DEFAULT_UV_LIGHT.strength || this.uvLight.ambient !== DEFAULT_UV_LIGHT.ambient) ext.uvLight = { ...this.uvLight };
+    else delete ext.uvLight;
     return ext;
   }
   /** Reads `layerChannels` and `lighting` from loaded extensions into the document. */
   readThick(state, ext, problems) {
     if (Array.isArray(ext.brushSources)) this.brushSources.set(ext.brushSources.map((x, i) => readBrushSource(x, `brushSources[${i}]`, problems)).filter((x) => x !== null));
     this.lighting = normalizeLighting(ext.lighting ?? {}, DEFAULT_LIGHTING);
+    this.uvLight = normalizeUvLight(ext.uvLight ?? {}, DEFAULT_UV_LIGHT);
     this.litCaches.clear();
+    this.uvCaches.clear();
+    this.thermoCaches.clear();
     if (ext.stickers && typeof ext.stickers === "object") {
       const stickers = {};
       for (const [id, list] of Object.entries(ext.stickers)) {
@@ -8627,6 +10061,35 @@ var PaintEditorController = class _PaintEditorController {
       }
       if (Object.keys(light).length) state = { ...state, light };
     }
+    if (ext.fluor && typeof ext.fluor === "object") {
+      const fluor = {};
+      for (const [id, v] of Object.entries(ext.fluor)) {
+        if (!isPixelLayer(findLayer(state.layers, id)?.layer)) continue;
+        try {
+          fluor[id] = fluorFromJSON(v);
+        } catch (e) {
+          problems.push(`The fluorescent ink of layer "${id}" could not be read (${e.message}); it loads without fluorescence.`);
+        }
+      }
+      if (Object.keys(fluor).length) state = { ...state, fluor };
+    }
+    if (ext.thermo && typeof ext.thermo === "object") {
+      const thermo = {};
+      for (const [id, v] of Object.entries(ext.thermo)) {
+        if (!isPixelLayer(findLayer(state.layers, id)?.layer)) continue;
+        try {
+          thermo[id] = thermoFromJSON(v);
+        } catch (e) {
+          problems.push(`The thermochromic ink of layer "${id}" could not be read (${e.message}); it loads without thermochromic shift.`);
+        }
+      }
+      if (Object.keys(thermo).length) state = { ...state, thermo };
+    }
+    if (ext.heat !== void 0) {
+      const heat = heatFromJSON(ext.heat, state.canvas.width, state.canvas.height);
+      if (heat) state = { ...state, heat };
+      else problems.push("The heat field could not be read; the canvas loads cool.");
+    }
     const raw = ext.layerChannels;
     if (!raw || typeof raw !== "object") return state;
     const thick = {};
@@ -8659,6 +10122,7 @@ var PaintEditorController = class _PaintEditorController {
     }
     this.undoStack = [];
     this.redoStack = [];
+    this.resetMutations();
     this.doc = this.readThick(loaded.state, loaded.extensions, loaded.problems);
     for (const list of Object.values(this.doc.liveStrokes ?? {})) {
       for (const s of list) {
@@ -8676,6 +10140,10 @@ var PaintEditorController = class _PaintEditorController {
     delete this.extensions.brushSources;
     delete this.extensions.effectLayers;
     delete this.extensions.paperEffect;
+    delete this.extensions.fluor;
+    delete this.extensions.thermo;
+    delete this.extensions.heat;
+    delete this.extensions.uvLight;
     this.viewCompositor.clear();
     this.emit();
     const refs = Object.values(this.doc.stickers ?? {}).flatMap((list) => list.map((x) => x.ref));
@@ -8737,7 +10205,7 @@ var PaintEditorController = class _PaintEditorController {
   exportPsd() {
     const driedBase = this.driedLayers(this.doc.layers);
     const backlight = this.backlightLayer(driedBase);
-    const dried = [...this.lightLayers(this.litLayers(driedBase)), ...backlight ? [backlight] : []];
+    const dried = [...this.lightLayers(this.uvLayers(this.litLayers(this.thermoLayers(driedBase)))), ...backlight ? [backlight] : []];
     const { width, height, dpi } = this.doc.canvas;
     const paperPixels = this.compositePixels({ layerIds: [], paper: true });
     const paperLayer = {
@@ -9420,8 +10888,24 @@ var PaintEditorController = class _PaintEditorController {
   withLiveStrokes(doc, layer, list, dirty) {
     if (isLayerLocked(layer, "pixels")) throw new PaintEditorError(`Layer "${layer.name}" has its pixels locked; unlock it (update_layer locks) first.`);
     const current = findLayer(doc.layers, layer.id)?.layer;
-    const surface = this.drawLiveStrokes(current ?? layer, list, dirty);
-    const next = { ...doc, layers: mapLayer(doc.layers, layer.id, (l) => ({ ...l, surface, offset: { x: 0, y: 0 } })), liveStrokes: { ...doc.liveStrokes ?? {}, [layer.id]: [...list] } };
+    const hasFilm = list.some((s) => Boolean(s.brush.iridescence)) || Boolean(doc.thick?.[layer.id]);
+    const surface = this.drawLiveStrokes(current ?? layer, list, hasFilm ? null : dirty);
+    let thick = doc.thick;
+    if (hasFilm) {
+      const plain = { ...current ?? layer, visible: true, locks: void 0, offset: { x: 0, y: 0 } };
+      const plainDoc = { ...doc, liveStrokes: void 0, stickers: void 0 };
+      let s = emptySurface(4);
+      let ch = list.some((st) => Boolean(st.brush.iridescence)) ? emptyThickChannels() : null;
+      if (ch) {
+        for (const st of list) {
+          const step = this.drawLiveStroke(plainDoc, plain, s, st, ch);
+          s = step.surface;
+          ch = step.thick ?? ch;
+        }
+      }
+      thick = withLayerThick(doc.thick, layer.id, ch);
+    }
+    const next = { ...doc, layers: mapLayer(doc.layers, layer.id, (l) => ({ ...l, surface, offset: { x: 0, y: 0 } })), liveStrokes: { ...doc.liveStrokes ?? {}, [layer.id]: [...list] }, ...thick ? { thick } : {} };
     return this.withPaintEvent(next, { kind: "live-strokes", layerId: layer.id, data: { strokes: list.map((x) => JSON.parse(JSON.stringify(x))) } });
   }
   /** Where a stroke painted (document pixels): as learnt when it was painted or drawn, else an estimate from its points and brush. */
@@ -9439,23 +10923,27 @@ var PaintEditorController = class _PaintEditorController {
     return out;
   }
   /** Draws one stroke onto `surface` of a plain copy of the layer; returns the result and the area it painted. */
-  drawLiveStroke(doc, plain, surface, st) {
+  drawLiveStroke(doc, plain, surface, st, thick) {
     let out = surface;
+    let outThick = thick;
     const host = {
       update: () => {
       },
-      commit: (_s, drawn, cancelled) => {
-        if (!cancelled && drawn) out = drawn;
+      commit: (s, drawn, cancelled) => {
+        if (!cancelled && drawn) {
+          out = drawn;
+          outThick = s.thickChannels() ?? outThick;
+        }
       }
     };
     const paint = st.paint && this.liveEffectAt !== null && isLiveEffect(st) ? framePaint(st.paint, this.liveEffectAt) : st.paint;
     const init = { layerId: plain.id, color: st.color, brush: st.brush, seed: st.seed, copies: st.copies ?? [], ...st.load ? { load: st.load } : {}, ...paint ? { paint } : {}, snapToPerspective: false, stencils: false, maskStencils: st.stencils ?? [] };
-    const session = this.sessionFor({ ...doc, layers: mapLayer(doc.layers, plain.id, () => ({ ...plain, surface })) }, init, host);
+    const session = this.sessionFor({ ...doc, layers: mapLayer(doc.layers, plain.id, () => ({ ...plain, surface })), ...outThick ? { thick: { ...doc.thick ?? {}, [plain.id]: outThick } } : {} }, init, host);
     session.push(st.points);
     const result = session.end();
     const had = this.paintedBounds.get(st);
     this.paintedBounds.set(st, had && result.bounds ? unionRect(had, result.bounds) : result.bounds ?? had ?? null);
-    return { surface: out, bounds: result.bounds };
+    return { surface: out, bounds: result.bounds, thick: outThick };
   }
   /**
    * A stroke layer's pixels drawn from its strokes, bottom first. With `dirty` (the areas the old
@@ -9839,6 +11327,532 @@ var PaintEditorController = class _PaintEditorController {
       });
     }
   }
+  // --- Mutation paint --------------------------------------------------------------
+  /**
+   * Hears each mutation once it has settled (`settle` seconds after the user's last mutation
+   * stroke). Registering a listener marks an agent as connected (`state.hasMutationAgent`).
+   */
+  onMutationRequest(listener) {
+    const had = this.mutationListeners.size > 0;
+    this.mutationListeners.add(listener);
+    if (!had) this.emit([]);
+    return () => {
+      this.mutationListeners.delete(listener);
+      if (this.mutationListeners.size === 0) this.emit([]);
+    };
+  }
+  /** Marks whether a mutation-answering agent is connected (for hosts that wake agents via tools). */
+  setMutationAgentConnected(connected) {
+    if (this.mutationAgentConnected === connected) return;
+    this.mutationAgentConnected = connected;
+    this.emit([]);
+  }
+  /** Attaches a `PaintDirector` so `answerMutation` and `readMutation` animate the agent's cursor. */
+  setMutationDirector(director) {
+    this.mutationDirector = director;
+  }
+  /** Lists pending mutations (or all mutations when `includeAll` is true). */
+  listMutations(options = {}) {
+    const list = options.includeAll ? this.mutations : this.mutations.filter((m) => m.state === "pending" || m.state === "settling");
+    return list.map((m) => this.toMutationInfo(m));
+  }
+  /** One mutation by id (`undefined` when unknown). */
+  getMutation(id) {
+    const m = this.mutations.find((x) => x.id === id);
+    return m ? this.toMutationInfo(m) : void 0;
+  }
+  /**
+   * Claims a mutation (`id`) and starts its fade. Returns the strokes (points, colour, brush), a
+   * PNG of the area around them (`cropPng`), and a preview of the whole painting (`canvasPng`) so
+   * the agent can choose where to answer. Refused if already claimed, answered or declined.
+   */
+  readMutation(id, options = {}) {
+    const m = this.mutations.find((x) => x.id === id);
+    if (!m) throw new PaintEditorError(`Unknown mutation "${id}". Call list_mutations for the pending ids.`);
+    if (m.state === "claimed" || m.state === "answered") {
+      throw new PaintEditorError(`Mutation "${id}" has already been claimed${m.claimedBy ? ` by ${m.claimedBy}` : ""}.`);
+    }
+    if (m.state === "declined") {
+      throw new PaintEditorError(`Mutation "${id}" was already declined.`);
+    }
+    const { width, height } = this.doc.canvas;
+    const pad = Math.max(0, Math.round(options.padding ?? 32));
+    const baseRect = m.bounds ?? { x: 0, y: 0, width, height };
+    const cropRect = clipRect(
+      { x: baseRect.x - pad, y: baseRect.y - pad, width: baseRect.width + pad * 2, height: baseRect.height + pad * 2 },
+      width,
+      height
+    ) ?? { x: 0, y: 0, width, height };
+    const full2 = this.compositePixels({ wet: "display" });
+    const cropData = new Uint8ClampedArray(cropRect.width * cropRect.height * 4);
+    for (let y = 0; y < cropRect.height; y++) {
+      const srcRow = ((cropRect.y + y) * width + cropRect.x) * 4;
+      cropData.set(full2.data.subarray(srcRow, srcRow + cropRect.width * 4), y * cropRect.width * 4);
+    }
+    const cropPngBase64 = bytesToBase64(encodePng(cropRect.width, cropRect.height, cropData));
+    const preview = this.renderPreview({ wet: "display", maxSide: options.maxSide ?? 512 });
+    const canvasPngBase64 = bytesToBase64(encodePng(preview.width, preview.height, preview.data));
+    const actorId = options.actor ?? (this.getOrigin() !== "user" ? this.getOrigin() : "agent");
+    m.state = "claimed";
+    m.claimedBy = actorId;
+    m.fadeRemaining = m.fade;
+    if (m.medium === "wet") {
+      this.releaseMutationEvaporation(m.layerId);
+      this.wet.releaseGhost(m.layerId, m.fade);
+      this.recordWetSetting({ kind: "ghost-release", layerId: m.layerId, data: { linger: m.fade } });
+    }
+    if (this.mutationDirector && m.bounds) {
+      const pid = actorId.replace(/^agent:/, "") || "mutation-agent";
+      this.mutationDirector.presence.set({
+        id: pid,
+        name: "Agent",
+        color: "#7c3aed",
+        x: m.bounds.x + m.bounds.width / 2,
+        y: m.bounds.y + m.bounds.height / 2,
+        message: "Reading\u2026"
+      });
+    }
+    this.emit([]);
+    return {
+      id: m.id,
+      state: "claimed",
+      layerId: m.layerId,
+      medium: m.medium,
+      bounds: m.bounds ? { ...m.bounds } : null,
+      fade: m.fade,
+      strokes: m.strokes.map((s) => ({
+        ...s,
+        points: s.points.map((p) => ({ ...p })),
+        bounds: s.bounds ? { ...s.bounds } : null
+      })),
+      cropPng: {
+        width: cropRect.width,
+        height: cropRect.height,
+        rect: cropRect,
+        data: cropPngBase64
+      },
+      canvasPng: {
+        width: preview.width,
+        height: preview.height,
+        data: canvasPngBase64
+      }
+    };
+  }
+  /**
+   * Paints the agent's answer to a claimed mutation (`id`). When a `PaintDirector` is attached (or
+   * passed in `options`), the agent's cursor is seen painting live; all strokes commit as one undo
+   * step with origin `agent:<id>`. A second answer to the same id is refused.
+   */
+  async answerMutation(id, input, options = {}) {
+    const m = this.mutations.find((x) => x.id === id);
+    if (!m) throw new PaintEditorError(`Unknown mutation "${id}". Call list_mutations for the pending ids.`);
+    if (m.state === "answered") throw new PaintEditorError(`Mutation "${id}" has already been answered.`);
+    if (m.state === "declined") throw new PaintEditorError(`Mutation "${id}" was declined and cannot be answered.`);
+    if (m.state !== "claimed") throw new PaintEditorError(`Mutation "${id}" has not been claimed yet; call read_mutation("${id}") first.`);
+    if (!Array.isArray(input?.strokes) || !input.strokes.length) {
+      throw new PaintEditorError("strokes is empty; give at least one stroke with points.");
+    }
+    const targetLayerId = input.layerId ?? m.layerId;
+    this.paintTarget(targetLayerId, "paint on");
+    const cleanedStrokes = input.strokes.map((s) => {
+      const pts = this.checkPoints(s.points);
+      const layerId = s.layerId ?? targetLayerId;
+      this.paintTarget(layerId, "paint on");
+      const baseBrush = s.brushId !== void 0 ? this.requireBrush(s.brushId) : this.brush;
+      const stripAutoGhost = baseBrush.ghost?.trigger === "agent" && !s.brush?.ghost;
+      const brushPatch = {
+        ...s.brush ?? {},
+        mutation: null,
+        ...stripAutoGhost ? { ghost: null } : {}
+      };
+      return {
+        ...s,
+        layerId,
+        brush: brushPatch,
+        points: pts
+      };
+    });
+    m.state = "answered";
+    try {
+      for (const s of cleanedStrokes) {
+        await this.prepareStrokePathEffect(s, [s.points]);
+      }
+    } catch (e) {
+      m.state = "claimed";
+      throw e;
+    }
+    const rawActorId = (options.actor?.id ?? m.claimedBy ?? "mutation-agent").replace(/^agent:/, "") || "mutation-agent";
+    const actor = options.actor ?? {
+      id: rawActorId,
+      name: "Agent",
+      color: "#7c3aed"
+    };
+    const origin = this.getOrigin() !== "user" ? this.getOrigin() : `agent:${actor.id}`;
+    const director = options.director ?? this.mutationDirector;
+    if (director) {
+      const perf = await this.withOrigin(origin, async () => {
+        this.answeringMutation = true;
+        try {
+          return await director.perform(
+            actor,
+            [{ kind: "strokes", strokes: cleanedStrokes, label: "Mutation answer", ...input.note ? { note: input.note } : {} }],
+            { key: m.id }
+          );
+        } finally {
+          this.answeringMutation = false;
+        }
+      });
+      const first = perf[0];
+      if (!first || !first.ok) {
+        m.state = "claimed";
+        throw new PaintEditorError(first ? first.message : "The mutation answer failed.");
+      }
+      const res = first.result;
+      m.answerStrokeIds = [...res.strokeIds];
+      this.cached = null;
+      this.emit([]);
+      return {
+        id: m.id,
+        state: "answered",
+        layerId: res.layerId,
+        strokeIds: res.strokeIds,
+        bounds: res.bounds,
+        dabs: res.dabs,
+        ...res.wet !== void 0 ? { wet: res.wet } : {}
+      };
+    }
+    return this.withOrigin(origin, () => {
+      this.answeringMutation = true;
+      try {
+        return this.group("Mutation answer", () => {
+          let bounds = null;
+          let dabs = 0;
+          const strokeIds = [];
+          let wet;
+          for (const s of cleanedStrokes) {
+            const r = this.paintStroke(s);
+            bounds = unionRect(bounds, r.bounds);
+            dabs += r.dabs;
+            if (r.strokeId) strokeIds.push(r.strokeId);
+            if (r.wet !== void 0) wet = r.wet;
+          }
+          m.answerStrokeIds = [...strokeIds];
+          this.cached = null;
+          return {
+            id: m.id,
+            state: "answered",
+            layerId: targetLayerId,
+            strokeIds,
+            bounds,
+            dabs,
+            ...wet !== void 0 ? { wet } : {}
+          };
+        });
+      } catch (e) {
+        m.state = "claimed";
+        throw e;
+      } finally {
+        this.answeringMutation = false;
+      }
+    });
+  }
+  /**
+   * Gives up on a mutation (`id`) without answering. The user's paint stays as ordinary paint (wet
+   * strokes stay in the wet layer, and dry temporary layers merge down into their target layer).
+   */
+  declineMutation(id, reason) {
+    const m = this.mutations.find((x) => x.id === id);
+    if (!m) throw new PaintEditorError(`Unknown mutation "${id}". Call list_mutations for the pending ids.`);
+    if (m.state === "answered") throw new PaintEditorError(`Mutation "${id}" has already been answered.`);
+    if (m.state === "declined") return this.toMutationInfo(m);
+    m.state = "declined";
+    if (reason?.trim()) m.declineReason = reason.trim();
+    this.keepMutationPaint(m);
+    if (this.mutationDirector && m.claimedBy) {
+      this.mutationDirector.presence.remove(m.claimedBy.replace(/^agent:/, "") || "mutation-agent");
+    }
+    this.emit();
+    return this.toMutationInfo(m);
+  }
+  /**
+   * Advances mutation timers (`settle`, `patience`, and dry temporary-layer `fade`) by `seconds`
+   * of simulated time. Called automatically from `tickMutations` and `advanceWet`.
+   */
+  advanceMutations(seconds) {
+    if (!(seconds > 0) || !this.mutations.length) return;
+    let changed = false;
+    let dirty = [];
+    for (const m of [...this.mutations]) {
+      const wasState = m.state;
+      if (wasState === "settling" || wasState === "pending" || wasState === "claimed") {
+        m.age += seconds;
+        changed = true;
+      }
+      if (wasState === "settling") {
+        m.sinceLastStroke += seconds;
+        if (m.sinceLastStroke >= m.settle - 1e-9) {
+          m.state = "pending";
+          m.sincePending = Math.max(0, m.sinceLastStroke - m.settle);
+          const info = this.toMutationInfo(m);
+          for (const listener of [...this.mutationListeners]) {
+            listener(info);
+          }
+          if (m.state === "pending" && m.sincePending >= m.patience - 1e-9) {
+            this.expireMutation(m);
+            dirty = "all";
+          }
+        }
+      } else if (wasState === "pending") {
+        m.sincePending += seconds;
+        if (m.sincePending >= m.patience - 1e-9) {
+          this.expireMutation(m);
+          dirty = "all";
+        }
+      } else if (wasState === "claimed" || wasState === "answered") {
+        if (m.medium === "dry" && m.tempLayerId) {
+          changed = true;
+          m.fadeRemaining = Math.max(0, m.fadeRemaining - seconds);
+          if (m.fadeRemaining <= 1e-9) {
+            this.removeTempMutationLayer(m);
+            dirty = "all";
+          } else {
+            const opacity = m.fade > 0 ? Math.max(0, Math.min(1, m.fadeRemaining / m.fade)) : 0;
+            const tempId = m.tempLayerId;
+            if (findLayer(this.doc.layers, tempId)) {
+              this.doc = { ...this.doc, layers: mapLayer(this.doc.layers, tempId, (l) => ({ ...l, opacity })) };
+              dirty = "all";
+            }
+          }
+        }
+      }
+    }
+    if (changed) {
+      this.cached = null;
+      this.emit(dirty);
+    }
+  }
+  /** Steps mutation timers with the wall clock (`performance.now()`, in ms). */
+  tickMutations(now) {
+    if (!Number.isFinite(now)) return;
+    if (this.lastMutationTick === null) {
+      this.lastMutationTick = now;
+      return;
+    }
+    const dt = Math.max(0, Math.min(1, (now - this.lastMutationTick) / 1e3));
+    this.lastMutationTick = now;
+    if (dt > 0 && !this.session) {
+      this.advanceMutations(dt);
+    }
+  }
+  toMutationInfo(m) {
+    return {
+      id: m.id,
+      state: m.state,
+      layerId: m.layerId,
+      medium: m.medium,
+      bounds: m.bounds ? { ...m.bounds } : null,
+      strokeCount: m.strokes.length,
+      age: Math.round(m.age * 100) / 100,
+      settle: m.settle,
+      patience: m.patience,
+      fade: m.fade,
+      ...m.claimedBy ? { claimedBy: m.claimedBy } : {},
+      ...m.answerStrokeIds ? { answerStrokeIds: [...m.answerStrokeIds] } : {},
+      ...m.declineReason ? { declineReason: m.declineReason } : {}
+    };
+  }
+  recordMutationStroke(stroke, bounds) {
+    const mut = stroke.brush.mutation;
+    if (!mut || this.answeringMutation || this.previewing || this.getOrigin().startsWith("agent:")) return;
+    const medium = isWetBrush(stroke.brush) ? "wet" : "dry";
+    const tempLayerId = medium === "dry" && this.tempLayerTargets.has(stroke.layerId) ? stroke.layerId : void 0;
+    const targetLayerId = tempLayerId ? this.tempLayerTargets.get(tempLayerId) : stroke.layerId;
+    let entry = this.mutations.find((m) => m.state === "settling" && m.layerId === targetLayerId && m.medium === medium);
+    if (!entry) {
+      entry = {
+        id: `m${this.nextMutationId++}`,
+        state: "settling",
+        layerId: targetLayerId,
+        ...tempLayerId ? { tempLayerId } : {},
+        medium,
+        strokes: [],
+        bounds: null,
+        settle: mut.settle,
+        patience: mut.patience,
+        fade: mut.fade,
+        age: 0,
+        sinceLastStroke: 0,
+        sincePending: 0,
+        fadeRemaining: mut.fade
+      };
+      this.mutations.push(entry);
+      if (medium === "wet") this.holdMutationEvaporation(targetLayerId);
+    } else {
+      entry.settle = mut.settle;
+      entry.patience = mut.patience;
+      entry.fade = mut.fade;
+      entry.fadeRemaining = mut.fade;
+      entry.sinceLastStroke = 0;
+      if (tempLayerId && !entry.tempLayerId) entry.tempLayerId = tempLayerId;
+    }
+    const strokeRect = bounds ?? strokeBounds(stroke.points);
+    entry.strokes.push({
+      id: stroke.id,
+      color: stroke.color,
+      brushId: stroke.brush.id,
+      brushName: stroke.brush.name,
+      size: stroke.brush.tip.size,
+      points: stroke.points.map((p) => ({ ...p })),
+      bounds: strokeRect ? { ...strokeRect } : null
+    });
+    entry.bounds = unionRect(entry.bounds, strokeRect);
+    this.cached = null;
+  }
+  holdMutationEvaporation(layerId) {
+    if (this.heldEvaporation.has(layerId)) return;
+    const currentEvap = (this.wet.settings.get(layerId)?.params ?? this.wet.info(layerId).params).evaporation;
+    this.heldEvaporation.set(layerId, currentEvap);
+    this.wet.setParams(layerId, { evaporation: 0 });
+  }
+  releaseMutationEvaporation(layerId) {
+    const stillWaiting = this.mutations.some(
+      (m) => m.medium === "wet" && m.layerId === layerId && (m.state === "settling" || m.state === "pending")
+    );
+    if (stillWaiting) return;
+    const saved = this.heldEvaporation.get(layerId);
+    if (saved === void 0) return;
+    this.heldEvaporation.delete(layerId);
+    if (findLayer(this.doc.layers, layerId)) {
+      this.wet.setParams(layerId, { evaporation: saved });
+    }
+  }
+  finishWetMutationsOnDry(layerId) {
+    for (const m of this.mutations) {
+      if (m.medium === "wet" && m.layerId === layerId && (m.state === "settling" || m.state === "pending")) {
+        m.state = "declined";
+        m.declineReason = "Dried before an agent claimed it.";
+      }
+    }
+    this.releaseMutationEvaporation(layerId);
+  }
+  expireMutation(m) {
+    m.state = "declined";
+    m.declineReason = "No agent answered before patience ran out.";
+    this.keepMutationPaint(m);
+  }
+  keepMutationPaint(m) {
+    if (m.medium === "wet") {
+      this.releaseMutationEvaporation(m.layerId);
+      this.wet.keepGhost(m.layerId);
+      this.recordWetSetting({ kind: "ghost-keep", layerId: m.layerId });
+      return;
+    }
+    const tempId = m.tempLayerId;
+    if (!tempId) return;
+    m.tempLayerId = void 0;
+    this.tempLayerTargets.delete(tempId);
+    if (!findLayer(this.doc.layers, tempId)) return;
+    this.doc = this.mergeTempLayerIntoTarget(this.doc, tempId, m.layerId);
+    for (const e of this.undoStack) {
+      if (findLayer(e.before.layers, tempId)) e.before = this.mergeTempLayerIntoTarget(e.before, tempId, m.layerId);
+      if (findLayer(e.after.layers, tempId)) e.after = this.mergeTempLayerIntoTarget(e.after, tempId, m.layerId);
+    }
+    while (this.undoStack.length >= 2 && !findLayer(this.undoStack[this.undoStack.length - 2].before.layers, tempId) && this.undoStack[this.undoStack.length - 1].before.strokes.some((s) => m.strokes.some((ms) => ms.id === s.id)) && this.undoStack[this.undoStack.length - 2].after.strokes.some((s) => m.strokes.some((ms) => ms.id === s.id))) {
+      const top = this.undoStack.pop();
+      const prev = this.undoStack[this.undoStack.length - 1];
+      prev.after = top.after;
+    }
+  }
+  mergeTempLayerIntoTarget(doc, tempLayerId, targetLayerId) {
+    const upper = findLayer(doc.layers, tempLayerId)?.layer;
+    const below = findLayer(doc.layers, targetLayerId)?.layer;
+    if (!isPixelLayer(upper)) return doc;
+    if (!isPixelLayer(below)) {
+      return {
+        ...doc,
+        layers: mapLayer(doc.layers, tempLayerId, () => null),
+        strokes: doc.strokes.filter((s) => s.layerId !== tempLayerId)
+      };
+    }
+    const rect = unionRect(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
+    let surface = below.surface;
+    let offset = below.offset;
+    if (rect) {
+      const base = { ...below, opacity: 1, blend: "normal", visible: true, clipped: void 0, mask: void 0 };
+      const top = { ...upper, opacity: 1, visible: true };
+      const px = createPaintCompositor().composite([base, top], rect, this.sources());
+      surface = surfaceFromPixels({ width: rect.width, height: rect.height, data: px }, 4, rect.x, rect.y);
+      offset = { x: 0, y: 0 };
+    }
+    const merged = { ...below, surface, offset };
+    const layers = mapLayer(mapLayer(doc.layers, upper.id, () => null), below.id, () => merged);
+    const strokes = doc.strokes.map((s) => s.layerId === tempLayerId ? { ...s, layerId: targetLayerId } : s);
+    return { ...doc, layers, strokes };
+  }
+  removeTempMutationLayer(m) {
+    const tempId = m.tempLayerId;
+    if (!tempId) return;
+    m.tempLayerId = void 0;
+    this.tempLayerTargets.delete(tempId);
+    const strip = (d) => {
+      if (!findLayer(d.layers, tempId) && !d.strokes.some((s) => s.layerId === tempId)) return d;
+      return {
+        ...d,
+        layers: mapLayer(d.layers, tempId, () => null),
+        strokes: d.strokes.filter((s) => s.layerId !== tempId)
+      };
+    };
+    this.doc = strip(this.doc);
+    const mutStrokeIds = new Set(m.strokes.map((s) => s.id));
+    for (const e of this.undoStack) {
+      const isMutationCreationStep = !e.before.strokes.some((s) => mutStrokeIds.has(s.id)) && e.after.strokes.some((s) => mutStrokeIds.has(s.id));
+      if (!isMutationCreationStep) {
+        e.before = strip(e.before);
+        e.after = strip(e.after);
+      }
+    }
+  }
+  reconcileMutationsAfterUndo() {
+    if (!this.mutations.length) return;
+    const remainingIds = new Set(this.doc.strokes.map((s) => s.id));
+    const kept = [];
+    for (const m of this.mutations) {
+      m.strokes = m.strokes.filter((s) => remainingIds.has(s.id));
+      if (m.strokes.length === 0) {
+        this.mutationDirector?.cancel(m.id);
+        if (m.claimedBy && this.mutationDirector) {
+          this.mutationDirector.presence.remove(m.claimedBy.replace(/^agent:/, "") || "mutation-agent");
+        }
+        if (m.tempLayerId) {
+          const tempId = m.tempLayerId;
+          this.tempLayerTargets.delete(tempId);
+          if (findLayer(this.doc.layers, tempId)) {
+            this.doc = {
+              ...this.doc,
+              layers: mapLayer(this.doc.layers, tempId, () => null),
+              strokes: this.doc.strokes.filter((s) => s.layerId !== tempId)
+            };
+          }
+        }
+        if (m.medium === "wet") {
+          this.releaseMutationEvaporation(m.layerId);
+        }
+      } else {
+        m.bounds = m.strokes.reduce((acc, s) => unionRect(acc, s.bounds), null);
+        kept.push(m);
+      }
+    }
+    this.mutations = kept;
+  }
+  resetMutations() {
+    for (const m of this.mutations) {
+      this.mutationDirector?.cancel(m.id);
+    }
+    this.mutations = [];
+    this.heldEvaporation.clear();
+    this.tempLayerTargets.clear();
+    this.lastMutationTick = null;
+  }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
     const l = findLayer(this.currentLayers(), id)?.layer;
@@ -9989,6 +12003,7 @@ var MAX_IMAGE_SIDE = 8192;
 var movePoint = (p, dx, dy) => ({ x: p.x + dx, y: p.y + dy });
 var moveRect = (r, dx, dy) => ({ ...r, x: r.x + dx, y: r.y + dy });
 var SPILL_SUFFIX = "::light";
+var UV_SPILL_SUFFIX = "::uv";
 function withLayerLight(light, layerId, next) {
   if (!next) return light ? { ...light } : void 0;
   const out = { ...light ?? {} };
@@ -9996,6 +12011,13 @@ function withLayerLight(light, layerId, next) {
   else delete out[layerId];
   return out;
 }
+function withLayerThick(thick, layerId, next) {
+  if (!next) return thick ? { ...thick } : void 0;
+  const out = { ...thick ?? {} };
+  if (hasThickChannels(next)) out[layerId] = next;
+  else delete out[layerId];
+  return out;
+}
 var BACKLIGHT_LAYER_ID = "__backlight";
 function insertAfter(layers, id, node) {
   const i = layers.findIndex((l) => l.id === id);
@@ -10207,16 +12229,42 @@ var PaintDirector = class {
   options;
   clock;
   queue;
+  cancelled = /* @__PURE__ */ new Set();
+  currentRun = null;
+  /** Cancels any queued or running performance with `key` (e.g. a mutation that was undone). */
+  cancel(key) {
+    this.cancelled.add(key);
+    if (this.currentRun?.key === key) {
+      const { actorId, cancelSession } = this.currentRun;
+      this.currentRun = null;
+      cancelSession?.();
+      this.presence.remove(actorId);
+    }
+  }
   /** Acts out `commands` in order for `actor`. Resolves with one result per command. */
-  perform(actor, commands) {
+  perform(actor, commands, options) {
+    const key = options?.key;
+    if (key) this.cancelled.delete(key);
     return this.queue.run(actor, async () => {
+      if (key && this.cancelled.has(key)) {
+        return commands.map((command) => ({ ok: false, command, message: "The mutation was cancelled." }));
+      }
+      if (key) this.currentRun = { actorId: actor.id, key };
       const results = [];
-      for (const command of commands) {
-        try {
-          results.push({ ok: true, command, result: await this.performOne(actor.id, command) });
-        } catch (error) {
-          results.push({ ok: false, command, message: error instanceof Error ? error.message : String(error) });
+      try {
+        for (const command of commands) {
+          if (key && this.cancelled.has(key)) {
+            results.push({ ok: false, command, message: "The mutation was cancelled." });
+            continue;
+          }
+          try {
+            results.push({ ok: true, command, result: await this.performOne(actor.id, command, key) });
+          } catch (error) {
+            results.push({ ok: false, command, message: error instanceof Error ? error.message : String(error) });
+          }
         }
+      } finally {
+        if (this.currentRun?.key === key) this.currentRun = null;
       }
       return results;
     });
@@ -10242,7 +12290,7 @@ var PaintDirector = class {
     this.presence.set({ id, message: text });
     await this.clock.wait(this.ms(ms));
   }
-  async performOne(id, command) {
+  async performOne(id, command, key) {
     const c = this.controller;
     switch (command.kind) {
       case "say":
@@ -10257,10 +12305,10 @@ var PaintDirector = class {
         return void 0;
       case "stroke":
         await this.say(id, command.note, 500);
-        return this.stroke(id, command.stroke);
+        return this.stroke(id, command.stroke, void 0, key);
       case "strokes":
         await this.say(id, command.note, 500);
-        return this.strokes(id, command.strokes, command.label);
+        return this.strokes(id, command.strokes, command.label, key);
       case "fill": {
         await this.say(id, command.note, 500);
         const { width, height } = c.getState().document.canvas;
@@ -10297,19 +12345,26 @@ var PaintDirector = class {
     }
   }
   /** Paints a stroke live: begins it, pushes its points frame by frame as the cursor reaches them, then ends it (one undo step). */
-  async stroke(id, init, within = (step) => step()) {
+  async stroke(id, init, within = (step) => step(), key) {
     const c = this.controller;
     const points = c.checkPoints(init.points);
     const { points: _points, ...rest } = init;
     const session = within(() => c.beginStroke({ snapToPerspective: false, start: points[0], ...rest }));
+    if (key && this.currentRun?.key === key) {
+      this.currentRun.cancelSession = () => {
+        if (c.activeStroke === session) session.cancel();
+      };
+    }
     try {
       await this.glide(id, points[0]);
+      if (key && this.cancelled.has(key)) throw new PaintEditorError("The mutation was cancelled.");
       this.presence.set({ id, pressed: true });
       const at = strokeSchedule(points);
       const duration = this.ms(strokeDuration(points, this.options.maxStrokeMs));
       let next = 0;
       const frames = Math.max(1, Math.round(duration / FRAME));
       for (let f = 1; f <= frames; f++) {
+        if (key && this.cancelled.has(key)) throw new PaintEditorError("The mutation was cancelled.");
         const t = f / frames;
         const from = next;
         while (next < points.length && at[next] <= t + 1e-9) next++;
@@ -10320,6 +12375,7 @@ var PaintDirector = class {
         }
         if (f < frames) await this.clock.wait(duration / frames);
       }
+      if (key && this.cancelled.has(key)) throw new PaintEditorError("The mutation was cancelled.");
       if (next < points.length) session.push(points.slice(next));
       this.presence.set({ id, pressed: false });
       return session.end();
@@ -10327,10 +12383,12 @@ var PaintDirector = class {
       if (c.activeStroke === session) session.cancel();
       this.presence.set({ id, pressed: false });
       throw error;
+    } finally {
+      if (key && this.currentRun?.key === key) delete this.currentRun.cancelSession;
     }
   }
   /** Paints several strokes live in turn and commits them as one undo step (e.g. a path's subpaths). */
-  async strokes(id, inits, label) {
+  async strokes(id, inits, label, key) {
     const c = this.controller;
     if (!Array.isArray(inits) || !inits.length) throw new PaintEditorError("strokes is empty; give at least one stroke.");
     const checked = inits.map((s) => ({ ...s, points: c.checkPoints(s.points) }));
@@ -10344,7 +12402,8 @@ var PaintDirector = class {
       const strokeIds = [];
       let last = null;
       for (const s of checked) {
-        const r = await this.stroke(id, s, within);
+        if (key && this.cancelled.has(key)) throw new PaintEditorError("The mutation was cancelled.");
+        const r = await this.stroke(id, s, within, key);
         layerId = r.layerId;
         bounds = unionRect2(bounds, r.bounds);
         dabs += r.dabs;
@@ -11290,7 +13349,7 @@ function createPaintThickTools(c) {
     {
       name: "set_lighting",
       title: "Move the light",
-      description: "Sets where the light comes from for thick paint (impasto relief) and metallic paper: azimuth (degrees clockwise from the top of the canvas; 315 is top left), elevation (5 grazing, deep shadows .. 90 straight on, no relief) and relief (0 flat .. 1 strong). Nothing is repainted: the relief is lit at render time. Saved with the document, not an undo step. Returns the lighting.",
+      description: "Sets where the light comes from for thick paint (impasto relief), thin-film iridescence and metallic paper: azimuth (degrees clockwise from the top of the canvas; 315 is top left), elevation (5 grazing, deep shadows .. 90 straight on, no relief) and relief (0 flat .. 1 strong). Nothing is repainted: the relief and iridescence are lit at render time. Saved with the document, not an undo step. Returns the lighting.",
       inputSchema: {
         type: "object",
         properties: {
@@ -11303,6 +13362,29 @@ function createPaintThickTools(c) {
       annotations: { title: "Move the light", ...SET3 },
       handler: (a) => c.setLighting(a)
     },
+    {
+      name: "set_view_tilt",
+      title: "Tilt the view angle for iridescence",
+      description: "Tilts the viewer\u2019s look angle for thin-film iridescence and specular highlights: x (-1 left .. 1 right, default 0) and y (-1 top .. 1 bottom, default 0). Moves the view vector, not the light, so iridescent paint (brushes with iridescence, such as scarab-lacquer, soap-film, pearl-glaze) shifts hue across the spectrum as the angle changes. Editor state (not saved with the document, not an undo step). Returns the view tilt.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          x: { type: "number", minimum: -1, maximum: 1, description: "Horizontal view tilt, -1 (left) .. 1 (right); default 0." },
+          y: { type: "number", minimum: -1, maximum: 1, description: "Vertical view tilt, -1 (top) .. 1 (bottom); default 0." }
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "Tilt the view angle for iridescence", ...SET3 },
+      handler: (a) => c.setViewTilt(a)
+    },
+    {
+      name: "get_view_tilt",
+      title: "Read the view tilt",
+      description: "Reads the viewer\u2019s look angle for thin-film iridescence and specular highlights: x and y in -1..1 (0, 0 is straight on). Changes nothing.",
+      inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      annotations: { title: "Read the view tilt", ...READ4 },
+      handler: () => c.getViewTilt()
+    },
     {
       name: "get_relief",
       title: "Read a layer\u2019s relief",
@@ -11327,6 +13409,111 @@ function createPaintThickTools(c) {
       inputSchema: { type: "object", properties: { on: { type: "boolean", description: "true dries every wet stroke as it ends." } }, required: ["on"], additionalProperties: false },
       annotations: { title: "Dry wet strokes at once", ...SET3 },
       handler: ({ on }) => ({ instantDry: c.setInstantDry(on) })
+    },
+    {
+      name: "set_uv_light",
+      title: "Set UV blacklight",
+      description: "Switches the virtual UV blacklight (on) and sets its glow strength (0..2, default 1) and ambient daylight level (0..1, default 0.15). When on, the paper and daylight paint dim to ambient and fluorescent strokes (fluorescence.amount > 0, including invisible UV ink) glow and spill in their own colour. Saved with the document, not an undo step. Returns the UV light settings and fluorescentLayerIds.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          on: { type: "boolean", description: "Whether the UV blacklight is switched on (default false)." },
+          strength: { type: "number", minimum: 0, maximum: 2, description: "UV emission and spill strength, 0..2 (default 1)." },
+          ambient: { type: "number", minimum: 0, maximum: 1, description: "How much normal daylight remains under UV, 0 (pitch dark) .. 1 (full daylight, default 0.15)." }
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "Set UV blacklight", ...SET3 },
+      handler: (a) => ({ ...c.setUvLight(a), fluorescentLayerIds: c.fluorescentLayerIds() })
+    },
+    {
+      name: "get_uv_light",
+      title: "Read UV blacklight",
+      description: "Reads the virtual UV blacklight settings (on, strength, ambient) and the ids of layers that hold UV-fluorescent ink (fluorescentLayerIds). Changes nothing.",
+      inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      annotations: { title: "Read UV blacklight", ...READ4 },
+      handler: () => ({ ...c.getUvLight(), fluorescentLayerIds: c.fluorescentLayerIds() })
+    },
+    {
+      name: "paint_heat",
+      title: "Warm or cool the canvas",
+      description: "Applies a heat brush along points on the document\u2019s coarse heat field (radius in document pixels, default 24; temperature 0 cools .. 1 warms, default 1). Thermochromic strokes (thermochromic.hotColor) shift smoothly toward their hot colour where local temperature crosses their threshold, and wet paint under hot tiles (temperature >= 0.5) dries in place. One undo step. Returns the heat field stats (max, mean, hotCells, bounds) and any dried wet layers.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          points: {
+            type: "array",
+            minItems: 1,
+            description: "Polyline of document positions to warm or cool along.",
+            items: {
+              type: "object",
+              properties: {
+                x: { type: "number", description: "Document x in pixels." },
+                y: { type: "number", description: "Document y in pixels." }
+              },
+              required: ["x", "y"],
+              additionalProperties: false
+            }
+          },
+          radius: { type: "number", minimum: 1, maximum: 512, description: "Heat falloff radius in document pixels, 1..512 (default 24)." },
+          temperature: { type: "number", minimum: 0, maximum: 1, description: "Target temperature along the stroke, 0 (cool) .. 1 (hot, default 1)." }
+        },
+        required: ["points"],
+        additionalProperties: false
+      },
+      annotations: { title: "Warm or cool the canvas", ...WRITE4 },
+      coordinates: { in: ["points"], out: ["bounds", "dried[].bounds"] },
+      handler: ({ points, radius, temperature }) => c.paintHeat({ points, radius, temperature })
+    },
+    {
+      name: "advance_heat",
+      title: "Spread and cool heat",
+      description: "Advances the document\u2019s heat field by steps (1..200, default 10) of thermal diffusion and Newtonian cooling, so warm patches spread outward and fade back toward cold paint. Any wet paint under hot cells dries. Not an undo step (time passing never is). Returns steps, the updated heat stats (max, mean, hotCells, bounds) and any dried wet layers.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          steps: { type: "integer", minimum: 1, maximum: 200, description: "Diffusion and cooling steps to run, 1..200 (default 10)." }
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "Spread and cool heat", ...SET3 },
+      coordinates: { out: ["bounds", "dried[].bounds"] },
+      handler: ({ steps }) => c.advanceHeat(steps)
+    },
+    {
+      name: "clear_heat",
+      title: "Cool the whole canvas",
+      description: "Cools the entire document heat field back to 0 at once so all thermochromic paint returns to its cold colour. One undo step when the canvas was warm. Returns { cleared }.",
+      inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      annotations: { title: "Cool the whole canvas", ...WRITE4 },
+      handler: () => c.clearHeat()
+    },
+    {
+      name: "get_heat",
+      title: "Read canvas heat",
+      description: "Reads the document\u2019s heat field stats (max, mean, hotCells, bounds), optional temperature samples (0..1) at points in document pixels, and thermochromicLayerIds. Changes nothing.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          points: {
+            type: "array",
+            description: "Optional document positions (px) at which to sample the local temperature (0..1).",
+            items: {
+              type: "object",
+              properties: {
+                x: { type: "number", description: "Document x in pixels." },
+                y: { type: "number", description: "Document y in pixels." }
+              },
+              required: ["x", "y"],
+              additionalProperties: false
+            }
+          }
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "Read canvas heat", ...READ4 },
+      coordinates: { in: ["points"], out: ["bounds", "samples"] },
+      handler: ({ points }) => ({ ...c.getHeat(points), thermochromicLayerIds: c.thermochromicLayerIds() })
     }
   ];
 }
@@ -11394,9 +13581,220 @@ function createPaintReplayTools(c) {
   ];
 }
 
-// src/paint-editor/evolution-tools.ts
+// src/paint-editor/mutation-tools.ts
 var READ6 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var SET4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var POINTS = {
+  type: "array",
+  minItems: 1,
+  maxItems: 2e4,
+  description: "The path in document pixels (raw samples; the brush smooths them). One point paints one dab.",
+  items: {
+    type: "object",
+    properties: {
+      x: { type: "number", description: "Document x in pixels." },
+      y: { type: "number", description: "Document y in pixels." },
+      pressure: { type: "number", minimum: 0, maximum: 1, description: "Pen pressure 0..1 (default 1)." },
+      t: { type: "number", description: "Time in milliseconds (optional; drives velocity dynamics)." },
+      tiltX: { type: "number", minimum: -90, maximum: 90, description: "Pen tilt in degrees towards +x (Pointer Events tiltX)." },
+      tiltY: { type: "number", minimum: -90, maximum: 90, description: "Pen tilt in degrees towards +y (Pointer Events tiltY)." },
+      altitude: { type: "number", minimum: 0, maximum: 1.5708, description: "Pen altitude in radians: 1.5708 upright, 0 lying flat (overrides tiltX / tiltY)." },
+      azimuth: { type: "number", minimum: 0, maximum: 6.2832, description: "Where the pen leans, radians clockwise from +x (with altitude)." },
+      twist: { type: "number", minimum: 0, maximum: 359, description: "Barrel rotation in degrees (brushes with rotation barrel)." }
+    },
+    required: ["x", "y"],
+    additionalProperties: false
+  }
+};
+function createMutationTools(c, options = {}) {
+  return [
+    {
+      name: "list_mutations",
+      title: "List pending mutations",
+      description: 'Lists mutation exchanges waiting for an agent (or all of them when includeAll is true): each with id, state ("settling" | "pending" | "claimed" | "answered" | "declined"), layerId, medium ("wet" | "dry"), bounds in document pixels, strokeCount, age in seconds, settle, patience and fade. Use an id with read_mutation or decline_mutation.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          includeAll: {
+            type: "boolean",
+            description: "Include settling, claimed, answered and declined mutations as well as pending ones (default false)."
+          }
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "List pending mutations", ...READ6 },
+      coordinates: { out: ["mutations[].bounds"] },
+      handler: (a) => ({ mutations: c.listMutations({ includeAll: Boolean(a.includeAll) }) })
+    },
+    {
+      name: "read_mutation",
+      title: "Read and claim a mutation",
+      description: 'Claims a mutation by id and starts its fade so the user\u2019s stroke sinks away as you read it. Returns the mutation\u2019s id, state ("claimed"), layerId, medium, bounds, fade duration in seconds, the strokes (id, color, brushId, brushName, size, points and bounds in document pixels), cropPng (base64 PNG and rect of the area around the strokes) and canvasPng (base64 PNG preview of the whole painting so you can choose where to answer). Refused if already claimed, answered or declined. Follow with answer_mutation or decline_mutation.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Mutation id from list_mutations (e.g. "m1").'
+          },
+          padding: {
+            type: "integer",
+            minimum: 0,
+            maximum: 512,
+            description: "Padding around the mutation bounds for cropPng, in document pixels (default 32)."
+          },
+          maxSide: {
+            type: "integer",
+            minimum: 64,
+            maximum: 2048,
+            description: "Longest side of the canvasPng preview in pixels (default 512)."
+          }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      annotations: { title: "Read and claim a mutation", ...WRITE5 },
+      coordinates: { out: ["bounds", "strokes[].bounds", "strokes[].points[]", "cropPng.rect"] },
+      handler: (a) => c.readMutation(a.id, {
+        actor: options.actor?.id,
+        padding: a.padding,
+        maxSide: a.maxSide
+      })
+    },
+    {
+      name: "answer_mutation",
+      title: "Answer a mutation with strokes",
+      description: 'Paints your answer to a claimed mutation (from read_mutation). Pass one or more strokes (each with points in document pixels, and optional brushId, brush facets, color, paint, layerId and seed). When a director is attached, your cursor glides across the canvas and paints live; all strokes commit as one undo step with origin agent:<id>. A second answer to the same mutation id is refused. Returns the mutation id, state ("answered"), layerId, new strokeIds, painted bounds and dab count.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Claimed mutation id from read_mutation (e.g. "m1").'
+          },
+          strokes: {
+            type: "array",
+            minItems: 1,
+            maxItems: 200,
+            description: "The strokes that form the answer, painted in order as one undo step.",
+            items: {
+              type: "object",
+              properties: {
+                points: POINTS,
+                layerId: {
+                  type: "string",
+                  description: "Layer id from list_layers for this stroke (default the answer layerId or the mutation layerId)."
+                },
+                brushId: {
+                  type: "string",
+                  description: "Brush id from list_brush_presets (default the active brush)."
+                },
+                brush: {
+                  type: "object",
+                  description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).",
+                  properties: BRUSH_PATCH_PROPERTIES,
+                  additionalProperties: false
+                },
+                color: {
+                  type: "string",
+                  pattern: "^#[0-9a-fA-F]{6}$",
+                  description: "Paint colour #rrggbb (default the paint colour)."
+                },
+                paint: {
+                  ...PAINT_SOURCE_JSON_SCHEMA,
+                  description: "Colour or gradient paint for this stroke."
+                },
+                seed: {
+                  type: "integer",
+                  minimum: 0,
+                  description: "Jitter seed for reproducible marks (default a new one)."
+                },
+                snapToPerspective: {
+                  type: "boolean",
+                  description: "Snap the points to the perspective guide (default false)."
+                }
+              },
+              required: ["points"],
+              additionalProperties: false
+            }
+          },
+          layerId: {
+            type: "string",
+            description: "Default pixel layer id from list_layers for the answer strokes (default the mutation\u2019s layerId)."
+          },
+          note: {
+            type: "string",
+            description: "Short note shown next to the agent cursor while painting (optional)."
+          }
+        },
+        required: ["id", "strokes"],
+        additionalProperties: false
+      },
+      annotations: { title: "Answer a mutation with strokes", ...WRITE5 },
+      coordinates: { in: ["strokes[].points[]"], out: ["bounds"] },
+      handler: async (a) => {
+        await c.wetIdle();
+        const rawStrokes = a.strokes;
+        const strokes = [];
+        for (const s of rawStrokes) {
+          const base = s.brushId ? c.getBrush(s.brushId) : c.getState().brush;
+          const brush = s.brush ? c.brushChanges(s.brush, s.brushId) : void 0;
+          if (base) {
+            const refs = brushStickerRefs(normalizePaintBrush({ ...brush ?? {}, id: base.id }, base));
+            if (refs.length) await c.prepareStickers(refs);
+          }
+          strokes.push({
+            points: s.points,
+            ...s.layerId !== void 0 ? { layerId: s.layerId } : {},
+            ...s.brushId !== void 0 ? { brushId: s.brushId } : {},
+            ...brush !== void 0 ? { brush } : {},
+            ...s.color !== void 0 ? { color: s.color } : {},
+            ...s.paint !== void 0 ? { paint: s.paint } : {},
+            ...s.seed !== void 0 ? { seed: s.seed } : {},
+            ...s.snapToPerspective !== void 0 ? { snapToPerspective: s.snapToPerspective } : {}
+          });
+        }
+        return c.answerMutation(
+          a.id,
+          {
+            strokes,
+            ...a.layerId !== void 0 ? { layerId: a.layerId } : {},
+            ...a.note !== void 0 ? { note: a.note } : {}
+          },
+          { director: options.director, actor: options.actor }
+        );
+      }
+    },
+    {
+      name: "decline_mutation",
+      title: "Decline a mutation",
+      description: "Declines a mutation without answering so the user\u2019s paint stays as ordinary paint (wet strokes stay in the wet layer and dry temporary layers merge down into their target layer). Returns the updated mutation info.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Mutation id from list_mutations (e.g. "m1").'
+          },
+          reason: {
+            type: "string",
+            description: "Why the mutation was declined (optional)."
+          }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      annotations: { title: "Decline a mutation", ...SET4 },
+      coordinates: { out: ["bounds"] },
+      handler: (a) => c.declineMutation(a.id, a.reason)
+    }
+  ];
+}
+
+// src/paint-editor/evolution-tools.ts
+var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var UNIT2 = (description) => ({ type: "number", minimum: 0, maximum: 1, description });
 var EVOLUTION_MUTATION_SCHEMA = {
   type: "object",
@@ -11441,7 +13839,7 @@ function createPaintEvolutionTools(c) {
         required: ["strokeIds"],
         additionalProperties: false
       },
-      annotations: { title: "Breed stroke variants", ...WRITE5 },
+      annotations: { title: "Breed stroke variants", ...WRITE6 },
       coordinates: { out: ["proposals[].bounds"] },
       handler: ({ strokeIds, count, mutation, seed }, context) => {
         const actor = context?.actor?.id;
@@ -11484,7 +13882,7 @@ function createPaintEvolutionTools(c) {
         required: ["proposalIds"],
         additionalProperties: false
       },
-      annotations: { title: "Breed from paint proposals", ...WRITE5 },
+      annotations: { title: "Breed from paint proposals", ...WRITE6 },
       coordinates: { out: ["proposals[].bounds"] },
       handler: ({ proposalIds, count, mutation, seed }, context) => {
         const actor = context?.actor?.id;
@@ -11512,7 +13910,7 @@ function createPaintEvolutionTools(c) {
         required: ["proposalId"],
         additionalProperties: false
       },
-      annotations: { title: "Get a proposal\u2019s stroke genome", ...READ6 },
+      annotations: { title: "Get a proposal\u2019s stroke genome", ...READ7 },
       coordinates: { out: ["bounds", "strokes[].points[]"] },
       handler: ({ proposalId }) => c.getProposalGenome(proposalId)
     }
@@ -11531,15 +13929,15 @@ function createPaintEvolutionToolProvider(controller, options = {}) {
 }
 
 // src/paint-editor/tools.ts
-var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var SET4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE7 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var SET5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var EMPTY3 = { type: "object", properties: {}, additionalProperties: false };
 var COLOR3 = { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: 'Colour #rrggbb, e.g. "#2a4b8d".' };
 var LAYER_ID4 = { type: "string", description: "Layer id from list_layers (default the active layer)." };
 var TIME = { type: "number", minimum: 0, description: "Draw live effect paint (strokes on stroke layers painted with live effect paint) this many ms into its animation (default: as painted, its own time)." };
-var POINTS = {
+var POINTS2 = {
   type: "array",
   minItems: 1,
   maxItems: 2e4,
@@ -11581,7 +13979,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Get the canvas",
     description: "Reads the canvas: size in pixels and dpi, its origin (where (0, 0) is relative to the canvas it was extended from), bounds (the rectangle the painting covers, in the coordinates every other tool takes), the paper (preset, colour, grain depth), the active layer, the active brush id, the paint colour, the view (zoom, rotation, mirror), the hand, how many strokes are recorded, the undo / redo labels, and the blend modes. Call it first.",
     inputSchema: EMPTY3,
-    annotations: { title: "Get the canvas", ...READ7 },
+    annotations: { title: "Get the canvas", ...READ8 },
     coordinates: { out: ["bounds"] },
     handler: () => {
       const s = c.getState();
@@ -11642,7 +14040,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Resize the canvas", ...SET4 },
+    annotations: { title: "Resize the canvas", ...SET5 },
     handler: (a) => c.setCanvas({ width: a.width, height: a.height, dpi: a.dpi })
   });
   const EXTEND_SIDE = (side) => ({ type: "integer", minimum: 0, maximum: MAX_CANVAS_SIDE - 1, description: `Pixels to add on the ${side} (default 0).` });
@@ -11655,7 +14053,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       properties: { left: EXTEND_SIDE("left"), top: EXTEND_SIDE("top"), right: EXTEND_SIDE("right"), bottom: EXTEND_SIDE("bottom") },
       additionalProperties: false
     },
-    annotations: { title: "Extend the canvas", ...WRITE6 },
+    annotations: { title: "Extend the canvas", ...WRITE7 },
     handler: (a) => c.extendCanvas({ left: a.left, top: a.top, right: a.right, bottom: a.bottom })
   });
   add({
@@ -11663,7 +14061,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "List papers",
     description: "Lists the built-in paper library (generated grain, no textures): id, name, family, grain pattern, colour, grain depth and the wet-media properties (absorption, permeability, roughness). Use an id with set_paper or new_canvas.",
     inputSchema: EMPTY3,
-    annotations: { title: "List papers", ...READ7 },
+    annotations: { title: "List papers", ...READ8 },
     handler: () => ({
       papers: PAPER_LIBRARY.map((p) => ({ id: p.preset, name: p.name, family: p.family, pattern: p.pattern, color: p.color, depth: p.depth, absorption: p.absorption, permeability: p.permeability, roughness: p.roughness })),
       families: [...PAPER_FAMILIES],
@@ -11675,7 +14073,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Get the paper",
     description: "Reads every setting of the current paper (preset, pattern, seed, colour, scale, tiling, depth, shading, dry and wet tuning, absorption, permeability, roughness, and metallic, backlight and backlightColor when set).",
     inputSchema: EMPTY3,
-    annotations: { title: "Get the paper", ...READ7 },
+    annotations: { title: "Get the paper", ...READ8 },
     handler: () => JSON.parse(JSON.stringify(c.document.paper))
   });
   const tuning = {
@@ -11713,7 +14111,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Set the paper", ...SET4 },
+    annotations: { title: "Set the paper", ...SET5 },
     handler: (a) => c.setPaper(a)
   });
   add({
@@ -11721,7 +14119,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "List layers",
     description: "Lists the layers top first: id, name, type (pixel or group), visibility, opacity, blend, clipping, locks, whether it is active, the painted bounds in document pixels (null when empty), parent and depth.",
     inputSchema: EMPTY3,
-    annotations: { title: "List layers", ...READ7 },
+    annotations: { title: "List layers", ...READ8 },
     coordinates: { out: ["layers[].bounds"] },
     handler: () => ({ layers: c.listLayers(), activeLayerId: c.document.activeLayerId })
   });
@@ -11739,7 +14137,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Add a layer", ...WRITE6 },
+    annotations: { title: "Add a layer", ...WRITE7 },
     coordinates: { out: ["bounds"] },
     handler: (a) => c.addLayer({ name: a.name, type: a.type, aboveId: a.aboveId, parentId: a.parentId })
   });
@@ -11775,7 +14173,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Change a layer", ...SET4 },
+    annotations: { title: "Change a layer", ...SET5 },
     coordinates: { out: ["bounds"] },
     handler: ({ layerId, ...u }) => c.updateLayer(layerId, u)
   });
@@ -11784,7 +14182,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "List blend modes",
     description: "Lists every layer and brush blend mode: id, label, group (standard Photoshop modes, pigment, or painterly), what the pigment and painterly modes do, and the standard mode PSD export writes in their place. Changes nothing. Read it before choosing a painterly mode for update_layer or a brush tip.",
     inputSchema: EMPTY3,
-    annotations: { title: "List blend modes", ...READ7 },
+    annotations: { title: "List blend modes", ...READ8 },
     handler: () => ({
       modes: BLEND_MODES.map((m) => ({
         id: m.id,
@@ -11800,7 +14198,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Choose the active layer",
     description: "Makes a layer active: strokes, fills and clears without a layerId go to it. Editor state, not an undo step. Returns the layer.",
     inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Choose the active layer", ...SET4 },
+    annotations: { title: "Choose the active layer", ...SET5 },
     coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => {
       c.setActiveLayer(layerId);
@@ -11820,7 +14218,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Duplicate a layer",
     description: "Copies a layer (a group with its children) directly above it; the copy becomes active. One undo step. Returns the copy.",
     inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Duplicate a layer", ...WRITE6 },
+    annotations: { title: "Duplicate a layer", ...WRITE7 },
     coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.duplicateLayer(layerId)
   });
@@ -11838,7 +14236,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["layerId", "index"],
       additionalProperties: false
     },
-    annotations: { title: "Reorder a layer", ...WRITE6 },
+    annotations: { title: "Reorder a layer", ...WRITE7 },
     coordinates: { out: ["bounds"] },
     handler: ({ layerId, index, parentId }) => c.moveLayer(layerId, index, parentId)
   });
@@ -11867,7 +14265,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Fill a layer", ...WRITE6 },
+    annotations: { title: "Fill a layer", ...WRITE7 },
     coordinates: { out: ["bounds"] },
     handler: (a) => act({ kind: "fill", fill: a }, () => c.fillLayer(a))
   });
@@ -11914,7 +14312,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Fill a region (bucket / flats)", ...WRITE6 },
+    annotations: { title: "Fill a region (bucket / flats)", ...WRITE7 },
     coordinates: { in: ["", "points[]"], out: ["bounds", "regions[].point", "regions[].bounds"] },
     handler: (a) => act({ kind: "fill-region", fill: a }, () => c.fillRegion(a))
   });
@@ -11938,7 +14336,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Find enclosed unfilled regions", ...READ7 },
+    annotations: { title: "Find enclosed unfilled regions", ...READ8 },
     coordinates: { out: ["regions[].point", "regions[].centroid", "regions[].bounds"] },
     handler: (a) => c.findUnfilledRegions(a)
   });
@@ -11956,7 +14354,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Get a brush",
     description: "Reads a brush as facets (kind, medium, variety or tool, tip, marks, dynamics, behaviour, light, motion, colour: the brush library's form, as describe_brush returns it), with the engine it paints with and whether it is an unchanged built-in preset. Without id, the active brush as edited. Also returns strokePaint: what a stroke with it would paint now (its gradient colour, else the editor's paint from set_paint). Changes nothing.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." } }, additionalProperties: false },
-    annotations: { title: "Get a brush", ...READ7 },
+    annotations: { title: "Get a brush", ...READ8 },
     handler: ({ id }) => {
       const st = c.getState();
       const b = id === void 0 ? st.brush : c.getBrush(id);
@@ -11970,7 +14368,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Set the brush",
     description: "Chooses the active brush (id, from list_brush_presets) and / or changes it with facets laid over it (objects merge, lists and values replace, marks of another kind replace the marks; the brush library's create_brush fields); unset removes whole facets first (unset colour drops a brush's own gradient). Strokes without a brush use it. Editor state, not an undo step: the changes stay on the active brush until the library's create_brush or update_brush stores a brush. Returns the active brush as facets, the engine it paints with, and problems (values clamped or dropped).",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets to start from (default the active brush)." }, name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." }, ...BRUSH_PATCH_PROPERTIES, unset: BRUSH_UNSET_PROPERTY }, additionalProperties: false },
-    annotations: { title: "Set the brush", ...SET4 },
+    annotations: { title: "Set the brush", ...SET5 },
     handler: async ({ id, unset, ...patch }) => {
       const stamps = patch.tip?.stamps;
       if (stamps) await c.prepareStickers(stamps);
@@ -11991,7 +14389,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Set the paint colour", ...SET4 },
+    annotations: { title: "Set the paint colour", ...SET5 },
     handler: ({ color, secondaryColor, locked }) => {
       if (color === void 0 && secondaryColor === void 0 && locked === void 0) throw new Error("Pass color, secondaryColor or locked.");
       if (color !== void 0) c.setColor(color);
@@ -12006,7 +14404,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Set the paint (colour or gradient)",
     description: 'Sets what strokes paint with: one colour, or gradient paint that changes colour as the stroke goes. Gradient paint: 2..16 stops sorted by offset (#rrggbb, or "paint" / "secondary" for the two editor colours), space pigment (default: mixes like paint) / oklab / srgb, and map: distance (default: the colour changes as the stroke is dragged out, 300 px then mirrored back), pressure, tilt, velocity, direction, time, across-tip or random. Every stroking brush samples it per dab (dab, mixer, watercolour and gouache, oil and impasto, particle, bristle, sticker); erasers, blenders and smudges ignore it, and a brush with its own gradient (get_brush paint) paints that instead. It also ends effect paint (set_effect_paint); set_color goes back to one colour. Editor state, not an undo step. Returns paint, color and secondaryColor.',
     inputSchema: { type: "object", properties: { paint: PAINT_SOURCE_JSON_SCHEMA }, required: ["paint"], additionalProperties: false },
-    annotations: { title: "Set the paint (colour or gradient)", ...SET4 },
+    annotations: { title: "Set the paint (colour or gradient)", ...SET5 },
     handler: ({ paint }) => {
       const p = c.setPaint(paint);
       const s = c.getState();
@@ -12027,7 +14425,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["x", "y"],
       additionalProperties: false
     },
-    annotations: { title: "Pick a colour", ...READ7 },
+    annotations: { title: "Pick a colour", ...READ8 },
     coordinates: { in: [""] },
     handler: ({ x, y, layerId }) => c.pickColor(x, y, { layerId })
   });
@@ -12036,7 +14434,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Get the Mixer Brush load",
     description: "Reads what the brush carries between strokes: reservoir #rrggbb or null (the Mixer Brush's loaded paint), amount 0..1 left, pickup #rrggbb or null (paint picked up from the canvas, kept by dirty brushes and a Mixer Brush that does not clean each stroke). Call before painting with mixer-brush when its loadEachStroke is false, or with a dirty brush.",
     inputSchema: EMPTY3,
-    annotations: { title: "Get the Mixer Brush load", ...READ7 },
+    annotations: { title: "Get the Mixer Brush load", ...READ8 },
     handler: () => loadResult(c.getState().mixerLoad)
   });
   add({
@@ -12044,7 +14442,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Load the Mixer Brush",
     description: "Fills the Mixer Brush reservoir with a colour (amount 1), keeping what it picked up. Editor state, not an undo step. Returns the load.",
     inputSchema: { type: "object", properties: { color: { ...COLOR3, description: "Colour #rrggbb (default the paint colour)." } }, additionalProperties: false },
-    annotations: { title: "Load the Mixer Brush", ...SET4 },
+    annotations: { title: "Load the Mixer Brush", ...SET5 },
     handler: ({ color }) => loadResult(c.loadMixerBrush(color))
   });
   add({
@@ -12052,7 +14450,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Clean the Mixer Brush",
     description: "Cleans the brush: empties the picked-up paint a dirty brush or the Mixer Brush carries (and with emptyReservoir the Mixer Brush paint too). Editor state, not an undo step. Returns the load.",
     inputSchema: { type: "object", properties: { emptyReservoir: { type: "boolean", description: "Also drop the loaded paint (default false)." } }, additionalProperties: false },
-    annotations: { title: "Clean the Mixer Brush", ...SET4 },
+    annotations: { title: "Clean the Mixer Brush", ...SET5 },
     handler: ({ emptyReservoir }) => loadResult(c.cleanMixerBrush(emptyReservoir === true))
   });
   add({
@@ -12062,7 +14460,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     inputSchema: {
       type: "object",
       properties: {
-        points: POINTS,
+        points: POINTS2,
         layerId: LAYER_ID4,
         brushId: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." },
         brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: BRUSH_PATCH_PROPERTIES, additionalProperties: false },
@@ -12074,7 +14472,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Paint a brush stroke", ...WRITE6 },
+    annotations: { title: "Paint a brush stroke", ...WRITE7 },
     coordinates: { in: ["points[]"], out: ["bounds"] },
     handler: async (a) => {
       await c.wetIdle();
@@ -12111,7 +14509,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["path"],
       additionalProperties: false
     },
-    annotations: { title: "Brush along a path", ...WRITE6 },
+    annotations: { title: "Brush along a path", ...WRITE7 },
     coordinates: { out: ["bounds"] },
     handler: async (a) => {
       await c.wetIdle();
@@ -12165,7 +14563,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       properties: { limit: { type: "integer", minimum: 1, maximum: 5e3, description: "Most recent samples to return (default 500)." } },
       additionalProperties: false
     },
-    annotations: { title: "Get the stroke being painted", ...READ7 },
+    annotations: { title: "Get the stroke being painted", ...READ8 },
     handler: (args) => {
       const live = c.getLiveStroke();
       if (!live) return { live: false };
@@ -12187,7 +14585,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "List recorded strokes", ...READ7 },
+    annotations: { title: "List recorded strokes", ...READ8 },
     coordinates: { out: ["strokes[].bounds", "strokes[].points[]"] },
     handler: ({ ids, last, live, layerId }) => {
       if (layerId !== void 0 && !c.getLayer(layerId)) throw new Error(`Unknown layer "${layerId}". Call list_layers for the ids.`);
@@ -12216,7 +14614,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["x", "y"],
       additionalProperties: false
     },
-    annotations: { title: "Find the stroke at a point", ...READ7 },
+    annotations: { title: "Find the stroke at a point", ...READ8 },
     coordinates: { in: [""], out: ["stroke.bounds"] },
     handler: ({ layerId, x, y }) => {
       const s = c.liveStrokeAt(layerId, x, y);
@@ -12240,7 +14638,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["id"],
       additionalProperties: false
     },
-    annotations: { title: "Change a stroke", ...WRITE6 },
+    annotations: { title: "Change a stroke", ...WRITE7 },
     coordinates: { out: ["bounds", "stroke.bounds"] },
     handler: ({ id, ...update }) => {
       if (!Object.keys(update).length) throw new Error("Pass at least one change: brushId, brush, color, paint or seed.");
@@ -12261,7 +14659,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       type: "object",
       properties: {
         id: { type: "string", description: "Stroke id from list_strokes {live: true}." },
-        points: POINTS,
+        points: POINTS2,
         transform: {
           type: "object",
           description: "A move, scale, rotation or flip of the whole stroke.",
@@ -12279,7 +14677,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["id"],
       additionalProperties: false
     },
-    annotations: { title: "Move or reshape a stroke", ...WRITE6 },
+    annotations: { title: "Move or reshape a stroke", ...WRITE7 },
     coordinates: { in: ["points[]", "transform.origin"], out: ["bounds", "stroke.bounds", "stroke.points[]"] },
     handler: async ({ id, points, transform }) => {
       await c.prepareStrokeEdit(id, { points, transform });
@@ -12297,7 +14695,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["id", "index"],
       additionalProperties: false
     },
-    annotations: { title: "Move a stroke up or down", ...WRITE6 },
+    annotations: { title: "Move a stroke up or down", ...WRITE7 },
     handler: ({ id, index }) => ({ order: c.reorderStroke(id, index) })
   });
   add({
@@ -12319,7 +14717,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Make a layer a stroke layer",
     description: 'Makes an empty pixel layer a stroke layer, so strokes painted on it stay editable. Refuses a layer with paint (add_layer {type: "strokes"} instead). One undo step. Returns the layer.',
     inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers (default the active layer)." } }, additionalProperties: false },
-    annotations: { title: "Make a layer a stroke layer", ...WRITE6 },
+    annotations: { title: "Make a layer a stroke layer", ...WRITE7 },
     coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.convertToLiveStrokes(layerId)
   });
@@ -12361,7 +14759,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       required: ["strokeIds"],
       additionalProperties: false
     },
-    annotations: { title: "Replay strokes, varied", ...WRITE6 },
+    annotations: { title: "Replay strokes, varied", ...WRITE7 },
     coordinates: { in: ["origin"], out: ["bounds"] },
     handler: async (a) => {
       const replay = a;
@@ -12383,7 +14781,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Rotate, mirror or zoom the view", ...SET4 },
+    annotations: { title: "Rotate, mirror or zoom the view", ...SET5 },
     handler: ({ reset, ...v }) => {
       if (reset) c.resetView();
       return c.setView(v);
@@ -12394,7 +14792,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Set the drawing hand",
     description: "Says which hand holds the pen; palm rejection ignores touches on that side of the pen. Editor state, not an undo step. Returns the hand.",
     inputSchema: { type: "object", properties: { hand: { type: "string", enum: ["right", "left"], description: "right or left." } }, required: ["hand"], additionalProperties: false },
-    annotations: { title: "Set the drawing hand", ...SET4 },
+    annotations: { title: "Set the drawing hand", ...SET5 },
     handler: ({ hand }) => ({ hand: c.setHand(hand) })
   });
   add({
@@ -12402,7 +14800,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Undo",
     description: "Undoes the last step (a stroke, a fill, a layer or paper change). Returns the label undone (null when there was nothing) and what can be undone and redone next.",
     inputSchema: EMPTY3,
-    annotations: { title: "Undo", ...WRITE6 },
+    annotations: { title: "Undo", ...WRITE7 },
     handler: () => {
       const undone = c.undo();
       const s = c.getState();
@@ -12414,7 +14812,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Redo",
     description: "Redoes the last undone step. Returns the label redone (null when there was nothing) and what can be undone and redone next.",
     inputSchema: EMPTY3,
-    annotations: { title: "Redo", ...WRITE6 },
+    annotations: { title: "Redo", ...WRITE7 },
     handler: () => {
       const redone = c.redo();
       const s = c.getState();
@@ -12434,7 +14832,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Render a preview", ...READ7 },
+    annotations: { title: "Render a preview", ...READ8 },
     handler: ({ maxSide, layerIds, paper }) => {
       if (layerIds) {
         for (const id of layerIds) if (!c.getLayer(id)) throw new Error(`Unknown layer "${id}". Call list_layers for the ids.`);
@@ -12458,7 +14856,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Export the painting", ...READ7 },
+    annotations: { title: "Export the painting", ...READ8 },
     handler: async ({ format, quality, scale, paper, time }) => {
       const run = () => c.exportImage({ format, quality, scale, paper });
       const bytes = time === void 0 ? await run() : await c.withEffectTime(time, run);
@@ -12470,7 +14868,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     title: "Export as PSD",
     description: 'Writes the painting as an 8-bit RGB PSD (PSB above 30000 px) through the shared PSD writer: every layer and group with its opacity, blend, mask and locks, the paper as a locked "Paper" pixel layer at the bottom, and the composite as the merged image. Changes nothing. Returns the file as base64, its size, whether it is a PSB, and warnings (pigment and painterly blend modes have no PSD equivalent: they are written as the nearest standard mode, see list_blend_modes).',
     inputSchema: { type: "object", properties: { time: TIME }, additionalProperties: false },
-    annotations: { title: "Export as PSD", ...READ7 },
+    annotations: { title: "Export as PSD", ...READ8 },
     handler: async ({ time }) => {
       const r = time === void 0 ? c.exportPsd() : await c.withEffectTime(time, () => c.exportPsd());
       return { data: bytesToBase64(r.bytes), bytes: r.bytes.length, psb: r.psb, warnings: r.warnings };
@@ -12482,6 +14880,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   tools.push(...createPaintReplayTools(c));
   tools.push(...createPaintEvolutionTools(c));
   tools.push(...createPaintStickerTools(c));
+  tools.push(...createMutationTools(c, { director: options.director, actor: options.actor }));
   tools.push(...createPigmentTools());
   tools.push(...createStickerTools({ provider: () => c.stickersProvider }));
   tools.push(
@@ -13097,6 +15496,53 @@ var LIGHT_SLIDERS = [
   { path: "elevation", label: "Light height", min: 5, max: 90, step: 1 },
   { path: "relief", label: "Relief", min: 0, max: 1, step: 0.01 }
 ];
+var UV_LIGHT_SLIDERS = [
+  { path: "strength", label: "UV strength", min: 0, max: 2, step: 0.05 },
+  { path: "ambient", label: "Ambient light", min: 0, max: 1, step: 0.01 }
+];
+var VIEW_TILT_SLIDERS = [
+  { path: "x", label: "View tilt X", min: -1, max: 1, step: 0.01 },
+  { path: "y", label: "View tilt Y", min: -1, max: 1, step: 0.01 }
+];
+function deviceOrientationToViewTilt(betaOrEvent, gammaOrRest, rest = { beta: 45, gamma: 0 }) {
+  const isObj = typeof betaOrEvent === "object" && betaOrEvent !== null;
+  const r = isObj && typeof gammaOrRest === "object" && gammaOrRest !== null ? gammaOrRest : rest;
+  const rawBeta = isObj ? betaOrEvent.beta : betaOrEvent;
+  const rawGamma = isObj ? betaOrEvent.gamma : typeof gammaOrRest === "number" ? gammaOrRest : void 0;
+  const b = typeof rawBeta === "number" && Number.isFinite(rawBeta) ? rawBeta : r.beta;
+  const g = typeof rawGamma === "number" && Number.isFinite(rawGamma) ? rawGamma : r.gamma;
+  const clamp2 = (v) => Math.round(Math.max(-1, Math.min(1, v)) * 100) / 100;
+  return { x: clamp2((g - r.gamma) / 35), y: clamp2((b - r.beta) / 35) };
+}
+async function requestDeviceTiltPermission() {
+  const g = globalThis;
+  if (!g.DeviceOrientationEvent) return "unsupported";
+  if (typeof g.DeviceOrientationEvent.requestPermission === "function") {
+    try {
+      return await g.DeviceOrientationEvent.requestPermission() === "granted" ? "granted" : "denied";
+    } catch {
+      return "denied";
+    }
+  }
+  return "granted";
+}
+function startDeviceTilt(controller) {
+  const g = globalThis;
+  if (typeof g.addEventListener !== "function") return () => {
+  };
+  let rest = null;
+  const onOrientation = (e) => {
+    if (typeof e.beta !== "number" || typeof e.gamma !== "number") return;
+    if (!rest) rest = { beta: e.beta, gamma: e.gamma };
+    const next = deviceOrientationToViewTilt(e.beta, e.gamma, rest);
+    const cur = controller.getViewTilt();
+    if (next.x !== cur.x || next.y !== cur.y) controller.setViewTilt(next);
+  };
+  g.addEventListener("deviceorientation", onOrientation);
+  return () => {
+    g.removeEventListener?.("deviceorientation", onOrientation);
+  };
+}
 var PARTICLE_KIND_LABELS = { string: "Strings", spring: "Springs", orbit: "Orbits", flow: "Flow", elastic: "Elastic", fuzzy: "Fuzzy" };
 var PARTICLE_RENDER_LABELS = { dot: "Dots", line: "Lines", sequence: "Beads", ribbon: "Ribbon" };
 var RIBBON_PAIR_LABELS = { adjacent: "Neighbours", "first-last": "Outermost" };
@@ -13427,8 +15873,8 @@ function createPaintEditorDocument(controller, options = {}) {
 }
 
 // src/paint-editor/collaboration-tools.ts
-var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE7 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE8 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var proposalIdArg = {
   type: "object",
   properties: { proposalId: { type: "string", minLength: 1, description: "Id of a pending paint proposal, from propose_paint or list_paint_proposals." } },
@@ -13506,7 +15952,7 @@ function createPaintProposalToolProvider(proposals, options = {}) {
       required: ["title", "ops"],
       additionalProperties: false
     },
-    annotations: { title: "Propose paint", ...WRITE7 },
+    annotations: { title: "Propose paint", ...WRITE8 },
     handler: (args, context) => {
       const origin = context.actor?.id ? `agent:${context.actor.id}` : options.fallbackOrigin;
       const proposal = proposals.propose({ ...args, ...origin ? { origin } : {} });
@@ -13519,7 +15965,7 @@ function createPaintProposalToolProvider(proposals, options = {}) {
     title: "List paint proposals",
     description: "Lists the pending paint proposals (ghost paint not yet on the canvas): id, title, rationale, who proposed it, its op kinds, where it goes, where the ghost sits, the strokes it echoes and any of those since removed (missing: it can no longer be accepted), and whether accepting is allowed. Call before accept_paint_proposal or reject_paint_proposal.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "List paint proposals", ...READ8 },
+    annotations: { title: "List paint proposals", ...READ9 },
     handler: () => ({ proposals: proposals.getState().proposals.map(describe), readOnly: readOnlyReason() })
   };
   const acceptTool = {
@@ -13527,7 +15973,7 @@ function createPaintProposalToolProvider(proposals, options = {}) {
     title: "Accept a paint proposal",
     description: "Paints a pending proposal on a new layer as one undo step, recorded as made by whoever proposed it, and drops it from the pending list; the user's active layer stays theirs. Refuses, changing nothing, when the painting is read-only or a stroke it echoes was removed. Returns the new layer id, the stroke ids painted and the undo step name.",
     inputSchema: proposalIdArg,
-    annotations: { title: "Accept a paint proposal", ...WRITE7 },
+    annotations: { title: "Accept a paint proposal", ...WRITE8 },
     handler: (args) => {
       const reason = readOnlyReason();
       if (reason) throw new Error(reason);
@@ -13539,7 +15985,7 @@ function createPaintProposalToolProvider(proposals, options = {}) {
     title: "Reject a paint proposal",
     description: "Dismisses a pending paint proposal: its ghost disappears and the painting and its history are unchanged. Use it to withdraw a suggestion that no longer fits. Returns the dismissed proposal id and title.",
     inputSchema: proposalIdArg,
-    annotations: { title: "Reject a paint proposal", ...WRITE7 },
+    annotations: { title: "Reject a paint proposal", ...WRITE8 },
     handler: (args) => {
       const p = proposals.reject(args.proposalId);
       return { proposalId: p.id, title: p.title, rejected: true };
@@ -13611,6 +16057,35 @@ var PAINT_DOCUMENT_JSON_SCHEMA = {
             },
             required: ["id", "layerId", "points", "brush"]
           }
+        },
+        fluor: {
+          type: "object",
+          description: "Per-layer UV-fluorescent ink channels (layerId \u2192 bounds + PNG data URL).",
+          additionalProperties: { type: "object" }
+        },
+        thermo: {
+          type: "object",
+          description: "Per-layer thermochromic ink channels (layerId \u2192 bounds + PNG data URL).",
+          additionalProperties: { type: "object" }
+        },
+        heat: {
+          type: "object",
+          description: "Coarse document heat field (width, height, png) when the canvas is warm.",
+          properties: {
+            width: { type: "integer", minimum: 1, description: "Heat grid width in cells (1/4 canvas resolution)." },
+            height: { type: "integer", minimum: 1, description: "Heat grid height in cells (1/4 canvas resolution)." },
+            png: { type: "string", description: "Heat grid encoded as an RGBA PNG data URL." }
+          },
+          required: ["width", "height", "png"]
+        },
+        uvLight: {
+          type: "object",
+          description: "Virtual UV blacklight settings when non-default.",
+          properties: {
+            on: { type: "boolean", description: "Whether the UV blacklight is switched on." },
+            strength: { type: "number", minimum: 0, maximum: 2, description: "UV emission and spill strength (0..2)." },
+            ambient: { type: "number", minimum: 0, maximum: 1, description: "Remaining daylight ambient level (0..1)." }
+          }
         }
       },
       required: ["format", "version", "width", "height", "dpi", "paper", "layers", "assets", "activeLayerId"]
@@ -13633,7 +16108,7 @@ function uiTables() {
     brushOptions: BRUSH_OPTION_CONTROLS,
     blendMenu: BLEND_MENU_GROUPS,
     layerEffects: LAYER_EFFECT_MENU.map(({ kind, label }) => ({ kind, label, controls: layerEffectControls(defaultLayerEffect(kind, kind)) })),
-    sliders: { paper: PAPER_SLIDERS, wet: WET_PARAM_SLIDERS, wetTilt: WET_TILT_SLIDERS, wetSpeed: WET_SPEED_SLIDER, light: LIGHT_SLIDERS, ghost: GHOST_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS },
+    sliders: { paper: PAPER_SLIDERS, wet: WET_PARAM_SLIDERS, wetTilt: WET_TILT_SLIDERS, wetSpeed: WET_SPEED_SLIDER, light: LIGHT_SLIDERS, uvLight: UV_LIGHT_SLIDERS, viewTilt: VIEW_TILT_SLIDERS, ghost: GHOST_SLIDERS, mutation: MUTATION_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS },
     pathStrokeTapers: PATH_STROKE_TAPERS,
     padSampleSizes: PAD_SAMPLE_SIZES,
     wetGpu: WET_GPU_OPTIONS,
@@ -13710,11 +16185,14 @@ export {
   DEFAULT_DPI,
   DEFAULT_DYNAMICS,
   DEFAULT_FLOW,
+  DEFAULT_FLUORESCENCE,
   DEFAULT_GHOST,
   DEFAULT_IMPASTO,
+  DEFAULT_IRIDESCENCE,
   DEFAULT_LIGHT,
   DEFAULT_LIGHTING,
   DEFAULT_MULTI_COLOR,
+  DEFAULT_MUTATION,
   DEFAULT_MUTATION_RATES,
   DEFAULT_PAINT_GRADIENT,
   DEFAULT_PAINT_GRADIENT_MAPPING,
@@ -13723,8 +16201,11 @@ export {
   DEFAULT_SPRAY,
   DEFAULT_STICKER,
   DEFAULT_SWATCHES,
+  DEFAULT_THERMOCHROMIC,
   DEFAULT_TIP_GRAIN,
+  DEFAULT_UV_LIGHT,
   DEFAULT_VIEW,
+  DEFAULT_VIEW_TILT,
   DEFAULT_WET_BRUSH,
   DEFAULT_WET_PARAMS,
   DOT_ROTATIONS,
@@ -13737,15 +16218,22 @@ export {
   EVOLUTION_BRUSH_FACETS,
   EVOLUTION_MUTATION_SCHEMA,
   EVOLUTION_SLIDERS,
+  FilmBuffer,
   GHOST_SLIDERS,
+  GHOST_TRIGGERS,
   GPU_LEAD,
   GRAIN_PATTERNS,
   GRAIN_TILE,
   HARMONY_KINDS,
+  HEAT_COOLING,
+  HEAT_DIFFUSION,
+  HEAT_DRY_THRESHOLD,
+  HEAT_SCALE,
   IDENTITY_AFFINE,
   IDENTITY_COPY,
   IMPASTO_TOOLS,
   IMPASTO_TOOL_LABELS,
+  IRIDESCENCE_SLIDERS,
   LIGHT_SLIDERS,
   LIVE_STROKE_ENGINES,
   LitCache,
@@ -13764,6 +16252,7 @@ export {
   MIXING_PAD_HEIGHT,
   MIXING_PAD_WIDTH,
   MULTI_COLOR_MODES,
+  MUTATION_SLIDERS,
   MixingPad,
   PAD_SAMPLE_SIZES,
   PAINTERLY_BLEND_MODES,
@@ -13836,9 +16325,13 @@ export {
   StickerSpray,
   TIP_GRAIN_MODES,
   TRACING_NODE_ID,
+  ThermoCache,
   ThickStrokeDriver,
   TileableNoise,
   TipGrain,
+  UV_LIGHT_SLIDERS,
+  UvCache,
+  VIEW_TILT_SLIDERS,
   WET_FLOW_KINDS,
   WET_GPU_MODES,
   WET_GPU_OPTIONS,
@@ -13855,6 +16348,7 @@ export {
   WetStrokeDriver,
   addPaintGradientStop,
   addPolygonArea,
+  advanceHeatField,
   affineCopy,
   applyAffine,
   backlightOf,
@@ -13866,11 +16360,16 @@ export {
   buildTimeLapse,
   checkEvolutionStrokes,
   checkPaintEffectPlace,
+  clearHeatField,
+  cloneHeatField,
   clonePaper,
   colorHarmony2 as colorHarmony,
   composeAffine,
+  computeUvSpill,
   contactSheet,
   createEvolutionTools,
+  createHeatField,
+  createMutationTools,
   createPaintAgentStrokes,
   createPaintBrushLibraryToolProvider,
   createPaintChangeFeed,
@@ -13899,6 +16398,7 @@ export {
   describeGenomeDiff,
   deserializePaintDocument,
   deserializePaintDocumentAsync,
+  deviceOrientationToViewTilt,
   documentExtensions,
   documentToScreen,
   downloadBytes,
@@ -13912,19 +16412,30 @@ export {
   effectPaintKey,
   effectPaintSize,
   emptiedLayers,
+  emptyFluor,
+  emptyThermo,
   emptyThickChannels,
   engineBrushSourceIds,
   exportProposalContactSheetPng,
   fillRegionMask,
+  finalizeThermoStroke,
   findUnfilledRegionsMask,
   fitZoom,
+  fluorFromJSON,
+  fluorToJSON,
+  fluorTwinBrush,
   grainCatch,
   grainHeights,
   guideOverlay,
   handlePaintShortcut,
+  hasThickChannels,
   hash2,
+  heatFromJSON,
+  heatStats,
+  heatToJSON,
   hexToPaintRgb,
   hexToRgb8,
+  hotCellsBounds,
   hslToRgb,
   hsvToRgb,
   hueToWheel,
@@ -13943,6 +16454,7 @@ export {
   liveStrokeBounds,
   liveStrokeRefusal,
   mapPenPoint,
+  mergeFourChannel,
   mix32,
   mixColorOklch,
   mixPixels,
@@ -13955,6 +16467,7 @@ export {
   multiColorToPaint,
   mutateGenome,
   mutateStroke,
+  mutationBrushRefusal,
   newPaintLayerId,
   nextPaperEffectVersion,
   normalizeBehavior,
@@ -13963,12 +16476,14 @@ export {
   normalizeCanvas,
   normalizeDynamics,
   normalizeFlow,
+  normalizeFluorescence,
   normalizeGhost,
   normalizeHexColor,
   normalizeImpasto,
   normalizeLight,
   normalizeLighting,
   normalizeMultiColor,
+  normalizeMutation,
   normalizeMutationRates,
   normalizePaintBrush,
   normalizePaper,
@@ -13979,7 +16494,10 @@ export {
   normalizeStickerSettings,
   normalizeStickerUpdate,
   normalizeSymmetry,
+  normalizeThermochromic,
+  normalizeUvLight,
   normalizeView,
+  normalizeViewTilt,
   normalizeWetBrush,
   normalizeWetParams,
   overPixels,
@@ -13988,6 +16506,7 @@ export {
   paintBrushPreviewRenderer,
   paintContracts,
   paintGradientMappingFor,
+  paintHeatField,
   paintPlaybackPanel,
   paintProposalGhost,
   paintShortcutFor,
@@ -14030,6 +16549,7 @@ export {
   replayFrame,
   replayItems,
   replayPainting,
+  requestDeviceTiltPermission,
   rerollStrokeSeed,
   resampleStrokePoints,
   resolvePaintGradient,
@@ -14040,8 +16560,10 @@ export {
   sampleArt,
   sampleEffectAt,
   sampleEffectField,
+  sampleHeatAt,
   samplePath,
   samplePressure,
+  scaleFluor,
   scalePaintGradient,
   scaleStencil,
   screenToDocument,
@@ -14049,10 +16571,12 @@ export {
   seededStrokeVariation,
   serializePaintDocument,
   serializePaintDocumentExternal,
+  shiftHeatField,
   solidPaint,
   squaredDistanceTransform,
   stampCoverage,
   standardBlendMode,
+  startDeviceTilt,
   startWetClock,
   stencilMask,
   stencilOutline,
@@ -14070,8 +16594,12 @@ export {
   symmetryAxisAngles,
   symmetryAxisSegments,
   symmetryCopies,
+  thermoFromJSON,
+  thermoToJSON,
+  thermoTwinBrush,
   thickFromJSON,
   thickToJSON,
+  thinFilmRgb,
   thumbnailStroke,
   tiltToOrientation,
   timeLapseVideo,
@@ -14083,11 +16611,14 @@ export {
   translateStencil,
   updatePaintGradientStop,
   usesPaintExchange,
+  uvLightKey,
+  uvPaper,
   variationAffine,
   varyStroke,
   viewCssTransform,
   viewMatrix,
   viewPenToDocument,
+  viewTiltKey,
   wetEngineSummary,
   wetPaperInput,
   wetPigmentOf,