@pixerate/editor 0.262.1 → 0.264.0

package/dist/paint-editor/index.cjs

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21;
 
 
-var _chunkRVGP2XLFcjs = require('../chunk-RVGP2XLF.cjs');
+var _chunkXORJ7UZOcjs = require('../chunk-XORJ7UZO.cjs');
 
 
 
@@ -11,11 +11,11 @@ var _chunkRVGP2XLFcjs = require('../chunk-RVGP2XLF.cjs');
 
 
 
-var _chunkPYTJBVW5cjs = require('../chunk-PYTJBVW5.cjs');
+var _chunkF3KKR6DDcjs = require('../chunk-F3KKR6DD.cjs');
 
 
 
-var _chunkAVTPZO4Zcjs = require('../chunk-AVTPZO4Z.cjs');
+var _chunkPE6YJMQTcjs = require('../chunk-PE6YJMQT.cjs');
 
 
 var _chunkCBVNCWJMcjs = require('../chunk-CBVNCWJM.cjs');
@@ -30,7 +30,7 @@ var _chunk7TD63DZPcjs = require('../chunk-7TD63DZP.cjs');
 
 
 
-var _chunk43NT242Dcjs = require('../chunk-43NT242D.cjs');
+var _chunkKXNZNOEFcjs = require('../chunk-KXNZNOEF.cjs');
 require('../chunk-3ZRNK3RO.cjs');
 
 
@@ -88,7 +88,7 @@ var _chunkJLWLX52Lcjs = require('../chunk-JLWLX52L.cjs');
 
 
 var _chunkK7ENM55Pcjs = require('../chunk-K7ENM55P.cjs');
-require('../chunk-7AUQ2UJ3.cjs');
+require('../chunk-USJX5SW4.cjs');
 
 
 
@@ -143,7 +143,7 @@ require('../chunk-7AUQ2UJ3.cjs');
 
 
 
-var _chunkTZOX7KWVcjs = require('../chunk-TZOX7KWV.cjs');
+var _chunkBY5EBP26cjs = require('../chunk-BY5EBP26.cjs');
 
 
 
@@ -151,7 +151,8 @@ var _chunkTZOX7KWVcjs = require('../chunk-TZOX7KWV.cjs');
 
 
 
-var _chunkJSDND7DFcjs = require('../chunk-JSDND7DF.cjs');
+
+var _chunkOTN6VB5Scjs = require('../chunk-OTN6VB5S.cjs');
 require('../chunk-CVFAAZXE.cjs');
 
 
@@ -603,13 +604,13 @@ var samplers = /* @__PURE__ */ new WeakMap();
 function stampSampler(ref2, art) {
   let kind = null;
   try {
-    kind = _chunkJSDND7DFcjs.editorStampOf.call(void 0, ref2.includes(":") ? ref2 : `editor:${ref2}`);
+    kind = _chunkOTN6VB5Scjs.editorStampOf.call(void 0, ref2.includes(":") ? ref2 : `editor:${ref2}`);
   } catch (e3) {
     return null;
   }
   if (kind) {
     const k = kind;
-    return (u, v, seed) => _chunkJSDND7DFcjs.stampCoverage.call(void 0, k, u, v, seed);
+    return (u, v, seed) => _chunkOTN6VB5Scjs.stampCoverage.call(void 0, k, u, v, seed);
   }
   const a = _optionalChain([art, 'optionalCall', _5 => _5(ref2)]);
   if (!a || !(a.width > 0 && a.height > 0)) return null;
@@ -1737,7 +1738,7 @@ function shadowToLight(shadow) {
   return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
 }
 function lightTwinBrush(brush) {
-  return _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, 
+  return _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, 
     {
       tip: { ...brush.tip, blend: "normal", pressureOpacity: brush.tip.pressureOpacity || brush.light.pressure },
       behavior: { ...brush.behavior, mixing: "rgb" },
@@ -2538,49 +2539,77 @@ var defaultStickerRasterizer = async (asset, size) => {
   const img = ctx.getImageData(0, 0, w, h);
   return { width: w, height: h, data: img.data };
 };
-var StickerArtCache = (_class10 = class {constructor() { _class10.prototype.__init52.call(this);_class10.prototype.__init53.call(this); }
+var StickerArtCache = (_class10 = class _StickerArtCache {constructor() { _class10.prototype.__init52.call(this);_class10.prototype.__init53.call(this);_class10.prototype.__init54.call(this);_class10.prototype.__init55.call(this); }
   __init52() {this.entries = /* @__PURE__ */ new Map()}
-  /** The art for `ref` when it has loaded (editor stamps never need any). */
-  __init53() {this.get = (ref2) => {
-    const e = this.entries.get(ref2);
+  /** Descriptions by ref (their variants pick the art), shared by the loads that need them. */
+  __init53() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init54() {this.variants = /* @__PURE__ */ new Map()}
+  static key(ref2, variant = "light") {
+    return variant === "dark" ? `${ref2}#dark` : ref2;
+  }
+  /** The art for `ref` in `variant` (default `light`) when it has loaded (editor stamps never need any). */
+  __init55() {this.get = (ref2, variant) => {
+    const e = this.entries.get(_StickerArtCache.key(ref2, variant));
     return _optionalChain([e, 'optionalAccess', _47 => _47.status]) === "ready" ? e.art : void 0;
   }}
+  /** The variant to draw `ref` in on a dark or light background: `dark` once the sticker is known to have it. */
+  variantFor(ref2, dark) {
+    return dark && _optionalChain([this, 'access', _48 => _48.variants, 'access', _49 => _49.get, 'call', _50 => _50(ref2), 'optionalAccess', _51 => _51.includes, 'call', _52 => _52("dark")]) ? "dark" : "light";
+  }
   /** `ready`, `loading`, `failed` (with the reason) or `none` (never asked for). Editor stamps are always `ready`. */
-  status(ref2) {
-    if (_chunkJSDND7DFcjs.editorStampOf.call(void 0, ref2)) return { status: "ready" };
-    const e = this.entries.get(ref2);
-    if (!e) return { status: "none" };
+  status(ref2, variant) {
+    if (_chunkOTN6VB5Scjs.editorStampOf.call(void 0, ref2)) return { status: "ready" };
+    const e = this.entries.get(_StickerArtCache.key(ref2, variant));
+    if (!e) return this.descriptions.has(ref2) && !this.variants.has(ref2) ? { status: "loading" } : { status: "none" };
     return e.status === "failed" ? { status: "failed", error: e.error } : { status: e.status };
   }
   /**
-   * Loads and rasterises `ref` from `provider` once (later calls share the load). Unknown refs
-   * reject with the closest known ones; failures are kept so they are reported, and retried on
-   * the next call.
+   * Loads and rasterises `ref` from `provider` once per variant (later calls share the load): the
+   * dark variant when `dark` and the sticker has one, else the light. Unknown refs reject with the
+   * closest known ones; failures are kept so they are reported, and retried on the next call.
    */
-  ensure(provider, ref2, rasterize) {
-    if (_chunkJSDND7DFcjs.editorStampOf.call(void 0, ref2)) return Promise.resolve(null);
-    const e = this.entries.get(ref2);
-    if (_optionalChain([e, 'optionalAccess', _48 => _48.status]) === "ready") return Promise.resolve(e.art);
-    if (_optionalChain([e, 'optionalAccess', _49 => _49.status]) === "loading") return e.promise;
+  async ensure(provider, ref2, rasterize, dark = false) {
+    if (_chunkOTN6VB5Scjs.editorStampOf.call(void 0, ref2)) return null;
+    let described = this.descriptions.get(ref2);
+    if (!described) {
+      described = _chunkPE6YJMQTcjs.describeStickerRef.call(void 0, provider, ref2);
+      this.descriptions.set(ref2, described);
+    }
+    let d;
+    try {
+      d = await described;
+    } catch (err) {
+      this.descriptions.delete(ref2);
+      this.entries.set(_StickerArtCache.key(ref2), { status: "failed", error: err instanceof Error ? err.message : String(err) });
+      throw err;
+    }
+    this.variants.set(ref2, _nullishCoalesce(d.variants, () => ( ["light"])));
+    return this.load(provider, ref2, d, _chunkOTN6VB5Scjs.stickerVariantFor.call(void 0, d, dark), rasterize);
+  }
+  load(provider, ref2, d, variant, rasterize) {
+    const key = _StickerArtCache.key(ref2, variant);
+    const e = this.entries.get(key);
+    if (_optionalChain([e, 'optionalAccess', _53 => _53.status]) === "ready") return Promise.resolve(e.art);
+    if (_optionalChain([e, 'optionalAccess', _54 => _54.status]) === "loading") return e.promise;
     const promise = (async () => {
-      const d = await _chunkAVTPZO4Zcjs.describeStickerRef.call(void 0, provider, ref2);
-      const id = _chunkJSDND7DFcjs.stickerIdFor.call(void 0, provider, ref2);
+      const id = _chunkOTN6VB5Scjs.stickerIdFor.call(void 0, provider, ref2);
       const max = _nullishCoalesce(provider.capabilities.maxSize, () => ( STICKER_ART_SIZE));
       const size = Math.min(STICKER_ART_SIZE, max);
-      const asset = await provider.load(id, d.formats.includes("png") ? { format: "png", size } : { format: _nullishCoalesce(d.formats[0], () => ( "svg")), size });
+      const v = variant === "dark" ? { variant } : {};
+      const asset = await provider.load(id, d.formats.includes("png") ? { format: "png", size, ...v } : { format: _nullishCoalesce(d.formats[0], () => ( "svg")), size, ...v });
       const px = await rasterize(asset, size);
       if (!(px.width > 0 && px.height > 0) || px.data.length !== px.width * px.height * 4) throw new (0, _chunkU67EN7GGcjs.StickerError)("load_failed", `The art for "${ref2}" came back empty or the wrong size.`);
       return { ...px, tintable: d.tintable };
     })();
-    this.entries.set(ref2, { status: "loading", promise });
+    this.entries.set(key, { status: "loading", promise });
     return promise.then(
       (art) => {
-        this.entries.set(ref2, { status: "ready", art });
+        this.entries.set(key, { status: "ready", art });
         return art;
       },
       (err) => {
         const message = err instanceof Error ? err.message : String(err);
-        this.entries.set(ref2, { status: "failed", error: message });
+        this.entries.set(key, { status: "failed", error: message });
         throw err;
       }
     );
@@ -2588,6 +2617,8 @@ var StickerArtCache = (_class10 = class {constructor() { _class10.prototype.__in
   /** Forgets every load (a new provider). */
   clear() {
     this.entries.clear();
+    this.descriptions.clear();
+    this.variants.clear();
   }
 }, _class10);
 function sampleArt(art, x, y, out) {
@@ -2635,17 +2666,17 @@ function stickerRect(s) {
 function stickerStamp(s) {
   if (s.ref) {
     try {
-      return _chunkJSDND7DFcjs.editorStampOf.call(void 0, s.ref);
+      return _chunkOTN6VB5Scjs.editorStampOf.call(void 0, s.ref);
     } catch (e4) {
       return null;
     }
   }
-  return s.stamp && _chunkJSDND7DFcjs.STAMP_KINDS.includes(s.stamp) ? s.stamp : null;
+  return s.stamp && _chunkOTN6VB5Scjs.STAMP_KINDS.includes(s.stamp) ? s.stamp : null;
 }
 function drawSticker(medium, s, art) {
   const kind = stickerStamp(s);
   if (!kind) {
-    const a2 = _optionalChain([art, 'optionalCall', _50 => _50(s.ref)]);
+    const a2 = _optionalChain([art, 'optionalCall', _55 => _55(s.ref, s.variant)]);
     return a2 ? drawArtSticker(medium, s, a2) : stickerRect(s);
   }
   const rect = stickerRect(s);
@@ -2665,7 +2696,7 @@ function drawSticker(medium, s, art) {
       const v = (-dx * sa + dy * ca) / rad2;
       if (u < -1.05 || u > 1.05 || v < -1.05 || v > 1.05) continue;
       let c = 0;
-      for (let k = 0; k < 4; k++) c += _chunkJSDND7DFcjs.stampCoverage.call(void 0, kind, u + ((k & 1) - 0.5) / rad2 / 2, v + ((k >> 1) - 0.5) / rad2 / 2, s.seed);
+      for (let k = 0; k < 4; k++) c += _chunkOTN6VB5Scjs.stampCoverage.call(void 0, kind, u + ((k & 1) - 0.5) / rad2 / 2, v + ((k >> 1) - 0.5) / rad2 / 2, s.seed);
       c /= 4;
       if (c <= 0) continue;
       cov[p] = c;
@@ -2728,7 +2759,7 @@ function jitterColor(hex2, amount, seed, i) {
   return "#" + [out.r, out.g, out.b].map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join("");
 }
 var StickerSpray = (_class11 = class {
-  constructor(init) {;_class11.prototype.__init54.call(this);_class11.prototype.__init55.call(this);_class11.prototype.__init56.call(this);_class11.prototype.__init57.call(this);_class11.prototype.__init58.call(this);
+  constructor(init) {;_class11.prototype.__init56.call(this);_class11.prototype.__init57.call(this);_class11.prototype.__init58.call(this);_class11.prototype.__init59.call(this);_class11.prototype.__init60.call(this);
     this.init = init;
     const b = init.brush;
     this.smoother = new PenSmoother(b.tip.smoothing, b.pressureSmoothing);
@@ -2740,16 +2771,16 @@ var StickerSpray = (_class11 = class {
     this.next = init.nextId;
   }
   
-  __init54() {this.dabCount = 0}
-  __init55() {this.stickers = []}
+  __init56() {this.dabCount = 0}
+  __init57() {this.stickers = []}
   /** Refs the spray picked but could not draw because their art had not loaded. */
-  __init56() {this.skipped = /* @__PURE__ */ new Set()}
+  __init58() {this.skipped = /* @__PURE__ */ new Set()}
   
   
   
   
-  __init57() {this.lastRaw = null}
-  __init58() {this.lastFed = null}
+  __init59() {this.lastRaw = null}
+  __init60() {this.lastFed = null}
   
   push(points) {
     const rects = [];
@@ -2792,7 +2823,8 @@ var StickerSpray = (_class11 = class {
     }
     const ref2 = _nullishCoalesce(st.stamps[Math.floor(_chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 57) * st.stamps.length)], () => ( "editor:dot"));
     const stamp = stickerStamp({ ref: ref2 });
-    if (!stamp && !_optionalChain([this, 'access', _51 => _51.init, 'access', _52 => _52.art, 'optionalCall', _53 => _53(ref2)])) {
+    const variant = stamp ? "light" : _nullishCoalesce(_optionalChain([this, 'access', _56 => _56.init, 'access', _57 => _57.variant, 'optionalCall', _58 => _58(ref2)]), () => ( "light"));
+    if (!stamp && !_optionalChain([this, 'access', _59 => _59.init, 'access', _60 => _60.art, 'optionalCall', _61 => _61(ref2, variant)])) {
       this.skipped.add(ref2);
       this.next++;
       return;
@@ -2807,7 +2839,8 @@ var StickerSpray = (_class11 = class {
       rotation: Math.round((-d.angle * 180 / Math.PI + (_chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 59) * 2 - 1) * 180 * st.rotationJitter) * 10) / 10,
       color: st.colorJitter > 0 ? jitterColor(base.color, st.colorJitter, seed, i) : base.color,
       opacity: Math.round(Math.min(1, d.opacity * this.init.brush.tip.opacity * base.alpha) * 1e3) / 1e3,
-      seed: Math.floor(_chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 65) * 1e9)
+      seed: Math.floor(_chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 65) * 1e9),
+      ...variant === "dark" ? { variant } : {}
     };
     this.stickers.push(sticker);
     rects.push(drawSticker(this.medium, sticker, this.init.art));
@@ -2837,12 +2870,12 @@ function normalizeStickerUpdate(u) {
   const out = {};
   if (u.ref !== void 0 && u.stamp !== void 0) throw new Error("Give ref or stamp, not both (stamp is the older name for an editor stamp).");
   if (u.stamp !== void 0) {
-    if (!_chunkJSDND7DFcjs.STAMP_KINDS.includes(u.stamp)) throw new Error(`stamp ${JSON.stringify(u.stamp)} is not a stamp; use ${_chunkJSDND7DFcjs.STAMP_KINDS.join(", ")}, or ref for any sticker (find_stickers).`);
+    if (!_chunkOTN6VB5Scjs.STAMP_KINDS.includes(u.stamp)) throw new Error(`stamp ${JSON.stringify(u.stamp)} is not a stamp; use ${_chunkOTN6VB5Scjs.STAMP_KINDS.join(", ")}, or ref for any sticker (find_stickers).`);
     out.ref = `editor:${u.stamp}`;
     out.stamp = u.stamp;
   }
   if (u.ref !== void 0) {
-    out.ref = _chunkJSDND7DFcjs.normalizeStickerRef.call(void 0, u.ref);
+    out.ref = _chunkOTN6VB5Scjs.normalizeStickerRef.call(void 0, u.ref);
     const stamp = stickerStamp({ ref: out.ref });
     if (stamp) out.stamp = stamp;
     else out.stamp = void 0;
@@ -2911,10 +2944,10 @@ function stickerAt(stickers, x, y, art) {
     if (s.size < 16) return s;
     const kind = stickerStamp(s);
     if (kind) {
-      if (_chunkJSDND7DFcjs.stampCoverage.call(void 0, kind, u, v, s.seed) > 0.25) return s;
+      if (_chunkOTN6VB5Scjs.stampCoverage.call(void 0, kind, u, v, s.seed) > 0.25) return s;
       continue;
     }
-    const pic = _optionalChain([art, 'optionalCall', _54 => _54(s.ref)]);
+    const pic = _optionalChain([art, 'optionalCall', _62 => _62(s.ref, s.variant)]);
     if (!pic) return s;
     const scale = Math.max(pic.width, pic.height) / 2;
     if (sampleArt(pic, u * scale + pic.width / 2, v * scale + pic.height / 2, [0, 0, 0, 0])[3] > 0.25) return s;
@@ -2942,7 +2975,7 @@ 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 = (_class12 = class _PaintStrokeSession {
-  constructor(host, init) {;_class12.prototype.__init59.call(this);_class12.prototype.__init60.call(this);_class12.prototype.__init61.call(this);_class12.prototype.__init62.call(this);_class12.prototype.__init63.call(this);_class12.prototype.__init64.call(this);_class12.prototype.__init65.call(this);_class12.prototype.__init66.call(this);_class12.prototype.__init67.call(this);_class12.prototype.__init68.call(this);_class12.prototype.__init69.call(this);_class12.prototype.__init70.call(this);_class12.prototype.__init71.call(this);_class12.prototype.__init72.call(this);_class12.prototype.__init73.call(this);_class12.prototype.__init74.call(this);
+  constructor(host, init) {;_class12.prototype.__init61.call(this);_class12.prototype.__init62.call(this);_class12.prototype.__init63.call(this);_class12.prototype.__init64.call(this);_class12.prototype.__init65.call(this);_class12.prototype.__init66.call(this);_class12.prototype.__init67.call(this);_class12.prototype.__init68.call(this);_class12.prototype.__init69.call(this);_class12.prototype.__init70.call(this);_class12.prototype.__init71.call(this);_class12.prototype.__init72.call(this);_class12.prototype.__init73.call(this);_class12.prototype.__init74.call(this);_class12.prototype.__init75.call(this);_class12.prototype.__init76.call(this);
     this.host = host;
     this.init = init;
     this.layerId = init.layerId;
@@ -2952,7 +2985,7 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
     const brush = init.brush;
     if (init.wet) this.wetDriver = init.wet.driver;
     if (init.light && !init.wet && !init.sticker) this.lightTwin = this.makeLightTwin(init.light.surface);
-    const effect = _nullishCoalesce(_optionalChain([init, 'access', _55 => _55.effect, 'optionalAccess', _56 => _56.pixels]), () => ( null));
+    const effect = _nullishCoalesce(_optionalChain([init, 'access', _63 => _63.effect, 'optionalAccess', _64 => _64.pixels]), () => ( null));
     this.apply = {
       mode: brush.engine === "eraser" ? "erase" : "paint",
       color: init.color,
@@ -2965,11 +2998,11 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
     };
     if (this.wetDriver) {
     } else if (init.sticker) {
-      this.stickerSpray = new StickerSpray({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: _nullishCoalesce(init.paint, () => ( null)), effect, art: init.sticker.art });
+      this.stickerSpray = new StickerSpray({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: _nullishCoalesce(init.paint, () => ( null)), effect, art: init.sticker.art, variant: init.sticker.variant });
     } 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)), effect });
-    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || _chunkTZOX7KWVcjs.usesPaintExchange.call(void 0, brush, Boolean(init.paint))) {
+    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || _chunkBY5EBP26cjs.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(),
@@ -2993,29 +3026,29 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
   
   
   /** The raw input so far (what a replay feeds back in). */
-  __init59() {this.points = []}
+  __init61() {this.points = []}
   
   
-  __init60() {this.touched = /* @__PURE__ */ new Set()}
-  __init61() {this.fresh = /* @__PURE__ */ new Set()}
-  __init62() {this.dry = null}
-  __init63() {this.wet = null}
-  __init64() {this.wetDriver = null}
-  __init65() {this.thickDriver = null}
-  __init66() {this.stickerSpray = null}
+  __init62() {this.touched = /* @__PURE__ */ new Set()}
+  __init63() {this.fresh = /* @__PURE__ */ new Set()}
+  __init64() {this.dry = null}
+  __init65() {this.wet = null}
+  __init66() {this.wetDriver = null}
+  __init67() {this.thickDriver = null}
+  __init68() {this.stickerSpray = null}
   /** Light paint: the stroke's twin over the light channel, and what it left there. */
-  __init67() {this.lightTwin = null}
-  __init68() {this.lightResult = null}
+  __init69() {this.lightTwin = null}
+  __init70() {this.lightResult = null}
   /** A wet stroke that ended while the simulation was mid-batch: it commits when the driver catches up. */
-  __init69() {this.wetEndPending = false}
+  __init71() {this.wetEndPending = false}
   
   
-  __init70() {this.bounds = null}
-  __init71() {this.lastRaw = null}
-  __init72() {this.closed = false}
-  __init73() {this.result = null}
+  __init72() {this.bounds = null}
+  __init73() {this.lastRaw = null}
+  __init74() {this.closed = false}
+  __init75() {this.result = null}
   /** The mask stencils this stroke was painted with when they are not the editor's (replays). */
-  __init74() {this.maskStencils = null}
+  __init76() {this.maskStencils = null}
   /** The stroke's twin over the light channel: the same marks in grey at the brush's light amount (see `light.ts`). */
   makeLightTwin(light) {
     const init = this.init;
@@ -3056,11 +3089,11 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
       offset: this.init.offset,
       lockTransparency: this.init.lockTransparency,
       selection: _nullishCoalesce(this.init.selection, () => ( null)),
-      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _57 => _57.live, 'access', _58 => _58.get, 'call', _59 => _59(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _60 => _60.data]), () => ( null)),
+      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _65 => _65.live, 'access', _66 => _66.get, 'call', _67 => _67(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _68 => _68.data]), () => ( null)),
       writeTile: (tx, ty) => {
         const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
         if (!this.touched.has(key)) {
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _61 => _61.base, 'access', _62 => _62.tiles, 'access', _63 => _63.get, 'call', _64 => _64(key), 'optionalAccess', _65 => _65.data]), () => ( defaultTile(this.base)));
+          const src = _nullishCoalesce(_optionalChain([this, 'access', _69 => _69.base, 'access', _70 => _70.tiles, 'access', _71 => _71.get, 'call', _72 => _72(key), 'optionalAccess', _73 => _73.data]), () => ( defaultTile(this.base)));
           this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
           this.touched.add(key);
         }
@@ -3079,8 +3112,8 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
     if (filter) points = points.map(filter);
     for (const p of points) this.points.push(p);
     this.lastRaw = points[points.length - 1];
-    _optionalChain([this, 'access', _66 => _66.host, 'access', _67 => _67.sampled, 'optionalCall', _68 => _68(this, points)]);
-    _optionalChain([this, 'access', _69 => _69.lightTwin, 'optionalAccess', _70 => _70.push, 'call', _71 => _71(points)]);
+    _optionalChain([this, 'access', _74 => _74.host, 'access', _75 => _75.sampled, 'optionalCall', _76 => _76(this, points)]);
+    _optionalChain([this, 'access', _77 => _77.lightTwin, 'optionalAccess', _78 => _78.push, 'call', _79 => _79(points)]);
     if (this.wetDriver) {
       this.wetUpdate(this.wetDriver.push(points));
       return;
@@ -3093,7 +3126,7 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
   }
   /** Impasto strokes: the layer's thick-paint channels with the stroke so far. */
   thickChannels() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _72 => _72.thickDriver, 'optionalAccess', _73 => _73.channels, 'call', _74 => _74()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _80 => _80.thickDriver, 'optionalAccess', _81 => _81.channels, 'call', _82 => _82()]), () => ( null));
   }
   /** Shows a wet stroke's progress (the wet layer's display). */
   wetUpdate(rects) {
@@ -3139,8 +3172,8 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
       }
     }
     for (const [key, { tx, ty, r }] of regions) {
-      const src = _nullishCoalesce(_optionalChain([this, 'access', _75 => _75.base, 'access', _76 => _76.tiles, 'access', _77 => _77.get, 'call', _78 => _78(key), 'optionalAccess', _79 => _79.data]), () => ( defaultTile(this.base)));
-      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _80 => _80.live, 'access', _81 => _81.get, 'call', _82 => _82(key), 'optionalAccess', _83 => _83.data]) : void 0;
+      const src = _nullishCoalesce(_optionalChain([this, 'access', _83 => _83.base, 'access', _84 => _84.tiles, 'access', _85 => _85.get, 'call', _86 => _86(key), 'optionalAccess', _87 => _87.data]), () => ( defaultTile(this.base)));
+      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _88 => _88.live, 'access', _89 => _89.get, 'call', _90 => _90(key), 'optionalAccess', _91 => _91.data]) : void 0;
       this.touched.add(key);
       const data = _chunkFQPUF2W2cjs.applyStrokeToTile.call(void 0, this.dry.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
@@ -3162,7 +3195,7 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
     }
     this.update(this.dry ? this.dry.finish() : this.thickDriver ? this.thickDriver.finish() : this.stickerSpray ? this.stickerSpray.finish() : this.wet.finish());
     this.closed = true;
-    if (_optionalChain([this, 'access', _84 => _84.lightTwin, 'optionalAccess', _85 => _85.open])) this.lightTwin.end();
+    if (_optionalChain([this, 'access', _92 => _92.lightTwin, 'optionalAccess', _93 => _93.open])) this.lightTwin.end();
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
     let changed = false;
@@ -3177,8 +3210,8 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
     const surface = changed ? new (0, _chunk474IQG74cjs.TiledSurface)(ch, tiles, this.base.defaultValue) : null;
     const dabs = this.dry ? this.dry.dabCount : this.thickDriver ? this.thickDriver.dabCount : this.stickerSpray ? this.stickerSpray.dabCount : this.wet.dabCount;
     this.result = { layerId: this.layerId, bounds: changed ? this.bounds : null, dabs, strokeId: null };
-    if (_optionalChain([this, 'access', _86 => _86.stickerSpray, 'optionalAccess', _87 => _87.skipped, 'access', _88 => _88.size])) this.result.skippedStickers = [...this.stickerSpray.skipped];
-    const carried = _nullishCoalesce(_optionalChain([this, 'access', _89 => _89.wet, 'optionalAccess', _90 => _90.load]), () => ( _optionalChain([this, 'access', _91 => _91.thickDriver, 'optionalAccess', _92 => _92.load])));
+    if (_optionalChain([this, 'access', _94 => _94.stickerSpray, 'optionalAccess', _95 => _95.skipped, 'access', _96 => _96.size])) this.result.skippedStickers = [...this.stickerSpray.skipped];
+    const carried = _nullishCoalesce(_optionalChain([this, 'access', _97 => _97.wet, 'optionalAccess', _98 => _98.load]), () => ( _optionalChain([this, 'access', _99 => _99.thickDriver, 'optionalAccess', _100 => _100.load])));
     if (carried) this.result.mixerLoad = this.init.brush.behavior.dirty ? carried : _chunkFQPUF2W2cjs.cleanMixer.call(void 0, carried);
     this.host.commit(this, surface, false);
     return this.result;
@@ -3187,7 +3220,7 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
   cancel() {
     if (this.closed) return;
     this.closed = true;
-    if (_optionalChain([this, 'access', _93 => _93.lightTwin, 'optionalAccess', _94 => _94.open])) this.lightTwin.cancel();
+    if (_optionalChain([this, 'access', _101 => _101.lightTwin, 'optionalAccess', _102 => _102.open])) this.lightTwin.cancel();
     this.lightResult = null;
     this.host.commit(this, null, true);
   }
@@ -3209,7 +3242,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 } : _chunkFQPUF2W2cjs.EMPTY_MIXER_LOAD;
-  if (_chunkTZOX7KWVcjs.usesPaintExchange.call(void 0, brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
+  if (_chunkBY5EBP26cjs.usesPaintExchange.call(void 0, brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
   return _chunkFQPUF2W2cjs.EMPTY_MIXER_LOAD;
 }
 
@@ -3219,36 +3252,36 @@ var STENCIL_SHAPES = ["rect", "ellipse", "polygon"];
 var finite = (v) => typeof v === "number" && Number.isFinite(v);
 var pt = (p) => p && finite(p.x) && finite(p.y) ? { x: p.x, y: p.y } : void 0;
 function normalizeStencil(raw, id, base) {
-  const kind = STENCIL_KINDS.includes(raw.kind) ? raw.kind : _optionalChain([base, 'optionalAccess', _95 => _95.kind]);
+  const kind = STENCIL_KINDS.includes(raw.kind) ? raw.kind : _optionalChain([base, 'optionalAccess', _103 => _103.kind]);
   if (!kind) throw new Error(`kind ${JSON.stringify(raw.kind)} is not a stencil; use ${STENCIL_KINDS.join(", ")}.`);
   const s = {
     id,
     kind,
-    mode: raw.mode === "guide" || raw.mode === "mask" ? raw.mode : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _96 => _96.mode]), () => ( (kind === "ruler" || kind === "arc" ? "guide" : "mask"))),
-    enabled: typeof raw.enabled === "boolean" ? raw.enabled : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _97 => _97.enabled]), () => ( true)),
-    invert: typeof raw.invert === "boolean" ? raw.invert : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _98 => _98.invert]), () => ( false)),
-    snap: finite(raw.snap) ? Math.min(400, Math.max(1, raw.snap)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _99 => _99.snap]), () => ( 40)),
-    feather: finite(raw.feather) ? Math.min(100, Math.max(0, raw.feather)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _100 => _100.feather]), () => ( 1))
+    mode: raw.mode === "guide" || raw.mode === "mask" ? raw.mode : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _104 => _104.mode]), () => ( (kind === "ruler" || kind === "arc" ? "guide" : "mask"))),
+    enabled: typeof raw.enabled === "boolean" ? raw.enabled : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _105 => _105.enabled]), () => ( true)),
+    invert: typeof raw.invert === "boolean" ? raw.invert : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _106 => _106.invert]), () => ( false)),
+    snap: finite(raw.snap) ? Math.min(400, Math.max(1, raw.snap)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _107 => _107.snap]), () => ( 40)),
+    feather: finite(raw.feather) ? Math.min(100, Math.max(0, raw.feather)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _108 => _108.feather]), () => ( 1))
   };
   if (kind === "ruler" || kind === "line") {
-    s.from = _nullishCoalesce(pt(raw.from), () => ( _optionalChain([base, 'optionalAccess', _101 => _101.from])));
-    s.to = _nullishCoalesce(pt(raw.to), () => ( _optionalChain([base, 'optionalAccess', _102 => _102.to])));
+    s.from = _nullishCoalesce(pt(raw.from), () => ( _optionalChain([base, 'optionalAccess', _109 => _109.from])));
+    s.to = _nullishCoalesce(pt(raw.to), () => ( _optionalChain([base, 'optionalAccess', _110 => _110.to])));
     if (!s.from || !s.to) throw new Error(`A ${kind} needs from and to points ({x, y} in document pixels).`);
     if (Math.hypot(s.to.x - s.from.x, s.to.y - s.from.y) < 1) throw new Error(`A ${kind}'s from and to must be at least 1 px apart.`);
   } else if (kind === "arc") {
-    s.center = _nullishCoalesce(pt(raw.center), () => ( _optionalChain([base, 'optionalAccess', _103 => _103.center])));
-    s.radius = finite(raw.radius) ? raw.radius : _optionalChain([base, 'optionalAccess', _104 => _104.radius]);
+    s.center = _nullishCoalesce(pt(raw.center), () => ( _optionalChain([base, 'optionalAccess', _111 => _111.center])));
+    s.radius = finite(raw.radius) ? raw.radius : _optionalChain([base, 'optionalAccess', _112 => _112.radius]);
     if (!s.center || !(s.radius > 0)) throw new Error("An arc needs a center ({x, y}) and a radius above 0.");
-    s.startAngle = finite(raw.startAngle) ? raw.startAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _105 => _105.startAngle]), () => ( 0));
-    s.endAngle = finite(raw.endAngle) ? raw.endAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _106 => _106.endAngle]), () => ( 360));
+    s.startAngle = finite(raw.startAngle) ? raw.startAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _113 => _113.startAngle]), () => ( 0));
+    s.endAngle = finite(raw.endAngle) ? raw.endAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _114 => _114.endAngle]), () => ( 360));
   } else {
-    s.shape = STENCIL_SHAPES.includes(raw.shape) ? raw.shape : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _107 => _107.shape]), () => ( "rect"));
+    s.shape = STENCIL_SHAPES.includes(raw.shape) ? raw.shape : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _115 => _115.shape]), () => ( "rect"));
     if (s.shape === "polygon") {
-      const pts = Array.isArray(raw.points) ? raw.points.map(pt).filter((p) => Boolean(p)) : _optionalChain([base, 'optionalAccess', _108 => _108.points]);
+      const pts = Array.isArray(raw.points) ? raw.points.map(pt).filter((p) => Boolean(p)) : _optionalChain([base, 'optionalAccess', _116 => _116.points]);
       if (!pts || pts.length < 3) throw new Error("A polygon stencil needs at least 3 points.");
       s.points = pts;
     } else {
-      const r = _nullishCoalesce(raw.rect, () => ( _optionalChain([base, 'optionalAccess', _109 => _109.rect])));
+      const r = _nullishCoalesce(raw.rect, () => ( _optionalChain([base, 'optionalAccess', _117 => _117.rect])));
       if (!r || !finite(r.x) || !finite(r.y) || !(r.width > 0) || !(r.height > 0)) throw new Error(`A ${s.shape} stencil needs rect {x, y, width, height} with a width and height above 0.`);
       s.rect = { x: r.x, y: r.y, width: r.width, height: r.height };
     }
