@pixerate/editor 0.255.0 → 0.256.0

package/dist/paint-editor/index.cjs

@@ -370,8 +370,8 @@ function normalizePaper(raw = {}, base) {
     ...readOffset(r.offset, b.offset)
   };
 }
-function hexToRgb8(hex) {
-  const n = parseInt(hex.slice(1, 7), 16);
+function hexToRgb8(hex2) {
+  const n = parseInt(hex2.slice(1, 7), 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
 }
 function renderPaper(paper, rect, grain = new (0, _chunkPXDIAYB6cjs.PaperGrain)(paper), light) {
@@ -1929,8 +1929,8 @@ function sampleArt(art, x, y, out) {
 }
 
 // src/paint-editor/stickers.ts
-function hexRgb(hex) {
-  const n = parseInt(hex.slice(1, 7), 16);
+function hexRgb(hex2) {
+  const n = parseInt(hex2.slice(1, 7), 16);
   return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
 }
 function stickerRect(s) {
@@ -2014,8 +2014,8 @@ function drawArtSticker(medium, s, art) {
   medium.deposit(rect, cov, s.opacity, [r, g, b], null, field);
   return rect;
 }
-function jitterColor(hex, amount, seed, i) {
-  const [r, g, b] = hexRgb(hex);
+function jitterColor(hex2, amount, seed, i) {
+  const [r, g, b] = hexRgb(hex2);
   const lch = _chunk5UEFBM2Mcjs.oklabToOklch.call(void 0, _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, { r, g, b, a: 1 }));
   const l = Math.min(1, Math.max(0, lch.l + (_chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 61) - 0.5) * amount * 0.3));
   const h = lch.h + (_chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 63) - 0.5) * amount * 80;
@@ -2897,7 +2897,7 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
     const init = this.init;
     const grey = Math.round(init.brush.light.amount * 255);
     const g = grey / 255;
-    const hex = "#" + grey.toString(16).padStart(2, "0").repeat(3);
+    const hex2 = "#" + grey.toString(16).padStart(2, "0").repeat(3);
     const host = {
       update: () => {
       },
@@ -2906,14 +2906,14 @@ var PaintStrokeSession = (_class12 = class _PaintStrokeSession {
       }
     };
     const effect = init.effect ? { source: init.effect.source, pixels: { ...init.effect.pixels, data: greyPixels(init.effect.pixels.data, grey) } } : null;
-    const paint = init.paint ? { ...init.paint, stops: init.paint.stops.map((st) => ({ ...st, color: hex })) } : null;
+    const paint = init.paint ? { ...init.paint, stops: init.paint.stops.map((st) => ({ ...st, color: hex2 })) } : null;
     return new _PaintStrokeSession(host, {
       ...init,
       surface: lightToShadow(light),
       lockTransparency: false,
       brush: lightTwinBrush(init.brush),
       color: [grey, grey, grey, 255],
-      colorHex: hex,
+      colorHex: hex2,
       secondary: [grey, grey, grey, 255],
       inputFilter: void 0,
       mixerLoad: { reservoir: init.mixerLoad.reservoir ? [g, g, g] : null, amount: init.mixerLoad.amount, pickup: null },
@@ -4461,8 +4461,8 @@ var PaintWetLayers = (_class14 = class {
     this.gpu = null;
   }
 }, _class14);
-function wetPigmentOf(hex, body) {
-  const [r, g, b] = hexToRgb8(hex);
+function wetPigmentOf(hex2, body) {
+  const [r, g, b] = hexToRgb8(hex2);
   return Array.from(_chunkKBYB7OWBcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
 }
 
@@ -4934,8 +4934,8 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
       A += a;
     }
     if (A === 0) return null;
-    const hex = (v) => Math.round(v / A).toString(16).padStart(2, "0");
-    return `#${hex(R)}${hex(G)}${hex(B)}`;
+    const hex2 = (v) => Math.round(v / A).toString(16).padStart(2, "0");
+    return `#${hex2(R)}${hex2(G)}${hex2(B)}`;
   }
   clear() {
     this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4);
@@ -4996,8 +4996,8 @@ var MixingPad = (_class16 = class {constructor() { _class16.prototype.__init106.
       paints2.map((p) => p.parts)
     );
     const core = _chunkHIMGBZAMcjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
-    const hex = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
-    this.run(core, [{ x: cx, y: cy }], hex);
+    const hex2 = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
+    this.run(core, [{ x: cx, y: cy }], hex2);
     return { color: this.pick(cx, cy, 2), bounds };
   }
   /** The pad's pixels as a PNG data URL (with alpha), for saving. */
@@ -5699,8 +5699,8 @@ function parseColor(value, what = "color") {
   if (typeof value !== "string" || !HEX3.test(value.trim())) throw new PaintEditorError(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
   return value.trim().toLowerCase();
 }
-function rgbaOf(hex) {
-  const [r, g, b] = hexToRgb8(hex);
+function rgbaOf(hex2) {
+  const [r, g, b] = hexToRgb8(hex2);
   return [r, g, b, 255];
 }
 function rgbToHex(r, g, b) {
@@ -5753,61 +5753,68 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   __init133() {this.stickerPreview = null}
   
   __init134() {this.listeners = /* @__PURE__ */ new Set()}
-  __init135() {this.version = 0}
-  __init136() {this.cached = null}
-  __init137() {this.session = null}
-  __init138() {this.live = null}
-  __init139() {this.liveLayers = null}
-  __init140() {this.dirty = "all"}
-  __init141() {this.seedCounter = 1}
-  __init142() {this.strokeCounter = 1}
+  __init135() {this.commitListeners = /* @__PURE__ */ new Set()}
+  /** Origins set by `withOrigin`, innermost last. */
+  __init136() {this.origins = []}
+  /** `group` in progress: commits fold into one step, recorded when it ends. */
+  __init137() {this.grouping = null}
+  /** `previewPaint` in progress: nothing is emitted or recorded. */
+  __init138() {this.previewing = false}
+  __init139() {this.version = 0}
+  __init140() {this.cached = null}
+  __init141() {this.session = null}
+  __init142() {this.live = null}
+  __init143() {this.liveLayers = null}
+  __init144() {this.dirty = "all"}
+  __init145() {this.seedCounter = 1}
+  __init146() {this.strokeCounter = 1}
   /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
-  __init143() {this.lightSpills = {}}
-  __init144() {this.lightCaches = /* @__PURE__ */ new Map()}
+  __init147() {this.lightSpills = {}}
+  __init148() {this.lightCaches = /* @__PURE__ */ new Map()}
   /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
-  __init145() {this.backlightView = new BacklightCache()}
-  __init146() {this.backlightCommitted = new BacklightCache()}
+  __init149() {this.backlightView = new BacklightCache()}
+  __init150() {this.backlightCommitted = new BacklightCache()}
   /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
-  __init147() {this.effectPlaybackState = { playing: true, fps: 30 }}
-  __init148() {this.effectTime = 0}
+  __init151() {this.effectPlaybackState = { playing: true, fps: 30 }}
+  __init152() {this.effectTime = 0}
   /** While a frame is drawn: the time live effect strokes are drawn at (else their own time). */
-  __init149() {this.liveEffectAt = null}
+  __init153() {this.liveEffectAt = null}
   /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
-  __init150() {this.animatedLayers = /* @__PURE__ */ new Map()}
+  __init154() {this.animatedLayers = /* @__PURE__ */ new Map()}
   /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
-  __init151() {this.frameOverride = null}
+  __init155() {this.frameOverride = null}
   /** The area each stroke painted (document pixels; `null`: nothing), learnt as it is painted or drawn, so a stroke layer edit redraws only where it changes (see `drawLiveStrokes`). */
-  __init152() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
+  __init156() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
   
-  __init153() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init154() {this.pad = new MixingPad()}
-  __init155() {this.savedPads = []}
-  __init156() {this.nextPadId = 1}
-  __init157() {this.tracingVersion = 1}
-  __init158() {this.tracingCache = null}
-  __init159() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init160() {this.nextReferenceId = 1}
-  __init161() {this.viewCompositor = createPaintCompositor()}
-  __init162() {this.exportCompositor = createPaintCompositor()}
+  __init157() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init158() {this.pad = new MixingPad()}
+  __init159() {this.savedPads = []}
+  __init160() {this.nextPadId = 1}
+  __init161() {this.tracingVersion = 1}
+  __init162() {this.tracingCache = null}
+  __init163() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init164() {this.nextReferenceId = 1}
+  __init165() {this.viewCompositor = createPaintCompositor()}
+  __init166() {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). */
-  __init163() {this.lighting = { ...DEFAULT_LIGHTING }}
-  __init164() {this.litCaches = /* @__PURE__ */ new Map()}
+  __init167() {this.lighting = { ...DEFAULT_LIGHTING }}
+  __init168() {this.litCaches = /* @__PURE__ */ new Map()}
   /** The live impasto stroke's channels. */
-  __init165() {this.liveThick = null}
+  __init169() {this.liveThick = null}
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
-  __init166() {this.wetOp = null}
+  __init170() {this.wetOp = null}
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init167() {this.effects = new (0, _chunkL2JTLW6Bcjs.EffectsSlot)()}
+  __init171() {this.effects = new (0, _chunkL2JTLW6Bcjs.EffectsSlot)()}
   /** The sticker library slot (see `setStickersProvider`). */
-  __init168() {this.stickers = new (0, _chunkJSDND7DFcjs.StickersSlot)(_chunkSABJMH6Mcjs.editorStickers.call(void 0, ))}
-  __init169() {this.stickerArt = new StickerArtCache()}
+  __init172() {this.stickers = new (0, _chunkJSDND7DFcjs.StickersSlot)(_chunkSABJMH6Mcjs.editorStickers.call(void 0, ))}
+  __init173() {this.stickerArt = new StickerArtCache()}
   
-  __init170() {this.effectsRenderer = new PaintEffectsRenderer()}
-  __init171() {this.paperEffectNodeCache = null}
-  constructor(options = {}) {;_class19.prototype.__init117.call(this);_class19.prototype.__init118.call(this);_class19.prototype.__init119.call(this);_class19.prototype.__init120.call(this);_class19.prototype.__init121.call(this);_class19.prototype.__init122.call(this);_class19.prototype.__init123.call(this);_class19.prototype.__init124.call(this);_class19.prototype.__init125.call(this);_class19.prototype.__init126.call(this);_class19.prototype.__init127.call(this);_class19.prototype.__init128.call(this);_class19.prototype.__init129.call(this);_class19.prototype.__init130.call(this);_class19.prototype.__init131.call(this);_class19.prototype.__init132.call(this);_class19.prototype.__init133.call(this);_class19.prototype.__init134.call(this);_class19.prototype.__init135.call(this);_class19.prototype.__init136.call(this);_class19.prototype.__init137.call(this);_class19.prototype.__init138.call(this);_class19.prototype.__init139.call(this);_class19.prototype.__init140.call(this);_class19.prototype.__init141.call(this);_class19.prototype.__init142.call(this);_class19.prototype.__init143.call(this);_class19.prototype.__init144.call(this);_class19.prototype.__init145.call(this);_class19.prototype.__init146.call(this);_class19.prototype.__init147.call(this);_class19.prototype.__init148.call(this);_class19.prototype.__init149.call(this);_class19.prototype.__init150.call(this);_class19.prototype.__init151.call(this);_class19.prototype.__init152.call(this);_class19.prototype.__init153.call(this);_class19.prototype.__init154.call(this);_class19.prototype.__init155.call(this);_class19.prototype.__init156.call(this);_class19.prototype.__init157.call(this);_class19.prototype.__init158.call(this);_class19.prototype.__init159.call(this);_class19.prototype.__init160.call(this);_class19.prototype.__init161.call(this);_class19.prototype.__init162.call(this);_class19.prototype.__init163.call(this);_class19.prototype.__init164.call(this);_class19.prototype.__init165.call(this);_class19.prototype.__init166.call(this);_class19.prototype.__init167.call(this);_class19.prototype.__init168.call(this);_class19.prototype.__init169.call(this);_class19.prototype.__init170.call(this);_class19.prototype.__init171.call(this);_class19.prototype.__init172.call(this);_class19.prototype.__init173.call(this);_class19.prototype.__init174.call(this);_class19.prototype.__init175.call(this);
+  __init174() {this.effectsRenderer = new PaintEffectsRenderer()}
+  __init175() {this.paperEffectNodeCache = null}
+  constructor(options = {}) {;_class19.prototype.__init117.call(this);_class19.prototype.__init118.call(this);_class19.prototype.__init119.call(this);_class19.prototype.__init120.call(this);_class19.prototype.__init121.call(this);_class19.prototype.__init122.call(this);_class19.prototype.__init123.call(this);_class19.prototype.__init124.call(this);_class19.prototype.__init125.call(this);_class19.prototype.__init126.call(this);_class19.prototype.__init127.call(this);_class19.prototype.__init128.call(this);_class19.prototype.__init129.call(this);_class19.prototype.__init130.call(this);_class19.prototype.__init131.call(this);_class19.prototype.__init132.call(this);_class19.prototype.__init133.call(this);_class19.prototype.__init134.call(this);_class19.prototype.__init135.call(this);_class19.prototype.__init136.call(this);_class19.prototype.__init137.call(this);_class19.prototype.__init138.call(this);_class19.prototype.__init139.call(this);_class19.prototype.__init140.call(this);_class19.prototype.__init141.call(this);_class19.prototype.__init142.call(this);_class19.prototype.__init143.call(this);_class19.prototype.__init144.call(this);_class19.prototype.__init145.call(this);_class19.prototype.__init146.call(this);_class19.prototype.__init147.call(this);_class19.prototype.__init148.call(this);_class19.prototype.__init149.call(this);_class19.prototype.__init150.call(this);_class19.prototype.__init151.call(this);_class19.prototype.__init152.call(this);_class19.prototype.__init153.call(this);_class19.prototype.__init154.call(this);_class19.prototype.__init155.call(this);_class19.prototype.__init156.call(this);_class19.prototype.__init157.call(this);_class19.prototype.__init158.call(this);_class19.prototype.__init159.call(this);_class19.prototype.__init160.call(this);_class19.prototype.__init161.call(this);_class19.prototype.__init162.call(this);_class19.prototype.__init163.call(this);_class19.prototype.__init164.call(this);_class19.prototype.__init165.call(this);_class19.prototype.__init166.call(this);_class19.prototype.__init167.call(this);_class19.prototype.__init168.call(this);_class19.prototype.__init169.call(this);_class19.prototype.__init170.call(this);_class19.prototype.__init171.call(this);_class19.prototype.__init172.call(this);_class19.prototype.__init173.call(this);_class19.prototype.__init174.call(this);_class19.prototype.__init175.call(this);_class19.prototype.__init176.call(this);_class19.prototype.__init177.call(this);_class19.prototype.__init178.call(this);_class19.prototype.__init179.call(this);
     this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
     this.rasterizeSticker = _nullishCoalesce(options.rasterizeSticker, () => ( defaultStickerRasterizer));
     if (options.stickers) this.stickers.set(options.stickers);
@@ -5860,7 +5867,125 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
   }
+  /** Hears each undo step recorded, merged, undone or redone, with who made it. Returns an unsubscribe function. */
+  onCommit(listener) {
+    this.commitListeners.add(listener);
+    return () => {
+      this.commitListeners.delete(listener);
+    };
+  }
+  notifyCommit(event) {
+    if (this.previewing) return;
+    for (const l of [...this.commitListeners]) l(event);
+  }
+  /** The origin steps are recorded with now: the innermost `withOrigin`, else `user`. */
+  getOrigin() {
+    return _nullishCoalesce(this.origins[this.origins.length - 1], () => ( "user"));
+  }
+  /**
+   * Records the steps `fn` makes as made by `origin` (`agent:<id>` for an agent). When `fn` returns
+   * a promise, the origin holds until it settles. Satisfies `createOriginMiddleware`'s history target,
+   * so agent tool calls are recorded as the calling agent's.
+   */
+  withOrigin(origin, fn) {
+    this.origins.push(origin);
+    let pending = false;
+    const pop = () => {
+      const i = this.origins.lastIndexOf(origin);
+      if (i >= 0) this.origins.splice(i, 1);
+    };
+    try {
+      const result = fn();
+      if (result && typeof result.then === "function") {
+        pending = true;
+        return Promise.resolve(result).finally(pop);
+      }
+      return result;
+    } finally {
+      if (!pending) pop();
+    }
+  }
+  /**
+   * Runs `fn` as one undo step named `label`: every change it makes (strokes, fills, new layers) is
+   * undone together. Wet paint can't be grouped. Nested groups join the outer one. If `fn` throws,
+   * its changes are put back and nothing is recorded.
+   */
+  group(label, fn) {
+    if (this.grouping) return fn();
+    this.requireIdle("grouping changes");
+    const before = this.doc;
+    const revision = this.docRevision;
+    this.grouping = { label, before, changed: false };
+    let result;
+    try {
+      result = fn();
+    } catch (e) {
+      this.grouping = null;
+      if (this.doc !== before) {
+        this.doc = before;
+        this.docRevision = revision + 1;
+        this.emit();
+      }
+      throw e;
+    }
+    const g = this.grouping;
+    this.grouping = null;
+    if (g.changed && this.doc !== before) {
+      this.undoStack.push({ label, origin: this.getOrigin(), before, after: this.doc });
+      if (this.undoStack.length > this.historyLimit) this.undoStack.shift();
+      this.redoStack = [];
+      this.notifyCommit({ kind: "execute", label, origin: this.getOrigin() });
+      this.emit();
+    }
+    return result;
+  }
+  /**
+   * What `fn` would paint, without changing anything: it runs on a new empty layer (above the
+   * active layer, another one, or at the bottom), and the layer's pixels and the picture with them
+   * come back while the document, history and listeners stay as they were. `fn` gets that layer's id and must paint on it with dry brushes (strokes, replays and
+   * fills); wet paint can't be previewed. For ghost paint an agent suggests (`createPaintProposals`).
+   */
+  previewPaint(fn, placement = {}) {
+    this.requireIdle("previewing");
+    if (this.previewing) throw new PaintEditorError("A preview is already running.");
+    const saved = {
+      doc: this.doc,
+      undo: [...this.undoStack],
+      redo: this.redoStack,
+      revision: this.docRevision,
+      strokeCounter: this.strokeCounter,
+      seedCounter: this.seedCounter,
+      mixerLoad: this.mixerLoad
+    };
+    this.previewing = true;
+    try {
+      const layer = this.addLayer({ name: "Preview", ...placement.aboveId ? { aboveId: placement.aboveId } : {} });
+      if (placement.bottom) this.moveLayer(layer.id, 0, null);
+      fn(layer.id);
+      if (this.wetOp || this.pendingWetEvents.length) throw new PaintEditorError("Wet paint can't be previewed; suggest it with a dry brush.");
+      const found = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layer.id), 'optionalAccess', _265 => _265.layer]);
+      const surface = found && isPixelLayer(found) ? found.surface : null;
+      const bounds = surface ? _chunk474IQG74cjs.contentBounds.call(void 0, surface) : null;
+      const box = bounds ? clipToCanvas(bounds, this.doc.canvas) : null;
+      if (!surface || !box) return { bounds: null, pixels: new Uint8ClampedArray(0), composite: new Uint8ClampedArray(0) };
+      const composite = this.exportCompositor.composite(this.renderLayers({ wet: "display" }), box, this.sources());
+      return { bounds: box, pixels: _chunk474IQG74cjs.readRegion.call(void 0, surface, box), composite };
+    } finally {
+      this.wetOp = null;
+      this.pendingWetEvents = [];
+      this.doc = saved.doc;
+      this.undoStack = saved.undo;
+      this.redoStack = saved.redo;
+      this.docRevision = saved.revision;
+      this.strokeCounter = saved.strokeCounter;
+      this.seedCounter = saved.seedCounter;
+      this.mixerLoad = saved.mixerLoad;
+      this.cached = null;
+      this.previewing = false;
+    }
+  }
   emit(dirty = "all") {
+    if (this.previewing) return;
     if (dirty === "all" || this.dirty === "all") this.dirty = "all";
     else this.dirty.push(...dirty);
     this.version++;
@@ -5889,8 +6014,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       selectedSticker: this.selectedSticker,
       canUndo: this.undoStack.length > 0 && !this.session,
       canRedo: this.redoStack.length > 0 && !this.session,
-      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _265 => _265.label]), () => ( null)),
-      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _266 => _266.label]), () => ( null)),
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _266 => _266.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _267 => _267.label]), () => ( null)),
       guides: this.guides,
       swatches: this.swatches,
       mixingPadVersion: this.pad.version,
