@pixerate/editor 0.280.0 → 0.282.0

package/dist/paint-editor/index.js

@@ -3,6 +3,7 @@ import {
   editorStickers
 } from "../chunk-NSETJI74.js";
 import {
+  ANTIMATTER_SLIDERS,
   BRUSH_PATCH_PROPERTIES,
   BRUSH_SLIDERS,
   BRUSH_UNSET_PROPERTY,
@@ -14,7 +15,7 @@ import {
   mergeBrushPatch,
   multiColorSliders,
   patchBrushValue
-} from "../chunk-NJLPW4MM.js";
+} from "../chunk-KV7QHPKL.js";
 import {
   createStickerTools,
   describeStickerRef
@@ -22,7 +23,7 @@ import {
 import {
   BRUSH_PREVIEW_DARK_PAPER,
   brushPreviewsOnDark
-} from "../chunk-ROURHJYT.js";
+} from "../chunk-NEDS6DSC.js";
 import {
   toVideoFfmpeg
 } from "../chunk-S2XPXA47.js";
@@ -42,7 +43,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-NJDEKU5D.js";
+} from "../chunk-2YGYYVSG.js";
 import "../chunk-ADMRNWR7.js";
 import "../chunk-WJ4WQJCC.js";
 import {
@@ -125,7 +126,7 @@ import {
   wetPaperInput,
   wetPigmentOf,
   withStrokePath
-} from "../chunk-YOM76H2V.js";
+} from "../chunk-VEX6YVNG.js";
 import {
   BRUSH_ID,
   BRUSH_PRESETS,
@@ -133,6 +134,7 @@ import {
   BUILTIN_BRUSHES,
   BrushLibraryError,
   DAB_FLIPS,
+  DEFAULT_ANTIMATTER,
   DEFAULT_BEHAVIOR,
   DEFAULT_BRISTLE,
   DEFAULT_BRUSH_ID,
@@ -155,6 +157,7 @@ import {
   DOT_TEXTURE_ORDERS,
   GHOST_TRIGGERS,
   IMPASTO_TOOLS,
+  INVERT_MODES,
   MAX_DOT_TEXTURES,
   MAX_STICKER_STAMPS,
   MULTI_COLOR_MODES,
@@ -179,6 +182,7 @@ import {
   isWetCapable,
   migrateBrushV1,
   multiColorToPaint,
+  normalizeAntimatter,
   normalizeBehavior,
   normalizeBristle,
   normalizeBrushSpec,
@@ -200,7 +204,7 @@ import {
   readBrushSource,
   resolveBrush,
   usesPaintExchange
-} from "../chunk-PPDUCZZV.js";
+} from "../chunk-YRGTQLDN.js";
 import {
   STAMP_KINDS,
   StickersSlot,
@@ -417,6 +421,724 @@ function createPaintDocument(options = {}) {
   return { canvas, paper: normalizePaper(options.paper ?? {}), layers: [layer], activeLayerId: layer.id, strokes: [] };
 }
 
+// src/paint-editor/antimatter.ts
+var COVERAGE_STEPS = 4096;
+function unionRect(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+function sameTile(a, b) {
+  if (!a || !b) return !a && !b;
+  if (a === b) return true;
+  if (a.uniform !== null || b.uniform !== null) return a.uniform === b.uniform;
+  for (let i = 0; i < a.data.length; i++) if (a.data[i] !== b.data[i]) return false;
+  return true;
+}
+function blastNoise2D(ux, uy, salt) {
+  const x0 = Math.floor(ux);
+  const y0 = Math.floor(uy);
+  const fx = ux - x0;
+  const fy = uy - y0;
+  const tx = fx * fx * (3 - 2 * fx);
+  const ty = fy * fy * (3 - 2 * fy);
+  const n00 = hash2(x0, y0, salt);
+  const n10 = hash2(x0 + 1, y0, salt);
+  const n01 = hash2(x0, y0 + 1, salt);
+  const n11 = hash2(x0 + 1, y0 + 1, salt);
+  const a = n00 + (n10 - n00) * tx;
+  const b = n01 + (n11 - n01) * tx;
+  return a + (b - a) * ty;
+}
+function invertOklab8(r, g, b) {
+  const lab = rgbToOklab({ r: r / 255, g: g / 255, b: b / 255, a: 1 });
+  const rgb = oklabToRgb({ l: 1 - lab.l, a: -lab.a, b: -lab.b, alpha: 1 });
+  return [
+    Math.min(255, Math.max(0, Math.round(rgb.r * 255))),
+    Math.min(255, Math.max(0, Math.round(rgb.g * 255))),
+    Math.min(255, Math.max(0, Math.round(rgb.b * 255)))
+  ];
+}
+function heatProfile(h) {
+  if (h <= 0) return { core: 0, ring: 0 };
+  const coreT = Math.min(1, Math.max(0, (h - 0.32) / 0.5));
+  const core = coreT * coreT * (3 - 2 * coreT);
+  const ringIn = Math.min(1, Math.max(0, h / 0.35));
+  const ringOut = Math.min(1, Math.max(0, (0.82 - h) / 0.47));
+  const ring = ringIn * ringOut * (3 - 2 * ringIn) * (3 - 2 * ringOut);
+  return { core, ring };
+}
+var AntimatterStrokeDriver = class {
+  constructor(init) {
+    this.init = init;
+    const { brush } = init;
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    const copies = init.copies.length ? init.copies : [IDENTITY_COPY];
+    this.copies = copies;
+    this.states = copies.map((c, i) => {
+      const seed = init.seed + i * 9973 | 0;
+      return {
+        walker: new PenDabWalker(brush, seed, c.linear),
+        seed,
+        blastCount: 0,
+        firedAny: false,
+        travel: 0,
+        fuelSum: 0,
+        fuelDabs: 0,
+        lastPos: null
+      };
+    });
+    const g = init.paint ?? null;
+    this.sampler = g ? new PaintGradientSampler(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
+  }
+  init;
+  dabCount = 0;
+  bounds = null;
+  blasts = [];
+  smoother;
+  copies;
+  states;
+  sampler;
+  sample = { rgb: [0, 0, 0], alpha: 1 };
+  effRgb = [0, 0, 0];
+  heat = /* @__PURE__ */ new Map();
+  heatCoords = /* @__PURE__ */ new Map();
+  tipBuf = new Float32Array(0);
+  lastRaw = null;
+  lastFed = null;
+  totalFuel = 0;
+  reachedSkipped = /* @__PURE__ */ new Set();
+  editedIds = /* @__PURE__ */ new Set();
+  outputs = /* @__PURE__ */ new Map();
+  /** Pushes raw pen samples and returns the bounding rectangles of any blasts that fired. */
+  push(points) {
+    const rects = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      const tNow = typeof raw.t === "number" && Number.isFinite(raw.t) ? raw.t : this.init.now ? this.init.now() : 0;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        this.states[i].walker.push(c.map(p), dabs);
+        this.processDabs(i, dabs, tNow, rects);
+      });
+    }
+    if (rects.length) this.recompositeAll();
+    return rects;
+  }
+  /** Flushes the smoother tail and finishes the stroke. */
+  finish() {
+    const rects = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    const tNow = raw && typeof raw.t === "number" && Number.isFinite(raw.t) ? raw.t : this.init.now ? this.init.now() : 0;
+    this.copies.forEach((c, i) => {
+      const dabs = [];
+      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) {
+        this.states[i].walker.push(c.map({ ...raw, pressure: fed.pressure }), dabs);
+      }
+      this.states[i].walker.finish(dabs);
+      this.processDabs(i, dabs, tNow, rects);
+    });
+    if (rects.length) this.recompositeAll();
+    return rects;
+  }
+  processDabs(copyIdx, dabs, tNow, rects) {
+    const st = this.states[copyIdx];
+    const settings = this.init.brush.antimatter;
+    for (const d of dabs) {
+      this.dabCount++;
+      const stepDist = st.lastPos ? Math.hypot(d.x - st.lastPos.x, d.y - st.lastPos.y) / Math.max(1, d.radius * 2) : 0;
+      st.lastPos = { x: d.x, y: d.y };
+      const dabFuel = this.measureFuel(d);
+      if (!st.firedAny) {
+        if (dabFuel >= settings.threshold && dabFuel > 0) {
+          st.firedAny = true;
+          st.travel = 0;
+          st.fuelSum = 0;
+          st.fuelDabs = 0;
+          rects.push(this.fireBlast(st, d, dabFuel, tNow));
+        }
+        continue;
+      }
+      st.travel += stepDist;
+      if (dabFuel > 0) {
+        st.fuelSum += dabFuel;
+        st.fuelDabs++;
+      }
+      if (st.travel >= settings.blastSpacing) {
+        const meanFuel = st.fuelDabs > 0 ? st.fuelSum / st.fuelDabs : dabFuel;
+        if (meanFuel >= settings.threshold && meanFuel > 0 && dabFuel > 0) {
+          st.travel = 0;
+          st.fuelSum = 0;
+          st.fuelDabs = 0;
+          rects.push(this.fireBlast(st, d, Math.min(1, meanFuel), tNow));
+        } else if (dabFuel < settings.threshold) {
+          st.fuelSum = 0;
+          st.fuelDabs = 0;
+        }
+      }
+    }
+  }
+  /** Measures fuel (`0..1`) under `d` from the pre-stroke pixels of every visible layer. */
+  measureFuel(d) {
+    const rect = dabRect(d, this.init.brush.tip.hardness);
+    if (rect.width <= 0 || rect.height <= 0) return 0;
+    const n = rect.width * rect.height;
+    if (this.tipBuf.length < n) this.tipBuf = new Float32Array(n);
+    const tip = this.tipBuf.subarray(0, n);
+    tip.fill(0);
+    rasterizeDab({ ...d, alpha: 1 }, this.init.brush.tip.hardness, rect, tip);
+    const mask = this.init.selection;
+    const targets = this.init.targets;
+    let sum = 0;
+    let activePixels = 0;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const py = rect.y + yy;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        let rawC = tip[k];
+        if (rawC <= 0) continue;
+        const px = rect.x + xx;
+        if (mask) {
+          rawC *= px >= 0 && py >= 0 && px < mask.width && py < mask.height ? mask.data[py * mask.width + px] / 255 : 0;
+        }
+        const c = Math.round(rawC * COVERAGE_STEPS) / COVERAGE_STEPS;
+        if (c <= 0) continue;
+        activePixels++;
+        let prod = 1;
+        for (let i = 0; i < targets.length; i++) {
+          const t = targets[i];
+          if (t.opacity <= 0) continue;
+          const lx = px - t.offset.x;
+          const ly = py - t.offset.y;
+          const tx = Math.floor(lx / TILE);
+          const ty = Math.floor(ly / TILE);
+          const tile = t.base.tiles.get(tileKey(tx, ty));
+          if (!tile) continue;
+          const ox = lx - tx * TILE;
+          const oy = ly - ty * TILE;
+          const a = tile.data[(oy * TILE + ox) * 4 + 3] / 255;
+          if (a > 0) prod *= 1 - a * t.opacity;
+        }
+        const combinedAlpha = 1 - prod;
+        if (combinedAlpha > 0) sum += c * combinedAlpha;
+      }
+    }
+    if (activePixels === 0 || sum <= 0) return 0;
+    return Math.round(sum / activePixels * COVERAGE_STEPS) / COVERAGE_STEPS;
+  }
+  fireBlast(st, d, fuel, tNow) {
+    const { brush, color, effect } = this.init;
+    const settings = brush.antimatter;
+    const blastIndex = st.blastCount++;
+    const tipRadius = Math.max(1, d.radius);
+    const fuelScale = 0.55 + 0.65 * Math.sqrt(fuel);
+    const jitter = 0.88 + 0.24 * rand01(st.seed, blastIndex, 17);
+    const radius = Math.max(2, tipRadius * settings.blastRadius * fuelScale * jitter);
+    let sparkRgb = [color[0], color[1], color[2]];
+    let flow = 1;
+    if (effect) {
+      const effA = sampleEffectAt(effect, d.x, d.y, this.effRgb, d);
+      sparkRgb = [Math.round(this.effRgb[0] * 255), Math.round(this.effRgb[1] * 255), Math.round(this.effRgb[2] * 255)];
+      flow = effA;
+    } else if (this.sampler) {
+      const g = this.sampler.dab(d, this.sample);
+      sparkRgb = [Math.round(g.rgb[0] * 255), Math.round(g.rgb[1] * 255), Math.round(g.rgb[2] * 255)];
+      flow = g.alpha;
+    }
+    const tipOpacity = Math.min(1, d.alpha * d.opacity * brush.tip.opacity * flow);
+    const lightAmount = brush.light.amount * (brush.light.pressure ? d.pressure : 1);
+    const sparkCount = settings.sparks > 0 ? Math.max(1, Math.round(settings.sparks * (6 + 10 * fuel))) : 0;
+    const blast = {
+      index: blastIndex,
+      x: d.x,
+      y: d.y,
+      radius,
+      tipSize: d.radius * 2,
+      tipOpacity,
+      fuel,
+      seed: st.seed,
+      color: sparkRgb,
+      lightAmount,
+      sparkCount,
+      t: tNow
+    };
+    this.blasts.push(blast);
+    this.totalFuel += fuel;
+    const rect = this.writeBlastToHeat(blast, this.heat, this.heatCoords, 1);
+    this.bounds = unionRect(this.bounds, rect);
+    return rect;
+  }
+  /** Writes one blast into `heatMap` (at `progress` 0..1) and returns the bounding rectangle including sparks. */
+  writeBlastToHeat(b, heatMap, coordMap, progress) {
+    const expand2 = 1 - (1 - progress) * (1 - progress);
+    const effRadius = b.radius * (0.2 + 0.8 * expand2);
+    const maxR = Math.ceil(effRadius * 1.22);
+    const x0 = Math.floor(b.x - maxR);
+    const y0 = Math.floor(b.y - maxR);
+    const x1 = Math.ceil(b.x + maxR);
+    const y1 = Math.ceil(b.y + maxR);
+    const salt = b.seed + b.index * 4099 | 0;
+    const mask = this.init.selection;
+    const targets = this.init.targets;
+    for (let py = y0; py <= y1; py++) {
+      const dy = py + 0.5 - b.y;
+      if (Math.abs(dy) > effRadius * 1.2) continue;
+      for (let px = x0; px <= x1; px++) {
+        const dx = px + 0.5 - b.x;
+        const dist = Math.hypot(dx, dy);
+        if (dist > effRadius * 1.2) continue;
+        let maskA = 1;
+        if (mask) {
+          if (px < 0 || py < 0 || px >= mask.width || py >= mask.height) continue;
+          maskA = mask.data[py * mask.width + px] / 255;
+          if (maskA <= 0) continue;
+        }
+        const rNorm = dist / effRadius;
+        const n = blastNoise2D(dx / effRadius * 2.5, dy / effRadius * 2.5, salt) - 0.5;
+        const rWarped = rNorm + n * 0.22 * Math.min(1, rNorm * 1.5);
+        if (rWarped >= 1) continue;
+        const t = 1 - rWarped;
+        const h = t * t * (3 - 2 * t) * b.tipOpacity * maskA;
+        if (h <= 0) continue;
+        const tx = Math.floor(px / TILE);
+        const ty = Math.floor(py / TILE);
+        const key = tileKey(tx, ty);
+        let tile = heatMap.get(key);
+        if (!tile) {
+          tile = new Float32Array(TILE * TILE);
+          heatMap.set(key, tile);
+          coordMap.set(key, { tx, ty });
+        }
+        const idx = (py - ty * TILE) * TILE + (px - tx * TILE);
+        if (h > tile[idx]) tile[idx] = h;
+        if (progress >= 1) {
+          for (let ti = 0; ti < targets.length; ti++) {
+            const tgt = targets[ti];
+            if (tgt.editable || this.reachedSkipped.has(tgt.id)) continue;
+            const lx = px - tgt.offset.x;
+            const ly = py - tgt.offset.y;
+            const ltx = Math.floor(lx / TILE);
+            const lty = Math.floor(ly / TILE);
+            const lt = tgt.base.tiles.get(tileKey(ltx, lty));
+            if (lt && lt.data[((ly - lty * TILE) * TILE + (lx - ltx * TILE)) * 4 + 3] > 0) {
+              this.reachedSkipped.add(tgt.id);
+            }
+          }
+        }
+      }
+    }
+    const sparkPad = b.sparkCount > 0 ? Math.ceil(b.tipSize * this.init.brush.antimatter.sparkReach * 1.3 + 4) : 0;
+    const reachR = Math.max(maxR, Math.ceil(b.radius * 0.6 + sparkPad));
+    return {
+      x: Math.floor(b.x - reachR),
+      y: Math.floor(b.y - reachR),
+      width: Math.ceil(reachR * 2) + 1,
+      height: Math.ceil(reachR * 2) + 1
+    };
+  }
+  /** Recomposites all editable target layers from their pre-stroke tiles using the current committed `heat` and `blasts`. */
+  recompositeAll() {
+    this.outputs.clear();
+    this.editedIds.clear();
+    const built = this.buildOutputs(this.heat, this.heatCoords, () => 1);
+    for (const out of built) {
+      this.outputs.set(out.id, out);
+      if (out.changed) this.editedIds.add(out.id);
+    }
+  }
+  /**
+   * Builds per-layer outputs for the given `heatMap` and blast progress function `progressOf(b)`.
+   * At `progressOf(b) === 1`, no flash or shock ring is drawn and sparks reach 100%, matching the
+   * committed pixels bit-for-bit.
+   */
+  buildOutputs(heatMap, coordMap, progressOf) {
+    const settings = this.init.brush.antimatter;
+    const activeId = this.init.activeLayerId;
+    const outList = [];
+    for (const tgt of this.init.targets) {
+      if (!tgt.editable) continue;
+      const isActive = tgt.id === activeId;
+      const offX = tgt.offset.x;
+      const offY = tgt.offset.y;
+      const tiles = new Map(tgt.base.tiles);
+      const lightTiles = tgt.baseLight ? new Map(tgt.baseLight.tiles) : /* @__PURE__ */ new Map();
+      const heightTiles = tgt.baseThick ? new Map(tgt.baseThick.height.tiles) : null;
+      const touchedTiles = /* @__PURE__ */ new Map();
+      const touchedLight = /* @__PURE__ */ new Map();
+      const touchedHeight = /* @__PURE__ */ new Map();
+      const getLayerTile = (ltx, lty) => {
+        const lk = tileKey(ltx, lty);
+        let buf = touchedTiles.get(lk);
+        if (!buf) {
+          const src = tgt.base.tiles.get(lk)?.data;
+          buf = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(TILE * TILE * 4);
+          touchedTiles.set(lk, buf);
+        }
+        return buf;
+      };
+      const getLightTile = (ltx, lty) => {
+        const lk = tileKey(ltx, lty);
+        let buf = touchedLight.get(lk);
+        if (!buf) {
+          const src = tgt.baseLight?.tiles.get(lk)?.data;
+          buf = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(TILE * TILE);
+          touchedLight.set(lk, buf);
+        }
+        return buf;
+      };
+      const getHeightTile = (ltx, lty) => {
+        const lk = tileKey(ltx, lty);
+        let buf = touchedHeight.get(lk);
+        if (!buf) {
+          const src = tgt.baseThick?.height.tiles.get(lk)?.data;
+          buf = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(TILE * TILE);
+          touchedHeight.set(lk, buf);
+        }
+        return buf;
+      };
+      for (const [hk, hData] of heatMap) {
+        const { tx: dtx, ty: dty } = coordMap.get(hk);
+        const docOx = dtx * TILE;
+        const docOy = dty * TILE;
+        for (let oy = 0; oy < TILE; oy++) {
+          const py = docOy + oy;
+          const ly = py - offY;
+          const lty = Math.floor(ly / TILE);
+          const loy = ly - lty * TILE;
+          for (let ox = 0; ox < TILE; ox++) {
+            const h = hData[oy * TILE + ox];
+            if (h <= 0) continue;
+            const px = docOx + ox;
+            const lx = px - offX;
+            const ltx = Math.floor(lx / TILE);
+            const lox = lx - ltx * TILE;
+            const lk = tileKey(ltx, lty);
+            const lIdx = loy * TILE + lox;
+            const pIdx = lIdx * 4;
+            const srcTile = tgt.base.tiles.get(lk);
+            const a0 = srcTile ? srcTile.data[pIdx + 3] : 0;
+            const { core, ring } = heatProfile(h);
+            if (a0 > 0 || isActive && !tgt.lockTransparency && ring * settings.scorch > 0) {
+              const dst = getLayerTile(ltx, lty);
+              let r = srcTile ? srcTile.data[pIdx] : 0;
+              let g = srcTile ? srcTile.data[pIdx + 1] : 0;
+              let b = srcTile ? srcTile.data[pIdx + 2] : 0;
+              let a = a0;
+              const aNorm = a0 / 255;
+              if (a0 > 0) {
+                const invAmt = core * settings.invert;
+                if (invAmt > 0) {
+                  let ir;
+                  let ig;
+                  let ib;
+                  if (settings.invertMode === "oklab") {
+                    [ir, ig, ib] = invertOklab8(r, g, b);
+                  } else {
+                    ir = 255 - r;
+                    ig = 255 - g;
+                    ib = 255 - b;
+                  }
+                  r = r + (ir - r) * invAmt;
+                  g = g + (ig - g) * invAmt;
+                  b = b + (ib - b) * invAmt;
+                }
+                const scorchAmt = ring * settings.scorch;
+                if (scorchAmt > 0) {
+                  const lum = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                  const desat = Math.min(1, scorchAmt * 0.85);
+                  const sr = r + (lum * 0.85 + 2.7 - r) * desat;
+                  const sg = g + (lum * 0.85 + 2.1 - g) * desat;
+                  const sb = b + (lum * 0.85 + 1.8 - b) * desat;
+                  const keep = 1 - scorchAmt * 0.78;
+                  r = sr * keep;
+                  g = sg * keep;
+                  b = sb * keep;
+                }
+                if (!tgt.lockTransparency && settings.annihilate > 0 && core > 0) {
+                  a = Math.round(a0 * (1 - core * settings.annihilate));
+                  if (a <= 0) r = g = b = a = 0;
+                }
+              }
+              if (isActive && !tgt.lockTransparency && ring * settings.scorch > 0 && a < 255) {
+                const sootA = Math.round(ring * settings.scorch * 96 * (1 - aNorm));
+                if (sootA > 0) {
+                  const sa = sootA / 255;
+                  const da = a / 255;
+                  const outA = da + sa * (1 - da);
+                  if (outA > 0) {
+                    r = (r * da + 20 * sa * (1 - da)) / outA;
+                    g = (g * da + 16 * sa * (1 - da)) / outA;
+                    b = (b * da + 14 * sa * (1 - da)) / outA;
+                    a = Math.round(outA * 255);
+                  }
+                }
+              }
+              dst[pIdx] = Math.min(255, Math.max(0, Math.round(r)));
+              dst[pIdx + 1] = Math.min(255, Math.max(0, Math.round(g)));
+              dst[pIdx + 2] = Math.min(255, Math.max(0, Math.round(b)));
+              dst[pIdx + 3] = Math.min(255, Math.max(0, a));
+            }
+            if (tgt.baseLight && core > 0) {
+              const lSrc = tgt.baseLight.tiles.get(lk);
+              const l0 = lSrc ? lSrc.data[lIdx] : 0;
+              if (l0 > 0) {
+                const lDst = getLightTile(ltx, lty);
+                lDst[lIdx] = Math.round(l0 * (1 - core));
+              }
+            }
+            if (tgt.baseThick && settings.crater > 0 && (core > 0 || ring > 0)) {
+              const hSrc = tgt.baseThick.height.tiles.get(lk);
+              const h0 = hSrc ? hSrc.data[lIdx] : 0;
+              if (h0 > 0 || a0 > 0) {
+                const hDst = getHeightTile(ltx, lty);
+                const aNorm = a0 / 255;
+                const nextH = Math.round(
+                  h0 * (1 - core * settings.crater * 0.85) - core * settings.crater * 40 + ring * settings.crater * 72 * aNorm
+                );
+                hDst[lIdx] = Math.min(255, Math.max(0, nextH));
+              }
+            }
+          }
+        }
+      }
+      if (isActive) {
+        this.drawActiveExtras(tgt, getLayerTile, getLightTile, progressOf);
+      }
+      let changed = false;
+      for (const [lk, buf] of touchedTiles) {
+        const ft = finishTile(buf, 4, 0);
+        const prev = tgt.base.tiles.get(lk);
+        if (ft) tiles.set(lk, ft);
+        else tiles.delete(lk);
+        if (!sameTile(prev, ft)) changed = true;
+      }
+      let lightOut = null;
+      let lightChanged = false;
+      for (const [lk, buf] of touchedLight) {
+        const ft = finishTile(buf, 1, 0);
+        const prev = tgt.baseLight?.tiles.get(lk);
+        if (ft) lightTiles.set(lk, ft);
+        else lightTiles.delete(lk);
+        if (!sameTile(prev, ft)) lightChanged = true;
+      }
+      if (lightChanged) {
+        changed = true;
+        lightOut = new TiledSurface(1, lightTiles, 0);
+      }
+      let thickOut = null;
+      if (heightTiles && tgt.baseThick) {
+        let heightChanged = false;
+        for (const [lk, buf] of touchedHeight) {
+          const ft = finishTile(buf, 1, 0);
+          const prev = tgt.baseThick.height.tiles.get(lk);
+          if (ft) heightTiles.set(lk, ft);
+          else heightTiles.delete(lk);
+          if (!sameTile(prev, ft)) heightChanged = true;
+        }
+        if (heightChanged) {
+          changed = true;
+          thickOut = { ...tgt.baseThick, height: new TiledSurface(1, heightTiles, 0) };
+        }
+      }
+      outList.push({
+        id: tgt.id,
+        surface: changed ? new TiledSurface(4, tiles, 0) : tgt.base,
+        light: lightOut,
+        thick: thickOut,
+        changed
+      });
+    }
+    return outList;
+  }
+  /** Draws sparks and (when `progress < 1`) the view-only flash and expanding shock ring on the active layer. */
+  drawActiveExtras(tgt, getLayerTile, getLightTile, progressOf) {
+    const { selection, brush } = this.init;
+    const reachFactor = brush.antimatter.sparkReach;
+    const offX = tgt.offset.x;
+    const offY = tgt.offset.y;
+    const blendPixel = (px, py, sr, sg, sb, sa, lightVal) => {
+      if (sa <= 0) return;
+      let maskA = 1;
+      if (selection) {
+        if (px < 0 || py < 0 || px >= selection.width || py >= selection.height) return;
+        maskA = selection.data[py * selection.width + px] / 255;
+        if (maskA <= 0) return;
+      }
+      const lx = px - offX;
+      const ly = py - offY;
+      const ltx = Math.floor(lx / TILE);
+      const lty = Math.floor(ly / TILE);
+      const lox = lx - ltx * TILE;
+      const loy = ly - lty * TILE;
+      const lIdx = loy * TILE + lox;
+      const pIdx = lIdx * 4;
+      const dst = getLayerTile(ltx, lty);
+      const da = dst[pIdx + 3] / 255;
+      if (tgt.lockTransparency && da <= 0) return;
+      const srcA = Math.min(1, sa * maskA);
+      const outA = tgt.lockTransparency ? da : da + srcA * (1 - da);
+      if (outA <= 0) return;
+      const w = tgt.lockTransparency ? srcA : srcA / outA;
+      dst[pIdx] = Math.min(255, Math.max(0, Math.round(dst[pIdx] * (1 - w) + sr * w)));
+      dst[pIdx + 1] = Math.min(255, Math.max(0, Math.round(dst[pIdx + 1] * (1 - w) + sg * w)));
+      dst[pIdx + 2] = Math.min(255, Math.max(0, Math.round(dst[pIdx + 2] * (1 - w) + sb * w)));
+      if (!tgt.lockTransparency) {
+        dst[pIdx + 3] = Math.min(255, Math.max(0, Math.round(outA * 255)));
+      }
+      if (lightVal > 0) {
+        const lDst = getLightTile(ltx, lty);
+        const nextL = Math.min(255, lDst[lIdx] + Math.round(lightVal * maskA * 255));
+        if (nextL > lDst[lIdx]) lDst[lIdx] = nextL;
+      }
+    };
+    for (const b of this.blasts) {
+      const progress = Math.max(0, Math.min(1, progressOf(b)));
+      if (progress <= 0) continue;
+      const seed = b.seed;
+      const bi = b.index;
+      const [cr, cg, cb] = b.color;
+      const baseAlpha = b.tipOpacity;
+      for (let si = 0; si < b.sparkCount; si++) {
+        const angle = rand01(seed, bi * 64 + si, 31) * Math.PI * 2;
+        const speed = 0.45 + 0.85 * rand01(seed, bi * 64 + si, 37);
+        const curve = (rand01(seed, bi * 64 + si, 41) - 0.5) * 0.45;
+        const dist = b.tipSize * reachFactor * speed * progress;
+        const startR = b.radius * (0.2 + 0.25 * rand01(seed, bi * 64 + si, 43));
+        const steps = Math.max(2, Math.ceil(dist * 1.5));
+        const ux = Math.round(Math.cos(angle) * 65536) / 65536;
+        const uy = Math.round(Math.sin(angle) * 65536) / 65536;
+        const nx = -uy;
+        const ny = ux;
+        for (let st = 0; st <= steps; st++) {
+          const u = st / steps;
+          const d = startR + u * dist;
+          const bend = curve * u * u * dist * 0.35;
+          const sx = Math.round(b.x + ux * d + nx * bend);
+          const sy = Math.round(b.y + uy * d + ny * bend);
+          const cool = Math.min(1, u * 1.15);
+          const sr = 255 + (cr - 255) * cool;
+          const sg = 252 + (cg - 252) * cool;
+          const sb = 240 + (cb - 240) * cool;
+          const fade = (1 - u * 0.72) * baseAlpha;
+          const lightHit = b.lightAmount > 0 ? b.lightAmount * (1 - u * 0.65) : 0;
+          blendPixel(sx, sy, sr, sg, sb, fade, lightHit);
+        }
+      }
+      if (progress < 1) {
+        const flashStrength = Math.max(0, 1 - progress * 2.2);
+        const shockFade = (1 - progress) * (1 - progress);
+        const shockR = b.radius * (0.25 + 0.75 * Math.sqrt(progress));
+        const band = Math.max(1.5, b.radius * 0.14);
+        const maxR = Math.ceil(shockR + band + 1);
+        const minX = Math.floor(b.x - maxR);
+        const maxX = Math.ceil(b.x + maxR);
+        const minY = Math.floor(b.y - maxR);
+        const maxY = Math.ceil(b.y + maxR);
+        for (let py = minY; py <= maxY; py++) {
+          const dy = py - b.y;
+          for (let px = minX; px <= maxX; px++) {
+            const dx = px - b.x;
+            const d = Math.hypot(dx, dy);
+            let a = 0;
+            if (flashStrength > 0 && d < b.radius * 0.55) {
+              const f = 1 - d / (b.radius * 0.55);
+              a = Math.max(a, f * f * flashStrength * 0.9);
+            }
+            const ringDist = Math.abs(d - shockR);
+            if (ringDist < band) {
+              const rf = 1 - ringDist / band;
+              a = Math.max(a, rf * rf * shockFade * 0.75);
+            }
+            if (a > 0) {
+              blendPixel(px, py, 255, 250, 235, a, b.lightAmount * a);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Renders the blast state at `now` (ms) for view-only blast animation.
+   * When `active` is `false` (all blasts have reached `progress === 1`), `outputs` match `layerOutputs()` bit-for-bit.
+   */
+  renderAtTime(now) {
+    const durationMs = this.init.brush.antimatter.duration * 1e3;
+    if (durationMs <= 0 || this.blasts.length === 0) {
+      return { outputs: this.layerOutputs(), active: false };
+    }
+    let anyActive = false;
+    const progressOf = (b) => {
+      if (now < b.t) return 0;
+      const elapsed = now - b.t;
+      if (elapsed >= durationMs) return 1;
+      anyActive = true;
+      return Math.min(1, 0.05 + 0.95 * (elapsed / durationMs));
+    };
+    for (const b of this.blasts) {
+      if (now - b.t < durationMs) {
+        anyActive = true;
+        break;
+      }
+    }
+    if (!anyActive) {
+      return { outputs: this.layerOutputs(), active: false };
+    }
+    const animHeat = /* @__PURE__ */ new Map();
+    const animCoords = /* @__PURE__ */ new Map();
+    for (const b of this.blasts) {
+      const p = progressOf(b);
+      if (p > 0) {
+        this.writeBlastToHeat(b, animHeat, animCoords, p);
+      }
+    }
+    const outputs = this.buildOutputs(animHeat, animCoords, progressOf);
+    return { outputs, active: true };
+  }
+  hasBlasts() {
+    return this.blasts.length > 0;
+  }
+  /** Rebases blast birth times so the earliest blast starts at `now` ms. */
+  rebaseTime(now) {
+    if (!this.blasts.length) return;
+    let minT = Infinity;
+    for (const b of this.blasts) if (b.t < minT) minT = b.t;
+    const shift = now - minT;
+    for (const b of this.blasts) b.t += shift;
+  }
+  layerOutputs() {
+    const list = [];
+    for (const tgt of this.init.targets) {
+      if (!tgt.editable) continue;
+      const out = this.outputs.get(tgt.id);
+      if (out) list.push(out);
+    }
+    return list;
+  }
+  stats() {
+    const layers = [];
+    const skippedLayers = [];
+    for (const tgt of this.init.targets) {
+      if (tgt.editable) {
+        if (this.editedIds.has(tgt.id)) layers.push(tgt.id);
+      } else if (this.reachedSkipped.has(tgt.id)) {
+        skippedLayers.push(tgt.id);
+      }
+    }
+    let sparks = 0;
+    for (const b of this.blasts) sparks += b.sparkCount;
+    return {
+      blasts: this.blasts.length,
+      sparks,
+      fuel: Math.round(this.totalFuel * 1e4) / 1e4,
+      layers,
+      skippedLayers
+    };
+  }
+};
+
 // src/paint-editor/ferro.ts
 var DEFAULT_MAGNET_STRENGTH = 0.75;
 var DEFAULT_MAGNET_RADIUS = 72;
@@ -3433,7 +4155,7 @@ function defaultTile(surface) {
   if (surface.defaultValue) data.fill(surface.defaultValue);
   return data;
 }
-function sameTile(a, b) {
+function sameTile2(a, b) {
   if (!a || !b) return !a && !b;
   if (a === b) return true;
   if (a.uniform !== null || b.uniform !== null) return a.uniform === b.uniform;
@@ -3456,11 +4178,12 @@ var PaintStrokeSession = class _PaintStrokeSession {
     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";
+    const isAntimatter = brush.engine === "antimatter";
     if (init.wet) this.wetDriver = init.wet.driver;
-    if (init.light && !init.wet && !init.sticker) this.lightTwin = this.makeLightTwin(init.light.surface);
-    if (init.ferro && !init.wet && !init.sticker) this.ferroTwin = this.makeFerroTwin(init.ferro.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);
+    if (init.light && !init.wet && !init.sticker && !isAntimatter) this.lightTwin = this.makeLightTwin(init.light.surface);
+    if (init.ferro && !init.wet && !init.sticker && !isAntimatter) this.ferroTwin = this.makeFerroTwin(init.ferro.surface);
+    if (init.fluor && !init.wet && !init.sticker && !isAntimatter) this.fluorTwin = this.makeFluorTwin(init.fluor.surface);
+    if (init.thermo && !init.wet && !init.sticker && !isAntimatter) this.thermoTwin = this.makeThermoTwin(init.thermo.surface);
     this.apply = {
       mode: brush.engine === "eraser" ? "erase" : "paint",
       color: init.color,
@@ -3488,6 +4211,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
   thickDriver = null;
   filmBuffer = null;
   stickerSpray = null;
+  antimatter = null;
   /** Light paint: the stroke's twin over the light channel, and what it left there. */
   lightTwin = null;
   lightResult = null;
@@ -3515,8 +4239,21 @@ var PaintStrokeSession = class _PaintStrokeSession {
   build(effect) {
     const init = this.init;
     const brush = init.brush;
-    this.dry = this.wet = this.thickDriver = this.stickerSpray = this.filmBuffer = null;
-    if (init.sticker) {
+    this.dry = this.wet = this.thickDriver = this.stickerSpray = this.filmBuffer = this.antimatter = null;
+    if (brush.engine === "antimatter" && init.antimatter) {
+      this.antimatter = new AntimatterStrokeDriver({
+        activeLayerId: init.layerId,
+        targets: init.antimatter.targets,
+        brush,
+        color: init.color,
+        seed: init.seed,
+        copies: this.copies,
+        selection: init.selection ?? null,
+        paint: init.paint ?? null,
+        effect,
+        now: init.antimatter.now
+      });
+    } else 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 (brush.engine === "impasto" && init.thick) {
       const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
@@ -3560,7 +4297,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
     this.fresh.clear();
     this.bounds = null;
     this.build(pixels);
-    const rects = this.points.length ? this.dry ? this.dry.push(this.points) : this.thickDriver ? this.thickDriver.push(this.points) : this.stickerSpray ? this.stickerSpray.push(this.points) : this.wet.push(this.points) : [];
+    const rects = this.points.length ? this.dry ? this.dry.push(this.points) : this.thickDriver ? this.thickDriver.push(this.points) : this.stickerSpray ? this.stickerSpray.push(this.points) : this.antimatter ? this.antimatter.push(this.points) : this.wet.push(this.points) : [];
     this.update(was ? [...rects, was] : rects);
   }
   /** The stroke's twin over the light channel: the same marks in grey at the brush's light amount (see `light.ts`). */
@@ -3743,7 +4480,17 @@ var PaintStrokeSession = class _PaintStrokeSession {
       this.wetUpdate(this.wetDriver.push(points));
       return;
     }
-    this.update(this.dry ? this.dry.push(points) : this.thickDriver ? this.thickDriver.push(points) : this.stickerSpray ? this.stickerSpray.push(points) : this.wet.push(points));
+    this.update(
+      this.dry ? this.dry.push(points) : this.thickDriver ? this.thickDriver.push(points) : this.stickerSpray ? this.stickerSpray.push(points) : this.antimatter ? this.antimatter.push(points) : this.wet.push(points)
+    );
+  }
+  /** Antimatter strokes: per-layer outputs (pixel surface, light channel, thick channels) after the stroke so far. */
+  antimatterOutputs() {
+    return this.antimatter ? this.antimatter.layerOutputs() : null;
+  }
+  /** Antimatter strokes: the driver, used to play blast animations after commit. */
+  antimatterDriver() {
+    return this.antimatter;
   }
   /** Sticker strokes: the stickers sprayed so far. */
   stickers() {
@@ -3752,6 +4499,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
   /** Impasto or iridescent strokes: the layer's thick-paint channels with the stroke so far. */
   thickChannels() {
     if (this.thickDriver) return this.thickDriver.channels();
+    if (this.antimatter) return this.antimatter.layerOutputs().find((o) => o.id === this.layerId)?.thick ?? null;
     const f = this.filmBuffer ?? this.wetDriver?.init.film ?? null;
     if (f && this.init.thick) return { ...this.init.thick.channels, film: f.surface() };
     return null;
@@ -3785,6 +4533,12 @@ var PaintStrokeSession = class _PaintStrokeSession {
   update(rects) {
     if (!rects.length) return;
     for (const r of rects) this.bounds = union(this.bounds, r);
+    if (this.antimatter) {
+      for (const out of this.antimatter.layerOutputs()) {
+        this.host.update(out.id, out.surface, rects);
+      }
+      return;
+    }
     if (this.invisibleDaylight) {
       this.host.update(this.layerId, this.base, rects);
       return;
@@ -3827,6 +4581,24 @@ var PaintStrokeSession = class _PaintStrokeSession {
       }
       return this.result;
     }
+    if (this.antimatter) {
+      this.update(this.antimatter.finish());
+      this.closed = true;
+      const stats = this.antimatter.stats();
+      const changed2 = stats.blasts > 0 && stats.layers.length > 0;
+      const activeOut = this.antimatter.layerOutputs().find((o) => o.id === this.layerId);
+      const surface2 = changed2 ? activeOut?.surface ?? this.base : null;
+      this.lightResult = activeOut?.light ?? null;
+      this.result = {
+        layerId: this.layerId,
+        bounds: changed2 ? this.bounds : null,
+        dabs: this.antimatter.dabCount,
+        strokeId: null,
+        antimatter: stats
+      };
+      this.host.commit(this, surface2, false);
+      return this.result;
+    }
     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();
@@ -3844,7 +4616,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
         const prev = this.base.tiles.get(key);
         if (tile) tiles.set(key, tile);
         else tiles.delete(key);
-        if (!sameTile(prev, tile)) changed = true;
+        if (!sameTile2(prev, tile)) changed = true;
       }
     }
     if (this.thickDriver && this.thickDriver.dabCount > 0) changed = true;
@@ -4196,6 +4968,10 @@ function normalizeBrushStroke(raw) {
   if (effect) out.paint = effect;
   else if (paint && paint.type === "gradient") out.paint = paint;
   if (Array.isArray(r.steps) && r.steps.length === points.length && r.steps.every((v) => Number.isInteger(v) && v >= 0)) out.steps = [...r.steps];
+  if (Array.isArray(r.targets)) {
+    const targets = r.targets.filter((v) => typeof v === "string" && v.length > 0);
+    if (targets.length) out.targets = targets;
+  }
   return out;
 }
 function strokeBounds(points) {
@@ -4740,8 +5516,21 @@ function paintTestStroke(surface, brush, paper, color, width, height, stampArt)
       mixerLoad: brushLoadForStroke(brush, EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]),
       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,
+      light: brush.light.amount > 0 && brush.engine !== "wet" && brush.engine !== "sticker" && brush.engine !== "antimatter" ? { surface: emptyLight() } : null,
+      fluor: brush.fluorescence.amount > 0 && brush.engine !== "wet" && brush.engine !== "sticker" && brush.engine !== "antimatter" ? { surface: emptyFluor() } : null,
+      antimatter: brush.engine === "antimatter" ? {
+        targets: [
+          {
+            id: "thumbnail",
+            editable: true,
+            lockTransparency: false,
+            opacity: 1,
+            offset: { x: 0, y: 0 },
+            base: surface,
+            baseLight: brush.light.amount > 0 ? emptyLight() : null
+          }
+        ]
+      } : null,
       stampArt
     }
   );
@@ -4762,7 +5551,7 @@ function renderBrushThumbnail(brush, options) {
   if (b.engine === "eraser") {
     surface = fillRect(surface, { x: 0, y: 0, width, height }, rgba);
   } else if (b.engine === "wet") {
-  } else if (b.engine === "blender" || b.engine === "smudge" || b.engine === "mixer" && !b.loadsColor || b.behavior.pickup > 0) {
+  } else if (b.engine === "blender" || b.engine === "smudge" || b.engine === "antimatter" || b.engine === "mixer" && !b.loadsColor || b.behavior.pickup > 0) {
     const half = Math.ceil(height / 2);
     surface = fillRect(surface, { x: 0, y: 0, width, height: half }, rgba);
     surface = fillRect(surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
@@ -5430,6 +6219,8 @@ function liveStrokeRefusal(brush) {
     case "blender":
     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.`;
+    case "antimatter":
+      return `The ${brush.name} brush detonates existing paint across visible layers, so it can't be redrawn on a stroke layer; paint it on a pixel layer (add_layer) or rasterize the layer first (rasterize_stroke_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).`;
@@ -5808,7 +6599,7 @@ async function replayPainting(source, target, options = {}) {
     strokes++;
     if (!target.getLayer(st.layerId)) continue;
     if (st.paint?.type === "effect" && st.paint.map?.by === "path") await target.prepareEffectPaints([st.paint]);
-    const init = { layerId: st.layerId, color: st.color, brush: st.brush, seed: st.seed, copies: st.copies ?? [], ...st.load ? { load: st.load } : {}, ...st.paint ? { paint: st.paint } : {}, snapToPerspective: false, stencils: false, maskStencils: (st.stencils ?? []).map((x) => s === 1 ? x : scaleStencil(x, s)) };
+    const init = { layerId: st.layerId, color: st.color, brush: st.brush, seed: st.seed, copies: st.copies ?? [], ...st.load ? { load: st.load } : {}, ...st.paint ? { paint: st.paint } : {}, ...st.targets ? { targets: st.targets } : {}, snapToPerspective: false, stencils: false, maskStencils: (st.stencils ?? []).map((x) => s === 1 ? x : scaleStencil(x, s)) };
     if (st.brush.engine === "wet" && st.steps?.length === st.points.length) {
       await target.wetIdle();
       await advanceTo(st.steps[0]);
@@ -6926,7 +7717,7 @@ function rgbaOf(hex2) {
 function rgbToHex(r, g, b) {
   return "#" + [r, g, b].map((v) => Math.round(Math.min(255, Math.max(0, v))).toString(16).padStart(2, "0")).join("");
 }
-function unionRect(a, b) {
+function unionRect2(a, b) {
   if (!a) return b ? { ...b } : null;
   if (!b) return { ...a };
   const x = Math.min(a.x, b.x);
@@ -6996,6 +7787,9 @@ var PaintEditorController = class _PaintEditorController {
   cached = null;
   session = null;
   live = null;
+  liveMulti = null;
+  liveThickMulti = null;
+  liveLightMulti = null;
   liveLayers = null;
   dirty = "all";
   seedCounter = 1;
@@ -7013,6 +7807,13 @@ var PaintEditorController = class _PaintEditorController {
   liveEffectAt = null;
   /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
   animatedLayers = /* @__PURE__ */ new Map();
+  /** Blast animation frames (view only), kept apart from live effect frames so neither replaces the other. */
+  blastLayers = /* @__PURE__ */ new Map();
+  /** Blast animation light / thick channels (`null` light: none at this frame). */
+  animatedLight = /* @__PURE__ */ new Map();
+  animatedThick = /* @__PURE__ */ new Map();
+  activeBlastAnim = null;
+  playingClock = null;
   /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
   frameOverride = null;
   /** The area each stroke painted (document pixels; `null`: nothing), learnt as it is painted or drawn, so a stroke layer edit redraws only where it changes (see `drawLiveStrokes`). */
@@ -7505,6 +8306,7 @@ var PaintEditorController = class _PaintEditorController {
   }
   undo() {
     this.requireIdle("undoing");
+    this.clearBlastAnimation();
     const e = this.undoStack[this.undoStack.length - 1];
     if (!e) return null;
     if (e.wet) this.requireWetIdle("undoing");
@@ -7526,6 +8328,7 @@ var PaintEditorController = class _PaintEditorController {
   }
   redo() {
     this.requireIdle("redoing");
+    this.clearBlastAnimation();
     const e = this.redoStack[this.redoStack.length - 1];
     if (!e) return null;
     if (e.wet) this.requireWetIdle("redoing");
@@ -7563,6 +8366,7 @@ var PaintEditorController = class _PaintEditorController {
   /** Starts a new canvas: one empty layer over the paper (one undo step; undo brings the old one back). */
   newCanvas(options = {}) {
     this.requireIdle("starting a new canvas");
+    this.clearBlastAnimation();
     const next = createPaintDocument({
       width: options.width ?? this.doc.canvas.width,
       height: options.height ?? this.doc.canvas.height,
@@ -7728,9 +8532,9 @@ 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 = unionRect(unionRect(contentBounds(l.surface), this.doc.fluor?.[l.id] ? contentBounds(this.doc.fluor[l.id]) : null), this.doc.ferro?.[l.id]?.bounds ?? null);
+      const b = unionRect2(unionRect2(contentBounds(l.surface), this.doc.fluor?.[l.id] ? contentBounds(this.doc.fluor[l.id]) : null), this.doc.ferro?.[l.id]?.bounds ?? 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);
+    } else for (const c of flattenLayers(l.children)) if (c.type === "pixel") bounds = unionRect2(bounds, this.describeLayer(c, l.id, depth + 1).bounds);
     return {
       id: l.id,
       name: l.name,
@@ -8016,7 +8820,7 @@ var PaintEditorController = class _PaintEditorController {
     const upper = loc.layer;
     if (!isPixelLayer(upper) || !isPixelLayer(below)) throw new PaintEditorError("Merge down needs a pixel layer directly above another pixel layer in the same group.");
     if (isLayerLocked(below, "pixels")) throw new PaintEditorError(`Layer "${below.name}" has its pixels locked; unlock it to merge into it.`);
-    const rect = unionRect(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
+    const rect = unionRect2(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
     let surface = emptySurface(4);
     if (rect) {
       const base = { ...below, opacity: 1, blend: "normal", visible: true, clipped: void 0, mask: void 0 };
@@ -9480,6 +10284,15 @@ var PaintEditorController = class _PaintEditorController {
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
+    } else if (brush.engine === "antimatter") {
+      const targetIds = new Set(this.antimatterTargetsOf(this.doc, init.targets).map((t) => t.id));
+      targetIds.add(layer.id);
+      const wetVisible = this.wet.wetLayerIds().filter((id) => targetIds.has(id));
+      if (wetVisible.length) {
+        this.dryLayersFirst(wetVisible);
+        doc = this.doc;
+        layer = findLayer(this.doc.layers, layer.id).layer;
+      }
     } else if (this.wet.wetLayerIds().includes(layer.id)) {
       this.dryLayersFirst([layer.id]);
       const dried = findLayer(this.doc.layers, layer.id).layer;
@@ -9524,7 +10337,8 @@ var PaintEditorController = class _PaintEditorController {
     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 needThick = brush.engine !== "antimatter" && (brush.engine === "impasto" || Boolean(brush.iridescence) || brush.engine === "eraser" && hasThick || Boolean(wet?.driver.init.film));
+    const isSpecialEngine = brush.engine === "sticker" || brush.engine === "antimatter";
     const gradient = effect ? null : this.strokeGradient(init, brush, color);
     const session = new PaintStrokeSession(host, {
       layerId: layer.id,
@@ -9549,12 +10363,13 @@ var PaintEditorController = class _PaintEditorController {
       wet,
       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,
+      light: !wet && !isSpecialEngine && (brush.light.amount > 0 || doc.light?.[layer.id]) ? { surface: doc.light?.[layer.id] ?? emptyLight() } : null,
       // Ferrofluid paint: a twin of the stroke paints the liquid ferrofluid channel.
-      ferro: !wet && brush.engine !== "sticker" && (brush.ferro.amount > 0 || doc.ferro?.[layer.id]) ? { surface: doc.ferro?.[layer.id] ?? emptyFerro() } : 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,
+      ferro: !wet && !isSpecialEngine && (brush.ferro.amount > 0 || doc.ferro?.[layer.id]) ? { surface: doc.ferro?.[layer.id] ?? emptyFerro() } : null,
+      fluor: !isSpecialEngine && (brush.fluorescence.amount > 0 || doc.fluor?.[layer.id]) ? { surface: doc.fluor?.[layer.id] ?? emptyFluor() } : null,
+      thermo: !isSpecialEngine && (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,
+      antimatter: brush.engine === "antimatter" ? { targets: this.antimatterTargetsOf(doc, init.targets), now: () => (this.playingClock ?? defaultEffectClock).now() } : null,
       stampArt: this.stampArt,
       paint: gradient,
       effect
@@ -9582,6 +10397,8 @@ var PaintEditorController = class _PaintEditorController {
     else if (init.paint) stroke.paint = JSON.parse(JSON.stringify(init.paint));
     if (init.mixerLoad.reservoir || init.mixerLoad.pickup) stroke.load = JSON.parse(JSON.stringify(init.mixerLoad));
     if (init.wet) stroke.steps = [...init.wet.driver.steps];
+    const fuel = init.antimatter?.targets;
+    if (fuel?.length) stroke.targets = fuel.map((t) => t.id);
     if (init.selection) {
       const masks = (session.maskStencils ?? this.guides.stencils).filter((x) => x.enabled && x.mode === "mask");
       if (masks.length) stroke.stencils = masks.map((x) => ({ ...x }));
@@ -9594,6 +10411,7 @@ var PaintEditorController = class _PaintEditorController {
    */
   beginStroke(init = {}) {
     this.requireIdle("starting another");
+    this.clearBlastAnimation();
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
@@ -9603,6 +10421,23 @@ var PaintEditorController = class _PaintEditorController {
           this.wet.syncDisplays();
           return;
         }
+        const amOutputs = this.session?.antimatterOutputs();
+        if (amOutputs) {
+          const liveMulti = /* @__PURE__ */ new Map();
+          const liveThickMulti = /* @__PURE__ */ new Map();
+          const liveLightMulti = /* @__PURE__ */ new Map();
+          for (const out of amOutputs) {
+            liveMulti.set(out.id, out.surface);
+            if (out.thick) liveThickMulti.set(out.id, out.thick);
+            if (out.light) liveLightMulti.set(out.id, out.light);
+          }
+          this.liveMulti = liveMulti;
+          this.liveThickMulti = liveThickMulti.size ? liveThickMulti : null;
+          this.liveLightMulti = liveLightMulti.size ? liveLightMulti : null;
+          this.live = { layerId: this.session.layerId, surface: liveMulti.get(this.session.layerId) ?? surface };
+          this.emit(rects);
+          return;
+        }
         this.live = { layerId, surface };
         const ch = this.session?.thickChannels();
         this.liveThick = ch ? { layerId, channels: ch } : null;
@@ -9629,6 +10464,9 @@ var PaintEditorController = class _PaintEditorController {
           return;
         }
         this.live = null;
+        this.liveMulti = null;
+        this.liveThickMulti = null;
+        this.liveLightMulti = null;
         this.liveLayers = null;
         this.liveThick = null;
         this.liveFerro = null;
@@ -9643,8 +10481,8 @@ var PaintEditorController = class _PaintEditorController {
             const snap = this.wetOp.before;
             this.wetOp = null;
             this.pendingWetEvents = [];
-            if (wetStroke) this.wet.restore(snap);
-            this.doc = { ...this.doc, layers: before.layers };
+            this.wet.restore(snap);
+            this.doc = before;
             this.wet.syncDisplays();
           } else if (this.doc.layers !== before.layers) {
             this.doc = { ...this.doc, layers: before.layers };
@@ -9656,6 +10494,21 @@ var PaintEditorController = class _PaintEditorController {
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
         this.paintedBounds.set(stroke, s.result?.bounds ?? null);
+        const amOutputs = s.antimatterOutputs();
+        if (amOutputs) {
+          this.commit(
+            `${brush.name} stroke`,
+            this.withWetEvents(this.applyAntimatterOutputs(this.doc, amOutputs, stroke)),
+            before
+          );
+          const amDriver = s.antimatterDriver();
+          if (amDriver && brush.antimatter.duration > 0 && amDriver.hasBlasts()) {
+            this.startBlastAnimation(amDriver, s.result?.bounds ?? null);
+          }
+          this.recordMutationStroke(stroke, s.result?.bounds ?? null);
+          this.notifySample("end", s, [], stroke.id);
+          return;
+        }
         if (wetStroke && this.wet.instantDry) {
           this.wet.dry(s.layerId);
           this.logWet({ kind: "dry", layerId: s.layerId, at: this.doc.strokes.length + 1 });
@@ -9837,6 +10690,11 @@ var PaintEditorController = class _PaintEditorController {
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
         this.paintedBounds.set(stroke, s.result?.bounds ?? null);
+        const amOutputs = s.antimatterOutputs();
+        if (amOutputs) {
+          out = this.applyAntimatterOutputs(out, amOutputs, stroke);
+          return;
+        }
         const targetId = this.tempLayerTargets.get(s.layerId);
         if (targetId && !findLayer(out.layers, s.layerId)) {
           const temp = findLayer(this.doc.layers, s.layerId)?.layer;
@@ -9902,11 +10760,12 @@ var PaintEditorController = class _PaintEditorController {
       }
       result.wet = this.wet.isWet(session.layerId);
     }
-    return { doc: out, result, brush: session.init.brush };
+    return { doc: out, result, brush: session.init.brush, antimatterDriver: session.antimatterDriver() };
   }
   /** Paints one stroke from data (one undo step). */
   paintStroke(init) {
     this.requireIdle("painting");
+    this.clearBlastAnimation();
     const points = this.checkPoints(init.points);
     const before = this.doc;
     let run;
@@ -9916,10 +10775,23 @@ var PaintEditorController = class _PaintEditorController {
       this.wetOp = null;
       throw e;
     }
-    const { doc, result, brush } = run;
+    const { doc, result, brush, antimatterDriver } = run;
+    if (!result.strokeId && this.wetOp) {
+      const snap = this.wetOp.before;
+      this.wetOp = null;
+      this.pendingWetEvents = [];
+      this.wet.restore(snap);
+      this.doc = before;
+      this.wet.syncDisplays();
+      this.emit([]);
+      return result;
+    }
     if (result.mixerLoad) this.keepLoad(brush, result.mixerLoad);
     if (doc !== before || this.wetOp) {
       this.commit(`${brush.name} stroke`, this.withWetEvents(doc), before);
+      if (antimatterDriver && brush.antimatter.duration > 0 && antimatterDriver.hasBlasts()) {
+        this.startBlastAnimation(antimatterDriver, result.bounds);
+      }
       const lastStroke = this.doc.strokes[this.doc.strokes.length - 1];
       if (lastStroke && lastStroke.id === result.strokeId) this.recordMutationStroke(lastStroke, result.bounds);
     } else this.emit([]);
@@ -9951,7 +10823,7 @@ var PaintEditorController = class _PaintEditorController {
       subpaths.forEach((points, i) => {
         last = this.runStroke(doc, { ...stroke, ...stroke.seed !== void 0 ? { seed: stroke.seed + i } : {}, start: points[0] }, points);
         doc = last.doc;
-        bounds = unionRect(bounds, last.result.bounds);
+        bounds = unionRect2(bounds, last.result.bounds);
         dabs += last.result.dabs;
         if (last.result.strokeId) strokeIds.push(last.result.strokeId);
       });
@@ -10039,11 +10911,15 @@ var PaintEditorController = class _PaintEditorController {
           load = { ...load, reservoir: [r / 255, g / 255, b / 255] };
         }
         const paint = v.paint && options.color === void 0 ? { paint: v.paint } : {};
-        const run = this.runStroke(doc, { layerId, color: options.color ?? s.color, brush, seed: s.seed, copies: v.copies ?? [], stencils: false, maskStencils: [], ...paint, ...load && options.brushId === void 0 ? { load } : {} }, v.points);
+        const targets = s.targets && options.layerId === void 0 ? { targets: s.targets } : {};
+        const run = this.runStroke(doc, { layerId, color: options.color ?? s.color, brush, seed: s.seed, copies: v.copies ?? [], stencils: false, maskStencils: [], ...paint, ...targets, ...load && options.brushId === void 0 ? { load } : {} }, v.points);
         doc = run.doc;
-        bounds = unionRect(bounds, run.result.bounds);
+        bounds = unionRect2(bounds, run.result.bounds);
         if (run.result.strokeId) ids.push(run.result.strokeId);
         layerIds.add(layerId);
+        if (run.result.antimatter) {
+          for (const lid of run.result.antimatter.layers) layerIds.add(lid);
+        }
       }
     }
     if (doc !== this.doc) this.commit(strokes.length === 1 && repeat === 1 ? "Replay stroke" : "Replay strokes", doc);
@@ -10859,6 +11735,13 @@ var PaintEditorController = class _PaintEditorController {
   currentLayers() {
     const override = this.frameOverride;
     if (override) return Array.from(override).reduce((ls, [id, surface]) => mapLayer(ls, id, (l) => ({ ...l, surface })), this.doc.layers);
+    if (this.liveMulti) {
+      let layers2 = this.doc.layers;
+      for (const [id, surface] of this.liveMulti) {
+        layers2 = mapLayer(layers2, id, (l) => ({ ...l, surface }));
+      }
+      return layers2;
+    }
     const live = this.live;
     if (!live) return this.schemeLayers(this.animatedView());
     if (this.liveLayers?.key === live.surface) return this.liveLayers.layers;
@@ -10956,13 +11839,17 @@ var PaintEditorController = class _PaintEditorController {
   litLayers(layers) {
     const thick = this.doc.thick;
     const live = this.liveThick;
+    const liveMulti = this.liveThickMulti;
+    const animThick = this.animatedThick;
     const ferro = this.doc.ferro;
     const liveFerro = this.liveFerro;
-    if (!thick && !live && !ferro && !liveFerro) return layers;
+    if (!thick && !live && !liveMulti && !animThick.size && !ferro && !liveFerro) return layers;
     let out = layers;
     const ids = /* @__PURE__ */ new Set([
       ...Object.keys(thick ?? {}),
       ...live ? [live.layerId] : [],
+      ...liveMulti ? liveMulti.keys() : [],
+      ...animThick.keys(),
       ...Object.keys(ferro ?? {}),
       ...liveFerro ? [liveFerro.layerId] : []
     ]);
@@ -10970,7 +11857,7 @@ var PaintEditorController = class _PaintEditorController {
     for (const id of ids) {
       const l = findLayer(out, id)?.layer;
       if (!isPixelLayer(l)) continue;
-      const ch = (live?.layerId === id ? live.channels : thick?.[id]) ?? emptyThickChannels();
+      const ch = liveMulti?.get(id) ?? (live?.layerId === id ? live.channels : animThick.get(id) ?? thick?.[id]) ?? emptyThickChannels();
       const fSurf = liveFerro?.layerId === id ? liveFerro.surface : ferro?.[id];
       const fSet = (liveFerro?.layerId === id ? liveFerro.settings : this.doc.ferroSettings?.[id]) ?? DEFAULT_FERRO;
       const hasThick = ch.height.tiles.size > 0 || ch.material.tiles.size > 0 || ch.film.tiles.size > 0;
@@ -10990,7 +11877,16 @@ var PaintEditorController = class _PaintEditorController {
    */
   lightLayers(layers) {
     const light = this.doc.light ?? {};
-    const ids = /* @__PURE__ */ new Set([...Object.keys(light), ...Object.keys(this.doc.thick ?? {})]);
+    const liveLight = this.liveLightMulti;
+    const animLight = this.animatedLight;
+    const ids = /* @__PURE__ */ new Set([
+      ...Object.keys(light),
+      ...liveLight ? liveLight.keys() : [],
+      ...animLight.keys(),
+      ...Object.keys(this.doc.thick ?? {}),
+      ...this.liveThickMulti ? this.liveThickMulti.keys() : [],
+      ...this.animatedThick.keys()
+    ]);
     if (!ids.size) return layers;
     let out = layers;
     for (const id of ids) {
@@ -10998,10 +11894,12 @@ var PaintEditorController = class _PaintEditorController {
       if (!isPixelLayer(l)) continue;
       let cache = this.lightCaches.get(id);
       if (!cache) this.lightCaches.set(id, cache = new LightCache());
-      const glowed = cache.glow(l.surface, light[id], this.liveThick?.layerId === id ? this.liveThick.channels : this.doc.thick?.[id]);
+      const layerLight = liveLight?.has(id) ? liveLight.get(id) ?? void 0 : animLight.has(id) ? animLight.get(id) ?? void 0 : light[id];
+      const layerThick = this.liveThickMulti?.get(id) ?? (this.liveThick?.layerId === id ? this.liveThick.channels : this.animatedThick.get(id) ?? this.doc.thick?.[id]);
+      const glowed = cache.glow(l.surface, layerLight, layerThick);
       if (glowed !== l.surface) out = mapLayer(out, id, () => ({ ...l, surface: glowed }));
       const committed = findLayer(this.doc.layers, id)?.layer;
-      const spill = light[id] && isPixelLayer(committed) ? cache.spill(committed.surface, light[id], this.lightSpillOf(id)) : null;
+      const spill = layerLight && isPixelLayer(committed) ? cache.spill(committed.surface, layerLight, this.lightSpillOf(id)) : null;
       if (spill) out = insertAfter(out, id, { type: "pixel", id: `${id}${SPILL_SUFFIX}`, name: `${l.name} light`, visible: l.visible, opacity: l.opacity, blend: "linear-dodge", surface: spill, offset: { ...l.offset } });
     }
     return out;
@@ -11012,7 +11910,7 @@ var PaintEditorController = class _PaintEditorController {
       if (!l.visible) continue;
       if (l.type === "group") this.backlitLayers(l.children, committed, opacity * l.opacity, out);
       else if (isPixelLayer(l)) {
-        const thick = !committed && this.liveThick?.layerId === l.id ? this.liveThick.channels : this.doc.thick?.[l.id];
+        const thick = !committed ? this.liveThickMulti?.get(l.id) ?? (this.liveThick?.layerId === l.id ? this.liveThick.channels : this.animatedThick.get(l.id) ?? this.doc.thick?.[l.id]) : this.doc.thick?.[l.id];
         out.push({ surface: l.surface, offset: l.offset, opacity: opacity * l.opacity, ...thick ? { thick } : {} });
       }
     }
@@ -11057,7 +11955,8 @@ var PaintEditorController = class _PaintEditorController {
    */
   compositeTiles(rect, onTile, options = {}) {
     const dirty = options.dirty === "all" ? void 0 : options.dirty;
-    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: this.live?.layerId ?? this.doc.activeLayerId });
+    const multiChanging = this.liveMulti && this.liveMulti.size > 1 || Boolean(this.activeBlastAnim);
+    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: multiChanging ? void 0 : this.live?.layerId ?? this.doc.activeLayerId });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -12058,7 +12957,7 @@ var PaintEditorController = class _PaintEditorController {
     else delete next.load;
     const list = strokes.map((x, i) => i === index ? next : x);
     this.commitLiveStrokes("Edit stroke", layer, list, this.strokeAreas([was]));
-    return { stroke: { ...next }, bounds: unionRect(this.strokeArea(was), this.strokeArea(next)) ?? { x: 0, y: 0, width: 0, height: 0 } };
+    return { stroke: { ...next }, bounds: unionRect2(this.strokeArea(was), this.strokeArea(next)) ?? { x: 0, y: 0, width: 0, height: 0 } };
   }
   /**
    * Replaces a live stroke's points, or moves, scales, rotates or flips them (`transform`, about
@@ -12083,7 +12982,7 @@ var PaintEditorController = class _PaintEditorController {
     }
     const list = strokes.map((x, i) => i === index ? next : x);
     this.commitLiveStrokes("Edit stroke points", layer, list, this.strokeAreas([was]));
-    return { stroke: { ...next }, bounds: unionRect(this.strokeArea(was), this.strokeArea(next)) ?? { x: 0, y: 0, width: 0, height: 0 } };
+    return { stroke: { ...next }, bounds: unionRect2(this.strokeArea(was), this.strokeArea(next)) ?? { x: 0, y: 0, width: 0, height: 0 } };
   }
   /** Deletes live strokes (one undo step). Returns the ids removed and the area that changed. */
   removeStrokes(ids) {
@@ -12096,7 +12995,7 @@ var PaintEditorController = class _PaintEditorController {
     for (const f of found) layers.set(f.layer.id, f.layer);
     for (const [layerId, layer] of layers) {
       const gone = (doc.liveStrokes?.[layerId] ?? []).filter((x) => ids.includes(x.id));
-      for (const x of gone) bounds = unionRect(bounds, this.strokeArea(x));
+      for (const x of gone) bounds = unionRect2(bounds, this.strokeArea(x));
       doc = this.withLiveStrokes(doc, layer, (doc.liveStrokes?.[layerId] ?? []).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
     }
     this.commit(ids.length === 1 ? "Remove stroke" : "Remove strokes", doc);
@@ -12226,7 +13125,7 @@ var PaintEditorController = class _PaintEditorController {
     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);
+    this.paintedBounds.set(st, had && result.bounds ? unionRect2(had, result.bounds) : result.bounds ?? had ?? null);
     return { surface: out, bounds: result.bounds, thick: outThick };
   }
   /**
@@ -12266,11 +13165,13 @@ var PaintEditorController = class _PaintEditorController {
   // --- Live effect paint ------------------------------------------------------------
   /** The view's layers: stroke layers playing live effects at `effectTime`, the rest as they are. */
   animatedView() {
-    if (!this.animatedLayers.size) return this.doc.layers;
+    if (!this.animatedLayers.size && !this.blastLayers.size) return this.doc.layers;
     let layers = this.doc.layers;
-    for (const [id, a] of this.animatedLayers) {
-      const l = findLayer(layers, id)?.layer;
-      if (isPixelLayer(l) && l.surface === a.base) layers = mapLayer(layers, id, () => ({ ...l, surface: a.surface }));
+    for (const frames of [this.animatedLayers, this.blastLayers]) {
+      for (const [id, a] of frames) {
+        const l = findLayer(layers, id)?.layer;
+        if (isPixelLayer(l) && l.surface === a.base) layers = mapLayer(layers, id, () => ({ ...l, surface: a.surface }));
+      }
     }
     return layers;
   }
@@ -12352,6 +13253,11 @@ var PaintEditorController = class _PaintEditorController {
    * stroke is painted, or when nothing is live. The bindings start it while the editor is shown.
    */
   playEffects(clock = defaultEffectClock) {
+    this.playingClock = clock;
+    if (this.activeBlastAnim && !this.activeBlastAnim.ticked) {
+      this.activeBlastAnim.driver.rebaseTime(clock.now());
+      this.stepBlastAnimation(clock.now());
+    }
     let stopped = false;
     let cancel = () => {
     };
@@ -12361,6 +13267,9 @@ var PaintEditorController = class _PaintEditorController {
       if (stopped) return;
       const now = clock.now();
       const { playing, fps } = this.effectPlaybackState;
+      if (this.activeBlastAnim && !this.session) {
+        this.stepBlastAnimation(now);
+      }
       if (!playing) started = now - this.effectTime;
       if (!playing || this.session || now - last < 1e3 / fps - 1 || !this.liveEffects().layers.length) {
         cancel = clock.frame(tick);
@@ -12377,13 +13286,133 @@ var PaintEditorController = class _PaintEditorController {
       );
     };
     cancel = clock.frame(tick);
+    const self = this;
     return {
       stop() {
         stopped = true;
+        if (self.playingClock === clock) self.playingClock = null;
         cancel();
       }
     };
   }
+  /**
+   * The fuel layers of an antimatter stroke: every visible, non-temporary pixel layer (group
+   * opacity multiplied in), or on a replay exactly the recorded `targetIds` whatever their
+   * visibility now. The editable ones (not locked, stroke, sticker or effect layers) change.
+   */
+  antimatterTargetsOf(doc, targetIds) {
+    const targetSet = targetIds?.length ? new Set(targetIds) : null;
+    const out = [];
+    const hasForcedDescendant = (list) => Boolean(targetSet && list.some((l) => l.type === "group" ? hasForcedDescendant(l.children) : targetSet.has(l.id)));
+    const walk = (list, groupOpacity, groupVisible) => {
+      for (const l of list) {
+        if (l.type === "group") {
+          const vis2 = groupVisible && l.visible;
+          if (vis2 || hasForcedDescendant(l.children)) {
+            walk(l.children, groupOpacity * (l.visible ? l.opacity : 1), vis2);
+          }
+          continue;
+        }
+        if (!isPixelLayer(l) || l.temporary) continue;
+        const vis = groupVisible && l.visible;
+        if (targetSet ? !targetSet.has(l.id) : !vis) continue;
+        const canEdit = !isLayerLocked(l, "pixels") && !doc.liveStrokes?.[l.id] && !doc.stickers?.[l.id]?.length && !doc.effectLayers?.[l.id];
+        out.push({
+          id: l.id,
+          editable: canEdit,
+          lockTransparency: isLayerLocked(l, "transparency"),
+          opacity: groupOpacity * (l.visible ? l.opacity : l.opacity || 1),
+          offset: { ...l.offset },
+          base: l.surface,
+          baseLight: doc.light?.[l.id] ?? null,
+          baseThick: doc.thick?.[l.id] ?? null
+        });
+      }
+    };
+    walk(doc.layers, 1, true);
+    return out;
+  }
+  /** Applies every target layer's output from an antimatter stroke into a new document state. */
+  applyAntimatterOutputs(doc, outputs, stroke) {
+    let layers = doc.layers;
+    let thick = doc.thick;
+    let light = doc.light;
+    for (const o of outputs) {
+      if (!o.changed) continue;
+      const l = findLayer(layers, o.id)?.layer;
+      if (!isPixelLayer(l)) continue;
+      layers = mapLayer(layers, o.id, () => ({ ...l, surface: o.surface }));
+      if (o.thick !== null) thick = withLayerThick(thick, o.id, o.thick);
+      if (o.light !== null) light = withLayerLight(light, o.id, o.light);
+    }
+    return withLiveStroke(
+      {
+        ...doc,
+        layers,
+        strokes: [...doc.strokes, stroke],
+        ...thick && Object.keys(thick).length ? { thick } : { thick: void 0 },
+        ...light && Object.keys(light).length ? { light } : { light: void 0 }
+      },
+      stroke
+    );
+  }
+  startBlastAnimation(driver, dirty) {
+    driver.rebaseTime((this.playingClock ?? defaultEffectClock).now());
+    this.activeBlastAnim = {
+      driver,
+      committedDoc: this.doc,
+      dirty,
+      ticked: false
+    };
+    if (this.playingClock) {
+      this.stepBlastAnimation(this.playingClock.now());
+    }
+  }
+  stepBlastAnimation(now) {
+    const anim = this.activeBlastAnim;
+    if (!anim) return false;
+    if (this.doc !== anim.committedDoc || this.session) {
+      this.clearBlastAnimation();
+      return false;
+    }
+    anim.ticked = true;
+    const frame = anim.driver.renderAtTime(now);
+    if (!frame.active) {
+      this.clearBlastAnimation(true);
+      return true;
+    }
+    const nextLayers = /* @__PURE__ */ new Map();
+    const nextLight = /* @__PURE__ */ new Map();
+    const nextThick = /* @__PURE__ */ new Map();
+    const targets = new Map(anim.driver.init.targets.map((t) => [t.id, t]));
+    for (const out of frame.outputs) {
+      const id = out.id;
+      const committed = findLayer(this.doc.layers, id)?.layer;
+      if (!isPixelLayer(committed)) continue;
+      nextLayers.set(id, { base: committed.surface, surface: out.surface });
+      const tgt = targets.get(id);
+      const light = out.light ?? tgt?.baseLight ?? null;
+      if (light || this.doc.light?.[id]) nextLight.set(id, light);
+      const thick = out.thick ?? tgt?.baseThick ?? null;
+      if (thick) nextThick.set(id, thick);
+    }
+    this.blastLayers = nextLayers;
+    this.animatedLight = nextLight;
+    this.animatedThick = nextThick;
+    this.emit(anim.dirty ? [anim.dirty] : "all");
+    return true;
+  }
+  clearBlastAnimation(emitDirty = false) {
+    const anim = this.activeBlastAnim;
+    if (!anim) return;
+    this.activeBlastAnim = null;
+    this.blastLayers.clear();
+    this.animatedLight.clear();
+    this.animatedThick.clear();
+    if (emitDirty) {
+      this.emit(anim.dirty ? [anim.dirty] : "all");
+    }
+  }
   /**
    * Runs `fn` with the painting as it is `time` ms into its live effects (see `getAnimation`): for
    * exports at a moment. Nothing in the document changes.
@@ -12815,7 +13844,7 @@ var PaintEditorController = class _PaintEditorController {
           let wet;
           for (const s of cleanedStrokes) {
             const r = this.paintStroke(s);
-            bounds = unionRect(bounds, r.bounds);
+            bounds = unionRect2(bounds, r.bounds);
             dabs += r.dabs;
             if (r.strokeId) strokeIds.push(r.strokeId);
             if (r.wet !== void 0) wet = r.wet;
@@ -12989,7 +14018,7 @@ var PaintEditorController = class _PaintEditorController {
       points: stroke.points.map((p) => ({ ...p })),
       bounds: strokeRect ? { ...strokeRect } : null
     });
-    entry.bounds = unionRect(entry.bounds, strokeRect);
+    entry.bounds = unionRect2(entry.bounds, strokeRect);
     this.cached = null;
   }
   holdMutationEvaporation(layerId) {
@@ -13058,7 +14087,7 @@ var PaintEditorController = class _PaintEditorController {
         strokes: doc.strokes.filter((s) => s.layerId !== tempLayerId)
       };
     }
-    const rect = unionRect(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
+    const rect = unionRect2(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
     let surface = below.surface;
     let offset = below.offset;
     if (rect) {
@@ -13122,7 +14151,7 @@ var PaintEditorController = class _PaintEditorController {
           this.releaseMutationEvaporation(m.layerId);
         }
       } else {
-        m.bounds = m.strokes.reduce((acc, s) => unionRect(acc, s.bounds), null);
+        m.bounds = m.strokes.reduce((acc, s) => unionRect2(acc, s.bounds), null);
         kept.push(m);
       }
     }
@@ -13715,7 +14744,7 @@ var PaintDirector = class {
         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);
+        bounds = unionRect3(bounds, r.bounds);
         dabs += r.dabs;
         if (r.strokeId) strokeIds.push(r.strokeId);
         last = r;
@@ -13731,7 +14760,7 @@ var PaintDirector = class {
     });
   }
 };
-function unionRect2(a, b) {
+function unionRect3(a, b) {
   if (!a) return b ? { ...b } : null;
   if (!b) return { ...a };
   const x = Math.min(a.x, b.x);
@@ -15982,7 +17011,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer of the canvas with a library brush or the active one, optionally changed (by facets) for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
+    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer of the canvas with a library brush or the active one, optionally changed (by facets) for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers), and antimatter brushes (engine antimatter: antimatter, antimatter-flare, antimatter-charge) detonate where they touch paint across every visible layer, inverting colours in the core, removing alpha, scorching a soot ring, denting thick relief, clearing core light, and throwing sparks on the active layer (returning antimatter: { blasts, sparks, fuel, layers, skippedLayers }). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet), for antimatter brushes antimatter, and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
     inputSchema: {
       type: "object",
       properties: {
@@ -17087,6 +18116,7 @@ var PARTICLE_RENDER_LABELS = { dot: "Dots", line: "Lines", sequence: "Beads", ri
 var RIBBON_PAIR_LABELS = { adjacent: "Neighbours", "first-last": "Outermost" };
 var DOT_TEXTURE_ORDER_LABELS = { sequence: "In turn", random: "Random" };
 var DOT_ROTATION_LABELS = { follow: "Follow motion", random: "Random", fixed: "Tip angle" };
+var INVERT_MODE_LABELS = { rgb: "RGB", oklab: "OKLab" };
 var STAMP_LABELS = { dot: "Dot", star: "Star", heart: "Heart", leaf: "Leaf", flower: "Flower", confetti: "Confetti", splat: "Splat", sparkle: "Sparkle", ring: "Ring" };
 function toggleStickerRef(refs, ref2) {
   if (refs.includes(ref2)) return refs.length > 1 ? refs.filter((r) => r !== ref2) : [...refs];
@@ -17678,7 +18708,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, uvLight: UV_LIGHT_SLIDERS, viewTilt: VIEW_TILT_SLIDERS, ghost: GHOST_SLIDERS, mutation: MUTATION_SLIDERS, livePatterns: LIVE_PATTERN_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS, magnet: MAGNET_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, livePatterns: LIVE_PATTERN_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS, magnet: MAGNET_SLIDERS, antimatter: ANTIMATTER_SLIDERS },
     pathStrokeTapers: PATH_STROKE_TAPERS,
     padSampleSizes: PAD_SAMPLE_SIZES,
     wetGpu: WET_GPU_OPTIONS,
@@ -17692,6 +18722,7 @@ function uiTables() {
       ribbonPairs: RIBBON_PAIR_LABELS,
       dotTextureOrders: DOT_TEXTURE_ORDER_LABELS,
       dotRotations: DOT_ROTATION_LABELS,
+      invertModes: INVERT_MODE_LABELS,
       stamps: STAMP_LABELS
     }
   };
@@ -17739,6 +18770,8 @@ function createPaintConformanceHost(setup, options) {
   };
 }
 export {
+  ANTIMATTER_SLIDERS,
+  AntimatterStrokeDriver,
   BACKLIGHT_SPILL,
   BLEND_MENU_GROUPS,
   BLEND_MODES,
@@ -17749,6 +18782,7 @@ export {
   BristleStroke,
   BrushSourceArtCache,
   DAB_FLIPS,
+  DEFAULT_ANTIMATTER,
   DEFAULT_BACKLIGHT_COLOR,
   DEFAULT_BEHAVIOR,
   DEFAULT_BRISTLE,
@@ -17813,6 +18847,8 @@ export {
   IDENTITY_COPY,
   IMPASTO_TOOLS,
   IMPASTO_TOOL_LABELS,
+  INVERT_MODES,
+  INVERT_MODE_LABELS,
   IRIDESCENCE_SLIDERS,
   LIGHT_SLIDERS,
   LIVE_PATTERN_KINDS,
@@ -17940,6 +18976,7 @@ export {
   applyAffine,
   backlightOf,
   bakeFerroIntoThick,
+  blastNoise2D,
   brushEngineControls,
   brushLoadColor,
   brushLoadForStroke,
@@ -18029,6 +19066,7 @@ export {
   hasThickChannels,
   hash2,
   heatFromJSON,
+  heatProfile,
   heatStats,
   heatToJSON,
   hexToPaintRgb,
@@ -18039,6 +19077,7 @@ export {
   hueToWheel,
   inferEffectPathControl,
   invertAffine,
+  invertOklab8,
   isBlendMode,
   isGradientPaint,
   isPaintEffectPaint,
@@ -18070,6 +19109,7 @@ export {
   mutationBrushRefusal,
   newPaintLayerId,
   nextPaperEffectVersion,
+  normalizeAntimatter,
   normalizeBehavior,
   normalizeBristle,
   normalizeBrushStroke,