@pixerate/editor 0.125.0 → 0.126.0

package/dist/paint-editor/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12;
 
 
 
@@ -73,7 +73,7 @@
 var _chunkW4LNKTHTcjs = require('../chunk-W4LNKTHT.cjs');
 
 
-var _chunkUXFI3CDZcjs = require('../chunk-UXFI3CDZ.cjs');
+var _chunkSFCPGMCTcjs = require('../chunk-SFCPGMCT.cjs');
 
 
 
@@ -82,7 +82,9 @@ var _chunkUXFI3CDZcjs = require('../chunk-UXFI3CDZ.cjs');
 
 var _chunkO5RVCDECcjs = require('../chunk-O5RVCDEC.cjs');
 require('../chunk-2YQONY6G.cjs');
-require('../chunk-W6QTLHZ3.cjs');
+
+
+var _chunkW6QTLHZ3cjs = require('../chunk-W6QTLHZ3.cjs');
 
 
 
@@ -210,7 +212,12 @@ var _chunkCOAMRKVIcjs = require('../chunk-COAMRKVI.cjs');
 
 var _chunkEGFUVXKKcjs = require('../chunk-EGFUVXKK.cjs');
 require('../chunk-QQKTOA4U.cjs');
-require('../chunk-IOXKXQNW.cjs');
+
+
+
+
+
+var _chunkJODTP4DPcjs = require('../chunk-JODTP4DP.cjs');
 require('../chunk-N3FVUOZD.cjs');
 require('../chunk-GUZ47CJM.cjs');
 require('../chunk-RIWPYSKU.cjs');
@@ -1483,6 +1490,7 @@ function varyStroke(stroke, m, v) {
 // src/paint-editor/render.ts
 var PAPER_NODE_ID = "__paper";
 var TRACING_NODE_ID = "__tracing";
+var PAPER_EFFECT_NODE_ID = "__paper_effect";
 function paperKey(p, light) {
   const metal = _nullishCoalesce(p.metallic, () => ( 0));
   return JSON.stringify([p.pattern, p.seed, p.color, p.scale, p.tiling, p.shading, p.dry, metal, metal > 0 && light ? [light.azimuth, light.elevation] : null]);
@@ -3161,7 +3169,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: _chunkUXFI3CDZcjs.toVideoFfmpeg.call(void 0, video, { output: "timelapse.mp4" }), durationMs };
+  return { video, ffmpeg: _chunkSFCPGMCTcjs.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)))));
@@ -3216,6 +3224,130 @@ ${tl.ffmpeg.command}
   return _chunkCOAMRKVIcjs.writeZip.call(void 0, entries, { compression: "store" });
 }
 
