@pixerate/editor 0.246.0 → 0.249.0

package/dist/paint-editor/index.js

@@ -1,23 +1,36 @@
+import {
+  StickerBrowser,
+  editorStickers
+} from "../chunk-EJLRBS5Q.js";
 import {
   toVideoFfmpeg
 } from "../chunk-L3JFOTBQ.js";
 import {
+  createLayerEffectTools,
   deserializeLayers,
   exportPsd,
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-4PMCMWQS.js";
+} from "../chunk-UBRJOIR5.js";
 import "../chunk-3CI7FRMK.js";
 import "../chunk-ZNA3IQZF.js";
 import {
+  LAYER_EFFECT_KINDS,
+  LayerEffectError,
   RasterCompositor,
+  defaultLayerEffect,
   findLayer,
   flattenLayers,
   insertLayer,
+  isLayerEffectKind,
   isLayerLocked,
-  mapLayer
-} from "../chunk-UOOK7HTX.js";
+  layerEffectLabel,
+  mapLayer,
+  mergeLayerEffect,
+  newEffectId,
+  validateLayerEffects
+} from "../chunk-3PPJRMIG.js";
 import "../chunk-OHKOFKBY.js";
 import "../chunk-ZIF4UJJ6.js";
 import {
@@ -44,7 +57,7 @@ import {
   pigmentOf,
   pointerPressure,
   wetSupport
-} from "../chunk-P3NIPIKS.js";
+} from "../chunk-WQCNC4DK.js";
 import "../chunk-HVQVHUTV.js";
 import {
   writeZip
@@ -55,7 +68,7 @@ import {
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-IVSWRVB4.js";
-import "../chunk-N6WUB3Y5.js";
+import "../chunk-PZP2SZIZ.js";
 import {
   BRUSH_ID,
   BRUSH_ROTATIONS,
@@ -72,11 +85,15 @@ import {
   DEFAULT_PARTICLE,
   DEFAULT_STICKER,
   DEFAULT_WET_BRUSH,
+  DOT_ROTATIONS,
+  DOT_TEXTURE_ORDERS,
   DryStroke,
   EFFECT_MAP_REPEATS,
   EFFECT_STRIP_HEIGHT,
   IDENTITY_COPY,
   IMPASTO_TOOLS,
+  MAX_DOT_TEXTURES,
+  MAX_STICKER_STAMPS,
   MULTI_COLOR_MODES,
   PAINT_BRUSH_CATEGORIES,
   PAINT_BRUSH_ENGINES,
@@ -87,13 +104,17 @@ import {
   ParticleStroke,
   PenDabWalker,
   PenSmoother,
-  STAMP_KINDS,
+  RIBBON_PAIRS,
+  STICKER_ART_SIZE,
+  StickerArtCache,
   StickerSpray,
   WET_MEDIA,
   WET_TOOLS,
+  addPolygonArea,
   brushTakesPaint,
   brushToJSON,
   clonePaper,
+  defaultStickerRasterizer,
   drawSticker,
   effectDabField,
   effectPaintKey,
@@ -124,16 +145,25 @@ import {
   readPaintEffectPaint,
   renderPaper,
   renderStickers,
+  sampleArt,
   sampleEffectAt,
   sampleEffectField,
-  stampCoverage,
   stickerAt,
   stickerRect,
+  stickerStamp,
   stickerSurface,
   tiltToOrientation,
   toStrokePoint,
   usesPaintExchange
-} from "../chunk-VDAWA546.js";
+} from "../chunk-J7T5QZ45.js";
+import {
+  STAMP_KINDS,
+  StickersSlot,
+  createStickerTools,
+  editorStampOf,
+  normalizeStickerRef,
+  stampCoverage
+} from "../chunk-5RH3VXAK.js";
 import "../chunk-M6DNZNVY.js";
 import "../chunk-WEIK3UYB.js";
 import "../chunk-PWBZH3FK.js";
@@ -174,7 +204,6 @@ import {
   PaperGrain,
   SmudgeTip,
   TileMedium,
-  TileableNoise,
   addPaintGradientStop,
   applyStrokeToTile,
   blenderDab,
@@ -184,46 +213,51 @@ import {
   exchangeRates,
   grainCatch,
   grainHeights,
-  hash2,
   hexToPaintRgb,
   isGradientPaint,
   loadMixer,
-  mix32,
   mixerRates,
   normalizeHexColor,
   paintGradientMappingFor,
   paintSourceColor,
   paintSourceCss,
   parsePaintSource,
-  rand01,
-  randSigned,
   rasterizeDab,
   readPaintSource,
   removePaintGradientStop,
   resolvePaintGradient,
   reversePaintGradient,
   scalePaintGradient,
-  seedFromString,
   solidPaint,
   updatePaintGradientStop
-} from "../chunk-2PBZBRP5.js";
+} from "../chunk-D5KGAO4Z.js";
+import {
+  TileableNoise,
+  hash2,
+  mix32,
+  rand01,
+  randSigned,
+  seedFromString
+} from "../chunk-4D6KP5BV.js";
 import "../chunk-ODBT55Q7.js";
 import {
   BLEND_MODES,
   PAINTERLY_BLEND_MODES,
+  isBlendMode,
+  isPainterlyBlendMode,
+  mixPigment8,
+  mixPigments,
+  standardBlendMode
+} from "../chunk-IRSTHLQQ.js";
+import {
   base64ToBytes,
   bytesToBase64,
   decodePng,
   encodePng,
-  isBlendMode,
-  isPainterlyBlendMode,
   isPng,
-  mixPigment8,
-  mixPigments,
   parseDataUrl,
-  pngDataUrl,
-  standardBlendMode
-} from "../chunk-42TWUPNJ.js";
+  pngDataUrl
+} from "../chunk-OTTT5N3K.js";
 import {
   TILE,
   TiledSurface,
@@ -1291,7 +1325,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
     };
     if (this.wetDriver) {
     } else if (init.sticker) {
-      this.stickerSpray = new StickerSpray({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: init.paint ?? null, effect });
+      this.stickerSpray = new StickerSpray({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: init.paint ?? null, effect, art: init.sticker.art });
     } else if (init.thick) {
       const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
       this.thickDriver = new ThickStrokeDriver({ brush, target: this.tileTarget(), channels: init.thick.channels, color: rgb(init.color), load: init.mixerLoad, seed: init.seed, copies: this.copies, paint: init.paint ?? null, effect });
@@ -1501,6 +1535,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
     const surface = changed ? new TiledSurface(ch, tiles, this.base.defaultValue) : null;
     const dabs = this.dry ? this.dry.dabCount : this.thickDriver ? this.thickDriver.dabCount : this.stickerSpray ? this.stickerSpray.dabCount : this.wet.dabCount;
     this.result = { layerId: this.layerId, bounds: changed ? this.bounds : null, dabs, strokeId: null };
+    if (this.stickerSpray?.skipped.size) this.result.skippedStickers = [...this.stickerSpray.skipped];
     const carried = this.wet?.load ?? this.thickDriver?.load;
     if (carried) this.result.mixerLoad = this.init.brush.behavior.dirty ? carried : cleanMixer(carried);
     this.host.commit(this, surface, false);
@@ -3500,7 +3535,9 @@ function liveStrokeBounds(stroke) {
       if (q.y > y1) y1 = q.y;
     }
   }
-  const pad = stroke.brush.tip.size * (stroke.brush.engine === "particle" ? 2 : 1) + 2;
+  const particle = stroke.brush.engine === "particle" ? stroke.brush.particle : null;
+  const wave = particle ? Math.max(particle.waveAmplitude ?? 0, particle.kind === "fuzzy" ? 0.12 : 0) : 0;
+  const pad = stroke.brush.tip.size * (particle ? 2 + wave : 1) + 2;
   return { x: Math.floor(x0 - pad), y: Math.floor(y0 - pad), width: Math.ceil(x1 - x0 + 2 * pad), height: Math.ceil(y1 - y0 + 2 * pad) };
 }
 
@@ -4032,6 +4069,14 @@ function effectLayersToJSON(map, keep) {
 }
 
 // src/paint-editor/controller.ts
+function effectGuard(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    if (e instanceof LayerEffectError) throw new PaintEditorError(e.message);
+    throw e;
+  }
+}
 var PaintEditorError = class extends Error {
   constructor(message) {
     super(message);
@@ -4137,10 +4182,16 @@ var PaintEditorController = class _PaintEditorController {
   wetOp = null;
   /** The effects provider slot (see `setEffectsProvider`). */
   effects = new EffectsSlot();
+  /** The sticker library slot (see `setStickersProvider`). */
+  stickers = new StickersSlot(editorStickers());
+  stickerArt = new StickerArtCache();
+  rasterizeSticker;
   effectsRenderer = new PaintEffectsRenderer();
   paperEffectNodeCache = null;
   constructor(options = {}) {
     this.historyLimit = Math.max(1, options.historyLimit ?? 200);
+    this.rasterizeSticker = options.rasterizeSticker ?? defaultStickerRasterizer;
+    if (options.stickers) this.stickers.set(options.stickers);
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
     this.userBrushes = (options.brushes ?? []).map((b) => normalizePaintBrush({ ...b, builtin: false }));
     const start = this.findBrush(options.brushId ?? DEFAULT_BRUSH_ID) ?? this.findBrush(DEFAULT_BRUSH_ID);
@@ -4557,6 +4608,7 @@ var PaintEditorController = class _PaintEditorController {
       active: l.id === this.doc.activeLayerId,
       bounds,
       ...this.doc.liveStrokes?.[l.id] ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
+      ...l.effects?.items.length ? { effects: l.effects.items.length } : {},
       parentId,
       depth
     };
@@ -4630,6 +4682,94 @@ var PaintEditorController = class _PaintEditorController {
     this.commit("Layer properties", { ...this.doc, layers: mapLayer(this.doc.layers, id, () => next) });
     return this.describeLayer(next);
   }
+  // --- Layer effects (layer styles) ---------------------------------------------
+  /** A layer's live effects (an empty, enabled list when it has none). */
+  getLayerEffects(id) {
+    return this.requireLayer(id).effects ?? { enabled: true, items: [] };
+  }
+  /**
+   * Adds a live effect of `kind` (outer and inner glow, drop and inner shadow, stroke, bevel &
+   * emboss, satin, colour / gradient / pattern overlay) with Photoshop's defaults and `settings`
+   * applied, at `index` in the layer's list (default the end). The effect is drawn from the
+   * layer's pixels when it is composited, so it follows later painting. One undo step.
+   */
+  addLayerEffect(id, kind, settings = {}, index) {
+    if (!isLayerEffectKind(kind)) throw new PaintEditorError(`Unknown effect kind "${String(kind)}". Kinds: ${LAYER_EFFECT_KINDS.join(", ")}.`);
+    const current = this.effectsLayer(id, "add effects").effects ?? { enabled: true, items: [] };
+    const ids = new Set(current.items.map((e) => e.id));
+    let effectId = newEffectId();
+    while (ids.has(effectId)) effectId = newEffectId();
+    const { id: _id, kind: _kind, ...rest } = settings;
+    const effect = effectGuard(() => mergeLayerEffect(defaultLayerEffect(kind, effectId), rest));
+    const items = [...current.items];
+    const at = index === void 0 ? items.length : Math.max(0, Math.min(items.length, Math.floor(index)));
+    items.splice(at, 0, effect);
+    this.writeLayerEffects(id, { ...current, items }, `Add ${layerEffectLabel(kind)}`, true);
+    return { effect, effects: this.getLayerEffects(id) };
+  }
+  /**
+   * Changes one effect: only the given settings (nested objects replace whole; `null` removes an
+   * optional contour or texture). One undo step, or with `commitToHistory` false folded into the
+   * last change of this effect (a slider drag). Returns the layer's effects.
+   */
+  updateLayerEffect(id, effectId, changes, commitToHistory = true) {
+    const current = this.effectsLayer(id, "change its effects").effects;
+    const i = this.requireEffect(id, effectId);
+    const items = [...current.items];
+    items[i] = effectGuard(() => mergeLayerEffect(items[i], changes));
+    this.writeLayerEffects(id, { ...current, items }, `Change ${layerEffectLabel(items[i].kind)}`, commitToHistory);
+    return this.getLayerEffects(id);
+  }
+  /** Removes one effect (one undo step). Returns the layer's remaining effects. */
+  removeLayerEffect(id, effectId) {
+    const current = this.effectsLayer(id, "change its effects").effects;
+    const i = this.requireEffect(id, effectId);
+    this.writeLayerEffects(id, { ...current, items: current.items.filter((e) => e.id !== effectId) }, `Remove ${layerEffectLabel(current.items[i].kind)}`, true);
+    return this.getLayerEffects(id);
+  }
+  /** Turns all of a layer's effects on or off and, when given, sets Scale Effects (0.01..10). One undo step. */
+  setLayerEffectsEnabled(id, enabled, scale, commitToHistory = true) {
+    const current = this.effectsLayer(id, "change its effects").effects ?? { enabled: true, items: [] };
+    if (scale !== void 0 && !(Number.isFinite(scale) && scale >= 0.01 && scale <= 10)) throw new PaintEditorError(`scale must be from 0.01 to 10 (1 = 100 %), got ${scale}.`);
+    const next = { ...current, enabled };
+    if (scale !== void 0) {
+      if (scale === 1) delete next.scale;
+      else next.scale = scale;
+    }
+    this.writeLayerEffects(id, next, "Layer effects", commitToHistory);
+    return this.getLayerEffects(id);
+  }
+  /** Replaces a layer's effects, validated (`null` removes them). One undo step. Returns the effects. */
+  setLayerEffects(id, effects, commitToHistory = true) {
+    this.effectsLayer(id, "change its effects");
+    if (effects) effectGuard(() => validateLayerEffects(effects));
+    this.writeLayerEffects(id, effects, "Layer effects", commitToHistory);
+    return this.getLayerEffects(id);
+  }
+  /** Document patterns for pattern effects besides the built-in ones: none (paint documents bring none). */
+  getDocumentPatterns() {
+    return [];
+  }
+  effectsLayer(id, action) {
+    this.requireIdle("changing layer effects");
+    const l = this.requireLayer(id);
+    if (isLayerLocked(l, "all")) throw new PaintEditorError(`Layer "${l.name}" is fully locked, so it can't ${action}; unlock it first (locks {all: false}).`);
+    return l;
+  }
+  requireEffect(id, effectId) {
+    const l = this.requireLayer(id);
+    const items = l.effects?.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;
+  }
+  /** Writes a layer's effects (dropped when empty, enabled and unscaled), as an undo step or folded into the last one. */
+  writeLayerEffects(id, effects, label, commitToHistory) {
+    const next = { ...this.requireLayer(id) };
+    if (effects && (effects.items.length || effects.psd || effects.scale !== void 0 || !effects.enabled)) next.effects = effects;
+    else delete next.effects;
+    this.commitOrAmend(label, { ...this.doc, layers: mapLayer(this.doc.layers, id, () => next) }, commitToHistory);
+  }
   removeLayer(id) {
     this.requireIdle("removing a layer");
     const l = this.requireLayer(id);
@@ -5210,6 +5350,7 @@ var PaintEditorController = class _PaintEditorController {
     else delete next.builtin;
     this.brush = next;
     this.emit([]);
+    if (next.engine === "sticker" && next.sticker.stamps.some((r) => !editorStampOf(r))) void this.prepareStickers(next.sticker.stamps).catch(() => this.emit([]));
     return this.brush;
   }
   /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
@@ -5535,7 +5676,7 @@ var PaintEditorController = class _PaintEditorController {
       thick: brush.engine === "impasto" ? { channels: doc.thick?.[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 || doc.light?.[layer.id]) ? { surface: doc.light?.[layer.id] ?? emptyLight() } : null,
-      sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc) } : void 0,
+      sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc), art: this.stickerArt.get } : void 0,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
     });
@@ -6332,9 +6473,19 @@ var PaintEditorController = class _PaintEditorController {
       const stickers = {};
       for (const [id, list] of Object.entries(ext.stickers)) {
         if (!findLayer(state.layers, id) || !Array.isArray(list)) continue;
-        const ok = list.filter((x) => x && typeof x.id === "string" && STAMP_KINDS.includes(x.stamp) && Number.isFinite(x.x) && Number.isFinite(x.y) && x.size > 0);
+        const ok = list.flatMap((x) => {
+          if (!x || typeof x.id !== "string" || !Number.isFinite(x.x) || !Number.isFinite(x.y) || !(x.size > 0)) return [];
+          try {
+            const ref2 = normalizeStickerRef(x.ref ?? x.stamp);
+            const stamp = editorStampOf(ref2);
+            const { stamp: _old, ...rest } = x;
+            return [{ ...rest, ref: ref2, ...stamp ? { stamp } : {} }];
+          } catch {
+            return [];
+          }
+        });
         if (ok.length !== list.length) problems.push(`Some stickers of layer "${id}" could not be read; they were dropped.`);
-        stickers[id] = ok.map((x) => ({ ...x }));
+        stickers[id] = ok;
       }
       if (Object.keys(stickers).length) state = { ...state, stickers };
     }
@@ -6438,6 +6589,8 @@ var PaintEditorController = class _PaintEditorController {
     delete this.extensions.paperEffect;
     this.viewCompositor.clear();
     this.emit();
+    const refs = Object.values(this.doc.stickers ?? {}).flatMap((list) => list.map((x) => x.ref));
+    if (refs.some((r) => !editorStampOf(r))) void this.prepareStickers(refs).catch(() => this.emit([]));
     return loaded.problems;
   }
   /** Opens a saved document (clears the history). Returns what could not be read. */
@@ -6765,6 +6918,56 @@ var PaintEditorController = class _PaintEditorController {
     if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (list_brushes category sticker).`);
     return { layer: l, stickers };
   }
+  // --- The sticker library ---------------------------------------------------------
+  /** The sticker library: the editor's own stamps unless a host set its own. */
+  get stickersProvider() {
+    return this.stickers.provider;
+  }
+  /**
+   * Sets the sticker library (`null` goes back to the editor's own stamps, `editorStickers()`);
+   * to offer both, pass `combineStickerProviders([editorStickers(), yours])`. Loaded art is
+   * forgotten. Not an edit: no undo step.
+   */
+  setStickersProvider(provider) {
+    if ((provider ?? this.stickers.fallback) === this.stickers.provider) return;
+    this.stickers.set(provider);
+    this.stickerArt.clear();
+    this.emit([]);
+  }
+  /**
+   * Loads the art of `refs` (provider stickers; editor stamps need none) so sprays and placements
+   * can draw them. Rejects with a `PaintEditorError` naming an unknown ref and the closest known
+   * ones, or a sticker whose art failed. Emits when art arrives, so views redraw.
+   */
+  async prepareStickers(refs) {
+    const list = [...new Set(refs.map((r) => this.readStickerRef(r)))].filter((r) => !editorStampOf(r));
+    try {
+      await Promise.all(list.map((r) => this.stickerArt.ensure(this.stickers.provider, r, this.rasterizeSticker)));
+    } catch (e) {
+      throw new PaintEditorError(e instanceof Error ? e.message : String(e));
+    } finally {
+      if (list.length) this.emit([]);
+    }
+  }
+  /** Whether a sticker's art is ready to draw: `ready` (always for editor stamps), `loading`, `failed` (with why) or `none`. */
+  stickerArtStatus(ref2) {
+    return this.stickerArt.status(this.readStickerRef(ref2));
+  }
+  readStickerRef(ref2) {
+    try {
+      return normalizeStickerRef(ref2);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+  }
+  /** Refuses to redraw stickers whose art has not loaded (they would vanish), naming them and what to call. */
+  requireStickerArt(stickers) {
+    const missing = [...new Set(stickers.filter((s) => !stickerStamp(s) && !this.stickerArt.get(s.ref)).map((s) => s.ref))];
+    if (missing.length) {
+      for (const r of missing) void this.stickerArt.ensure(this.stickers.provider, r, this.rasterizeSticker).then(() => this.emit([]), () => this.emit([]));
+      throw new PaintEditorError(`The art for ${missing.map((r) => `"${r}"`).join(", ")} has not loaded yet; it is loading now (prepareStickers), so try again when it has.`);
+    }
+  }
   /** A layer's stickers, bottom first. */
   listStickers(layerId) {
     const id = layerId ?? this.doc.activeLayerId;
@@ -6778,6 +6981,7 @@ var PaintEditorController = class _PaintEditorController {
    */
   commitStickers(label, layer, stickers, dirty) {
     if (isLayerLocked(layer, "pixels")) throw new PaintEditorError(`Layer "${layer.name}" has its pixels locked; unlock it first.`);
+    this.requireStickerArt(stickers);
     const before = this.previewBase() ?? this.doc;
     this.stickerPreview = null;
     const surface = this.redrawStickers(layer, stickers, dirty);
@@ -6786,7 +6990,7 @@ var PaintEditorController = class _PaintEditorController {
   }
   redrawStickers(layer, stickers, dirty) {
     const partial = dirty && !layer.offset.x && !layer.offset.y;
-    return partial ? stickerSurface(stickers, layer.surface, dirty) : stickerSurface(stickers);
+    return partial ? stickerSurface(stickers, layer.surface, dirty, this.stickerArt.get) : stickerSurface(stickers, void 0, void 0, this.stickerArt.get);
   }
   /** The document from before the sticker preview on screen, or `null` when none is (anything else changed the document since). */
   previewBase() {
@@ -6805,7 +7009,7 @@ var PaintEditorController = class _PaintEditorController {
     const id = layerId ?? this.doc.activeLayerId;
     if (!id) return null;
     this.requireLayer(id);
-    const hit = stickerAt(this.doc.stickers?.[id] ?? [], x, y);
+    const hit = stickerAt(this.doc.stickers?.[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. */
@@ -6859,7 +7063,7 @@ var PaintEditorController = class _PaintEditorController {
    */
   addStickers(layerId, input) {
     const layer = this.wetLayer(layerId, "add stickers to");
-    if (!input.length) throw new PaintEditorError("Pass at least one sticker (stamp, x, y).");
+    if (!input.length) 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 = this.doc.stickers?.[layer.id];
     if (!existing?.length) {
@@ -6867,7 +7071,8 @@ var PaintEditorController = class _PaintEditorController {
     }
     let n = this.nextStickerNumber();
     const added = input.map((raw, i) => {
-      for (const k of ["stamp", "x", "y"]) if (raw[k] === void 0) throw new PaintEditorError(`Sticker ${i} needs ${k}.`);
+      if (raw.ref === void 0 && raw.stamp === void 0) throw new PaintEditorError(`Sticker ${i} needs ref (a sticker ref from find_stickers, e.g. "editor:star").`);
+      for (const k of ["x", "y"]) if (raw[k] === void 0) throw new PaintEditorError(`Sticker ${i} needs ${k}.`);
       let u;
       try {
         u = this.readStickerUpdate(raw);
@@ -7932,7 +8137,7 @@ function createPaintStickerTools(c) {
     {
       name: "list_stickers",
       title: "List stickers",
-      description: "Lists a layer\u2019s stickers bottom first: id, stamp, x, y (centre, document pixels), size (diameter px), rotation (degrees clockwise), color, opacity. Empty for a layer without stickers. Changes nothing.",
+      description: "Lists a layer\u2019s stickers bottom first: id, ref (provider:id; stamp too for the editor\u2019s own), x, y (centre, document pixels), size (diameter px), rotation (degrees clockwise), color, opacity. Empty for a layer without stickers. Changes nothing.",
       inputSchema: { type: "object", properties: { layerId: LAYER_ID }, additionalProperties: false },
       annotations: { title: "List stickers", ...READ },
       coordinates: { out: ["stickers[]"] },
@@ -7959,7 +8164,7 @@ function createPaintStickerTools(c) {
     {
       name: "add_stickers",
       title: "Place stickers",
-      description: "Places stickers exactly where you say, on top of a sticker layer or onto an empty layer (which becomes a sticker layer). Use it for deliberate placement; spray with paint_stroke and a sticker brush for a random scatter. One undo step. Returns the new stickers with their ids, for update_sticker, arrange_stickers and remove_stickers.",
+      description: "Places stickers exactly where you say, on top of a sticker layer or onto an empty layer (which becomes a sticker layer): any sticker from the sticker library by ref (find_stickers), its art loaded first; tintable ones take color. Use it for deliberate placement; spray with paint_stroke and a sticker brush for a random scatter. An unknown ref is refused with the closest ones. One undo step. Returns the new stickers with their ids, for update_sticker, arrange_stickers and remove_stickers.",
       inputSchema: {
         type: "object",
         properties: {
@@ -7972,7 +8177,8 @@ function createPaintStickerTools(c) {
             items: {
               type: "object",
               properties: {
-                stamp: { type: "string", enum: [...STAMP_KINDS], description: "The stamp." },
+                ref: { type: "string", minLength: 1, description: "The sticker: a ref provider:id from find_stickers (e.g. editor:star). Give ref or stamp." },
+                stamp: { type: "string", enum: [...STAMP_KINDS], description: "Older form: an editor stamp (same as ref editor:<stamp>)." },
                 x: { type: "number", description: "Centre x in document pixels." },
                 y: { type: "number", description: "Centre y in document pixels." },
                 size: { type: "number", minimum: 2, maximum: 2048, description: "Diameter in pixels (default 48)." },
@@ -7981,7 +8187,7 @@ function createPaintStickerTools(c) {
                 opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0..1 (default 1)." },
                 seed: { type: "integer", minimum: 0, description: "Texture seed (default from the new id); splat and confetti shapes vary with it." }
               },
-              required: ["stamp", "x", "y"],
+              required: ["x", "y"],
               additionalProperties: false
             }
           }
@@ -7991,7 +8197,14 @@ function createPaintStickerTools(c) {
       },
       annotations: { title: "Place stickers", ...WRITE },
       coordinates: { in: ["stickers[]"], out: ["stickers[]"] },
-      handler: ({ layerId, stickers }) => ({ layerId: layerId ?? c.document.activeLayerId, stickers: c.addStickers(layerId, stickers) })
+      handler: async ({ layerId, stickers }) => {
+        const list = stickers;
+        list.forEach((x, i) => {
+          if (x.ref === void 0 && x.stamp === void 0) throw new Error(`Sticker ${i} needs ref (a sticker ref from find_stickers, e.g. "editor:star").`);
+        });
+        await c.prepareStickers(list.map((x) => x.ref ?? `editor:${x.stamp}`));
+        return { layerId: layerId ?? c.document.activeLayerId, stickers: c.addStickers(layerId, list) };
+      }
     },
     {
       name: "update_sticker",
@@ -8002,7 +8215,8 @@ function createPaintStickerTools(c) {
         properties: {
           layerId: LAYER_ID,
           id: { type: "string", description: "Sticker id from list_stickers." },
-          stamp: { type: "string", enum: [...STAMP_KINDS], description: "Another stamp." },
+          ref: { type: "string", minLength: 1, description: "Another sticker: a ref provider:id from find_stickers." },
+          stamp: { type: "string", enum: [...STAMP_KINDS], description: "Older form: another editor stamp (same as ref editor:<stamp>)." },
           x: { type: "number", description: "Centre x in document pixels." },
           y: { type: "number", description: "Centre y in document pixels." },
           size: { type: "number", minimum: 2, maximum: 2048, description: "Diameter in pixels." },
@@ -8015,7 +8229,11 @@ function createPaintStickerTools(c) {
       },
       annotations: { title: "Change a sticker", ...WRITE },
       coordinates: { in: [""], out: [""] },
-      handler: ({ layerId, id, ...update }) => c.updateSticker(layerId, id, update)
+      handler: async ({ layerId, id, ...update }) => {
+        const refs = c.listStickers(layerId).map((s) => s.ref);
+        await c.prepareStickers(update.ref ? [...refs, update.ref] : refs);
+        return c.updateSticker(layerId, id, update);
+      }
     },
     {
       name: "arrange_stickers",
@@ -8032,7 +8250,10 @@ function createPaintStickerTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Bring stickers forward or back", ...WRITE },
-      handler: ({ layerId, ids, to }) => ({ order: c.arrangeStickers(layerId, ids, to) })
+      handler: async ({ layerId, ids, to }) => {
+        await c.prepareStickers(c.listStickers(layerId).map((s) => s.ref));
+        return { order: c.arrangeStickers(layerId, ids, to) };
+      }
     },
     {
       name: "remove_stickers",
@@ -8040,7 +8261,10 @@ function createPaintStickerTools(c) {
       description: "Deletes stickers by id, or every sticker on the layer when ids is missing. One undo step. Returns the ids removed.",
       inputSchema: { type: "object", properties: { layerId: LAYER_ID, ids: { type: "array", items: { type: "string", description: "Sticker id." }, description: "Sticker ids (default all)." } }, additionalProperties: false },
       annotations: { title: "Delete stickers", ...DESTRUCTIVE },
-      handler: ({ layerId, ids }) => ({ removed: c.removeStickers(layerId, ids) })
+      handler: async ({ layerId, ids }) => {
+        await c.prepareStickers(c.listStickers(layerId).map((s) => s.ref));
+        return { removed: c.removeStickers(layerId, ids) };
+      }
     }
   ];
 }
@@ -9001,17 +9225,39 @@ var PARTICLE_BRUSH = {
   type: "object",
   description: "Particle engine settings (procedural brushes). Missing fields keep their current values.",
   properties: {
-    kind: { type: "string", enum: [...PARTICLE_KINDS], description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade." },
-    render: { type: "string", enum: [...PARTICLE_RENDERS], description: "dot: a mark at each step; line: each particle draws a continuous line; sequence: beads spaced along each path." },
+    kind: {
+      type: "string",
+      enum: [...PARTICLE_KINDS],
+      description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade; elastic: strands whose links keep a rest length, stretching when the pen is fast and snapping back; fuzzy: winding strings, each strand waving out of step with the others (always waves by at least 0.12 of the tip size)."
+    },
+    render: {
+      type: "string",
+      enum: [...PARTICLE_RENDERS],
+      description: "dot: a mark at each step (round, or dotTextures); line: each particle draws a continuous line; sequence: beads spaced along each path (round, or dotTextures); ribbon: the band between neighbouring particles' paths filled (ribbonFill), with the paths drawn as its edges at the mark size (flame, silk, smoke)."
+    },
     count: { type: "integer", minimum: 1, maximum: 64, description: "Particles (flow: how many are thrown per tip of travel)." },
-    size: { type: "number", minimum: 0, maximum: 1, description: "Mark size as a fraction of the tip size." },
-    spread: { type: "number", minimum: 0, maximum: 1, description: "How far apart the particles start, as a fraction of the tip size." },
-    stiffness: { type: "number", minimum: 0, maximum: 1, description: "Spring and string stiffness: stiff follows closely, soft swings wide." },
+    size: { type: "number", minimum: 0, maximum: 1, description: "Mark size as a fraction of the tip size (ribbon: the width of its edges)." },
+    spread: { type: "number", minimum: 0, maximum: 1, description: "How far apart the particles start, as a fraction of the tip size (ribbon: how wide it is)." },
+    stiffness: { type: "number", minimum: 0, maximum: 1, description: "Spring, string and elastic stiffness: stiff follows closely (elastic: snaps back faster), soft swings wide." },
     damping: { type: "number", minimum: 0, maximum: 1, description: "How quickly motion dies down." },
     speed: { type: "number", minimum: 0, maximum: 1, description: "Orbit and flow speed." },
     gravity: { type: "number", minimum: -1, maximum: 1, description: "Pull downwards (negative: upwards)." },
     life: { type: "number", minimum: 0, maximum: 1, description: "Flow particles: how long they live." },
-    interval: { type: "number", minimum: 0, maximum: 1, description: "Sequence: spacing of the beads." }
+    interval: { type: "number", minimum: 0, maximum: 1, description: "Sequence: spacing of the beads." },
+    ribbonFill: { type: "number", minimum: 0, maximum: 1, description: "Ribbon: opacity of the fill between the paths, relative to their edges (default 0.5; 0 draws only the edges)." },
+    ribbonPairs: { type: "string", enum: [...RIBBON_PAIRS], description: "Ribbon: adjacent (default) joins each particle to its neighbour around the pen; first-last makes one band between the outermost two." },
+    waveAmplitude: { type: "number", minimum: 0, maximum: 1, description: "Wave: how far each particle's drawn place swings sideways to the stroke, as a fraction of the tip size (default 0: no wave). Works with every kind and render." },
+    waveLength: { type: "number", minimum: 4, maximum: 2e3, description: "Wave: wavelength in px of pen travel (default 60)." },
+    waveSpeed: { type: "number", minimum: 0, maximum: 1, description: "Wave: how fast the waves run, by stroke time (0 default: they stand still on the path; 1: about four a second, so slow strokes wave more). Strokes without times run at a nominal 0.5 px/ms." },
+    wavePhaseJitter: { type: "number", minimum: 0, maximum: 1, description: "Wave: how far out of step the particles' waves are (default 0: all in step, a wavy band; 1: random phases, tangled strands)." },
+    dotTextures: {
+      type: "array",
+      maxItems: MAX_DOT_TEXTURES,
+      items: { type: "string", enum: [...STAMP_KINDS], description: "A stamp." },
+      description: `Dot and sequence renders: up to ${MAX_DOT_TEXTURES} sticker stamps (list_stickers) drawn instead of round marks; repeats are allowed (they weight the order). Empty (default): round marks.`
+    },
+    dotTextureOrder: { type: "string", enum: [...DOT_TEXTURE_ORDERS], description: "Textured dots: sequence (default) uses the stamps in turn; random picks one per dot (seeded, so replays are exact)." },
+    dotRotation: { type: "string", enum: [...DOT_ROTATIONS], description: "Textured dots: follow turns each with its particle's motion; random (default) turns each at random; fixed uses the tip angle." }
   },
   additionalProperties: false
 };
@@ -9032,7 +9278,13 @@ var STICKER_BRUSH = {
   type: "object",
   description: "Sticker engine settings: stamps sprayed along the stroke as editable stickers. Missing fields keep their current values.",
   properties: {
-    stamps: { type: "array", minItems: 1, maxItems: 9, items: { type: "string", enum: [...STAMP_KINDS], description: "A stamp." }, description: "The stamps to spray (one picked at random per sticker)." },
+    stamps: {
+      type: "array",
+      minItems: 1,
+      maxItems: MAX_STICKER_STAMPS,
+      items: { type: "string", minLength: 1, description: "A sticker ref provider:id from find_stickers (e.g. editor:star); a bare editor stamp (star) means editor:star." },
+      description: `The stickers to spray, one picked at random per sticker: refs from find_stickers (the editor's own: ${STAMP_KINDS.map((k) => `editor:${k}`).join(", ")}). Each is checked against the sticker library and an unknown ref is refused with the closest ones. A provider's sticker is drawn from its art (tinted to the paint colour when tintable), loaded before the stroke.`
+    },
     density: { type: "number", minimum: 0, maximum: 1, description: "How closely stickers follow each other: about density \xD7 4 stickers per tip diameter of travel (0.25 \u2248 one per diameter, 1 \u2248 four). Default 0.4." },
     sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change." },
     rotationJitter: { type: "number", minimum: 0, maximum: 1, description: "Random turn as a fraction of \xB1180\xB0." },
@@ -9431,7 +9683,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "list_brushes",
     title: "List brushes",
-    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush), light paint (category light: glow gel, neon marker, light airbrush, spark trail, glow wash, highlighter; light is the amount they lay) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
+    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush), light paint (category light: glow gel, neon marker, light airbrush, spark trail, light ribbon, flame ribbon, neon strand, smoke ribbon, bokeh dots, twinkle sparks, glow wash, highlighter; light is the amount they lay) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
     inputSchema: EMPTY3,
     annotations: { title: "List brushes", ...READ6 },
     handler: () => {
@@ -9459,7 +9711,11 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Chooses the active brush (id) and / or changes its settings; strokes without a brush use it. Editor state, not an undo step. Changes stay on the active brush until save_brush stores them. Returns the active brush.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes to start from." }, ...BRUSH_FIELDS }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
-    handler: (a) => brushToJSON(c.setBrush(a))
+    handler: async (a) => {
+      const stamps = a.sticker?.stamps;
+      if (stamps) await c.prepareStickers(stamps);
+      return brushToJSON(c.setBrush(a));
+    }
   });
   add({
     name: "save_brush",
@@ -9635,6 +9891,9 @@ function createPaintEditorToolProvider(controller, options = {}) {
     coordinates: { in: ["points[]"], out: ["bounds"] },
     handler: async (a) => {
       await c.wetIdle();
+      const base = a.brushId ? c.getBrush(a.brushId) : c.getState().brush;
+      const over = a.brush;
+      if ((over?.engine ?? base?.engine) === "sticker") await c.prepareStickers(over?.sticker?.stamps ?? base?.sticker.stamps ?? []);
       const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush: a.brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
       const r = await act({ kind: "stroke", stroke }, () => c.paintStroke(stroke));
       return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
@@ -9943,6 +10202,20 @@ function createPaintEditorToolProvider(controller, options = {}) {
   tools.push(...createPaintReplayTools(c));
   tools.push(...createPaintStickerTools(c));
   tools.push(...createPigmentTools());
+  tools.push(...createStickerTools({ provider: () => c.stickersProvider }));
+  tools.push(
+    ...createLayerEffectTools(
+      {
+        requireLayer: (id) => void c.getLayerEffects(id),
+        getLayerEffects: (id) => c.getLayerEffects(id),
+        addLayerEffect: (id, kind, settings, index) => c.addLayerEffect(id, kind, settings, index),
+        updateLayerEffect: (id, effectId, changes) => c.updateLayerEffect(id, effectId, changes),
+        removeLayerEffect: (id, effectId) => c.removeLayerEffect(id, effectId),
+        setLayerEffectsEnabled: (id, enabled, scale) => c.setLayerEffectsEnabled(id, enabled, scale)
+      },
+      { layers: "a pixel, stroke, sticker or group layer", error: (m) => new PaintEditorError(m) }
+    )
+  );
   const exclude = new Set(options.exclude ?? []);
   const description = "Natural-media painting: paper and grain, dry and wet brushes, the brush library, strokes as data, pigment mixing, stencils, guides, layers and export.";
   return withPaintPlayback({
@@ -10103,7 +10376,7 @@ var PaintGesture = class {
       }
       const brush = this.controller.getState().brush;
       const size = Math.min(2048, Math.max(2, Math.round(brush.tip.size)));
-      const [added] = this.controller.addStickers(void 0, [{ stamp: brush.sticker.stamps[0] ?? "star", x: round2(p.x), y: round2(p.y), size }]);
+      const [added] = this.controller.addStickers(void 0, [{ ref: brush.sticker.stamps[0] ?? "editor:star", x: round2(p.x), y: round2(p.y), size }]);
       this.controller.selectSticker(added.id);
     } catch (err) {
       this.error = err instanceof Error ? err.message : String(err);
@@ -10413,7 +10686,12 @@ function engineControls(brush) {
           { path: "particle.speed", label: "Speed", min: 0, max: 1, step: 0.01 },
           { path: "particle.gravity", label: "Gravity", min: -1, max: 1, step: 0.01 },
           { path: "particle.life", label: "Life", min: 0, max: 1, step: 0.01 },
-          { path: "particle.interval", label: "Bead spacing", min: 0, max: 1, step: 0.01 }
+          { path: "particle.interval", label: "Bead spacing", min: 0, max: 1, step: 0.01 },
+          { path: "particle.ribbonFill", label: "Ribbon fill", min: 0, max: 1, step: 0.01 },
+          { path: "particle.waveAmplitude", label: "Wave", min: 0, max: 1, step: 0.01 },
+          { path: "particle.waveLength", label: "Wavelength", min: 4, max: 400, step: 1 },
+          { path: "particle.waveSpeed", label: "Wave speed", min: 0, max: 1, step: 0.01 },
+          { path: "particle.wavePhaseJitter", label: "Wave scatter", min: 0, max: 1, step: 0.01 }
         ],
         mixingPath: null,
         dirty: false,
@@ -10628,13 +10906,29 @@ var LIGHT_SLIDERS = [
   { path: "elevation", label: "Light height", min: 5, max: 90, step: 1 },
   { path: "relief", label: "Relief", min: 0, max: 1, step: 0.01 }
 ];
-var PARTICLE_KIND_LABELS = { string: "Strings", spring: "Springs", orbit: "Orbits", flow: "Flow" };
-var PARTICLE_RENDER_LABELS = { dot: "Dots", line: "Lines", sequence: "Beads" };
+var PARTICLE_KIND_LABELS = { string: "Strings", spring: "Springs", orbit: "Orbits", flow: "Flow", elastic: "Elastic", fuzzy: "Fuzzy" };
+var PARTICLE_RENDER_LABELS = { dot: "Dots", line: "Lines", sequence: "Beads", ribbon: "Ribbon" };
+var RIBBON_PAIR_LABELS = { adjacent: "Neighbours", "first-last": "Outermost" };
+var DOT_TEXTURE_ORDER_LABELS = { sequence: "In turn", random: "Random" };
+var DOT_ROTATION_LABELS = { follow: "Follow motion", random: "Random", fixed: "Tip angle" };
 var STAMP_LABELS = { dot: "Dot", star: "Star", heart: "Heart", leaf: "Leaf", flower: "Flower", confetti: "Confetti", splat: "Splat", sparkle: "Sparkle", ring: "Ring" };
+function toggleStickerRef(refs, ref2) {
+  if (refs.includes(ref2)) return refs.length > 1 ? refs.filter((r) => r !== ref2) : [...refs];
+  return refs.length < MAX_STICKER_STAMPS ? [...refs, ref2] : [...refs];
+}
+function stickerRefLabel(ref2) {
+  const stamp = ref2.startsWith("editor:") ? ref2.slice(7) : null;
+  if (stamp && STAMP_LABELS[stamp]) return STAMP_LABELS[stamp];
+  return ref2.slice(ref2.indexOf(":") + 1);
+}
 function toggleStamp(stamps, stamp) {
   const next = stamps.includes(stamp) ? stamps.filter((s) => s !== stamp) : [...stamps, stamp];
   return next.length ? next : [stamp];
 }
+function toggleDotTexture(textures, stamp) {
+  if (textures.includes(stamp)) return textures.filter((s) => s !== stamp);
+  return textures.length < MAX_DOT_TEXTURES ? [...textures, stamp] : [...textures];
+}
 var STROKE_SLIDERS = [
   { path: "tip.size", label: "Size", min: 1, max: 400, step: 1 },
   { path: "tip.opacity", label: "Opacity", min: 0, max: 1, step: 0.01 },
@@ -10957,6 +11251,10 @@ export {
   DEFAULT_VIEW,
   DEFAULT_WET_BRUSH,
   DEFAULT_WET_PARAMS,
+  DOT_ROTATIONS,
+  DOT_ROTATION_LABELS,
+  DOT_TEXTURE_ORDERS,
+  DOT_TEXTURE_ORDER_LABELS,
   DryStroke,
   EFFECT_MAP_REPEATS,
   EFFECT_STRIP_HEIGHT,
@@ -10974,8 +11272,10 @@ export {
   MAX_BRUSH_SIZE,
   MAX_CANVAS_SIDE,
   MAX_COORDINATE,
+  MAX_DOT_TEXTURES,
   MAX_IMAGE_SIDE,
   MAX_LIVE_EFFECT_SOURCES,
+  MAX_STICKER_STAMPS,
   MAX_ZOOM,
   MIN_CANVAS_SIDE,
   MIN_ZOOM,
@@ -11033,15 +11333,20 @@ export {
   PenDabWalker,
   PenSmoother,
   PerspectiveSnapper,
+  RIBBON_PAIRS,
+  RIBBON_PAIR_LABELS,
   SNAP_DECIDE_DISTANCE,
   STAMP_KINDS,
   STAMP_LABELS,
   STENCIL_KINDS,
   STENCIL_SHAPES,
+  STICKER_ART_SIZE,
   STICKER_SLIDERS,
   STROKE_SLIDERS,
   SYMMETRY_MODES,
   StencilSnapper,
+  StickerArtCache,
+  StickerBrowser,
   StickerSpray,
   TRACING_NODE_ID,
   ThickStrokeDriver,
@@ -11061,6 +11366,7 @@ export {
   WET_TOOL_LABELS,
   WetStrokeDriver,
   addPaintGradientStop,
+  addPolygonArea,
   affineCopy,
   applyAffine,
   backlightOf,
@@ -11088,6 +11394,7 @@ export {
   decodeImageBlob,
   defaultGuides,
   defaultImageEncoder,
+  defaultStickerRasterizer,
   deserializePaintDocument,
   deserializePaintDocumentAsync,
   documentExtensions,
@@ -11206,6 +11513,7 @@ export {
   rgbToHexColor,
   rgbToHsl,
   rgbToHsv,
+  sampleArt,
   sampleEffectAt,
   sampleEffectField,
   samplePressure,
@@ -11223,6 +11531,8 @@ export {
   stencilOutline,
   stickerAt,
   stickerRect,
+  stickerRefLabel,
+  stickerStamp,
   stickerSurface,
   strokeBounds,
   strokeDuration,
@@ -11238,7 +11548,9 @@ export {
   timeLapseVideo,
   timeLapseZip,
   toStrokePoint,
+  toggleDotTexture,
   toggleStamp,
+  toggleStickerRef,
   translateStencil,
   updatePaintGradientStop,
   usesPaintExchange,