@@ -3330,7 +3363,7 @@ var StencilSnapper = class {
         const { distance } = nearestOnStencil(s, p);
         if (distance <= s.snap && (!best || distance < best.d)) best = { s, d: distance };
       }
-      this.guide = _nullishCoalesce(_optionalChain([best, 'optionalAccess', _110 => _110.s]), () => ( null));
+      this.guide = _nullishCoalesce(_optionalChain([best, 'optionalAccess', _118 => _118.s]), () => ( null));
     }
     if (!this.guide) return p;
     const q = nearestOnStencil(this.guide, p).point;
@@ -3471,15 +3504,15 @@ function readLoad(raw) {
 function readStrokeBrush(raw) {
   if (raw && typeof raw === "object" && "kind" in raw && !("engine" in raw)) {
     try {
-      return _chunkTZOX7KWVcjs.resolveBrush.call(void 0, _chunkTZOX7KWVcjs.normalizeBrushSpec.call(void 0, raw));
+      return _chunkBY5EBP26cjs.resolveBrush.call(void 0, _chunkBY5EBP26cjs.normalizeBrushSpec.call(void 0, raw));
     } catch (e5) {
     }
   }
-  return _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, _nullishCoalesce(raw, () => ( {})));
+  return _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, _nullishCoalesce(raw, () => ( {})));
 }
 function strokeToJSON(stroke) {
   const { brush, ...rest } = stroke;
-  return { ...JSON.parse(JSON.stringify(rest)), brush: _chunkTZOX7KWVcjs.migrateBrushV1.call(void 0, brush) };
+  return { ...JSON.parse(JSON.stringify(rest)), brush: _chunkBY5EBP26cjs.migrateBrushV1.call(void 0, brush) };
 }
 function normalizeBrushStroke(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -3503,7 +3536,7 @@ function normalizeBrushStroke(raw) {
     const st = [];
     for (const raw2 of r.stencils) {
       try {
-        st.push(normalizeStencil(raw2, typeof _optionalChain([raw2, 'optionalAccess', _111 => _111.id]) === "string" ? raw2.id : "stencil"));
+        st.push(normalizeStencil(raw2, typeof _optionalChain([raw2, 'optionalAccess', _119 => _119.id]) === "string" ? raw2.id : "stencil"));
       } catch (e6) {
       }
     }
@@ -3549,11 +3582,11 @@ function varyStroke(stroke, m, v) {
     if (ps !== 1) q.pressure = Math.min(1, Math.max(0, (_nullishCoalesce(p.pressure, () => ( 1))) * ps));
     return q;
   });
-  const brush = s !== 1 ? _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
+  const brush = s !== 1 ? _chunkBY5EBP26cjs.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', _112 => _112.paint, 'optionalAccess', _113 => _113.type]) === "gradient" && s !== 1) out.paint = _chunkFQPUF2W2cjs.scalePaintGradient.call(void 0, stroke.paint, s);
-  if (_optionalChain([stroke, 'access', _114 => _114.paint, 'optionalAccess', _115 => _115.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', _116 => _116.copies, 'optionalAccess', _117 => _117.length])) {
+  if (_optionalChain([stroke, 'access', _120 => _120.paint, 'optionalAccess', _121 => _121.type]) === "gradient" && s !== 1) out.paint = _chunkFQPUF2W2cjs.scalePaintGradient.call(void 0, stroke.paint, s);
+  if (_optionalChain([stroke, 'access', _122 => _122.paint, 'optionalAccess', _123 => _123.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', _124 => _124.copies, 'optionalAccess', _125 => _125.length])) {
     const inv = invertAffine(m);
     out.copies = stroke.copies.map((c) => composeAffine(m, composeAffine(c, inv)));
   }
@@ -3572,7 +3605,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', _118 => _118.light, 'optionalAccess', _119 => _119.azimuth]) !== _optionalChain([light, 'optionalAccess', _120 => _120.azimuth]) || _optionalChain([n, 'access', _121 => _121.light, 'optionalAccess', _122 => _122.elevation]) !== _optionalChain([light, 'optionalAccess', _123 => _123.elevation]))) {
+  if (!n || metal && (_optionalChain([n, 'access', _126 => _126.light, 'optionalAccess', _127 => _127.azimuth]) !== _optionalChain([light, 'optionalAccess', _128 => _128.azimuth]) || _optionalChain([n, 'access', _129 => _129.light, 'optionalAccess', _130 => _130.elevation]) !== _optionalChain([light, 'optionalAccess', _131 => _131.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);
   }
@@ -3693,17 +3726,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', _124 => _124.wetEvents, 'optionalAccess', _125 => _125.length])) out.wetEvents = JSON.parse(JSON.stringify(state.wetEvents));
-  if (_optionalChain([state, 'access', _126 => _126.paintEvents, 'optionalAccess', _127 => _127.length])) out.paintEvents = JSON.parse(JSON.stringify(state.paintEvents));
+  if (_optionalChain([state, 'access', _132 => _132.wetEvents, 'optionalAccess', _133 => _133.length])) out.wetEvents = JSON.parse(JSON.stringify(state.wetEvents));
+  if (_optionalChain([state, 'access', _134 => _134.paintEvents, 'optionalAccess', _135 => _135.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 } = _chunk43NT242Dcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkKXNZNOEFcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunk43NT242Dcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkKXNZNOEFcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -3711,7 +3744,7 @@ function paintLayersOnly(layers, problems) {
   for (const l of layers) {
     if (l.type === "pixel") {
       const { filters, source, ...rest } = l;
-      if (_optionalChain([filters, 'optionalAccess', _128 => _128.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
+      if (_optionalChain([filters, 'optionalAccess', _136 => _136.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) });
@@ -3740,9 +3773,9 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = normalizePaper(_nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunk43NT242Dcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkKXNZNOEFcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
-  const activeLayerId = wanted && _chunkPVJMTLPJcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.flattenLayers.call(void 0, layers), 'access', _129 => _129.filter, 'call', _130 => _130((l) => l.type === "pixel"), 'access', _131 => _131.pop, 'call', _132 => _132(), 'optionalAccess', _133 => _133.id]), () => ( null));
+  const activeLayerId = wanted && _chunkPVJMTLPJcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.flattenLayers.call(void 0, layers), 'access', _137 => _137.filter, 'call', _138 => _138((l) => l.type === "pixel"), 'access', _139 => _139.pop, 'call', _140 => _140(), 'optionalAccess', _141 => _141.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;
@@ -3756,7 +3789,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 _chunk43NT242Dcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkKXNZNOEFcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -3887,7 +3920,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', _134 => _134.close, 'optionalCall', _135 => _135()]);
+  _optionalChain([bitmap, 'access', _142 => _142.close, 'optionalCall', _143 => _143()]);
   return { width: bitmap.width, height: bitmap.height, data };
 }
 function downloadBytes(bytes, fileName, mimeType) {
@@ -3924,7 +3957,7 @@ function wetPaperInput(paper) {
   };
 }
 var WetStrokeDriver = (_class13 = class {
-  constructor(init) {;_class13.prototype.__init75.call(this);_class13.prototype.__init76.call(this);_class13.prototype.__init77.call(this);_class13.prototype.__init78.call(this);_class13.prototype.__init79.call(this);_class13.prototype.__init80.call(this);_class13.prototype.__init81.call(this);_class13.prototype.__init82.call(this);_class13.prototype.__init83.call(this);_class13.prototype.__init84.call(this);_class13.prototype.__init85.call(this);_class13.prototype.__init86.call(this);_class13.prototype.__init87.call(this);
+  constructor(init) {;_class13.prototype.__init77.call(this);_class13.prototype.__init78.call(this);_class13.prototype.__init79.call(this);_class13.prototype.__init80.call(this);_class13.prototype.__init81.call(this);_class13.prototype.__init82.call(this);_class13.prototype.__init83.call(this);_class13.prototype.__init84.call(this);_class13.prototype.__init85.call(this);_class13.prototype.__init86.call(this);_class13.prototype.__init87.call(this);_class13.prototype.__init88.call(this);_class13.prototype.__init89.call(this);
     this.init = init;
     const brush = init.brush;
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
@@ -3952,30 +3985,30 @@ var WetStrokeDriver = (_class13 = class {
     this.sampler = g ? new (0, _chunkFQPUF2W2cjs.PaintGradientSampler)(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
   }
   
-  __init75() {this.dabCount = 0}
-  __init76() {this.bounds = null}
+  __init77() {this.dabCount = 0}
+  __init78() {this.bounds = null}
   /** The world's clock at which each raw point was applied (recorded with the stroke). */
-  __init77() {this.steps = []}
+  __init79() {this.steps = []}
   
   
   
-  __init78() {this.queue = []}
-  __init79() {this.finishing = false}
-  __init80() {this.finished = false}
-  __init81() {this.lastRaw = null}
-  __init82() {this.lastFed = null}
-  __init83() {this.tip = new Float32Array(0)}
-  __init84() {this.cov = new Float32Array(0)}
-  __init85() {this.paint = [0, 0, 0]}
-  __init86() {this.centre = [0, 0, 0]}
+  __init80() {this.queue = []}
+  __init81() {this.finishing = false}
+  __init82() {this.finished = false}
+  __init83() {this.lastRaw = null}
+  __init84() {this.lastFed = null}
+  __init85() {this.tip = new Float32Array(0)}
+  __init86() {this.cov = new Float32Array(0)}
+  __init87() {this.paint = [0, 0, 0]}
+  __init88() {this.centre = [0, 0, 0]}
   
   
   
-  __init87() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  __init89() {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', _136 => _136.states, 'access', _137 => _137[0], 'access', _138 => _138.exchange, 'optionalAccess', _139 => _139.load]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _144 => _144.states, 'access', _145 => _145[0], 'access', _146 => _146.exchange, 'optionalAccess', _147 => _147.load]), () => ( null));
   }
   /** Whether every point (and the end) has been applied. */
   get done() {
@@ -4128,7 +4161,7 @@ var WET_GPU_MODES = ["auto", "off"];
 var GPU_LEAD = 16;
 var DISPLAY_TILES_PER_TICK = 24;
 var PaintWetLayers = (_class14 = class {
-  constructor(host, options = {}) {;_class14.prototype.__init88.call(this);_class14.prototype.__init89.call(this);_class14.prototype.__init90.call(this);_class14.prototype.__init91.call(this);_class14.prototype.__init92.call(this);_class14.prototype.__init93.call(this);_class14.prototype.__init94.call(this);_class14.prototype.__init95.call(this);_class14.prototype.__init96.call(this);_class14.prototype.__init97.call(this);_class14.prototype.__init98.call(this);_class14.prototype.__init99.call(this);_class14.prototype.__init100.call(this);_class14.prototype.__init101.call(this);_class14.prototype.__init102.call(this);_class14.prototype.__init103.call(this);
+  constructor(host, options = {}) {;_class14.prototype.__init90.call(this);_class14.prototype.__init91.call(this);_class14.prototype.__init92.call(this);_class14.prototype.__init93.call(this);_class14.prototype.__init94.call(this);_class14.prototype.__init95.call(this);_class14.prototype.__init96.call(this);_class14.prototype.__init97.call(this);_class14.prototype.__init98.call(this);_class14.prototype.__init99.call(this);_class14.prototype.__init100.call(this);_class14.prototype.__init101.call(this);_class14.prototype.__init102.call(this);_class14.prototype.__init103.call(this);_class14.prototype.__init104.call(this);_class14.prototype.__init105.call(this);
     this.host = host;
     this.options = options;
     this.speed = Math.max(1, Math.min(2e3, _nullishCoalesce(options.speed, () => ( 120))));
@@ -4138,27 +4171,27 @@ var PaintWetLayers = (_class14 = class {
   }
   
   
-  __init88() {this.world = null}
-  __init89() {this.tilt = { ..._chunkYHDHFJUCcjs.FLAT }}
-  __init90() {this.settings = /* @__PURE__ */ new Map()}
-  __init91() {this.paused = false}
+  __init90() {this.world = null}
+  __init91() {this.tilt = { ..._chunkYHDHFJUCcjs.FLAT }}
+  __init92() {this.settings = /* @__PURE__ */ new Map()}
+  __init93() {this.paused = false}
   /** Wet strokes dry as soon as they end (one undo step with the stroke). */
-  __init92() {this.instantDry = false}
+  __init94() {this.instantDry = false}
   
-  __init93() {this.overlay = false}
+  __init95() {this.overlay = false}
   
   /** The live wet stroke, if any. */
-  __init94() {this.driver = null}
-  __init95() {this.lastTick = null}
-  __init96() {this.ticking = null}
-  __init97() {this.stepsOwed = 0}
-  __init98() {this.displaying = null}
-  __init99() {this.leadAt = 0}
+  __init96() {this.driver = null}
+  __init97() {this.lastTick = null}
+  __init98() {this.ticking = null}
+  __init99() {this.stepsOwed = 0}
+  __init100() {this.displaying = null}
+  __init101() {this.leadAt = 0}
   
   
-  __init100() {this.gpu = null}
-  __init101() {this.gpuSupport = null}
-  __init102() {this.gpuStarting = null}
+  __init102() {this.gpu = null}
+  __init103() {this.gpuSupport = null}
+  __init104() {this.gpuStarting = null}
   // --- Engine B ------------------------------------------------------------------
   /** Starts the GPU engine for the world (once; it may turn out unavailable). */
   startGpu() {
@@ -4194,8 +4227,8 @@ var PaintWetLayers = (_class14 = class {
     if (mode === this.gpuMode) return this.engineInfo();
     this.gpuMode = mode;
     if (mode === "off") {
-      _optionalChain([this, 'access', _140 => _140.world, 'optionalAccess', _141 => _141.attachGpu, 'call', _142 => _142(null)]);
-      _optionalChain([this, 'access', _143 => _143.gpu, 'optionalAccess', _144 => _144.destroy, 'call', _145 => _145()]);
+      _optionalChain([this, 'access', _148 => _148.world, 'optionalAccess', _149 => _149.attachGpu, 'call', _150 => _150(null)]);
+      _optionalChain([this, 'access', _151 => _151.gpu, 'optionalAccess', _152 => _152.destroy, 'call', _153 => _153()]);
       this.gpu = null;
       this.gpuSupport = null;
     } else if (this.world) this.startGpu();
@@ -4203,13 +4236,13 @@ var PaintWetLayers = (_class14 = class {
   }
   engineInfo() {
     const w = this.world;
-    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _146 => _146.gpuSupport, 'optionalAccess', _147 => _147.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _148 => _148.gpuSupport, 'optionalAccess', _149 => _149.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _150 => _150.activeTiles, 'call', _151 => _151()]), () => ( 0)), cpu: this.backend() };
+    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _154 => _154.gpuSupport, 'optionalAccess', _155 => _155.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _156 => _156.gpuSupport, 'optionalAccess', _157 => _157.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _158 => _158.activeTiles, 'call', _159 => _159()]), () => ( 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', _152 => _152.gpuError])) return { ...base, state: "failed", reason: w.gpuError };
+    if (_optionalChain([w, 'optionalAccess', _160 => _160.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', _153 => _153.gpuActive])) return { ...base, state: "active", reason: null };
+    if (_optionalChain([w, 'optionalAccess', _161 => _161.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). */
@@ -4248,13 +4281,13 @@ var PaintWetLayers = (_class14 = 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', _154 => _154.laneIds, 'call', _155 => _155(), 'access', _156 => _156.length]) ? old.snapshot() : null;
+    const snap = _optionalChain([old, 'optionalAccess', _162 => _162.laneIds, 'call', _163 => _163(), 'access', _164 => _164.length]) ? old.snapshot() : null;
     this.dropWorld();
     this.lastTick = null;
     this.stepsOwed = 0;
     if (!old || !snap) return;
     const moved = _chunkYHDHFJUCcjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left, top, (l) => {
-      const flow = _optionalChain([this, 'access', _157 => _157.settings, 'access', _158 => _158.get, 'call', _159 => _159(l.id), 'optionalAccess', _160 => _160.flow]);
+      const flow = _optionalChain([this, 'access', _165 => _165.settings, 'access', _166 => _166.get, 'call', _167 => _167(l.id), 'optionalAccess', _168 => _168.flow]);
       return {
         base: _chunk474IQG74cjs.translateSurface.call(void 0, l.base, left, top),
         ...l.light ? { light: _chunk474IQG74cjs.translateSurface.call(void 0, l.light, left, top) } : {},
@@ -4273,11 +4306,11 @@ var PaintWetLayers = (_class14 = class {
   }
   /** Layers holding a wet layer (wet or drying). */
   wetLayerIds() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _161 => _161.world, 'optionalAccess', _162 => _162.laneIds, 'call', _163 => _163()]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _169 => _169.world, 'optionalAccess', _170 => _170.laneIds, 'call', _171 => _171()]), () => ( []));
   }
   /** Whether a batch is running (edits wait). */
   get busy() {
-    return Boolean(_optionalChain([this, 'access', _164 => _164.world, 'optionalAccess', _165 => _165.busy]));
+    return Boolean(_optionalChain([this, 'access', _172 => _172.world, 'optionalAccess', _173 => _173.busy]));
   }
   /** Resolves when no batch is running. */
   async idle() {
@@ -4306,13 +4339,13 @@ var PaintWetLayers = (_class14 = class {
   setParams(layerId, update) {
     const s = this.settingsOf(layerId);
     s.params = _chunkYHDHFJUCcjs.normalizeWetParams.call(void 0, update, s.params);
-    if (_optionalChain([this, 'access', _166 => _166.world, 'optionalAccess', _167 => _167.hasLane, 'call', _168 => _168(layerId)])) this.world.setParams(layerId, s.params);
+    if (_optionalChain([this, 'access', _174 => _174.world, 'optionalAccess', _175 => _175.hasLane, 'call', _176 => _176(layerId)])) this.world.setParams(layerId, s.params);
     return { ...s.params };
   }
   setFlow(layerId, update) {
     const s = this.settingsOf(layerId);
     s.flow = _chunkYHDHFJUCcjs.normalizeFlow.call(void 0, update, s.flow);
-    if (_optionalChain([this, 'access', _169 => _169.world, 'optionalAccess', _170 => _170.hasLane, 'call', _171 => _171(layerId)])) {
+    if (_optionalChain([this, 'access', _177 => _177.world, 'optionalAccess', _178 => _178.hasLane, 'call', _179 => _179(layerId)])) {
       const { width, height } = this.host.canvas();
       this.world.setFlow(layerId, _chunkYHDHFJUCcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
     }
@@ -4320,29 +4353,29 @@ var PaintWetLayers = (_class14 = class {
   }
   setTilt(update) {
     this.tilt = _chunkYHDHFJUCcjs.normalizeTilt.call(void 0, update, this.tilt);
-    _optionalChain([this, 'access', _172 => _172.world, 'optionalAccess', _173 => _173.setTilt, 'call', _174 => _174(this.tilt)]);
+    _optionalChain([this, 'access', _180 => _180.world, 'optionalAccess', _181 => _181.setTilt, 'call', _182 => _182(this.tilt)]);
     return { ...this.tilt };
   }
   /** The paper changed. */
   paperChanged() {
-    _optionalChain([this, 'access', _175 => _175.world, 'optionalAccess', _176 => _176.setPaper, 'call', _177 => _177(wetPaperInput(this.host.paper()))]);
+    _optionalChain([this, 'access', _183 => _183.world, 'optionalAccess', _184 => _184.setPaper, 'call', _185 => _185(wetPaperInput(this.host.paper()))]);
   }
   /** A layer as tools describe it. */
   info(layerId) {
     const s = this.settingsOf(layerId);
-    const st = _optionalChain([this, 'access', _178 => _178.world, 'optionalAccess', _179 => _179.hasLane, 'call', _180 => _180(layerId)]) ? this.world.stats(layerId) : null;
+    const st = _optionalChain([this, 'access', _186 => _186.world, 'optionalAccess', _187 => _187.hasLane, 'call', _188 => _188(layerId)]) ? this.world.stats(layerId) : null;
     return {
       layerId,
       wet: Boolean(st && st.wetCells > 0),
-      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _181 => _181.wetCells]), () => ( 0)),
-      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _182 => _182.wetBounds]), () => ( null)),
-      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _183 => _183.activeTiles]), () => ( 0)),
+      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _189 => _189.wetCells]), () => ( 0)),
+      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _190 => _190.wetBounds]), () => ( null)),
+      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _191 => _191.activeTiles]), () => ( 0)),
       params: { ...s.params },
       flow: { ...s.flow }
     };
   }
   backend() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _184 => _184.world, 'optionalAccess', _185 => _185.backend, 'call', _186 => _186()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _192 => _192.world, 'optionalAccess', _193 => _193.backend, 'call', _194 => _194()]), () => ( null));
   }
   /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
   syncDisplays(maxTiles = Infinity) {
@@ -4391,7 +4424,7 @@ var PaintWetLayers = (_class14 = class {
     const w = this.world;
     if (!w) return;
     for (const id of w.laneIds()) {
-      if (w.isActive(id) || _optionalChain([this, 'access', _187 => _187.driver, 'optionalAccess', _188 => _188.init, 'access', _189 => _189.laneId]) === id) continue;
+      if (w.isActive(id) || _optionalChain([this, 'access', _195 => _195.driver, 'optionalAccess', _196 => _196.init, 'access', _197 => _197.laneId]) === id) continue;
       const base = w.getBase(id);
       const light = w.isLit(id) ? w.getLight(id) : null;
       w.removeLane(id);
@@ -4473,10 +4506,10 @@ var PaintWetLayers = (_class14 = 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', _190 => _190.onDriverDone, 'optionalCall', _191 => _191(d)]);
+    if (d.done) _optionalChain([this, 'access', _198 => _198.onDriverDone, 'optionalCall', _199 => _199(d)]);
   }
   /** Called when a live stroke that ended mid-batch has finished applying. */
-  __init103() {this.onDriverDone = null}
+  __init105() {this.onDriverDone = null}
   /** Steps `steps` times now (agents, tests). Returns the steps run. */
   async advance(steps) {
     await this.idle();
@@ -4517,13 +4550,13 @@ var PaintWetLayers = (_class14 = class {
   /** The layer's light paint with all its wet paint dried (`null` without a wet layer or light), without changing anything. */
   bakedLight(layerId) {
     const w = this.world;
-    if (!_optionalChain([w, 'optionalAccess', _192 => _192.hasLane, 'call', _193 => _193(layerId)]) || !w.isLit(layerId)) return null;
+    if (!_optionalChain([w, 'optionalAccess', _200 => _200.hasLane, 'call', _201 => _201(layerId)]) || !w.isLit(layerId)) return null;
     return w.bakedLight(layerId);
   }
   /** The layer's pixels with all its wet paint dried (deterministic), without changing anything. */
   bakedSurface(layerId) {
     const w = this.world;
-    if (!_optionalChain([w, 'optionalAccess', _194 => _194.hasLane, 'call', _195 => _195(layerId)])) return null;
+    if (!_optionalChain([w, 'optionalAccess', _202 => _202.hasLane, 'call', _203 => _203(layerId)])) return null;
     return w.bakedSurface(layerId);
   }
   /** A snapshot of the world for undo (`null` when there is none). */
@@ -4544,13 +4577,13 @@ var PaintWetLayers = (_class14 = class {
     this.syncDisplays();
   }
   dropWorld() {
-    _optionalChain([this, 'access', _196 => _196.world, 'optionalAccess', _197 => _197.destroy, 'call', _198 => _198()]);
+    _optionalChain([this, 'access', _204 => _204.world, 'optionalAccess', _205 => _205.destroy, 'call', _206 => _206()]);
     this.world = null;
     this.driver = null;
   }
   /** Forgets everything wet (a new canvas, a resize, opening a document). */
   reset() {
-    _optionalChain([this, 'access', _199 => _199.world, 'optionalAccess', _200 => _200.destroy, 'call', _201 => _201()]);
+    _optionalChain([this, 'access', _207 => _207.world, 'optionalAccess', _208 => _208.destroy, 'call', _209 => _209()]);
     this.world = null;
     this.driver = null;
     this.settings.clear();
@@ -4580,9 +4613,9 @@ var PaintWetLayers = (_class14 = class {
     return out;
   }
   destroy() {
-    _optionalChain([this, 'access', _202 => _202.world, 'optionalAccess', _203 => _203.destroy, 'call', _204 => _204()]);
+    _optionalChain([this, 'access', _210 => _210.world, 'optionalAccess', _211 => _211.destroy, 'call', _212 => _212()]);
     this.world = null;
-    _optionalChain([this, 'access', _205 => _205.gpu, 'optionalAccess', _206 => _206.destroy, 'call', _207 => _207()]);
+    _optionalChain([this, 'access', _213 => _213.gpu, 'optionalAccess', _214 => _214.destroy, 'call', _215 => _215()]);
     this.gpu = null;
   }
 }, _class14);
@@ -4595,7 +4628,7 @@ function wetPigmentOf(hex2, body) {
 var thumbWorld = null;
 function paintWetTestStroke(brush, paper, color, width, height) {
   if (!thumbWorld || thumbWorld.width !== width || thumbWorld.height !== height) {
-    _optionalChain([thumbWorld, 'optionalAccess', _208 => _208.destroy, 'call', _209 => _209()]);
+    _optionalChain([thumbWorld, 'optionalAccess', _216 => _216.destroy, 'call', _217 => _217()]);
     thumbWorld = new (0, _chunkYHDHFJUCcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: "typescript", threads: 0 });
   } else thumbWorld.setPaper(wetPaperInput(paper));
   const w = thumbWorld;
@@ -4680,7 +4713,7 @@ 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 ? _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: maxSize } }, brush) : brush;
+  const b = brush.tip.size > maxSize ? _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: maxSize } }, brush) : brush;
   const rgba = [...hexToRgb8(options.color), 255];
   let surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4);
   if (b.engine === "eraser") {
@@ -4829,12 +4862,12 @@ function perspectiveDirections(g, p) {
 }
 var SNAP_DECIDE_DISTANCE = 6;
 var PerspectiveSnapper = (_class15 = class {
-  constructor(guide) {;_class15.prototype.__init104.call(this);_class15.prototype.__init105.call(this);
+  constructor(guide) {;_class15.prototype.__init106.call(this);_class15.prototype.__init107.call(this);
     this.guide = guide;
   }
   
-  __init104() {this.start = null}
-  __init105() {this.dir = null}
+  __init106() {this.start = null}
+  __init107() {this.dir = null}
   /** The line the stroke follows, once chosen. */
   get line() {
     return this.start && this.dir ? { from: this.start, direction: this.dir } : null;
@@ -4940,11 +4973,11 @@ function readSwatch(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
   const g = _chunkFQPUF2W2cjs.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', _210 => _210.type]) === "gradient" ? _chunkFQPUF2W2cjs.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', _218 => _218.type]) === "gradient" ? _chunkFQPUF2W2cjs.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', _211 => _211.type]) === "gradient") out.paint = g;
+  if (_optionalChain([g, 'optionalAccess', _219 => _219.type]) === "gradient") out.paint = g;
   return out;
 }
 var DEFAULT_SWATCHES = [
@@ -4963,7 +4996,7 @@ var DEFAULT_SWATCHES = [
 // src/paint-editor/mixing-pad.ts
 var MIXING_PAD_WIDTH = 360;
 var MIXING_PAD_HEIGHT = 220;
-var PAD_PAINT = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, {
+var PAD_PAINT = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, {
   id: "pad-paint",
   name: "Pad paint",
   category: "mixer",
@@ -4971,7 +5004,7 @@ var PAD_PAINT = _chunkTZOX7KWVcjs.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 = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, {
+var PAD_KNIFE = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, {
   id: "pad-knife",
   name: "Palette knife",
   category: "smudge",
@@ -4981,19 +5014,19 @@ var PAD_KNIFE = _chunkTZOX7KWVcjs.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 = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, {
+var PAD_BLOB = _chunkBY5EBP26cjs.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 = (_class16 = class {constructor() { _class16.prototype.__init106.call(this);_class16.prototype.__init107.call(this);_class16.prototype.__init108.call(this);_class16.prototype.__init109.call(this); }
-  __init106() {this.width = MIXING_PAD_WIDTH}
-  __init107() {this.height = MIXING_PAD_HEIGHT}
-  __init108() {this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4)}
+var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init108.call(this);_class16.prototype.__init109.call(this);_class16.prototype.__init110.call(this);_class16.prototype.__init111.call(this); }
+  __init108() {this.width = MIXING_PAD_WIDTH}
+  __init109() {this.height = MIXING_PAD_HEIGHT}
+  __init110() {this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4)}
   /** Increments on every change (for redrawing). */
-  __init109() {this.version = 0}
+  __init111() {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.");
@@ -5003,7 +5036,7 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
       }
     }
     let brush = options.tool === "knife" ? PAD_KNIFE : PAD_PAINT;
-    if (options.size !== void 0) brush = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: options.size } }, brush);
+    if (options.size !== void 0) brush = _chunkBY5EBP26cjs.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. */
@@ -5102,10 +5135,10 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
       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 = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: Math.max(2, 2 * r) } }, PAD_BLOB);
+      const blob = _chunkBY5EBP26cjs.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 = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_KNIFE.tip, size: Math.max(12, R * 0.5) } }, PAD_KNIFE);
+    const knife = _chunkBY5EBP26cjs.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;
@@ -5120,7 +5153,7 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
       paints2.map((p) => hexToRgb8(p.color).map((v) => v / 255)),
       paints2.map((p) => p.parts)
     );
-    const core = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
+    const core = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
     const hex2 = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
     this.run(core, [{ x: cx, y: cy }], hex2);
     return { color: this.pick(cx, cy, 2), bounds };
@@ -5131,7 +5164,7 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
   }
   /** 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([_chunkW5M3J7PVcjs.parseDataUrl.call(void 0, png), 'optionalAccess', _212 => _212.bytes]) : _chunkW5M3J7PVcjs.base64ToBytes.call(void 0, png);
+    const bytes = png.startsWith("data:") ? _optionalChain([_chunkW5M3J7PVcjs.parseDataUrl.call(void 0, png), 'optionalAccess', _220 => _220.bytes]) : _chunkW5M3J7PVcjs.base64ToBytes.call(void 0, png);
     if (!bytes || !_chunkW5M3J7PVcjs.isPng.call(void 0, bytes)) throw new Error("The pad image is not a PNG data URL or base64 PNG.");
     const img = _chunkW5M3J7PVcjs.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}.`);
@@ -5160,21 +5193,21 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
 var copyJSON = (v) => JSON.parse(JSON.stringify(v));
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function libraryBrush(spec, builtin, resolved) {
-  const brush = resolved ? _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, resolved, resolved) : _chunkTZOX7KWVcjs.resolveBrush.call(void 0, spec);
+  const brush = resolved ? _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, resolved, resolved) : _chunkBY5EBP26cjs.resolveBrush.call(void 0, spec);
   if (builtin) brush.builtin = true;
   else delete brush.builtin;
   return { spec, brush, builtin };
 }
 var builtins = null;
 function builtinLibraryBrushes() {
-  return builtins ??= _chunkTZOX7KWVcjs.BRUSH_PRESETS.map((spec) => {
-    const resolved = _chunkTZOX7KWVcjs.BUILTIN_BRUSHES.find((b) => b.id === spec.id);
+  return builtins ??= _chunkBY5EBP26cjs.BRUSH_PRESETS.map((spec) => {
+    const resolved = _chunkBY5EBP26cjs.BUILTIN_BRUSHES.find((b) => b.id === spec.id);
     return libraryBrush(spec, true, resolved);
   });
 }
 function seededStorage(brushes) {
   if (!brushes.length) return void 0;
-  let stored = JSON.stringify({ format: "pixerate-brushes", version: 1, brushes: brushes.map(_chunkTZOX7KWVcjs.brushToJSON) });
+  let stored = JSON.stringify({ format: "pixerate-brushes", version: 1, brushes: brushes.map(_chunkBY5EBP26cjs.brushToJSON) });
   return {
     get: async () => stored,
     set: async (_key, value) => {
@@ -5187,28 +5220,28 @@ var paints = (b) => {
   return JSON.stringify(rest);
 };
 function brushSpecOf(next, from) {
-  const plain = _chunkTZOX7KWVcjs.migrateBrushV1.call(void 0, next);
+  const plain = _chunkBY5EBP26cjs.migrateBrushV1.call(void 0, next);
   const out = copyJSON(plain);
   if (from.description) out.description = from.description;
-  if (_optionalChain([from, 'access', _213 => _213.tags, 'optionalAccess', _214 => _214.length])) out.tags = [...from.tags];
+  if (_optionalChain([from, 'access', _221 => _221.tags, 'optionalAccess', _222 => _222.length])) out.tags = [...from.tags];
   if (out.kind === "mark" && from.kind === "mark") {
     if (from.medium) out.medium = from.medium;
     if (from.variety) out.variety = from.variety;
   }
   const colour = { ..._nullishCoalesce(from.colour, () => ( {})) };
-  if (_optionalChain([plain, 'access', _215 => _215.colour, 'optionalAccess', _216 => _216.default]) !== void 0) colour.default = plain.colour.default;
+  if (_optionalChain([plain, 'access', _223 => _223.colour, 'optionalAccess', _224 => _224.default]) !== void 0) colour.default = plain.colour.default;
   else if (isObject(colour.default) && colour.default.type === "gradient") delete colour.default;
   if (Object.keys(colour).length) out.colour = copyJSON(colour);
   else delete out.colour;
-  if ((_nullishCoalesce(_optionalChain([out, 'access', _217 => _217.light, 'optionalAccess', _218 => _218.amount]), () => ( 0))) > 0 && (_optionalChain([from, 'access', _219 => _219.light, 'optionalAccess', _220 => _220.spill]) || _optionalChain([from, 'access', _221 => _221.light, 'optionalAccess', _222 => _222.glow]) !== void 0)) {
+  if ((_nullishCoalesce(_optionalChain([out, 'access', _225 => _225.light, 'optionalAccess', _226 => _226.amount]), () => ( 0))) > 0 && (_optionalChain([from, 'access', _227 => _227.light, 'optionalAccess', _228 => _228.spill]) || _optionalChain([from, 'access', _229 => _229.light, 'optionalAccess', _230 => _230.glow]) !== void 0)) {
     out.light = { ...out.light, ...from.light.spill ? { spill: { ...from.light.spill } } : {}, ...from.light.glow !== void 0 ? { glow: from.light.glow } : {} };
   }
-  if (_optionalChain([from, 'access', _223 => _223.motion, 'optionalAccess', _224 => _224.live]) !== void 0 || _optionalChain([from, 'access', _225 => _225.motion, 'optionalAccess', _226 => _226.fps]) !== void 0) {
+  if (_optionalChain([from, 'access', _231 => _231.motion, 'optionalAccess', _232 => _232.live]) !== void 0 || _optionalChain([from, 'access', _233 => _233.motion, 'optionalAccess', _234 => _234.fps]) !== void 0) {
     out.motion = { ..._nullishCoalesce(out.motion, () => ( {})), ...from.motion.live !== void 0 ? { live: from.motion.live } : {}, ...from.motion.fps !== void 0 ? { fps: from.motion.fps } : {} };
   }
   try {
-    const hinted = _chunkTZOX7KWVcjs.normalizeBrushSpec.call(void 0, out, []);
-    if (paints(_chunkTZOX7KWVcjs.resolveBrush.call(void 0, hinted)) === paints(_chunkTZOX7KWVcjs.resolveBrush.call(void 0, plain))) return hinted;
+    const hinted = _chunkBY5EBP26cjs.normalizeBrushSpec.call(void 0, out, []);
+    if (paints(_chunkBY5EBP26cjs.resolveBrush.call(void 0, hinted)) === paints(_chunkBY5EBP26cjs.resolveBrush.call(void 0, plain))) return hinted;
   } catch (e7) {
   }
   return plain;
@@ -5345,11 +5378,11 @@ function tilesUnder(surface, rect, offset, out) {
   for (let ty = y0; ty <= y1; ty++) for (let tx = x0; tx <= x1; tx++) out.push(_nullishCoalesce(surface.tiles.get(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), () => ( null)));
 }
 var sameRefs = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-var BacklightCache = (_class17 = class {constructor() { _class17.prototype.__init110.call(this);_class17.prototype.__init111.call(this);_class17.prototype.__init112.call(this);_class17.prototype.__init113.call(this); }
-  __init110() {this.tiles = /* @__PURE__ */ new Map()}
-  __init111() {this.key = ""}
-  __init112() {this.spillOf = null}
-  __init113() {this.out = null}
+var BacklightCache = (_class17 = class {constructor() { _class17.prototype.__init112.call(this);_class17.prototype.__init113.call(this);_class17.prototype.__init114.call(this);_class17.prototype.__init115.call(this); }
+  __init112() {this.tiles = /* @__PURE__ */ new Map()}
+  __init113() {this.key = ""}
+  __init114() {this.spillOf = null}
+  __init115() {this.out = null}
   /**
    * The backlight layer's pixels for `layers` (bottom first) on `paper` over a `width` × `height`
    * canvas, or `null` when the paper has no backlight. `spillFrom` is the committed painting (the
@@ -5375,8 +5408,8 @@ var BacklightCache = (_class17 = class {constructor() { _class17.prototype.__ini
         refs.length = 0;
         for (const l of layers) {
           tilesUnder(l.surface, rect, l.offset, refs);
-          tilesUnder(_optionalChain([l, 'access', _227 => _227.thick, 'optionalAccess', _228 => _228.height]), rect, l.offset, refs);
-          tilesUnder(_optionalChain([l, 'access', _229 => _229.thick, 'optionalAccess', _230 => _230.material]), rect, l.offset, refs);
+          tilesUnder(_optionalChain([l, 'access', _235 => _235.thick, 'optionalAccess', _236 => _236.height]), rect, l.offset, refs);
+          tilesUnder(_optionalChain([l, 'access', _237 => _237.thick, 'optionalAccess', _238 => _238.material]), rect, l.offset, refs);
         }
         const k = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
         let r = this.tiles.get(k);
@@ -5470,8 +5503,8 @@ function computeTile(paper, grain, amount, rect, layers) {
     const lr = { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height };
     if (!l.surface.tiles.size) continue;
     const px = _chunk474IQG74cjs.readRegion.call(void 0, l.surface, lr);
-    const h = _optionalChain([l, 'access', _231 => _231.thick, 'optionalAccess', _232 => _232.height, 'access', _233 => _233.tiles, 'access', _234 => _234.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.height, lr) : null;
-    const m = h && _optionalChain([l, 'access', _235 => _235.thick, 'optionalAccess', _236 => _236.material, 'access', _237 => _237.tiles, 'access', _238 => _238.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.material, lr) : null;
+    const h = _optionalChain([l, 'access', _239 => _239.thick, 'optionalAccess', _240 => _240.height, 'access', _241 => _241.tiles, 'access', _242 => _242.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.height, lr) : null;
+    const m = h && _optionalChain([l, 'access', _243 => _243.thick, 'optionalAccess', _244 => _244.material, 'access', _245 => _245.tiles, 'access', _246 => _246.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.material, lr) : null;
     const op = l.opacity;
     for (let i = 0; i < n; i++) {
       const a8 = px[i * 4 + 3];
@@ -5546,7 +5579,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', _239 => _239.paint, 'optionalAccess', _240 => _240.type]) === "effect" ? [st.paint] : []));
+  await target.prepareEffectPaints(source.strokes.slice(0, maxStrokes).flatMap((st) => _optionalChain([st, 'access', _247 => _247.paint, 'optionalAccess', _248 => _248.type]) === "effect" ? [st.paint] : []));
   const advanceTo = async (clock) => {
     const now = target.getState().wet.clock;
     let left = clock - now;
@@ -5554,7 +5587,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', _241 => _241.onWetSteps, 'optionalCall', _242 => _242(target.getState().wet.clock)]);
+      if (Number.isFinite(chunk)) await _optionalChain([options, 'access', _249 => _249.onWetSteps, 'optionalCall', _250 => _250(target.getState().wet.clock)]);
     }
   };
   const sr = (r) => ({ x: r.x * s, y: r.y * s, width: r.width * s, height: r.height * s });
@@ -5567,14 +5600,14 @@ async function replayPainting(source, target, options = {}) {
       else if (e.kind === "clear") target.clearLayer(e.layerId);
       else if (e.kind === "live-strokes") {
         const d = e.data;
-        if (_optionalChain([d, 'optionalAccess', _243 => _243.rasterized])) target.replaceLiveStrokes(e.layerId, null);
+        if (_optionalChain([d, 'optionalAccess', _251 => _251.rasterized])) target.replaceLiveStrokes(e.layerId, null);
         else {
-          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _244 => _244.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', _245 => _245.paint, 'optionalAccess', _246 => _246.type]) === "effect" ? [st2.paint] : []));
+          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _252 => _252.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', _253 => _253.paint, 'optionalAccess', _254 => _254.type]) === "effect" ? [st2.paint] : []));
           target.replaceLiveStrokes(e.layerId, list);
         }
       } else if (e.kind === "stickers") {
-        const list = (_nullishCoalesce(_optionalChain([e, 'access', _247 => _247.data, 'optionalAccess', _248 => _248.stickers]), () => ( []))).map((x) => s === 1 ? x : { ...x, x: x.x * s, y: x.y * s, size: x.size * s });
+        const list = (_nullishCoalesce(_optionalChain([e, 'access', _255 => _255.data, 'optionalAccess', _256 => _256.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;
@@ -5587,8 +5620,8 @@ async function replayPainting(source, target, options = {}) {
         switch (e.kind) {
           case "dry": {
             const rect = e.data;
-            const ids = _optionalChain([e, 'access', _249 => _249.layerId, 'optionalAccess', _250 => _250.split, 'call', _251 => _251(","), 'access', _252 => _252.filter, 'call', _253 => _253(Boolean)]);
-            if (_optionalChain([ids, 'optionalAccess', _254 => _254.length])) for (const id of ids) target.dryPaint({ layerId: id, rect: rect ? sr(rect) : void 0 });
+            const ids = _optionalChain([e, 'access', _257 => _257.layerId, 'optionalAccess', _258 => _258.split, 'call', _259 => _259(","), 'access', _260 => _260.filter, 'call', _261 => _261(Boolean)]);
+            if (_optionalChain([ids, 'optionalAccess', _262 => _262.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;
           }
@@ -5619,7 +5652,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', _255 => _255.steps, 'optionalAccess', _256 => _256.length]) === st.points.length) {
+    if (st.brush.engine === "wet" && _optionalChain([st, 'access', _263 => _263.steps, 'optionalAccess', _264 => _264.length]) === st.points.length) {
       await target.wetIdle();
       await advanceTo(st.steps[0]);
       const session = target.beginStroke({ ...init, start: st.points[0] });
@@ -5639,7 +5672,7 @@ async function replayPainting(source, target, options = {}) {
       await target.wetIdle();
       target.paintStroke({ ...init, points: st.points });
     }
-    await _optionalChain([options, 'access', _257 => _257.onStroke, 'optionalCall', _258 => _258(strokes)]);
+    await _optionalChain([options, 'access', _265 => _265.onStroke, 'optionalCall', _266 => _266(strokes)]);
   }
   void IDENTITY_AFFINE;
 }
@@ -5684,7 +5717,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', _259 => _259.onProgress, 'optionalCall', _260 => _260(total ? i / total : 1)]);
+      _optionalChain([options, 'access', _267 => _267.onProgress, 'optionalCall', _268 => _268(total ? i / total : 1)]);
     },
     onWetSteps: wetEvery > 0 ? () => shoot(-1) : void 0
   });
@@ -5771,10 +5804,10 @@ function mixPixels(before, after, amount) {
   }
   return out;
 }
-var PaintEffectsRenderer = (_class18 = class {constructor() { _class18.prototype.__init114.call(this);_class18.prototype.__init115.call(this);_class18.prototype.__init116.call(this); }
-  __init114() {this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: 3 })}
-  __init115() {this.descriptions = /* @__PURE__ */ new Map()}
-  __init116() {this.provider = null}
+var PaintEffectsRenderer = (_class18 = class {constructor() { _class18.prototype.__init116.call(this);_class18.prototype.__init117.call(this);_class18.prototype.__init118.call(this); }
+  __init116() {this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: 3 })}
+  __init117() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init118() {this.provider = null}
   /** Forgets cached descriptions and renderers when the provider changes. */
   follow(provider) {
     if (provider === this.provider) return;
@@ -5864,7 +5897,7 @@ async function libraryCall(call) {
   try {
     return await call();
   } catch (e) {
-    throw e instanceof _chunkTZOX7KWVcjs.BrushLibraryError ? new PaintEditorError(e.message) : e;
+    throw e instanceof _chunkBY5EBP26cjs.BrushLibraryError ? new PaintEditorError(e.message) : e;
   }
 }
 var HEX3 = /^#[0-9a-f]{6}$/i;
@@ -5887,12 +5920,12 @@ 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', _261 => _261.type]) === "pixel";
+var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _269 => _269.type]) === "pixel";
 var PaintEditorController = (_class19 = class _PaintEditorController {
   
-  __init117() {this.extensions = {}}
-  __init118() {this.undoStack = []}
-  __init119() {this.redoStack = []}
+  __init119() {this.extensions = {}}
+  __init120() {this.undoStack = []}
+  __init121() {this.redoStack = []}
   
   /** The brush library this editor lists, saves into and paints from (shared with other editors when the host passes one). */
   
@@ -5902,107 +5935,107 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** The library's brushes as last read, each as stored (facets) and as the engine paints it. */
   
   /** The brush id asked for at construction, while the library had not listed it yet. */
-  __init120() {this.pendingBrushId = null}
-  __init121() {this.brushesLoaded = Promise.resolve()}
+  __init122() {this.pendingBrushId = null}
+  __init123() {this.brushesLoaded = Promise.resolve()}
   
   /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
-  __init122() {this.library = null}
+  __init124() {this.library = null}
   
-  __init123() {this.secondaryColor = "#ffffff"}
+  __init125() {this.secondaryColor = "#ffffff"}
   /** Gradient paint chosen with `setPaint` (`null`: the paint colour). */
-  __init124() {this.gradient = null}
+  __init126() {this.gradient = null}
   /** Effect paint chosen with `setEffectPaint` (rendered), and one still rendering. */
-  __init125() {this.effectPaint = null}
-  __init126() {this.effectPaintPending = null}
+  __init127() {this.effectPaint = null}
+  __init128() {this.effectPaintPending = null}
   /** Changes whenever the paint is chosen, so an effect paint that finishes rendering late does not take over. */
-  __init127() {this.paintEpoch = 0}
+  __init129() {this.paintEpoch = 0}
   /** Rendered effect paints by `effectPaintKey` (most recently used last). */
-  __init128() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
-  __init129() {this.mixerLoad = _chunkFQPUF2W2cjs.EMPTY_MIXER_LOAD}
-  __init130() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  __init130() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
+  __init131() {this.mixerLoad = _chunkFQPUF2W2cjs.EMPTY_MIXER_LOAD}
+  __init132() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
   
-  __init131() {this.selectedStroke = null}
-  __init132() {this.selectedSticker = null}
+  __init133() {this.selectedStroke = null}
+  __init134() {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. */
-  __init133() {this.stickerPreview = null}
+  __init135() {this.stickerPreview = null}
   
-  __init134() {this.listeners = /* @__PURE__ */ new Set()}
-  __init135() {this.commitListeners = /* @__PURE__ */ new Set()}
-  __init136() {this.sampleListeners = /* @__PURE__ */ new Set()}
+  __init136() {this.listeners = /* @__PURE__ */ new Set()}
+  __init137() {this.commitListeners = /* @__PURE__ */ new Set()}
+  __init138() {this.sampleListeners = /* @__PURE__ */ new Set()}
   /** Origins set by `withOrigin`, innermost last. */
-  __init137() {this.origins = []}
+  __init139() {this.origins = []}
   /** `group` in progress: commits fold into one step, recorded when it ends. */
-  __init138() {this.grouping = null}
+  __init140() {this.grouping = null}
   /** `previewPaint` in progress: nothing is emitted or recorded. */
-  __init139() {this.previewing = false}
-  __init140() {this.version = 0}
-  __init141() {this.cached = null}
-  __init142() {this.session = null}
-  __init143() {this.live = null}
-  __init144() {this.liveLayers = null}
-  __init145() {this.dirty = "all"}
-  __init146() {this.seedCounter = 1}
-  __init147() {this.strokeCounter = 1}
+  __init141() {this.previewing = false}
+  __init142() {this.version = 0}
+  __init143() {this.cached = null}
+  __init144() {this.session = null}
+  __init145() {this.live = null}
+  __init146() {this.liveLayers = null}
+  __init147() {this.dirty = "all"}
+  __init148() {this.seedCounter = 1}
+  __init149() {this.strokeCounter = 1}
   /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
-  __init148() {this.lightSpills = {}}
-  __init149() {this.lightCaches = /* @__PURE__ */ new Map()}
+  __init150() {this.lightSpills = {}}
+  __init151() {this.lightCaches = /* @__PURE__ */ new Map()}
   /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
-  __init150() {this.backlightView = new BacklightCache()}
-  __init151() {this.backlightCommitted = new BacklightCache()}
+  __init152() {this.backlightView = new BacklightCache()}
+  __init153() {this.backlightCommitted = new BacklightCache()}
   /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
-  __init152() {this.effectPlaybackState = { playing: true, fps: 30 }}
-  __init153() {this.effectTime = 0}
+  __init154() {this.effectPlaybackState = { playing: true, fps: 30 }}
+  __init155() {this.effectTime = 0}
   /** While a frame is drawn: the time live effect strokes are drawn at (else their own time). */
-  __init154() {this.liveEffectAt = null}
+  __init156() {this.liveEffectAt = null}
   /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
-  __init155() {this.animatedLayers = /* @__PURE__ */ new Map()}
+  __init157() {this.animatedLayers = /* @__PURE__ */ new Map()}
   /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
-  __init156() {this.frameOverride = null}
+  __init158() {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`). */
-  __init157() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
+  __init159() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
   
-  __init158() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init159() {this.pad = new MixingPad()}
-  __init160() {this.savedPads = []}
-  __init161() {this.nextPadId = 1}
-  __init162() {this.tracingVersion = 1}
-  __init163() {this.tracingCache = null}
-  __init164() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init165() {this.nextReferenceId = 1}
-  __init166() {this.viewCompositor = createPaintCompositor()}
-  __init167() {this.exportCompositor = createPaintCompositor()}
+  __init160() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init161() {this.pad = new MixingPad()}
+  __init162() {this.savedPads = []}
+  __init163() {this.nextPadId = 1}
+  __init164() {this.tracingVersion = 1}
+  __init165() {this.tracingCache = null}
+  __init166() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init167() {this.nextReferenceId = 1}
+  __init168() {this.viewCompositor = createPaintCompositor()}
+  __init169() {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). */
-  __init168() {this.lighting = { ...DEFAULT_LIGHTING }}
-  __init169() {this.litCaches = /* @__PURE__ */ new Map()}
+  __init170() {this.lighting = { ...DEFAULT_LIGHTING }}
+  __init171() {this.litCaches = /* @__PURE__ */ new Map()}
   /** The live impasto stroke's channels. */
-  __init170() {this.liveThick = null}
+  __init172() {this.liveThick = null}
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
-  __init171() {this.wetOp = null}
+  __init173() {this.wetOp = null}
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init172() {this.effects = new (0, _chunkL2JTLW6Bcjs.EffectsSlot)()}
+  __init174() {this.effects = new (0, _chunkL2JTLW6Bcjs.EffectsSlot)()}
   /** The sticker library slot (see `setStickersProvider`). */
-  __init173() {this.stickers = new (0, _chunkJSDND7DFcjs.StickersSlot)(_chunkRVGP2XLFcjs.editorStickers.call(void 0, ))}
-  __init174() {this.stickerArt = new StickerArtCache()}
+  __init175() {this.stickers = new (0, _chunkOTN6VB5Scjs.StickersSlot)(_chunkXORJ7UZOcjs.editorStickers.call(void 0, ))}
+  __init176() {this.stickerArt = new StickerArtCache()}
   
-  __init175() {this.effectsRenderer = new PaintEffectsRenderer()}
-  __init176() {this.paperEffectNodeCache = null}
-  constructor(options = {}) {;_class19.prototype.__init117.call(this);_class19.prototype.__init118.call(this);_class19.prototype.__init119.call(this);_class19.prototype.__init120.call(this);_class19.prototype.__init121.call(this);_class19.prototype.__init122.call(this);_class19.prototype.__init123.call(this);_class19.prototype.__init124.call(this);_class19.prototype.__init125.call(this);_class19.prototype.__init126.call(this);_class19.prototype.__init127.call(this);_class19.prototype.__init128.call(this);_class19.prototype.__init129.call(this);_class19.prototype.__init130.call(this);_class19.prototype.__init131.call(this);_class19.prototype.__init132.call(this);_class19.prototype.__init133.call(this);_class19.prototype.__init134.call(this);_class19.prototype.__init135.call(this);_class19.prototype.__init136.call(this);_class19.prototype.__init137.call(this);_class19.prototype.__init138.call(this);_class19.prototype.__init139.call(this);_class19.prototype.__init140.call(this);_class19.prototype.__init141.call(this);_class19.prototype.__init142.call(this);_class19.prototype.__init143.call(this);_class19.prototype.__init144.call(this);_class19.prototype.__init145.call(this);_class19.prototype.__init146.call(this);_class19.prototype.__init147.call(this);_class19.prototype.__init148.call(this);_class19.prototype.__init149.call(this);_class19.prototype.__init150.call(this);_class19.prototype.__init151.call(this);_class19.prototype.__init152.call(this);_class19.prototype.__init153.call(this);_class19.prototype.__init154.call(this);_class19.prototype.__init155.call(this);_class19.prototype.__init156.call(this);_class19.prototype.__init157.call(this);_class19.prototype.__init158.call(this);_class19.prototype.__init159.call(this);_class19.prototype.__init160.call(this);_class19.prototype.__init161.call(this);_class19.prototype.__init162.call(this);_class19.prototype.__init163.call(this);_class19.prototype.__init164.call(this);_class19.prototype.__init165.call(this);_class19.prototype.__init166.call(this);_class19.prototype.__init167.call(this);_class19.prototype.__init168.call(this);_class19.prototype.__init169.call(this);_class19.prototype.__init170.call(this);_class19.prototype.__init171.call(this);_class19.prototype.__init172.call(this);_class19.prototype.__init173.call(this);_class19.prototype.__init174.call(this);_class19.prototype.__init175.call(this);_class19.prototype.__init176.call(this);_class19.prototype.__init177.call(this);_class19.prototype.__init178.call(this);_class19.prototype.__init179.call(this);_class19.prototype.__init180.call(this);_class19.prototype.__init181.call(this);_class19.prototype.__init182.call(this);
+  __init177() {this.effectsRenderer = new PaintEffectsRenderer()}
+  __init178() {this.paperEffectNodeCache = null}
+  constructor(options = {}) {;_class19.prototype.__init119.call(this);_class19.prototype.__init120.call(this);_class19.prototype.__init121.call(this);_class19.prototype.__init122.call(this);_class19.prototype.__init123.call(this);_class19.prototype.__init124.call(this);_class19.prototype.__init125.call(this);_class19.prototype.__init126.call(this);_class19.prototype.__init127.call(this);_class19.prototype.__init128.call(this);_class19.prototype.__init129.call(this);_class19.prototype.__init130.call(this);_class19.prototype.__init131.call(this);_class19.prototype.__init132.call(this);_class19.prototype.__init133.call(this);_class19.prototype.__init134.call(this);_class19.prototype.__init135.call(this);_class19.prototype.__init136.call(this);_class19.prototype.__init137.call(this);_class19.prototype.__init138.call(this);_class19.prototype.__init139.call(this);_class19.prototype.__init140.call(this);_class19.prototype.__init141.call(this);_class19.prototype.__init142.call(this);_class19.prototype.__init143.call(this);_class19.prototype.__init144.call(this);_class19.prototype.__init145.call(this);_class19.prototype.__init146.call(this);_class19.prototype.__init147.call(this);_class19.prototype.__init148.call(this);_class19.prototype.__init149.call(this);_class19.prototype.__init150.call(this);_class19.prototype.__init151.call(this);_class19.prototype.__init152.call(this);_class19.prototype.__init153.call(this);_class19.prototype.__init154.call(this);_class19.prototype.__init155.call(this);_class19.prototype.__init156.call(this);_class19.prototype.__init157.call(this);_class19.prototype.__init158.call(this);_class19.prototype.__init159.call(this);_class19.prototype.__init160.call(this);_class19.prototype.__init161.call(this);_class19.prototype.__init162.call(this);_class19.prototype.__init163.call(this);_class19.prototype.__init164.call(this);_class19.prototype.__init165.call(this);_class19.prototype.__init166.call(this);_class19.prototype.__init167.call(this);_class19.prototype.__init168.call(this);_class19.prototype.__init169.call(this);_class19.prototype.__init170.call(this);_class19.prototype.__init171.call(this);_class19.prototype.__init172.call(this);_class19.prototype.__init173.call(this);_class19.prototype.__init174.call(this);_class19.prototype.__init175.call(this);_class19.prototype.__init176.call(this);_class19.prototype.__init177.call(this);_class19.prototype.__init178.call(this);_class19.prototype.__init179.call(this);_class19.prototype.__init180.call(this);_class19.prototype.__init181.call(this);_class19.prototype.__init182.call(this);_class19.prototype.__init183.call(this);_class19.prototype.__init184.call(this);
     this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
     this.rasterizeSticker = _nullishCoalesce(options.rasterizeSticker, () => ( defaultStickerRasterizer));
     if (options.stickers) this.stickers.set(options.stickers);
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
-    const seed = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
-    this.brushLibrary = _nullishCoalesce(options.brushLibrary, () => ( _chunkTZOX7KWVcjs.createBrushLibrary.call(void 0, { storage: seededStorage(seed) })));
-    this.brushEntries = [...builtinLibraryBrushes(), ...seed.map((b) => libraryBrush(_chunkTZOX7KWVcjs.migrateBrushV1.call(void 0, b), false, b))];
-    const wanted = _nullishCoalesce(options.brushId, () => ( _chunkTZOX7KWVcjs.DEFAULT_BRUSH_ID));
-    const start = _nullishCoalesce(this.findEntry(wanted), () => ( this.findEntry(_chunkTZOX7KWVcjs.DEFAULT_BRUSH_ID)));
-    this.brush = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, start.brush);
+    const seed = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
+    this.brushLibrary = _nullishCoalesce(options.brushLibrary, () => ( _chunkBY5EBP26cjs.createBrushLibrary.call(void 0, { storage: seededStorage(seed) })));
+    this.brushEntries = [...builtinLibraryBrushes(), ...seed.map((b) => libraryBrush(_chunkBY5EBP26cjs.migrateBrushV1.call(void 0, b), false, b))];
+    const wanted = _nullishCoalesce(options.brushId, () => ( _chunkBY5EBP26cjs.DEFAULT_BRUSH_ID));
+    const start = _nullishCoalesce(this.findEntry(wanted), () => ( this.findEntry(_chunkBY5EBP26cjs.DEFAULT_BRUSH_ID)));
+    this.brush = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, start.brush);
     this.brushSpec = copyJSON(start.spec);
     this.unsubscribeLibrary = this.brushLibrary.subscribe(() => void this.refreshBrushes().catch(() => void 0));
-    if (options.brushLibrary && seed.length) void this.brushLibrary.importFile(seed.map(_chunkTZOX7KWVcjs.brushToJSON)).catch(() => void 0);
+    if (options.brushLibrary && seed.length) void this.brushLibrary.importFile(seed.map(_chunkBY5EBP26cjs.brushToJSON)).catch(() => void 0);
     void this.refreshBrushes().catch(() => void 0);
     this.pendingBrushId = start.brush.id === wanted ? null : wanted;
     this.color = options.color ? parseColor(options.color) : "#1f2937";
@@ -6016,7 +6049,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         canvas: () => this.doc.canvas,
         paper: () => this.doc.paper,
         layerSurface: (id) => {
-          const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _262 => _262.layer]);
+          const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _270 => _270.layer]);
           return isPixelLayer(l) ? l.surface : null;
         },
         updateSurfaces: (surfaces, rects) => {
@@ -6025,7 +6058,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
           this.doc = { ...this.doc, layers };
           this.emit(rects.length ? rects : "all");
         },
-        layerLight: (id) => _nullishCoalesce(_optionalChain([this, 'access', _263 => _263.doc, 'access', _264 => _264.light, 'optionalAccess', _265 => _265[id]]), () => ( null)),
+        layerLight: (id) => _nullishCoalesce(_optionalChain([this, 'access', _271 => _271.doc, 'access', _272 => _272.light, 'optionalAccess', _273 => _273[id]]), () => ( null)),
         updateLights: (lights) => {
           let light = this.doc.light;
           for (const [id, surface] of lights) if (_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id)) light = withLayerLight(light, id, surface);
@@ -6036,7 +6069,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       },
       options.wet
     );
-    this.wet.onDriverDone = () => _optionalChain([this, 'access', _266 => _266.session, 'optionalAccess', _267 => _267.completeWetEnd, 'call', _268 => _268()]);
+    this.wet.onDriverDone = () => _optionalChain([this, 'access', _274 => _274.session, 'optionalAccess', _275 => _275.completeWetEnd, 'call', _276 => _276()]);
   }
   // --- State and events ----------------------------------------------------------
   subscribe(listener) {
@@ -6160,7 +6193,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       if (placement.bottom) this.moveLayer(layer.id, 0, null);
       fn(layer.id);
       if (this.wetOp || this.pendingWetEvents.length) throw new PaintEditorError("Wet paint can't be previewed; suggest it with a dry brush.");
-      const found = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, layer.id), 'optionalAccess', _269 => _269.layer]);
+      const found = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, layer.id), 'optionalAccess', _277 => _277.layer]);
       const surface = found && isPixelLayer(found) ? found.surface : null;
       const bounds = surface ? _chunk474IQG74cjs.contentBounds.call(void 0, surface) : null;
       const box = bounds ? clipToCanvas(bounds, this.doc.canvas) : null;
@@ -6213,8 +6246,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       selectedSticker: this.selectedSticker,
       canUndo: this.undoStack.length > 0 && !this.session,
       canRedo: this.redoStack.length > 0 && !this.session,
-      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _270 => _270.label]), () => ( null)),
-      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _271 => _271.label]), () => ( null)),
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _278 => _278.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _279 => _279.label]), () => ( null)),
       guides: this.guides,
       swatches: this.swatches,
       mixingPadVersion: this.pad.version,
@@ -6227,10 +6260,10 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         overlay: this.wet.overlay,
         instantDry: this.wet.instantDry,
         speed: this.wet.speed,
-        clock: _nullishCoalesce(_optionalChain([this, 'access', _272 => _272.wet, 'access', _273 => _273.world, 'optionalAccess', _274 => _274.clock]), () => ( 0)),
+        clock: _nullishCoalesce(_optionalChain([this, 'access', _280 => _280.wet, 'access', _281 => _281.world, 'optionalAccess', _282 => _282.clock]), () => ( 0)),
         tilt: { ...this.wet.tilt },
         gpu: this.wet.gpuMode,
-        gpuActive: Boolean(_optionalChain([this, 'access', _275 => _275.wet, 'access', _276 => _276.world, 'optionalAccess', _277 => _277.gpuActive]))
+        gpuActive: Boolean(_optionalChain([this, 'access', _283 => _283.wet, 'access', _284 => _284.world, 'optionalAccess', _285 => _285.gpuActive]))
       },
       version: this.version
     };
@@ -6249,7 +6282,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return d;
   }
   // --- History -------------------------------------------------------------------
-  __init177() {this.docRevision = 0}
+  __init179() {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.
@@ -6340,9 +6373,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return wetIds;
   }
   /** Records a wet event (for replays) in the document being built. */
-  __init178() {this.pendingWetEvents = []}
+  __init180() {this.pendingWetEvents = []}
   logWet(e) {
-    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _278 => _278.wet, 'access', _279 => _279.world, 'optionalAccess', _280 => _280.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
+    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _286 => _286.wet, 'access', _287 => _287.world, 'optionalAccess', _288 => _288.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
   }
   /** The document with a paint event appended (for replays). */
   withPaintEvent(doc, e) {
@@ -6488,7 +6521,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
     for (const id of keptWet) {
-      const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _281 => _281.layer]);
+      const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _289 => _289.layer]);
       if (isPixelLayer(l)) next = { ...next, layers: _chunkPVJMTLPJcjs.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) {
@@ -6532,7 +6565,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   // --- Layers --------------------------------------------------------------------
   getLayer(id) {
-    return _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _282 => _282.layer]);
+    return _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _290 => _290.layer]);
   }
   /** The active pixel layer (or `undefined`). */
   getActiveLayer() {
@@ -6551,7 +6584,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     walk(this.doc.layers, null, 0);
     return out;
   }
-  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _283 => _283.parent, 'optionalAccess', _284 => _284.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _285 => _285.path, 'access', _286 => _286.length]), () => ( 0))) {
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _291 => _291.parent, 'optionalAccess', _292 => _292.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _293 => _293.path, 'access', _294 => _294.length]), () => ( 0))) {
     let bounds = null;
     if (l.type === "pixel") {
       const b = _chunk474IQG74cjs.contentBounds.call(void 0, l.surface);
@@ -6568,8 +6601,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       locks: { ..._nullishCoalesce(l.locks, () => ( {})) },
       active: l.id === this.doc.activeLayerId,
       bounds,
-      ..._optionalChain([this, 'access', _287 => _287.doc, 'access', _288 => _288.liveStrokes, 'optionalAccess', _289 => _289[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
-      ..._optionalChain([l, 'access', _290 => _290.effects, 'optionalAccess', _291 => _291.items, 'access', _292 => _292.length]) ? { effects: l.effects.items.length } : {},
+      ..._optionalChain([this, 'access', _295 => _295.doc, 'access', _296 => _296.liveStrokes, 'optionalAccess', _297 => _297[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
+      ..._optionalChain([l, 'access', _298 => _298.effects, 'optionalAccess', _299 => _299.items, 'access', _300 => _300.length]) ? { effects: l.effects.items.length } : {},
       parentId,
       depth
     };
@@ -6601,7 +6634,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.requireIdle("adding a layer");
     const count = _chunkPVJMTLPJcjs.flattenLayers.call(void 0, this.doc.layers).length;
     const type = _nullishCoalesce(options.type, () => ( "pixel"));
-    const name = _optionalChain([options, 'access', _293 => _293.name, 'optionalAccess', _294 => _294.trim, 'call', _295 => _295()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
+    const name = _optionalChain([options, 'access', _301 => _301.name, 'optionalAccess', _302 => _302.trim, 'call', _303 => _303()]) || (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;
@@ -6613,7 +6646,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     } else if (above) {
       const loc = _chunkPVJMTLPJcjs.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', _296 => _296.parent, 'optionalAccess', _297 => _297.id]), () => ( null));
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _304 => _304.parent, 'optionalAccess', _305 => _305.id]), () => ( null));
       index = loc.index + 1;
     }
     const layers = _chunkPVJMTLPJcjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
@@ -6719,7 +6752,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   requireEffect(id, effectId) {
     const l = this.requireLayer(id);
-    const items = _nullishCoalesce(_optionalChain([l, 'access', _298 => _298.effects, 'optionalAccess', _299 => _299.items]), () => ( []));
+    const items = _nullishCoalesce(_optionalChain([l, 'access', _306 => _306.effects, 'optionalAccess', _307 => _307.items]), () => ( []));
     const i = items.findIndex((e) => e.id === effectId);
     if (i === -1) throw new PaintEditorError(`Layer "${l.name}" has no effect "${effectId}". Effects: ${items.map((e) => `${e.id} (${e.kind})`).join(", ") || "none"}; call list_layer_effects.`);
     return i;
@@ -6742,7 +6775,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     const layers = _chunkPVJMTLPJcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
-    if (active && !_chunkPVJMTLPJcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.flattenLayers.call(void 0, layers), 'access', _300 => _300.filter, 'call', _301 => _301((x) => x.type === "pixel"), 'access', _302 => _302.pop, 'call', _303 => _303(), 'optionalAccess', _304 => _304.id]), () => ( null));
+    if (active && !_chunkPVJMTLPJcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.flattenLayers.call(void 0, layers), 'access', _308 => _308.filter, 'call', _309 => _309((x) => x.type === "pixel"), 'access', _310 => _310.pop, 'call', _311 => _311(), 'optionalAccess', _312 => _312.id]), () => ( null));
     this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkPVJMTLPJcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkPVJMTLPJcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.liveStrokesWithout(_chunkPVJMTLPJcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.lightWithout(_chunkPVJMTLPJcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
     return { removed: id, activeLayerId: active };
   }
@@ -6768,7 +6801,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       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 = _chunkPVJMTLPJcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _305 => _305.parent, 'optionalAccess', _306 => _306.id]), () => ( null)), loc.index + 1);
+    const layers = _chunkPVJMTLPJcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _313 => _313.parent, 'optionalAccess', _314 => _314.id]), () => ( null)), loc.index + 1);
     this.commit("Duplicate layer", this.withWetEvents({ ...this.doc, layers, activeLayerId: dup.id, ...this.doc.thick ? { thick } : {}, ...this.doc.stickers ? { stickers } : {}, ...this.doc.liveStrokes ? { liveStrokes } : {}, ...this.doc.light ? { light } : {} }));
     return this.describeLayer(dup);
   }
@@ -6777,7 +6810,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.requireIdle("moving a layer");
     const loc = _chunkPVJMTLPJcjs.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', _307 => _307.parent, 'optionalAccess', _308 => _308.id]), () => ( null)) : parentId;
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _315 => _315.parent, 'optionalAccess', _316 => _316.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.`);
@@ -6796,7 +6829,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const pre = _chunkPVJMTLPJcjs.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', _309 => _309[pre.index - 1], 'optionalAccess', _310 => _310.id])].filter((x) => Boolean(x)));
+      this.dryLayersFirst([id, _optionalChain([sib, 'access', _317 => _317[pre.index - 1], 'optionalAccess', _318 => _318.id])].filter((x) => Boolean(x)));
     }
     const loc = _chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
@@ -6816,7 +6849,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = _chunkPVJMTLPJcjs.mapLayer.call(void 0, _chunkPVJMTLPJcjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
     const toDoc = (t, l) => t ? _chunk474IQG74cjs.translateSurface.call(void 0, t, l.offset.x, l.offset.y) : void 0;
-    const mergedLight = _optionalChain([this, 'access', _311 => _311.doc, 'access', _312 => _312.light, 'optionalAccess', _313 => _313[upper.id]]) || _optionalChain([this, 'access', _314 => _314.doc, 'access', _315 => _315.light, 'optionalAccess', _316 => _316[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _317 => _317.doc, 'access', _318 => _318.light, 'optionalAccess', _319 => _319[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _320 => _320.doc, 'access', _321 => _321.light, 'optionalAccess', _322 => _322[upper.id]]), upper) : void 0, _chunk474IQG74cjs.translateSurface.call(void 0, upper.surface, upper.offset.x, upper.offset.y)) : void 0;
+    const mergedLight = _optionalChain([this, 'access', _319 => _319.doc, 'access', _320 => _320.light, 'optionalAccess', _321 => _321[upper.id]]) || _optionalChain([this, 'access', _322 => _322.doc, 'access', _323 => _323.light, 'optionalAccess', _324 => _324[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _325 => _325.doc, 'access', _326 => _326.light, 'optionalAccess', _327 => _327[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _328 => _328.doc, 'access', _329 => _329.light, 'optionalAccess', _330 => _330[upper.id]]), upper) : void 0, _chunk474IQG74cjs.translateSurface.call(void 0, upper.surface, upper.offset.x, upper.offset.y)) : void 0;
     const lightAfter = _nullishCoalesce(this.lightWithout([upper.id, below.id]).light, () => ( (this.doc.light ? { ...this.doc.light } : void 0)));
     const light = mergedLight ? { ..._nullishCoalesce(lightAfter, () => ( {})), [below.id]: mergedLight } : lightAfter;
     this.commit("Merge down", this.withWetEvents({ ...this.doc, layers, activeLayerId: below.id, ...this.thickWithout([upper.id]), ...this.stickersWithout([upper.id, below.id]), ...this.liveStrokesWithout([upper.id, below.id]), ...light ? { light } : {} }));
@@ -6831,7 +6864,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       this.wet.world.removeLane(l.id);
     }
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkPVJMTLPJcjs.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', _323 => _323.doc, 'access', _324 => _324.liveStrokes, 'optionalAccess', _325 => _325[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
+    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkPVJMTLPJcjs.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', _331 => _331.doc, 'access', _332 => _332.liveStrokes, 'optionalAccess', _333 => _333[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
     return { layerId: l.id, bounds };
   }
   /**
@@ -6841,8 +6874,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   fillLayer(options = {}) {
     this.requireIdle("filling");
     const fillTarget = this.paintTarget(options.layerId, "fill");
-    if (_optionalChain([this, 'access', _326 => _326.doc, 'access', _327 => _327.stickers, 'optionalAccess', _328 => _328[fillTarget.id], 'optionalAccess', _329 => _329.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _330 => _330.doc, 'access', _331 => _331.liveStrokes, 'optionalAccess', _332 => _332[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).`);
+    if (_optionalChain([this, 'access', _334 => _334.doc, 'access', _335 => _335.stickers, 'optionalAccess', _336 => _336[fillTarget.id], 'optionalAccess', _337 => _337.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _338 => _338.doc, 'access', _339 => _339.liveStrokes, 'optionalAccess', _340 => _340[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);
@@ -6875,7 +6908,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       offset: l.offset
     };
     const surface = this.applyCoverage(l, coverage, rect, apply);
-    const lit = _optionalChain([this, 'access', _333 => _333.doc, 'access', _334 => _334.light, 'optionalAccess', _335 => _335[l.id]]);
+    const lit = _optionalChain([this, 'access', _341 => _341.doc, 'access', _342 => _342.light, 'optionalAccess', _343 => _343[l.id]]);
     const light = lit ? withLayerLight(this.doc.light, l.id, scaleLight(lit, 1 - opacity)) : void 0;
     this.commit("Fill layer", this.withPaintEvent(this.withWetEvents({ ...this.doc, layers: _chunkPVJMTLPJcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), ...light ? { light } : {} }), { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }));
     return { layerId: l.id, bounds: rect };
@@ -6885,7 +6918,7 @@ var PaintEditorController = (_class19 = 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', _336 => _336.tiles, 'access', _337 => _337.get, 'call', _338 => _338(key), 'optionalAccess', _339 => _339.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _344 => _344.tiles, 'access', _345 => _345.get, 'call', _346 => _346(key), 'optionalAccess', _347 => _347.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
       const tile = _chunk474IQG74cjs.finishTile.call(void 0, _chunkFQPUF2W2cjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
       if (tile) tiles.set(key, tile);
       else tiles.delete(key);
@@ -6918,7 +6951,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** The effect a layer is drawn from, or `undefined` for other layers. */
   getEffectLayer(layerId) {
-    return _chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _340 => _340.doc, 'access', _341 => _341.effectLayers, 'optionalAccess', _342 => _342[layerId]]) : void 0;
+    return _chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _348 => _348.doc, 'access', _349 => _349.effectLayers, 'optionalAccess', _350 => _350[layerId]]) : void 0;
   }
   /** The effect paper (without its pixels), or `null`. */
   getPaperEffect() {
@@ -6955,8 +6988,8 @@ var PaintEditorController = (_class19 = 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', _343 => _343.doc, 'access', _344 => _344.stickers, 'optionalAccess', _345 => _345[l.id], 'optionalAccess', _346 => _346.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _347 => _347.doc, 'access', _348 => _348.liveStrokes, 'optionalAccess', _349 => _349[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 (_optionalChain([this, 'access', _351 => _351.doc, 'access', _352 => _352.stickers, 'optionalAccess', _353 => _353[l.id], 'optionalAccess', _354 => _354.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _355 => _355.doc, 'access', _356 => _356.liveStrokes, 'optionalAccess', _357 => _357[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;
   }
@@ -6995,8 +7028,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const was = this.doc.paperEffect;
     const paperEffect = {
       ...this.sourceOf(d, values, options.time),
-      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _350 => _350.opacity]))), () => ( 1)),
-      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _351 => _351.blend]))), () => ( "multiply")),
+      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _358 => _358.opacity]))), () => ( 1)),
+      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _359 => _359.blend]))), () => ( "multiply")),
       image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) },
       version: nextPaperEffectVersion()
     };
