@pixerate/editor 0.267.0 → 0.268.1

package/dist/{chunk-AGNUD5BI.js → chunk-KZI3YWKW.js}

@@ -11,6 +11,7 @@ import {
   DEFAULT_BRUSH,
   DEFAULT_MIXER,
   DEFAULT_SMUDGE,
+  GRAIN_PATTERNS,
   MAX_BRUSH_SIZE,
   PAINT_GRADIENT_JSON_SCHEMA,
   normalizeBlender,
@@ -18,10 +19,15 @@ import {
   normalizeMixer,
   normalizeSmudge,
   readPaintSource
-} from "./chunk-GCVFEPJG.js";
+} from "./chunk-ACTHSQOI.js";
 import {
   BLEND_MODES
 } from "./chunk-IRSTHLQQ.js";
+import {
+  decodePng,
+  parseDataUrl,
+  pngDataUrl
+} from "./chunk-OTTT5N3K.js";
 
 // src/brushes/presets.ts
 var BRUSH_PRESETS = [
@@ -908,6 +914,9 @@ 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 DAB_FLIPS = ["none", "x", "y", "xy"];
+var TIP_GRAIN_MODES = ["moving", "texturised"];
+var DEFAULT_TIP_GRAIN = { mode: "texturised", scale: 1, depth: 0.6, contrast: 1, invert: false };
 var DEFAULT_DYNAMICS = {
   minSize: 0,
   pressureFlow: 0,
@@ -935,7 +944,8 @@ function normalizeDynamics(raw = {}, base = DEFAULT_DYNAMICS) {
     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)
+    scatter: range(raw.scatter, 0, 4, base.scatter),
+    ...countAndFlip(raw, base)
   };
 }
 var BRUSH_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
@@ -959,6 +969,28 @@ function normalizeBehavior(raw = {}, base = DEFAULT_BEHAVIOR) {
     multicolor: normalizeMultiColor(raw.multicolor ?? {}, base.multicolor)
   };
 }
