@pixerate/editor 0.239.0 → 0.241.0

package/dist/paint-editor/index.cjs

@@ -7,7 +7,7 @@ var _chunkZQIWBJGHcjs = require('../chunk-ZQIWBJGH.cjs');
 
 
 
-var _chunkBBUE3UJLcjs = require('../chunk-BBUE3UJL.cjs');
+var _chunkHW72ABGRcjs = require('../chunk-HW72ABGR.cjs');
 require('../chunk-A2IS7EHE.cjs');
 require('../chunk-SS53NNZO.cjs');
 
@@ -55,7 +55,7 @@ var _chunkJLWLX52Lcjs = require('../chunk-JLWLX52L.cjs');
 
 
 var _chunkK7ENM55Pcjs = require('../chunk-K7ENM55P.cjs');
-require('../chunk-THXFU3JB.cjs');
+require('../chunk-KCMV2534.cjs');
 
 
 
@@ -126,7 +126,12 @@ require('../chunk-THXFU3JB.cjs');
 
 
 
-var _chunkNKTNLJUJcjs = require('../chunk-NKTNLJUJ.cjs');
+
+
+
+
+
+var _chunk5BR7LC24cjs = require('../chunk-5BR7LC24.cjs');
 require('../chunk-CVFAAZXE.cjs');
 require('../chunk-GF2RBSDM.cjs');
 require('../chunk-NM3G4VQT.cjs');
@@ -285,7 +290,7 @@ function normalizeCanvas(raw) {
 function createPaintDocument(options = {}) {
   const canvas = normalizeCanvas({ width: _nullishCoalesce(options.width, () => ( 2048)), height: _nullishCoalesce(options.height, () => ( 1536)), dpi: options.dpi });
   const layer = createPaintLayer("Layer 1");
-  return { canvas, paper: _chunkNKTNLJUJcjs.normalizePaper.call(void 0, _nullishCoalesce(options.paper, () => ( {}))), layers: [layer], activeLayerId: layer.id, strokes: [] };
+  return { canvas, paper: _chunk5BR7LC24cjs.normalizePaper.call(void 0, _nullishCoalesce(options.paper, () => ( {}))), layers: [layer], activeLayerId: layer.id, strokes: [] };
 }
 
 // src/paint-editor/dab-stroke.ts
@@ -339,13 +344,13 @@ var PaintDabStroke = (_class = class {
   constructor(brush, options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);
     this.brush = brush;
     this.options = options;
-    this.smoother = new (0, _chunkNKTNLJUJcjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = _optionalChain([options, 'access', _2 => _2.copies, 'optionalAccess', _3 => _3.length]) ? options.copies : [_chunkNKTNLJUJcjs.IDENTITY_COPY];
+    this.smoother = new (0, _chunk5BR7LC24cjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = _optionalChain([options, 'access', _2 => _2.copies, 'optionalAccess', _3 => _3.length]) ? options.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
     const exchanging = brush.engine === "mixer" || brush.engine === "dab";
     const rates = brush.engine === "mixer" ? _chunkPQ3H2AANcjs.mixerRates.call(void 0, brush.mixer) : _chunkPQ3H2AANcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, 1, brush.behavior.mixing);
     this.mixing = brush.engine === "mixer" ? brush.mixer.mixing : brush.behavior.mixing;
     this.states = this.copies.map((c, i) => ({
-      walker: new (0, _chunkNKTNLJUJcjs.PenDabWalker)(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear),
+      walker: new (0, _chunk5BR7LC24cjs.PenDabWalker)(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear),
       exchange: exchanging ? new (0, _chunkPQ3H2AANcjs.PaintExchange)(rates, options.load) : null,
       smudge: brush.engine === "smudge" ? new (0, _chunkPQ3H2AANcjs.SmudgeTip)(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
     }));
@@ -458,7 +463,7 @@ var PaintDabStroke = (_class = class {
     let flow = 1;
     if (this.options.effect) {
       const rgb = [0, 0, 0];
-      flow = _chunkNKTNLJUJcjs.sampleEffectAt.call(void 0, this.options.effect, d.x, d.y, rgb);
+      flow = _chunk5BR7LC24cjs.sampleEffectAt.call(void 0, this.options.effect, d.x, d.y, rgb, d);
       ex.setReservoirColor(rgb[0], rgb[1], rgb[2]);
     } else if (this.sampler && !this.gradient) {
       const g = this.sampler.dab(d, this.sample);
@@ -686,15 +691,15 @@ function expand(t, channels) {
   return out;
 }
 var ThickStrokeDriver = (_class3 = class {
-  constructor(init) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);
+  constructor(init) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);
     this.init = init;
     const b = init.brush;
-    this.smoother = new (0, _chunkNKTNLJUJcjs.PenSmoother)(b.tip.smoothing, b.pressureSmoothing);
-    const copies = init.copies.length ? init.copies : [_chunkNKTNLJUJcjs.IDENTITY_COPY];
+    this.smoother = new (0, _chunk5BR7LC24cjs.PenSmoother)(b.tip.smoothing, b.pressureSmoothing);
+    const copies = init.copies.length ? init.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
     this.copies = copies;
     const rates = _chunkPQ3H2AANcjs.exchangeRates.call(void 0, b.behavior.pickup, b.behavior.mix, 1, b.behavior.mixing);
     this.states = copies.map((c, i) => ({
-      walker: new (0, _chunkNKTNLJUJcjs.PenDabWalker)(b, init.seed + i * 7919 | 0, c.linear),
+      walker: new (0, _chunk5BR7LC24cjs.PenDabWalker)(b, init.seed + i * 7919 | 0, c.linear),
       exchange: new (0, _chunkPQ3H2AANcjs.PaintExchange)(rates, init.load),
       smudge: b.impasto.tool === "knife" ? new (0, _chunkPQ3H2AANcjs.SmudgeTip)({ strength: 0.85, length: 0.6 + 0.38 * b.impasto.drag, mixing: b.behavior.mixing }, b.tip.size * 1.2) : null,
       carried: null,
@@ -711,13 +716,14 @@ var ThickStrokeDriver = (_class3 = class {
   __init13() {this.height = /* @__PURE__ */ new Map()}
   __init14() {this.material = /* @__PURE__ */ new Map()}
   __init15() {this.paint = [0, 0, 0]}
-  __init16() {this.tip = new Float32Array(0)}
-  __init17() {this.lastRaw = null}
-  __init18() {this.lastFed = null}
-  __init19() {this.version = 0}
+  __init16() {this.centre = [0, 0, 0]}
+  __init17() {this.tip = new Float32Array(0)}
+  __init18() {this.lastRaw = null}
+  __init19() {this.lastFed = null}
+  __init20() {this.version = 0}
   
   
-  __init20() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  __init21() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
   /** What copy 0 carries after the dabs so far. */
   get load() {
     return this.states[0].exchange.load;
@@ -837,7 +843,11 @@ var ThickStrokeDriver = (_class3 = class {
     }
     const ex = st.exchange;
     let flow = 1;
-    if (this.sampler) {
+    const effect = this.init.effect;
+    if (effect) {
+      _chunk5BR7LC24cjs.sampleEffectAt.call(void 0, effect, d.x, d.y, this.centre, d);
+      ex.setReservoirColor(this.centre[0], this.centre[1], this.centre[2]);
+    } else if (this.sampler) {
       const g = this.sampler.dab(d, this.sample);
       ex.setReservoirColor(g.rgb[0], g.rgb[1], g.rgb[2]);
       flow = g.alpha;
@@ -849,7 +859,12 @@ var ThickStrokeDriver = (_class3 = class {
     if (dep > 0) {
       const cov = new Float32Array(n);
       for (let p = 0; p < n; p++) cov[p] = tip[p] > 0 ? Math.min(1, tip[p] * (im.tool === "roller" || im.tool === "gloop" || im.tool === "tube" ? 1.6 : 1.1)) : 0;
-      this.medium.deposit(rect, cov, dep, this.paint, ex.paintPigment);
+      let field = null;
+      if (effect) {
+        field = new Float32Array(n * 3);
+        _chunk5BR7LC24cjs.effectDabField.call(void 0, effect, rect, cov, this.centre, this.paint, field, 0, d);
+      }
+      this.medium.deposit(rect, cov, dep, this.paint, ex.paintPigment, field);
     }
     const seed = this.init.seed;
     for (let yy = 0, p = 0; yy < rect.height; yy++) {
@@ -986,17 +1001,16 @@ function union(a, b) {
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
 var PaintStrokeSession = (_class4 = class {
-  constructor(host, init) {;_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);_class4.prototype.__init29.call(this);_class4.prototype.__init30.call(this);_class4.prototype.__init31.call(this);_class4.prototype.__init32.call(this);_class4.prototype.__init33.call(this);_class4.prototype.__init34.call(this);
+  constructor(host, init) {;_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);_class4.prototype.__init29.call(this);_class4.prototype.__init30.call(this);_class4.prototype.__init31.call(this);_class4.prototype.__init32.call(this);_class4.prototype.__init33.call(this);_class4.prototype.__init34.call(this);_class4.prototype.__init35.call(this);
     this.host = host;
     this.init = init;
     this.layerId = init.layerId;
     this.base = init.surface;
     this.live = new Map(this.base.tiles);
-    this.copies = init.copies.length ? init.copies : [_chunkNKTNLJUJcjs.IDENTITY_COPY];
+    this.copies = init.copies.length ? init.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
     const brush = init.brush;
     if (init.wet) this.wetDriver = init.wet.driver;
     const effect = _nullishCoalesce(_optionalChain([init, 'access', _15 => _15.effect, 'optionalAccess', _16 => _16.pixels]), () => ( null));
-    if (effect && (init.wet || init.thick || init.sticker)) throw new Error(`The ${brush.name} brush (${brush.engine} engine) cannot paint with effect paint.`);
     this.apply = {
       mode: brush.engine === "eraser" ? "erase" : "paint",
       color: init.color,
@@ -1009,11 +1023,11 @@ var PaintStrokeSession = (_class4 = class {
     };
     if (this.wetDriver) {
     } else if (init.sticker) {
-      this.stickerSpray = new (0, _chunkNKTNLJUJcjs.StickerSpray)({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: _nullishCoalesce(init.paint, () => ( null)) });
+      this.stickerSpray = new (0, _chunk5BR7LC24cjs.StickerSpray)({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: _nullishCoalesce(init.paint, () => ( null)), effect });
     } else if (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: _nullishCoalesce(init.paint, () => ( null)) });
-    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || _chunkNKTNLJUJcjs.usesPaintExchange.call(void 0, brush, Boolean(init.paint))) {
+      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: _nullishCoalesce(init.paint, () => ( null)), effect });
+    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || _chunk5BR7LC24cjs.usesPaintExchange.call(void 0, brush, Boolean(init.paint))) {
       const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
       this.wet = new PaintDabStroke(brush, {
         target: this.tileTarget(),
@@ -1029,33 +1043,33 @@ var PaintStrokeSession = (_class4 = class {
       });
     } else {
       const opts = { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies, paint: _nullishCoalesce(init.paint, () => ( null)), effect };
-      this.dry = brush.engine === "particle" ? new (0, _chunkNKTNLJUJcjs.ParticleStroke)(brush, opts) : brush.engine === "bristle" ? new (0, _chunkNKTNLJUJcjs.BristleStroke)(brush, opts) : new (0, _chunkNKTNLJUJcjs.DryStroke)(brush, opts);
+      this.dry = brush.engine === "particle" ? new (0, _chunk5BR7LC24cjs.ParticleStroke)(brush, opts) : brush.engine === "bristle" ? new (0, _chunk5BR7LC24cjs.BristleStroke)(brush, opts) : new (0, _chunk5BR7LC24cjs.DryStroke)(brush, opts);
     }
   }
   
   
   
   /** The raw input so far (what a replay feeds back in). */
-  __init21() {this.points = []}
+  __init22() {this.points = []}
   
   
-  __init22() {this.touched = /* @__PURE__ */ new Set()}
-  __init23() {this.fresh = /* @__PURE__ */ new Set()}
-  __init24() {this.dry = null}
-  __init25() {this.wet = null}
-  __init26() {this.wetDriver = null}
-  __init27() {this.thickDriver = null}
-  __init28() {this.stickerSpray = null}
+  __init23() {this.touched = /* @__PURE__ */ new Set()}
+  __init24() {this.fresh = /* @__PURE__ */ new Set()}
+  __init25() {this.dry = null}
+  __init26() {this.wet = null}
+  __init27() {this.wetDriver = null}
+  __init28() {this.thickDriver = null}
+  __init29() {this.stickerSpray = null}
   /** A wet stroke that ended while the simulation was mid-batch: it commits when the driver catches up. */
-  __init29() {this.wetEndPending = false}
+  __init30() {this.wetEndPending = false}
   
   
-  __init30() {this.bounds = null}
-  __init31() {this.lastRaw = null}
-  __init32() {this.closed = false}
-  __init33() {this.result = null}
+  __init31() {this.bounds = null}
+  __init32() {this.lastRaw = null}
+  __init33() {this.closed = false}
+  __init34() {this.result = null}
   /** The mask stencils this stroke was painted with when they are not the editor's (replays). */
-  __init34() {this.maskStencils = null}
+  __init35() {this.maskStencils = null}
   tileTarget() {
     return {
       offset: this.init.offset,
@@ -1200,7 +1214,7 @@ function brushLoadForStroke(brush, current, color) {
   if (brush.engine === "mixer") return mixerLoadForStroke(brush, current, color);
   if (brush.engine === "impasto") return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
   if (brush.engine === "wet") return brush.wet.tool === "paint" ? { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null } : _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD;
-  if (_chunkNKTNLJUJcjs.usesPaintExchange.call(void 0, brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
+  if (_chunk5BR7LC24cjs.usesPaintExchange.call(void 0, brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
   return _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD;
 }
 
@@ -1468,7 +1482,7 @@ function normalizeBrushStroke(raw) {
   const out = {
     id: r.id,
     layerId: r.layerId,
-    brush: _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, _nullishCoalesce(r.brush, () => ( {}))),
+    brush: _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, _nullishCoalesce(r.brush, () => ( {}))),
     color: typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : "#000000",
     points,
     seed: finite2(r.seed) ? r.seed | 0 : 0
@@ -1487,7 +1501,7 @@ function normalizeBrushStroke(raw) {
     }
     if (st.length) out.stencils = st;
   }
-  const effect = _chunkNKTNLJUJcjs.readPaintEffectPaint.call(void 0, r.paint);
+  const effect = _chunk5BR7LC24cjs.readPaintEffectPaint.call(void 0, r.paint);
   const paint = effect ? null : _chunkPQ3H2AANcjs.readPaintSource.call(void 0, r.paint);
   if (effect) out.paint = effect;
   else if (paint && paint.type === "gradient") out.paint = paint;
@@ -1519,17 +1533,19 @@ function variationAffine(v, origin) {
   return composeAffine(back, composeAffine(linear, toOrigin));
 }
 function varyStroke(stroke, m, v) {
-  const s = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+  const det = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+  const s = Math.abs(det - 1) < 1e-9 ? 1 : det;
   const ps = _nullishCoalesce(v.pressureScale, () => ( 1));
   const points = stroke.points.map((p) => {
     const q = mapPenPoint(m, p);
     if (ps !== 1) q.pressure = Math.min(1, Math.max(0, (_nullishCoalesce(p.pressure, () => ( 1))) * ps));
     return q;
   });
-  const brush = s !== 1 ? _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
+  const brush = s !== 1 ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
   const out = { ...stroke, brush, points };
   if (_optionalChain([stroke, 'access', _59 => _59.paint, 'optionalAccess', _60 => _60.type]) === "gradient" && s !== 1) out.paint = _chunkPQ3H2AANcjs.scalePaintGradient.call(void 0, stroke.paint, s);
-  if (_optionalChain([stroke, 'access', _61 => _61.copies, 'optionalAccess', _62 => _62.length])) {
+  if (_optionalChain([stroke, 'access', _61 => _61.paint, 'optionalAccess', _62 => _62.type]) === "effect" && stroke.paint.map && s !== 1) out.paint = { ...stroke.paint, map: { ...stroke.paint.map, length: Math.min(4096, Math.max(16, Math.round(stroke.paint.map.length * s))) } };
+  if (_optionalChain([stroke, 'access', _63 => _63.copies, 'optionalAccess', _64 => _64.length])) {
     const inv = invertAffine(m);
     out.copies = stroke.copies.map((c) => composeAffine(m, composeAffine(c, inv)));
   }
@@ -1548,7 +1564,7 @@ var paperNodes = /* @__PURE__ */ new WeakMap();
 function paperNode(paper, light) {
   let n = paperNodes.get(paper);
   const metal = (_nullishCoalesce(paper.metallic, () => ( 0))) > 0;
-  if (!n || metal && (_optionalChain([n, 'access', _63 => _63.light, 'optionalAccess', _64 => _64.azimuth]) !== _optionalChain([light, 'optionalAccess', _65 => _65.azimuth]) || _optionalChain([n, 'access', _66 => _66.light, 'optionalAccess', _67 => _67.elevation]) !== _optionalChain([light, 'optionalAccess', _68 => _68.elevation]))) {
+  if (!n || metal && (_optionalChain([n, 'access', _65 => _65.light, 'optionalAccess', _66 => _66.azimuth]) !== _optionalChain([light, 'optionalAccess', _67 => _67.azimuth]) || _optionalChain([n, 'access', _68 => _68.light, 'optionalAccess', _69 => _69.elevation]) !== _optionalChain([light, 'optionalAccess', _70 => _70.elevation]))) {
     n = { type: "paper", id: PAPER_NODE_ID, name: "Paper", visible: true, opacity: 1, blend: "normal", paper, ...metal && light ? { light: { azimuth: light.azimuth, elevation: light.elevation } } : {} };
     paperNodes.set(paper, n);
   }
@@ -1570,7 +1586,7 @@ function paperTile(paper, r, light) {
   const key = `${paperKey(paper, light)}|${r.x},${r.y},${r.width},${r.height}`;
   let t = tileCache.get(key);
   if (!t) {
-    t = _chunkNKTNLJUJcjs.renderPaper.call(void 0, paper, r, paperGrain(paper), light);
+    t = _chunk5BR7LC24cjs.renderPaper.call(void 0, paper, r, paperGrain(paper), light);
     if (tileCache.size > 512) tileCache.delete(tileCache.keys().next().value);
     tileCache.set(key, t);
   }
@@ -1669,17 +1685,17 @@ function header(state, options) {
   if (options.swatches !== void 0) out.swatches = JSON.parse(JSON.stringify(options.swatches));
   if (options.mixingPad !== void 0) out.mixingPad = JSON.parse(JSON.stringify(options.mixingPad));
   if (options.wet !== void 0) out.wet = JSON.parse(JSON.stringify(options.wet));
-  if (_optionalChain([state, 'access', _69 => _69.wetEvents, 'optionalAccess', _70 => _70.length])) out.wetEvents = JSON.parse(JSON.stringify(state.wetEvents));
-  if (_optionalChain([state, 'access', _71 => _71.paintEvents, 'optionalAccess', _72 => _72.length])) out.paintEvents = JSON.parse(JSON.stringify(state.paintEvents));
+  if (_optionalChain([state, 'access', _71 => _71.wetEvents, 'optionalAccess', _72 => _72.length])) out.wetEvents = JSON.parse(JSON.stringify(state.wetEvents));
+  if (_optionalChain([state, 'access', _73 => _73.paintEvents, 'optionalAccess', _74 => _74.length])) out.paintEvents = JSON.parse(JSON.stringify(state.paintEvents));
   if (state.origin && (state.origin.x || state.origin.y)) out.origin = { ...state.origin };
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkBBUE3UJLcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkHW72ABGRcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkBBUE3UJLcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkHW72ABGRcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1687,7 +1703,7 @@ function paintLayersOnly(layers, problems) {
   for (const l of layers) {
     if (l.type === "pixel") {
       const { filters, source, ...rest } = l;
-      if (_optionalChain([filters, 'optionalAccess', _73 => _73.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
+      if (_optionalChain([filters, 'optionalAccess', _75 => _75.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
       if (source) problems.push(`Layer "${l.name}" refers to an image editor source image; it loads empty.`);
       out.push(rest);
     } else if (l.type === "group") out.push({ ...l, children: paintLayersOnly(l.children, problems) });
@@ -1714,11 +1730,11 @@ function deserializePaintDocument(raw) {
   }
   const problems = [];
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
-  const paper = _chunkNKTNLJUJcjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
+  const paper = _chunk5BR7LC24cjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkBBUE3UJLcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkHW72ABGRcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
-  const activeLayerId = wanted && _chunkHB4ICNNAcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _74 => _74.filter, 'call', _75 => _75((l) => l.type === "pixel"), 'access', _76 => _76.pop, 'call', _77 => _77(), 'optionalAccess', _78 => _78.id]), () => ( null));
+  const activeLayerId = wanted && _chunkHB4ICNNAcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _76 => _76.filter, 'call', _77 => _77((l) => l.type === "pixel"), 'access', _78 => _78.pop, 'call', _79 => _79(), 'optionalAccess', _80 => _80.id]), () => ( null));
   const wetEvents = Array.isArray(r.wetEvents) ? r.wetEvents.filter((e) => e && typeof e === "object" && Number.isInteger(e.clock) && typeof e.kind === "string") : [];
   const state = { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) };
   if (wetEvents.length) state.wetEvents = wetEvents;
@@ -1732,7 +1748,7 @@ async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkBBUE3UJLcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkHW72ABGRcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -1815,7 +1831,7 @@ function pointerToPenPoint(e, x, y, view) {
   const p = { x, y, pressure: samplePressure(e) };
   if (typeof e.timeStamp === "number" && Number.isFinite(e.timeStamp)) p.t = e.timeStamp;
   if (e.pointerType !== "pen") return p;
-  const o = _chunkNKTNLJUJcjs.penOrientation.call(void 0, {
+  const o = _chunk5BR7LC24cjs.penOrientation.call(void 0, {
     x,
     y,
     altitude: typeof e.altitudeAngle === "number" ? e.altitudeAngle : void 0,
@@ -1863,7 +1879,7 @@ async function decodeImageBlob(blob) {
   if (!ctx) throw new Error("No 2D context to decode with.");
   ctx.drawImage(bitmap, 0, 0);
   const data = new Uint8ClampedArray(ctx.getImageData(0, 0, bitmap.width, bitmap.height).data);
-  _optionalChain([bitmap, 'access', _79 => _79.close, 'optionalCall', _80 => _80()]);
+  _optionalChain([bitmap, 'access', _81 => _81.close, 'optionalCall', _82 => _82()]);
   return { width: bitmap.width, height: bitmap.height, data };
 }
 function downloadBytes(bytes, fileName, mimeType) {
@@ -1894,16 +1910,16 @@ function wetPaperInput(paper) {
     absorption: paper.absorption,
     permeability: paper.permeability,
     roughness: flat ? 0 : paper.roughness,
-    color: _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, paper.color),
+    color: _chunk5BR7LC24cjs.hexToRgb8.call(void 0, paper.color),
     heightAt: flat ? () => 0.5 : (x, y) => grain.at(x, y)
   };
 }
 var WetStrokeDriver = (_class5 = class {
-  constructor(init) {;_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);_class5.prototype.__init41.call(this);_class5.prototype.__init42.call(this);_class5.prototype.__init43.call(this);_class5.prototype.__init44.call(this);_class5.prototype.__init45.call(this);_class5.prototype.__init46.call(this);
+  constructor(init) {;_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);_class5.prototype.__init41.call(this);_class5.prototype.__init42.call(this);_class5.prototype.__init43.call(this);_class5.prototype.__init44.call(this);_class5.prototype.__init45.call(this);_class5.prototype.__init46.call(this);_class5.prototype.__init47.call(this);_class5.prototype.__init48.call(this);
     this.init = init;
     const brush = init.brush;
-    this.smoother = new (0, _chunkNKTNLJUJcjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
-    const copies = init.copies.length ? init.copies : [_chunkNKTNLJUJcjs.IDENTITY_COPY];
+    this.smoother = new (0, _chunk5BR7LC24cjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
+    const copies = init.copies.length ? init.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
     const wet = brush.wet;
     const spacing = Math.max(0.02, brush.tip.spacing);
     const perDab = Math.min(1, spacing * 1.2);
@@ -1915,7 +1931,7 @@ var WetStrokeDriver = (_class5 = class {
     });
     const rates = _chunkPQ3H2AANcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, wet.load, brush.behavior.mixing);
     this.states = copies.map((c, i) => ({
-      walker: new (0, _chunkNKTNLJUJcjs.PenDabWalker)(brush, init.seed + i * 7919 | 0, c.linear),
+      walker: new (0, _chunk5BR7LC24cjs.PenDabWalker)(brush, init.seed + i * 7919 | 0, c.linear),
       exchange: wet.tool === "paint" ? new (0, _chunkPQ3H2AANcjs.PaintExchange)(rates, init.load) : null,
       last: null
     }));
@@ -1925,28 +1941,29 @@ var WetStrokeDriver = (_class5 = class {
     this.sampler = g ? new (0, _chunkPQ3H2AANcjs.PaintGradientSampler)(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
   }
   
-  __init35() {this.dabCount = 0}
-  __init36() {this.bounds = null}
+  __init36() {this.dabCount = 0}
+  __init37() {this.bounds = null}
   /** The world's clock at which each raw point was applied (recorded with the stroke). */
-  __init37() {this.steps = []}
+  __init38() {this.steps = []}
   
   
   
-  __init38() {this.queue = []}
-  __init39() {this.finishing = false}
-  __init40() {this.finished = false}
-  __init41() {this.lastRaw = null}
-  __init42() {this.lastFed = null}
-  __init43() {this.tip = new Float32Array(0)}
-  __init44() {this.cov = new Float32Array(0)}
-  __init45() {this.paint = [0, 0, 0]}
+  __init39() {this.queue = []}
+  __init40() {this.finishing = false}
+  __init41() {this.finished = false}
+  __init42() {this.lastRaw = null}
+  __init43() {this.lastFed = null}
+  __init44() {this.tip = new Float32Array(0)}
+  __init45() {this.cov = new Float32Array(0)}
+  __init46() {this.paint = [0, 0, 0]}
+  __init47() {this.centre = [0, 0, 0]}
   
   
-  __init46() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  __init48() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
   
   /** What copy 0's brush carries after the dabs so far. */
   get load() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _81 => _81.states, 'access', _82 => _82[0], 'access', _83 => _83.exchange, 'optionalAccess', _84 => _84.load]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _83 => _83.states, 'access', _84 => _84[0], 'access', _85 => _85.exchange, 'optionalAccess', _86 => _86.load]), () => ( null));
   }
   /** Whether every point (and the end) has been applied. */
   get done() {
@@ -2040,14 +2057,23 @@ var WetStrokeDriver = (_class5 = class {
       case "paint": {
         const ex = st.exchange;
         let flow = 1;
-        if (this.sampler) {
+        const effect = this.init.effect;
+        if (effect) {
+          _chunk5BR7LC24cjs.sampleEffectAt.call(void 0, effect, d.x, d.y, this.centre, d);
+          ex.setReservoirColor(this.centre[0], this.centre[1], this.centre[2]);
+        } else if (this.sampler) {
           const g = this.sampler.dab(d, this.sample);
           ex.setReservoirColor(g.rgb[0], g.rgb[1], g.rgb[2]);
           flow = g.alpha;
         }
         ex.pickUp(this.medium.sample(rect, tip));
         const total = ex.paint(this.paint);
-        if (total > 0 && flow > 0) this.medium.deposit(rect, cov, Math.min(1, total) * k * flow, this.paint, null);
+        if (total > 0 && flow > 0 && effect) {
+          const ec = cov.slice();
+          const field = new Float32Array(ec.length * 3);
+          _chunk5BR7LC24cjs.effectDabField.call(void 0, effect, rect, ec, this.centre, this.paint, field, COVERAGE_STEPS, d);
+          this.medium.deposit(rect, ec, Math.min(1, total) * k, this.paint, null, field);
+        } else if (total > 0 && flow > 0) this.medium.deposit(rect, cov, Math.min(1, total) * k * flow, this.paint, null);
         else world.paint(laneId, rect, cov, this.medium.options.water * k, null);
         ex.drain();
         if (wet.rewet > 0) world.rewet(laneId, rect, cov, wet.rewet * k * 0.15, this.init.paperColor);
@@ -2089,7 +2115,7 @@ var WET_GPU_MODES = ["auto", "off"];
 var GPU_LEAD = 16;
 var DISPLAY_TILES_PER_TICK = 24;
 var PaintWetLayers = (_class6 = class {
-  constructor(host, options = {}) {;_class6.prototype.__init47.call(this);_class6.prototype.__init48.call(this);_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);_class6.prototype.__init53.call(this);_class6.prototype.__init54.call(this);_class6.prototype.__init55.call(this);_class6.prototype.__init56.call(this);_class6.prototype.__init57.call(this);_class6.prototype.__init58.call(this);_class6.prototype.__init59.call(this);_class6.prototype.__init60.call(this);_class6.prototype.__init61.call(this);_class6.prototype.__init62.call(this);
+  constructor(host, options = {}) {;_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);_class6.prototype.__init53.call(this);_class6.prototype.__init54.call(this);_class6.prototype.__init55.call(this);_class6.prototype.__init56.call(this);_class6.prototype.__init57.call(this);_class6.prototype.__init58.call(this);_class6.prototype.__init59.call(this);_class6.prototype.__init60.call(this);_class6.prototype.__init61.call(this);_class6.prototype.__init62.call(this);_class6.prototype.__init63.call(this);_class6.prototype.__init64.call(this);
     this.host = host;
     this.options = options;
     this.speed = Math.max(1, Math.min(2e3, _nullishCoalesce(options.speed, () => ( 120))));
@@ -2099,27 +2125,27 @@ var PaintWetLayers = (_class6 = class {
   }
   
   
-  __init47() {this.world = null}
-  __init48() {this.tilt = { ..._chunkXFYLA3ZOcjs.FLAT }}
-  __init49() {this.settings = /* @__PURE__ */ new Map()}
-  __init50() {this.paused = false}
+  __init49() {this.world = null}
+  __init50() {this.tilt = { ..._chunkXFYLA3ZOcjs.FLAT }}
+  __init51() {this.settings = /* @__PURE__ */ new Map()}
+  __init52() {this.paused = false}
   /** Wet strokes dry as soon as they end (one undo step with the stroke). */
-  __init51() {this.instantDry = false}
+  __init53() {this.instantDry = false}
   
-  __init52() {this.overlay = false}
+  __init54() {this.overlay = false}
   
   /** The live wet stroke, if any. */
-  __init53() {this.driver = null}
-  __init54() {this.lastTick = null}
-  __init55() {this.ticking = null}
-  __init56() {this.stepsOwed = 0}
-  __init57() {this.displaying = null}
-  __init58() {this.leadAt = 0}
+  __init55() {this.driver = null}
+  __init56() {this.lastTick = null}
+  __init57() {this.ticking = null}
+  __init58() {this.stepsOwed = 0}
+  __init59() {this.displaying = null}
+  __init60() {this.leadAt = 0}
   
   
-  __init59() {this.gpu = null}
-  __init60() {this.gpuSupport = null}
-  __init61() {this.gpuStarting = null}
+  __init61() {this.gpu = null}
+  __init62() {this.gpuSupport = null}
+  __init63() {this.gpuStarting = null}
   // --- Engine B ------------------------------------------------------------------
   /** Starts the GPU engine for the world (once; it may turn out unavailable). */
   startGpu() {
@@ -2155,8 +2181,8 @@ var PaintWetLayers = (_class6 = class {
     if (mode === this.gpuMode) return this.engineInfo();
     this.gpuMode = mode;
     if (mode === "off") {
-      _optionalChain([this, 'access', _85 => _85.world, 'optionalAccess', _86 => _86.attachGpu, 'call', _87 => _87(null)]);
-      _optionalChain([this, 'access', _88 => _88.gpu, 'optionalAccess', _89 => _89.destroy, 'call', _90 => _90()]);
+      _optionalChain([this, 'access', _87 => _87.world, 'optionalAccess', _88 => _88.attachGpu, 'call', _89 => _89(null)]);
+      _optionalChain([this, 'access', _90 => _90.gpu, 'optionalAccess', _91 => _91.destroy, 'call', _92 => _92()]);
       this.gpu = null;
       this.gpuSupport = null;
     } else if (this.world) this.startGpu();
@@ -2164,13 +2190,13 @@ var PaintWetLayers = (_class6 = class {
   }
   engineInfo() {
     const w = this.world;
-    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _91 => _91.gpuSupport, 'optionalAccess', _92 => _92.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.gpuSupport, 'optionalAccess', _94 => _94.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _95 => _95.activeTiles, 'call', _96 => _96()]), () => ( 0)), cpu: this.backend() };
+    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.gpuSupport, 'optionalAccess', _94 => _94.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _95 => _95.gpuSupport, 'optionalAccess', _96 => _96.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _97 => _97.activeTiles, 'call', _98 => _98()]), () => ( 0)), cpu: this.backend() };
     if (this.gpuMode === "off") return { ...base, state: "off", reason: "Forced to the CPU." };
     if (this.gpuStarting) return { ...base, state: "starting", reason: null };
-    if (_optionalChain([w, 'optionalAccess', _97 => _97.gpuError])) return { ...base, state: "failed", reason: w.gpuError };
+    if (_optionalChain([w, 'optionalAccess', _99 => _99.gpuError])) return { ...base, state: "failed", reason: w.gpuError };
     if (this.gpuSupport && !this.gpuSupport.supported) return { ...base, state: "unavailable", reason: this.gpuSupport.reason };
     if (!this.gpu) return { ...base, state: "not-started", reason: "Starts with the first wet stroke." };
-    if (_optionalChain([w, 'optionalAccess', _98 => _98.gpuActive])) return { ...base, state: "active", reason: null };
+    if (_optionalChain([w, 'optionalAccess', _100 => _100.gpuActive])) return { ...base, state: "active", reason: null };
     return { ...base, state: "standby", reason: `The GPU takes over at ${this.gpuMinTiles} wet tiles (256 px).` };
   }
   /** The world (made on first use, at the canvas size). */
@@ -2209,13 +2235,13 @@ var PaintWetLayers = (_class6 = class {
     if (!this.canExtend(left, top)) throw new Error("Wet paint only moves by whole 256 px tiles, between strokes.");
     for (const [id, s] of this.settings) if (s.flow.center) this.settings.set(id, { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } });
     const old = this.world;
-    const snap = _optionalChain([old, 'optionalAccess', _99 => _99.laneIds, 'call', _100 => _100(), 'access', _101 => _101.length]) ? old.snapshot() : null;
+    const snap = _optionalChain([old, 'optionalAccess', _101 => _101.laneIds, 'call', _102 => _102(), 'access', _103 => _103.length]) ? old.snapshot() : null;
     this.dropWorld();
     this.lastTick = null;
     this.stepsOwed = 0;
     if (!old || !snap) return;
     const moved = _chunkXFYLA3ZOcjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left, top, (l) => {
-      const flow = _optionalChain([this, 'access', _102 => _102.settings, 'access', _103 => _103.get, 'call', _104 => _104(l.id), 'optionalAccess', _105 => _105.flow]);
+      const flow = _optionalChain([this, 'access', _104 => _104.settings, 'access', _105 => _105.get, 'call', _106 => _106(l.id), 'optionalAccess', _107 => _107.flow]);
       return {
         base: _chunk474IQG74cjs.translateSurface.call(void 0, l.base, left, top),
         flow: l.flow && flow && flow.kind !== "none" ? _chunkXFYLA3ZOcjs.flowField.call(void 0, flow, width, height) : l.flow
@@ -2233,11 +2259,11 @@ var PaintWetLayers = (_class6 = class {
   }
   /** Layers holding a wet layer (wet or drying). */
   wetLayerIds() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _106 => _106.world, 'optionalAccess', _107 => _107.laneIds, 'call', _108 => _108()]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _108 => _108.world, 'optionalAccess', _109 => _109.laneIds, 'call', _110 => _110()]), () => ( []));
   }
   /** Whether a batch is running (edits wait). */
   get busy() {
-    return Boolean(_optionalChain([this, 'access', _109 => _109.world, 'optionalAccess', _110 => _110.busy]));
+    return Boolean(_optionalChain([this, 'access', _111 => _111.world, 'optionalAccess', _112 => _112.busy]));
   }
   /** Resolves when no batch is running. */
   async idle() {
@@ -2266,13 +2292,13 @@ var PaintWetLayers = (_class6 = class {
   setParams(layerId, update) {
     const s = this.settingsOf(layerId);
     s.params = _chunkXFYLA3ZOcjs.normalizeWetParams.call(void 0, update, s.params);
-    if (_optionalChain([this, 'access', _111 => _111.world, 'optionalAccess', _112 => _112.hasLane, 'call', _113 => _113(layerId)])) this.world.setParams(layerId, s.params);
+    if (_optionalChain([this, 'access', _113 => _113.world, 'optionalAccess', _114 => _114.hasLane, 'call', _115 => _115(layerId)])) this.world.setParams(layerId, s.params);
     return { ...s.params };
   }
   setFlow(layerId, update) {
     const s = this.settingsOf(layerId);
     s.flow = _chunkXFYLA3ZOcjs.normalizeFlow.call(void 0, update, s.flow);
-    if (_optionalChain([this, 'access', _114 => _114.world, 'optionalAccess', _115 => _115.hasLane, 'call', _116 => _116(layerId)])) {
+    if (_optionalChain([this, 'access', _116 => _116.world, 'optionalAccess', _117 => _117.hasLane, 'call', _118 => _118(layerId)])) {
       const { width, height } = this.host.canvas();
       this.world.setFlow(layerId, _chunkXFYLA3ZOcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
     }
@@ -2280,29 +2306,29 @@ var PaintWetLayers = (_class6 = class {
   }
   setTilt(update) {
     this.tilt = _chunkXFYLA3ZOcjs.normalizeTilt.call(void 0, update, this.tilt);
-    _optionalChain([this, 'access', _117 => _117.world, 'optionalAccess', _118 => _118.setTilt, 'call', _119 => _119(this.tilt)]);
+    _optionalChain([this, 'access', _119 => _119.world, 'optionalAccess', _120 => _120.setTilt, 'call', _121 => _121(this.tilt)]);
     return { ...this.tilt };
   }
   /** The paper changed. */
   paperChanged() {
-    _optionalChain([this, 'access', _120 => _120.world, 'optionalAccess', _121 => _121.setPaper, 'call', _122 => _122(wetPaperInput(this.host.paper()))]);
+    _optionalChain([this, 'access', _122 => _122.world, 'optionalAccess', _123 => _123.setPaper, 'call', _124 => _124(wetPaperInput(this.host.paper()))]);
   }
   /** A layer as tools describe it. */
   info(layerId) {
     const s = this.settingsOf(layerId);
-    const st = _optionalChain([this, 'access', _123 => _123.world, 'optionalAccess', _124 => _124.hasLane, 'call', _125 => _125(layerId)]) ? this.world.stats(layerId) : null;
+    const st = _optionalChain([this, 'access', _125 => _125.world, 'optionalAccess', _126 => _126.hasLane, 'call', _127 => _127(layerId)]) ? this.world.stats(layerId) : null;
     return {
       layerId,
       wet: Boolean(st && st.wetCells > 0),
-      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _126 => _126.wetCells]), () => ( 0)),
-      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _127 => _127.wetBounds]), () => ( null)),
-      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _128 => _128.activeTiles]), () => ( 0)),
+      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _128 => _128.wetCells]), () => ( 0)),
+      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _129 => _129.wetBounds]), () => ( null)),
+      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _130 => _130.activeTiles]), () => ( 0)),
       params: { ...s.params },
       flow: { ...s.flow }
     };
   }
   backend() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _129 => _129.world, 'optionalAccess', _130 => _130.backend, 'call', _131 => _131()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _131 => _131.world, 'optionalAccess', _132 => _132.backend, 'call', _133 => _133()]), () => ( null));
   }
   /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
   syncDisplays(maxTiles = Infinity) {
@@ -2338,7 +2364,7 @@ var PaintWetLayers = (_class6 = class {
     const w = this.world;
     if (!w) return;
     for (const id of w.laneIds()) {
-      if (w.isActive(id) || _optionalChain([this, 'access', _132 => _132.driver, 'optionalAccess', _133 => _133.init, 'access', _134 => _134.laneId]) === id) continue;
+      if (w.isActive(id) || _optionalChain([this, 'access', _134 => _134.driver, 'optionalAccess', _135 => _135.init, 'access', _136 => _136.laneId]) === id) continue;
       const base = w.getBase(id);
       w.removeLane(id);
       this.host.updateSurfaces(/* @__PURE__ */ new Map([[id, base]]), []);
@@ -2418,10 +2444,10 @@ var PaintWetLayers = (_class6 = class {
     if (!d || !this.world) return;
     const rects = d.flush();
     if (rects.length) this.syncDisplays(DISPLAY_TILES_PER_TICK);
-    if (d.done) _optionalChain([this, 'access', _135 => _135.onDriverDone, 'optionalCall', _136 => _136(d)]);
+    if (d.done) _optionalChain([this, 'access', _137 => _137.onDriverDone, 'optionalCall', _138 => _138(d)]);
   }
   /** Called when a live stroke that ended mid-batch has finished applying. */
-  __init62() {this.onDriverDone = null}
+  __init64() {this.onDriverDone = null}
   /** Steps `steps` times now (agents, tests). Returns the steps run. */
   async advance(steps) {
     await this.idle();
@@ -2462,7 +2488,7 @@ var PaintWetLayers = (_class6 = class {
   /** The layer's pixels with all its wet paint dried (deterministic), without changing anything. */
   bakedSurface(layerId) {
     const w = this.world;
-    if (!_optionalChain([w, 'optionalAccess', _137 => _137.hasLane, 'call', _138 => _138(layerId)])) return null;
+    if (!_optionalChain([w, 'optionalAccess', _139 => _139.hasLane, 'call', _140 => _140(layerId)])) return null;
     return w.bakedSurface(layerId);
   }
   /** A snapshot of the world for undo (`null` when there is none). */
@@ -2483,13 +2509,13 @@ var PaintWetLayers = (_class6 = class {
     this.syncDisplays();
   }
   dropWorld() {
-    _optionalChain([this, 'access', _139 => _139.world, 'optionalAccess', _140 => _140.destroy, 'call', _141 => _141()]);
+    _optionalChain([this, 'access', _141 => _141.world, 'optionalAccess', _142 => _142.destroy, 'call', _143 => _143()]);
     this.world = null;
     this.driver = null;
   }
   /** Forgets everything wet (a new canvas, a resize, opening a document). */
   reset() {
-    _optionalChain([this, 'access', _142 => _142.world, 'optionalAccess', _143 => _143.destroy, 'call', _144 => _144()]);
+    _optionalChain([this, 'access', _144 => _144.world, 'optionalAccess', _145 => _145.destroy, 'call', _146 => _146()]);
     this.world = null;
     this.driver = null;
     this.settings.clear();
@@ -2519,14 +2545,14 @@ var PaintWetLayers = (_class6 = class {
     return out;
   }
   destroy() {
-    _optionalChain([this, 'access', _145 => _145.world, 'optionalAccess', _146 => _146.destroy, 'call', _147 => _147()]);
+    _optionalChain([this, 'access', _147 => _147.world, 'optionalAccess', _148 => _148.destroy, 'call', _149 => _149()]);
     this.world = null;
-    _optionalChain([this, 'access', _148 => _148.gpu, 'optionalAccess', _149 => _149.destroy, 'call', _150 => _150()]);
+    _optionalChain([this, 'access', _150 => _150.gpu, 'optionalAccess', _151 => _151.destroy, 'call', _152 => _152()]);
     this.gpu = null;
   }
 }, _class6);
 function wetPigmentOf(hex, body) {
-  const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, hex);
+  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, hex);
   return Array.from(_chunkXFYLA3ZOcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
 }
 
@@ -2534,13 +2560,13 @@ function wetPigmentOf(hex, body) {
 var thumbWorld = null;
 function paintWetTestStroke(brush, paper, color, width, height) {
   if (!thumbWorld || thumbWorld.width !== width || thumbWorld.height !== height) {
-    _optionalChain([thumbWorld, 'optionalAccess', _151 => _151.destroy, 'call', _152 => _152()]);
+    _optionalChain([thumbWorld, 'optionalAccess', _153 => _153.destroy, 'call', _154 => _154()]);
     thumbWorld = new (0, _chunkXFYLA3ZOcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: "typescript", threads: 0 });
   } else thumbWorld.setPaper(wetPaperInput(paper));
   const w = thumbWorld;
   if (w.hasLane("thumb")) w.removeLane("thumb");
   w.ensureLane("thumb");
-  const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, color);
+  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color);
   if (brush.wet.tool !== "paint" && brush.wet.tool !== "water") {
     const half = Math.ceil(height / 2);
     w.paint("thumb", { x: 0, y: 0, width, height: half }, null, 0.4, Array.from(_chunkXFYLA3ZOcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], 0), (v) => v * 0.05));
@@ -2554,9 +2580,9 @@ function paintWetTestStroke(brush, paper, color, width, height) {
     load: brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]),
     grain: paperGrain(paper),
     paperDepth: paper.depth,
-    paperColor: _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, paper.color),
+    paperColor: _chunk5BR7LC24cjs.hexToRgb8.call(void 0, paper.color),
     seed: 7,
-    copies: [_chunkNKTNLJUJcjs.IDENTITY_COPY]
+    copies: [_chunk5BR7LC24cjs.IDENTITY_COPY]
   });
   driver.push(thumbnailStroke(width, height));
   driver.finish();
@@ -2576,7 +2602,7 @@ function thumbnailStroke(width, height) {
   return pts;
 }
 function paintTestStroke(surface, brush, paper, color, width, height) {
-  const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, color);
+  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color);
   let result = surface;
   let thick = null;
   const session = new PaintStrokeSession(
@@ -2595,13 +2621,13 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       lockTransparency: false,
       brush,
       color: [r, g, b, 255],
-      background: [..._chunkNKTNLJUJcjs.hexToRgb8.call(void 0, paper.color), 255],
+      background: [..._chunk5BR7LC24cjs.hexToRgb8.call(void 0, paper.color), 255],
       grain: paperGrain(paper),
       paperDepth: paper.depth,
       seed: 7,
       colorHex: color,
       affineCopies: [],
-      copies: [_chunkNKTNLJUJcjs.IDENTITY_COPY],
+      copies: [_chunk5BR7LC24cjs.IDENTITY_COPY],
       mixerLoad: brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]),
       thick: brush.engine === "impasto" ? { channels: emptyThickChannels() } : void 0,
       sticker: brush.engine === "sticker" ? { nextId: 1 } : void 0
@@ -2615,8 +2641,8 @@ function renderBrushThumbnail(brush, options) {
   const width = Math.max(16, Math.min(512, Math.round(_nullishCoalesce(options.width, () => ( 160)))));
   const height = Math.max(16, Math.min(512, Math.round(_nullishCoalesce(options.height, () => ( 48)))));
   const maxSize = height * 0.42;
-  const b = brush.tip.size > maxSize ? _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: maxSize } }, brush) : brush;
-  const rgba = [..._chunkNKTNLJUJcjs.hexToRgb8.call(void 0, options.color), 255];
+  const b = brush.tip.size > maxSize ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: maxSize } }, brush) : brush;
+  const rgba = [..._chunk5BR7LC24cjs.hexToRgb8.call(void 0, options.color), 255];
   let surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4);
   if (b.engine === "eraser") {
     surface = _chunk474IQG74cjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height }, rgba);
@@ -2758,12 +2784,12 @@ function perspectiveDirections(g, p) {
 }
 var SNAP_DECIDE_DISTANCE = 6;
 var PerspectiveSnapper = (_class7 = class {
-  constructor(guide) {;_class7.prototype.__init63.call(this);_class7.prototype.__init64.call(this);
+  constructor(guide) {;_class7.prototype.__init65.call(this);_class7.prototype.__init66.call(this);
     this.guide = guide;
   }
   
-  __init63() {this.start = null}
-  __init64() {this.dir = null}
+  __init65() {this.start = null}
+  __init66() {this.dir = null}
   /** The line the stroke follows, once chosen. */
   get line() {
     return this.start && this.dir ? { from: this.start, direction: this.dir } : null;
@@ -2869,11 +2895,11 @@ function readSwatch(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
   const g = _chunkPQ3H2AANcjs.readPaintSource.call(void 0, r.paint);
-  const color = typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : _optionalChain([g, 'optionalAccess', _153 => _153.type]) === "gradient" ? _chunkPQ3H2AANcjs.paintSourceColor.call(void 0, g) : null;
+  const color = typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : _optionalChain([g, 'optionalAccess', _155 => _155.type]) === "gradient" ? _chunkPQ3H2AANcjs.paintSourceColor.call(void 0, g) : null;
   if (!color) return null;
   const out = { color };
   if (typeof r.name === "string" && r.name.trim()) out.name = r.name.trim().slice(0, 80);
-  if (_optionalChain([g, 'optionalAccess', _154 => _154.type]) === "gradient") out.paint = g;
+  if (_optionalChain([g, 'optionalAccess', _156 => _156.type]) === "gradient") out.paint = g;
   return out;
 }
 var DEFAULT_SWATCHES = [
@@ -2892,7 +2918,7 @@ var DEFAULT_SWATCHES = [
 // src/paint-editor/mixing-pad.ts
 var MIXING_PAD_WIDTH = 360;
 var MIXING_PAD_HEIGHT = 220;
-var PAD_PAINT = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, {
+var PAD_PAINT = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
   id: "pad-paint",
   name: "Pad paint",
   category: "mixer",
@@ -2900,7 +2926,7 @@ var PAD_PAINT = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, {
   tip: { size: 28, hardness: 0.75, spacing: 0.1, opacity: 1, flow: 0.7, pressureSize: false, pressureOpacity: false },
   mixer: { wet: 0.45, load: 1, mix: 0.4, loadEachStroke: true, cleanEachStroke: true, mixing: "pigment" }
 });
-var PAD_KNIFE = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, {
+var PAD_KNIFE = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
   id: "pad-knife",
   name: "Palette knife",
   category: "smudge",
@@ -2910,19 +2936,19 @@ var PAD_KNIFE = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, {
   // A knife drags streaks of paint and folds them into each other, mixing them as pigment.
   smudge: { strength: 0.6, length: 0.8, mixing: "pigment" }
 });
-var PAD_BLOB = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, {
+var PAD_BLOB = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
   id: "pad-blob",
   name: "Pad blob",
   category: "custom",
   engine: "dab",
   tip: { size: 20, hardness: 1, spacing: 0.1, opacity: 1, flow: 1, pressureSize: false, pressureOpacity: false }
 });
-var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.call(this);_class8.prototype.__init66.call(this);_class8.prototype.__init67.call(this);_class8.prototype.__init68.call(this); }
-  __init65() {this.width = MIXING_PAD_WIDTH}
-  __init66() {this.height = MIXING_PAD_HEIGHT}
-  __init67() {this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4)}
+var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.call(this);_class8.prototype.__init68.call(this);_class8.prototype.__init69.call(this);_class8.prototype.__init70.call(this); }
+  __init67() {this.width = MIXING_PAD_WIDTH}
+  __init68() {this.height = MIXING_PAD_HEIGHT}
+  __init69() {this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4)}
   /** Increments on every change (for redrawing). */
-  __init68() {this.version = 0}
+  __init70() {this.version = 0}
   /** Paints (`paint`, with `color`) or smears (`knife`) through `points` in pad pixels. */
   stroke(points, options) {
     if (!points.length) throw new Error("points is empty; give at least one {x, y} in pad pixels.");
@@ -2932,12 +2958,12 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.cal
       }
     }
     let brush = options.tool === "knife" ? PAD_KNIFE : PAD_PAINT;
-    if (options.size !== void 0) brush = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: options.size } }, brush);
+    if (options.size !== void 0) brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: options.size } }, brush);
     return this.run(brush, points, options.color);
   }
   /** Paints `points` with `brush` in `color` on the pad. */
   run(brush, points, color) {
-    const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, color);
+    const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color);
     let result = null;
     const session = new PaintStrokeSession(
       { update: () => {
@@ -2955,7 +2981,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.cal
         seed: 1,
         colorHex: color,
         affineCopies: [],
-        copies: [_chunkNKTNLJUJcjs.IDENTITY_COPY],
+        copies: [_chunk5BR7LC24cjs.IDENTITY_COPY],
         mixerLoad: brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
       }
     );
@@ -3031,10 +3057,10 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.cal
       const off = used.length === 1 ? 0 : 0.45 * R;
       const x = Math.min(cx + R - r, Math.max(cx - R + r, cx + Math.cos(a) * off));
       const y = Math.min(cy + R - r, Math.max(cy - R + r, cy + Math.sin(a) * off));
-      const blob = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: Math.max(2, 2 * r) } }, PAD_BLOB);
+      const blob = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: Math.max(2, 2 * r) } }, PAD_BLOB);
       this.run(blob, [{ x, y }], p.color.toLowerCase());
     });
-    const knife = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_KNIFE.tip, size: Math.max(12, R * 0.5) } }, PAD_KNIFE);
+    const knife = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_KNIFE.tip, size: Math.max(12, R * 0.5) } }, PAD_KNIFE);
     for (let k = 0; k < passes; k++) {
       const stir = [];
       const turns = 1.6;
@@ -3046,10 +3072,10 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.cal
       this.run(knife, stir, "#000000");
     }
     const mixed = _chunkOLNIPTB3cjs.mixPigments.call(void 0, 
-      paints.map((p) => _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, p.color).map((v) => v / 255)),
+      paints.map((p) => _chunk5BR7LC24cjs.hexToRgb8.call(void 0, p.color).map((v) => v / 255)),
       paints.map((p) => p.parts)
     );