+// src/paint-editor/effects.ts
+var PAINT_EFFECT_PLACES = {
+  /** Effect paper: drawn over the whole sheet. */
+  paper: ["generator"],
+  /** An effect layer: drawn at the canvas size. */
+  layer: ["generator", "overlay", "title"],
+  /** An effect fill: composited onto a layer's pixels. */
+  fill: ["generator", "overlay", "title"],
+  /** Light (or any filter) on a layer's dried paint. */
+  light: ["filter"]
+};
+var PLACE_WORDS = {
+  paper: "effect paper takes generator effects",
+  layer: "an effect layer takes generator, overlay or title effects",
+  fill: "an effect fill takes generator, overlay or title effects",
+  light: "light on dried paint takes filter effects"
+};
+function checkPaintEffectPlace(d, place) {
+  const allowed = PAINT_EFFECT_PLACES[place];
+  if (d.kind !== "motion" && d.kind !== "vector" && d.uses.some((u) => allowed.includes(u))) return;
+  let instead = "";
+  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, _chunkJODTP4DPcjs.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;
+function nextPaperEffectVersion() {
+  return paperVersion++;
+}
+function overPixels(base, top, opacity = 1) {
+  const out = new Uint8ClampedArray(base.length);
+  for (let i = 0; i < out.length; i += 4) {
+    const ta = top[i + 3] / 255 * opacity;
+    const ba = base[i + 3] / 255;
+    const a = ta + ba * (1 - ta);
+    out[i + 3] = Math.round(a * 255);
+    if (a > 0) for (let c = 0; c < 3; c++) out[i + c] = (top[i + c] * ta + base[i + c] * ba * (1 - ta)) / a;
+  }
+  return out;
+}
+function mixPixels(before, after, amount) {
+  const out = new Uint8ClampedArray(before.length);
+  for (let i = 0; i < out.length; i += 4) {
+    for (let c = 0; c < 3; c++) out[i + c] = before[i + c] + (after[i + c] - before[i + c]) * amount;
+    out[i + 3] = before[i + 3];
+  }
+  return out;
+}
+var PaintEffectsRenderer = (_class9 = class {constructor() { _class9.prototype.__init69.call(this);_class9.prototype.__init70.call(this);_class9.prototype.__init71.call(this); }
+  __init69() {this.pool = new (0, _chunkW6QTLHZ3cjs.EffectRendererPool)({ maxRenderers: 3 })}
+  __init70() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init71() {this.provider = null}
+  /** Forgets cached descriptions and renderers when the provider changes. */
+  follow(provider) {
+    if (provider === this.provider) return;
+    this.provider = provider;
+    this.descriptions.clear();
+    this.pool.clear();
+  }
+  describe(provider, id) {
+    this.follow(provider);
+    let d = this.descriptions.get(id);
+    if (!d) {
+      d = Promise.resolve().then(() => provider.describe(id));
+      d.catch(() => this.descriptions.delete(id));
+      this.descriptions.set(id, d);
+    }
+    return d;
+  }
+  async render(provider, id, size, request) {
+    this.follow(provider);
+    const out = await this.pool.render(provider, id, { ...size, depth: 8 }, request);
+    if (out.width !== size.width || out.height !== size.height || out.data.length !== size.width * size.height * 4) {
+      throw new Error(`The effect "${id}" returned ${out.width}\xD7${out.height} pixels for a ${size.width}\xD7${size.height} canvas.`);
+    }
+    return out;
+  }
+  dispose() {
+    this.pool.clear();
+    this.descriptions.clear();
+  }
+}, _class9);
+var sourceOut = (s) => ({
+  effect: s.effect,
+  ...s.provider ? { provider: s.provider } : {},
+  ...s.name ? { name: s.name } : {},
+  values: JSON.parse(JSON.stringify(s.values)),
+  ...s.time ? { time: s.time } : {}
+});
+function readPaintEffectSource(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.effect !== "string" || !r.effect || !r.values || typeof r.values !== "object" || Array.isArray(r.values)) return null;
+  return {
+    effect: r.effect,
+    ...typeof r.provider === "string" ? { provider: r.provider } : {},
+    ...typeof r.name === "string" ? { name: r.name } : {},
+    values: r.values,
+    ...typeof r.time === "number" && r.time > 0 ? { time: r.time } : {}
+  };
+}
+function paperEffectToJSON(p) {
+  return { ...sourceOut(p), opacity: p.opacity, blend: p.blend, png: _chunkDCLJNVZScjs.pngDataUrl.call(void 0, p.image.width, p.image.height, p.image.data) };
+}
+function paperEffectFromJSON(raw, width, height) {
+  const source = readPaintEffectSource(raw);
+  if (!source) throw new Error("it is not an effect (effect id and values)");
+  const r = raw;
+  const parsed = typeof r.png === "string" ? _chunkDCLJNVZScjs.parseDataUrl.call(void 0, r.png) : null;
+  if (!parsed) throw new Error("its pixels are missing");
+  const image = _chunkDCLJNVZScjs.decodePng.call(void 0, parsed.bytes);
+  if (image.width !== width || image.height !== height) throw new Error(`its pixels are ${image.width}\xD7${image.height}, not the canvas size ${width}\xD7${height}`);
+  const opacity = typeof r.opacity === "number" && r.opacity >= 0 && r.opacity <= 1 ? r.opacity : 1;
+  const blend = PAPER_EFFECT_BLENDS.includes(r.blend) ? r.blend : "multiply";
+  return { ...source, opacity, blend, image: { width, height, data: new Uint8ClampedArray(image.data) }, version: nextPaperEffectVersion() };
+}
+function effectLayersToJSON(map, keep) {
+  const out = {};
+  for (const [id, s] of Object.entries(map)) if (keep(id)) out[id] = sourceOut(s);
+  return Object.keys(out).length ? out : void 0;
+}
+
 // src/paint-editor/controller.ts
 var PaintEditorError = class extends Error {
   constructor(message) {
@@ -3243,55 +3375,59 @@ function unionRect(a, b) {
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
 var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _158 => _158.type]) === "pixel";
-var PaintEditorController = (_class9 = class _PaintEditorController {
+var PaintEditorController = (_class10 = class _PaintEditorController {
   
-  __init69() {this.extensions = {}}
-  __init70() {this.undoStack = []}
-  __init71() {this.redoStack = []}
+  __init72() {this.extensions = {}}
+  __init73() {this.undoStack = []}
+  __init74() {this.redoStack = []}
   
   
   
   /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
-  __init72() {this.library = null}
+  __init75() {this.library = null}
   
-  __init73() {this.secondaryColor = "#ffffff"}
+  __init76() {this.secondaryColor = "#ffffff"}
   /** Gradient paint chosen with `setPaint` (`null`: the paint colour). */
-  __init74() {this.gradient = null}
-  __init75() {this.mixerLoad = _chunk6GFRKLLScjs.EMPTY_MIXER_LOAD}
-  __init76() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  __init77() {this.gradient = null}
+  __init78() {this.mixerLoad = _chunk6GFRKLLScjs.EMPTY_MIXER_LOAD}
+  __init79() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
   
   
-  __init77() {this.listeners = /* @__PURE__ */ new Set()}
-  __init78() {this.version = 0}
-  __init79() {this.cached = null}
-  __init80() {this.session = null}
-  __init81() {this.live = null}
-  __init82() {this.liveLayers = null}
-  __init83() {this.dirty = "all"}
-  __init84() {this.seedCounter = 1}
-  __init85() {this.strokeCounter = 1}
+  __init80() {this.listeners = /* @__PURE__ */ new Set()}
+  __init81() {this.version = 0}
+  __init82() {this.cached = null}
+  __init83() {this.session = null}
+  __init84() {this.live = null}
+  __init85() {this.liveLayers = null}
+  __init86() {this.dirty = "all"}
+  __init87() {this.seedCounter = 1}
+  __init88() {this.strokeCounter = 1}
   
-  __init86() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init87() {this.pad = new MixingPad()}
-  __init88() {this.savedPads = []}
-  __init89() {this.nextPadId = 1}
-  __init90() {this.tracingVersion = 1}
-  __init91() {this.tracingCache = null}
-  __init92() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init93() {this.nextReferenceId = 1}
-  __init94() {this.viewCompositor = createPaintCompositor()}
-  __init95() {this.exportCompositor = createPaintCompositor()}
+  __init89() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init90() {this.pad = new MixingPad()}
+  __init91() {this.savedPads = []}
+  __init92() {this.nextPadId = 1}
+  __init93() {this.tracingVersion = 1}
+  __init94() {this.tracingCache = null}
+  __init95() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init96() {this.nextReferenceId = 1}
+  __init97() {this.viewCompositor = createPaintCompositor()}
+  __init98() {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). */
-  __init96() {this.lighting = { ...DEFAULT_LIGHTING }}
-  __init97() {this.litCaches = /* @__PURE__ */ new Map()}
+  __init99() {this.lighting = { ...DEFAULT_LIGHTING }}
+  __init100() {this.litCaches = /* @__PURE__ */ new Map()}
   /** The live impasto stroke's channels. */
-  __init98() {this.liveThick = null}
+  __init101() {this.liveThick = null}
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
-  __init99() {this.wetOp = null}
-  constructor(options = {}) {;_class9.prototype.__init69.call(this);_class9.prototype.__init70.call(this);_class9.prototype.__init71.call(this);_class9.prototype.__init72.call(this);_class9.prototype.__init73.call(this);_class9.prototype.__init74.call(this);_class9.prototype.__init75.call(this);_class9.prototype.__init76.call(this);_class9.prototype.__init77.call(this);_class9.prototype.__init78.call(this);_class9.prototype.__init79.call(this);_class9.prototype.__init80.call(this);_class9.prototype.__init81.call(this);_class9.prototype.__init82.call(this);_class9.prototype.__init83.call(this);_class9.prototype.__init84.call(this);_class9.prototype.__init85.call(this);_class9.prototype.__init86.call(this);_class9.prototype.__init87.call(this);_class9.prototype.__init88.call(this);_class9.prototype.__init89.call(this);_class9.prototype.__init90.call(this);_class9.prototype.__init91.call(this);_class9.prototype.__init92.call(this);_class9.prototype.__init93.call(this);_class9.prototype.__init94.call(this);_class9.prototype.__init95.call(this);_class9.prototype.__init96.call(this);_class9.prototype.__init97.call(this);_class9.prototype.__init98.call(this);_class9.prototype.__init99.call(this);_class9.prototype.__init100.call(this);_class9.prototype.__init101.call(this);_class9.prototype.__init102.call(this);
+  __init102() {this.wetOp = null}
+  /** The effects provider slot (see `setEffectsProvider`). */
+  __init103() {this.effects = new (0, _chunkJODTP4DPcjs.EffectsSlot)()}
+  __init104() {this.effectsRenderer = new PaintEffectsRenderer()}
+  __init105() {this.paperEffectNodeCache = null}
+  constructor(options = {}) {;_class10.prototype.__init72.call(this);_class10.prototype.__init73.call(this);_class10.prototype.__init74.call(this);_class10.prototype.__init75.call(this);_class10.prototype.__init76.call(this);_class10.prototype.__init77.call(this);_class10.prototype.__init78.call(this);_class10.prototype.__init79.call(this);_class10.prototype.__init80.call(this);_class10.prototype.__init81.call(this);_class10.prototype.__init82.call(this);_class10.prototype.__init83.call(this);_class10.prototype.__init84.call(this);_class10.prototype.__init85.call(this);_class10.prototype.__init86.call(this);_class10.prototype.__init87.call(this);_class10.prototype.__init88.call(this);_class10.prototype.__init89.call(this);_class10.prototype.__init90.call(this);_class10.prototype.__init91.call(this);_class10.prototype.__init92.call(this);_class10.prototype.__init93.call(this);_class10.prototype.__init94.call(this);_class10.prototype.__init95.call(this);_class10.prototype.__init96.call(this);_class10.prototype.__init97.call(this);_class10.prototype.__init98.call(this);_class10.prototype.__init99.call(this);_class10.prototype.__init100.call(this);_class10.prototype.__init101.call(this);_class10.prototype.__init102.call(this);_class10.prototype.__init103.call(this);_class10.prototype.__init104.call(this);_class10.prototype.__init105.call(this);_class10.prototype.__init106.call(this);_class10.prototype.__init107.call(this);_class10.prototype.__init108.call(this);
     this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
     this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunkW4LNKTHTcjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
@@ -3404,6 +3540,21 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     this.trimWetHistory();
     this.emit();
   }
+  /**
+   * Commits `next` as a new undo step, or with `commitToHistory` false folds it into the last step
+   * when that step has the same label (the later values of one slider drag).
+   */
+  commitOrAmend(label, next, commitToHistory) {
+    const last = this.undoStack[this.undoStack.length - 1];
+    if (commitToHistory || !last || last.label !== label || last.wet || this.wetOp) {
+      this.commit(label, next);
+      return;
+    }
+    last.after = next;
+    this.redoStack = [];
+    this.doc = next;
+    this.emit();
+  }
   /** Keeps the wet snapshots in history within the wet undo memory, dropping the oldest. */
   trimWetHistory() {
     const seen = /* @__PURE__ */ new Set();
@@ -3440,7 +3591,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     return wetIds;
   }
   /** Records a wet event (for replays) in the document being built. */
-  __init100() {this.pendingWetEvents = []}
+  __init106() {this.pendingWetEvents = []}
   logWet(e) {
     this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _171 => _171.wet, 'access', _172 => _172.world, 'optionalAccess', _173 => _173.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
   }
@@ -3812,6 +3963,257 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     }
     return new (0, _chunkJ5BA3BQ6cjs.TiledSurface)(4, tiles, 0);
   }
+  // --- Provider effects ------------------------------------------------------------
+  /** The registered effects provider, or `null`. */
+  get effectsProvider() {
+    return this.effects.provider;
+  }
+  /** Registers (or with `null` removes) the effects provider. Not an edit: no undo step. */
+  setEffectsProvider(provider) {
+    this.effects.set(provider);
+  }
+  /** Registers `provider` and returns a function that removes it again (if it is still the one set). */
+  useEffects(provider) {
+    return this.effects.use(provider);
+  }
+  /** The provider's description of an effect, checked for `place` (rejects without a provider or for an unknown id). */
+  async describeEffect(effect, place) {
+    const d = await this.effectsRenderer.describe(this.effects.require(), effect);
+    if (place) checkPaintEffectPlace(d, place);
+    return d;
+  }
+  /** Every effect layer (top first) with its effect. */
+  listEffectLayers() {
+    const map = _nullishCoalesce(this.doc.effectLayers, () => ( {}));
+    return this.listLayers().filter((l) => map[l.id]).map((l) => ({ layerId: l.id, name: l.name, source: map[l.id] }));
+  }
+  /** The effect a layer is drawn from, or `undefined` for other layers. */
+  getEffectLayer(layerId) {
+    return _chunkMZXQTKUMcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _203 => _203.doc, 'access', _204 => _204.effectLayers, 'optionalAccess', _205 => _205[layerId]]) : void 0;
+  }
+  /** The effect paper (without its pixels), or `null`. */
+  getPaperEffect() {
+    const p = this.doc.paperEffect;
+    if (!p) return null;
+    const { image: _i, version: _v, ...rest } = p;
+    return { ...rest, values: { ...rest.values } };
+  }
+  /** Values over `base` (`null` resets a control to its default), checked against the effect's controls. */
+  effectValues(d, base, changes) {
+    const merged = { ...base };
+    const given = {};
+    for (const [k, v] of Object.entries(_nullishCoalesce(changes, () => ( {})))) {
+      if (!(k in d.controls.properties)) throw new PaintEditorError(`"${k}" is not a control of "${d.id}"; its controls are ${Object.keys(d.controls.properties).join(", ") || "none"} (describe_effect).`);
+      if (v === null) merged[k] = d.defaults[k];
+      else given[k] = v;
+    }
+    return { ...merged, ..._chunkJODTP4DPcjs.resolveEffectValues.call(void 0, { ...d, defaults: merged }, given) };
+  }
+  /** Renders a generator, overlay or title effect at the canvas size. */
+  renderEffectCanvas(d, values, time = 0) {
+    const { width, height } = this.doc.canvas;
+    return this.effectsRenderer.render(this.effects.require(), d.id, { width, height }, { time, values });
+  }
+  sourceOf(d, values, time) {
+    return { effect: d.id, provider: this.effects.require().id, name: d.name, values, ...time ? { time } : {} };
+  }
+  checkTime(time) {
+    if (time !== void 0 && !(Number.isFinite(time) && time >= 0)) throw new PaintEditorError(`time ${time} is not a moment of the effect; use 0 or more milliseconds.`);
+  }
+  checkOpacity(opacity) {
+    if (opacity !== void 0 && !(opacity >= 0 && opacity <= 1)) throw new PaintEditorError(`opacity ${opacity} is out of range; use 0..1.`);
+  }
+  /** 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', _206 => _206.doc, 'access', _207 => _207.stickers, 'optionalAccess', _208 => _208[l.id], 'optionalAccess', _209 => _209.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_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;
+  }
+  /** After an effect rendered: the layer must be as it was when the render started. */
+  sameLayerAfterRender(before) {
+    this.requireIdle("applying an effect");
+    const now = this.getLayer(before.id);
+    if (!isPixelLayer(now)) throw new PaintEditorError(`Layer "${before.name}" was removed while the effect rendered.`);
+    if (now.surface !== before.surface || now.offset.x !== before.offset.x || now.offset.y !== before.offset.y) throw new PaintEditorError(`Layer "${before.name}" changed while the effect rendered; apply the effect again.`);
+    return now;
+  }
+  /** The canvas rectangle in a layer's own coordinates. */
+  canvasRectOf(l) {
+    return { x: -l.offset.x, y: -l.offset.y, width: this.doc.canvas.width, height: this.doc.canvas.height };
+  }
+  /**
+   * Sets the effect paper: a provider generator drawn over the paper and under the paint, at the
+   * canvas size (`multiply` by default, so the paper's colour and grain still show). `null` removes
+   * it. One undo step. Returns the effect paper (without pixels), or `null`.
+   */
+  async setPaperEffect(effect, options = {}) {
+    this.requireIdle("changing the paper");
+    if (effect === null) {
+      if (!this.doc.paperEffect) return null;
+      const { paperEffect: _p, ...rest } = this.doc;
+      this.commit("Remove effect paper", rest);
+      return null;
+    }
+    this.checkOpacity(options.opacity);
+    this.checkTime(options.time);
+    if (options.blend !== void 0 && !PAPER_EFFECT_BLENDS.includes(options.blend)) throw new PaintEditorError(`Unknown effect paper blend "${options.blend}"; use ${PAPER_EFFECT_BLENDS.join(", ")}.`);
+    const d = await this.describeEffect(effect, "paper");
+    const values = this.effectValues(d, { ...d.defaults }, options.values);
+    const pixels = await this.renderEffectCanvas(d, values, options.time);
+    this.requireIdle("changing the paper");
+    const was = this.doc.paperEffect;
+    const paperEffect = {
+      ...this.sourceOf(d, values, options.time),
+      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _210 => _210.opacity]))), () => ( 1)),
+      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _211 => _211.blend]))), () => ( "multiply")),
+      image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) },
+      version: nextPaperEffectVersion()
+    };
+    this.commit("Effect paper", { ...this.doc, paperEffect });
+    return this.getPaperEffect();
+  }
+  /**
+   * Changes the effect paper: new control `values` (merged over its own; `null` resets one) or
+   * `time` draw it again at the canvas size; `opacity` and `blend` only change how it is drawn.
+   * One undo step; with `commitToHistory` false it joins the previous effect paper step (a slider
+   * drag). Returns the effect paper (without pixels).
+   */
+  async updatePaperEffect(changes, commitToHistory = true) {
+    this.requireIdle("changing the paper");
+    const was = this.doc.paperEffect;
+    if (!was) throw new PaintEditorError("There is no effect paper; set one with set_paper_effect.");
+    this.checkOpacity(changes.opacity);
+    this.checkTime(changes.time);
+    if (changes.blend !== void 0 && !PAPER_EFFECT_BLENDS.includes(changes.blend)) throw new PaintEditorError(`Unknown effect paper blend "${changes.blend}"; use ${PAPER_EFFECT_BLENDS.join(", ")}.`);
+    let next = { ...was, ...changes.opacity !== void 0 ? { opacity: changes.opacity } : {}, ...changes.blend !== void 0 ? { blend: changes.blend } : {} };
+    const { width, height } = this.doc.canvas;
+    if (changes.values !== void 0 || changes.time !== void 0 || was.image.width !== width || was.image.height !== height) {
+      const d = await this.describeEffect(was.effect, "paper");
+      const values = this.effectValues(d, was.values, changes.values);
+      const time = _nullishCoalesce(_nullishCoalesce(changes.time, () => ( was.time)), () => ( 0));
+      const pixels = await this.renderEffectCanvas(d, values, time);
+      this.requireIdle("changing the paper");
+      if (this.doc.paperEffect !== was) throw new PaintEditorError("The effect paper changed while it rendered; change it again.");
+      next = { ...next, ...this.sourceOf(d, values, time), image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) }, version: nextPaperEffectVersion() };
+      if (!time) delete next.time;
+    }
+    this.commitOrAmend("Effect paper", { ...this.doc, paperEffect: next }, commitToHistory);
+    return this.getPaperEffect();
+  }
+  /**
+   * Adds an effect layer above the active layer (or `aboveId`): a pixel layer drawn by a provider
+   * generator, overlay or title effect at the canvas size. It keeps its effect, so
+   * `updateEffectLayer` draws it again. One undo step. Returns the layer and its effect.
+   */
+  async addEffectLayer(effect, options = {}) {
+    this.requireIdle("adding a layer");
+    this.checkOpacity(options.opacity);
+    this.checkTime(options.time);
+    if (options.blend !== void 0 && !_chunkJ5BA3BQ6cjs.isBlendMode.call(void 0, options.blend)) throw new PaintEditorError(`Unknown blend mode "${options.blend}". Call get_canvas_info for the blend modes.`);
+    if (options.aboveId !== void 0) this.requireLayer(options.aboveId);
+    const d = await this.describeEffect(effect, "layer");
+    const values = this.effectValues(d, { ...d.defaults }, options.values);
+    const pixels = await this.renderEffectCanvas(d, values, options.time);
+    this.requireIdle("adding a layer");
+    const above = _nullishCoalesce(options.aboveId, () => ( this.doc.activeLayerId));
+    const loc = above ? _chunkMZXQTKUMcjs.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', _212 => _212.name, 'optionalAccess', _213 => _213.trim, 'call', _214 => _214()]) || d.name), surface: _chunkJ5BA3BQ6cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
+    const layers = _chunkMZXQTKUMcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _215 => _215.parent, 'optionalAccess', _216 => _216.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 };
+  }
+  /**
+   * Draws an effect layer again with new `values` (merged over its own; `null` resets one) or
+   * `time`, at the canvas size, replacing its pixels (paint on it is lost). One undo step; with
+   * `commitToHistory` false it joins the previous effect layer step (a slider drag).
+   */
+  async updateEffectLayer(layerId, changes, commitToHistory = true) {
+    this.requireIdle("changing an effect layer");
+    const was = this.getEffectLayer(layerId);
+    if (!was) throw new PaintEditorError(`"${layerId}" is not an effect layer; add one with add_effect_layer.`);
+    this.checkTime(changes.time);
+    const l = this.effectTarget(layerId, "draw the effect on");
+    const d = await this.describeEffect(was.effect, "layer");
+    const values = this.effectValues(d, was.values, changes.values);
+    const time = _nullishCoalesce(_nullishCoalesce(changes.time, () => ( was.time)), () => ( 0));
+    const pixels = await this.renderEffectCanvas(d, values, time);
+    const now = this.getLayer(l.id);
+    this.requireIdle("changing an effect layer");
+    if (!isPixelLayer(now)) throw new PaintEditorError(`Layer "${l.name}" was removed while the effect rendered.`);
+    const source = this.sourceOf(d, values, time);
+    this.commitOrAmend("Effect layer", { ...this.doc, layers: _chunkMZXQTKUMcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...now, surface: _chunkJ5BA3BQ6cjs.surfaceFromPixels.call(void 0, pixels, 4), offset: { x: 0, y: 0 } })), effectLayers: { ..._nullishCoalesce(this.doc.effectLayers, () => ( {})), [l.id]: source } }, commitToHistory);
+    return source;
+  }
+  /** Turns an effect layer into a plain pixel layer, keeping its pixels (one undo step). */
+  rasterizeEffectLayer(layerId) {
+    this.requireIdle("changing an effect layer");
+    if (!this.getEffectLayer(layerId)) throw new PaintEditorError(`"${layerId}" is not an effect layer; list_applied_effects lists them.`);
+    const { [layerId]: _gone, ...rest } = _nullishCoalesce(this.doc.effectLayers, () => ( {}));
+    this.commit("Rasterize effect layer", { ...this.doc, effectLayers: rest });
+    return this.describeLayer(this.requireLayer(layerId));
+  }
+  /**
+   * Fills a layer with a provider generator, overlay or title effect: its pixels, rendered at the
+   * canvas size, are composited onto the layer's paint at `opacity` (only where it is already
+   * painted with `lockTransparency`, or when the layer's transparency is locked). One undo step.
+   */
+  async fillLayerWithEffect(effect, options = {}) {
+    this.requireIdle("filling");
+    this.checkOpacity(options.opacity);
+    this.checkTime(options.time);
+    const l = this.effectTarget(options.layerId, "fill");
+    const d = await this.describeEffect(effect, "fill");
+    const values = this.effectValues(d, { ...d.defaults }, options.values);
+    const pixels = await this.renderEffectCanvas(d, values, options.time);
+    const now = this.sameLayerAfterRender(l);
+    const rect = this.canvasRectOf(now);
+    const before = _chunkJ5BA3BQ6cjs.readRegion.call(void 0, now.surface, rect);
+    let after = overPixels(before, pixels.data, _nullishCoalesce(options.opacity, () => ( 1)));
+    if (options.lockTransparency || _chunkMZXQTKUMcjs.isLayerLocked.call(void 0, now, "transparency")) after = mixPixels(before, after, 1);
+    const surface = _chunkJ5BA3BQ6cjs.writeRegion.call(void 0, now.surface, rect, after);
+    this.commit("Effect fill", { ...this.doc, layers: _chunkMZXQTKUMcjs.mapLayer.call(void 0, this.doc.layers, now.id, () => ({ ...now, surface })) });
+    return { layerId: now.id, source: this.sourceOf(d, values, options.time) };
+  }
+  /**
+   * Runs a filter effect (light, glow, colour grade …) on a layer's dried paint and bakes it in, at
+   * `amount` strength (0..1, default 1). Transparent areas stay transparent; thick paint keeps its
+   * relief, and an effect with a `height` input gets the relief as a height map. Wet paint is
+   * refused (dry it first). One undo step.
+   */
+  async applyLightEffect(layerId, effect, options = {}) {
+    this.requireIdle("applying an effect");
+    const amount = _nullishCoalesce(options.amount, () => ( 1));
+    if (!(amount >= 0 && amount <= 1)) throw new PaintEditorError(`amount ${options.amount} is out of range; use 0..1.`);
+    this.checkTime(options.time);
+    const l = this.effectTarget(layerId, "light");
+    if (!_chunkJ5BA3BQ6cjs.contentBounds.call(void 0, l.surface)) throw new PaintEditorError(`Layer "${l.name}" has no paint to light; paint on it first, or add an effect layer (add_effect_layer).`);
+    const d = await this.describeEffect(effect, "light");
+    const values = this.effectValues(d, { ...d.defaults }, options.values);
+    const rect = this.canvasRectOf(l);
+    const before = _chunkJ5BA3BQ6cjs.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', _217 => _217.doc, 'access', _218 => _218.thick, 'optionalAccess', _219 => _219[l.id]]);
+    if (heightInput && relief) {
+      const h = _chunkJ5BA3BQ6cjs.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', _220 => _220.inputs, 'access', _221 => _221.find, 'call', _222 => _222((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _223 => _223.name])), 'optionalAccess', _224 => _224.name]), () => ( "source"));
+    if (sourceInput !== "source") {
+      inputs[sourceInput] = inputs.source;
+      delete inputs.source;
+    }
+    const out = await this.effectsRenderer.render(this.effects.require(), d.id, { width: rect.width, height: rect.height }, { time: _nullishCoalesce(options.time, () => ( 0)), values, inputs });
+    const now = this.sameLayerAfterRender(l);
+    const surface = _chunkJ5BA3BQ6cjs.writeRegion.call(void 0, now.surface, rect, mixPixels(before, out.data, amount));
+    this.commit("Light effect", { ...this.doc, layers: _chunkMZXQTKUMcjs.mapLayer.call(void 0, this.doc.layers, now.id, () => ({ ...now, surface })) });
+    return { layerId: now.id, source: this.sourceOf(d, values, options.time), amount };
+  }
   // --- Brushes -------------------------------------------------------------------
   findBrush(id) {
     return _nullishCoalesce(_chunkW4LNKTHTcjs.BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
@@ -4054,7 +4456,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
       return l;
     })();
     const brush = this.strokeBrush(init);
-    const stickerLayer = Boolean(_optionalChain([doc, 'access', _203 => _203.stickers, 'optionalAccess', _204 => _204[layer.id], 'optionalAccess', _205 => _205.length]));
+    const stickerLayer = Boolean(_optionalChain([doc, 'access', _225 => _225.stickers, 'optionalAccess', _226 => _226[layer.id], 'optionalAccess', _227 => _227.length]));
     if (brush.engine === "sticker") {
       if (!stickerLayer && _chunkJ5BA3BQ6cjs.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) {
@@ -4104,7 +4506,7 @@ var PaintEditorController = (_class9 = 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', _206 => _206.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _228 => _228.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;
@@ -4133,7 +4535,7 @@ var PaintEditorController = (_class9 = 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', _207 => _207.thick, 'optionalAccess', _208 => _208[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _229 => _229.thick, 'optionalAccess', _230 => _230[layer.id]]), () => ( emptyThickChannels())) } : void 0,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc) } : void 0,
       paint: this.strokeGradient(init, brush, color)
     });
@@ -4170,12 +4572,12 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
-        if (_optionalChain([this, 'access', _209 => _209.session, 'optionalAccess', _210 => _210.init, 'access', _211 => _211.wet])) {
+        if (_optionalChain([this, 'access', _231 => _231.session, 'optionalAccess', _232 => _232.init, 'access', _233 => _233.wet])) {
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
-        const ch = _optionalChain([this, 'access', _212 => _212.session, 'optionalAccess', _213 => _213.thickChannels, 'call', _214 => _214()]);
+        const ch = _optionalChain([this, 'access', _234 => _234.session, 'optionalAccess', _235 => _235.thickChannels, 'call', _236 => _236()]);
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
@@ -4187,7 +4589,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
         const wetStroke = Boolean(s.init.wet);
         if (wetStroke) this.wet.driver = null;
         const brush = s.init.brush;
-        if (!cancelled && _optionalChain([s, 'access', _215 => _215.result, 'optionalAccess', _216 => _216.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
+        if (!cancelled && _optionalChain([s, 'access', _237 => _237.result, 'optionalAccess', _238 => _238.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           if (this.wetOp) {
             const snap = this.wetOp.before;
@@ -4212,7 +4614,7 @@ var PaintEditorController = (_class9 = 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', _217 => _217.doc, 'access', _218 => _218.stickers, 'optionalAccess', _219 => _219[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
+        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _239 => _239.doc, 'access', _240 => _240.stickers, 'optionalAccess', _241 => _241[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
         this.commit(`${brush.name} stroke`, this.withWetEvents({ ...this.doc, layers: _chunkMZXQTKUMcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {} }), wetStroke ? before : this.doc);
       }
     };
@@ -4250,7 +4652,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
           layers: _chunkMZXQTKUMcjs.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', _220 => _220.stickers, 'optionalAccess', _221 => _221[l.id]]), () => ( [])), ...sprayed] } } : {}
+          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _242 => _242.stickers, 'optionalAccess', _243 => _243[l.id]]), () => ( [])), ...sprayed] } } : {}
         };
       }
     };
@@ -4308,7 +4710,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _222 => _222.strokeIds, 'optionalAccess', _223 => _223.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _244 => _244.strokeIds, 'optionalAccess', _245 => _245.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.`);
@@ -4384,7 +4786,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const ch = _optionalChain([this, 'access', _224 => _224.doc, 'access', _225 => _225.thick, 'optionalAccess', _226 => _226[id]]);
+    const ch = _optionalChain([this, 'access', _246 => _246.doc, 'access', _247 => _247.thick, 'optionalAccess', _248 => _248[id]]);
     if (!ch) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
@@ -4464,6 +4866,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
   /** Stops the wet simulation's worker threads (call when the editor goes away). */
   dispose() {
     this.wet.destroy();
+    this.effectsRenderer.dispose();
   }
   /** Resolves when wet paint is between steps (edits, undo and exports can run). */
   wetIdle() {
@@ -4488,7 +4891,7 @@ var PaintEditorController = (_class9 = 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', _227 => _227.message]), () => ( _chunkFHPVDTI2cjs.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', _249 => _249.message]), () => ( _chunkFHPVDTI2cjs.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`,
@@ -4573,7 +4976,7 @@ var PaintEditorController = (_class9 = 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', _228 => _228.wet, 'access', _229 => _229.world, 'optionalAccess', _230 => _230.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
+    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _250 => _250.wet, 'access', _251 => _251.world, 'optionalAccess', _252 => _252.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) {
@@ -4640,7 +5043,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
   currentLayers() {
     const live = this.live;
     if (!live) return this.doc.layers;
-    if (_optionalChain([this, 'access', _231 => _231.liveLayers, 'optionalAccess', _232 => _232.key]) === live.surface) return this.liveLayers.layers;
+    if (_optionalChain([this, 'access', _253 => _253.liveLayers, 'optionalAccess', _254 => _254.key]) === live.surface) return this.liveLayers.layers;
     const layers = _chunkMZXQTKUMcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
@@ -4651,11 +5054,19 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     if (!t || !t.visible) return [];
     return [this.tracingNode(t)];
   }
+  /** The effect paper as a compositor layer (one object per effect paper, so caches hold). */
+  paperEffectNode(p) {
+    const c = this.paperEffectNodeCache;
+    if (c && c.image === p.image && c.opacity === p.opacity && c.blend === p.blend) return c;
+    const node = { type: "image", id: PAPER_EFFECT_NODE_ID, name: "Effect paper", visible: true, opacity: p.opacity, blend: p.blend, image: p.image, version: p.version };
+    this.paperEffectNodeCache = node;
+    return node;
+  }
   /** The tracing image resampled onto the canvas (cached until it or the canvas changes). */
   tracingNode(t) {
     const { width, height } = this.doc.canvas;
     const key = this.tracingVersion * 100003 + width * 7 + height;
-    if (_optionalChain([this, 'access', _233 => _233.tracingCache, 'optionalAccess', _234 => _234.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _255 => _255.tracingCache, 'optionalAccess', _256 => _256.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 };
@@ -4682,8 +5093,8 @@ var PaintEditorController = (_class9 = 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', _235 => _235.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _236 => _236[id]]);
-      const l = ch && _optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, out, id), 'optionalAccess', _237 => _237.layer]);
+      const ch = _optionalChain([live, 'optionalAccess', _257 => _257.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _258 => _258[id]]);
+      const l = ch && _optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, out, id), 'optionalAccess', _259 => _259.layer]);
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
@@ -4696,10 +5107,11 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     let layers = this.litLayers((_nullishCoalesce(options.wet, () => ( "display"))) === "dried" ? this.driedLayers() : this.currentLayers());
     if (options.layerIds) {
       const picked = [];
-      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _238 => _238.layer]), () => ( this.requireLayer(id))));
+      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _260 => _260.layer]), () => ( this.requireLayer(id))));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
     const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