@@ -7049,8 +7082,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const above = _nullishCoalesce(options.aboveId, () => ( this.doc.activeLayerId));
     const loc = above ? _chunkPVJMTLPJcjs.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', _352 => _352.name, 'optionalAccess', _353 => _353.trim, 'call', _354 => _354()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
-    const layers = _chunkPVJMTLPJcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _355 => _355.parent, 'optionalAccess', _356 => _356.id]), () => ( null)), loc ? loc.index + 1 : void 0);
+    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _360 => _360.name, 'optionalAccess', _361 => _361.trim, 'call', _362 => _362()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
+    const layers = _chunkPVJMTLPJcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _363 => _363.parent, 'optionalAccess', _364 => _364.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 };
@@ -7203,7 +7236,7 @@ var PaintEditorController = (_class19 = 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 paints2 = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _357 => _357.paint, 'optionalAccess', _358 => _358.type]) === "effect").map((s) => s.paint);
+    const paints2 = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _365 => _365.paint, 'optionalAccess', _366 => _366.type]) === "effect").map((s) => s.paint);
     await this.prepareEffectPaints(paints2);
   }
   /** A small preview of the effect paint (a PNG data URL `size` px wide), or `null` without a rendered one. */
@@ -7232,7 +7265,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * its pixels are not rendered.
    */
   strokeEffect(init, brush) {
-    if (!_chunkTZOX7KWVcjs.brushTakesPaint.call(void 0, brush)) return null;
+    if (!_chunkBY5EBP26cjs.brushTakesPaint.call(void 0, brush)) return null;
     let source = null;
     if (init.paint !== void 0) {
       if (!isPaintEffectPaint(init.paint)) return null;
@@ -7266,14 +7299,14 @@ var PaintEditorController = (_class19 = 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', _359 => _359.doc, 'access', _360 => _360.thick, 'optionalAccess', _361 => _361[l.id]]);
+    const relief = _optionalChain([this, 'access', _367 => _367.doc, 'access', _368 => _368.thick, 'optionalAccess', _369 => _369[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', _362 => _362.inputs, 'access', _363 => _363.find, 'call', _364 => _364((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _365 => _365.name])), 'optionalAccess', _366 => _366.name]), () => ( "source"));
+    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _370 => _370.inputs, 'access', _371 => _371.find, 'call', _372 => _372((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _373 => _373.name])), 'optionalAccess', _374 => _374.name]), () => ( "source"));
     if (sourceInput !== "source") {
       inputs[sourceInput] = inputs.source;
       delete inputs.source;
@@ -7289,11 +7322,11 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return this.brushEntries.find((e) => e.brush.id === id);
   }
   findBrush(id) {
-    return _optionalChain([this, 'access', _367 => _367.findEntry, 'call', _368 => _368(id), 'optionalAccess', _369 => _369.brush]);
+    return _optionalChain([this, 'access', _375 => _375.findEntry, 'call', _376 => _376(id), 'optionalAccess', _377 => _377.brush]);
   }
   requireEntry(id) {
     const e = this.findEntry(id);
-    if (!e) throw new PaintEditorError(`Unknown brush "${id}". ${_chunkTZOX7KWVcjs.closest.call(void 0, id, this.brushEntries.map((x) => x.brush.id))}Call list_brush_presets for the ids.`);
+    if (!e) throw new PaintEditorError(`Unknown brush "${id}". ${_chunkBY5EBP26cjs.closest.call(void 0, id, this.brushEntries.map((x) => x.brush.id))}Call list_brush_presets for the ids.`);
     return e;
   }
   requireBrush(id) {
@@ -7319,11 +7352,11 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** A library brush by id, as the engine paints it (`undefined` when unknown). */
   getBrush(id) {
     const b = this.findBrush(id);
-    return b ? _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, b, b) : void 0;
+    return b ? _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, b, b) : void 0;
   }
   /** A library brush by id as stored (its facets), or without an id the active brush as edited. */
   getBrushSpec(id) {
-    const spec = id === void 0 ? this.brushSpec : _optionalChain([this, 'access', _370 => _370.findEntry, 'call', _371 => _371(id), 'optionalAccess', _372 => _372.spec]);
+    const spec = id === void 0 ? this.brushSpec : _optionalChain([this, 'access', _378 => _378.findEntry, 'call', _379 => _379(id), 'optionalAccess', _380 => _380.spec]);
     return spec ? copyJSON(spec) : void 0;
   }
   /**
@@ -7337,7 +7370,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const baseSpec = entry ? entry.spec : this.brushSpec;
     if (changes.paint !== void 0 && changes.paint !== null) this.readStrokePaint(changes.paint);
     const unchanged = !Object.keys(changes).length;
-    const next = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
+    const next = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
     if (entry) this.takeBrushColour(entry.spec);
     this.useBrush(next, unchanged ? baseSpec : brushSpecOf(next, baseSpec), unchanged && base.builtin === true);
     return this.brush;
@@ -7355,8 +7388,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const base = copyJSON(entry ? entry.spec : this.brushSpec);
     for (const k of unset) delete base[k];
     const spec = this.readBrushPatch(base, patch, problems);
-    if (entry || _optionalChain([patch, 'access', _373 => _373.colour, 'optionalAccess', _374 => _374.default]) !== void 0) this.takeBrushColour(spec);
-    this.useBrush(unchanged && entry ? entry.brush : _chunkTZOX7KWVcjs.resolveBrush.call(void 0, spec), spec, unchanged && _optionalChain([entry, 'optionalAccess', _375 => _375.builtin]) === true);
+    if (entry || _optionalChain([patch, 'access', _381 => _381.colour, 'optionalAccess', _382 => _382.default]) !== void 0) this.takeBrushColour(spec);
+    this.useBrush(unchanged && entry ? entry.brush : _chunkBY5EBP26cjs.resolveBrush.call(void 0, spec), spec, unchanged && _optionalChain([entry, 'optionalAccess', _383 => _383.builtin]) === true);
     return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
   }
   /**
@@ -7366,15 +7399,15 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   setBrushSpec(spec) {
     const problems = [];
-    const paint = _optionalChain([spec, 'access', _376 => _376.colour, 'optionalAccess', _377 => _377.default]);
+    const paint = _optionalChain([spec, 'access', _384 => _384.colour, 'optionalAccess', _385 => _385.default]);
     if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
     let next;
     try {
-      next = _chunkTZOX7KWVcjs.normalizeBrushSpec.call(void 0, { ...spec, id: this.brush.id }, problems);
+      next = _chunkBY5EBP26cjs.normalizeBrushSpec.call(void 0, { ...spec, id: this.brush.id }, problems);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
-    this.useBrush(_chunkTZOX7KWVcjs.resolveBrush.call(void 0, next), next, false);
+    this.useBrush(_chunkBY5EBP26cjs.resolveBrush.call(void 0, next), next, false);
     return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
   }
   /**
@@ -7383,22 +7416,22 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   brushChanges(patch, from) {
     const entry = typeof from === "string" ? this.requireEntry(from) : null;
-    const base = entry ? entry.brush : typeof from === "object" ? _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, from, from) : this.brush;
-    const spec = entry ? entry.spec : typeof from === "object" ? _chunkTZOX7KWVcjs.migrateBrushV1.call(void 0, base) : this.brushSpec;
-    return engineChanges(base, _chunkTZOX7KWVcjs.resolveBrush.call(void 0, this.readBrushPatch(spec, patch, [])));
+    const base = entry ? entry.brush : typeof from === "object" ? _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, from, from) : this.brush;
+    const spec = entry ? entry.spec : typeof from === "object" ? _chunkBY5EBP26cjs.migrateBrushV1.call(void 0, base) : this.brushSpec;
+    return engineChanges(base, _chunkBY5EBP26cjs.resolveBrush.call(void 0, this.readBrushPatch(spec, patch, [])));
   }
   readBrushPatch(base, patch, problems) {
     const { id: _id, name, ...rest } = patch;
-    const paint = _optionalChain([rest, 'access', _378 => _378.colour, 'optionalAccess', _379 => _379.default]);
+    const paint = _optionalChain([rest, 'access', _386 => _386.colour, 'optionalAccess', _387 => _387.default]);
     if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
     try {
-      return _chunkTZOX7KWVcjs.normalizeBrushSpec.call(void 0, _chunkPYTJBVW5cjs.mergeBrushPatch.call(void 0, base, { ...rest, ...name !== void 0 ? { name } : {} }), problems);
+      return _chunkBY5EBP26cjs.normalizeBrushSpec.call(void 0, _chunkF3KKR6DDcjs.mergeBrushPatch.call(void 0, base, { ...rest, ...name !== void 0 ? { name } : {} }), problems);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
   }
   useBrush(next, spec, builtin) {
-    next = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, next, next);
+    next = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, next, next);
     if (builtin) next.builtin = true;
     else delete next.builtin;
     this.brush = next;
@@ -7414,9 +7447,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * saved brush.
    */
   async saveBrush(options) {
-    if (!_chunkTZOX7KWVcjs.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 (!_chunkBY5EBP26cjs.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 (this.brushLibrary.isBuiltin(options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
-    const spec = options.brush ? brushSpecOf(_chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, options.brush, this.brush), this.brushSpec) : this.brushSpec;
+    const spec = options.brush ? brushSpecOf(_chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, options.brush, this.brush), this.brushSpec) : this.brushSpec;
     const { brush } = await libraryCall(() => this.brushLibrary.save({ ...spec, id: options.id, name: _nullishCoalesce(options.name, () => ( spec.name)) }, { overwrite: true }));
     await this.refreshBrushes();
     return this.requireBrush(brush.id);
@@ -7429,7 +7462,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** The user's saved brushes, as the engine paints them. */
   getUserBrushes() {
-    return this.brushEntries.filter((e) => !e.builtin).map((e) => _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, e.brush, e.brush));
+    return this.brushEntries.filter((e) => !e.builtin).map((e) => _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, e.brush, e.brush));
   }
   /** A brush library file (version 2) of the given brushes (default: the user's brushes). */
   exportBrushes(ids) {
@@ -7452,9 +7485,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   // --- Colour --------------------------------------------------------------------
   
-  __init179() {this.colorLocked = false}
+  __init181() {this.colorLocked = false}
   /** The brush default colour the paint colour came from (resolved again when the scheme changes), or `null`. */
-  __init180() {this.brushColour = null}
+  __init182() {this.brushColour = null}
   /**
    * The host's colour scheme: a paint colour that came from a brush's light / dark default
    * resolves to the new side. Editor state, not an undo step.
@@ -7465,6 +7498,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.colorScheme = next;
     const hex2 = this.brushColour ? _chunkLRTR4ASZcjs.brushColourHex.call(void 0, this.brushColour, next) : null;
     if (hex2) this.color = hex2;
+    const refs = brushStickerRefs(this.brush);
+    if (refs.some((r) => !_chunkOTN6VB5Scjs.editorStampOf.call(void 0, r))) void this.prepareStickers(refs).catch(() => this.emit([]));
     this.emit([]);
   }
   /** Locks the paint colour: choosing a brush with a default colour keeps it. Editor state, not an undo step. */
@@ -7480,7 +7515,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   takeBrushColour(spec) {
     if (this.colorLocked) return;
-    const d = _optionalChain([spec, 'access', _380 => _380.colour, 'optionalAccess', _381 => _381.default]);
+    const d = _optionalChain([spec, 'access', _388 => _388.colour, 'optionalAccess', _389 => _389.default]);
     const hex2 = d !== void 0 ? _chunkLRTR4ASZcjs.brushColourHex.call(void 0, d, this.colorScheme) : null;
     if (!hex2) return;
     this.color = hex2;
@@ -7491,8 +7526,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** A brush that always paints its own colour (`colour.own`): that colour, resolved for the scheme now; else `null`. */
   ownColour(brushId) {
-    const spec = brushId !== void 0 ? _optionalChain([this, 'access', _382 => _382.findEntry, 'call', _383 => _383(brushId), 'optionalAccess', _384 => _384.spec]) : this.brushSpec;
-    const d = _optionalChain([spec, 'optionalAccess', _385 => _385.colour, 'optionalAccess', _386 => _386.own]) ? spec.colour.default : void 0;
+    const spec = brushId !== void 0 ? _optionalChain([this, 'access', _390 => _390.findEntry, 'call', _391 => _391(brushId), 'optionalAccess', _392 => _392.spec]) : this.brushSpec;
+    const d = _optionalChain([spec, 'optionalAccess', _393 => _393.colour, 'optionalAccess', _394 => _394.own]) ? spec.colour.default : void 0;
     return d !== void 0 ? _chunkLRTR4ASZcjs.brushColourHex.call(void 0, d, this.colorScheme) : null;
   }
   /** Sets the paint colour (and goes back to one colour from gradient paint). */
@@ -7535,7 +7570,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * brush's gradient, else the editor's gradient paint. Erasers, blenders and smudges take none.
    */
   strokeGradient(init, brush, color) {
-    if (!_chunkTZOX7KWVcjs.brushTakesPaint.call(void 0, brush)) return null;
+    if (!_chunkBY5EBP26cjs.brushTakesPaint.call(void 0, brush)) return null;
     let g = null;
     if (init.paint !== void 0) {
       if (isPaintEffectPaint(init.paint)) return null;
@@ -7612,7 +7647,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   // --- Strokes -------------------------------------------------------------------
   strokeBrush(init) {
     let brush = init.brushId !== void 0 ? this.requireBrush(init.brushId) : this.brush;
-    if (init.brush) brush = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ...init.brush, id: brush.id }, brush);
+    if (init.brush) brush = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { ...init.brush, id: brush.id }, brush);
     return brush;
   }
   /**
@@ -7645,30 +7680,30 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       return l;
     })();
     const brush = this.strokeBrush(init);
-    if (this.previewing && _chunkTZOX7KWVcjs.isWetBrush.call(void 0, brush)) throw new PaintEditorError(`Wet paint can't be previewed; the ${brush.name} brush paints wet media. Suggest it with a dry brush.`);
+    if (this.previewing && _chunkBY5EBP26cjs.isWetBrush.call(void 0, brush)) throw new PaintEditorError(`Wet paint can't be previewed; the ${brush.name} brush paints wet media. Suggest it with a dry brush.`);
     const effect = this.strokeEffect(init, brush);
     if (brush.light.amount > 0) {
       if (brush.engine === "sticker") throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take light yet; paint light with a dab or particle light brush (glow-gel, neon-marker; list_brush_presets lists them), or set light.amount to 0 (set_brush).`);
     }
-    if (_optionalChain([doc, 'access', _387 => _387.liveStrokes, 'optionalAccess', _388 => _388[layer.id]])) {
+    if (_optionalChain([doc, 'access', _395 => _395.liveStrokes, 'optionalAccess', _396 => _396[layer.id]])) {
       const why = liveStrokeRefusal(brush);
       if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
     }
-    if (_optionalChain([doc, 'access', _389 => _389.liveStrokes, 'optionalAccess', _390 => _390[layer.id]]) && _optionalChain([effect, 'optionalAccess', _391 => _391.source, 'access', _392 => _392.live])) {
+    if (_optionalChain([doc, 'access', _397 => _397.liveStrokes, 'optionalAccess', _398 => _398[layer.id]]) && _optionalChain([effect, 'optionalAccess', _399 => _399.source, 'access', _400 => _400.live])) {
       const key = effectPaintKey(effect.source);
       const { sources } = this.liveEffects(doc);
       if (!sources.some((p) => effectPaintKey(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', _393 => _393.stickers, 'optionalAccess', _394 => _394[layer.id], 'optionalAccess', _395 => _395.length]));
+    const stickerLayer = Boolean(_optionalChain([doc, 'access', _401 => _401.stickers, 'optionalAccess', _402 => _402[layer.id], 'optionalAccess', _403 => _403.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 (_chunkTZOX7KWVcjs.isWetBrush.call(void 0, brush)) {
+    if (_chunkBY5EBP26cjs.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 } };
@@ -7701,7 +7736,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         copies: [IDENTITY_AFFINE, ...copiesW].map(affineCopy),
         mask: init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null,
         paint: effect ? null : wetGradient,
-        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _396 => _396.pixels]), () => ( null))
+        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _404 => _404.pixels]), () => ( null))
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
@@ -7712,7 +7747,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     let color = init.color === void 0 ? _nullishCoalesce(this.ownColour(init.brushId), () => ( this.color)) : parseColor(init.color);
     const tracing = this.guides.tracing;
-    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _397 => _397.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _405 => _405.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;
@@ -7745,10 +7780,10 @@ var PaintEditorController = (_class19 = 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', _398 => _398.thick, 'optionalAccess', _399 => _399[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _406 => _406.thick, 'optionalAccess', _407 => _407[layer.id]]), () => ( emptyThickChannels())) } : void 0,
       // Light paint: a twin of the stroke paints the light channel (laying, dimming, moving light).
-      light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || _optionalChain([doc, 'access', _400 => _400.light, 'optionalAccess', _401 => _401[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _402 => _402.light, 'optionalAccess', _403 => _403[layer.id]]), () => ( emptyLight())) } : null,
-      sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc), art: this.stickerArt.get } : void 0,
+      light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || _optionalChain([doc, 'access', _408 => _408.light, 'optionalAccess', _409 => _409[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _410 => _410.light, 'optionalAccess', _411 => _411[layer.id]]), () => ( emptyLight())) } : null,
+      sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc), art: this.stickerArt.get, variant: (ref2) => this.stickerArt.variantFor(ref2, this.colorScheme === "dark") } : void 0,
       stampArt: this.stickerArt.get,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
@@ -7762,7 +7797,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const stroke = {
       id: `s${this.strokeCounter++}`,
       layerId: session.layerId,
-      brush: _chunkTZOX7KWVcjs.brushToJSON.call(void 0, init.brush),
+      brush: _chunkBY5EBP26cjs.brushToJSON.call(void 0, init.brush),
       color: init.colorHex,
       points: session.points.map((p) => ({ ...p })),
       seed: init.seed
@@ -7787,12 +7822,12 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
-        if (_optionalChain([this, 'access', _404 => _404.session, 'optionalAccess', _405 => _405.init, 'access', _406 => _406.wet])) {
+        if (_optionalChain([this, 'access', _412 => _412.session, 'optionalAccess', _413 => _413.init, 'access', _414 => _414.wet])) {
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
-        const ch = _optionalChain([this, 'access', _407 => _407.session, 'optionalAccess', _408 => _408.thickChannels, 'call', _409 => _409()]);
+        const ch = _optionalChain([this, 'access', _415 => _415.session, 'optionalAccess', _416 => _416.thickChannels, 'call', _417 => _417()]);
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
@@ -7805,7 +7840,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         const wetStroke = Boolean(s.init.wet);
         if (wetStroke) this.wet.driver = null;
         const brush = s.init.brush;
-        if (!cancelled && _optionalChain([s, 'access', _410 => _410.result, 'optionalAccess', _411 => _411.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
+        if (!cancelled && _optionalChain([s, 'access', _418 => _418.result, 'optionalAccess', _419 => _419.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           if (this.wetOp) {
             const snap = this.wetOp.before;
@@ -7821,7 +7856,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         }
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _412 => _412.result, 'optionalAccess', _413 => _413.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _420 => _420.result, 'optionalAccess', _421 => _421.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 });
@@ -7832,8 +7867,8 @@ var PaintEditorController = (_class19 = 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', _414 => _414.doc, 'access', _415 => _415.stickers, 'optionalAccess', _416 => _416[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
-        const wetLight = wetStroke && _optionalChain([this, 'access', _417 => _417.wet, 'access', _418 => _418.world, 'optionalAccess', _419 => _419.hasLane, 'call', _420 => _420(l.id)]) ? this.wet.world.lightDisplay(l.id) : null;
+        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _422 => _422.doc, 'access', _423 => _423.stickers, 'optionalAccess', _424 => _424[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
+        const wetLight = wetStroke && _optionalChain([this, 'access', _425 => _425.wet, 'access', _426 => _426.world, 'optionalAccess', _427 => _427.hasLane, 'call', _428 => _428(l.id)]) ? this.wet.world.lightDisplay(l.id) : null;
         const light = withLayerLight(this.doc.light, l.id, _nullishCoalesce(s.lightChannel(), () => ( wetLight)));
         this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: _chunkPVJMTLPJcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {}, ...light ? { light } : {} }, stroke)), wetStroke ? before : this.doc);
         this.notifySample("end", s, [], stroke.id);
@@ -7865,18 +7900,18 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         if (cancelled || !surface) return;
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _421 => _421.result, 'optionalAccess', _422 => _422.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _429 => _429.result, 'optionalAccess', _430 => _430.bounds]), () => ( null)));
         const l = _chunkPVJMTLPJcjs.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();
-        const lit = _nullishCoalesce(s.lightChannel(), () => ( (s.init.wet && _optionalChain([this, 'access', _423 => _423.wet, 'access', _424 => _424.world, 'optionalAccess', _425 => _425.hasLane, 'call', _426 => _426(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
+        const lit = _nullishCoalesce(s.lightChannel(), () => ( (s.init.wet && _optionalChain([this, 'access', _431 => _431.wet, 'access', _432 => _432.world, 'optionalAccess', _433 => _433.hasLane, 'call', _434 => _434(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
         out = withLiveStroke({
           ...out,
           layers: _chunkPVJMTLPJcjs.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', _427 => _427.stickers, 'optionalAccess', _428 => _428[l.id]]), () => ( [])), ...sprayed] } } : {},
+          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _435 => _435.stickers, 'optionalAccess', _436 => _436[l.id]]), () => ( [])), ...sprayed] } } : {},
           ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {}
         }, stroke);
       }
@@ -7949,11 +7984,11 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       throw e;
     }
     const run = last;
-    if (_optionalChain([run, 'optionalAccess', _429 => _429.result, 'access', _430 => _430.mixerLoad])) this.keepLoad(run.brush, run.result.mixerLoad);
-    if (doc !== before || this.wetOp) this.commit(`${_nullishCoalesce(_optionalChain([run, 'optionalAccess', _431 => _431.brush, 'access', _432 => _432.name]), () => ( "Brush"))} path stroke`, this.withWetEvents(doc), before);
+    if (_optionalChain([run, 'optionalAccess', _437 => _437.result, 'access', _438 => _438.mixerLoad])) this.keepLoad(run.brush, run.result.mixerLoad);
+    if (doc !== before || this.wetOp) this.commit(`${_nullishCoalesce(_optionalChain([run, 'optionalAccess', _439 => _439.brush, 'access', _440 => _440.name]), () => ( "Brush"))} path stroke`, this.withWetEvents(doc), before);
     else this.emit([]);
-    const layerId = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([run, 'optionalAccess', _433 => _433.result, 'access', _434 => _434.layerId]), () => ( stroke.layerId)), () => ( this.doc.activeLayerId)), () => ( ""));
-    return { layerId, bounds, dabs, strokeIds, ..._optionalChain([run, 'optionalAccess', _435 => _435.result, 'access', _436 => _436.mixerLoad]) ? { mixerLoad: run.result.mixerLoad } : {}, ..._optionalChain([run, 'optionalAccess', _437 => _437.result, 'access', _438 => _438.wet]) !== void 0 ? { wet: run.result.wet } : {} };
+    const layerId = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([run, 'optionalAccess', _441 => _441.result, 'access', _442 => _442.layerId]), () => ( stroke.layerId)), () => ( this.doc.activeLayerId)), () => ( ""));
+    return { layerId, bounds, dabs, strokeIds, ..._optionalChain([run, 'optionalAccess', _443 => _443.result, 'access', _444 => _444.mixerLoad]) ? { mixerLoad: run.result.mixerLoad } : {}, ..._optionalChain([run, 'optionalAccess', _445 => _445.result, 'access', _446 => _446.wet]) !== void 0 ? { wet: run.result.wet } : {} };
   }
   /** Checks stroke samples (finite x and y, pressure 0..1) and returns them; throws a sentence naming the bad point. */
   checkPoints(points) {
@@ -7976,7 +8011,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _439 => _439.strokeIds, 'optionalAccess', _440 => _440.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _447 => _447.strokeIds, 'optionalAccess', _448 => _448.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.`);
@@ -7990,7 +8025,7 @@ var PaintEditorController = (_class19 = 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', _441 => _441.paint, 'optionalAccess', _442 => _442.type]) === "effect" && !this.effectPaintImage(s.paint)) {
+        if (_optionalChain([s, 'access', _449 => _449.paint, 'optionalAccess', _450 => _450.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.`);
         }
       }
@@ -8013,7 +8048,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         let brush = v.brush;
         if (options.brushId !== void 0) {
           const b = this.requireBrush(options.brushId);
-          brush = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
+          brush = _chunkBY5EBP26cjs.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 (!_chunkPVJMTLPJcjs.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.`);
@@ -8048,7 +8083,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** A layer's light paint: whether it has any, where (document pixels), its brightest value 0..255, and its spill. */
   lightOf(layerId) {
     const l = this.wetLayer(layerId, "read the light of");
-    const info = lightInfo(_optionalChain([this, 'access', _443 => _443.doc, 'access', _444 => _444.light, 'optionalAccess', _445 => _445[l.id]]));
+    const info = lightInfo(_optionalChain([this, 'access', _451 => _451.doc, 'access', _452 => _452.light, 'optionalAccess', _453 => _453[l.id]]));
     const bounds = info.bounds ? { ...info.bounds, x: info.bounds.x + l.offset.x, y: info.bounds.y + l.offset.y } : null;
     return { layerId: l.id, hasLight: info.peak > 0, bounds, peak: info.peak, spill: { ...this.lightSpillOf(l.id) } };
   }
@@ -8099,7 +8134,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const ch = _optionalChain([this, 'access', _446 => _446.doc, 'access', _447 => _447.thick, 'optionalAccess', _448 => _448[id]]);
+    const ch = _optionalChain([this, 'access', _454 => _454.doc, 'access', _455 => _455.thick, 'optionalAccess', _456 => _456[id]]);
     if (!ch) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
@@ -8209,7 +8244,7 @@ var PaintEditorController = (_class19 = 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', _449 => _449.message]), () => ( _chunkYHDHFJUCcjs.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', _457 => _457.message]), () => ( _chunkYHDHFJUCcjs.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`,
@@ -8294,7 +8329,7 @@ var PaintEditorController = (_class19 = 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', _450 => _450.wet, 'access', _451 => _451.world, 'optionalAccess', _452 => _452.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
+    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _458 => _458.wet, 'access', _459 => _459.world, 'optionalAccess', _460 => _460.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) {
@@ -8363,7 +8398,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (override) return Array.from(override).reduce((ls, [id, surface]) => _chunkPVJMTLPJcjs.mapLayer.call(void 0, ls, id, (l) => ({ ...l, surface })), this.doc.layers);
     const live = this.live;
     if (!live) return this.animatedView();
-    if (_optionalChain([this, 'access', _453 => _453.liveLayers, 'optionalAccess', _454 => _454.key]) === live.surface) return this.liveLayers.layers;
+    if (_optionalChain([this, 'access', _461 => _461.liveLayers, 'optionalAccess', _462 => _462.key]) === live.surface) return this.liveLayers.layers;
     const layers = _chunkPVJMTLPJcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
@@ -8386,7 +8421,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   tracingNode(t) {
     const { width, height } = this.doc.canvas;
     const key = this.tracingVersion * 100003 + width * 7 + height;
-    if (_optionalChain([this, 'access', _455 => _455.tracingCache, 'optionalAccess', _456 => _456.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _463 => _463.tracingCache, 'optionalAccess', _464 => _464.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 };
@@ -8413,8 +8448,8 @@ var PaintEditorController = (_class19 = 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', _457 => _457.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _458 => _458[id]]);
-      const l = ch && _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, out, id), 'optionalAccess', _459 => _459.layer]);
+      const ch = _optionalChain([live, 'optionalAccess', _465 => _465.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _466 => _466[id]]);
+      const l = ch && _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, out, id), 'optionalAccess', _467 => _467.layer]);
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
@@ -8434,13 +8469,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (!ids.size) return layers;
     let out = layers;
     for (const id of ids) {
-      const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, out, id), 'optionalAccess', _460 => _460.layer]);
+      const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, out, id), 'optionalAccess', _468 => _468.layer]);
       if (!isPixelLayer(l)) continue;
       let cache = this.lightCaches.get(id);
       if (!cache) this.lightCaches.set(id, cache = new LightCache());