@@ -5903,10 +6028,10 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         overlay: this.wet.overlay,
         instantDry: this.wet.instantDry,
         speed: this.wet.speed,
-        clock: _nullishCoalesce(_optionalChain([this, 'access', _267 => _267.wet, 'access', _268 => _268.world, 'optionalAccess', _269 => _269.clock]), () => ( 0)),
+        clock: _nullishCoalesce(_optionalChain([this, 'access', _268 => _268.wet, 'access', _269 => _269.world, 'optionalAccess', _270 => _270.clock]), () => ( 0)),
         tilt: { ...this.wet.tilt },
         gpu: this.wet.gpuMode,
-        gpuActive: Boolean(_optionalChain([this, 'access', _270 => _270.wet, 'access', _271 => _271.world, 'optionalAccess', _272 => _272.gpuActive]))
+        gpuActive: Boolean(_optionalChain([this, 'access', _271 => _271.wet, 'access', _272 => _272.world, 'optionalAccess', _273 => _273.gpuActive]))
       },
       version: this.version
     };
@@ -5925,7 +6050,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return d;
   }
   // --- History -------------------------------------------------------------------
-  __init172() {this.docRevision = 0}
+  __init176() {this.docRevision = 0}
   /**
    * Bumped on every change to the painting (a committed or amended step, undo, redo, opening a
    * document), not on wet-paint frames or view changes. `createPaintEditorDocument` uses it.
@@ -5943,7 +6068,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (this.session) throw new PaintEditorError(`A stroke is in progress; end or cancel it before ${what}.`);
   }
   commit(label, next, before = this.doc) {
-    const entry = { label, before, after: next };
+    if (this.grouping) {
+      this.grouping.changed = true;
+      this.doc = next;
+      this.docRevision++;
+      return;
+    }
+    const entry = { label, origin: this.getOrigin(), before, after: next };
     if (this.wetOp) {
       entry.wet = { before: this.wetOp.before, after: this.wet.snapshot(), lost: false };
       this.wetOp = null;
@@ -5954,6 +6085,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.doc = next;
     this.docRevision++;
     this.trimWetHistory();
+    this.notifyCommit({ kind: "execute", label, origin: entry.origin });
     this.emit();
   }
   /**
@@ -5962,7 +6094,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   commitOrAmend(label, next, commitToHistory) {
     const last = this.undoStack[this.undoStack.length - 1];
-    if (commitToHistory || !last || last.label !== label || last.wet || this.wetOp) {
+    if (commitToHistory || !last || last.label !== label || last.wet || this.wetOp || this.grouping) {
       this.commit(label, next);
       return;
     }
@@ -5970,6 +6102,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.redoStack = [];
     this.doc = next;
     this.docRevision++;
+    this.notifyCommit({ kind: "merge", label, origin: last.origin });
     this.emit();
   }
   /** Keeps the wet snapshots in history within the wet undo memory, dropping the oldest. */
@@ -6008,9 +6141,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return wetIds;
   }
   /** Records a wet event (for replays) in the document being built. */
-  __init173() {this.pendingWetEvents = []}
+  __init177() {this.pendingWetEvents = []}
   logWet(e) {
-    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _273 => _273.wet, 'access', _274 => _274.world, 'optionalAccess', _275 => _275.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
+    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _274 => _274.wet, 'access', _275 => _275.world, 'optionalAccess', _276 => _276.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
   }
   /** The document with a paint event appended (for replays). */
   withPaintEvent(doc, e) {
@@ -6039,6 +6172,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       this.wet.restore(e.wet.lost ? null : e.wet.before);
       if (paper !== this.doc.paper) this.wet.paperChanged();
     }
+    this.notifyCommit({ kind: "undo", label: e.label, origin: this.getOrigin() });
     this.emit();
     return e.label;
   }
@@ -6057,6 +6191,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       this.wet.restore(e.wet.lost ? null : e.wet.after);
       if (paper !== this.doc.paper) this.wet.paperChanged();
     }
+    this.notifyCommit({ kind: "redo", label: e.label, origin: this.getOrigin() });
     this.emit();
     return e.label;
   }
@@ -6154,7 +6289,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
     for (const id of keptWet) {
-      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _276 => _276.layer]);
+      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _277 => _277.layer]);
       if (isPixelLayer(l)) next = { ...next, layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, next.layers, id, () => ({ ...l, surface: _chunk474IQG74cjs.translateSurface.call(void 0, l.surface, l.offset.x, l.offset.y), offset: { x: 0, y: 0 } })) };
     }
     if (this.wet.world) {
@@ -6198,7 +6333,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   // --- Layers --------------------------------------------------------------------
   getLayer(id) {
-    return _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _277 => _277.layer]);
+    return _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _278 => _278.layer]);
   }
   /** The active pixel layer (or `undefined`). */
   getActiveLayer() {
@@ -6217,7 +6352,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     walk(this.doc.layers, null, 0);
     return out;
   }
-  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _278 => _278.parent, 'optionalAccess', _279 => _279.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _280 => _280.path, 'access', _281 => _281.length]), () => ( 0))) {
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _279 => _279.parent, 'optionalAccess', _280 => _280.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _281 => _281.path, 'access', _282 => _282.length]), () => ( 0))) {
     let bounds = null;
     if (l.type === "pixel") {
       const b = _chunk474IQG74cjs.contentBounds.call(void 0, l.surface);
@@ -6234,8 +6369,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       locks: { ..._nullishCoalesce(l.locks, () => ( {})) },
       active: l.id === this.doc.activeLayerId,
       bounds,
-      ..._optionalChain([this, 'access', _282 => _282.doc, 'access', _283 => _283.liveStrokes, 'optionalAccess', _284 => _284[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
-      ..._optionalChain([l, 'access', _285 => _285.effects, 'optionalAccess', _286 => _286.items, 'access', _287 => _287.length]) ? { effects: l.effects.items.length } : {},
+      ..._optionalChain([this, 'access', _283 => _283.doc, 'access', _284 => _284.liveStrokes, 'optionalAccess', _285 => _285[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
+      ..._optionalChain([l, 'access', _286 => _286.effects, 'optionalAccess', _287 => _287.items, 'access', _288 => _288.length]) ? { effects: l.effects.items.length } : {},
       parentId,
       depth
     };
@@ -6267,7 +6402,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.requireIdle("adding a layer");
     const count = _chunkDPYAO5U6cjs.flattenLayers.call(void 0, this.doc.layers).length;
     const type = _nullishCoalesce(options.type, () => ( "pixel"));
-    const name = _optionalChain([options, 'access', _288 => _288.name, 'optionalAccess', _289 => _289.trim, 'call', _290 => _290()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
+    const name = _optionalChain([options, 'access', _289 => _289.name, 'optionalAccess', _290 => _290.trim, 'call', _291 => _291()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
     const layer = type === "group" ? { type: "group", id: newPaintLayerId(), name, visible: true, opacity: 1, blend: "pass-through", children: [] } : createPaintLayer(name);
     let parentId = null;
     let index;
@@ -6279,7 +6414,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     } else if (above) {
       const loc = _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, above);
       if (!loc) throw new PaintEditorError(`Unknown layer "${above}". Call list_layers for the ids.`);
-      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _291 => _291.parent, 'optionalAccess', _292 => _292.id]), () => ( null));
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _292 => _292.parent, 'optionalAccess', _293 => _293.id]), () => ( null));
       index = loc.index + 1;
     }
     const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
@@ -6385,7 +6520,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   requireEffect(id, effectId) {
     const l = this.requireLayer(id);
-    const items = _nullishCoalesce(_optionalChain([l, 'access', _293 => _293.effects, 'optionalAccess', _294 => _294.items]), () => ( []));
+    const items = _nullishCoalesce(_optionalChain([l, 'access', _294 => _294.effects, 'optionalAccess', _295 => _295.items]), () => ( []));
     const i = items.findIndex((e) => e.id === effectId);
     if (i === -1) throw new PaintEditorError(`Layer "${l.name}" has no effect "${effectId}". Effects: ${items.map((e) => `${e.id} (${e.kind})`).join(", ") || "none"}; call list_layer_effects.`);
     return i;
@@ -6408,7 +6543,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     const layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
-    if (active && !_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.flattenLayers.call(void 0, layers), 'access', _295 => _295.filter, 'call', _296 => _296((x) => x.type === "pixel"), 'access', _297 => _297.pop, 'call', _298 => _298(), 'optionalAccess', _299 => _299.id]), () => ( null));
+    if (active && !_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.flattenLayers.call(void 0, layers), 'access', _296 => _296.filter, 'call', _297 => _297((x) => x.type === "pixel"), 'access', _298 => _298.pop, 'call', _299 => _299(), 'optionalAccess', _300 => _300.id]), () => ( null));
     this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.liveStrokesWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.lightWithout(_chunkDPYAO5U6cjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
     return { removed: id, activeLayerId: active };
   }
@@ -6434,7 +6569,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       return l.type === "group" ? { ...l, id: id2, children: l.children.map(copy) } : { ...l, id: id2 };
     };
     const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
-    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _300 => _300.parent, 'optionalAccess', _301 => _301.id]), () => ( null)), loc.index + 1);
+    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _301 => _301.parent, 'optionalAccess', _302 => _302.id]), () => ( null)), loc.index + 1);
     this.commit("Duplicate layer", this.withWetEvents({ ...this.doc, layers, activeLayerId: dup.id, ...this.doc.thick ? { thick } : {}, ...this.doc.stickers ? { stickers } : {}, ...this.doc.liveStrokes ? { liveStrokes } : {}, ...this.doc.light ? { light } : {} }));
     return this.describeLayer(dup);
   }
@@ -6443,7 +6578,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.requireIdle("moving a layer");
     const loc = _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
-    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _302 => _302.parent, 'optionalAccess', _303 => _303.id]), () => ( null)) : parentId;
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _303 => _303.parent, 'optionalAccess', _304 => _304.id]), () => ( null)) : parentId;
     if (target) {
       const g = this.requireLayer(target);
       if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
@@ -6462,7 +6597,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const pre = _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id);
     if (pre) {
       const sib = pre.parent ? pre.parent.children : this.doc.layers;
-      this.dryLayersFirst([id, _optionalChain([sib, 'access', _304 => _304[pre.index - 1], 'optionalAccess', _305 => _305.id])].filter((x) => Boolean(x)));
+      this.dryLayersFirst([id, _optionalChain([sib, 'access', _305 => _305[pre.index - 1], 'optionalAccess', _306 => _306.id])].filter((x) => Boolean(x)));
     }
     const loc = _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
@@ -6482,7 +6617,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
     const toDoc = (t, l) => t ? _chunk474IQG74cjs.translateSurface.call(void 0, t, l.offset.x, l.offset.y) : void 0;
-    const mergedLight = _optionalChain([this, 'access', _306 => _306.doc, 'access', _307 => _307.light, 'optionalAccess', _308 => _308[upper.id]]) || _optionalChain([this, 'access', _309 => _309.doc, 'access', _310 => _310.light, 'optionalAccess', _311 => _311[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _312 => _312.doc, 'access', _313 => _313.light, 'optionalAccess', _314 => _314[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _315 => _315.doc, 'access', _316 => _316.light, 'optionalAccess', _317 => _317[upper.id]]), upper) : void 0, _chunk474IQG74cjs.translateSurface.call(void 0, upper.surface, upper.offset.x, upper.offset.y)) : void 0;
+    const mergedLight = _optionalChain([this, 'access', _307 => _307.doc, 'access', _308 => _308.light, 'optionalAccess', _309 => _309[upper.id]]) || _optionalChain([this, 'access', _310 => _310.doc, 'access', _311 => _311.light, 'optionalAccess', _312 => _312[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _313 => _313.doc, 'access', _314 => _314.light, 'optionalAccess', _315 => _315[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _316 => _316.doc, 'access', _317 => _317.light, 'optionalAccess', _318 => _318[upper.id]]), upper) : void 0, _chunk474IQG74cjs.translateSurface.call(void 0, upper.surface, upper.offset.x, upper.offset.y)) : void 0;
     const lightAfter = _nullishCoalesce(this.lightWithout([upper.id, below.id]).light, () => ( (this.doc.light ? { ...this.doc.light } : void 0)));
     const light = mergedLight ? { ..._nullishCoalesce(lightAfter, () => ( {})), [below.id]: mergedLight } : lightAfter;
     this.commit("Merge down", this.withWetEvents({ ...this.doc, layers, activeLayerId: below.id, ...this.thickWithout([upper.id]), ...this.stickersWithout([upper.id, below.id]), ...this.liveStrokesWithout([upper.id, below.id]), ...light ? { light } : {} }));