-    const core = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
+    const core = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
     const hex = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
     this.run(core, [{ x: cx, y: cy }], hex);
     return { color: this.pick(cx, cy, 2), bounds };
@@ -3060,7 +3086,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.cal
   }
   /** Replaces the pad with a PNG (data URL or base64) of the pad's size, as `toPng` writes. */
   fromPng(png) {
-    const bytes = png.startsWith("data:") ? _optionalChain([_chunkOLNIPTB3cjs.parseDataUrl.call(void 0, png), 'optionalAccess', _155 => _155.bytes]) : _chunkOLNIPTB3cjs.base64ToBytes.call(void 0, png);
+    const bytes = png.startsWith("data:") ? _optionalChain([_chunkOLNIPTB3cjs.parseDataUrl.call(void 0, png), 'optionalAccess', _157 => _157.bytes]) : _chunkOLNIPTB3cjs.base64ToBytes.call(void 0, png);
     if (!bytes || !_chunkOLNIPTB3cjs.isPng.call(void 0, bytes)) throw new Error("The pad image is not a PNG data URL or base64 PNG.");
     const img = _chunkOLNIPTB3cjs.decodePng.call(void 0, bytes);
     if (img.width !== this.width || img.height !== this.height) throw new Error(`The pad image is ${img.width}\xD7${img.height}; a mixing pad is ${this.width}\xD7${this.height}.`);
@@ -3085,6 +3111,43 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init65.cal
   }
 }, _class8);
 