-      const glowed = cache.glow(l.surface, light[id], _optionalChain([this, 'access', _461 => _461.liveThick, 'optionalAccess', _462 => _462.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _463 => _463.doc, 'access', _464 => _464.thick, 'optionalAccess', _465 => _465[id]]));
+      const glowed = cache.glow(l.surface, light[id], _optionalChain([this, 'access', _469 => _469.liveThick, 'optionalAccess', _470 => _470.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _471 => _471.doc, 'access', _472 => _472.thick, 'optionalAccess', _473 => _473[id]]));
       if (glowed !== l.surface) out = _chunkPVJMTLPJcjs.mapLayer.call(void 0, out, id, () => ({ ...l, surface: glowed }));
-      const committed = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _466 => _466.layer]);
+      const committed = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _474 => _474.layer]);
       const spill = light[id] && isPixelLayer(committed) ? cache.spill(committed.surface, light[id], this.lightSpillOf(id)) : null;
       if (spill) out = insertAfter(out, id, { type: "pixel", id: `${id}${SPILL_SUFFIX}`, name: `${l.name} light`, visible: l.visible, opacity: l.opacity, blend: "linear-dodge", surface: spill, offset: { ...l.offset } });
     }
@@ -8452,7 +8487,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       if (!l.visible) continue;
       if (l.type === "group") this.backlitLayers(l.children, committed, opacity * l.opacity, out);
       else if (isPixelLayer(l)) {
-        const thick = !committed && _optionalChain([this, 'access', _467 => _467.liveThick, 'optionalAccess', _468 => _468.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _469 => _469.doc, 'access', _470 => _470.thick, 'optionalAccess', _471 => _471[l.id]]);
+        const thick = !committed && _optionalChain([this, 'access', _475 => _475.liveThick, 'optionalAccess', _476 => _476.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _477 => _477.doc, 'access', _478 => _478.thick, 'optionalAccess', _479 => _479[l.id]]);
         out.push({ surface: l.surface, offset: l.offset, opacity: opacity * l.opacity, ...thick ? { thick } : {} });
       }
     }
