@pixerate/editor 0.252.0 → 0.254.0

package/dist/paint-editor/index.cjs

@@ -6,7 +6,25 @@
 var _chunkSABJMH6Mcjs = require('../chunk-SABJMH6M.cjs');
 
 
-var _chunkZBCT5MEAcjs = require('../chunk-ZBCT5MEA.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk34KLWUH4cjs = require('../chunk-34KLWUH4.cjs');
+
+
+var _chunkCBVNCWJMcjs = require('../chunk-CBVNCWJM.cjs');
 
 
 
@@ -139,7 +157,7 @@ var _chunkPY4GWSE2cjs = require('../chunk-PY4GWSE2.cjs');
 
 
 
-var _chunkISIO63Q5cjs = require('../chunk-ISIO63Q5.cjs');
+var _chunkL2JTLW6Bcjs = require('../chunk-L2JTLW6B.cjs');
 require('../chunk-WOFXZ3XU.cjs');
 
 
@@ -194,7 +212,6 @@ var _chunkPXDIAYB6cjs = require('../chunk-PXDIAYB6.cjs');
 
 
 
-
 
 
 var _chunkFQPUF2W2cjs = require('../chunk-FQPUF2W2.cjs');
@@ -3326,6 +3343,19 @@ function readLoad(raw) {
   if (!reservoir && !pickup) return null;
   return { reservoir, amount: reservoir && finite2(r.amount) ? Math.min(1, Math.max(0, r.amount)) : 0, pickup };
 }
+function readStrokeBrush(raw) {
+  if (raw && typeof raw === "object" && "kind" in raw && !("engine" in raw)) {
+    try {
+      return _chunk34KLWUH4cjs.resolveBrush.call(void 0, _chunk34KLWUH4cjs.normalizeBrushSpec.call(void 0, raw));
+    } catch (e4) {
+    }
+  }
+  return _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, _nullishCoalesce(raw, () => ( {})));
+}
+function strokeToJSON(stroke) {
+  const { brush, ...rest } = stroke;
+  return { ...JSON.parse(JSON.stringify(rest)), brush: _chunk34KLWUH4cjs.migrateBrushV1.call(void 0, brush) };
+}
 function normalizeBrushStroke(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
@@ -3335,7 +3365,7 @@ function normalizeBrushStroke(raw) {
   const out = {
     id: r.id,
     layerId: r.layerId,
-    brush: _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, _nullishCoalesce(r.brush, () => ( {}))),
+    brush: readStrokeBrush(r.brush),
     color: typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : "#000000",
     points,
     seed: finite2(r.seed) ? r.seed | 0 : 0
@@ -3349,7 +3379,7 @@ function normalizeBrushStroke(raw) {
     for (const raw2 of r.stencils) {
       try {
         st.push(normalizeStencil(raw2, typeof _optionalChain([raw2, 'optionalAccess', _107 => _107.id]) === "string" ? raw2.id : "stencil"));
-      } catch (e4) {
+      } catch (e5) {
       }
     }
     if (st.length) out.stencils = st;
@@ -3515,7 +3545,7 @@ function downsampleRgba(data, width, height, tw, th) {
 
 // src/paint-editor/serialize.ts
 var PAINT_FORMAT = "pixerate-paint";
-var PAINT_SCHEMA_VERSION = 1;
+var PAINT_SCHEMA_VERSION = 2;
 var KNOWN = /* @__PURE__ */ new Set(["format", "version", "width", "height", "dpi", "paper", "layers", "assets", "activeLayerId", "strokes", "guides", "swatches", "mixingPad", "wet", "wetEvents", "paintEvents", "origin"]);
 function documentExtensions(raw) {
   const out = {};
@@ -3533,7 +3563,7 @@ function header(state, options) {
     paper: { ...state.paper, dry: { ...state.paper.dry }, wet: { ...state.paper.wet } },
     activeLayerId: state.activeLayerId
   };
-  if (options.strokes !== false && state.strokes.length) out.strokes = JSON.parse(JSON.stringify(state.strokes));
+  if (options.strokes !== false && state.strokes.length) out.strokes = state.strokes.map(strokeToJSON);
   if (options.guides !== void 0) out.guides = JSON.parse(JSON.stringify(options.guides));
   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));
@@ -4921,10 +4951,10 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
    * mixed colour's scattering is re-estimated from its luminance, so repeated small mixes favour
    * the lighter paint (see GOTCHAS).
    */
-  mix(paints, options = {}) {
-    if (!paints.length || paints.length > 8) throw new Error(`Give 1 to 8 paints to mix; got ${paints.length}.`);
-    const total = paints.reduce((n, p) => n + p.parts, 0);
-    paints.forEach((p, i) => {
+  mix(paints2, options = {}) {
+    if (!paints2.length || paints2.length > 8) throw new Error(`Give 1 to 8 paints to mix; got ${paints2.length}.`);
+    const total = paints2.reduce((n, p) => n + p.parts, 0);
+    paints2.forEach((p, i) => {
       if (!(Number.isFinite(p.parts) && p.parts >= 0)) throw new Error(`paints[${i}].parts is ${p.parts}; use a number \u2265 0.`);
     });
     if (!(total > 0)) throw new Error("Every paint has 0 parts; give at least one paint parts above 0.");
@@ -4939,7 +4969,7 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
     }
     const bounds = { x: Math.floor(cx - R), y: Math.floor(cy - R), width: Math.ceil(2 * R), height: Math.ceil(2 * R) };
     if (options.clear !== false) this.surface = _chunk474IQG74cjs.writeRegion.call(void 0, this.surface, bounds, new Uint8ClampedArray(bounds.width * bounds.height * 4));
-    const used = paints.filter((p) => p.parts > 0);
+    const used = paints2.filter((p) => p.parts > 0);
     const area = Math.PI * (0.7 * R) ** 2;
     used.forEach((p, i) => {
       const r = Math.sqrt(area * (p.parts / total) / Math.PI);
@@ -4962,8 +4992,8 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
       this.run(knife, stir, "#000000");
     }
     const mixed = _chunk2VX55NFMcjs.mixPigments.call(void 0, 
-      paints.map((p) => hexToRgb8(p.color).map((v) => v / 255)),
-      paints.map((p) => p.parts)
+      paints2.map((p) => hexToRgb8(p.color).map((v) => v / 255)),
+      paints2.map((p) => p.parts)
     );
     const core = _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
     const hex = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
@@ -5001,6 +5031,79 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
   }
 }, _class16);
 
+// src/paint-editor/brush-library.ts
+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 ? _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, resolved, resolved) : _chunk34KLWUH4cjs.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 ??= _chunk34KLWUH4cjs.BRUSH_PRESETS.map((spec) => {
+    const resolved = _chunkHS6QDWDFcjs.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(_chunkHS6QDWDFcjs.brushToJSON) });
+  return {
+    get: async () => stored,
+    set: async (_key, value) => {
+      stored = value;
+    }
+  };
+}
+var paints = (b) => {
+  const { category: _c, builtin: _b, ...rest } = b;
+  return JSON.stringify(rest);
+};
+function brushSpecOf(next, from) {
+  const plain = _chunk34KLWUH4cjs.migrateBrushV1.call(void 0, next);
+  const out = copyJSON(plain);
+  if (from.description) out.description = from.description;
+  if (_optionalChain([from, 'access', _209 => _209.tags, 'optionalAccess', _210 => _210.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', _211 => _211.colour, 'optionalAccess', _212 => _212.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', _213 => _213.light, 'optionalAccess', _214 => _214.amount]), () => ( 0))) > 0 && (_optionalChain([from, 'access', _215 => _215.light, 'optionalAccess', _216 => _216.spill]) || _optionalChain([from, 'access', _217 => _217.light, 'optionalAccess', _218 => _218.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', _219 => _219.motion, 'optionalAccess', _220 => _220.live]) !== void 0 || _optionalChain([from, 'access', _221 => _221.motion, 'optionalAccess', _222 => _222.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 = _chunk34KLWUH4cjs.normalizeBrushSpec.call(void 0, out, []);
+    if (paints(_chunk34KLWUH4cjs.resolveBrush.call(void 0, hinted)) === paints(_chunk34KLWUH4cjs.resolveBrush.call(void 0, plain))) return hinted;
+  } catch (e6) {
+  }
+  return plain;
+}
+function engineChanges(base, next) {
+  const diff = (a, b) => {
+    if (isObject(a) && isObject(b)) {
+      const out = {};
+      for (const k of Object.keys(b)) {
+        const d = diff(a[k], b[k]);
+        if (d !== void 0) out[k] = d;
+      }
+      return Object.keys(out).length ? out : void 0;
+    }
+    return JSON.stringify(a) === JSON.stringify(b) ? void 0 : copyJSON(b);
+  };
+  const { id: _i, builtin: _b, ...rest } = _nullishCoalesce(diff(base, next), () => ( {}));
+  return rest;
+}
+
 // src/paint-editor/live-strokes.ts
 var LIVE_STROKE_ENGINES = ["dab", "particle", "bristle", "mixer"];
 function liveStrokeRefusal(brush) {
@@ -5098,8 +5201,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', _209 => _209.thick, 'optionalAccess', _210 => _210.height]), rect, l.offset, refs);
-          tilesUnder(_optionalChain([l, 'access', _211 => _211.thick, 'optionalAccess', _212 => _212.material]), rect, l.offset, refs);
+          tilesUnder(_optionalChain([l, 'access', _223 => _223.thick, 'optionalAccess', _224 => _224.height]), rect, l.offset, refs);
+          tilesUnder(_optionalChain([l, 'access', _225 => _225.thick, 'optionalAccess', _226 => _226.material]), rect, l.offset, refs);
         }
         const k = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
         let r = this.tiles.get(k);
@@ -5193,8 +5296,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', _213 => _213.thick, 'optionalAccess', _214 => _214.height, 'access', _215 => _215.tiles, 'access', _216 => _216.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.height, lr) : null;
-    const m = h && _optionalChain([l, 'access', _217 => _217.thick, 'optionalAccess', _218 => _218.material, 'access', _219 => _219.tiles, 'access', _220 => _220.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.material, lr) : null;
+    const h = _optionalChain([l, 'access', _227 => _227.thick, 'optionalAccess', _228 => _228.height, 'access', _229 => _229.tiles, 'access', _230 => _230.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.height, lr) : null;
+    const m = h && _optionalChain([l, 'access', _231 => _231.thick, 'optionalAccess', _232 => _232.material, 'access', _233 => _233.tiles, 'access', _234 => _234.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];
@@ -5269,7 +5372,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', _221 => _221.paint, 'optionalAccess', _222 => _222.type]) === "effect" ? [st.paint] : []));
+  await target.prepareEffectPaints(source.strokes.slice(0, maxStrokes).flatMap((st) => _optionalChain([st, 'access', _235 => _235.paint, 'optionalAccess', _236 => _236.type]) === "effect" ? [st.paint] : []));
   const advanceTo = async (clock) => {
     const now = target.getState().wet.clock;
     let left = clock - now;
@@ -5277,7 +5380,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', _223 => _223.onWetSteps, 'optionalCall', _224 => _224(target.getState().wet.clock)]);
+      if (Number.isFinite(chunk)) await _optionalChain([options, 'access', _237 => _237.onWetSteps, 'optionalCall', _238 => _238(target.getState().wet.clock)]);
     }
   };
   const sr = (r) => ({ x: r.x * s, y: r.y * s, width: r.width * s, height: r.height * s });
@@ -5290,14 +5393,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', _225 => _225.rasterized])) target.replaceLiveStrokes(e.layerId, null);
+        if (_optionalChain([d, 'optionalAccess', _239 => _239.rasterized])) target.replaceLiveStrokes(e.layerId, null);
         else {
-          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _226 => _226.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', _227 => _227.paint, 'optionalAccess', _228 => _228.type]) === "effect" ? [st2.paint] : []));
+          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _240 => _240.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', _241 => _241.paint, 'optionalAccess', _242 => _242.type]) === "effect" ? [st2.paint] : []));
           target.replaceLiveStrokes(e.layerId, list);
         }
       } else if (e.kind === "stickers") {
-        const list = (_nullishCoalesce(_optionalChain([e, 'access', _229 => _229.data, 'optionalAccess', _230 => _230.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', _243 => _243.data, 'optionalAccess', _244 => _244.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;
@@ -5310,8 +5413,8 @@ async function replayPainting(source, target, options = {}) {
         switch (e.kind) {
           case "dry": {
             const rect = e.data;
-            const ids = _optionalChain([e, 'access', _231 => _231.layerId, 'optionalAccess', _232 => _232.split, 'call', _233 => _233(","), 'access', _234 => _234.filter, 'call', _235 => _235(Boolean)]);
-            if (_optionalChain([ids, 'optionalAccess', _236 => _236.length])) for (const id of ids) target.dryPaint({ layerId: id, rect: rect ? sr(rect) : void 0 });
+            const ids = _optionalChain([e, 'access', _245 => _245.layerId, 'optionalAccess', _246 => _246.split, 'call', _247 => _247(","), 'access', _248 => _248.filter, 'call', _249 => _249(Boolean)]);
+            if (_optionalChain([ids, 'optionalAccess', _250 => _250.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;
           }
@@ -5334,7 +5437,7 @@ async function replayPainting(source, target, options = {}) {
             break;
           }
         }
-      } catch (e5) {
+      } catch (e7) {
       }
       continue;
     }
@@ -5342,7 +5445,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', _237 => _237.steps, 'optionalAccess', _238 => _238.length]) === st.points.length) {
+    if (st.brush.engine === "wet" && _optionalChain([st, 'access', _251 => _251.steps, 'optionalAccess', _252 => _252.length]) === st.points.length) {
       await target.wetIdle();
       await advanceTo(st.steps[0]);
       const session = target.beginStroke({ ...init, start: st.points[0] });
@@ -5362,7 +5465,7 @@ async function replayPainting(source, target, options = {}) {
       await target.wetIdle();
       target.paintStroke({ ...init, points: st.points });
     }
-    await _optionalChain([options, 'access', _239 => _239.onStroke, 'optionalCall', _240 => _240(strokes)]);
+    await _optionalChain([options, 'access', _253 => _253.onStroke, 'optionalCall', _254 => _254(strokes)]);
   }
   void IDENTITY_AFFINE;
 }
@@ -5385,7 +5488,7 @@ function timeLapseVideo(frameCount, width, height, fps, holdMs, name = "Time-lap
   }
   const video = { version: 1, name, width: w, height: h, fps, background: "#000000", assets, tracks: [{ id: "v1", kind: "video", clips }] };
   const durationMs = frameCount ? clips[clips.length - 1].start + clips[clips.length - 1].duration : 0;
-  return { video, ffmpeg: _chunkZBCT5MEAcjs.toVideoFfmpeg.call(void 0, video, { output: "timelapse.mp4" }), durationMs };
+  return { video, ffmpeg: _chunkCBVNCWJMcjs.toVideoFfmpeg.call(void 0, video, { output: "timelapse.mp4" }), durationMs };
 }
 async function buildTimeLapse(source, target, options = {}) {
   const maxSide = Math.max(32, Math.min(4096, Math.round(_nullishCoalesce(options.maxSide, () => ( 720)))));
@@ -5407,7 +5510,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', _241 => _241.onProgress, 'optionalCall', _242 => _242(total ? i / total : 1)]);
+      _optionalChain([options, 'access', _255 => _255.onProgress, 'optionalCall', _256 => _256(total ? i / total : 1)]);
     },
     onWetSteps: wetEvery > 0 ? () => shoot(-1) : void 0
   });
@@ -5468,7 +5571,7 @@ function checkPaintEffectPlace(d, place) {
   else if (d.uses.includes("filter") && place !== "light") instead = "; run it on a layer's dried paint with apply_effect instead";
   else if (place === "light" && d.uses.some((u) => PAINT_EFFECT_PLACES.layer.includes(u))) instead = "; add it as an effect layer (add_effect_layer) or fill a layer with it (fill_layer_with_effect) instead";
   else if (place === "paper" && d.uses.some((u) => u === "overlay" || u === "title")) instead = "; add it as an effect layer with add_effect_layer instead";
-  throw new (0, _chunkISIO63Q5cjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) is a ${d.uses.join(" / ") || d.kind} effect, and ${PLACE_WORDS[place]}${instead}.`, d.id);
+  throw new (0, _chunkL2JTLW6Bcjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) is a ${d.uses.join(" / ") || d.kind} effect, and ${PLACE_WORDS[place]}${instead}.`, d.id);
 }
 var PAPER_EFFECT_BLENDS = ["multiply", "normal", "overlay", "soft-light", "screen", "color"];
 var paperVersion = 1;
@@ -5583,6 +5686,13 @@ var PaintEditorError = class extends Error {
     this.name = "PaintEditorError";
   }
 };
+async function libraryCall(call) {
+  try {
+    return await call();
+  } catch (e) {
+    throw e instanceof _chunk34KLWUH4cjs.BrushLibraryError ? new PaintEditorError(e.message) : e;
+  }
+}
 var HEX3 = /^#[0-9a-f]{6}$/i;
 var MAX_ADD_STICKERS = 500;
 function parseColor(value, what = "color") {
@@ -5603,99 +5713,116 @@ 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', _243 => _243.type]) === "pixel";
+var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _257 => _257.type]) === "pixel";
 var PaintEditorController = (_class19 = class _PaintEditorController {
   
   __init117() {this.extensions = {}}
   __init118() {this.undoStack = []}
   __init119() {this.redoStack = []}
   
+  /** The brush library this editor lists, saves into and paints from (shared with other editors when the host passes one). */
+  
   
+  /** The active brush as facets (what `getBrushSpec` and saving use). */
+  
+  /** 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()}
   
   /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
-  __init120() {this.library = null}
+  __init122() {this.library = null}
   
-  __init121() {this.secondaryColor = "#ffffff"}
+  __init123() {this.secondaryColor = "#ffffff"}
   /** Gradient paint chosen with `setPaint` (`null`: the paint colour). */
-  __init122() {this.gradient = null}
+  __init124() {this.gradient = null}
   /** Effect paint chosen with `setEffectPaint` (rendered), and one still rendering. */
-  __init123() {this.effectPaint = null}
-  __init124() {this.effectPaintPending = null}
+  __init125() {this.effectPaint = null}
+  __init126() {this.effectPaintPending = null}
   /** Changes whenever the paint is chosen, so an effect paint that finishes rendering late does not take over. */
-  __init125() {this.paintEpoch = 0}
+  __init127() {this.paintEpoch = 0}
   /** Rendered effect paints by `effectPaintKey` (most recently used last). */
-  __init126() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
-  __init127() {this.mixerLoad = _chunkFQPUF2W2cjs.EMPTY_MIXER_LOAD}
-  __init128() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  __init128() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
+  __init129() {this.mixerLoad = _chunkFQPUF2W2cjs.EMPTY_MIXER_LOAD}
+  __init130() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
   
-  __init129() {this.selectedStroke = null}
-  __init130() {this.selectedSticker = null}
+  __init131() {this.selectedStroke = null}
+  __init132() {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. */
-  __init131() {this.stickerPreview = null}
+  __init133() {this.stickerPreview = null}
   
-  __init132() {this.listeners = /* @__PURE__ */ new Set()}
-  __init133() {this.version = 0}
-  __init134() {this.cached = null}
-  __init135() {this.session = null}
-  __init136() {this.live = null}
-  __init137() {this.liveLayers = null}
-  __init138() {this.dirty = "all"}
-  __init139() {this.seedCounter = 1}
-  __init140() {this.strokeCounter = 1}
+  __init134() {this.listeners = /* @__PURE__ */ new Set()}
+  __init135() {this.version = 0}
+  __init136() {this.cached = null}
+  __init137() {this.session = null}
+  __init138() {this.live = null}
+  __init139() {this.liveLayers = null}
+  __init140() {this.dirty = "all"}
+  __init141() {this.seedCounter = 1}
+  __init142() {this.strokeCounter = 1}
   /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
-  __init141() {this.lightSpills = {}}
-  __init142() {this.lightCaches = /* @__PURE__ */ new Map()}
+  __init143() {this.lightSpills = {}}
+  __init144() {this.lightCaches = /* @__PURE__ */ new Map()}
   /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
-  __init143() {this.backlightView = new BacklightCache()}
-  __init144() {this.backlightCommitted = new BacklightCache()}
+  __init145() {this.backlightView = new BacklightCache()}
+  __init146() {this.backlightCommitted = new BacklightCache()}
   /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
-  __init145() {this.effectPlaybackState = { playing: true, fps: 30 }}
-  __init146() {this.effectTime = 0}
+  __init147() {this.effectPlaybackState = { playing: true, fps: 30 }}
+  __init148() {this.effectTime = 0}
   /** While a frame is drawn: the time live effect strokes are drawn at (else their own time). */
-  __init147() {this.liveEffectAt = null}
+  __init149() {this.liveEffectAt = null}
   /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
-  __init148() {this.animatedLayers = /* @__PURE__ */ new Map()}
+  __init150() {this.animatedLayers = /* @__PURE__ */ new Map()}
   /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
-  __init149() {this.frameOverride = null}
+  __init151() {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`). */
-  __init150() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
+  __init152() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
   
-  __init151() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init152() {this.pad = new MixingPad()}
-  __init153() {this.savedPads = []}
-  __init154() {this.nextPadId = 1}
-  __init155() {this.tracingVersion = 1}
-  __init156() {this.tracingCache = null}
-  __init157() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init158() {this.nextReferenceId = 1}
-  __init159() {this.viewCompositor = createPaintCompositor()}
-  __init160() {this.exportCompositor = createPaintCompositor()}
+  __init153() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init154() {this.pad = new MixingPad()}
+  __init155() {this.savedPads = []}
+  __init156() {this.nextPadId = 1}
+  __init157() {this.tracingVersion = 1}
+  __init158() {this.tracingCache = null}
+  __init159() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init160() {this.nextReferenceId = 1}
+  __init161() {this.viewCompositor = createPaintCompositor()}
+  __init162() {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). */
-  __init161() {this.lighting = { ...DEFAULT_LIGHTING }}
-  __init162() {this.litCaches = /* @__PURE__ */ new Map()}
+  __init163() {this.lighting = { ...DEFAULT_LIGHTING }}
+  __init164() {this.litCaches = /* @__PURE__ */ new Map()}
   /** The live impasto stroke's channels. */
-  __init163() {this.liveThick = null}
+  __init165() {this.liveThick = null}
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
-  __init164() {this.wetOp = null}
+  __init166() {this.wetOp = null}
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init165() {this.effects = new (0, _chunkISIO63Q5cjs.EffectsSlot)()}
+  __init167() {this.effects = new (0, _chunkL2JTLW6Bcjs.EffectsSlot)()}
   /** The sticker library slot (see `setStickersProvider`). */
-  __init166() {this.stickers = new (0, _chunkJSDND7DFcjs.StickersSlot)(_chunkSABJMH6Mcjs.editorStickers.call(void 0, ))}
-  __init167() {this.stickerArt = new StickerArtCache()}
+  __init168() {this.stickers = new (0, _chunkJSDND7DFcjs.StickersSlot)(_chunkSABJMH6Mcjs.editorStickers.call(void 0, ))}
+  __init169() {this.stickerArt = new StickerArtCache()}
   
-  __init168() {this.effectsRenderer = new PaintEffectsRenderer()}
-  __init169() {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);
+  __init170() {this.effectsRenderer = new PaintEffectsRenderer()}
+  __init171() {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);
     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) });
-    this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
-    const start = _nullishCoalesce(this.findBrush(_nullishCoalesce(options.brushId, () => ( _chunkHS6QDWDFcjs.DEFAULT_BRUSH_ID))), () => ( this.findBrush(_chunkHS6QDWDFcjs.DEFAULT_BRUSH_ID)));
-    this.brush = _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, start);
+    const seed = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
+    this.brushLibrary = _nullishCoalesce(options.brushLibrary, () => ( _chunk34KLWUH4cjs.createBrushLibrary.call(void 0, { storage: seededStorage(seed) })));
+    this.brushEntries = [...builtinLibraryBrushes(), ...seed.map((b) => libraryBrush(_chunk34KLWUH4cjs.migrateBrushV1.call(void 0, b), false, b))];
+    const wanted = _nullishCoalesce(options.brushId, () => ( _chunkHS6QDWDFcjs.DEFAULT_BRUSH_ID));
+    const start = _nullishCoalesce(this.findEntry(wanted), () => ( this.findEntry(_chunkHS6QDWDFcjs.DEFAULT_BRUSH_ID)));
+    this.brush = _chunkHS6QDWDFcjs.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(_chunkHS6QDWDFcjs.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";
     this.hand = options.hand === "left" ? "left" : "right";
     this.encodeImage = options.encodeImage;
@@ -5706,7 +5833,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         canvas: () => this.doc.canvas,
         paper: () => this.doc.paper,
         layerSurface: (id) => {
-          const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _244 => _244.layer]);
+          const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _258 => _258.layer]);
           return isPixelLayer(l) ? l.surface : null;
         },
         updateSurfaces: (surfaces, rects) => {
@@ -5715,7 +5842,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
           this.doc = { ...this.doc, layers };
           this.emit(rects.length ? rects : "all");
         },
-        layerLight: (id) => _nullishCoalesce(_optionalChain([this, 'access', _245 => _245.doc, 'access', _246 => _246.light, 'optionalAccess', _247 => _247[id]]), () => ( null)),
+        layerLight: (id) => _nullishCoalesce(_optionalChain([this, 'access', _259 => _259.doc, 'access', _260 => _260.light, 'optionalAccess', _261 => _261[id]]), () => ( null)),
         updateLights: (lights) => {
           let light = this.doc.light;
           for (const [id, surface] of lights) if (_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id)) light = withLayerLight(light, id, surface);
@@ -5726,7 +5853,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       },
       options.wet
     );
-    this.wet.onDriverDone = () => _optionalChain([this, 'access', _248 => _248.session, 'optionalAccess', _249 => _249.completeWetEnd, 'call', _250 => _250()]);
+    this.wet.onDriverDone = () => _optionalChain([this, 'access', _262 => _262.session, 'optionalAccess', _263 => _263.completeWetEnd, 'call', _264 => _264()]);
   }
   // --- State and events ----------------------------------------------------------
   subscribe(listener) {
@@ -5748,7 +5875,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.cached = {
       document: this.doc,
       brush: this.brush,
-      brushes: this.library ??= [..._chunkHS6QDWDFcjs.BUILTIN_BRUSHES, ...this.userBrushes],
+      brushes: this.library ??= this.brushEntries.map((e) => e.brush),
       color: this.color,
       secondaryColor: this.secondaryColor,
       paint: _nullishCoalesce(this.gradient, () => ( { type: "color", color: this.color })),
@@ -5762,8 +5889,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', _251 => _251.label]), () => ( null)),
-      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _252 => _252.label]), () => ( null)),
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _265 => _265.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _266 => _266.label]), () => ( null)),
       guides: this.guides,
       swatches: this.swatches,
       mixingPadVersion: this.pad.version,
@@ -5776,10 +5903,10 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         overlay: this.wet.overlay,
         instantDry: this.wet.instantDry,
         speed: this.wet.speed,
-        clock: _nullishCoalesce(_optionalChain([this, 'access', _253 => _253.wet, 'access', _254 => _254.world, 'optionalAccess', _255 => _255.clock]), () => ( 0)),
+        clock: _nullishCoalesce(_optionalChain([this, 'access', _267 => _267.wet, 'access', _268 => _268.world, 'optionalAccess', _269 => _269.clock]), () => ( 0)),
         tilt: { ...this.wet.tilt },
         gpu: this.wet.gpuMode,
-        gpuActive: Boolean(_optionalChain([this, 'access', _256 => _256.wet, 'access', _257 => _257.world, 'optionalAccess', _258 => _258.gpuActive]))
+        gpuActive: Boolean(_optionalChain([this, 'access', _270 => _270.wet, 'access', _271 => _271.world, 'optionalAccess', _272 => _272.gpuActive]))
       },
       version: this.version
     };
@@ -5798,7 +5925,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return d;
   }
   // --- History -------------------------------------------------------------------
-  __init170() {this.docRevision = 0}
+  __init172() {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.
@@ -5881,9 +6008,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return wetIds;
   }
   /** Records a wet event (for replays) in the document being built. */
-  __init171() {this.pendingWetEvents = []}
+  __init173() {this.pendingWetEvents = []}
   logWet(e) {
-    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _259 => _259.wet, 'access', _260 => _260.world, 'optionalAccess', _261 => _261.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
+    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _273 => _273.wet, 'access', _274 => _274.world, 'optionalAccess', _275 => _275.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
   }
   /** The document with a paint event appended (for replays). */
   withPaintEvent(doc, e) {
@@ -6027,7 +6154,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _262 => _262.layer]);
+      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _276 => _276.layer]);
       if (isPixelLayer(l)) next = { ...next, layers: _chunkDPYAO5U6cjs.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) {
@@ -6071,7 +6198,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   // --- Layers --------------------------------------------------------------------
   getLayer(id) {
-    return _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _263 => _263.layer]);
+    return _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _277 => _277.layer]);
   }
   /** The active pixel layer (or `undefined`). */
   getActiveLayer() {
@@ -6090,7 +6217,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     walk(this.doc.layers, null, 0);
     return out;
   }
-  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _264 => _264.parent, 'optionalAccess', _265 => _265.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _266 => _266.path, 'access', _267 => _267.length]), () => ( 0))) {
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _278 => _278.parent, 'optionalAccess', _279 => _279.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _280 => _280.path, 'access', _281 => _281.length]), () => ( 0))) {
     let bounds = null;
     if (l.type === "pixel") {
       const b = _chunk474IQG74cjs.contentBounds.call(void 0, l.surface);
@@ -6107,8 +6234,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       locks: { ..._nullishCoalesce(l.locks, () => ( {})) },
       active: l.id === this.doc.activeLayerId,
       bounds,
-      ..._optionalChain([this, 'access', _268 => _268.doc, 'access', _269 => _269.liveStrokes, 'optionalAccess', _270 => _270[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
-      ..._optionalChain([l, 'access', _271 => _271.effects, 'optionalAccess', _272 => _272.items, 'access', _273 => _273.length]) ? { effects: l.effects.items.length } : {},
+      ..._optionalChain([this, 'access', _282 => _282.doc, 'access', _283 => _283.liveStrokes, 'optionalAccess', _284 => _284[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
+      ..._optionalChain([l, 'access', _285 => _285.effects, 'optionalAccess', _286 => _286.items, 'access', _287 => _287.length]) ? { effects: l.effects.items.length } : {},
       parentId,
       depth
     };
@@ -6140,7 +6267,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.requireIdle("adding a layer");
     const count = _chunkDPYAO5U6cjs.flattenLayers.call(void 0, this.doc.layers).length;
     const type = _nullishCoalesce(options.type, () => ( "pixel"));
-    const name = _optionalChain([options, 'access', _274 => _274.name, 'optionalAccess', _275 => _275.trim, 'call', _276 => _276()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
+    const name = _optionalChain([options, 'access', _288 => _288.name, 'optionalAccess', _289 => _289.trim, 'call', _290 => _290()]) || (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;
@@ -6152,7 +6279,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     } else if (above) {
       const loc = _chunkDPYAO5U6cjs.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', _277 => _277.parent, 'optionalAccess', _278 => _278.id]), () => ( null));
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _291 => _291.parent, 'optionalAccess', _292 => _292.id]), () => ( null));
       index = loc.index + 1;
     }
     const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
@@ -6258,7 +6385,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   requireEffect(id, effectId) {
     const l = this.requireLayer(id);
-    const items = _nullishCoalesce(_optionalChain([l, 'access', _279 => _279.effects, 'optionalAccess', _280 => _280.items]), () => ( []));
+    const items = _nullishCoalesce(_optionalChain([l, 'access', _293 => _293.effects, 'optionalAccess', _294 => _294.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;
@@ -6281,7 +6408,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     const layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
-    if (active && !_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.flattenLayers.call(void 0, layers), 'access', _281 => _281.filter, 'call', _282 => _282((x) => x.type === "pixel"), 'access', _283 => _283.pop, 'call', _284 => _284(), 'optionalAccess', _285 => _285.id]), () => ( null));
+    if (active && !_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.flattenLayers.call(void 0, layers), 'access', _295 => _295.filter, 'call', _296 => _296((x) => x.type === "pixel"), 'access', _297 => _297.pop, 'call', _298 => _298(), 'optionalAccess', _299 => _299.id]), () => ( null));
     this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.liveStrokesWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.lightWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
     return { removed: id, activeLayerId: active };
   }
@@ -6307,7 +6434,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 = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _286 => _286.parent, 'optionalAccess', _287 => _287.id]), () => ( null)), loc.index + 1);
+    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _300 => _300.parent, 'optionalAccess', _301 => _301.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);
   }
@@ -6316,7 +6443,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.requireIdle("moving a layer");
     const loc = _chunkDPYAO5U6cjs.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', _288 => _288.parent, 'optionalAccess', _289 => _289.id]), () => ( null)) : parentId;
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _302 => _302.parent, 'optionalAccess', _303 => _303.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.`);
@@ -6335,7 +6462,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const pre = _chunkDPYAO5U6cjs.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', _290 => _290[pre.index - 1], 'optionalAccess', _291 => _291.id])].filter((x) => Boolean(x)));
+      this.dryLayersFirst([id, _optionalChain([sib, 'access', _304 => _304[pre.index - 1], 'optionalAccess', _305 => _305.id])].filter((x) => Boolean(x)));
     }
     const loc = _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
@@ -6355,7 +6482,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, _chunkDPYAO5U6cjs.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', _292 => _292.doc, 'access', _293 => _293.light, 'optionalAccess', _294 => _294[upper.id]]) || _optionalChain([this, 'access', _295 => _295.doc, 'access', _296 => _296.light, 'optionalAccess', _297 => _297[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _298 => _298.doc, 'access', _299 => _299.light, 'optionalAccess', _300 => _300[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _301 => _301.doc, 'access', _302 => _302.light, 'optionalAccess', _303 => _303[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', _306 => _306.doc, 'access', _307 => _307.light, 'optionalAccess', _308 => _308[upper.id]]) || _optionalChain([this, 'access', _309 => _309.doc, 'access', _310 => _310.light, 'optionalAccess', _311 => _311[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _312 => _312.doc, 'access', _313 => _313.light, 'optionalAccess', _314 => _314[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _315 => _315.doc, 'access', _316 => _316.light, 'optionalAccess', _317 => _317[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 } : {} }));
@@ -6370,7 +6497,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: _chunkDPYAO5U6cjs.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', _304 => _304.doc, 'access', _305 => _305.liveStrokes, 'optionalAccess', _306 => _306[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: _chunkDPYAO5U6cjs.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', _318 => _318.doc, 'access', _319 => _319.liveStrokes, 'optionalAccess', _320 => _320[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
     return { layerId: l.id, bounds };
   }
   /**
@@ -6380,8 +6507,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   fillLayer(options = {}) {
     this.requireIdle("filling");
     const fillTarget = this.paintTarget(options.layerId, "fill");
-    if (_optionalChain([this, 'access', _307 => _307.doc, 'access', _308 => _308.stickers, 'optionalAccess', _309 => _309[fillTarget.id], 'optionalAccess', _310 => _310.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _311 => _311.doc, 'access', _312 => _312.liveStrokes, 'optionalAccess', _313 => _313[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', _321 => _321.doc, 'access', _322 => _322.stickers, 'optionalAccess', _323 => _323[fillTarget.id], 'optionalAccess', _324 => _324.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _325 => _325.doc, 'access', _326 => _326.liveStrokes, 'optionalAccess', _327 => _327[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);
@@ -6414,7 +6541,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       offset: l.offset
     };
     const surface = this.applyCoverage(l, coverage, rect, apply);
-    const lit = _optionalChain([this, 'access', _314 => _314.doc, 'access', _315 => _315.light, 'optionalAccess', _316 => _316[l.id]]);
+    const lit = _optionalChain([this, 'access', _328 => _328.doc, 'access', _329 => _329.light, 'optionalAccess', _330 => _330[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: _chunkDPYAO5U6cjs.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 };
@@ -6424,7 +6551,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', _317 => _317.tiles, 'access', _318 => _318.get, 'call', _319 => _319(key), 'optionalAccess', _320 => _320.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _331 => _331.tiles, 'access', _332 => _332.get, 'call', _333 => _333(key), 'optionalAccess', _334 => _334.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);
@@ -6457,7 +6584,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** The effect a layer is drawn from, or `undefined` for other layers. */
   getEffectLayer(layerId) {
-    return _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _321 => _321.doc, 'access', _322 => _322.effectLayers, 'optionalAccess', _323 => _323[layerId]]) : void 0;
+    return _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _335 => _335.doc, 'access', _336 => _336.effectLayers, 'optionalAccess', _337 => _337[layerId]]) : void 0;
   }
   /** The effect paper (without its pixels), or `null`. */
   getPaperEffect() {
@@ -6475,7 +6602,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       if (v === null) merged[k] = d.defaults[k];
       else given[k] = v;
     }
-    return { ...merged, ..._chunkISIO63Q5cjs.resolveEffectValues.call(void 0, { ...d, defaults: merged }, given) };
+    return { ...merged, ..._chunkL2JTLW6Bcjs.resolveEffectValues.call(void 0, { ...d, defaults: merged }, given) };
   }
   /** Renders a generator, overlay or title effect at the canvas size. */
   renderEffectCanvas(d, values, time = 0) {
@@ -6494,8 +6621,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', _324 => _324.doc, 'access', _325 => _325.stickers, 'optionalAccess', _326 => _326[l.id], 'optionalAccess', _327 => _327.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _328 => _328.doc, 'access', _329 => _329.liveStrokes, 'optionalAccess', _330 => _330[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', _338 => _338.doc, 'access', _339 => _339.stickers, 'optionalAccess', _340 => _340[l.id], 'optionalAccess', _341 => _341.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _342 => _342.doc, 'access', _343 => _343.liveStrokes, 'optionalAccess', _344 => _344[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;
   }
@@ -6534,8 +6661,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', _331 => _331.opacity]))), () => ( 1)),
-      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _332 => _332.blend]))), () => ( "multiply")),
+      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _345 => _345.opacity]))), () => ( 1)),
+      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _346 => _346.blend]))), () => ( "multiply")),
       image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) },
       version: nextPaperEffectVersion()
     };
