@pixerate/editor 0.251.0 → 0.252.0

package/dist/brushes/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
 
@@ -417,9 +417,9 @@ function normalizeBrushSpec(raw, problems = []) {
       if (c.palette !== void 0) {
         if (!Array.isArray(c.palette)) problems.push("brush.colour.palette must be a list; dropped.");
         else {
-          const list = c.palette.map((p, i) => readPaint(p, `brush.colour.palette[${i}]`, problems)).filter((p) => p !== void 0);
-          if (list.length > MAX_BRUSH_PALETTE) problems.push(`brush.colour.palette has more than ${MAX_BRUSH_PALETTE} colours; the rest were dropped.`);
-          colour.palette = list.slice(0, MAX_BRUSH_PALETTE);
+          const list2 = c.palette.map((p, i) => readPaint(p, `brush.colour.palette[${i}]`, problems)).filter((p) => p !== void 0);
+          if (list2.length > MAX_BRUSH_PALETTE) problems.push(`brush.colour.palette has more than ${MAX_BRUSH_PALETTE} colours; the rest were dropped.`);
+          colour.palette = list2.slice(0, MAX_BRUSH_PALETTE);
         }
       }
       if (typeof c.own === "boolean") colour.own = c.own;
@@ -516,7 +516,7 @@ var EDITOR_STAMPS = {
     try {
       const stamp = _chunkJSDND7DFcjs.editorStampOf.call(void 0, ref);
       return stamp ? [stamp] : [];
-    } catch (e) {
+    } catch (e2) {
       return [];
     }
   }),
@@ -1385,6 +1385,687 @@ var BRUSH_PRESETS = [
   }
 ];
 