@@ -6497,7 +6632,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       this.wet.world.removeLane(l.id);
     }
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunk474IQG74cjs.emptySurface.call(void 0, 4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ..._optionalChain([this, 'access', _318 => _318.doc, 'access', _319 => _319.liveStrokes, 'optionalAccess', _320 => _320[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
+    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunk474IQG74cjs.emptySurface.call(void 0, 4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ..._optionalChain([this, 'access', _319 => _319.doc, 'access', _320 => _320.liveStrokes, 'optionalAccess', _321 => _321[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
     return { layerId: l.id, bounds };
   }
   /**
@@ -6507,8 +6642,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   fillLayer(options = {}) {
     this.requireIdle("filling");
     const fillTarget = this.paintTarget(options.layerId, "fill");
-    if (_optionalChain([this, 'access', _321 => _321.doc, 'access', _322 => _322.stickers, 'optionalAccess', _323 => _323[fillTarget.id], 'optionalAccess', _324 => _324.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _325 => _325.doc, 'access', _326 => _326.liveStrokes, 'optionalAccess', _327 => _327[fillTarget.id]])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a stroke layer (its pixels are drawn from its strokes); fill another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
+    if (_optionalChain([this, 'access', _322 => _322.doc, 'access', _323 => _323.stickers, 'optionalAccess', _324 => _324[fillTarget.id], 'optionalAccess', _325 => _325.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _326 => _326.doc, 'access', _327 => _327.liveStrokes, 'optionalAccess', _328 => _328[fillTarget.id]])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a stroke layer (its pixels are drawn from its strokes); fill another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
     this.dryLayersFirst([_nullishCoalesce(_nullishCoalesce(options.layerId, () => ( this.doc.activeLayerId)), () => ( ""))]);
     const l = this.paintTarget(options.layerId, "fill");
     const color = options.color === void 0 ? this.color : parseColor(options.color);
@@ -6541,7 +6676,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       offset: l.offset
     };
     const surface = this.applyCoverage(l, coverage, rect, apply);
-    const lit = _optionalChain([this, 'access', _328 => _328.doc, 'access', _329 => _329.light, 'optionalAccess', _330 => _330[l.id]]);
+    const lit = _optionalChain([this, 'access', _329 => _329.doc, 'access', _330 => _330.light, 'optionalAccess', _331 => _331[l.id]]);
     const light = lit ? withLayerLight(this.doc.light, l.id, scaleLight(lit, 1 - opacity)) : void 0;
     this.commit("Fill layer", this.withPaintEvent(this.withWetEvents({ ...this.doc, layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), ...light ? { light } : {} }), { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }));
     return { layerId: l.id, bounds: rect };
@@ -6551,7 +6686,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const tiles = new Map(base.tiles);
     for (const { tx, ty } of _chunk474IQG74cjs.tilesInRect.call(void 0, { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height })) {
       const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
-      const src = _nullishCoalesce(_optionalChain([base, 'access', _331 => _331.tiles, 'access', _332 => _332.get, 'call', _333 => _333(key), 'optionalAccess', _334 => _334.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _332 => _332.tiles, 'access', _333 => _333.get, 'call', _334 => _334(key), 'optionalAccess', _335 => _335.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
       const tile = _chunk474IQG74cjs.finishTile.call(void 0, _chunkFQPUF2W2cjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
       if (tile) tiles.set(key, tile);
       else tiles.delete(key);
@@ -6584,7 +6719,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** The effect a layer is drawn from, or `undefined` for other layers. */
   getEffectLayer(layerId) {
-    return _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _335 => _335.doc, 'access', _336 => _336.effectLayers, 'optionalAccess', _337 => _337[layerId]]) : void 0;
+    return _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _336 => _336.doc, 'access', _337 => _337.effectLayers, 'optionalAccess', _338 => _338[layerId]]) : void 0;
   }
   /** The effect paper (without its pixels), or `null`. */
   getPaperEffect() {
@@ -6621,8 +6756,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** A pixel layer that takes effect pixels: unlocked, visible, no sticker layer, no wet paint. */
   effectTarget(layerId, what) {
     const l = this.paintTarget(layerId, what);
-    if (_optionalChain([this, 'access', _338 => _338.doc, 'access', _339 => _339.stickers, 'optionalAccess', _340 => _340[l.id], 'optionalAccess', _341 => _341.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _342 => _342.doc, 'access', _343 => _343.liveStrokes, 'optionalAccess', _344 => _344[l.id]])) throw new PaintEditorError(`Layer "${l.name}" is a stroke layer (its pixels are drawn from its strokes); ${what} another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
+    if (_optionalChain([this, 'access', _339 => _339.doc, 'access', _340 => _340.stickers, 'optionalAccess', _341 => _341[l.id], 'optionalAccess', _342 => _342.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _343 => _343.doc, 'access', _344 => _344.liveStrokes, 'optionalAccess', _345 => _345[l.id]])) throw new PaintEditorError(`Layer "${l.name}" is a stroke layer (its pixels are drawn from its strokes); ${what} another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
     if (this.wet.wetLayerIds().includes(l.id)) throw new PaintEditorError(`Layer "${l.name}" holds wet paint; effects go on dried paint, so dry it first (dry_paint) and try again.`);
     return l;
   }
@@ -6661,8 +6796,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const was = this.doc.paperEffect;
     const paperEffect = {
       ...this.sourceOf(d, values, options.time),
-      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _345 => _345.opacity]))), () => ( 1)),
-      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _346 => _346.blend]))), () => ( "multiply")),
+      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _346 => _346.opacity]))), () => ( 1)),
+      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _347 => _347.blend]))), () => ( "multiply")),
       image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) },
       version: nextPaperEffectVersion()
     };
@@ -6715,8 +6850,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const above = _nullishCoalesce(options.aboveId, () => ( this.doc.activeLayerId));
     const loc = above ? _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, above) : null;
     if (options.aboveId !== void 0 && !loc) throw new PaintEditorError(`Layer "${options.aboveId}" was removed while the effect rendered.`);
-    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _347 => _347.name, 'optionalAccess', _348 => _348.trim, 'call', _349 => _349()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
-    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _350 => _350.parent, 'optionalAccess', _351 => _351.id]), () => ( null)), loc ? loc.index + 1 : void 0);
+    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _348 => _348.name, 'optionalAccess', _349 => _349.trim, 'call', _350 => _350()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
+    const layers = _chunkDPYAO5U6cjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _351 => _351.parent, 'optionalAccess', _352 => _352.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 };
@@ -6869,7 +7004,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** Renders the effect paints of recorded strokes (default all of them) before a replay. */
   async prepareStrokeEffects(strokeIds) {
     const ids = strokeIds ? new Set(strokeIds) : null;
-    const paints2 = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _352 => _352.paint, 'optionalAccess', _353 => _353.type]) === "effect").map((s) => s.paint);
+    const paints2 = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _353 => _353.paint, 'optionalAccess', _354 => _354.type]) === "effect").map((s) => s.paint);
     await this.prepareEffectPaints(paints2);
   }
   /** A small preview of the effect paint (a PNG data URL `size` px wide), or `null` without a rendered one. */
@@ -6932,14 +7067,14 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const before = _chunk474IQG74cjs.readRegion.call(void 0, l.surface, rect);
     const inputs = { source: { width: rect.width, height: rect.height, data: before } };
     const heightInput = d.inputs.find((i) => i.kind === "image" && /^(height|depth|relief)$/i.test(i.name));
-    const relief = _optionalChain([this, 'access', _354 => _354.doc, 'access', _355 => _355.thick, 'optionalAccess', _356 => _356[l.id]]);
+    const relief = _optionalChain([this, 'access', _355 => _355.doc, 'access', _356 => _356.thick, 'optionalAccess', _357 => _357[l.id]]);
     if (heightInput && relief) {
       const h = _chunk474IQG74cjs.readRegion.call(void 0, relief.height, rect);
       const rgba = new Uint8ClampedArray(rect.width * rect.height * 4);
       for (let i = 0; i < h.length; i++) rgba.set([h[i], h[i], h[i], 255], i * 4);
       inputs[heightInput.name] = { width: rect.width, height: rect.height, data: rgba };
     }