@@ -6588,8 +6715,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const above = _nullishCoalesce(options.aboveId, () => ( this.doc.activeLayerId));
     const loc = above ? _chunkDPYAO5U6cjs.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', _333 => _333.name, 'optionalAccess', _334 => _334.trim, 'call', _335 => _335()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
-    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _336 => _336.parent, 'optionalAccess', _337 => _337.id]), () => ( null)), loc ? loc.index + 1 : void 0);
+    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _347 => _347.name, 'optionalAccess', _348 => _348.trim, 'call', _349 => _349()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
+    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _350 => _350.parent, 'optionalAccess', _351 => _351.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 };
@@ -6730,9 +6857,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * Renders effect paints that are not rendered yet (strokes and replays need them rendered
    * first, since strokes are synchronous). Throws naming the effect and provider when one cannot be.
    */
-  async prepareEffectPaints(paints) {
+  async prepareEffectPaints(paints2) {
     const seen = /* @__PURE__ */ new Set();
-    for (const p of paints) {
+    for (const p of paints2) {
       const key = effectPaintKey(p);
       if (seen.has(key)) continue;
       seen.add(key);
@@ -6742,8 +6869,8 @@ 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 paints = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _338 => _338.paint, 'optionalAccess', _339 => _339.type]) === "effect").map((s) => s.paint);
-    await this.prepareEffectPaints(paints);
+    const paints2 = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _352 => _352.paint, 'optionalAccess', _353 => _353.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. */
   effectPaintThumbnail(size = 48) {
@@ -6805,14 +6932,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', _340 => _340.doc, 'access', _341 => _341.thick, 'optionalAccess', _342 => _342[l.id]]);
+    const relief = _optionalChain([this, 'access', _354 => _354.doc, 'access', _355 => _355.thick, 'optionalAccess', _356 => _356[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', _343 => _343.inputs, 'access', _344 => _344.find, 'call', _345 => _345((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _346 => _346.name])), 'optionalAccess', _347 => _347.name]), () => ( "source"));
+    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _357 => _357.inputs, 'access', _358 => _358.find, 'call', _359 => _359((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _360 => _360.name])), 'optionalAccess', _361 => _361.name]), () => ( "source"));
     if (sourceInput !== "source") {
       inputs[sourceInput] = inputs.source;
       delete inputs.source;
@@ -6824,100 +6951,162 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return { layerId: now.id, source: this.sourceOf(d, values, options.time), amount };
   }
   // --- Brushes -------------------------------------------------------------------
+  findEntry(id) {
+    return this.brushEntries.find((e) => e.brush.id === id);
+  }
   findBrush(id) {
-    return _nullishCoalesce(_chunkHS6QDWDFcjs.BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
+    return _optionalChain([this, 'access', _362 => _362.findEntry, 'call', _363 => _363(id), 'optionalAccess', _364 => _364.brush]);
+  }
+  requireEntry(id) {
+    const e = this.findEntry(id);
+    if (!e) throw new PaintEditorError(`Unknown brush "${id}". ${_chunk34KLWUH4cjs.closest.call(void 0, id, this.brushEntries.map((x) => x.brush.id))}Call list_brush_presets for the ids.`);
+    return e;
   }
-  /** A library brush by id (`undefined` when unknown). */
+  requireBrush(id) {
+    return this.requireEntry(id).brush;
+  }
+  /** Reads the library again (after a change anywhere it is shared). */
+  refreshBrushes() {
+    const run = this.brushLibrary.list().then((entries) => {
+      this.brushEntries = entries.map((e) => libraryBrush(e.brush, e.builtin));
+      this.library = null;
+      const pending = this.pendingBrushId;
+      this.pendingBrushId = null;
+      if (pending && this.findEntry(pending)) this.setBrush({ id: pending });
+      else this.emit([]);
+    });
+    this.brushesLoaded = run.catch(() => void 0);
+    return run;
+  }
+  /** Resolves once the brush library has been read (user brushes kept in storage are listed from then on). */
+  whenBrushesLoaded() {
+    return this.brushesLoaded;
+  }
+  /** A library brush by id, as the engine paints it (`undefined` when unknown). */
   getBrush(id) {
     const b = this.findBrush(id);
     return b ? _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, b, b) : void 0;
   }
-  requireBrush(id) {
-    const b = this.findBrush(id);
-    if (!b) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
-    return b;
+  /** 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', _365 => _365.findEntry, 'call', _366 => _366(id), 'optionalAccess', _367 => _367.spec]);
+    return spec ? copyJSON(spec) : void 0;
   }
   /**
-   * Chooses the active brush (`id`: a library brush) and / or changes its settings. Editor state,
-   * not an undo step. Returns the active brush.
+   * Chooses the active brush (`id`: a library brush) and / or changes its engine settings. Editor
+   * state, not an undo step. Returns the active brush. `setBrushFacets` changes it by facets.
    */
   setBrush(update = {}) {
     const { id, ...changes } = update;
-    const base = id !== void 0 ? this.requireBrush(id) : this.brush;
+    const entry = id !== void 0 ? this.requireEntry(id) : null;
+    const base = entry ? entry.brush : this.brush;
+    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 = _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
-    if (base.builtin && !Object.keys(changes).length) next.builtin = true;
+    this.useBrush(next, unchanged ? baseSpec : brushSpecOf(next, baseSpec), unchanged && base.builtin === true);
+    return this.brush;
+  }
+  /**
+   * Chooses the active brush (`id`: a library brush) and / or lays a facet patch over it (objects
+   * merge, lists and values replace, as the library's `update_brush` does). Editor state, not an
+   * undo step. `unset` removes whole facets first. Returns the active brush as the engine paints
+   * it, its facets, and what was clamped or dropped.
+   */
+  setBrushFacets(patch = {}, id, unset = []) {
+    const entry = id !== void 0 ? this.requireEntry(id) : null;
+    const unchanged = !Object.keys(patch).length && !unset.length;
+    const problems = [];
+    const base = copyJSON(entry ? entry.spec : this.brushSpec);
+    for (const k of unset) delete base[k];
+    const spec = this.readBrushPatch(base, patch, problems);
+    this.useBrush(unchanged && entry ? entry.brush : _chunk34KLWUH4cjs.resolveBrush.call(void 0, spec), spec, unchanged && _optionalChain([entry, 'optionalAccess', _368 => _368.builtin]) === true);
+    return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
+  }
+  /**
+   * Makes `spec` (a whole facet brush, as the brush editor edits it) the active brush, keeping the
+   * active brush's id. Editor state, not an undo step. Returns it as the engine paints it, its
+   * facets, and what was clamped or dropped.
+   */
+  setBrushSpec(spec) {
+    const problems = [];
+    const paint = _optionalChain([spec, 'access', _369 => _369.colour, 'optionalAccess', _370 => _370.default]);
+    if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
+    let next;
+    try {
+      next = _chunk34KLWUH4cjs.normalizeBrushSpec.call(void 0, { ...spec, id: this.brush.id }, problems);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    this.useBrush(_chunk34KLWUH4cjs.resolveBrush.call(void 0, next), next, false);
+    return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
+  }
+  /**
+   * The engine settings a facet patch changes on a brush (`from`: a library brush id or a brush as
+   * painted; default the active brush), as `paintStroke`'s and `updateStroke`'s `brush` take them.
+   */
+  brushChanges(patch, from) {
+    const entry = typeof from === "string" ? this.requireEntry(from) : null;
+    const base = entry ? entry.brush : typeof from === "object" ? _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, from, from) : this.brush;
+    const spec = entry ? entry.spec : typeof from === "object" ? _chunk34KLWUH4cjs.migrateBrushV1.call(void 0, base) : this.brushSpec;
+    return engineChanges(base, _chunk34KLWUH4cjs.resolveBrush.call(void 0, this.readBrushPatch(spec, patch, [])));
+  }
+  readBrushPatch(base, patch, problems) {
+    const { id: _id, name, ...rest } = patch;
+    const paint = _optionalChain([rest, 'access', _371 => _371.colour, 'optionalAccess', _372 => _372.default]);
+    if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
+    try {
+      return _chunk34KLWUH4cjs.normalizeBrushSpec.call(void 0, _chunk34KLWUH4cjs.mergeBrushPatch.call(void 0, base, { ...rest, ...name !== void 0 ? { name } : {} }), problems);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+  }
+  useBrush(next, spec, builtin) {
+    next = _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, next, next);
+    if (builtin) next.builtin = true;
     else delete next.builtin;
     this.brush = next;
+    this.brushSpec = { ...copyJSON(spec), id: next.id, name: next.name };
+    this.pendingBrushId = null;
     this.emit([]);
     if (next.engine === "sticker" && next.sticker.stamps.some((r) => !_chunkJSDND7DFcjs.editorStampOf.call(void 0, r))) void this.prepareStickers(next.sticker.stamps).catch(() => this.emit([]));
-    return this.brush;
   }
-  /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
-  saveBrush(options) {
+  /**
+   * Saves the active brush (or `brush`, engine settings on top of it) into the brush library under
+   * `id` / `name`, replacing a user brush with that id. Built-in ids are refused. Resolves with the
+   * saved brush.
+   */
+  async saveBrush(options) {
     if (!_chunkHS6QDWDFcjs.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 (_chunkHS6QDWDFcjs.BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
-    const source = options.brush ? _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, options.brush, this.brush) : this.brush;
-    const saved = _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, { ...source, id: options.id, name: _nullishCoalesce(options.name, () => ( source.name)) });
-    delete saved.builtin;
-    const i = this.userBrushes.findIndex((b) => b.id === options.id);
-    if (i >= 0) this.userBrushes[i] = saved;
-    else this.userBrushes.push(saved);
-    this.library = null;
-    this.emit([]);
-    return saved;
-  }
-  removeBrush(id) {
-    if (_chunkHS6QDWDFcjs.BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
-    const i = this.userBrushes.findIndex((b) => b.id === id);
-    if (i < 0) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
-    this.userBrushes.splice(i, 1);
-    this.library = null;
-    this.emit([]);
-  }
-  /** The user's saved brushes. */
+    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(_chunkHS6QDWDFcjs.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);
+  }
+  /** Removes a user brush from the brush library (built-in brushes can't be removed). */
+  async removeBrush(id) {
+    if (this.brushLibrary.isBuiltin(id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
+    if (!await libraryCall(() => this.brushLibrary.remove(id))) throw new PaintEditorError(`Unknown brush "${id}". Call list_brush_presets for the ids.`);
+    await this.refreshBrushes();
+  }
+  /** The user's saved brushes, as the engine paints them. */
   getUserBrushes() {
-    return this.userBrushes.map((b) => _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, b, b));
+    return this.brushEntries.filter((e) => !e.builtin).map((e) => _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, e.brush, e.brush));
   }
-  /** A brush library file of the given brushes (default: the user's brushes). */
+  /** A brush library file (version 2) of the given brushes (default: the user's brushes). */
   exportBrushes(ids) {
-    const list = ids ? ids.map((id) => this.requireBrush(id)) : this.userBrushes;
-    return { format: "pixerate-brushes", version: 1, brushes: list.map(_chunkHS6QDWDFcjs.brushToJSON) };
+    return libraryCall(() => this.brushLibrary.exportFile(ids));
   }
   /**
-   * Adds the brushes of a library file to the user library. A brush whose id is taken is skipped
-   * unless `replace` (built-in ids are always skipped). Returns the ids added and the problems.
+   * Adds the brushes of a library file (version 1 or 2) to the brush library. A brush whose id is
+   * taken is skipped unless `replace` (built-in ids are always skipped). Resolves with the ids
+   * added or replaced, the ids skipped and the problems.
    */
-  importBrushes(file, options = {}) {
-    const problems = [];
-    let list;
-    try {
-      list = _chunkHS6QDWDFcjs.parseBrushLibrary.call(void 0, file, problems);
-    } catch (e) {
-      throw new PaintEditorError(e.message);
-    }
-    const added = [];
-    const skipped = [];
-    for (const b of list) {
-      if (_chunkHS6QDWDFcjs.BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
-        skipped.push(b.id);
-        problems.push(`"${b.id}" is a built-in brush id; rename it to import it.`);
-        continue;
-      }
-      const i = this.userBrushes.findIndex((x) => x.id === b.id);
-      if (i >= 0 && !options.replace) {
-        skipped.push(b.id);
-        continue;
-      }
-      if (i >= 0) this.userBrushes[i] = b;
-      else this.userBrushes.push(b);
-      added.push(b.id);
-    }
-    if (added.length) {
-      this.library = null;
-      this.emit([]);
-    }
-    return { added, skipped, problems };
+  async importBrushes(file, options = {}) {
+    const r = await libraryCall(() => this.brushLibrary.importFile(file, { overwrite: !!options.replace }));
+    await this.refreshBrushes();
+    return { added: [...r.added, ...r.replaced], skipped: r.skipped, problems: r.problems };
   }
   /** A thumbnail of a brush: a test stroke on the current paper. */
   brushThumbnail(id, options = {}) {
@@ -7076,20 +7265,20 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const brush = this.strokeBrush(init);
     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 (list_brushes category light), or set light.amount to 0 (set_brush).`);
+      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', _348 => _348.liveStrokes, 'optionalAccess', _349 => _349[layer.id]])) {
+    if (_optionalChain([doc, 'access', _373 => _373.liveStrokes, 'optionalAccess', _374 => _374[layer.id]])) {
       const why = liveStrokeRefusal(brush);
       if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
     }
-    if (_optionalChain([doc, 'access', _350 => _350.liveStrokes, 'optionalAccess', _351 => _351[layer.id]]) && _optionalChain([effect, 'optionalAccess', _352 => _352.source, 'access', _353 => _353.live])) {
+    if (_optionalChain([doc, 'access', _375 => _375.liveStrokes, 'optionalAccess', _376 => _376[layer.id]]) && _optionalChain([effect, 'optionalAccess', _377 => _377.source, 'access', _378 => _378.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', _354 => _354.stickers, 'optionalAccess', _355 => _355[layer.id], 'optionalAccess', _356 => _356.length]));
+    const stickerLayer = Boolean(_optionalChain([doc, 'access', _379 => _379.stickers, 'optionalAccess', _380 => _380[layer.id], 'optionalAccess', _381 => _381.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) {
@@ -7129,7 +7318,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', _357 => _357.pixels]), () => ( null))
+        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _382 => _382.pixels]), () => ( null))
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
@@ -7140,7 +7329,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     let color = init.color === void 0 ? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
-    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _358 => _358.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _383 => _383.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;
@@ -7173,9 +7362,9 @@ 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', _359 => _359.thick, 'optionalAccess', _360 => _360[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _384 => _384.thick, 'optionalAccess', _385 => _385[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', _361 => _361.light, 'optionalAccess', _362 => _362[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _363 => _363.light, 'optionalAccess', _364 => _364[layer.id]]), () => ( emptyLight())) } : null,
+      light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || _optionalChain([doc, 'access', _386 => _386.light, 'optionalAccess', _387 => _387[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _388 => _388.light, 'optionalAccess', _389 => _389[layer.id]]), () => ( emptyLight())) } : null,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc), art: this.stickerArt.get } : void 0,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
@@ -7214,12 +7403,12 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
-        if (_optionalChain([this, 'access', _365 => _365.session, 'optionalAccess', _366 => _366.init, 'access', _367 => _367.wet])) {
+        if (_optionalChain([this, 'access', _390 => _390.session, 'optionalAccess', _391 => _391.init, 'access', _392 => _392.wet])) {
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
-        const ch = _optionalChain([this, 'access', _368 => _368.session, 'optionalAccess', _369 => _369.thickChannels, 'call', _370 => _370()]);
+        const ch = _optionalChain([this, 'access', _393 => _393.session, 'optionalAccess', _394 => _394.thickChannels, 'call', _395 => _395()]);
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
@@ -7231,7 +7420,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', _371 => _371.result, 'optionalAccess', _372 => _372.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
+        if (!cancelled && _optionalChain([s, 'access', _396 => _396.result, 'optionalAccess', _397 => _397.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           if (this.wetOp) {
             const snap = this.wetOp.before;
@@ -7246,7 +7435,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         }
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _373 => _373.result, 'optionalAccess', _374 => _374.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _398 => _398.result, 'optionalAccess', _399 => _399.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 });
@@ -7257,8 +7446,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', _375 => _375.doc, 'access', _376 => _376.stickers, 'optionalAccess', _377 => _377[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
-        const wetLight = wetStroke && _optionalChain([this, 'access', _378 => _378.wet, 'access', _379 => _379.world, 'optionalAccess', _380 => _380.hasLane, 'call', _381 => _381(l.id)]) ? this.wet.world.lightDisplay(l.id) : null;
+        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _400 => _400.doc, 'access', _401 => _401.stickers, 'optionalAccess', _402 => _402[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
+        const wetLight = wetStroke && _optionalChain([this, 'access', _403 => _403.wet, 'access', _404 => _404.world, 'optionalAccess', _405 => _405.hasLane, 'call', _406 => _406(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: _chunkDPYAO5U6cjs.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);
       }
@@ -7288,18 +7477,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', _382 => _382.result, 'optionalAccess', _383 => _383.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _407 => _407.result, 'optionalAccess', _408 => _408.bounds]), () => ( null)));
         const l = _chunkDPYAO5U6cjs.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', _384 => _384.wet, 'access', _385 => _385.world, 'optionalAccess', _386 => _386.hasLane, 'call', _387 => _387(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
+        const lit = _nullishCoalesce(s.lightChannel(), () => ( (s.init.wet && _optionalChain([this, 'access', _409 => _409.wet, 'access', _410 => _410.world, 'optionalAccess', _411 => _411.hasLane, 'call', _412 => _412(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
         out = withLiveStroke({
           ...out,
           layers: _chunkDPYAO5U6cjs.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', _388 => _388.stickers, 'optionalAccess', _389 => _389[l.id]]), () => ( [])), ...sprayed] } } : {},
+          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _413 => _413.stickers, 'optionalAccess', _414 => _414[l.id]]), () => ( [])), ...sprayed] } } : {},
           ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {}
         }, stroke);
       }
@@ -7358,7 +7547,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _390 => _390.strokeIds, 'optionalAccess', _391 => _391.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _415 => _415.strokeIds, 'optionalAccess', _416 => _416.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.`);
@@ -7372,7 +7561,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', _392 => _392.paint, 'optionalAccess', _393 => _393.type]) === "effect" && !this.effectPaintImage(s.paint)) {
+        if (_optionalChain([s, 'access', _417 => _417.paint, 'optionalAccess', _418 => _418.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.`);
         }
       }
@@ -7430,7 +7619,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', _394 => _394.doc, 'access', _395 => _395.light, 'optionalAccess', _396 => _396[l.id]]));
+    const info = lightInfo(_optionalChain([this, 'access', _419 => _419.doc, 'access', _420 => _420.light, 'optionalAccess', _421 => _421[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) } };
   }
@@ -7481,7 +7670,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', _397 => _397.doc, 'access', _398 => _398.thick, 'optionalAccess', _399 => _399[id]]);
+    const ch = _optionalChain([this, 'access', _422 => _422.doc, 'access', _423 => _423.thick, 'optionalAccess', _424 => _424[id]]);
     if (!ch) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
@@ -7507,7 +7696,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const w = Math.round(width * scale);
     const h = Math.round(height * scale);
     if (w > 16384 || h > 16384) throw new PaintEditorError(`At scale ${scale} the canvas would be ${w}\xD7${h}; the limit is 16384 px per side. Use a smaller scale.`);
-    const target = new _PaintEditorController({ width: w, height: h, dpi: dpi * scale, brushes: this.userBrushes, wet: this.wetOptions });
+    const target = new _PaintEditorController({ width: w, height: h, dpi: dpi * scale, brushLibrary: this.brushLibrary, wet: this.wetOptions });
+    target.brushEntries = this.brushEntries;
     const paper = { ...this.doc.paper, scale: Math.min(8, this.doc.paper.scale * scale) };
     target.adopt({ state: { canvas: target.doc.canvas, paper, layers: emptiedLayers(this.doc.layers), activeLayerId: this.doc.activeLayerId, strokes: [] }, extensions: {}, problems: [] });
     target.lighting = { ...this.lighting };
@@ -7562,6 +7752,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** Stops the wet simulation's worker threads (call when the editor goes away). */
   dispose() {
+    this.unsubscribeLibrary();
     this.wet.destroy();
     this.effectsRenderer.dispose();
     this.effectPaintPixels.clear();
@@ -7589,7 +7780,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', _400 => _400.message]), () => ( _chunkKBYB7OWBcjs.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', _425 => _425.message]), () => ( _chunkKBYB7OWBcjs.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`,
@@ -7674,7 +7865,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', _401 => _401.wet, 'access', _402 => _402.world, 'optionalAccess', _403 => _403.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
+    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _426 => _426.wet, 'access', _427 => _427.world, 'optionalAccess', _428 => _428.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) {
@@ -7743,7 +7934,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (override) return Array.from(override).reduce((ls, [id, surface]) => _chunkDPYAO5U6cjs.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', _404 => _404.liveLayers, 'optionalAccess', _405 => _405.key]) === live.surface) return this.liveLayers.layers;
+    if (_optionalChain([this, 'access', _429 => _429.liveLayers, 'optionalAccess', _430 => _430.key]) === live.surface) return this.liveLayers.layers;
     const layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
@@ -7766,7 +7957,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', _406 => _406.tracingCache, 'optionalAccess', _407 => _407.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _431 => _431.tracingCache, 'optionalAccess', _432 => _432.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 };
@@ -7793,8 +7984,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', _408 => _408.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _409 => _409[id]]);
-      const l = ch && _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _410 => _410.layer]);
+      const ch = _optionalChain([live, 'optionalAccess', _433 => _433.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _434 => _434[id]]);
+      const l = ch && _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _435 => _435.layer]);
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
@@ -7814,13 +8005,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (!ids.size) return layers;
     let out = layers;
     for (const id of ids) {
-      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _411 => _411.layer]);
+      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _436 => _436.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', _412 => _412.liveThick, 'optionalAccess', _413 => _413.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _414 => _414.doc, 'access', _415 => _415.thick, 'optionalAccess', _416 => _416[id]]));
+      const glowed = cache.glow(l.surface, light[id], _optionalChain([this, 'access', _437 => _437.liveThick, 'optionalAccess', _438 => _438.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _439 => _439.doc, 'access', _440 => _440.thick, 'optionalAccess', _441 => _441[id]]));
       if (glowed !== l.surface) out = _chunkDPYAO5U6cjs.mapLayer.call(void 0, out, id, () => ({ ...l, surface: glowed }));
-      const committed = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _417 => _417.layer]);
+      const committed = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _442 => _442.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 } });
     }