+// src/paint-editor/live-strokes.ts
+var LIVE_STROKE_ENGINES = ["dab", "particle", "bristle", "mixer"];
+function liveStrokeRefusal(brush) {
+  switch (brush.engine) {
+    case "wet":
+      return `The ${brush.name} brush paints wet media, which a stroke layer can't redraw (the paint depends on the simulation's history); paint it on a pixel layer (add_layer).`;
+    case "impasto":
+      return `The ${brush.name} brush paints thick paint with relief, which a stroke layer doesn't keep; paint it on a pixel layer (add_layer).`;
+    case "sticker":
+      return `The ${brush.name} brush sprays stickers, which are their own objects; spray them on an empty pixel layer (add_layer).`;
+    case "eraser":
+      return `Erasers don't paint on a stroke layer; delete strokes instead (remove_strokes), or rasterize the layer first (rasterize_stroke_layer).`;
+    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.`;
+  }
+  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;
+}
+function liveStrokeBounds(stroke) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const m of [null, ..._nullishCoalesce(stroke.copies, () => ( []))]) {
+    for (const p of stroke.points) {
+      const q = m ? applyAffine(m, p.x, p.y) : p;
+      if (q.x < x0) x0 = q.x;
+      if (q.y < y0) y0 = q.y;
+      if (q.x > x1) x1 = q.x;
+      if (q.y > y1) y1 = q.y;
+    }
+  }
+  const pad = stroke.brush.tip.size * (stroke.brush.engine === "particle" ? 2 : 1) + 2;
+  return { x: Math.floor(x0 - pad), y: Math.floor(y0 - pad), width: Math.ceil(x1 - x0 + 2 * pad), height: Math.ceil(y1 - y0 + 2 * pad) };
+}
+
 // src/paint-editor/replay.ts
 function replayItems(doc) {
   const items = [];
@@ -3107,7 +3170,7 @@ async function replayPainting(source, target, options = {}) {
   const maxStrokes = _nullishCoalesce(options.strokes, () => ( source.strokes.length));
   const chunk = Math.max(1, _nullishCoalesce(options.wetChunk, () => ( 0))) || Infinity;
   let strokes = 0;
-  await target.prepareEffectPaints(source.strokes.slice(0, maxStrokes).flatMap((st) => _optionalChain([st, 'access', _156 => _156.paint, 'optionalAccess', _157 => _157.type]) === "effect" ? [st.paint] : []));
+  await target.prepareEffectPaints(source.strokes.slice(0, maxStrokes).flatMap((st) => _optionalChain([st, 'access', _158 => _158.paint, 'optionalAccess', _159 => _159.type]) === "effect" ? [st.paint] : []));
   const advanceTo = async (clock) => {
     const now = target.getState().wet.clock;
     let left = clock - now;
@@ -3115,7 +3178,7 @@ async function replayPainting(source, target, options = {}) {
       const n = Math.min(left, chunk);
       await target.advanceWet({ steps: n });
       left -= n;
-      if (Number.isFinite(chunk)) await _optionalChain([options, 'access', _158 => _158.onWetSteps, 'optionalCall', _159 => _159(target.getState().wet.clock)]);
+      if (Number.isFinite(chunk)) await _optionalChain([options, 'access', _160 => _160.onWetSteps, 'optionalCall', _161 => _161(target.getState().wet.clock)]);
     }
   };
   const sr = (r) => ({ x: r.x * s, y: r.y * s, width: r.width * s, height: r.height * s });
@@ -3126,8 +3189,16 @@ async function replayPainting(source, target, options = {}) {
       if (!target.getLayer(e.layerId)) continue;
       if (e.kind === "fill") target.fillLayer({ layerId: e.layerId, ...e.data });
       else if (e.kind === "clear") target.clearLayer(e.layerId);
-      else if (e.kind === "stickers") {
-        const list = (_nullishCoalesce(_optionalChain([e, 'access', _160 => _160.data, 'optionalAccess', _161 => _161.stickers]), () => ( []))).map((x) => s === 1 ? x : { ...x, x: x.x * s, y: x.y * s, size: x.size * s });
+      else if (e.kind === "live-strokes") {
+        const d = e.data;
+        if (_optionalChain([d, 'optionalAccess', _162 => _162.rasterized])) target.replaceLiveStrokes(e.layerId, null);
+        else {
+          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _163 => _163.strokes]), () => ( []))).map((st2) => s === 1 ? st2 : { ...varyStroke(st2, scaleM, { scale: s }), ...st2.stencils ? { stencils: st2.stencils.map((x) => scaleStencil(x, s)) } : {} });
+          await target.prepareEffectPaints(list.flatMap((st2) => _optionalChain([st2, 'access', _164 => _164.paint, 'optionalAccess', _165 => _165.type]) === "effect" ? [st2.paint] : []));
+          target.replaceLiveStrokes(e.layerId, list);
+        }
+      } else if (e.kind === "stickers") {
+        const list = (_nullishCoalesce(_optionalChain([e, 'access', _166 => _166.data, 'optionalAccess', _167 => _167.stickers]), () => ( []))).map((x) => s === 1 ? x : { ...x, x: x.x * s, y: x.y * s, size: x.size * s });
         target.replaceStickers(e.layerId, list);
       } else target.flattenRelief(e.layerId);
       continue;
@@ -3140,8 +3211,8 @@ async function replayPainting(source, target, options = {}) {
         switch (e.kind) {
           case "dry": {
             const rect = e.data;
-            const ids = _optionalChain([e, 'access', _162 => _162.layerId, 'optionalAccess', _163 => _163.split, 'call', _164 => _164(","), 'access', _165 => _165.filter, 'call', _166 => _166(Boolean)]);
-            if (_optionalChain([ids, 'optionalAccess', _167 => _167.length])) for (const id of ids) target.dryPaint({ layerId: id, rect: rect ? sr(rect) : void 0 });
+            const ids = _optionalChain([e, 'access', _168 => _168.layerId, 'optionalAccess', _169 => _169.split, 'call', _170 => _170(","), 'access', _171 => _171.filter, 'call', _172 => _172(Boolean)]);
+            if (_optionalChain([ids, 'optionalAccess', _173 => _173.length])) for (const id of ids) target.dryPaint({ layerId: id, rect: rect ? sr(rect) : void 0 });
             else target.dryPaint({ rect: rect ? sr(rect) : void 0 });
             break;
           }
@@ -3172,7 +3243,7 @@ async function replayPainting(source, target, options = {}) {
     strokes++;
     if (!target.getLayer(st.layerId)) continue;
     const init = { layerId: st.layerId, color: st.color, brush: st.brush, seed: st.seed, copies: _nullishCoalesce(st.copies, () => ( [])), ...st.load ? { load: st.load } : {}, ...st.paint ? { paint: st.paint } : {}, snapToPerspective: false, stencils: false, maskStencils: (_nullishCoalesce(st.stencils, () => ( []))).map((x) => s === 1 ? x : scaleStencil(x, s)) };
-    if (st.brush.engine === "wet" && _optionalChain([st, 'access', _168 => _168.steps, 'optionalAccess', _169 => _169.length]) === st.points.length) {
+    if (st.brush.engine === "wet" && _optionalChain([st, 'access', _174 => _174.steps, 'optionalAccess', _175 => _175.length]) === st.points.length) {
       await target.wetIdle();
       await advanceTo(st.steps[0]);
       const session = target.beginStroke({ ...init, start: st.points[0] });
@@ -3192,7 +3263,7 @@ async function replayPainting(source, target, options = {}) {
       await target.wetIdle();
       target.paintStroke({ ...init, points: st.points });
     }
-    await _optionalChain([options, 'access', _170 => _170.onStroke, 'optionalCall', _171 => _171(strokes)]);
+    await _optionalChain([options, 'access', _176 => _176.onStroke, 'optionalCall', _177 => _177(strokes)]);
   }
   void IDENTITY_AFFINE;
 }
@@ -3237,7 +3308,7 @@ async function buildTimeLapse(source, target, options = {}) {
     wetChunk: wetEvery > 0 ? wetEvery : 0,
     onStroke: (i) => {
       if (i % perFrame === 0 || i === total) shoot(i);
-      _optionalChain([options, 'access', _172 => _172.onProgress, 'optionalCall', _173 => _173(total ? i / total : 1)]);
+      _optionalChain([options, 'access', _178 => _178.onProgress, 'optionalCall', _179 => _179(total ? i / total : 1)]);
     },
     onWetSteps: wetEvery > 0 ? () => shoot(-1) : void 0
   });
@@ -3324,10 +3395,10 @@ function mixPixels(before, after, amount) {
   }
   return out;
 }
-var PaintEffectsRenderer = (_class9 = class {constructor() { _class9.prototype.__init69.call(this);_class9.prototype.__init70.call(this);_class9.prototype.__init71.call(this); }
-  __init69() {this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: 3 })}
-  __init70() {this.descriptions = /* @__PURE__ */ new Map()}
-  __init71() {this.provider = null}
+var PaintEffectsRenderer = (_class9 = class {constructor() { _class9.prototype.__init71.call(this);_class9.prototype.__init72.call(this);_class9.prototype.__init73.call(this); }
+  __init71() {this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: 3 })}
+  __init72() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init73() {this.provider = null}
   /** Forgets cached descriptions and renderers when the provider changes. */
   follow(provider) {
     if (provider === this.provider) return;
@@ -3412,7 +3483,7 @@ function parseColor(value, what = "color") {
   return value.trim().toLowerCase();
 }
 function rgbaOf(hex) {
-  const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, hex);
+  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, hex);
   return [r, g, b, 255];
 }
 function rgbToHex(r, g, b) {
@@ -3425,75 +3496,87 @@ function unionRect(a, b) {
   const y = Math.min(a.y, b.y);
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
-var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _174 => _174.type]) === "pixel";
+var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _180 => _180.type]) === "pixel";
 var PaintEditorController = (_class10 = class _PaintEditorController {
   
-  __init72() {this.extensions = {}}
-  __init73() {this.undoStack = []}
-  __init74() {this.redoStack = []}
+  __init74() {this.extensions = {}}
+  __init75() {this.undoStack = []}
+  __init76() {this.redoStack = []}
   
   
   
   /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
-  __init75() {this.library = null}
+  __init77() {this.library = null}
   
-  __init76() {this.secondaryColor = "#ffffff"}
+  __init78() {this.secondaryColor = "#ffffff"}
   /** Gradient paint chosen with `setPaint` (`null`: the paint colour). */
-  __init77() {this.gradient = null}
+  __init79() {this.gradient = null}
   /** Effect paint chosen with `setEffectPaint` (rendered), and one still rendering. */
-  __init78() {this.effectPaint = null}
-  __init79() {this.effectPaintPending = null}
+  __init80() {this.effectPaint = null}
+  __init81() {this.effectPaintPending = null}
   /** Changes whenever the paint is chosen, so an effect paint that finishes rendering late does not take over. */
-  __init80() {this.paintEpoch = 0}
+  __init82() {this.paintEpoch = 0}
   /** Rendered effect paints by `effectPaintKey` (most recently used last). */
-  __init81() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
-  __init82() {this.mixerLoad = _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD}
-  __init83() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  __init83() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
+  __init84() {this.mixerLoad = _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD}
+  __init85() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
   
-  __init84() {this.selectedSticker = null}
+  __init86() {this.selectedStroke = null}
+  __init87() {this.selectedSticker = null}
   /** A sticker drag in progress (`previewSticker`): the document before it, so the drop undoes in one step, and the one it showed last. */
-  __init85() {this.stickerPreview = null}
+  __init88() {this.stickerPreview = null}
   
-  __init86() {this.listeners = /* @__PURE__ */ new Set()}
-  __init87() {this.version = 0}
-  __init88() {this.cached = null}
-  __init89() {this.session = null}
-  __init90() {this.live = null}
-  __init91() {this.liveLayers = null}
-  __init92() {this.dirty = "all"}
-  __init93() {this.seedCounter = 1}
-  __init94() {this.strokeCounter = 1}
+  __init89() {this.listeners = /* @__PURE__ */ new Set()}
+  __init90() {this.version = 0}
+  __init91() {this.cached = null}
+  __init92() {this.session = null}
+  __init93() {this.live = null}
+  __init94() {this.liveLayers = null}
+  __init95() {this.dirty = "all"}
+  __init96() {this.seedCounter = 1}
+  __init97() {this.strokeCounter = 1}
+  /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
+  __init98() {this.effectPlaybackState = { playing: true, fps: 30 }}
+  __init99() {this.effectTime = 0}
+  /** While a frame is drawn: the time live effect strokes are drawn at (else their own time). */
+  __init100() {this.liveEffectAt = null}
+  /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
+  __init101() {this.animatedLayers = /* @__PURE__ */ new Map()}
+  /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
+  __init102() {this.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`). */
+  __init103() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
   
-  __init95() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init96() {this.pad = new MixingPad()}
-  __init97() {this.savedPads = []}
-  __init98() {this.nextPadId = 1}
-  __init99() {this.tracingVersion = 1}
-  __init100() {this.tracingCache = null}
-  __init101() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init102() {this.nextReferenceId = 1}
-  __init103() {this.viewCompositor = createPaintCompositor()}
-  __init104() {this.exportCompositor = createPaintCompositor()}
+  __init104() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init105() {this.pad = new MixingPad()}
+  __init106() {this.savedPads = []}
+  __init107() {this.nextPadId = 1}
+  __init108() {this.tracingVersion = 1}
+  __init109() {this.tracingCache = null}
+  __init110() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init111() {this.nextReferenceId = 1}
+  __init112() {this.viewCompositor = createPaintCompositor()}
+  __init113() {this.exportCompositor = createPaintCompositor()}
   /** Wet media: the simulation, its settings and time. */
   
   
   /** Where the light comes from for thick paint (saved with the document, not undo steps). */
-  __init105() {this.lighting = { ...DEFAULT_LIGHTING }}
-  __init106() {this.litCaches = /* @__PURE__ */ new Map()}
+  __init114() {this.lighting = { ...DEFAULT_LIGHTING }}
+  __init115() {this.litCaches = /* @__PURE__ */ new Map()}
   /** The live impasto stroke's channels. */
-  __init107() {this.liveThick = null}
+  __init116() {this.liveThick = null}
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
-  __init108() {this.wetOp = null}
+  __init117() {this.wetOp = null}
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init109() {this.effects = new (0, _chunkJAOSL334cjs.EffectsSlot)()}
-  __init110() {this.effectsRenderer = new PaintEffectsRenderer()}
-  __init111() {this.paperEffectNodeCache = null}
-  constructor(options = {}) {;_class10.prototype.__init72.call(this);_class10.prototype.__init73.call(this);_class10.prototype.__init74.call(this);_class10.prototype.__init75.call(this);_class10.prototype.__init76.call(this);_class10.prototype.__init77.call(this);_class10.prototype.__init78.call(this);_class10.prototype.__init79.call(this);_class10.prototype.__init80.call(this);_class10.prototype.__init81.call(this);_class10.prototype.__init82.call(this);_class10.prototype.__init83.call(this);_class10.prototype.__init84.call(this);_class10.prototype.__init85.call(this);_class10.prototype.__init86.call(this);_class10.prototype.__init87.call(this);_class10.prototype.__init88.call(this);_class10.prototype.__init89.call(this);_class10.prototype.__init90.call(this);_class10.prototype.__init91.call(this);_class10.prototype.__init92.call(this);_class10.prototype.__init93.call(this);_class10.prototype.__init94.call(this);_class10.prototype.__init95.call(this);_class10.prototype.__init96.call(this);_class10.prototype.__init97.call(this);_class10.prototype.__init98.call(this);_class10.prototype.__init99.call(this);_class10.prototype.__init100.call(this);_class10.prototype.__init101.call(this);_class10.prototype.__init102.call(this);_class10.prototype.__init103.call(this);_class10.prototype.__init104.call(this);_class10.prototype.__init105.call(this);_class10.prototype.__init106.call(this);_class10.prototype.__init107.call(this);_class10.prototype.__init108.call(this);_class10.prototype.__init109.call(this);_class10.prototype.__init110.call(this);_class10.prototype.__init111.call(this);_class10.prototype.__init112.call(this);_class10.prototype.__init113.call(this);_class10.prototype.__init114.call(this);_class10.prototype.__init115.call(this);
+  __init118() {this.effects = new (0, _chunkJAOSL334cjs.EffectsSlot)()}
+  __init119() {this.effectsRenderer = new PaintEffectsRenderer()}
+  __init120() {this.paperEffectNodeCache = null}
+  constructor(options = {}) {;_class10.prototype.__init74.call(this);_class10.prototype.__init75.call(this);_class10.prototype.__init76.call(this);_class10.prototype.__init77.call(this);_class10.prototype.__init78.call(this);_class10.prototype.__init79.call(this);_class10.prototype.__init80.call(this);_class10.prototype.__init81.call(this);_class10.prototype.__init82.call(this);_class10.prototype.__init83.call(this);_class10.prototype.__init84.call(this);_class10.prototype.__init85.call(this);_class10.prototype.__init86.call(this);_class10.prototype.__init87.call(this);_class10.prototype.__init88.call(this);_class10.prototype.__init89.call(this);_class10.prototype.__init90.call(this);_class10.prototype.__init91.call(this);_class10.prototype.__init92.call(this);_class10.prototype.__init93.call(this);_class10.prototype.__init94.call(this);_class10.prototype.__init95.call(this);_class10.prototype.__init96.call(this);_class10.prototype.__init97.call(this);_class10.prototype.__init98.call(this);_class10.prototype.__init99.call(this);_class10.prototype.__init100.call(this);_class10.prototype.__init101.call(this);_class10.prototype.__init102.call(this);_class10.prototype.__init103.call(this);_class10.prototype.__init104.call(this);_class10.prototype.__init105.call(this);_class10.prototype.__init106.call(this);_class10.prototype.__init107.call(this);_class10.prototype.__init108.call(this);_class10.prototype.__init109.call(this);_class10.prototype.__init110.call(this);_class10.prototype.__init111.call(this);_class10.prototype.__init112.call(this);_class10.prototype.__init113.call(this);_class10.prototype.__init114.call(this);_class10.prototype.__init115.call(this);_class10.prototype.__init116.call(this);_class10.prototype.__init117.call(this);_class10.prototype.__init118.call(this);_class10.prototype.__init119.call(this);_class10.prototype.__init120.call(this);_class10.prototype.__init121.call(this);_class10.prototype.__init122.call(this);_class10.prototype.__init123.call(this);_class10.prototype.__init124.call(this);
     this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
-    this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
-    const start = _nullishCoalesce(this.findBrush(_nullishCoalesce(options.brushId, () => ( _chunkNKTNLJUJcjs.DEFAULT_BRUSH_ID))), () => ( this.findBrush(_chunkNKTNLJUJcjs.DEFAULT_BRUSH_ID)));
-    this.brush = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, start);
+    this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
+    const start = _nullishCoalesce(this.findBrush(_nullishCoalesce(options.brushId, () => ( _chunk5BR7LC24cjs.DEFAULT_BRUSH_ID))), () => ( this.findBrush(_chunk5BR7LC24cjs.DEFAULT_BRUSH_ID)));
+    this.brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, start);
     this.color = options.color ? parseColor(options.color) : "#1f2937";
     this.hand = options.hand === "left" ? "left" : "right";
     this.encodeImage = options.encodeImage;
@@ -3504,7 +3587,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         canvas: () => this.doc.canvas,
         paper: () => this.doc.paper,
         layerSurface: (id) => {
-          const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _175 => _175.layer]);
+          const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _181 => _181.layer]);
           return isPixelLayer(l) ? l.surface : null;
         },
         updateSurfaces: (surfaces, rects) => {
@@ -3518,7 +3601,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       },
       options.wet
     );
-    this.wet.onDriverDone = () => _optionalChain([this, 'access', _176 => _176.session, 'optionalAccess', _177 => _177.completeWetEnd, 'call', _178 => _178()]);
+    this.wet.onDriverDone = () => _optionalChain([this, 'access', _182 => _182.session, 'optionalAccess', _183 => _183.completeWetEnd, 'call', _184 => _184()]);
   }
   // --- State and events ----------------------------------------------------------
   subscribe(listener) {
@@ -3540,7 +3623,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.cached = {
       document: this.doc,
       brush: this.brush,
-      brushes: this.library ??= [..._chunkNKTNLJUJcjs.BUILTIN_BRUSHES, ...this.userBrushes],
+      brushes: this.library ??= [..._chunk5BR7LC24cjs.BUILTIN_BRUSHES, ...this.userBrushes],
       color: this.color,
       secondaryColor: this.secondaryColor,
       paint: _nullishCoalesce(this.gradient, () => ( { type: "color", color: this.color })),
@@ -3549,11 +3632,13 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       mixerLoad: this.mixerLoad,
       view: this.view,
       hand: this.hand,
+      effectPlayback: { ...this.effectPlaybackState, time: this.effectTime },
+      selectedStroke: this.selectedStroke,
       selectedSticker: this.selectedSticker,
       canUndo: this.undoStack.length > 0 && !this.session,
       canRedo: this.redoStack.length > 0 && !this.session,
-      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _179 => _179.label]), () => ( null)),
-      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _180 => _180.label]), () => ( null)),
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _185 => _185.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _186 => _186.label]), () => ( null)),
       guides: this.guides,
       swatches: this.swatches,
       mixingPadVersion: this.pad.version,
@@ -3566,10 +3651,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         overlay: this.wet.overlay,
         instantDry: this.wet.instantDry,
         speed: this.wet.speed,
-        clock: _nullishCoalesce(_optionalChain([this, 'access', _181 => _181.wet, 'access', _182 => _182.world, 'optionalAccess', _183 => _183.clock]), () => ( 0)),
+        clock: _nullishCoalesce(_optionalChain([this, 'access', _187 => _187.wet, 'access', _188 => _188.world, 'optionalAccess', _189 => _189.clock]), () => ( 0)),
         tilt: { ...this.wet.tilt },
         gpu: this.wet.gpuMode,
-        gpuActive: Boolean(_optionalChain([this, 'access', _184 => _184.wet, 'access', _185 => _185.world, 'optionalAccess', _186 => _186.gpuActive]))
+        gpuActive: Boolean(_optionalChain([this, 'access', _190 => _190.wet, 'access', _191 => _191.world, 'optionalAccess', _192 => _192.gpuActive]))
       },
       version: this.version
     };
@@ -3588,7 +3673,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return d;
   }
   // --- History -------------------------------------------------------------------
-  __init112() {this.docRevision = 0}
+  __init121() {this.docRevision = 0}
   /**
    * Bumped on every change to the painting (a committed or amended step, undo, redo, opening a
    * document), not on wet-paint frames or view changes. `createPaintEditorDocument` uses it.
@@ -3671,9 +3756,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return wetIds;
   }
   /** Records a wet event (for replays) in the document being built. */
-  __init113() {this.pendingWetEvents = []}
+  __init122() {this.pendingWetEvents = []}
   logWet(e) {
-    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _187 => _187.wet, 'access', _188 => _188.world, 'optionalAccess', _189 => _189.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
+    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _193 => _193.wet, 'access', _194 => _194.world, 'optionalAccess', _195 => _195.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
   }
   /** The document with a paint event appended (for replays). */
   withPaintEvent(doc, e) {
@@ -3734,7 +3819,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   // --- Canvas and paper ----------------------------------------------------------
   resolvePaper(paper) {
     if (typeof paper === "string") {
-      const p = _chunkNKTNLJUJcjs.paperPreset.call(void 0, paper);
+      const p = _chunk5BR7LC24cjs.paperPreset.call(void 0, paper);
       if (!p) throw new PaintEditorError(`Unknown paper "${paper}". Call list_papers for the ids.`);
       return p;
     }
@@ -3817,7 +3902,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
     for (const id of keptWet) {
-      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _190 => _190.layer]);
+      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _196 => _196.layer]);
       if (isPixelLayer(l)) next = { ...next, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, next.layers, id, () => ({ ...l, surface: _chunk474IQG74cjs.translateSurface.call(void 0, l.surface, l.offset.x, l.offset.y), offset: { x: 0, y: 0 } })) };
     }
     if (this.wet.world) {
@@ -3845,23 +3930,23 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.requireIdle("changing the paper");
     let base = this.doc.paper;
     if (update.preset !== void 0 && update.preset !== this.doc.paper.preset) {
-      const p = _chunkNKTNLJUJcjs.paperPreset.call(void 0, update.preset);
+      const p = _chunk5BR7LC24cjs.paperPreset.call(void 0, update.preset);
       if (!p) throw new PaintEditorError(`Unknown paper "${update.preset}". Call list_papers for the ids.`);
       base = p;
     }
     const { preset: _p, ...rest } = update;
     if (rest.color !== void 0) parseColor(rest.color, "paper color");
-    const paper = _chunkNKTNLJUJcjs.normalizePaper.call(void 0, { ...rest, preset: base.preset, offset: _nullishCoalesce(rest.offset, () => ( this.doc.paper.offset)) }, base);
+    const paper = _chunk5BR7LC24cjs.normalizePaper.call(void 0, { ...rest, preset: base.preset, offset: _nullishCoalesce(rest.offset, () => ( this.doc.paper.offset)) }, base);
     const changedKeys = Object.keys(rest).filter((k) => k !== "name");
     if (changedKeys.length && update.preset === void 0) paper.preset = base.preset;
     if (this.wet.world) this.beginWetOp();
     this.commit("Paper", { ...this.doc, paper });
     this.wet.paperChanged();
-    return _chunkNKTNLJUJcjs.clonePaper.call(void 0, paper);
+    return _chunk5BR7LC24cjs.clonePaper.call(void 0, paper);
   }
   // --- Layers --------------------------------------------------------------------
   getLayer(id) {
-    return _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _191 => _191.layer]);
+    return _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _197 => _197.layer]);
   }
   /** The active pixel layer (or `undefined`). */
   getActiveLayer() {
@@ -3880,7 +3965,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     walk(this.doc.layers, null, 0);
     return out;
   }
-  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _192 => _192.parent, 'optionalAccess', _193 => _193.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _194 => _194.path, 'access', _195 => _195.length]), () => ( 0))) {
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _198 => _198.parent, 'optionalAccess', _199 => _199.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _200 => _200.path, 'access', _201 => _201.length]), () => ( 0))) {
     let bounds = null;
     if (l.type === "pixel") {
       const b = _chunk474IQG74cjs.contentBounds.call(void 0, l.surface);
@@ -3897,6 +3982,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       locks: { ..._nullishCoalesce(l.locks, () => ( {})) },
       active: l.id === this.doc.activeLayerId,
       bounds,
+      ..._optionalChain([this, 'access', _202 => _202.doc, 'access', _203 => _203.liveStrokes, 'optionalAccess', _204 => _204[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
       parentId,
       depth
     };
@@ -3923,11 +4009,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.emit();
   }
   /** Adds an empty pixel layer or group above `aboveId` (default: the active layer) and makes it active. */
+  /** Adds a layer above the active one: `pixel` (default), `group`, or `strokes`, a live stroke layer whose strokes stay editable. */
   addLayer(options = {}) {
     this.requireIdle("adding a layer");
     const count = _chunkHB4ICNNAcjs.flattenLayers.call(void 0, this.doc.layers).length;
     const type = _nullishCoalesce(options.type, () => ( "pixel"));
-    const name = _optionalChain([options, 'access', _196 => _196.name, 'optionalAccess', _197 => _197.trim, 'call', _198 => _198()]) || (type === "group" ? `Group ${count + 1}` : `Layer ${count + 1}`);
+    const name = _optionalChain([options, 'access', _205 => _205.name, 'optionalAccess', _206 => _206.trim, 'call', _207 => _207()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
     const layer = type === "group" ? { type: "group", id: newPaintLayerId(), name, visible: true, opacity: 1, blend: "pass-through", children: [] } : createPaintLayer(name);
     let parentId = null;
     let index;
@@ -3939,11 +4026,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     } else if (above) {
       const loc = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, above);
       if (!loc) throw new PaintEditorError(`Unknown layer "${above}". Call list_layers for the ids.`);
-      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _199 => _199.parent, 'optionalAccess', _200 => _200.id]), () => ( null));
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _208 => _208.parent, 'optionalAccess', _209 => _209.id]), () => ( null));
       index = loc.index + 1;
     }
     const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
