@pixerate/editor 0.254.1 → 0.256.0

package/dist/{chunk-LFMKWGFL.cjs → chunk-LRNUZKWV.cjs}

@@ -74,17 +74,25 @@ function profileAlongPolyline(points, values, count = 32) {
 var round3 = (v) => Math.round(v * 1e3) / 1e3;
 var loading = null;
 function loadCanvasBrushstrokeRenderer() {
-  loading ??= Promise.resolve().then(() => _interopRequireWildcard(require("./brushstrokeRender-7FLLSQEC.cjs"))).catch((error) => {
+  loading ??= Promise.resolve().then(() => _interopRequireWildcard(require("./brushstrokeRender-ZZOXI5O5.cjs"))).catch((error) => {
     loading = null;
     throw error;
   });
   return loading;
 }
-async function listCanvasBrushes() {
-  return (await loadCanvasBrushstrokeRenderer()).listCanvasBrushes();
+async function listCanvasBrushes(library) {
+  const user = library ? (await library.list({ source: "user" })).map((e) => e.brush) : [];
+  return (await loadCanvasBrushstrokeRenderer()).listCanvasBrushes(user);
 }
-async function validateCanvasBrush(brush) {
-  (await loadCanvasBrushstrokeRenderer()).resolveCanvasBrush(brush, 1);
+async function resolveCanvasBrushSpec(brush, library) {
+  if (typeof brush !== "string" || !library || library.isBuiltin(brush)) return void 0;
+  const entry = await library.get(brush);
+  if (!entry) return void 0;
+  (await loadCanvasBrushstrokeRenderer()).readCanvasBrushSpec(entry.brush);
+  return entry.brush;
+}
+async function validateCanvasBrush(brush, spec) {
+  (await loadCanvasBrushstrokeRenderer()).resolveCanvasBrush(brush, 1, spec);
 }
 async function validateCanvasBrushPaint(paint) {
   (await loadCanvasBrushstrokeRenderer()).resolveCanvasPaint(paint);
@@ -105,9 +113,15 @@ async function getBrushedShapeSvg(shape, size, options = {}) {
   if (!isBrushedShape(shape)) return null;
   return (await loadCanvasBrushstrokeRenderer()).brushedShapeSvgNow(shape, size, _nullishCoalesce(options.scale, () => ( 2)), options);
 }
-async function renderCanvasBrushSwatch(brush, options = {}) {
-  return (await loadCanvasBrushstrokeRenderer()).brushSwatchNow(brush, options);
+async function renderCanvasBrushSwatch(brush, options = {}, spec) {
+  return (await loadCanvasBrushstrokeRenderer()).brushSwatchNow(brush, options, spec);
 }
+var renderCanvasBrushPreview = async (brush, { width, height, color }) => {
+  const url = await renderCanvasBrushSwatch(brush.id, { width, height, color, scale: 1 }, brush);
+  return { data: url.replace(/^data:image\/png;base64,/, ""), mimeType: "image/png" };
+};
+
+
 
 
 
@@ -121,4 +135,4 @@ async function renderCanvasBrushSwatch(brush, options = {}) {
 
 
 
-exports.isBrushedShape = isBrushedShape; exports.pathDataToPolyline = pathDataToPolyline; exports.profileAlongPolyline = profileAlongPolyline; exports.loadCanvasBrushstrokeRenderer = loadCanvasBrushstrokeRenderer; exports.listCanvasBrushes = listCanvasBrushes; exports.validateCanvasBrush = validateCanvasBrush; exports.validateCanvasBrushPaint = validateCanvasBrushPaint; exports.brushstrokeSeed = brushstrokeSeed; exports.renderShapeBrushstroke = renderShapeBrushstroke; exports.getBrushedShapeSvg = getBrushedShapeSvg; exports.renderCanvasBrushSwatch = renderCanvasBrushSwatch;
+exports.isBrushedShape = isBrushedShape; exports.pathDataToPolyline = pathDataToPolyline; exports.profileAlongPolyline = profileAlongPolyline; exports.loadCanvasBrushstrokeRenderer = loadCanvasBrushstrokeRenderer; exports.listCanvasBrushes = listCanvasBrushes; exports.resolveCanvasBrushSpec = resolveCanvasBrushSpec; exports.validateCanvasBrush = validateCanvasBrush; exports.validateCanvasBrushPaint = validateCanvasBrushPaint; exports.brushstrokeSeed = brushstrokeSeed; exports.renderShapeBrushstroke = renderShapeBrushstroke; exports.getBrushedShapeSvg = getBrushedShapeSvg; exports.renderCanvasBrushSwatch = renderCanvasBrushSwatch; exports.renderCanvasBrushPreview = renderCanvasBrushPreview;

package/dist/chunk-PGPFWC35.cjs

@@ -0,0 +1,517 @@
+"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; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkHIMGBZAMcjs = require('./chunk-HIMGBZAM.cjs');
+
+// src/brushes/patch.ts
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var copy = (v) => JSON.parse(JSON.stringify(v));
+var FACETS = _chunkHIMGBZAMcjs.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" && isObject(old) && isObject(v) && old.kind !== v.kind;
+    out[k] = isObject(v) && isObject(old) && !replaceMarks ? mergeBrushPatch(old, v, `${path}${k}.`) : copy(v);
+  }
+  return out;
+}
+function changedBrushPaths(a, b, path = "") {
+  if (isObject(a) && isObject(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 = _chunkHIMGBZAMcjs.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(_chunkHIMGBZAMcjs.BRUSH_HOST_PROFILES);
+var copy2 = (v) => JSON.parse(JSON.stringify(v));
+var merge = mergeBrushPatch;
+var changedPaths = changedBrushPaths;
+function summary(entry, profile, withCheck) {
+  const b = entry.brush;
+  const engine = _chunkHIMGBZAMcjs.resolveEngine.call(void 0, b);
+  const check = withCheck ? _chunkHIMGBZAMcjs.checkBrush.call(void 0, 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: _chunkHIMGBZAMcjs.resolveCategory.call(void 0, b, engine),
+    engine,
+    tip: b.tip.shape,
+    ...b.tip.size !== void 0 ? { size: b.tip.size } : {},
+    marks: _nullishCoalesce(_optionalChain([b, 'access', _ => _.marks, 'optionalAccess', _2 => _2.kind]), () => ( "continuous")),
+    surface: _nullishCoalesce(_optionalChain([b, 'access', _3 => _3.behaviour, 'optionalAccess', _4 => _4.surface]), () => ( "dry")),
+    ..._optionalChain([b, 'access', _5 => _5.light, 'optionalAccess', _6 => _6.amount]) ? { light: b.light.amount } : {},
+    ..._optionalChain([b, 'access', _7 => _7.tags, 'optionalAccess', _8 => _8.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, () => ( _chunkHIMGBZAMcjs.PAINT_PROFILE));
+  const hostOf = (id) => {
+    if (id === void 0) return profile;
+    const p = _chunkHIMGBZAMcjs.BRUSH_HOST_PROFILES[id];
+    if (!p) throw new (0, _chunkHIMGBZAMcjs.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 (0, _chunkHIMGBZAMcjs.BrushLibraryError)("unknown_brush", `No brush "${id}". ${_chunkHIMGBZAMcjs.closest.call(void 0, id, ids)}list_brush_presets lists them.`);
+  };
+  const store = async (raw, overwrite) => {
+    const problems = [];
+    let brush;
+    try {
+      brush = _chunkHIMGBZAMcjs.normalizeBrushSpec.call(void 0, raw, problems);
+    } catch (e) {
+      throw new (0, _chunkHIMGBZAMcjs.BrushLibraryError)("invalid", e.message);
+    }
+    const check2 = _chunkHIMGBZAMcjs.checkBrush.call(void 0, brush, profile);
+    if (!check2.ok) throw new (0, _chunkHIMGBZAMcjs.BrushLibraryError)("invalid", refusal(check2, profile));
+    const saved = await library.save(brush, { overwrite });
+    return { ...saved, problems, check: check2 };
+  };
+  const list = {
+    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: [..._chunkHIMGBZAMcjs.BRUSH_KINDS], description: "mark (lays a material) or tool (works on paint already down)." },
+        medium: { type: "string", enum: [..._chunkHIMGBZAMcjs.BRUSH_MEDIA], description: "Marks laying this medium." },
+        variety: { type: "string", maxLength: 40, description: "This variety (oil, watercolor, pencil, highlighter\u2026)." },
+        tool: { type: "string", enum: [..._chunkHIMGBZAMcjs.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 = _chunkHIMGBZAMcjs.resolveEngine.call(void 0, e.brush);
+      return { brush: e.brush, builtin: e.builtin, engine, category: _chunkHIMGBZAMcjs.resolveCategory.call(void 0, e.brush, engine), check: _chunkHIMGBZAMcjs.checkBrush.call(void 0, 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 (0, _chunkHIMGBZAMcjs.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 = _chunkHIMGBZAMcjs.normalizeBrushSpec.call(void 0, brush, problems);
+        } catch (e) {
+          throw new (0, _chunkHIMGBZAMcjs.BrushLibraryError)("invalid", e.message);
+        }
+      }
+      const result = _chunkHIMGBZAMcjs.checkBrush.call(void 0, b, p);
+      return { host: p.id, ...result, ...problems.length ? { problems } : {}, ...!result.ok ? { degraded: _chunkHIMGBZAMcjs.degrade.call(void 0, 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 = [list, 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', _9 => _9.colour, 'optionalAccess', _10 => _10.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 (0, _chunkHIMGBZAMcjs.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 (0, _chunkHIMGBZAMcjs.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: _chunkHIMGBZAMcjs.resolveEngine.call(void 0, 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: 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 (0, _chunkHIMGBZAMcjs.BrushLibraryError)("builtin", `"${id}" is a built-in brush and can't be changed; duplicate_brush makes a copy you can change.`);
+        const base = copy2(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: { ...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 };
+      }
+    },
+    {
+      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, () => ( _chunkHIMGBZAMcjs.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
+  };
+}
+
+// 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', _11 => _11.wet, 'optionalAccess', _12 => _12.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', _13 => _13.wet, 'optionalAccess', _14 => _14.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) };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+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;