@@ -7832,7 +8023,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', _418 => _418.liveThick, 'optionalAccess', _419 => _419.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _420 => _420.doc, 'access', _421 => _421.thick, 'optionalAccess', _422 => _422[l.id]]);
+        const thick = !committed && _optionalChain([this, 'access', _443 => _443.liveThick, 'optionalAccess', _444 => _444.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _445 => _445.doc, 'access', _446 => _446.thick, 'optionalAccess', _447 => _447[l.id]]);
         out.push({ surface: l.surface, offset: l.offset, opacity: opacity * l.opacity, ...thick ? { thick } : {} });
       }
     }
@@ -7861,7 +8052,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _423 => _423.layer]), () => ( this.requireLayer(id))));
+      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _448 => _448.layer]), () => ( this.requireLayer(id))));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
     const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
@@ -7877,7 +8068,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', _424 => _424.live, 'optionalAccess', _425 => _425.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _449 => _449.live, 'optionalAccess', _450 => _450.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -7942,7 +8133,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (Object.keys(stickers).length) ext.stickers = stickers;
     else delete ext.stickers;
     const liveStrokes = {};
-    for (const [id, list] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) if (_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id)) liveStrokes[id] = list.map((x) => JSON.parse(JSON.stringify(x)));
+    for (const [id, list] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) if (_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id)) liveStrokes[id] = list.map(strokeToJSON);
     if (Object.keys(liveStrokes).length) ext.liveStrokes = liveStrokes;
     else delete ext.liveStrokes;
     const light = {};