-    this.commit(type === "group" ? "Add group" : "Add layer", { ...this.doc, layers, activeLayerId: layer.id });
+    const live = type === "strokes" ? { liveStrokes: { ..._nullishCoalesce(this.doc.liveStrokes, () => ( {})), [layer.id]: [] } } : {};
+    this.commit(type === "group" ? "Add group" : type === "strokes" ? "Add stroke layer" : "Add layer", { ...this.doc, layers, activeLayerId: layer.id, ...live });
     return this.describeLayer(layer);
   }
   updateLayer(id, update) {
@@ -3979,8 +4067,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     const layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
-    if (active && !_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _201 => _201.filter, 'call', _202 => _202((x) => x.type === "pixel"), 'access', _203 => _203.pop, 'call', _204 => _204(), 'optionalAccess', _205 => _205.id]), () => ( null));
-    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
+    if (active && !_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _210 => _210.filter, 'call', _211 => _211((x) => x.type === "pixel"), 'access', _212 => _212.pop, 'call', _213 => _213(), 'optionalAccess', _214 => _214.id]), () => ( null));
+    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.liveStrokesWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
     return { removed: id, activeLayerId: active };
   }
   duplicateLayer(id) {
@@ -3993,15 +4081,17 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
     const thick = { ..._nullishCoalesce(this.doc.thick, () => ( {})) };
     const stickers = { ..._nullishCoalesce(this.doc.stickers, () => ( {})) };
+    const liveStrokes = { ..._nullishCoalesce(this.doc.liveStrokes, () => ( {})) };
     const copy = (l) => {
       const id2 = newPaintLayerId();
       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 }));
       return l.type === "group" ? { ...l, id: id2, children: l.children.map(copy) } : { ...l, id: id2 };
     };
     const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
-    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _206 => _206.parent, 'optionalAccess', _207 => _207.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 } : {} }));
+    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _215 => _215.parent, 'optionalAccess', _216 => _216.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 } : {} }));
     return this.describeLayer(dup);
   }
   /** Moves a layer to `index` (0 = bottom) within `parentId` (default its own parent; `null` = top level). */
@@ -4009,7 +4099,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.requireIdle("moving a layer");
     const loc = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
-    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _208 => _208.parent, 'optionalAccess', _209 => _209.id]), () => ( null)) : parentId;
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _217 => _217.parent, 'optionalAccess', _218 => _218.id]), () => ( null)) : parentId;
     if (target) {
       const g = this.requireLayer(target);
       if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
@@ -4028,7 +4118,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const pre = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id);
     if (pre) {
       const sib = pre.parent ? pre.parent.children : this.doc.layers;
-      this.dryLayersFirst([id, _optionalChain([sib, 'access', _210 => _210[pre.index - 1], 'optionalAccess', _211 => _211.id])].filter((x) => Boolean(x)));
+      this.dryLayersFirst([id, _optionalChain([sib, 'access', _219 => _219[pre.index - 1], 'optionalAccess', _220 => _220.id])].filter((x) => Boolean(x)));
     }
     const loc = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
@@ -4047,7 +4137,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
-    this.commit("Merge down", this.withWetEvents({ ...this.doc, layers, activeLayerId: below.id, ...this.thickWithout([upper.id]), ...this.stickersWithout([upper.id, below.id]) }));
+    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]) }));
     return this.describeLayer(merged);
   }
   /** Removes every pixel of a layer. */
@@ -4059,7 +4149,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       this.wet.world.removeLane(l.id);
     }
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunk474IQG74cjs.emptySurface.call(void 0, 4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]) }, { kind: "clear", layerId: l.id }));
+    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunk474IQG74cjs.emptySurface.call(void 0, 4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ..._optionalChain([this, 'access', _221 => _221.doc, 'access', _222 => _222.liveStrokes, 'optionalAccess', _223 => _223[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {} }, { kind: "clear", layerId: l.id }));
     return { layerId: l.id, bounds };
   }
   /**
@@ -4069,7 +4159,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   fillLayer(options = {}) {
     this.requireIdle("filling");
     const fillTarget = this.paintTarget(options.layerId, "fill");
-    if (_optionalChain([this, 'access', _212 => _212.doc, 'access', _213 => _213.stickers, 'optionalAccess', _214 => _214[fillTarget.id], 'optionalAccess', _215 => _215.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _224 => _224.doc, 'access', _225 => _225.stickers, 'optionalAccess', _226 => _226[fillTarget.id], 'optionalAccess', _227 => _227.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _228 => _228.doc, 'access', _229 => _229.liveStrokes, 'optionalAccess', _230 => _230[fillTarget.id]])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a stroke layer (its pixels are drawn from its strokes); fill another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
     this.dryLayersFirst([_nullishCoalesce(_nullishCoalesce(options.layerId, () => ( this.doc.activeLayerId)), () => ( ""))]);
     const l = this.paintTarget(options.layerId, "fill");
     const color = options.color === void 0 ? this.color : parseColor(options.color);
@@ -4110,7 +4201,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const tiles = new Map(base.tiles);
     for (const { tx, ty } of _chunk474IQG74cjs.tilesInRect.call(void 0, { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height })) {
       const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
-      const src = _nullishCoalesce(_optionalChain([base, 'access', _216 => _216.tiles, 'access', _217 => _217.get, 'call', _218 => _218(key), 'optionalAccess', _219 => _219.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _231 => _231.tiles, 'access', _232 => _232.get, 'call', _233 => _233(key), 'optionalAccess', _234 => _234.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
       const tile = _chunk474IQG74cjs.finishTile.call(void 0, _chunkPQ3H2AANcjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
       if (tile) tiles.set(key, tile);
       else tiles.delete(key);
@@ -4143,7 +4234,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The effect a layer is drawn from, or `undefined` for other layers. */
   getEffectLayer(layerId) {
-    return _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _220 => _220.doc, 'access', _221 => _221.effectLayers, 'optionalAccess', _222 => _222[layerId]]) : void 0;
+    return _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _235 => _235.doc, 'access', _236 => _236.effectLayers, 'optionalAccess', _237 => _237[layerId]]) : void 0;
   }
   /** The effect paper (without its pixels), or `null`. */
   getPaperEffect() {
@@ -4180,7 +4271,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   /** A pixel layer that takes effect pixels: unlocked, visible, no sticker layer, no wet paint. */
   effectTarget(layerId, what) {
     const l = this.paintTarget(layerId, what);
-    if (_optionalChain([this, 'access', _223 => _223.doc, 'access', _224 => _224.stickers, 'optionalAccess', _225 => _225[l.id], 'optionalAccess', _226 => _226.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _238 => _238.doc, 'access', _239 => _239.stickers, 'optionalAccess', _240 => _240[l.id], 'optionalAccess', _241 => _241.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _242 => _242.doc, 'access', _243 => _243.liveStrokes, 'optionalAccess', _244 => _244[l.id]])) throw new PaintEditorError(`Layer "${l.name}" is a stroke layer (its pixels are drawn from its strokes); ${what} another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
     if (this.wet.wetLayerIds().includes(l.id)) throw new PaintEditorError(`Layer "${l.name}" holds wet paint; effects go on dried paint, so dry it first (dry_paint) and try again.`);
     return l;
   }
@@ -4219,8 +4311,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const was = this.doc.paperEffect;
     const paperEffect = {
       ...this.sourceOf(d, values, options.time),
-      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _227 => _227.opacity]))), () => ( 1)),
-      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _228 => _228.blend]))), () => ( "multiply")),
+      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _245 => _245.opacity]))), () => ( 1)),
+      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _246 => _246.blend]))), () => ( "multiply")),
       image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) },
       version: nextPaperEffectVersion()
     };
@@ -4273,8 +4365,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const above = _nullishCoalesce(options.aboveId, () => ( this.doc.activeLayerId));
     const loc = above ? _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, above) : null;
     if (options.aboveId !== void 0 && !loc) throw new PaintEditorError(`Layer "${options.aboveId}" was removed while the effect rendered.`);
-    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _229 => _229.name, 'optionalAccess', _230 => _230.trim, 'call', _231 => _231()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
-    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _232 => _232.parent, 'optionalAccess', _233 => _233.id]), () => ( null)), loc ? loc.index + 1 : void 0);
+    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _247 => _247.name, 'optionalAccess', _248 => _248.trim, 'call', _249 => _249()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
+    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _250 => _250.parent, 'optionalAccess', _251 => _251.id]), () => ( null)), loc ? loc.index + 1 : void 0);
     const source = this.sourceOf(d, values, options.time);
     this.commit("Add effect layer", { ...this.doc, layers, activeLayerId: layer.id, effectLayers: { ..._nullishCoalesce(this.doc.effectLayers, () => ( {})), [layer.id]: source } });
     return { layer: this.describeLayer(layer), source };
@@ -4344,16 +4436,25 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * size, and brushes then take each pixel's colour (and alpha) from it, fixed to the canvas, as if
    * painting a hidden picture into view. `setColor` and `setPaint` go back to colour. Editor state,
    * not an undo step. Strokes that would paint with it throw while it renders. Returns the paint.
+   * With `map: { by: 'stroke' }` the effect lies along each stroke instead of the canvas; with
+   * `live`, strokes on a stroke layer keep playing it (see `setEffectPlayback`).
    */
   async setEffectPaint(source) {
     if (!source || typeof source.effect !== "string" || !source.effect) throw new PaintEditorError("effect is missing; pass an effect id from search_effects (use generator, overlay or title).");
     this.checkTime(source.time);
+    let map;
+    try {
+      map = _chunk5BR7LC24cjs.readEffectStrokeMap.call(void 0, source.map);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    if (source.live !== void 0 && typeof source.live !== "boolean") throw new PaintEditorError("live must be true or false.");
     const epoch = ++this.paintEpoch;
     const changed = (name) => new PaintEditorError(`The paint changed while "${name}" rendered (set_color, set_paint or another set_effect_paint); call set_effect_paint again to paint with it.`);
     const d = await this.describeEffect(source.effect, "paint");
     const values = this.effectValues(d, { ...d.defaults }, source.values);
     if (epoch !== this.paintEpoch) throw changed(d.name);
-    const paint = { type: "effect", effect: d.id, provider: this.effects.require().id, values, time: _nullishCoalesce(source.time, () => ( 0)) };
+    const paint = { type: "effect", effect: d.id, provider: this.effects.require().id, values, time: _nullishCoalesce(source.time, () => ( 0)), ...map ? { map } : {}, ...source.live ? { live: true } : {} };
     this.effectPaintPending = paint;
     this.emit([]);
     try {
@@ -4374,9 +4475,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The rendered pixels of an effect paint at the current canvas size, or `null` when it has not been rendered. */
   effectPaintImage(p) {
-    const key = _chunkNKTNLJUJcjs.effectPaintKey.call(void 0, p);
+    const key = _chunk5BR7LC24cjs.effectPaintKey.call(void 0, p);
     const img = this.effectPaintPixels.get(key);
-    if (!img || img.width !== this.doc.canvas.width || img.height !== this.doc.canvas.height) return null;
+    const size = _chunk5BR7LC24cjs.effectPaintSize.call(void 0, p, this.doc.canvas);
+    if (!img || img.width !== size.width || img.height !== size.height) return null;
     this.effectPaintPixels.delete(key);
     this.effectPaintPixels.set(key, img);
     return img;
@@ -4389,15 +4491,15 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const what = `the effect "${p.effect}"${p.provider ? ` from provider "${p.provider}"` : ""}`;
     if (!provider) throw new PaintEditorError(`Effect paint needs ${what}, but no effects provider is registered; register it (setEffectsProvider) and try again.`);
     if (p.provider && provider.id !== p.provider) throw new PaintEditorError(`Effect paint needs ${what}, but the registered provider is "${provider.id}"; register "${p.provider}" (setEffectsProvider) and try again.`);
-    const { width, height } = this.doc.canvas;
+    const { width, height } = _chunk5BR7LC24cjs.effectPaintSize.call(void 0, p, this.doc.canvas);
     let pixels;
     try {
       pixels = await this.effectsRenderer.render(provider, p.effect, { width, height }, { time: p.time, values: p.values });
     } catch (e) {
       throw new PaintEditorError(`Effect paint could not render ${what}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    const img = { width, height, data: new Uint8ClampedArray(pixels.data) };
-    this.effectPaintPixels.set(_chunkNKTNLJUJcjs.effectPaintKey.call(void 0, p), img);
+    const img = { width, height, data: new Uint8ClampedArray(pixels.data), ...p.map ? { map: p.map } : {} };
+    this.effectPaintPixels.set(_chunk5BR7LC24cjs.effectPaintKey.call(void 0, p), img);
     while (this.effectPaintPixels.size > _PaintEditorController.EFFECT_PAINT_CACHE) this.effectPaintPixels.delete(this.effectPaintPixels.keys().next().value);
     return img;
   }
@@ -4408,7 +4510,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   async prepareEffectPaints(paints) {
     const seen = /* @__PURE__ */ new Set();
     for (const p of paints) {
-      const key = _chunkNKTNLJUJcjs.effectPaintKey.call(void 0, p);
+      const key = _chunk5BR7LC24cjs.effectPaintKey.call(void 0, p);
       if (seen.has(key)) continue;
       seen.add(key);
       await this.renderEffectPaint(p);
@@ -4417,7 +4519,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   /** Renders the effect paints of recorded strokes (default all of them) before a replay. */
   async prepareStrokeEffects(strokeIds) {
     const ids = strokeIds ? new Set(strokeIds) : null;
-    const paints = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _234 => _234.paint, 'optionalAccess', _235 => _235.type]) === "effect").map((s) => s.paint);
+    const paints = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _252 => _252.paint, 'optionalAccess', _253 => _253.type]) === "effect").map((s) => s.paint);
     await this.prepareEffectPaints(paints);
   }
   /** A small preview of the effect paint (a PNG data URL `size` px wide), or `null` without a rendered one. */
@@ -4446,22 +4548,17 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * its pixels are not rendered.
    */
   strokeEffect(init, brush) {
-    if (!_chunkNKTNLJUJcjs.brushTakesPaint.call(void 0, brush)) return null;
+    if (!_chunk5BR7LC24cjs.brushTakesPaint.call(void 0, brush)) return null;
     let source = null;
     if (init.paint !== void 0) {
-      if (!_chunkNKTNLJUJcjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
-      source = _chunkNKTNLJUJcjs.readPaintEffectPaint.call(void 0, init.paint);
+      if (!_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
+      source = _chunk5BR7LC24cjs.readPaintEffectPaint.call(void 0, init.paint);
       if (!source) throw new PaintEditorError("The stroke's effect paint needs an effect id and values (getEffectPaint returns one).");
     } else if (init.color === void 0 && !brush.paint) {
       if (this.effectPaintPending) throw new PaintEditorError(`The effect paint "${this.effectPaintPending.effect}" is still rendering; wait for set_effect_paint to finish, then paint.`);
       source = this.effectPaint;
     }
     if (!source) return null;
-    if (brush.engine === "wet" || brush.engine === "impasto" || brush.engine === "sticker") {
-      throw new PaintEditorError(
-        `The ${brush.name} brush (${brush.engine} engine) cannot paint with effect paint: it carries one colour as ${brush.engine === "sticker" ? "stickers" : brush.engine === "wet" ? "wet pigment" : "thick paint"}. Paint with a dry brush (a dab, particle, bristle or mixer brush), or paint the shape first and fill it with fill_layer_with_effect {lockTransparency: true}.`
-      );
-    }
     const pixels = this.effectPaintImage(source);
     if (!pixels) throw new PaintEditorError(`The effect paint "${source.effect}"${source.provider ? ` from provider "${source.provider}"` : ""} is not rendered at this canvas size; call set_effect_paint (or prepareEffectPaints) first.`);
     return { source, pixels };
@@ -4485,14 +4582,14 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const before = _chunk474IQG74cjs.readRegion.call(void 0, l.surface, rect);
     const inputs = { source: { width: rect.width, height: rect.height, data: before } };
     const heightInput = d.inputs.find((i) => i.kind === "image" && /^(height|depth|relief)$/i.test(i.name));
-    const relief = _optionalChain([this, 'access', _236 => _236.doc, 'access', _237 => _237.thick, 'optionalAccess', _238 => _238[l.id]]);
+    const relief = _optionalChain([this, 'access', _254 => _254.doc, 'access', _255 => _255.thick, 'optionalAccess', _256 => _256[l.id]]);
     if (heightInput && relief) {
       const h = _chunk474IQG74cjs.readRegion.call(void 0, relief.height, rect);
       const rgba = new Uint8ClampedArray(rect.width * rect.height * 4);
       for (let i = 0; i < h.length; i++) rgba.set([h[i], h[i], h[i], 255], i * 4);
       inputs[heightInput.name] = { width: rect.width, height: rect.height, data: rgba };
     }
-    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _239 => _239.inputs, 'access', _240 => _240.find, 'call', _241 => _241((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _242 => _242.name])), 'optionalAccess', _243 => _243.name]), () => ( "source"));
+    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _257 => _257.inputs, 'access', _258 => _258.find, 'call', _259 => _259((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _260 => _260.name])), 'optionalAccess', _261 => _261.name]), () => ( "source"));
     if (sourceInput !== "source") {
       inputs[sourceInput] = inputs.source;
       delete inputs.source;
@@ -4505,12 +4602,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   // --- Brushes -------------------------------------------------------------------
   findBrush(id) {
-    return _nullishCoalesce(_chunkNKTNLJUJcjs.BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
+    return _nullishCoalesce(_chunk5BR7LC24cjs.BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
   }
   /** A library brush by id (`undefined` when unknown). */
   getBrush(id) {
     const b = this.findBrush(id);
-    return b ? _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, b, b) : void 0;
+    return b ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, b, b) : void 0;
   }
   requireBrush(id) {
     const b = this.findBrush(id);
@@ -4525,7 +4622,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const { id, ...changes } = update;
     const base = id !== void 0 ? this.requireBrush(id) : this.brush;
     if (changes.paint !== void 0 && changes.paint !== null) this.readStrokePaint(changes.paint);
-    const next = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
+    const next = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
     if (base.builtin && !Object.keys(changes).length) next.builtin = true;
     else delete next.builtin;
     this.brush = next;
@@ -4534,10 +4631,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
   saveBrush(options) {
-    if (!_chunkNKTNLJUJcjs.BRUSH_ID.test(options.id)) throw new PaintEditorError(`Brush id "${options.id}" is invalid; use lowercase letters, digits and dashes (e.g. "my-pencil").`);
-    if (_chunkNKTNLJUJcjs.BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
-    const source = options.brush ? _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, options.brush, this.brush) : this.brush;
-    const saved = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { ...source, id: options.id, name: _nullishCoalesce(options.name, () => ( source.name)) });
+    if (!_chunk5BR7LC24cjs.BRUSH_ID.test(options.id)) throw new PaintEditorError(`Brush id "${options.id}" is invalid; use lowercase letters, digits and dashes (e.g. "my-pencil").`);
+    if (_chunk5BR7LC24cjs.BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
+    const source = options.brush ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, options.brush, this.brush) : this.brush;
+    const saved = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...source, id: options.id, name: _nullishCoalesce(options.name, () => ( source.name)) });
     delete saved.builtin;
     const i = this.userBrushes.findIndex((b) => b.id === options.id);
     if (i >= 0) this.userBrushes[i] = saved;
