@pixerate/editor 0.255.0 → 0.257.0

package/dist/paint-editor/index.js

@@ -1,9 +1,7 @@
 import {
   StickerBrowser,
-  createStickerTools,
-  describeStickerRef,
   editorStickers
-} from "../chunk-WZOGDKCQ.js";
+} from "../chunk-F7CPSRLN.js";
 import {
   BRUSH_PATCH_PROPERTIES,
   BRUSH_SLIDERS,
@@ -13,7 +11,11 @@ import {
   mergeBrushPatch,
   multiColorSliders,
   patchBrushValue
-} from "../chunk-YHUMGBZD.js";
+} from "../chunk-ICTPLVSR.js";
+import {
+  createStickerTools,
+  describeStickerRef
+} from "../chunk-J5UQHWVL.js";
 import {
   toVideoFfmpeg
 } from "../chunk-MWUZCEFT.js";
@@ -24,9 +26,12 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-DMTEQ6SH.js";
-import "../chunk-3CI7FRMK.js";
+} from "../chunk-SSFMWJDK.js";
 import "../chunk-ZNA3IQZF.js";
+import {
+  brushColourHex
+} from "../chunk-FJBQTZS4.js";
+import "../chunk-3CI7FRMK.js";
 import {
   LAYER_EFFECT_KINDS,
   LayerEffectError,
@@ -80,7 +85,7 @@ import {
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-IVSWRVB4.js";
-import "../chunk-AF23QK5F.js";
+import "../chunk-YQ4PQTBB.js";
 import {
   BRUSH_ID,
   BRUSH_PRESETS,
@@ -95,6 +100,7 @@ import {
   DEFAULT_LIGHT,
   DEFAULT_MULTI_COLOR,
   DEFAULT_PARTICLE,
+  DEFAULT_SPRAY,
   DEFAULT_STICKER,
   DEFAULT_WET_BRUSH,
   DOT_ROTATIONS,
@@ -134,7 +140,7 @@ import {
   parseBrushLibrary,
   resolveBrush,
   usesPaintExchange
-} from "../chunk-JVRLGV3C.js";
+} from "../chunk-SMTUQWGY.js";
 import {
   STAMP_KINDS,
   StickersSlot,
@@ -273,8 +279,10 @@ import {
   colorHarmony,
   hueToWheel,
   wheelToHue
-} from "../chunk-7272D3K2.js";
-import "../chunk-YBAPT7NL.js";
+} from "../chunk-2EUW2XZX.js";
+import "../chunk-E2V5DA3W.js";
+import "../chunk-VR6OGHU5.js";
+import "../chunk-JC2SHA4A.js";
 import {
   linearToSrgb,
   oklabToOklch,
@@ -370,8 +378,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 PaperGrain(paper), light) {
@@ -577,6 +585,75 @@ function effectDabField(img, rect, cov, centre2, mixed, field, steps = 0, dab =
   }
 }
 
+// src/paint-editor/stamp-tip.ts
+var samplers = /* @__PURE__ */ new WeakMap();
+function stampSampler(ref2, art) {
+  let kind = null;
+  try {
+    kind = editorStampOf(ref2.includes(":") ? ref2 : `editor:${ref2}`);
+  } catch {
+    return null;
+  }
+  if (kind) {
+    const k = kind;
+    return (u, v, seed) => stampCoverage(k, u, v, seed);
+  }
+  const a = art?.(ref2);
+  if (!a || !(a.width > 0 && a.height > 0)) return null;
+  const hit = samplers.get(a);
+  if (hit) return hit;
+  const { width: w, height: h, data } = a;
+  const scale = Math.max(w, h) / 2;
+  const alpha = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? 0 : data[(y * w + x) * 4 + 3] / 255;
+  const sampler = (u, v) => {
+    const x = u * scale + w / 2 - 0.5;
+    const y = v * scale + h / 2 - 0.5;
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const fx = x - x0;
+    const fy = y - y0;
+    return (alpha(x0, y0) * (1 - fx) + alpha(x0 + 1, y0) * fx) * (1 - fy) + (alpha(x0, y0 + 1) * (1 - fx) + alpha(x0 + 1, y0 + 1) * fx) * fy;
+  };
+  samplers.set(a, sampler);
+  return sampler;
+}
+function stampDabRect(d) {
+  const r = Math.max(0.5, d.radius) * Math.SQRT2 + 1.5;
+  const x0 = Math.floor(d.x - r);
+  const y0 = Math.floor(d.y - r);
+  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };
+}
+function rasterizeStampDab(d, sample, seed, rect, out) {
+  const w = rect.width;
+  const h = rect.height;
+  out.fill(0, 0, w * h);
+  const r = Math.max(0.5, d.radius);
+  const ro = Math.min(1, Math.max(0.05, d.roundness));
+  const sn = Math.sin(d.angle);
+  const cs = Math.cos(d.angle);
+  const ss = r < 6 ? 3 : 1;
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      let sum = 0;
+      for (let sy = 0; sy < ss; sy++) {
+        for (let sx = 0; sx < ss; sx++) {
+          const dx = rect.x + xx + (sx + 0.5) / ss - d.x;
+          const dy = rect.y + yy + (sy + 0.5) / ss - d.y;
+          const u = (dx * cs - dy * sn) / r;
+          const v = (dx * sn + dy * cs) / (r * ro);
+          if (u > -1.05 && u < 1.05 && v > -1.05 && v < 1.05) sum += sample(u, v, seed);
+        }
+      }
+      const val = sum / (ss * ss);
+      if (val > 0) out[yy * w + xx] = Math.min(1, val) * d.alpha;
+    }
+  }
+}
+function brushStickerRefs(brush) {
+  const refs = brush.engine === "sticker" ? [...brush.sticker.stamps] : brush.engine === "particle" ? [...brush.particle.dotTextures] : brush.engine === "dab" && brush.stamp ? [brush.stamp] : [];
+  return [...new Set(refs.filter((r) => r.includes(":") && !r.startsWith("editor:")))];
+}
+
 // src/paint-editor/engine.ts
 function penOrientation(p) {
   if (typeof p.altitude === "number" && Number.isFinite(p.altitude)) {
@@ -795,6 +872,7 @@ var DryStroke = class {
   constructor(brush, options) {
     this.brush = brush;
     this.options = options;
+    this.stamp = brush.stamp ? stampSampler(brush.stamp, options.stampArt) : null;
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
     this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
     this.walkers = this.copies.map((c, i) => new PenDabWalker(brush, (options.seed ?? 0) + i * 7919 | 0, c.linear));
@@ -812,6 +890,8 @@ var DryStroke = class {
   field = new Float32Array(0);
   lastRaw = null;
   lastFed = null;
+  /** The stamp tip's shape, or `null` for the round computed tip. */
+  stamp;
   /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
   push(points) {
     const dabs = [];
@@ -834,34 +914,52 @@ var DryStroke = class {
   }
   paint(dabs) {
     const rects = [];
-    const hardness = this.brush.tip.hardness;
-    const grain = this.options.grain;
+    const spray = this.brush.spray;
+    const seed = this.options.seed ?? 0;
     for (const d of dabs) {
-      const rect = dabRect(d, hardness);
-      const n = rect.width * rect.height;
-      if (this.buf.length < n) this.buf = new Float32Array(n);
-      const vals = this.buf.subarray(0, n);
-      rasterizeDab(d, hardness, rect, vals);
-      if (this.depth > 0 && grain) {
-        for (let yy = 0, k = 0; yy < rect.height; yy++) {
-          const y = rect.y + yy + 0.5;
-          for (let xx = 0; xx < rect.width; xx++, k++) {
-            if (vals[k] > 0) vals[k] *= grainCatch(grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
-          }
-        }
+      if (!spray) {
+        this.mark(d, d, rects);
+        continue;
       }
-      let field = null;
-      if (this.options.effect) {
-        if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
-        field = this.field.subarray(0, n * 3);
-        sampleEffectField(this.options.effect, rect, vals, field, d);
+      const count = 1 + Math.round(spray.density * 31);
+      const key = d.index * 131 + Math.round(d.travel * 8);
+      for (let i = 0; i < count; i++) {
+        const a = rand01(seed, key * 64 + i, 61) * Math.PI * 2;
+        const rr = Math.sqrt(rand01(seed, key * 64 + i, 67)) * d.radius;
+        const drop = { ...d, x: d.x + Math.cos(a) * rr, y: d.y + Math.sin(a) * rr, radius: Math.max(0.5, d.radius * spray.size * (0.6 + 0.8 * rand01(seed, key * 64 + i, 71))), roundness: 1, angle: rand01(seed, key * 64 + i, 73) * Math.PI * 2 };
+        this.mark(drop, d, rects);
       }
-      this.coverage.accumulate(rect, vals, d.opacity, null, field);
-      rects.push(rect);
-      this.dabCount++;
     }
     return rects;
   }
+  /** Lays one mark (a dab, or a spray droplet of dab `d`): the round tip or the stamp, the paper grain, effect paint. */
+  mark(m, d, rects) {
+    const hardness = this.brush.tip.hardness;
+    const grain = this.options.grain;
+    const rect = this.stamp ? stampDabRect(m) : dabRect(m, hardness);
+    const n = rect.width * rect.height;
+    if (this.buf.length < n) this.buf = new Float32Array(n);
+    const vals = this.buf.subarray(0, n);
+    if (this.stamp) rasterizeStampDab(m, this.stamp, d.index, rect, vals);
+    else rasterizeDab(m, hardness, rect, vals);
+    if (this.depth > 0 && grain) {
+      for (let yy = 0, k = 0; yy < rect.height; yy++) {
+        const y = rect.y + yy + 0.5;
+        for (let xx = 0; xx < rect.width; xx++, k++) {
+          if (vals[k] > 0) vals[k] *= grainCatch(grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
+        }
+      }
+    }
+    let field = null;
+    if (this.options.effect) {
+      if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
+      field = this.field.subarray(0, n * 3);
+      sampleEffectField(this.options.effect, rect, vals, field, d);
+    }
+    this.coverage.accumulate(rect, vals, m.opacity, null, field);
+    rects.push(rect);
+    this.dabCount++;
+  }
 };
 function mixerTip(brush) {
   return { ...brush.tip, smoothing: 0, pressureSize: brush.tip.pressureSize };
@@ -1820,984 +1918,986 @@ function lightFromJSON(raw) {
   return surfaceFromPixels({ width: img.width, height: img.height, data }, 1, r.rect.x, r.rect.y);
 }
 
-// src/paint-editor/sticker-art.ts
-var STICKER_ART_SIZE = 256;
-var defaultStickerRasterizer = async (asset, size) => {
-  if (asset.kind === "image") {
-    const parsed = parseDataUrl(asset.url);
-    if (parsed && parsed.mime === "image/png") {
-      const png = decodePng(parsed.bytes);
-      return { width: png.width, height: png.height, data: new Uint8ClampedArray(png.data) };
+// src/paint-editor/procedural.ts
+var STEP_PX = 1.5;
+var MarkStroke = class {
+  constructor(brush, options) {
+    this.brush = brush;
+    this.options = options;
+    this.sampler = options.paint ? new PaintGradientSampler(options.paint, options.seed ?? 0) : null;
+    this.tipTable = this.sampler?.acrossTip ? this.sampler.tipTable(TIP_GRADIENT_STEPS) : null;
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
+    this.seed = options.seed ?? 0;
+    const fine = { ...brush, tip: { ...brush.tip, spacing: Math.max(0.01, Math.min(0.25, STEP_PX / Math.max(1, brush.tip.size))) } };
+    this.walkers = this.copies.map((c, i) => new PenDabWalker(fine, (options.seed ?? 0) + i * 7919 | 0, c.linear));
+    this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
+  }
+  brush;
+  options;
+  coverage = new CoverageMap();
+  dabCount = 0;
+  smoother;
+  copies;
+  walkers;
+  depth;
+  buf = new Float32Array(0);
+  field = new Float32Array(0);
+  lastRaw = null;
+  lastFed = null;
+  seed;
+  sampler;
+  tipTable;
+  /** The pen dab the marks being made belong to, and its gradient colour. */
+  pen = null;
+  penColor = { rgb: [0, 0, 0], alpha: 1 };
+  push(points) {
+    const rects = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        this.walkers[i].push(c.map(p), dabs);
+        for (const d of dabs) this.step(i, d, rects);
+      });
     }
+    return rects;
   }
-  const g = globalThis;
-  if (!g.createImageBitmap || !g.OffscreenCanvas) {
-    throw new StickerError("unsupported_format", `This environment can't draw ${asset.kind === "svg" ? "SVG" : "non-PNG"} sticker art; pass rasterizeSticker in the paint editor's options (or use a provider that offers png).`);
+  step(copy, d, rects) {
+    this.pen = d;
+    if (this.sampler && !this.tipTable) this.sampler.dab(d, this.penColor);
+    this.advance(copy, d, rects);
   }
-  const blob = asset.kind === "svg" ? new Blob([asset.svg], { type: "image/svg+xml" }) : await (await g.fetch(asset.url)).blob();
-  const bitmap = await g.createImageBitmap(blob);
-  const scale = size / Math.max(bitmap.width, bitmap.height, 1);
-  const w = Math.max(1, Math.round(bitmap.width * scale));
-  const h = Math.max(1, Math.round(bitmap.height * scale));
-  const canvas = new g.OffscreenCanvas(w, h);
-  const ctx = canvas.getContext("2d");
-  ctx.drawImage(bitmap, 0, 0, w, h);
-  const img = ctx.getImageData(0, 0, w, h);
-  return { width: w, height: h, data: img.data };
-};
-var StickerArtCache = class {
-  entries = /* @__PURE__ */ new Map();
-  /** The art for `ref` when it has loaded (editor stamps never need any). */
-  get = (ref2) => {
-    const e = this.entries.get(ref2);
-    return e?.status === "ready" ? e.art : void 0;
-  };
-  /** `ready`, `loading`, `failed` (with the reason) or `none` (never asked for). Editor stamps are always `ready`. */
-  status(ref2) {
-    if (editorStampOf(ref2)) return { status: "ready" };
-    const e = this.entries.get(ref2);
-    if (!e) return { status: "none" };
-    return e.status === "failed" ? { status: "failed", error: e.error } : { status: e.status };
+  /** The colour of a mark at (x, y): its pen dab's, or across the tip by its offset from the pen. */
+  markColor(x, y) {
+    if (!this.sampler || !this.pen) return null;
+    if (!this.tipTable) return this.penColor;
+    const d = this.pen;
+    const u = ((x - d.x) * Math.sin(d.direction) + (y - d.y) * Math.cos(d.direction)) / Math.max(0.5, d.radius);
+    const last = this.tipTable.length - 1;
+    return this.tipTable[Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)))];
+  }
+  finish() {
+    const rects = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    this.copies.forEach((c, i) => {
+      const dabs = [];
+      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.walkers[i].push(c.map({ ...raw, pressure: fed.pressure }), dabs);
+      this.walkers[i].finish(dabs);
+      for (const d of dabs) this.step(i, d, rects);
+    });
+    return rects;
+  }
+  /** Stamps one round mark of radius `r` at (x, y) with flow `alpha` towards `opacity`. */
+  mark(x, y, r, alpha, opacity, pressure, rects) {
+    if (!(r > 0.05) || !(alpha > 0)) return;
+    const dab = { x, y, radius: Math.max(0.5, r), alpha: Math.min(1, alpha), opacity: Math.min(1, opacity), angle: 0, roundness: 1 };
+    const hardness = this.brush.tip.hardness;
+    const rect = dabRect(dab, hardness);
+    const n = rect.width * rect.height;
+    if (n <= 0) return;
+    const vals = this.scratch(n);
+    rasterizeDab(dab, hardness, rect, vals);
+    this.lay(rect, vals, dab.opacity, pressure, x, y, rects);
   }
   /**
-   * Loads and rasterises `ref` from `provider` once (later calls share the load). Unknown refs
-   * reject with the closest known ones; failures are kept so they are reported, and retried on
-   * the next call.
+   * Stamps a textured mark: `kind` from the sticker stamps over a square of half-size `r`, turned
+   * `rotation` radians clockwise, with flow `alpha` towards `opacity`. Small marks are supersampled.
    */
-  ensure(provider, ref2, rasterize) {
-    if (editorStampOf(ref2)) return Promise.resolve(null);
-    const e = this.entries.get(ref2);
-    if (e?.status === "ready") return Promise.resolve(e.art);
-    if (e?.status === "loading") return e.promise;
-    const promise = (async () => {
-      const d = await describeStickerRef(provider, ref2);
-      const id = stickerIdFor(provider, ref2);
-      const max = provider.capabilities.maxSize ?? STICKER_ART_SIZE;
-      const size = Math.min(STICKER_ART_SIZE, max);
-      const asset = await provider.load(id, d.formats.includes("png") ? { format: "png", size } : { format: d.formats[0] ?? "svg", size });
-      const px = await rasterize(asset, size);
-      if (!(px.width > 0 && px.height > 0) || px.data.length !== px.width * px.height * 4) throw new StickerError("load_failed", `The art for "${ref2}" came back empty or the wrong size.`);
-      return { ...px, tintable: d.tintable };
-    })();
-    this.entries.set(ref2, { status: "loading", promise });
-    return promise.then(
-      (art) => {
-        this.entries.set(ref2, { status: "ready", art });
-        return art;
-      },
-      (err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        this.entries.set(ref2, { status: "failed", error: message });
-        throw err;
+  stamp(x, y, r, kind, rotation, seed, alpha, opacity, pressure, rects) {
+    if (!(r > 0.05) || !(alpha > 0)) return;
+    const sample = stampSampler(kind, this.options.stampArt);
+    if (!sample) return this.mark(x, y, r, alpha, opacity, pressure, rects);
+    const reach = Math.max(0.5, r) * Math.SQRT2 + 1;
+    const rect = { x: Math.floor(x - reach), y: Math.floor(y - reach), width: 0, height: 0 };
+    rect.width = Math.ceil(x + reach) - rect.x;
+    rect.height = Math.ceil(y + reach) - rect.y;
+    const n = rect.width * rect.height;
+    const vals = this.scratch(n);
+    const ss = r < 10 ? 3 : 1;
+    const c = Math.cos(rotation);
+    const s = Math.sin(rotation);
+    const inv = 1 / Math.max(0.5, r);
+    const a = Math.min(1, alpha);
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        let sum = 0;
+        for (let sy = 0; sy < ss; sy++) {
+          for (let sx = 0; sx < ss; sx++) {
+            const dx = rect.x + xx + (sx + 0.5) / ss - x;
+            const dy = rect.y + yy + (sy + 0.5) / ss - y;
+            sum += sample((dx * c + dy * s) * inv, (dy * c - dx * s) * inv, seed);
+          }
+        }
+        vals[k] = sum / (ss * ss) * a;
       }
-    );
+    }
+    this.lay(rect, vals, Math.min(1, opacity), pressure, x, y, rects);
   }
-  /** Forgets every load (a new provider). */
-  clear() {
-    this.entries.clear();
+  /** A scratch buffer of `n` values (reused; valid until the next mark). */
+  scratch(n) {
+    if (this.buf.length < n) this.buf = new Float32Array(n);
+    const vals = this.buf.subarray(0, n);
+    vals.fill(0);
+    return vals;
+  }
+  /**
+   * Lays coverage `vals` over `rect` towards `opacity`: paper grain, then effect paint or the
+   * colour of a mark at (x, y) (gradient paint), into the stroke's coverage.
+   */
+  lay(rect, vals, opacity, pressure, x, y, rects) {
+    const n = rect.width * rect.height;
+    if (n <= 0) return;
+    const grain = this.options.grain;
+    if (this.depth > 0 && grain) {
+      for (let yy = 0, k = 0; yy < rect.height; yy++)
+        for (let xx = 0; xx < rect.width; xx++, k++) if (vals[k] > 0) vals[k] *= grainCatch(grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, pressure);
+    }
+    if (this.options.effect) {
+      if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
+      const field = this.field.subarray(0, n * 3);
+      sampleEffectField(this.options.effect, rect, vals, field, this.pen);
+      this.coverage.accumulate(rect, vals, opacity, null, field);
+    } else {
+      const color = this.markColor(x, y);
+      if (color && color.alpha < 1) for (let k = 0; k < n; k++) vals[k] *= color.alpha;
+      this.coverage.accumulate(rect, vals, opacity, color ? color.rgb : null);
+    }
+    rects.push(rect);
+    this.dabCount++;
+  }
+  /** Marks along a segment, spaced by a fraction of the radius. */
+  segment(x0, y0, x1, y1, r, alpha, opacity, pressure, rects) {
+    const len = Math.hypot(x1 - x0, y1 - y0);
+    const step = Math.max(0.35, r * 0.5);
+    const n = Math.max(1, Math.ceil(len / step));
+    for (let i = 1; i <= n; i++) this.mark(x0 + (x1 - x0) * i / n, y0 + (y1 - y0) * i / n, r, alpha, opacity, pressure, rects);
   }
 };
-function sampleArt(art, x, y, out) {
-  const { width: w, height: h, data } = art;
-  const fx = x - 0.5;
-  const fy = y - 0.5;
-  const x0 = Math.floor(fx);
-  const y0 = Math.floor(fy);
-  const tx = fx - x0;
-  const ty = fy - y0;
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let a = 0;
-  for (let k = 0; k < 4; k++) {
-    const xx = x0 + (k & 1);
-    const yy = y0 + (k >> 1);
-    if (xx < 0 || yy < 0 || xx >= w || yy >= h) continue;
-    const wgt = (k & 1 ? tx : 1 - tx) * (k >> 1 ? ty : 1 - ty);
-    const i = (yy * w + xx) * 4;
-    const al = data[i + 3] * wgt;
-    r += data[i] * al;
-    g += data[i + 1] * al;
-    b += data[i + 2] * al;
-    a += al;
-  }
-  out[0] = a > 0 ? r / a / 255 : 0;
-  out[1] = a > 0 ? g / a / 255 : 0;
-  out[2] = a > 0 ? b / a / 255 : 0;
-  out[3] = a / 255;
-  return out;
-}
-
-// src/paint-editor/stickers.ts
-function hexRgb(hex) {
-  const n = parseInt(hex.slice(1, 7), 16);
-  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
-}
-function stickerRect(s) {
-  const r = s.size / 2 + 1;
-  const x0 = Math.floor(s.x - r);
-  const y0 = Math.floor(s.y - r);
-  return { x: x0, y: y0, width: Math.ceil(s.x + r) - x0, height: Math.ceil(s.y + r) - y0 };
+var FUZZY_AMPLITUDE = 0.12;
+var NOMINAL_MS_PER_PX = 2;
+var RIBBON_SUB = 4;
+function chainDamp(damp, k) {
+  return Math.min(damp, 1 / (1 + 0.8 * Math.sqrt(Math.max(0, k))) ** 2);
 }
-function stickerStamp(s) {
-  if (s.ref) {
-    try {
-      return editorStampOf(s.ref);
-    } catch {
-      return null;
+function addPolygonArea(pts, rect, out, weight = 1) {
+  const n = pts.length >> 1;
+  if (n < 3) return;
+  let y0 = Infinity;
+  let y1 = -Infinity;
+  for (let i = 1; i < pts.length; i += 2) {
+    if (pts[i] < y0) y0 = pts[i];
+    if (pts[i] > y1) y1 = pts[i];
+  }
+  const r0 = Math.max(0, Math.floor(y0) - rect.y);
+  const r1 = Math.min(rect.height - 1, Math.floor(y1) - rect.y);
+  const xs = [];
+  const w = weight / RIBBON_SUB;
+  for (let row = r0; row <= r1; row++) {
+    const base = row * rect.width;
+    for (let sub = 0; sub < RIBBON_SUB; sub++) {
+      const y = rect.y + row + (sub + 0.5) / RIBBON_SUB;
+      xs.length = 0;
+      for (let i = 0, j = n - 1; i < n; j = i++) {
+        const yi = pts[i * 2 + 1];
+        const yj = pts[j * 2 + 1];
+        if (yi <= y !== yj <= y) xs.push(pts[i * 2] + (y - yi) / (yj - yi) * (pts[j * 2] - pts[i * 2]));
+      }
+      if (xs.length < 2) continue;
+      xs.sort((a, b) => a - b);
+      for (let k = 0; k + 1 < xs.length; k += 2) {
+        const a = Math.max(rect.x, xs[k]);
+        const b = Math.min(rect.x + rect.width, xs[k + 1]);
+        if (!(b > a)) continue;
+        for (let px = Math.floor(a); px < b; px++) {
+          const cover = Math.min(b, px + 1) - Math.max(a, px);
+          if (cover > 0) out[base + px - rect.x] += cover * w;
+        }
+      }
     }
   }
-  return s.stamp && STAMP_KINDS.includes(s.stamp) ? s.stamp : null;
 }
-function drawSticker(medium, s, art) {
-  const kind = stickerStamp(s);
-  if (!kind) {
-    const a2 = art?.(s.ref);
-    return a2 ? drawArtSticker(medium, s, a2) : stickerRect(s);
+function curl(x, y, seed) {
+  const n = (u, v) => {
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const sx = fx * fx * (3 - 2 * fx);
+    const sy = fy * fy * (3 - 2 * fy);
+    const h = (a2, b2) => rand01(seed, a2 * 73856093 + b2 * 19349663, 41);
+    const a = h(x0, y0);
+    const b = h(x0 + 1, y0);
+    const c = h(x0, y0 + 1);
+    const d = h(x0 + 1, y0 + 1);
+    return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;
+  };
+  const e = 0.01;
+  return [(n(x, y + e) - n(x, y - e)) / (2 * e), -(n(x + e, y) - n(x - e, y)) / (2 * e)];
+}
+var ParticleStroke = class extends MarkStroke {
+  sets;
+  /** Ribbon pairs per copy: particles in their order around the pen (non-flow kinds). */
+  orders;
+  s;
+  spawn = 0;
+  /** Textured dots drawn so far, per copy (sequence order, random picks). */
+  dots;
+  /** Ribbon fill: the area each pixel has had so far this stroke (telescoped into the coverage). */
+  filled = /* @__PURE__ */ new Map();
+  pts = [];
+  constructor(brush, options) {
+    super(brush, options);
+    this.s = brush.particle;
+    this.sets = this.copies.map(() => []);
+    this.orders = this.copies.map(() => []);
+    this.dots = this.copies.map(() => 0);
   }
-  const rect = stickerRect(s);
-  const n = rect.width * rect.height;
-  const cov = new Float32Array(n);
-  const field = new Float32Array(n * 3);
-  const rad2 = s.size / 2;
-  const a = s.rotation * Math.PI / 180;
-  const ca = Math.cos(a);
-  const sa = Math.sin(a);
-  const [r, g, b] = hexRgb(s.color);
-  for (let yy = 0, p = 0; yy < rect.height; yy++) {
-    for (let xx = 0, px = rect.x; xx < rect.width; xx++, p++, px++) {
-      const dx = px + 0.5 - s.x;
-      const dy = rect.y + yy + 0.5 - s.y;
-      const u = (dx * ca + dy * sa) / rad2;
-      const v = (-dx * sa + dy * ca) / rad2;
-      if (u < -1.05 || u > 1.05 || v < -1.05 || v > 1.05) continue;
-      let c = 0;
-      for (let k = 0; k < 4; k++) c += stampCoverage(kind, u + ((k & 1) - 0.5) / rad2 / 2, v + ((k >> 1) - 0.5) / rad2 / 2, s.seed);
-      c /= 4;
-      if (c <= 0) continue;
-      cov[p] = c;
-      const shade = 1 + 0.12 * (-(u + v) / 2) + 0.06 * (hash2(px, rect.y + yy, s.seed) - 0.5);
-      field[p * 3] = Math.min(1, Math.max(0, r * shade));
-      field[p * 3 + 1] = Math.min(1, Math.max(0, g * shade));
-      field[p * 3 + 2] = Math.min(1, Math.max(0, b * shade));
-    }
+  /** Strand kinds: a chain of masses behind each particle. */
+  get strands() {
+    return this.s.kind === "string" || this.s.kind === "elastic" || this.s.kind === "fuzzy";
   }
-  medium.deposit(rect, cov, s.opacity, [r, g, b], null, field);
-  return rect;
-}
-function drawArtSticker(medium, s, art) {
-  const rect = stickerRect(s);
-  const n = rect.width * rect.height;
-  const cov = new Float32Array(n);
-  const field = new Float32Array(n * 3);
-  const a = s.rotation * Math.PI / 180;
-  const ca = Math.cos(a);
-  const sa = Math.sin(a);
-  const scale = Math.max(art.width, art.height) / s.size;
-  const [r, g, b] = hexRgb(s.color);
-  const px = [0, 0, 0, 0];
-  for (let yy = 0, p = 0; yy < rect.height; yy++) {
-    for (let xx = 0; xx < rect.width; xx++, p++) {
-      const dx = rect.x + xx + 0.5 - s.x;
-      const dy = rect.y + yy + 0.5 - s.y;
-      const ax = (dx * ca + dy * sa) * scale + art.width / 2;
-      const ay = (-dx * sa + dy * ca) * scale + art.height / 2;
-      if (ax < -1 || ay < -1 || ax > art.width + 1 || ay > art.height + 1) continue;
-      sampleArt(art, ax, ay, px);
-      if (!(px[3] > 0)) continue;
-      cov[p] = px[3];
-      field[p * 3] = art.tintable ? r : px[0];
-      field[p * 3 + 1] = art.tintable ? g : px[1];
-      field[p * 3 + 2] = art.tintable ? b : px[2];
-    }
+  newParticle(x, y, ox, oy, k, phase, i, copy) {
+    const s = this.s;
+    const fuzzy = s.kind === "fuzzy";
+    const jitter = fuzzy ? 1 : s.wavePhaseJitter;
+    return {
+      x,
+      y,
+      vx: 0,
+      vy: 0,
+      ox,
+      oy,
+      k,
+      phase,
+      age: 0,
+      run: 0,
+      bead: 0,
+      alive: true,
+      wavePhase: jitter > 0 ? jitter * Math.PI * 2 * rand01(this.seed, i, 43 + copy) : 0,
+      waveScale: fuzzy ? 0.6 + 0.8 * rand01(this.seed, i, 47 + copy) : 1,
+      dx: x,
+      dy: y,
+      px: NaN,
+      py: NaN,
+      fade: 1
+    };
   }
-  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);
-  const lch = oklabToOklch(rgbToOklab({ r, g, b, a: 1 }));
-  const l = Math.min(1, Math.max(0, lch.l + (rand01(seed, i, 61) - 0.5) * amount * 0.3));
-  const h = lch.h + (rand01(seed, i, 63) - 0.5) * amount * 80;
-  const at = (c) => oklabToRgb(oklchToOklab({ l, c, h, alpha: 1 }));
-  const inGamut = (o) => [o.r, o.g, o.b].every((v) => v >= -1e-4 && v <= 1 + 1e-4);
-  let out = at(lch.c);
-  if (!inGamut(out)) {
-    let lo = 0;
-    let hi = lch.c;
-    for (let k = 0; k < 12; k++) {
-      const mid = (lo + hi) / 2;
-      if (inGamut(at(mid))) lo = mid;
-      else hi = mid;
+  init(copy, d) {
+    const s = this.s;
+    const list = this.sets[copy];
+    const size = Math.max(1, d.radius * 2);
+    for (let i = 0; i < (s.kind === "flow" ? 0 : s.count); i++) {
+      const r = rand01(this.seed, i, 3 + copy) * s.spread * size * 0.5;
+      const a = rand01(this.seed, i, 5 + copy) * Math.PI * 2;
+      const ox = Math.cos(a) * r;
+      const oy = Math.sin(a) * r;
+      const p = this.newParticle(d.x + ox, d.y + oy, ox, oy, 0.6 + 0.8 * rand01(this.seed, i, 7), a, i, copy);
+      if (this.strands) p.strand = Array.from({ length: 6 }, () => ({ x: d.x + ox, y: d.y + oy, vx: 0, vy: 0 }));
+      if (s.kind === "orbit") {
+        p.ox = Math.max(1, r + size * 0.15);
+        p.oy = 0;
+      }
+      list.push(p);
     }
-    out = at(lo);
-  }
-  return "#" + [out.r, out.g, out.b].map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join("");
-}
-var StickerSpray = class {
-  constructor(init) {
-    this.init = init;
-    const b = init.brush;
-    this.smoother = new PenSmoother(b.tip.smoothing, b.pressureSmoothing);
-    this.copies = init.copies.length ? init.copies : [IDENTITY_COPY];
-    const spacing = Math.max(0.05, 1 / Math.max(0.05, b.sticker.density * 4));
-    const walk = { ...b, tip: { ...b.tip, spacing }, dynamics: { ...b.dynamics, scatter: 0, sizeJitter: 0, angleJitter: 0 } };
-    this.walkers = this.copies.map((c, i) => new PenDabWalker(walk, init.seed + i * 7919 | 0, c.linear));
-    this.medium = new TileMedium(init.target, {});
-    this.next = init.nextId;
+    this.orders[copy] = list.map((_, i) => i).sort((i, j) => list[i].phase - list[j].phase || i - j);
   }
-  init;
-  dabCount = 0;
-  stickers = [];
-  /** Refs the spray picked but could not draw because their art had not loaded. */
-  skipped = /* @__PURE__ */ new Set();
-  smoother;
-  walkers;
-  copies;
-  medium;
-  lastRaw = null;
-  lastFed = null;
-  next;
-  push(points) {
-    const rects = [];
-    for (const raw of points) {
-      this.lastRaw = raw;
-      const p = this.smoother.push(raw);
-      this.lastFed = p;
-      this.copies.forEach((c, i) => {
-        const dabs = [];
-        this.walkers[i].push(c.map(p), dabs);
-        for (const d of dabs) this.drop(d, rects);
-      });
-    }
-    return rects;
-  }
-  finish() {
-    const rects = [];
-    const raw = this.lastRaw;
-    const fed = this.lastFed;
-    this.copies.forEach((c, i) => {
-      const dabs = [];
-      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.walkers[i].push(c.map({ ...raw, pressure: fed.pressure }), dabs);
-      this.walkers[i].finish(dabs);
-      for (const d of dabs) this.drop(d, rects);
-    });
-    return rects;
-  }
-  drop(d, rects) {
-    const st = this.init.brush.sticker;
-    const i = this.next;
-    const seed = this.init.seed;
-    const size = d.radius * 2 * (1 - st.sizeJitter * 0.7 * rand01(seed, i, 51));
-    const off = st.scatter * d.radius * 2;
-    const a = rand01(seed, i, 53) * Math.PI * 2;
-    const dist = rand01(seed, i, 55) * off;
-    const base = this.colorAt(d, Math.cos(a) * dist, Math.sin(a) * dist);
-    if (!(base.alpha > 0)) {
-      this.next++;
-      return;
-    }
-    const ref2 = st.stamps[Math.floor(rand01(seed, i, 57) * st.stamps.length)] ?? "editor:dot";
-    const stamp = stickerStamp({ ref: ref2 });
-    if (!stamp && !this.init.art?.(ref2)) {
-      this.skipped.add(ref2);
-      this.next++;
-      return;
-    }
-    const sticker = {
-      id: `st${this.next++}`,
-      ref: ref2,
-      ...stamp ? { stamp } : {},
-      x: Math.round((d.x + Math.cos(a) * dist) * 100) / 100,
-      y: Math.round((d.y + Math.sin(a) * dist) * 100) / 100,
-      size: Math.max(2, Math.round(size * 10) / 10),
-      rotation: Math.round((-d.angle * 180 / Math.PI + (rand01(seed, i, 59) * 2 - 1) * 180 * st.rotationJitter) * 10) / 10,
-      color: st.colorJitter > 0 ? jitterColor(base.color, st.colorJitter, seed, i) : base.color,
-      opacity: Math.round(Math.min(1, d.opacity * this.init.brush.tip.opacity * base.alpha) * 1e3) / 1e3,
-      seed: Math.floor(rand01(seed, i, 65) * 1e9)
-    };
-    this.stickers.push(sticker);
-    rects.push(drawSticker(this.medium, sticker, this.init.art));
-    this.dabCount++;
+  /** The sideways wave of particle `p` at pen dab `d` (px along the normal to the pen's direction). */
+  wave(p, d, size) {
+    const s = this.s;
+    const amp = s.kind === "fuzzy" ? Math.max(FUZZY_AMPLITUDE, s.waveAmplitude) : s.waveAmplitude;
+    if (!(amp > 0)) return 0;
+    const ms = d.time ?? d.travel * NOMINAL_MS_PER_PX;
+    const phase = 2 * Math.PI * d.travel / (s.waveLength * p.waveScale) - s.waveSpeed * 0.025 * ms + p.wavePhase;
+    return amp * size * Math.sin(phase);
   }
-  sampler;
-  /** A sticker's colour: the paint colour, or gradient paint at its dab (`dx`, `dy` from the dab's centre). */
-  colorAt(d, dx, dy) {
-    const effect = this.init.effect;
-    if (effect) {
-      const rgb = [0, 0, 0];
-      const alpha = sampleEffectAt(effect, d.x + dx, d.y + dy, rgb, d);
-      return { color: "#" + rgb.map((c) => Math.round(c * 255).toString(16).padStart(2, "0")).join(""), alpha };
+  advance(copy, d, rects) {
+    const s = this.s;
+    let list = this.sets[copy];
+    if (d.index === 0 && !list.length) this.init(copy, d);
+    const size = Math.max(1, d.radius * 2);
+    const markR = Math.max(0.5, size * s.size / 2);
+    const k = 0.02 + 0.3 * s.stiffness;
+    const damp = 0.6 + 0.38 * (1 - s.damping);
+    const g = s.gravity * 0.15;
+    const op = d.opacity;
+    const al = Math.max(0.05, d.alpha);
+    const nx = Math.sin(d.direction);
+    const ny = Math.cos(d.direction);
+    if (s.kind === "flow") {
+      this.spawn += s.count / 8;
+      while (this.spawn >= 1) {
+        this.spawn -= 1;
+        const i = this.dabCount + list.length * 31 + Math.floor(d.index);
+        const a = rand01(this.seed, i, 11 + copy) * Math.PI * 2;
+        const r = rand01(this.seed, i, 13 + copy) * s.spread * size * 0.5;
+        list.push(this.newParticle(d.x + Math.cos(a) * r, d.y + Math.sin(a) * r, 0, 0, 1, a, i, copy));
+      }
     }
-    const g = this.init.paint;
-    if (!g) return { color: this.init.color, alpha: 1 };
-    this.sampler ??= new PaintGradientSampler(g, this.init.seed);
-    const s = g.map.by === "across-tip" ? this.sampler.sample(((dx * Math.sin(d.direction) + dy * Math.cos(d.direction)) / Math.max(0.5, d.radius) + 1) / 2) : this.sampler.dab(d);
-    return { color: "#" + s.rgb.map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join(""), alpha: s.alpha };
-  }
-};
-function renderStickers(stickers, target, art) {
-  const medium = new TileMedium(target, {});
-  for (const s of stickers) drawSticker(medium, s, art);
-}
-function normalizeStickerUpdate(u) {
-  const out = {};
-  if (u.ref !== void 0 && u.stamp !== void 0) throw new Error("Give ref or stamp, not both (stamp is the older name for an editor stamp).");
-  if (u.stamp !== void 0) {
-    if (!STAMP_KINDS.includes(u.stamp)) throw new Error(`stamp ${JSON.stringify(u.stamp)} is not a stamp; use ${STAMP_KINDS.join(", ")}, or ref for any sticker (find_stickers).`);
-    out.ref = `editor:${u.stamp}`;
-    out.stamp = u.stamp;
-  }
-  if (u.ref !== void 0) {
-    out.ref = normalizeStickerRef(u.ref);
-    const stamp = stickerStamp({ ref: out.ref });
-    if (stamp) out.stamp = stamp;
-    else out.stamp = void 0;
-  }
-  for (const k of ["x", "y"]) if (u[k] !== void 0) {
-    if (!Number.isFinite(u[k])) throw new Error(`${k} must be a number of pixels.`);
-    out[k] = u[k];
-  }
-  if (u.size !== void 0) {
-    if (!(u.size >= 2 && u.size <= 2048)) throw new Error(`size ${u.size} is out of range; use 2..2048 px.`);
-    out.size = u.size;
-  }
-  if (u.rotation !== void 0) {
-    if (!Number.isFinite(u.rotation)) throw new Error("rotation must be degrees.");
-    out.rotation = u.rotation;
-  }
-  if (u.color !== void 0) {
-    if (!/^#[0-9a-f]{6}$/i.test(u.color)) throw new Error(`color ${JSON.stringify(u.color)} must be #rrggbb.`);
-    out.color = u.color.toLowerCase();
-  }
-  if (u.opacity !== void 0) {
-    if (!(u.opacity >= 0 && u.opacity <= 1)) throw new Error(`opacity ${u.opacity} is out of range; use 0..1.`);
-    out.opacity = u.opacity;
-  }
-  return out;
-}
-function stickerSurface(stickers, base, dirty, art) {
-  const only = base && dirty ? new Set(dirty.flatMap((r) => tilesInRect(r).map(({ tx, ty }) => tileKey(tx, ty)))) : null;
-  const live = /* @__PURE__ */ new Map();
-  let scratch = null;
-  const target = {
-    offset: { x: 0, y: 0 },
-    lockTransparency: false,
-    selection: null,
-    readTile: (tx, ty) => live.get(tileKey(tx, ty)) ?? null,
-    writeTile: (tx, ty) => {
-      const k = tileKey(tx, ty);
-      if (only && !only.has(k)) return (scratch ??= new Uint8ClampedArray(TILE * TILE * 4)).fill(0);
-      let t = live.get(k);
-      if (!t) live.set(k, t = new Uint8ClampedArray(TILE * TILE * 4));
-      return t;
+    const lifeSteps = 8 + 120 * s.life;
+    for (let i = 0; i < list.length; i++) {
+      const p = list[i];
+      if (!p.alive) continue;
+      switch (s.kind) {
+        case "spring": {
+          p.vx = (p.vx + (d.x + p.ox - p.x) * k * p.k) * damp;
+          p.vy = (p.vy + (d.y + p.oy - p.y) * k * p.k + g) * damp;
+          p.x += p.vx;
+          p.y += p.vy;
+          break;
+        }
+        case "string":
+        case "fuzzy": {
+          const strand = p.strand;
+          const dm = s.kind === "fuzzy" ? chainDamp(damp, k * p.k) : damp;
+          let ax = d.x + p.ox;
+          let ay = d.y + p.oy;
+          for (const m of strand) {
+            m.vx = (m.vx + (ax - m.x) * k * p.k + 0) * dm;
+            m.vy = (m.vy + (ay - m.y) * k * p.k + g) * dm;
+            m.x += m.vx;
+            m.y += m.vy;
+            ax = m.x;
+            ay = m.y;
+          }
+          p.x = strand[strand.length - 1].x;
+          p.y = strand[strand.length - 1].y;
+          break;
+        }
+        case "elastic": {
+          const strand = p.strand;
+          const rest = size * 0.12;
+          const ke = Math.min(0.9, (0.1 + 0.6 * s.stiffness) * p.k);
+          const dm = chainDamp(damp, ke);
+          let ax = d.x + p.ox;
+          let ay = d.y + p.oy;
+          for (const m of strand) {
+            const ex = ax - m.x;
+            const ey = ay - m.y;
+            const len = Math.hypot(ex, ey);
+            const pull = len > rest ? (len - rest) / len : 0;
+            m.vx = (m.vx + ex * pull * ke) * dm;
+            m.vy = (m.vy + ey * pull * ke + g) * dm;
+            m.x += m.vx;
+            m.y += m.vy;
+            ax = m.x;
+            ay = m.y;
+          }
+          p.x = strand[strand.length - 1].x;
+          p.y = strand[strand.length - 1].y;
+          break;
+        }
+        case "orbit": {
+          p.phase += (0.05 + 0.3 * s.speed) * (i % 2 ? -1 : 1) * (0.7 + 0.6 * rand01(this.seed, i, 17));
+          p.x = d.x + Math.cos(p.phase) * p.ox;
+          p.y = d.y + Math.sin(p.phase) * p.ox + g * p.ox;
+          break;
+        }
+        case "flow": {
+          const [fx, fy] = curl(p.x / Math.max(8, size * 1.5), p.y / Math.max(8, size * 1.5), this.seed);
+          const push = size * 0.012 * (0.3 + 1.5 * s.speed);
+          const fl = Math.hypot(fx, fy) || 1;
+          p.vx = p.vx * 0.8 + fx / fl * push;
+          p.vy = p.vy * 0.8 + fy / fl * push + g * 0.2;
+          p.x += p.vx;
+          p.y += p.vy;
+          p.age++;
+          if (p.age > lifeSteps) p.alive = false;
+          break;
+        }
+      }
+      const w = this.wave(p, d, size);
+      const qx = w ? p.x + nx * w : p.x;
+      const qy = w ? p.y + ny * w : p.y;
+      const px = p.dx;
+      const py = p.dy;
+      p.px = p.dx;
+      p.py = p.dy;
+      p.dx = qx;
+      p.dy = qy;
+      const fade = s.kind === "flow" ? 1 - p.age / lifeSteps : 1;
+      p.fade = fade;
+      const moved = Math.hypot(qx - px, qy - py);
+      if (d.index === 0 && s.kind !== "flow") continue;
+      if (s.render === "dot") this.dot(copy, qx, qy, qx - px, qy - py, markR * fade, al * fade, op, d, rects);
+      else if (s.render === "line" || s.render === "ribbon") this.segment(px, py, qx, qy, markR * fade, al * fade, op, d.pressure, rects);
+      else {
+        p.run += moved;
+        const gap = Math.max(markR * 2, size * (0.05 + s.interval));
+        while (p.run >= gap) {
+          p.run -= gap;
+          p.bead++;
+          const t = moved > 0 ? 1 - p.run / Math.max(moved, 1e-6) : 1;
+          const bx = px + (qx - px) * Math.min(1, Math.max(0, t));
+          const by = py + (qy - py) * Math.min(1, Math.max(0, t));
+          this.dot(copy, bx, by, qx - px, qy - py, markR * (0.7 + 0.6 * (p.bead % 3 / 2)) * fade, al * fade, op, d, rects);
+        }
+      }
     }
-  };
-  const reaches = (s) => !only || tilesInRect(stickerRect(s)).some(({ tx, ty }) => only.has(tileKey(tx, ty)));
-  renderStickers(stickers.filter(reaches), target, art);
-  const tiles = /* @__PURE__ */ new Map();
-  if (only && base) {
-    for (const [k, t] of base.tiles) if (!only.has(k)) tiles.set(k, t);
-  }
-  for (const [k, d] of live) {
-    const t = finishTile(d, 4, 0);
-    if (t) tiles.set(k, t);
-  }
-  return new TiledSurface(4, tiles, 0);
-}
-function stickerAt(stickers, x, y, art) {
-  for (let i = stickers.length - 1; i >= 0; i--) {
-    const s = stickers[i];
-    const rad2 = s.size / 2;
-    const a = s.rotation * Math.PI / 180;
-    const dx = x - s.x;
-    const dy = y - s.y;
-    const u = (dx * Math.cos(a) + dy * Math.sin(a)) / rad2;
-    const v = (-dx * Math.sin(a) + dy * Math.cos(a)) / rad2;
-    if (Math.abs(u) > 1.05 || Math.abs(v) > 1.05) continue;
-    if (s.size < 16) return s;
-    const kind = stickerStamp(s);
-    if (kind) {
-      if (stampCoverage(kind, u, v, s.seed) > 0.25) return s;
-      continue;
+    if (s.render === "ribbon" && !(d.index === 0 && s.kind !== "flow")) this.ribbon(copy, list, op, al, d, rects);
+    if (s.kind === "flow" && list.length > 512) {
+      list = list.filter((p) => p.alive);
+      this.sets[copy] = list;
     }
-    const pic = art?.(s.ref);
-    if (!pic) return s;
-    const scale = Math.max(pic.width, pic.height) / 2;
-    if (sampleArt(pic, u * scale + pic.width / 2, v * scale + pic.height / 2, [0, 0, 0, 0])[3] > 0.25) return s;
   }
-  return null;
-}
-
-// src/paint-editor/procedural.ts
-var STEP_PX = 1.5;
-var MarkStroke = class {
-  constructor(brush, options) {
-    this.brush = brush;
-    this.options = options;
-    this.sampler = options.paint ? new PaintGradientSampler(options.paint, options.seed ?? 0) : null;
-    this.tipTable = this.sampler?.acrossTip ? this.sampler.tipTable(TIP_GRADIENT_STEPS) : null;
-    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
-    this.seed = options.seed ?? 0;
-    const fine = { ...brush, tip: { ...brush.tip, spacing: Math.max(0.01, Math.min(0.25, STEP_PX / Math.max(1, brush.tip.size))) } };
-    this.walkers = this.copies.map((c, i) => new PenDabWalker(fine, (options.seed ?? 0) + i * 7919 | 0, c.linear));
-    this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
+  /** A dot (or bead): round, or a textured stamp turned by the particle's motion (mx, my), at random or to the tip angle. */
+  dot(copy, x, y, mx, my, r, alpha, opacity, d, rects) {
+    const s = this.s;
+    const textures = s.dotTextures;
+    if (!textures.length) return this.mark(x, y, r, alpha, opacity, d.pressure, rects);
+    const n = this.dots[copy]++;
+    const pick = s.dotTextureOrder === "random" ? Math.min(textures.length - 1, Math.floor(rand01(this.seed, n, 31 + copy) * textures.length)) : n % textures.length;
+    const rotation = s.dotRotation === "random" ? rand01(this.seed, n, 37 + copy) * Math.PI * 2 : s.dotRotation === "follow" ? mx || my ? Math.atan2(my, mx) : -d.direction : -this.brush.tip.angle * Math.PI / 180;
+    this.stamp(x, y, r, textures[pick], rotation, this.seed + n * 2654435761 >>> 0, alpha, opacity, d.pressure, rects);
   }
-  brush;
-  options;
-  coverage = new CoverageMap();
-  dabCount = 0;
-  smoother;
-  copies;
-  walkers;
-  depth;
-  buf = new Float32Array(0);
-  field = new Float32Array(0);
-  lastRaw = null;
-  lastFed = null;
-  seed;
-  sampler;
-  tipTable;
-  /** The pen dab the marks being made belong to, and its gradient colour. */
-  pen = null;
-  penColor = { rgb: [0, 0, 0], alpha: 1 };
-  push(points) {
-    const rects = [];
-    for (const raw of points) {
-      this.lastRaw = raw;
-      const p = this.smoother.push(raw);
-      this.lastFed = p;
-      this.copies.forEach((c, i) => {
-        const dabs = [];
-        this.walkers[i].push(c.map(p), dabs);
-        for (const d of dabs) this.step(i, d, rects);
-      });
+  /**
+   * Ribbon fill for one step: the band between each pair of joined particles, from where they
+   * were drawn last step to where they are drawn now. Bands of one step, and of consecutive steps,
+   * share edges exactly, so the fill has no seams; it is telescoped into the coverage
+   * (`telescope`), so it does not build up at the joins.
+   */
+  ribbon(copy, list, opacity, alpha, d, rects) {
+    const s = this.s;
+    if (!(s.ribbonFill > 0)) return;
+    const live = (p) => !!p && p.alive && !Number.isNaN(p.px);
+    let order;
+    if (s.kind === "flow") order = list.filter(live);
+    else order = this.orders[copy].map((i) => list[i]).filter(live);
+    if (order.length < 2) return;
+    const pairs = [];
+    if (s.ribbonPairs === "first-last") pairs.push([order[0], order[order.length - 1]]);
+    else for (let i = 0; i + 1 < order.length; i++) pairs.push([order[i], order[i + 1]]);
+    const pts = this.pts;
+    const ceil = Math.min(1, opacity * s.ribbonFill);
+    for (const [a, b] of pairs) {
+      pts.length = 0;
+      pts.push(a.px, a.py, a.dx, a.dy, b.dx, b.dy, b.px, b.py);
+      let x0 = Infinity;
+      let y0 = Infinity;
+      let x1 = -Infinity;
+      let y1 = -Infinity;
+      for (let i = 0; i < 8; i += 2) {
+        x0 = Math.min(x0, pts[i]);
+        x1 = Math.max(x1, pts[i]);
+        y0 = Math.min(y0, pts[i + 1]);
+        y1 = Math.max(y1, pts[i + 1]);
+      }
+      const rect = { x: Math.floor(x0), y: Math.floor(y0), width: Math.floor(x1) - Math.floor(x0) + 1, height: Math.floor(y1) - Math.floor(y0) + 1 };
+      const area = this.scratch(rect.width * rect.height);
+      addPolygonArea(pts, rect, area, Math.min(a.fade, b.fade) * alpha);
+      if (this.telescope(rect, area)) this.lay(rect, area, ceil, d.pressure, (a.dx + b.dx) / 2, (a.dy + b.dy) / 2, rects);
     }
-    return rects;
-  }
-  step(copy, d, rects) {
-    this.pen = d;
-    if (this.sampler && !this.tipTable) this.sampler.dab(d, this.penColor);
-    this.advance(copy, d, rects);
-  }
-  /** The colour of a mark at (x, y): its pen dab's, or across the tip by its offset from the pen. */
-  markColor(x, y) {
-    if (!this.sampler || !this.pen) return null;
-    if (!this.tipTable) return this.penColor;
-    const d = this.pen;
-    const u = ((x - d.x) * Math.sin(d.direction) + (y - d.y) * Math.cos(d.direction)) / Math.max(0.5, d.radius);
-    const last = this.tipTable.length - 1;
-    return this.tipTable[Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)))];
-  }
-  finish() {
-    const rects = [];
-    const raw = this.lastRaw;
-    const fed = this.lastFed;
-    this.copies.forEach((c, i) => {
-      const dabs = [];
-      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.walkers[i].push(c.map({ ...raw, pressure: fed.pressure }), dabs);
-      this.walkers[i].finish(dabs);
-      for (const d of dabs) this.step(i, d, rects);
-    });
-    return rects;
-  }
-  /** Stamps one round mark of radius `r` at (x, y) with flow `alpha` towards `opacity`. */
-  mark(x, y, r, alpha, opacity, pressure, rects) {
-    if (!(r > 0.05) || !(alpha > 0)) return;
-    const dab = { x, y, radius: Math.max(0.5, r), alpha: Math.min(1, alpha), opacity: Math.min(1, opacity), angle: 0, roundness: 1 };
-    const hardness = this.brush.tip.hardness;
-    const rect = dabRect(dab, hardness);
-    const n = rect.width * rect.height;
-    if (n <= 0) return;
-    const vals = this.scratch(n);
-    rasterizeDab(dab, hardness, rect, vals);
-    this.lay(rect, vals, dab.opacity, pressure, x, y, rects);
   }
   /**
-   * Stamps a textured mark: `kind` from the sticker stamps over a square of half-size `r`, turned
-   * `rotation` radians clockwise, with flow `alpha` towards `opacity`. Small marks are supersampled.
+   * Turns the area newly filled over `rect` into coverage to lay towards the fill's ceiling: the
+   * share of what was left unfilled, so after any number of bands (in any grouping) a pixel's
+   * coverage is the ceiling times the area filled there. False when nothing was added.
    */
-  stamp(x, y, r, kind, rotation, seed, alpha, opacity, pressure, rects) {
-    if (!(r > 0.05) || !(alpha > 0)) return;
-    const reach = Math.max(0.5, r) * Math.SQRT2 + 1;
-    const rect = { x: Math.floor(x - reach), y: Math.floor(y - reach), width: 0, height: 0 };
-    rect.width = Math.ceil(x + reach) - rect.x;
-    rect.height = Math.ceil(y + reach) - rect.y;
-    const n = rect.width * rect.height;
-    const vals = this.scratch(n);
-    const ss = r < 10 ? 3 : 1;
-    const c = Math.cos(rotation);
-    const s = Math.sin(rotation);
-    const inv = 1 / Math.max(0.5, r);
-    const a = Math.min(1, alpha);
+  telescope(rect, area) {
+    let any = false;
     for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const gy = rect.y + yy;
+      const ty = Math.floor(gy / TILE);
+      let t;
+      let tx = NaN;
       for (let xx = 0; xx < rect.width; xx++, k++) {
-        let sum = 0;
-        for (let sy = 0; sy < ss; sy++) {
-          for (let sx = 0; sx < ss; sx++) {
-            const dx = rect.x + xx + (sx + 0.5) / ss - x;
-            const dy = rect.y + yy + (sy + 0.5) / ss - y;
-            sum += stampCoverage(kind, (dx * c + dy * s) * inv, (dy * c - dx * s) * inv, seed);
+        const add = area[k];
+        if (!(add > 0)) continue;
+        const gx = rect.x + xx;
+        const ntx = Math.floor(gx / TILE);
+        if (ntx !== tx || !t) {
+          tx = ntx;
+          const key = tileKey(tx, ty);
+          t = this.filled.get(key);
+          if (!t) {
+            t = new Float32Array(TILE * TILE);
+            this.filled.set(key, t);
           }
         }
-        vals[k] = sum / (ss * ss) * a;
+        const ti = (gy - ty * TILE) * TILE + (gx - tx * TILE);
+        const before = t[ti];
+        const after = Math.min(1, before + add);
+        t[ti] = after;
+        area[k] = before < 1 ? (after - before) / (1 - before) : 0;
+        any = true;
       }
     }
-    this.lay(rect, vals, Math.min(1, opacity), pressure, x, y, rects);
+    return any;
   }
-  /** A scratch buffer of `n` values (reused; valid until the next mark). */
-  scratch(n) {
-    if (this.buf.length < n) this.buf = new Float32Array(n);
-    const vals = this.buf.subarray(0, n);
-    vals.fill(0);
-    return vals;
+};
+var BristleStroke = class extends MarkStroke {
+  tufts;
+  s;
+  constructor(brush, options) {
+    super(brush, options);
+    this.s = brush.bristle;
+    const s = this.s;
+    this.tufts = this.copies.map(
+      (_, c) => Array.from({ length: s.count }, (_2, i) => {
+        const a = rand01(this.seed, i, 21 + c) * Math.PI * 2;
+        const r = Math.sqrt(rand01(this.seed, i, 23 + c));
+        return {
+          u: Math.cos(a) * r,
+          v: Math.sin(a) * r,
+          x: 0,
+          y: 0,
+          paint: 1 - s.jitter * 0.4 * rand01(this.seed, i, 25 + c),
+          thirst: 1 + s.jitter * (rand01(this.seed, i, 27 + c) * 2 - 1),
+          w: 1 + s.jitter * 0.6 * (rand01(this.seed, i, 29 + c) - 0.5),
+          started: false
+        };
+      })
+    );
   }
-  /**
-   * Lays coverage `vals` over `rect` towards `opacity`: paper grain, then effect paint or the
-   * colour of a mark at (x, y) (gradient paint), into the stroke's coverage.
-   */
-  lay(rect, vals, opacity, pressure, x, y, rects) {
-    const n = rect.width * rect.height;
-    if (n <= 0) return;
-    const grain = this.options.grain;
-    if (this.depth > 0 && grain) {
-      for (let yy = 0, k = 0; yy < rect.height; yy++)
-        for (let xx = 0; xx < rect.width; xx++, k++) if (vals[k] > 0) vals[k] *= grainCatch(grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, pressure);
-    }
-    if (this.options.effect) {
-      if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
-      const field = this.field.subarray(0, n * 3);
-      sampleEffectField(this.options.effect, rect, vals, field, this.pen);
-      this.coverage.accumulate(rect, vals, opacity, null, field);
-    } else {
-      const color = this.markColor(x, y);
-      if (color && color.alpha < 1) for (let k = 0; k < n; k++) vals[k] *= color.alpha;
-      this.coverage.accumulate(rect, vals, opacity, color ? color.rgb : null);
+  advance(copy, d, rects) {
+    const s = this.s;
+    const tuft = this.tufts[copy];
+    const spread = d.radius * (0.55 + 0.9 * s.splay * d.pressure);
+    const ca = Math.cos(d.angle);
+    const sa = Math.sin(d.angle);
+    const ro = Math.max(0.15, d.roundness);
+    const tx = Math.cos(d.direction);
+    const ty = -Math.sin(d.direction);
+    const follow = 0.15 + 0.85 * s.stiffness;
+    const bend = d.radius * (1 - s.stiffness) * d.pressure * 0.8;
+    const lineR = Math.max(0.5, d.radius * 2 * s.thickness * 0.5);
+    const dryRate = 4e-3 * (1 - s.load);
+    for (const b of tuft) {
+      const lu = b.u * spread;
+      const lv = b.v * spread * ro;
+      const ox = lu * ca - lv * sa;
+      const oy = -(lu * sa + lv * ca);
+      const lag = bend * (1 - 0.5 * b.v);
+      const wx = d.x + ox - tx * lag;
+      const wy = d.y + oy - ty * lag;
+      if (!b.started) {
+        b.x = wx;
+        b.y = wy;
+        b.started = true;
+        continue;
+      }
+      const nx = b.x + (wx - b.x) * follow;
+      const ny = b.y + (wy - b.y) * follow;
+      const paint = Math.max(0, b.paint);
+      if (paint > 0.02) this.segment(b.x, b.y, nx, ny, lineR * b.w * (0.6 + 0.4 * d.pressure), d.alpha * Math.min(1, paint * 1.4), d.opacity, d.pressure, rects);
+      b.paint -= dryRate * b.thirst * Math.hypot(nx - b.x, ny - b.y);
+      b.x = nx;
+      b.y = ny;
     }
-    rects.push(rect);
-    this.dabCount++;
-  }
-  /** Marks along a segment, spaced by a fraction of the radius. */
-  segment(x0, y0, x1, y1, r, alpha, opacity, pressure, rects) {
-    const len = Math.hypot(x1 - x0, y1 - y0);
-    const step = Math.max(0.35, r * 0.5);
-    const n = Math.max(1, Math.ceil(len / step));
-    for (let i = 1; i <= n; i++) this.mark(x0 + (x1 - x0) * i / n, y0 + (y1 - y0) * i / n, r, alpha, opacity, pressure, rects);
   }
 };
-var FUZZY_AMPLITUDE = 0.12;
-var NOMINAL_MS_PER_PX = 2;
-var RIBBON_SUB = 4;
-function chainDamp(damp, k) {
-  return Math.min(damp, 1 / (1 + 0.8 * Math.sqrt(Math.max(0, k))) ** 2);
-}
-function addPolygonArea(pts, rect, out, weight = 1) {
-  const n = pts.length >> 1;
-  if (n < 3) return;
-  let y0 = Infinity;
-  let y1 = -Infinity;
-  for (let i = 1; i < pts.length; i += 2) {
-    if (pts[i] < y0) y0 = pts[i];
-    if (pts[i] > y1) y1 = pts[i];
-  }
-  const r0 = Math.max(0, Math.floor(y0) - rect.y);
-  const r1 = Math.min(rect.height - 1, Math.floor(y1) - rect.y);
-  const xs = [];
-  const w = weight / RIBBON_SUB;
-  for (let row = r0; row <= r1; row++) {
-    const base = row * rect.width;
-    for (let sub = 0; sub < RIBBON_SUB; sub++) {
-      const y = rect.y + row + (sub + 0.5) / RIBBON_SUB;
-      xs.length = 0;
-      for (let i = 0, j = n - 1; i < n; j = i++) {
-        const yi = pts[i * 2 + 1];
-        const yj = pts[j * 2 + 1];
-        if (yi <= y !== yj <= y) xs.push(pts[i * 2] + (y - yi) / (yj - yi) * (pts[j * 2] - pts[i * 2]));
-      }
-      if (xs.length < 2) continue;
-      xs.sort((a, b) => a - b);
-      for (let k = 0; k + 1 < xs.length; k += 2) {
-        const a = Math.max(rect.x, xs[k]);
-        const b = Math.min(rect.x + rect.width, xs[k + 1]);
-        if (!(b > a)) continue;
-        for (let px = Math.floor(a); px < b; px++) {
-          const cover = Math.min(b, px + 1) - Math.max(a, px);
-          if (cover > 0) out[base + px - rect.x] += cover * w;
-        }
-      }
+
+// src/paint-editor/sticker-art.ts
+var STICKER_ART_SIZE = 256;
+var defaultStickerRasterizer = async (asset, size) => {
+  if (asset.kind === "image") {
+    const parsed = parseDataUrl(asset.url);
+    if (parsed && parsed.mime === "image/png") {
+      const png = decodePng(parsed.bytes);
+      return { width: png.width, height: png.height, data: new Uint8ClampedArray(png.data) };
     }
   }
-}
-function curl(x, y, seed) {
-  const n = (u, v) => {
-    const x0 = Math.floor(u);
-    const y0 = Math.floor(v);
-    const fx = u - x0;
-    const fy = v - y0;
-    const sx = fx * fx * (3 - 2 * fx);
-    const sy = fy * fy * (3 - 2 * fy);
-    const h = (a2, b2) => rand01(seed, a2 * 73856093 + b2 * 19349663, 41);
-    const a = h(x0, y0);
-    const b = h(x0 + 1, y0);
-    const c = h(x0, y0 + 1);
-    const d = h(x0 + 1, y0 + 1);
-    return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;
+  const g = globalThis;
+  if (!g.createImageBitmap || !g.OffscreenCanvas) {
+    throw new StickerError("unsupported_format", `This environment can't draw ${asset.kind === "svg" ? "SVG" : "non-PNG"} sticker art; pass rasterizeSticker in the paint editor's options (or use a provider that offers png).`);
+  }
+  const blob = asset.kind === "svg" ? new Blob([asset.svg], { type: "image/svg+xml" }) : await (await g.fetch(asset.url)).blob();
+  const bitmap = await g.createImageBitmap(blob);
+  const scale = size / Math.max(bitmap.width, bitmap.height, 1);
+  const w = Math.max(1, Math.round(bitmap.width * scale));
+  const h = Math.max(1, Math.round(bitmap.height * scale));
+  const canvas = new g.OffscreenCanvas(w, h);
+  const ctx = canvas.getContext("2d");
+  ctx.drawImage(bitmap, 0, 0, w, h);
+  const img = ctx.getImageData(0, 0, w, h);
+  return { width: w, height: h, data: img.data };
+};
+var StickerArtCache = class {
+  entries = /* @__PURE__ */ new Map();
+  /** The art for `ref` when it has loaded (editor stamps never need any). */
+  get = (ref2) => {
+    const e = this.entries.get(ref2);
+    return e?.status === "ready" ? e.art : void 0;
   };
-  const e = 0.01;
-  return [(n(x, y + e) - n(x, y - e)) / (2 * e), -(n(x + e, y) - n(x - e, y)) / (2 * e)];
-}
-var ParticleStroke = class extends MarkStroke {
-  sets;
-  /** Ribbon pairs per copy: particles in their order around the pen (non-flow kinds). */
-  orders;
-  s;
-  spawn = 0;
-  /** Textured dots drawn so far, per copy (sequence order, random picks). */
-  dots;
-  /** Ribbon fill: the area each pixel has had so far this stroke (telescoped into the coverage). */
-  filled = /* @__PURE__ */ new Map();
-  pts = [];
-  constructor(brush, options) {
-    super(brush, options);
-    this.s = brush.particle;
-    this.sets = this.copies.map(() => []);
-    this.orders = this.copies.map(() => []);
-    this.dots = this.copies.map(() => 0);
+  /** `ready`, `loading`, `failed` (with the reason) or `none` (never asked for). Editor stamps are always `ready`. */
+  status(ref2) {
+    if (editorStampOf(ref2)) return { status: "ready" };
+    const e = this.entries.get(ref2);
+    if (!e) return { status: "none" };
+    return e.status === "failed" ? { status: "failed", error: e.error } : { status: e.status };
   }
-  /** Strand kinds: a chain of masses behind each particle. */
-  get strands() {
-    return this.s.kind === "string" || this.s.kind === "elastic" || this.s.kind === "fuzzy";
+  /**
+   * Loads and rasterises `ref` from `provider` once (later calls share the load). Unknown refs
+   * reject with the closest known ones; failures are kept so they are reported, and retried on
+   * the next call.
+   */
+  ensure(provider, ref2, rasterize) {
+    if (editorStampOf(ref2)) return Promise.resolve(null);
+    const e = this.entries.get(ref2);
+    if (e?.status === "ready") return Promise.resolve(e.art);
+    if (e?.status === "loading") return e.promise;
+    const promise = (async () => {
+      const d = await describeStickerRef(provider, ref2);
+      const id = stickerIdFor(provider, ref2);
+      const max = provider.capabilities.maxSize ?? STICKER_ART_SIZE;
+      const size = Math.min(STICKER_ART_SIZE, max);
+      const asset = await provider.load(id, d.formats.includes("png") ? { format: "png", size } : { format: d.formats[0] ?? "svg", size });
+      const px = await rasterize(asset, size);
+      if (!(px.width > 0 && px.height > 0) || px.data.length !== px.width * px.height * 4) throw new StickerError("load_failed", `The art for "${ref2}" came back empty or the wrong size.`);
+      return { ...px, tintable: d.tintable };
+    })();
+    this.entries.set(ref2, { status: "loading", promise });
+    return promise.then(
+      (art) => {
+        this.entries.set(ref2, { status: "ready", art });
+        return art;
+      },
+      (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        this.entries.set(ref2, { status: "failed", error: message });
+        throw err;
+      }
+    );
   }
-  newParticle(x, y, ox, oy, k, phase, i, copy) {
-    const s = this.s;
-    const fuzzy = s.kind === "fuzzy";
-    const jitter = fuzzy ? 1 : s.wavePhaseJitter;
-    return {
-      x,
-      y,
-      vx: 0,
-      vy: 0,
-      ox,
-      oy,
-      k,
-      phase,
-      age: 0,
-      run: 0,
-      bead: 0,
-      alive: true,
-      wavePhase: jitter > 0 ? jitter * Math.PI * 2 * rand01(this.seed, i, 43 + copy) : 0,
-      waveScale: fuzzy ? 0.6 + 0.8 * rand01(this.seed, i, 47 + copy) : 1,
-      dx: x,
-      dy: y,
-      px: NaN,
-      py: NaN,
-      fade: 1
-    };
+  /** Forgets every load (a new provider). */
+  clear() {
+    this.entries.clear();
   }
-  init(copy, d) {
-    const s = this.s;
-    const list = this.sets[copy];
-    const size = Math.max(1, d.radius * 2);
-    for (let i = 0; i < (s.kind === "flow" ? 0 : s.count); i++) {
-      const r = rand01(this.seed, i, 3 + copy) * s.spread * size * 0.5;
-      const a = rand01(this.seed, i, 5 + copy) * Math.PI * 2;
-      const ox = Math.cos(a) * r;
-      const oy = Math.sin(a) * r;
-      const p = this.newParticle(d.x + ox, d.y + oy, ox, oy, 0.6 + 0.8 * rand01(this.seed, i, 7), a, i, copy);
-      if (this.strands) p.strand = Array.from({ length: 6 }, () => ({ x: d.x + ox, y: d.y + oy, vx: 0, vy: 0 }));
-      if (s.kind === "orbit") {
-        p.ox = Math.max(1, r + size * 0.15);
-        p.oy = 0;
-      }
-      list.push(p);
+};
+function sampleArt(art, x, y, out) {
+  const { width: w, height: h, data } = art;
+  const fx = x - 0.5;
+  const fy = y - 0.5;
+  const x0 = Math.floor(fx);
+  const y0 = Math.floor(fy);
+  const tx = fx - x0;
+  const ty = fy - y0;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
+  for (let k = 0; k < 4; k++) {
+    const xx = x0 + (k & 1);
+    const yy = y0 + (k >> 1);
+    if (xx < 0 || yy < 0 || xx >= w || yy >= h) continue;
+    const wgt = (k & 1 ? tx : 1 - tx) * (k >> 1 ? ty : 1 - ty);
+    const i = (yy * w + xx) * 4;
+    const al = data[i + 3] * wgt;
+    r += data[i] * al;
+    g += data[i + 1] * al;
+    b += data[i + 2] * al;
+    a += al;
+  }
+  out[0] = a > 0 ? r / a / 255 : 0;
+  out[1] = a > 0 ? g / a / 255 : 0;
+  out[2] = a > 0 ? b / a / 255 : 0;
+  out[3] = a / 255;
+  return out;
+}
+
+// src/paint-editor/stickers.ts
+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) {
+  const r = s.size / 2 + 1;
+  const x0 = Math.floor(s.x - r);
+  const y0 = Math.floor(s.y - r);
+  return { x: x0, y: y0, width: Math.ceil(s.x + r) - x0, height: Math.ceil(s.y + r) - y0 };
+}
+function stickerStamp(s) {
+  if (s.ref) {
+    try {
+      return editorStampOf(s.ref);
+    } catch {
+      return null;
     }
-    this.orders[copy] = list.map((_, i) => i).sort((i, j) => list[i].phase - list[j].phase || i - j);
   }
-  /** The sideways wave of particle `p` at pen dab `d` (px along the normal to the pen's direction). */
-  wave(p, d, size) {
-    const s = this.s;
-    const amp = s.kind === "fuzzy" ? Math.max(FUZZY_AMPLITUDE, s.waveAmplitude) : s.waveAmplitude;
-    if (!(amp > 0)) return 0;
-    const ms = d.time ?? d.travel * NOMINAL_MS_PER_PX;
-    const phase = 2 * Math.PI * d.travel / (s.waveLength * p.waveScale) - s.waveSpeed * 0.025 * ms + p.wavePhase;
-    return amp * size * Math.sin(phase);
+  return s.stamp && STAMP_KINDS.includes(s.stamp) ? s.stamp : null;
+}
+function drawSticker(medium, s, art) {
+  const kind = stickerStamp(s);
+  if (!kind) {
+    const a2 = art?.(s.ref);
+    return a2 ? drawArtSticker(medium, s, a2) : stickerRect(s);
   }
-  advance(copy, d, rects) {
-    const s = this.s;
-    let list = this.sets[copy];
-    if (d.index === 0 && !list.length) this.init(copy, d);
-    const size = Math.max(1, d.radius * 2);
-    const markR = Math.max(0.5, size * s.size / 2);
-    const k = 0.02 + 0.3 * s.stiffness;
-    const damp = 0.6 + 0.38 * (1 - s.damping);
-    const g = s.gravity * 0.15;
-    const op = d.opacity;
-    const al = Math.max(0.05, d.alpha);
-    const nx = Math.sin(d.direction);
-    const ny = Math.cos(d.direction);
-    if (s.kind === "flow") {
-      this.spawn += s.count / 8;
-      while (this.spawn >= 1) {
-        this.spawn -= 1;
-        const i = this.dabCount + list.length * 31 + Math.floor(d.index);
-        const a = rand01(this.seed, i, 11 + copy) * Math.PI * 2;
-        const r = rand01(this.seed, i, 13 + copy) * s.spread * size * 0.5;
-        list.push(this.newParticle(d.x + Math.cos(a) * r, d.y + Math.sin(a) * r, 0, 0, 1, a, i, copy));
-      }
+  const rect = stickerRect(s);
+  const n = rect.width * rect.height;
+  const cov = new Float32Array(n);
+  const field = new Float32Array(n * 3);
+  const rad2 = s.size / 2;
+  const a = s.rotation * Math.PI / 180;
+  const ca = Math.cos(a);
+  const sa = Math.sin(a);
+  const [r, g, b] = hexRgb(s.color);
+  for (let yy = 0, p = 0; yy < rect.height; yy++) {
+    for (let xx = 0, px = rect.x; xx < rect.width; xx++, p++, px++) {
+      const dx = px + 0.5 - s.x;
+      const dy = rect.y + yy + 0.5 - s.y;
+      const u = (dx * ca + dy * sa) / rad2;
+      const v = (-dx * sa + dy * ca) / rad2;
+      if (u < -1.05 || u > 1.05 || v < -1.05 || v > 1.05) continue;
+      let c = 0;
+      for (let k = 0; k < 4; k++) c += stampCoverage(kind, u + ((k & 1) - 0.5) / rad2 / 2, v + ((k >> 1) - 0.5) / rad2 / 2, s.seed);
+      c /= 4;
+      if (c <= 0) continue;
+      cov[p] = c;
+      const shade = 1 + 0.12 * (-(u + v) / 2) + 0.06 * (hash2(px, rect.y + yy, s.seed) - 0.5);
+      field[p * 3] = Math.min(1, Math.max(0, r * shade));
+      field[p * 3 + 1] = Math.min(1, Math.max(0, g * shade));
+      field[p * 3 + 2] = Math.min(1, Math.max(0, b * shade));
     }
-    const lifeSteps = 8 + 120 * s.life;
-    for (let i = 0; i < list.length; i++) {
-      const p = list[i];
-      if (!p.alive) continue;
-      switch (s.kind) {
-        case "spring": {
-          p.vx = (p.vx + (d.x + p.ox - p.x) * k * p.k) * damp;
-          p.vy = (p.vy + (d.y + p.oy - p.y) * k * p.k + g) * damp;
-          p.x += p.vx;
-          p.y += p.vy;
-          break;
-        }
-        case "string":
-        case "fuzzy": {
-          const strand = p.strand;
-          const dm = s.kind === "fuzzy" ? chainDamp(damp, k * p.k) : damp;
-          let ax = d.x + p.ox;
-          let ay = d.y + p.oy;
-          for (const m of strand) {
-            m.vx = (m.vx + (ax - m.x) * k * p.k + 0) * dm;
-            m.vy = (m.vy + (ay - m.y) * k * p.k + g) * dm;
-            m.x += m.vx;
-            m.y += m.vy;
-            ax = m.x;
-            ay = m.y;
-          }
-          p.x = strand[strand.length - 1].x;
-          p.y = strand[strand.length - 1].y;
-          break;
-        }
-        case "elastic": {
-          const strand = p.strand;
-          const rest = size * 0.12;
-          const ke = Math.min(0.9, (0.1 + 0.6 * s.stiffness) * p.k);
-          const dm = chainDamp(damp, ke);
-          let ax = d.x + p.ox;
-          let ay = d.y + p.oy;
-          for (const m of strand) {
-            const ex = ax - m.x;
-            const ey = ay - m.y;
-            const len = Math.hypot(ex, ey);
-            const pull = len > rest ? (len - rest) / len : 0;
-            m.vx = (m.vx + ex * pull * ke) * dm;
-            m.vy = (m.vy + ey * pull * ke + g) * dm;
-            m.x += m.vx;
-            m.y += m.vy;
-            ax = m.x;
-            ay = m.y;
-          }
-          p.x = strand[strand.length - 1].x;
-          p.y = strand[strand.length - 1].y;
-          break;
-        }
-        case "orbit": {
-          p.phase += (0.05 + 0.3 * s.speed) * (i % 2 ? -1 : 1) * (0.7 + 0.6 * rand01(this.seed, i, 17));
-          p.x = d.x + Math.cos(p.phase) * p.ox;
-          p.y = d.y + Math.sin(p.phase) * p.ox + g * p.ox;
-          break;
-        }
-        case "flow": {
-          const [fx, fy] = curl(p.x / Math.max(8, size * 1.5), p.y / Math.max(8, size * 1.5), this.seed);
-          const push = size * 0.012 * (0.3 + 1.5 * s.speed);
-          const fl = Math.hypot(fx, fy) || 1;
-          p.vx = p.vx * 0.8 + fx / fl * push;
-          p.vy = p.vy * 0.8 + fy / fl * push + g * 0.2;
-          p.x += p.vx;
-          p.y += p.vy;
-          p.age++;
-          if (p.age > lifeSteps) p.alive = false;
-          break;
-        }
-      }
-      const w = this.wave(p, d, size);
-      const qx = w ? p.x + nx * w : p.x;
-      const qy = w ? p.y + ny * w : p.y;
-      const px = p.dx;
-      const py = p.dy;
-      p.px = p.dx;
-      p.py = p.dy;
-      p.dx = qx;
-      p.dy = qy;
-      const fade = s.kind === "flow" ? 1 - p.age / lifeSteps : 1;
-      p.fade = fade;
-      const moved = Math.hypot(qx - px, qy - py);
-      if (d.index === 0 && s.kind !== "flow") continue;
-      if (s.render === "dot") this.dot(copy, qx, qy, qx - px, qy - py, markR * fade, al * fade, op, d, rects);
-      else if (s.render === "line" || s.render === "ribbon") this.segment(px, py, qx, qy, markR * fade, al * fade, op, d.pressure, rects);
-      else {
-        p.run += moved;
-        const gap = Math.max(markR * 2, size * (0.05 + s.interval));
-        while (p.run >= gap) {
-          p.run -= gap;
-          p.bead++;
-          const t = moved > 0 ? 1 - p.run / Math.max(moved, 1e-6) : 1;
-          const bx = px + (qx - px) * Math.min(1, Math.max(0, t));
-          const by = py + (qy - py) * Math.min(1, Math.max(0, t));
-          this.dot(copy, bx, by, qx - px, qy - py, markR * (0.7 + 0.6 * (p.bead % 3 / 2)) * fade, al * fade, op, d, rects);
-        }
-      }
+  }
+  medium.deposit(rect, cov, s.opacity, [r, g, b], null, field);
+  return rect;
+}
+function drawArtSticker(medium, s, art) {
+  const rect = stickerRect(s);
+  const n = rect.width * rect.height;
+  const cov = new Float32Array(n);
+  const field = new Float32Array(n * 3);
+  const a = s.rotation * Math.PI / 180;
+  const ca = Math.cos(a);
+  const sa = Math.sin(a);
+  const scale = Math.max(art.width, art.height) / s.size;
+  const [r, g, b] = hexRgb(s.color);
+  const px = [0, 0, 0, 0];
+  for (let yy = 0, p = 0; yy < rect.height; yy++) {
+    for (let xx = 0; xx < rect.width; xx++, p++) {
+      const dx = rect.x + xx + 0.5 - s.x;
+      const dy = rect.y + yy + 0.5 - s.y;
+      const ax = (dx * ca + dy * sa) * scale + art.width / 2;
+      const ay = (-dx * sa + dy * ca) * scale + art.height / 2;
+      if (ax < -1 || ay < -1 || ax > art.width + 1 || ay > art.height + 1) continue;
+      sampleArt(art, ax, ay, px);
+      if (!(px[3] > 0)) continue;
+      cov[p] = px[3];
+      field[p * 3] = art.tintable ? r : px[0];
+      field[p * 3 + 1] = art.tintable ? g : px[1];
+      field[p * 3 + 2] = art.tintable ? b : px[2];
     }
-    if (s.render === "ribbon" && !(d.index === 0 && s.kind !== "flow")) this.ribbon(copy, list, op, al, d, rects);
-    if (s.kind === "flow" && list.length > 512) {
-      list = list.filter((p) => p.alive);
-      this.sets[copy] = list;
+  }
+  medium.deposit(rect, cov, s.opacity, [r, g, b], null, field);
+  return rect;
+}
+function jitterColor(hex2, amount, seed, i) {
+  const [r, g, b] = hexRgb(hex2);
+  const lch = oklabToOklch(rgbToOklab({ r, g, b, a: 1 }));
+  const l = Math.min(1, Math.max(0, lch.l + (rand01(seed, i, 61) - 0.5) * amount * 0.3));
+  const h = lch.h + (rand01(seed, i, 63) - 0.5) * amount * 80;
+  const at = (c) => oklabToRgb(oklchToOklab({ l, c, h, alpha: 1 }));
+  const inGamut = (o) => [o.r, o.g, o.b].every((v) => v >= -1e-4 && v <= 1 + 1e-4);
+  let out = at(lch.c);
+  if (!inGamut(out)) {
+    let lo = 0;
+    let hi = lch.c;
+    for (let k = 0; k < 12; k++) {
+      const mid = (lo + hi) / 2;
+      if (inGamut(at(mid))) lo = mid;
+      else hi = mid;
     }
+    out = at(lo);
   }
-  /** A dot (or bead): round, or a textured stamp turned by the particle's motion (mx, my), at random or to the tip angle. */
-  dot(copy, x, y, mx, my, r, alpha, opacity, d, rects) {
-    const s = this.s;
-    const textures = s.dotTextures;
-    if (!textures.length) return this.mark(x, y, r, alpha, opacity, d.pressure, rects);
-    const n = this.dots[copy]++;
-    const pick = s.dotTextureOrder === "random" ? Math.min(textures.length - 1, Math.floor(rand01(this.seed, n, 31 + copy) * textures.length)) : n % textures.length;
-    const rotation = s.dotRotation === "random" ? rand01(this.seed, n, 37 + copy) * Math.PI * 2 : s.dotRotation === "follow" ? mx || my ? Math.atan2(my, mx) : -d.direction : -this.brush.tip.angle * Math.PI / 180;
-    this.stamp(x, y, r, textures[pick], rotation, this.seed + n * 2654435761 >>> 0, alpha, opacity, d.pressure, rects);
+  return "#" + [out.r, out.g, out.b].map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join("");
+}
+var StickerSpray = class {
+  constructor(init) {
+    this.init = init;
+    const b = init.brush;
+    this.smoother = new PenSmoother(b.tip.smoothing, b.pressureSmoothing);
+    this.copies = init.copies.length ? init.copies : [IDENTITY_COPY];
+    const spacing = Math.max(0.05, 1 / Math.max(0.05, b.sticker.density * 4));
+    const walk = { ...b, tip: { ...b.tip, spacing }, dynamics: { ...b.dynamics, scatter: 0, sizeJitter: 0, angleJitter: 0 } };
+    this.walkers = this.copies.map((c, i) => new PenDabWalker(walk, init.seed + i * 7919 | 0, c.linear));
+    this.medium = new TileMedium(init.target, {});
+    this.next = init.nextId;
   }
-  /**
-   * Ribbon fill for one step: the band between each pair of joined particles, from where they
-   * were drawn last step to where they are drawn now. Bands of one step, and of consecutive steps,
-   * share edges exactly, so the fill has no seams; it is telescoped into the coverage
-   * (`telescope`), so it does not build up at the joins.
-   */
-  ribbon(copy, list, opacity, alpha, d, rects) {
-    const s = this.s;
-    if (!(s.ribbonFill > 0)) return;
-    const live = (p) => !!p && p.alive && !Number.isNaN(p.px);
-    let order;
-    if (s.kind === "flow") order = list.filter(live);
-    else order = this.orders[copy].map((i) => list[i]).filter(live);
-    if (order.length < 2) return;
-    const pairs = [];
-    if (s.ribbonPairs === "first-last") pairs.push([order[0], order[order.length - 1]]);
-    else for (let i = 0; i + 1 < order.length; i++) pairs.push([order[i], order[i + 1]]);
-    const pts = this.pts;
-    const ceil = Math.min(1, opacity * s.ribbonFill);
-    for (const [a, b] of pairs) {
-      pts.length = 0;
-      pts.push(a.px, a.py, a.dx, a.dy, b.dx, b.dy, b.px, b.py);
-      let x0 = Infinity;
-      let y0 = Infinity;
-      let x1 = -Infinity;
-      let y1 = -Infinity;
-      for (let i = 0; i < 8; i += 2) {
-        x0 = Math.min(x0, pts[i]);
-        x1 = Math.max(x1, pts[i]);
-        y0 = Math.min(y0, pts[i + 1]);
-        y1 = Math.max(y1, pts[i + 1]);
-      }
-      const rect = { x: Math.floor(x0), y: Math.floor(y0), width: Math.floor(x1) - Math.floor(x0) + 1, height: Math.floor(y1) - Math.floor(y0) + 1 };
-      const area = this.scratch(rect.width * rect.height);
-      addPolygonArea(pts, rect, area, Math.min(a.fade, b.fade) * alpha);
-      if (this.telescope(rect, area)) this.lay(rect, area, ceil, d.pressure, (a.dx + b.dx) / 2, (a.dy + b.dy) / 2, rects);
+  init;
+  dabCount = 0;
+  stickers = [];
+  /** Refs the spray picked but could not draw because their art had not loaded. */
+  skipped = /* @__PURE__ */ new Set();
+  smoother;
+  walkers;
+  copies;
+  medium;
+  lastRaw = null;
+  lastFed = null;
+  next;
+  push(points) {
+    const rects = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        this.walkers[i].push(c.map(p), dabs);
+        for (const d of dabs) this.drop(d, rects);
+      });
     }
+    return rects;
   }
-  /**
-   * Turns the area newly filled over `rect` into coverage to lay towards the fill's ceiling: the
-   * share of what was left unfilled, so after any number of bands (in any grouping) a pixel's
-   * coverage is the ceiling times the area filled there. False when nothing was added.
-   */
-  telescope(rect, area) {
-    let any = false;
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      const gy = rect.y + yy;
-      const ty = Math.floor(gy / TILE);
-      let t;
-      let tx = NaN;
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        const add = area[k];
-        if (!(add > 0)) continue;
-        const gx = rect.x + xx;
-        const ntx = Math.floor(gx / TILE);
-        if (ntx !== tx || !t) {
-          tx = ntx;
-          const key = tileKey(tx, ty);
-          t = this.filled.get(key);
-          if (!t) {
-            t = new Float32Array(TILE * TILE);
-            this.filled.set(key, t);
-          }
-        }
-        const ti = (gy - ty * TILE) * TILE + (gx - tx * TILE);
-        const before = t[ti];
-        const after = Math.min(1, before + add);
-        t[ti] = after;
-        area[k] = before < 1 ? (after - before) / (1 - before) : 0;
-        any = true;
-      }
+  finish() {
+    const rects = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    this.copies.forEach((c, i) => {
+      const dabs = [];
+      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.walkers[i].push(c.map({ ...raw, pressure: fed.pressure }), dabs);
+      this.walkers[i].finish(dabs);
+      for (const d of dabs) this.drop(d, rects);
+    });
+    return rects;
+  }
+  drop(d, rects) {
+    const st = this.init.brush.sticker;
+    const i = this.next;
+    const seed = this.init.seed;
+    const size = d.radius * 2 * (1 - st.sizeJitter * 0.7 * rand01(seed, i, 51));
+    const off = st.scatter * d.radius * 2;
+    const a = rand01(seed, i, 53) * Math.PI * 2;
+    const dist = rand01(seed, i, 55) * off;
+    const base = this.colorAt(d, Math.cos(a) * dist, Math.sin(a) * dist);
+    if (!(base.alpha > 0)) {
+      this.next++;
+      return;
+    }
+    const ref2 = st.stamps[Math.floor(rand01(seed, i, 57) * st.stamps.length)] ?? "editor:dot";
+    const stamp = stickerStamp({ ref: ref2 });
+    if (!stamp && !this.init.art?.(ref2)) {
+      this.skipped.add(ref2);
+      this.next++;
+      return;
+    }
+    const sticker = {
+      id: `st${this.next++}`,
+      ref: ref2,
+      ...stamp ? { stamp } : {},
+      x: Math.round((d.x + Math.cos(a) * dist) * 100) / 100,
+      y: Math.round((d.y + Math.sin(a) * dist) * 100) / 100,
+      size: Math.max(2, Math.round(size * 10) / 10),
+      rotation: Math.round((-d.angle * 180 / Math.PI + (rand01(seed, i, 59) * 2 - 1) * 180 * st.rotationJitter) * 10) / 10,
+      color: st.colorJitter > 0 ? jitterColor(base.color, st.colorJitter, seed, i) : base.color,
+      opacity: Math.round(Math.min(1, d.opacity * this.init.brush.tip.opacity * base.alpha) * 1e3) / 1e3,
+      seed: Math.floor(rand01(seed, i, 65) * 1e9)
+    };
+    this.stickers.push(sticker);
+    rects.push(drawSticker(this.medium, sticker, this.init.art));
+    this.dabCount++;
+  }
+  sampler;
+  /** A sticker's colour: the paint colour, or gradient paint at its dab (`dx`, `dy` from the dab's centre). */
+  colorAt(d, dx, dy) {
+    const effect = this.init.effect;
+    if (effect) {
+      const rgb = [0, 0, 0];
+      const alpha = sampleEffectAt(effect, d.x + dx, d.y + dy, rgb, d);
+      return { color: "#" + rgb.map((c) => Math.round(c * 255).toString(16).padStart(2, "0")).join(""), alpha };
+    }
+    const g = this.init.paint;
+    if (!g) return { color: this.init.color, alpha: 1 };
+    this.sampler ??= new PaintGradientSampler(g, this.init.seed);
+    const s = g.map.by === "across-tip" ? this.sampler.sample(((dx * Math.sin(d.direction) + dy * Math.cos(d.direction)) / Math.max(0.5, d.radius) + 1) / 2) : this.sampler.dab(d);
+    return { color: "#" + s.rgb.map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join(""), alpha: s.alpha };
+  }
+};
+function renderStickers(stickers, target, art) {
+  const medium = new TileMedium(target, {});
+  for (const s of stickers) drawSticker(medium, s, art);
+}
+function normalizeStickerUpdate(u) {
+  const out = {};
+  if (u.ref !== void 0 && u.stamp !== void 0) throw new Error("Give ref or stamp, not both (stamp is the older name for an editor stamp).");
+  if (u.stamp !== void 0) {
+    if (!STAMP_KINDS.includes(u.stamp)) throw new Error(`stamp ${JSON.stringify(u.stamp)} is not a stamp; use ${STAMP_KINDS.join(", ")}, or ref for any sticker (find_stickers).`);
+    out.ref = `editor:${u.stamp}`;
+    out.stamp = u.stamp;
+  }
+  if (u.ref !== void 0) {
+    out.ref = normalizeStickerRef(u.ref);
+    const stamp = stickerStamp({ ref: out.ref });
+    if (stamp) out.stamp = stamp;
+    else out.stamp = void 0;
+  }
+  for (const k of ["x", "y"]) if (u[k] !== void 0) {
+    if (!Number.isFinite(u[k])) throw new Error(`${k} must be a number of pixels.`);
+    out[k] = u[k];
+  }
+  if (u.size !== void 0) {
+    if (!(u.size >= 2 && u.size <= 2048)) throw new Error(`size ${u.size} is out of range; use 2..2048 px.`);
+    out.size = u.size;
+  }
+  if (u.rotation !== void 0) {
+    if (!Number.isFinite(u.rotation)) throw new Error("rotation must be degrees.");
+    out.rotation = u.rotation;
+  }
+  if (u.color !== void 0) {
+    if (!/^#[0-9a-f]{6}$/i.test(u.color)) throw new Error(`color ${JSON.stringify(u.color)} must be #rrggbb.`);
+    out.color = u.color.toLowerCase();
+  }
+  if (u.opacity !== void 0) {
+    if (!(u.opacity >= 0 && u.opacity <= 1)) throw new Error(`opacity ${u.opacity} is out of range; use 0..1.`);
+    out.opacity = u.opacity;
+  }
+  return out;
+}
+function stickerSurface(stickers, base, dirty, art) {
+  const only = base && dirty ? new Set(dirty.flatMap((r) => tilesInRect(r).map(({ tx, ty }) => tileKey(tx, ty)))) : null;
+  const live = /* @__PURE__ */ new Map();
+  let scratch = null;
+  const target = {
+    offset: { x: 0, y: 0 },
+    lockTransparency: false,
+    selection: null,
+    readTile: (tx, ty) => live.get(tileKey(tx, ty)) ?? null,
+    writeTile: (tx, ty) => {
+      const k = tileKey(tx, ty);
+      if (only && !only.has(k)) return (scratch ??= new Uint8ClampedArray(TILE * TILE * 4)).fill(0);
+      let t = live.get(k);
+      if (!t) live.set(k, t = new Uint8ClampedArray(TILE * TILE * 4));
+      return t;
     }
-    return any;
+  };
+  const reaches = (s) => !only || tilesInRect(stickerRect(s)).some(({ tx, ty }) => only.has(tileKey(tx, ty)));
+  renderStickers(stickers.filter(reaches), target, art);
+  const tiles = /* @__PURE__ */ new Map();
+  if (only && base) {
+    for (const [k, t] of base.tiles) if (!only.has(k)) tiles.set(k, t);
   }
-};
-var BristleStroke = class extends MarkStroke {
-  tufts;
-  s;
-  constructor(brush, options) {
-    super(brush, options);
-    this.s = brush.bristle;
-    const s = this.s;
-    this.tufts = this.copies.map(
-      (_, c) => Array.from({ length: s.count }, (_2, i) => {
-        const a = rand01(this.seed, i, 21 + c) * Math.PI * 2;
-        const r = Math.sqrt(rand01(this.seed, i, 23 + c));
-        return {
-          u: Math.cos(a) * r,
-          v: Math.sin(a) * r,
-          x: 0,
-          y: 0,
-          paint: 1 - s.jitter * 0.4 * rand01(this.seed, i, 25 + c),
-          thirst: 1 + s.jitter * (rand01(this.seed, i, 27 + c) * 2 - 1),
-          w: 1 + s.jitter * 0.6 * (rand01(this.seed, i, 29 + c) - 0.5),
-          started: false
-        };
-      })
-    );
+  for (const [k, d] of live) {
+    const t = finishTile(d, 4, 0);
+    if (t) tiles.set(k, t);
   }
-  advance(copy, d, rects) {
-    const s = this.s;
-    const tuft = this.tufts[copy];
-    const spread = d.radius * (0.55 + 0.9 * s.splay * d.pressure);
-    const ca = Math.cos(d.angle);
-    const sa = Math.sin(d.angle);
-    const ro = Math.max(0.15, d.roundness);
-    const tx = Math.cos(d.direction);
-    const ty = -Math.sin(d.direction);
-    const follow = 0.15 + 0.85 * s.stiffness;
-    const bend = d.radius * (1 - s.stiffness) * d.pressure * 0.8;
-    const lineR = Math.max(0.5, d.radius * 2 * s.thickness * 0.5);
-    const dryRate = 4e-3 * (1 - s.load);
-    for (const b of tuft) {
-      const lu = b.u * spread;
-      const lv = b.v * spread * ro;
-      const ox = lu * ca - lv * sa;
-      const oy = -(lu * sa + lv * ca);
-      const lag = bend * (1 - 0.5 * b.v);
-      const wx = d.x + ox - tx * lag;
-      const wy = d.y + oy - ty * lag;
-      if (!b.started) {
-        b.x = wx;
-        b.y = wy;
-        b.started = true;
-        continue;
-      }
-      const nx = b.x + (wx - b.x) * follow;
-      const ny = b.y + (wy - b.y) * follow;
-      const paint = Math.max(0, b.paint);
-      if (paint > 0.02) this.segment(b.x, b.y, nx, ny, lineR * b.w * (0.6 + 0.4 * d.pressure), d.alpha * Math.min(1, paint * 1.4), d.opacity, d.pressure, rects);
-      b.paint -= dryRate * b.thirst * Math.hypot(nx - b.x, ny - b.y);
-      b.x = nx;
-      b.y = ny;
+  return new TiledSurface(4, tiles, 0);
+}
+function stickerAt(stickers, x, y, art) {
+  for (let i = stickers.length - 1; i >= 0; i--) {
+    const s = stickers[i];
+    const rad2 = s.size / 2;
+    const a = s.rotation * Math.PI / 180;
+    const dx = x - s.x;
+    const dy = y - s.y;
+    const u = (dx * Math.cos(a) + dy * Math.sin(a)) / rad2;
+    const v = (-dx * Math.sin(a) + dy * Math.cos(a)) / rad2;
+    if (Math.abs(u) > 1.05 || Math.abs(v) > 1.05) continue;
+    if (s.size < 16) return s;
+    const kind = stickerStamp(s);
+    if (kind) {
+      if (stampCoverage(kind, u, v, s.seed) > 0.25) return s;
+      continue;
     }
+    const pic = art?.(s.ref);
+    if (!pic) return s;
+    const scale = Math.max(pic.width, pic.height) / 2;
+    if (sampleArt(pic, u * scale + pic.width / 2, v * scale + pic.height / 2, [0, 0, 0, 0])[3] > 0.25) return s;
   }
-};
+  return null;
+}
 
 // src/paint-editor/stroke.ts
 function defaultTile(surface) {
@@ -2861,7 +2961,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
         effect
       });
     } else {
-      const opts = { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies, paint: init.paint ?? null, effect };
+      const opts = { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies, paint: init.paint ?? null, effect, stampArt: init.stampArt };
       this.dry = brush.engine === "particle" ? new ParticleStroke(brush, opts) : brush.engine === "bristle" ? new BristleStroke(brush, opts) : new DryStroke(brush, opts);
     }
   }
@@ -2897,7 +2997,7 @@ var PaintStrokeSession = 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 +3006,14 @@ var PaintStrokeSession = 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 +4561,8 @@ var PaintWetLayers = class {
     this.gpu = null;
   }
 };
-function wetPigmentOf(hex, body) {
-  const [r, g, b] = hexToRgb8(hex);
+function wetPigmentOf(hex2, body) {
+  const [r, g, b] = hexToRgb8(hex2);
   return Array.from(pigmentOf([r / 255, g / 255, b / 255], body));
 }
 
@@ -4934,8 +5034,8 @@ var MixingPad = class {
       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 = emptySurface(4);
@@ -4996,8 +5096,8 @@ var MixingPad = class {
       paints2.map((p) => p.parts)
     );
     const core = normalizePaintBrush({ 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 +5799,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,6 +5853,13 @@ var PaintEditorController = class _PaintEditorController {
   stickerPreview = null;
   encodeImage;
   listeners = /* @__PURE__ */ new Set();
+  commitListeners = /* @__PURE__ */ new Set();
+  /** Origins set by `withOrigin`, innermost last. */
+  origins = [];
+  /** `group` in progress: commits fold into one step, recorded when it ends. */
+  grouping = null;
+  /** `previewPaint` in progress: nothing is emitted or recorded. */
+  previewing = false;
   version = 0;
   cached = null;
   session = null;
@@ -5824,6 +5931,7 @@ var PaintEditorController = class _PaintEditorController {
     void this.refreshBrushes().catch(() => void 0);
     this.pendingBrushId = start.brush.id === wanted ? null : wanted;
     this.color = options.color ? parseColor(options.color) : "#1f2937";
+    this.colorScheme = options.colorScheme === "dark" ? "dark" : "light";
     this.hand = options.hand === "left" ? "left" : "right";
     this.encodeImage = options.encodeImage;
     this.guides = defaultGuides(this.doc.canvas);
@@ -5860,7 +5968,125 @@ var PaintEditorController = 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 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 = findLayer(this.doc.layers, layer.id)?.layer;
+      const surface = found && isPixelLayer(found) ? found.surface : null;
+      const bounds = surface ? contentBounds(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: readRegion(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++;
@@ -5877,6 +6103,8 @@ var PaintEditorController = class _PaintEditorController {
       brush: this.brush,
       brushes: this.library ??= this.brushEntries.map((e) => e.brush),
       color: this.color,
+      colorScheme: this.colorScheme,
+      colorLocked: this.colorLocked,
       secondaryColor: this.secondaryColor,
       paint: this.gradient ?? { type: "color", color: this.color },
       effectPaint: this.effectPaintPending ?? this.effectPaint,
@@ -5943,7 +6171,13 @@ var PaintEditorController = 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 +6188,7 @@ var PaintEditorController = class _PaintEditorController {
     this.doc = next;
     this.docRevision++;
     this.trimWetHistory();
+    this.notifyCommit({ kind: "execute", label, origin: entry.origin });
     this.emit();
   }
   /**
@@ -5962,7 +6197,7 @@ var PaintEditorController = 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 +6205,7 @@ var PaintEditorController = 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. */
@@ -6039,6 +6275,7 @@ var PaintEditorController = 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 +6294,7 @@ var PaintEditorController = 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;
   }
@@ -7004,6 +7242,7 @@ var PaintEditorController = class _PaintEditorController {
     if (changes.paint !== void 0 && changes.paint !== null) this.readStrokePaint(changes.paint);
     const unchanged = !Object.keys(changes).length;
     const next = normalizePaintBrush({ ...changes, id: base.id }, base);
+    if (entry) this.takeBrushColour(entry.spec);
     this.useBrush(next, unchanged ? baseSpec : brushSpecOf(next, baseSpec), unchanged && base.builtin === true);
     return this.brush;
   }
@@ -7020,6 +7259,7 @@ var PaintEditorController = class _PaintEditorController {
     const base = copyJSON(entry ? entry.spec : this.brushSpec);
     for (const k of unset) delete base[k];
     const spec = this.readBrushPatch(base, patch, problems);
+    if (entry || patch.colour?.default !== void 0) this.takeBrushColour(spec);
     this.useBrush(unchanged && entry ? entry.brush : resolveBrush(spec), spec, unchanged && entry?.builtin === true);
     return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
   }
@@ -7069,7 +7309,8 @@ var PaintEditorController = class _PaintEditorController {
     this.brushSpec = { ...copyJSON(spec), id: next.id, name: next.name };
     this.pendingBrushId = null;
     this.emit([]);
-    if (next.engine === "sticker" && next.sticker.stamps.some((r) => !editorStampOf(r))) void this.prepareStickers(next.sticker.stamps).catch(() => this.emit([]));
+    const refs = brushStickerRefs(next);
+    if (refs.length) void this.prepareStickers(refs).catch(() => this.emit([]));
   }
   /**
    * Saves the active brush (or `brush`, engine settings on top of it) into the brush library under
@@ -7114,9 +7355,54 @@ var PaintEditorController = class _PaintEditorController {
     return renderBrushThumbnail(b, { paper: this.doc.paper, width: options.width, height: options.height, color: options.color ? parseColor(options.color) : this.color });
   }
   // --- Colour --------------------------------------------------------------------
+  colorScheme;
+  colorLocked = false;
+  /** The brush default colour the paint colour came from (resolved again when the scheme changes), or `null`. */
+  brushColour = null;
+  /**
+   * The host's colour scheme: a paint colour that came from a brush's light / dark default
+   * resolves to the new side. Editor state, not an undo step.
+   */
+  setColorScheme(scheme) {
+    const next = scheme === "dark" ? "dark" : "light";
+    if (next === this.colorScheme) return;
+    this.colorScheme = next;
+    const hex2 = this.brushColour ? brushColourHex(this.brushColour, next) : null;
+    if (hex2) this.color = hex2;
+    this.emit([]);
+  }
+  /** Locks the paint colour: choosing a brush with a default colour keeps it. Editor state, not an undo step. */
+  setColorLocked(locked) {
+    if (this.colorLocked === locked) return;
+    this.colorLocked = locked;
+    this.emit([]);
+  }
+  /**
+   * After the user chooses a brush: its solid or light / dark default colour becomes the paint
+   * colour (resolved for the colour scheme), unless the colour is locked. Gradient defaults are the
+   * brush's own paint already; effect defaults stay a suggestion.
+   */
+  takeBrushColour(spec) {
+    if (this.colorLocked) return;
+    const d = spec.colour?.default;
+    const hex2 = d !== void 0 ? brushColourHex(d, this.colorScheme) : null;
+    if (!hex2) return;
+    this.color = hex2;
+    this.gradient = null;
+    this.effectPaint = this.effectPaintPending = null;
+    this.paintEpoch++;
+    this.brushColour = d;
+  }
+  /** A brush that always paints its own colour (`colour.own`): that colour, resolved for the scheme now; else `null`. */
+  ownColour(brushId) {
+    const spec = brushId !== void 0 ? this.findEntry(brushId)?.spec : this.brushSpec;
+    const d = spec?.colour?.own ? spec.colour.default : void 0;
+    return d !== void 0 ? brushColourHex(d, this.colorScheme) : null;
+  }
   /** Sets the paint colour (and goes back to one colour from gradient paint). */
   setColor(color) {
     this.color = parseColor(color);
+    this.brushColour = null;
     this.gradient = null;
     this.effectPaint = this.effectPaintPending = null;
     this.paintEpoch++;
@@ -7263,6 +7549,7 @@ var PaintEditorController = class _PaintEditorController {
       return l;
     })();
     const brush = this.strokeBrush(init);
+    if (this.previewing && isWetBrush(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).`);
@@ -7299,7 +7586,7 @@ var PaintEditorController = class _PaintEditorController {
       this.beginWetOp();
       const world = this.wet.ensureLane(layer.id, brush.wet.medium);
       const id = layer.id;
-      const wetColor = init.color === void 0 ? this.color : parseColor(init.color);
+      const wetColor = init.color === void 0 ? this.ownColour(init.brushId) ?? this.color : parseColor(init.color);
       const [r, g, b] = hexToRgb8(wetColor);
       const wetGradient = this.strokeGradient(init, brush, wetColor);
       const load = init.load ?? brushLoadForStroke(brush, this.mixerLoad, [r / 255, g / 255, b / 255]);
@@ -7327,7 +7614,7 @@ var PaintEditorController = class _PaintEditorController {
       const dried = findLayer(this.doc.layers, layer.id).layer;
       layer = dried;
     }
-    let color = init.color === void 0 ? this.color : parseColor(init.color);
+    let color = init.color === void 0 ? this.ownColour(init.brushId) ?? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
     if (init.color === void 0 && init.start && tracing?.visible && tracing.sampleColors) color = this.sampleTracingColor(init.start.x, init.start.y) ?? color;
     const perspective = this.guides.perspective;
@@ -7366,6 +7653,7 @@ var PaintEditorController = class _PaintEditorController {
       // 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), art: this.stickerArt.get } : void 0,
+      stampArt: this.stickerArt.get,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
     });
@@ -9566,6 +9854,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 PresenceStore {
@@ -10786,8 +11081,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;
@@ -11133,18 +11428,24 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "set_color",
     title: "Set the paint colour",
-    description: "Sets the paint colour (and optionally the second colour) that strokes and fills use by default. Setting color goes back to one colour from gradient paint (set_paint) or effect paint (set_effect_paint). Editor state, not an undo step. Returns both colours.",
+    description: "Sets the paint colour (and optionally the second colour) that strokes and fills use by default, and whether it is locked. Choosing a brush with a default colour (set_brush id, e.g. the highlighter's yellow) makes that the paint colour unless the colour is locked; a brush with colour.own always paints its own. Setting color goes back to one colour from gradient paint (set_paint) or effect paint (set_effect_paint). Editor state, not an undo step. Returns both colours and locked.",
     inputSchema: {
       type: "object",
-      properties: { color: { ...COLOR3, description: "Paint colour #rrggbb." }, secondaryColor: { ...COLOR3, description: "Second colour #rrggbb." } },
+      properties: {
+        color: { ...COLOR3, description: "Paint colour #rrggbb." },
+        secondaryColor: { ...COLOR3, description: "Second colour #rrggbb." },
+        locked: { type: "boolean", description: "Lock the paint colour: brushes chosen later keep it instead of taking their default colour (default: unchanged; the editor starts unlocked)." }
+      },
       additionalProperties: false
     },
     annotations: { title: "Set the paint colour", ...SET4 },
-    handler: ({ color, secondaryColor }) => {
+    handler: ({ color, secondaryColor, locked }) => {
+      if (color === void 0 && secondaryColor === void 0 && locked === void 0) throw new Error("Pass color, secondaryColor or locked.");
       if (color !== void 0) c.setColor(color);
       if (secondaryColor !== void 0) c.setSecondaryColor(secondaryColor);
+      if (locked !== void 0) c.setColorLocked(locked);
       const s = c.getState();
-      return { color: s.color, secondaryColor: s.secondaryColor };
+      return { color: s.color, secondaryColor: s.secondaryColor, locked: s.colorLocked };
     }
   });
   add({
@@ -11226,7 +11527,10 @@ 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 ((brush?.engine ?? base?.engine) === "sticker") await c.prepareStickers(brush?.sticker?.stamps ?? base?.sticker.stamps ?? []);
+      if (base) {
+        const refs = brushStickerRefs(normalizePaintBrush({ ...brush ?? {}, id: base.id }, base));
+        if (refs.length) await c.prepareStickers(refs);
+      }
       const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
       const r = await act({ kind: "stroke", stroke }, () => c.paintStroke(stroke));
       return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
@@ -11603,6 +11907,7 @@ function strokeSummary(s, withPoints, live) {
 function createPaintBrushLibraryToolProvider(controller, options = {}) {
   return createBrushLibraryToolProvider(controller.brushLibrary, {
     profile: PAINT_PROFILE,
+    stickers: () => controller.stickers.provider,
     ...options,
     renderPreview: (brush, { width, height, color }) => {
       const t = renderBrushThumbnail(resolveBrush(brush), { paper: controller.getState().document.paper, width, height, color: color.toLowerCase() });
@@ -12405,6 +12710,392 @@ function createPaintEditorDocument(controller, options = {}) {
     readOnly: () => controller.busyReason() ?? false
   });
 }
+
+// src/paint-editor/collaboration.ts
+var LAYER_FIELDS = ["name", "visible", "opacity", "blend"];
+function createPaintChangeFeed(controller, options = {}) {
+  const now = 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: doc.paintEvents?.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 = 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: commit?.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 = options.now ?? (() => Date.now());
+  const maxPoints = options.maxPoints ?? 4e3;
+  let seq = 0;
+  const makeId = 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 (!input.title?.trim()) 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 = 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 (!op.points?.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(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 (!op.strokeIds?.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 * (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: op.opacity ?? 0.35, grain: 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: input.place ?? "top",
+    ...input.layerId ? { layerId: input.layerId } : {},
+    ...input.layerName ? { layerName: input.layerName } : {}
+  });
+  const topLayerId = () => controller.listLayers().find((l) => l.parentId === null)?.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: 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: 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 = context.actor?.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: 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]
+  };
+}
 export {
   BACKLIGHT_SPILL,
   BLEND_MENU_GROUPS,
@@ -12429,6 +13120,7 @@ export {
   DEFAULT_PAINT_GRADIENT_MAPPING,
   DEFAULT_PAPER,
   DEFAULT_PARTICLE,
+  DEFAULT_SPRAY,
   DEFAULT_STICKER,
   DEFAULT_SWATCHES,
   DEFAULT_VIEW,
@@ -12565,12 +13257,15 @@ export {
   composeAffine,
   contactSheet,
   createPaintBrushLibraryToolProvider,
+  createPaintChangeFeed,
   createPaintCompositor,
   createPaintDocument,
   createPaintEditorDocument,
   createPaintEditorToolProvider,
   createPaintEffectsToolProvider,
   createPaintLayer,
+  createPaintProposalToolProvider,
+  createPaintProposals,
   createPaintReplayTools,
   createPaintStickerTools,
   createPaintThickTools,
@@ -12655,6 +13350,7 @@ export {
   padSampleRadius,
   paintGradientMappingFor,
   paintPlaybackPanel,
+  paintProposalGhost,
   paintSourceColor,
   paintSourceCss,
   paintToMultiColor,