@@ -8481,7 +8516,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (backlight) layers = [...layers, backlight];
     if (options.layerIds) {
       const picked = [];
-      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _472 => _472.layer]), () => ( this.requireLayer(id))));
+      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _480 => _480.layer]), () => ( this.requireLayer(id))));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
     const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
@@ -8497,7 +8532,7 @@ var PaintEditorController = (_class19 = 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', _473 => _473.live, 'optionalAccess', _474 => _474.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _481 => _481.live, 'optionalAccess', _482 => _482.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -8576,7 +8611,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const spills = Object.fromEntries(Object.entries(this.lightSpills).filter(([id]) => _chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id)));
     if (Object.keys(spills).length) ext.lightSpill = spills;
     else delete ext.lightSpill;
-    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _475 => _475.layer])));
+    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _483 => _483.layer])));
     if (effectLayers) ext.effectLayers = effectLayers;
     else delete ext.effectLayers;
     if (this.doc.paperEffect) ext.paperEffect = paperEffectToJSON(this.doc.paperEffect);
@@ -8596,10 +8631,10 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         const ok = list.flatMap((x) => {
           if (!x || typeof x.id !== "string" || !Number.isFinite(x.x) || !Number.isFinite(x.y) || !(x.size > 0)) return [];
           try {
-            const ref2 = _chunkJSDND7DFcjs.normalizeStickerRef.call(void 0, _nullishCoalesce(x.ref, () => ( x.stamp)));
-            const stamp = _chunkJSDND7DFcjs.editorStampOf.call(void 0, ref2);
-            const { stamp: _old, ...rest } = x;
-            return [{ ...rest, ref: ref2, ...stamp ? { stamp } : {} }];
+            const ref2 = _chunkOTN6VB5Scjs.normalizeStickerRef.call(void 0, _nullishCoalesce(x.ref, () => ( x.stamp)));
+            const stamp = _chunkOTN6VB5Scjs.editorStampOf.call(void 0, ref2);
+            const { stamp: _old, variant, ...rest } = x;
+            return [{ ...rest, ref: ref2, ...stamp ? { stamp } : {}, ...variant === "dark" && !stamp ? { variant } : {} }];
           } catch (e9) {
             return [];
           }
@@ -8612,7 +8647,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (ext.liveStrokes && typeof ext.liveStrokes === "object") {
       const liveStrokes = {};
       for (const [id, list] of Object.entries(ext.liveStrokes)) {
-        if (!isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _476 => _476.layer])) || !Array.isArray(list)) continue;
+        if (!isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _484 => _484.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;
@@ -8622,7 +8657,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (ext.effectLayers && typeof ext.effectLayers === "object") {
       const effectLayers = {};
       for (const [id, v] of Object.entries(ext.effectLayers)) {
-        if (!isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _477 => _477.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _485 => _485.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.`);
@@ -8650,7 +8685,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (ext.light && typeof ext.light === "object") {
       const light = {};
       for (const [id, v] of Object.entries(ext.light)) {
-        if (!isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _478 => _478.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _486 => _486.layer]))) continue;
         try {
           light[id] = lightFromJSON(v);
         } catch (e) {
@@ -8686,7 +8721,7 @@ var PaintEditorController = (_class19 = 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', _479 => _479.exec, 'call', _480 => _480(s.id), 'optionalAccess', _481 => _481[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _487 => _487.exec, 'call', _488 => _488(s.id), 'optionalAccess', _489 => _489[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
@@ -8694,7 +8729,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     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', _482 => _482.exec, 'call', _483 => _483(s.id), 'optionalAccess', _484 => _484[1]]), () => ( 0)));
+        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _490 => _490.exec, 'call', _491 => _491(s.id), 'optionalAccess', _492 => _492[1]]), () => ( 0)));
         if (n >= this.strokeCounter) this.strokeCounter = n + 1;
       }
     }
@@ -8710,7 +8745,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.viewCompositor.clear();
     this.emit();
     const refs = Object.values(_nullishCoalesce(this.doc.stickers, () => ( {}))).flatMap((list) => list.map((x) => x.ref));
-    if (refs.some((r) => !_chunkJSDND7DFcjs.editorStampOf.call(void 0, r))) void this.prepareStickers(refs).catch(() => this.emit([]));
+    if (refs.some((r) => !_chunkOTN6VB5Scjs.editorStampOf.call(void 0, r))) void this.prepareStickers(refs).catch(() => this.emit([]));
     return loaded.problems;
   }
   /** Opens a saved document (clears the history). Returns what could not be read. */
@@ -8791,10 +8826,10 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunk43NT242Dcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkKXNZNOEFcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
-      const label = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _485 => _485.find, 'call', _486 => _486((m) => m.id === mode), 'optionalAccess', _487 => _487.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _488 => _488.find, 'call', _489 => _489((m) => m.id === _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _490 => _490.label]), () => ( _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _493 => _493.find, 'call', _494 => _494((m) => m.id === mode), 'optionalAccess', _495 => _495.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _496 => _496.find, 'call', _497 => _497((m) => m.id === _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _498 => _498.label]), () => ( _chunk2VX55NFMcjs.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).`);
@@ -8916,7 +8951,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const { src, pixels } = this.importImage(options, "The reference image");
     const ref2 = {
       id: `ref${this.nextReferenceId++}`,
-      name: _optionalChain([options, 'access', _491 => _491.name, 'optionalAccess', _492 => _492.trim, 'call', _493 => _493()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _499 => _499.name, 'optionalAccess', _500 => _500.trim, 'call', _501 => _501()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -8995,7 +9030,7 @@ var PaintEditorController = (_class19 = 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', _494 => _494.exec, 'call', _495 => _495(ref2.id), 'optionalAccess', _496 => _496[1]]), () => ( 0)));
+          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _502 => _502.exec, 'call', _503 => _503(ref2.id), 'optionalAccess', _504 => _504[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -9006,7 +9041,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       guides.stencils = [];
       r.stencils.forEach((raw2, i) => {
         try {
-          const id = typeof _optionalChain([raw2, 'optionalAccess', _497 => _497.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
+          const id = typeof _optionalChain([raw2, 'optionalAccess', _505 => _505.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;
@@ -9029,12 +9064,12 @@ var PaintEditorController = (_class19 = 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', _498 => _498.exec, 'call', _499 => _499(st.id), 'optionalAccess', _500 => _500[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', _506 => _506.exec, 'call', _507 => _507(st.id), 'optionalAccess', _508 => _508[1]]), () => ( 0))));
     return n + 1;
   }
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
-    const stickers = _optionalChain([this, 'access', _501 => _501.doc, 'access', _502 => _502.stickers, 'optionalAccess', _503 => _503[l.id]]);
+    const stickers = _optionalChain([this, 'access', _509 => _509.doc, 'access', _510 => _510.stickers, 'optionalAccess', _511 => _511[l.id]]);
     if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (sticker-stars; list_brush_presets lists them).`);
     return { layer: l, stickers };
   }
@@ -9056,36 +9091,53 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /**
    * Loads the art of `refs` (provider stickers; editor stamps need none) so sprays and placements
-   * can draw them. Rejects with a `PaintEditorError` naming an unknown ref and the closest known
+   * can draw them: their dark variants when the colour scheme is dark and they have one. Rejects with a `PaintEditorError` naming an unknown ref and the closest known
    * ones, or a sticker whose art failed. Emits when art arrives, so views redraw.
    */
   async prepareStickers(refs) {
-    const list = [...new Set(refs.map((r) => this.readStickerRef(r)))].filter((r) => !_chunkJSDND7DFcjs.editorStampOf.call(void 0, r));
+    const list = [...new Set(refs.map((r) => this.readStickerRef(r)))].filter((r) => !_chunkOTN6VB5Scjs.editorStampOf.call(void 0, r));
     try {
-      await Promise.all(list.map((r) => this.stickerArt.ensure(this.stickers.provider, r, this.rasterizeSticker)));
+      await Promise.all(list.map((r) => this.stickerArt.ensure(this.stickers.provider, r, this.rasterizeSticker, this.colorScheme === "dark")));
     } catch (e) {
       throw new PaintEditorError(e instanceof Error ? e.message : String(e));
     } finally {
       if (list.length) this.emit([]);
     }
   }
-  /** Whether a sticker's art is ready to draw: `ready` (always for editor stamps), `loading`, `failed` (with why) or `none`. */
+  /** Whether a sticker's art is ready to draw in the variant the colour scheme picks: `ready` (always for editor stamps), `loading`, `failed` (with why) or `none`. */
   stickerArtStatus(ref2) {
-    return this.stickerArt.status(this.readStickerRef(ref2));
+    const r = this.readStickerRef(ref2);
+    return this.stickerArt.status(r, this.stickerArt.variantFor(r, this.colorScheme === "dark"));
+  }
+  /**
+   * A sticker whose ref is new (placed or restamped) in the variant the colour scheme picks: `dark`
+   * on a dark scheme when its sticker has one (known once its art was asked for).
+   */
+  withStickerVariant(s) {
+    const { variant: _old, ...rest } = s;
+    const v = _chunkOTN6VB5Scjs.editorStampOf.call(void 0, s.ref) ? "light" : this.stickerArt.variantFor(s.ref, this.colorScheme === "dark");
+    return v === "dark" ? { ...rest, variant: v } : rest;
   }
   readStickerRef(ref2) {
     try {
-      return _chunkJSDND7DFcjs.normalizeStickerRef.call(void 0, ref2);
+      return _chunkOTN6VB5Scjs.normalizeStickerRef.call(void 0, ref2);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
   }
   /** Refuses to redraw stickers whose art has not loaded (they would vanish), naming them and what to call. */
   requireStickerArt(stickers) {
-    const missing = [...new Set(stickers.filter((s) => !stickerStamp(s) && !this.stickerArt.get(s.ref)).map((s) => s.ref))];
+    const missing = stickers.filter((s) => !stickerStamp(s) && !this.stickerArt.get(s.ref, s.variant));
     if (missing.length) {
-      for (const r of missing) void this.stickerArt.ensure(this.stickers.provider, r, this.rasterizeSticker).then(() => this.emit([]), () => this.emit([]));
-      throw new PaintEditorError(`The art for ${missing.map((r) => `"${r}"`).join(", ")} has not loaded yet; it is loading now (prepareStickers), so try again when it has.`);
+      const dark = this.colorScheme === "dark";
+      const loads = /* @__PURE__ */ new Map();
+      for (const s of missing) {
+        loads.set(`${s.ref}#${_nullishCoalesce(s.variant, () => ( "light"))}`, [s.ref, s.variant === "dark"]);
+        if (dark) loads.set(`${s.ref}#dark`, [s.ref, true]);
+      }
+      for (const [r, d] of loads.values()) void this.stickerArt.ensure(this.stickers.provider, r, this.rasterizeSticker, d).then(() => this.emit([]), () => this.emit([]));
+      const refs = [...new Set(missing.map((s) => s.ref))];
+      throw new PaintEditorError(`The art for ${refs.map((r) => `"${r}"`).join(", ")} has not loaded yet; it is loading now (prepareStickers), so try again when it has.`);
     }
   }
   /** A layer's stickers, bottom first. */
@@ -9093,7 +9145,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return [];
     this.requireLayer(id);
-    return (_nullishCoalesce(_optionalChain([this, 'access', _504 => _504.doc, 'access', _505 => _505.stickers, 'optionalAccess', _506 => _506[id]]), () => ( []))).map((s) => ({ ...s }));
+    return (_nullishCoalesce(_optionalChain([this, 'access', _512 => _512.doc, 'access', _513 => _513.stickers, 'optionalAccess', _514 => _514[id]]), () => ( []))).map((s) => ({ ...s }));
   }
   /**
    * Replaces a layer's stickers and redraws its pixels from them (one undo step). With `dirty`,
@@ -9114,7 +9166,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** 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', _507 => _507.stickerPreview, 'optionalAccess', _508 => _508.shown]) === this.doc ? this.stickerPreview.base : null;
+    return _optionalChain([this, 'access', _515 => _515.stickerPreview, 'optionalAccess', _516 => _516.shown]) === this.doc ? this.stickerPreview.base : null;
   }
   readStickerUpdate(update) {
     try {
@@ -9129,7 +9181,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const hit = stickerAt(_nullishCoalesce(_optionalChain([this, 'access', _509 => _509.doc, 'access', _510 => _510.stickers, 'optionalAccess', _511 => _511[id]]), () => ( [])), x, y, this.stickerArt.get);
+    const hit = stickerAt(_nullishCoalesce(_optionalChain([this, 'access', _517 => _517.doc, 'access', _518 => _518.stickers, 'optionalAccess', _519 => _519[id]]), () => ( [])), x, y, this.stickerArt.get);
     return hit ? { ...hit } : null;
   }
   /** Picks a sticker for the panel and canvas (`null` for none). Editor state, not an undo step. */
@@ -9148,7 +9200,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (_chunkPVJMTLPJcjs.isLayerLocked.call(void 0, layer, "pixels")) throw new PaintEditorError(`Layer "${layer.name}" has its pixels locked; unlock it first.`);
     const i = stickers.findIndex((s) => s.id === id);
     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 u = this.readStickerUpdate(update);
+    const next = u.ref !== void 0 ? this.withStickerVariant({ ...stickers[i], ...u }) : { ...stickers[i], ...u };
     const list = stickers.map((s, j) => j === i ? next : s);
     const dirty = [stickerRect(stickers[i]), stickerRect(next)];
     const base = _nullishCoalesce(this.previewBase(), () => ( this.doc));
@@ -9172,7 +9225,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const i = stickers.findIndex((s) => s.id === id);
     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 };
+    const next = u.ref !== void 0 ? this.withStickerVariant({ ...stickers[i], ...u }) : { ...stickers[i], ...u };
     this.commitStickers("Edit sticker", layer, stickers.map((s, j) => j === i ? next : s), [stickerRect(stickers[i]), stickerRect(next)]);
     return { ...next };
   }
@@ -9185,8 +9238,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layer = this.wetLayer(layerId, "add stickers to");
     if (!input.length) throw new PaintEditorError("Pass at least one sticker (ref, 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', _512 => _512.doc, 'access', _513 => _513.stickers, 'optionalAccess', _514 => _514[layer.id]]);
-    if (!_optionalChain([existing, 'optionalAccess', _515 => _515.length])) {
+    const existing = _optionalChain([this, 'access', _520 => _520.doc, 'access', _521 => _521.stickers, 'optionalAccess', _522 => _522[layer.id]]);
+    if (!_optionalChain([existing, 'optionalAccess', _523 => _523.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();
@@ -9201,9 +9254,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       }
       if (raw.seed !== void 0 && !Number.isInteger(raw.seed)) throw new PaintEditorError(`Sticker ${i}: seed must be a whole number.`);
       const id = n++;
-      return { id: `st${id}`, size: 48, rotation: 0, color: this.color, opacity: 1, seed: _nullishCoalesce(raw.seed, () => ( _chunk3K6HWEXZcjs.mix32.call(void 0, id * 2654435761 >>> 0) & 2147483647)), ...u };
+      return this.withStickerVariant({ id: `st${id}`, size: 48, rotation: 0, color: this.color, opacity: 1, seed: _nullishCoalesce(raw.seed, () => ( _chunk3K6HWEXZcjs.mix32.call(void 0, id * 2654435761 >>> 0) & 2147483647)), ...u });
     });
-    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _516 => _516.length]) ? added.map(stickerRect) : void 0);
+    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _524 => _524.length]) ? added.map(stickerRect) : void 0);
     return added.map((s) => ({ ...s }));
   }
   /** Brings stickers to the top (`front`) or bottom of their layer (one undo step). */