+// src/brushes/profiles.ts
+var ALL_COLOURS = ["solid", "dual", "gradient", "effect"];
+var ELLIPSES = ["round", "flat", "chisel"];
+var PAINT_PROFILE = {
+  id: "paint",
+  name: "Paint editor",
+  kinds: ["mark", "tool"],
+  tools: BRUSH_TOOLS,
+  tipShapes: BRUSH_TIP_SHAPES,
+  marks: BRUSH_MARKS_KINDS,
+  surfaces: ["dry", "wet", "thick"],
+  exchange: "full",
+  reservoir: "full",
+  grain: "full",
+  light: "full",
+  motion: "full",
+  colours: ALL_COLOURS,
+  velocity: "full",
+  tilt: "full"
+};
+var IMAGE_PROFILE = {
+  id: "image",
+  name: "Image editor",
+  kinds: ["mark", "tool"],
+  tools: ["eraser"],
+  tipShapes: ELLIPSES,
+  marks: ["continuous"],
+  surfaces: ["dry"],
+  exchange: "ignored",
+  reservoir: "full",
+  grain: "ignored",
+  light: "none",
+  motion: "none",
+  colours: ["solid", "dual", "gradient"],
+  velocity: "ignored",
+  tilt: "ignored"
+};
+var CANVAS_PROFILE = {
+  id: "canvas",
+  name: "Canvas",
+  kinds: ["mark"],
+  tools: [],
+  tipShapes: ELLIPSES,
+  marks: ["continuous"],
+  surfaces: ["dry"],
+  exchange: "ignored",
+  reservoir: "none",
+  grain: "full",
+  light: "none",
+  motion: "none",
+  colours: ["solid", "dual", "gradient"],
+  velocity: "ignored",
+  tilt: "full"
+};
+var VECTOR_PROFILE = { ...CANVAS_PROFILE, id: "vector", name: "Vector editor", light: "ignored" };
+var BRUSH_HOST_PROFILES = { paint: PAINT_PROFILE, image: IMAGE_PROFILE, canvas: CANVAS_PROFILE, vector: VECTOR_PROFILE };
+function brushColourKind(paint) {
+  if (typeof paint === "string") return "solid";
+  if ("type" in paint) return paint.type === "gradient" ? "gradient" : "effect";
+  return "dual";
+}
+var list = (values) => values.join(", ");
+var nonZero = (v) => v !== void 0 && v !== 0;
+function checkBrush(brush, profile) {
+  const issues = [];
+  const host = profile.name;
+  const add = (facet, severity, reason, fix) => issues.push({ facet, severity, reason, fix });
+  const feature = (support, used, facet, what, fix) => {
+    if (!used || support === "full") return;
+    if (support === "none") add(facet, "error", `${host} can't paint ${what}.`, fix);
+    else add(facet, "warning", `${host} paints this brush without ${what}.`, `Nothing to do; or ${fix.charAt(0).toLowerCase()}${fix.slice(1)}`);
+  };
+  if (!profile.kinds.includes(brush.kind)) add("kind", "error", `${host} has no ${brush.kind} brushes.`, `Use a ${list(profile.kinds)} brush.`);
+  else if (brush.kind === "tool" && brush.tool && !profile.tools.includes(brush.tool)) {
+    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"));
+  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"));
+  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 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) {
+    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)))];
+  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 };
+}
+function listPresets(profile, presets = BRUSH_PRESETS) {
+  return presets.filter((b) => checkBrush(b, profile).ok);
+}
+function degrade(brush, profile) {
+  const before = checkBrush(brush, profile).issues.filter((i) => i.severity === "error");
+  const b = JSON.parse(JSON.stringify(brush));
+  const dropped = [];
+  for (const issue of before) {
+    switch (issue.facet) {
+      case "tip.shape":
+        b.tip = { ...b.tip, shape: profile.tipShapes.includes("round") ? "round" : profile.tipShapes[0] };
+        delete b.tip.bristle;
+        delete b.tip.stamps;
+        break;
+      case "marks":
+        delete b.marks;
+        if (b.tip.shape === "stamp") {
+          b.tip.shape = "round";
+          delete b.tip.stamps;
+        }
+        break;
+      case "behaviour.surface":
+        delete b.behaviour.surface;
+        delete b.behaviour.wet;
+        delete b.behaviour.thick;
+        break;
+      case "behaviour.exchange.reservoir":
+        delete b.behaviour.exchange.reservoir;
+        break;
+      case "behaviour.exchange":
+        delete b.behaviour.exchange;
+        break;
+      case "behaviour.grain":
+        delete b.behaviour.grain;
+        break;
+      case "light":
+        delete b.light;
+        break;
+      case "motion":
+        delete b.motion;
+        break;
+      case "dynamics.velocity":
+        delete b.dynamics.velocitySize;
+        delete b.dynamics.velocityOpacity;
+        break;
+      case "dynamics.tilt":
+        delete b.dynamics.tiltSize;
+        delete b.dynamics.tiltRoundness;
+        delete b.dynamics.tiltOpacity;
+        break;
+      case "colour.default":
+        delete b.colour.default;
+        break;
+      default:
+        continue;
+    }
+    dropped.push(issue);
+  }
+  if (_optionalChain([b, 'access', _43 => _43.behaviour, 'optionalAccess', _44 => _44.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 };
+}
+
+// src/brushes/library.ts
+var BrushLibraryError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrushLibraryError";
+  }
+  
+};
+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 = []) {
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch (e3) {
+      throw new BrushLibraryError("invalid", "Not a brush library: the text is not JSON.");
+    }
+  }
+  const file = isObject2(raw) ? raw : null;
+  const items = Array.isArray(raw) ? raw : file && Array.isArray(file.brushes) ? file.brushes : null;
+  if (!items) throw new BrushLibraryError("invalid", 'Not a brush library: expected {"format":"pixerate-brushes","version":2,"brushes":[...]} or an array of brushes.');
+  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 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.name !== "string" || !item.name.trim()) return void problems.push(`${at} ("${item.id}") has no name; skipped.`);
+    const { builtin: _b, ...rest } = item;
+    const own = [];
+    try {
+      out.push(normalizeBrushSpec(v1File || isV1(rest) ? migrateBrushV1(rest) : rest, own));
+    } catch (e) {
+      own.push(`${e.message} Skipped.`);
+    }
+    problems.push(...own.map((p) => `${at} ("${item.id}"): ${p}`));
+  });
+  return out;
+}
+var words = (s) => s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+function matches(entry, f2) {
+  const b = entry.brush;
+  if (f2.source && f2.source === "builtin" !== entry.builtin) return false;
+  if (f2.kind && b.kind !== f2.kind) return false;
+  if (f2.medium && b.medium !== f2.medium) return false;
+  if (f2.variety && b.variety !== f2.variety) return false;
+  if (f2.tool && b.tool !== f2.tool) return false;
+  if (f2.tag && !(_nullishCoalesce(b.tags, () => ( []))).includes(f2.tag)) return false;
+  if (f2.text) {
+    const text = words([b.id, b.name, _nullishCoalesce(b.description, () => ( "")), _nullishCoalesce(b.variety, () => ( "")), _nullishCoalesce(b.medium, () => ( "")), _nullishCoalesce(b.tool, () => ( "")), ..._nullishCoalesce(b.tags, () => ( []))].join(" "));
+    if (!words(f2.text).every((w) => text.some((t) => t.startsWith(w)))) return false;
+  }
+  if (f2.profile && !checkBrush(b, f2.profile).ok) return false;
+  return true;
+}
+var copy3 = (v) => JSON.parse(JSON.stringify(v));
+function createBrushLibrary(options = {}) {
+  const presets = (_nullishCoalesce(options.presets, () => ( BRUSH_PRESETS))).map(copy3);
+  const builtinIds = new Set(presets.map((b) => b.id));
+  const key = `${_nullishCoalesce(options.namespace, () => ( "pixerate.brushes"))}:user`;
+  const listeners = /* @__PURE__ */ new Set();
+  let user = null;
+  let queue = Promise.resolve();
+  const run = (task) => {
+    const result = queue.then(task, task);
+    queue = result.catch(() => void 0);
+    return result;
+  };
+  const notify = () => listeners.forEach((listener) => listener());
+  const load = async () => {
+    if (user) return user;
+    const raw = options.storage ? await options.storage.get(key) : null;
+    let brushes = [];
+    if (raw) {
+      try {
+        brushes = parseBrushLibrary(raw).filter((b) => !builtinIds.has(b.id));
+      } catch (e4) {
+      }
+    }
+    user = brushes;
+    return user;
+  };
+  const store = async (brushes) => {
+    const file = { format: "pixerate-brushes", version: 2, brushes };
+    if (options.storage) await options.storage.set(key, JSON.stringify(file));
+    user = brushes;
+  };
+  const entries = async () => [...presets.map((brush) => ({ brush, builtin: true })), ...(await load()).map((brush) => ({ brush, builtin: false }))];
+  const find = async (id) => {
+    const entry = (await entries()).find((e) => e.brush.id === id);
+    if (!entry) throw new BrushLibraryError("unknown_brush", `No brush "${id}". ${closest(id, (await entries()).map((e) => e.brush.id))}list_brush_presets lists them.`);
+    return entry;
+  };
+  const refuseBuiltin = (id, what) => {
+    if (builtinIds.has(id)) throw new BrushLibraryError("builtin", `"${id}" is a built-in brush and can't be ${what}; duplicate it first (duplicate_brush) and change the copy.`);
+  };
+  const freeId = async (base) => {
+    const taken = new Set((await entries()).map((e) => e.brush.id));
+    const stem = base.slice(0, 58);
+    for (let n = 1; ; n++) {
+      const id = n === 1 ? `${stem}-copy` : `${stem}-copy-${n}`;
+      if (!taken.has(id)) return id;
+    }
+  };
+  const saveLocked = async (raw, overwrite) => {
+    const problems = [];
+    let brush;
+    try {
+      brush = normalizeBrushSpec(raw, problems);
+    } catch (e) {
+      throw new BrushLibraryError("invalid", e.message);
+    }
+    refuseBuiltin(brush.id, "overwritten");
+    const brushes = await load();
+    const at = brushes.findIndex((b) => b.id === brush.id);
+    if (at !== -1 && !overwrite) throw new BrushLibraryError("exists", `A brush "${brush.id}" exists already; pick another id, or update it (update_brush).`);
+    await store(at === -1 ? [...brushes, brush] : brushes.map((b, i) => i === at ? brush : b));
+    return { brush: copy3(brush), problems, replaced: at !== -1 };
+  };
+  return {
+    list: (filter = {}) => run(async () => (await entries()).filter((e) => matches(e, filter)).map(copy3)),
+    get: (id) => run(async () => {
+      const entry = (await entries()).find((e) => e.brush.id === id);
+      return entry ? copy3(entry) : null;
+    }),
+    isBuiltin: (id) => builtinIds.has(id),
+    save: (brush, o = {}) => run(async () => {
+      const result = await saveLocked(brush, !!o.overwrite);
+      notify();
+      return result;
+    }),
+    remove: (id) => run(async () => {
+      refuseBuiltin(id, "removed");
+      const brushes = await load();
+      if (!brushes.some((b) => b.id === id)) return false;
+      await store(brushes.filter((b) => b.id !== id));
+      notify();
+      return true;
+    }),
+    duplicate: (id, o = {}) => run(async () => {
+      const { brush } = await find(id);
+      const newId = await _asyncNullishCoalesce(o.id, async () => ( await freeId(id)));
+      const { brush: saved } = await saveLocked({ ...copy3(brush), id: newId, name: _nullishCoalesce(o.name, () => ( `${brush.name} copy`.slice(0, 80))) }, false);
+      notify();
+      return saved;
+    }),
+    exportFile: (ids) => run(async () => {
+      const brushes = ids ? await Promise.all(ids.map(async (id) => (await find(id)).brush)) : await load();
+      return { format: "pixerate-brushes", version: 2, brushes: brushes.map(copy3) };
+    }),
+    importFile: (raw, o = {}) => run(async () => {
+      const problems = [];
+      const incoming = parseBrushLibrary(raw, problems);
+      const result = { added: [], replaced: [], skipped: [], problems };
+      let brushes = [...await load()];
+      for (const brush of incoming) {
+        if (builtinIds.has(brush.id)) {
+          result.skipped.push(brush.id);
+          problems.push(`"${brush.id}" is a built-in brush id; skipped (rename it to import it).`);
+          continue;
+        }
+        const at = brushes.findIndex((b) => b.id === brush.id);
+        if (at === -1) {
+          brushes.push(brush);
+          result.added.push(brush.id);
+        } else if (o.overwrite) {
+          brushes = brushes.map((b, i) => i === at ? brush : b);
+          result.replaced.push(brush.id);
+        } else {
+          result.skipped.push(brush.id);
+          problems.push(`"${brush.id}" exists already; skipped (pass overwrite to replace it).`);
+        }
+      }
+      if (result.added.length || result.replaced.length) {
+        await store(brushes);
+        notify();
+      }
+      return result;
+    }),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function closest(id, ids, max = 3) {
+  const stem = id.toLowerCase();
+  const score = (c) => {
+    let n = 0;
+    while (n < Math.min(c.length, stem.length) && c[n] === stem[n]) n++;
+    return n + (c.includes(stem) || stem.includes(c) ? 4 : 0) + words(c).filter((w) => words(stem).includes(w)).length * 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/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var FACETS = BRUSH_JSON_SCHEMA.properties;
+var ID = { type: "string", pattern: String(FACETS.id.pattern), description: "Brush id from list_brush_presets (lowercase letters, digits and dashes)." };
+var FACET_PROPS = (({ id: _id, name: _name, ...rest }) => rest)(FACETS);
+FACET_PROPS.tip = (({ required: _r, ...tip }) => ({ ...tip, description: `${tip.description} In a patch, shape may be left out to keep it.` }))(FACET_PROPS.tip);
+var UNSETTABLE = ["description", "tags", "medium", "variety", "marks", "dynamics", "behaviour", "light", "motion", "colour"];
+var HOSTS = Object.keys(BRUSH_HOST_PROFILES);
+var isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var copy4 = (v) => JSON.parse(JSON.stringify(v));
+function merge(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 ? merge(old, v, `${path}${k}.`) : copy4(v);
+  }
+  return out;
+}
+function changedPaths(a, b, path = "") {
+  if (isObject3(a) && isObject3(b)) return [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].flatMap((k) => changedPaths(a[k], b[k], path ? `${path}.${k}` : k));
+  return JSON.stringify(a) === JSON.stringify(b) ? [] : [path];
+}
+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
+    },
+    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: "Create a brush",
+      description: `Saves a new brush made of facets, 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: { ...FACETS.id, description: "The new brush id: lowercase letters, digits and dashes, not taken (list_brush_presets)." },
+          name: FACETS.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: "Create a 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) };
+      }
+    },
+    {
+      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: FACETS.name,
+          ...FACET_PROPS,
+          unset: { type: "array", minItems: 1, uniqueItems: true, items: { type: "string", enum: [...UNSETTABLE], description: "A facet to remove." }, description: "Facets to remove (applied before the facets given)." }
+        },
+        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 = copy4(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) };
+      }
+    },
+    {
+      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: { ...FACETS.id, description: "Id for the copy (default <id>-copy, -copy-2\u2026); must not be taken." },
+          name: { ...FACETS.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 };
+      }
+    },
+    {
+      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
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1403,4 +2084,4 @@ var BRUSH_PRESETS = [
 
 
 
-exports.BRUSH_FACET_SCHEMAS = BRUSH_FACET_SCHEMAS; exports.BRUSH_JSON_SCHEMA = BRUSH_JSON_SCHEMA; exports.BRUSH_KINDS = BRUSH_KINDS; exports.BRUSH_MARKS_KINDS = BRUSH_MARKS_KINDS; exports.BRUSH_MEDIA = BRUSH_MEDIA; exports.BRUSH_PRESETS = BRUSH_PRESETS; exports.BRUSH_SURFACES = BRUSH_SURFACES; exports.BRUSH_TIP_SHAPES = BRUSH_TIP_SHAPES; exports.BRUSH_TOOLS = BRUSH_TOOLS; exports.BRUSH_WORD = BRUSH_WORD; exports.MAX_BRUSH_PALETTE = MAX_BRUSH_PALETTE; exports.WET_BRUSH_TOOLS = WET_BRUSH_TOOLS; exports.migrateBrushV1 = migrateBrushV1; exports.normalizeBrushSpec = normalizeBrushSpec; exports.resolveBrush = resolveBrush; exports.resolveCategory = resolveCategory; exports.resolveEngine = resolveEngine; exports.resolveWetMedium = resolveWetMedium;
+exports.BRUSH_FACET_SCHEMAS = BRUSH_FACET_SCHEMAS; exports.BRUSH_HOST_PROFILES = BRUSH_HOST_PROFILES; exports.BRUSH_JSON_SCHEMA = BRUSH_JSON_SCHEMA; exports.BRUSH_KINDS = BRUSH_KINDS; exports.BRUSH_MARKS_KINDS = BRUSH_MARKS_KINDS; exports.BRUSH_MEDIA = BRUSH_MEDIA; exports.BRUSH_PRESETS = BRUSH_PRESETS; exports.BRUSH_SURFACES = BRUSH_SURFACES; exports.BRUSH_TIP_SHAPES = BRUSH_TIP_SHAPES; exports.BRUSH_TOOLS = BRUSH_TOOLS; exports.BRUSH_WORD = BRUSH_WORD; exports.BrushLibraryError = BrushLibraryError; exports.CANVAS_PROFILE = CANVAS_PROFILE; exports.IMAGE_PROFILE = IMAGE_PROFILE; exports.MAX_BRUSH_PALETTE = MAX_BRUSH_PALETTE; exports.PAINT_PROFILE = PAINT_PROFILE; exports.VECTOR_PROFILE = VECTOR_PROFILE; exports.WET_BRUSH_TOOLS = WET_BRUSH_TOOLS; exports.brushColourKind = brushColourKind; exports.checkBrush = checkBrush; exports.createBrushLibrary = createBrushLibrary; exports.createBrushLibraryToolProvider = createBrushLibraryToolProvider; exports.createBrushLibraryTools = createBrushLibraryTools; exports.degrade = degrade; exports.listPresets = listPresets; exports.migrateBrushV1 = migrateBrushV1; exports.normalizeBrushSpec = normalizeBrushSpec; exports.parseBrushLibrary = parseBrushLibrary; exports.resolveBrush = resolveBrush; exports.resolveCategory = resolveCategory; exports.resolveEngine = resolveEngine; exports.resolveWetMedium = resolveWetMedium;