@pixerate/editor 0.254.1 → 0.256.0

package/dist/{chunk-34KLWUH4.cjs → chunk-HIMGBZAM.cjs}

@@ -2,8 +2,10 @@
 
 
 
+var _chunkJSDND7DFcjs = require('./chunk-JSDND7DF.cjs');
 
 
+var _chunkWOFXZ3XUcjs = require('./chunk-WOFXZ3XU.cjs');
 
 
 
@@ -11,15 +13,7 @@
 
 
 
-var _chunkHS6QDWDFcjs = require('./chunk-HS6QDWDF.cjs');
-
-
-
 
-var _chunkJSDND7DFcjs = require('./chunk-JSDND7DF.cjs');
-
-
-var _chunkWOFXZ3XUcjs = require('./chunk-WOFXZ3XU.cjs');
 
 
 
@@ -29,6 +23,973 @@ var _chunkFQPUF2W2cjs = require('./chunk-FQPUF2W2.cjs');
 
 var _chunk2VX55NFMcjs = require('./chunk-2VX55NFM.cjs');
 
+// src/paint-editor/mark-settings.ts
+var unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+var oneOf = (v, all, d) => all.includes(v) ? v : d;
+var MAX_STICKER_STAMPS = 16;
+var DEFAULT_STICKER = { stamps: ["editor:star"], density: 0.4, sizeJitter: 0.4, rotationJitter: 1, scatter: 0.5, colorJitter: 0.2 };
+function normalizeStickerSettings(raw = {}, base = DEFAULT_STICKER) {
+  const refs = (list2) => list2.flatMap((s) => {
+    try {
+      return [_chunkJSDND7DFcjs.normalizeStickerRef.call(void 0, s)];
+    } catch (e2) {
+      return [];
+    }
+  });
+  const stamps = Array.isArray(raw.stamps) ? refs(raw.stamps) : refs(base.stamps);
+  return {
+    stamps: stamps.length ? [...new Set(stamps)].slice(0, MAX_STICKER_STAMPS) : refs(base.stamps.length ? base.stamps : DEFAULT_STICKER.stamps),
+    density: unit(raw.density, base.density),
+    sizeJitter: unit(raw.sizeJitter, base.sizeJitter),
+    rotationJitter: unit(raw.rotationJitter, base.rotationJitter),
+    scatter: typeof raw.scatter === "number" && Number.isFinite(raw.scatter) ? Math.min(2, Math.max(0, raw.scatter)) : base.scatter,
+    colorJitter: unit(raw.colorJitter, base.colorJitter)
+  };
+}
+var PARTICLE_KINDS = ["string", "spring", "orbit", "flow", "elastic", "fuzzy"];
+var PARTICLE_RENDERS = ["dot", "line", "sequence", "ribbon"];
+var RIBBON_PAIRS = ["adjacent", "first-last"];
+var DOT_TEXTURE_ORDERS = ["sequence", "random"];
+var DOT_ROTATIONS = ["follow", "random", "fixed"];
+var MAX_DOT_TEXTURES = 4;
+var DEFAULT_PARTICLE = {
+  kind: "spring",
+  render: "line",
+  count: 12,
+  size: 0.08,
+  spread: 0.5,
+  stiffness: 0.4,
+  damping: 0.25,
+  speed: 0.5,
+  gravity: 0,
+  life: 0.5,
+  interval: 0.3,
+  ribbonFill: 0.5,
+  ribbonPairs: "adjacent",
+  waveAmplitude: 0,
+  waveLength: 60,
+  waveSpeed: 0,
+  wavePhaseJitter: 0,
+  dotTextures: [],
+  dotTextureOrder: "sequence",
+  dotRotation: "random"
+};
+function normalizeParticle(raw = {}, base = DEFAULT_PARTICLE) {
+  const textures = Array.isArray(raw.dotTextures) ? raw.dotTextures.filter((t) => _chunkJSDND7DFcjs.STAMP_KINDS.includes(t)).slice(0, MAX_DOT_TEXTURES) : [..._nullishCoalesce(base.dotTextures, () => ( []))];
+  return {
+    kind: oneOf(raw.kind, PARTICLE_KINDS, base.kind),
+    render: oneOf(raw.render, PARTICLE_RENDERS, base.render),
+    count: typeof raw.count === "number" && Number.isFinite(raw.count) ? Math.min(64, Math.max(1, Math.round(raw.count))) : base.count,
+    size: unit(raw.size, base.size),
+    spread: unit(raw.spread, base.spread),
+    stiffness: unit(raw.stiffness, base.stiffness),
+    damping: unit(raw.damping, base.damping),
+    speed: unit(raw.speed, base.speed),
+    gravity: typeof raw.gravity === "number" && Number.isFinite(raw.gravity) ? Math.min(1, Math.max(-1, raw.gravity)) : base.gravity,
+    life: unit(raw.life, base.life),
+    interval: unit(raw.interval, base.interval),
+    ribbonFill: unit(raw.ribbonFill, _nullishCoalesce(base.ribbonFill, () => ( DEFAULT_PARTICLE.ribbonFill))),
+    ribbonPairs: oneOf(raw.ribbonPairs, RIBBON_PAIRS, _nullishCoalesce(base.ribbonPairs, () => ( DEFAULT_PARTICLE.ribbonPairs))),
+    waveAmplitude: unit(raw.waveAmplitude, _nullishCoalesce(base.waveAmplitude, () => ( 0))),
+    waveLength: typeof raw.waveLength === "number" && Number.isFinite(raw.waveLength) ? Math.min(2e3, Math.max(4, raw.waveLength)) : _nullishCoalesce(base.waveLength, () => ( DEFAULT_PARTICLE.waveLength)),
+    waveSpeed: unit(raw.waveSpeed, _nullishCoalesce(base.waveSpeed, () => ( 0))),
+    wavePhaseJitter: unit(raw.wavePhaseJitter, _nullishCoalesce(base.wavePhaseJitter, () => ( 0))),
+    dotTextures: textures,
+    dotTextureOrder: oneOf(raw.dotTextureOrder, DOT_TEXTURE_ORDERS, _nullishCoalesce(base.dotTextureOrder, () => ( DEFAULT_PARTICLE.dotTextureOrder))),
+    dotRotation: oneOf(raw.dotRotation, DOT_ROTATIONS, _nullishCoalesce(base.dotRotation, () => ( DEFAULT_PARTICLE.dotRotation)))
+  };
+}
+var DEFAULT_BRISTLE = { count: 32, stiffness: 0.5, splay: 0.5, thickness: 0.06, load: 0.6, jitter: 0.4 };
+function normalizeBristle(raw = {}, base = DEFAULT_BRISTLE) {
+  return {
+    count: typeof raw.count === "number" && Number.isFinite(raw.count) ? Math.min(128, Math.max(3, Math.round(raw.count))) : base.count,
+    stiffness: unit(raw.stiffness, base.stiffness),
+    splay: unit(raw.splay, base.splay),
+    thickness: unit(raw.thickness, base.thickness),
+    load: unit(raw.load, base.load),
+    jitter: unit(raw.jitter, base.jitter)
+  };
+}
+
+// src/paint-editor/brushes.ts
+var PAINT_BRUSH_ENGINES = ["dab", "eraser", "mixer", "blender", "smudge", "wet", "impasto", "particle", "bristle", "sticker"];
+var PAINT_BRUSH_CATEGORIES = ["pencil", "pastel", "charcoal", "airbrush", "marker", "ink", "paint", "eraser", "blender", "smudge", "mixer", "watercolor", "wet-tool", "oil", "impasto", "procedural", "bristle", "sticker", "light", "custom"];
+var WET_TOOLS = ["paint", "water", "dry", "blow", "blend", "smudge", "blot"];
+var WET_MEDIA = ["watercolor", "gouache", "oil"];
+var DEFAULT_WET_BRUSH = { tool: "paint", water: 0.5, pigment: 0.5, body: 0, strength: 0.5, rewet: 0, medium: "watercolor", load: 1, thinner: 0 };
+function normalizeWetBrush(raw = {}, base = DEFAULT_WET_BRUSH) {
+  return {
+    tool: WET_TOOLS.includes(raw.tool) ? raw.tool : base.tool,
+    water: unit2(raw.water, base.water),
+    pigment: unit2(raw.pigment, base.pigment),
+    body: unit2(raw.body, base.body),
+    strength: unit2(raw.strength, base.strength),
+    rewet: unit2(raw.rewet, base.rewet),
+    medium: WET_MEDIA.includes(raw.medium) ? raw.medium : _nullishCoalesce(base.medium, () => ( "watercolor")),
+    load: unit2(raw.load, _nullishCoalesce(base.load, () => ( 1))),
+    thinner: unit2(raw.thinner, _nullishCoalesce(base.thinner, () => ( 0)))
+  };
+}
+var IMPASTO_TOOLS = ["brush", "tube", "knife", "roller", "gloop"];
+var DEFAULT_IMPASTO = { tool: "brush", thickness: 0.6, gloss: 0.4, metallic: 0, load: 0.9, thinner: 0, drag: 0.4, rim: 0, clarity: 0 };
+var DEFAULT_LIGHT = { amount: 0, pressure: false };
+function normalizeLight(raw = {}, base = DEFAULT_LIGHT) {
+  return { amount: unit2(raw.amount, base.amount), pressure: typeof raw.pressure === "boolean" ? raw.pressure : base.pressure };
+}
+function normalizeImpasto(raw = {}, base = DEFAULT_IMPASTO) {
+  return {
+    tool: IMPASTO_TOOLS.includes(raw.tool) ? raw.tool : base.tool,
+    thickness: unit2(raw.thickness, base.thickness),
+    gloss: unit2(raw.gloss, base.gloss),
+    metallic: unit2(raw.metallic, base.metallic),
+    load: unit2(raw.load, base.load),
+    thinner: unit2(raw.thinner, base.thinner),
+    drag: unit2(raw.drag, base.drag),
+    rim: unit2(raw.rim, _nullishCoalesce(base.rim, () => ( 0))),
+    clarity: unit2(raw.clarity, _nullishCoalesce(base.clarity, () => ( 0)))
+  };
+}
+var MULTI_COLOR_MODES = ["off", "tip", "dab"];
+var DEFAULT_MULTI_COLOR = { mode: "off", colors: [], order: "sequence", length: 12, softness: 1 };
+var DEFAULT_BEHAVIOR = { pickup: 0, mix: 0.5, dirty: false, mixing: "pigment", multicolor: DEFAULT_MULTI_COLOR };
+var BRUSH_ROTATIONS = ["fixed", "stroke", "barrel"];
+var DEFAULT_DYNAMICS = {
+  minSize: 0,
+  pressureFlow: 0,
+  tiltSize: 0,
+  tiltRoundness: 0,
+  tiltOpacity: 0,
+  velocitySize: 0,
+  velocityOpacity: 0,
+  sizeJitter: 0,
+  angleJitter: 0,
+  opacityJitter: 0,
+  scatter: 0
+};
+var unit2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+var range = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
+function normalizeDynamics(raw = {}, base = DEFAULT_DYNAMICS) {
+  return {
+    minSize: unit2(raw.minSize, base.minSize),
+    pressureFlow: unit2(raw.pressureFlow, base.pressureFlow),
+    tiltSize: unit2(raw.tiltSize, base.tiltSize),
+    tiltRoundness: unit2(raw.tiltRoundness, base.tiltRoundness),
+    tiltOpacity: unit2(raw.tiltOpacity, base.tiltOpacity),
+    velocitySize: range(raw.velocitySize, -1, 1, base.velocitySize),
+    velocityOpacity: range(raw.velocityOpacity, -1, 1, base.velocityOpacity),
+    sizeJitter: unit2(raw.sizeJitter, base.sizeJitter),
+    angleJitter: unit2(raw.angleJitter, base.angleJitter),
+    opacityJitter: unit2(raw.opacityJitter, base.opacityJitter),
+    scatter: range(raw.scatter, 0, 4, base.scatter)
+  };
+}
+var BRUSH_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var HEX = /^#[0-9a-f]{6}$/i;
+function normalizeMultiColor(raw = {}, base = DEFAULT_MULTI_COLOR) {
+  const colors = Array.isArray(raw.colors) ? raw.colors.filter((c) => typeof c === "string" && HEX.test(c.trim())).map((c) => c.trim().toLowerCase()).slice(0, 8) : base.colors;
+  return {
+    mode: MULTI_COLOR_MODES.includes(raw.mode) ? raw.mode : base.mode,
+    colors: [...colors],
+    order: raw.order === "random" || raw.order === "sequence" ? raw.order : base.order,
+    length: typeof raw.length === "number" && Number.isFinite(raw.length) ? Math.min(500, Math.max(1, Math.round(raw.length))) : base.length,
+    softness: unit2(raw.softness, base.softness)
+  };
+}
+function normalizeBehavior(raw = {}, base = DEFAULT_BEHAVIOR) {
+  return {
+    pickup: unit2(raw.pickup, base.pickup),
+    mix: unit2(raw.mix, base.mix),
+    dirty: typeof raw.dirty === "boolean" ? raw.dirty : base.dirty,
+    mixing: raw.mixing === "rgb" || raw.mixing === "pigment" ? raw.mixing : base.mixing,
+    multicolor: normalizeMultiColor(_nullishCoalesce(raw.multicolor, () => ( {})), base.multicolor)
+  };
+}
+function isWetCapable(brush) {
+  return brush.engine === "dab" || brush.engine === "mixer" || brush.engine === "wet" || brush.engine === "impasto";
+}
+function isWetBrush(brush) {
+  return brush.engine === "wet";
+}
+function usesPaintExchange(brush, gradient = brush.paint !== null) {
+  return brush.engine === "dab" && (brush.behavior.pickup > 0 || gradient);
+}
+function brushTakesPaint(brush) {
+  if (brush.engine === "eraser" || brush.engine === "blender" || brush.engine === "smudge") return false;
+  if (brush.engine === "wet") return brush.wet.tool === "paint";
+  if (brush.engine === "mixer") return brush.loadsColor;
+  return true;
+}
+function paintToMultiColor(g) {
+  if (!g || g.space === "oklab" || g.stops.some((s) => s.opacity !== void 0 || s.midpoint !== void 0)) return null;
+  const colors = g.stops.map((s) => s.color);
+  const own = (list2) => list2.length === 2 && list2[0] === "paint" && list2[1] === "secondary" ? [] : list2.some((c) => c === "paint" || c === "secondary") ? null : list2;
+  const uniform = (n) => g.stops.every((s, k) => s.offset === k / n);
+  const softness = _nullishCoalesce(g.softness, () => ( 1));
+  if (g.map.by === "across-tip" && colors.length <= 8 && uniform(colors.length - 1)) {
+    const c = own(colors);
+    return c ? { mode: "tip", colors: c, order: "sequence", length: DEFAULT_MULTI_COLOR.length, softness } : null;
+  }
+  if (g.map.by === "random" && colors.length % 2 === 0 && colors.length <= 16) {
+    const n = colors.length / 2;
+    const pairs = Array.from({ length: n }, (_, k) => colors[2 * k]);
+    const hard = g.stops.every((s, i) => s.offset === (Math.floor(i / 2) + i % 2) / n && s.color === pairs[Math.floor(i / 2)]);
+    const c = hard ? own(pairs) : null;
+    return c ? { mode: "dab", colors: c, order: "random", length: _nullishCoalesce(g.map.every, () => ( 1)), softness } : null;
+  }
+  if (g.map.by === "distance" && g.map.unit === "dabs" && g.map.repeat === "repeat" && colors.length >= 3 && colors.length <= 9 && colors[0] === colors[colors.length - 1] && uniform(colors.length - 1)) {
+    const n = colors.length - 1;
+    const c = own(colors.slice(0, n));
+    const length = g.map.length / n;
+    return c && Number.isInteger(length) ? { mode: "dab", colors: c, order: "sequence", length, softness } : null;
+  }
+  return null;
+}
+function multiColorToPaint(mc, mixing) {
+  if (mc.mode === "off") return null;
+  const colors = mc.colors.length >= 2 ? mc.colors : ["paint", "secondary"];
+  const n = colors.length;
+  const space = mixing === "rgb" ? "srgb" : "pigment";
+  const soft = mc.softness < 1 ? { softness: mc.softness } : {};
+  if (mc.mode === "tip") return { type: "gradient", stops: colors.map((color, k) => ({ offset: k / (n - 1), color })), space, map: { by: "across-tip" }, ...soft };
+  if (mc.order === "random") {
+    const stops = colors.flatMap((color, k) => [
+      { offset: k / n, color },
+      { offset: (k + 1) / n, color }
+    ]);
+    return { type: "gradient", stops, space, map: { by: "random", every: mc.length } };
+  }
+  return { type: "gradient", stops: [...colors, colors[0]].map((color, k) => ({ offset: k / n, color })), space, map: { by: "distance", length: mc.length * n, repeat: "repeat", unit: "dabs" }, ...soft };
+}
+function normalizePaintBrush(raw = {}, base) {
+  const b = _nullishCoalesce(base, () => ( BASE_BRUSH));
+  const id = typeof raw.id === "string" && BRUSH_ID.test(raw.id) ? raw.id : b.id;
+  const engine = PAINT_BRUSH_ENGINES.includes(raw.engine) ? raw.engine : b.engine;
+  const rb = _nullishCoalesce(raw.behavior, () => ( {}));
+  const mixerIn = { ...b.mixer, ..._nullishCoalesce(raw.mixer, () => ( {})) };
+  if (engine === "mixer") {
+    if (rb.pickup !== void 0) mixerIn.wet = rb.pickup;
+    if (rb.mix !== void 0) mixerIn.mix = rb.mix;
+    if (rb.dirty !== void 0) mixerIn.cleanEachStroke = !rb.dirty;
+    if (rb.mixing !== void 0) mixerIn.mixing = rb.mixing;
+  }
+  const mixer = _chunkFQPUF2W2cjs.normalizeMixer.call(void 0, mixerIn);
+  let behavior = normalizeBehavior(rb, b.behavior);
+  if (engine === "mixer") behavior = { ...behavior, pickup: mixer.wet, mix: mixer.mix, dirty: !mixer.cleanEachStroke, mixing: mixer.mixing };
+  let paint = _nullishCoalesce(b.paint, () => ( null));
+  if (raw.paint !== void 0) {
+    const p = _chunkFQPUF2W2cjs.readPaintSource.call(void 0, raw.paint);
+    paint = p && p.type === "gradient" ? p : null;
+  } else if (rb.multicolor !== void 0) {
+    const mc = normalizeMultiColor(rb.multicolor, _nullishCoalesce(paintToMultiColor(paint), () => ( DEFAULT_MULTI_COLOR)));
+    paint = mc.mode === "off" ? paintToMultiColor(paint) ? null : paint : multiColorToPaint(mc, behavior.mixing);
+  }
+  behavior = { ...behavior, multicolor: _nullishCoalesce(paintToMultiColor(paint), () => ( { ...DEFAULT_MULTI_COLOR, colors: [] })) };
+  return {
+    id,
+    name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim().slice(0, 80) : b.name,
+    category: PAINT_BRUSH_CATEGORIES.includes(raw.category) ? raw.category : b.category,
+    engine,
+    tip: _chunkFQPUF2W2cjs.normalizeBrush.call(void 0, { ...b.tip, ..._nullishCoalesce(raw.tip, () => ( {})) }),
+    grain: unit2(raw.grain, b.grain),
+    pressureSmoothing: range(raw.pressureSmoothing, 0, 0.95, b.pressureSmoothing),
+    rotation: BRUSH_ROTATIONS.includes(raw.rotation) ? raw.rotation : b.rotation,
+    dynamics: normalizeDynamics(_nullishCoalesce(raw.dynamics, () => ( {})), b.dynamics),
+    mixer,
+    loadsColor: typeof raw.loadsColor === "boolean" ? raw.loadsColor : b.loadsColor,
+    behavior,
+    blender: _chunkFQPUF2W2cjs.normalizeBlender.call(void 0, _nullishCoalesce(raw.blender, () => ( {})), b.blender),
+    smudge: _chunkFQPUF2W2cjs.normalizeSmudge.call(void 0, _nullishCoalesce(raw.smudge, () => ( {})), b.smudge),
+    wet: normalizeWetBrush(_nullishCoalesce(raw.wet, () => ( {})), _nullishCoalesce(b.wet, () => ( DEFAULT_WET_BRUSH))),
+    impasto: normalizeImpasto(_nullishCoalesce(raw.impasto, () => ( {})), _nullishCoalesce(b.impasto, () => ( DEFAULT_IMPASTO))),
+    particle: normalizeParticle(_nullishCoalesce(raw.particle, () => ( {})), _nullishCoalesce(b.particle, () => ( DEFAULT_PARTICLE))),
+    bristle: normalizeBristle(_nullishCoalesce(raw.bristle, () => ( {})), _nullishCoalesce(b.bristle, () => ( DEFAULT_BRISTLE))),
+    sticker: normalizeStickerSettings(_nullishCoalesce(raw.sticker, () => ( {})), _nullishCoalesce(b.sticker, () => ( DEFAULT_STICKER))),
+    light: normalizeLight(_nullishCoalesce(raw.light, () => ( {})), _nullishCoalesce(b.light, () => ( DEFAULT_LIGHT))),
+    paint,
+    ...raw.builtin ? { builtin: true } : {}
+  };
+}
+var BASE_BRUSH = {
+  id: "round",
+  name: "Round",
+  category: "custom",
+  engine: "dab",
+  tip: { ..._chunkFQPUF2W2cjs.DEFAULT_BRUSH },
+  grain: 0,
+  pressureSmoothing: 0,
+  rotation: "fixed",
+  dynamics: { ...DEFAULT_DYNAMICS },
+  mixer: { ..._chunkFQPUF2W2cjs.DEFAULT_MIXER },
+  loadsColor: true,
+  behavior: { ...DEFAULT_BEHAVIOR, multicolor: { ...DEFAULT_MULTI_COLOR, colors: [] } },
+  blender: { ..._chunkFQPUF2W2cjs.DEFAULT_BLENDER },
+  smudge: { ..._chunkFQPUF2W2cjs.DEFAULT_SMUDGE },
+  wet: { ...DEFAULT_WET_BRUSH },
+  impasto: { ...DEFAULT_IMPASTO },
+  particle: { ...DEFAULT_PARTICLE },
+  bristle: { ...DEFAULT_BRISTLE },
+  sticker: { ...DEFAULT_STICKER, stamps: [...DEFAULT_STICKER.stamps] },
+  light: { ...DEFAULT_LIGHT },
+  paint: null
+};
+var builtin = (init) => ({ ...normalizePaintBrush(init), builtin: true });
+var BUILTIN_BRUSHES = [
+  builtin({
+    id: "pencil-hb",
+    name: "HB pencil",
+    category: "pencil",
+    tip: { size: 4, hardness: 0.7, spacing: 0.08, opacity: 0.85, flow: 0.55, smoothing: 0.25, pressureSize: true, pressureOpacity: true },
+    grain: 0.85,
+    pressureSmoothing: 0.3,
+    dynamics: { minSize: 0.55, tiltSize: 0.9, tiltRoundness: 0.7, tiltOpacity: 0.5 }
+  }),
+  builtin({
+    id: "pencil-6b",
+    name: "6B pencil",
+    category: "pencil",
+    tip: { size: 7, hardness: 0.55, spacing: 0.07, opacity: 1, flow: 0.75, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    grain: 0.7,
+    pressureSmoothing: 0.3,
+    dynamics: { minSize: 0.5, tiltSize: 1, tiltRoundness: 0.75, tiltOpacity: 0.35 }
+  }),
+  builtin({
+    id: "soft-pastel",
+    name: "Soft pastel",
+    category: "pastel",
+    rotation: "stroke",
+    tip: { size: 32, hardness: 0.55, spacing: 0.05, angle: 90, roundness: 0.55, opacity: 1, flow: 0.7, smoothing: 0.15, pressureSize: false, pressureOpacity: true },
+    grain: 1,
+    pressureSmoothing: 0.25,
+    dynamics: { sizeJitter: 0.06, angleJitter: 0.02 }
+  }),
+  builtin({
+    id: "oil-pastel",
+    name: "Oil pastel",
+    category: "pastel",
+    rotation: "stroke",
+    tip: { size: 26, hardness: 0.8, spacing: 0.05, angle: 90, roundness: 0.7, opacity: 1, flow: 0.9, smoothing: 0.15, pressureSize: true, pressureOpacity: false, blend: "pigment" },
+    grain: 0.5,
+    pressureSmoothing: 0.25,
+    dynamics: { minSize: 0.6 }
+  }),
+  builtin({
+    id: "charcoal-stick",
+    name: "Charcoal stick",
+    category: "charcoal",
+    rotation: "stroke",
+    tip: { size: 26, hardness: 0.4, spacing: 0.05, angle: 90, roundness: 0.35, opacity: 0.95, flow: 0.5, smoothing: 0.15, pressureSize: false, pressureOpacity: true },
+    grain: 0.95,
+    pressureSmoothing: 0.2,
+    dynamics: { sizeJitter: 0.1, angleJitter: 0.03, tiltSize: 0.6 }
+  }),
+  builtin({
+    id: "vine-charcoal",
+    name: "Vine charcoal",
+    category: "charcoal",
+    tip: { size: 10, hardness: 0.3, spacing: 0.06, opacity: 0.75, flow: 0.45, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    grain: 0.9,
+    pressureSmoothing: 0.2,
+    dynamics: { minSize: 0.4, tiltSize: 0.8, tiltRoundness: 0.5, tiltOpacity: 0.3, sizeJitter: 0.08 }
+  }),
+  builtin({
+    id: "airbrush",
+    name: "Airbrush",
+    category: "airbrush",
+    tip: { size: 90, hardness: 0, spacing: 0.04, opacity: 1, flow: 0.06, smoothing: 0.3, pressureSize: false, pressureOpacity: false },
+    grain: 0,
+    pressureSmoothing: 0.3,
+    dynamics: { pressureFlow: 1, tiltSize: 0.5, tiltRoundness: 0.6 }
+  }),
+  builtin({
+    id: "marker",
+    name: "Chisel marker",
+    category: "marker",
+    tip: { size: 24, hardness: 0.85, spacing: 0.04, angle: 45, roundness: 0.35, opacity: 0.6, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: false, blend: "multiply" },
+    grain: 0.1
+  }),
+  builtin({
+    id: "ink-pen",
+    name: "Ink pen",
+    category: "ink",
+    tip: { size: 4, hardness: 1, spacing: 0.05, opacity: 1, flow: 1, smoothing: 0.5, pressureSize: true, pressureOpacity: false },
+    pressureSmoothing: 0.4,
+    dynamics: { minSize: 0.25, velocitySize: -0.45 }
+  }),
+  builtin({
+    id: "brush-pen",
+    name: "Brush pen",
+    category: "ink",
+    rotation: "stroke",
+    tip: { size: 14, hardness: 0.9, spacing: 0.04, roundness: 0.8, opacity: 1, flow: 1, smoothing: 0.5, pressureSize: true, pressureOpacity: false },
+    pressureSmoothing: 0.45,
+    dynamics: { minSize: 0.05, velocitySize: -0.3 }
+  }),
+  builtin({
+    id: "eraser-soft",
+    name: "Soft eraser",
+    category: "eraser",
+    engine: "eraser",
+    tip: { size: 40, hardness: 0.2, spacing: 0.08, opacity: 1, flow: 0.6, pressureSize: false, pressureOpacity: true }
+  }),
+  builtin({
+    id: "eraser-hard",
+    name: "Hard eraser",
+    category: "eraser",
+    engine: "eraser",
+    tip: { size: 16, hardness: 0.9, spacing: 0.06, opacity: 1, flow: 1, pressureSize: true, pressureOpacity: false },
+    grain: 0.3,
+    dynamics: { minSize: 0.5 }
+  }),
+  builtin({
+    id: "blender",
+    name: "Blender",
+    category: "blender",
+    engine: "blender",
+    loadsColor: false,
+    tip: { size: 34, hardness: 0.4, spacing: 0.1, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    blender: { strength: 0.5, distance: 0.35, mixing: "pigment" }
+  }),
+  builtin({
+    id: "smudge",
+    name: "Smudge",
+    category: "smudge",
+    engine: "smudge",
+    loadsColor: false,
+    tip: { size: 26, hardness: 0.6, spacing: 0.06, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    smudge: { strength: 0.75, length: 0.85, mixing: "rgb" }
+  }),
+  builtin({
+    id: "wet-smudge",
+    name: "Pigment smudge",
+    category: "smudge",
+    engine: "smudge",
+    loadsColor: false,
+    tip: { size: 30, hardness: 0.5, spacing: 0.06, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    smudge: { strength: 0.7, length: 0.9, mixing: "pigment" },
+    dynamics: { minSize: 0.6 }
+  }),
+  builtin({
+    id: "dirty-round",
+    name: "Dirty round",
+    category: "paint",
+    tip: { size: 22, hardness: 0.65, spacing: 0.06, opacity: 1, flow: 0.7, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    behavior: { pickup: 0.55, mix: 0.6, dirty: true, mixing: "pigment" },
+    dynamics: { minSize: 0.5 }
+  }),
+  builtin({
+    id: "multicolor-flat",
+    name: "Multi-colour flat",
+    category: "paint",
+    rotation: "stroke",
+    tip: { size: 30, hardness: 0.75, spacing: 0.05, angle: 90, roundness: 0.3, opacity: 1, flow: 0.85, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    behavior: { pickup: 0.15, mix: 0.4, mixing: "pigment" },
+    // The paint and second colours side by side across the tip.
+    paint: { type: "gradient", stops: [{ offset: 0, color: "paint" }, { offset: 1, color: "secondary" }], space: "pigment", map: { by: "across-tip" }, softness: 0.7 },
+    dynamics: { minSize: 0.6 }
+  }),
+  builtin({
+    id: "palette-dabber",
+    name: "Palette dabber",
+    category: "paint",
+    tip: { size: 18, hardness: 0.7, spacing: 0.35, opacity: 1, flow: 0.9, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    // From the paint colour to the second colour and back, every 6 dabs.
+    paint: { type: "gradient", stops: [{ offset: 0, color: "paint" }, { offset: 0.5, color: "secondary" }, { offset: 1, color: "paint" }], space: "pigment", map: { by: "distance", length: 12, repeat: "repeat", unit: "dabs" }, softness: 0.4 },
+    dynamics: { minSize: 0.5, sizeJitter: 0.15, scatter: 0.3 }
+  }),
+  builtin({
+    id: "gradient-round",
+    name: "Gradient round",
+    category: "paint",
+    tip: { size: 24, hardness: 0.8, spacing: 0.05, opacity: 1, flow: 0.9, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    // Changes colour as it is dragged out: paint → second colour over 300 px, and back.
+    paint: { type: "gradient", stops: [{ offset: 0, color: "paint" }, { offset: 1, color: "secondary" }], space: "pigment", map: { by: "distance", length: 300, repeat: "mirror" } },
+    dynamics: { minSize: 0.5 }
+  }),
+  builtin({
+    id: "pressure-ombre",
+    name: "Pressure ombr\xE9",
+    category: "paint",
+    tip: { size: 26, hardness: 0.6, spacing: 0.05, opacity: 1, flow: 0.8, smoothing: 0.2, pressureSize: false, pressureOpacity: false },
+    // Light pressure lays the second colour, full pressure the paint colour.
+    paint: { type: "gradient", stops: [{ offset: 0, color: "secondary" }, { offset: 1, color: "paint" }], space: "pigment", map: { by: "pressure" } }
+  }),
+  builtin({
+    id: "rainbow-marker",
+    name: "Rainbow marker",
+    category: "marker",
+    rotation: "stroke",
+    tip: { size: 18, hardness: 0.9, spacing: 0.04, angle: 90, roundness: 0.4, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: false, pressureOpacity: false },
+    paint: {
+      type: "gradient",
+      stops: [
+        { offset: 0, color: "#e11d48" },
+        { offset: 0.2, color: "#f59e0b" },
+        { offset: 0.4, color: "#facc15" },
+        { offset: 0.6, color: "#22c55e" },
+        { offset: 0.8, color: "#3b82f6" },
+        { offset: 1, color: "#8b5cf6" }
+      ],
+      space: "oklab",
+      map: { by: "distance", length: 600, repeat: "repeat" }
+    }
+  }),
+  builtin({
+    id: "mixer-brush",
+    name: "Mixer Brush",
+    category: "mixer",
+    engine: "mixer",
+    tip: { size: 30, hardness: 0.7, spacing: 0.1, opacity: 1, flow: 0.5, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    mixer: { wet: 0.5, load: 0.95, mix: 0.5, loadEachStroke: true, cleanEachStroke: true, mixing: "pigment" },
+    dynamics: { minSize: 0.5 }
+  }),
+  builtin({
+    id: "watercolor-round",
+    name: "Watercolour round",
+    category: "watercolor",
+    engine: "wet",
+    tip: { size: 28, hardness: 0.6, spacing: 0.12, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: true },
+    dynamics: { minSize: 0.35 },
+    behavior: { pickup: 0.55, mix: 0.5, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.55, pigment: 0.5, body: 0, rewet: 0.2 }
+  }),
+  builtin({
+    id: "watercolor-wash",
+    name: "Wash brush",
+    category: "watercolor",
+    engine: "wet",
+    rotation: "stroke",
+    tip: { size: 90, hardness: 0.35, spacing: 0.1, angle: 90, roundness: 0.45, opacity: 1, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: true },
+    behavior: { pickup: 0.45, mix: 0.45, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.8, pigment: 0.45, body: 0, rewet: 0.2 }
+  }),
+  builtin({
+    id: "gradient-wash",
+    name: "Gradient wash",
+    category: "watercolor",
+    engine: "wet",
+    rotation: "stroke",
+    tip: { size: 80, hardness: 0.35, spacing: 0.1, angle: 90, roundness: 0.5, opacity: 1, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: true },
+    behavior: { pickup: 0.4, mix: 0.4, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.8, pigment: 0.45, body: 0, rewet: 0.2 },
+    // A graded wash: the paint colour runs into the second colour as the brush travels.
+    paint: { type: "gradient", stops: [{ offset: 0, color: "paint" }, { offset: 1, color: "secondary" }], space: "pigment", map: { by: "distance", length: 500, repeat: "mirror" } }
+  }),
+  builtin({
+    id: "watercolor-detail",
+    name: "Watercolour rigger",
+    category: "watercolor",
+    engine: "wet",
+    tip: { size: 7, hardness: 0.75, spacing: 0.1, opacity: 1, flow: 1, smoothing: 0.4, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.2 },
+    behavior: { pickup: 0.4, mix: 0.45, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.4, pigment: 0.7, body: 0, rewet: 0.2 }
+  }),
+  builtin({
+    id: "gouache",
+    name: "Gouache",
+    category: "watercolor",
+    engine: "wet",
+    tip: { size: 26, hardness: 0.7, spacing: 0.1, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5 },
+    behavior: { pickup: 0.65, mix: 0.6, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.35, pigment: 0.8, body: 1, medium: "gouache", rewet: 0.3 }
+  }),
+  builtin({
+    id: "oil-round",
+    name: "Wet oil round",
+    category: "oil",
+    engine: "wet",
+    tip: { size: 24, hardness: 0.75, spacing: 0.08, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5 },
+    behavior: { pickup: 0.6, mix: 0.55, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.4, pigment: 0.9, body: 1, medium: "oil", load: 0.97 }
+  }),
+  builtin({
+    id: "oil-flat",
+    name: "Wet oil flat",
+    category: "oil",
+    engine: "wet",
+    rotation: "stroke",
+    tip: { size: 40, hardness: 0.85, spacing: 0.06, angle: 90, roundness: 0.35, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.6 },
+    behavior: { pickup: 0.65, mix: 0.6, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.45, pigment: 0.9, body: 1, medium: "oil", load: 0.95 }
+  }),
+  builtin({
+    id: "impasto-brush",
+    name: "Impasto brush",
+    category: "impasto",
+    engine: "impasto",
+    rotation: "stroke",
+    tip: { size: 36, hardness: 0.8, spacing: 0.06, angle: 90, roundness: 0.55, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.55 },
+    behavior: { pickup: 0.4, mix: 0.5, mixing: "pigment" },
+    impasto: { tool: "brush", thickness: 0.6, gloss: 0.45, load: 0.92, drag: 0.4 }
+  }),
+  builtin({
+    id: "paint-tube",
+    name: "Paint tube",
+    category: "impasto",
+    engine: "impasto",
+    tip: { size: 22, hardness: 0.9, spacing: 0.05, opacity: 1, flow: 1, smoothing: 0.35, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.4 },
+    impasto: { tool: "tube", thickness: 0.9, gloss: 0.5, load: 1, drag: 0.1 }
+  }),
+  builtin({
+    id: "palette-knife",
+    name: "Palette knife",
+    category: "impasto",
+    engine: "impasto",
+    rotation: "stroke",
+    tip: { size: 48, hardness: 1, spacing: 0.05, angle: 90, roundness: 0.18, opacity: 1, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: false },
+    impasto: { tool: "knife", thickness: 0.3, gloss: 0.55, load: 1, drag: 0.85 }
+  }),
+  builtin({
+    id: "paint-roller",
+    name: "Roller",
+    category: "impasto",
+    engine: "impasto",
+    rotation: "stroke",
+    tip: { size: 70, hardness: 0.95, spacing: 0.04, angle: 90, roundness: 0.12, opacity: 1, flow: 1, smoothing: 0.4, pressureSize: false, pressureOpacity: false },
+    impasto: { tool: "roller", thickness: 0.25, gloss: 0.3, load: 0.9, drag: 0.15 }
+  }),
+  builtin({
+    id: "gloop-pen",
+    name: "Gloop pen",
+    category: "impasto",
+    engine: "impasto",
+    tip: { size: 14, hardness: 0.9, spacing: 0.05, opacity: 1, flow: 1, smoothing: 0.5, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5 },
+    impasto: { tool: "gloop", thickness: 1, gloss: 0.9, load: 1, drag: 0 }
+  }),
+  builtin({
+    id: "metallic-paint",
+    name: "Metallic paint",
+    category: "impasto",
+    engine: "impasto",
+    rotation: "stroke",
+    tip: { size: 30, hardness: 0.8, spacing: 0.06, angle: 90, roundness: 0.6, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5 },
+    behavior: { pickup: 0.2, mix: 0.4, mixing: "pigment" },
+    impasto: { tool: "brush", thickness: 0.45, gloss: 0.8, metallic: 1, load: 0.95, drag: 0.3 }
+  }),
+  builtin({
+    id: "hair-strands",
+    name: "Hair strands",
+    category: "procedural",
+    engine: "particle",
+    tip: { size: 40, hardness: 0.8, opacity: 0.9, flow: 0.6, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    particle: { kind: "string", render: "line", count: 22, size: 0.025, spread: 1, stiffness: 0.08, damping: 0.3 }
+  }),
+  builtin({
+    id: "spring-ink",
+    name: "Spring ink",
+    category: "procedural",
+    engine: "particle",
+    tip: { size: 30, hardness: 0.9, opacity: 1, flow: 0.8, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "spring", render: "line", count: 5, size: 0.08, spread: 0.6, stiffness: 0.2, damping: 0.1 }
+  }),
+  builtin({
+    id: "orbit-curls",
+    name: "Orbit curls",
+    category: "procedural",
+    engine: "particle",
+    tip: { size: 36, hardness: 0.85, opacity: 0.9, flow: 0.7, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "orbit", render: "line", count: 4, size: 0.05, spread: 0.6, speed: 0.45 }
+  }),
+  builtin({
+    id: "flow-fur",
+    name: "Flow fur",
+    category: "procedural",
+    engine: "particle",
+    tip: { size: 50, hardness: 0.7, opacity: 0.8, flow: 0.5, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    particle: { kind: "flow", render: "line", count: 10, size: 0.03, spread: 0.6, speed: 0.5, life: 0.25 }
+  }),
+  builtin({
+    id: "bead-trail",
+    name: "Bead trail",
+    category: "procedural",
+    engine: "particle",
+    tip: { size: 34, hardness: 0.9, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "spring", render: "sequence", count: 3, size: 0.18, spread: 0.5, stiffness: 0.3, damping: 0.3, interval: 0.4 }
+  }),
+  builtin({
+    id: "sparkle-dust",
+    name: "Sparkle dust",
+    category: "procedural",
+    engine: "particle",
+    tip: { size: 60, hardness: 0.6, opacity: 1, flow: 0.9, smoothing: 0.1, pressureSize: true, pressureOpacity: true },
+    particle: { kind: "flow", render: "dot", count: 6, size: 0.05, spread: 0.9, speed: 0.7, life: 0.4 }
+  }),
+  builtin({
+    id: "bristle-round",
+    name: "Bristle round",
+    category: "bristle",
+    engine: "bristle",
+    rotation: "stroke",
+    tip: { size: 30, hardness: 0.85, opacity: 1, flow: 0.9, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.4, tiltSize: 0.6, tiltRoundness: 0.6 },
+    bristle: { count: 28, stiffness: 0.45, splay: 0.6, thickness: 0.035, load: 0.7, jitter: 0.5 }
+  }),
+  builtin({
+    id: "bristle-flat",
+    name: "Bristle flat",
+    category: "bristle",
+    engine: "bristle",
+    rotation: "stroke",
+    tip: { size: 46, hardness: 0.85, angle: 90, roundness: 0.3, opacity: 1, flow: 0.9, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5, tiltSize: 0.5 },
+    bristle: { count: 40, stiffness: 0.6, splay: 0.4, thickness: 0.025, load: 0.65, jitter: 0.45 }
+  }),
+  builtin({
+    id: "dry-brush",
+    name: "Dry brush",
+    category: "bristle",
+    engine: "bristle",
+    rotation: "stroke",
+    tip: { size: 44, hardness: 0.9, angle: 90, roundness: 0.45, opacity: 1, flow: 0.8, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    grain: 0.6,
+    bristle: { count: 48, stiffness: 0.35, splay: 0.7, thickness: 0.05, load: 0.15, jitter: 0.8 }
+  }),
+  // Light paint: brushes that lay light with their colour (glow and spill; see light.ts).
+  builtin({
+    id: "glow-gel",
+    name: "Glow gel",
+    category: "light",
+    engine: "impasto",
+    tip: { size: 16, hardness: 0.9, spacing: 0.05, opacity: 1, flow: 1, smoothing: 0.5, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.6 },
+    impasto: { tool: "gloop", thickness: 1, gloss: 0.95, load: 1, drag: 0, rim: 0.8, clarity: 0.5 },
+    light: { amount: 0.85 }
+  }),
+  builtin({
+    id: "neon-marker",
+    name: "Neon marker",
+    category: "light",
+    tip: { size: 10, hardness: 0.9, spacing: 0.04, opacity: 1, flow: 1, smoothing: 0.45, pressureSize: false, pressureOpacity: false },
+    light: { amount: 1 }
+  }),
+  builtin({
+    id: "light-airbrush",
+    name: "Light airbrush",
+    category: "light",
+    tip: { size: 90, hardness: 0, spacing: 0.04, opacity: 1, flow: 0.06, smoothing: 0.3, pressureSize: false, pressureOpacity: false },
+    pressureSmoothing: 0.3,
+    dynamics: { pressureFlow: 1 },
+    light: { amount: 0.7, pressure: true }
+  }),
+  builtin({
+    id: "spark-trail",
+    name: "Spark trail",
+    category: "light",
+    engine: "particle",
+    tip: { size: 50, hardness: 0.7, opacity: 1, flow: 1, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "dot", count: 8, size: 0.06, spread: 0.7, speed: 0.9, life: 0.3 },
+    light: { amount: 1 }
+  }),
+  builtin({
+    // Silk of light: strands dragged behind the pen on slow waves, the bands between them filled.
+    id: "light-ribbon",
+    name: "Light ribbon",
+    category: "light",
+    engine: "particle",
+    tip: { size: 80, hardness: 0.8, opacity: 0.9, flow: 1, smoothing: 0.35, pressureSize: false, pressureOpacity: false },
+    particle: { kind: "string", render: "ribbon", count: 5, size: 0.015, spread: 1, stiffness: 0.05, damping: 0.3, ribbonFill: 0.45, waveAmplitude: 0.25, waveLength: 220, wavePhaseJitter: 0.25 },
+    light: { amount: 0.8 }
+  }),
+  builtin({
+    // Flames: short-lived bands thrown off the pen, rising and curling in the flow.
+    id: "flame-ribbon",
+    name: "Flame ribbon",
+    category: "light",
+    engine: "particle",
+    tip: { size: 50, hardness: 0.6, opacity: 0.85, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "ribbon", count: 4, size: 0.012, spread: 0.5, speed: 0.6, gravity: -0.6, life: 0.2, ribbonFill: 0.5 },
+    light: { amount: 1 }
+  }),
+  builtin({
+    // A neon tube that lags and snaps back, with a slow shimmer.
+    id: "neon-strand",
+    name: "Neon strand",
+    category: "light",
+    engine: "particle",
+    tip: { size: 40, hardness: 0.9, opacity: 1, flow: 1, smoothing: 0.4, pressureSize: false, pressureOpacity: false },
+    particle: { kind: "elastic", render: "line", count: 3, size: 0.05, spread: 0.25, stiffness: 0.6, damping: 0.3, waveAmplitude: 0.06, waveLength: 120 },
+    light: { amount: 1 }
+  }),
+  builtin({
+    // Smoke lit from within: thin bands thrown into a slow, rising flow.
+    id: "smoke-ribbon",
+    name: "Smoke ribbon",
+    category: "light",
+    engine: "particle",
+    tip: { size: 70, hardness: 0.3, opacity: 0.45, flow: 1, smoothing: 0.3, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "ribbon", count: 3, size: 5e-3, spread: 0.5, speed: 0.15, gravity: -0.15, life: 0.35, ribbonFill: 0.25, waveAmplitude: 0.1, waveLength: 140, wavePhaseJitter: 1 },
+    light: { amount: 0.3 }
+  }),
+  builtin({
+    // Out-of-focus lights: soft discs and rings spaced along springy paths.
+    id: "bokeh-dots",
+    name: "Bokeh dots",
+    category: "light",
+    engine: "particle",
+    tip: { size: 80, hardness: 0.7, opacity: 0.6, flow: 1, smoothing: 0.3, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "spring", render: "sequence", count: 3, size: 0.3, spread: 1, stiffness: 0.15, damping: 0.4, interval: 1, dotTextures: ["dot", "dot", "ring"], dotTextureOrder: "random" },
+    light: { amount: 0.9 }
+  }),
+  builtin({
+    // Sparks: twinkles and stars thrown into the flow, spaced along it.
+    id: "twinkle-sparks",
+    name: "Twinkle sparks",
+    category: "light",
+    engine: "particle",
+    tip: { size: 50, hardness: 0.8, opacity: 1, flow: 1, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "sequence", count: 3, size: 0.25, spread: 0.8, speed: 0.9, life: 0.35, interval: 0.6, dotTextures: ["sparkle", "sparkle", "star"], dotTextureOrder: "random", dotRotation: "random" },
+    light: { amount: 1 }
+  }),
+  builtin({
+    id: "glow-wash",
+    name: "Glow wash",
+    category: "light",
+    engine: "wet",
+    tip: { size: 40, hardness: 0.55, spacing: 0.12, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: true },
+    dynamics: { minSize: 0.35 },
+    behavior: { pickup: 0.4, mix: 0.5, mixing: "pigment" },
+    wet: { tool: "paint", water: 0.65, pigment: 0.75, body: 0, rewet: 0.1 },
+    light: { amount: 0.7 }
+  }),
+  builtin({
+    // Fluorescent ink: a transparent chisel marker that multiplies (text under it stays dark) and
+    // glows a little brighter than the paper. Turn the layer's spill off (set_light_spill radius 0).
+    id: "highlighter",
+    name: "Highlighter",
+    category: "light",
+    tip: { size: 30, hardness: 0.85, spacing: 0.04, angle: 45, roundness: 0.35, opacity: 0.6, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: false, blend: "multiply" },
+    grain: 0.05,
+    light: { amount: 0.5 }
+  }),
+  builtin({
+    id: "sticker-stars",
+    name: "Star stickers",
+    category: "sticker",
+    engine: "sticker",
+    tip: { size: 36, opacity: 1, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5 },
+    sticker: { stamps: ["star", "sparkle"], density: 0.35, sizeJitter: 0.5, rotationJitter: 1, scatter: 0.6, colorJitter: 0.3 }
+  }),
+  builtin({
+    id: "sticker-leaves",
+    name: "Leaf stickers",
+    category: "sticker",
+    engine: "sticker",
+    rotation: "stroke",
+    tip: { size: 40, opacity: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    dynamics: { minSize: 0.5 },
+    sticker: { stamps: ["leaf"], density: 0.5, sizeJitter: 0.4, rotationJitter: 0.35, scatter: 0.4, colorJitter: 0.35 }
+  }),
+  builtin({
+    id: "sticker-confetti",
+    name: "Confetti",
+    category: "sticker",
+    engine: "sticker",
+    tip: { size: 22, opacity: 1, smoothing: 0.1, pressureSize: false, pressureOpacity: false },
+    sticker: { stamps: ["confetti", "dot", "ring"], density: 0.7, sizeJitter: 0.5, rotationJitter: 1, scatter: 1.5, colorJitter: 1 }
+  }),
+  builtin({
+    id: "sticker-flowers",
+    name: "Flower stickers",
+    category: "sticker",
+    engine: "sticker",
+    tip: { size: 44, opacity: 1, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    sticker: { stamps: ["flower", "heart"], density: 0.3, sizeJitter: 0.5, rotationJitter: 1, scatter: 0.7, colorJitter: 0.4 }
+  }),
+  builtin({
+    id: "sticker-splats",
+    name: "Paint splats",
+    category: "sticker",
+    engine: "sticker",
+    tip: { size: 50, opacity: 0.95, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    sticker: { stamps: ["splat"], density: 0.25, sizeJitter: 0.6, rotationJitter: 1, scatter: 0.8, colorJitter: 0.15 }
+  }),
+  builtin({
+    id: "add-water",
+    name: "Add water",
+    category: "wet-tool",
+    engine: "wet",
+    tip: { size: 40, hardness: 0.4, spacing: 0.12, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: true },
+    dynamics: { minSize: 0.5 },
+    wet: { tool: "water", water: 0.6, pigment: 0, rewet: 0.3 }
+  }),
+  builtin({
+    id: "hair-dryer",
+    name: "Dry",
+    category: "wet-tool",
+    engine: "wet",
+    tip: { size: 80, hardness: 0.1, spacing: 0.15, opacity: 1, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: true },
+    wet: { tool: "dry", strength: 0.5 }
+  }),
+  builtin({
+    id: "blow",
+    name: "Blow",
+    category: "wet-tool",
+    engine: "wet",
+    tip: { size: 50, hardness: 0.2, spacing: 0.1, opacity: 1, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: true },
+    wet: { tool: "blow", strength: 0.6 }
+  }),
+  builtin({
+    id: "wet-blend",
+    name: "Wet blend",
+    category: "wet-tool",
+    engine: "wet",
+    tip: { size: 36, hardness: 0.3, spacing: 0.1, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: false, pressureOpacity: true },
+    wet: { tool: "blend", strength: 0.4 }
+  }),
+  builtin({
+    id: "wet-drag",
+    name: "Wet smudge",
+    category: "wet-tool",
+    engine: "wet",
+    tip: { size: 30, hardness: 0.5, spacing: 0.08, opacity: 1, flow: 1, smoothing: 0.25, pressureSize: false, pressureOpacity: true },
+    wet: { tool: "smudge", strength: 0.6 }
+  }),
+  builtin({
+    id: "blot",
+    name: "Blot (erase wet)",
+    category: "wet-tool",
+    engine: "wet",
+    tip: { size: 40, hardness: 0.5, spacing: 0.12, opacity: 1, flow: 1, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    wet: { tool: "blot", strength: 0.7 }
+  })
+];
+var DEFAULT_BRUSH_ID = "pencil-6b";
+function brushToJSON(brush) {
+  const { builtin: _b, ...rest } = brush;
+  return JSON.parse(JSON.stringify(rest));
+}
+function parseBrushLibrary(raw, problems = []) {
+  const list2 = Array.isArray(raw) ? raw : raw && typeof raw === "object" && Array.isArray(raw.brushes) ? raw.brushes : null;
+  if (!list2) throw new Error('Not a brush library: expected {"format":"pixerate-brushes","version":1,"brushes":[...]} or an array of brushes.');
+  const out = [];
+  list2.forEach((item, i) => {
+    if (!item || typeof item !== "object") {
+      problems.push(`brushes[${i}] is not an object; skipped.`);
+      return;
+    }
+    const r = item;
+    if (typeof r.id !== "string" || !BRUSH_ID.test(r.id)) {
+      problems.push(`brushes[${i}] has no valid id (lowercase letters, digits and dashes); skipped.`);
+      return;
+    }
+    if (typeof r.name !== "string" || !r.name.trim()) {
+      problems.push(`brushes[${i}] ("${r.id}") has no name; skipped.`);
+      return;
+    }
+    const { builtin: _b, ...rest } = r;
+    out.push(normalizePaintBrush(rest));
+  });
+  return out;
+}
+
 // src/brushes/resolve.ts
 var ALL = ["dab", "eraser", "mixer", "blender", "smudge", "wet", "impasto", "particle", "bristle", "sticker"];
 var EXCHANGE = ["dab", "wet", "impasto"];
@@ -38,7 +999,7 @@ var EDITOR_STAMPS = {
     try {
       const stamp = _chunkJSDND7DFcjs.editorStampOf.call(void 0, ref);
       return stamp ? [stamp] : [];
-    } catch (e2) {
+    } catch (e3) {
       return [];
     }
   }),
@@ -111,13 +1072,13 @@ function setPath(o, path, value) {
 var copy = (v) => v !== null && typeof v === "object" ? JSON.parse(JSON.stringify(v)) : v;
 function resolveEngine(brush) {
   if (brush.kind === "tool") return brush.tool === "eraser" || brush.tool === "blender" || brush.tool === "smudge" ? brush.tool : "wet";
-  if (_optionalChain([brush, 'access', _ => _.marks, 'optionalAccess', _2 => _2.kind]) === "particles") return "particle";
-  if (_optionalChain([brush, 'access', _3 => _3.marks, 'optionalAccess', _4 => _4.kind]) === "objects") return "sticker";
+  if (_optionalChain([brush, 'access', _2 => _2.marks, 'optionalAccess', _3 => _3.kind]) === "particles") return "particle";
+  if (_optionalChain([brush, 'access', _4 => _4.marks, 'optionalAccess', _5 => _5.kind]) === "objects") return "sticker";
   if (brush.tip.shape === "bristle") return "bristle";
-  const surface = _optionalChain([brush, 'access', _5 => _5.behaviour, 'optionalAccess', _6 => _6.surface]);
+  const surface = _optionalChain([brush, 'access', _6 => _6.behaviour, 'optionalAccess', _7 => _7.surface]);
   if (surface === "thick") return "impasto";
   if (surface === "wet") return "wet";
-  if (_optionalChain([brush, 'access', _7 => _7.behaviour, 'optionalAccess', _8 => _8.exchange, 'optionalAccess', _9 => _9.reservoir])) return "mixer";
+  if (_optionalChain([brush, 'access', _8 => _8.behaviour, 'optionalAccess', _9 => _9.exchange, 'optionalAccess', _10 => _10.reservoir])) return "mixer";
   return "dab";
 }
 var VARIETY_CATEGORY = {
@@ -131,11 +1092,11 @@ var VARIETY_CATEGORY = {
 };
 var MEDIUM_CATEGORY = { paint: "paint", ink: "ink", dry: "pencil", spray: "airbrush" };
 function resolveWetMedium(brush) {
-  return _nullishCoalesce(_optionalChain([brush, 'access', _10 => _10.behaviour, 'optionalAccess', _11 => _11.wet, 'optionalAccess', _12 => _12.medium]), () => ( (_chunkHS6QDWDFcjs.WET_MEDIA.includes(brush.variety) ? brush.variety : void 0)));
+  return _nullishCoalesce(_optionalChain([brush, 'access', _11 => _11.behaviour, 'optionalAccess', _12 => _12.wet, 'optionalAccess', _13 => _13.medium]), () => ( (WET_MEDIA.includes(brush.variety) ? brush.variety : void 0)));
 }
 function resolveCategory(brush, engine = resolveEngine(brush)) {
   if (brush.kind === "tool") return brush.tool === "eraser" || brush.tool === "blender" || brush.tool === "smudge" ? brush.tool : "wet-tool";
-  if ((_nullishCoalesce(_optionalChain([brush, 'access', _13 => _13.light, 'optionalAccess', _14 => _14.amount]), () => ( 0))) > 0) return "light";
+  if ((_nullishCoalesce(_optionalChain([brush, 'access', _14 => _14.light, 'optionalAccess', _15 => _15.amount]), () => ( 0))) > 0) return "light";
   switch (engine) {
     case "particle":
       return "procedural";
@@ -167,9 +1128,9 @@ function resolveBrush(brush, options = {}) {
     if (medium) setPath(input, "wet.medium", medium);
   }
   if (engine === "blender" || engine === "smudge") input.loadsColor = false;
-  const paint = _optionalChain([brush, 'access', _15 => _15.colour, 'optionalAccess', _16 => _16.default]);
+  const paint = _optionalChain([brush, 'access', _16 => _16.colour, 'optionalAccess', _17 => _17.default]);
   if (paint && typeof paint === "object" && "type" in paint && paint.type === "gradient") input.paint = copy(paint);
-  return _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, { ...input, ...options.builtin ? { builtin: true } : {} });
+  return normalizePaintBrush({ ...input, ...options.builtin ? { builtin: true } : {} });
 }
 
 // src/brushes/migrate.ts
@@ -218,7 +1179,7 @@ function skeleton(b) {
 }
 var ORDER = ["id", "name", "description", "tags", "kind", "medium", "variety", "tool", "tip", "marks", "dynamics", "behaviour", "light", "motion", "colour"];
 function migrateBrushV1(raw) {
-  const b = _chunkHS6QDWDFcjs.normalizePaintBrush.call(void 0, raw);
+  const b = normalizePaintBrush(raw);
   const brush = skeleton(b);
   const defaults = resolveBrush(brush);
   for (const field of BRUSH_FIELDS) {
@@ -241,11 +1202,11 @@ var BRUSH_SURFACES = ["dry", "wet", "thick"];
 // src/brushes/schema.ts
 var MAX_BRUSH_PALETTE = 16;
 var BRUSH_WORD = /^[a-z0-9][a-z0-9-]{0,39}$/;
-var unit = (description) => ({ type: "number", minimum: 0, maximum: 1, description });
+var unit3 = (description) => ({ type: "number", minimum: 0, maximum: 1, description });
 var num = (minimum, maximum, description) => ({ type: "number", minimum, maximum, description });
 var int = (minimum, maximum, description) => ({ type: "integer", minimum, maximum, description });
 var bool = (description) => ({ type: "boolean", description });
-var oneOf = (values, description) => ({ type: "string", enum: [...values], description });
+var oneOf2 = (values, description) => ({ type: "string", enum: [...values], description });
 var object = (description, properties, required) => ({
   type: "object",
   description,
@@ -253,7 +1214,7 @@ var object = (description, properties, required) => ({
   ...required ? { required } : {},
   additionalProperties: false
 });
-var MIXING = oneOf(["pigment", "rgb"], "How colours mix: pigment (Kubelka-Munk, blue and yellow make green) or rgb (straight averages). Default pigment; a Mixer Brush and the smudge tool default to rgb.");
+var MIXING = oneOf2(["pigment", "rgb"], "How colours mix: pigment (Kubelka-Munk, blue and yellow make green) or rgb (straight averages). Default pigment; a Mixer Brush and the smudge tool default to rgb.");
 var BRUSH_STAMP_PATTERN = `^(?:[^:\\s]+:\\S+|${_chunkJSDND7DFcjs.STAMP_KINDS.join("|")})$`;
 var STAMP = {
   type: "string",
@@ -262,24 +1223,24 @@ var STAMP = {
 };
 var BRISTLES = object("Bristle tips: the tuft. Missing fields take their defaults.", {
   count: int(3, 128, "Bristles in the tuft (default 32)."),
-  stiffness: unit("Stiff bristles follow the tip; soft ones lag and bend into curves at turns (default 0.5)."),
-  splay: unit("How far pressure spreads the tuft (default 0.5)."),
-  thickness: unit("Each bristle's line width as a fraction of the tip size (default 0.06)."),
-  load: unit("Paint per bristle: 1 never runs dry; lower, bristles run out along the stroke, a dry brush (default 0.6)."),
-  jitter: unit("Random variation between bristles: length, paint, position (default 0.4).")
+  stiffness: unit3("Stiff bristles follow the tip; soft ones lag and bend into curves at turns (default 0.5)."),
+  splay: unit3("How far pressure spreads the tuft (default 0.5)."),
+  thickness: unit3("Each bristle's line width as a fraction of the tip size (default 0.06)."),
+  load: unit3("Paint per bristle: 1 never runs dry; lower, bristles run out along the stroke, a dry brush (default 0.6)."),
+  jitter: unit3("Random variation between bristles: length, paint, position (default 0.4).")
 });
 var TIP = object(
   "The tip: its shape and the dab it lays.",
   {
-    shape: oneOf(BRUSH_TIP_SHAPES, "round, flat, chisel: an ellipse set by roundness and angle (the name is for people); bristle: a tuft of bristles (see bristle); stamp: textured stamps (see stamps), laid as objects or particles."),
+    shape: oneOf2(BRUSH_TIP_SHAPES, "round, flat, chisel: an ellipse set by roundness and angle (the name is for people); bristle: a tuft of bristles (see bristle); stamp: textured stamps (see stamps), laid as objects or particles."),
     size: num(1, _chunkFQPUF2W2cjs.MAX_BRUSH_SIZE, "Diameter in px (default 20)."),
-    hardness: unit("Edge hardness, 0 soft .. 1 hard (default 1)."),
+    hardness: unit3("Edge hardness, 0 soft .. 1 hard (default 1)."),
     spacing: num(0.01, 10, "Dab spacing as a fraction of the diameter: 0.05 smooth, 1 dotted (default 0.1)."),
     angle: num(-360, 360, "Tip angle in degrees, counter-clockwise; added to the stroke direction or barrel with dynamics.rotation (default 0)."),
     roundness: num(0.01, 1, "Roundness: 1 round (default), lower a flat ellipse (pastel, chisel)."),
-    opacity: unit("Stroke opacity ceiling: overlapping dabs never exceed it (default 1)."),
-    flow: unit("Build-up per dab towards the opacity: low flow builds softly, like an airbrush (default 1)."),
-    blend: oneOf(
+    opacity: unit3("Stroke opacity ceiling: overlapping dabs never exceed it (default 1)."),
+    flow: unit3("Build-up per dab towards the opacity: low flow builds softly, like an airbrush (default 1)."),
+    blend: oneOf2(
       _chunk2VX55NFMcjs.BLEND_MODES.map((m) => m.id),
       "How the stroke paints onto the layer (default normal). pigment mixes like real paint; multiply darkens like marker ink; watercolor glazes; tint, highlight and shadow recolour, light and shade."
     ),
@@ -287,9 +1248,9 @@ var TIP = object(
     stamps: {
       type: "array",
       minItems: 1,
-      maxItems: _chunkHS6QDWDFcjs.MAX_STICKER_STAMPS,
+      maxItems: MAX_STICKER_STAMPS,
       items: STAMP,
-      description: `Stamp tips: the stickers. Objects take any sticker and pick one at random per mark (default editor:star; repeats count once); particles take only the editor's stamps, use the first ${_chunkHS6QDWDFcjs.MAX_DOT_TEXTURES} in marks.stampOrder, and repeats weight the order.`
+      description: `Stamp tips: the stickers. Objects take any sticker and pick one at random per mark (default editor:star; repeats count once); particles take only the editor's stamps, use the first ${MAX_DOT_TEXTURES} in marks.stampOrder, and repeats weight the order.`
     }
   },
   ["shape"]
@@ -299,27 +1260,27 @@ var PARTICLES = object(
   "Particles that move with the pen and draw as they go. Missing fields take their defaults.",
   {
     kind: { type: "string", const: "particles", description: 'Always "particles".' },
-    physics: oneOf(
-      _chunkHS6QDWDFcjs.PARTICLE_KINDS,
+    physics: oneOf2(
+      PARTICLE_KINDS,
       "How the particles move (default spring). string: strands dragged behind the pen (hair, fur); spring: on springs to the pen, overshooting; orbit: circling the pen (curls); flow: thrown into a swirling flow until they fade; elastic: links that stretch and snap back; fuzzy: winding strings waving out of step."
     ),
-    render: oneOf(_chunkHS6QDWDFcjs.PARTICLE_RENDERS, "How they draw (default line). dot: a mark per step; line: a continuous line each; sequence: beads spaced along each path; ribbon: the band between neighbouring paths filled."),
+    render: oneOf2(PARTICLE_RENDERS, "How they draw (default line). dot: a mark per step; line: a continuous line each; sequence: beads spaced along each path; ribbon: the band between neighbouring paths filled."),
     count: int(1, 64, "Particles (flow: thrown per tip of travel). Default 12."),
-    size: unit("Mark size as a fraction of the tip size; ribbon: its edge width (default 0.08)."),
-    spread: unit("How far apart they start, as a fraction of the tip size; ribbon: its width (default 0.5)."),
-    stiffness: unit("Spring, string and elastic stiffness: stiff follows closely, soft swings wide (default 0.4)."),
-    damping: unit("How quickly motion dies down (default 0.25)."),
-    speed: unit("Orbit and flow speed (default 0.5)."),
+    size: unit3("Mark size as a fraction of the tip size; ribbon: its edge width (default 0.08)."),
+    spread: unit3("How far apart they start, as a fraction of the tip size; ribbon: its width (default 0.5)."),
+    stiffness: unit3("Spring, string and elastic stiffness: stiff follows closely, soft swings wide (default 0.4)."),
+    damping: unit3("How quickly motion dies down (default 0.25)."),
+    speed: unit3("Orbit and flow speed (default 0.5)."),
     gravity: num(-1, 1, "Pull downwards; negative pulls up (default 0)."),
-    life: unit("Flow particles: how long they live (default 0.5)."),
-    interval: unit("Sequence: spacing of the beads (default 0.3)."),
-    ribbonFill: unit("Ribbon: fill opacity between the paths, relative to their edges (default 0.5; 0 only edges)."),
-    ribbonPairs: oneOf(_chunkHS6QDWDFcjs.RIBBON_PAIRS, "Ribbon: adjacent (default) joins each particle to its neighbour; first-last makes one band between the outermost two."),
-    waveAmplitude: unit("Wave: sideways swing as a fraction of the tip size (default 0: no wave)."),
+    life: unit3("Flow particles: how long they live (default 0.5)."),
+    interval: unit3("Sequence: spacing of the beads (default 0.3)."),
+    ribbonFill: unit3("Ribbon: fill opacity between the paths, relative to their edges (default 0.5; 0 only edges)."),
+    ribbonPairs: oneOf2(RIBBON_PAIRS, "Ribbon: adjacent (default) joins each particle to its neighbour; first-last makes one band between the outermost two."),
+    waveAmplitude: unit3("Wave: sideways swing as a fraction of the tip size (default 0: no wave)."),
     waveLength: num(4, 2e3, "Wave: wavelength in px of pen travel (default 60)."),
-    wavePhaseJitter: unit("Wave: how far out of step the particles' waves are; 0 in step, 1 random phases (default 0)."),
-    stampOrder: oneOf(_chunkHS6QDWDFcjs.DOT_TEXTURE_ORDERS, "Stamp tips: sequence (default) uses the stamps in turn; random picks one per dot, seeded."),
-    stampRotation: oneOf(_chunkHS6QDWDFcjs.DOT_ROTATIONS, "Stamp tips: follow turns each with its particle's motion; random (default); fixed uses the tip angle.")
+    wavePhaseJitter: unit3("Wave: how far out of step the particles' waves are; 0 in step, 1 random phases (default 0)."),
+    stampOrder: oneOf2(DOT_TEXTURE_ORDERS, "Stamp tips: sequence (default) uses the stamps in turn; random picks one per dot, seeded."),
+    stampRotation: oneOf2(DOT_ROTATIONS, "Stamp tips: follow turns each with its particle's motion; random (default); fixed uses the tip angle.")
   },
   ["kind"]
 );
@@ -327,11 +1288,11 @@ var OBJECTS = object(
   "Each mark stays an editable object (a sticker) on a sticker layer; needs a stamp tip. Missing fields take their defaults.",
   {
     kind: { type: "string", const: "objects", description: 'Always "objects".' },
-    density: unit("About density \xD7 4 marks per tip diameter of travel; 0.25 \u2248 one per diameter (default 0.4)."),
-    sizeJitter: unit("Random size change (default 0.4)."),
-    rotationJitter: unit("Random turn as a fraction of \xB1180\xB0 (default 1)."),
+    density: unit3("About density \xD7 4 marks per tip diameter of travel; 0.25 \u2248 one per diameter (default 0.4)."),
+    sizeJitter: unit3("Random size change (default 0.4)."),
+    rotationJitter: unit3("Random turn as a fraction of \xB1180\xB0 (default 1)."),
     scatter: num(0, 2, "How far from the path marks land, in tip diameters (default 0.5)."),
-    colourJitter: unit("Random colour change: at 1 up to \xB140\xB0 of hue and \xB10.15 OKLab lightness (default 0.2).")
+    colourJitter: unit3("Random colour change: at 1 up to \xB140\xB0 of hue and \xB10.15 OKLab lightness (default 0.2).")
   },
   ["kind"]
 );
@@ -340,62 +1301,62 @@ var DYNAMICS = object("Pen feel: pressure, tilt, velocity, jitter, rotation and
   pressureOpacity: bool("Pressure scales the opacity (default false)."),
   smoothing: num(0, 0.95, "Position smoothing of the input (default 0)."),
   pressureSmoothing: num(0, 0.95, "Pressure smoothing, separate from position smoothing (default 0)."),
-  rotation: oneOf(_chunkHS6QDWDFcjs.BRUSH_ROTATIONS, "What turns the tip: fixed (tip.angle, default), stroke (direction of travel) or barrel (pen barrel rotation)."),
-  minSize: unit("Size at zero pressure as a fraction of the full size, with pressureSize (default 0)."),
-  pressureFlow: unit("How much pressure scales flow (default 0)."),
-  tiltSize: unit("Laying the pen down widens the tip, up to 2.5\xD7 (default 0)."),
-  tiltRoundness: unit("Laying the pen down flattens the tip along the tilt, side-of-the-pencil shading (default 0)."),
-  tiltOpacity: unit("Laying the pen down lightens the mark (default 0)."),
+  rotation: oneOf2(BRUSH_ROTATIONS, "What turns the tip: fixed (tip.angle, default), stroke (direction of travel) or barrel (pen barrel rotation)."),
+  minSize: unit3("Size at zero pressure as a fraction of the full size, with pressureSize (default 0)."),
+  pressureFlow: unit3("How much pressure scales flow (default 0)."),
+  tiltSize: unit3("Laying the pen down widens the tip, up to 2.5\xD7 (default 0)."),
+  tiltRoundness: unit3("Laying the pen down flattens the tip along the tilt, side-of-the-pencil shading (default 0)."),
+  tiltOpacity: unit3("Laying the pen down lightens the mark (default 0)."),
   velocitySize: num(-1, 1, "Positive grows the tip on fast strokes, negative thins it; needs timed points (default 0)."),
   velocityOpacity: num(-1, 1, "Positive darkens fast marks, negative lightens them; needs timed points (default 0)."),
-  sizeJitter: unit("Random size change per dab (default 0)."),
-  angleJitter: unit("Random angle per dab, as a fraction of \xB1180\xB0 (default 0)."),
-  opacityJitter: unit("Random opacity drop per dab (default 0)."),
+  sizeJitter: unit3("Random size change per dab (default 0)."),
+  angleJitter: unit3("Random angle per dab, as a fraction of \xB1180\xB0 (default 0)."),
+  opacityJitter: unit3("Random opacity drop per dab (default 0)."),
   scatter: num(0, 4, "Random offset across the stroke, in diameters (default 0).")
 });
 var EXCHANGE2 = object("Paint exchange with the canvas: picking up paint and mixing it into what the brush lays. Paint brushes on a dry, wet or thick surface and Mixer Brushes.", {
-  pickup: unit("Pick-up ratio: how much of the paint under each dab the brush lifts and carries (default 0; with a reservoir 0.5)."),
-  mix: unit("Mix ratio: how much of the carried paint goes into what the brush lays, against its own colour (default 0.5)."),
+  pickup: unit3("Pick-up ratio: how much of the paint under each dab the brush lifts and carries (default 0; with a reservoir 0.5)."),
+  mix: unit3("Mix ratio: how much of the carried paint goes into what the brush lays, against its own colour (default 0.5)."),
   dirty: bool("Keep the carried paint after the stroke, so the next one starts with the last colour touched (default false)."),
   reservoir: object("A paint reservoir makes this a Mixer Brush (an empty object takes every default).", {
-    load: unit("How much paint the reservoir holds; below 1 it drains per dab and long strokes run dry (default 0.5)."),
+    load: unit3("How much paint the reservoir holds; below 1 it drains per dab and long strokes run dry (default 0.5)."),
     refill: bool("Refill with the paint colour before each stroke (default true)."),
     loadsColour: bool("Load the current colour at all (default true; false: it only moves paint already down).")
   })
 });
 var WET = object("Wet surface (watercolour, gouache, wet oil) and the wet tools. Missing fields take their defaults.", {
-  medium: oneOf(_chunkHS6QDWDFcjs.WET_MEDIA, "The wet medium; a layer takes the medium's wet settings the first time it holds wet paint (default: the variety when it is watercolor, gouache or oil, else watercolor)."),
-  water: unit("Wetness: water laid, 0.2 a damp brush .. 1 dripping (default 0.5)."),
-  pigment: unit("Pigment concentration: 0 clear water .. 1 straight from the tube (default 0.5)."),
-  body: unit("Body: 0 transparent watercolour .. 1 opaque gouache (default 0)."),
-  rewet: unit("How much dried paint the water lifts again: 0 staining (default 0)."),
-  load: unit("Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (default 1)."),
-  thinner: unit("Thinner (water or solvent): more transparent, runnier paint (default 0).")
+  medium: oneOf2(WET_MEDIA, "The wet medium; a layer takes the medium's wet settings the first time it holds wet paint (default: the variety when it is watercolor, gouache or oil, else watercolor)."),
+  water: unit3("Wetness: water laid, 0.2 a damp brush .. 1 dripping (default 0.5)."),
+  pigment: unit3("Pigment concentration: 0 clear water .. 1 straight from the tube (default 0.5)."),
+  body: unit3("Body: 0 transparent watercolour .. 1 opaque gouache (default 0)."),
+  rewet: unit3("How much dried paint the water lifts again: 0 staining (default 0)."),
+  load: unit3("Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (default 1)."),
+  thinner: unit3("Thinner (water or solvent): more transparent, runnier paint (default 0).")
 });
 var THICK = object("Thick surface (impasto: paint with relief, lit by the canvas lighting). Missing fields take their defaults.", {
-  applicator: oneOf(_chunkHS6QDWDFcjs.IMPASTO_TOOLS, "What lays the paint (default brush). brush: bristle ridges; tube: blobs squeezed from the tube; knife: scrapes the relief flat and smears; roller: a flat stippled band; gloop: a thick glossy bead."),
-  thickness: unit("How far the paint stands up (default 0.6)."),
-  gloss: unit("Shine: 0 matte .. 1 wet-looking gloss (default 0.4)."),
-  metallic: unit("Metallic: highlights take the paint colour, gold, copper, silver (default 0)."),
-  load: unit("Paint loading: 1 never runs out; lower, the stroke thins as the brush empties (default 0.9)."),
-  thinner: unit("Thinner: flatter, more transparent paint (default 0)."),
-  drag: unit("Knife and brush: how much of the paint under the tool is dragged along (default 0.4)."),
-  rim: unit("Light paint: light is stronger where the bead turns away, as on backlit glass (default 0)."),
-  clarity: unit("Glassy paint: the middle of a bead lets the layers below show through (default 0).")
+  applicator: oneOf2(IMPASTO_TOOLS, "What lays the paint (default brush). brush: bristle ridges; tube: blobs squeezed from the tube; knife: scrapes the relief flat and smears; roller: a flat stippled band; gloop: a thick glossy bead."),
+  thickness: unit3("How far the paint stands up (default 0.6)."),
+  gloss: unit3("Shine: 0 matte .. 1 wet-looking gloss (default 0.4)."),
+  metallic: unit3("Metallic: highlights take the paint colour, gold, copper, silver (default 0)."),
+  load: unit3("Paint loading: 1 never runs out; lower, the stroke thins as the brush empties (default 0.9)."),
+  thinner: unit3("Thinner: flatter, more transparent paint (default 0)."),
+  drag: unit3("Knife and brush: how much of the paint under the tool is dragged along (default 0.4)."),
+  rim: unit3("Light paint: light is stronger where the bead turns away, as on backlit glass (default 0)."),
+  clarity: unit3("Glassy paint: the middle of a bead lets the layers below show through (default 0).")
 });
 var BEHAVIOUR = object("What the material does on the surface, and how tools work. Missing fields take their defaults.", {
-  surface: oneOf(BRUSH_SURFACES, "dry (default): stays where it lands; wet: flows, pools and dries (see wet); thick: stands up in relief (see thick)."),
-  grain: unit("Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Default 0."),
+  surface: oneOf2(BRUSH_SURFACES, "dry (default): stays where it lands; wet: flows, pools and dries (see wet); thick: stands up in relief (see thick)."),
+  grain: unit3("Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Default 0."),
   mixing: MIXING,
   exchange: EXCHANGE2,
   wet: WET,
   thick: THICK,
-  strength: unit("Tools: how strongly the blender, smudge or wet tool works per dab (default 0.5; smudge 0.7)."),
-  distance: unit("Blender: how far away colours are mixed in, as a fraction of the tip diameter (default 0.35)."),
-  length: unit("Smudge: how far paint is dragged, the share of carried paint kept per dab (default 0.85).")
+  strength: unit3("Tools: how strongly the blender, smudge or wet tool works per dab (default 0.5; smudge 0.7)."),
+  distance: unit3("Blender: how far away colours are mixed in, as a fraction of the tip diameter (default 0.35)."),
+  length: unit3("Smudge: how far paint is dragged, the share of carried paint kept per dab (default 0.85).")
 });
 var LIGHT = object("Light the brush gives off with its colour (glow and spill). Give light brushes dark paper.", {
-  amount: unit("Light per dab, scaled by its coverage and flow (default 0: none)."),
+  amount: unit3("Light per dab, scaled by its coverage and flow (default 0: none)."),
   pressure: bool("Pressure scales the light (default false)."),
   spill: object("Suggested spill for the layer, applied when it has none of its own.", {
     radius: num(0, 512, "How far the light reaches, px; 0 turns spill off (a highlighter)."),
@@ -406,7 +1367,7 @@ var LIGHT = object("Light the brush gives off with its colour (glow and spill).
 var MOTION = object("Animation after painting.", {
   live: bool("Effect paint keeps playing on stroke layers (default false)."),
   fps: int(1, 60, "Suggested playback rate in frames per second."),
-  waveSpeed: unit("Particle waves: how fast they run by stroke time; 0 they stand still (default 0), 1 about four a second.")
+  waveSpeed: unit3("Particle waves: how fast they run by stroke time; 0 they stand still (default 0), 1 about four a second.")
 });
 var SOLID = {
   type: "string",
@@ -427,7 +1388,7 @@ var EFFECT = object(
       {
         by: { type: "string", const: "stroke", description: 'Always "stroke".' },
         length: num(16, 4096, "Strip length: px of stroke per repeat of the effect."),
-        repeat: oneOf(["repeat", "mirror", "clamp"], "Past the strip end: start again, run back or hold.")
+        repeat: oneOf2(["repeat", "mirror", "clamp"], "Past the strip end: start again, run back or hold.")
       },
       ["by", "length", "repeat"]
     ),
@@ -450,14 +1411,14 @@ var COLOUR = object("The brush's colours. The user's colour still wins unless ow
 var BRUSH_JSON_SCHEMA = object(
   "A brush made of facets. Only id, name, kind and tip.shape are required; every other field takes the default for its engine.",
   {
-    id: { type: "string", pattern: _chunkHS6QDWDFcjs.BRUSH_ID.source, description: "Library id: lowercase letters, digits and dashes, up to 64 characters." },
+    id: { type: "string", pattern: BRUSH_ID.source, description: "Library id: lowercase letters, digits and dashes, up to 64 characters." },
     name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
     description: { type: "string", maxLength: 500, description: "What the brush is for, in a sentence." },
     tags: { type: "array", maxItems: 16, uniqueItems: true, items: { type: "string", pattern: BRUSH_WORD.source, description: "A tag: lowercase letters, digits and dashes." }, description: "Search tags." },
-    kind: oneOf(BRUSH_KINDS, "mark: lays a material (see medium); tool: works on paint already down (see tool)."),
-    medium: oneOf(BRUSH_MEDIA, "Marks: what it lays. paint (dry, wet or thick), ink, dry (pencil, pastel, charcoal) or spray (airbrush). Descriptive: the tip, marks and behaviour decide how it renders."),
+    kind: oneOf2(BRUSH_KINDS, "mark: lays a material (see medium); tool: works on paint already down (see tool)."),
+    medium: oneOf2(BRUSH_MEDIA, "Marks: what it lays. paint (dry, wet or thick), ink, dry (pencil, pastel, charcoal) or spray (airbrush). Descriptive: the tip, marks and behaviour decide how it renders."),
     variety: { type: "string", pattern: BRUSH_WORD.source, description: "What kind of the medium: oil, watercolor, gouache, pencil, pastel, charcoal, airbrush, marker, highlighter\u2026 A wet brush whose variety is watercolor, gouache or oil paints that medium." },
-    tool: oneOf(
+    tool: oneOf2(
       BRUSH_TOOLS,
       "Tools: eraser removes paint; blender mixes the colours under the tip; smudge drags paint along; water lays clear water (lifts dried paint with behaviour.wet.rewet); dryer dries wet paint; blow pushes water along; blot takes wet paint up; wet-blend evens out wet pigment; wet-drag drags wet paint."
     ),
@@ -549,7 +1510,7 @@ function readObject(value, schema, path, problems) {
   const out = {};
   for (const [key, v] of Object.entries(value)) {
     if (v === void 0) continue;
-    const child = _optionalChain([schema, 'access', _17 => _17.properties, 'optionalAccess', _18 => _18[key]]);
+    const child = _optionalChain([schema, 'access', _18 => _18.properties, 'optionalAccess', _19 => _19[key]]);
     if (!child) {
       problems.push(`${path}.${key} is not a brush field; dropped.`);
       continue;
@@ -575,7 +1536,7 @@ function readPaint(value, path, problems) {
 }
 function normalizeBrushSpec(raw, problems = []) {
   if (!isObject(raw)) throw new Error("A brush must be an object with id, name, kind and tip.");
-  if (typeof raw.id !== "string" || !_chunkHS6QDWDFcjs.BRUSH_ID.test(raw.id)) throw new Error(`Brush id ${JSON.stringify(raw.id)} is not valid: use lowercase letters, digits and dashes (up to 64), starting with a letter or digit.`);
+  if (typeof raw.id !== "string" || !BRUSH_ID.test(raw.id)) throw new Error(`Brush id ${JSON.stringify(raw.id)} is not valid: use lowercase letters, digits and dashes (up to 64), starting with a letter or digit.`);
   const name = typeof raw.name === "string" ? raw.name.trim().slice(0, 80) : "";
   if (!name) throw new Error(`Brush "${raw.id}" needs a name.`);
   const tool = BRUSH_TOOLS.includes(raw.tool) ? raw.tool : void 0;
@@ -639,7 +1600,7 @@ function normalizeBrushSpec(raw, problems = []) {
       delete brush.marks;
     }
   }
-  if (_optionalChain([brush, 'access', _19 => _19.marks, 'optionalAccess', _20 => _20.kind]) === "objects" && brush.tip.shape !== "stamp") {
+  if (_optionalChain([brush, 'access', _20 => _20.marks, 'optionalAccess', _21 => _21.kind]) === "objects" && brush.tip.shape !== "stamp") {
     problems.push("marks objects lay stamps: tip.shape set to stamp.");
     brush.tip.shape = "stamp";
   }
@@ -652,7 +1613,7 @@ function normalizeBrushSpec(raw, problems = []) {
     delete brush.tip.stamps;
   }
   if (brush.tip.stamps) {
-    const particles = _optionalChain([brush, 'access', _21 => _21.marks, 'optionalAccess', _22 => _22.kind]) === "particles";
+    const particles = _optionalChain([brush, 'access', _22 => _22.marks, 'optionalAccess', _23 => _23.kind]) === "particles";
     const stamps = brush.tip.stamps.flatMap((s) => {
       const ref = _chunkJSDND7DFcjs.normalizeStickerRef.call(void 0, s);
       if (particles && !_chunkJSDND7DFcjs.editorStampOf.call(void 0, ref)) {
@@ -697,7 +1658,7 @@ function normalizeBrushSpec(raw, problems = []) {
     if (b.exchange && kind === "tool" && !wetTool) {
       drop("behaviour.exchange", `the ${brush.tool} does not pick paint up`);
       delete b.exchange;
-    } else if (b.exchange && (_optionalChain([brush, 'access', _23 => _23.marks, 'optionalAccess', _24 => _24.kind]) === "particles" || _optionalChain([brush, 'access', _25 => _25.marks, 'optionalAccess', _26 => _26.kind]) === "objects" || brush.tip.shape === "bristle")) {
+    } else if (b.exchange && (_optionalChain([brush, 'access', _24 => _24.marks, 'optionalAccess', _25 => _25.kind]) === "particles" || _optionalChain([brush, 'access', _26 => _26.marks, 'optionalAccess', _27 => _27.kind]) === "objects" || brush.tip.shape === "bristle")) {
       drop("behaviour.exchange", "particle, object and bristle marks do not pick paint up");
       delete b.exchange;
     }
@@ -1459,26 +2420,26 @@ function checkBrush(brush, profile) {
     add("tool", "error", `${host} has no ${brush.tool} tool.`, profile.tools.length ? `Use one of: ${list(profile.tools)}.` : `${host} has no tools; use a mark brush.`);
   }
   if (!profile.tipShapes.includes(brush.tip.shape)) add("tip.shape", "error", `${host} can't lay a ${brush.tip.shape} tip.`, `Set tip.shape to one of: ${list(profile.tipShapes)}.`);
-  const marks = _nullishCoalesce(_optionalChain([brush, 'access', _27 => _27.marks, 'optionalAccess', _28 => _28.kind]), () => ( "continuous"));
+  const marks = _nullishCoalesce(_optionalChain([brush, 'access', _28 => _28.marks, 'optionalAccess', _29 => _29.kind]), () => ( "continuous"));
   if (!profile.marks.includes(marks)) add("marks", "error", `${host} can't lay ${marks} marks.`, `Use marks ${list(profile.marks)} (remove marks for continuous dabs).`);
-  const surface = _nullishCoalesce(_optionalChain([brush, 'access', _29 => _29.behaviour, 'optionalAccess', _30 => _30.surface]), () => ( "dry"));
+  const surface = _nullishCoalesce(_optionalChain([brush, 'access', _30 => _30.behaviour, 'optionalAccess', _31 => _31.surface]), () => ( "dry"));
   if (brush.kind === "mark" && !profile.surfaces.includes(surface)) add("behaviour.surface", "error", `${host} has no ${surface} surface.`, `Set behaviour.surface to ${list(profile.surfaces)}.`);
-  const ex = _optionalChain([brush, 'access', _31 => _31.behaviour, 'optionalAccess', _32 => _32.exchange]);
-  feature(profile.reservoir, !!_optionalChain([ex, 'optionalAccess', _33 => _33.reservoir]), "behaviour.exchange.reservoir", "a Mixer Brush reservoir", "Remove behaviour.exchange.reservoir.");
-  feature(profile.exchange, !_optionalChain([ex, 'optionalAccess', _34 => _34.reservoir]) && (nonZero(_optionalChain([ex, 'optionalAccess', _35 => _35.pickup])) || !!_optionalChain([ex, 'optionalAccess', _36 => _36.dirty])), "behaviour.exchange", "picking paint up", "Remove behaviour.exchange.");
-  feature(profile.grain, nonZero(_optionalChain([brush, 'access', _37 => _37.behaviour, 'optionalAccess', _38 => _38.grain])), "behaviour.grain", "paper grain", "Set behaviour.grain to 0.");
-  feature(profile.light, nonZero(_optionalChain([brush, 'access', _39 => _39.light, 'optionalAccess', _40 => _40.amount])), "light", "light paint (glow and spill)", "Remove light (or set light.amount to 0).");
+  const ex = _optionalChain([brush, 'access', _32 => _32.behaviour, 'optionalAccess', _33 => _33.exchange]);
+  feature(profile.reservoir, !!_optionalChain([ex, 'optionalAccess', _34 => _34.reservoir]), "behaviour.exchange.reservoir", "a Mixer Brush reservoir", "Remove behaviour.exchange.reservoir.");
+  feature(profile.exchange, !_optionalChain([ex, 'optionalAccess', _35 => _35.reservoir]) && (nonZero(_optionalChain([ex, 'optionalAccess', _36 => _36.pickup])) || !!_optionalChain([ex, 'optionalAccess', _37 => _37.dirty])), "behaviour.exchange", "picking paint up", "Remove behaviour.exchange.");
+  feature(profile.grain, nonZero(_optionalChain([brush, 'access', _38 => _38.behaviour, 'optionalAccess', _39 => _39.grain])), "behaviour.grain", "paper grain", "Set behaviour.grain to 0.");
+  feature(profile.light, nonZero(_optionalChain([brush, 'access', _40 => _40.light, 'optionalAccess', _41 => _41.amount])), "light", "light paint (glow and spill)", "Remove light (or set light.amount to 0).");
   const m = brush.motion;
   feature(profile.motion, !!m && (!!m.live || nonZero(m.waveSpeed) || m.fps !== void 0), "motion", "animation", "Remove motion.");
   const d = _nullishCoalesce(brush.dynamics, () => ( {}));
   feature(profile.velocity, nonZero(d.velocitySize) || nonZero(d.velocityOpacity), "dynamics.velocity", "velocity dynamics (its strokes carry no timing)", "Set dynamics.velocitySize and velocityOpacity to 0.");
   feature(profile.tilt, nonZero(d.tiltSize) || nonZero(d.tiltRoundness) || nonZero(d.tiltOpacity), "dynamics.tilt", "tilt dynamics", "Set dynamics.tiltSize, tiltRoundness and tiltOpacity to 0.");
   const colour = brush.colour;
-  if (_optionalChain([colour, 'optionalAccess', _41 => _41.default]) !== void 0) {
+  if (_optionalChain([colour, 'optionalAccess', _42 => _42.default]) !== void 0) {
     const kind = brushColourKind(colour.default);
     if (!profile.colours.includes(kind)) add("colour.default", "error", `${host} can't paint ${kind} colours.`, `Use a ${list(profile.colours)} colour, or remove colour.default.`);
   }
-  const foreign = [...new Set((_nullishCoalesce(_optionalChain([colour, 'optionalAccess', _42 => _42.palette]), () => ( []))).map(brushColourKind).filter((k) => !profile.colours.includes(k)))];
+  const foreign = [...new Set((_nullishCoalesce(_optionalChain([colour, 'optionalAccess', _43 => _43.palette]), () => ( []))).map(brushColourKind).filter((k) => !profile.colours.includes(k)))];
   if (foreign.length) add("colour.palette", "warning", `${host} skips the palette's ${list(foreign)} colours.`, `Nothing to do; or keep to ${list(profile.colours)} colours.`);
   return { ok: !issues.some((i) => i.severity === "error"), issues };
 }
@@ -1540,7 +2501,7 @@ function degrade(brush, profile) {
     }
     dropped.push(issue);
   }
-  if (_optionalChain([b, 'access', _43 => _43.behaviour, 'optionalAccess', _44 => _44.exchange]) && !Object.keys(b.behaviour.exchange).length) delete b.behaviour.exchange;
+  if (_optionalChain([b, 'access', _44 => _44.behaviour, 'optionalAccess', _45 => _45.exchange]) && !Object.keys(b.behaviour.exchange).length) delete b.behaviour.exchange;
   const after = checkBrush(b, profile).issues.filter((i) => i.severity === "error");
   return { brush: b, dropped, issues: after };
 }
@@ -1556,11 +2517,11 @@ var BrushLibraryError = class extends Error {
 };
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isV1 = (item) => "engine" in item || "category" in item || !("kind" in item);
-function parseBrushLibrary(raw, problems = []) {
+function parseBrushLibrary2(raw, problems = []) {
   if (typeof raw === "string") {
     try {
       raw = JSON.parse(raw);
-    } catch (e3) {
+    } catch (e4) {
       throw new BrushLibraryError("invalid", "Not a brush library: the text is not JSON.");
     }
   }
@@ -1570,12 +2531,12 @@ function parseBrushLibrary(raw, problems = []) {
   if (file && file.version !== void 0 && file.version !== 1 && file.version !== 2) {
     throw new BrushLibraryError("invalid", `Brush library version ${JSON.stringify(file.version)} is not supported; this library reads versions 1 and 2.`);
   }
-  const v1File = _optionalChain([file, 'optionalAccess', _45 => _45.version]) === 1;
+  const v1File = _optionalChain([file, 'optionalAccess', _46 => _46.version]) === 1;
   const out = [];
   items.forEach((item, i) => {
     const at = `brushes[${i}]`;
     if (!isObject2(item)) return void problems.push(`${at} is not an object; skipped.`);
-    if (typeof item.id !== "string" || !_chunkHS6QDWDFcjs.BRUSH_ID.test(item.id)) return void problems.push(`${at} has no valid id (lowercase letters, digits and dashes); skipped.`);
+    if (typeof item.id !== "string" || !BRUSH_ID.test(item.id)) return void problems.push(`${at} has no valid id (lowercase letters, digits and dashes); skipped.`);
     if (typeof item.name !== "string" || !item.name.trim()) return void problems.push(`${at} ("${item.id}") has no name; skipped.`);
     const { builtin: _b, ...rest } = item;
     const own = [];
@@ -1624,8 +2585,8 @@ function createBrushLibrary(options = {}) {
     let brushes = [];
     if (raw) {
       try {
-        brushes = parseBrushLibrary(raw).filter((b) => !builtinIds.has(b.id));
-      } catch (e4) {
+        brushes = parseBrushLibrary2(raw).filter((b) => !builtinIds.has(b.id));
+      } catch (e5) {
       }
     }
     user = brushes;
@@ -1701,7 +2662,7 @@ function createBrushLibrary(options = {}) {
     }),
     importFile: (raw, o = {}) => run(async () => {
       const problems = [];
-      const incoming = parseBrushLibrary(raw, problems);
+      const incoming = parseBrushLibrary2(raw, problems);
       const result = { added: [], replaced: [], skipped: [], problems };
       let brushes = [...await load()];
       for (const brush of incoming) {
@@ -1746,494 +2707,36 @@ function closest(id, ids, max = 3) {
   const near = ids.map((c) => [c, score(c)]).filter(([, s]) => s >= 3).sort((a, b) => b[1] - a[1]).slice(0, max).map(([c]) => c);
   return near.length ? `Closest: ${near.join(", ")}. ` : "";
 }
-
-// src/brushes/patch.ts
-var isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var copy4 = (v) => JSON.parse(JSON.stringify(v));
-var FACETS = BRUSH_JSON_SCHEMA.properties;
-var BRUSH_PATCH_PROPERTIES = (() => {
-  const { id: _id, name: _name, ...rest } = FACETS;
-  const { required: _r, ...tip } = rest.tip;
-  return { ...rest, tip: { ...tip, description: `${tip.description} In a patch, shape may be left out to keep it.` } };
-})();
-var UNSETTABLE_BRUSH_FACETS = ["description", "tags", "medium", "variety", "marks", "dynamics", "behaviour", "light", "motion", "colour"];
-var BRUSH_UNSET_PROPERTY = {
-  type: "array",
-  minItems: 1,
-  uniqueItems: true,
-  items: { type: "string", enum: [...UNSETTABLE_BRUSH_FACETS], description: "A facet to remove." },
-  description: "Facets to remove, back to their defaults (applied before the facets given)."
-};
-function mergeBrushPatch(base, patch, path = "") {
-  const out = { ...base };
-  for (const [k, v] of Object.entries(patch)) {
-    if (v === void 0) continue;
-    const old = out[k];
-    const replaceMarks = path === "" && k === "marks" && isObject3(old) && isObject3(v) && old.kind !== v.kind;
-    out[k] = isObject3(v) && isObject3(old) && !replaceMarks ? mergeBrushPatch(old, v, `${path}${k}.`) : copy4(v);
-  }
-  return out;
-}
-function changedBrushPaths(a, b, path = "") {
-  if (isObject3(a) && isObject3(b)) return [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].flatMap((k) => changedBrushPaths(a[k], b[k], path ? `${path}.${k}` : k));
-  return JSON.stringify(a) === JSON.stringify(b) ? [] : [path];
-}
-
-// src/brushes/tools.ts
-var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var FACETS2 = BRUSH_JSON_SCHEMA.properties;
-var ID = { type: "string", pattern: String(FACETS2.id.pattern), description: "Brush id from list_brush_presets (lowercase letters, digits and dashes)." };
-var FACET_PROPS = BRUSH_PATCH_PROPERTIES;
-var HOSTS = Object.keys(BRUSH_HOST_PROFILES);
-var copy5 = (v) => JSON.parse(JSON.stringify(v));
-var merge = mergeBrushPatch;
-var changedPaths = changedBrushPaths;
-function summary(entry, profile, withCheck) {
-  const b = entry.brush;
-  const engine = resolveEngine(b);
-  const check = withCheck ? checkBrush(b, profile) : null;
-  return {
-    id: b.id,
-    name: b.name,
-    builtin: entry.builtin,
-    kind: b.kind,
-    ...b.medium ? { medium: b.medium } : {},
-    ...b.variety ? { variety: b.variety } : {},
-    ...b.tool ? { tool: b.tool } : {},
-    category: resolveCategory(b, engine),
-    engine,
-    tip: b.tip.shape,
-    ...b.tip.size !== void 0 ? { size: b.tip.size } : {},
-    marks: _nullishCoalesce(_optionalChain([b, 'access', _46 => _46.marks, 'optionalAccess', _47 => _47.kind]), () => ( "continuous")),
-    surface: _nullishCoalesce(_optionalChain([b, 'access', _48 => _48.behaviour, 'optionalAccess', _49 => _49.surface]), () => ( "dry")),
-    ..._optionalChain([b, 'access', _50 => _50.light, 'optionalAccess', _51 => _51.amount]) ? { light: b.light.amount } : {},
-    ..._optionalChain([b, 'access', _52 => _52.tags, 'optionalAccess', _53 => _53.length]) ? { tags: b.tags } : {},
-    ...check ? { renderable: check.ok } : {}
-  };
-}
-var refusal = (check, host) => `${host.name} can't use this brush: ${check.issues.filter((i) => i.severity === "error").map((i) => `${i.facet}: ${i.reason} ${i.fix}`).join(" ")} (check_brush lists every issue; nothing was saved.)`;
-var warnings = (check) => check.issues.filter((i) => i.severity === "warning");
-function createBrushLibraryTools(library, options = {}) {
-  const profile = _nullishCoalesce(options.profile, () => ( PAINT_PROFILE));
-  const hostOf = (id) => {
-    if (id === void 0) return profile;
-    const p = BRUSH_HOST_PROFILES[id];
-    if (!p) throw new BrushLibraryError("invalid", `No host "${id}"; use one of: ${HOSTS.join(", ")}.`);
-    return p;
-  };
-  const entry = async (id) => {
-    const found = await library.get(id);
-    if (found) return found;
-    const ids = (await library.list()).map((e) => e.brush.id);
-    throw new BrushLibraryError("unknown_brush", `No brush "${id}". ${closest(id, ids)}list_brush_presets lists them.`);
-  };
-  const store = async (raw, overwrite) => {
-    const problems = [];
-    let brush;
-    try {
-      brush = normalizeBrushSpec(raw, problems);
-    } catch (e) {
-      throw new BrushLibraryError("invalid", e.message);
-    }
-    const check2 = checkBrush(brush, profile);
-    if (!check2.ok) throw new BrushLibraryError("invalid", refusal(check2, profile));
-    const saved = await library.save(brush, { overwrite });
-    return { ...saved, problems, check: check2 };
-  };
-  const list2 = {
-    name: "list_brush_presets",
-    title: "List brushes",
-    description: `Lists the brush library (built-in presets and saved brushes) that this host (${profile.name}) can render, filtered by kind, medium, variety, tool, tag or words. Returns each brush's id (for describe_brush, create_brush basedOn, duplicate_brush and the editor's set_brush), name, builtin, kind, medium, variety or tool, category, engine, tip shape and size, marks, surface and light, plus total. Call it first to find the nearest brush to start from. Changes nothing.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        kind: { type: "string", enum: [...BRUSH_KINDS], description: "mark (lays a material) or tool (works on paint already down)." },
-        medium: { type: "string", enum: [...BRUSH_MEDIA], description: "Marks laying this medium." },
-        variety: { type: "string", maxLength: 40, description: "This variety (oil, watercolor, pencil, highlighter\u2026)." },
-        tool: { type: "string", enum: [...BRUSH_TOOLS], description: "Tools that do this." },
-        tag: { type: "string", maxLength: 40, description: "Brushes with this tag." },
-        text: { type: "string", maxLength: 200, description: "Words in the id, name, description, variety or tags (each word must match the start of one)." },
-        source: { type: "string", enum: ["all", "builtin", "user"], description: "all (default), builtin presets only, or user (saved) brushes only." },
-        all: { type: "boolean", description: "Also list brushes this host can't render, each with renderable false (default false)." },
-        offset: { type: "integer", minimum: 0, description: "Skip this many (default 0)." },
-        limit: { type: "integer", minimum: 1, maximum: 200, description: "At most this many (default 100)." }
-      },
-      additionalProperties: false
+function snapshotBrushLibrary(library, onChange) {
+  let entries = [];
+  let user = [];
+  const refresh = () => library.list().then(
+    (list2) => {
+      entries = list2;
+      user = list2.filter((e) => !e.builtin).map((e) => e.brush);
+      _optionalChain([onChange, 'optionalCall', _47 => _47()]);
     },
-    annotations: { title: "List brushes", ...READ },
-    handler: async (a) => {
-      const source = a.source === "all" ? void 0 : a.source;
-      const found = await library.list({ kind: a.kind, medium: a.medium, variety: a.variety, tool: a.tool, tag: a.tag, text: a.text, source, ...a.all ? {} : { profile } });
-      const offset = _nullishCoalesce(a.offset, () => ( 0));
-      const page = found.slice(offset, offset + (_nullishCoalesce(a.limit, () => ( 100))));
-      return { host: profile.id, total: found.length, brushes: page.map((e) => summary(e, profile, !!a.all)) };
-    }
-  };
-  const describe = {
-    name: "describe_brush",
-    title: "Describe a brush",
-    description: `Reads one brush by id: its full facet spec (kind, medium, variety or tool, tip, marks, dynamics, behaviour, light, motion, colour), whether it is built in, the engine and category it resolves to, and check: what this host (${profile.name}) refuses or paints without, each with a fix. Unknown ids are refused with the closest ones. Changes nothing.`,
-    inputSchema: { type: "object", properties: { id: ID }, required: ["id"], additionalProperties: false },
-    annotations: { title: "Describe a brush", ...READ },
-    handler: async ({ id }) => {
-      const e = await entry(id);
-      const engine = resolveEngine(e.brush);
-      return { brush: e.brush, builtin: e.builtin, engine, category: resolveCategory(e.brush, engine), check: checkBrush(e.brush, profile) };
-    }
-  };
-  const check = {
-    name: "check_brush",
-    title: "Check a brush for a host",
-    description: `Checks a brush (by id, or a facet spec not yet saved) against a host profile: ${HOSTS.join(", ")} (default this host, ${profile.id}). Returns ok (no errors), issues (facet, severity error or warning, reason, fix) and, when it is refused, degraded: the brush with the refused facets stripped and what was dropped. Use it before create_brush, or to see whether a brush works in another editor. Changes nothing.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { ...ID, description: "A brush in the library (give id or brush, not both)." },
-        brush: { type: "object", description: "A facet brush spec (the create_brush fields, with id and name)." },
-        host: { type: "string", enum: HOSTS, description: `The host profile (default ${profile.id}).` }
-      },
-      additionalProperties: false
-    },
-    annotations: { title: "Check a brush for a host", ...READ },
-    handler: async ({ id, brush, host }) => {
-      if (id === void 0 === (brush === void 0)) throw new BrushLibraryError("invalid", "Give either id (a library brush) or brush (a spec), not both or neither.");
-      const p = hostOf(host);
-      let b;
-      const problems = [];
-      if (id !== void 0) b = (await entry(id)).brush;
-      else {
-        try {
-          b = normalizeBrushSpec(brush, problems);
-        } catch (e) {
-          throw new BrushLibraryError("invalid", e.message);
-        }
-      }
-      const result = checkBrush(b, p);
-      return { host: p.id, ...result, ...problems.length ? { problems } : {}, ...!result.ok ? { degraded: degrade(b, p) } : {} };
-    }
-  };
-  const exportTool = {
-    name: "export_brushes",
-    title: "Export brushes",
-    description: "Writes a brush library file (format pixerate-brushes, version 2) of the saved brushes, or of the ids given (built-ins included). Returns the file as JSON, for import_brushes in another library. Changes nothing.",
-    inputSchema: { type: "object", properties: { ids: { type: "array", minItems: 1, maxItems: 500, uniqueItems: true, items: ID, description: "Only these brushes (default every saved brush)." } }, additionalProperties: false },
-    annotations: { title: "Export brushes", ...READ },
-    handler: async ({ ids }) => ({ file: await library.exportFile(ids) })
-  };
-  const tools = [list2, describe, check, exportTool];
-  if (options.renderPreview) {
-    const render = options.renderPreview;
-    tools.push({
-      name: "preview_brush",
-      title: "Preview a brush",
-      description: "Draws a sample S-stroke with a brush (by id) on a plain background and returns it as an image, to see a brush before painting with it or after create_brush / update_brush. Returns the image plus id, width and height. Changes nothing.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: ID,
-          width: { type: "integer", minimum: 32, maximum: 1024, description: "Image width in px (default 256)." },
-          height: { type: "integer", minimum: 16, maximum: 512, description: "Image height in px (default 96)." },
-          color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "Paint colour #rrggbb (default the brush's own default colour, else #1f2937)." }
-        },
-        required: ["id"],
-        additionalProperties: false
-      },
-      annotations: { title: "Preview a brush", ...READ },
-      handler: async ({ id, width, height, color }) => {
-        const { brush } = await entry(id);
-        const own = typeof _optionalChain([brush, 'access', _54 => _54.colour, 'optionalAccess', _55 => _55.default]) === "string" && /^#[0-9a-f]{6}/i.test(brush.colour.default) ? brush.colour.default.slice(0, 7) : void 0;
-        const w = _nullishCoalesce(width, () => ( 256));
-        const h = _nullishCoalesce(height, () => ( 96));
-        const image = await render(brush, { width: w, height: h, color: _nullishCoalesce(_nullishCoalesce(color, () => ( own)), () => ( "#1f2937")) });
-        return { content: [{ type: "image", data: image.data, mimeType: image.mimeType }], structuredContent: { id, width: w, height: h } };
-      }
-    });
-  }
-  if (options.readOnly) return tools;
-  tools.push(
-    {
-      name: "create_brush",
-      title: "Save a new brush",
-      description: `Saves a new brush made of facets (to save an editor's current brush settings, pass the brush get_brush returns), optionally basedOn an existing brush (its facets are copied and the ones given here laid over them: objects merge, lists and values replace). Values are normalised (out-of-range numbers clamped, unused facets dropped, each reported in problems) and checked against this host (${profile.name}): a brush it can't render is refused with the facet and fix, and nothing is saved. Returns the new id, the stored brush, the engine it resolves to, problems and warnings (settings this host paints without). Start from the nearest preset (list_brush_presets) rather than from nothing.`,
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { ...FACETS2.id, description: "The new brush id: lowercase letters, digits and dashes, not taken (list_brush_presets)." },
-          name: FACETS2.name,
-          basedOn: { ...ID, description: "Copy this brush's facets first (a built-in preset or a saved brush)." },
-          ...FACET_PROPS
-        },
-        required: ["id", "name"],
-        additionalProperties: false
-      },
-      annotations: { title: "Save a new brush", ...WRITE },
-      handler: async ({ basedOn, ...spec }) => {
-        if (library.isBuiltin(spec.id)) throw new BrushLibraryError("builtin", `"${spec.id}" is a built-in brush id; pick another id (or basedOn "${spec.id}" with a new id).`);
-        if (await library.get(spec.id)) throw new BrushLibraryError("exists", `A brush "${spec.id}" exists already; pick another id, or change it with update_brush.`);
-        const base = basedOn !== void 0 ? (await entry(basedOn)).brush : void 0;
-        const raw = base ? merge(base, spec) : spec;
-        const saved = await store(raw, false);
-        return { id: saved.brush.id, brush: saved.brush, engine: resolveEngine(saved.brush), problems: saved.problems, warnings: warnings(saved.check) };
-      }
+    () => void 0
+  );
+  let ready = refresh();
+  const unsubscribe = library.subscribe(() => {
+    ready = refresh();
+  });
+  return {
+    get entries() {
+      return entries;
     },
-    {
-      name: "update_brush",
-      title: "Update a brush",
-      description: `Changes a saved brush: the facets given are laid over its own (objects merge, lists and values replace; marks of another kind replace the marks), and unset removes whole facets back to their defaults. Built-in presets are refused (duplicate_brush first). Checked against this host like create_brush; a refused change saves nothing. One change. Returns the brush, the leaf paths changed, problems and warnings.`,
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { ...ID, description: "The saved brush to change (not a built-in)." },
-          name: FACETS2.name,
-          ...FACET_PROPS,
-          unset: BRUSH_UNSET_PROPERTY
-        },
-        required: ["id"],
-        additionalProperties: false
-      },
-      annotations: { title: "Update a brush", ...WRITE, idempotentHint: true },
-      handler: async ({ id, unset, ...patch }) => {
-        const e = await entry(id);
-        if (e.builtin) throw new BrushLibraryError("builtin", `"${id}" is a built-in brush and can't be changed; duplicate_brush makes a copy you can change.`);
-        const base = copy5(e.brush);
-        for (const k of _nullishCoalesce(unset, () => ( []))) delete base[k];
-        const saved = await store(merge(base, { ...patch, id }), true);
-        return { id, brush: saved.brush, changed: changedPaths(e.brush, saved.brush), problems: saved.problems, warnings: warnings(saved.check) };
-      }
+    get user() {
+      return user;
     },
-    {
-      name: "duplicate_brush",
-      title: "Duplicate a brush",
-      description: "Copies any brush (built-in presets included) to a new saved brush you can change with update_brush. Returns the new id (default <id>-copy, -copy-2\u2026) and the brush.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: ID,
-          newId: { ...FACETS2.id, description: "Id for the copy (default <id>-copy, -copy-2\u2026); must not be taken." },
-          name: { ...FACETS2.name, description: 'Name for the copy (default "<name> copy").' }
-        },
-        required: ["id"],
-        additionalProperties: false
-      },
-      annotations: { title: "Duplicate a brush", ...WRITE },
-      handler: async ({ id, newId, name }) => {
-        const brush = await library.duplicate(id, { ...newId !== void 0 ? { id: newId } : {}, ...name !== void 0 ? { name } : {} });
-        return { id: brush.id, brush };
-      }
-    },
-    {
-      name: "remove_brush",
-      title: "Remove a brush",
-      description: "Deletes a saved brush from the library for good (export_brushes first to keep a copy). Built-in presets are refused. Returns the id removed.",
-      inputSchema: { type: "object", properties: { id: { ...ID, description: "The saved brush to remove (not a built-in)." } }, required: ["id"], additionalProperties: false },
-      annotations: { title: "Remove a brush", ...WRITE, destructiveHint: true },
-      handler: async ({ id }) => {
-        await entry(id);
-        await library.remove(id);
-        return { removed: id };
-      }
+    get ready() {
+      return ready;
     },
-    {
-      name: "import_brushes",
-      title: "Import brushes",
-      description: "Adds the brushes of a library file (format pixerate-brushes version 2 from export_brushes, a version 1 file of the paint editor's brushes, which are migrated, or a bare list of brushes). Brushes with a built-in id are skipped, and so are ids already saved unless overwrite. Returns added, replaced and skipped ids and problems (each fix or skip, per brush).",
-      inputSchema: {
-        type: "object",
-        properties: {
-          file: { type: ["object", "array"], description: "The library file object, or an array of brushes." },
-          overwrite: { type: "boolean", description: "Replace saved brushes with the same id (default false: skip them)." }
-        },
-        required: ["file"],
-        additionalProperties: false
-      },
-      annotations: { title: "Import brushes", ...WRITE, destructiveHint: true },
-      handler: async ({ file, overwrite }) => library.importFile(file, { overwrite: !!overwrite })
-    }
-  );
-  return tools;
-}
-function createBrushLibraryToolProvider(library, options = {}) {
-  const profile = _nullishCoalesce(options.profile, () => ( PAINT_PROFILE));
-  const tools = createBrushLibraryTools(library, options);
-  return {
-    id: _nullishCoalesce(options.id, () => ( "brushes")),
-    namespace: options.namespace,
-    title: "Brush library",
-    description: `The shared brush library: find, describe, create, change, check and share brushes made of facets, for ${profile.name}.`,
-    skill: "pixerate-brushes",
-    tools
+    refresh: () => ready = refresh(),
+    dispose: unsubscribe
   };
 }
 
-// src/paint-editor/brush-controls.ts
-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 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" && _optionalChain([brush, 'access', _56 => _56.wet, 'optionalAccess', _57 => _57.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 = _nullishCoalesce(_optionalChain([brush, 'access', _58 => _58.wet, 'optionalAccess', _59 => _59.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(_nullishCoalesce(obj[head2], () => ( {})), rest2) };
-  };
-  const [head, ...rest] = path.split(".");
-  if (!rest.length) return { [head]: value };
-  return { [head]: set({ ..._nullishCoalesce(brush[head], () => ( {})) }, rest) };
-}
 
 
 
@@ -2281,4 +2784,37 @@ function patchBrushValue(brush, path, value) {
 
 
 
-exports.BRUSH_FIELDS = BRUSH_FIELDS; exports.getPath = getPath; exports.setPath = setPath; exports.resolveEngine = resolveEngine; exports.resolveWetMedium = resolveWetMedium; exports.resolveCategory = resolveCategory; exports.resolveBrush = resolveBrush; exports.migrateBrushV1 = migrateBrushV1; exports.BRUSH_KINDS = BRUSH_KINDS; exports.BRUSH_MEDIA = BRUSH_MEDIA; exports.BRUSH_TOOLS = BRUSH_TOOLS; exports.BRUSH_TIP_SHAPES = BRUSH_TIP_SHAPES; exports.BRUSH_MARKS_KINDS = BRUSH_MARKS_KINDS; exports.BRUSH_SURFACES = BRUSH_SURFACES; exports.MAX_BRUSH_PALETTE = MAX_BRUSH_PALETTE; exports.BRUSH_WORD = BRUSH_WORD; exports.BRUSH_JSON_SCHEMA = BRUSH_JSON_SCHEMA; exports.BRUSH_FACET_SCHEMAS = BRUSH_FACET_SCHEMAS; exports.WET_BRUSH_TOOLS = WET_BRUSH_TOOLS; exports.normalizeBrushSpec = normalizeBrushSpec; exports.BRUSH_PRESETS = BRUSH_PRESETS; exports.PAINT_PROFILE = PAINT_PROFILE; exports.IMAGE_PROFILE = IMAGE_PROFILE; exports.CANVAS_PROFILE = CANVAS_PROFILE; exports.VECTOR_PROFILE = VECTOR_PROFILE; exports.BRUSH_HOST_PROFILES = BRUSH_HOST_PROFILES; exports.brushColourKind = brushColourKind; exports.checkBrush = checkBrush; exports.listPresets = listPresets; exports.degrade = degrade; exports.BrushLibraryError = BrushLibraryError; exports.parseBrushLibrary = parseBrushLibrary; exports.createBrushLibrary = createBrushLibrary; exports.closest = closest; exports.BRUSH_PATCH_PROPERTIES = BRUSH_PATCH_PROPERTIES; exports.UNSETTABLE_BRUSH_FACETS = UNSETTABLE_BRUSH_FACETS; exports.BRUSH_UNSET_PROPERTY = BRUSH_UNSET_PROPERTY; exports.mergeBrushPatch = mergeBrushPatch; exports.changedBrushPaths = changedBrushPaths; exports.createBrushLibraryTools = createBrushLibraryTools; exports.createBrushLibraryToolProvider = createBrushLibraryToolProvider; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.brushEngineControls = brushEngineControls; exports.multiColorSliders = multiColorSliders; exports.patchBrushValue = patchBrushValue;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.MAX_STICKER_STAMPS = MAX_STICKER_STAMPS; exports.DEFAULT_STICKER = DEFAULT_STICKER; exports.normalizeStickerSettings = normalizeStickerSettings; exports.PARTICLE_KINDS = PARTICLE_KINDS; exports.PARTICLE_RENDERS = PARTICLE_RENDERS; exports.RIBBON_PAIRS = RIBBON_PAIRS; exports.DOT_TEXTURE_ORDERS = DOT_TEXTURE_ORDERS; exports.DOT_ROTATIONS = DOT_ROTATIONS; exports.MAX_DOT_TEXTURES = MAX_DOT_TEXTURES; exports.DEFAULT_PARTICLE = DEFAULT_PARTICLE; exports.normalizeParticle = normalizeParticle; exports.DEFAULT_BRISTLE = DEFAULT_BRISTLE; exports.normalizeBristle = normalizeBristle; exports.PAINT_BRUSH_ENGINES = PAINT_BRUSH_ENGINES; exports.PAINT_BRUSH_CATEGORIES = PAINT_BRUSH_CATEGORIES; exports.WET_TOOLS = WET_TOOLS; exports.WET_MEDIA = WET_MEDIA; exports.DEFAULT_WET_BRUSH = DEFAULT_WET_BRUSH; exports.normalizeWetBrush = normalizeWetBrush; exports.IMPASTO_TOOLS = IMPASTO_TOOLS; exports.DEFAULT_IMPASTO = DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = DEFAULT_LIGHT; exports.normalizeLight = normalizeLight; exports.normalizeImpasto = normalizeImpasto; exports.MULTI_COLOR_MODES = MULTI_COLOR_MODES; exports.DEFAULT_MULTI_COLOR = DEFAULT_MULTI_COLOR; exports.DEFAULT_BEHAVIOR = DEFAULT_BEHAVIOR; exports.BRUSH_ROTATIONS = BRUSH_ROTATIONS; exports.DEFAULT_DYNAMICS = DEFAULT_DYNAMICS; exports.normalizeDynamics = normalizeDynamics; exports.BRUSH_ID = BRUSH_ID; exports.normalizeMultiColor = normalizeMultiColor; exports.normalizeBehavior = normalizeBehavior; exports.isWetCapable = isWetCapable; exports.isWetBrush = isWetBrush; exports.usesPaintExchange = usesPaintExchange; exports.brushTakesPaint = brushTakesPaint; exports.paintToMultiColor = paintToMultiColor; exports.multiColorToPaint = multiColorToPaint; exports.normalizePaintBrush = normalizePaintBrush; exports.BUILTIN_BRUSHES = BUILTIN_BRUSHES; exports.DEFAULT_BRUSH_ID = DEFAULT_BRUSH_ID; exports.brushToJSON = brushToJSON; exports.parseBrushLibrary = parseBrushLibrary; exports.BRUSH_FIELDS = BRUSH_FIELDS; exports.getPath = getPath; exports.setPath = setPath; exports.resolveEngine = resolveEngine; exports.resolveWetMedium = resolveWetMedium; exports.resolveCategory = resolveCategory; exports.resolveBrush = resolveBrush; exports.migrateBrushV1 = migrateBrushV1; exports.BRUSH_KINDS = BRUSH_KINDS; exports.BRUSH_MEDIA = BRUSH_MEDIA; exports.BRUSH_TOOLS = BRUSH_TOOLS; exports.BRUSH_TIP_SHAPES = BRUSH_TIP_SHAPES; exports.BRUSH_MARKS_KINDS = BRUSH_MARKS_KINDS; exports.BRUSH_SURFACES = BRUSH_SURFACES; exports.MAX_BRUSH_PALETTE = MAX_BRUSH_PALETTE; exports.BRUSH_WORD = BRUSH_WORD; exports.BRUSH_JSON_SCHEMA = BRUSH_JSON_SCHEMA; exports.BRUSH_FACET_SCHEMAS = BRUSH_FACET_SCHEMAS; exports.WET_BRUSH_TOOLS = WET_BRUSH_TOOLS; exports.normalizeBrushSpec = normalizeBrushSpec; exports.BRUSH_PRESETS = BRUSH_PRESETS; exports.PAINT_PROFILE = PAINT_PROFILE; exports.IMAGE_PROFILE = IMAGE_PROFILE; exports.CANVAS_PROFILE = CANVAS_PROFILE; exports.VECTOR_PROFILE = VECTOR_PROFILE; exports.BRUSH_HOST_PROFILES = BRUSH_HOST_PROFILES; exports.brushColourKind = brushColourKind; exports.checkBrush = checkBrush; exports.listPresets = listPresets; exports.degrade = degrade; exports.BrushLibraryError = BrushLibraryError; exports.parseBrushLibrary2 = parseBrushLibrary2; exports.createBrushLibrary = createBrushLibrary; exports.closest = closest; exports.snapshotBrushLibrary = snapshotBrushLibrary;