@@ -9242,20 +9295,20 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   liveStrokeLayer(layerId, what) {
     const l = this.wetLayer(layerId, what);
-    const strokes = _optionalChain([this, 'access', _517 => _517.doc, 'access', _518 => _518.liveStrokes, 'optionalAccess', _519 => _519[l.id]]);
+    const strokes = _optionalChain([this, 'access', _525 => _525.doc, 'access', _526 => _526.liveStrokes, 'optionalAccess', _527 => _527[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', _520 => _520.doc, 'access', _521 => _521.liveStrokes, 'optionalAccess', _522 => _522[layerId]]));
+    return Boolean(_optionalChain([this, 'access', _528 => _528.doc, 'access', _529 => _529.liveStrokes, 'optionalAccess', _530 => _530[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', _523 => _523.doc, 'access', _524 => _524.liveStrokes, 'optionalAccess', _525 => _525[l.id]])) return this.describeLayer(l);
-    if (_optionalChain([this, 'access', _526 => _526.doc, 'access', _527 => _527.stickers, 'optionalAccess', _528 => _528[l.id], 'optionalAccess', _529 => _529.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
+    if (_optionalChain([this, 'access', _531 => _531.doc, 'access', _532 => _532.liveStrokes, 'optionalAccess', _533 => _533[l.id]])) return this.describeLayer(l);
+    if (_optionalChain([this, 'access', _534 => _534.doc, 'access', _535 => _535.stickers, 'optionalAccess', _536 => _536[l.id], 'optionalAccess', _537 => _537.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));
@@ -9268,7 +9321,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   findLiveStroke(id) {
     for (const [layerId, strokes] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
       const index = strokes.findIndex((x) => x.id === id);
-      const layer = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _530 => _530.layer]);
+      const layer = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _538 => _538.layer]);
       if (index >= 0 && isPixelLayer(layer)) return { layer, strokes, index };
     }
     const baked = this.doc.strokes.some((x) => x.id === id);
@@ -9288,15 +9341,15 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     let brush = was.brush;
     if (update.brushId !== void 0) {
       const b = this.requireBrush(update.brushId);
-      brush = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: was.brush.tip.size } }, b);
+      brush = _chunkBY5EBP26cjs.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 = _chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ...update.brush, id: brush.id }, brush);
+      brush = _chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { ...update.brush, id: brush.id }, brush);
     }
     const why = liveStrokeRefusal(brush);
     if (why) throw new PaintEditorError(why);
-    const next = { ...was, brush: _chunkTZOX7KWVcjs.brushToJSON.call(void 0, brush) };
+    const next = { ...was, brush: _chunkBY5EBP26cjs.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;
@@ -9363,9 +9416,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     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', _531 => _531.liveStrokes, 'optionalAccess', _532 => _532[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
+      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _539 => _539.liveStrokes, 'optionalAccess', _540 => _540[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', _533 => _533.liveStrokes, 'optionalAccess', _534 => _534[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
+      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _541 => _541.liveStrokes, 'optionalAccess', _542 => _542[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
     }
     this.commit(ids.length === 1 ? "Remove stroke" : "Remove strokes", doc);
     return { removed: [...ids], bounds };
@@ -9433,7 +9486,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   withLiveStrokes(doc, layer, list, dirty) {
     if (_chunkPVJMTLPJcjs.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([_chunkPVJMTLPJcjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _535 => _535.layer]);
+    const current = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _543 => _543.layer]);
     const surface = this.drawLiveStrokes(_nullishCoalesce(current, () => ( layer)), list, dirty);
     const next = { ...doc, layers: _chunkPVJMTLPJcjs.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))) } });