@@ -4547,7 +4644,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return saved;
   }
   removeBrush(id) {
-    if (_chunkNKTNLJUJcjs.BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
+    if (_chunk5BR7LC24cjs.BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
     const i = this.userBrushes.findIndex((b) => b.id === id);
     if (i < 0) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
     this.userBrushes.splice(i, 1);
@@ -4556,12 +4653,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The user's saved brushes. */
   getUserBrushes() {
-    return this.userBrushes.map((b) => _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, b, b));
+    return this.userBrushes.map((b) => _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, b, b));
   }
   /** A brush library file of the given brushes (default: the user's brushes). */
   exportBrushes(ids) {
     const list = ids ? ids.map((id) => this.requireBrush(id)) : this.userBrushes;
-    return { format: "pixerate-brushes", version: 1, brushes: list.map(_chunkNKTNLJUJcjs.brushToJSON) };
+    return { format: "pixerate-brushes", version: 1, brushes: list.map(_chunk5BR7LC24cjs.brushToJSON) };
   }
   /**
    * Adds the brushes of a library file to the user library. A brush whose id is taken is skipped
@@ -4571,14 +4668,14 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const problems = [];
     let list;
     try {
-      list = _chunkNKTNLJUJcjs.parseBrushLibrary.call(void 0, file, problems);
+      list = _chunk5BR7LC24cjs.parseBrushLibrary.call(void 0, file, problems);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
     const added = [];
     const skipped = [];
     for (const b of list) {
-      if (_chunkNKTNLJUJcjs.BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
+      if (_chunk5BR7LC24cjs.BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
         skipped.push(b.id);
         problems.push(`"${b.id}" is a built-in brush id; rename it to import it.`);
         continue;
@@ -4643,10 +4740,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * brush's gradient, else the editor's gradient paint. Erasers, blenders and smudges take none.
    */
   strokeGradient(init, brush, color) {
-    if (!_chunkNKTNLJUJcjs.brushTakesPaint.call(void 0, brush)) return null;
+    if (!_chunk5BR7LC24cjs.brushTakesPaint.call(void 0, brush)) return null;
     let g = null;
     if (init.paint !== void 0) {
-      if (_chunkNKTNLJUJcjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
+      if (_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
       const p = this.readStrokePaint(init.paint);
       g = p.type === "gradient" ? p : null;
     } else g = _nullishCoalesce(brush.paint, () => ( (init.color === void 0 ? this.gradient : null)));
@@ -4690,7 +4787,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   // --- Mixer Brush ---------------------------------------------------------------
   /** Fills the Mixer Brush reservoir with a colour (default the editor colour). */
   loadMixerBrush(color) {
-    const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, color === void 0 ? this.color : parseColor(color));
+    const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color === void 0 ? this.color : parseColor(color));
     this.mixerLoad = _chunkPQ3H2AANcjs.loadMixer.call(void 0, this.mixerLoad, [r / 255, g / 255, b / 255]);
     this.emit([]);
     return this.mixerLoad;
@@ -4720,7 +4817,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   // --- Strokes -------------------------------------------------------------------
   strokeBrush(init) {
     let brush = init.brushId !== void 0 ? this.requireBrush(init.brushId) : this.brush;
-    if (init.brush) brush = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { ...init.brush, id: brush.id }, brush);
+    if (init.brush) brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...init.brush, id: brush.id }, brush);
     return brush;
   }
   /**
@@ -4736,7 +4833,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return symmetryCopies(this.guides.symmetry);
   }
   sessionFor(doc, init, host) {
-    if (init.paint !== void 0 && !_chunkNKTNLJUJcjs.isPaintEffectPaint.call(void 0, init.paint)) {
+    if (init.paint !== void 0 && !_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, init.paint)) {
       const p = this.readStrokePaint(init.paint);
       if (p.type === "color") init = { ...init, color: p.color, paint: void 0 };
       else init = { ...init, paint: p };
@@ -4754,14 +4851,25 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     })();
     const brush = this.strokeBrush(init);
     const effect = this.strokeEffect(init, brush);
-    const stickerLayer = Boolean(_optionalChain([doc, 'access', _244 => _244.stickers, 'optionalAccess', _245 => _245[layer.id], 'optionalAccess', _246 => _246.length]));
+    if (_optionalChain([doc, 'access', _262 => _262.liveStrokes, 'optionalAccess', _263 => _263[layer.id]])) {
+      const why = liveStrokeRefusal(brush);
+      if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
+    }
+    if (_optionalChain([doc, 'access', _264 => _264.liveStrokes, 'optionalAccess', _265 => _265[layer.id]]) && _optionalChain([effect, 'optionalAccess', _266 => _266.source, 'access', _267 => _267.live])) {
+      const key = _chunk5BR7LC24cjs.effectPaintKey.call(void 0, effect.source);
+      const { sources } = this.liveEffects(doc);
+      if (!sources.some((p) => _chunk5BR7LC24cjs.effectPaintKey.call(void 0, p) === key) && sources.length >= MAX_LIVE_EFFECT_SOURCES) {
+        throw new PaintEditorError(`The painting already plays ${MAX_LIVE_EFFECT_SOURCES} live effects, the most it can; paint with one of them, or set_effect_paint with live false to bake this one.`);
+      }
+    }
+    const stickerLayer = Boolean(_optionalChain([doc, 'access', _268 => _268.stickers, 'optionalAccess', _269 => _269[layer.id], 'optionalAccess', _270 => _270.length]));
     if (brush.engine === "sticker") {
       if (!stickerLayer && _chunk474IQG74cjs.contentBounds.call(void 0, layer.surface)) throw new PaintEditorError(`Layer "${layer.name}" already has paint; spray stickers onto an empty layer (add_layer) so they stay editable.`);
     } else if (stickerLayer) {
       throw new PaintEditorError(`Layer "${layer.name}" is a sticker layer (its pixels are drawn from its stickers); paint on another layer (add_layer).`);
     }
     let wet;
-    if (_chunkNKTNLJUJcjs.isWetBrush.call(void 0, brush)) {
+    if (_chunk5BR7LC24cjs.isWetBrush.call(void 0, brush)) {
       this.requireWetIdle("painting");
       if (layer.offset.x || layer.offset.y) {
         const moved = { ...layer, surface: _chunk474IQG74cjs.translateSurface.call(void 0, layer.surface, layer.offset.x, layer.offset.y), offset: { x: 0, y: 0 } };
@@ -4776,7 +4884,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       const world = this.wet.ensureLane(layer.id, brush.wet.medium);
       const id = layer.id;
       const wetColor = init.color === void 0 ? this.color : parseColor(init.color);
-      const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, wetColor);
+      const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, wetColor);
       const wetGradient = this.strokeGradient(init, brush, wetColor);
       const load = _nullishCoalesce(init.load, () => ( brushLoadForStroke(brush, this.mixerLoad, [r / 255, g / 255, b / 255])));
       const seedW = _nullishCoalesce(init.seed, () => ( _chunkPQ3H2AANcjs.mix32.call(void 0, this.seedCounter * 2654435761 >>> 0) & 2147483647));
@@ -4789,11 +4897,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         load,
         grain: paperGrain(doc.paper),
         paperDepth: doc.paper.depth,
-        paperColor: _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, doc.paper.color),
+        paperColor: _chunk5BR7LC24cjs.hexToRgb8.call(void 0, doc.paper.color),
         seed: seedW,
         copies: [IDENTITY_AFFINE, ...copiesW].map(affineCopy),
         mask: init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null,
-        paint: wetGradient
+        paint: effect ? null : wetGradient,
+        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _271 => _271.pixels]), () => ( null))
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
@@ -4804,7 +4913,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     let color = init.color === void 0 ? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
-    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _247 => _247.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _272 => _272.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
     const perspective = this.guides.perspective;
     const snapper = init.snapToPerspective && perspective.enabled && perspective.snap ? new PerspectiveSnapper(perspective) : null;
     const useStencils = init.stencils !== false;
@@ -4837,7 +4946,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       mixerLoad: _nullishCoalesce(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: _nullishCoalesce(_optionalChain([doc, 'access', _248 => _248.thick, 'optionalAccess', _249 => _249[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _273 => _273.thick, 'optionalAccess', _274 => _274[layer.id]]), () => ( emptyThickChannels())) } : void 0,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc) } : void 0,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
@@ -4851,7 +4960,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const stroke = {
       id: `s${this.strokeCounter++}`,
       layerId: session.layerId,
-      brush: _chunkNKTNLJUJcjs.brushToJSON.call(void 0, init.brush),
+      brush: _chunk5BR7LC24cjs.brushToJSON.call(void 0, init.brush),
       color: init.colorHex,
       points: session.points.map((p) => ({ ...p })),
       seed: init.seed
@@ -4876,12 +4985,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
-        if (_optionalChain([this, 'access', _250 => _250.session, 'optionalAccess', _251 => _251.init, 'access', _252 => _252.wet])) {
+        if (_optionalChain([this, 'access', _275 => _275.session, 'optionalAccess', _276 => _276.init, 'access', _277 => _277.wet])) {
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
-        const ch = _optionalChain([this, 'access', _253 => _253.session, 'optionalAccess', _254 => _254.thickChannels, 'call', _255 => _255()]);
+        const ch = _optionalChain([this, 'access', _278 => _278.session, 'optionalAccess', _279 => _279.thickChannels, 'call', _280 => _280()]);
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
@@ -4893,7 +5002,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         const wetStroke = Boolean(s.init.wet);
         if (wetStroke) this.wet.driver = null;
         const brush = s.init.brush;
-        if (!cancelled && _optionalChain([s, 'access', _256 => _256.result, 'optionalAccess', _257 => _257.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
+        if (!cancelled && _optionalChain([s, 'access', _281 => _281.result, 'optionalAccess', _282 => _282.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           if (this.wetOp) {
             const snap = this.wetOp.before;
@@ -4908,6 +5017,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         }
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _283 => _283.result, 'optionalAccess', _284 => _284.bounds]), () => ( null)));
         if (wetStroke && this.wet.instantDry) {
           this.wet.dry(s.layerId);
           this.logWet({ kind: "dry", layerId: s.layerId, at: this.doc.strokes.length + 1 });
@@ -4918,8 +5028,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         const ch = s.thickChannels();
         const thick = ch ? { ..._nullishCoalesce(this.doc.thick, () => ( {})), [l.id]: ch } : this.doc.thick;
         const sprayed = s.stickers();
-        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _258 => _258.doc, 'access', _259 => _259.stickers, 'optionalAccess', _260 => _260[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
-        this.commit(`${brush.name} stroke`, this.withWetEvents({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {} }), wetStroke ? before : this.doc);
+        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _285 => _285.doc, 'access', _286 => _286.stickers, 'optionalAccess', _287 => _287[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
+        this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {} }, stroke)), wetStroke ? before : this.doc);
       }
     };
     let session;
@@ -4947,17 +5057,18 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         if (cancelled || !surface) return;
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _288 => _288.result, 'optionalAccess', _289 => _289.bounds]), () => ( null)));
         const l = _chunkHB4ICNNAcjs.findLayer.call(void 0, out.layers, s.layerId).layer;
         const offset = s.init.wet ? { x: 0, y: 0 } : l.offset;
         const ch = s.thickChannels();
         const sprayed = s.stickers();
-        out = {
+        out = withLiveStroke({
           ...out,
           layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, out.layers, l.id, () => ({ ...l, surface, offset })),
           strokes: [...out.strokes, stroke],
           ...ch ? { thick: { ..._nullishCoalesce(out.thick, () => ( {})), [l.id]: ch } } : {},
-          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _261 => _261.stickers, 'optionalAccess', _262 => _262[l.id]]), () => ( [])), ...sprayed] } } : {}
-        };
+          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _290 => _290.stickers, 'optionalAccess', _291 => _291[l.id]]), () => ( [])), ...sprayed] } } : {}
+        }, stroke);
       }
     };
     const session = this.sessionFor(doc, init, host);
@@ -5014,7 +5125,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _263 => _263.strokeIds, 'optionalAccess', _264 => _264.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _292 => _292.strokeIds, 'optionalAccess', _293 => _293.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
     const strokes = options.strokeIds.map((id) => {
       const s = this.doc.strokes.find((x) => x.id === id);
       if (!s) throw new PaintEditorError(`Unknown stroke "${id}". Call list_strokes for the ids.`);
@@ -5028,7 +5139,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (options.layerId !== void 0) this.paintTarget(options.layerId, "replay onto");
     if (options.color === void 0) {
       for (const s of strokes) {
-        if (_optionalChain([s, 'access', _265 => _265.paint, 'optionalAccess', _266 => _266.type]) === "effect" && !this.effectPaintImage(s.paint)) {
+        if (_optionalChain([s, 'access', _294 => _294.paint, 'optionalAccess', _295 => _295.type]) === "effect" && !this.effectPaintImage(s.paint)) {
           throw new PaintEditorError(`Stroke "${s.id}" paints with the effect "${s.paint.effect}"${s.paint.provider ? ` from provider "${s.paint.provider}"` : ""}, which is not rendered in this editor; render it first (prepareStrokeEffects; the replay_strokes tool does this) or recolour the replay with color.`);
         }
       }
@@ -5051,13 +5162,13 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         let brush = v.brush;
         if (options.brushId !== void 0) {
           const b = this.requireBrush(options.brushId);
-          brush = _chunkNKTNLJUJcjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
+          brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
         }
         const layerId = _nullishCoalesce(options.layerId, () => ( s.layerId));
         if (!_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, layerId)) throw new PaintEditorError(`Stroke "${s.id}" was painted on layer "${layerId}", which no longer exists; pass layerId to replay it elsewhere.`);
         let load = s.load;
         if (load && options.color !== void 0 && load.reservoir) {
-          const [r, g, b] = _chunkNKTNLJUJcjs.hexToRgb8.call(void 0, options.color);
+          const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, options.color);
           load = { ...load, reservoir: [r / 255, g / 255, b / 255] };
         }
         const paint = v.paint && options.color === void 0 ? { paint: v.paint } : {};
@@ -5097,7 +5208,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const ch = _optionalChain([this, 'access', _267 => _267.doc, 'access', _268 => _268.thick, 'optionalAccess', _269 => _269[id]]);
+    const ch = _optionalChain([this, 'access', _296 => _296.doc, 'access', _297 => _297.thick, 'optionalAccess', _298 => _298[id]]);
     if (!ch) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
@@ -5205,7 +5316,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   wetState() {
     const st = this.getState().wet;
     const backend = this.wet.backend();
-    return { ...st, layers: this.wet.wetLayerIds().map((id) => this.wet.info(id)), backend, message: _nullishCoalesce(_optionalChain([backend, 'optionalAccess', _270 => _270.message]), () => ( _chunkXFYLA3ZOcjs.wetSupport.call(void 0, ).message)), engine: this.wet.engineInfo() };
+    return { ...st, layers: this.wet.wetLayerIds().map((id) => this.wet.info(id)), backend, message: _nullishCoalesce(_optionalChain([backend, 'optionalAccess', _299 => _299.message]), () => ( _chunkXFYLA3ZOcjs.wetSupport.call(void 0, ).message)), engine: this.wet.engineInfo() };
   }
   /**
    * Engine B, the WebGPU accelerator for large wet areas: whether it may run, its state (`off`,
@@ -5290,7 +5401,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** Records a settings change as a wet event (not an undo step). */
   recordWetSetting(e) {
-    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _271 => _271.wet, 'access', _272 => _272.world, 'optionalAccess', _273 => _273.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
+    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _300 => _300.wet, 'access', _301 => _301.world, 'optionalAccess', _302 => _302.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
   }
   /** Changes a layer's wet settings (viscosity, evaporation, granulation…). Editor settings saved with the document, not an undo step. */
   setWetParams(layerId, update) {
@@ -5355,9 +5466,11 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The layers with the live stroke's surface in place. */
   currentLayers() {
+    const override = this.frameOverride;
+    if (override) return Array.from(override).reduce((ls, [id, surface]) => _chunkHB4ICNNAcjs.mapLayer.call(void 0, ls, id, (l) => ({ ...l, surface })), this.doc.layers);
     const live = this.live;
-    if (!live) return this.doc.layers;
-    if (_optionalChain([this, 'access', _274 => _274.liveLayers, 'optionalAccess', _275 => _275.key]) === live.surface) return this.liveLayers.layers;
+    if (!live) return this.animatedView();
+    if (_optionalChain([this, 'access', _303 => _303.liveLayers, 'optionalAccess', _304 => _304.key]) === live.surface) return this.liveLayers.layers;
     const layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
@@ -5380,7 +5493,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   tracingNode(t) {
     const { width, height } = this.doc.canvas;
     const key = this.tracingVersion * 100003 + width * 7 + height;
-    if (_optionalChain([this, 'access', _276 => _276.tracingCache, 'optionalAccess', _277 => _277.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _305 => _305.tracingCache, 'optionalAccess', _306 => _306.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
     const src = _nullishCoalesce(this.imagePixels.get(t.src), () => ( this.decodeImage(t.src)));
     const image = resampleInto(src, t.rect, width, height);
     const node = { type: "image", id: TRACING_NODE_ID, name: "Tracing", visible: true, opacity: t.opacity, blend: "normal", image, version: key + Math.round(t.opacity * 1e3) / 1e4 };
@@ -5407,8 +5520,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     let out = layers;
     const ids = /* @__PURE__ */ new Set([...Object.keys(_nullishCoalesce(thick, () => ( {}))), ...live ? [live.layerId] : []]);
     for (const id of ids) {
-      const ch = _optionalChain([live, 'optionalAccess', _278 => _278.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _279 => _279[id]]);
-      const l = ch && _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, out, id), 'optionalAccess', _280 => _280.layer]);
+      const ch = _optionalChain([live, 'optionalAccess', _307 => _307.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _308 => _308[id]]);
+      const l = ch && _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, out, id), 'optionalAccess', _309 => _309.layer]);
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
@@ -5421,7 +5534,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     let layers = this.litLayers((_nullishCoalesce(options.wet, () => ( "display"))) === "dried" ? this.driedLayers() : this.currentLayers());
     if (options.layerIds) {
       const picked = [];
-      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _281 => _281.layer]), () => ( this.requireLayer(id))));
+      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _310 => _310.layer]), () => ( this.requireLayer(id))));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
     const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
@@ -5437,7 +5550,7 @@ var PaintEditorController = (_class10 = 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: _nullishCoalesce(_optionalChain([this, 'access', _282 => _282.live, 'optionalAccess', _283 => _283.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _311 => _311.live, 'optionalAccess', _312 => _312.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -5501,7 +5614,11 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     for (const [id, list] of Object.entries(_nullishCoalesce(this.doc.stickers, () => ( {})))) if (list.length && _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id)) stickers[id] = list.map((x) => ({ ...x }));
     if (Object.keys(stickers).length) ext.stickers = stickers;
     else delete ext.stickers;
-    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _284 => _284.layer])));
+    const liveStrokes = {};
+    for (const [id, list] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) if (_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id)) liveStrokes[id] = list.map((x) => JSON.parse(JSON.stringify(x)));
+    if (Object.keys(liveStrokes).length) ext.liveStrokes = liveStrokes;
+    else delete ext.liveStrokes;
+    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _313 => _313.layer])));
     if (effectLayers) ext.effectLayers = effectLayers;
     else delete ext.effectLayers;
     if (this.doc.paperEffect) ext.paperEffect = paperEffectToJSON(this.doc.paperEffect);
@@ -5518,16 +5635,26 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       const stickers = {};
       for (const [id, list] of Object.entries(ext.stickers)) {
         if (!_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id) || !Array.isArray(list)) continue;
-        const ok = list.filter((x) => x && typeof x.id === "string" && _chunkNKTNLJUJcjs.STAMP_KINDS.includes(x.stamp) && Number.isFinite(x.x) && Number.isFinite(x.y) && x.size > 0);
+        const ok = list.filter((x) => x && typeof x.id === "string" && _chunk5BR7LC24cjs.STAMP_KINDS.includes(x.stamp) && Number.isFinite(x.x) && Number.isFinite(x.y) && x.size > 0);
         if (ok.length !== list.length) problems.push(`Some stickers of layer "${id}" could not be read; they were dropped.`);
         stickers[id] = ok.map((x) => ({ ...x }));
       }
       if (Object.keys(stickers).length) state = { ...state, stickers };
     }
+    if (ext.liveStrokes && typeof ext.liveStrokes === "object") {
+      const liveStrokes = {};
+      for (const [id, list] of Object.entries(ext.liveStrokes)) {
+        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _314 => _314.layer])) || !Array.isArray(list)) continue;
+        const ok = list.map(normalizeBrushStroke).filter((x) => x !== null).map((x) => ({ ...x, layerId: id }));
+        if (ok.length !== list.length) problems.push(`Some strokes of stroke layer "${id}" could not be read; they were dropped (the layer's pixels are kept until a stroke is edited).`);
+        liveStrokes[id] = ok;
+      }
+      if (Object.keys(liveStrokes).length) state = { ...state, liveStrokes };
+    }
     if (ext.effectLayers && typeof ext.effectLayers === "object") {
       const effectLayers = {};
       for (const [id, v] of Object.entries(ext.effectLayers)) {
-        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _285 => _285.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _315 => _315.layer]))) continue;
         const source = readPaintEffectSource(v);
         if (source) effectLayers[id] = source;
         else problems.push(`The effect of layer "${id}" could not be read; it loads as a plain layer.`);
@@ -5568,16 +5695,23 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.readGuides(loaded.guides, loaded.state, loaded.problems);
     if (Array.isArray(loaded.swatches)) this.swatches = loaded.swatches.map(readSwatch).filter((x) => x !== null);
     for (const s of loaded.state.strokes) {
-      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _286 => _286.exec, 'call', _287 => _287(s.id), 'optionalAccess', _288 => _288[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _316 => _316.exec, 'call', _317 => _317(s.id), 'optionalAccess', _318 => _318[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
     this.redoStack = [];
     this.doc = this.readThick(loaded.state, loaded.extensions, loaded.problems);
+    for (const list of Object.values(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
+      for (const s of list) {
+        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _319 => _319.exec, 'call', _320 => _320(s.id), 'optionalAccess', _321 => _321[1]]), () => ( 0)));
+        if (n >= this.strokeCounter) this.strokeCounter = n + 1;
+      }
+    }
     this.docRevision++;
     delete this.extensions.layerChannels;
     delete this.extensions.lighting;
     delete this.extensions.stickers;
+    delete this.extensions.liveStrokes;
     delete this.extensions.effectLayers;
     delete this.extensions.paperEffect;
     this.viewCompositor.clear();
@@ -5660,10 +5794,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunkBBUE3UJLcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkHW72ABGRcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
-      const label = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _289 => _289.find, 'call', _290 => _290((m) => m.id === mode), 'optionalAccess', _291 => _291.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _292 => _292.find, 'call', _293 => _293((m) => m.id === _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _294 => _294.label]), () => ( _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _322 => _322.find, 'call', _323 => _323((m) => m.id === mode), 'optionalAccess', _324 => _324.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _325 => _325.find, 'call', _326 => _326((m) => m.id === _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _327 => _327.label]), () => ( _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)));
       const list = names.map((n) => `"${n}"`).join(", ");
       const one = names.length === 1;
       result.warnings.push(`${label} blending has no PSD equivalent; ${list} ${one ? "was" : "were"} written as ${std}, the nearest Photoshop mode, so ${one ? "it looks" : "they look"} different in Photoshop (the merged image is exact).`);