+function countAndFlip(raw, base) {
+  const n = typeof raw.count === "number" && Number.isFinite(raw.count) ? Math.min(16, Math.max(1, Math.round(raw.count))) : base.count ?? 1;
+  const flip = DAB_FLIPS.includes(raw.flip) ? raw.flip : base.flip ?? "none";
+  return { ...n > 1 ? { count: n } : {}, ...flip !== "none" ? { flip } : {} };
+}
+var withTipGrain = (g) => g ? { tipGrain: g } : {};
+function readTipGrain(raw, base) {
+  if (raw === null) return null;
+  if (!raw || typeof raw !== "object") return base;
+  const r = raw;
+  const source = typeof r.source === "string" && /^\S{1,200}$/.test(r.source) ? r.source : base?.source;
+  if (!source) return base;
+  const b = base ?? { source, ...DEFAULT_TIP_GRAIN };
+  return {
+    source,
+    mode: TIP_GRAIN_MODES.includes(r.mode) ? r.mode : b.mode,
+    scale: range(r.scale, 0.05, 20, b.scale),
+    depth: unit2(r.depth, b.depth),
+    contrast: range(r.contrast, 0, 3, b.contrast),
+    invert: typeof r.invert === "boolean" ? r.invert : b.invert
+  };
+}
 var DEFAULT_SPRAY = { density: 0.5, size: 0.12 };
 function readStamp(raw, base) {
   if (raw === null) return null;
@@ -1076,6 +1108,7 @@ function normalizePaintBrush(raw = {}, base) {
     light: normalizeLight(raw.light ?? {}, b.light ?? DEFAULT_LIGHT),
     stamp: readStamp(raw.stamp, b.stamp ?? null),
     spray: readSpray(raw.spray, b.spray ?? null),
+    ...withTipGrain(readTipGrain(raw.tipGrain, b.tipGrain ?? null)),
     paint,
     ...raw.builtin ? { builtin: true } : {}
   };
@@ -1109,6 +1142,7 @@ var BASE_BRUSH = {
 // src/brushes/resolve.ts
 var ALL = ["dab", "eraser", "mixer", "blender", "smudge", "wet", "impasto", "particle", "bristle", "sticker"];
 var EXCHANGE = ["dab", "wet", "impasto"];
+var DABS = ["dab", "eraser", "mixer", "blender", "smudge"];
 var NOT = { toEngine: (v) => !v, toFacet: (v) => !v };
 var EDITOR_STAMPS = {
   toEngine: (v) => v.flatMap((ref) => {
@@ -1133,6 +1167,9 @@ var BRUSH_FIELDS = [
   f("dynamics.pressureSmoothing", "pressureSmoothing"),
   f("dynamics.rotation", "rotation"),
   ...each("dynamics", "dynamics", ["minSize", "pressureFlow", "tiltSize", "tiltRoundness", "tiltOpacity", "velocitySize", "velocityOpacity", "sizeJitter", "angleJitter", "opacityJitter", "scatter"]),
+  f("dynamics.count", "dynamics.count", DABS),
+  f("dynamics.flip", "dynamics.flip", DABS),
+  f("tip.grain", "tipGrain", DABS),
   f("behaviour.grain", "grain"),
   ...each("light", "light", ["amount", "pressure"]),
   // Paint exchange: the dab, wet and impasto engines' behaviour, or the Mixer Brush's settings.
@@ -1355,6 +1392,8 @@ var BRUSH_TOOLS = ["eraser", "blender", "smudge", "water", "dryer", "blow", "blo
 var BRUSH_TIP_SHAPES = ["round", "flat", "chisel", "bristle", "stamp"];
 var BRUSH_MARKS_KINDS = ["continuous", "scatter", "particles", "objects"];
 var BRUSH_SURFACES = ["dry", "wet", "thick"];
+var BRUSH_GRAIN_MODES = ["moving", "texturised"];
+var BRUSH_FLIPS = ["none", "x", "y", "xy"];
 
 // src/brushes/schema.ts
 var MAX_BRUSH_PALETTE = 16;
@@ -1376,8 +1415,22 @@ var BRUSH_STAMP_PATTERN = `^(?:[^:\\s]+:\\S+|${STAMP_KINDS.join("|")})$`;
 var STAMP = {
   type: "string",
   pattern: BRUSH_STAMP_PATTERN,
-  description: `A sticker ref provider:id (find_stickers lists them; the editor's own are ${STAMP_KINDS.map((k) => `editor:${k}`).join(", ")}). A bare editor stamp (star) means editor:star.`
+  description: `A sticker ref provider:id (find_stickers lists them; the editor's own are ${STAMP_KINDS.map((k) => `editor:${k}`).join(", ")}), or an image source source:<id> (list_brush_sources lists them; add_brush_source makes one from an image). A bare editor stamp (star) means editor:star.`
 };
+var TIP_GRAIN_PATTERNS = GRAIN_PATTERNS.filter((p) => p !== "smooth");
+var BRUSH_GRAIN_SOURCE_PATTERN = `^(?:source:[a-z0-9][a-z0-9-]{0,63}|${TIP_GRAIN_PATTERNS.join("|")})$`;
+var TIP_GRAIN = object(
+  "Texture inside the tip (a grain source), separate from the paper's grain: each dab is multiplied by it. Continuous and scatter marks of round and stamp tips.",
+  {
+    source: { type: "string", pattern: BRUSH_GRAIN_SOURCE_PATTERN, description: `The texture: a built-in pattern (${TIP_GRAIN_PATTERNS.join(", ")}) or an image source source:<id> (list_brush_sources); light parts are peaks, which paint.` },
+    mode: oneOf2(BRUSH_GRAIN_MODES, "texturised (default): the grain stays put on the canvas, a texture under the paint; moving: it rolls along with the tip, turning with it."),
+    scale: num(0.05, 20, "Grain size: 1 is the pattern's or image's own size, 2 twice as coarse (default 1)."),
+    depth: unit3("How much the grain takes out of each dab: 0 none, 1 only the peaks paint (default 0.6)."),
+    contrast: num(0, 3, "Height contrast around the middle: below 1 softer, above 1 harsher (default 1)."),
+    invert: bool("Swap peaks and valleys (default false).")
+  },
+  ["source"]
+);
 var BRISTLES = object("Bristle tips: the tuft. Missing fields take their defaults.", {
   count: int(3, 128, "Bristles in the tuft (default 32)."),
   stiffness: unit3("Stiff bristles follow the tip; soft ones lag and bend into curves at turns (default 0.5)."),
@@ -1389,9 +1442,9 @@ var BRISTLES = object("Bristle tips: the tuft. Missing fields take their default
 var TIP = object(
   "The tip: its shape and the dab it lays.",
   {
-    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."),
+    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: dabs shaped like a stamp, a sticker or an image source (see stamps), also laid as sprays, objects or particles."),
     size: num(1, MAX_BRUSH_SIZE, "Diameter in px (default 20)."),
-    hardness: unit3("Edge hardness, 0 soft .. 1 hard (default 1)."),
+    hardness: unit3("Edge hardness, 0 soft .. 1 hard (default 1). Image-source stamps fade towards their edges below 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)."),
@@ -1407,8 +1460,9 @@ var TIP = object(
       minItems: 1,
       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 ${MAX_DOT_TEXTURES} in marks.stampOrder, and repeats weight the order.`
-    }
+      description: `Stamp tips: stickers or image sources (source:<id>). Continuous dabs and sprays lay the first; objects take only stickers and pick one at random per mark (default editor:star; repeats count once); particles use the first ${MAX_DOT_TEXTURES} in marks.stampOrder, and repeats weight the order.`
+    },
+    grain: TIP_GRAIN
   },
   ["shape"]
 );
@@ -1478,7 +1532,9 @@ var DYNAMICS = object("Pen feel: pressure, tilt, velocity, jitter, rotation and
   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).")
+  scatter: num(0, 4, "Random offset across the stroke, in diameters (default 0)."),
+  count: int(1, 16, "Dabs laid at each spacing step, each with its own jitter and scatter (default 1). Dab brushes."),
+  flip: oneOf2(BRUSH_FLIPS, "Mirror each dab at random across x, y or both (default none): variety for image and stamp tips.")
 });
 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: unit3("Pick-up ratio: how much of the paint under each dab the brush lifts and carries (default 0; with a reservoir 0.5)."),
@@ -1600,6 +1656,7 @@ var BRUSH_JSON_SCHEMA = object(
 );
 var BRUSH_FACET_SCHEMAS = {
   tip: TIP,
+  tipGrain: TIP_GRAIN,
   marks: { continuous: CONTINUOUS, scatter: SCATTER, particles: PARTICLES, objects: OBJECTS },
   dynamics: DYNAMICS,
   behaviour: BEHAVIOUR,
@@ -1609,6 +1666,139 @@ var BRUSH_FACET_SCHEMAS = {
   paint: PAINT
 };
 
+// src/brushes/sources.ts
+var BRUSH_SOURCE_PROVIDER = "source";
+var MAX_BRUSH_SOURCE_SIZE = 512;
+var MAX_BRUSH_SOURCE_INPUT_PIXELS = 4096 * 4096;
+var MAX_BRUSH_SOURCES = 500;
+var BRUSH_SOURCE_CHANNELS = ["auto", "alpha", "darkness", "lightness"];
+var BrushSourceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrushSourceError";
+  }
+};
+function brushSourceRef(id) {
+  return `${BRUSH_SOURCE_PROVIDER}:${id}`;
+}
+function isBrushSourceRef(ref) {
+  return typeof ref === "string" && ref.startsWith(`${BRUSH_SOURCE_PROVIDER}:`);
+}
+function brushSourceIdOf(ref) {
+  return isBrushSourceRef(ref) ? ref.slice(BRUSH_SOURCE_PROVIDER.length + 1) : null;
+}
+function brushSourceIds(brush) {
+  const refs = [...brush.tip.stamps ?? [], ...brush.tip.grain ? [brush.tip.grain.source] : []];
+  return [...new Set(refs.map(brushSourceIdOf).filter((id) => id !== null))];
+}
+function summarizeBrushSource(s) {
+  const { image: _i, ...rest } = s;
+  return { ...rest, ref: brushSourceRef(s.id) };
+}
+function brushSourceIdFromName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "source";
+}
+var text = (v, max) => typeof v === "string" && v.trim() ? v.trim().slice(0, max) : void 0;
+function fit(width, height, mask, max) {
+  const scale = Math.min(1, max / Math.max(width, height));
+  if (scale >= 1) return { width, height, mask: Uint8Array.from(mask) };
+  const w = Math.max(1, Math.round(width * scale));
+  const h = Math.max(1, Math.round(height * scale));
+  const out = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    const y0 = Math.floor(y * height / h);
+    const y1 = Math.max(y0 + 1, Math.floor((y + 1) * height / h));
+    for (let x = 0; x < w; x++) {
+      const x0 = Math.floor(x * width / w);
+      const x1 = Math.max(x0 + 1, Math.floor((x + 1) * width / w));
+      let sum = 0;
+      for (let yy = y0; yy < y1; yy++) for (let xx = x0; xx < x1; xx++) sum += mask[yy * width + xx];
+      out[y * w + x] = Math.round(sum / ((y1 - y0) * (x1 - x0)));
+    }
+  }
+  return { width: w, height: h, mask: out };
+}
+function brushSourceFromMask(meta, width, height, mask) {
+  if (!BRUSH_ID.test(meta.id)) throw new BrushSourceError(`Source id ${JSON.stringify(meta.id)} is not valid: use lowercase letters, digits and dashes (up to 64).`);
+  if (!(Number.isInteger(width) && Number.isInteger(height) && width > 0 && height > 0) || mask.length !== width * height) throw new BrushSourceError("The mask is not width \xD7 height bytes.");
+  let any = false;
+  for (let i = 0; i < mask.length && !any; i++) any = mask[i] > 0;
+  if (!any) throw new BrushSourceError(`"${meta.name}" has no marks: every pixel is empty. Pick another channel (alpha, darkness or lightness) or set invert.`);
+  const f2 = fit(width, height, mask, MAX_BRUSH_SOURCE_SIZE);
+  const name = text(meta.name, 80) ?? meta.id;
+  const licence = text(meta.licence, 2e3);
+  const origin = text(meta.origin, 200);
+  return { id: meta.id, name, width: f2.width, height: f2.height, image: pngDataUrl(f2.width, f2.height, f2.mask, 1), ...licence ? { licence } : {}, ...origin ? { origin } : {} };
+}
+function makeBrushSource(input, problems = []) {
+  const name = text(input.name, 80);
+  if (!name) throw new BrushSourceError("A brush source needs a name.");
+  const id = input.id ?? brushSourceIdFromName(name);
+  if (!BRUSH_ID.test(id)) throw new BrushSourceError(`Source id ${JSON.stringify(id)} is not valid: use lowercase letters, digits and dashes (up to 64), starting with a letter or digit.`);
+  let bytes;
+  if (typeof input.image === "string") {
+    const parsed = parseDataUrl(input.image);
+    if (!parsed) throw new BrushSourceError("image must be a data: URL (data:image/png;base64,\u2026) or PNG bytes.");
+    bytes = parsed.bytes;
+  } else bytes = input.image;
+  let png;
+  try {
+    png = decodePng(bytes, { maxPixels: MAX_BRUSH_SOURCE_INPUT_PIXELS });
+  } catch (e) {
+    throw new BrushSourceError(`The image can't be read as a PNG (${e.message}); convert it to PNG, at most ${MAX_BRUSH_SOURCE_INPUT_PIXELS} pixels.`);
+  }
+  const { width, height, data } = png;
+  const n = width * height;
+  let channel = input.channel ?? "auto";
+  if (channel === "auto") {
+    let transparent = false;
+    for (let i = 0; i < n && !transparent; i++) transparent = data[i * 4 + 3] < 250;
+    channel = transparent ? "alpha" : "darkness";
+    problems.push(`channel auto read the marks from ${channel === "alpha" ? "the transparency" : "the dark parts (dark marks on a light background)"}.`);
+  }
+  const mask = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    const a = data[i * 4 + 3];
+    const lum = (0.2126 * data[i * 4] + 0.7152 * data[i * 4 + 1] + 0.0722 * data[i * 4 + 2]) * (a / 255) + 255 * (1 - a / 255);
+    const v = channel === "alpha" ? a : channel === "darkness" ? 255 - lum : lum;
+    mask[i] = Math.round(input.invert ? 255 - v : v);
+  }
+  const source = brushSourceFromMask({ id, name, licence: input.licence, origin: input.origin }, width, height, mask);
+  if (source.width !== width) problems.push(`The image was scaled from ${width}\xD7${height} to ${source.width}\xD7${source.height} (sources are kept at most ${MAX_BRUSH_SOURCE_SIZE} px).`);
+  return source;
+}
+var GREY_PNG = /^data:image\/png;base64,[A-Za-z0-9+/]+=*$/;
+function readBrushSource(raw, at, problems) {
+  const r = raw;
+  if (!r || typeof r !== "object" || Array.isArray(r)) return void problems.push(`${at} is not a brush source; skipped.`), null;
+  if (typeof r.id !== "string" || !BRUSH_ID.test(r.id)) return void problems.push(`${at} has no valid id; skipped.`), null;
+  const ok = (v) => Number.isInteger(v) && v >= 1 && v <= MAX_BRUSH_SOURCE_SIZE;
+  if (!ok(r.width) || !ok(r.height)) return void problems.push(`${at} ("${r.id}") has no valid width and height (1..${MAX_BRUSH_SOURCE_SIZE}); skipped.`), null;
+  if (typeof r.image !== "string" || !GREY_PNG.test(r.image)) return void problems.push(`${at} ("${r.id}") has no PNG data: URL image; skipped.`), null;
+  const name = text(r.name, 80) ?? r.id;
+  const licence = text(r.licence, 2e3);
+  const origin = text(r.origin, 200);
+  return { id: r.id, name, width: r.width, height: r.height, image: r.image, ...licence ? { licence } : {}, ...origin ? { origin } : {} };
+}
+var decoded = /* @__PURE__ */ new Map();
+function decodeBrushSource(source) {
+  const hit = decoded.get(source.image);
+  if (hit) return hit;
+  const parsed = parseDataUrl(source.image);
+  if (!parsed) throw new BrushSourceError("The source image is not a data: URL.");
+  const png = decodePng(parsed.bytes, { keepGray: true, maxPixels: MAX_BRUSH_SOURCE_SIZE * MAX_BRUSH_SOURCE_SIZE });
+  let mask;
+  if (png.channels === 1) mask = png.data;
+  else {
+    mask = new Uint8ClampedArray(png.width * png.height);
+    for (let i = 0; i < mask.length; i++) mask[i] = Math.round(png.data[i * 4] * png.data[i * 4 + 3] / 255);
+  }
+  const out = { width: png.width, height: png.height, mask };
+  if (decoded.size > 256) decoded.delete(decoded.keys().next().value);
+  decoded.set(source.image, out);
+  return out;
+}
+
 // src/brushes/normalize.ts
 var WET_BRUSH_TOOLS = ["water", "dryer", "blow", "blot", "wet-blend", "wet-drag"];
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -1787,13 +1977,26 @@ function normalizeBrushSpec(raw, problems = []) {
     delete brush.tip.stamps;
   }
   if (brush.tip.stamps) {
-    const stamps = brush.tip.stamps.map((s) => normalizeStickerRef(s));
+    let stamps = brush.tip.stamps.map((s) => normalizeStickerRef(s));
+    if (brush.marks?.kind === "objects" && stamps.some(isBrushSourceRef)) {
+      problems.push("tip.stamps: image sources (source:\u2026) dropped: objects marks lay stickers; use continuous, scatter or particles marks for an image tip.");
+      stamps = stamps.filter((s) => !isBrushSourceRef(s));
+    }
     if (stamps.length) brush.tip.stamps = stamps;
     else {
       drop("tip.stamps", "none of the stamps can be laid");
       delete brush.tip.stamps;
     }
   }
+  if (brush.tip.grain) {
+    const surface = brush.behaviour?.surface;
+    const marks = brush.marks?.kind;
+    const why = !brush.tip.grain.source ? "it needs a source (a grain pattern or source:<id>)" : brush.tip.shape === "bristle" ? "bristle tips lay their own marks" : marks === "particles" || marks === "objects" ? `${marks} marks are not dabs` : surface === "wet" || surface === "thick" ? `${surface} paint lays its own texture` : kind === "tool" && WET_BRUSH_TOOLS.includes(brush.tool) ? "the wet tools work on the wet layer" : null;
+    if (why) {
+      drop("tip.grain", why);
+      delete brush.tip.grain;
+    }
+  }
   const b = brush.behaviour;
   if (b) {
     const wetTool = kind === "tool" && WET_BRUSH_TOOLS.includes(brush.tool);
@@ -1850,7 +2053,9 @@ var PAINT_PROFILE = {
   motion: "full",
   colours: ALL_COLOURS,
   velocity: "full",
-  tilt: "full"
+  tilt: "full",
+  tipGrain: "full",
+  dabCount: "full"
 };
 var IMAGE_PROFILE = {
   id: "image",
@@ -1867,7 +2072,9 @@ var IMAGE_PROFILE = {
   motion: "none",
   colours: ["solid", "dual", "gradient"],
   velocity: "ignored",
-  tilt: "ignored"
+  tilt: "ignored",
+  tipGrain: "ignored",
+  dabCount: "ignored"
 };
 var CANVAS_PROFILE = {
   id: "canvas",
@@ -1884,7 +2091,9 @@ var CANVAS_PROFILE = {
   motion: "none",
   colours: ["solid", "dual", "gradient"],
   velocity: "ignored",
-  tilt: "full"
+  tilt: "full",
+  tipGrain: "ignored",
+  dabCount: "ignored"
 };
 var VECTOR_PROFILE = { ...CANVAS_PROFILE, id: "vector", name: "Vector editor", kinds: ["mark", "tool"], tools: ["blender", "smudge"], surfaces: ["dry", "wet"], reservoir: "full", light: "ignored" };
 var BRUSH_HOST_PROFILES = { paint: PAINT_PROFILE, image: IMAGE_PROFILE, canvas: CANVAS_PROFILE, vector: VECTOR_PROFILE };
@@ -1908,7 +2117,10 @@ function checkBrush(brush, profile) {
   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)}.`);
+  if (!profile.tipShapes.includes(brush.tip.shape)) {
+    const image = brush.tip.shape === "stamp" && (brush.tip.stamps ?? []).some(isBrushSourceRef);
+    add("tip.shape", "error", `${host} can't lay a ${image ? "stamp tip (image tips are stamps)" : `${brush.tip.shape} tip`}.`, `Set tip.shape to one of: ${list(profile.tipShapes)}.`);
+  }
   const marks = brush.marks?.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 = brush.behaviour?.surface ?? "dry";
@@ -1921,6 +2133,8 @@ function checkBrush(brush, profile) {
   const m = brush.motion;
   feature(profile.motion, !!m && (!!m.live || nonZero(m.waveSpeed) || m.fps !== void 0), "motion", "animation", "Remove motion.");
   const d = brush.dynamics ?? {};
+  feature(profile.tipGrain ?? "none", !!brush.tip.grain, "tip.grain", "tip grain", "Remove tip.grain (behaviour.grain textures with the paper instead).");
+  feature(profile.dabCount ?? "none", (d.count ?? 1) > 1, "dynamics.count", "several dabs per step", "Set dynamics.count to 1.");
   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;
@@ -1976,6 +2190,12 @@ function degrade(brush, profile, options = {}) {
       case "behaviour.grain":
         delete b.behaviour.grain;
         break;
+      case "tip.grain":
+        delete b.tip.grain;
+        break;
+      case "dynamics.count":
+        delete b.dynamics.count;
+        break;
       case "light":
         delete b.light;
         break;
@@ -2024,6 +2244,15 @@ function isBrushLibrary(library) {
 }
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isV1 = (item) => "engine" in item || "category" in item || !("kind" in item);
+function parseBrushLibrarySources(raw, problems = []) {
+  const file = isObject2(raw) ? raw : null;
+  if (!file || file.sources === void 0) return [];
+  if (!Array.isArray(file.sources)) {
+    problems.push("sources is not a list; skipped.");
+    return [];
+  }
+  return file.sources.map((s, i) => readBrushSource(s, `sources[${i}]`, problems)).filter((s) => s !== null);
+}
 function parseBrushLibrary2(raw, problems = []) {
   if (typeof raw === "string") {
     try {
@@ -2066,8 +2295,8 @@ function matches(entry, f2) {
   if (f2.tool && b.tool !== f2.tool) return false;
   if (f2.tag && !(b.tags ?? []).includes(f2.tag)) return false;
   if (f2.text) {
-    const text = words([b.id, b.name, b.description ?? "", b.variety ?? "", b.medium ?? "", b.tool ?? "", ...b.tags ?? []].join(" "));
-    if (!words(f2.text).every((w) => text.some((t) => t.startsWith(w)))) return false;
+    const text2 = words([b.id, b.name, b.description ?? "", b.variety ?? "", b.medium ?? "", b.tool ?? "", ...b.tags ?? []].join(" "));
+    if (!words(f2.text).every((w) => text2.some((t) => t.startsWith(w)))) return false;
   }
   if (f2.profile && !checkBrush(b, f2.profile).ok) return false;
   return true;
@@ -2077,8 +2306,10 @@ function createBrushLibrary(options = {}) {
   const presets = (options.presets ?? BRUSH_PRESETS).map(copy3);
   const builtinIds = new Set(presets.map((b) => b.id));
   const key = `${options.namespace ?? "pixerate.brushes"}:user`;
+  const sourcesKey = `${options.namespace ?? "pixerate.brushes"}:sources`;
   const listeners = /* @__PURE__ */ new Set();
   let user = null;
+  let sources = null;
   let queue = Promise.resolve();
   const run = (task) => {
     const result = queue.then(task, task);
@@ -2104,6 +2335,44 @@ function createBrushLibrary(options = {}) {
     if (options.storage) await options.storage.set(key, JSON.stringify(file));
     user = brushes;
   };
+  const loadSources = async () => {
+    if (sources) return sources;
+    const raw = options.storage ? await options.storage.get(sourcesKey) : null;
+    let list2 = [];
+    if (raw) {
+      try {
+        list2 = parseBrushLibrarySources(JSON.parse(raw));
+      } catch {
+      }
+    }
+    sources = list2;
+    return sources;
+  };
+  const storeSources = async (list2) => {
+    if (options.storage) await options.storage.set(sourcesKey, JSON.stringify({ format: "pixerate-brush-sources", version: 1, sources: list2 }));
+    sources = list2;
+  };
+  const putSources = async (incoming, overwrite, problems) => {
+    let list2 = [...await loadSources()];
+    const changed = [];
+    for (const src of incoming) {
+      const at = list2.findIndex((x) => x.id === src.id);
+      if (at === -1) {
+        if (list2.length >= MAX_BRUSH_SOURCES) {
+          problems.push(`Source "${src.id}" skipped: the library holds at most ${MAX_BRUSH_SOURCES} sources.`);
+          continue;
+        }
+        list2.push(src);
+        changed.push(src.id);
+      } else if (list2[at].image === src.image) continue;
+      else if (overwrite) {
+        list2 = list2.map((x, i) => i === at ? src : x);
+        changed.push(src.id);
+      } else problems.push(`Source "${src.id}" exists already with another image; skipped (pass overwrite to replace it).`);
+    }
+    if (changed.length) await storeSources(list2);
+    return changed;
+  };
   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);
@@ -2165,12 +2434,17 @@ function createBrushLibrary(options = {}) {
     }),
     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) };
+      const used = new Set(brushes.flatMap(brushSourceIds));
+      const withSources = (await loadSources()).filter((s) => used.has(s.id));
+      return { format: "pixerate-brushes", version: 2, brushes: brushes.map(copy3), ...withSources.length ? { sources: withSources.map(copy3) } : {} };
     }),
     importFile: (raw, o = {}) => run(async () => {
       const problems = [];
       const incoming = parseBrushLibrary2(raw, problems);
       const result = { added: [], replaced: [], skipped: [], problems };
+      const fileSources = parseBrushLibrarySources(typeof raw === "string" ? JSON.parse(raw) : raw, problems);
+      const changedSources = fileSources.length ? await putSources(fileSources, !!o.overwrite, problems) : [];
+      if (changedSources.length) result.sources = changedSources;
       let brushes = [...await load()];
       for (const brush of incoming) {
         if (builtinIds.has(brush.id)) {
@@ -2190,12 +2464,45 @@ function createBrushLibrary(options = {}) {
           problems.push(`"${brush.id}" exists already; skipped (pass overwrite to replace it).`);
         }
       }
-      if (result.added.length || result.replaced.length) {
-        await store(brushes);
-        notify();
-      }
+      if (result.added.length || result.replaced.length) await store(brushes);
+      if (result.added.length || result.replaced.length || changedSources.length) notify();
       return result;
     }),
+    listSources: () => run(async () => (await loadSources()).map(copy3)),
+    getSource: (id) => run(async () => {
+      const s = (await loadSources()).find((x) => x.id === id);
+      return s ? copy3(s) : null;
+    }),
+    addSource: (input, o = {}) => run(async () => {
+      const problems = [];
+      let source;
+      if (isObject2(input) && "width" in input) {
+        const read2 = readBrushSource(input, "source", problems);
+        if (!read2) throw new BrushLibraryError("invalid", problems.join(" "));
+        source = read2;
+      } else {
+        const given = input;
+        const taken = new Set((await loadSources()).map((x) => x.id));
+        let id = given.id;
+        if (id === void 0 && typeof given.name === "string") {
+          const stem = brushSourceIdFromName(given.name);
+          id = stem;
+          for (let n = 2; taken.has(id); n++) id = `${stem}-${n}`;
+        }
+        try {
+          source = makeBrushSource({ ...given, id }, problems);
+        } catch (e) {
+          throw new BrushLibraryError("invalid", e.message);
+        }
+      }
+      const list2 = await loadSources();
+      const at = list2.findIndex((x) => x.id === source.id);
+      if (at !== -1 && !o.overwrite) throw new BrushLibraryError("exists", `A source "${source.id}" exists already; pick another id, or pass overwrite to replace its image (brushes using it change too).`);
+      if (at === -1 && list2.length >= MAX_BRUSH_SOURCES) throw new BrushLibraryError("invalid", `The library holds at most ${MAX_BRUSH_SOURCES} sources.`);
+      await storeSources(at === -1 ? [...list2, source] : list2.map((x, i) => i === at ? source : x));
+      notify();
+      return { source: copy3(source), problems, replaced: at !== -1 };
+    }),
     subscribe(listener) {
       listeners.add(listener);
       return () => {
@@ -2274,6 +2581,9 @@ export {
   DEFAULT_MULTI_COLOR,
   DEFAULT_BEHAVIOR,
   BRUSH_ROTATIONS,
+  DAB_FLIPS,
+  TIP_GRAIN_MODES,
+  DEFAULT_TIP_GRAIN,
   DEFAULT_DYNAMICS,
   normalizeDynamics,
   BRUSH_ID,
@@ -2305,10 +2615,30 @@ export {
   BRUSH_TIP_SHAPES,
   BRUSH_MARKS_KINDS,
   BRUSH_SURFACES,
+  BRUSH_GRAIN_MODES,
+  BRUSH_FLIPS,
   MAX_BRUSH_PALETTE,
   BRUSH_WORD,
+  TIP_GRAIN_PATTERNS,
+  BRUSH_GRAIN_SOURCE_PATTERN,
   BRUSH_JSON_SCHEMA,
   BRUSH_FACET_SCHEMAS,
+  BRUSH_SOURCE_PROVIDER,
+  MAX_BRUSH_SOURCE_SIZE,
+  MAX_BRUSH_SOURCE_INPUT_PIXELS,
+  MAX_BRUSH_SOURCES,
+  BRUSH_SOURCE_CHANNELS,
+  BrushSourceError,
+  brushSourceRef,
+  isBrushSourceRef,
+  brushSourceIdOf,
+  brushSourceIds,
+  summarizeBrushSource,
+  brushSourceIdFromName,
+  brushSourceFromMask,
+  makeBrushSource,
+  readBrushSource,
+  decodeBrushSource,
   WET_BRUSH_TOOLS,
   normalizeBrushSpec,
   PAINT_PROFILE,
@@ -2324,6 +2654,7 @@ export {
   degrade,
   BrushLibraryError,
   isBrushLibrary,
+  parseBrushLibrarySources,
   parseBrushLibrary2,
   createBrushLibrary,
   closest,