@@ -9511,7 +9564,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (!this.animatedLayers.size) return this.doc.layers;
     let layers = this.doc.layers;
     for (const [id, a] of this.animatedLayers) {
-      const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _536 => _536.layer]);
+      const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _544 => _544.layer]);
       if (isPixelLayer(l) && l.surface === a.base) layers = _chunkPVJMTLPJcjs.mapLayer.call(void 0, layers, id, () => ({ ...l, surface: a.surface }));
     }
     return layers;
@@ -9521,7 +9574,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layers = [];
     const sources = /* @__PURE__ */ new Map();
     for (const [id, strokes] of Object.entries(_nullishCoalesce(doc.liveStrokes, () => ( {})))) {
-      const layer = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _537 => _537.layer]);
+      const layer = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _545 => _545.layer]);
       const live = strokes.filter(isLiveEffect);
       if (!isPixelLayer(layer) || !live.length) continue;
       layers.push({ layer, strokes });
@@ -9646,13 +9699,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return this.withEffectTime(time, () => this.compositePixels(options));
   }
   // --- Stencils --------------------------------------------------------------------
-  __init181() {this.stencilCache = null}
-  __init182() {this.nextStencilId = 1}
+  __init183() {this.stencilCache = null}
+  __init184() {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', _538 => _538.stencilCache, 'optionalAccess', _539 => _539.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
+    if (_optionalChain([this, 'access', _546 => _546.stencilCache, 'optionalAccess', _547 => _547.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
     const mask = stencilMask(stencils, width, height);
     this.stencilCache = { key: stencils, size, mask };
     return mask;
@@ -9714,7 +9767,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   makeSwatch(color, name) {
     const p = typeof color === "string" ? { type: "color", color: parseColor(color) } : this.readStrokePaint(color);
     const out = { color: _chunkFQPUF2W2cjs.paintSourceColor.call(void 0, p, { paint: this.color, secondary: this.secondaryColor }) };
-    if (_optionalChain([name, 'optionalAccess', _540 => _540.trim, 'call', _541 => _541()])) out.name = name.trim();
+    if (_optionalChain([name, 'optionalAccess', _548 => _548.trim, 'call', _549 => _549()])) out.name = name.trim();
     if (p.type === "gradient") out.paint = p;
     return out;
   }
@@ -9766,7 +9819,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
   mixOnPad(paints2, options = {}) {
-    const parsed = (_nullishCoalesce(paints2, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _542 => _542.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _543 => _543.parts]) }));
+    const parsed = (_nullishCoalesce(paints2, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _550 => _550.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _551 => _551.parts]) }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -9855,7 +9908,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
-    const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _544 => _544.layer]);
+    const l = _optionalChain([_chunkPVJMTLPJcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _552 => _552.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
 }, _class19.__initStatic(), _class19);
@@ -9877,7 +9930,7 @@ function insertAfter(layers, id, node) {
   return layers.map((l) => l.type === "group" ? { ...l, children: insertAfter(l.children, id, node) } : l);
 }
 function isLiveEffect(s) {
-  return _optionalChain([s, 'access', _545 => _545.paint, 'optionalAccess', _546 => _546.type]) === "effect" && s.paint.live === true;
+  return _optionalChain([s, 'access', _553 => _553.paint, 'optionalAccess', _554 => _554.type]) === "effect" && s.paint.live === true;
 }
 function framePaint(p, t) {
   return { ...p, time: p.time + t };
@@ -9902,7 +9955,7 @@ function clipRect(r, width, 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', _547 => _547.liveStrokes, 'optionalAccess', _548 => _548[stroke.layerId]]);
+  const list = _optionalChain([doc, 'access', _555 => _555.liveStrokes, 'optionalAccess', _556 => _556[stroke.layerId]]);
   return list ? { ...doc, liveStrokes: { ...doc.liveStrokes, [stroke.layerId]: [...list, stroke] } } : doc;
 }
 function shiftDocument(doc, dx, dy) {
@@ -9929,9 +9982,9 @@ function shiftDocument(doc, dx, dy) {
   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', _549 => _549.data, 'optionalAccess', _550 => _550.stickers]) : void 0;
+      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _557 => _557.data, 'optionalAccess', _558 => _558.stickers]) : void 0;
       if (list) return { ...e, data: { ...e.data, stickers: moveStickers(list) } };
-      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _551 => _551.data, 'optionalAccess', _552 => _552.strokes]) : void 0;
+      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _559 => _559.data, 'optionalAccess', _560 => _560.strokes]) : void 0;
       return strokes ? { ...e, data: { ...e.data, strokes: strokes.map(moveStroke) } } : e;
     });
   }
@@ -10020,8 +10073,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', _553 => _553[0], 'optionalAccess', _554 => _554.t]);
-  const t1 = _optionalChain([points, 'access', _555 => _555[points.length - 1], 'optionalAccess', _556 => _556.t]);
+  const t0 = _optionalChain([points, 'access', _561 => _561[0], 'optionalAccess', _562 => _562.t]);
+  const t1 = _optionalChain([points, 'access', _563 => _563[points.length - 1], 'optionalAccess', _564 => _564.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -10075,7 +10128,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _557 => _557.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _558 => _558.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _565 => _565.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _566 => _566.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -10122,8 +10175,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _559 => _559.replay, 'access', _560 => _560.strokeIds, 'optionalAccess', _561 => _561.includes, 'call', _562 => _562(s.id)]));
-        const first = _optionalChain([source, 'access', _563 => _563[0], 'optionalAccess', _564 => _564.points, 'access', _565 => _565[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _567 => _567.replay, 'access', _568 => _568.strokeIds, 'optionalAccess', _569 => _569.includes, 'call', _570 => _570(s.id)]));
+        const first = _optionalChain([source, 'access', _571 => _571[0], 'optionalAccess', _572 => _572.points, 'access', _573 => _573[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);
@@ -10305,7 +10358,7 @@ function createPaintStickerTools(c) {
               type: "object",
               properties: {
                 ref: { type: "string", minLength: 1, description: "The sticker: a ref provider:id from find_stickers (e.g. editor:star). Give ref or stamp." },
-                stamp: { type: "string", enum: [..._chunkJSDND7DFcjs.STAMP_KINDS], description: "Older form: an editor stamp (same as ref editor:<stamp>)." },
+                stamp: { type: "string", enum: [..._chunkOTN6VB5Scjs.STAMP_KINDS], description: "Older form: an editor stamp (same as ref editor:<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)." },
@@ -10343,7 +10396,7 @@ function createPaintStickerTools(c) {
           layerId: LAYER_ID,
           id: { type: "string", description: "Sticker id from list_stickers." },
           ref: { type: "string", minLength: 1, description: "Another sticker: a ref provider:id from find_stickers." },
-          stamp: { type: "string", enum: [..._chunkJSDND7DFcjs.STAMP_KINDS], description: "Older form: another editor stamp (same as ref editor:<stamp>)." },
+          stamp: { type: "string", enum: [..._chunkOTN6VB5Scjs.STAMP_KINDS], description: "Older form: another editor stamp (same as ref editor:<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." },
@@ -11557,10 +11610,10 @@ function createPaintEditorToolProvider(controller, options = {}) {
     name: "set_brush",
     title: "Set the brush",
     description: "Chooses the active brush (id, from list_brush_presets) and / or changes it with facets laid over it (objects merge, lists and values replace, marks of another kind replace the marks; the brush library's create_brush fields); unset removes whole facets first (unset colour drops a brush's own gradient). Strokes without a brush use it. Editor state, not an undo step: the changes stay on the active brush until the library's create_brush or update_brush stores a brush. Returns the active brush as facets, the engine it paints with, and problems (values clamped or dropped).",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets to start from (default the active brush)." }, name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." }, ..._chunkPYTJBVW5cjs.BRUSH_PATCH_PROPERTIES, unset: _chunkPYTJBVW5cjs.BRUSH_UNSET_PROPERTY }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets to start from (default the active brush)." }, name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." }, ..._chunkF3KKR6DDcjs.BRUSH_PATCH_PROPERTIES, unset: _chunkF3KKR6DDcjs.BRUSH_UNSET_PROPERTY }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
     handler: async ({ id, unset, ...patch }) => {
-      const stamps = _optionalChain([patch, 'access', _566 => _566.tip, 'optionalAccess', _567 => _567.stamps]);
+      const stamps = _optionalChain([patch, 'access', _574 => _574.tip, 'optionalAccess', _575 => _575.stamps]);
       if (stamps) await c.prepareStickers(stamps);
       const r = c.setBrushFacets(patch, id, unset);
       return { brush: r.spec, engine: r.brush.engine, problems: r.problems };
@@ -11653,7 +11706,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         points: POINTS,
         layerId: LAYER_ID4,
         brushId: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." },
-        brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: _chunkPYTJBVW5cjs.BRUSH_PATCH_PROPERTIES, additionalProperties: false },
+        brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: _chunkF3KKR6DDcjs.BRUSH_PATCH_PROPERTIES, additionalProperties: false },
         color: { ...COLOR3, description: "Paint colour #rrggbb (default the paint colour)." },
         paint: { ..._chunkFQPUF2W2cjs.PAINT_SOURCE_JSON_SCHEMA, description: "What this stroke paints with instead of the editor's paint: a colour, or gradient paint that changes colour as the stroke goes (by distance, pressure, tilt, speed, direction, time, across the tip or at random). Wins over the brush's own gradient." },
         seed: { type: "integer", minimum: 0, description: "Jitter seed (default a new one); the same seed and points give the same marks." },
@@ -11669,7 +11722,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       const base = a.brushId ? c.getBrush(a.brushId) : c.getState().brush;
       const brush = a.brush ? c.brushChanges(a.brush, a.brushId) : void 0;
       if (base) {
-        const refs = brushStickerRefs(_chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ..._nullishCoalesce(brush, () => ( {})), id: base.id }, base));
+        const refs = brushStickerRefs(_chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { ..._nullishCoalesce(brush, () => ( {})), id: base.id }, base));
         if (refs.length) await c.prepareStickers(refs);
       }
       const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
@@ -11689,7 +11742,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         pressure: { type: "array", minItems: 1, maxItems: 64, items: { type: "number", minimum: 0, maximum: 1 }, description: "Pen pressure along each subpath, spread evenly from start to end (default full pressure); [0.2, 1, 0.2] tapers both ends." },
         layerId: LAYER_ID4,
         brushId: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." },
-        brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: _chunkPYTJBVW5cjs.BRUSH_PATCH_PROPERTIES, additionalProperties: false },
+        brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: _chunkF3KKR6DDcjs.BRUSH_PATCH_PROPERTIES, additionalProperties: false },
         color: { ...COLOR3, description: "Paint colour #rrggbb (default the paint colour)." },
         paint: { ..._chunkFQPUF2W2cjs.PAINT_SOURCE_JSON_SCHEMA, description: "What the strokes paint with instead of the editor's paint: a colour, or gradient paint that changes colour as each stroke goes." },
         seed: { type: "integer", minimum: 0, description: "Jitter seed of the first subpath, the next ones take the following seeds (default new ones); the same seed and path give the same marks." }
@@ -11704,7 +11757,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       const base = a.brushId ? c.getBrush(a.brushId) : c.getState().brush;
       const brush = a.brush ? c.brushChanges(a.brush, a.brushId) : void 0;
       if (base) {
-        const refs = brushStickerRefs(_chunkTZOX7KWVcjs.normalizePaintBrush.call(void 0, { ..._nullishCoalesce(brush, () => ( {})), id: base.id }, base));
+        const refs = brushStickerRefs(_chunkBY5EBP26cjs.normalizePaintBrush.call(void 0, { ..._nullishCoalesce(brush, () => ( {})), id: base.id }, base));
         if (refs.length) await c.prepareStickers(refs);
       }
       const path = options.origin && typeof a.path === "string" && a.path.trim() ? _chunkGF2RBSDMcjs.bezierPathToSvg.call(void 0, a.path, { offset: { x: -options.origin.x, y: -options.origin.y } }) : a.path;