@@ -5779,7 +5913,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const { src, pixels } = this.importImage(options, "The reference image");
     const ref2 = {
       id: `ref${this.nextReferenceId++}`,
-      name: _optionalChain([options, 'access', _295 => _295.name, 'optionalAccess', _296 => _296.trim, 'call', _297 => _297()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _328 => _328.name, 'optionalAccess', _329 => _329.trim, 'call', _330 => _330()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -5858,7 +5992,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         try {
           const px = this.decodeImage(ref2.src, `Reference "${ref2.name}"`);
           guides.references.push({ id: ref2.id, name: String(_nullishCoalesce(ref2.name, () => ( ref2.id))), src: ref2.src, width: px.width, height: px.height, x: Number(ref2.x) || 0, y: Number(ref2.y) || 0, displayWidth: Number(ref2.displayWidth) || 240, visible: ref2.visible !== false });
-          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _298 => _298.exec, 'call', _299 => _299(ref2.id), 'optionalAccess', _300 => _300[1]]), () => ( 0)));
+          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _331 => _331.exec, 'call', _332 => _332(ref2.id), 'optionalAccess', _333 => _333[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -5869,7 +6003,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       guides.stencils = [];
       r.stencils.forEach((raw2, i) => {
         try {
-          const id = typeof _optionalChain([raw2, 'optionalAccess', _301 => _301.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
+          const id = typeof _optionalChain([raw2, 'optionalAccess', _334 => _334.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
           guides.stencils.push(normalizeStencil(raw2, id));
           const n = Number(id.slice(7));
           if (n >= this.nextStencilId) this.nextStencilId = n + 1;
@@ -5892,12 +6026,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   /** The next free sticker number (ids `st<n>` are unique across the document). */
   nextStickerNumber(doc = this.doc) {
     let n = 0;
-    for (const list of Object.values(_nullishCoalesce(doc.stickers, () => ( {})))) for (const st of list) n = Math.max(n, Number(_nullishCoalesce(_optionalChain([/^st(\d+)$/, 'access', _302 => _302.exec, 'call', _303 => _303(st.id), 'optionalAccess', _304 => _304[1]]), () => ( 0))));
+    for (const list of Object.values(_nullishCoalesce(doc.stickers, () => ( {})))) for (const st of list) n = Math.max(n, Number(_nullishCoalesce(_optionalChain([/^st(\d+)$/, 'access', _335 => _335.exec, 'call', _336 => _336(st.id), 'optionalAccess', _337 => _337[1]]), () => ( 0))));
     return n + 1;
   }
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
-    const stickers = _optionalChain([this, 'access', _305 => _305.doc, 'access', _306 => _306.stickers, 'optionalAccess', _307 => _307[l.id]]);
+    const stickers = _optionalChain([this, 'access', _338 => _338.doc, 'access', _339 => _339.stickers, 'optionalAccess', _340 => _340[l.id]]);
     if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (list_brushes category sticker).`);
     return { layer: l, stickers };
   }
@@ -5906,7 +6040,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return [];
     this.requireLayer(id);
-    return (_nullishCoalesce(_optionalChain([this, 'access', _308 => _308.doc, 'access', _309 => _309.stickers, 'optionalAccess', _310 => _310[id]]), () => ( []))).map((s) => ({ ...s }));
+    return (_nullishCoalesce(_optionalChain([this, 'access', _341 => _341.doc, 'access', _342 => _342.stickers, 'optionalAccess', _343 => _343[id]]), () => ( []))).map((s) => ({ ...s }));
   }
   /**
    * Replaces a layer's stickers and redraws its pixels from them (one undo step). With `dirty`,
@@ -5922,15 +6056,15 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   redrawStickers(layer, stickers, dirty) {
     const partial = dirty && !layer.offset.x && !layer.offset.y;
-    return partial ? _chunkNKTNLJUJcjs.stickerSurface.call(void 0, stickers, layer.surface, dirty) : _chunkNKTNLJUJcjs.stickerSurface.call(void 0, stickers);
+    return partial ? _chunk5BR7LC24cjs.stickerSurface.call(void 0, stickers, layer.surface, dirty) : _chunk5BR7LC24cjs.stickerSurface.call(void 0, stickers);
   }
   /** The document from before the sticker preview on screen, or `null` when none is (anything else changed the document since). */
   previewBase() {
-    return _optionalChain([this, 'access', _311 => _311.stickerPreview, 'optionalAccess', _312 => _312.shown]) === this.doc ? this.stickerPreview.base : null;
+    return _optionalChain([this, 'access', _344 => _344.stickerPreview, 'optionalAccess', _345 => _345.shown]) === this.doc ? this.stickerPreview.base : null;
   }
   readStickerUpdate(update) {
     try {
-      return _chunkNKTNLJUJcjs.normalizeStickerUpdate.call(void 0, update);
+      return _chunk5BR7LC24cjs.normalizeStickerUpdate.call(void 0, update);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
@@ -5941,7 +6075,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const hit = _chunkNKTNLJUJcjs.stickerAt.call(void 0, _nullishCoalesce(_optionalChain([this, 'access', _313 => _313.doc, 'access', _314 => _314.stickers, 'optionalAccess', _315 => _315[id]]), () => ( [])), x, y);
+    const hit = _chunk5BR7LC24cjs.stickerAt.call(void 0, _nullishCoalesce(_optionalChain([this, 'access', _346 => _346.doc, 'access', _347 => _347.stickers, 'optionalAccess', _348 => _348[id]]), () => ( [])), x, y);
     return hit ? { ...hit } : null;
   }
   /** Picks a sticker for the panel and canvas (`null` for none). Editor state, not an undo step. */
@@ -5962,7 +6096,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (i < 0) throw new PaintEditorError(`Layer "${layer.name}" has no sticker "${id}". Call list_stickers for the ids.`);
     const next = { ...stickers[i], ...this.readStickerUpdate(update) };
     const list = stickers.map((s, j) => j === i ? next : s);
-    const dirty = [_chunkNKTNLJUJcjs.stickerRect.call(void 0, stickers[i]), _chunkNKTNLJUJcjs.stickerRect.call(void 0, next)];
+    const dirty = [_chunk5BR7LC24cjs.stickerRect.call(void 0, stickers[i]), _chunk5BR7LC24cjs.stickerRect.call(void 0, next)];
     const base = _nullishCoalesce(this.previewBase(), () => ( this.doc));
     const surface = this.redrawStickers(layer, list, dirty);
     this.doc = { ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, layer.id, () => ({ ...layer, surface, offset: { x: 0, y: 0 } })), stickers: { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [layer.id]: list } };
@@ -5985,7 +6119,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (i < 0) throw new PaintEditorError(`Layer "${layer.name}" has no sticker "${id}". Call list_stickers for the ids.`);
     const u = this.readStickerUpdate(update);
     const next = { ...stickers[i], ...u };
-    this.commitStickers("Edit sticker", layer, stickers.map((s, j) => j === i ? next : s), [_chunkNKTNLJUJcjs.stickerRect.call(void 0, stickers[i]), _chunkNKTNLJUJcjs.stickerRect.call(void 0, next)]);
+    this.commitStickers("Edit sticker", layer, stickers.map((s, j) => j === i ? next : s), [_chunk5BR7LC24cjs.stickerRect.call(void 0, stickers[i]), _chunk5BR7LC24cjs.stickerRect.call(void 0, next)]);
     return { ...next };
   }
   /**
@@ -5997,8 +6131,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const layer = this.wetLayer(layerId, "add stickers to");
     if (!input.length) throw new PaintEditorError("Pass at least one sticker (stamp, x, y).");
     if (input.length > MAX_ADD_STICKERS) throw new PaintEditorError(`At most ${MAX_ADD_STICKERS} stickers per call; split them over several calls.`);
-    const existing = _optionalChain([this, 'access', _316 => _316.doc, 'access', _317 => _317.stickers, 'optionalAccess', _318 => _318[layer.id]]);
-    if (!_optionalChain([existing, 'optionalAccess', _319 => _319.length])) {
+    const existing = _optionalChain([this, 'access', _349 => _349.doc, 'access', _350 => _350.stickers, 'optionalAccess', _351 => _351[layer.id]]);
+    if (!_optionalChain([existing, 'optionalAccess', _352 => _352.length])) {
       if (this.wet.wetLayerIds().includes(layer.id) || _chunk474IQG74cjs.contentBounds.call(void 0, layer.surface)) throw new PaintEditorError(`Layer "${layer.name}" already has paint; add stickers to an empty layer (add_layer) or a sticker layer so they stay editable.`);
     }
     let n = this.nextStickerNumber();
@@ -6014,7 +6148,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       const id = n++;
       return { id: `st${id}`, size: 48, rotation: 0, color: this.color, opacity: 1, seed: _nullishCoalesce(raw.seed, () => ( _chunkPQ3H2AANcjs.mix32.call(void 0, id * 2654435761 >>> 0) & 2147483647)), ...u };
     });
-    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _320 => _320.length]) ? added.map(_chunkNKTNLJUJcjs.stickerRect) : void 0);
+    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _353 => _353.length]) ? added.map(_chunk5BR7LC24cjs.stickerRect) : void 0);
     return added.map((s) => ({ ...s }));
   }
   /** Brings stickers to the top (`front`) or bottom of their layer (one undo step). */
@@ -6024,7 +6158,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const picked = stickers.filter((s) => ids.includes(s.id));
     const rest = stickers.filter((s) => !ids.includes(s.id));
     const next = to === "front" ? [...rest, ...picked] : [...picked, ...rest];
-    this.commitStickers("Arrange stickers", layer, next, picked.map(_chunkNKTNLJUJcjs.stickerRect));
+    this.commitStickers("Arrange stickers", layer, next, picked.map(_chunk5BR7LC24cjs.stickerRect));
     return next.map((s) => s.id);
   }
   /** Deletes stickers (`ids`, or all of them on the layer) (one undo step). Returns the ids removed. */
@@ -6034,7 +6168,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       for (const id of ids) if (!stickers.some((s) => s.id === id)) throw new PaintEditorError(`Layer "${layer.name}" has no sticker "${id}". Call list_stickers for the ids.`);
     }
     const removed = ids ? [...ids] : stickers.map((s) => s.id);
-    this.commitStickers("Remove stickers", layer, stickers.filter((s) => !removed.includes(s.id)), ids ? stickers.filter((s) => removed.includes(s.id)).map(_chunkNKTNLJUJcjs.stickerRect) : void 0);
+    this.commitStickers("Remove stickers", layer, stickers.filter((s) => !removed.includes(s.id)), ids ? stickers.filter((s) => removed.includes(s.id)).map(_chunk5BR7LC24cjs.stickerRect) : void 0);
     return removed;
   }
   /** Sets a layer's stickers (replays). */
@@ -6042,14 +6176,428 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const l = this.wetLayer(layerId, "set the stickers of");
     this.commitStickers("Stickers", l, stickers.map((s) => ({ ...s })));
   }
+  // --- Live stroke layers ---------------------------------------------------------
+  /** The document's `liveStrokes` without these layers (as a spread: `{}` when unchanged). */
+  liveStrokesWithout(ids) {
+    const t = this.doc.liveStrokes;
+    if (!t || !ids.some((id) => t[id])) return {};
+    const out = { ...t };
+    for (const id of ids) delete out[id];
+    return { liveStrokes: out };
+  }
+  liveStrokeLayer(layerId, what) {
+    const l = this.wetLayer(layerId, what);
+    const strokes = _optionalChain([this, 'access', _354 => _354.doc, 'access', _355 => _355.liveStrokes, 'optionalAccess', _356 => _356[l.id]]);
+    if (!strokes) throw new PaintEditorError(`Layer "${l.name}" is not a stroke layer; add one with add_layer {type: "strokes"} (or convert_to_stroke_layer on an empty layer), then paint on it.`);
+    return { layer: l, strokes };
+  }
+  /** Whether a layer is a live stroke layer. */
+  isLiveStrokeLayer(layerId) {
+    return Boolean(_optionalChain([this, 'access', _357 => _357.doc, 'access', _358 => _358.liveStrokes, 'optionalAccess', _359 => _359[layerId]]));
+  }
+  /** Makes an empty pixel layer a live stroke layer (one undo step). */
+  convertToLiveStrokes(layerId) {
+    this.requireIdle("converting a layer");
+    const l = this.paintTarget(layerId, "convert");
+    if (_optionalChain([this, 'access', _360 => _360.doc, 'access', _361 => _361.liveStrokes, 'optionalAccess', _362 => _362[l.id]])) return this.describeLayer(l);
+    if (_optionalChain([this, 'access', _363 => _363.doc, 'access', _364 => _364.stickers, 'optionalAccess', _365 => _365[l.id], 'optionalAccess', _366 => _366.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
+    if (_chunk474IQG74cjs.contentBounds.call(void 0, l.surface) || this.wet.wetLayerIds().includes(l.id)) throw new PaintEditorError(`Layer "${l.name}" already has paint, which isn't kept as strokes; convert an empty layer or add a stroke layer (add_layer {type: "strokes"}).`);
+    this.commit("Convert to stroke layer", { ...this.doc, liveStrokes: { ..._nullishCoalesce(this.doc.liveStrokes, () => ( {})), [l.id]: [] } });
+    return this.describeLayer(this.getLayer(l.id));
+  }
+  /** A stroke layer's strokes, bottom first. */
+  listLiveStrokes(layerId) {
+    return this.liveStrokeLayer(layerId, "list the strokes of").strokes.map((x) => ({ ...x }));
+  }
+  /** The stroke layer holding a live stroke, and where. */
+  findLiveStroke(id) {
+    for (const [layerId, strokes] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
+      const index = strokes.findIndex((x) => x.id === id);
+      const layer = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _367 => _367.layer]);
+      if (index >= 0 && isPixelLayer(layer)) return { layer, strokes, index };
+    }
+    const baked = this.doc.strokes.some((x) => x.id === id);
+    throw new PaintEditorError(
+      baked ? `Stroke "${id}" was painted on a pixel layer, so its pixels are baked; only strokes on a stroke layer can be edited (list_strokes {live: true}). Replay it onto a stroke layer (replay_strokes layerId) to edit the copy.` : `Unknown stroke "${id}". Call list_strokes {live: true} for the ids of editable strokes.`
+    );
+  }
+  /**
+   * Changes a live stroke's brush (a preset by `brushId`, keeping the stroke's size, and/or brush
+   * settings), colour, paint or seed, and redraws its layer (one undo step). A new colour replaces
+   * gradient or effect paint. Returns the stroke and the area that changed.
+   */
+  updateStroke(id, update) {
+    this.requireIdle("editing a stroke");
+    const { layer, strokes, index } = this.findLiveStroke(id);
+    const was = strokes[index];
+    let brush = was.brush;
+    if (update.brushId !== void 0) {
+      const b = this.requireBrush(update.brushId);
+      brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: was.brush.tip.size } }, b);
+    }
+    if (update.brush !== void 0) {
+      if (!update.brush || typeof update.brush !== "object") throw new PaintEditorError("brush must be an object of brush settings (as set_brush takes).");
+      brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...update.brush, id: brush.id }, brush);
+    }
+    const why = liveStrokeRefusal(brush);
+    if (why) throw new PaintEditorError(why);
+    const next = { ...was, brush: _chunk5BR7LC24cjs.brushToJSON.call(void 0, brush) };
+    if (update.seed !== void 0) {
+      if (!Number.isInteger(update.seed) || update.seed < 0) throw new PaintEditorError(`seed ${update.seed} must be a whole number of 0 or more.`);
+      next.seed = update.seed;
+    }
+    if (update.color !== void 0) {
+      next.color = parseColor(update.color);
+      delete next.paint;
+    }
+    if (update.paint !== void 0) {
+      if (update.paint === null) delete next.paint;
+      else if (_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, update.paint)) {
+        if (!this.effectPaintImage(update.paint)) throw new PaintEditorError(`The effect "${update.paint.effect}" is not rendered yet; render it first (prepareEffectPaints; the update_stroke tool does this).`);
+        next.paint = JSON.parse(JSON.stringify(update.paint));
+      } else {
+        const p = this.readStrokePaint(update.paint);
+        if (p.type === "color") {
+          next.color = p.color;
+          delete next.paint;
+        } else next.paint = JSON.parse(JSON.stringify(p));
+      }
+    }
+    const rgb = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, next.color).map((v) => v / 255);
+    const load = brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, rgb);
+    if (load.reservoir || load.pickup) next.load = load;
+    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: _nullishCoalesce(unionRect(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
+   * the stroke's centre unless an origin is given; the brush size scales too), and redraws its
+   * layer (one undo step). Returns the stroke and the area that changed.
+   */
+  editStrokePoints(id, edit) {
+    this.requireIdle("editing a stroke");
+    if (edit.points === void 0 === (edit.transform === void 0)) throw new PaintEditorError("Pass either points (the new pen samples) or transform (dx, dy, scale, rotate, flipX), not both.");
+    const { layer, strokes, index } = this.findLiveStroke(id);
+    const was = strokes[index];
+    let next;
+    if (edit.points !== void 0) {
+      const points = this.checkPoints(edit.points);
+      next = { ...was, points: points.map((p) => ({ ...p })) };
+    } else {
+      const t = edit.transform;
+      if (t.scale !== void 0 && !(t.scale > 0 && t.scale <= 20)) throw new PaintEditorError(`scale ${t.scale} is out of range; use above 0 up to 20.`);
+      for (const k of ["dx", "dy", "rotate"]) if (t[k] !== void 0 && !Number.isFinite(t[k])) throw new PaintEditorError(`${k} must be a number.`);
+      const b = strokeBounds(was.points);
+      const m = variationAffine(t, _nullishCoalesce(t.origin, () => ( { x: b.x + b.width / 2, y: b.y + b.height / 2 })));
+      next = varyStroke(was, m, {});
+      if (was.stencils) next.stencils = was.stencils;
+    }
+    const list = strokes.map((x, i) => i === index ? next : x);
+    this.commitLiveStrokes("Edit stroke points", layer, list, this.strokeAreas([was]));
+    return { stroke: { ...next }, bounds: _nullishCoalesce(unionRect(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) {
+    this.requireIdle("removing strokes");
+    if (!ids.length) throw new PaintEditorError("Pass at least one stroke id (list_strokes {live: true}).");
+    const found = ids.map((id) => this.findLiveStroke(id));
+    let doc = this.doc;
+    let bounds = null;
+    const layers = /* @__PURE__ */ new Map();
+    for (const f of found) layers.set(f.layer.id, f.layer);
+    for (const [layerId, layer] of layers) {
+      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _368 => _368.liveStrokes, 'optionalAccess', _369 => _369[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
+      for (const x of gone) bounds = unionRect(bounds, this.strokeArea(x));
+      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _370 => _370.liveStrokes, 'optionalAccess', _371 => _371[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
+    }
+    this.commit(ids.length === 1 ? "Remove stroke" : "Remove strokes", doc);
+    return { removed: [...ids], bounds };
+  }
+  /** Moves a live stroke to `index` in its layer (0 = bottom) and redraws (one undo step). Returns the new order. */
+  reorderStroke(id, index) {
+    this.requireIdle("reordering strokes");
+    const { layer, strokes, index: from } = this.findLiveStroke(id);
+    if (!Number.isInteger(index) || index < 0 || index >= strokes.length) throw new PaintEditorError(`index ${index} is out of range; the layer has ${strokes.length} strokes, so use 0..${strokes.length - 1} (0 = bottom).`);
+    const list = [...strokes];
+    const [moved] = list.splice(from, 1);
+    list.splice(index, 0, moved);
+    if (from !== index) this.commitLiveStrokes("Reorder stroke", layer, list, this.strokeAreas([moved]));
+    return list.map((x) => x.id);
+  }
+  /** Turns a stroke layer into a plain pixel layer with the same pixels (one undo step). */
+  rasterizeLiveStrokes(layerId) {
+    this.requireIdle("rasterizing");
+    const { layer } = this.liveStrokeLayer(layerId, "rasterize");
+    this.commit("Rasterize stroke layer", this.withPaintEvent({ ...this.doc, ...this.liveStrokesWithout([layer.id]) }, { kind: "live-strokes", layerId: layer.id, data: { rasterized: true } }));
+    return this.describeLayer(this.getLayer(layer.id));
+  }
+  /** Sets a layer's live strokes and redraws it (replays). `null` makes it a plain pixel layer. */
+  replaceLiveStrokes(layerId, strokes) {
+    const l = this.wetLayer(layerId, "set the strokes of");
+    if (strokes === null) {
+      this.commit("Rasterize stroke layer", { ...this.doc, ...this.liveStrokesWithout([l.id]) });
+      return;
+    }
+    this.commitLiveStrokes("Strokes", l, strokes.map((x) => ({ ...x, layerId: l.id })));
+  }
+  /**
+   * The top-most stroke of a stroke layer (default the active layer) that painted the pixel at
+   * (x, y) document pixels, or `null`. Strokes whose area holds the point are drawn alone, top
+   * first, until one covers it.
+   */
+  liveStrokeAt(layerId, x, y) {
+    if (!Number.isFinite(x) || !Number.isFinite(y)) throw new PaintEditorError("x and y must be numbers of document pixels.");
+    const { layer, strokes } = this.liveStrokeLayer(layerId, "pick a stroke on");
+    const plain = { ...layer, visible: true, locks: void 0, offset: { x: 0, y: 0 } };
+    const doc = { ...this.doc, liveStrokes: void 0, stickers: void 0 };
+    const px = Math.floor(x);
+    const py = Math.floor(y);
+    for (let i = strokes.length - 1; i >= 0; i--) {
+      const area = this.strokeArea(strokes[i]);
+      if (!area || px < area.x || py < area.y || px >= area.x + area.width || py >= area.y + area.height) continue;
+      const drawn = this.drawLiveStroke(doc, plain, _chunk474IQG74cjs.emptySurface.call(void 0, 4), strokes[i]).surface;
+      if (_chunk474IQG74cjs.readPixel.call(void 0, drawn, px, py)[3] > 24) return { ...strokes[i] };
+    }
+    return null;
+  }
+  /** Picks a stroke for the stroke panel and canvas (`null` for none). Editor state, not an undo step. */
+  selectStroke(id) {
+    if (id === this.selectedStroke) return;
+    this.selectedStroke = id;
+    this.emit([]);
+  }
+  /** Where a live stroke painted (document pixels), or `null`. */
+  liveStrokeArea(id) {
+    return this.strokeArea(this.findLiveStroke(id).strokes.find((s) => s.id === id));
+  }
+  /** Commits a layer's new stroke list with its redrawn pixels, recorded for replays (one undo step). */
+  commitLiveStrokes(label, layer, list, dirty) {
+    this.commit(label, this.withLiveStrokes(this.doc, layer, list, dirty));
+  }
+  withLiveStrokes(doc, layer, list, dirty) {
+    if (_chunkHB4ICNNAcjs.isLayerLocked.call(void 0, layer, "pixels")) throw new PaintEditorError(`Layer "${layer.name}" has its pixels locked; unlock it (update_layer locks) first.`);
+    const current = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _372 => _372.layer]);
+    const surface = this.drawLiveStrokes(_nullishCoalesce(current, () => ( layer)), list, dirty);
+    const next = { ...doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, doc.layers, layer.id, (l) => ({ ...l, surface, offset: { x: 0, y: 0 } })), liveStrokes: { ..._nullishCoalesce(doc.liveStrokes, () => ( {})), [layer.id]: [...list] } };
+    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. */
+  strokeArea(s) {
+    return this.paintedBounds.has(s) ? this.paintedBounds.get(s) : liveStrokeBounds(s);
+  }
+  /** The areas strokes painted, or `null` when one is not known (a full redraw then). */
+  strokeAreas(strokes) {
+    const out = [];
+    for (const s of strokes) {
+      if (!this.paintedBounds.has(s)) return null;
+      const b = this.paintedBounds.get(s);
+      if (b) out.push(b);
+    }
+    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) {
+    let out = surface;
+    const host = {
+      update: () => {
+      },
+      commit: (_s, drawn, cancelled) => {
+        if (!cancelled && drawn) out = drawn;
+      }
+    };
+    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: _nullishCoalesce(st.copies, () => ( [])), ...st.load ? { load: st.load } : {}, ...paint ? { paint } : {}, snapToPerspective: false, stencils: false, maskStencils: _nullishCoalesce(st.stencils, () => ( [])) };
+    const session = this.sessionFor({ ...doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, doc.layers, plain.id, () => ({ ...plain, surface })) }, 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) : _nullishCoalesce(_nullishCoalesce(result.bounds, () => ( had)), () => ( null)));
+    return { surface: out, bounds: result.bounds };
+  }
+  /**
+   * A stroke layer's pixels drawn from its strokes, bottom first. With `dirty` (the areas the old
+   * strokes that changed had painted), only the tiles there and under any stroke whose area isn't
+   * known yet are drawn again, from the strokes that reach them (a pixel depends only on the
+   * strokes over it); the other tiles are kept. Without it, or with `null`, every stroke is drawn.
+   */
+  drawLiveStrokes(layer, list, dirty) {
+    const plain = { ...layer, visible: true, locks: void 0, offset: { x: 0, y: 0 } };
+    const doc = { ...this.doc, liveStrokes: void 0, stickers: void 0 };
+    const unknown = list.filter((s) => !this.paintedBounds.has(s));
+    const partial = dirty && !layer.offset.x && !layer.offset.y && unknown.length <= 4;
+    if (!partial) {
+      let surface2 = _chunk474IQG74cjs.emptySurface.call(void 0, 4);
+      for (const st of list) surface2 = this.drawLiveStroke(doc, plain, surface2, st).surface;
+      return surface2;
+    }
+    const areas = [...dirty];
+    for (const st of unknown) {
+      const b = this.drawLiveStroke(doc, plain, _chunk474IQG74cjs.emptySurface.call(void 0, 4), st).bounds;
+      if (b) areas.push(b);
+    }
+    const { width, height } = this.doc.canvas;
+    const rects = areas.map((r) => clipRect(r, width, height)).filter((r) => r !== null);
+    if (!rects.length) return layer.surface;
+    const overlaps = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+    let drawn = _chunk474IQG74cjs.emptySurface.call(void 0, 4);
+    for (const st of list) {
+      const b = this.paintedBounds.get(st);
+      if (b && rects.some((r) => overlaps(r, b))) drawn = this.drawLiveStroke(doc, plain, drawn, st).surface;
+    }
+    let surface = layer.surface;
+    for (const r of rects) surface = _chunk474IQG74cjs.writeRegion.call(void 0, surface, r, _chunk474IQG74cjs.readRegion.call(void 0, drawn, r));
+    return surface;
+  }
+  // --- 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;
+    let layers = this.doc.layers;
+    for (const [id, a] of this.animatedLayers) {
+      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _373 => _373.layer]);
+      if (isPixelLayer(l) && l.surface === a.base) layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, layers, id, () => ({ ...l, surface: a.surface }));
+    }
+    return layers;
+  }
+  /** Stroke layers with live effect strokes, and the distinct live sources (frame 0). */
+  liveEffects(doc = this.doc) {
+    const layers = [];
+    const sources = /* @__PURE__ */ new Map();
+    for (const [id, strokes] of Object.entries(_nullishCoalesce(doc.liveStrokes, () => ( {})))) {
+      const layer = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _374 => _374.layer]);
+      const live = strokes.filter(isLiveEffect);
+      if (!isPixelLayer(layer) || !live.length) continue;
+      layers.push({ layer, strokes });
+      for (const st of live) sources.set(_chunk5BR7LC24cjs.effectPaintKey.call(void 0, st.paint), st.paint);
+    }
+    return { layers, sources: [...sources.values()] };
+  }
+  /** What plays: the live effect strokes and their layers, or `null` when nothing does. */
+  getAnimation() {
+    const { layers, sources } = this.liveEffects();
+    if (!layers.length) return null;
+    return { layerIds: layers.map((x) => x.layer.id), strokes: layers.reduce((n, x) => n + x.strokes.filter(isLiveEffect).length, 0), sources: sources.length };
+  }
+  /** Plays or pauses live effect paint, and caps its frame rate (1..60). Editor state, not an undo step. */
+  setEffectPlayback(update) {
+    if (update.playing !== void 0 && typeof update.playing !== "boolean") throw new PaintEditorError("playing must be true or false.");
+    if (update.fps !== void 0 && !(Number.isInteger(update.fps) && update.fps >= 1 && update.fps <= 60)) throw new PaintEditorError(`fps ${update.fps} is out of range; use a whole number 1..60.`);
+    this.effectPlaybackState = { ...this.effectPlaybackState, ...update };
+    this.emit([]);
+    return { ...this.effectPlaybackState, time: this.effectTime };
+  }
+  /** The surfaces of every stroke layer with live effects at `time` ms, drawn in full (frames rendered first). */
+  async liveSurfacesAt(time) {
+    const { layers, sources } = this.liveEffects();
+    await this.prepareEffectPaints(sources.map((p) => framePaint(p, time)));
+    const out = /* @__PURE__ */ new Map();
+    this.liveEffectAt = time;
+    try {
+      for (const { layer, strokes } of layers) out.set(layer.id, this.drawLiveStrokes({ ...layer, offset: { x: 0, y: 0 } }, strokes));
+    } finally {
+      this.liveEffectAt = null;
+    }
+    return out;
+  }
+  /**
+   * Shows the live effects at `time` ms (each live stroke's effect at its own time plus `time`):
+   * renders their frames, then redraws only where live effect strokes paint. Nothing in the
+   * document changes. Resolves `false` when the document changed while frames rendered (the next
+   * frame catches up).
+   */
+  async showEffectTime(time) {
+    this.checkTime(time);
+    const { layers, sources } = this.liveEffects();
+    const revision = this.docRevision;
+    await this.prepareEffectPaints(sources.map((p) => framePaint(p, time)));
+    if (revision !== this.docRevision || this.session) return false;
+    const next = /* @__PURE__ */ new Map();
+    const dirty = [];
+    this.liveEffectAt = time;
+    try {
+      for (const { layer, strokes } of layers) {
+        const shown = this.animatedLayers.get(layer.id);
+        const from = shown && shown.base === layer.surface ? shown.surface : layer.surface;
+        const areas = strokes.filter(isLiveEffect).flatMap((st) => [liveStrokeBounds(st), ...this.paintedBounds.get(st) ? [this.paintedBounds.get(st)] : []]);
+        const surface = this.drawLiveStrokes({ ...layer, surface: from, offset: { x: 0, y: 0 } }, strokes, layer.offset.x || layer.offset.y ? null : areas);
+        next.set(layer.id, { base: layer.surface, surface });
+        dirty.push(...areas);
+      }
+    } finally {
+      this.liveEffectAt = null;
+    }
+    this.animatedLayers = next;
+    this.effectTime = time;
+    this.emit(dirty);
+    return true;
+  }
+  /**
+   * Plays live effect paint in the view until `stop`: a frame per tick of `clock` (default
+   * animation frames) at most `fps` a second, one render in flight. Idle while paused, while a
+   * stroke is painted, or when nothing is live. The bindings start it while the editor is shown.
+   */
+  playEffects(clock = defaultEffectClock) {
+    let stopped = false;
+    let cancel = () => {
+    };
+    let last = -Infinity;
+    let started = clock.now() - this.effectTime;
+    const tick = () => {
+      if (stopped) return;
+      const now = clock.now();
+      const { playing, fps } = this.effectPlaybackState;
+      if (!playing) started = now - this.effectTime;
+      if (!playing || this.session || now - last < 1e3 / fps - 1 || !this.liveEffects().layers.length) {
+        cancel = clock.frame(tick);
+        return;
+      }
+      last = now;
+      this.showEffectTime(Math.max(0, now - started)).then(
+        () => {
+          if (!stopped) cancel = clock.frame(tick);
+        },
+        () => {
+          if (!stopped) cancel = clock.frame(tick);
+        }
+      );
+    };
+    cancel = clock.frame(tick);
+    return {
+      stop() {
+        stopped = true;
+        cancel();
+      }
+    };
+  }
+  /**
+   * 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.
+   */
+  async withEffectTime(time, fn) {
+    this.checkTime(time);
+    const surfaces = await this.liveSurfacesAt(time);
+    const was = this.frameOverride;
+    this.frameOverride = surfaces;
+    try {
+      return await fn();
+    } finally {
+      this.frameOverride = was;
+    }
+  }
+  /** The painting composited `time` ms into its live effects, like `compositePixels`. Nothing in the document changes. */
+  async renderAnimationFrame(time, options = {}) {
+    return this.withEffectTime(time, () => this.compositePixels(options));
+  }
   // --- Stencils --------------------------------------------------------------------
-  __init114() {this.stencilCache = null}
-  __init115() {this.nextStencilId = 1}
+  __init123() {this.stencilCache = null}
+  __init124() {this.nextStencilId = 1}
   /** The mask stencils' coverage over the canvas (cached), or `null` when none masks. */
   stencilSelection(stencils = this.guides.stencils) {
     const { width, height } = this.doc.canvas;
     const size = `${width}x${height}`;
-    if (_optionalChain([this, 'access', _321 => _321.stencilCache, 'optionalAccess', _322 => _322.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
+    if (_optionalChain([this, 'access', _375 => _375.stencilCache, 'optionalAccess', _376 => _376.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
     const mask = stencilMask(stencils, width, height);
     this.stencilCache = { key: stencils, size, mask };
     return mask;
@@ -6111,7 +6659,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   makeSwatch(color, name) {
     const p = typeof color === "string" ? { type: "color", color: parseColor(color) } : this.readStrokePaint(color);
     const out = { color: _chunkPQ3H2AANcjs.paintSourceColor.call(void 0, p, { paint: this.color, secondary: this.secondaryColor }) };
-    if (_optionalChain([name, 'optionalAccess', _323 => _323.trim, 'call', _324 => _324()])) out.name = name.trim();
+    if (_optionalChain([name, 'optionalAccess', _377 => _377.trim, 'call', _378 => _378()])) out.name = name.trim();
     if (p.type === "gradient") out.paint = p;
     return out;
   }
@@ -6163,7 +6711,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
   mixOnPad(paints, options = {}) {
-    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _325 => _325.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _326 => _326.parts]) }));
+    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _379 => _379.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _380 => _380.parts]) }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -6252,13 +6800,42 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
-    const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _327 => _327.layer]);
+    const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _381 => _381.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
 }, _class10.__initStatic(), _class10);
 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 });
+function isLiveEffect(s) {
+  return _optionalChain([s, 'access', _382 => _382.paint, 'optionalAccess', _383 => _383.type]) === "effect" && s.paint.live === true;
+}
+function framePaint(p, t) {
+  return { ...p, time: p.time + t };
+}
+var MAX_LIVE_EFFECT_SOURCES = 8;
+var defaultEffectClock = {
+  now: () => typeof performance !== "undefined" ? performance.now() : Date.now(),
+  frame: (cb) => {
+    if (typeof requestAnimationFrame === "undefined") {
+      const t = setTimeout(cb, 16);
+      return () => clearTimeout(t);
+    }
+    const id = requestAnimationFrame(cb);
+    return () => cancelAnimationFrame(id);
+  }
+};
+function clipRect(r, width, height) {
+  const x0 = Math.max(0, Math.floor(r.x));
+  const y0 = Math.max(0, Math.floor(r.y));
+  const x1 = Math.min(width, Math.ceil(r.x + r.width));
+  const y1 = Math.min(height, Math.ceil(r.y + r.height));
+  return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
+}
+function withLiveStroke(doc, stroke) {
+  const list = _optionalChain([doc, 'access', _384 => _384.liveStrokes, 'optionalAccess', _385 => _385[stroke.layerId]]);
+  return list ? { ...doc, liveStrokes: { ...doc.liveStrokes, [stroke.layerId]: [...list, stroke] } } : doc;
+}
 function shiftDocument(doc, dx, dy) {
   if (!dx && !dy) return doc;
   let layers = doc.layers;
@@ -6275,11 +6852,18 @@ function shiftDocument(doc, dx, dy) {
       return s.stencils ? { ...moved, stencils: s.stencils.map((x) => translateStencil(x, dx, dy)) } : moved;
     })
   };
+  const moveStroke = (s) => {
+    const moved = varyStroke(s, m, {});
+    return s.stencils ? { ...moved, stencils: s.stencils.map((x) => translateStencil(x, dx, dy)) } : moved;
+  };
   if (doc.stickers) out.stickers = Object.fromEntries(Object.entries(doc.stickers).map(([id, list]) => [id, moveStickers(list)]));