-    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _357 => _357.inputs, 'access', _358 => _358.find, 'call', _359 => _359((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _360 => _360.name])), 'optionalAccess', _361 => _361.name]), () => ( "source"));
+    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _358 => _358.inputs, 'access', _359 => _359.find, 'call', _360 => _360((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _361 => _361.name])), 'optionalAccess', _362 => _362.name]), () => ( "source"));
     if (sourceInput !== "source") {
       inputs[sourceInput] = inputs.source;
       delete inputs.source;
@@ -6955,7 +7090,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return this.brushEntries.find((e) => e.brush.id === id);
   }
   findBrush(id) {
-    return _optionalChain([this, 'access', _362 => _362.findEntry, 'call', _363 => _363(id), 'optionalAccess', _364 => _364.brush]);
+    return _optionalChain([this, 'access', _363 => _363.findEntry, 'call', _364 => _364(id), 'optionalAccess', _365 => _365.brush]);
   }
   requireEntry(id) {
     const e = this.findEntry(id);
@@ -6989,7 +7124,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** A library brush by id as stored (its facets), or without an id the active brush as edited. */
   getBrushSpec(id) {
-    const spec = id === void 0 ? this.brushSpec : _optionalChain([this, 'access', _365 => _365.findEntry, 'call', _366 => _366(id), 'optionalAccess', _367 => _367.spec]);
+    const spec = id === void 0 ? this.brushSpec : _optionalChain([this, 'access', _366 => _366.findEntry, 'call', _367 => _367(id), 'optionalAccess', _368 => _368.spec]);
     return spec ? copyJSON(spec) : void 0;
   }
   /**
@@ -7020,7 +7155,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const base = copyJSON(entry ? entry.spec : this.brushSpec);
     for (const k of unset) delete base[k];
     const spec = this.readBrushPatch(base, patch, problems);
-    this.useBrush(unchanged && entry ? entry.brush : _chunkHIMGBZAMcjs.resolveBrush.call(void 0, spec), spec, unchanged && _optionalChain([entry, 'optionalAccess', _368 => _368.builtin]) === true);
+    this.useBrush(unchanged && entry ? entry.brush : _chunkHIMGBZAMcjs.resolveBrush.call(void 0, spec), spec, unchanged && _optionalChain([entry, 'optionalAccess', _369 => _369.builtin]) === true);
     return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
   }
   /**
@@ -7030,7 +7165,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   setBrushSpec(spec) {
     const problems = [];
-    const paint = _optionalChain([spec, 'access', _369 => _369.colour, 'optionalAccess', _370 => _370.default]);
+    const paint = _optionalChain([spec, 'access', _370 => _370.colour, 'optionalAccess', _371 => _371.default]);
     if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
     let next;
     try {
@@ -7053,7 +7188,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   readBrushPatch(base, patch, problems) {
     const { id: _id, name, ...rest } = patch;
-    const paint = _optionalChain([rest, 'access', _371 => _371.colour, 'optionalAccess', _372 => _372.default]);
+    const paint = _optionalChain([rest, 'access', _372 => _372.colour, 'optionalAccess', _373 => _373.default]);
     if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
     try {
       return _chunkHIMGBZAMcjs.normalizeBrushSpec.call(void 0, _chunkPGPFWC35cjs.mergeBrushPatch.call(void 0, base, { ...rest, ...name !== void 0 ? { name } : {} }), problems);
@@ -7263,22 +7398,23 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       return l;
     })();
     const brush = this.strokeBrush(init);
+    if (this.previewing && _chunkHIMGBZAMcjs.isWetBrush.call(void 0, brush)) throw new PaintEditorError(`Wet paint can't be previewed; the ${brush.name} brush paints wet media. Suggest it with a dry brush.`);
     const effect = this.strokeEffect(init, brush);
     if (brush.light.amount > 0) {
       if (brush.engine === "sticker") throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take light yet; paint light with a dab or particle light brush (glow-gel, neon-marker; list_brush_presets lists them), or set light.amount to 0 (set_brush).`);
     }
-    if (_optionalChain([doc, 'access', _373 => _373.liveStrokes, 'optionalAccess', _374 => _374[layer.id]])) {
+    if (_optionalChain([doc, 'access', _374 => _374.liveStrokes, 'optionalAccess', _375 => _375[layer.id]])) {
       const why = liveStrokeRefusal(brush);
       if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
     }
-    if (_optionalChain([doc, 'access', _375 => _375.liveStrokes, 'optionalAccess', _376 => _376[layer.id]]) && _optionalChain([effect, 'optionalAccess', _377 => _377.source, 'access', _378 => _378.live])) {
+    if (_optionalChain([doc, 'access', _376 => _376.liveStrokes, 'optionalAccess', _377 => _377[layer.id]]) && _optionalChain([effect, 'optionalAccess', _378 => _378.source, 'access', _379 => _379.live])) {
       const key = effectPaintKey(effect.source);
       const { sources } = this.liveEffects(doc);
       if (!sources.some((p) => effectPaintKey(p) === key) && sources.length >= MAX_LIVE_EFFECT_SOURCES) {
         throw new PaintEditorError(`The painting already plays ${MAX_LIVE_EFFECT_SOURCES} live effects, the most it can; paint with one of them, or set_effect_paint with live false to bake this one.`);
       }
     }
-    const stickerLayer = Boolean(_optionalChain([doc, 'access', _379 => _379.stickers, 'optionalAccess', _380 => _380[layer.id], 'optionalAccess', _381 => _381.length]));
+    const stickerLayer = Boolean(_optionalChain([doc, 'access', _380 => _380.stickers, 'optionalAccess', _381 => _381[layer.id], 'optionalAccess', _382 => _382.length]));
     if (brush.engine === "sticker") {
       if (!stickerLayer && _chunk474IQG74cjs.contentBounds.call(void 0, layer.surface)) throw new PaintEditorError(`Layer "${layer.name}" already has paint; spray stickers onto an empty layer (add_layer) so they stay editable.`);
     } else if (stickerLayer) {
@@ -7318,7 +7454,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         copies: [IDENTITY_AFFINE, ...copiesW].map(affineCopy),
         mask: init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null,
         paint: effect ? null : wetGradient,
-        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _382 => _382.pixels]), () => ( null))
+        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _383 => _383.pixels]), () => ( null))
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
@@ -7329,7 +7465,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     }
     let color = init.color === void 0 ? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
-    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _383 => _383.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _384 => _384.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;
@@ -7362,9 +7498,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       mixerLoad: _nullishCoalesce(init.load, () => ( brushLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]))),
       secondary: rgbaOf(this.secondaryColor),
       wet,
-      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _384 => _384.thick, 'optionalAccess', _385 => _385[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _385 => _385.thick, 'optionalAccess', _386 => _386[layer.id]]), () => ( emptyThickChannels())) } : void 0,
       // Light paint: a twin of the stroke paints the light channel (laying, dimming, moving light).
-      light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || _optionalChain([doc, 'access', _386 => _386.light, 'optionalAccess', _387 => _387[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _388 => _388.light, 'optionalAccess', _389 => _389[layer.id]]), () => ( emptyLight())) } : null,
+      light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || _optionalChain([doc, 'access', _387 => _387.light, 'optionalAccess', _388 => _388[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _389 => _389.light, 'optionalAccess', _390 => _390[layer.id]]), () => ( emptyLight())) } : null,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc), art: this.stickerArt.get } : void 0,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
@@ -7403,12 +7539,12 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
-        if (_optionalChain([this, 'access', _390 => _390.session, 'optionalAccess', _391 => _391.init, 'access', _392 => _392.wet])) {
+        if (_optionalChain([this, 'access', _391 => _391.session, 'optionalAccess', _392 => _392.init, 'access', _393 => _393.wet])) {
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
-        const ch = _optionalChain([this, 'access', _393 => _393.session, 'optionalAccess', _394 => _394.thickChannels, 'call', _395 => _395()]);
+        const ch = _optionalChain([this, 'access', _394 => _394.session, 'optionalAccess', _395 => _395.thickChannels, 'call', _396 => _396()]);
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
@@ -7420,7 +7556,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         const wetStroke = Boolean(s.init.wet);
         if (wetStroke) this.wet.driver = null;
         const brush = s.init.brush;
-        if (!cancelled && _optionalChain([s, 'access', _396 => _396.result, 'optionalAccess', _397 => _397.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
+        if (!cancelled && _optionalChain([s, 'access', _397 => _397.result, 'optionalAccess', _398 => _398.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           if (this.wetOp) {
             const snap = this.wetOp.before;
@@ -7435,7 +7571,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         }
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _398 => _398.result, 'optionalAccess', _399 => _399.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _399 => _399.result, 'optionalAccess', _400 => _400.bounds]), () => ( null)));
         if (wetStroke && this.wet.instantDry) {
           this.wet.dry(s.layerId);
           this.logWet({ kind: "dry", layerId: s.layerId, at: this.doc.strokes.length + 1 });
@@ -7446,8 +7582,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         const ch = s.thickChannels();
         const thick = ch ? { ..._nullishCoalesce(this.doc.thick, () => ( {})), [l.id]: ch } : this.doc.thick;
         const sprayed = s.stickers();
-        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _400 => _400.doc, 'access', _401 => _401.stickers, 'optionalAccess', _402 => _402[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
-        const wetLight = wetStroke && _optionalChain([this, 'access', _403 => _403.wet, 'access', _404 => _404.world, 'optionalAccess', _405 => _405.hasLane, 'call', _406 => _406(l.id)]) ? this.wet.world.lightDisplay(l.id) : null;
+        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _401 => _401.doc, 'access', _402 => _402.stickers, 'optionalAccess', _403 => _403[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
+        const wetLight = wetStroke && _optionalChain([this, 'access', _404 => _404.wet, 'access', _405 => _405.world, 'optionalAccess', _406 => _406.hasLane, 'call', _407 => _407(l.id)]) ? this.wet.world.lightDisplay(l.id) : null;
         const light = withLayerLight(this.doc.light, l.id, _nullishCoalesce(s.lightChannel(), () => ( wetLight)));
         this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {}, ...light ? { light } : {} }, stroke)), wetStroke ? before : this.doc);
       }
@@ -7477,18 +7613,18 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         if (cancelled || !surface) return;
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _407 => _407.result, 'optionalAccess', _408 => _408.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _408 => _408.result, 'optionalAccess', _409 => _409.bounds]), () => ( null)));
         const l = _chunkDPYAO5U6cjs.findLayer.call(void 0, out.layers, s.layerId).layer;
         const offset = s.init.wet ? { x: 0, y: 0 } : l.offset;
         const ch = s.thickChannels();
         const sprayed = s.stickers();
-        const lit = _nullishCoalesce(s.lightChannel(), () => ( (s.init.wet && _optionalChain([this, 'access', _409 => _409.wet, 'access', _410 => _410.world, 'optionalAccess', _411 => _411.hasLane, 'call', _412 => _412(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
+        const lit = _nullishCoalesce(s.lightChannel(), () => ( (s.init.wet && _optionalChain([this, 'access', _410 => _410.wet, 'access', _411 => _411.world, 'optionalAccess', _412 => _412.hasLane, 'call', _413 => _413(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
         out = withLiveStroke({
           ...out,
           layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, out.layers, l.id, () => ({ ...l, surface, offset })),
           strokes: [...out.strokes, stroke],
           ...ch ? { thick: { ..._nullishCoalesce(out.thick, () => ( {})), [l.id]: ch } } : {},
-          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _413 => _413.stickers, 'optionalAccess', _414 => _414[l.id]]), () => ( [])), ...sprayed] } } : {},
+          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _414 => _414.stickers, 'optionalAccess', _415 => _415[l.id]]), () => ( [])), ...sprayed] } } : {},
           ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {}
         }, stroke);
       }
@@ -7547,7 +7683,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _415 => _415.strokeIds, 'optionalAccess', _416 => _416.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _416 => _416.strokeIds, 'optionalAccess', _417 => _417.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.`);
@@ -7561,7 +7697,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (options.layerId !== void 0) this.paintTarget(options.layerId, "replay onto");
     if (options.color === void 0) {
       for (const s of strokes) {
-        if (_optionalChain([s, 'access', _417 => _417.paint, 'optionalAccess', _418 => _418.type]) === "effect" && !this.effectPaintImage(s.paint)) {
+        if (_optionalChain([s, 'access', _418 => _418.paint, 'optionalAccess', _419 => _419.type]) === "effect" && !this.effectPaintImage(s.paint)) {
           throw new PaintEditorError(`Stroke "${s.id}" paints with the effect "${s.paint.effect}"${s.paint.provider ? ` from provider "${s.paint.provider}"` : ""}, which is not rendered in this editor; render it first (prepareStrokeEffects; the replay_strokes tool does this) or recolour the replay with color.`);
         }
       }
@@ -7619,7 +7755,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** A layer's light paint: whether it has any, where (document pixels), its brightest value 0..255, and its spill. */
   lightOf(layerId) {
     const l = this.wetLayer(layerId, "read the light of");
-    const info = lightInfo(_optionalChain([this, 'access', _419 => _419.doc, 'access', _420 => _420.light, 'optionalAccess', _421 => _421[l.id]]));
+    const info = lightInfo(_optionalChain([this, 'access', _420 => _420.doc, 'access', _421 => _421.light, 'optionalAccess', _422 => _422[l.id]]));
     const bounds = info.bounds ? { ...info.bounds, x: info.bounds.x + l.offset.x, y: info.bounds.y + l.offset.y } : null;
     return { layerId: l.id, hasLight: info.peak > 0, bounds, peak: info.peak, spill: { ...this.lightSpillOf(l.id) } };
   }
@@ -7670,7 +7806,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const ch = _optionalChain([this, 'access', _422 => _422.doc, 'access', _423 => _423.thick, 'optionalAccess', _424 => _424[id]]);
+    const ch = _optionalChain([this, 'access', _423 => _423.doc, 'access', _424 => _424.thick, 'optionalAccess', _425 => _425[id]]);
     if (!ch) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
@@ -7780,7 +7916,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   wetState() {
     const st = this.getState().wet;
     const backend = this.wet.backend();
-    return { ...st, layers: this.wet.wetLayerIds().map((id) => this.wet.info(id)), backend, message: _nullishCoalesce(_optionalChain([backend, 'optionalAccess', _425 => _425.message]), () => ( _chunkKBYB7OWBcjs.wetSupport.call(void 0, ).message)), engine: this.wet.engineInfo() };
+    return { ...st, layers: this.wet.wetLayerIds().map((id) => this.wet.info(id)), backend, message: _nullishCoalesce(_optionalChain([backend, 'optionalAccess', _426 => _426.message]), () => ( _chunkKBYB7OWBcjs.wetSupport.call(void 0, ).message)), engine: this.wet.engineInfo() };
   }
   /**
    * Engine B, the WebGPU accelerator for large wet areas: whether it may run, its state (`off`,
@@ -7865,7 +8001,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** Records a settings change as a wet event (not an undo step). */
   recordWetSetting(e) {
-    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _426 => _426.wet, 'access', _427 => _427.world, 'optionalAccess', _428 => _428.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
+    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _427 => _427.wet, 'access', _428 => _428.world, 'optionalAccess', _429 => _429.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) {
@@ -7934,7 +8070,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (override) return Array.from(override).reduce((ls, [id, surface]) => _chunkDPYAO5U6cjs.mapLayer.call(void 0, ls, id, (l) => ({ ...l, surface })), this.doc.layers);
     const live = this.live;
     if (!live) return this.animatedView();
-    if (_optionalChain([this, 'access', _429 => _429.liveLayers, 'optionalAccess', _430 => _430.key]) === live.surface) return this.liveLayers.layers;
+    if (_optionalChain([this, 'access', _430 => _430.liveLayers, 'optionalAccess', _431 => _431.key]) === live.surface) return this.liveLayers.layers;
     const layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
@@ -7957,7 +8093,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   tracingNode(t) {
     const { width, height } = this.doc.canvas;
     const key = this.tracingVersion * 100003 + width * 7 + height;
-    if (_optionalChain([this, 'access', _431 => _431.tracingCache, 'optionalAccess', _432 => _432.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _432 => _432.tracingCache, 'optionalAccess', _433 => _433.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 };
@@ -7984,8 +8120,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     let out = layers;
     const ids = /* @__PURE__ */ new Set([...Object.keys(_nullishCoalesce(thick, () => ( {}))), ...live ? [live.layerId] : []]);
     for (const id of ids) {
-      const ch = _optionalChain([live, 'optionalAccess', _433 => _433.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _434 => _434[id]]);
-      const l = ch && _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _435 => _435.layer]);
+      const ch = _optionalChain([live, 'optionalAccess', _434 => _434.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _435 => _435[id]]);
+      const l = ch && _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _436 => _436.layer]);
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
@@ -8005,13 +8141,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (!ids.size) return layers;
     let out = layers;
     for (const id of ids) {
-      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _436 => _436.layer]);
+      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, out, id), 'optionalAccess', _437 => _437.layer]);
       if (!isPixelLayer(l)) continue;
       let cache = this.lightCaches.get(id);
       if (!cache) this.lightCaches.set(id, cache = new LightCache());
-      const glowed = cache.glow(l.surface, light[id], _optionalChain([this, 'access', _437 => _437.liveThick, 'optionalAccess', _438 => _438.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _439 => _439.doc, 'access', _440 => _440.thick, 'optionalAccess', _441 => _441[id]]));
+      const glowed = cache.glow(l.surface, light[id], _optionalChain([this, 'access', _438 => _438.liveThick, 'optionalAccess', _439 => _439.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _440 => _440.doc, 'access', _441 => _441.thick, 'optionalAccess', _442 => _442[id]]));
       if (glowed !== l.surface) out = _chunkDPYAO5U6cjs.mapLayer.call(void 0, out, id, () => ({ ...l, surface: glowed }));
-      const committed = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _442 => _442.layer]);
+      const committed = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _443 => _443.layer]);
       const spill = light[id] && isPixelLayer(committed) ? cache.spill(committed.surface, light[id], this.lightSpillOf(id)) : null;
       if (spill) out = insertAfter(out, id, { type: "pixel", id: `${id}${SPILL_SUFFIX}`, name: `${l.name} light`, visible: l.visible, opacity: l.opacity, blend: "linear-dodge", surface: spill, offset: { ...l.offset } });
     }
@@ -8023,7 +8159,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       if (!l.visible) continue;
       if (l.type === "group") this.backlitLayers(l.children, committed, opacity * l.opacity, out);
       else if (isPixelLayer(l)) {
-        const thick = !committed && _optionalChain([this, 'access', _443 => _443.liveThick, 'optionalAccess', _444 => _444.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _445 => _445.doc, 'access', _446 => _446.thick, 'optionalAccess', _447 => _447[l.id]]);
+        const thick = !committed && _optionalChain([this, 'access', _444 => _444.liveThick, 'optionalAccess', _445 => _445.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _446 => _446.doc, 'access', _447 => _447.thick, 'optionalAccess', _448 => _448[l.id]]);
         out.push({ surface: l.surface, offset: l.offset, opacity: opacity * l.opacity, ...thick ? { thick } : {} });
       }
     }
@@ -8052,7 +8188,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (backlight) layers = [...layers, backlight];
     if (options.layerIds) {
       const picked = [];
-      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _448 => _448.layer]), () => ( this.requireLayer(id))));
+      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _449 => _449.layer]), () => ( this.requireLayer(id))));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
     const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
@@ -8068,7 +8204,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    */
   compositeTiles(rect, onTile, options = {}) {
     const dirty = options.dirty === "all" ? void 0 : options.dirty;
-    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _449 => _449.live, 'optionalAccess', _450 => _450.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _450 => _450.live, 'optionalAccess', _451 => _451.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -8147,7 +8283,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const spills = Object.fromEntries(Object.entries(this.lightSpills).filter(([id]) => _chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id)));
     if (Object.keys(spills).length) ext.lightSpill = spills;
     else delete ext.lightSpill;
-    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _451 => _451.layer])));
+    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _452 => _452.layer])));
     if (effectLayers) ext.effectLayers = effectLayers;
     else delete ext.effectLayers;
     if (this.doc.paperEffect) ext.paperEffect = paperEffectToJSON(this.doc.paperEffect);
@@ -8183,7 +8319,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (ext.liveStrokes && typeof ext.liveStrokes === "object") {
       const liveStrokes = {};
       for (const [id, list] of Object.entries(ext.liveStrokes)) {
-        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _452 => _452.layer])) || !Array.isArray(list)) continue;
+        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _453 => _453.layer])) || !Array.isArray(list)) continue;
         const ok = list.map(normalizeBrushStroke).filter((x) => x !== null).map((x) => ({ ...x, layerId: id }));
         if (ok.length !== list.length) problems.push(`Some strokes of stroke layer "${id}" could not be read; they were dropped (the layer's pixels are kept until a stroke is edited).`);
         liveStrokes[id] = ok;
@@ -8193,7 +8329,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (ext.effectLayers && typeof ext.effectLayers === "object") {
       const effectLayers = {};
       for (const [id, v] of Object.entries(ext.effectLayers)) {
-        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _453 => _453.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _454 => _454.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.`);
@@ -8221,7 +8357,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (ext.light && typeof ext.light === "object") {
       const light = {};
       for (const [id, v] of Object.entries(ext.light)) {
-        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _454 => _454.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _455 => _455.layer]))) continue;
         try {
           light[id] = lightFromJSON(v);
         } catch (e) {
@@ -8257,7 +8393,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.readGuides(loaded.guides, loaded.state, loaded.problems);
     if (Array.isArray(loaded.swatches)) this.swatches = loaded.swatches.map(readSwatch).filter((x) => x !== null);
     for (const s of loaded.state.strokes) {
-      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _455 => _455.exec, 'call', _456 => _456(s.id), 'optionalAccess', _457 => _457[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _456 => _456.exec, 'call', _457 => _457(s.id), 'optionalAccess', _458 => _458[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
@@ -8265,7 +8401,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     this.doc = this.readThick(loaded.state, loaded.extensions, loaded.problems);
     for (const list of Object.values(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
       for (const s of list) {
-        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _458 => _458.exec, 'call', _459 => _459(s.id), 'optionalAccess', _460 => _460[1]]), () => ( 0)));
+        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _459 => _459.exec, 'call', _460 => _460(s.id), 'optionalAccess', _461 => _461[1]]), () => ( 0)));
         if (n >= this.strokeCounter) this.strokeCounter = n + 1;
       }
     }
@@ -8364,8 +8500,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layers = toStandard(dried);
     const result = _chunkB7V34GIHcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
-      const label = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _461 => _461.find, 'call', _462 => _462((m) => m.id === mode), 'optionalAccess', _463 => _463.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _464 => _464.find, 'call', _465 => _465((m) => m.id === _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _466 => _466.label]), () => ( _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _462 => _462.find, 'call', _463 => _463((m) => m.id === mode), 'optionalAccess', _464 => _464.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunk2VX55NFMcjs.BLEND_MODES, 'access', _465 => _465.find, 'call', _466 => _466((m) => m.id === _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _467 => _467.label]), () => ( _chunk2VX55NFMcjs.standardBlendMode.call(void 0, mode)));
       const list = names.map((n) => `"${n}"`).join(", ");
       const one = names.length === 1;
       result.warnings.push(`${label} blending has no PSD equivalent; ${list} ${one ? "was" : "were"} written as ${std}, the nearest Photoshop mode, so ${one ? "it looks" : "they look"} different in Photoshop (the merged image is exact).`);
@@ -8487,7 +8623,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const { src, pixels } = this.importImage(options, "The reference image");
     const ref2 = {
       id: `ref${this.nextReferenceId++}`,
-      name: _optionalChain([options, 'access', _467 => _467.name, 'optionalAccess', _468 => _468.trim, 'call', _469 => _469()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _468 => _468.name, 'optionalAccess', _469 => _469.trim, 'call', _470 => _470()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -8566,7 +8702,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
         try {
           const px = this.decodeImage(ref2.src, `Reference "${ref2.name}"`);
           guides.references.push({ id: ref2.id, name: String(_nullishCoalesce(ref2.name, () => ( ref2.id))), src: ref2.src, width: px.width, height: px.height, x: Number(ref2.x) || 0, y: Number(ref2.y) || 0, displayWidth: Number(ref2.displayWidth) || 240, visible: ref2.visible !== false });
-          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _470 => _470.exec, 'call', _471 => _471(ref2.id), 'optionalAccess', _472 => _472[1]]), () => ( 0)));
+          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _471 => _471.exec, 'call', _472 => _472(ref2.id), 'optionalAccess', _473 => _473[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -8577,7 +8713,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       guides.stencils = [];
       r.stencils.forEach((raw2, i) => {
         try {
-          const id = typeof _optionalChain([raw2, 'optionalAccess', _473 => _473.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
+          const id = typeof _optionalChain([raw2, 'optionalAccess', _474 => _474.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;
@@ -8600,12 +8736,12 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   /** The next free sticker number (ids `st<n>` are unique across the document). */
   nextStickerNumber(doc = this.doc) {
     let n = 0;
-    for (const list of Object.values(_nullishCoalesce(doc.stickers, () => ( {})))) for (const st of list) n = Math.max(n, Number(_nullishCoalesce(_optionalChain([/^st(\d+)$/, 'access', _474 => _474.exec, 'call', _475 => _475(st.id), 'optionalAccess', _476 => _476[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', _475 => _475.exec, 'call', _476 => _476(st.id), 'optionalAccess', _477 => _477[1]]), () => ( 0))));
     return n + 1;
   }
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
-    const stickers = _optionalChain([this, 'access', _477 => _477.doc, 'access', _478 => _478.stickers, 'optionalAccess', _479 => _479[l.id]]);
+    const stickers = _optionalChain([this, 'access', _478 => _478.doc, 'access', _479 => _479.stickers, 'optionalAccess', _480 => _480[l.id]]);
     if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (sticker-stars; list_brush_presets lists them).`);
     return { layer: l, stickers };
   }