@@ -7956,7 +8147,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const spills = Object.fromEntries(Object.entries(this.lightSpills).filter(([id]) => _chunkDPYAO5U6cjs.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([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _426 => _426.layer])));
+    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _451 => _451.layer])));
     if (effectLayers) ext.effectLayers = effectLayers;
     else delete ext.effectLayers;
     if (this.doc.paperEffect) ext.paperEffect = paperEffectToJSON(this.doc.paperEffect);
@@ -7980,7 +8171,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
             const stamp = _chunkJSDND7DFcjs.editorStampOf.call(void 0, ref2);
             const { stamp: _old, ...rest } = x;
             return [{ ...rest, ref: ref2, ...stamp ? { stamp } : {} }];
-          } catch (e6) {
+          } catch (e8) {
             return [];
           }
         });
@@ -7992,7 +8183,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _427 => _427.layer])) || !Array.isArray(list)) continue;
+        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _452 => _452.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;
@@ -8002,7 +8193,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _428 => _428.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _453 => _453.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.`);
@@ -8022,7 +8213,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       for (const [id, v] of Object.entries(ext.lightSpill)) {
         try {
           if (_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id)) this.lightSpills[id] = normalizeLightSpill(_nullishCoalesce(v, () => ( {})));
-        } catch (e7) {
+        } catch (e9) {
           problems.push(`The light spill of layer "${id}" could not be read; it takes the defaults.`);
         }
       }
@@ -8030,7 +8221,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _429 => _429.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _454 => _454.layer]))) continue;
         try {
           light[id] = lightFromJSON(v);
         } catch (e) {
@@ -8066,7 +8257,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', _430 => _430.exec, 'call', _431 => _431(s.id), 'optionalAccess', _432 => _432[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _455 => _455.exec, 'call', _456 => _456(s.id), 'optionalAccess', _457 => _457[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
@@ -8074,7 +8265,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', _433 => _433.exec, 'call', _434 => _434(s.id), 'optionalAccess', _435 => _435[1]]), () => ( 0)));
+        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _458 => _458.exec, 'call', _459 => _459(s.id), 'optionalAccess', _460 => _460[1]]), () => ( 0)));
         if (n >= this.strokeCounter) this.strokeCounter = n + 1;
       }
     }
@@ -8173,8 +8364,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layers = toStandard(dried);
     const result = _chunkJFHBXNR2cjs.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', _436 => _436.find, 'call', _437 => _437((m) => m.id === mode), 'optionalAccess', _438 => _438.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _439 => _439.find, 'call', _440 => _440((m) => m.id === _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _441 => _441.label]), () => ( _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _461 => _461.find, 'call', _462 => _462((m) => m.id === mode), 'optionalAccess', _463 => _463.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _464 => _464.find, 'call', _465 => _465((m) => m.id === _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _466 => _466.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).`);