+  if (doc.liveStrokes) out.liveStrokes = Object.fromEntries(Object.entries(doc.liveStrokes).map(([id, list]) => [id, list.map(moveStroke)]));
   if (doc.paintEvents) {
     out.paintEvents = doc.paintEvents.map((e) => {
-      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _328 => _328.data, 'optionalAccess', _329 => _329.stickers]) : void 0;
-      return list ? { ...e, data: { ...e.data, stickers: moveStickers(list) } } : e;
+      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _386 => _386.data, 'optionalAccess', _387 => _387.stickers]) : void 0;
+      if (list) return { ...e, data: { ...e.data, stickers: moveStickers(list) } };
+      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _388 => _388.data, 'optionalAccess', _389 => _389.strokes]) : void 0;
+      return strokes ? { ...e, data: { ...e.data, strokes: strokes.map(moveStroke) } } : e;
     });
   }
   if (doc.wetEvents) {
@@ -6360,8 +6944,8 @@ function strokeSchedule(points) {
   return total > 0 ? acc.map((d) => d / total) : points.map(() => 1);
 }
 function strokeDuration(points, max = 1800) {
-  const t0 = _optionalChain([points, 'access', _330 => _330[0], 'optionalAccess', _331 => _331.t]);
-  const t1 = _optionalChain([points, 'access', _332 => _332[points.length - 1], 'optionalAccess', _333 => _333.t]);
+  const t0 = _optionalChain([points, 'access', _390 => _390[0], 'optionalAccess', _391 => _391.t]);
+  const t1 = _optionalChain([points, 'access', _392 => _392[points.length - 1], 'optionalAccess', _393 => _393.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -6415,7 +6999,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _334 => _334.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _335 => _335.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _394 => _394.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _395 => _395.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -6462,8 +7046,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _336 => _336.replay, 'access', _337 => _337.strokeIds, 'optionalAccess', _338 => _338.includes, 'call', _339 => _339(s.id)]));
-        const first = _optionalChain([source, 'access', _340 => _340[0], 'optionalAccess', _341 => _341.points, 'access', _342 => _342[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _396 => _396.replay, 'access', _397 => _397.strokeIds, 'optionalAccess', _398 => _398.includes, 'call', _399 => _399(s.id)]));
+        const first = _optionalChain([source, 'access', _400 => _400[0], 'optionalAccess', _401 => _401.points, 'access', _402 => _402[0]]);
         if (first) await this.glide(id, first);
         const result = c.replayStrokes(command.replay);
         if (result.bounds) await this.glide(id, centre(result.bounds), 520);
@@ -6644,7 +7228,7 @@ function createPaintStickerTools(c) {
             items: {
               type: "object",
               properties: {
-                stamp: { type: "string", enum: [..._chunkNKTNLJUJcjs.STAMP_KINDS], description: "The stamp." },
+                stamp: { type: "string", enum: [..._chunk5BR7LC24cjs.STAMP_KINDS], description: "The stamp." },
                 x: { type: "number", description: "Centre x in document pixels." },
                 y: { type: "number", description: "Centre y in document pixels." },
                 size: { type: "number", minimum: 2, maximum: 2048, description: "Diameter in pixels (default 48)." },
@@ -6674,7 +7258,7 @@ function createPaintStickerTools(c) {
         properties: {
           layerId: LAYER_ID,
           id: { type: "string", description: "Sticker id from list_stickers." },
-          stamp: { type: "string", enum: [..._chunkNKTNLJUJcjs.STAMP_KINDS], description: "Another stamp." },
+          stamp: { type: "string", enum: [..._chunk5BR7LC24cjs.STAMP_KINDS], description: "Another stamp." },
           x: { type: "number", description: "Centre x in document pixels." },
           y: { type: "number", description: "Centre y in document pixels." },
           size: { type: "number", minimum: 2, maximum: 2048, description: "Diameter in pixels." },
@@ -7552,7 +8136,7 @@ var BEHAVIOR = {
       type: "object",
       description: "Multi-coloured brush (the older form of paint, the brush's own gradient: tip is across-tip, dab is distance in dabs or random). Read back from paint when it has a multi-colour equivalent. Missing fields keep their current values.",
       properties: {
-        mode: { type: "string", enum: [..._chunkNKTNLJUJcjs.MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
+        mode: { type: "string", enum: [..._chunk5BR7LC24cjs.MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
         colors: { type: "array", maxItems: 8, items: { ...COLOR3 }, description: "2..8 colours #rrggbb; fewer than 2 uses the paint colour and the secondary colour." },
         order: { type: "string", enum: ["sequence", "random"], description: "dab mode: sequence runs through the colours in order, blending between them; random picks one per run of dabs (seeded)." },
         length: { type: "integer", minimum: 1, maximum: 500, description: "dab mode: dabs per colour (default 12)." },
@@ -7593,10 +8177,10 @@ var WET_BRUSH = {
   properties: {
     tool: {
       type: "string",
-      enum: [..._chunkNKTNLJUJcjs.WET_TOOLS],
+      enum: [..._chunk5BR7LC24cjs.WET_TOOLS],
       description: "paint: water and pigment (picks up and mixes wet paint by behavior.pickup / mix); water: clear water (with rewet it lifts dried paint); dry: a hair dryer, takes water; blow: pushes the water along the stroke; blend: evens out wet pigment; smudge: drags wet paint; blot: a tissue, takes wet paint up (erase wet)."
     },
-    medium: { type: "string", enum: [..._chunkNKTNLJUJcjs.WET_MEDIA], description: "The medium: watercolor, gouache or oil. A layer takes the medium's wet settings the first time it holds wet paint (oil: thick, barely flows, stays wet long and blends into the wet paint it meets)." },
+    medium: { type: "string", enum: [..._chunk5BR7LC24cjs.WET_MEDIA], description: "The medium: watercolor, gouache or oil. A layer takes the medium's wet settings the first time it holds wet paint (oil: thick, barely flows, stays wet long and blends into the wet paint it meets)." },
     load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (each stroke reloads)." },
     thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner (water or solvent): more transparent, runnier paint." },
     water: { type: "number", minimum: 0, maximum: 1, description: "Wetness: water laid per stroke, 0.2 a damp brush .. 1 a dripping one." },
@@ -7613,7 +8197,7 @@ var IMPASTO_BRUSH = {
   properties: {
     tool: {
       type: "string",
-      enum: [..._chunkNKTNLJUJcjs.IMPASTO_TOOLS],
+      enum: [..._chunk5BR7LC24cjs.IMPASTO_TOOLS],
       description: "brush: thick paint with bristle ridges along the stroke; tube: blobs squeezed from the tube; knife: a palette knife that scrapes the relief flat and smears the paint; roller: a flat stippled band; gloop: a thick, glossy, rounded bead."
     },
     thickness: { type: "number", minimum: 0, maximum: 1, description: "How far the paint stands up." },
@@ -7629,8 +8213,8 @@ var PARTICLE_BRUSH = {
   type: "object",
   description: "Particle engine settings (procedural brushes). Missing fields keep their current values.",
   properties: {
-    kind: { type: "string", enum: [..._chunkNKTNLJUJcjs.PARTICLE_KINDS], description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade." },
-    render: { type: "string", enum: [..._chunkNKTNLJUJcjs.PARTICLE_RENDERS], description: "dot: a mark at each step; line: each particle draws a continuous line; sequence: beads spaced along each path." },
+    kind: { type: "string", enum: [..._chunk5BR7LC24cjs.PARTICLE_KINDS], description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade." },
+    render: { type: "string", enum: [..._chunk5BR7LC24cjs.PARTICLE_RENDERS], description: "dot: a mark at each step; line: each particle draws a continuous line; sequence: beads spaced along each path." },
     count: { type: "integer", minimum: 1, maximum: 64, description: "Particles (flow: how many are thrown per tip of travel)." },
     size: { type: "number", minimum: 0, maximum: 1, description: "Mark size as a fraction of the tip size." },
     spread: { type: "number", minimum: 0, maximum: 1, description: "How far apart the particles start, as a fraction of the tip size." },
@@ -7660,7 +8244,7 @@ var STICKER_BRUSH = {
   type: "object",
   description: "Sticker engine settings: stamps sprayed along the stroke as editable stickers. Missing fields keep their current values.",
   properties: {
-    stamps: { type: "array", minItems: 1, maxItems: 9, items: { type: "string", enum: [..._chunkNKTNLJUJcjs.STAMP_KINDS], description: "A stamp." }, description: "The stamps to spray (one picked at random per sticker)." },
+    stamps: { type: "array", minItems: 1, maxItems: 9, items: { type: "string", enum: [..._chunk5BR7LC24cjs.STAMP_KINDS], description: "A stamp." }, description: "The stamps to spray (one picked at random per sticker)." },
     density: { type: "number", minimum: 0, maximum: 1, description: "How closely stickers follow each other: about density \xD7 4 stickers per tip diameter of travel (0.25 \u2248 one per diameter, 1 \u2248 four). Default 0.4." },
     sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change." },
     rotationJitter: { type: "number", minimum: 0, maximum: 1, description: "Random turn as a fraction of \xB1180\xB0." },
@@ -7671,16 +8255,16 @@ var STICKER_BRUSH = {
 };
 var BRUSH_FIELDS = {
   name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
-  category: { type: "string", enum: [..._chunkNKTNLJUJcjs.PAINT_BRUSH_CATEGORIES], description: "Library category." },
+  category: { type: "string", enum: [..._chunk5BR7LC24cjs.PAINT_BRUSH_CATEGORIES], description: "Library category." },
   engine: {
     type: "string",
-    enum: [..._chunkNKTNLJUJcjs.PAINT_BRUSH_ENGINES],
+    enum: [..._chunk5BR7LC24cjs.PAINT_BRUSH_ENGINES],
     description: "dab: paints dabs (with behavior.pickup or gradient paint it paints dab by dab, lifting and mixing paint); eraser: removes paint; mixer: the Mixer Brush (a reservoir plus picked-up paint); blender: mixes the colours under and near the tip; smudge: drags paint along the stroke; wet: watercolour, gouache, oil and the wet tools on a simulated wet layer (see wet); impasto: thick paint with relief (see impasto); particle: procedural particle brushes (see particle); bristle: a tuft of bristles that bend and splay (see bristle); sticker: sprays editable sticker stamps (see sticker)."
   },
   tip: TIP,
   grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Multiplied by the paper depth." },
   pressureSmoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Pressure smoothing, separate from the tip position smoothing." },
-  rotation: { type: "string", enum: [..._chunkNKTNLJUJcjs.BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
+  rotation: { type: "string", enum: [..._chunk5BR7LC24cjs.BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
   dynamics: DYNAMICS,
   mixer: MIXER,
   loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for a mixer that only moves paint)." },
@@ -7694,6 +8278,7 @@ var BRUSH_FIELDS = {
   sticker: STICKER_BRUSH,
   paint: BRUSH_PAINT
 };
+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 = {
   type: "array",
   minItems: 1,
@@ -7730,7 +8315,7 @@ function brushSummary(b) {
     size: b.tip.size,
     grain: b.grain,
     rotation: b.rotation,
-    wetCapable: _chunkNKTNLJUJcjs.isWetCapable.call(void 0, b),
+    wetCapable: _chunk5BR7LC24cjs.isWetCapable.call(void 0, b),
     pickup: b.behavior.pickup,
     dirty: b.behavior.dirty,
     multicolor: b.behavior.multicolor.mode,
@@ -7838,8 +8423,8 @@ function createPaintEditorToolProvider(controller, options = {}) {
     inputSchema: EMPTY3,
     annotations: { title: "List papers", ...READ6 },
     handler: () => ({
-      papers: _chunkNKTNLJUJcjs.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: [..._chunkNKTNLJUJcjs.PAPER_FAMILIES],
+      papers: _chunk5BR7LC24cjs.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: [..._chunk5BR7LC24cjs.PAPER_FAMILIES],
       patterns: [..._chunkPQ3H2AANcjs.GRAIN_PATTERNS]
     })
   });
@@ -7899,12 +8484,12 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "add_layer",
     title: "Add a layer",
-    description: "Adds an empty pixel layer (or a group) above the active layer, or above aboveId, or at the top of parentId; it becomes the active layer. One undo step. Returns the layer.",
+    description: "Adds an empty pixel layer, a group, or a stroke layer (type strokes: its strokes stay editable with update_stroke and edit_stroke_points) above the active layer, or above aboveId, or at the top of parentId; it becomes the active layer. One undo step. Returns the layer (liveStrokes: its stroke count, for a stroke layer).",
     inputSchema: {
       type: "object",
       properties: {
         name: { type: "string", minLength: 1, description: 'Layer name (default "Layer n").' },
-        type: { type: "string", enum: ["pixel", "group"], description: "pixel (default) or group." },
+        type: { type: "string", enum: ["pixel", "group", "strokes"], description: "pixel (default), group, or strokes: a live stroke layer whose pixels are drawn from its strokes, so each stays editable. It takes dab, particle, bristle and Mixer Brush strokes that pick up no paint." },
         aboveId: { type: "string", description: "Put it directly above this layer (default the active layer)." },
         parentId: { type: "string", description: "Put it at the top of this group instead." }
       },
@@ -8059,7 +8644,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "List brushes", ...READ6 },
     handler: () => {
       const s = c.getState();
-      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _343 => _343.getBrush, 'call', _344 => _344(s.brush.id), 'optionalAccess', _345 => _345.builtin])), brushes: s.brushes.map(brushSummary) };
+      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _403 => _403.getBrush, 'call', _404 => _404(s.brush.id), 'optionalAccess', _405 => _405.builtin])), brushes: s.brushes.map(brushSummary) };
     }
   });
   add({
@@ -8070,10 +8655,10 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "Get a brush", ...READ6 },
     handler: ({ id }) => {
       const st = c.getState();
-      if (id === void 0) return { ..._chunkNKTNLJUJcjs.brushToJSON.call(void 0, st.brush), strokePaint: _nullishCoalesce(st.brush.paint, () => ( st.paint)) };
+      if (id === void 0) return { ..._chunk5BR7LC24cjs.brushToJSON.call(void 0, st.brush), strokePaint: _nullishCoalesce(st.brush.paint, () => ( st.paint)) };
       const b = c.getBrush(id);
       if (!b) throw new Error(`Unknown brush "${id}". Call list_brushes for the ids.`);
-      return { ..._chunkNKTNLJUJcjs.brushToJSON.call(void 0, b), builtin: Boolean(b.builtin), strokePaint: _nullishCoalesce(b.paint, () => ( st.paint)) };
+      return { ..._chunk5BR7LC24cjs.brushToJSON.call(void 0, b), builtin: Boolean(b.builtin), strokePaint: _nullishCoalesce(b.paint, () => ( st.paint)) };
     }
   });
   add({
@@ -8082,7 +8667,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Chooses the active brush (id) and / or changes its settings; strokes without a brush use it. Editor state, not an undo step. Changes stay on the active brush until save_brush stores them. Returns the active brush.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes to start from." }, ...BRUSH_FIELDS }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
-    handler: (a) => _chunkNKTNLJUJcjs.brushToJSON.call(void 0, c.setBrush(a))
+    handler: (a) => _chunk5BR7LC24cjs.brushToJSON.call(void 0, c.setBrush(a))
   });
   add({
     name: "save_brush",
@@ -8098,7 +8683,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Save a brush", ...SET4 },
-    handler: ({ id, name }) => _chunkNKTNLJUJcjs.brushToJSON.call(void 0, c.saveBrush({ id, name }))
+    handler: ({ id, name }) => _chunk5BR7LC24cjs.brushToJSON.call(void 0, c.saveBrush({ id, name }))
   });
   add({
     name: "remove_brush",
@@ -8266,44 +8851,156 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "list_strokes",
     title: "List recorded strokes",
-    description: "Lists the recorded strokes, oldest first (every stroke is kept as data): id, layer, brush id and name, colour, point count, bounds and seed. With ids, also the points. Use the ids with replay_strokes.",
+    description: "Lists the recorded strokes, oldest first (every stroke is kept as data): id, layer, brush id and name, colour, point count, bounds, seed and whether it is live. With ids, also the points. Use the ids with replay_strokes. With live true, lists the strokes of stroke layers as they are now, bottom first: the ones update_stroke, edit_stroke_points, reorder_stroke and remove_strokes change.",
     inputSchema: {
       type: "object",
       properties: {
         ids: { type: "array", items: { type: "string", description: "Stroke id." }, description: "Only these strokes, with their points." },
-        last: { type: "integer", minimum: 1, maximum: 1e3, description: "Only the most recent n strokes (default 100)." }
+        last: { type: "integer", minimum: 1, maximum: 1e3, description: "Only the most recent n strokes (default 100)." },
+        live: { type: "boolean", description: "Only the editable strokes of stroke layers, as they are now, bottom first (default false: the whole recorded history)." },
+        layerId: { type: "string", description: "Only strokes of this layer." }
       },
       additionalProperties: false
     },
     annotations: { title: "List recorded strokes", ...READ6 },
     coordinates: { out: ["strokes[].bounds", "strokes[].points[]"] },
-    handler: ({ ids, last }) => {
-      const all = c.getStrokes();
+    handler: ({ ids, last, live, layerId }) => {
+      if (layerId !== void 0 && !c.getLayer(layerId)) throw new Error(`Unknown layer "${layerId}". Call list_layers for the ids.`);
+      const liveAll = Object.values(_nullishCoalesce(c.document.liveStrokes, () => ( {}))).flat();
+      const liveIds = new Set(liveAll.map((s) => s.id));
+      let all = live ? liveAll : c.getStrokes();
+      if (layerId !== void 0) all = all.filter((s) => s.layerId === layerId);
       const picked = ids ? all.filter((s) => ids.includes(s.id)) : all.slice(-(_nullishCoalesce(last, () => ( 100))));
       if (ids) {
         for (const id of ids) if (!all.some((s) => s.id === id)) throw new Error(`Unknown stroke "${id}". Call list_strokes without ids for the ids.`);
       }
-      return {
-        total: all.length,
-        strokes: picked.map((s) => {
-          const xs = s.points.map((p) => p.x);
-          const ys = s.points.map((p) => p.y);
-          const pad = s.brush.tip.size / 2;
-          return {
-            id: s.id,
-            layerId: s.layerId,
-            brushId: s.brush.id,
-            brushName: s.brush.name,
-            color: s.color,
-            points: ids ? s.points : s.points.length,
-            seed: s.seed,
-            copies: _nullishCoalesce(_optionalChain([s, 'access', _346 => _346.copies, 'optionalAccess', _347 => _347.length]), () => ( 0)),
-            bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
-          };
-        })
-      };
+      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _406 => _406.document, 'access', _407 => _407.liveStrokes, 'optionalAccess', _408 => _408[s.layerId], 'optionalAccess', _409 => _409.includes, 'call', _410 => _410(s)]) === true)) };
+    }
+  });
+  add({
+    name: "stroke_at",
+    title: "Find the stroke at a point",
+    description: "Returns the top-most stroke of a stroke layer that painted the pixel at a point (document pixels), or stroke null when none did, so you can pick one stroke among overlapping ones before update_stroke, edit_stroke_points or remove_strokes. Changes nothing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: { type: "string", description: "Stroke layer id from list_layers (default the active layer)." },
+        x: { type: "number", description: "Point x in document pixels." },
+        y: { type: "number", description: "Point y in document pixels." }
+      },
+      required: ["x", "y"],
+      additionalProperties: false
+    },
+    annotations: { title: "Find the stroke at a point", ...READ6 },
+    coordinates: { in: [""], out: ["stroke.bounds"] },
+    handler: ({ layerId, x, y }) => {
+      const s = c.liveStrokeAt(layerId, x, y);
+      return { stroke: s ? strokeSummary(s, false, true) : null };
+    }
+  });
+  add({
+    name: "update_stroke",
+    title: "Change a stroke",
+    description: "Changes a stroke on a stroke layer after it was painted: another brush preset (brushId, keeping the stroke size), brush settings (as set_brush takes), colour (replaces gradient paint), paint, or seed, then redraws the layer exactly. Ids come from list_strokes {live: true}. Refuses brushes a stroke layer cannot redraw (wet, impasto, sticker, eraser, smudge, blender, pick-up). One undo step. Returns the stroke and the area that changed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Stroke id from list_strokes {live: true}." },
+        brushId: { type: "string", description: "Brush preset id from list_brushes; the stroke keeps its size." },
+        brush: { type: "object", properties: BRUSH_FIELDS, additionalProperties: false, description: "Brush settings to change on top of brushId or the stroke\u2019s brush; missing fields keep their values." },
+        color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "New colour #rrggbb (replaces gradient paint)." },
+        paint: { anyOf: [_chunkPQ3H2AANcjs.PAINT_SOURCE_JSON_SCHEMA, { type: "null", description: "Back to the stroke\u2019s plain colour." }], description: "A colour or gradient paint for the stroke; null drops its gradient." },
+        seed: { type: "integer", minimum: 0, description: "Another jitter seed: particles, scatter and texture fall differently." }
+      },
+      required: ["id"],
+      additionalProperties: false
+    },
+    annotations: { title: "Change a stroke", ...WRITE5 },
+    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.");
+      const r = c.updateStroke(id, update);
+      return { stroke: strokeSummary(r.stroke, false, true), bounds: r.bounds };
+    }
+  });
+  add({
+    name: "edit_stroke_points",
+    title: "Move or reshape a stroke",
+    description: "Replaces a stroke\u2019s points (points, document pixels), or moves, scales, rotates or flips it (transform, about its centre unless origin is given; the brush size scales with it), then redraws its stroke layer exactly. Pass one of points or transform. One undo step. Returns the stroke with its points and the area that changed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Stroke id from list_strokes {live: true}." },
+        points: POINTS,
+        transform: {
+          type: "object",
+          description: "A move, scale, rotation or flip of the whole stroke.",
+          properties: {
+            dx: { type: "number", description: "Move right by this many pixels (default 0)." },
+            dy: { type: "number", description: "Move down by this many pixels (default 0)." },
+            scale: { type: "number", exclusiveMinimum: 0, maximum: 20, description: "Scale about the origin; brush size scales too (default 1)." },
+            rotate: { type: "number", minimum: -360, maximum: 360, description: "Rotate about the origin, degrees clockwise (default 0)." },
+            flipX: { type: "boolean", description: "Mirror left to right about the origin (default false)." },
+            origin: { type: "object", description: "Centre for scale, rotate and flip (default the centre of the stroke).", properties: { x: { type: "number", description: "Document x." }, y: { type: "number", description: "Document y." } }, required: ["x", "y"], additionalProperties: false }
+          },
+          additionalProperties: false
+        }
+      },
+      required: ["id"],
+      additionalProperties: false
+    },
+    annotations: { title: "Move or reshape a stroke", ...WRITE5 },
+    coordinates: { in: ["points[]", "transform.origin"], out: ["bounds", "stroke.bounds", "stroke.points[]"] },
+    handler: ({ id, points, transform }) => {
+      const r = c.editStrokePoints(id, { points, transform });
+      return { stroke: strokeSummary(r.stroke, true, true), bounds: r.bounds };
     }
   });
+  add({
+    name: "reorder_stroke",
+    title: "Move a stroke up or down",
+    description: "Moves a stroke to index in its stroke layer (0 = bottom, drawn first) and redraws the layer. One undo step. Returns the new order of ids, bottom first.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "Stroke id from list_strokes {live: true}." }, index: { type: "integer", minimum: 0, description: "New position, 0 = bottom." } },
+      required: ["id", "index"],
+      additionalProperties: false
+    },
+    annotations: { title: "Move a stroke up or down", ...WRITE5 },
+    handler: ({ id, index }) => ({ order: c.reorderStroke(id, index) })
+  });
+  add({
+    name: "remove_strokes",
+    title: "Delete strokes",
+    description: "Deletes strokes from their stroke layers (the eraser of a stroke layer) and redraws them. All checked first; one undo step. Returns the ids removed and the area that changed.",
+    inputSchema: {
+      type: "object",
+      properties: { ids: { type: "array", minItems: 1, items: { type: "string", description: "Stroke id." }, description: "Stroke ids from list_strokes {live: true}." } },
+      required: ["ids"],
+      additionalProperties: false
+    },
+    annotations: { title: "Delete strokes", ...DESTRUCTIVE3 },
+    coordinates: { out: ["bounds"] },
+    handler: ({ ids }) => c.removeStrokes(ids)
+  });
+  add({
+    name: "convert_to_stroke_layer",
+    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", ...WRITE5 },
+    coordinates: { out: ["bounds"] },
+    handler: ({ layerId }) => c.convertToLiveStrokes(layerId)
+  });
+  add({
+    name: "rasterize_stroke_layer",
+    title: "Rasterize a stroke layer",
+    description: "Turns a stroke layer into a plain pixel layer with the same pixels: its strokes stop being editable, and erasers, smudges and fills work on it. One undo step. Returns the layer.",
+    inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Stroke layer id from list_layers (default the active layer)." } }, additionalProperties: false },
+    annotations: { title: "Rasterize a stroke layer", ...DESTRUCTIVE3 },
+    coordinates: { out: ["bounds"] },
+    handler: ({ layerId }) => c.rasterizeLiveStrokes(layerId)
+  });
   add({
     name: "replay_strokes",
     title: "Replay strokes, varied",
@@ -8418,20 +9115,22 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "export_image",
     title: "Export the painting",
-    description: "Exports the painting as PNG, JPEG or WebP (base64). JPEG always includes the paper; JPEG and WebP need a browser canvas. Changes nothing. Returns the data, its MIME type and size.",
+    description: "Exports the painting as PNG, JPEG or WebP (base64). JPEG always includes the paper; JPEG and WebP need a browser canvas. With time, live effect paint is drawn at that moment (get_effect_playback / set_effect_playback). Changes nothing. Returns the data, its MIME type and size.",
     inputSchema: {
       type: "object",
       properties: {
         format: { type: "string", enum: ["image/png", "image/jpeg", "image/webp"], description: "File type (default image/png)." },
         quality: { type: "number", minimum: 0, maximum: 1, description: "JPEG / WebP quality 0..1 (default 0.92)." },
         scale: { type: "number", exclusiveMinimum: 0, maximum: 1, description: "Shrink by this factor (default 1)." },
-        paper: { type: "boolean", description: "Include the paper (default true)." }
+        paper: { type: "boolean", description: "Include the paper (default true)." },
+        time: TIME
       },
       additionalProperties: false
     },
     annotations: { title: "Export the painting", ...READ6 },
-    handler: async ({ format, quality, scale, paper }) => {
-      const bytes = await c.exportImage({ format, quality, scale, paper });
+    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);
       return { mimeType: _nullishCoalesce(format, () => ( "image/png")), bytes: bytes.length, data: _chunkOLNIPTB3cjs.bytesToBase64.call(void 0, bytes) };
     }
   });
@@ -8439,10 +9138,10 @@ function createPaintEditorToolProvider(controller, options = {}) {
     name: "export_psd",
     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: EMPTY3,
+    inputSchema: { type: "object", properties: { time: TIME }, additionalProperties: false },
     annotations: { title: "Export as PSD", ...READ6 },
-    handler: () => {
-      const r = c.exportPsd();
+    handler: async ({ time }) => {
+      const r = time === void 0 ? c.exportPsd() : await c.withEffectTime(time, () => c.exportPsd());
       return { data: _chunkOLNIPTB3cjs.bytesToBase64.call(void 0, r.bytes), bytes: r.bytes.length, psb: r.psb, warnings: r.warnings };
     }
   });
@@ -8465,44 +9164,62 @@ function createPaintEditorToolProvider(controller, options = {}) {
 }
 function hostTool({ coordinates, ...tool }, { origin, onChange }) {
   if (!origin && !onChange) return tool;
-  const write = !_optionalChain([tool, 'access', _348 => _348.annotations, 'optionalAccess', _349 => _349.readOnlyHint]);
+  const write = !_optionalChain([tool, 'access', _411 => _411.annotations, 'optionalAccess', _412 => _412.readOnlyHint]);
   const done = (result) => {
-    if (write) _optionalChain([onChange, 'optionalCall', _350 => _350({ tool: tool.name })]);
-    return origin && _optionalChain([coordinates, 'optionalAccess', _351 => _351.out]) ? fromDocument(result, coordinates.out, origin) : result;
+    if (write) _optionalChain([onChange, 'optionalCall', _413 => _413({ tool: tool.name })]);
+    return origin && _optionalChain([coordinates, 'optionalAccess', _414 => _414.out]) ? fromDocument(result, coordinates.out, origin) : result;
   };
   return {
     ...tool,
     ...origin ? { description: hostedText(_nullishCoalesce(tool.description, () => ( ""))), inputSchema: hostedSchema(tool.inputSchema) } : {},
     handler: (args, context) => {
-      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _352 => _352.in]) ? toDocument(args, coordinates.in, origin) : args, context);
+      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _415 => _415.in]) ? toDocument(args, coordinates.in, origin) : args, context);
       return r instanceof Promise ? r.then(done) : done(r);
     }
   };
 }