@@ -8664,7 +8800,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return [];
     this.requireLayer(id);
-    return (_nullishCoalesce(_optionalChain([this, 'access', _480 => _480.doc, 'access', _481 => _481.stickers, 'optionalAccess', _482 => _482[id]]), () => ( []))).map((s) => ({ ...s }));
+    return (_nullishCoalesce(_optionalChain([this, 'access', _481 => _481.doc, 'access', _482 => _482.stickers, 'optionalAccess', _483 => _483[id]]), () => ( []))).map((s) => ({ ...s }));
   }
   /**
    * Replaces a layer's stickers and redraws its pixels from them (one undo step). With `dirty`,
@@ -8685,7 +8821,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** The document from before the sticker preview on screen, or `null` when none is (anything else changed the document since). */
   previewBase() {
-    return _optionalChain([this, 'access', _483 => _483.stickerPreview, 'optionalAccess', _484 => _484.shown]) === this.doc ? this.stickerPreview.base : null;
+    return _optionalChain([this, 'access', _484 => _484.stickerPreview, 'optionalAccess', _485 => _485.shown]) === this.doc ? this.stickerPreview.base : null;
   }
   readStickerUpdate(update) {
     try {
@@ -8700,7 +8836,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const hit = stickerAt(_nullishCoalesce(_optionalChain([this, 'access', _485 => _485.doc, 'access', _486 => _486.stickers, 'optionalAccess', _487 => _487[id]]), () => ( [])), x, y, this.stickerArt.get);
+    const hit = stickerAt(_nullishCoalesce(_optionalChain([this, 'access', _486 => _486.doc, 'access', _487 => _487.stickers, 'optionalAccess', _488 => _488[id]]), () => ( [])), x, y, this.stickerArt.get);
     return hit ? { ...hit } : null;
   }
   /** Picks a sticker for the panel and canvas (`null` for none). Editor state, not an undo step. */
@@ -8756,8 +8892,8 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layer = this.wetLayer(layerId, "add stickers to");
     if (!input.length) throw new PaintEditorError("Pass at least one sticker (ref, x, y).");
     if (input.length > MAX_ADD_STICKERS) throw new PaintEditorError(`At most ${MAX_ADD_STICKERS} stickers per call; split them over several calls.`);
-    const existing = _optionalChain([this, 'access', _488 => _488.doc, 'access', _489 => _489.stickers, 'optionalAccess', _490 => _490[layer.id]]);
-    if (!_optionalChain([existing, 'optionalAccess', _491 => _491.length])) {
+    const existing = _optionalChain([this, 'access', _489 => _489.doc, 'access', _490 => _490.stickers, 'optionalAccess', _491 => _491[layer.id]]);
+    if (!_optionalChain([existing, 'optionalAccess', _492 => _492.length])) {
       if (this.wet.wetLayerIds().includes(layer.id) || _chunk474IQG74cjs.contentBounds.call(void 0, layer.surface)) throw new PaintEditorError(`Layer "${layer.name}" already has paint; add stickers to an empty layer (add_layer) or a sticker layer so they stay editable.`);
     }
     let n = this.nextStickerNumber();
@@ -8774,7 +8910,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
       const id = n++;
       return { id: `st${id}`, size: 48, rotation: 0, color: this.color, opacity: 1, seed: _nullishCoalesce(raw.seed, () => ( _chunk3K6HWEXZcjs.mix32.call(void 0, id * 2654435761 >>> 0) & 2147483647)), ...u };
     });
-    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _492 => _492.length]) ? added.map(stickerRect) : void 0);
+    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _493 => _493.length]) ? added.map(stickerRect) : void 0);
     return added.map((s) => ({ ...s }));
   }
   /** Brings stickers to the top (`front`) or bottom of their layer (one undo step). */
@@ -8813,20 +8949,20 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   liveStrokeLayer(layerId, what) {
     const l = this.wetLayer(layerId, what);
-    const strokes = _optionalChain([this, 'access', _493 => _493.doc, 'access', _494 => _494.liveStrokes, 'optionalAccess', _495 => _495[l.id]]);
+    const strokes = _optionalChain([this, 'access', _494 => _494.doc, 'access', _495 => _495.liveStrokes, 'optionalAccess', _496 => _496[l.id]]);
     if (!strokes) throw new PaintEditorError(`Layer "${l.name}" is not a stroke layer; add one with add_layer {type: "strokes"} (or convert_to_stroke_layer on an empty layer), then paint on it.`);
     return { layer: l, strokes };
   }
   /** Whether a layer is a live stroke layer. */
   isLiveStrokeLayer(layerId) {
-    return Boolean(_optionalChain([this, 'access', _496 => _496.doc, 'access', _497 => _497.liveStrokes, 'optionalAccess', _498 => _498[layerId]]));
+    return Boolean(_optionalChain([this, 'access', _497 => _497.doc, 'access', _498 => _498.liveStrokes, 'optionalAccess', _499 => _499[layerId]]));
   }
   /** Makes an empty pixel layer a live stroke layer (one undo step). */
   convertToLiveStrokes(layerId) {
     this.requireIdle("converting a layer");
     const l = this.paintTarget(layerId, "convert");
-    if (_optionalChain([this, 'access', _499 => _499.doc, 'access', _500 => _500.liveStrokes, 'optionalAccess', _501 => _501[l.id]])) return this.describeLayer(l);
-    if (_optionalChain([this, 'access', _502 => _502.doc, 'access', _503 => _503.stickers, 'optionalAccess', _504 => _504[l.id], 'optionalAccess', _505 => _505.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
+    if (_optionalChain([this, 'access', _500 => _500.doc, 'access', _501 => _501.liveStrokes, 'optionalAccess', _502 => _502[l.id]])) return this.describeLayer(l);
+    if (_optionalChain([this, 'access', _503 => _503.doc, 'access', _504 => _504.stickers, 'optionalAccess', _505 => _505[l.id], 'optionalAccess', _506 => _506.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
     if (_chunk474IQG74cjs.contentBounds.call(void 0, l.surface) || this.wet.wetLayerIds().includes(l.id)) throw new PaintEditorError(`Layer "${l.name}" already has paint, which isn't kept as strokes; convert an empty layer or add a stroke layer (add_layer {type: "strokes"}).`);
     this.commit("Convert to stroke layer", { ...this.doc, liveStrokes: { ..._nullishCoalesce(this.doc.liveStrokes, () => ( {})), [l.id]: [] } });
     return this.describeLayer(this.getLayer(l.id));
@@ -8839,7 +8975,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   findLiveStroke(id) {
     for (const [layerId, strokes] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
       const index = strokes.findIndex((x) => x.id === id);
-      const layer = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _506 => _506.layer]);
+      const layer = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _507 => _507.layer]);
       if (index >= 0 && isPixelLayer(layer)) return { layer, strokes, index };
     }
     const baked = this.doc.strokes.some((x) => x.id === id);
@@ -8934,9 +9070,9 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layers = /* @__PURE__ */ new Map();
     for (const f of found) layers.set(f.layer.id, f.layer);
     for (const [layerId, layer] of layers) {
-      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _507 => _507.liveStrokes, 'optionalAccess', _508 => _508[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
+      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _508 => _508.liveStrokes, 'optionalAccess', _509 => _509[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
       for (const x of gone) bounds = unionRect(bounds, this.strokeArea(x));
-      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _509 => _509.liveStrokes, 'optionalAccess', _510 => _510[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
+      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _510 => _510.liveStrokes, 'optionalAccess', _511 => _511[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
     }
     this.commit(ids.length === 1 ? "Remove stroke" : "Remove strokes", doc);
     return { removed: [...ids], bounds };
@@ -9004,7 +9140,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   withLiveStrokes(doc, layer, list, dirty) {
     if (_chunkDPYAO5U6cjs.isLayerLocked.call(void 0, layer, "pixels")) throw new PaintEditorError(`Layer "${layer.name}" has its pixels locked; unlock it (update_layer locks) first.`);
-    const current = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _511 => _511.layer]);
+    const current = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _512 => _512.layer]);
     const surface = this.drawLiveStrokes(_nullishCoalesce(current, () => ( layer)), list, dirty);
     const next = { ...doc, layers: _chunkDPYAO5U6cjs.mapLayer.call(void 0, doc.layers, layer.id, (l) => ({ ...l, surface, offset: { x: 0, y: 0 } })), liveStrokes: { ..._nullishCoalesce(doc.liveStrokes, () => ( {})), [layer.id]: [...list] } };
     return this.withPaintEvent(next, { kind: "live-strokes", layerId: layer.id, data: { strokes: list.map((x) => JSON.parse(JSON.stringify(x))) } });
@@ -9082,7 +9218,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     if (!this.animatedLayers.size) return this.doc.layers;
     let layers = this.doc.layers;
     for (const [id, a] of this.animatedLayers) {
-      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _512 => _512.layer]);
+      const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, layers, id), 'optionalAccess', _513 => _513.layer]);
       if (isPixelLayer(l) && l.surface === a.base) layers = _chunkDPYAO5U6cjs.mapLayer.call(void 0, layers, id, () => ({ ...l, surface: a.surface }));
     }
     return layers;
@@ -9092,7 +9228,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     const layers = [];
     const sources = /* @__PURE__ */ new Map();
     for (const [id, strokes] of Object.entries(_nullishCoalesce(doc.liveStrokes, () => ( {})))) {
-      const layer = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _513 => _513.layer]);
+      const layer = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _514 => _514.layer]);
       const live = strokes.filter(isLiveEffect);
       if (!isPixelLayer(layer) || !live.length) continue;
       layers.push({ layer, strokes });
@@ -9217,13 +9353,13 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
     return this.withEffectTime(time, () => this.compositePixels(options));
   }
   // --- Stencils --------------------------------------------------------------------
-  __init174() {this.stencilCache = null}
-  __init175() {this.nextStencilId = 1}
+  __init178() {this.stencilCache = null}
+  __init179() {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', _514 => _514.stencilCache, 'optionalAccess', _515 => _515.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
+    if (_optionalChain([this, 'access', _515 => _515.stencilCache, 'optionalAccess', _516 => _516.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
     const mask = stencilMask(stencils, width, height);
     this.stencilCache = { key: stencils, size, mask };
     return mask;
@@ -9285,7 +9421,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   makeSwatch(color, name) {
     const p = typeof color === "string" ? { type: "color", color: parseColor(color) } : this.readStrokePaint(color);
     const out = { color: _chunkFQPUF2W2cjs.paintSourceColor.call(void 0, p, { paint: this.color, secondary: this.secondaryColor }) };
-    if (_optionalChain([name, 'optionalAccess', _516 => _516.trim, 'call', _517 => _517()])) out.name = name.trim();
+    if (_optionalChain([name, 'optionalAccess', _517 => _517.trim, 'call', _518 => _518()])) out.name = name.trim();
     if (p.type === "gradient") out.paint = p;
     return out;
   }
@@ -9337,7 +9473,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
   mixOnPad(paints2, options = {}) {
-    const parsed = (_nullishCoalesce(paints2, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _518 => _518.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _519 => _519.parts]) }));
+    const parsed = (_nullishCoalesce(paints2, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _519 => _519.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _520 => _520.parts]) }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -9426,7 +9562,7 @@ var PaintEditorController = (_class19 = class _PaintEditorController {
   }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
-    const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _520 => _520.layer]);
+    const l = _optionalChain([_chunkDPYAO5U6cjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _521 => _521.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
 }, _class19.__initStatic(), _class19);
@@ -9448,7 +9584,7 @@ function insertAfter(layers, id, node) {
   return layers.map((l) => l.type === "group" ? { ...l, children: insertAfter(l.children, id, node) } : l);
 }
 function isLiveEffect(s) {
-  return _optionalChain([s, 'access', _521 => _521.paint, 'optionalAccess', _522 => _522.type]) === "effect" && s.paint.live === true;
+  return _optionalChain([s, 'access', _522 => _522.paint, 'optionalAccess', _523 => _523.type]) === "effect" && s.paint.live === true;
 }
 function framePaint(p, t) {
   return { ...p, time: p.time + t };
@@ -9473,7 +9609,7 @@ function clipRect(r, width, height) {
   return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
 }
 function withLiveStroke(doc, stroke) {
-  const list = _optionalChain([doc, 'access', _523 => _523.liveStrokes, 'optionalAccess', _524 => _524[stroke.layerId]]);
+  const list = _optionalChain([doc, 'access', _524 => _524.liveStrokes, 'optionalAccess', _525 => _525[stroke.layerId]]);
   return list ? { ...doc, liveStrokes: { ...doc.liveStrokes, [stroke.layerId]: [...list, stroke] } } : doc;
 }
 function shiftDocument(doc, dx, dy) {
@@ -9500,9 +9636,9 @@ function shiftDocument(doc, dx, dy) {
   if (doc.liveStrokes) out.liveStrokes = Object.fromEntries(Object.entries(doc.liveStrokes).map(([id, list]) => [id, list.map(moveStroke)]));
   if (doc.paintEvents) {
     out.paintEvents = doc.paintEvents.map((e) => {
-      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _525 => _525.data, 'optionalAccess', _526 => _526.stickers]) : void 0;
+      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _526 => _526.data, 'optionalAccess', _527 => _527.stickers]) : void 0;
       if (list) return { ...e, data: { ...e.data, stickers: moveStickers(list) } };
-      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _527 => _527.data, 'optionalAccess', _528 => _528.strokes]) : void 0;
+      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _528 => _528.data, 'optionalAccess', _529 => _529.strokes]) : void 0;
       return strokes ? { ...e, data: { ...e.data, strokes: strokes.map(moveStroke) } } : e;
     });
   }
@@ -9566,6 +9702,13 @@ function resampleInto(src, rect, width, height) {
   }
   return { width, height, data: out };
 }
