@pixerate/editor 0.251.0 → 0.253.0

package/dist/paint-editor/index.js

@@ -4,6 +4,24 @@ import {
   describeStickerRef,
   editorStickers
 } from "../chunk-WZOGDKCQ.js";
+import {
+  BRUSH_PATCH_PROPERTIES,
+  BRUSH_PRESETS,
+  BRUSH_SLIDERS,
+  BRUSH_UNSET_PROPERTY,
+  BrushLibraryError,
+  PAINT_PROFILE,
+  brushEngineControls,
+  closest,
+  createBrushLibrary,
+  createBrushLibraryToolProvider,
+  mergeBrushPatch,
+  migrateBrushV1,
+  multiColorSliders,
+  normalizeBrushSpec,
+  patchBrushValue,
+  resolveBrush
+} from "../chunk-QPHNVZHO.js";
 import {
   toVideoFfmpeg
 } from "../chunk-5E2Q7ZHI.js";
@@ -154,7 +172,6 @@ import {
   DEFAULT_PAINT_GRADIENT_MAPPING,
   EMPTY_MIXER_LOAD,
   MAX_BRUSH_SIZE,
-  MIXING_MODELS,
   PAINT_COLOR_JSON_SCHEMA,
   PAINT_GRADIENT_FULL_SPEED,
   PAINT_GRADIENT_JSON_SCHEMA,
@@ -3326,6 +3343,19 @@ function readLoad(raw) {
   if (!reservoir && !pickup) return null;
   return { reservoir, amount: reservoir && finite2(r.amount) ? Math.min(1, Math.max(0, r.amount)) : 0, pickup };
 }
+function readStrokeBrush(raw) {
+  if (raw && typeof raw === "object" && "kind" in raw && !("engine" in raw)) {
+    try {
+      return resolveBrush(normalizeBrushSpec(raw));
+    } catch {
+    }
+  }
+  return normalizePaintBrush(raw ?? {});
+}
+function strokeToJSON(stroke) {
+  const { brush, ...rest } = stroke;
+  return { ...JSON.parse(JSON.stringify(rest)), brush: migrateBrushV1(brush) };
+}
 function normalizeBrushStroke(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
@@ -3335,7 +3365,7 @@ function normalizeBrushStroke(raw) {
   const out = {
     id: r.id,
     layerId: r.layerId,
-    brush: normalizePaintBrush(r.brush ?? {}),
+    brush: readStrokeBrush(r.brush),
     color: typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : "#000000",
     points,
     seed: finite2(r.seed) ? r.seed | 0 : 0
@@ -3515,7 +3545,7 @@ function downsampleRgba(data, width, height, tw, th) {
 
 // src/paint-editor/serialize.ts
 var PAINT_FORMAT = "pixerate-paint";
-var PAINT_SCHEMA_VERSION = 1;
+var PAINT_SCHEMA_VERSION = 2;
 var KNOWN = /* @__PURE__ */ new Set(["format", "version", "width", "height", "dpi", "paper", "layers", "assets", "activeLayerId", "strokes", "guides", "swatches", "mixingPad", "wet", "wetEvents", "paintEvents", "origin"]);
 function documentExtensions(raw) {
   const out = {};
@@ -3533,7 +3563,7 @@ function header(state, options) {
     paper: { ...state.paper, dry: { ...state.paper.dry }, wet: { ...state.paper.wet } },
     activeLayerId: state.activeLayerId
   };
-  if (options.strokes !== false && state.strokes.length) out.strokes = JSON.parse(JSON.stringify(state.strokes));
+  if (options.strokes !== false && state.strokes.length) out.strokes = state.strokes.map(strokeToJSON);
   if (options.guides !== void 0) out.guides = JSON.parse(JSON.stringify(options.guides));
   if (options.swatches !== void 0) out.swatches = JSON.parse(JSON.stringify(options.swatches));
   if (options.mixingPad !== void 0) out.mixingPad = JSON.parse(JSON.stringify(options.mixingPad));
@@ -4921,10 +4951,10 @@ var MixingPad = class {
    * mixed colour's scattering is re-estimated from its luminance, so repeated small mixes favour
    * the lighter paint (see GOTCHAS).
    */
-  mix(paints, options = {}) {
-    if (!paints.length || paints.length > 8) throw new Error(`Give 1 to 8 paints to mix; got ${paints.length}.`);
-    const total = paints.reduce((n, p) => n + p.parts, 0);
-    paints.forEach((p, i) => {
+  mix(paints2, options = {}) {
+    if (!paints2.length || paints2.length > 8) throw new Error(`Give 1 to 8 paints to mix; got ${paints2.length}.`);
+    const total = paints2.reduce((n, p) => n + p.parts, 0);
+    paints2.forEach((p, i) => {
       if (!(Number.isFinite(p.parts) && p.parts >= 0)) throw new Error(`paints[${i}].parts is ${p.parts}; use a number \u2265 0.`);
     });
     if (!(total > 0)) throw new Error("Every paint has 0 parts; give at least one paint parts above 0.");
@@ -4939,7 +4969,7 @@ var MixingPad = class {
     }
     const bounds = { x: Math.floor(cx - R), y: Math.floor(cy - R), width: Math.ceil(2 * R), height: Math.ceil(2 * R) };
     if (options.clear !== false) this.surface = writeRegion(this.surface, bounds, new Uint8ClampedArray(bounds.width * bounds.height * 4));
-    const used = paints.filter((p) => p.parts > 0);
+    const used = paints2.filter((p) => p.parts > 0);
     const area = Math.PI * (0.7 * R) ** 2;
     used.forEach((p, i) => {
       const r = Math.sqrt(area * (p.parts / total) / Math.PI);
@@ -4962,8 +4992,8 @@ var MixingPad = class {
       this.run(knife, stir, "#000000");
     }
     const mixed = mixPigments(
-      paints.map((p) => hexToRgb8(p.color).map((v) => v / 255)),
-      paints.map((p) => p.parts)
+      paints2.map((p) => hexToRgb8(p.color).map((v) => v / 255)),
+      paints2.map((p) => p.parts)
     );
     const core = 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("");
@@ -5001,6 +5031,79 @@ var MixingPad = class {
   }
 };
 
+// src/paint-editor/brush-library.ts
+var copyJSON = (v) => JSON.parse(JSON.stringify(v));
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function libraryBrush(spec, builtin, resolved) {
+  const brush = resolved ? normalizePaintBrush(resolved, resolved) : resolveBrush(spec);
+  if (builtin) brush.builtin = true;
+  else delete brush.builtin;
+  return { spec, brush, builtin };
+}
+var builtins = null;
+function builtinLibraryBrushes() {
+  return builtins ??= BRUSH_PRESETS.map((spec) => {
+    const resolved = BUILTIN_BRUSHES.find((b) => b.id === spec.id);
+    return libraryBrush(spec, true, resolved);
+  });
+}
+function seededStorage(brushes) {
+  if (!brushes.length) return void 0;
+  let stored = JSON.stringify({ format: "pixerate-brushes", version: 1, brushes: brushes.map(brushToJSON) });
+  return {
+    get: async () => stored,
+    set: async (_key, value) => {
+      stored = value;
+    }
+  };
+}
+var paints = (b) => {
+  const { category: _c, builtin: _b, ...rest } = b;
+  return JSON.stringify(rest);
+};
+function brushSpecOf(next, from) {
+  const plain = migrateBrushV1(next);
+  const out = copyJSON(plain);
+  if (from.description) out.description = from.description;
+  if (from.tags?.length) out.tags = [...from.tags];
+  if (out.kind === "mark" && from.kind === "mark") {
+    if (from.medium) out.medium = from.medium;
+    if (from.variety) out.variety = from.variety;
+  }
+  const colour = { ...from.colour ?? {} };
+  if (plain.colour?.default !== void 0) colour.default = plain.colour.default;
+  else if (isObject(colour.default) && colour.default.type === "gradient") delete colour.default;
+  if (Object.keys(colour).length) out.colour = copyJSON(colour);
+  else delete out.colour;
+  if ((out.light?.amount ?? 0) > 0 && (from.light?.spill || from.light?.glow !== void 0)) {
+    out.light = { ...out.light, ...from.light.spill ? { spill: { ...from.light.spill } } : {}, ...from.light.glow !== void 0 ? { glow: from.light.glow } : {} };
+  }
+  if (from.motion?.live !== void 0 || from.motion?.fps !== void 0) {
+    out.motion = { ...out.motion ?? {}, ...from.motion.live !== void 0 ? { live: from.motion.live } : {}, ...from.motion.fps !== void 0 ? { fps: from.motion.fps } : {} };
+  }
+  try {
+    const hinted = normalizeBrushSpec(out, []);
+    if (paints(resolveBrush(hinted)) === paints(resolveBrush(plain))) return hinted;
+  } catch {
+  }
+  return plain;
+}
+function engineChanges(base, next) {
+  const diff = (a, b) => {
+    if (isObject(a) && isObject(b)) {
+      const out = {};
+      for (const k of Object.keys(b)) {
+        const d = diff(a[k], b[k]);
+        if (d !== void 0) out[k] = d;
+      }
+      return Object.keys(out).length ? out : void 0;
+    }
+    return JSON.stringify(a) === JSON.stringify(b) ? void 0 : copyJSON(b);
+  };
+  const { id: _i, builtin: _b, ...rest } = diff(base, next) ?? {};
+  return rest;
+}
+
 // src/paint-editor/live-strokes.ts
 var LIVE_STROKE_ENGINES = ["dab", "particle", "bristle", "mixer"];
 function liveStrokeRefusal(brush) {
@@ -5583,6 +5686,13 @@ var PaintEditorError = class extends Error {
     this.name = "PaintEditorError";
   }
 };
+async function libraryCall(call) {
+  try {
+    return await call();
+  } catch (e) {
+    throw e instanceof BrushLibraryError ? new PaintEditorError(e.message) : e;
+  }
+}
 var HEX3 = /^#[0-9a-f]{6}$/i;
 var MAX_ADD_STICKERS = 500;
 function parseColor(value, what = "color") {
@@ -5610,8 +5720,17 @@ var PaintEditorController = class _PaintEditorController {
   undoStack = [];
   redoStack = [];
   historyLimit;
+  /** The brush library this editor lists, saves into and paints from (shared with other editors when the host passes one). */
+  brushLibrary;
   brush;
-  userBrushes;
+  /** The active brush as facets (what `getBrushSpec` and saving use). */
+  brushSpec;
+  /** The library's brushes as last read, each as stored (facets) and as the engine paints it. */
+  brushEntries;
+  /** The brush id asked for at construction, while the library had not listed it yet. */
+  pendingBrushId = null;
+  brushesLoaded = Promise.resolve();
+  unsubscribeLibrary;
   /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
   library = null;
   color;
@@ -5693,9 +5812,17 @@ var PaintEditorController = class _PaintEditorController {
     this.rasterizeSticker = options.rasterizeSticker ?? defaultStickerRasterizer;
     if (options.stickers) this.stickers.set(options.stickers);
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
-    this.userBrushes = (options.brushes ?? []).map((b) => normalizePaintBrush({ ...b, builtin: false }));
-    const start = this.findBrush(options.brushId ?? DEFAULT_BRUSH_ID) ?? this.findBrush(DEFAULT_BRUSH_ID);
-    this.brush = normalizePaintBrush(start);
+    const seed = (options.brushes ?? []).map((b) => normalizePaintBrush({ ...b, builtin: false }));
+    this.brushLibrary = options.brushLibrary ?? createBrushLibrary({ storage: seededStorage(seed) });
+    this.brushEntries = [...builtinLibraryBrushes(), ...seed.map((b) => libraryBrush(migrateBrushV1(b), false, b))];
+    const wanted = options.brushId ?? DEFAULT_BRUSH_ID;
+    const start = this.findEntry(wanted) ?? this.findEntry(DEFAULT_BRUSH_ID);
+    this.brush = normalizePaintBrush(start.brush);
+    this.brushSpec = copyJSON(start.spec);
+    this.unsubscribeLibrary = this.brushLibrary.subscribe(() => void this.refreshBrushes().catch(() => void 0));
+    if (options.brushLibrary && seed.length) void this.brushLibrary.importFile(seed.map(brushToJSON)).catch(() => void 0);
+    void this.refreshBrushes().catch(() => void 0);
+    this.pendingBrushId = start.brush.id === wanted ? null : wanted;
     this.color = options.color ? parseColor(options.color) : "#1f2937";
     this.hand = options.hand === "left" ? "left" : "right";
     this.encodeImage = options.encodeImage;
@@ -5748,7 +5875,7 @@ var PaintEditorController = class _PaintEditorController {
     this.cached = {
       document: this.doc,
       brush: this.brush,
-      brushes: this.library ??= [...BUILTIN_BRUSHES, ...this.userBrushes],
+      brushes: this.library ??= this.brushEntries.map((e) => e.brush),
       color: this.color,
       secondaryColor: this.secondaryColor,
       paint: this.gradient ?? { type: "color", color: this.color },
@@ -6730,9 +6857,9 @@ var PaintEditorController = class _PaintEditorController {
    * Renders effect paints that are not rendered yet (strokes and replays need them rendered
    * first, since strokes are synchronous). Throws naming the effect and provider when one cannot be.
    */
-  async prepareEffectPaints(paints) {
+  async prepareEffectPaints(paints2) {
     const seen = /* @__PURE__ */ new Set();
-    for (const p of paints) {
+    for (const p of paints2) {
       const key = effectPaintKey(p);
       if (seen.has(key)) continue;
       seen.add(key);
@@ -6742,8 +6869,8 @@ var PaintEditorController = class _PaintEditorController {
   /** Renders the effect paints of recorded strokes (default all of them) before a replay. */
   async prepareStrokeEffects(strokeIds) {
     const ids = strokeIds ? new Set(strokeIds) : null;
-    const paints = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && s.paint?.type === "effect").map((s) => s.paint);
-    await this.prepareEffectPaints(paints);
+    const paints2 = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && s.paint?.type === "effect").map((s) => s.paint);
+    await this.prepareEffectPaints(paints2);
   }
   /** A small preview of the effect paint (a PNG data URL `size` px wide), or `null` without a rendered one. */
   effectPaintThumbnail(size = 48) {
@@ -6824,100 +6951,162 @@ var PaintEditorController = class _PaintEditorController {
     return { layerId: now.id, source: this.sourceOf(d, values, options.time), amount };
   }
   // --- Brushes -------------------------------------------------------------------
+  findEntry(id) {
+    return this.brushEntries.find((e) => e.brush.id === id);
+  }
   findBrush(id) {
-    return BUILTIN_BRUSHES.find((b) => b.id === id) ?? this.userBrushes.find((b) => b.id === id);
+    return this.findEntry(id)?.brush;
+  }
+  requireEntry(id) {
+    const e = this.findEntry(id);
+    if (!e) throw new PaintEditorError(`Unknown brush "${id}". ${closest(id, this.brushEntries.map((x) => x.brush.id))}Call list_brush_presets for the ids.`);
+    return e;
+  }
+  requireBrush(id) {
+    return this.requireEntry(id).brush;
   }
-  /** A library brush by id (`undefined` when unknown). */
+  /** Reads the library again (after a change anywhere it is shared). */
+  refreshBrushes() {
+    const run = this.brushLibrary.list().then((entries) => {
+      this.brushEntries = entries.map((e) => libraryBrush(e.brush, e.builtin));
+      this.library = null;
+      const pending = this.pendingBrushId;
+      this.pendingBrushId = null;
+      if (pending && this.findEntry(pending)) this.setBrush({ id: pending });
+      else this.emit([]);
+    });
+    this.brushesLoaded = run.catch(() => void 0);
+    return run;
+  }
+  /** Resolves once the brush library has been read (user brushes kept in storage are listed from then on). */
+  whenBrushesLoaded() {
+    return this.brushesLoaded;
+  }
+  /** A library brush by id, as the engine paints it (`undefined` when unknown). */
   getBrush(id) {
     const b = this.findBrush(id);
     return b ? normalizePaintBrush(b, b) : void 0;
   }
-  requireBrush(id) {
-    const b = this.findBrush(id);
-    if (!b) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
-    return b;
+  /** A library brush by id as stored (its facets), or without an id the active brush as edited. */
+  getBrushSpec(id) {
+    const spec = id === void 0 ? this.brushSpec : this.findEntry(id)?.spec;
+    return spec ? copyJSON(spec) : void 0;
   }
   /**
-   * Chooses the active brush (`id`: a library brush) and / or changes its settings. Editor state,
-   * not an undo step. Returns the active brush.
+   * Chooses the active brush (`id`: a library brush) and / or changes its engine settings. Editor
+   * state, not an undo step. Returns the active brush. `setBrushFacets` changes it by facets.
    */
   setBrush(update = {}) {
     const { id, ...changes } = update;
-    const base = id !== void 0 ? this.requireBrush(id) : this.brush;
+    const entry = id !== void 0 ? this.requireEntry(id) : null;
+    const base = entry ? entry.brush : this.brush;
+    const baseSpec = entry ? entry.spec : this.brushSpec;
     if (changes.paint !== void 0 && changes.paint !== null) this.readStrokePaint(changes.paint);
+    const unchanged = !Object.keys(changes).length;
     const next = normalizePaintBrush({ ...changes, id: base.id }, base);
-    if (base.builtin && !Object.keys(changes).length) next.builtin = true;
+    this.useBrush(next, unchanged ? baseSpec : brushSpecOf(next, baseSpec), unchanged && base.builtin === true);
+    return this.brush;
+  }
+  /**
+   * Chooses the active brush (`id`: a library brush) and / or lays a facet patch over it (objects
+   * merge, lists and values replace, as the library's `update_brush` does). Editor state, not an
+   * undo step. `unset` removes whole facets first. Returns the active brush as the engine paints
+   * it, its facets, and what was clamped or dropped.
+   */
+  setBrushFacets(patch = {}, id, unset = []) {
+    const entry = id !== void 0 ? this.requireEntry(id) : null;
+    const unchanged = !Object.keys(patch).length && !unset.length;
+    const problems = [];
+    const base = copyJSON(entry ? entry.spec : this.brushSpec);
+    for (const k of unset) delete base[k];
+    const spec = this.readBrushPatch(base, patch, problems);
+    this.useBrush(unchanged && entry ? entry.brush : resolveBrush(spec), spec, unchanged && entry?.builtin === true);
+    return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
+  }
+  /**
+   * Makes `spec` (a whole facet brush, as the brush editor edits it) the active brush, keeping the
+   * active brush's id. Editor state, not an undo step. Returns it as the engine paints it, its
+   * facets, and what was clamped or dropped.
+   */
+  setBrushSpec(spec) {
+    const problems = [];
+    const paint = spec.colour?.default;
+    if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
+    let next;
+    try {
+      next = normalizeBrushSpec({ ...spec, id: this.brush.id }, problems);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    this.useBrush(resolveBrush(next), next, false);
+    return { brush: this.brush, spec: copyJSON(this.brushSpec), problems };
+  }
+  /**
+   * The engine settings a facet patch changes on a brush (`from`: a library brush id or a brush as
+   * painted; default the active brush), as `paintStroke`'s and `updateStroke`'s `brush` take them.
+   */
+  brushChanges(patch, from) {
+    const entry = typeof from === "string" ? this.requireEntry(from) : null;
+    const base = entry ? entry.brush : typeof from === "object" ? normalizePaintBrush(from, from) : this.brush;
+    const spec = entry ? entry.spec : typeof from === "object" ? migrateBrushV1(base) : this.brushSpec;
+    return engineChanges(base, resolveBrush(this.readBrushPatch(spec, patch, [])));
+  }
+  readBrushPatch(base, patch, problems) {
+    const { id: _id, name, ...rest } = patch;
+    const paint = rest.colour?.default;
+    if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") this.readStrokePaint(paint);
+    try {
+      return normalizeBrushSpec(mergeBrushPatch(base, { ...rest, ...name !== void 0 ? { name } : {} }), problems);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+  }
+  useBrush(next, spec, builtin) {
+    next = normalizePaintBrush(next, next);
+    if (builtin) next.builtin = true;
     else delete next.builtin;
     this.brush = next;
+    this.brushSpec = { ...copyJSON(spec), id: next.id, name: next.name };
+    this.pendingBrushId = null;
     this.emit([]);
     if (next.engine === "sticker" && next.sticker.stamps.some((r) => !editorStampOf(r))) void this.prepareStickers(next.sticker.stamps).catch(() => this.emit([]));
-    return this.brush;
   }
-  /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
-  saveBrush(options) {
+  /**
+   * Saves the active brush (or `brush`, engine settings on top of it) into the brush library under
+   * `id` / `name`, replacing a user brush with that id. Built-in ids are refused. Resolves with the
+   * saved brush.
+   */
+  async saveBrush(options) {
     if (!BRUSH_ID.test(options.id)) throw new PaintEditorError(`Brush id "${options.id}" is invalid; use lowercase letters, digits and dashes (e.g. "my-pencil").`);
-    if (BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
-    const source = options.brush ? normalizePaintBrush(options.brush, this.brush) : this.brush;
-    const saved = normalizePaintBrush({ ...source, id: options.id, name: options.name ?? source.name });
-    delete saved.builtin;
-    const i = this.userBrushes.findIndex((b) => b.id === options.id);
-    if (i >= 0) this.userBrushes[i] = saved;
-    else this.userBrushes.push(saved);
-    this.library = null;
-    this.emit([]);
-    return saved;
-  }
-  removeBrush(id) {
-    if (BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
-    const i = this.userBrushes.findIndex((b) => b.id === id);
-    if (i < 0) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
-    this.userBrushes.splice(i, 1);
-    this.library = null;
-    this.emit([]);
-  }
-  /** The user's saved brushes. */
+    if (this.brushLibrary.isBuiltin(options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
+    const spec = options.brush ? brushSpecOf(normalizePaintBrush(options.brush, this.brush), this.brushSpec) : this.brushSpec;
+    const { brush } = await libraryCall(() => this.brushLibrary.save({ ...spec, id: options.id, name: options.name ?? spec.name }, { overwrite: true }));
+    await this.refreshBrushes();
+    return this.requireBrush(brush.id);
+  }
+  /** Removes a user brush from the brush library (built-in brushes can't be removed). */
+  async removeBrush(id) {
+    if (this.brushLibrary.isBuiltin(id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
+    if (!await libraryCall(() => this.brushLibrary.remove(id))) throw new PaintEditorError(`Unknown brush "${id}". Call list_brush_presets for the ids.`);
+    await this.refreshBrushes();
+  }
+  /** The user's saved brushes, as the engine paints them. */
   getUserBrushes() {
-    return this.userBrushes.map((b) => normalizePaintBrush(b, b));
+    return this.brushEntries.filter((e) => !e.builtin).map((e) => normalizePaintBrush(e.brush, e.brush));
   }
-  /** A brush library file of the given brushes (default: the user's brushes). */
+  /** A brush library file (version 2) of the given brushes (default: the user's brushes). */
   exportBrushes(ids) {
-    const list = ids ? ids.map((id) => this.requireBrush(id)) : this.userBrushes;
-    return { format: "pixerate-brushes", version: 1, brushes: list.map(brushToJSON) };
+    return libraryCall(() => this.brushLibrary.exportFile(ids));
   }
   /**
-   * Adds the brushes of a library file to the user library. A brush whose id is taken is skipped
-   * unless `replace` (built-in ids are always skipped). Returns the ids added and the problems.
+   * Adds the brushes of a library file (version 1 or 2) to the brush library. A brush whose id is
+   * taken is skipped unless `replace` (built-in ids are always skipped). Resolves with the ids
+   * added or replaced, the ids skipped and the problems.
    */
-  importBrushes(file, options = {}) {
-    const problems = [];
-    let list;
-    try {
-      list = parseBrushLibrary(file, problems);
-    } catch (e) {
-      throw new PaintEditorError(e.message);
-    }
-    const added = [];
-    const skipped = [];
-    for (const b of list) {
-      if (BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
-        skipped.push(b.id);
-        problems.push(`"${b.id}" is a built-in brush id; rename it to import it.`);
-        continue;
-      }
-      const i = this.userBrushes.findIndex((x) => x.id === b.id);
-      if (i >= 0 && !options.replace) {
-        skipped.push(b.id);
-        continue;
-      }
-      if (i >= 0) this.userBrushes[i] = b;
-      else this.userBrushes.push(b);
-      added.push(b.id);
-    }
-    if (added.length) {
-      this.library = null;
-      this.emit([]);
-    }
-    return { added, skipped, problems };
+  async importBrushes(file, options = {}) {
+    const r = await libraryCall(() => this.brushLibrary.importFile(file, { overwrite: !!options.replace }));
+    await this.refreshBrushes();
+    return { added: [...r.added, ...r.replaced], skipped: r.skipped, problems: r.problems };
   }
   /** A thumbnail of a brush: a test stroke on the current paper. */
   brushThumbnail(id, options = {}) {
@@ -7076,7 +7265,7 @@ var PaintEditorController = class _PaintEditorController {
     const brush = this.strokeBrush(init);
     const effect = this.strokeEffect(init, brush);
     if (brush.light.amount > 0) {
-      if (brush.engine === "sticker") throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take light yet; paint light with a dab or particle light brush (list_brushes category light), or set light.amount to 0 (set_brush).`);
+      if (brush.engine === "sticker") throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take light yet; paint light with a dab or particle light brush (glow-gel, neon-marker; list_brush_presets lists them), or set light.amount to 0 (set_brush).`);
     }
     if (doc.liveStrokes?.[layer.id]) {
       const why = liveStrokeRefusal(brush);
@@ -7507,7 +7696,8 @@ var PaintEditorController = class _PaintEditorController {
     const w = Math.round(width * scale);
     const h = Math.round(height * scale);
     if (w > 16384 || h > 16384) throw new PaintEditorError(`At scale ${scale} the canvas would be ${w}\xD7${h}; the limit is 16384 px per side. Use a smaller scale.`);
-    const target = new _PaintEditorController({ width: w, height: h, dpi: dpi * scale, brushes: this.userBrushes, wet: this.wetOptions });
+    const target = new _PaintEditorController({ width: w, height: h, dpi: dpi * scale, brushLibrary: this.brushLibrary, wet: this.wetOptions });
+    target.brushEntries = this.brushEntries;
     const paper = { ...this.doc.paper, scale: Math.min(8, this.doc.paper.scale * scale) };
     target.adopt({ state: { canvas: target.doc.canvas, paper, layers: emptiedLayers(this.doc.layers), activeLayerId: this.doc.activeLayerId, strokes: [] }, extensions: {}, problems: [] });
     target.lighting = { ...this.lighting };
@@ -7562,6 +7752,7 @@ var PaintEditorController = class _PaintEditorController {
   }
   /** Stops the wet simulation's worker threads (call when the editor goes away). */
   dispose() {
+    this.unsubscribeLibrary();
     this.wet.destroy();
     this.effectsRenderer.dispose();
     this.effectPaintPixels.clear();
@@ -7942,7 +8133,7 @@ var PaintEditorController = class _PaintEditorController {
     if (Object.keys(stickers).length) ext.stickers = stickers;
     else delete ext.stickers;
     const liveStrokes = {};
-    for (const [id, list] of Object.entries(this.doc.liveStrokes ?? {})) if (findLayer(this.doc.layers, id)) liveStrokes[id] = list.map((x) => JSON.parse(JSON.stringify(x)));
+    for (const [id, list] of Object.entries(this.doc.liveStrokes ?? {})) if (findLayer(this.doc.layers, id)) liveStrokes[id] = list.map(strokeToJSON);
     if (Object.keys(liveStrokes).length) ext.liveStrokes = liveStrokes;
     else delete ext.liveStrokes;
     const light = {};
@@ -8415,7 +8606,7 @@ var PaintEditorController = class _PaintEditorController {
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
     const stickers = this.doc.stickers?.[l.id];
-    if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (list_brushes category sticker).`);
+    if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (sticker-stars; list_brush_presets lists them).`);
     return { layer: l, stickers };
   }
   // --- The sticker library ---------------------------------------------------------
@@ -9145,8 +9336,8 @@ var PaintEditorController = class _PaintEditorController {
    * and a fully mixed core of the Kubelka-Munk mix (see `MixingPad.mix`). With `setColor` the
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
-  mixOnPad(paints, options = {}) {
-    const parsed = (paints ?? []).map((p, i) => ({ color: parseColor(p?.color, `paints[${i}].color`), parts: p?.parts }));
+  mixOnPad(paints2, options = {}) {
+    const parsed = (paints2 ?? []).map((p, i) => ({ color: parseColor(p?.color, `paints[${i}].color`), parts: p?.parts }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -10140,7 +10331,7 @@ function createPaintGuideTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Mix paints on the pad", ...WRITE2 },
-      handler: ({ paints, x, y, radius, passes, clear, setColor }) => c.mixOnPad(paints, { x, y, radius, passes, clear, setColor })
+      handler: ({ paints: paints2, x, y, radius, passes, clear, setColor }) => c.mixOnPad(paints2, { x, y, radius, passes, clear, setColor })
     },
     {
       name: "save_mixing_pad",
@@ -10571,254 +10762,6 @@ var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint:
 var EMPTY3 = { type: "object", properties: {}, additionalProperties: false };
 var COLOR3 = { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: 'Colour #rrggbb, e.g. "#2a4b8d".' };
 var LAYER_ID4 = { type: "string", description: "Layer id from list_layers (default the active layer)." };
-var TIP = {
-  type: "object",
-  description: "The tip (the shared brush engine). Missing fields keep their current values.",
-  properties: {
-    size: { type: "number", minimum: 1, maximum: MAX_BRUSH_SIZE, description: "Diameter in pixels." },
-    hardness: { type: "number", minimum: 0, maximum: 1, description: "Edge hardness, 0 (soft) .. 1 (hard)." },
-    spacing: { type: "number", minimum: 0.01, maximum: 10, description: "Dab spacing as a fraction of the diameter (0.05 is smooth, 1 is dotted)." },
-    angle: { type: "number", minimum: -360, maximum: 360, description: "Tip angle in degrees, counter-clockwise; with rotation stroke or barrel it is added to the stroke direction or pen rotation." },
-    roundness: { type: "number", minimum: 0.01, maximum: 1, description: "Tip roundness: 1 round, lower is a flat ellipse (a pastel or chisel tip)." },
-    opacity: { type: "number", minimum: 0, maximum: 1, description: "Stroke opacity ceiling: overlapping dabs never exceed it." },
-    flow: { type: "number", minimum: 0, maximum: 1, description: "Build-up per dab towards the opacity (low flow builds up softly, like an airbrush)." },
-    smoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Position smoothing of the input, 0..0.95." },
-    pressureSize: { type: "boolean", description: "Pressure scales the size (down to dynamics.minSize)." },
-    pressureOpacity: { type: "boolean", description: "Pressure scales the opacity." },
-    blend: {
-      type: "string",
-      enum: BLEND_MODES.map((m) => m.id),
-      description: "How paint combines with the layer. pigment mixes it in like real paint (blue into yellow gives green); multiply darkens like marker ink; watercolor glazes like a transparent wash; tint, highlight and shadow recolour, light and shade (see list_blend_modes)."
-    }
-  },
-  additionalProperties: false
-};
-var DYNAMICS = {
-  type: "object",
-  description: "Pen dynamics and jitter. Missing fields keep their current values.",
-  properties: {
-    minSize: { type: "number", minimum: 0, maximum: 1, description: "Size at zero pressure as a fraction of the full size (when pressureSize)." },
-    pressureFlow: { type: "number", minimum: 0, maximum: 1, description: "How much pressure scales flow." },
-    tiltSize: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down widens the tip (up to 2.5\xD7)." },
-    tiltRoundness: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down flattens the tip along the tilt (side-of-the-pencil shading)." },
-    tiltOpacity: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down lightens the mark." },
-    velocitySize: { type: "number", minimum: -1, maximum: 1, description: "Positive grows the tip on fast strokes, negative thins it (needs point times t)." },
-    velocityOpacity: { type: "number", minimum: -1, maximum: 1, description: "Positive darkens fast marks, negative lightens them (needs point times t)." },
-    sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change per dab." },
-    angleJitter: { type: "number", minimum: 0, maximum: 1, description: "Random angle per dab, as a fraction of \xB1180\xB0." },
-    opacityJitter: { type: "number", minimum: 0, maximum: 1, description: "Random opacity drop per dab." },
-    scatter: { type: "number", minimum: 0, maximum: 4, description: "Random offset across the stroke, in diameters." }
-  },
-  additionalProperties: false
-};
-var MIXER = {
-  type: "object",
-  description: "Mixer engine settings (the Mixer Brush). Missing fields keep their current values.",
-  properties: {
-    wet: { type: "number", minimum: 0, maximum: 1, description: "Pick-up ratio: how much canvas colour each dab picks up, 0 (dry) .. 1." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "How much paint the reservoir holds; below 1 it drains per dab, so long strokes run dry." },
-    mix: { type: "number", minimum: 0, maximum: 1, description: "Mix ratio: how far each dab's paint moves from the reservoir towards the picked-up colour." },
-    loadEachStroke: { type: "boolean", description: "Refill the reservoir with the colour before each stroke." },
-    cleanEachStroke: { type: "boolean", description: "Empty the pickup well after each stroke." },
-    mixing: { type: "string", enum: [...MIXING_MODELS], description: "rgb: RGB averages. pigment: mixes like paint (Kubelka-Munk)." }
-  },
-  additionalProperties: false
-};
-var MIXING = { type: "string", enum: [...MIXING_MODELS], description: "pigment: mixes like paint (Kubelka-Munk, blue and yellow make green); rgb: straight RGB averages." };
-var BEHAVIOR = {
-  type: "object",
-  description: "How the brush handles paint on the canvas (dab and mixer engines; on a mixer brush pickup, mix, dirty and mixing are its mixer wet, mix, !cleanEachStroke and mixing). Missing fields keep their current values.",
-  properties: {
-    pickup: { type: "number", minimum: 0, maximum: 1, description: "Pick-up ratio 0..1: how much of the paint under each dab the brush lifts and carries along (0: none, a dry brush)." },
-    mix: { type: "number", minimum: 0, maximum: 1, description: "Mix ratio 0..1: how much of the carried paint goes into what the brush lays down, against the brush's own colour (scaled by pickup)." },
-    dirty: { type: "boolean", description: "Dirty brush: keep the carried paint after the stroke, so the next stroke starts with the last colour it touched (needs pickup above 0). clean_mixer_brush wipes it." },
-    mixing: MIXING,
-    multicolor: {
-      type: "object",
-      description: "Multi-coloured brush (the older form of paint, the brush's own gradient: tip is across-tip, dab is distance in dabs or random). Read back from paint when it has a multi-colour equivalent. Missing fields keep their current values.",
-      properties: {
-        mode: { type: "string", enum: [...MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
-        colors: { type: "array", maxItems: 8, items: { ...COLOR3 }, description: "2..8 colours #rrggbb; fewer than 2 uses the paint colour and the secondary colour." },
-        order: { type: "string", enum: ["sequence", "random"], description: "dab mode: sequence runs through the colours in order, blending between them; random picks one per run of dabs (seeded)." },
-        length: { type: "integer", minimum: 1, maximum: 500, description: "dab mode: dabs per colour (default 12)." },
-        softness: { type: "number", minimum: 0, maximum: 1, description: "How softly neighbouring colours blend: 0 hard stripes or steps, 1 a smooth gradient." }
-      },
-      additionalProperties: false
-    }
-  },
-  additionalProperties: false
-};
-var BRUSH_PAINT = {
-  description: `The brush's own gradient paint, used instead of the editor's paint (null: the editor's paint). It is what the multi-colour settings became; stops may be "paint" / "secondary" for the editor's two colours.`,
-  anyOf: [PAINT_GRADIENT_JSON_SCHEMA, { type: "null", description: "No gradient of its own: the editor's paint." }]
-};
-var BLENDER = {
-  type: "object",
-  description: "Blender engine settings. Missing fields keep their current values.",
-  properties: {
-    strength: { type: "number", minimum: 0, maximum: 1, description: "How far each pixel under the tip moves towards the mix of the paint near it, per dab." },
-    distance: { type: "number", minimum: 0, maximum: 1, description: "Blend distance: how far away colours are mixed in, as a fraction of the tip diameter (0.35 default; higher blends wider and softer)." },
-    mixing: MIXING
-  },
-  additionalProperties: false
-};
-var SMUDGE = {
-  type: "object",
-  description: "Smudge engine settings. Missing fields keep their current values.",
-  properties: {
-    strength: { type: "number", minimum: 0, maximum: 1, description: "How strongly the dragged paint covers what is under the tip, per dab." },
-    length: { type: "number", minimum: 0, maximum: 1, description: "How far paint is dragged: the share of the carried paint kept from dab to dab (0.85 default; 1 drags it the whole stroke)." },
-    mixing: { ...MIXING, description: "rgb (default): smeared colours average; pigment: they mix like paint." }
-  },
-  additionalProperties: false
-};
-var WET_BRUSH = {
-  type: "object",
-  description: "Wet engine settings (watercolour, gouache and the wet tools). Missing fields keep their current values.",
-  properties: {
-    tool: {
-      type: "string",
-      enum: [...WET_TOOLS],
-      description: "paint: water and pigment (picks up and mixes wet paint by behavior.pickup / mix); water: clear water (with rewet it lifts dried paint); dry: a hair dryer, takes water; blow: pushes the water along the stroke; blend: evens out wet pigment; smudge: drags wet paint; blot: a tissue, takes wet paint up (erase wet)."
-    },
-    medium: { type: "string", enum: [...WET_MEDIA], description: "The medium: watercolor, gouache or oil. A layer takes the medium's wet settings the first time it holds wet paint (oil: thick, barely flows, stays wet long and blends into the wet paint it meets)." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (each stroke reloads)." },
-    thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner (water or solvent): more transparent, runnier paint." },
-    water: { type: "number", minimum: 0, maximum: 1, description: "Wetness: water laid per stroke, 0.2 a damp brush .. 1 a dripping one." },
-    pigment: { type: "number", minimum: 0, maximum: 1, description: "Pigment concentration: 0 clear water .. 1 straight from the tube." },
-    body: { type: "number", minimum: 0, maximum: 1, description: "Body: 0 a transparent watercolour (glazes) .. 1 opaque gouache (hides what is under it)." },
-    strength: { type: "number", minimum: 0, maximum: 1, description: "Strength of dry, blow, blend, smudge and blot." },
-    rewet: { type: "number", minimum: 0, maximum: 1, description: "How much dried paint the water lifts again: 0 none (staining) .. 1." }
-  },
-  additionalProperties: false
-};
-var IMPASTO_BRUSH = {
-  type: "object",
-  description: "Impasto engine settings (thick paint with relief, lit by set_lighting). Missing fields keep their current values.",
-  properties: {
-    tool: {
-      type: "string",
-      enum: [...IMPASTO_TOOLS],
-      description: "brush: thick paint with bristle ridges along the stroke; tube: blobs squeezed from the tube; knife: a palette knife that scrapes the relief flat and smears the paint; roller: a flat stippled band; gloop: a thick, glossy, rounded bead."
-    },
-    thickness: { type: "number", minimum: 0, maximum: 1, description: "How far the paint stands up." },
-    gloss: { type: "number", minimum: 0, maximum: 1, description: "Shine: 0 matte .. 1 wet-looking gloss." },
-    metallic: { type: "number", minimum: 0, maximum: 1, description: "Metallic paint: highlights take the paint colour (gold, copper, silver)." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the stroke thins and fades as the brush empties." },
-    thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner: flatter, more transparent paint." },
-    drag: { type: "number", minimum: 0, maximum: 1, description: "Knife and brush: how much of the paint under the tool is dragged along." },
-    rim: { type: "number", minimum: 0, maximum: 1, description: "Light paint (with light.amount): the bead's light is stronger where its surface turns away, as on backlit glass (default 0)." },
-    clarity: { type: "number", minimum: 0, maximum: 1, description: "Glassy paint: the middle of a bead lets the layers below show through while its edges stay solid (default 0). flatten_relief clears it." }
-  },
-  additionalProperties: false
-};
-var LIGHT_BRUSH = {
-  type: "object",
-  description: "Light paint: the light the brush lays with its colour, glowing in the paint's own colour and spilling onto its surroundings (set_light_spill). Dab, particle, bristle, Mixer Brush, impasto and wet paint brushes take it (wet light flows, pools, granulates and blooms with the pigment until the paint dries, then is ordinary light paint); wet tools other than paint lay none, and sticker brushes refuse light above 0. Missing fields keep their current values.",
-  properties: {
-    amount: { type: "number", minimum: 0, maximum: 1, description: "Light each dab lays, scaled by its coverage and flow (0 none, default; 1 full)." },
-    pressure: { type: "boolean", description: "Pressure scales the light (default false)." }
-  },
-  additionalProperties: false
-};
-var PARTICLE_BRUSH = {
-  type: "object",
-  description: "Particle engine settings (procedural brushes). Missing fields keep their current values.",
-  properties: {
-    kind: {
-      type: "string",
-      enum: [...PARTICLE_KINDS],
-      description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade; elastic: strands whose links keep a rest length, stretching when the pen is fast and snapping back; fuzzy: winding strings, each strand waving out of step with the others (always waves by at least 0.12 of the tip size)."
-    },
-    render: {
-      type: "string",
-      enum: [...PARTICLE_RENDERS],
-      description: "dot: a mark at each step (round, or dotTextures); line: each particle draws a continuous line; sequence: beads spaced along each path (round, or dotTextures); ribbon: the band between neighbouring particles' paths filled (ribbonFill), with the paths drawn as its edges at the mark size (flame, silk, smoke)."
-    },
-    count: { type: "integer", minimum: 1, maximum: 64, description: "Particles (flow: how many are thrown per tip of travel)." },
-    size: { type: "number", minimum: 0, maximum: 1, description: "Mark size as a fraction of the tip size (ribbon: the width of its edges)." },
-    spread: { type: "number", minimum: 0, maximum: 1, description: "How far apart the particles start, as a fraction of the tip size (ribbon: how wide it is)." },
-    stiffness: { type: "number", minimum: 0, maximum: 1, description: "Spring, string and elastic stiffness: stiff follows closely (elastic: snaps back faster), soft swings wide." },
-    damping: { type: "number", minimum: 0, maximum: 1, description: "How quickly motion dies down." },
-    speed: { type: "number", minimum: 0, maximum: 1, description: "Orbit and flow speed." },
-    gravity: { type: "number", minimum: -1, maximum: 1, description: "Pull downwards (negative: upwards)." },
-    life: { type: "number", minimum: 0, maximum: 1, description: "Flow particles: how long they live." },
-    interval: { type: "number", minimum: 0, maximum: 1, description: "Sequence: spacing of the beads." },
-    ribbonFill: { type: "number", minimum: 0, maximum: 1, description: "Ribbon: opacity of the fill between the paths, relative to their edges (default 0.5; 0 draws only the edges)." },
-    ribbonPairs: { type: "string", enum: [...RIBBON_PAIRS], description: "Ribbon: adjacent (default) joins each particle to its neighbour around the pen; first-last makes one band between the outermost two." },
-    waveAmplitude: { type: "number", minimum: 0, maximum: 1, description: "Wave: how far each particle's drawn place swings sideways to the stroke, as a fraction of the tip size (default 0: no wave). Works with every kind and render." },
-    waveLength: { type: "number", minimum: 4, maximum: 2e3, description: "Wave: wavelength in px of pen travel (default 60)." },
-    waveSpeed: { type: "number", minimum: 0, maximum: 1, description: "Wave: how fast the waves run, by stroke time (0 default: they stand still on the path; 1: about four a second, so slow strokes wave more). Strokes without times run at a nominal 0.5 px/ms." },
-    wavePhaseJitter: { type: "number", minimum: 0, maximum: 1, description: "Wave: how far out of step the particles' waves are (default 0: all in step, a wavy band; 1: random phases, tangled strands)." },
-    dotTextures: {
-      type: "array",
-      maxItems: MAX_DOT_TEXTURES,
-      items: { type: "string", enum: [...STAMP_KINDS], description: "A stamp." },
-      description: `Dot and sequence renders: up to ${MAX_DOT_TEXTURES} sticker stamps (list_stickers) drawn instead of round marks; repeats are allowed (they weight the order). Empty (default): round marks.`
-    },
-    dotTextureOrder: { type: "string", enum: [...DOT_TEXTURE_ORDERS], description: "Textured dots: sequence (default) uses the stamps in turn; random picks one per dot (seeded, so replays are exact)." },
-    dotRotation: { type: "string", enum: [...DOT_ROTATIONS], description: "Textured dots: follow turns each with its particle's motion; random (default) turns each at random; fixed uses the tip angle." }
-  },
-  additionalProperties: false
-};
-var BRISTLE_BRUSH = {
-  type: "object",
-  description: "Bristle engine settings: a tuft of bristles, each its own line. Missing fields keep their current values.",
-  properties: {
-    count: { type: "integer", minimum: 3, maximum: 128, description: "Bristles in the tuft." },
-    stiffness: { type: "number", minimum: 0, maximum: 1, description: "Stiff bristles follow the tip; soft ones lag and bend into curves at turns." },
-    splay: { type: "number", minimum: 0, maximum: 1, description: "How far pressure spreads the tuft." },
-    thickness: { type: "number", minimum: 0, maximum: 1, description: "Each bristle's line width as a fraction of the tip size." },
-    load: { type: "number", minimum: 0, maximum: 1, description: "Paint per bristle: 1 never runs dry; lower, bristles run out along the stroke (dry brush)." },
-    jitter: { type: "number", minimum: 0, maximum: 1, description: "Random variation between bristles." }
-  },
-  additionalProperties: false
-};
-var STICKER_BRUSH = {
-  type: "object",
-  description: "Sticker engine settings: stamps sprayed along the stroke as editable stickers. Missing fields keep their current values.",
-  properties: {
-    stamps: {
-      type: "array",
-      minItems: 1,
-      maxItems: MAX_STICKER_STAMPS,
-      items: { type: "string", minLength: 1, description: "A sticker ref provider:id from find_stickers (e.g. editor:star); a bare editor stamp (star) means editor:star." },
-      description: `The stickers to spray, one picked at random per sticker: refs from find_stickers (the editor's own: ${STAMP_KINDS.map((k) => `editor:${k}`).join(", ")}). Each is checked against the sticker library and an unknown ref is refused with the closest ones. A provider's sticker is drawn from its art (tinted to the paint colour when tintable), loaded before the stroke.`
-    },
-    density: { type: "number", minimum: 0, maximum: 1, description: "How closely stickers follow each other: about density \xD7 4 stickers per tip diameter of travel (0.25 \u2248 one per diameter, 1 \u2248 four). Default 0.4." },
-    sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change." },
-    rotationJitter: { type: "number", minimum: 0, maximum: 1, description: "Random turn as a fraction of \xB1180\xB0." },
-    scatter: { type: "number", minimum: 0, maximum: 2, description: "How far from the path stickers land, in tip diameters." },
-    colorJitter: { type: "number", minimum: 0, maximum: 1, description: "Random colour change around the paint colour: at 1, up to \xB140\xB0 of hue and \xB10.15 OKLab lightness, kept in gamut. Default 0.2." }
-  },
-  additionalProperties: false
-};
-var BRUSH_FIELDS = {
-  name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
-  category: { type: "string", enum: [...PAINT_BRUSH_CATEGORIES], description: "Library category." },
-  engine: {
-    type: "string",
-    enum: [...PAINT_BRUSH_ENGINES],
-    description: "dab: paints dabs (with behavior.pickup or gradient paint it paints dab by dab, lifting and mixing paint); eraser: removes paint; mixer: the Mixer Brush (a reservoir plus picked-up paint); blender: mixes the colours under and near the tip; smudge: drags paint along the stroke; wet: watercolour, gouache, oil and the wet tools on a simulated wet layer (see wet); impasto: thick paint with relief (see impasto); particle: procedural particle brushes (see particle); bristle: a tuft of bristles that bend and splay (see bristle); sticker: sprays editable sticker stamps (see sticker)."
-  },
-  tip: TIP,
-  grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Multiplied by the paper depth." },
-  pressureSmoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Pressure smoothing, separate from the tip position smoothing." },
-  rotation: { type: "string", enum: [...BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
-  dynamics: DYNAMICS,
-  mixer: MIXER,
-  loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for a mixer that only moves paint)." },
-  behavior: BEHAVIOR,
-  blender: BLENDER,
-  smudge: SMUDGE,
-  wet: WET_BRUSH,
-  impasto: IMPASTO_BRUSH,
-  particle: PARTICLE_BRUSH,
-  bristle: BRISTLE_BRUSH,
-  sticker: STICKER_BRUSH,
-  light: LIGHT_BRUSH,
-  paint: BRUSH_PAINT
-};
 var TIME = { type: "number", minimum: 0, description: "Draw live effect paint (strokes on stroke layers painted with live effect paint) this many ms into its animation (default: as painted, its own time)." };
 var POINTS = {
   type: "array",
@@ -10846,26 +10789,6 @@ function loadResult(load) {
   const hex = (c) => c ? "#" + c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("") : null;
   return { reservoir: hex(load.reservoir), amount: Math.round(load.amount * 1e3) / 1e3, pickup: hex(load.pickup) };
 }
-function brushSummary(b) {
-  return {
-    gradient: b.paint !== null,
-    id: b.id,
-    name: b.name,
-    category: b.category,
-    engine: b.engine,
-    size: b.tip.size,
-    grain: b.grain,
-    rotation: b.rotation,
-    wetCapable: isWetCapable(b),
-    pickup: b.behavior.pickup,
-    dirty: b.behavior.dirty,
-    multicolor: b.behavior.multicolor.mode,
-    ...b.engine === "wet" ? { wetTool: b.wet.tool, medium: b.wet.medium } : {},
-    ...b.engine === "impasto" ? { impastoTool: b.impasto.tool } : {},
-    ...b.light.amount > 0 ? { light: b.light.amount } : {},
-    builtin: Boolean(b.builtin)
-  };
-}
 function createPaintEditorToolProvider(controller, options = {}) {
   const c = typeof controller === "function" ? lazyController(controller) : controller;
   const tools = [];
@@ -11180,121 +11103,31 @@ function createPaintEditorToolProvider(controller, options = {}) {
     coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.clearLayer(layerId)
   });
-  add({
-    name: "list_brushes",
-    title: "List brushes",
-    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush), light paint (category light: glow gel, neon marker, light airbrush, spark trail, light ribbon, flame ribbon, neon strand, smoke ribbon, bokeh dots, twinkle sparks, glow wash, highlighter; light is the amount they lay) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
-    inputSchema: EMPTY3,
-    annotations: { title: "List brushes", ...READ6 },
-    handler: () => {
-      const s = c.getState();
-      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(c.getBrush(s.brush.id)?.builtin), brushes: s.brushes.map(brushSummary) };
-    }
-  });
   add({
     name: "get_brush",
     title: "Get a brush",
-    description: "Reads every setting of a brush (tip, grain, pressure smoothing, rotation, dynamics, mixer, behavior: pick-up / mix / dirty, blender, smudge, its own gradient paint as paint, null when it paints the editor's paint). Without id, the active brush as edited. Also returns strokePaint: what a stroke with it would paint now (its gradient, else the editor's paint from set_paint).",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes (default the active brush)." } }, additionalProperties: false },
+    description: "Reads a brush as facets (kind, medium, variety or tool, tip, marks, dynamics, behaviour, light, motion, colour: the brush library's form, as describe_brush returns it), with the engine it paints with and whether it is an unchanged built-in preset. Without id, the active brush as edited. Also returns strokePaint: what a stroke with it would paint now (its gradient colour, else the editor's paint from set_paint). Changes nothing.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." } }, additionalProperties: false },
     annotations: { title: "Get a brush", ...READ6 },
     handler: ({ id }) => {
       const st = c.getState();
-      if (id === void 0) return { ...brushToJSON(st.brush), strokePaint: st.brush.paint ?? st.paint };
-      const b = c.getBrush(id);
-      if (!b) throw new Error(`Unknown brush "${id}". Call list_brushes for the ids.`);
-      return { ...brushToJSON(b), builtin: Boolean(b.builtin), strokePaint: b.paint ?? st.paint };
+      const b = id === void 0 ? st.brush : c.getBrush(id);
+      if (!b) c.setBrushFacets({}, id);
+      const brush = b;
+      return { brush: c.getBrushSpec(id), engine: brush.engine, category: brush.category, builtin: Boolean(brush.builtin), strokePaint: brush.paint ?? st.paint };
     }
   });
   add({
     name: "set_brush",
     title: "Set the brush",
-    description: "Chooses the active brush (id) and / or changes its settings; strokes without a brush use it. Editor state, not an undo step. Changes stay on the active brush until save_brush stores them. Returns the active brush.",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes to start from." }, ...BRUSH_FIELDS }, additionalProperties: false },
+    description: "Chooses the active brush (id, from list_brush_presets) and / or changes it with facets laid over it (objects merge, lists and values replace, marks of another kind replace the marks; the brush library's create_brush fields); unset removes whole facets first (unset colour drops a brush's own gradient). Strokes without a brush use it. Editor state, not an undo step: the changes stay on the active brush until the library's create_brush or update_brush stores a brush. Returns the active brush as facets, the engine it paints with, and problems (values clamped or dropped).",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brush_presets to start from (default the active brush)." }, name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." }, ...BRUSH_PATCH_PROPERTIES, unset: BRUSH_UNSET_PROPERTY }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
-    handler: async (a) => {
-      const stamps = a.sticker?.stamps;
+    handler: async ({ id, unset, ...patch }) => {
+      const stamps = patch.tip?.stamps;
       if (stamps) await c.prepareStickers(stamps);
-      return brushToJSON(c.setBrush(a));
-    }
-  });
-  add({
-    name: "save_brush",
-    title: "Save a brush",
-    description: "Saves the active brush (with its changes) into the user library under a new or existing user id. Built-in ids are refused. Library state, not an undo step. Returns the saved brush.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", pattern: "^[a-z0-9][a-z0-9-]{0,63}$", description: "Library id: lowercase letters, digits and dashes." },
-        name: { type: "string", minLength: 1, maxLength: 80, description: "Display name (default the brush name)." }
-      },
-      required: ["id"],
-      additionalProperties: false
-    },
-    annotations: { title: "Save a brush", ...SET4 },
-    handler: ({ id, name }) => brushToJSON(c.saveBrush({ id, name }))
-  });
-  add({
-    name: "remove_brush",
-    title: "Remove a saved brush",
-    description: "Removes a user brush from the library (built-in brushes cannot be removed). Library state, not an undo step. Returns the removed id.",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "User brush id from list_brushes." } }, required: ["id"], additionalProperties: false },
-    annotations: { title: "Remove a saved brush", ...DESTRUCTIVE3 },
-    handler: ({ id }) => {
-      c.removeBrush(id);
-      return { removed: id };
-    }
-  });
-  add({
-    name: "export_brushes",
-    title: "Export brushes",
-    description: "Returns a brush library file (JSON: format pixerate-brushes, version 1, brushes) of the given brushes, or of every user brush. Changes nothing.",
-    inputSchema: {
-      type: "object",
-      properties: { ids: { type: "array", items: { type: "string", description: "Brush id." }, description: "Brush ids from list_brushes (default every user brush)." } },
-      additionalProperties: false
-    },
-    annotations: { title: "Export brushes", ...READ6 },
-    handler: ({ ids }) => c.exportBrushes(ids)
-  });
-  add({
-    name: "import_brushes",
-    title: "Import brushes",
-    description: "Adds the brushes of a brush library file (as export_brushes returns) to the user library. Taken ids are skipped unless replace is true; built-in ids are always skipped. Library state, not an undo step. Returns the ids added and skipped and any problems.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        library: { type: "object", description: 'The library file: {format: "pixerate-brushes", version: 1, brushes: [...]}.' },
-        replace: { type: "boolean", description: "Replace user brushes with the same id (default false)." }
-      },
-      required: ["library"],
-      additionalProperties: false
-    },
-    annotations: { title: "Import brushes", ...WRITE5 },
-    handler: ({ library, replace }) => c.importBrushes(library, { replace })
-  });
-  add({
-    name: "render_brush_thumbnail",
-    title: "Render a brush thumbnail",
-    description: "Renders a brush as a PNG: a test stroke (an S-curve swelling and fading in pressure) on the current paper, so you can see what it does before painting. Changes nothing.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Brush id from list_brushes (default the active brush)." },
-        width: { type: "integer", minimum: 16, maximum: 512, description: "Width in pixels (default 160)." },
-        height: { type: "integer", minimum: 16, maximum: 512, description: "Height in pixels (default 48)." },
-        color: { ...COLOR3, description: "Stroke colour (default the paint colour)." }
-      },
-      additionalProperties: false
-    },
-    annotations: { title: "Render a brush thumbnail", ...READ6 },
-    handler: ({ id, width, height, color }) => {
-      const t = c.brushThumbnail(id ?? c.getState().brush.id, { width, height, color });
-      return {
-        content: [
-          { type: "image", data: bytesToBase64(encodePng(t.width, t.height, t.data)), mimeType: "image/png" },
-          { type: "text", text: `Brush ${id ?? c.getState().brush.id} ${t.width}\xD7${t.height}` }
-        ]
-      };
+      const r = c.setBrushFacets(patch, id, unset);
+      return { brush: r.spec, engine: r.brush.engine, problems: r.problems };
     }
   });
   add({
@@ -11371,14 +11204,14 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer with a library brush or the active one, optionally changed for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
+    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer of the canvas with a library brush or the active one, optionally changed (by facets) for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
     inputSchema: {
       type: "object",
       properties: {
         points: POINTS,
         layerId: LAYER_ID4,
-        brushId: { type: "string", description: "Brush id from list_brushes (default the active brush)." },
-        brush: { type: "object", description: "Brush changes for this stroke only.", properties: BRUSH_FIELDS, additionalProperties: false },
+        brushId: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." },
+        brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: BRUSH_PATCH_PROPERTIES, additionalProperties: false },
         color: { ...COLOR3, description: "Paint colour #rrggbb (default the paint colour)." },
         paint: { ...PAINT_SOURCE_JSON_SCHEMA, description: "What this stroke paints with instead of the editor's paint: a colour, or gradient paint that changes colour as the stroke goes (by distance, pressure, tilt, speed, direction, time, across the tip or at random). Wins over the brush's own gradient." },
         seed: { type: "integer", minimum: 0, description: "Jitter seed (default a new one); the same seed and points give the same marks." },
@@ -11392,9 +11225,9 @@ function createPaintEditorToolProvider(controller, options = {}) {
     handler: async (a) => {
       await c.wetIdle();
       const base = a.brushId ? c.getBrush(a.brushId) : c.getState().brush;
-      const over = a.brush;
-      if ((over?.engine ?? base?.engine) === "sticker") await c.prepareStickers(over?.sticker?.stamps ?? base?.sticker.stamps ?? []);
-      const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush: a.brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
+      const 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 ?? []);
+      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;
     }
@@ -11457,8 +11290,8 @@ function createPaintEditorToolProvider(controller, options = {}) {
       type: "object",
       properties: {
         id: { type: "string", description: "Stroke id from list_strokes {live: true}." },
-        brushId: { type: "string", description: "Brush preset id from list_brushes; the stroke keeps its size." },
-        brush: { type: "object", properties: BRUSH_FIELDS, additionalProperties: false, description: "Brush settings to change on top of brushId or the stroke\u2019s brush; missing fields keep their values." },
+        brushId: { type: "string", description: "Brush id from list_brush_presets; the stroke keeps its size." },
+        brush: { type: "object", properties: BRUSH_PATCH_PROPERTIES, additionalProperties: false, description: "Facets to change on top of brushId or the stroke\u2019s brush (as set_brush takes them); missing fields keep their values." },
         color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "New colour #rrggbb (replaces gradient paint)." },
         paint: { anyOf: [PAINT_SOURCE_JSON_SCHEMA, { type: "null", description: "Back to the stroke\u2019s plain colour." }], description: "A colour or gradient paint for the stroke; null drops its gradient." },
         seed: { type: "integer", minimum: 0, description: "Another jitter seed: particles, scatter and texture fall differently." }
@@ -11470,6 +11303,11 @@ function createPaintEditorToolProvider(controller, options = {}) {
     coordinates: { out: ["bounds", "stroke.bounds"] },
     handler: ({ id, ...update }) => {
       if (!Object.keys(update).length) throw new Error("Pass at least one change: brushId, brush, color, paint or seed.");
+      if (update.brush) {
+        const stroke = Object.values(c.document.liveStrokes ?? {}).flat().find((s) => s.id === id);
+        if (!stroke) throw new Error(`Unknown stroke "${id}" on a stroke layer. Call list_strokes {live: true} for the ids.`);
+        update.brush = c.brushChanges(update.brush, update.brushId ?? stroke.brush);
+      }
       const r = c.updateStroke(id, update);
       return { stroke: strokeSummary(r.stroke, false, true), bounds: r.bounds };
     }
@@ -11574,7 +11412,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         },
         pressureScale: { type: "number", minimum: 0, maximum: 4, description: "Multiply every pressure (default 1)." },
         color: { ...COLOR3, description: "Recolour (default each stroke\u2019s colour)." },
-        brushId: { type: "string", description: "Replay with this brush from list_brushes (default each stroke\u2019s brush)." },
+        brushId: { type: "string", description: "Replay with this brush from list_brush_presets (default each stroke\u2019s brush)." },
         layerId: { type: "string", description: "Paint on this layer (default each stroke\u2019s layer)." },
         repeat: { type: "integer", minimum: 1, maximum: 100, description: "How many copies (default 1)." }
       },
@@ -11761,6 +11599,18 @@ function strokeSummary(s, withPoints, live) {
   };
 }
 
+// src/paint-editor/brush-library-tools.ts
+function createPaintBrushLibraryToolProvider(controller, options = {}) {
+  return createBrushLibraryToolProvider(controller.brushLibrary, {
+    profile: PAINT_PROFILE,
+    ...options,
+    renderPreview: (brush, { width, height, color }) => {
+      const t = renderBrushThumbnail(resolveBrush(brush), { paper: controller.getState().document.paper, width, height, color: color.toLowerCase() });
+      return { data: bytesToBase64(encodePng(t.width, t.height, t.data)), mimeType: "image/png" };
+    }
+  });
+}
+
 // src/paint-editor/ui.ts
 var PAINT_TOOLS = [
   { id: "brush", label: "Brush", key: "b" },
@@ -12087,21 +11937,6 @@ function guideOverlay(controller, drag) {
   if (s.guides.perspective.enabled) for (const [from, to] of perspectiveGuideLines(s.guides.perspective, size, 16)) out.push({ from, to, kind: "perspective" });
   return out;
 }
-var BRUSH_SLIDERS = [
-  { path: "tip.size", label: "Size", min: 1, max: 400, step: 1 },
-  { path: "tip.opacity", label: "Opacity", min: 0, max: 1, step: 0.01 },
-  { path: "tip.flow", label: "Flow", min: 0, max: 1, step: 0.01 },
-  { path: "tip.hardness", label: "Hardness", min: 0, max: 1, step: 0.01 },
-  { path: "tip.spacing", label: "Spacing", min: 0.01, max: 1, step: 0.01 },
-  { path: "tip.roundness", label: "Roundness", min: 0.05, max: 1, step: 0.01 },
-  { path: "tip.angle", label: "Angle", min: -180, max: 180, step: 1 },
-  { path: "grain", label: "Grain", min: 0, max: 1, step: 0.01 },
-  { path: "tip.smoothing", label: "Smoothing", min: 0, max: 0.95, step: 0.01 },
-  { path: "pressureSmoothing", label: "Pressure smoothing", min: 0, max: 0.95, step: 0.01 },
-  { path: "dynamics.minSize", label: "Min size", min: 0, max: 1, step: 0.01 },
-  { path: "dynamics.tiltSize", label: "Tilt size", min: 0, max: 1, step: 0.01 },
-  { path: "dynamics.velocitySize", label: "Speed size", min: -1, max: 1, step: 0.01 }
-];
 var PAPER_SLIDERS = [
   { path: "depth", label: "Grain depth", min: 0, max: 1, step: 0.01 },
   { path: "scale", label: "Grain scale", min: 0.25, max: 8, step: 0.05 },
@@ -12160,158 +11995,6 @@ var BLEND_MENU_GROUPS = [
   { label: "Standard", modes: BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
   { label: "Paint", modes: BLEND_MODES.filter((m) => m.painterly || m.id === "pigment") }
 ];
-var LIGHT_SLIDER = { path: "light.amount", label: "Light", min: 0, max: 1, step: 0.01 };
-var PICKUP_SLIDERS = [
-  { path: "behavior.pickup", label: "Pick-up", min: 0, max: 1, step: 0.01 },
-  { path: "behavior.mix", label: "Mix", min: 0, max: 1, step: 0.01 }
-];
-function brushEngineControls(brush) {
-  const c = engineControls(brush);
-  const wetPaint = brush.engine === "wet" && brush.wet?.tool === "paint";
-  if (!c || !(wetPaint || ["dab", "mixer", "particle", "bristle", "impasto"].includes(brush.engine))) return c;
-  const extra = brush.engine === "impasto" ? [{ path: "impasto.rim", label: "Rim", min: 0, max: 1, step: 0.01 }, { path: "impasto.clarity", label: "Clarity", min: 0, max: 1, step: 0.01 }] : [];
-  return { ...c, sliders: [...c.sliders, LIGHT_SLIDER, ...extra], light: true };
-}
-function engineControls(brush) {
-  switch (brush.engine) {
-    case "particle":
-      return {
-        title: "Particles",
-        sliders: [
-          { path: "particle.count", label: "Particles", min: 1, max: 64, step: 1 },
-          { path: "particle.size", label: "Mark size", min: 0, max: 1, step: 0.01 },
-          { path: "particle.spread", label: "Spread", min: 0, max: 1, step: 0.01 },
-          { path: "particle.stiffness", label: "Stiffness", min: 0, max: 1, step: 0.01 },
-          { path: "particle.damping", label: "Damping", min: 0, max: 1, step: 0.01 },
-          { path: "particle.speed", label: "Speed", min: 0, max: 1, step: 0.01 },
-          { path: "particle.gravity", label: "Gravity", min: -1, max: 1, step: 0.01 },
-          { path: "particle.life", label: "Life", min: 0, max: 1, step: 0.01 },
-          { path: "particle.interval", label: "Bead spacing", min: 0, max: 1, step: 0.01 },
-          { path: "particle.ribbonFill", label: "Ribbon fill", min: 0, max: 1, step: 0.01 },
-          { path: "particle.waveAmplitude", label: "Wave", min: 0, max: 1, step: 0.01 },
-          { path: "particle.waveLength", label: "Wavelength", min: 4, max: 400, step: 1 },
-          { path: "particle.waveSpeed", label: "Wave speed", min: 0, max: 1, step: 0.01 },
-          { path: "particle.wavePhaseJitter", label: "Wave scatter", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: null,
-        dirty: false,
-        multicolor: false,
-        load: false,
-        particleMenus: true
-      };
-    case "bristle":
-      return {
-        title: "Bristles",
-        sliders: [
-          { path: "bristle.count", label: "Bristles", min: 3, max: 128, step: 1 },
-          { path: "bristle.stiffness", label: "Stiffness", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.splay", label: "Splay", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.thickness", label: "Bristle width", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.load", label: "Load", min: 0, max: 1, step: 0.01 },
-          { path: "bristle.jitter", label: "Variation", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: null,
-        dirty: false,
-        multicolor: false,
-        load: false
-      };
-    case "sticker":
-      return {
-        title: "Stickers",
-        sliders: [
-          { path: "sticker.density", label: "Density", min: 0, max: 1, step: 0.01 },
-          { path: "sticker.sizeJitter", label: "Size jitter", min: 0, max: 1, step: 0.01 },
-          { path: "sticker.rotationJitter", label: "Turn jitter", min: 0, max: 1, step: 0.01 },
-          { path: "sticker.scatter", label: "Scatter", min: 0, max: 2, step: 0.01 },
-          { path: "sticker.colorJitter", label: "Colour jitter", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: null,
-        dirty: false,
-        multicolor: false,
-        load: false,
-        stickerStamps: true
-      };
-    case "impasto":
-      return {
-        title: "Thick paint",
-        sliders: [
-          { path: "impasto.thickness", label: "Thickness", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.gloss", label: "Gloss", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.metallic", label: "Metallic", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.load", label: "Load", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.thinner", label: "Thinner", min: 0, max: 1, step: 0.01 },
-          { path: "impasto.drag", label: "Drag", min: 0, max: 1, step: 0.01 },
-          ...PICKUP_SLIDERS
-        ],
-        mixingPath: "behavior.mixing",
-        dirty: true,
-        multicolor: false,
-        load: true,
-        impastoTool: true
-      };
-    case "wet": {
-      const tool = brush.wet?.tool ?? "paint";
-      const sliders = tool === "paint" ? [
-        { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
-        { path: "wet.pigment", label: "Pigment", min: 0, max: 1, step: 0.01 },
-        { path: "wet.body", label: "Body (opacity)", min: 0, max: 1, step: 0.01 },
-        { path: "wet.rewet", label: "Re-wet", min: 0, max: 1, step: 0.01 },
-        { path: "wet.load", label: "Load", min: 0, max: 1, step: 0.01 },
-        { path: "wet.thinner", label: "Thinner", min: 0, max: 1, step: 0.01 },
-        ...PICKUP_SLIDERS
-      ] : tool === "water" ? [
-        { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
-        { path: "wet.rewet", label: "Re-wet", min: 0, max: 1, step: 0.01 }
-      ] : [{ path: "wet.strength", label: "Strength", min: 0, max: 1, step: 0.01 }];
-      return { title: "Wet brush", sliders, mixingPath: tool === "paint" ? "behavior.mixing" : null, dirty: tool === "paint", multicolor: false, load: tool === "paint", wetTool: true };
-    }
-    case "blender":
-      return {
-        title: "Blender",
-        sliders: [
-          { path: "blender.strength", label: "Strength", min: 0, max: 1, step: 0.01 },
-          { path: "blender.distance", label: "Blend distance", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: "blender.mixing",
-        dirty: false,
-        multicolor: false,
-        load: false
-      };
-    case "smudge":
-      return {
-        title: "Smudge",
-        sliders: [
-          { path: "smudge.strength", label: "Strength", min: 0, max: 1, step: 0.01 },
-          { path: "smudge.length", label: "Length", min: 0, max: 1, step: 0.01 }
-        ],
-        mixingPath: "smudge.mixing",
-        dirty: false,
-        multicolor: false,
-        load: false
-      };
-    case "mixer":
-      return { title: "Mixer Brush", sliders: [...PICKUP_SLIDERS, { path: "mixer.load", label: "Load", min: 0, max: 1, step: 0.01 }], mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
-    case "dab":
-      return { title: "Paint behaviour", sliders: PICKUP_SLIDERS, mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
-    default:
-      return null;
-  }
-}
-function multiColorSliders(mode) {
-  if (mode === "off") return [];
-  const soft = { path: "behavior.multicolor.softness", label: "Colour softness", min: 0, max: 1, step: 0.01 };
-  return mode === "dab" ? [soft, { path: "behavior.multicolor.length", label: "Dabs per colour", min: 1, max: 100, step: 1 }] : [soft];
-}
-function patchBrushValue(brush, path, value) {
-  const set = (obj, keys) => {
-    const [head2, ...rest2] = keys;
-    if (!rest2.length) return { ...obj, [head2]: value };
-    return { ...obj, [head2]: set(obj[head2] ?? {}, rest2) };
-  };
-  const [head, ...rest] = path.split(".");
-  if (!rest.length) return { [head]: value };
-  return { [head]: set({ ...brush[head] ?? {} }, rest) };
-}
 function brushLoadColor(load) {
   const c = load.pickup ?? load.reservoir;
   return c ? rgbToHexColor(Math.round(c[0] * 255), Math.round(c[1] * 255), Math.round(c[2] * 255)) : null;
@@ -12881,6 +12564,7 @@ export {
   colorHarmony2 as colorHarmony,
   composeAffine,
   contactSheet,
+  createPaintBrushLibraryToolProvider,
   createPaintCompositor,
   createPaintDocument,
   createPaintEditorDocument,
@@ -13037,6 +12721,7 @@ export {
   strokeBounds,
   strokeDuration,
   strokeSchedule,
+  strokeToJSON,
   sweepPath,
   symmetryAxisAngles,
   symmetryAxisSegments,