+    if (options.paper !== false && this.doc.paperEffect) under.push(this.paperEffectNode(this.doc.paperEffect));
     if (view) under.push(...this.underlayLayers());
     return [...under, ...layers];
   }
@@ -4710,7 +5122,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
    */
   compositeTiles(rect, onTile, options = {}) {
     const dirty = options.dirty === "all" ? void 0 : options.dirty;
-    this.viewCompositor.compositeTiles(this.renderLayers({}, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _239 => _239.live, 'optionalAccess', _240 => _240.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({}, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _261 => _261.live, 'optionalAccess', _262 => _262.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -4774,6 +5186,11 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     for (const [id, list] of Object.entries(_nullishCoalesce(this.doc.stickers, () => ( {})))) if (list.length && _chunkMZXQTKUMcjs.findLayer.call(void 0, this.doc.layers, id)) stickers[id] = list.map((x) => ({ ...x }));
     if (Object.keys(stickers).length) ext.stickers = stickers;
     else delete ext.stickers;
+    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _263 => _263.layer])));
+    if (effectLayers) ext.effectLayers = effectLayers;
+    else delete ext.effectLayers;
+    if (this.doc.paperEffect) ext.paperEffect = paperEffectToJSON(this.doc.paperEffect);
+    else delete ext.paperEffect;
     if (this.lighting.azimuth !== DEFAULT_LIGHTING.azimuth || this.lighting.elevation !== DEFAULT_LIGHTING.elevation || this.lighting.relief !== DEFAULT_LIGHTING.relief) ext.lighting = { ...this.lighting };
     else delete ext.lighting;
     return ext;