+function clipToCanvas(rect, canvas) {
+  const x0 = Math.max(0, rect.x);
+  const y0 = Math.max(0, rect.y);
+  const x1 = Math.min(canvas.width, rect.x + rect.width);
+  const y1 = Math.min(canvas.height, rect.y + rect.height);
+  return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
+}
 
 // src/paint-editor/presence.ts
 var PaintPresence = class extends _chunkK7ENM55Pcjs.PresenceStore {
@@ -9584,8 +9727,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', _529 => _529[0], 'optionalAccess', _530 => _530.t]);
-  const t1 = _optionalChain([points, 'access', _531 => _531[points.length - 1], 'optionalAccess', _532 => _532.t]);
+  const t0 = _optionalChain([points, 'access', _530 => _530[0], 'optionalAccess', _531 => _531.t]);
+  const t1 = _optionalChain([points, 'access', _532 => _532[points.length - 1], 'optionalAccess', _533 => _533.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -9639,7 +9782,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _533 => _533.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _534 => _534.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _534 => _534.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _535 => _535.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -9686,8 +9829,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _535 => _535.replay, 'access', _536 => _536.strokeIds, 'optionalAccess', _537 => _537.includes, 'call', _538 => _538(s.id)]));
-        const first = _optionalChain([source, 'access', _539 => _539[0], 'optionalAccess', _540 => _540.points, 'access', _541 => _541[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _536 => _536.replay, 'access', _537 => _537.strokeIds, 'optionalAccess', _538 => _538.includes, 'call', _539 => _539(s.id)]));
+        const first = _optionalChain([source, 'access', _540 => _540[0], 'optionalAccess', _541 => _541.points, 'access', _542 => _542[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);
@@ -10786,8 +10929,8 @@ var POINTS = {
   }
 };
 function loadResult(load) {
-  const hex = (c) => c ? "#" + c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("") : null;
-  return { reservoir: hex(load.reservoir), amount: Math.round(load.amount * 1e3) / 1e3, pickup: hex(load.pickup) };
+  const hex2 = (c) => c ? "#" + c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("") : null;
+  return { reservoir: hex2(load.reservoir), amount: Math.round(load.amount * 1e3) / 1e3, pickup: hex2(load.pickup) };
 }
 function createPaintEditorToolProvider(controller, options = {}) {
   const c = typeof controller === "function" ? lazyController(controller) : controller;
@@ -11124,7 +11267,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets to start from (default the active brush)." }, name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." }, ..._chunkPGPFWC35cjs.BRUSH_PATCH_PROPERTIES, unset: _chunkPGPFWC35cjs.BRUSH_UNSET_PROPERTY }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
     handler: async ({ id, unset, ...patch }) => {
-      const stamps = _optionalChain([patch, 'access', _542 => _542.tip, 'optionalAccess', _543 => _543.stamps]);
+      const stamps = _optionalChain([patch, 'access', _543 => _543.tip, 'optionalAccess', _544 => _544.stamps]);
       if (stamps) await c.prepareStickers(stamps);
       const r = c.setBrushFacets(patch, id, unset);
       return { brush: r.spec, engine: r.brush.engine, problems: r.problems };
@@ -11226,7 +11369,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       await c.wetIdle();
       const base = a.brushId ? c.getBrush(a.brushId) : c.getState().brush;
       const brush = a.brush ? c.brushChanges(a.brush, a.brushId) : void 0;
-      if ((_nullishCoalesce(_optionalChain([brush, 'optionalAccess', _544 => _544.engine]), () => ( _optionalChain([base, 'optionalAccess', _545 => _545.engine])))) === "sticker") await c.prepareStickers(_nullishCoalesce(_nullishCoalesce(_optionalChain([brush, 'optionalAccess', _546 => _546.sticker, 'optionalAccess', _547 => _547.stamps]), () => ( _optionalChain([base, 'optionalAccess', _548 => _548.sticker, 'access', _549 => _549.stamps]))), () => ( [])));
+      if ((_nullishCoalesce(_optionalChain([brush, 'optionalAccess', _545 => _545.engine]), () => ( _optionalChain([base, 'optionalAccess', _546 => _546.engine])))) === "sticker") await c.prepareStickers(_nullishCoalesce(_nullishCoalesce(_optionalChain([brush, 'optionalAccess', _547 => _547.sticker, 'optionalAccess', _548 => _548.stamps]), () => ( _optionalChain([base, 'optionalAccess', _549 => _549.sticker, 'access', _550 => _550.stamps]))), () => ( [])));
       const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
       const r = await act({ kind: "stroke", stroke }, () => c.paintStroke(stroke));
       return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
@@ -11258,7 +11401,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       if (ids) {
         for (const id of ids) if (!all.some((s) => s.id === id)) throw new Error(`Unknown stroke "${id}". Call list_strokes without ids for the ids.`);
       }
-      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _550 => _550.document, 'access', _551 => _551.liveStrokes, 'optionalAccess', _552 => _552[s.layerId], 'optionalAccess', _553 => _553.includes, 'call', _554 => _554(s)]) === true)) };
+      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _551 => _551.document, 'access', _552 => _552.liveStrokes, 'optionalAccess', _553 => _553[s.layerId], 'optionalAccess', _554 => _554.includes, 'call', _555 => _555(s)]) === true)) };
     }
   });
   add({
@@ -11567,16 +11710,16 @@ function createPaintEditorToolProvider(controller, options = {}) {
 }
 function hostTool({ coordinates, ...tool }, { origin, onChange }) {
   if (!origin && !onChange) return tool;
-  const write = !_optionalChain([tool, 'access', _555 => _555.annotations, 'optionalAccess', _556 => _556.readOnlyHint]);
+  const write = !_optionalChain([tool, 'access', _556 => _556.annotations, 'optionalAccess', _557 => _557.readOnlyHint]);
   const done = (result) => {
-    if (write) _optionalChain([onChange, 'optionalCall', _557 => _557({ tool: tool.name })]);
-    return origin && _optionalChain([coordinates, 'optionalAccess', _558 => _558.out]) ? fromDocument(result, coordinates.out, origin) : result;
+    if (write) _optionalChain([onChange, 'optionalCall', _558 => _558({ tool: tool.name })]);
+    return origin && _optionalChain([coordinates, 'optionalAccess', _559 => _559.out]) ? fromDocument(result, coordinates.out, origin) : result;
   };
   return {
     ...tool,
     ...origin ? { description: hostedText(_nullishCoalesce(tool.description, () => ( ""))), inputSchema: hostedSchema(tool.inputSchema) } : {},
     handler: (args, context) => {
-      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _559 => _559.in]) ? toDocument(args, coordinates.in, origin) : args, context);
+      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _560 => _560.in]) ? toDocument(args, coordinates.in, origin) : args, context);
       return r instanceof Promise ? r.then(done) : done(r);
     }
   };
@@ -11593,7 +11736,7 @@ function strokeSummary(s, withPoints, live) {
     color: s.color,
     points: withPoints ? s.points : s.points.length,
     seed: s.seed,
-    copies: _nullishCoalesce(_optionalChain([s, 'access', _560 => _560.copies, 'optionalAccess', _561 => _561.length]), () => ( 0)),
+    copies: _nullishCoalesce(_optionalChain([s, 'access', _561 => _561.copies, 'optionalAccess', _562 => _562.length]), () => ( 0)),
     live,
     bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
   };