+function strokeSummary(s, withPoints, live) {
+  const xs = s.points.map((p) => p.x);
+  const ys = s.points.map((p) => p.y);
+  const pad = s.brush.tip.size / 2;
+  return {
+    id: s.id,
+    layerId: s.layerId,
+    brushId: s.brush.id,
+    brushName: s.brush.name,
+    color: s.color,
+    points: withPoints ? s.points : s.points.length,
+    seed: s.seed,
+    copies: _nullishCoalesce(_optionalChain([s, 'access', _416 => _416.copies, 'optionalAccess', _417 => _417.length]), () => ( 0)),
+    live,
+    bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
+  };
+}
 
 // src/paint-editor/ui.ts
 var PAINT_TOOLS = [
   { id: "brush", label: "Brush", key: "b" },
   { id: "eyedropper", label: "Eyedropper", key: "i" },
   { id: "sticker", label: "Stickers", key: "s" },
+  { id: "stroke", label: "Select stroke", key: "v" },
   { id: "pan", label: "Pan", key: "h" },
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
 var PaintGesture = (_class11 = class {
-  constructor(controller, box) {;_class11.prototype.__init116.call(this);_class11.prototype.__init117.call(this);_class11.prototype.__init118.call(this);_class11.prototype.__init119.call(this);_class11.prototype.__init120.call(this);_class11.prototype.__init121.call(this);
+  constructor(controller, box) {;_class11.prototype.__init125.call(this);_class11.prototype.__init126.call(this);_class11.prototype.__init127.call(this);_class11.prototype.__init128.call(this);_class11.prototype.__init129.call(this);_class11.prototype.__init130.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init116() {this.tool = "brush"}
+  __init125() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init117() {this.error = null}
+  __init126() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init118() {this.predicted = []}
-  __init119() {this.mode = null}
-  __init120() {this.penAt = null}
-  __init121() {this.penDown = false}
+  __init127() {this.predicted = []}
+  __init128() {this.mode = null}
+  __init129() {this.penAt = null}
+  __init130() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -8533,6 +9250,7 @@ var PaintGesture = (_class11 = class {
       this.mode = { kind: "rotate", pointerId: e.pointerId, angle: Math.atan2(e.clientY - b.top - b.height / 2, e.clientX - b.left - b.width / 2), rotation: this.controller.getState().view.rotation };
       return true;
     }
+    if (tool === "stroke") return this.strokeDown(e);
     if (tool === "eyedropper" || e.altKey) {
       this.pick(e);
       return false;
@@ -8549,6 +9267,34 @@ var PaintGesture = (_class11 = class {
       return false;
     }
   }
+  /**
+   * The Select stroke tool, on a stroke layer: pressing a stroke picks it and dragging moves it
+   * (one undo step at the drop); pressing where no stroke painted clears the pick.
+   */
+  strokeDown(e) {
+    const p = this.doc(e);
+    const s = this.controller.getState();
+    const layerId = s.document.activeLayerId;
+    if (!layerId || !_optionalChain([s, 'access', _418 => _418.document, 'access', _419 => _419.liveStrokes, 'optionalAccess', _420 => _420[layerId]])) {
+      this.error = "Pick a stroke layer in the Layers panel (or add one) to select its strokes.";
+      return false;
+    }
+    try {
+      const hit = this.controller.liveStrokeAt(layerId, p.x, p.y);
+      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _421 => _421.id]), () => ( null)));
+      if (!hit) return false;
+      this.mode = { kind: "move-stroke", pointerId: e.pointerId, id: hit.id, from: p, to: p };
+      return true;
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+      return false;
+    }
+  }
+  /** While a stroke is dragged: how far it has moved (document pixels), to draw its outline there. */
+  get strokeDrag() {
+    const m = this.mode;
+    return _optionalChain([m, 'optionalAccess', _422 => _422.kind]) === "move-stroke" ? { id: m.id, dx: m.to.x - m.from.x, dy: m.to.y - m.from.y } : null;
+  }
   /**
    * The Stickers tool: pressing a sticker picks it and dragging moves it (one undo step at the
    * drop); pressing anywhere else places the active brush's first stamp there, at its tip size and
@@ -8594,6 +9340,10 @@ var PaintGesture = (_class11 = class {
       this.controller.setView({ rotation: r });
       return;
     }
+    if (m.kind === "move-stroke") {
+      m.to = this.doc(e);
+      return;
+    }
     if (m.kind === "sticker") {
       const p = this.doc(e);
       m.at = { x: round2(p.x + m.dx), y: round2(p.y + m.dy) };
@@ -8617,7 +9367,18 @@ var PaintGesture = (_class11 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _353 => _353.controller, 'access', _354 => _354.activeStroke, 'optionalAccess', _355 => _355.end, 'call', _356 => _356()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _423 => _423.controller, 'access', _424 => _424.activeStroke, 'optionalAccess', _425 => _425.end, 'call', _426 => _426()]);
+    if (m.kind === "move-stroke") {
+      const dx = Math.round((this.doc(e).x - m.from.x) * 100) / 100;
+      const dy = Math.round((this.doc(e).y - m.from.y) * 100) / 100;
+      if (dx || dy) {
+        try {
+          this.controller.editStrokePoints(m.id, { transform: { dx, dy } });
+        } catch (err) {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      }
+    }
     if (m.kind === "sticker" && m.at) {
       try {
         this.controller.updateSticker(void 0, m.id, m.at);
@@ -8630,8 +9391,8 @@ var PaintGesture = (_class11 = class {
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _357 => _357.mode, 'optionalAccess', _358 => _358.kind]) === "stroke") _optionalChain([this, 'access', _359 => _359.controller, 'access', _360 => _360.activeStroke, 'optionalAccess', _361 => _361.cancel, 'call', _362 => _362()]);
-    if (_optionalChain([this, 'access', _363 => _363.mode, 'optionalAccess', _364 => _364.kind]) === "sticker") this.controller.cancelStickerPreview();
+    if (_optionalChain([this, 'access', _427 => _427.mode, 'optionalAccess', _428 => _428.kind]) === "stroke") _optionalChain([this, 'access', _429 => _429.controller, 'access', _430 => _430.activeStroke, 'optionalAccess', _431 => _431.cancel, 'call', _432 => _432()]);
+    if (_optionalChain([this, 'access', _433 => _433.mode, 'optionalAccess', _434 => _434.kind]) === "sticker") this.controller.cancelStickerPreview();
     this.mode = null;
   }
   get active() {
@@ -8693,13 +9454,13 @@ function handlePaintShortcut(controller, gesture, e) {
   return false;
 }
 var PaintCanvasPresenter = (_class12 = class {
-  constructor(controller) {;_class12.prototype.__init122.call(this);_class12.prototype.__init123.call(this);_class12.prototype.__init124.call(this);
+  constructor(controller) {;_class12.prototype.__init131.call(this);_class12.prototype.__init132.call(this);_class12.prototype.__init133.call(this);
     this.controller = controller;
   }
   
-  __init122() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init123() {this.scratch = null}
-  __init124() {this.size = ""}
+  __init131() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init132() {this.scratch = null}
+  __init133() {this.size = ""}
   /** Draws what changed into `ctx` (a canvas the size of the document); returns the tiles drawn. */
   render(ctx) {
     const { width, height } = this.controller.document.canvas;
@@ -8726,12 +9487,25 @@ var PaintCanvasPresenter = (_class12 = class {
     return drawn;
   }
 }, _class12);
-function guideOverlay(controller) {
+function guideOverlay(controller, drag) {
   const s = controller.getState();
   const size = s.document.canvas;
   const out = [];
   const layerId = s.document.activeLayerId;
-  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _365 => _365.document, 'access', _366 => _366.stickers, 'optionalAccess', _367 => _367[layerId], 'optionalAccess', _368 => _368.find, 'call', _369 => _369((x) => x.id === s.selectedSticker)]) : void 0;
+  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _435 => _435.document, 'access', _436 => _436.liveStrokes, 'optionalAccess', _437 => _437[layerId], 'optionalAccess', _438 => _438.some, 'call', _439 => _439((x) => x.id === s.selectedStroke)]) : false;
+  const area = strokePicked ? controller.liveStrokeArea(s.selectedStroke) : null;
+  if (area) {
+    const dx = drag && drag.id === s.selectedStroke ? drag.dx : 0;
+    const dy = drag && drag.id === s.selectedStroke ? drag.dy : 0;
+    const box = [
+      { x: area.x + dx, y: area.y + dy },
+      { x: area.x + area.width + dx, y: area.y + dy },
+      { x: area.x + area.width + dx, y: area.y + area.height + dy },
+      { x: area.x + dx, y: area.y + area.height + dy }
+    ];
+    for (let i = 0; i < 4; i++) out.push({ from: box[i], to: box[(i + 1) % 4], kind: "stroke" });
+  }
+  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _440 => _440.document, 'access', _441 => _441.stickers, 'optionalAccess', _442 => _442[layerId], 'optionalAccess', _443 => _443.find, 'call', _444 => _444((x) => x.id === s.selectedSticker)]) : void 0;
   if (picked) {
     const r = picked.size / 2 + 2;
     const a = picked.rotation * Math.PI / 180;
@@ -8775,7 +9549,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _370 => _370[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _445 => _445[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -8897,7 +9671,7 @@ function brushEngineControls(brush) {
         impastoTool: true
       };
     case "wet": {
-      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _371 => _371.wet, 'optionalAccess', _372 => _372.tool]), () => ( "paint"));
+      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _446 => _446.wet, 'optionalAccess', _447 => _447.tool]), () => ( "paint"));
       const sliders = tool === "paint" ? [
         { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
         { path: "wet.pigment", label: "Pigment", min: 0, max: 1, step: 0.01 },
@@ -9030,7 +9804,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _373 => _373(id)]);
+    _optionalChain([caf, 'optionalCall', _448 => _448(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {
@@ -9060,6 +9834,11 @@ function toggleStamp(stamps, stamp) {
   const next = stamps.includes(stamp) ? stamps.filter((s) => s !== stamp) : [...stamps, stamp];
   return next.length ? next : [stamp];
 }
+var STROKE_SLIDERS = [
+  { path: "tip.size", label: "Size", min: 1, max: 400, step: 1 },
+  { path: "tip.opacity", label: "Opacity", min: 0, max: 1, step: 0.01 },
+  { path: "tip.flow", label: "Flow", min: 0, max: 1, step: 0.01 }
+];
 var STICKER_SLIDERS = [
   { path: "size", label: "Size", min: 2, max: 400, step: 1 },
   { path: "rotation", label: "Rotation", min: -180, max: 180, step: 1 },
@@ -9094,7 +9873,7 @@ function createPaintEffectsToolProvider(controller, options = {}) {
   };
   const paintInfo = () => {
     const p = controller.getEffectPaint();
-    return p ? [{ id: PAINT_TARGET, effect: p.effect, provider: p.provider, role: controller.getState().effectPaintRendering ? "effect paint (rendering)" : "effect paint", enabled: true, values: p.values, ...p.time ? { time: p.time } : {} }] : [];
+    return p ? [{ id: PAINT_TARGET, effect: p.effect, provider: p.provider, role: controller.getState().effectPaintRendering ? "effect paint (rendering)" : "effect paint", enabled: true, values: p.values, ...p.time ? { time: p.time } : {}, ...p.map ? { map: p.map } : {}, ...p.live ? { live: true } : {} }] : [];
   };
   const layerInfo = (layerId) => {
     const s = controller.getEffectLayer(layerId);
@@ -9163,7 +9942,7 @@ function createPaintEffectsToolProvider(controller, options = {}) {
       if (target === PAINT_TARGET) {
         if (changes.opacity !== void 0) throw new Error("opacity does not apply to the effect paint: change the brush opacity (set_brush tip.opacity).");
         const p = controller.getEffectPaint();
-        await controller.setEffectPaint({ effect: p.effect, values: { ...p.values, ..._nullishCoalesce(changes.values, () => ( {})) }, time: p.time });
+        await controller.setEffectPaint({ effect: p.effect, values: { ...p.values, ..._nullishCoalesce(changes.values, () => ( {})) }, time: p.time, map: p.map, live: p.live });
         const effects2 = paintInfo();
         return { target, effect: effects2[0], effects: effects2 };
       }
@@ -9222,13 +10001,25 @@ function createPaintEffectsToolProvider(controller, options = {}) {
       {
         name: "set_effect_paint",
         title: "Paint with an effect",
-        description: `Makes brushes paint with a provider generator, overlay or title effect (search_effects with use generator, overlay or title): it is rendered once at the canvas size, and each stroke then takes every pixel's colour from it, fixed to the canvas, as if painting a hidden picture into view (the effect's transparency paints nothing). Dab, particle and bristle brushes take the colour per pixel; mixer brushes and dab brushes that pick up paint take it per dab, at its centre. Wet, impasto and sticker brushes refuse it (paint the shape and use fill_layer_with_effect with lockTransparency instead); erasers, blenders and smudges ignore it. It replaces the paint colour or gradient until set_color or set_paint; a brush with its own gradient paints that instead. Strokes record it and replay exactly. Editor state, not an undo step. Returns the effect paint: { effect, provider, values (every control), time } (list_applied_effects target "paint" shows it; update_effect / remove_effect with target and effect "paint" change or clear it).`,
+        description: `Makes brushes paint with a provider generator, overlay or title effect (search_effects with use generator, overlay or title): it is rendered once at the canvas size, and each stroke then takes every pixel's colour from it, fixed to the canvas, as if painting a hidden picture into view (the effect's transparency paints nothing). Dab, particle and bristle brushes take the colour per pixel; mixer brushes and dab brushes that pick up paint take it per dab, at its centre. Watercolour, gouache, oil and impasto brushes take it per pixel too, shifted by paint they pick up (in wet paint the pattern then flows with the water; impasto keeps its relief), and sprayed stickers take the colour at their centre. Erasers, blenders and smudges ignore it. It replaces the paint colour or gradient until set_color or set_paint; a brush with its own gradient paints that instead. Strokes record it and replay exactly. Editor state, not an undo step. Returns the effect paint: { effect, provider, values (every control), time } (list_applied_effects target "paint" shows it; update_effect / remove_effect with target and effect "paint" change or clear it).`,
         inputSchema: {
           type: "object",
           properties: {
             effect: ctx.effectIdSchema(["generator", "overlay", "title"]),
             values: ctx.valuesSchema("Control values over the effect's defaults"),
-            time: { type: "number", minimum: 0, description: "Which moment of an animated effect to paint with, in ms (default 0)." }
+            time: { type: "number", minimum: 0, description: "Which moment of an animated effect to paint with, in ms (default 0)." },
+            map: {
+              type: "object",
+              description: "How the effect lies on the paint: by canvas (default: fixed to the canvas, painting reveals a hidden picture) or by stroke (along each stroke: the effect is rendered as a strip length px long, and each pixel takes the colour at its distance along the stroke and its place across the tip).",
+              properties: {
+                by: { type: "string", enum: ["canvas", "stroke"], description: "canvas (default) or stroke." },
+                length: { type: "number", minimum: 16, maximum: 4096, description: "by stroke: px of stroke per repeat of the effect (default 300)." },
+                repeat: { type: "string", enum: ["repeat", "mirror", "clamp"], description: "by stroke: past the strip end start again (default), run back, or hold the last colour." }
+              },
+              required: ["by"],
+              additionalProperties: false
+            },
+            live: { type: "boolean", description: "Live effect paint (default false): strokes on a stroke layer (add_layer type strokes) keep playing the effect, so the paint moves (set_effect_playback); elsewhere strokes bake the frame at time." }
           },
           required: ["effect"],
           additionalProperties: false
@@ -9236,9 +10027,24 @@ function createPaintEffectsToolProvider(controller, options = {}) {
         annotations: { title: "Paint with an effect", ...ctx.annotations.writeIdempotent },
         handler: async (args) => {
           ctx.requireProvider();
-          return { effectPaint: await controller.setEffectPaint({ effect: args.effect, values: values(args.values), time: args.time }) };
+          return { effectPaint: await controller.setEffectPaint({ effect: args.effect, values: values(args.values), time: args.time, map: args.map, live: args.live }) };
         }
       },
+      {
+        name: "set_effect_playback",
+        title: "Play or pause live effect paint",
+        description: "Plays or pauses live effect paint (strokes painted on stroke layers with set_effect_paint live true) in the editor view, and caps its frame rate. Exports draw it at a chosen time with export_image / export_psd time. Editor state, not an undo step. Returns playing, fps, the time the view shows (ms) and what plays (animation: layer ids, live strokes, sources; null when nothing does).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            playing: { type: "boolean", description: "Play (true, the default state) or pause at the current frame." },
+            fps: { type: "integer", minimum: 1, maximum: 60, description: "Frame rate cap, frames a second (default 30); lower it on large canvases." }
+          },
+          additionalProperties: false
+        },
+        annotations: { title: "Play or pause live effect paint", ...ctx.annotations.writeIdempotent },
+        handler: async (args) => ({ ...controller.setEffectPlayback({ playing: args.playing, fps: args.fps }), animation: controller.getAnimation() })
+      },
       {
         name: "add_effect_layer",
         title: "Add an effect layer",
@@ -9634,4 +10440,14 @@ function createPaintEditorDocument(controller, options = {}) {
 
 
 
-exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkOLNIPTB3cjs.BLEND_MODES; exports.BRUSH_ID = _chunkNKTNLJUJcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkNKTNLJUJcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkNKTNLJUJcjs.BUILTIN_BRUSHES; exports.BristleStroke = _chunkNKTNLJUJcjs.BristleStroke; exports.DEFAULT_BEHAVIOR = _chunkNKTNLJUJcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkNKTNLJUJcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkNKTNLJUJcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkNKTNLJUJcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkXFYLA3ZOcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkNKTNLJUJcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkNKTNLJUJcjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = _chunkNKTNLJUJcjs.DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkNKTNLJUJcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkNKTNLJUJcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkNKTNLJUJcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkXFYLA3ZOcjs.DEFAULT_WET_PARAMS; exports.DryStroke = _chunkNKTNLJUJcjs.DryStroke; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPQ3H2AANcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPQ3H2AANcjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunk7PT4RJL5cjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = _chunkNKTNLJUJcjs.IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkNKTNLJUJcjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunkPQ3H2AANcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunkNKTNLJUJcjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkOLNIPTB3cjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkNKTNLJUJcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkNKTNLJUJcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkPQ3H2AANcjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkPQ3H2AANcjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TARGET = PAINT_TARGET; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = _chunkNKTNLJUJcjs.PAPER_FAMILIES; exports.PAPER_LIBRARY = _chunkNKTNLJUJcjs.PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunkNKTNLJUJcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkNKTNLJUJcjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkPQ3H2AANcjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkPQ3H2AANcjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPQ3H2AANcjs.PaperGrain; exports.ParticleStroke = _chunkNKTNLJUJcjs.ParticleStroke; exports.PenDabWalker = _chunkNKTNLJUJcjs.PenDabWalker; exports.PenSmoother = _chunkNKTNLJUJcjs.PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkNKTNLJUJcjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerSpray = _chunkNKTNLJUJcjs.StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunkPQ3H2AANcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkXFYLA3ZOcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkNKTNLJUJcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkXFYLA3ZOcjs.WET_PARAM_KEYS; exports.WET_PARAM_SCHEMA = WET_PARAM_SCHEMA; exports.WET_PARAM_SLIDERS = WET_PARAM_SLIDERS; exports.WET_SPEED_SLIDER = WET_SPEED_SLIDER; exports.WET_TILT_SLIDERS = WET_TILT_SLIDERS; exports.WET_TOOLS = _chunkNKTNLJUJcjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkPQ3H2AANcjs.addPaintGradientStop; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkNKTNLJUJcjs.brushTakesPaint; exports.brushToJSON = _chunkNKTNLJUJcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = _chunkNKTNLJUJcjs.clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = _chunkNKTNLJUJcjs.drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = _chunkNKTNLJUJcjs.effectPaintKey; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPQ3H2AANcjs.grainCatch; exports.grainHeights = _chunkPQ3H2AANcjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunkPQ3H2AANcjs.hash2; exports.hexToPaintRgb = _chunkPQ3H2AANcjs.hexToPaintRgb; exports.hexToRgb8 = _chunkNKTNLJUJcjs.hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunk7PT4RJL5cjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkOLNIPTB3cjs.isBlendMode; exports.isGradientPaint = _chunkPQ3H2AANcjs.isGradientPaint; exports.isPaintEffectPaint = _chunkNKTNLJUJcjs.isPaintEffectPaint; exports.isPainterlyBlendMode = _chunkOLNIPTB3cjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkNKTNLJUJcjs.isWetBrush; exports.isWetCapable = _chunkNKTNLJUJcjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunkPQ3H2AANcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = _chunkNKTNLJUJcjs.mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.multiColorToPaint = _chunkNKTNLJUJcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkNKTNLJUJcjs.normalizeBehavior; exports.normalizeBristle = _chunkNKTNLJUJcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkNKTNLJUJcjs.normalizeDynamics; exports.normalizeFlow = _chunkXFYLA3ZOcjs.normalizeFlow; exports.normalizeHexColor = _chunkPQ3H2AANcjs.normalizeHexColor; exports.normalizeImpasto = _chunkNKTNLJUJcjs.normalizeImpasto; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkNKTNLJUJcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkNKTNLJUJcjs.normalizePaintBrush; exports.normalizePaper = _chunkNKTNLJUJcjs.normalizePaper; exports.normalizeParticle = _chunkNKTNLJUJcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkNKTNLJUJcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = _chunkNKTNLJUJcjs.normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkNKTNLJUJcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkXFYLA3ZOcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkPQ3H2AANcjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkPQ3H2AANcjs.paintSourceColor; exports.paintSourceCss = _chunkPQ3H2AANcjs.paintSourceCss; exports.paintToMultiColor = _chunkNKTNLJUJcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = _chunkNKTNLJUJcjs.paperPreset; exports.parseBrushLibrary = _chunkNKTNLJUJcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkPQ3H2AANcjs.parsePaintSource; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = _chunkNKTNLJUJcjs.penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunkPQ3H2AANcjs.rand01; exports.randSigned = _chunkPQ3H2AANcjs.randSigned; exports.readPaintEffectPaint = _chunkNKTNLJUJcjs.readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkPQ3H2AANcjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkPQ3H2AANcjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = _chunkNKTNLJUJcjs.renderPaper; exports.renderStickers = _chunkNKTNLJUJcjs.renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkPQ3H2AANcjs.resolvePaintGradient; exports.reversePaintGradient = _chunkPQ3H2AANcjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleEffectAt = _chunkNKTNLJUJcjs.sampleEffectAt; exports.sampleEffectField = _chunkNKTNLJUJcjs.sampleEffectField; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkPQ3H2AANcjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunkPQ3H2AANcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkPQ3H2AANcjs.solidPaint; exports.stampCoverage = _chunkNKTNLJUJcjs.stampCoverage; exports.standardBlendMode = _chunkOLNIPTB3cjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = _chunkNKTNLJUJcjs.stickerAt; exports.stickerRect = _chunkNKTNLJUJcjs.stickerRect; exports.stickerSurface = _chunkNKTNLJUJcjs.stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = _chunkNKTNLJUJcjs.tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = _chunkNKTNLJUJcjs.toStrokePoint; exports.toggleStamp = toggleStamp; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkPQ3H2AANcjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkNKTNLJUJcjs.usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wetEngineSummary = wetEngineSummary; exports.wetPaperInput = wetPaperInput; exports.wetPigmentOf = wetPigmentOf; exports.wetSupport = _chunkXFYLA3ZOcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunk7PT4RJL5cjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;
+
+
+
+
+
+
+
+
+
+
+exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkOLNIPTB3cjs.BLEND_MODES; exports.BRUSH_ID = _chunk5BR7LC24cjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunk5BR7LC24cjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunk5BR7LC24cjs.BUILTIN_BRUSHES; exports.BristleStroke = _chunk5BR7LC24cjs.BristleStroke; exports.DEFAULT_BEHAVIOR = _chunk5BR7LC24cjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunk5BR7LC24cjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunk5BR7LC24cjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunk5BR7LC24cjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkXFYLA3ZOcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunk5BR7LC24cjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunk5BR7LC24cjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = _chunk5BR7LC24cjs.DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunk5BR7LC24cjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunk5BR7LC24cjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunk5BR7LC24cjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkXFYLA3ZOcjs.DEFAULT_WET_PARAMS; exports.DryStroke = _chunk5BR7LC24cjs.DryStroke; exports.EFFECT_MAP_REPEATS = _chunk5BR7LC24cjs.EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = _chunk5BR7LC24cjs.EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPQ3H2AANcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPQ3H2AANcjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunk7PT4RJL5cjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = _chunk5BR7LC24cjs.IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunk5BR7LC24cjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LIVE_STROKE_ENGINES = LIVE_STROKE_ENGINES; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunkPQ3H2AANcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunk5BR7LC24cjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkOLNIPTB3cjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunk5BR7LC24cjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunk5BR7LC24cjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkPQ3H2AANcjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkPQ3H2AANcjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TARGET = PAINT_TARGET; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = _chunk5BR7LC24cjs.PAPER_FAMILIES; exports.PAPER_LIBRARY = _chunk5BR7LC24cjs.PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunk5BR7LC24cjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunk5BR7LC24cjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkPQ3H2AANcjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkPQ3H2AANcjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPQ3H2AANcjs.PaperGrain; exports.ParticleStroke = _chunk5BR7LC24cjs.ParticleStroke; exports.PenDabWalker = _chunk5BR7LC24cjs.PenDabWalker; exports.PenSmoother = _chunk5BR7LC24cjs.PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunk5BR7LC24cjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerSpray = _chunk5BR7LC24cjs.StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunkPQ3H2AANcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkXFYLA3ZOcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunk5BR7LC24cjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkXFYLA3ZOcjs.WET_PARAM_KEYS; exports.WET_PARAM_SCHEMA = WET_PARAM_SCHEMA; exports.WET_PARAM_SLIDERS = WET_PARAM_SLIDERS; exports.WET_SPEED_SLIDER = WET_SPEED_SLIDER; exports.WET_TILT_SLIDERS = WET_TILT_SLIDERS; exports.WET_TOOLS = _chunk5BR7LC24cjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkPQ3H2AANcjs.addPaintGradientStop; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunk5BR7LC24cjs.brushTakesPaint; exports.brushToJSON = _chunk5BR7LC24cjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = _chunk5BR7LC24cjs.clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = _chunk5BR7LC24cjs.drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = _chunk5BR7LC24cjs.effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = _chunk5BR7LC24cjs.effectPaintKey; exports.effectPaintSize = _chunk5BR7LC24cjs.effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPQ3H2AANcjs.grainCatch; exports.grainHeights = _chunkPQ3H2AANcjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunkPQ3H2AANcjs.hash2; exports.hexToPaintRgb = _chunkPQ3H2AANcjs.hexToPaintRgb; exports.hexToRgb8 = _chunk5BR7LC24cjs.hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunk7PT4RJL5cjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkOLNIPTB3cjs.isBlendMode; exports.isGradientPaint = _chunkPQ3H2AANcjs.isGradientPaint; exports.isPaintEffectPaint = _chunk5BR7LC24cjs.isPaintEffectPaint; exports.isPainterlyBlendMode = _chunkOLNIPTB3cjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunk5BR7LC24cjs.isWetBrush; exports.isWetCapable = _chunk5BR7LC24cjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunkPQ3H2AANcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = _chunk5BR7LC24cjs.mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.multiColorToPaint = _chunk5BR7LC24cjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunk5BR7LC24cjs.normalizeBehavior; exports.normalizeBristle = _chunk5BR7LC24cjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunk5BR7LC24cjs.normalizeDynamics; exports.normalizeFlow = _chunkXFYLA3ZOcjs.normalizeFlow; exports.normalizeHexColor = _chunkPQ3H2AANcjs.normalizeHexColor; exports.normalizeImpasto = _chunk5BR7LC24cjs.normalizeImpasto; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunk5BR7LC24cjs.normalizeMultiColor; exports.normalizePaintBrush = _chunk5BR7LC24cjs.normalizePaintBrush; exports.normalizePaper = _chunk5BR7LC24cjs.normalizePaper; exports.normalizeParticle = _chunk5BR7LC24cjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunk5BR7LC24cjs.normalizeStickerSettings; exports.normalizeStickerUpdate = _chunk5BR7LC24cjs.normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunk5BR7LC24cjs.normalizeWetBrush; exports.normalizeWetParams = _chunkXFYLA3ZOcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkPQ3H2AANcjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkPQ3H2AANcjs.paintSourceColor; exports.paintSourceCss = _chunkPQ3H2AANcjs.paintSourceCss; exports.paintToMultiColor = _chunk5BR7LC24cjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = _chunk5BR7LC24cjs.paperPreset; exports.parseBrushLibrary = _chunk5BR7LC24cjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkPQ3H2AANcjs.parsePaintSource; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = _chunk5BR7LC24cjs.penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunkPQ3H2AANcjs.rand01; exports.randSigned = _chunkPQ3H2AANcjs.randSigned; exports.readEffectStrokeMap = _chunk5BR7LC24cjs.readEffectStrokeMap; exports.readPaintEffectPaint = _chunk5BR7LC24cjs.readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkPQ3H2AANcjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkPQ3H2AANcjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = _chunk5BR7LC24cjs.renderPaper; exports.renderStickers = _chunk5BR7LC24cjs.renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkPQ3H2AANcjs.resolvePaintGradient; exports.reversePaintGradient = _chunkPQ3H2AANcjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleEffectAt = _chunk5BR7LC24cjs.sampleEffectAt; exports.sampleEffectField = _chunk5BR7LC24cjs.sampleEffectField; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkPQ3H2AANcjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunkPQ3H2AANcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkPQ3H2AANcjs.solidPaint; exports.stampCoverage = _chunk5BR7LC24cjs.stampCoverage; exports.standardBlendMode = _chunkOLNIPTB3cjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = _chunk5BR7LC24cjs.stickerAt; exports.stickerRect = _chunk5BR7LC24cjs.stickerRect; exports.stickerSurface = _chunk5BR7LC24cjs.stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = _chunk5BR7LC24cjs.tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = _chunk5BR7LC24cjs.toStrokePoint; exports.toggleStamp = toggleStamp; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkPQ3H2AANcjs.updatePaintGradientStop; exports.usesPaintExchange = _chunk5BR7LC24cjs.usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wetEngineSummary = wetEngineSummary; exports.wetPaperInput = wetPaperInput; exports.wetPigmentOf = wetPigmentOf; exports.wetSupport = _chunkXFYLA3ZOcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunk7PT4RJL5cjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;