@@ -4792,6 +5209,23 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
       }
       if (Object.keys(stickers).length) state = { ...state, stickers };
     }
+    if (ext.effectLayers && typeof ext.effectLayers === "object") {
+      const effectLayers = {};
+      for (const [id, v] of Object.entries(ext.effectLayers)) {
+        if (!isPixelLayer(_optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _264 => _264.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.`);
+      }
+      if (Object.keys(effectLayers).length) state = { ...state, effectLayers };
+    }
+    if (ext.paperEffect !== void 0) {
+      try {
+        state = { ...state, paperEffect: paperEffectFromJSON(ext.paperEffect, state.canvas.width, state.canvas.height) };
+      } catch (e) {
+        problems.push(`The effect paper could not be read (${e.message}); the plain paper shows.`);
+      }
+    }
     const raw = ext.layerChannels;
     if (!raw || typeof raw !== "object") return state;
     const thick = {};
@@ -4819,7 +5253,7 @@ var PaintEditorController = (_class9 = 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', _241 => _241.exec, 'call', _242 => _242(s.id), 'optionalAccess', _243 => _243[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _265 => _265.exec, 'call', _266 => _266(s.id), 'optionalAccess', _267 => _267[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
@@ -4828,6 +5262,8 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     delete this.extensions.layerChannels;
     delete this.extensions.lighting;
     delete this.extensions.stickers;
+    delete this.extensions.effectLayers;
+    delete this.extensions.paperEffect;
     this.viewCompositor.clear();
     this.emit();
     return loaded.problems;
@@ -4910,8 +5346,8 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     const layers = toStandard(dried);
     const result = _chunkO5RVCDECcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
-      const label = _nullishCoalesce(_optionalChain([_chunkJ5BA3BQ6cjs.BLEND_MODES, 'access', _244 => _244.find, 'call', _245 => _245((m) => m.id === mode), 'optionalAccess', _246 => _246.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunkJ5BA3BQ6cjs.BLEND_MODES, 'access', _247 => _247.find, 'call', _248 => _248((m) => m.id === _chunkJ5BA3BQ6cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _249 => _249.label]), () => ( _chunkJ5BA3BQ6cjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunkJ5BA3BQ6cjs.BLEND_MODES, 'access', _268 => _268.find, 'call', _269 => _269((m) => m.id === mode), 'optionalAccess', _270 => _270.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunkJ5BA3BQ6cjs.BLEND_MODES, 'access', _271 => _271.find, 'call', _272 => _272((m) => m.id === _chunkJ5BA3BQ6cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _273 => _273.label]), () => ( _chunkJ5BA3BQ6cjs.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).`);
@@ -5025,9 +5461,9 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
   /** Adds a floating reference image to look at and pick colours from. */
   addReferenceImage(options) {
     const { src, pixels } = this.importImage(options, "The reference image");
-    const ref = {
+    const ref2 = {
       id: `ref${this.nextReferenceId++}`,
-      name: _optionalChain([options, 'access', _250 => _250.name, 'optionalAccess', _251 => _251.trim, 'call', _252 => _252()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _274 => _274.name, 'optionalAccess', _275 => _275.trim, 'call', _276 => _276()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -5036,8 +5472,8 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
       displayWidth: _nullishCoalesce(options.displayWidth, () => ( Math.min(240, pixels.width))),
       visible: true
     };
-    this.setGuides({ ...this.guides, references: [...this.guides.references, ref] });
-    return ref;
+    this.setGuides({ ...this.guides, references: [...this.guides.references, ref2] });
+    return ref2;
   }
   requireReference(id) {
     const r = this.guides.references.find((x) => x.id === id);
@@ -5101,12 +5537,12 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
       }
     }
     if (Array.isArray(r.references)) {
-      for (const ref of r.references) {
-        if (!ref || typeof ref.src !== "string" || typeof ref.id !== "string") continue;
+      for (const ref2 of r.references) {
+        if (!ref2 || typeof ref2.src !== "string" || typeof ref2.id !== "string") continue;
         try {
-          const px = this.decodeImage(ref.src, `Reference "${ref.name}"`);
-          guides.references.push({ id: ref.id, name: String(_nullishCoalesce(ref.name, () => ( ref.id))), src: ref.src, width: px.width, height: px.height, x: Number(ref.x) || 0, y: Number(ref.y) || 0, displayWidth: Number(ref.displayWidth) || 240, visible: ref.visible !== false });
-          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _253 => _253.exec, 'call', _254 => _254(ref.id), 'optionalAccess', _255 => _255[1]]), () => ( 0)));
+          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', _277 => _277.exec, 'call', _278 => _278(ref2.id), 'optionalAccess', _279 => _279[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -5117,7 +5553,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
       guides.stencils = [];
       r.stencils.forEach((raw2, i) => {
         try {
-          const id = typeof _optionalChain([raw2, 'optionalAccess', _256 => _256.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
+          const id = typeof _optionalChain([raw2, 'optionalAccess', _280 => _280.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;
@@ -5140,12 +5576,12 @@ var PaintEditorController = (_class9 = 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', _257 => _257.exec, 'call', _258 => _258(st.id), 'optionalAccess', _259 => _259[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', _281 => _281.exec, 'call', _282 => _282(st.id), 'optionalAccess', _283 => _283[1]]), () => ( 0))));
     return n + 1;
   }
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
-    const stickers = _optionalChain([this, 'access', _260 => _260.doc, 'access', _261 => _261.stickers, 'optionalAccess', _262 => _262[l.id]]);
+    const stickers = _optionalChain([this, 'access', _284 => _284.doc, 'access', _285 => _285.stickers, 'optionalAccess', _286 => _286[l.id]]);
     if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (list_brushes category sticker).`);
     return { layer: l, stickers };
   }
@@ -5154,7 +5590,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return [];
     this.requireLayer(id);
-    return (_nullishCoalesce(_optionalChain([this, 'access', _263 => _263.doc, 'access', _264 => _264.stickers, 'optionalAccess', _265 => _265[id]]), () => ( []))).map((s) => ({ ...s }));
+    return (_nullishCoalesce(_optionalChain([this, 'access', _287 => _287.doc, 'access', _288 => _288.stickers, 'optionalAccess', _289 => _289[id]]), () => ( []))).map((s) => ({ ...s }));
   }
   /** Replaces a layer's stickers and redraws its pixels from them (one undo step). */
   commitStickers(label, layer, stickers) {
@@ -5204,13 +5640,13 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
     this.commitStickers("Stickers", l, stickers.map((s) => ({ ...s })));
   }
   // --- Stencils --------------------------------------------------------------------
-  __init101() {this.stencilCache = null}
-  __init102() {this.nextStencilId = 1}
+  __init107() {this.stencilCache = null}
+  __init108() {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', _266 => _266.stencilCache, 'optionalAccess', _267 => _267.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
+    if (_optionalChain([this, 'access', _290 => _290.stencilCache, 'optionalAccess', _291 => _291.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
     const mask = stencilMask(stencils, width, height);
     this.stencilCache = { key: stencils, size, mask };
     return mask;
@@ -5272,7 +5708,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
   makeSwatch(color, name) {
     const p = typeof color === "string" ? { type: "color", color: parseColor(color) } : this.readStrokePaint(color);
     const out = { color: _chunk6GFRKLLScjs.paintSourceColor.call(void 0, p, { paint: this.color, secondary: this.secondaryColor }) };
-    if (_optionalChain([name, 'optionalAccess', _268 => _268.trim, 'call', _269 => _269()])) out.name = name.trim();
+    if (_optionalChain([name, 'optionalAccess', _292 => _292.trim, 'call', _293 => _293()])) out.name = name.trim();
     if (p.type === "gradient") out.paint = p;
     return out;
   }
@@ -5324,7 +5760,7 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
   mixOnPad(paints, options = {}) {
-    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _270 => _270.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _271 => _271.parts]) }));
+    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _294 => _294.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _295 => _295.parts]) }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -5413,10 +5849,10 @@ var PaintEditorController = (_class9 = class _PaintEditorController {
   }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
-    const l = _optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _272 => _272.layer]);
+    const l = _optionalChain([_chunkMZXQTKUMcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _296 => _296.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
-}, _class9);
+}, _class10);
 var MAX_IMAGE_SIDE = 8192;
 function resampleInto(src, rect, width, height) {
   const out = new Uint8ClampedArray(width * height * 4);
@@ -5467,8 +5903,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', _273 => _273[0], 'optionalAccess', _274 => _274.t]);
-  const t1 = _optionalChain([points, 'access', _275 => _275[points.length - 1], 'optionalAccess', _276 => _276.t]);
+  const t0 = _optionalChain([points, 'access', _297 => _297[0], 'optionalAccess', _298 => _298.t]);
+  const t1 = _optionalChain([points, 'access', _299 => _299[points.length - 1], 'optionalAccess', _300 => _300.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -5522,7 +5958,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _277 => _277.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _278 => _278.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _301 => _301.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _302 => _302.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -5569,8 +6005,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _279 => _279.replay, 'access', _280 => _280.strokeIds, 'optionalAccess', _281 => _281.includes, 'call', _282 => _282(s.id)]));
-        const first = _optionalChain([source, 'access', _283 => _283[0], 'optionalAccess', _284 => _284.points, 'access', _285 => _285[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _303 => _303.replay, 'access', _304 => _304.strokeIds, 'optionalAccess', _305 => _305.includes, 'call', _306 => _306(s.id)]));
+        const first = _optionalChain([source, 'access', _307 => _307[0], 'optionalAccess', _308 => _308.points, 'access', _309 => _309[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);
@@ -6983,7 +7419,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "List brushes", ...READ6 },
     handler: () => {
       const s = c.getState();
-      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _286 => _286.getBrush, 'call', _287 => _287(s.brush.id), 'optionalAccess', _288 => _288.builtin])), brushes: s.brushes.map(brushSummary) };
+      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _310 => _310.getBrush, 'call', _311 => _311(s.brush.id), 'optionalAccess', _312 => _312.builtin])), brushes: s.brushes.map(brushSummary) };
     }
   });
   add({
@@ -7218,7 +7654,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
             color: s.color,
             points: ids ? s.points : s.points.length,
             seed: s.seed,
-            copies: _nullishCoalesce(_optionalChain([s, 'access', _289 => _289.copies, 'optionalAccess', _290 => _290.length]), () => ( 0)),
+            copies: _nullishCoalesce(_optionalChain([s, 'access', _313 => _313.copies, 'optionalAccess', _314 => _314.length]), () => ( 0)),
             bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
           };
         })
@@ -7401,21 +7837,21 @@ var PAINT_TOOLS = [
   { id: "pan", label: "Pan", key: "h" },
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
-var PaintGesture = (_class10 = class {
-  constructor(controller, box) {;_class10.prototype.__init103.call(this);_class10.prototype.__init104.call(this);_class10.prototype.__init105.call(this);_class10.prototype.__init106.call(this);_class10.prototype.__init107.call(this);_class10.prototype.__init108.call(this);
+var PaintGesture = (_class11 = class {
+  constructor(controller, box) {;_class11.prototype.__init109.call(this);_class11.prototype.__init110.call(this);_class11.prototype.__init111.call(this);_class11.prototype.__init112.call(this);_class11.prototype.__init113.call(this);_class11.prototype.__init114.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init103() {this.tool = "brush"}
+  __init109() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init104() {this.error = null}
+  __init110() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init105() {this.predicted = []}
-  __init106() {this.mode = null}
-  __init107() {this.penAt = null}
-  __init108() {this.penDown = false}
+  __init111() {this.predicted = []}
+  __init112() {this.mode = null}
+  __init113() {this.penAt = null}
+  __init114() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -7496,12 +7932,12 @@ var PaintGesture = (_class10 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _291 => _291.controller, 'access', _292 => _292.activeStroke, 'optionalAccess', _293 => _293.end, 'call', _294 => _294()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _315 => _315.controller, 'access', _316 => _316.activeStroke, 'optionalAccess', _317 => _317.end, 'call', _318 => _318()]);
   }
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _295 => _295.mode, 'optionalAccess', _296 => _296.kind]) === "stroke") _optionalChain([this, 'access', _297 => _297.controller, 'access', _298 => _298.activeStroke, 'optionalAccess', _299 => _299.cancel, 'call', _300 => _300()]);
+    if (_optionalChain([this, 'access', _319 => _319.mode, 'optionalAccess', _320 => _320.kind]) === "stroke") _optionalChain([this, 'access', _321 => _321.controller, 'access', _322 => _322.activeStroke, 'optionalAccess', _323 => _323.cancel, 'call', _324 => _324()]);
     this.mode = null;
   }
   get active() {
@@ -7521,7 +7957,7 @@ var PaintGesture = (_class10 = class {
     const py = e.clientY - b.top - b.height / 2;
     this.controller.setView({ zoom, pan: { x: px - (px - s.view.pan.x) * k, y: py - (py - s.view.pan.y) * k } });
   }
-}, _class10);
+}, _class11);
 function handlePaintShortcut(controller, gesture, e) {
   const mod = e.ctrlKey || e.metaKey;
   const key = e.key.toLowerCase();
@@ -7561,14 +7997,14 @@ function handlePaintShortcut(controller, gesture, e) {
   }
   return false;
 }
-var PaintCanvasPresenter = (_class11 = class {
-  constructor(controller) {;_class11.prototype.__init109.call(this);_class11.prototype.__init110.call(this);_class11.prototype.__init111.call(this);
+var PaintCanvasPresenter = (_class12 = class {
+  constructor(controller) {;_class12.prototype.__init115.call(this);_class12.prototype.__init116.call(this);_class12.prototype.__init117.call(this);
     this.controller = controller;
   }
   
-  __init109() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init110() {this.scratch = null}
-  __init111() {this.size = ""}
+  __init115() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init116() {this.scratch = null}
+  __init117() {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;
@@ -7594,7 +8030,7 @@ var PaintCanvasPresenter = (_class11 = class {
     }, { dirty });
     return drawn;
   }
-}, _class11);
+}, _class12);
 function guideOverlay(controller) {
   const s = controller.getState();
   const size = s.document.canvas;
@@ -7635,7 +8071,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _301 => _301[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _325 => _325[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -7757,7 +8193,7 @@ function brushEngineControls(brush) {
         impastoTool: true
       };
     case "wet": {
-      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _302 => _302.wet, 'optionalAccess', _303 => _303.tool]), () => ( "paint"));
+      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _326 => _326.wet, 'optionalAccess', _327 => _327.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 },
@@ -7890,7 +8326,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _304 => _304(id)]);
+    _optionalChain([caf, 'optionalCall', _328 => _328(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {
@@ -7939,6 +8375,190 @@ function quickStencil(kind, canvas) {
   }
 }
 
+// src/paint-editor/effect-tools.ts
+var PAPER_TARGET = "paper";
+var ref = (s) => ({ effect: s.effect, ...s.name ? { name: s.name } : {}, ...s.provider ? { provider: s.provider } : {} });
+function createPaintEffectsToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const ro = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    return ro ? typeof ro === "string" ? ro : "The painting is read-only." : null;
+  };
+  const paperInfo = () => {
+    const p = controller.getPaperEffect();
+    return p ? [{ id: PAPER_TARGET, ...ref(p), role: "effect paper", enabled: true, opacity: p.opacity, blend: p.blend, values: p.values, ...p.time ? { time: p.time } : {} }] : [];
+  };
+  const layerInfo = (layerId) => {
+    const s = controller.getEffectLayer(layerId);
+    return s ? [{ id: "effect", ...ref(s), role: "effect layer", enabled: true, values: s.values, ...s.time ? { time: s.time } : {} }] : [];
+  };
+  const requireLayer = (id) => {
+    const l = controller.getLayer(id);
+    if (!l) {
+      const ids = controller.listLayers().map((x) => `"${x.id}"`);
+      throw new Error(`There is no layer "${id}"; the targets are "${PAPER_TARGET}" and the layers ${ids.join(", ") || "(none)"} (list_layers lists them).`);
+    }
+    return l;
+  };
+  const effectsOf = (target) => target === PAPER_TARGET ? paperInfo() : layerInfo(target);
+  const instanceCheck = (target, instance) => {
+    const want = target === PAPER_TARGET ? PAPER_TARGET : "effect";
+    if (target !== PAPER_TARGET) requireLayer(target);
+    if (instance !== want || !effectsOf(target).length) {
+      const have = effectsOf(target).map((e) => `"${e.id}"`);
+      throw new Error(
+        `${target === PAPER_TARGET ? "The paper" : `Layer "${target}"`} has no provider effect "${instance}"; its effects are ${have.join(", ") || "none"} (list_applied_effects). Light baked into paint is part of the pixels: undo takes it back.`
+      );
+    }
+  };
+  const noStackArgs = (changes) => {
+    if (changes.index !== void 0) throw new Error("index does not apply: the paper and each effect layer have one effect.");
+    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 _chunkJODTP4DPcjs.createEffectToolProvider.call(void 0, {
+    id: _nullishCoalesce(options.id, () => ( "paint-effects")),
+    namespace: options.namespace,
+    target: { noun: "layer", id: `A pixel layer id from list_layers ("${PAPER_TARGET}" is the effect paper, for list, update and remove).` },
+    applyUses: ["filter"],
+    applyDetails: "Light on dried paint: the filter (search_effects with use filter, e.g. a light, glow or grade) runs on the layer's paint at the canvas size and is baked into its pixels; transparent areas stay transparent, and thick paint keeps its relief (an effect with a height input gets it). opacity is the strength (default 1). Wet paint is refused: dry it first (dry_paint). It is one undo step and is not listed afterwards (it is part of the pixels). Generators go on the paper (set_paper_effect), on their own layer (add_effect_layer) or into a layer (fill_layer_with_effect).",
+    provider: () => controller.effectsProvider,
+    readOnlyReason,
+    list: (target) => {
+      if (target === PAPER_TARGET) return [{ target: PAPER_TARGET, name: "Paper", effects: paperInfo() }];
+      if (target) {
+        const l = requireLayer(target);
+        return [{ target, name: l.name, effects: layerInfo(target) }];
+      }
+      const out = [];
+      if (paperInfo().length) out.push({ target: PAPER_TARGET, name: "Paper", effects: paperInfo() });
+      for (const e of controller.listEffectLayers()) out.push({ target: e.layerId, name: e.name, effects: layerInfo(e.layerId) });
+      return out;
+    },
+    apply: async (target, effect, args) => {
+      if (target === PAPER_TARGET) throw new Error("The paper takes generator effects through set_paper_effect; apply_effect runs a filter on a layer's paint.");
+      noStackArgs(args);
+      requireLayer(target);
+      const r = await controller.applyLightEffect(target, effect, { values: values(args.values), amount: args.opacity });
+      const applied = { id: "light", ...ref(r.source), role: "baked light", enabled: true, opacity: r.amount, values: r.source.values };
+      return { target, effect: applied, effects: layerInfo(target), baked: true };
+    },
+    update: async (target, instance, changes) => {
+      instanceCheck(target, instance);
+      noStackArgs(changes);
+      if (target === PAPER_TARGET) {
+        await controller.updatePaperEffect({ values: changes.values, opacity: changes.opacity });
+        const effects2 = paperInfo();
+        return { target, effect: effects2[0], effects: effects2 };
+      }
+      if (changes.opacity !== void 0) throw new Error("An effect layer's opacity is the layer's: change it with update_layer.");
+      await controller.updateEffectLayer(target, { values: changes.values });
+      const effects = layerInfo(target);
+      return { target, effect: effects[0], effects };
+    },
+    remove: async (target, instance) => {
+      instanceCheck(target, instance);
+      const was = effectsOf(target)[0];
+      if (target === PAPER_TARGET) await controller.setPaperEffect(null);
+      else controller.rasterizeEffectLayer(target);
+      return { target, effect: was, effects: [], ...target === PAPER_TARGET ? {} : { keptPixels: true } };
+    },
+    subscribe: (notify) => {
+      const a = controller.subscribe(() => notify());
+      const b = controller.effects.subscribe(() => notify());
+      return () => {
+        a();
+        b();
+      };
+    },
+    extraTools: (ctx) => [
+      {
+        name: "set_paper_effect",
+        title: "Set the effect paper",
+        description: `Draws a provider generator (search_effects with use generator) over the paper and under the paint, at the canvas size: multiplied by default, so the paper's colour and grain still show. Replaces any effect paper; it is saved and exported with the painting. effect null removes it. One undo step. Returns the effect paper (update_effect / remove_effect with target and effect "paper" change it later).`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            effect: { anyOf: [ctx.effectIdSchema(["generator"]), { type: "null" }], description: "A generator effect id from search_effects, or null to remove the effect paper." },
+            values: ctx.valuesSchema("Control values over the effect's defaults"),
+            opacity: { type: "number", minimum: 0, maximum: 1, description: "Strength 0\u20131 (default 1, or the current effect paper's)." },
+            blend: { type: "string", enum: [...PAPER_EFFECT_BLENDS], description: "How it draws over the paper (default multiply, which keeps the paper's grain; normal covers it)." },
+            time: { type: "number", minimum: 0, description: "Which moment of an animated effect to draw, in ms (default 0)." }
+          },
+          required: ["effect"],
+          additionalProperties: false
+        },
+        annotations: { title: "Set the effect paper", ...ctx.annotations.writeIdempotent },
+        handler: async (args) => {
+          if (args.effect !== null) ctx.requireProvider();
+          return { paperEffect: await controller.setPaperEffect(args.effect, { values: values(args.values), opacity: args.opacity, blend: args.blend, time: args.time }) };
+        }
+      },
+      {
+        name: "add_effect_layer",
+        title: "Add an effect layer",
+        description: 'Adds a pixel layer drawn by a provider generator, overlay or title effect (search_effects with use generator, overlay or title) at the canvas size, above the active layer unless aboveId is given, and makes it active. Paint on it like any layer; update_effect (effect "effect") draws it again with new values, replacing its pixels; remove_effect keeps its pixels as a plain layer. One undo step. Returns the new layer and its effect.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            effect: ctx.effectIdSchema(["generator", "overlay", "title"]),
+            values: ctx.valuesSchema("Control values over the effect's defaults"),
+            name: { type: "string", minLength: 1, description: "The layer name (default: the effect's name)." },
+            aboveId: { type: "string", minLength: 1, description: "Put it directly above this layer (default: above the active layer, else on top)." },
+            opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0\u20131 (default 1)." },
+            blend: { type: "string", enum: _chunkJ5BA3BQ6cjs.BLEND_MODES.map((m) => m.id), description: "Layer blend mode (default normal); screen or linear-dodge for light, multiply for textures." },
+            time: { type: "number", minimum: 0, description: "Which moment of an animated effect to draw, in ms (default 0)." }
+          },
+          required: ["effect"],
+          additionalProperties: false
+        },
+        annotations: { title: "Add an effect layer", ...ctx.annotations.write },
+        handler: async (args) => {
+          ctx.requireProvider();
+          const r = await controller.addEffectLayer(args.effect, { values: values(args.values), name: args.name, aboveId: args.aboveId, opacity: args.opacity, blend: args.blend, time: args.time });
+          return { layer: r.layer, effects: layerInfo(r.layer.id) };
+        }
+      },
+      {
+        name: "fill_layer_with_effect",
+        title: "Fill a layer with an effect",
+        description: "Composites a provider generator, overlay or title effect (rendered at the canvas size) onto a layer's pixels at opacity, as a fill: the layer keeps no link to the effect. lockTransparency (or a transparency-locked layer) only colours what is already painted. Wet paint is refused: dry it first (dry_paint). One undo step. Returns the layer id and the effect used.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            effect: ctx.effectIdSchema(["generator", "overlay", "title"]),
+            layerId: { type: "string", minLength: 1, description: "The pixel layer to fill (default: the active layer)." },
+            values: ctx.valuesSchema("Control values over the effect's defaults"),
+            opacity: { type: "number", minimum: 0, maximum: 1, description: "Fill strength 0\u20131 (default 1)." },
+            lockTransparency: { type: "boolean", description: "Only colour pixels that are already painted (default false)." },
+            time: { type: "number", minimum: 0, description: "Which moment of an animated effect to draw, in ms (default 0)." }
+          },
+          required: ["effect"],
+          additionalProperties: false
+        },
+        annotations: { title: "Fill a layer with an effect", ...ctx.annotations.write },
+        handler: async (args) => {
+          ctx.requireProvider();
+          return controller.fillLayerWithEffect(args.effect, { layerId: args.layerId, values: values(args.values), opacity: args.opacity, lockTransparency: args.lockTransparency, time: args.time });
+        }
+      }
+    ]
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -8225,5 +8845,5 @@ function quickStencil(kind, canvas) {
 
 
 
-exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkJ5BA3BQ6cjs.BLEND_MODES; exports.BRUSH_ID = _chunkW4LNKTHTcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkW4LNKTHTcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkW4LNKTHTcjs.BUILTIN_BRUSHES; exports.BristleStroke = _chunkW4LNKTHTcjs.BristleStroke; exports.DEFAULT_BEHAVIOR = _chunkW4LNKTHTcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkW4LNKTHTcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkW4LNKTHTcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkW4LNKTHTcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkFHPVDTI2cjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkW4LNKTHTcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkW4LNKTHTcjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunk6GFRKLLScjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunk6GFRKLLScjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = _chunkW4LNKTHTcjs.DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkW4LNKTHTcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkW4LNKTHTcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkW4LNKTHTcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkFHPVDTI2cjs.DEFAULT_WET_PARAMS; exports.DryStroke = _chunkW4LNKTHTcjs.DryStroke; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkW4LNKTHTcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkW4LNKTHTcjs.GRAIN_TILE; exports.HARMONY_KINDS = HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = _chunkW4LNKTHTcjs.IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkW4LNKTHTcjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunk6GFRKLLScjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunkW4LNKTHTcjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkJ5BA3BQ6cjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkW4LNKTHTcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkW4LNKTHTcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunk6GFRKLLScjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunk6GFRKLLScjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunk6GFRKLLScjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunk6GFRKLLScjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunk6GFRKLLScjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunk6GFRKLLScjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunk6GFRKLLScjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunk6GFRKLLScjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunk6GFRKLLScjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunk6GFRKLLScjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunk6GFRKLLScjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunk6GFRKLLScjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_FAMILIES = _chunkW4LNKTHTcjs.PAPER_FAMILIES; exports.PAPER_LIBRARY = _chunkW4LNKTHTcjs.PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PARTICLE_KINDS = _chunkW4LNKTHTcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkW4LNKTHTcjs.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.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunk6GFRKLLScjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunk6GFRKLLScjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkW4LNKTHTcjs.PaperGrain; exports.ParticleStroke = _chunkW4LNKTHTcjs.ParticleStroke; exports.PenDabWalker = _chunkW4LNKTHTcjs.PenDabWalker; exports.PenSmoother = _chunkW4LNKTHTcjs.PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkW4LNKTHTcjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerSpray = _chunkW4LNKTHTcjs.StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunkW4LNKTHTcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkFHPVDTI2cjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkW4LNKTHTcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkFHPVDTI2cjs.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 = _chunkW4LNKTHTcjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunk6GFRKLLScjs.addPaintGradientStop; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkW4LNKTHTcjs.brushTakesPaint; exports.brushToJSON = _chunkW4LNKTHTcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.clonePaper = _chunkW4LNKTHTcjs.clonePaper; exports.colorHarmony = colorHarmony; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = _chunkW4LNKTHTcjs.drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkW4LNKTHTcjs.grainCatch; exports.grainHeights = _chunkW4LNKTHTcjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunk6GFRKLLScjs.hash2; exports.hexToPaintRgb = _chunk6GFRKLLScjs.hexToPaintRgb; exports.hexToRgb8 = _chunkW4LNKTHTcjs.hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkJ5BA3BQ6cjs.isBlendMode; exports.isGradientPaint = _chunk6GFRKLLScjs.isGradientPaint; exports.isPainterlyBlendMode = _chunkJ5BA3BQ6cjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkW4LNKTHTcjs.isWetBrush; exports.isWetCapable = _chunkW4LNKTHTcjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunk6GFRKLLScjs.mix32; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = _chunkW4LNKTHTcjs.mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.multiColorToPaint = _chunkW4LNKTHTcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.normalizeBehavior = _chunkW4LNKTHTcjs.normalizeBehavior; exports.normalizeBristle = _chunkW4LNKTHTcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkW4LNKTHTcjs.normalizeDynamics; exports.normalizeFlow = _chunkFHPVDTI2cjs.normalizeFlow; exports.normalizeHexColor = _chunk6GFRKLLScjs.normalizeHexColor; exports.normalizeImpasto = _chunkW4LNKTHTcjs.normalizeImpasto; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkW4LNKTHTcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkW4LNKTHTcjs.normalizePaintBrush; exports.normalizePaper = _chunkW4LNKTHTcjs.normalizePaper; exports.normalizeParticle = _chunkW4LNKTHTcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkW4LNKTHTcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = _chunkW4LNKTHTcjs.normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkW4LNKTHTcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkFHPVDTI2cjs.normalizeWetParams; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunk6GFRKLLScjs.paintGradientMappingFor; exports.paintSourceColor = _chunk6GFRKLLScjs.paintSourceColor; exports.paintSourceCss = _chunk6GFRKLLScjs.paintSourceCss; exports.paintToMultiColor = _chunkW4LNKTHTcjs.paintToMultiColor; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = _chunkW4LNKTHTcjs.paperPreset; exports.parseBrushLibrary = _chunkW4LNKTHTcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunk6GFRKLLScjs.parsePaintSource; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = _chunkW4LNKTHTcjs.penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunk6GFRKLLScjs.rand01; exports.randSigned = _chunkW4LNKTHTcjs.randSigned; exports.readPaintSource = _chunk6GFRKLLScjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunk6GFRKLLScjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = _chunkW4LNKTHTcjs.renderPaper; exports.renderStickers = _chunkW4LNKTHTcjs.renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunk6GFRKLLScjs.resolvePaintGradient; exports.reversePaintGradient = _chunk6GFRKLLScjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunk6GFRKLLScjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunkW4LNKTHTcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunk6GFRKLLScjs.solidPaint; exports.stampCoverage = _chunkW4LNKTHTcjs.stampCoverage; exports.standardBlendMode = _chunkJ5BA3BQ6cjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerRect = _chunkW4LNKTHTcjs.stickerRect; exports.stickerSurface = _chunkW4LNKTHTcjs.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 = _chunkW4LNKTHTcjs.tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = _chunkW4LNKTHTcjs.toStrokePoint; exports.toggleStamp = toggleStamp; exports.updatePaintGradientStop = _chunk6GFRKLLScjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkW4LNKTHTcjs.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 = _chunkFHPVDTI2cjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = wheelToHue;
+exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkJ5BA3BQ6cjs.BLEND_MODES; exports.BRUSH_ID = _chunkW4LNKTHTcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkW4LNKTHTcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkW4LNKTHTcjs.BUILTIN_BRUSHES; exports.BristleStroke = _chunkW4LNKTHTcjs.BristleStroke; exports.DEFAULT_BEHAVIOR = _chunkW4LNKTHTcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkW4LNKTHTcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkW4LNKTHTcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkW4LNKTHTcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkFHPVDTI2cjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkW4LNKTHTcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkW4LNKTHTcjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunk6GFRKLLScjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunk6GFRKLLScjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = _chunkW4LNKTHTcjs.DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkW4LNKTHTcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkW4LNKTHTcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkW4LNKTHTcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkFHPVDTI2cjs.DEFAULT_WET_PARAMS; exports.DryStroke = _chunkW4LNKTHTcjs.DryStroke; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkW4LNKTHTcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkW4LNKTHTcjs.GRAIN_TILE; exports.HARMONY_KINDS = HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = _chunkW4LNKTHTcjs.IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkW4LNKTHTcjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunk6GFRKLLScjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunkW4LNKTHTcjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkJ5BA3BQ6cjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkW4LNKTHTcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkW4LNKTHTcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunk6GFRKLLScjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunk6GFRKLLScjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunk6GFRKLLScjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunk6GFRKLLScjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunk6GFRKLLScjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunk6GFRKLLScjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunk6GFRKLLScjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunk6GFRKLLScjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunk6GFRKLLScjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunk6GFRKLLScjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunk6GFRKLLScjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunk6GFRKLLScjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = _chunkW4LNKTHTcjs.PAPER_FAMILIES; exports.PAPER_LIBRARY = _chunkW4LNKTHTcjs.PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunkW4LNKTHTcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkW4LNKTHTcjs.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 = _chunk6GFRKLLScjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunk6GFRKLLScjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkW4LNKTHTcjs.PaperGrain; exports.ParticleStroke = _chunkW4LNKTHTcjs.ParticleStroke; exports.PenDabWalker = _chunkW4LNKTHTcjs.PenDabWalker; exports.PenSmoother = _chunkW4LNKTHTcjs.PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkW4LNKTHTcjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerSpray = _chunkW4LNKTHTcjs.StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunkW4LNKTHTcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkFHPVDTI2cjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkW4LNKTHTcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkFHPVDTI2cjs.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 = _chunkW4LNKTHTcjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunk6GFRKLLScjs.addPaintGradientStop; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkW4LNKTHTcjs.brushTakesPaint; exports.brushToJSON = _chunkW4LNKTHTcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = _chunkW4LNKTHTcjs.clonePaper; exports.colorHarmony = colorHarmony; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = _chunkW4LNKTHTcjs.drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectLayersToJSON = effectLayersToJSON; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkW4LNKTHTcjs.grainCatch; exports.grainHeights = _chunkW4LNKTHTcjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunk6GFRKLLScjs.hash2; exports.hexToPaintRgb = _chunk6GFRKLLScjs.hexToPaintRgb; exports.hexToRgb8 = _chunkW4LNKTHTcjs.hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkJ5BA3BQ6cjs.isBlendMode; exports.isGradientPaint = _chunk6GFRKLLScjs.isGradientPaint; exports.isPainterlyBlendMode = _chunkJ5BA3BQ6cjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkW4LNKTHTcjs.isWetBrush; exports.isWetCapable = _chunkW4LNKTHTcjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunk6GFRKLLScjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = _chunkW4LNKTHTcjs.mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.multiColorToPaint = _chunkW4LNKTHTcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkW4LNKTHTcjs.normalizeBehavior; exports.normalizeBristle = _chunkW4LNKTHTcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkW4LNKTHTcjs.normalizeDynamics; exports.normalizeFlow = _chunkFHPVDTI2cjs.normalizeFlow; exports.normalizeHexColor = _chunk6GFRKLLScjs.normalizeHexColor; exports.normalizeImpasto = _chunkW4LNKTHTcjs.normalizeImpasto; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkW4LNKTHTcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkW4LNKTHTcjs.normalizePaintBrush; exports.normalizePaper = _chunkW4LNKTHTcjs.normalizePaper; exports.normalizeParticle = _chunkW4LNKTHTcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkW4LNKTHTcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = _chunkW4LNKTHTcjs.normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkW4LNKTHTcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkFHPVDTI2cjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunk6GFRKLLScjs.paintGradientMappingFor; exports.paintSourceColor = _chunk6GFRKLLScjs.paintSourceColor; exports.paintSourceCss = _chunk6GFRKLLScjs.paintSourceCss; exports.paintToMultiColor = _chunkW4LNKTHTcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = _chunkW4LNKTHTcjs.paperPreset; exports.parseBrushLibrary = _chunkW4LNKTHTcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunk6GFRKLLScjs.parsePaintSource; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = _chunkW4LNKTHTcjs.penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunk6GFRKLLScjs.rand01; exports.randSigned = _chunkW4LNKTHTcjs.randSigned; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunk6GFRKLLScjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunk6GFRKLLScjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = _chunkW4LNKTHTcjs.renderPaper; exports.renderStickers = _chunkW4LNKTHTcjs.renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunk6GFRKLLScjs.resolvePaintGradient; exports.reversePaintGradient = _chunk6GFRKLLScjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunk6GFRKLLScjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunkW4LNKTHTcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunk6GFRKLLScjs.solidPaint; exports.stampCoverage = _chunkW4LNKTHTcjs.stampCoverage; exports.standardBlendMode = _chunkJ5BA3BQ6cjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerRect = _chunkW4LNKTHTcjs.stickerRect; exports.stickerSurface = _chunkW4LNKTHTcjs.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 = _chunkW4LNKTHTcjs.tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = _chunkW4LNKTHTcjs.toStrokePoint; exports.toggleStamp = toggleStamp; exports.updatePaintGradientStop = _chunk6GFRKLLScjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkW4LNKTHTcjs.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 = _chunkFHPVDTI2cjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = wheelToHue;
 //# sourceMappingURL=index.cjs.map