@@ -11621,20 +11764,20 @@ var PAINT_TOOLS = [
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
 var PaintGesture = (_class20 = class {
-  constructor(controller, box) {;_class20.prototype.__init176.call(this);_class20.prototype.__init177.call(this);_class20.prototype.__init178.call(this);_class20.prototype.__init179.call(this);_class20.prototype.__init180.call(this);_class20.prototype.__init181.call(this);
+  constructor(controller, box) {;_class20.prototype.__init180.call(this);_class20.prototype.__init181.call(this);_class20.prototype.__init182.call(this);_class20.prototype.__init183.call(this);_class20.prototype.__init184.call(this);_class20.prototype.__init185.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init176() {this.tool = "brush"}
+  __init180() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init177() {this.error = null}
+  __init181() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init178() {this.predicted = []}
-  __init179() {this.mode = null}
-  __init180() {this.penAt = null}
-  __init181() {this.penDown = false}
+  __init182() {this.predicted = []}
+  __init183() {this.mode = null}
+  __init184() {this.penAt = null}
+  __init185() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -11690,13 +11833,13 @@ var PaintGesture = (_class20 = class {
     const p = this.doc(e);
     const s = this.controller.getState();
     const layerId = s.document.activeLayerId;
-    if (!layerId || !_optionalChain([s, 'access', _562 => _562.document, 'access', _563 => _563.liveStrokes, 'optionalAccess', _564 => _564[layerId]])) {
+    if (!layerId || !_optionalChain([s, 'access', _563 => _563.document, 'access', _564 => _564.liveStrokes, 'optionalAccess', _565 => _565[layerId]])) {
       this.error = "Pick a stroke layer in the Layers panel (or add one) to select its strokes.";
       return false;
     }
     try {
       const hit = this.controller.liveStrokeAt(layerId, p.x, p.y);
-      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _565 => _565.id]), () => ( null)));
+      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _566 => _566.id]), () => ( null)));
       if (!hit) return false;
       this.mode = { kind: "move-stroke", pointerId: e.pointerId, id: hit.id, from: p, to: p };
       return true;
@@ -11708,7 +11851,7 @@ var PaintGesture = (_class20 = class {
   /** While a stroke is dragged: how far it has moved (document pixels), to draw its outline there. */
   get strokeDrag() {
     const m = this.mode;
-    return _optionalChain([m, 'optionalAccess', _566 => _566.kind]) === "move-stroke" ? { id: m.id, dx: m.to.x - m.from.x, dy: m.to.y - m.from.y } : null;
+    return _optionalChain([m, 'optionalAccess', _567 => _567.kind]) === "move-stroke" ? { id: m.id, dx: m.to.x - m.from.x, dy: m.to.y - m.from.y } : null;
   }
   /**
    * The Stickers tool: pressing a sticker picks it and dragging moves it (one undo step at the
@@ -11782,7 +11925,7 @@ var PaintGesture = (_class20 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _567 => _567.controller, 'access', _568 => _568.activeStroke, 'optionalAccess', _569 => _569.end, 'call', _570 => _570()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _568 => _568.controller, 'access', _569 => _569.activeStroke, 'optionalAccess', _570 => _570.end, 'call', _571 => _571()]);
     if (m.kind === "move-stroke") {
       const dx = Math.round((this.doc(e).x - m.from.x) * 100) / 100;
       const dy = Math.round((this.doc(e).y - m.from.y) * 100) / 100;
@@ -11806,8 +11949,8 @@ var PaintGesture = (_class20 = class {
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _571 => _571.mode, 'optionalAccess', _572 => _572.kind]) === "stroke") _optionalChain([this, 'access', _573 => _573.controller, 'access', _574 => _574.activeStroke, 'optionalAccess', _575 => _575.cancel, 'call', _576 => _576()]);
-    if (_optionalChain([this, 'access', _577 => _577.mode, 'optionalAccess', _578 => _578.kind]) === "sticker") this.controller.cancelStickerPreview();
+    if (_optionalChain([this, 'access', _572 => _572.mode, 'optionalAccess', _573 => _573.kind]) === "stroke") _optionalChain([this, 'access', _574 => _574.controller, 'access', _575 => _575.activeStroke, 'optionalAccess', _576 => _576.cancel, 'call', _577 => _577()]);
+    if (_optionalChain([this, 'access', _578 => _578.mode, 'optionalAccess', _579 => _579.kind]) === "sticker") this.controller.cancelStickerPreview();
     this.mode = null;
   }
   get active() {
@@ -11869,13 +12012,13 @@ function handlePaintShortcut(controller, gesture, e) {
   return false;
 }
 var PaintCanvasPresenter = (_class21 = class {
-  constructor(controller) {;_class21.prototype.__init182.call(this);_class21.prototype.__init183.call(this);_class21.prototype.__init184.call(this);
+  constructor(controller) {;_class21.prototype.__init186.call(this);_class21.prototype.__init187.call(this);_class21.prototype.__init188.call(this);
     this.controller = controller;
   }
   
-  __init182() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init183() {this.scratch = null}
-  __init184() {this.size = ""}
+  __init186() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init187() {this.scratch = null}
+  __init188() {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;
@@ -11907,7 +12050,7 @@ function guideOverlay(controller, drag) {
   const size = s.document.canvas;
   const out = [];
   const layerId = s.document.activeLayerId;
-  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _579 => _579.document, 'access', _580 => _580.liveStrokes, 'optionalAccess', _581 => _581[layerId], 'optionalAccess', _582 => _582.some, 'call', _583 => _583((x) => x.id === s.selectedStroke)]) : false;
+  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _580 => _580.document, 'access', _581 => _581.liveStrokes, 'optionalAccess', _582 => _582[layerId], 'optionalAccess', _583 => _583.some, 'call', _584 => _584((x) => x.id === s.selectedStroke)]) : false;
   const area = strokePicked ? controller.liveStrokeArea(s.selectedStroke) : null;
   if (area) {
     const dx = drag && drag.id === s.selectedStroke ? drag.dx : 0;
@@ -11920,7 +12063,7 @@ function guideOverlay(controller, drag) {
     ];
     for (let i = 0; i < 4; i++) out.push({ from: box[i], to: box[(i + 1) % 4], kind: "stroke" });
   }
-  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _584 => _584.document, 'access', _585 => _585.stickers, 'optionalAccess', _586 => _586[layerId], 'optionalAccess', _587 => _587.find, 'call', _588 => _588((x) => x.id === s.selectedSticker)]) : void 0;
+  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _585 => _585.document, 'access', _586 => _586.stickers, 'optionalAccess', _587 => _587[layerId], 'optionalAccess', _588 => _588.find, 'call', _589 => _589((x) => x.id === s.selectedSticker)]) : void 0;
   if (picked) {
     const r = picked.size / 2 + 2;
     const a = picked.rotation * Math.PI / 180;
@@ -11950,7 +12093,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _589 => _589[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _590 => _590[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -12066,7 +12209,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _590 => _590(id)]);
+    _optionalChain([caf, 'optionalCall', _591 => _591(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {
@@ -12406,6 +12549,396 @@ function createPaintEditorDocument(controller, options = {}) {
   });
 }
 
+// src/paint-editor/collaboration.ts
+var LAYER_FIELDS = ["name", "visible", "opacity", "blend"];
+function createPaintChangeFeed(controller, options = {}) {
+  const now = _nullishCoalesce(options.now, () => ( (() => Date.now())));
+  const listeners = /* @__PURE__ */ new Set();
+  let seq = 0;
+  let pending;
+  const take = () => {
+    const state = controller.getState();
+    const doc = state.document;
+    const layers = /* @__PURE__ */ new Map();
+    for (const l of controller.listLayers()) layers.set(l.id, { name: l.name, visible: l.visible, opacity: l.opacity, blend: l.blend });
+    return { doc, strokes: new Map(doc.strokes.map((s) => [s.id, s])), events: _nullishCoalesce(_optionalChain([doc, 'access', _592 => _592.paintEvents, 'optionalAccess', _593 => _593.length]), () => ( 0)), layers, stroking: state.stroking };
+  };
+  let last = take();
+  const check = () => {
+    const state = controller.getState();
+    if (state.document === last.doc && state.stroking === last.stroking) return null;
+    const next = take();
+    const addedStrokes = [...next.strokes.values()].filter((s) => !last.strokes.has(s.id));
+    const removedStrokes = [...last.strokes.values()].filter((s) => !next.strokes.has(s.id));
+    const allEvents = _nullishCoalesce(state.document.paintEvents, () => ( []));
+    const events = next.events > last.events ? allEvents.slice(last.events) : [];
+    const addedLayers = [];
+    const changedLayers = [];
+    for (const [id, l] of next.layers) {
+      const before = last.layers.get(id);
+      if (!before) addedLayers.push({ id, name: String(l.name) });
+      else {
+        const fields = LAYER_FIELDS.filter((f) => before[f] !== l[f]);
+        if (fields.length) changedLayers.push({ id, name: String(l.name), fields });
+      }
+    }
+    const removedLayers = [...last.layers].filter(([id]) => !next.layers.has(id)).map(([id, l]) => ({ id, name: String(l.name) }));
+    const gestureStarted = next.stroking && !last.stroking;
+    const gestureEnded = !next.stroking && last.stroking;
+    last = next;
+    const edited = addedStrokes.length + removedStrokes.length + events.length + addedLayers.length + removedLayers.length + changedLayers.length > 0;
+    if (!edited && !gestureStarted && !gestureEnded) return null;
+    const commit = edited ? pending : void 0;
+    if (edited) pending = void 0;
+    const change = {
+      seq: ++seq,
+      origin: _nullishCoalesce(_optionalChain([commit, 'optionalAccess', _594 => _594.origin]), () => ( "user")),
+      ...commit ? { commit } : {},
+      addedStrokes,
+      removedStrokes,
+      events,
+      addedLayers,
+      removedLayers,
+      changedLayers,
+      inGesture: next.stroking,
+      ...gestureStarted ? { gestureStarted: true } : {},
+      ...gestureEnded ? { gestureEnded: true } : {},
+      at: now()
+    };
+    listeners.forEach((l) => l(change));
+    return change;
+  };
+  const offCommit = controller.onCommit((event) => {
+    pending = event;
+  });
+  const offState = controller.subscribe(() => {
+    check();
+  });
+  return {
+    check,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    reset() {
+      last = take();
+      pending = void 0;
+    },
+    dispose() {
+      offCommit();
+      offState();
+      listeners.clear();
+    }
+  };
+}
+var HEX4 = /^#[0-9a-f]{6}$/i;
+var DRY_ENGINES = /* @__PURE__ */ new Set(["dab", "particle", "bristle", "mixer"]);
+function suggestionBrushRefusal(brush) {
+  if (!DRY_ENGINES.has(brush.engine)) return `The ${brush.name} brush (${brush.engine}) can't paint a suggestion: suggestions are dry paint on a layer of their own. Use a dab, particle, bristle or mixer brush.`;
+  if (brush.behavior.pickup > 0) return `The ${brush.name} brush picks up paint, which a suggestion on its own layer can't; choose a brush without pickup.`;
+  return null;
+}
+function createPaintProposals(options) {
+  const { controller } = options;
+  const now = _nullishCoalesce(options.now, () => ( (() => Date.now())));
+  const maxPoints = _nullishCoalesce(options.maxPoints, () => ( 4e3));
+  let seq = 0;
+  const makeId = _nullishCoalesce(options.idGenerator, () => ( (() => `paint-proposal-${++seq}`)));
+  let state = { proposals: [] };
+  const listeners = /* @__PURE__ */ new Set();
+  const set = (proposals) => {
+    state = { proposals };
+    listeners.forEach((l) => l(state));
+  };
+  const find = (id) => {
+    const p = state.proposals.find((x) => x.id === id);
+    if (!p) throw new PaintEditorError(`No pending paint proposal "${id}". Call list_paint_proposals for the ids.`);
+    return p;
+  };
+  const strokeIds = () => new Set(controller.getStrokes().map((s) => s.id));
+  const validate = (input) => {
+    if (!_optionalChain([input, 'access', _595 => _595.title, 'optionalAccess', _596 => _596.trim, 'call', _597 => _597()])) throw new PaintEditorError("A proposal needs a title: what it adds, in a few words.");
+    if (!Array.isArray(input.ops) || !input.ops.length) throw new PaintEditorError("A proposal needs at least one op (stroke, wash or echo).");
+    const place = _nullishCoalesce(input.place, () => ( "top"));
+    if (place === "above") {
+      if (!input.layerId) throw new PaintEditorError('place "above" needs layerId: the layer to put the suggestion above (list_layers).');
+      if (!controller.listLayers().some((l) => l.id === input.layerId)) throw new PaintEditorError(`Unknown layer "${input.layerId}". Call list_layers for the ids.`);
+    }
+    const known = strokeIds();
+    let points = 0;
+    input.ops.forEach((op, i) => {
+      const at = `ops[${i}]`;
+      if (op.kind === "stroke") {
+        if (!_optionalChain([op, 'access', _598 => _598.points, 'optionalAccess', _599 => _599.length])) throw new PaintEditorError(`${at}: a stroke needs points in document pixels.`);
+        points += op.points.length;
+        if (op.color !== void 0 && !HEX4.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
+        const brush = op.brushId ? controller.getBrush(op.brushId) : controller.getState().brush;
+        if (!brush) throw new PaintEditorError(`${at}: unknown brush "${op.brushId}". Call list_brush_presets for the ids.`);
+        const refusal = suggestionBrushRefusal(brush);
+        if (refusal) throw new PaintEditorError(`${at}: ${refusal}`);
+        if (op.size !== void 0 && !(op.size > 0)) throw new PaintEditorError(`${at}: size must be above 0 (document pixels).`);
+      } else if (op.kind === "wash") {
+        if (!HEX4.test(_nullishCoalesce(op.color, () => ( "")))) throw new PaintEditorError(`${at}: a wash needs color as #rrggbb.`);
+        if (op.opacity !== void 0 && !(op.opacity > 0 && op.opacity <= 1)) throw new PaintEditorError(`${at}: opacity must be in (0, 1].`);
+      } else if (op.kind === "echo") {
+        if (!_optionalChain([op, 'access', _600 => _600.strokeIds, 'optionalAccess', _601 => _601.length])) throw new PaintEditorError(`${at}: an echo needs strokeIds (list_strokes).`);
+        const unknown = op.strokeIds.filter((id) => !known.has(id));
+        if (unknown.length) throw new PaintEditorError(`${at}: unknown stroke ${unknown.map((u) => `"${u}"`).join(", ")}. Call list_strokes for the ids.`);
+        if (op.color !== void 0 && !HEX4.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
+        if (op.repeat !== void 0 && !(Number.isInteger(op.repeat) && op.repeat >= 1 && op.repeat <= 50)) throw new PaintEditorError(`${at}: repeat must be a whole number from 1 to 50.`);
+        for (const id of op.strokeIds) {
+          const stroke = controller.getStrokes().find((s) => s.id === id);
+          const refusal = suggestionBrushRefusal(stroke.brush);
+          if (refusal) throw new PaintEditorError(`${at}: stroke "${id}": ${refusal}`);
+          points += stroke.points.length * (_nullishCoalesce(op.repeat, () => ( 1)));
+        }
+      } else {
+        throw new PaintEditorError(`${at}: unknown kind "${op.kind}"; use stroke, wash or echo.`);
+      }
+    });
+    if (points > maxPoints) throw new PaintEditorError(`The proposal paints ${points} points; the most is ${maxPoints}. Suggest less, or echo fewer strokes.`);
+  };
+  const paint = (ops, layerId) => {
+    const before = strokeIds();
+    for (const op of ops) {
+      if (op.kind === "stroke") {
+        controller.paintStroke({
+          layerId,
+          points: op.points,
+          ...op.brushId ? { brushId: op.brushId } : {},
+          ...op.color ? { color: op.color } : {},
+          ...op.size ? { brush: { tip: { size: op.size } } } : {},
+          stencils: false
+        });
+      } else if (op.kind === "wash") {
+        controller.fillLayer({ layerId, color: op.color, opacity: _nullishCoalesce(op.opacity, () => ( 0.35)), grain: _nullishCoalesce(op.grain, () => ( 0.4)) });
+      } else {
+        const { kind: _kind, strokeIds: ids, color, repeat, ...variation } = op;
+        controller.replayStrokes({ strokeIds: ids, layerId, ...color ? { color } : {}, ...repeat ? { repeat } : {}, ...variation });
+      }
+    }
+    return controller.getStrokes().map((s) => s.id).filter((id) => !before.has(id));
+  };
+  const missing = (id) => {
+    const p = state.proposals.find((x) => x.id === id);
+    if (!p) return [];
+    const known = strokeIds();
+    return p.anchors.filter((a) => !known.has(a));
+  };
+  const placementOf = (input) => ({
+    place: _nullishCoalesce(input.place, () => ( "top")),
+    ...input.layerId ? { layerId: input.layerId } : {},
+    ...input.layerName ? { layerName: input.layerName } : {}
+  });
+  const topLayerId = () => _optionalChain([controller, 'access', _602 => _602.listLayers, 'call', _603 => _603(), 'access', _604 => _604.find, 'call', _605 => _605((l) => l.parentId === null), 'optionalAccess', _606 => _606.id]);
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    propose(input) {
+      validate(input);
+      const placement = placementOf(input);
+      const preview = controller.previewPaint(
+        (layerId) => {
+          paint(input.ops, layerId);
+        },
+        placement.place === "bottom" ? { bottom: true } : { aboveId: placement.place === "above" ? placement.layerId : topLayerId() }
+      );
+      const proposal = {
+        id: makeId(),
+        title: input.title.trim().slice(0, 120),
+        ...input.rationale ? { rationale: input.rationale } : {},
+        origin: _nullishCoalesce(_nullishCoalesce(input.origin, () => ( options.origin)), () => ( "agent:anonymous")),
+        ops: input.ops.map((op) => ({ ...op })),
+        placement,
+        bounds: preview.bounds,
+        ghost: preview.composite,
+        anchors: [...new Set(input.ops.flatMap((op) => op.kind === "echo" ? op.strokeIds : []))],
+        createdAt: now()
+      };
+      set([...state.proposals, proposal]);
+      return proposal;
+    },
+    accept(id) {
+      const p = find(id);
+      const gone = missing(id);
+      if (gone.length) throw new PaintEditorError(`Paint proposal "${p.title}" echoes strokes that are no longer on the canvas (${gone.join(", ")}); dismiss it or propose it again.`);
+      const placement = p.placement;
+      if (placement.place === "above" && !controller.listLayers().some((l) => l.id === placement.layerId)) {
+        throw new PaintEditorError(`Paint proposal "${p.title}" goes above layer "${placement.layerId}", which is gone; dismiss it or propose it again.`);
+      }
+      const active = controller.getState().document.activeLayerId;
+      const result = controller.withOrigin(
+        p.origin,
+        () => controller.group(p.title, () => {
+          const layer = controller.addLayer({ name: _nullishCoalesce(placement.layerName, () => ( p.title)), ...placement.place === "above" ? { aboveId: placement.layerId } : placement.place === "top" ? { aboveId: topLayerId() } : {} });
+          if (placement.place === "bottom") controller.moveLayer(layer.id, 0, null);
+          return { layerId: layer.id, strokeIds: paint(p.ops, layer.id) };
+        })
+      );
+      if (active && controller.listLayers().some((l) => l.id === active)) controller.setActiveLayer(active);
+      set(state.proposals.filter((x) => x.id !== id));
+      return { proposalId: id, layerId: result.layerId, strokeIds: result.strokeIds, label: p.title };
+    },
+    reject(id) {
+      const p = find(id);
+      set(state.proposals.filter((x) => x.id !== id));
+      return p;
+    },
+    clear(origin) {
+      const dropped = state.proposals.filter((p) => !origin || p.origin === origin);
+      if (dropped.length) set(state.proposals.filter((p) => !dropped.includes(p)));
+      return dropped.map((p) => p.id);
+    },
+    get: (id) => state.proposals.find((p) => p.id === id),
+    missing
+  };
+}
+function paintProposalGhost(proposal) {
+  const b = proposal.bounds;
+  if (!b || !b.width || !b.height || proposal.ghost.length !== b.width * b.height * 4) return null;
+  return { x: b.x, y: b.y, width: b.width, height: b.height, data: proposal.ghost };
+}
+
+// src/paint-editor/collaboration-tools.ts
+var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var proposalIdArg = {
+  type: "object",
+  properties: { proposalId: { type: "string", minLength: 1, description: "Id of a pending paint proposal, from propose_paint or list_paint_proposals." } },
+  required: ["proposalId"],
+  additionalProperties: false
+};
+var hex = { type: "string", pattern: "^#[0-9a-fA-F]{6}$" };
+var opSchema = {
+  type: "object",
+  description: `One thing to paint. kind "stroke": a stroke along points with a dry brush. kind "wash": an even wash over the suggestion's layer (a ground, a glaze). kind "echo": strokes already on the canvas painted again, moved, turned, scaled or mirrored (grass along a horizon, rain, hatching).`,
+  properties: {
+    kind: { type: "string", enum: ["stroke", "wash", "echo"], description: "What this op paints (see above)." },
+    points: {
+      type: "array",
+      minItems: 1,
+      description: "stroke: pen samples in document pixels, in drawing order.",
+      items: {
+        type: "object",
+        properties: {
+          x: { type: "number", description: "Document x in pixels." },
+          y: { type: "number", description: "Document y in pixels." },
+          pressure: { type: "number", minimum: 0, maximum: 1, description: "Pen pressure 0..1 (default 0.5)." }
+        },
+        required: ["x", "y"],
+        additionalProperties: false
+      }
+    },
+    brushId: { type: "string", description: "stroke: a dry brush id from list_brush_presets (dab, particle, bristle or mixer without pickup). Default the editor brush." },
+    size: { type: "number", exclusiveMinimum: 0, description: "stroke: brush size in document pixels. Default the brush's." },
+    color: { ...hex, description: "stroke and echo: #rrggbb (stroke default the editor colour; echo default each stroke's colour). wash: required." },
+    opacity: { type: "number", exclusiveMinimum: 0, maximum: 1, description: "wash: 0..1 (default 0.35)." },
+    grain: { type: "number", minimum: 0, maximum: 1, description: "wash: how much it catches the paper grain, 0..1 (default 0.4)." },
+    strokeIds: { type: "array", minItems: 1, items: { type: "string" }, description: "echo: ids of strokes on the canvas (list_strokes)." },
+    dx: { type: "number", description: "echo: move right by this many document pixels (default 0)." },
+    dy: { type: "number", description: "echo: move down by this many document pixels (default 0)." },
+    rotate: { type: "number", description: "echo: turn this many degrees clockwise about the strokes' centre (default 0)." },
+    scale: { type: "number", exclusiveMinimum: 0, description: "echo: scale about the centre; brush size scales too (default 1)." },
+    flipX: { type: "boolean", description: "echo: mirror horizontally about the centre (default false)." },
+    repeat: { type: "integer", minimum: 1, maximum: 50, description: "echo: repeat the move this many times, each on top of the last (default 1)." }
+  },
+  required: ["kind"],
+  additionalProperties: false
+};
+function createPaintProposalToolProvider(proposals, options = {}) {
+  const readOnlyReason = () => {
+    const ro = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    return ro ? typeof ro === "string" ? ro : "The painting is read-only: paint proposals can be made and rejected but not accepted." : null;
+  };
+  const describe = (p) => ({
+    id: p.id,
+    title: p.title,
+    ...p.rationale ? { rationale: p.rationale } : {},
+    origin: p.origin,
+    ops: p.ops.map((op) => op.kind),
+    placement: p.placement,
+    bounds: p.bounds,
+    anchors: p.anchors,
+    missing: proposals.missing(p.id),
+    createdAt: new Date(p.createdAt).toISOString()
+  });
+  const proposeTool = {
+    name: "propose_paint",
+    title: "Propose paint",
+    description: "Suggests paint without painting it: the user sees it as a ghost over the canvas and accepts or dismisses it, so use it for contributions they did not ask for. Accepted, it is painted on a new layer of its own (on top by default, at the bottom for a ground, or above a layer) as one undo step recorded as yours. Prefer what agents do well: a wash or ground, an echo of the user's strokes, a few deliberate strokes. Dry brushes only. Returns the proposal id, where the ghost sits (bounds, document pixels) and the strokes it builds on. Follow with accept_paint_proposal only when the user asked for it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", minLength: 1, maxLength: 120, description: `What the suggestion adds, in a few words, e.g. "Warm ground behind the figure". The undo step's name once accepted.` },
+        rationale: { type: "string", description: "Why it fits what the user is painting, in one sentence. Shown beside the ghost." },
+        ops: { type: "array", minItems: 1, items: opSchema, description: "What to paint, in order, onto the suggestion's layer." },
+        place: { type: "string", enum: ["top", "bottom", "above"], description: "Where the new layer goes: top (default), bottom (behind everything: grounds and washes), or above layerId." },
+        layerId: { type: "string", description: 'With place "above": the layer to put it above (list_layers).' },
+        layerName: { type: "string", description: "The new layer's name (default the title)." }
+      },
+      required: ["title", "ops"],
+      additionalProperties: false
+    },
+    annotations: { title: "Propose paint", ...WRITE6 },
+    handler: (args, context) => {
+      const origin = _optionalChain([context, 'access', _607 => _607.actor, 'optionalAccess', _608 => _608.id]) ? `agent:${context.actor.id}` : options.fallbackOrigin;
+      const proposal = proposals.propose({ ...args, ...origin ? { origin } : {} });
+      const { id: _id, missing: _missing, createdAt: _createdAt, ...rest } = describe(proposal);
+      return { proposalId: proposal.id, ...rest };
+    }
+  };
+  const listTool = {
+    name: "list_paint_proposals",
+    title: "List paint proposals",
+    description: "Lists the pending paint proposals (ghost paint not yet on the canvas): id, title, rationale, who proposed it, its op kinds, where it goes, where the ghost sits, the strokes it echoes and any of those since removed (missing: it can no longer be accepted), and whether accepting is allowed. Call before accept_paint_proposal or reject_paint_proposal.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "List paint proposals", ...READ7 },
+    handler: () => ({ proposals: proposals.getState().proposals.map(describe), readOnly: readOnlyReason() })
+  };
+  const acceptTool = {
+    name: "accept_paint_proposal",
+    title: "Accept a paint proposal",
+    description: "Paints a pending proposal on a new layer as one undo step, recorded as made by whoever proposed it, and drops it from the pending list; the user's active layer stays theirs. Refuses, changing nothing, when the painting is read-only or a stroke it echoes was removed. Returns the new layer id, the stroke ids painted and the undo step name.",
+    inputSchema: proposalIdArg,
+    annotations: { title: "Accept a paint proposal", ...WRITE6 },
+    handler: (args) => {
+      const reason = readOnlyReason();
+      if (reason) throw new Error(reason);
+      return proposals.accept(args.proposalId);
+    }
+  };
+  const rejectTool = {
+    name: "reject_paint_proposal",
+    title: "Reject a paint proposal",
+    description: "Dismisses a pending paint proposal: its ghost disappears and the painting and its history are unchanged. Use it to withdraw a suggestion that no longer fits. Returns the dismissed proposal id and title.",
+    inputSchema: proposalIdArg,
+    annotations: { title: "Reject a paint proposal", ...WRITE6 },
+    handler: (args) => {
+      const p = proposals.reject(args.proposalId);
+      return { proposalId: p.id, title: p.title, rejected: true };
+    }
+  };
+  return {
+    id: _nullishCoalesce(options.id, () => ( "paint-proposals")),
+    ...options.namespace !== void 0 ? { namespace: options.namespace } : {},
+    title: "Paint proposals",
+    description: "Suggest paint as a ghost the user accepts or dismisses, and accept or reject pending suggestions.",
+    skill: "pixerate-paint-editor",
+    tools: [proposeTool, listTool, acceptTool, rejectTool]
+  };
+}
+
+
+
+
+
 
 
 