@@ -8296,7 +8487,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', _442 => _442.name, 'optionalAccess', _443 => _443.trim, 'call', _444 => _444()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _467 => _467.name, 'optionalAccess', _468 => _468.trim, 'call', _469 => _469()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -8375,7 +8566,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', _445 => _445.exec, 'call', _446 => _446(ref2.id), 'optionalAccess', _447 => _447[1]]), () => ( 0)));
+          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _470 => _470.exec, 'call', _471 => _471(ref2.id), 'optionalAccess', _472 => _472[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -8386,7 +8577,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       guides.stencils = [];
       r.stencils.forEach((raw2, i) => {
         try {
-          const id = typeof _optionalChain([raw2, 'optionalAccess', _448 => _448.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
+          const id = typeof _optionalChain([raw2, 'optionalAccess', _473 => _473.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;
@@ -8409,13 +8600,13 @@ 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', _449 => _449.exec, 'call', _450 => _450(st.id), 'optionalAccess', _451 => _451[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', _474 => _474.exec, 'call', _475 => _475(st.id), 'optionalAccess', _476 => _476[1]]), () => ( 0))));
     return n + 1;
   }
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
-    const stickers = _optionalChain([this, 'access', _452 => _452.doc, 'access', _453 => _453.stickers, 'optionalAccess', _454 => _454[l.id]]);
-    if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (list_brushes category sticker).`);
+    const stickers = _optionalChain([this, 'access', _477 => _477.doc, 'access', _478 => _478.stickers, 'optionalAccess', _479 => _479[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 };
   }
   // --- The sticker library ---------------------------------------------------------
@@ -8473,7 +8664,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return [];
     this.requireLayer(id);
-    return (_nullishCoalesce(_optionalChain([this, 'access', _455 => _455.doc, 'access', _456 => _456.stickers, 'optionalAccess', _457 => _457[id]]), () => ( []))).map((s) => ({ ...s }));
+    return (_nullishCoalesce(_optionalChain([this, 'access', _480 => _480.doc, 'access', _481 => _481.stickers, 'optionalAccess', _482 => _482[id]]), () => ( []))).map((s) => ({ ...s }));
   }
   /**
    * Replaces a layer's stickers and redraws its pixels from them (one undo step). With `dirty`,
@@ -8494,7 +8685,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', _458 => _458.stickerPreview, 'optionalAccess', _459 => _459.shown]) === this.doc ? this.stickerPreview.base : null;
+    return _optionalChain([this, 'access', _483 => _483.stickerPreview, 'optionalAccess', _484 => _484.shown]) === this.doc ? this.stickerPreview.base : null;
   }
   readStickerUpdate(update) {
     try {
@@ -8509,7 +8700,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', _460 => _460.doc, 'access', _461 => _461.stickers, 'optionalAccess', _462 => _462[id]]), () => ( [])), x, y, this.stickerArt.get);
+    const hit = stickerAt(_nullishCoalesce(_optionalChain([this, 'access', _485 => _485.doc, 'access', _486 => _486.stickers, 'optionalAccess', _487 => _487[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. */
@@ -8565,8 +8756,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', _463 => _463.doc, 'access', _464 => _464.stickers, 'optionalAccess', _465 => _465[layer.id]]);
-    if (!_optionalChain([existing, 'optionalAccess', _466 => _466.length])) {
+    const existing = _optionalChain([this, 'access', _488 => _488.doc, 'access', _489 => _489.stickers, 'optionalAccess', _490 => _490[layer.id]]);
+    if (!_optionalChain([existing, 'optionalAccess', _491 => _491.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();
@@ -8583,7 +8774,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       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 };
     });
-    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _467 => _467.length]) ? added.map(stickerRect) : void 0);
+    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _492 => _492.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). */
@@ -8622,20 +8813,20 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   liveStrokeLayer(layerId, what) {
     const l = this.wetLayer(layerId, what);
-    const strokes = _optionalChain([this, 'access', _468 => _468.doc, 'access', _469 => _469.liveStrokes, 'optionalAccess', _470 => _470[l.id]]);
+    const strokes = _optionalChain([this, 'access', _493 => _493.doc, 'access', _494 => _494.liveStrokes, 'optionalAccess', _495 => _495[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', _471 => _471.doc, 'access', _472 => _472.liveStrokes, 'optionalAccess', _473 => _473[layerId]]));
+    return Boolean(_optionalChain([this, 'access', _496 => _496.doc, 'access', _497 => _497.liveStrokes, 'optionalAccess', _498 => _498[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', _474 => _474.doc, 'access', _475 => _475.liveStrokes, 'optionalAccess', _476 => _476[l.id]])) return this.describeLayer(l);
-    if (_optionalChain([this, 'access', _477 => _477.doc, 'access', _478 => _478.stickers, 'optionalAccess', _479 => _479[l.id], 'optionalAccess', _480 => _480.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
+    if (_optionalChain([this, 'access', _499 => _499.doc, 'access', _500 => _500.liveStrokes, 'optionalAccess', _501 => _501[l.id]])) return this.describeLayer(l);
+    if (_optionalChain([this, 'access', _502 => _502.doc, 'access', _503 => _503.stickers, 'optionalAccess', _504 => _504[l.id], 'optionalAccess', _505 => _505.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));
@@ -8648,7 +8839,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _481 => _481.layer]);
+      const layer = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _506 => _506.layer]);
       if (index >= 0 && isPixelLayer(layer)) return { layer, strokes, index };
     }
     const baked = this.doc.strokes.some((x) => x.id === id);
@@ -8743,9 +8934,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', _482 => _482.liveStrokes, 'optionalAccess', _483 => _483[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
+      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _507 => _507.liveStrokes, 'optionalAccess', _508 => _508[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', _484 => _484.liveStrokes, 'optionalAccess', _485 => _485[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
+      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _509 => _509.liveStrokes, 'optionalAccess', _510 => _510[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
     }
     this.commit(ids.length === 1 ? "Remove stroke" : "Remove strokes", doc);
     return { removed: [...ids], bounds };
@@ -8813,7 +9004,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   withLiveStrokes(doc, layer, list, dirty) {
     if (_chunkDPYAO5U6cjs.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([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _486 => _486.layer]);
+    const current = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _511 => _511.layer]);
     const surface = this.drawLiveStrokes(_nullishCoalesce(current, () => ( layer)), list, dirty);
     const next = { ...doc, layers: _chunkDPYAO5U6cjs.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))) } });
@@ -8891,7 +9082,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _487 => _487.layer]);
+      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _512 => _512.layer]);
       if (isPixelLayer(l) && l.surface === a.base) layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, layers, id, () => ({ ...l, surface: a.surface }));
     }
     return layers;
@@ -8901,7 +9092,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([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _488 => _488.layer]);
+      const layer = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _513 => _513.layer]);
       const live = strokes.filter(isLiveEffect);
       if (!isPixelLayer(layer) || !live.length) continue;
       layers.push({ layer, strokes });
@@ -9026,13 +9217,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return this.withEffectTime(time, () => this.compositePixels(options));
   }
   // --- Stencils --------------------------------------------------------------------
-  __init172() {this.stencilCache = null}
-  __init173() {this.nextStencilId = 1}
+  __init174() {this.stencilCache = null}
+  __init175() {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', _489 => _489.stencilCache, 'optionalAccess', _490 => _490.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
+    if (_optionalChain([this, 'access', _514 => _514.stencilCache, 'optionalAccess', _515 => _515.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
     const mask = stencilMask(stencils, width, height);
     this.stencilCache = { key: stencils, size, mask };
     return mask;
@@ -9094,7 +9285,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', _491 => _491.trim, 'call', _492 => _492()])) out.name = name.trim();
+    if (_optionalChain([name, 'optionalAccess', _516 => _516.trim, 'call', _517 => _517()])) out.name = name.trim();
     if (p.type === "gradient") out.paint = p;
     return out;
   }
@@ -9145,8 +9336,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * and a fully mixed core of the Kubelka-Munk mix (see `MixingPad.mix`). With `setColor` the
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
-  mixOnPad(paints, options = {}) {
-    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _493 => _493.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _494 => _494.parts]) }));
+  mixOnPad(paints2, options = {}) {
+    const parsed = (_nullishCoalesce(paints2, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _518 => _518.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _519 => _519.parts]) }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -9235,7 +9426,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
-    const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _495 => _495.layer]);
+    const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _520 => _520.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
 }, _class19.__initStatic(), _class19);
@@ -9257,7 +9448,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', _496 => _496.paint, 'optionalAccess', _497 => _497.type]) === "effect" && s.paint.live === true;
+  return _optionalChain([s, 'access', _521 => _521.paint, 'optionalAccess', _522 => _522.type]) === "effect" && s.paint.live === true;
 }
 function framePaint(p, t) {
   return { ...p, time: p.time + t };
@@ -9282,7 +9473,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', _498 => _498.liveStrokes, 'optionalAccess', _499 => _499[stroke.layerId]]);
+  const list = _optionalChain([doc, 'access', _523 => _523.liveStrokes, 'optionalAccess', _524 => _524[stroke.layerId]]);
   return list ? { ...doc, liveStrokes: { ...doc.liveStrokes, [stroke.layerId]: [...list, stroke] } } : doc;
 }
 function shiftDocument(doc, dx, dy) {
@@ -9309,9 +9500,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', _500 => _500.data, 'optionalAccess', _501 => _501.stickers]) : void 0;
+      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _525 => _525.data, 'optionalAccess', _526 => _526.stickers]) : void 0;
       if (list) return { ...e, data: { ...e.data, stickers: moveStickers(list) } };
-      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _502 => _502.data, 'optionalAccess', _503 => _503.strokes]) : void 0;
+      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _527 => _527.data, 'optionalAccess', _528 => _528.strokes]) : void 0;
       return strokes ? { ...e, data: { ...e.data, strokes: strokes.map(moveStroke) } } : e;
     });
   }
@@ -9393,8 +9584,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', _504 => _504[0], 'optionalAccess', _505 => _505.t]);
-  const t1 = _optionalChain([points, 'access', _506 => _506[points.length - 1], 'optionalAccess', _507 => _507.t]);
+  const t0 = _optionalChain([points, 'access', _529 => _529[0], 'optionalAccess', _530 => _530.t]);
+  const t1 = _optionalChain([points, 'access', _531 => _531[points.length - 1], 'optionalAccess', _532 => _532.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -9448,7 +9639,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _508 => _508.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _509 => _509.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _533 => _533.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _534 => _534.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -9495,8 +9686,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _510 => _510.replay, 'access', _511 => _511.strokeIds, 'optionalAccess', _512 => _512.includes, 'call', _513 => _513(s.id)]));
-        const first = _optionalChain([source, 'access', _514 => _514[0], 'optionalAccess', _515 => _515.points, 'access', _516 => _516[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _535 => _535.replay, 'access', _536 => _536.strokeIds, 'optionalAccess', _537 => _537.includes, 'call', _538 => _538(s.id)]));
+        const first = _optionalChain([source, 'access', _539 => _539[0], 'optionalAccess', _540 => _540.points, 'access', _541 => _541[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);
@@ -10140,7 +10331,7 @@ function createPaintGuideTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Mix paints on the pad", ...WRITE2 },
-      handler: ({ paints, x, y, radius, passes, clear, setColor }) => c.mixOnPad(paints, { x, y, radius, passes, clear, setColor })
+      handler: ({ paints: paints2, x, y, radius, passes, clear, setColor }) => c.mixOnPad(paints2, { x, y, radius, passes, clear, setColor })
     },
     {
       name: "save_mixing_pad",
@@ -10571,254 +10762,6 @@ var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint:
 var EMPTY3 = { type: "object", properties: {}, additionalProperties: false };
 var COLOR3 = { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: 'Colour #rrggbb, e.g. "#2a4b8d".' };
 var LAYER_ID4 = { type: "string", description: "Layer id from list_layers (default the active layer)." };
-var TIP = {
-  type: "object",
-  description: "The tip (the shared brush engine). Missing fields keep their current values.",
-  properties: {
-    size: { type: "number", minimum: 1, maximum: _chunkFQPUF2W2cjs.MAX_BRUSH_SIZE, description: "Diameter in pixels." },
-    hardness: { type: "number", minimum: 0, maximum: 1, description: "Edge hardness, 0 (soft) .. 1 (hard)." },
-    spacing: { type: "number", minimum: 0.01, maximum: 10, description: "Dab spacing as a fraction of the diameter (0.05 is smooth, 1 is dotted)." },
-    angle: { type: "number", minimum: -360, maximum: 360, description: "Tip angle in degrees, counter-clockwise; with rotation stroke or barrel it is added to the stroke direction or pen rotation." },
-    roundness: { type: "number", minimum: 0.01, maximum: 1, description: "Tip roundness: 1 round, lower is a flat ellipse (a pastel or chisel tip)." },
-    opacity: { type: "number", minimum: 0, maximum: 1, description: "Stroke opacity ceiling: overlapping dabs never exceed it." },
-    flow: { type: "number", minimum: 0, maximum: 1, description: "Build-up per dab towards the opacity (low flow builds up softly, like an airbrush)." },
-    smoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Position smoothing of the input, 0..0.95." },
-    pressureSize: { type: "boolean", description: "Pressure scales the size (down to dynamics.minSize)." },
-    pressureOpacity: { type: "boolean", description: "Pressure scales the opacity." },
-    blend: {
-      type: "string",
-      enum: _chunk2VX55NFMcjs.BLEND_MODES.map((m) => m.id),
-      description: "How paint combines with the layer. pigment mixes it in like real paint (blue into yellow gives green); multiply darkens like marker ink; watercolor glazes like a transparent wash; tint, highlight and shadow recolour, light and shade (see list_blend_modes)."
-    }
-  },
-  additionalProperties: false
-};
-var DYNAMICS = {
-  type: "object",
-  description: "Pen dynamics and jitter. Missing fields keep their current values.",
-  properties: {
-    minSize: { type: "number", minimum: 0, maximum: 1, description: "Size at zero pressure as a fraction of the full size (when pressureSize)." },
-    pressureFlow: { type: "number", minimum: 0, maximum: 1, description: "How much pressure scales flow." },
-    tiltSize: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down widens the tip (up to 2.5\xD7)." },
-    tiltRoundness: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down flattens the tip along the tilt (side-of-the-pencil shading)." },
-    tiltOpacity: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down lightens the mark." },
-    velocitySize: { type: "number", minimum: -1, maximum: 1, description: "Positive grows the tip on fast strokes, negative thins it (needs point times t)." },
-    velocityOpacity: { type: "number", minimum: -1, maximum: 1, description: "Positive darkens fast marks, negative lightens them (needs point times t)." },
-    sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change per dab." },
-    angleJitter: { type: "number", minimum: 0, maximum: 1, description: "Random angle per dab, as a fraction of \xB1180\xB0." },
-    opacityJitter: { type: "number", minimum: 0, maximum: 1, description: "Random opacity drop per dab." },
-    scatter: { type: "number", minimum: 0, maximum: 4, description: "Random offset across the stroke, in diameters." }
-  },
-  additionalProperties: false
-};
-var MIXER = {
-  type: "object",
-  description: "Mixer engine settings (the Mixer Brush). Missing fields keep their current values.",
-  properties: {
-    wet: { type: "number", minimum: 0, maximum: 1, description: "Pick-up ratio: how much canvas colour each dab picks up, 0 (dry) .. 1." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "How much paint the reservoir holds; below 1 it drains per dab, so long strokes run dry." },
-    mix: { type: "number", minimum: 0, maximum: 1, description: "Mix ratio: how far each dab's paint moves from the reservoir towards the picked-up colour." },
-    loadEachStroke: { type: "boolean", description: "Refill the reservoir with the colour before each stroke." },
-    cleanEachStroke: { type: "boolean", description: "Empty the pickup well after each stroke." },
-    mixing: { type: "string", enum: [..._chunkFQPUF2W2cjs.MIXING_MODELS], description: "rgb: RGB averages. pigment: mixes like paint (Kubelka-Munk)." }
-  },
-  additionalProperties: false
-};
-var MIXING = { type: "string", enum: [..._chunkFQPUF2W2cjs.MIXING_MODELS], description: "pigment: mixes like paint (Kubelka-Munk, blue and yellow make green); rgb: straight RGB averages." };
-var BEHAVIOR = {
-  type: "object",
-  description: "How the brush handles paint on the canvas (dab and mixer engines; on a mixer brush pickup, mix, dirty and mixing are its mixer wet, mix, !cleanEachStroke and mixing). Missing fields keep their current values.",
-  properties: {
-    pickup: { type: "number", minimum: 0, maximum: 1, description: "Pick-up ratio 0..1: how much of the paint under each dab the brush lifts and carries along (0: none, a dry brush)." },
-    mix: { type: "number", minimum: 0, maximum: 1, description: "Mix ratio 0..1: how much of the carried paint goes into what the brush lays down, against the brush's own colour (scaled by pickup)." },
-    dirty: { type: "boolean", description: "Dirty brush: keep the carried paint after the stroke, so the next stroke starts with the last colour it touched (needs pickup above 0). clean_mixer_brush wipes it." },
-    mixing: MIXING,
-    multicolor: {
-      type: "object",
-      description: "Multi-coloured brush (the older form of paint, the brush's own gradient: tip is across-tip, dab is distance in dabs or random). Read back from paint when it has a multi-colour equivalent. Missing fields keep their current values.",
-      properties: {
-        mode: { type: "string", enum: [..._chunkHS6QDWDFcjs.MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
-        colors: { type: "array", maxItems: 8, items: { ...COLOR3 }, description: "2..8 colours #rrggbb; fewer than 2 uses the paint colour and the secondary colour." },
-        order: { type: "string", enum: ["sequence", "random"], description: "dab mode: sequence runs through the colours in order, blending between them; random picks one per run of dabs (seeded)." },
-        length: { type: "integer", minimum: 1, maximum: 500, description: "dab mode: dabs per colour (default 12)." },
-        softness: { type: "number", minimum: 0, maximum: 1, description: "How softly neighbouring colours blend: 0 hard stripes or steps, 1 a smooth gradient." }
-      },
-      additionalProperties: false
-    }
-  },
-  additionalProperties: false
-};
-var BRUSH_PAINT = {
-  description: `The brush's own gradient paint, used instead of the editor's paint (null: the editor's paint). It is what the multi-colour settings became; stops may be "paint" / "secondary" for the editor's two colours.`,
-  anyOf: [_chunkFQPUF2W2cjs.PAINT_GRADIENT_JSON_SCHEMA, { type: "null", description: "No gradient of its own: the editor's paint." }]
-};
-var BLENDER = {
-  type: "object",
-  description: "Blender engine settings. Missing fields keep their current values.",
-  properties: {
-    strength: { type: "number", minimum: 0, maximum: 1, description: "How far each pixel under the tip moves towards the mix of the paint near it, per dab." },
-    distance: { type: "number", minimum: 0, maximum: 1, description: "Blend distance: how far away colours are mixed in, as a fraction of the tip diameter (0.35 default; higher blends wider and softer)." },
-    mixing: MIXING
-  },
-  additionalProperties: false
-};
-var SMUDGE = {
-  type: "object",
-  description: "Smudge engine settings. Missing fields keep their current values.",
-  properties: {
-    strength: { type: "number", minimum: 0, maximum: 1, description: "How strongly the dragged paint covers what is under the tip, per dab." },
-    length: { type: "number", minimum: 0, maximum: 1, description: "How far paint is dragged: the share of the carried paint kept from dab to dab (0.85 default; 1 drags it the whole stroke)." },
-    mixing: { ...MIXING, description: "rgb (default): smeared colours average; pigment: they mix like paint." }
-  },
-  additionalProperties: false
-};
-var WET_BRUSH = {
-  type: "object",
-  description: "Wet engine settings (watercolour, gouache and the wet tools). Missing fields keep their current values.",
-  properties: {
-    tool: {
-      type: "string",
-      enum: [..._chunkHS6QDWDFcjs.WET_TOOLS],
-      description: "paint: water and pigment (picks up and mixes wet paint by behavior.pickup / mix); water: clear water (with rewet it lifts dried paint); dry: a hair dryer, takes water; blow: pushes the water along the stroke; blend: evens out wet pigment; smudge: drags wet paint; blot: a tissue, takes wet paint up (erase wet)."
-    },
-    medium: { type: "string", enum: [..._chunkHS6QDWDFcjs.WET_MEDIA], description: "The medium: watercolor, gouache or oil. A layer takes the medium's wet settings the first time it holds wet paint (oil: thick, barely flows, stays wet long and blends into the wet paint it meets)." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (each stroke reloads)." },
-    thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner (water or solvent): more transparent, runnier paint." },
-    water: { type: "number", minimum: 0, maximum: 1, description: "Wetness: water laid per stroke, 0.2 a damp brush .. 1 a dripping one." },
-    pigment: { type: "number", minimum: 0, maximum: 1, description: "Pigment concentration: 0 clear water .. 1 straight from the tube." },
-    body: { type: "number", minimum: 0, maximum: 1, description: "Body: 0 a transparent watercolour (glazes) .. 1 opaque gouache (hides what is under it)." },
-    strength: { type: "number", minimum: 0, maximum: 1, description: "Strength of dry, blow, blend, smudge and blot." },
-    rewet: { type: "number", minimum: 0, maximum: 1, description: "How much dried paint the water lifts again: 0 none (staining) .. 1." }
-  },
-  additionalProperties: false
-};
-var IMPASTO_BRUSH = {
-  type: "object",
-  description: "Impasto engine settings (thick paint with relief, lit by set_lighting). Missing fields keep their current values.",
-  properties: {
-    tool: {
-      type: "string",
-      enum: [..._chunkHS6QDWDFcjs.IMPASTO_TOOLS],
-      description: "brush: thick paint with bristle ridges along the stroke; tube: blobs squeezed from the tube; knife: a palette knife that scrapes the relief flat and smears the paint; roller: a flat stippled band; gloop: a thick, glossy, rounded bead."
-    },
-    thickness: { type: "number", minimum: 0, maximum: 1, description: "How far the paint stands up." },
-    gloss: { type: "number", minimum: 0, maximum: 1, description: "Shine: 0 matte .. 1 wet-looking gloss." },
-    metallic: { type: "number", minimum: 0, maximum: 1, description: "Metallic paint: highlights take the paint colour (gold, copper, silver)." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the stroke thins and fades as the brush empties." },
-    thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner: flatter, more transparent paint." },
-    drag: { type: "number", minimum: 0, maximum: 1, description: "Knife and brush: how much of the paint under the tool is dragged along." },
-    rim: { type: "number", minimum: 0, maximum: 1, description: "Light paint (with light.amount): the bead's light is stronger where its surface turns away, as on backlit glass (default 0)." },
-    clarity: { type: "number", minimum: 0, maximum: 1, description: "Glassy paint: the middle of a bead lets the layers below show through while its edges stay solid (default 0). flatten_relief clears it." }
-  },
-  additionalProperties: false
-};
-var LIGHT_BRUSH = {
-  type: "object",
-  description: "Light paint: the light the brush lays with its colour, glowing in the paint's own colour and spilling onto its surroundings (set_light_spill). Dab, particle, bristle, Mixer Brush, impasto and wet paint brushes take it (wet light flows, pools, granulates and blooms with the pigment until the paint dries, then is ordinary light paint); wet tools other than paint lay none, and sticker brushes refuse light above 0. Missing fields keep their current values.",
-  properties: {
-    amount: { type: "number", minimum: 0, maximum: 1, description: "Light each dab lays, scaled by its coverage and flow (0 none, default; 1 full)." },
-    pressure: { type: "boolean", description: "Pressure scales the light (default false)." }
-  },
-  additionalProperties: false
-};
-var PARTICLE_BRUSH = {
-  type: "object",
-  description: "Particle engine settings (procedural brushes). Missing fields keep their current values.",
-  properties: {
-    kind: {
-      type: "string",
-      enum: [..._chunkHS6QDWDFcjs.PARTICLE_KINDS],
-      description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade; elastic: strands whose links keep a rest length, stretching when the pen is fast and snapping back; fuzzy: winding strings, each strand waving out of step with the others (always waves by at least 0.12 of the tip size)."
-    },
-    render: {
-      type: "string",
-      enum: [..._chunkHS6QDWDFcjs.PARTICLE_RENDERS],
-      description: "dot: a mark at each step (round, or dotTextures); line: each particle draws a continuous line; sequence: beads spaced along each path (round, or dotTextures); ribbon: the band between neighbouring particles' paths filled (ribbonFill), with the paths drawn as its edges at the mark size (flame, silk, smoke)."
-    },
-    count: { type: "integer", minimum: 1, maximum: 64, description: "Particles (flow: how many are thrown per tip of travel)." },
-    size: { type: "number", minimum: 0, maximum: 1, description: "Mark size as a fraction of the tip size (ribbon: the width of its edges)." },
-    spread: { type: "number", minimum: 0, maximum: 1, description: "How far apart the particles start, as a fraction of the tip size (ribbon: how wide it is)." },
-    stiffness: { type: "number", minimum: 0, maximum: 1, description: "Spring, string and elastic stiffness: stiff follows closely (elastic: snaps back faster), soft swings wide." },
-    damping: { type: "number", minimum: 0, maximum: 1, description: "How quickly motion dies down." },
-    speed: { type: "number", minimum: 0, maximum: 1, description: "Orbit and flow speed." },
-    gravity: { type: "number", minimum: -1, maximum: 1, description: "Pull downwards (negative: upwards)." },
-    life: { type: "number", minimum: 0, maximum: 1, description: "Flow particles: how long they live." },
-    interval: { type: "number", minimum: 0, maximum: 1, description: "Sequence: spacing of the beads." },
-    ribbonFill: { type: "number", minimum: 0, maximum: 1, description: "Ribbon: opacity of the fill between the paths, relative to their edges (default 0.5; 0 draws only the edges)." },
-    ribbonPairs: { type: "string", enum: [..._chunkHS6QDWDFcjs.RIBBON_PAIRS], description: "Ribbon: adjacent (default) joins each particle to its neighbour around the pen; first-last makes one band between the outermost two." },
-    waveAmplitude: { type: "number", minimum: 0, maximum: 1, description: "Wave: how far each particle's drawn place swings sideways to the stroke, as a fraction of the tip size (default 0: no wave). Works with every kind and render." },
-    waveLength: { type: "number", minimum: 4, maximum: 2e3, description: "Wave: wavelength in px of pen travel (default 60)." },
-    waveSpeed: { type: "number", minimum: 0, maximum: 1, description: "Wave: how fast the waves run, by stroke time (0 default: they stand still on the path; 1: about four a second, so slow strokes wave more). Strokes without times run at a nominal 0.5 px/ms." },
-    wavePhaseJitter: { type: "number", minimum: 0, maximum: 1, description: "Wave: how far out of step the particles' waves are (default 0: all in step, a wavy band; 1: random phases, tangled strands)." },
-    dotTextures: {
-      type: "array",
-      maxItems: _chunkHS6QDWDFcjs.MAX_DOT_TEXTURES,
-      items: { type: "string", enum: [..._chunkJSDND7DFcjs.STAMP_KINDS], description: "A stamp." },
-      description: `Dot and sequence renders: up to ${_chunkHS6QDWDFcjs.MAX_DOT_TEXTURES} sticker stamps (list_stickers) drawn instead of round marks; repeats are allowed (they weight the order). Empty (default): round marks.`
-    },
-    dotTextureOrder: { type: "string", enum: [..._chunkHS6QDWDFcjs.DOT_TEXTURE_ORDERS], description: "Textured dots: sequence (default) uses the stamps in turn; random picks one per dot (seeded, so replays are exact)." },
-    dotRotation: { type: "string", enum: [..._chunkHS6QDWDFcjs.DOT_ROTATIONS], description: "Textured dots: follow turns each with its particle's motion; random (default) turns each at random; fixed uses the tip angle." }
-  },
-  additionalProperties: false
-};
-var BRISTLE_BRUSH = {
-  type: "object",
-  description: "Bristle engine settings: a tuft of bristles, each its own line. Missing fields keep their current values.",
-  properties: {
-    count: { type: "integer", minimum: 3, maximum: 128, description: "Bristles in the tuft." },
-    stiffness: { type: "number", minimum: 0, maximum: 1, description: "Stiff bristles follow the tip; soft ones lag and bend into curves at turns." },
-    splay: { type: "number", minimum: 0, maximum: 1, description: "How far pressure spreads the tuft." },
-    thickness: { type: "number", minimum: 0, maximum: 1, description: "Each bristle's line width as a fraction of the tip size." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "Paint per bristle: 1 never runs dry; lower, bristles run out along the stroke (dry brush)." },
-    jitter: { type: "number", minimum: 0, maximum: 1, description: "Random variation between bristles." }
-  },
-  additionalProperties: false
-};
-var STICKER_BRUSH = {
-  type: "object",
-  description: "Sticker engine settings: stamps sprayed along the stroke as editable stickers. Missing fields keep their current values.",
-  properties: {
-    stamps: {
-      type: "array",
-      minItems: 1,
-      maxItems: _chunkHS6QDWDFcjs.MAX_STICKER_STAMPS,
-      items: { type: "string", minLength: 1, description: "A sticker ref provider:id from find_stickers (e.g. editor:star); a bare editor stamp (star) means editor:star." },
-      description: `The stickers to spray, one picked at random per sticker: refs from find_stickers (the editor's own: ${_chunkJSDND7DFcjs.STAMP_KINDS.map((k) => `editor:${k}`).join(", ")}). Each is checked against the sticker library and an unknown ref is refused with the closest ones. A provider's sticker is drawn from its art (tinted to the paint colour when tintable), loaded before the stroke.`
-    },
-    density: { type: "number", minimum: 0, maximum: 1, description: "How closely stickers follow each other: about density \xD7 4 stickers per tip diameter of travel (0.25 \u2248 one per diameter, 1 \u2248 four). Default 0.4." },
-    sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change." },
-    rotationJitter: { type: "number", minimum: 0, maximum: 1, description: "Random turn as a fraction of \xB1180\xB0." },
-    scatter: { type: "number", minimum: 0, maximum: 2, description: "How far from the path stickers land, in tip diameters." },
-    colorJitter: { type: "number", minimum: 0, maximum: 1, description: "Random colour change around the paint colour: at 1, up to \xB140\xB0 of hue and \xB10.15 OKLab lightness, kept in gamut. Default 0.2." }
-  },
-  additionalProperties: false
-};
-var BRUSH_FIELDS = {
-  name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
-  category: { type: "string", enum: [..._chunkHS6QDWDFcjs.PAINT_BRUSH_CATEGORIES], description: "Library category." },
-  engine: {
-    type: "string",
-    enum: [..._chunkHS6QDWDFcjs.PAINT_BRUSH_ENGINES],
-    description: "dab: paints dabs (with behavior.pickup or gradient paint it paints dab by dab, lifting and mixing paint); eraser: removes paint; mixer: the Mixer Brush (a reservoir plus picked-up paint); blender: mixes the colours under and near the tip; smudge: drags paint along the stroke; wet: watercolour, gouache, oil and the wet tools on a simulated wet layer (see wet); impasto: thick paint with relief (see impasto); particle: procedural particle brushes (see particle); bristle: a tuft of bristles that bend and splay (see bristle); sticker: sprays editable sticker stamps (see sticker)."
-  },
-  tip: TIP,
-  grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Multiplied by the paper depth." },
-  pressureSmoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Pressure smoothing, separate from the tip position smoothing." },
-  rotation: { type: "string", enum: [..._chunkHS6QDWDFcjs.BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
-  dynamics: DYNAMICS,
-  mixer: MIXER,
-  loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for a mixer that only moves paint)." },
-  behavior: BEHAVIOR,
-  blender: BLENDER,
-  smudge: SMUDGE,
-  wet: WET_BRUSH,
-  impasto: IMPASTO_BRUSH,
-  particle: PARTICLE_BRUSH,
-  bristle: BRISTLE_BRUSH,
-  sticker: STICKER_BRUSH,
-  light: LIGHT_BRUSH,
-  paint: BRUSH_PAINT
-};
 var TIME = { type: "number", minimum: 0, description: "Draw live effect paint (strokes on stroke layers painted with live effect paint) this many ms into its animation (default: as painted, its own time)." };
 var POINTS = {
   type: "array",
@@ -10846,26 +10789,6 @@ function loadResult(load) {
   const hex = (c) => c ? "#" + c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("") : null;
   return { reservoir: hex(load.reservoir), amount: Math.round(load.amount * 1e3) / 1e3, pickup: hex(load.pickup) };
 }
-function brushSummary(b) {
-  return {
-    gradient: b.paint !== null,
-    id: b.id,
-    name: b.name,
-    category: b.category,
-    engine: b.engine,
-    size: b.tip.size,
-    grain: b.grain,
-    rotation: b.rotation,
-    wetCapable: _chunkHS6QDWDFcjs.isWetCapable.call(void 0, b),
-    pickup: b.behavior.pickup,
-    dirty: b.behavior.dirty,
-    multicolor: b.behavior.multicolor.mode,
-    ...b.engine === "wet" ? { wetTool: b.wet.tool, medium: b.wet.medium } : {},
-    ...b.engine === "impasto" ? { impastoTool: b.impasto.tool } : {},
-    ...b.light.amount > 0 ? { light: b.light.amount } : {},
-    builtin: Boolean(b.builtin)
-  };
-}
 function createPaintEditorToolProvider(controller, options = {}) {
   const c = typeof controller === "function" ? lazyController(controller) : controller;
   const tools = [];
@@ -11180,121 +11103,31 @@ function createPaintEditorToolProvider(controller, options = {}) {
     coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.clearLayer(layerId)
   });
-  add({
-    name: "list_brushes",
-    title: "List brushes",
-    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush), light paint (category light: glow gel, neon marker, light airbrush, spark trail, light ribbon, flame ribbon, neon strand, smoke ribbon, bokeh dots, twinkle sparks, glow wash, highlighter; light is the amount they lay) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
-    inputSchema: EMPTY3,
-    annotations: { title: "List brushes", ...READ6 },
-    handler: () => {
-      const s = c.getState();
-      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _517 => _517.getBrush, 'call', _518 => _518(s.brush.id), 'optionalAccess', _519 => _519.builtin])), brushes: s.brushes.map(brushSummary) };
-    }
-  });
   add({
     name: "get_brush",
     title: "Get a brush",
-    description: "Reads every setting of a brush (tip, grain, pressure smoothing, rotation, dynamics, mixer, behavior: pick-up / mix / dirty, blender, smudge, its own gradient paint as paint, null when it paints the editor's paint). Without id, the active brush as edited. Also returns strokePaint: what a stroke with it would paint now (its gradient, else the editor's paint from set_paint).",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes (default the active brush)." } }, additionalProperties: false },
+    description: "Reads a brush as facets (kind, medium, variety or tool, tip, marks, dynamics, behaviour, light, motion, colour: the brush library's form, as describe_brush returns it), with the engine it paints with and whether it is an unchanged built-in preset. Without id, the active brush as edited. Also returns strokePaint: what a stroke with it would paint now (its gradient colour, else the editor's paint from set_paint). Changes nothing.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." } }, additionalProperties: false },
     annotations: { title: "Get a brush", ...READ6 },
     handler: ({ id }) => {
       const st = c.getState();
-      if (id === void 0) return { ..._chunkHS6QDWDFcjs.brushToJSON.call(void 0, st.brush), strokePaint: _nullishCoalesce(st.brush.paint, () => ( st.paint)) };
-      const b = c.getBrush(id);
-      if (!b) throw new Error(`Unknown brush "${id}". Call list_brushes for the ids.`);
-      return { ..._chunkHS6QDWDFcjs.brushToJSON.call(void 0, b), builtin: Boolean(b.builtin), strokePaint: _nullishCoalesce(b.paint, () => ( st.paint)) };
+      const b = id === void 0 ? st.brush : c.getBrush(id);
+      if (!b) c.setBrushFacets({}, id);
+      const brush = b;
+      return { brush: c.getBrushSpec(id), engine: brush.engine, category: brush.category, builtin: Boolean(brush.builtin), strokePaint: _nullishCoalesce(brush.paint, () => ( st.paint)) };
     }
   });
   add({
     name: "set_brush",
     title: "Set the brush",
-    description: "Chooses the active brush (id) and / or changes its settings; strokes without a brush use it. Editor state, not an undo step. Changes stay on the active brush until save_brush stores them. Returns the active brush.",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes to start from." }, ...BRUSH_FIELDS }, additionalProperties: false },
+    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." }, ..._chunk34KLWUH4cjs.BRUSH_PATCH_PROPERTIES, unset: _chunk34KLWUH4cjs.BRUSH_UNSET_PROPERTY }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
-    handler: async (a) => {
-      const stamps = _optionalChain([a, 'access', _520 => _520.sticker, 'optionalAccess', _521 => _521.stamps]);
+    handler: async ({ id, unset, ...patch }) => {
+      const stamps = _optionalChain([patch, 'access', _542 => _542.tip, 'optionalAccess', _543 => _543.stamps]);
       if (stamps) await c.prepareStickers(stamps);
-      return _chunkHS6QDWDFcjs.brushToJSON.call(void 0, c.setBrush(a));
-    }
-  });
-  add({
-    name: "save_brush",
-    title: "Save a brush",
-    description: "Saves the active brush (with its changes) into the user library under a new or existing user id. Built-in ids are refused. Library state, not an undo step. Returns the saved brush.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", pattern: "^[a-z0-9][a-z0-9-]{0,63}$", description: "Library id: lowercase letters, digits and dashes." },
-        name: { type: "string", minLength: 1, maxLength: 80, description: "Display name (default the brush name)." }
-      },
-      required: ["id"],
-      additionalProperties: false
-    },
-    annotations: { title: "Save a brush", ...SET4 },
-    handler: ({ id, name }) => _chunkHS6QDWDFcjs.brushToJSON.call(void 0, c.saveBrush({ id, name }))
-  });
-  add({
-    name: "remove_brush",
-    title: "Remove a saved brush",
-    description: "Removes a user brush from the library (built-in brushes cannot be removed). Library state, not an undo step. Returns the removed id.",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "User brush id from list_brushes." } }, required: ["id"], additionalProperties: false },
-    annotations: { title: "Remove a saved brush", ...DESTRUCTIVE3 },
-    handler: ({ id }) => {
-      c.removeBrush(id);
-      return { removed: id };
-    }
-  });
-  add({
-    name: "export_brushes",
-    title: "Export brushes",
-    description: "Returns a brush library file (JSON: format pixerate-brushes, version 1, brushes) of the given brushes, or of every user brush. Changes nothing.",
-    inputSchema: {
-      type: "object",
-      properties: { ids: { type: "array", items: { type: "string", description: "Brush id." }, description: "Brush ids from list_brushes (default every user brush)." } },
-      additionalProperties: false
-    },
-    annotations: { title: "Export brushes", ...READ6 },
-    handler: ({ ids }) => c.exportBrushes(ids)
-  });
-  add({
-    name: "import_brushes",
-    title: "Import brushes",
-    description: "Adds the brushes of a brush library file (as export_brushes returns) to the user library. Taken ids are skipped unless replace is true; built-in ids are always skipped. Library state, not an undo step. Returns the ids added and skipped and any problems.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        library: { type: "object", description: 'The library file: {format: "pixerate-brushes", version: 1, brushes: [...]}.' },
-        replace: { type: "boolean", description: "Replace user brushes with the same id (default false)." }
-      },
-      required: ["library"],
-      additionalProperties: false
-    },
-    annotations: { title: "Import brushes", ...WRITE5 },
-    handler: ({ library, replace }) => c.importBrushes(library, { replace })
-  });
-  add({
-    name: "render_brush_thumbnail",
-    title: "Render a brush thumbnail",
-    description: "Renders a brush as a PNG: a test stroke (an S-curve swelling and fading in pressure) on the current paper, so you can see what it does before painting. Changes nothing.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Brush id from list_brushes (default the active brush)." },
-        width: { type: "integer", minimum: 16, maximum: 512, description: "Width in pixels (default 160)." },
-        height: { type: "integer", minimum: 16, maximum: 512, description: "Height in pixels (default 48)." },
-        color: { ...COLOR3, description: "Stroke colour (default the paint colour)." }
-      },
-      additionalProperties: false
-    },
-    annotations: { title: "Render a brush thumbnail", ...READ6 },
-    handler: ({ id, width, height, color }) => {
-      const t = c.brushThumbnail(_nullishCoalesce(id, () => ( c.getState().brush.id)), { width, height, color });
-      return {
-        content: [
-          { type: "image", data: _chunkW5M3J7PVcjs.bytesToBase64.call(void 0, _chunkW5M3J7PVcjs.encodePng.call(void 0, t.width, t.height, t.data)), mimeType: "image/png" },
-          { type: "text", text: `Brush ${_nullishCoalesce(id, () => ( c.getState().brush.id))} ${t.width}\xD7${t.height}` }
-        ]
-      };
+      const r = c.setBrushFacets(patch, id, unset);
+      return { brush: r.spec, engine: r.brush.engine, problems: r.problems };
     }
   });
   add({
@@ -11371,14 +11204,14 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer with a library brush or the active one, optionally changed for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
+    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer of the canvas with a library brush or the active one, optionally changed (by facets) for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
     inputSchema: {
       type: "object",
       properties: {
         points: POINTS,
         layerId: LAYER_ID4,
-        brushId: { type: "string", description: "Brush id from list_brushes (default the active brush)." },
-        brush: { type: "object", description: "Brush changes for this stroke only.", properties: BRUSH_FIELDS, additionalProperties: false },
+        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: _chunk34KLWUH4cjs.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." },
@@ -11392,9 +11225,9 @@ function createPaintEditorToolProvider(controller, options = {}) {
     handler: async (a) => {
       await c.wetIdle();
       const base = a.brushId ? c.getBrush(a.brushId) : c.getState().brush;
-      const over = a.brush;
-      if ((_nullishCoalesce(_optionalChain([over, 'optionalAccess', _522 => _522.engine]), () => ( _optionalChain([base, 'optionalAccess', _523 => _523.engine])))) === "sticker") await c.prepareStickers(_nullishCoalesce(_nullishCoalesce(_optionalChain([over, 'optionalAccess', _524 => _524.sticker, 'optionalAccess', _525 => _525.stamps]), () => ( _optionalChain([base, 'optionalAccess', _526 => _526.sticker, 'access', _527 => _527.stamps]))), () => ( [])));
-      const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush: a.brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
+      const brush = a.brush ? c.brushChanges(a.brush, a.brushId) : void 0;
+      if ((_nullishCoalesce(_optionalChain([brush, 'optionalAccess', _544 => _544.engine]), () => ( _optionalChain([base, 'optionalAccess', _545 => _545.engine])))) === "sticker") await c.prepareStickers(_nullishCoalesce(_nullishCoalesce(_optionalChain([brush, 'optionalAccess', _546 => _546.sticker, 'optionalAccess', _547 => _547.stamps]), () => ( _optionalChain([base, 'optionalAccess', _548 => _548.sticker, 'access', _549 => _549.stamps]))), () => ( [])));
+      const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
       const r = await act({ kind: "stroke", stroke }, () => c.paintStroke(stroke));
       return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
     }
@@ -11425,7 +11258,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', _528 => _528.document, 'access', _529 => _529.liveStrokes, 'optionalAccess', _530 => _530[s.layerId], 'optionalAccess', _531 => _531.includes, 'call', _532 => _532(s)]) === true)) };
+      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _550 => _550.document, 'access', _551 => _551.liveStrokes, 'optionalAccess', _552 => _552[s.layerId], 'optionalAccess', _553 => _553.includes, 'call', _554 => _554(s)]) === true)) };
     }
   });
   add({
@@ -11457,8 +11290,8 @@ function createPaintEditorToolProvider(controller, options = {}) {
       type: "object",
       properties: {
         id: { type: "string", description: "Stroke id from list_strokes {live: true}." },
-        brushId: { type: "string", description: "Brush preset id from list_brushes; the stroke keeps its size." },
-        brush: { type: "object", properties: BRUSH_FIELDS, additionalProperties: false, description: "Brush settings to change on top of brushId or the stroke\u2019s brush; missing fields keep their values." },
+        brushId: { type: "string", description: "Brush id from list_brush_presets; the stroke keeps its size." },
+        brush: { type: "object", properties: _chunk34KLWUH4cjs.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." }
@@ -11470,6 +11303,11 @@ function createPaintEditorToolProvider(controller, options = {}) {
     coordinates: { out: ["bounds", "stroke.bounds"] },
     handler: ({ id, ...update }) => {
       if (!Object.keys(update).length) throw new Error("Pass at least one change: brushId, brush, color, paint or seed.");
+      if (update.brush) {
+        const stroke = Object.values(_nullishCoalesce(c.document.liveStrokes, () => ( {}))).flat().find((s) => s.id === id);
+        if (!stroke) throw new Error(`Unknown stroke "${id}" on a stroke layer. Call list_strokes {live: true} for the ids.`);
+        update.brush = c.brushChanges(update.brush, _nullishCoalesce(update.brushId, () => ( stroke.brush)));
+      }
       const r = c.updateStroke(id, update);
       return { stroke: strokeSummary(r.stroke, false, true), bounds: r.bounds };
     }
@@ -11574,7 +11412,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         },
         pressureScale: { type: "number", minimum: 0, maximum: 4, description: "Multiply every pressure (default 1)." },
         color: { ...COLOR3, description: "Recolour (default each stroke\u2019s colour)." },
-        brushId: { type: "string", description: "Replay with this brush from list_brushes (default each stroke\u2019s brush)." },
+        brushId: { type: "string", description: "Replay with this brush from list_brush_presets (default each stroke\u2019s brush)." },
         layerId: { type: "string", description: "Paint on this layer (default each stroke\u2019s layer)." },
         repeat: { type: "integer", minimum: 1, maximum: 100, description: "How many copies (default 1)." }
       },
@@ -11729,16 +11567,16 @@ function createPaintEditorToolProvider(controller, options = {}) {
 }
 function hostTool({ coordinates, ...tool }, { origin, onChange }) {
   if (!origin && !onChange) return tool;
-  const write = !_optionalChain([tool, 'access', _533 => _533.annotations, 'optionalAccess', _534 => _534.readOnlyHint]);
+  const write = !_optionalChain([tool, 'access', _555 => _555.annotations, 'optionalAccess', _556 => _556.readOnlyHint]);
   const done = (result) => {
-    if (write) _optionalChain([onChange, 'optionalCall', _535 => _535({ tool: tool.name })]);
-    return origin && _optionalChain([coordinates, 'optionalAccess', _536 => _536.out]) ? fromDocument(result, coordinates.out, origin) : result;
+    if (write) _optionalChain([onChange, 'optionalCall', _557 => _557({ tool: tool.name })]);
+    return origin && _optionalChain([coordinates, 'optionalAccess', _558 => _558.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', _537 => _537.in]) ? toDocument(args, coordinates.in, origin) : args, context);
+      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _559 => _559.in]) ? toDocument(args, coordinates.in, origin) : args, context);
       return r instanceof Promise ? r.then(done) : done(r);
     }
   };
@@ -11755,12 +11593,24 @@ function strokeSummary(s, withPoints, live) {
     color: s.color,
     points: withPoints ? s.points : s.points.length,
     seed: s.seed,
-    copies: _nullishCoalesce(_optionalChain([s, 'access', _538 => _538.copies, 'optionalAccess', _539 => _539.length]), () => ( 0)),
+    copies: _nullishCoalesce(_optionalChain([s, 'access', _560 => _560.copies, 'optionalAccess', _561 => _561.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 createPaintBrushLibraryToolProvider(controller, options = {}) {
+  return _chunk34KLWUH4cjs.createBrushLibraryToolProvider.call(void 0, controller.brushLibrary, {
+    profile: _chunk34KLWUH4cjs.PAINT_PROFILE,
+    ...options,
+    renderPreview: (brush, { width, height, color }) => {
+      const t = renderBrushThumbnail(_chunk34KLWUH4cjs.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" };
+    }
+  });
+}
+
 // src/paint-editor/ui.ts
 var PAINT_TOOLS = [
   { id: "brush", label: "Brush", key: "b" },
@@ -11771,20 +11621,20 @@ var PAINT_TOOLS = [
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
 var PaintGesture = (_class20 = class {
-  constructor(controller, box) {;_class20.prototype.__init174.call(this);_class20.prototype.__init175.call(this);_class20.prototype.__init176.call(this);_class20.prototype.__init177.call(this);_class20.prototype.__init178.call(this);_class20.prototype.__init179.call(this);
+  constructor(controller, box) {;_class20.prototype.__init176.call(this);_class20.prototype.__init177.call(this);_class20.prototype.__init178.call(this);_class20.prototype.__init179.call(this);_class20.prototype.__init180.call(this);_class20.prototype.__init181.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init174() {this.tool = "brush"}
+  __init176() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init175() {this.error = null}
+  __init177() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init176() {this.predicted = []}
-  __init177() {this.mode = null}
-  __init178() {this.penAt = null}
-  __init179() {this.penDown = false}
+  __init178() {this.predicted = []}
+  __init179() {this.mode = null}
+  __init180() {this.penAt = null}
+  __init181() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -11840,13 +11690,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', _540 => _540.document, 'access', _541 => _541.liveStrokes, 'optionalAccess', _542 => _542[layerId]])) {
+    if (!layerId || !_optionalChain([s, 'access', _562 => _562.document, 'access', _563 => _563.liveStrokes, 'optionalAccess', _564 => _564[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', _543 => _543.id]), () => ( null)));
+      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _565 => _565.id]), () => ( null)));
       if (!hit) return false;
       this.mode = { kind: "move-stroke", pointerId: e.pointerId, id: hit.id, from: p, to: p };
       return true;
@@ -11858,7 +11708,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', _544 => _544.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', _566 => _566.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
@@ -11932,7 +11782,7 @@ var PaintGesture = (_class20 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _545 => _545.controller, 'access', _546 => _546.activeStroke, 'optionalAccess', _547 => _547.end, 'call', _548 => _548()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _567 => _567.controller, 'access', _568 => _568.activeStroke, 'optionalAccess', _569 => _569.end, 'call', _570 => _570()]);
     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;
@@ -11956,8 +11806,8 @@ var PaintGesture = (_class20 = class {
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _549 => _549.mode, 'optionalAccess', _550 => _550.kind]) === "stroke") _optionalChain([this, 'access', _551 => _551.controller, 'access', _552 => _552.activeStroke, 'optionalAccess', _553 => _553.cancel, 'call', _554 => _554()]);
-    if (_optionalChain([this, 'access', _555 => _555.mode, 'optionalAccess', _556 => _556.kind]) === "sticker") this.controller.cancelStickerPreview();
+    if (_optionalChain([this, 'access', _571 => _571.mode, 'optionalAccess', _572 => _572.kind]) === "stroke") _optionalChain([this, 'access', _573 => _573.controller, 'access', _574 => _574.activeStroke, 'optionalAccess', _575 => _575.cancel, 'call', _576 => _576()]);
+    if (_optionalChain([this, 'access', _577 => _577.mode, 'optionalAccess', _578 => _578.kind]) === "sticker") this.controller.cancelStickerPreview();
     this.mode = null;
   }
   get active() {
@@ -12019,13 +11869,13 @@ function handlePaintShortcut(controller, gesture, e) {
   return false;
 }
 var PaintCanvasPresenter = (_class21 = class {
-  constructor(controller) {;_class21.prototype.__init180.call(this);_class21.prototype.__init181.call(this);_class21.prototype.__init182.call(this);
+  constructor(controller) {;_class21.prototype.__init182.call(this);_class21.prototype.__init183.call(this);_class21.prototype.__init184.call(this);
     this.controller = controller;
   }
   
-  __init180() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init181() {this.scratch = null}
-  __init182() {this.size = ""}
+  __init182() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init183() {this.scratch = null}
+  __init184() {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;
@@ -12057,7 +11907,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', _557 => _557.document, 'access', _558 => _558.liveStrokes, 'optionalAccess', _559 => _559[layerId], 'optionalAccess', _560 => _560.some, 'call', _561 => _561((x) => x.id === s.selectedStroke)]) : false;
+  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _579 => _579.document, 'access', _580 => _580.liveStrokes, 'optionalAccess', _581 => _581[layerId], 'optionalAccess', _582 => _582.some, 'call', _583 => _583((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;
@@ -12070,7 +11920,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', _562 => _562.document, 'access', _563 => _563.stickers, 'optionalAccess', _564 => _564[layerId], 'optionalAccess', _565 => _565.find, 'call', _566 => _566((x) => x.id === s.selectedSticker)]) : void 0;
+  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _584 => _584.document, 'access', _585 => _585.stickers, 'optionalAccess', _586 => _586[layerId], 'optionalAccess', _587 => _587.find, 'call', _588 => _588((x) => x.id === s.selectedSticker)]) : void 0;
   if (picked) {
     const r = picked.size / 2 + 2;
     const a = picked.rotation * Math.PI / 180;
@@ -12087,21 +11937,6 @@ function guideOverlay(controller, drag) {
   if (s.guides.perspective.enabled) for (const [from, to] of perspectiveGuideLines(s.guides.perspective, size, 16)) out.push({ from, to, kind: "perspective" });
   return out;
 }
-var BRUSH_SLIDERS = [
-  { path: "tip.size", label: "Size", min: 1, max: 400, step: 1 },
-  { path: "tip.opacity", label: "Opacity", min: 0, max: 1, step: 0.01 },
-  { path: "tip.flow", label: "Flow", min: 0, max: 1, step: 0.01 },
-  { path: "tip.hardness", label: "Hardness", min: 0, max: 1, step: 0.01 },
-  { path: "tip.spacing", label: "Spacing", min: 0.01, max: 1, step: 0.01 },
-  { path: "tip.roundness", label: "Roundness", min: 0.05, max: 1, step: 0.01 },
-  { path: "tip.angle", label: "Angle", min: -180, max: 180, step: 1 },
-  { path: "grain", label: "Grain", min: 0, max: 1, step: 0.01 },
-  { path: "tip.smoothing", label: "Smoothing", min: 0, max: 0.95, step: 0.01 },
-  { path: "pressureSmoothing", label: "Pressure smoothing", min: 0, max: 0.95, step: 0.01 },
-  { path: "dynamics.minSize", label: "Min size", min: 0, max: 1, step: 0.01 },
-  { path: "dynamics.tiltSize", label: "Tilt size", min: 0, max: 1, step: 0.01 },
-  { path: "dynamics.velocitySize", label: "Speed size", min: -1, max: 1, step: 0.01 }
-];
 var PAPER_SLIDERS = [
   { path: "depth", label: "Grain depth", min: 0, max: 1, step: 0.01 },
   { path: "scale", label: "Grain scale", min: 0.25, max: 8, step: 0.05 },
@@ -12115,7 +11950,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _567 => _567[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _589 => _589[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -12160,158 +11995,6 @@ var BLEND_MENU_GROUPS = [
   { label: "Standard", modes: _chunk2VX55NFMcjs.BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
   { label: "Paint", modes: _chunk2VX55NFMcjs.BLEND_MODES.filter((m) => m.painterly || m.id === "pigment") }
 ];
-var LIGHT_SLIDER = { path: "light.amount", label: "Light", min: 0, max: 1, step: 0.01 };
-var PICKUP_SLIDERS = [
-  { path: "behavior.pickup", label: "Pick-up", min: 0, max: 1, step: 0.01 },
-  { path: "behavior.mix", label: "Mix", min: 0, max: 1, step: 0.01 }
-];
-function brushEngineControls(brush) {
-  const c = engineControls(brush);
-  const wetPaint = brush.engine === "wet" && _optionalChain([brush, 'access', _568 => _568.wet, 'optionalAccess', _569 => _569.tool]) === "paint";
-  if (!c || !(wetPaint || ["dab", "mixer", "particle", "bristle", "impasto"].includes(brush.engine))) return c;
-  const extra = brush.engine === "impasto" ? [{ path: "impasto.rim", label: "Rim", min: 0, max: 1, step: 0.01 }, { path: "impasto.clarity", label: "Clarity", min: 0, max: 1, step: 0.01 }] : [];
-  return { ...c, sliders: [...c.sliders, LIGHT_SLIDER, ...extra], light: true };
-}
-function engineControls(brush) {
-  switch (brush.engine) {
-    case "particle":
-      return {
-        title: "Particles",
-        sliders: [
-          { path: "particle.count", label: "Particles", min: 1, max: 64, step: 1 },
-          { path: "particle.size", label: "Mark size", min: 0, max: 1, step: 0.01 },
-          { path: "particle.spread", label: "Spread", min: 0, max: 1, step: 0.01 },
-          { path: "particle.stiffness", label: "Stiffness", min: 0, max: 1, step: 0.01 },
-          { path: "particle.damping", label: "Damping", min: 0, max: 1, step: 0.01 },
-          { path: "particle.speed", label: "Speed", min: 0, max: 1, step: 0.01 },
-          { path: "particle.gravity", label: "Gravity", min: -1, max: 1, step: 0.01 },
-          { path: "particle.life", label: "Life", min: 0, max: 1, step: 0.01 },
-          { path: "particle.interval", label: "Bead spacing", min: 0, max: 1, step: 0.01 },
-          { path: "particle.ribbonFill", label: "Ribbon fill", min: 0, max: 1, step: 0.01 },
-          { path: "particle.waveAmplitude", label: "Wave", min: 0, max: 1, step: 0.01 },
-          { path: "particle.waveLength", label: "Wavelength", min: 4, max: 400, step: 1 },
-          { path: "particle.waveSpeed", label: "Wave speed", min: 0, max: 1, step: 0.01 },
-          { path: "particle.wavePhaseJitter", label: "Wave scatter", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: null,
-        dirty: false,
-        multicolor: false,
-        load: false,
-        particleMenus: true
-      };
-    case "bristle":
-      return {
-        title: "Bristles",
-        sliders: [
-          { path: "bristle.count", label: "Bristles", min: 3, max: 128, step: 1 },
-          { path: "bristle.stiffness", label: "Stiffness", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.splay", label: "Splay", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.thickness", label: "Bristle width", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.load", label: "Load", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.jitter", label: "Variation", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: null,
-        dirty: false,
-        multicolor: false,
-        load: false
-      };
-    case "sticker":
-      return {
-        title: "Stickers",
-        sliders: [
-          { path: "sticker.density", label: "Density", min: 0, max: 1, step: 0.01 },
-          { path: "sticker.sizeJitter", label: "Size jitter", min: 0, max: 1, step: 0.01 },
-          { path: "sticker.rotationJitter", label: "Turn jitter", min: 0, max: 1, step: 0.01 },
-          { path: "sticker.scatter", label: "Scatter", min: 0, max: 2, step: 0.01 },
-          { path: "sticker.colorJitter", label: "Colour jitter", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: null,
-        dirty: false,
-        multicolor: false,
-        load: false,
-        stickerStamps: true
-      };
-    case "impasto":
-      return {
-        title: "Thick paint",
-        sliders: [
-          { path: "impasto.thickness", label: "Thickness", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.gloss", label: "Gloss", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.metallic", label: "Metallic", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.load", label: "Load", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.thinner", label: "Thinner", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.drag", label: "Drag", min: 0, max: 1, step: 0.01 },
-          ...PICKUP_SLIDERS
-        ],
-        mixingPath: "behavior.mixing",
-        dirty: true,
-        multicolor: false,
-        load: true,
-        impastoTool: true
-      };
-    case "wet": {
-      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _570 => _570.wet, 'optionalAccess', _571 => _571.tool]), () => ( "paint"));
-      const sliders = tool === "paint" ? [
-        { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
-        { path: "wet.pigment", label: "Pigment", min: 0, max: 1, step: 0.01 },
-        { path: "wet.body", label: "Body (opacity)", min: 0, max: 1, step: 0.01 },
-        { path: "wet.rewet", label: "Re-wet", min: 0, max: 1, step: 0.01 },
-        { path: "wet.load", label: "Load", min: 0, max: 1, step: 0.01 },
-        { path: "wet.thinner", label: "Thinner", min: 0, max: 1, step: 0.01 },
-        ...PICKUP_SLIDERS
-      ] : tool === "water" ? [
-        { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
-        { path: "wet.rewet", label: "Re-wet", min: 0, max: 1, step: 0.01 }
-      ] : [{ path: "wet.strength", label: "Strength", min: 0, max: 1, step: 0.01 }];
-      return { title: "Wet brush", sliders, mixingPath: tool === "paint" ? "behavior.mixing" : null, dirty: tool === "paint", multicolor: false, load: tool === "paint", wetTool: true };
-    }
-    case "blender":
-      return {
-        title: "Blender",
-        sliders: [
-          { path: "blender.strength", label: "Strength", min: 0, max: 1, step: 0.01 },
-          { path: "blender.distance", label: "Blend distance", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: "blender.mixing",
-        dirty: false,
-        multicolor: false,
-        load: false
-      };
-    case "smudge":
-      return {
-        title: "Smudge",
-        sliders: [
-          { path: "smudge.strength", label: "Strength", min: 0, max: 1, step: 0.01 },
-          { path: "smudge.length", label: "Length", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: "smudge.mixing",
-        dirty: false,
-        multicolor: false,
-        load: false
-      };
-    case "mixer":
-      return { title: "Mixer Brush", sliders: [...PICKUP_SLIDERS, { path: "mixer.load", label: "Load", min: 0, max: 1, step: 0.01 }], mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
-    case "dab":
-      return { title: "Paint behaviour", sliders: PICKUP_SLIDERS, mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
-    default:
-      return null;
-  }
-}
-function multiColorSliders(mode) {
-  if (mode === "off") return [];
-  const soft = { path: "behavior.multicolor.softness", label: "Colour softness", min: 0, max: 1, step: 0.01 };
-  return mode === "dab" ? [soft, { path: "behavior.multicolor.length", label: "Dabs per colour", min: 1, max: 100, step: 1 }] : [soft];
-}
-function patchBrushValue(brush, path, value) {
-  const set = (obj, keys) => {
-    const [head2, ...rest2] = keys;
-    if (!rest2.length) return { ...obj, [head2]: value };
-    return { ...obj, [head2]: set(_nullishCoalesce(obj[head2], () => ( {})), rest2) };
-  };
-  const [head, ...rest] = path.split(".");
-  if (!rest.length) return { [head]: value };
-  return { [head]: set({ ..._nullishCoalesce(brush[head], () => ( {})) }, rest) };
-}
 function brushLoadColor(load) {
   const c = _nullishCoalesce(load.pickup, () => ( load.reservoir));
   return c ? rgbToHexColor(Math.round(c[0] * 255), Math.round(c[1] * 255), Math.round(c[2] * 255)) : null;
@@ -12383,7 +12066,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _572 => _572(id)]);
+    _optionalChain([caf, 'optionalCall', _590 => _590(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {
@@ -12498,7 +12181,7 @@ function createPaintEffectsToolProvider(controller, options = {}) {
     if (changes.enabled !== void 0) throw new Error("enabled does not apply here: hide an effect layer with update_layer visible false, or remove the effect paper.");
   };
   const values = (v) => v;
-  return withPaintPlayback(_chunkISIO63Q5cjs.createEffectToolProvider.call(void 0, {
+  return withPaintPlayback(_chunkL2JTLW6Bcjs.createEffectToolProvider.call(void 0, {
     id: _nullishCoalesce(options.id, () => ( "paint-effects")),
     namespace: options.namespace,
     title: "Paint effects",
@@ -13068,4 +12751,6 @@ function createPaintEditorDocument(controller, options = {}) {
 
 
 
-exports.BACKLIGHT_SPILL = BACKLIGHT_SPILL; exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunk2VX55NFMcjs.BLEND_MODES; exports.BRUSH_ID = _chunkHS6QDWDFcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkHS6QDWDFcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkHS6QDWDFcjs.BUILTIN_BRUSHES; exports.BristleStroke = BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunkHS6QDWDFcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkHS6QDWDFcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkHS6QDWDFcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkHS6QDWDFcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkKBYB7OWBcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkHS6QDWDFcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunkHS6QDWDFcjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkHS6QDWDFcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkHS6QDWDFcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkKBYB7OWBcjs.DEFAULT_WET_PARAMS; exports.DOT_ROTATIONS = _chunkHS6QDWDFcjs.DOT_ROTATIONS; exports.DOT_ROTATION_LABELS = DOT_ROTATION_LABELS; exports.DOT_TEXTURE_ORDERS = _chunkHS6QDWDFcjs.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 = _chunkEUIDTZNQcjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.MAX_DOT_TEXTURES; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_STICKER_STAMPS = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkHS6QDWDFcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_COLOR_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_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 = _chunkHS6QDWDFcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkHS6QDWDFcjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _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 = _chunkHS6QDWDFcjs.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 = _chunkSABJMH6Mcjs.StickerBrowser; exports.StickerSpray = StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunk3K6HWEXZcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkKBYB7OWBcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkHS6QDWDFcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkKBYB7OWBcjs.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 = _chunkHS6QDWDFcjs.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 = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkHS6QDWDFcjs.brushTakesPaint; exports.brushToJSON = _chunkHS6QDWDFcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.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 = _chunkEUIDTZNQcjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunk2VX55NFMcjs.isBlendMode; exports.isGradientPaint = _chunkFQPUF2W2cjs.isGradientPaint; exports.isPaintEffectPaint = isPaintEffectPaint; exports.isPainterlyBlendMode = _chunk2VX55NFMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkHS6QDWDFcjs.isWetBrush; exports.isWetCapable = _chunkHS6QDWDFcjs.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 = multiColorSliders; exports.multiColorToPaint = _chunkHS6QDWDFcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkHS6QDWDFcjs.normalizeBehavior; exports.normalizeBristle = _chunkHS6QDWDFcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkHS6QDWDFcjs.normalizeDynamics; exports.normalizeFlow = _chunkKBYB7OWBcjs.normalizeFlow; exports.normalizeHexColor = _chunkFQPUF2W2cjs.normalizeHexColor; exports.normalizeImpasto = _chunkHS6QDWDFcjs.normalizeImpasto; exports.normalizeLight = _chunkHS6QDWDFcjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkHS6QDWDFcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkHS6QDWDFcjs.normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeParticle = _chunkHS6QDWDFcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkHS6QDWDFcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkHS6QDWDFcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkKBYB7OWBcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkFQPUF2W2cjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkFQPUF2W2cjs.paintSourceColor; exports.paintSourceCss = _chunkFQPUF2W2cjs.paintSourceCss; exports.paintToMultiColor = _chunkHS6QDWDFcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = _chunkHS6QDWDFcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkFQPUF2W2cjs.parsePaintSource; exports.patchBrushValue = 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.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.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 = _chunkHS6QDWDFcjs.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 = _chunkKBYB7OWBcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunkEUIDTZNQcjs.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 = _chunkHS6QDWDFcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkHS6QDWDFcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = _chunk34KLWUH4cjs.BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkHS6QDWDFcjs.BUILTIN_BRUSHES; exports.BristleStroke = BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunkHS6QDWDFcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkHS6QDWDFcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkHS6QDWDFcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkHS6QDWDFcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkKBYB7OWBcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkHS6QDWDFcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunkHS6QDWDFcjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkHS6QDWDFcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkHS6QDWDFcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkKBYB7OWBcjs.DEFAULT_WET_PARAMS; exports.DOT_ROTATIONS = _chunkHS6QDWDFcjs.DOT_ROTATIONS; exports.DOT_ROTATION_LABELS = DOT_ROTATION_LABELS; exports.DOT_TEXTURE_ORDERS = _chunkHS6QDWDFcjs.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 = _chunkEUIDTZNQcjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.MAX_DOT_TEXTURES; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_STICKER_STAMPS = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.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 = _chunkHS6QDWDFcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkHS6QDWDFcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_COLOR_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_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 = _chunkHS6QDWDFcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkHS6QDWDFcjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _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 = _chunkHS6QDWDFcjs.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 = _chunkSABJMH6Mcjs.StickerBrowser; exports.StickerSpray = StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunk3K6HWEXZcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkKBYB7OWBcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkHS6QDWDFcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkKBYB7OWBcjs.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 = _chunkHS6QDWDFcjs.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 = _chunk34KLWUH4cjs.brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkHS6QDWDFcjs.brushTakesPaint; exports.brushToJSON = _chunkHS6QDWDFcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintBrushLibraryToolProvider = createPaintBrushLibraryToolProvider; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.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 = _chunkEUIDTZNQcjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunk2VX55NFMcjs.isBlendMode; exports.isGradientPaint = _chunkFQPUF2W2cjs.isGradientPaint; exports.isPaintEffectPaint = isPaintEffectPaint; exports.isPainterlyBlendMode = _chunk2VX55NFMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkHS6QDWDFcjs.isWetBrush; exports.isWetCapable = _chunkHS6QDWDFcjs.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 = _chunk34KLWUH4cjs.multiColorSliders; exports.multiColorToPaint = _chunkHS6QDWDFcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkHS6QDWDFcjs.normalizeBehavior; exports.normalizeBristle = _chunkHS6QDWDFcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkHS6QDWDFcjs.normalizeDynamics; exports.normalizeFlow = _chunkKBYB7OWBcjs.normalizeFlow; exports.normalizeHexColor = _chunkFQPUF2W2cjs.normalizeHexColor; exports.normalizeImpasto = _chunkHS6QDWDFcjs.normalizeImpasto; exports.normalizeLight = _chunkHS6QDWDFcjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkHS6QDWDFcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkHS6QDWDFcjs.normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeParticle = _chunkHS6QDWDFcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkHS6QDWDFcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkHS6QDWDFcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkKBYB7OWBcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkFQPUF2W2cjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkFQPUF2W2cjs.paintSourceColor; exports.paintSourceCss = _chunkFQPUF2W2cjs.paintSourceCss; exports.paintToMultiColor = _chunkHS6QDWDFcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = _chunkHS6QDWDFcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkFQPUF2W2cjs.parsePaintSource; exports.patchBrushValue = _chunk34KLWUH4cjs.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.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 = _chunkHS6QDWDFcjs.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 = _chunkKBYB7OWBcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunkEUIDTZNQcjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;