@@ -11755,7 +11808,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       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) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _568 => _568.document, 'access', _569 => _569.liveStrokes, 'optionalAccess', _570 => _570[s.layerId], 'optionalAccess', _571 => _571.includes, 'call', _572 => _572(s)]) === true)) };
+      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _576 => _576.document, 'access', _577 => _577.liveStrokes, 'optionalAccess', _578 => _578[s.layerId], 'optionalAccess', _579 => _579.includes, 'call', _580 => _580(s)]) === true)) };
     }
   });
   add({
@@ -11788,7 +11841,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       properties: {
         id: { type: "string", description: "Stroke id from list_strokes {live: true}." },
         brushId: { type: "string", description: "Brush id from list_brush_presets; the stroke keeps its size." },
-        brush: { type: "object", properties: _chunkPYTJBVW5cjs.BRUSH_PATCH_PROPERTIES, additionalProperties: false, description: "Facets to change on top of brushId or the stroke\u2019s brush (as set_brush takes them); missing fields keep their values." },
+        brush: { type: "object", properties: _chunkF3KKR6DDcjs.BRUSH_PATCH_PROPERTIES, additionalProperties: false, description: "Facets to change on top of brushId or the stroke\u2019s brush (as set_brush takes them); missing fields keep their values." },
         color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "New colour #rrggbb (replaces gradient paint)." },
         paint: { anyOf: [_chunkFQPUF2W2cjs.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." }
@@ -12037,9 +12090,9 @@ function createPaintEditorToolProvider(controller, options = {}) {
   tools.push(...createPaintReplayTools(c));
   tools.push(...createPaintStickerTools(c));
   tools.push(..._chunkYHDHFJUCcjs.createPigmentTools.call(void 0, ));
-  tools.push(..._chunkAVTPZO4Zcjs.createStickerTools.call(void 0, { provider: () => c.stickersProvider }));
+  tools.push(..._chunkPE6YJMQTcjs.createStickerTools.call(void 0, { provider: () => c.stickersProvider }));
   tools.push(
-    ..._chunk43NT242Dcjs.createLayerEffectTools.call(void 0, 
+    ..._chunkKXNZNOEFcjs.createLayerEffectTools.call(void 0, 
       {
         requireLayer: (id) => void c.getLayerEffects(id),
         getLayerEffects: (id) => c.getLayerEffects(id),
@@ -12064,16 +12117,16 @@ function createPaintEditorToolProvider(controller, options = {}) {
 }
 function hostTool({ coordinates, ...tool }, { origin, onChange }) {
   if (!origin && !onChange) return tool;
-  const write = !_optionalChain([tool, 'access', _573 => _573.annotations, 'optionalAccess', _574 => _574.readOnlyHint]);
+  const write = !_optionalChain([tool, 'access', _581 => _581.annotations, 'optionalAccess', _582 => _582.readOnlyHint]);
   const done = (result) => {
-    if (write) _optionalChain([onChange, 'optionalCall', _575 => _575({ tool: tool.name })]);
-    return origin && _optionalChain([coordinates, 'optionalAccess', _576 => _576.out]) ? fromDocument(result, coordinates.out, origin) : result;
+    if (write) _optionalChain([onChange, 'optionalCall', _583 => _583({ tool: tool.name })]);
+    return origin && _optionalChain([coordinates, 'optionalAccess', _584 => _584.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', _577 => _577.in]) ? toDocument(args, coordinates.in, origin) : args, context);
+      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _585 => _585.in]) ? toDocument(args, coordinates.in, origin) : args, context);
       return r instanceof Promise ? r.then(done) : done(r);
     }
   };
@@ -12090,22 +12143,25 @@ function strokeSummary(s, withPoints, live) {
     color: s.color,
     points: withPoints ? s.points : s.points.length,
     seed: s.seed,
-    copies: _nullishCoalesce(_optionalChain([s, 'access', _578 => _578.copies, 'optionalAccess', _579 => _579.length]), () => ( 0)),
+    copies: _nullishCoalesce(_optionalChain([s, 'access', _586 => _586.copies, 'optionalAccess', _587 => _587.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/brush-library-tools.ts
+function paintBrushPreviewRenderer(paper = () => DEFAULT_PAPER) {
+  return (brush, { width, height, color }) => {
+    const t = renderBrushThumbnail(_chunkBY5EBP26cjs.resolveBrush.call(void 0, brush), { paper: paper(), width, height, color: color.toLowerCase() });
+    return { data: _chunkW5M3J7PVcjs.bytesToBase64.call(void 0, _chunkW5M3J7PVcjs.encodePng.call(void 0, t.width, t.height, t.data)), mimeType: "image/png" };
+  };
+}
 function createPaintBrushLibraryToolProvider(controller, options = {}) {
-  return _chunkPYTJBVW5cjs.createBrushLibraryToolProvider.call(void 0, controller.brushLibrary, {
-    profile: _chunkTZOX7KWVcjs.PAINT_PROFILE,
+  return _chunkF3KKR6DDcjs.createBrushLibraryToolProvider.call(void 0, controller.brushLibrary, {
+    profile: _chunkBY5EBP26cjs.PAINT_PROFILE,
     stickers: () => controller.stickers.provider,
     ...options,
-    renderPreview: (brush, { width, height, color }) => {
-      const t = renderBrushThumbnail(_chunkTZOX7KWVcjs.resolveBrush.call(void 0, brush), { paper: controller.getState().document.paper, width, height, color: color.toLowerCase() });
-      return { data: _chunkW5M3J7PVcjs.bytesToBase64.call(void 0, _chunkW5M3J7PVcjs.encodePng.call(void 0, t.width, t.height, t.data)), mimeType: "image/png" };
-    }
+    renderPreview: paintBrushPreviewRenderer(() => controller.getState().document.paper)
   });
 }
 
@@ -12119,20 +12175,20 @@ var PAINT_TOOLS = [
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
 var PaintGesture = (_class20 = class {
-  constructor(controller, box) {;_class20.prototype.__init183.call(this);_class20.prototype.__init184.call(this);_class20.prototype.__init185.call(this);_class20.prototype.__init186.call(this);_class20.prototype.__init187.call(this);_class20.prototype.__init188.call(this);
+  constructor(controller, box) {;_class20.prototype.__init185.call(this);_class20.prototype.__init186.call(this);_class20.prototype.__init187.call(this);_class20.prototype.__init188.call(this);_class20.prototype.__init189.call(this);_class20.prototype.__init190.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init183() {this.tool = "brush"}
+  __init185() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init184() {this.error = null}
+  __init186() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init185() {this.predicted = []}
-  __init186() {this.mode = null}
-  __init187() {this.penAt = null}
-  __init188() {this.penDown = false}
+  __init187() {this.predicted = []}
+  __init188() {this.mode = null}
+  __init189() {this.penAt = null}
+  __init190() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -12188,13 +12244,13 @@ var PaintGesture = (_class20 = class {
     const p = this.doc(e);
     const s = this.controller.getState();
     const layerId = s.document.activeLayerId;
-    if (!layerId || !_optionalChain([s, 'access', _580 => _580.document, 'access', _581 => _581.liveStrokes, 'optionalAccess', _582 => _582[layerId]])) {
+    if (!layerId || !_optionalChain([s, 'access', _588 => _588.document, 'access', _589 => _589.liveStrokes, 'optionalAccess', _590 => _590[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', _583 => _583.id]), () => ( null)));
+      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _591 => _591.id]), () => ( null)));
       if (!hit) return false;
       this.mode = { kind: "move-stroke", pointerId: e.pointerId, id: hit.id, from: p, to: p };
       return true;
@@ -12206,7 +12262,7 @@ var PaintGesture = (_class20 = class {
   /** 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', _584 => _584.kind]) === "move-stroke" ? { id: m.id, dx: m.to.x - m.from.x, dy: m.to.y - m.from.y } : null;
+    return _optionalChain([m, 'optionalAccess', _592 => _592.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
@@ -12280,7 +12336,7 @@ var PaintGesture = (_class20 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _585 => _585.controller, 'access', _586 => _586.activeStroke, 'optionalAccess', _587 => _587.end, 'call', _588 => _588()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _593 => _593.controller, 'access', _594 => _594.activeStroke, 'optionalAccess', _595 => _595.end, 'call', _596 => _596()]);
     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;
@@ -12304,8 +12360,8 @@ var PaintGesture = (_class20 = class {
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _589 => _589.mode, 'optionalAccess', _590 => _590.kind]) === "stroke") _optionalChain([this, 'access', _591 => _591.controller, 'access', _592 => _592.activeStroke, 'optionalAccess', _593 => _593.cancel, 'call', _594 => _594()]);
-    if (_optionalChain([this, 'access', _595 => _595.mode, 'optionalAccess', _596 => _596.kind]) === "sticker") this.controller.cancelStickerPreview();
+    if (_optionalChain([this, 'access', _597 => _597.mode, 'optionalAccess', _598 => _598.kind]) === "stroke") _optionalChain([this, 'access', _599 => _599.controller, 'access', _600 => _600.activeStroke, 'optionalAccess', _601 => _601.cancel, 'call', _602 => _602()]);
+    if (_optionalChain([this, 'access', _603 => _603.mode, 'optionalAccess', _604 => _604.kind]) === "sticker") this.controller.cancelStickerPreview();
     this.mode = null;
   }
   get active() {
@@ -12370,13 +12426,13 @@ function handlePaintShortcut(controller, gesture, e) {
   return true;
 }
 var PaintCanvasPresenter = (_class21 = class {
-  constructor(controller) {;_class21.prototype.__init189.call(this);_class21.prototype.__init190.call(this);_class21.prototype.__init191.call(this);
+  constructor(controller) {;_class21.prototype.__init191.call(this);_class21.prototype.__init192.call(this);_class21.prototype.__init193.call(this);
     this.controller = controller;
   }
   
-  __init189() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init190() {this.scratch = null}
-  __init191() {this.size = ""}
+  __init191() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init192() {this.scratch = null}
+  __init193() {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;
@@ -12408,7 +12464,7 @@ function guideOverlay(controller, drag) {
   const size = s.document.canvas;
   const out = [];
   const layerId = s.document.activeLayerId;
-  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _597 => _597.document, 'access', _598 => _598.liveStrokes, 'optionalAccess', _599 => _599[layerId], 'optionalAccess', _600 => _600.some, 'call', _601 => _601((x) => x.id === s.selectedStroke)]) : false;
+  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _605 => _605.document, 'access', _606 => _606.liveStrokes, 'optionalAccess', _607 => _607[layerId], 'optionalAccess', _608 => _608.some, 'call', _609 => _609((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;
@@ -12421,7 +12477,7 @@ function guideOverlay(controller, drag) {
     ];
     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', _602 => _602.document, 'access', _603 => _603.stickers, 'optionalAccess', _604 => _604[layerId], 'optionalAccess', _605 => _605.find, 'call', _606 => _606((x) => x.id === s.selectedSticker)]) : void 0;
+  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _610 => _610.document, 'access', _611 => _611.stickers, 'optionalAccess', _612 => _612[layerId], 'optionalAccess', _613 => _613.find, 'call', _614 => _614((x) => x.id === s.selectedSticker)]) : void 0;
   if (picked) {
     const r = picked.size / 2 + 2;
     const a = picked.rotation * Math.PI / 180;
@@ -12451,7 +12507,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _607 => _607[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _615 => _615[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -12567,7 +12623,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _608 => _608(id)]);
+    _optionalChain([caf, 'optionalCall', _616 => _616(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {
@@ -12598,7 +12654,7 @@ var DOT_ROTATION_LABELS = { follow: "Follow motion", random: "Random", fixed: "T
 var STAMP_LABELS = { dot: "Dot", star: "Star", heart: "Heart", leaf: "Leaf", flower: "Flower", confetti: "Confetti", splat: "Splat", sparkle: "Sparkle", ring: "Ring" };
 function toggleStickerRef(refs, ref2) {
   if (refs.includes(ref2)) return refs.length > 1 ? refs.filter((r) => r !== ref2) : [...refs];
-  return refs.length < _chunkTZOX7KWVcjs.MAX_STICKER_STAMPS ? [...refs, ref2] : [...refs];
+  return refs.length < _chunkBY5EBP26cjs.MAX_STICKER_STAMPS ? [...refs, ref2] : [...refs];
 }
 function stickerRefLabel(ref2) {
   const stamp = ref2.startsWith("editor:") ? ref2.slice(7) : null;
@@ -12611,7 +12667,7 @@ function toggleStamp(stamps, stamp) {
 }
 function toggleDotTexture(textures, stamp) {
   if (textures.includes(stamp)) return textures.filter((s) => s !== stamp);
-  return textures.length < _chunkTZOX7KWVcjs.MAX_DOT_TEXTURES ? [...textures, stamp] : [...textures];
+  return textures.length < _chunkBY5EBP26cjs.MAX_DOT_TEXTURES ? [...textures, stamp] : [...textures];
 }
 var PATH_STROKE_TAPERS = [
   { id: "even", label: "Even" },
@@ -12925,7 +12981,7 @@ function createPaintChangeFeed(controller, options = {}) {
     const doc = state.document;
     const layers = /* @__PURE__ */ new Map();
     for (const l of controller.listLayers()) layers.set(l.id, { name: l.name, visible: l.visible, opacity: l.opacity, blend: l.blend });
-    return { doc, strokes: new Map(doc.strokes.map((s) => [s.id, s])), events: _nullishCoalesce(_optionalChain([doc, 'access', _609 => _609.paintEvents, 'optionalAccess', _610 => _610.length]), () => ( 0)), layers, stroking: state.stroking };
+    return { doc, strokes: new Map(doc.strokes.map((s) => [s.id, s])), events: _nullishCoalesce(_optionalChain([doc, 'access', _617 => _617.paintEvents, 'optionalAccess', _618 => _618.length]), () => ( 0)), layers, stroking: state.stroking };
   };
   let last = take();
   const check = () => {
@@ -12956,7 +13012,7 @@ function createPaintChangeFeed(controller, options = {}) {
     if (edited) pending = void 0;
     const change = {
       seq: ++seq,
-      origin: _nullishCoalesce(_optionalChain([commit, 'optionalAccess', _611 => _611.origin]), () => ( "user")),
+      origin: _nullishCoalesce(_optionalChain([commit, 'optionalAccess', _619 => _619.origin]), () => ( "user")),
       ...commit ? { commit } : {},
       addedStrokes,
       removedStrokes,
@@ -13023,7 +13079,7 @@ function createPaintProposals(options) {
   };
   const strokeIds = () => new Set(controller.getStrokes().map((s) => s.id));
   const validate = (input) => {
-    if (!_optionalChain([input, 'access', _612 => _612.title, 'optionalAccess', _613 => _613.trim, 'call', _614 => _614()])) throw new PaintEditorError("A proposal needs a title: what it adds, in a few words.");
+    if (!_optionalChain([input, 'access', _620 => _620.title, 'optionalAccess', _621 => _621.trim, 'call', _622 => _622()])) throw new PaintEditorError("A proposal needs a title: what it adds, in a few words.");
     if (!Array.isArray(input.ops) || !input.ops.length) throw new PaintEditorError("A proposal needs at least one op (stroke, wash or echo).");
     const place = _nullishCoalesce(input.place, () => ( "top"));
     if (place === "above") {
@@ -13035,7 +13091,7 @@ function createPaintProposals(options) {
     input.ops.forEach((op, i) => {
       const at = `ops[${i}]`;
       if (op.kind === "stroke") {
-        if (!_optionalChain([op, 'access', _615 => _615.points, 'optionalAccess', _616 => _616.length])) throw new PaintEditorError(`${at}: a stroke needs points in document pixels.`);
+        if (!_optionalChain([op, 'access', _623 => _623.points, 'optionalAccess', _624 => _624.length])) throw new PaintEditorError(`${at}: a stroke needs points in document pixels.`);
         points += op.points.length;
         if (op.color !== void 0 && !HEX4.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
         const brush = op.brushId ? controller.getBrush(op.brushId) : controller.getState().brush;
@@ -13047,7 +13103,7 @@ function createPaintProposals(options) {
         if (!HEX4.test(_nullishCoalesce(op.color, () => ( "")))) throw new PaintEditorError(`${at}: a wash needs color as #rrggbb.`);
         if (op.opacity !== void 0 && !(op.opacity > 0 && op.opacity <= 1)) throw new PaintEditorError(`${at}: opacity must be in (0, 1].`);
       } else if (op.kind === "echo") {
-        if (!_optionalChain([op, 'access', _617 => _617.strokeIds, 'optionalAccess', _618 => _618.length])) throw new PaintEditorError(`${at}: an echo needs strokeIds (list_strokes).`);
+        if (!_optionalChain([op, 'access', _625 => _625.strokeIds, 'optionalAccess', _626 => _626.length])) throw new PaintEditorError(`${at}: an echo needs strokeIds (list_strokes).`);
         const unknown = op.strokeIds.filter((id) => !known.has(id));
         if (unknown.length) throw new PaintEditorError(`${at}: unknown stroke ${unknown.map((u) => `"${u}"`).join(", ")}. Call list_strokes for the ids.`);
         if (op.color !== void 0 && !HEX4.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
@@ -13096,7 +13152,7 @@ function createPaintProposals(options) {
     ...input.layerId ? { layerId: input.layerId } : {},
     ...input.layerName ? { layerName: input.layerName } : {}
   });
-  const topLayerId = () => _optionalChain([controller, 'access', _619 => _619.listLayers, 'call', _620 => _620(), 'access', _621 => _621.find, 'call', _622 => _622((l) => l.parentId === null), 'optionalAccess', _623 => _623.id]);
+  const topLayerId = () => _optionalChain([controller, 'access', _627 => _627.listLayers, 'call', _628 => _628(), 'access', _629 => _629.find, 'call', _630 => _630((l) => l.parentId === null), 'optionalAccess', _631 => _631.id]);
   return {
     getState: () => state,
     subscribe(listener) {
@@ -13283,7 +13339,7 @@ function createPaintProposalToolProvider(proposals, options = {}) {
     },
     annotations: { title: "Propose paint", ...WRITE6 },
     handler: (args, context) => {
-      const origin = _optionalChain([context, 'access', _624 => _624.actor, 'optionalAccess', _625 => _625.id]) ? `agent:${context.actor.id}` : options.fallbackOrigin;
+      const origin = _optionalChain([context, 'access', _632 => _632.actor, 'optionalAccess', _633 => _633.id]) ? `agent:${context.actor.id}` : options.fallbackOrigin;
       const proposal = proposals.propose({ ...args, ...origin ? { origin } : {} });
       const { id: _id, missing: _missing, createdAt: _createdAt, ...rest } = describe(proposal);
       return { proposalId: proposal.id, ...rest };
@@ -13405,7 +13461,7 @@ function toolList(provider) {
 function uiTables() {
   return {
     tools: PAINT_TOOLS,
-    brushOptions: _chunk43NT242Dcjs.BRUSH_OPTION_CONTROLS,
+    brushOptions: _chunkKXNZNOEFcjs.BRUSH_OPTION_CONTROLS,
     blendMenu: BLEND_MENU_GROUPS,
     layerEffects: _chunkPVJMTLPJcjs.LAYER_EFFECT_MENU.map(({ kind, label }) => ({ kind, label, controls: _chunkPVJMTLPJcjs.layerEffectControls.call(void 0, _chunkPVJMTLPJcjs.defaultLayerEffect.call(void 0, kind, kind)) })),
     sliders: { paper: PAPER_SLIDERS, wet: WET_PARAM_SLIDERS, wetTilt: WET_TILT_SLIDERS, wetSpeed: WET_SPEED_SLIDER, light: LIGHT_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS },
@@ -13831,4 +13887,5 @@ function createPaintConformanceHost(setup, options) {
 
 
 
-exports.BACKLIGHT_SPILL = BACKLIGHT_SPILL; exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunk2VX55NFMcjs.BLEND_MODES; exports.BRUSH_ID = _chunkTZOX7KWVcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkTZOX7KWVcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = _chunkPYTJBVW5cjs.BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkTZOX7KWVcjs.BUILTIN_BRUSHES; exports.BristleStroke = BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunkTZOX7KWVcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkTZOX7KWVcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkTZOX7KWVcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkTZOX7KWVcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkYHDHFJUCcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkTZOX7KWVcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunkTZOX7KWVcjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkTZOX7KWVcjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkTZOX7KWVcjs.DEFAULT_PARTICLE; exports.DEFAULT_SPRAY = _chunkTZOX7KWVcjs.DEFAULT_SPRAY; exports.DEFAULT_STICKER = _chunkTZOX7KWVcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkTZOX7KWVcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkYHDHFJUCcjs.DEFAULT_WET_PARAMS; exports.DOT_ROTATIONS = _chunkTZOX7KWVcjs.DOT_ROTATIONS; exports.DOT_ROTATION_LABELS = DOT_ROTATION_LABELS; exports.DOT_TEXTURE_ORDERS = _chunkTZOX7KWVcjs.DOT_TEXTURE_ORDERS; exports.DOT_TEXTURE_ORDER_LABELS = DOT_TEXTURE_ORDER_LABELS; exports.DryStroke = DryStroke; exports.EFFECT_MAP_REPEATS = EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPXDIAYB6cjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPXDIAYB6cjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunkI3Y2Q3PMcjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkTZOX7KWVcjs.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 = _chunkFQPUF2W2cjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_DOT_TEXTURES = _chunkTZOX7KWVcjs.MAX_DOT_TEXTURES; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_PATH_SAMPLES = MAX_PATH_SAMPLES; exports.MAX_STICKER_STAMPS = _chunkTZOX7KWVcjs.MAX_STICKER_STAMPS; 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 = _chunkTZOX7KWVcjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunk2VX55NFMcjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkTZOX7KWVcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkTZOX7KWVcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_CONTRACT_FORMAT_VERSION = PAINT_CONTRACT_FORMAT_VERSION; exports.PAINT_DOCUMENT_JSON_SCHEMA = PAINT_DOCUMENT_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkFQPUF2W2cjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkFQPUF2W2cjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SHORTCUTS = PAINT_SHORTCUTS; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkFQPUF2W2cjs.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 = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunkTZOX7KWVcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkTZOX7KWVcjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PATH_STROKE_TAPERS = PATH_STROKE_TAPERS; 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 = _chunkFQPUF2W2cjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkFQPUF2W2cjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPXDIAYB6cjs.PaperGrain; exports.ParticleStroke = ParticleStroke; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.RIBBON_PAIRS = _chunkTZOX7KWVcjs.RIBBON_PAIRS; exports.RIBBON_PAIR_LABELS = RIBBON_PAIR_LABELS; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkJSDND7DFcjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_ART_SIZE = STICKER_ART_SIZE; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerArtCache = StickerArtCache; exports.StickerBrowser = _chunkRVGP2XLFcjs.StickerBrowser; exports.StickerSpray = StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunk3K6HWEXZcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkYHDHFJUCcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkTZOX7KWVcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkYHDHFJUCcjs.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 = _chunkTZOX7KWVcjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkFQPUF2W2cjs.addPaintGradientStop; exports.addPolygonArea = addPolygonArea; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.backlightOf = backlightOf; exports.brushEngineControls = _chunkPYTJBVW5cjs.brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkTZOX7KWVcjs.brushTakesPaint; exports.brushToJSON = _chunkTZOX7KWVcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintAgentStrokes = createPaintAgentStrokes; exports.createPaintBrushLibraryToolProvider = createPaintBrushLibraryToolProvider; exports.createPaintChangeFeed = createPaintChangeFeed; exports.createPaintCompositor = createPaintCompositor; exports.createPaintConformanceHost = createPaintConformanceHost; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintProposalToolProvider = createPaintProposalToolProvider; exports.createPaintProposals = createPaintProposals; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.defaultStickerRasterizer = defaultStickerRasterizer; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = effectPaintKey; exports.effectPaintSize = effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPXDIAYB6cjs.grainCatch; exports.grainHeights = _chunkPXDIAYB6cjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunk3K6HWEXZcjs.hash2; exports.hexToPaintRgb = _chunkFQPUF2W2cjs.hexToPaintRgb; exports.hexToRgb8 = hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunkI3Y2Q3PMcjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunk2VX55NFMcjs.isBlendMode; exports.isGradientPaint = _chunkFQPUF2W2cjs.isGradientPaint; exports.isPaintEffectPaint = isPaintEffectPaint; exports.isPainterlyBlendMode = _chunk2VX55NFMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkTZOX7KWVcjs.isWetBrush; exports.isWetCapable = _chunkTZOX7KWVcjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunk3K6HWEXZcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = _chunkPYTJBVW5cjs.multiColorSliders; exports.multiColorToPaint = _chunkTZOX7KWVcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkTZOX7KWVcjs.normalizeBehavior; exports.normalizeBristle = _chunkTZOX7KWVcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkTZOX7KWVcjs.normalizeDynamics; exports.normalizeFlow = _chunkYHDHFJUCcjs.normalizeFlow; exports.normalizeHexColor = _chunkFQPUF2W2cjs.normalizeHexColor; exports.normalizeImpasto = _chunkTZOX7KWVcjs.normalizeImpasto; exports.normalizeLight = _chunkTZOX7KWVcjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkTZOX7KWVcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkTZOX7KWVcjs.normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeParticle = _chunkTZOX7KWVcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkTZOX7KWVcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkTZOX7KWVcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkYHDHFJUCcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintAgentStrokePoints = paintAgentStrokePoints; exports.paintContracts = paintContracts; exports.paintGradientMappingFor = _chunkFQPUF2W2cjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintProposalGhost = paintProposalGhost; exports.paintShortcutFor = paintShortcutFor; exports.paintSourceColor = _chunkFQPUF2W2cjs.paintSourceColor; exports.paintSourceCss = _chunkFQPUF2W2cjs.paintSourceCss; exports.paintToMultiColor = _chunkTZOX7KWVcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = _chunkTZOX7KWVcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkFQPUF2W2cjs.parsePaintSource; exports.patchBrushValue = _chunkPYTJBVW5cjs.patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunk3K6HWEXZcjs.rand01; exports.randSigned = _chunk3K6HWEXZcjs.randSigned; exports.readEffectStrokeMap = readEffectStrokeMap; exports.readPaintEffectPaint = readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkFQPUF2W2cjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkFQPUF2W2cjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = renderPaper; exports.renderStickers = renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkFQPUF2W2cjs.resolvePaintGradient; exports.reversePaintGradient = _chunkFQPUF2W2cjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleArt = sampleArt; exports.sampleEffectAt = sampleEffectAt; exports.sampleEffectField = sampleEffectField; exports.samplePath = samplePath; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkFQPUF2W2cjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunk3K6HWEXZcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkFQPUF2W2cjs.solidPaint; exports.stampCoverage = _chunkJSDND7DFcjs.stampCoverage; exports.standardBlendMode = _chunk2VX55NFMcjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = stickerAt; exports.stickerRect = stickerRect; exports.stickerRefLabel = stickerRefLabel; exports.stickerStamp = stickerStamp; exports.stickerSurface = stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.strokeToJSON = strokeToJSON; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = toStrokePoint; exports.toggleDotTexture = toggleDotTexture; exports.toggleStamp = toggleStamp; exports.toggleStickerRef = toggleStickerRef; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkFQPUF2W2cjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkTZOX7KWVcjs.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 = _chunkYHDHFJUCcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunkI3Y2Q3PMcjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;
+
+exports.BACKLIGHT_SPILL = BACKLIGHT_SPILL; exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunk2VX55NFMcjs.BLEND_MODES; exports.BRUSH_ID = _chunkBY5EBP26cjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkBY5EBP26cjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = _chunkF3KKR6DDcjs.BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkBY5EBP26cjs.BUILTIN_BRUSHES; exports.BristleStroke = BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunkBY5EBP26cjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkBY5EBP26cjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkBY5EBP26cjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkBY5EBP26cjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkYHDHFJUCcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkBY5EBP26cjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunkBY5EBP26cjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkBY5EBP26cjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkBY5EBP26cjs.DEFAULT_PARTICLE; exports.DEFAULT_SPRAY = _chunkBY5EBP26cjs.DEFAULT_SPRAY; exports.DEFAULT_STICKER = _chunkBY5EBP26cjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkBY5EBP26cjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkYHDHFJUCcjs.DEFAULT_WET_PARAMS; exports.DOT_ROTATIONS = _chunkBY5EBP26cjs.DOT_ROTATIONS; exports.DOT_ROTATION_LABELS = DOT_ROTATION_LABELS; exports.DOT_TEXTURE_ORDERS = _chunkBY5EBP26cjs.DOT_TEXTURE_ORDERS; exports.DOT_TEXTURE_ORDER_LABELS = DOT_TEXTURE_ORDER_LABELS; exports.DryStroke = DryStroke; exports.EFFECT_MAP_REPEATS = EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPXDIAYB6cjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPXDIAYB6cjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunkI3Y2Q3PMcjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkBY5EBP26cjs.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 = _chunkFQPUF2W2cjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_DOT_TEXTURES = _chunkBY5EBP26cjs.MAX_DOT_TEXTURES; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_PATH_SAMPLES = MAX_PATH_SAMPLES; exports.MAX_STICKER_STAMPS = _chunkBY5EBP26cjs.MAX_STICKER_STAMPS; 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 = _chunkBY5EBP26cjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunk2VX55NFMcjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkBY5EBP26cjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkBY5EBP26cjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_CONTRACT_FORMAT_VERSION = PAINT_CONTRACT_FORMAT_VERSION; exports.PAINT_DOCUMENT_JSON_SCHEMA = PAINT_DOCUMENT_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkFQPUF2W2cjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkFQPUF2W2cjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SHORTCUTS = PAINT_SHORTCUTS; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkFQPUF2W2cjs.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 = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunkBY5EBP26cjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkBY5EBP26cjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PATH_STROKE_TAPERS = PATH_STROKE_TAPERS; 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 = _chunkFQPUF2W2cjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkFQPUF2W2cjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPXDIAYB6cjs.PaperGrain; exports.ParticleStroke = ParticleStroke; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.RIBBON_PAIRS = _chunkBY5EBP26cjs.RIBBON_PAIRS; exports.RIBBON_PAIR_LABELS = RIBBON_PAIR_LABELS; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkOTN6VB5Scjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_ART_SIZE = STICKER_ART_SIZE; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerArtCache = StickerArtCache; exports.StickerBrowser = _chunkXORJ7UZOcjs.StickerBrowser; exports.StickerSpray = StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunk3K6HWEXZcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkYHDHFJUCcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkBY5EBP26cjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkYHDHFJUCcjs.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 = _chunkBY5EBP26cjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkFQPUF2W2cjs.addPaintGradientStop; exports.addPolygonArea = addPolygonArea; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.backlightOf = backlightOf; exports.brushEngineControls = _chunkF3KKR6DDcjs.brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkBY5EBP26cjs.brushTakesPaint; exports.brushToJSON = _chunkBY5EBP26cjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintAgentStrokes = createPaintAgentStrokes; exports.createPaintBrushLibraryToolProvider = createPaintBrushLibraryToolProvider; exports.createPaintChangeFeed = createPaintChangeFeed; exports.createPaintCompositor = createPaintCompositor; exports.createPaintConformanceHost = createPaintConformanceHost; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintProposalToolProvider = createPaintProposalToolProvider; exports.createPaintProposals = createPaintProposals; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.defaultStickerRasterizer = defaultStickerRasterizer; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = effectPaintKey; exports.effectPaintSize = effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPXDIAYB6cjs.grainCatch; exports.grainHeights = _chunkPXDIAYB6cjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunk3K6HWEXZcjs.hash2; exports.hexToPaintRgb = _chunkFQPUF2W2cjs.hexToPaintRgb; exports.hexToRgb8 = hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunkI3Y2Q3PMcjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunk2VX55NFMcjs.isBlendMode; exports.isGradientPaint = _chunkFQPUF2W2cjs.isGradientPaint; exports.isPaintEffectPaint = isPaintEffectPaint; exports.isPainterlyBlendMode = _chunk2VX55NFMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkBY5EBP26cjs.isWetBrush; exports.isWetCapable = _chunkBY5EBP26cjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunk3K6HWEXZcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = _chunkF3KKR6DDcjs.multiColorSliders; exports.multiColorToPaint = _chunkBY5EBP26cjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkBY5EBP26cjs.normalizeBehavior; exports.normalizeBristle = _chunkBY5EBP26cjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkBY5EBP26cjs.normalizeDynamics; exports.normalizeFlow = _chunkYHDHFJUCcjs.normalizeFlow; exports.normalizeHexColor = _chunkFQPUF2W2cjs.normalizeHexColor; exports.normalizeImpasto = _chunkBY5EBP26cjs.normalizeImpasto; exports.normalizeLight = _chunkBY5EBP26cjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkBY5EBP26cjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkBY5EBP26cjs.normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeParticle = _chunkBY5EBP26cjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkBY5EBP26cjs.normalizeStickerSettings; exports.normalizeStickerUpdate = normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkBY5EBP26cjs.normalizeWetBrush; exports.normalizeWetParams = _chunkYHDHFJUCcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintAgentStrokePoints = paintAgentStrokePoints; exports.paintBrushPreviewRenderer = paintBrushPreviewRenderer; exports.paintContracts = paintContracts; exports.paintGradientMappingFor = _chunkFQPUF2W2cjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintProposalGhost = paintProposalGhost; exports.paintShortcutFor = paintShortcutFor; exports.paintSourceColor = _chunkFQPUF2W2cjs.paintSourceColor; exports.paintSourceCss = _chunkFQPUF2W2cjs.paintSourceCss; exports.paintToMultiColor = _chunkBY5EBP26cjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = _chunkBY5EBP26cjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkFQPUF2W2cjs.parsePaintSource; exports.patchBrushValue = _chunkF3KKR6DDcjs.patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunk3K6HWEXZcjs.rand01; exports.randSigned = _chunk3K6HWEXZcjs.randSigned; exports.readEffectStrokeMap = readEffectStrokeMap; exports.readPaintEffectPaint = readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkFQPUF2W2cjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkFQPUF2W2cjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = renderPaper; exports.renderStickers = renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkFQPUF2W2cjs.resolvePaintGradient; exports.reversePaintGradient = _chunkFQPUF2W2cjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleArt = sampleArt; exports.sampleEffectAt = sampleEffectAt; exports.sampleEffectField = sampleEffectField; exports.samplePath = samplePath; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkFQPUF2W2cjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunk3K6HWEXZcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkFQPUF2W2cjs.solidPaint; exports.stampCoverage = _chunkOTN6VB5Scjs.stampCoverage; exports.standardBlendMode = _chunk2VX55NFMcjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = stickerAt; exports.stickerRect = stickerRect; exports.stickerRefLabel = stickerRefLabel; exports.stickerStamp = stickerStamp; exports.stickerSurface = stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.strokeToJSON = strokeToJSON; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = toStrokePoint; exports.toggleDotTexture = toggleDotTexture; exports.toggleStamp = toggleStamp; exports.toggleStickerRef = toggleStickerRef; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkFQPUF2W2cjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkBY5EBP26cjs.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 = _chunkYHDHFJUCcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunkI3Y2Q3PMcjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;