@@ -12753,4 +13286,4 @@ function createPaintEditorDocument(controller, options = {}) {
 
 
 
-exports.BACKLIGHT_SPILL = BACKLIGHT_SPILL; exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunk2VX55NFMcjs.BLEND_MODES; exports.BRUSH_ID = _chunkHIMGBZAMcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkHIMGBZAMcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = _chunkPGPFWC35cjs.BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkHIMGBZAMcjs.BUILTIN_BRUSHES; exports.BristleStroke = BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunkHIMGBZAMcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkHIMGBZAMcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkHIMGBZAMcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkHIMGBZAMcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkKBYB7OWBcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkHIMGBZAMcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunkHIMGBZAMcjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkHIMGBZAMcjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkHIMGBZAMcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkHIMGBZAMcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkHIMGBZAMcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkKBYB7OWBcjs.DEFAULT_WET_PARAMS; exports.DOT_ROTATIONS = _chunkHIMGBZAMcjs.DOT_ROTATIONS; exports.DOT_ROTATION_LABELS = DOT_ROTATION_LABELS; exports.DOT_TEXTURE_ORDERS = _chunkHIMGBZAMcjs.DOT_TEXTURE_ORDERS; exports.DOT_TEXTURE_ORDER_LABELS = DOT_TEXTURE_ORDER_LABELS; exports.DryStroke = DryStroke; exports.EFFECT_MAP_REPEATS = EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPXDIAYB6cjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPXDIAYB6cjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunkEUIDTZNQcjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkHIMGBZAMcjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LIVE_STROKE_ENGINES = LIVE_STROKE_ENGINES; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunkFQPUF2W2cjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_DOT_TEXTURES = _chunkHIMGBZAMcjs.MAX_DOT_TEXTURES; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_STICKER_STAMPS = _chunkHIMGBZAMcjs.MAX_STICKER_STAMPS; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunkHIMGBZAMcjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunk2VX55NFMcjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkHIMGBZAMcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkHIMGBZAMcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkFQPUF2W2cjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkFQPUF2W2cjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TARGET = PAINT_TARGET; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunkHIMGBZAMcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkHIMGBZAMcjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkFQPUF2W2cjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkFQPUF2W2cjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPXDIAYB6cjs.PaperGrain; exports.ParticleStroke = ParticleStroke; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.RIBBON_PAIRS = _chunkHIMGBZAMcjs.RIBBON_PAIRS; exports.RIBBON_PAIR_LABELS = RIBBON_PAIR_LABELS; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkJSDND7DFcjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_ART_SIZE = STICKER_ART_SIZE; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerArtCache = StickerArtCache; exports.StickerBrowser = _chunkSABJMH6Mcjs.StickerBrowser; exports.StickerSpray = StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunk3K6HWEXZcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkKBYB7OWBcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkHIMGBZAMcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkKBYB7OWBcjs.WET_PARAM_KEYS; exports.WET_PARAM_SCHEMA = WET_PARAM_SCHEMA; exports.WET_PARAM_SLIDERS = WET_PARAM_SLIDERS; exports.WET_SPEED_SLIDER = WET_SPEED_SLIDER; exports.WET_TILT_SLIDERS = WET_TILT_SLIDERS; exports.WET_TOOLS = _chunkHIMGBZAMcjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkFQPUF2W2cjs.addPaintGradientStop; exports.addPolygonArea = addPolygonArea; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.backlightOf = backlightOf; exports.brushEngineControls = _chunkPGPFWC35cjs.brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkHIMGBZAMcjs.brushTakesPaint; exports.brushToJSON = _chunkHIMGBZAMcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintBrushLibraryToolProvider = createPaintBrushLibraryToolProvider; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.defaultStickerRasterizer = defaultStickerRasterizer; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = effectPaintKey; exports.effectPaintSize = effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPXDIAYB6cjs.grainCatch; exports.grainHeights = _chunkPXDIAYB6cjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunk3K6HWEXZcjs.hash2; exports.hexToPaintRgb = _chunkFQPUF2W2cjs.hexToPaintRgb; exports.hexToRgb8 = hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunkEUIDTZNQcjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunk2VX55NFMcjs.isBlendMode; exports.isGradientPaint = _chunkFQPUF2W2cjs.isGradientPaint; exports.isPaintEffectPaint = isPaintEffectPaint; exports.isPainterlyBlendMode = _chunk2VX55NFMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkHIMGBZAMcjs.isWetBrush; exports.isWetCapable = _chunkHIMGBZAMcjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunk3K6HWEXZcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = _chunkPGPFWC35cjs.multiColorSliders; exports.multiColorToPaint = _chunkHIMGBZAMcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkHIMGBZAMcjs.normalizeBehavior; exports.normalizeBristle = _chunkHIMGBZAMcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkHIMGBZAMcjs.normalizeDynamics; exports.normalizeFlow = _chunkKBYB7OWBcjs.normalizeFlow; exports.normalizeHexColor = _chunkFQPUF2W2cjs.normalizeHexColor; exports.normalizeImpasto = _chunkHIMGBZAMcjs.normalizeImpasto; exports.normalizeLight = _chunkHIMGBZAMcjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkHIMGBZAMcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkHIMGBZAMcjs.normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeParticle = _chunkHIMGBZAMcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkHIMGBZAMcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkHIMGBZAMcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkKBYB7OWBcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkFQPUF2W2cjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkFQPUF2W2cjs.paintSourceColor; exports.paintSourceCss = _chunkFQPUF2W2cjs.paintSourceCss; exports.paintToMultiColor = _chunkHIMGBZAMcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = _chunkHIMGBZAMcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkFQPUF2W2cjs.parsePaintSource; exports.patchBrushValue = _chunkPGPFWC35cjs.patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunk3K6HWEXZcjs.rand01; exports.randSigned = _chunk3K6HWEXZcjs.randSigned; exports.readEffectStrokeMap = readEffectStrokeMap; exports.readPaintEffectPaint = readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkFQPUF2W2cjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkFQPUF2W2cjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = renderPaper; exports.renderStickers = renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkFQPUF2W2cjs.resolvePaintGradient; exports.reversePaintGradient = _chunkFQPUF2W2cjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleArt = sampleArt; exports.sampleEffectAt = sampleEffectAt; exports.sampleEffectField = sampleEffectField; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkFQPUF2W2cjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunk3K6HWEXZcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkFQPUF2W2cjs.solidPaint; exports.stampCoverage = _chunkJSDND7DFcjs.stampCoverage; exports.standardBlendMode = _chunk2VX55NFMcjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = stickerAt; exports.stickerRect = stickerRect; exports.stickerRefLabel = stickerRefLabel; exports.stickerStamp = stickerStamp; exports.stickerSurface = stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.strokeToJSON = strokeToJSON; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = toStrokePoint; exports.toggleDotTexture = toggleDotTexture; exports.toggleStamp = toggleStamp; exports.toggleStickerRef = toggleStickerRef; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkFQPUF2W2cjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkHIMGBZAMcjs.usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wetEngineSummary = wetEngineSummary; exports.wetPaperInput = wetPaperInput; exports.wetPigmentOf = wetPigmentOf; exports.wetSupport = _chunkKBYB7OWBcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunkEUIDTZNQcjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;
+exports.BACKLIGHT_SPILL = BACKLIGHT_SPILL; exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunk2VX55NFMcjs.BLEND_MODES; exports.BRUSH_ID = _chunkHIMGBZAMcjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunkHIMGBZAMcjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = _chunkPGPFWC35cjs.BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunkHIMGBZAMcjs.BUILTIN_BRUSHES; exports.BristleStroke = BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunkHIMGBZAMcjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunkHIMGBZAMcjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunkHIMGBZAMcjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunkHIMGBZAMcjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkKBYB7OWBcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunkHIMGBZAMcjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunkHIMGBZAMcjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunkHIMGBZAMcjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkFQPUF2W2cjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunkHIMGBZAMcjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunkHIMGBZAMcjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunkHIMGBZAMcjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkKBYB7OWBcjs.DEFAULT_WET_PARAMS; exports.DOT_ROTATIONS = _chunkHIMGBZAMcjs.DOT_ROTATIONS; exports.DOT_ROTATION_LABELS = DOT_ROTATION_LABELS; exports.DOT_TEXTURE_ORDERS = _chunkHIMGBZAMcjs.DOT_TEXTURE_ORDERS; exports.DOT_TEXTURE_ORDER_LABELS = DOT_TEXTURE_ORDER_LABELS; exports.DryStroke = DryStroke; exports.EFFECT_MAP_REPEATS = EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPXDIAYB6cjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPXDIAYB6cjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunkEUIDTZNQcjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunkHIMGBZAMcjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LIVE_STROKE_ENGINES = LIVE_STROKE_ENGINES; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunkFQPUF2W2cjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_DOT_TEXTURES = _chunkHIMGBZAMcjs.MAX_DOT_TEXTURES; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_STICKER_STAMPS = _chunkHIMGBZAMcjs.MAX_STICKER_STAMPS; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunkHIMGBZAMcjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunk2VX55NFMcjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunkHIMGBZAMcjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunkHIMGBZAMcjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkFQPUF2W2cjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkFQPUF2W2cjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkFQPUF2W2cjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkFQPUF2W2cjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TARGET = PAINT_TARGET; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunkHIMGBZAMcjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunkHIMGBZAMcjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkFQPUF2W2cjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkFQPUF2W2cjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPXDIAYB6cjs.PaperGrain; exports.ParticleStroke = ParticleStroke; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.RIBBON_PAIRS = _chunkHIMGBZAMcjs.RIBBON_PAIRS; exports.RIBBON_PAIR_LABELS = RIBBON_PAIR_LABELS; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunkJSDND7DFcjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_ART_SIZE = STICKER_ART_SIZE; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerArtCache = StickerArtCache; exports.StickerBrowser = _chunkSABJMH6Mcjs.StickerBrowser; exports.StickerSpray = StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunk3K6HWEXZcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkKBYB7OWBcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunkHIMGBZAMcjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkKBYB7OWBcjs.WET_PARAM_KEYS; exports.WET_PARAM_SCHEMA = WET_PARAM_SCHEMA; exports.WET_PARAM_SLIDERS = WET_PARAM_SLIDERS; exports.WET_SPEED_SLIDER = WET_SPEED_SLIDER; exports.WET_TILT_SLIDERS = WET_TILT_SLIDERS; exports.WET_TOOLS = _chunkHIMGBZAMcjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkFQPUF2W2cjs.addPaintGradientStop; exports.addPolygonArea = addPolygonArea; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.backlightOf = backlightOf; exports.brushEngineControls = _chunkPGPFWC35cjs.brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunkHIMGBZAMcjs.brushTakesPaint; exports.brushToJSON = _chunkHIMGBZAMcjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintBrushLibraryToolProvider = createPaintBrushLibraryToolProvider; exports.createPaintChangeFeed = createPaintChangeFeed; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintProposalToolProvider = createPaintProposalToolProvider; exports.createPaintProposals = createPaintProposals; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.defaultStickerRasterizer = defaultStickerRasterizer; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = effectPaintKey; exports.effectPaintSize = effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPXDIAYB6cjs.grainCatch; exports.grainHeights = _chunkPXDIAYB6cjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunk3K6HWEXZcjs.hash2; exports.hexToPaintRgb = _chunkFQPUF2W2cjs.hexToPaintRgb; exports.hexToRgb8 = hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunkEUIDTZNQcjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunk2VX55NFMcjs.isBlendMode; exports.isGradientPaint = _chunkFQPUF2W2cjs.isGradientPaint; exports.isPaintEffectPaint = isPaintEffectPaint; exports.isPainterlyBlendMode = _chunk2VX55NFMcjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunkHIMGBZAMcjs.isWetBrush; exports.isWetCapable = _chunkHIMGBZAMcjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunk3K6HWEXZcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = _chunkPGPFWC35cjs.multiColorSliders; exports.multiColorToPaint = _chunkHIMGBZAMcjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunkHIMGBZAMcjs.normalizeBehavior; exports.normalizeBristle = _chunkHIMGBZAMcjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunkHIMGBZAMcjs.normalizeDynamics; exports.normalizeFlow = _chunkKBYB7OWBcjs.normalizeFlow; exports.normalizeHexColor = _chunkFQPUF2W2cjs.normalizeHexColor; exports.normalizeImpasto = _chunkHIMGBZAMcjs.normalizeImpasto; exports.normalizeLight = _chunkHIMGBZAMcjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunkHIMGBZAMcjs.normalizeMultiColor; exports.normalizePaintBrush = _chunkHIMGBZAMcjs.normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeParticle = _chunkHIMGBZAMcjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunkHIMGBZAMcjs.normalizeStickerSettings; exports.normalizeStickerUpdate = normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunkHIMGBZAMcjs.normalizeWetBrush; exports.normalizeWetParams = _chunkKBYB7OWBcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkFQPUF2W2cjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintProposalGhost = paintProposalGhost; exports.paintSourceColor = _chunkFQPUF2W2cjs.paintSourceColor; exports.paintSourceCss = _chunkFQPUF2W2cjs.paintSourceCss; exports.paintToMultiColor = _chunkHIMGBZAMcjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = _chunkHIMGBZAMcjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkFQPUF2W2cjs.parsePaintSource; exports.patchBrushValue = _chunkPGPFWC35cjs.patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunk3K6HWEXZcjs.rand01; exports.randSigned = _chunk3K6HWEXZcjs.randSigned; exports.readEffectStrokeMap = readEffectStrokeMap; exports.readPaintEffectPaint = readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkFQPUF2W2cjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkFQPUF2W2cjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = renderPaper; exports.renderStickers = renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkFQPUF2W2cjs.resolvePaintGradient; exports.reversePaintGradient = _chunkFQPUF2W2cjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleArt = sampleArt; exports.sampleEffectAt = sampleEffectAt; exports.sampleEffectField = sampleEffectField; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkFQPUF2W2cjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunk3K6HWEXZcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkFQPUF2W2cjs.solidPaint; exports.stampCoverage = _chunkJSDND7DFcjs.stampCoverage; exports.standardBlendMode = _chunk2VX55NFMcjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = stickerAt; exports.stickerRect = stickerRect; exports.stickerRefLabel = stickerRefLabel; exports.stickerStamp = stickerStamp; exports.stickerSurface = stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.strokeToJSON = strokeToJSON; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = toStrokePoint; exports.toggleDotTexture = toggleDotTexture; exports.toggleStamp = toggleStamp; exports.toggleStickerRef = toggleStickerRef; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkFQPUF2W2cjs.updatePaintGradientStop; exports.usesPaintExchange = _chunkHIMGBZAMcjs.usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wetEngineSummary = wetEngineSummary; exports.wetPaperInput = wetPaperInput; exports.wetPigmentOf = wetPigmentOf; exports.wetSupport = _chunkKBYB7OWBcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunkEUIDTZNQcjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;