@pixerate/editor 0.266.2 → 0.267.0

package/dist/vector/index.js

@@ -35,7 +35,10 @@ import {
   traceField,
   traceVectorImage,
   vectorTraceContours
-} from "../chunk-EZOJBP4D.js";
+} from "../chunk-YIC6MAJ2.js";
+import {
+  rasterizeCoverage
+} from "../chunk-ADMRNWR7.js";
 import {
   applyHomography,
   homographyFromPoints,
@@ -63,7 +66,7 @@ import {
   reverseMorphContour,
   subpathToMorphContour,
   turnMorphContour
-} from "../chunk-LK4SXL3V.js";
+} from "../chunk-OSEXT7JL.js";
 import {
   DEFAULT_VECTOR_FONT,
   IDENTITY_MATRIX,
@@ -119,6 +122,7 @@ import {
   VECTOR_TRANSFORM_HANDLES,
   VECTOR_VERTICAL_RESIZING,
   VECTOR_VERTICAL_RESIZING_LABELS,
+  VECTOR_WET_STEPS,
   VECTOR_WIDTH_PRESETS,
   VECTOR_WIDTH_PRESET_IDS,
   VECTOR_WIDTH_PROFILE_MAX_POINTS,
@@ -128,6 +132,7 @@ import {
   VectorTextError,
   WARP_STYLES,
   WARP_STYLE_LABELS,
+  WetBrushstrokeJob,
   activeVectorEffects,
   activeVectorFilters,
   applyMatrix,
@@ -220,6 +225,7 @@ import {
   isUniformWidthProfile,
   isValidWarpMesh,
   isVectorBlendMode,
+  isVectorBrushstrokeEngine,
   isVectorBrushstrokeLayer,
   isVectorConnector,
   isVectorFilterType,
@@ -270,6 +276,7 @@ import {
   normalizeVectorPaintStacks,
   normalizeVectorTextRuns,
   offsetPaths,
+  onVectorBrushstrokesSettled,
   parseSvgTransform,
   parseVectorColor,
   parseVectorSvg,
@@ -287,6 +294,7 @@ import {
   puckerBloatPaths,
   pullWarpMesh,
   randomVectorBrushstrokeSeed,
+  readVectorBrushstrokePaint,
   rectSubpath,
   removeAnchors,
   removeVectorFreeformPoint,
@@ -294,6 +302,8 @@ import {
   removeWarpMeshSplitU,
   removeWarpMeshSplitV,
   removeWidthPoints,
+  renderBackdropBrushstroke,
+  renderWetBrushstroke,
   repeatPaths,
   replaceVectorText,
   rerouteVectorConnectors,
@@ -335,9 +345,11 @@ import {
   scaleVectorStrokeWidths,
   setAnchorCorner,
   setSubpathCorners,
+  setVectorBackdropSource,
   setVectorGradientVector,
   setVectorTextShaper,
   setWidthPoint,
+  settleVectorBrushstrokes,
   shadeVectorColor,
   simplifyPolyline,
   skewMatrix,
@@ -374,12 +386,14 @@ import {
   trimPathsIndividually,
   twistPaths,
   unionBounds,
+  usesVectorBackdrop,
   variableStrokeOutline,
   variableStrokeRings,
   vectorAppearanceNodes,
   vectorAppearanceOutline,
   vectorAppearanceShapes,
   vectorArtboards,
+  vectorBackdropRect,
   vectorBevelFaces,
   vectorBlendModeCss,
   vectorBlendModeFromCss,
@@ -392,7 +406,9 @@ import {
   vectorBrushstrokeCharacterError,
   vectorBrushstrokeDefaultColour,
   vectorBrushstrokeImages,
+  vectorBrushstrokePaintError,
   vectorBrushstrokeReach,
+  vectorBrushstrokesSettling,
   vectorChildAppearanceShapes,
   vectorConnectionSites,
   vectorConnectorTargetAt,
@@ -455,6 +471,7 @@ import {
   vectorMaskedShapes,
   vectorMasterArt,
   vectorMasterPages,
+  vectorMediaEngine,
   vectorMeshColorAt,
   vectorMeshFromOutline,
   vectorMeshLines,
@@ -539,11 +556,11 @@ import {
   withVectorStrokes,
   withVectorTargetPaint,
   zigzagPaths
-} from "../chunk-T2LDTEXK.js";
+} from "../chunk-4IDUYB45.js";
 import {
   snapshotBrushLibrary
-} from "../chunk-CIJBSUM5.js";
-import "../chunk-ACFSFUQH.js";
+} from "../chunk-AGNUD5BI.js";
+import "../chunk-JL6YH5WD.js";
 import {
   createProvenance
 } from "../chunk-M6DNZNVY.js";
@@ -580,6 +597,7 @@ import {
   resolveEffectValues
 } from "../chunk-MV7CYFMJ.js";
 import "../chunk-V2ZCJRDM.js";
+import "../chunk-GSTSZPSR.js";
 import {
   GRAIN_PATTERNS
 } from "../chunk-TXFWZ5ZJ.js";
@@ -1240,6 +1258,245 @@ function releaseVectorBlend(group, newId) {
   return [...keys, group.transform ? transformVectorNode(path, m) : path];
 }
 
+// src/vector/backdrop.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+var mul = (a, b) => [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
+var inv = (m) => {
+  const det = m[0] * m[3] - m[1] * m[2];
+  if (!det || !Number.isFinite(det)) return null;
+  return [m[3] / det, -m[1] / det, -m[2] / det, m[0] / det, (m[2] * m[5] - m[3] * m[4]) / det, (m[1] * m[4] - m[0] * m[5]) / det];
+};
+function parseVectorTransform(value) {
+  if (!value) return IDENTITY;
+  let m = IDENTITY;
+  for (const [, fn, args] of value.matchAll(/(matrix|translate|scale|rotate)\s*\(([^)]*)\)/g)) {
+    const n2 = args.split(/[\s,]+/).filter(Boolean).map(Number);
+    if (n2.some((v) => !Number.isFinite(v))) continue;
+    let t = IDENTITY;
+    if (fn === "matrix" && n2.length === 6) t = n2;
+    else if (fn === "translate") t = [1, 0, 0, 1, n2[0] ?? 0, n2[1] ?? 0];
+    else if (fn === "scale") t = [n2[0] ?? 1, 0, 0, n2[1] ?? n2[0] ?? 1, 0, 0];
+    else if (fn === "rotate") {
+      const a = (n2[0] ?? 0) * Math.PI / 180;
+      const [cx, cy] = [n2[1] ?? 0, n2[2] ?? 0];
+      t = mul(mul([1, 0, 0, 1, cx, cy], [Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0]), [1, 0, 0, 1, -cx, -cy]);
+    }
+    m = mul(m, t);
+  }
+  return m;
+}
+function flatten(d, m, tolerance = 0.25) {
+  const out = [];
+  let cur = null;
+  let x = 0, y = 0, sx = 0, sy = 0;
+  const push = (px, py) => cur.pts.push(m[0] * px + m[2] * py + m[4], m[1] * px + m[3] * py + m[5]);
+  const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
+  const steps = (len2) => Math.max(2, Math.min(64, Math.ceil(Math.sqrt(len2 * scale / tolerance))));
+  for (const c of parseSvgPath(d)) {
+    if (c.type === "M") {
+      cur = { pts: [], closed: false };
+      out.push(cur);
+      x = sx = c.x;
+      y = sy = c.y;
+      push(x, y);
+      continue;
+    }
+    if (!cur) continue;
+    if (c.type === "Z") {
+      cur.closed = true;
+      x = sx;
+      y = sy;
+      cur = { pts: [], closed: false };
+      out.push(cur);
+      push(x, y);
+      continue;
+    }
+    if (c.type === "C") {
+      const n2 = steps(Math.hypot(c.x1 - x, c.y1 - y) + Math.hypot(c.x2 - c.x1, c.y2 - c.y1) + Math.hypot(c.x - c.x2, c.y - c.y2));
+      for (let i = 1; i <= n2; i++) {
+        const t = i / n2, u = 1 - t;
+        push(u * u * u * x + 3 * u * u * t * c.x1 + 3 * u * t * t * c.x2 + t * t * t * c.x, u * u * u * y + 3 * u * u * t * c.y1 + 3 * u * t * t * c.y2 + t * t * t * c.y);
+      }
+    } else if (c.type === "Q") {
+      const n2 = steps(Math.hypot(c.x1 - x, c.y1 - y) + Math.hypot(c.x - c.x1, c.y - c.y1));
+      for (let i = 1; i <= n2; i++) {
+        const t = i / n2, u = 1 - t;
+        push(u * u * x + 2 * u * t * c.x1 + t * t * c.x, u * u * y + 2 * u * t * c.y1 + t * t * c.y);
+      }
+    } else push(c.x, c.y);
+    x = c.x;
+    y = c.y;
+  }
+  return out.filter((p) => p.pts.length >= 4);
+}
+function strokeCoverage(lines, width, rect) {
+  const r = width / 2;
+  if (!(r > 0)) return null;
+  const w = rect.width, h = rect.height;
+  let out = null;
+  for (const line2 of lines) {
+    const p = line2.pts;
+    const n2 = p.length / 2;
+    const segs = line2.closed ? n2 : n2 - 1;
+    for (let s = 0; s < segs; s++) {
+      const ax = p[2 * s] - rect.x, ay = p[2 * s + 1] - rect.y;
+      const k = (s + 1) % n2;
+      const bx = p[2 * k] - rect.x, by = p[2 * k + 1] - rect.y;
+      const x0 = Math.max(0, Math.floor(Math.min(ax, bx) - r - 1)), x1 = Math.min(w - 1, Math.ceil(Math.max(ax, bx) + r + 1));
+      const y0 = Math.max(0, Math.floor(Math.min(ay, by) - r - 1)), y1 = Math.min(h - 1, Math.ceil(Math.max(ay, by) + r + 1));
+      if (x0 > x1 || y0 > y1) continue;
+      const dx = bx - ax, dy = by - ay;
+      const l2 = dx * dx + dy * dy;
+      for (let yy = y0; yy <= y1; yy++) {
+        for (let xx = x0; xx <= x1; xx++) {
+          const px = xx + 0.5 - ax, py = yy + 0.5 - ay;
+          const t = l2 > 0 ? Math.min(1, Math.max(0, (px * dx + py * dy) / l2)) : 0;
+          const dist3 = Math.hypot(px - t * dx, py - t * dy);
+          const c = Math.min(1, Math.max(0, r + 0.5 - dist3));
+          if (c <= 0) continue;
+          out ??= new Float32Array(w * h);
+          const i = yy * w + xx;
+          if (c > out[i]) out[i] = c;
+        }
+      }
+    }
+  }
+  return out;
+}
+var pngs = /* @__PURE__ */ new Map();
+function decoded(href) {
+  if (pngs.has(href)) return pngs.get(href);
+  let img = null;
+  try {
+    const parsed = parseDataUrl(href);
+    const png = parsed ? decodePng(parsed.bytes) : null;
+    if (png && png.channels === 4) img = { width: png.width, height: png.height, data: png.data };
+  } catch {
+    img = null;
+  }
+  if (pngs.size >= 64) pngs.delete(pngs.keys().next().value);
+  pngs.set(href, img);
+  return img;
+}
+var Canvas = class {
+  constructor(rect) {
+    this.rect = rect;
+    this.px = new Float32Array(rect.width * rect.height * 4);
+  }
+  rect;
+  px;
+  over(i, c, a) {
+    const k = Math.min(1, Math.max(0, c[3] * a));
+    if (k <= 0) return;
+    const o = i * 4, px = this.px, rest = 1 - k;
+    px[o] = c[0] * k + px[o] * rest;
+    px[o + 1] = c[1] * k + px[o + 1] * rest;
+    px[o + 2] = c[2] * k + px[o + 2] * rest;
+    px[o + 3] = k + px[o + 3] * rest;
+  }
+  bytes() {
+    const out = new Uint8ClampedArray(this.px.length);
+    for (let i = 0; i < this.px.length; i += 4) {
+      const a = this.px[i + 3];
+      if (a <= 0) continue;
+      out[i] = Math.round(this.px[i] / a * 255);
+      out[i + 1] = Math.round(this.px[i + 1] / a * 255);
+      out[i + 2] = Math.round(this.px[i + 2] / a * 255);
+      out[i + 3] = Math.round(a * 255);
+    }
+    return out;
+  }
+};
+function paintCoverage(canvas, coverage, paint, defs, toLocal, alpha) {
+  if (!coverage || paint === "none") return;
+  const url = /^url\(#(.+)\)$/.exec(paint);
+  const solid = url ? null : parseVectorColor(paint);
+  if (!url && !solid) return;
+  const { x: rx, y: ry, width: w } = canvas.rect;
+  for (let i = 0; i < coverage.length; i++) {
+    const c = coverage[i];
+    if (c <= 0) continue;
+    let col = solid;
+    if (url) {
+      const px = rx + i % w + 0.5, py = ry + Math.floor(i / w) + 0.5;
+      col = sampleVectorPaintDefAt(defs, url[1], { x: toLocal[0] * px + toLocal[2] * py + toLocal[4], y: toLocal[1] * px + toLocal[3] * py + toLocal[5] });
+    }
+    if (col) canvas.over(i, col, c * alpha);
+  }
+}
+function drawImage(canvas, im, toLocal, alpha) {
+  const img = decoded(im.href);
+  if (!img || !(im.width > 0 && im.height > 0)) return;
+  const { x: rx, y: ry, width: w, height: h } = canvas.rect;
+  const c = [0, 0, 0, 0];
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const px = rx + xx + 0.5, py = ry + yy + 0.5;
+      const lx = toLocal[0] * px + toLocal[2] * py + toLocal[4], ly = toLocal[1] * px + toLocal[3] * py + toLocal[5];
+      const u = (lx - im.x) / im.width * img.width - 0.5, v = (ly - im.y) / im.height * img.height - 0.5;
+      if (u < -1 || v < -1 || u > img.width || v > img.height) continue;
+      const u0 = Math.floor(u), v0 = Math.floor(v), fu = u - u0, fv = v - v0;
+      c[0] = c[1] = c[2] = c[3] = 0;
+      for (let k = 0; k < 4; k++) {
+        const sx = u0 + (k & 1), sy = v0 + (k >> 1);
+        if (sx < 0 || sy < 0 || sx >= img.width || sy >= img.height) continue;
+        const wgt = (k & 1 ? fu : 1 - fu) * (k >> 1 ? fv : 1 - fv);
+        const o = (sy * img.width + sx) * 4, a = img.data[o + 3] / 255 * wgt;
+        c[0] += img.data[o] / 255 * a;
+        c[1] += img.data[o + 1] / 255 * a;
+        c[2] += img.data[o + 2] / 255 * a;
+        c[3] += a;
+      }
+      if (c[3] <= 0) continue;
+      canvas.over(yy * w + xx, [c[0] / c[3], c[1] / c[3], c[2] / c[3], c[3]], alpha);
+    }
+  }
+}
+function drawPath(canvas, p, defs, m, alpha) {
+  const toLocal = inv(m);
+  if (!toLocal) return;
+  const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+  const rule = p.fillRule === "evenodd" ? "evenodd" : "nonzero";
+  const layers = p.layers ?? [
+    { kind: "fill", index: 0, fill: p.fill, stroke: "none", strokeWidth: 0, opacity: 1 },
+    { kind: "stroke", index: 0, fill: "none", stroke: p.stroke, strokeWidth: p.strokeWidth, opacity: 1, strokeParts: p.strokeParts }
+  ];
+  let lines = null;
+  const shape = () => lines ??= flatten(p.d, m);
+  const fill = (d, rl) => {
+    const flat = (d ? flatten(d, m) : shape()).map((l) => Float64Array.from(l.pts));
+    return rasterizeCoverage(flat, canvas.rect, rl);
+  };
+  for (const l of layers) {
+    const a = alpha * l.opacity;
+    if (a <= 0) continue;
+    if (l.kind === "brushstroke") {
+      for (const im of l.images ?? []) drawImage(canvas, im, toLocal, a);
+    } else if (l.kind === "fill") {
+      if (l.fill !== "none") paintCoverage(canvas, fill(null, rule), l.fill, defs, toLocal, a);
+    } else if (l.stroke !== "none" && l.strokeWidth > 0) {
+      const parts = l.strokeParts;
+      const cov = parts?.outline ? fill(parts.outline, "nonzero") : strokeCoverage(parts ? flatten(parts.d, m) : shape(), (parts ? parts.align === "center" ? parts.width : parts.width / 2 : l.strokeWidth) * scale, canvas.rect);
+      paintCoverage(canvas, cov, l.stroke, defs, toLocal, a);
+    }
+  }
+}
+function drawNodes(canvas, nodes, defs, m, alpha) {
+  for (const n2 of nodes) {
+    if (n2.kind === "text") continue;
+    const mm = mul(m, parseVectorTransform(n2.transform));
+    const a = alpha * (n2.opacity ?? 1);
+    if (a <= 0) continue;
+    if (n2.kind === "group") drawNodes(canvas, n2.children, defs, mm, a);
+    else drawPath(canvas, n2, defs, mm, a);
+  }
+}
+function rasterizeVectorBackdrop(nodes, defs, toPixels, rect) {
+  const canvas = new Canvas(rect);
+  if (rect.width > 0 && rect.height > 0) drawNodes(canvas, nodes, defs, toPixels, 1);
+  return canvas.bytes();
+}
+
 // src/vector/perspective.ts
 function vectorPerspectivePlanes(p) {
   return p.vanishingPoints.length <= 1 ? ["floor", "side", "front"] : ["floor", "left", "right"];
@@ -1295,11 +1552,11 @@ function vectorPerspectiveFlatToPlane(p, plane) {
 }
 function vectorPerspectivePlaneToFlat(p, plane) {
   const h = vectorPerspectivePlaneMap(p, plane);
-  const inv = h ? invertHomography(h) : null;
-  if (!inv) return null;
+  const inv2 = h ? invertHomography(h) : null;
+  if (!inv2) return null;
   const o = p.origin;
   return (q) => {
-    const f = applyHomography(inv, q);
+    const f = applyHomography(inv2, q);
     if (!f) return null;
     const w = h[6] * f.x + h[7] * f.y + h[8];
     if (!(w > 1e-6)) return null;
@@ -1890,8 +2147,8 @@ var Model = class {
     const changed = /* @__PURE__ */ new Map();
     for (const [nodeId, slots] of byNode) {
       const loc = this.located.get(nodeId);
-      const inv = invertMatrix(loc.world);
-      const toLocal = (p) => applyMatrix(inv, p);
+      const inv2 = invertMatrix(loc.world);
+      const toLocal = (p) => applyMatrix(inv2, p);
       let subpaths = loc.node.subpaths;
       const circle = slots.find((s) => s.kind === "circle");
       if (circle) {
@@ -2678,7 +2935,7 @@ function renderLayers(node, defs, idPrefix) {
   const out = [];
   for (const l of vectorPaintLayerNodes(node)) {
     if (l.kind === "stroke" && isVectorBrushstrokeLayer(l.layer) && l.layer.visible !== false && (l.layer.opacity ?? 1) > 0) {
-      const images = vectorBrushstrokeImages(node, l.layer);
+      const images = vectorBrushstrokeImages(node, l.layer, scene ?? {});
       const blend2 = vectorBlendModeCss(l.layer.blendMode);
       if (images.length) out.push({ kind: "brushstroke", index: l.index, fill: "none", stroke: "none", strokeWidth: 0, opacity: l.layer.opacity ?? 1, ...blend2 ? { blendMode: blend2 } : {}, images });
       continue;
@@ -2852,6 +3109,68 @@ function resolvedLensNodes(doc) {
   return nodes;
 }
 function getVectorSceneRenderData(state, options = {}) {
+  const outer = scene;
+  scene = { document: state.document, settle: options.brushstrokes === "settled" ? "now" : "async" };
+  try {
+    return sceneRenderData(state, options);
+  } finally {
+    scene = outer;
+  }
+}
+var scene = null;
+function nodeChain(nodes, id) {
+  for (let i = 0; i < nodes.length; i++) {
+    const n2 = nodes[i];
+    if (n2.id === id) return [{ list: nodes, at: i }];
+    if (n2.type === "group") {
+      const inner = nodeChain(n2.children, id);
+      if (inner) return [{ list: nodes, at: i }, ...inner];
+    }
+  }
+  return null;
+}
+function nodesBelow(chain, last) {
+  const [level, ...rest] = chain;
+  const before = level.list.slice(0, level.at);
+  if (!rest.length) return [...before, last];
+  const group = level.list[level.at];
+  return [...before, { ...group, children: nodesBelow(rest, last) }];
+}
+setVectorBackdropSource((document, node, index, settle) => {
+  const nodes = document ? resolvedLensNodes(document) : [];
+  const chain = document ? nodeChain(nodes, node.id) : null;
+  const deps = [];
+  if (chain) {
+    for (let k = 0; k < chain.length; k++) {
+      const { list, at } = chain[k];
+      deps.push(...list.slice(0, at));
+      const n2 = list[at];
+      if (k < chain.length - 1) deps.push(JSON.stringify([n2.transform ?? null, n2.opacity ?? 1, n2.visible ?? true]));
+    }
+    if (document?.symbols) deps.push(document.symbols);
+  }
+  deps.push(...vectorFills(node), ...vectorStrokes(node).slice(0, index));
+  return {
+    deps,
+    backdrop: (rect, scale) => {
+      const lower = withVectorStrokes(node, vectorStrokes(node).slice(0, index));
+      const below = chain ? nodesBelow(chain, lower) : [lower];
+      const world = (chain ? vectorWorldMatrix(nodes, node.id) : null) ?? nodeMatrix(node);
+      const defs = [];
+      const outer = scene;
+      scene = { document: document ?? outer?.document ?? { width: 0, height: 0, nodes: [] }, settle };
+      let items;
+      try {
+        items = below.map((n2) => renderNode(n2, defs, [], "ve-backdrop-")).filter((n2) => !!n2);
+      } finally {
+        scene = outer;
+      }
+      const toPixels = multiplyMatrices(invertMatrix(world), [scale, 0, 0, scale, -rect.x, -rect.y]);
+      return rasterizeVectorBackdrop(items, defs, toPixels, { x: 0, y: 0, width: rect.width, height: rect.height });
+    }
+  };
+});
+function sceneRenderData(state, options) {
   const defs = [];
   const filters = [];
   const prefix = options.idPrefix ?? "ve-";
@@ -2974,13 +3293,13 @@ function symmetryOverlay(state) {
     if (!isVectorSymmetryGroup(n2)) continue;
     const world = vectorWorldMatrix(state.document.nodes, id);
     if (!world) continue;
-    const inv = invertMatrix(world);
+    const inv2 = invertMatrix(world);
     const corners2 = [
       { x: 0, y: 0 },
       { x: state.document.width, y: 0 },
       { x: 0, y: state.document.height },
       { x: state.document.width, y: state.document.height }
-    ].map((p) => applyMatrix(inv, p));
+    ].map((p) => applyMatrix(inv2, p));
     const { transform: _t, ...own } = n2;
     const b = unionBoxes([vectorNodeBounds(own), boundsFromCorners(corners2)]);
     if (!b) continue;
@@ -3793,7 +4112,7 @@ var BLEND = {
 function matrixOf(t) {
   if (!t) return [1, 0, 0, 1, 0, 0];
   let m = [1, 0, 0, 1, 0, 0];
-  const mul = (a, b) => [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
+  const mul2 = (a, b) => [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
   for (const [, name, args] of t.matchAll(/(\w+)\s*\(([^)]*)\)/g)) {
     const v = args.split(/[\s,]+/).filter(Boolean).map(Number);
     let k = [1, 0, 0, 1, 0, 0];
@@ -3803,9 +4122,9 @@ function matrixOf(t) {
     else if (name === "rotate") {
       const r = (v[0] ?? 0) * Math.PI / 180;
       const [cx, cy] = [v[1] ?? 0, v[2] ?? 0];
-      k = mul(mul([1, 0, 0, 1, cx, cy], [Math.cos(r), Math.sin(r), -Math.sin(r), Math.cos(r), 0, 0]), [1, 0, 0, 1, -cx, -cy]);
+      k = mul2(mul2([1, 0, 0, 1, cx, cy], [Math.cos(r), Math.sin(r), -Math.sin(r), Math.cos(r), 0, 0]), [1, 0, 0, 1, -cx, -cy]);
     }
-    m = mul(m, k);
+    m = mul2(m, k);
   }
   return m;
 }
@@ -4150,8 +4469,8 @@ function vectorDocumentToPdf(doc, options = {}) {
   const pageIds = [];
   docs.forEach((d, k) => {
     w.pageIndex = k;
-    const scene = getVectorSceneRenderData({ document: d, viewport: { x: 0, y: 0, zoom: 1 } }, { idPrefix: `p${k}-` });
-    const defs = new Map(scene.defs.map((x) => [x.id, x]));
+    const scene2 = getVectorSceneRenderData({ document: d, viewport: { x: 0, y: 0, zoom: 1 } }, { idPrefix: `p${k}-`, brushstrokes: "settled" });
+    const defs = new Map(scene2.defs.map((x) => [x.id, x]));
     const page = new Page(w, defs, notes);
     const W = d.width * scale;
     const H = d.height * scale;
@@ -4160,7 +4479,7 @@ function vectorDocumentToPdf(doc, options = {}) {
       const c = parseVectorColor(d.background);
       if (c) page.content.push(`${n(c[0])} ${n(c[1])} ${n(c[2])} rg`, `0 0 ${n(d.width)} ${n(d.height)} re`, "f");
     }
-    for (const node of scene.nodes) page.node(node, 1);
+    for (const node of scene2.nodes) page.node(node, 1);
     const content = w.add(w.stream("", new TextEncoder().encode(page.content.join("\n")), compress));
     const gsEntries = [...page.states.values()].map((name) => `/${name} ${w.add(w.gsDicts.get(`${k}:${name}`))} 0 R`);
     const shEntries = [...page.shadings.values()].map((name) => `/${name} ${w.add(w.shadingDicts.get(`${k}:${name}`))} 0 R`);
@@ -4988,8 +5307,8 @@ function mapEffects(node, f) {
 }
 function distortVectorNode(node, parentToDoc, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
   const toDoc = multiplyMatrices(nodeMatrix(node), parentToDoc);
-  const inv = invertMatrix(toDoc);
-  const local = (p) => applyMatrix(inv, f(applyMatrix(toDoc, p)));
+  const inv2 = invertMatrix(toDoc);
+  const local = (p) => applyMatrix(inv2, f(applyMatrix(toDoc, p)));
   const effects = mapEffects(node, local);
   if (node.type === "group") {
     const group = node;
@@ -6838,8 +7157,10 @@ var VectorEditorController = class _VectorEditorController {
   revision = 0;
   state;
   colorScheme;
+  colorLocked;
   constructor(options = {}) {
-    this.colorScheme = options.colorScheme ?? "light";
+    this.colorScheme = options.colorScheme === "dark" ? "dark" : "light";
+    this.colorLocked = !!options.colorLocked;
     this.brushLibrary = options.brushLibrary ?? null;
     this.brushPreview = options.brushPreview ?? null;
     this.brushes = options.brushLibrary ? snapshotBrushLibrary(options.brushLibrary, () => this.notify()) : null;
@@ -6866,7 +7187,9 @@ var VectorEditorController = class _VectorEditorController {
     this.cleanups.push(
       this.history.subscribe((h) => {
         if (!this.applying && this.historyDiffers(h)) this.notify();
-      })
+      }),
+      // A wet brushstroke settled: views redraw with its final image.
+      onVectorBrushstrokesSettled(() => this.notify())
     );
     if (this.historyDiffers(this.history.getState())) this.state = this.computeState();
   }
@@ -6949,6 +7272,8 @@ var VectorEditorController = class _VectorEditorController {
       blendDefaults: this.blendDefaults,
       gradientEdit: this.gradientEdit,
       freeDistort: this.freeDistort,
+      colorScheme: this.colorScheme,
+      colorLocked: this.colorLocked,
       textEdit: this.textEdit ? { nodeId: this.textEdit.nodeId, anchor: this.textEdit.anchor, focus: this.textEdit.focus } : null,
       textDefaults: this.textDefaults,
       symbolEdit: this.symbolEditState(),
@@ -7507,8 +7832,8 @@ var VectorEditorController = class _VectorEditorController {
     const node = this.getNode(id);
     if (!node || node.type !== "group" || !node.generation) return { ok: false, message: `"${id}" is not generated art.` };
     if (node.locked) return { ok: false, message: `"${id}" is locked; unlock it first.` };
-    const inv = invertMatrix(this.worldOf(id));
-    const placed = children.map((c) => this.freshIds(isIdentityMatrix(inv) ? c : transformVectorNode(c, inv)));
+    const inv2 = invertMatrix(this.worldOf(id));
+    const placed = children.map((c) => this.freshIds(isIdentityMatrix(inv2) ? c : transformVectorNode(c, inv2)));
     this.change("Regenerate Art", () => {
       this.replaceNode(id, { ...node, generation, children: placed });
       this.anchors = [];
@@ -8208,7 +8533,7 @@ var VectorEditorController = class _VectorEditorController {
    * Adds a brushstroke to the selected (or given) paths: a stroke layer that paints the path with
    * brush `brushId` (a preset, or a saved brush of the brush library: `listBrushstrokeBrushes`), `size` document
    * units across (default the brush's own), an optional `pressure` profile along the length, in
-   * `color` (default the brush's own default colour, unless `keepColour`; else the top stroke's
+   * `color` (default the brush's own default colour, unless `keepColour` or the colour is locked; else the top stroke's
    * paint, else black) at `opacity`. At the top of the stroke
    * stack or at `index`. A `seed` gives it the brush's character (jitter and the grain of `paper`,
    * `null` for none); without one it renders plain. One undo step.
@@ -8221,9 +8546,11 @@ var VectorEditorController = class _VectorEditorController {
     if (brush.size !== void 0 && !(brush.size > 0 && brush.size <= 500)) return { ok: false, message: "size must be above 0 and at most 500 (document units)." };
     const characterError = vectorBrushstrokeCharacterError(brush);
     if (characterError) return { ok: false, message: characterError };
+    const paintError = brush.paint !== void 0 ? vectorBrushstrokePaintError(brush.paint) : null;
+    if (paintError) return { ok: false, message: paintError };
     if (options.color !== void 0 && !parseVectorColor(options.color)) return { ok: false, message: `"${options.color}" is not a colour.` };
     if (options.opacity !== void 0 && !(options.opacity >= 0 && options.opacity <= 1)) return { ok: false, message: "opacity must be from 0 to 1." };
-    const own = options.keepColour ? null : vectorBrushstrokeDefaultColour(clean.brushId, user, this.colorScheme);
+    const own = options.keepColour || this.colorLocked ? null : vectorBrushstrokeDefaultColour(clean.brushId, user, this.colorScheme);
     return this.editStacks("stroke", options.ids, "Add Brushstroke", (stack, path) => {
       const top = [...stack].reverse().find((l) => (l.kind ?? "paint") === "paint");
       const paint = options.color ?? own ?? (typeof top?.paint === "string" && top.paint !== "none" ? top.paint : typeof path.stroke === "string" && path.stroke !== "none" ? path.stroke : "#000000");
@@ -8237,7 +8564,7 @@ var VectorEditorController = class _VectorEditorController {
    * given) paths: another brush, size, pressure profile (null removes it), colour or opacity, the
    * character `seed` (null removes it: plain dabs) or the `paper` (replaced whole: `null` for no
    * grain, `{}` for the default paper). Another brush without a `color` takes that brush's default
-   * colour, if it has one, unless `keepColour`. Fails, changing nothing, when that layer is not a
+   * colour, if it has one, unless `keepColour` or the colour is locked. Fails, changing nothing, when that layer is not a
    * brushstroke. With `merge`, consecutive edits fold into one undo step.
    */
   setBrushstroke(index, patch, options = {}) {
@@ -8249,6 +8576,8 @@ var VectorEditorController = class _VectorEditorController {
     if (patch.opacity !== void 0 && !(patch.opacity >= 0 && patch.opacity <= 1)) return { ok: false, message: "opacity must be from 0 to 1." };
     const characterError = vectorBrushstrokeCharacterError({ ...patch.seed !== null && patch.seed !== void 0 ? { seed: patch.seed } : {}, ...patch.paper !== void 0 ? { paper: patch.paper } : {} });
     if (characterError) return { ok: false, message: characterError };
+    const paintError = patch.paint !== void 0 && patch.paint !== null ? vectorBrushstrokePaintError(patch.paint) : null;
+    if (paintError) return { ok: false, message: paintError };
     const merge = options.merge === true ? `brushstroke:${index}` : options.merge || void 0;
     return this.editStacks(
       "stroke",
@@ -8265,7 +8594,9 @@ var VectorEditorController = class _VectorEditorController {
         if (patch.seed === null) delete brush.seed;
         else if (patch.seed !== void 0) brush.seed = patch.seed;
         if (patch.paper !== void 0) brush.paper = patch.paper;
-        const own = patch.brushId && patch.brushId !== layer.brush.brushId && !patch.keepColour ? vectorBrushstrokeDefaultColour(patch.brushId, user, this.colorScheme) : null;
+        if (patch.paint === null) delete brush.paint;
+        else if (patch.paint !== void 0) brush.paint = patch.paint;
+        const own = patch.brushId && patch.brushId !== layer.brush.brushId && !patch.keepColour && !this.colorLocked ? vectorBrushstrokeDefaultColour(patch.brushId, user, this.colorScheme) : null;
         const colour = patch.color ?? own;
         const next = { ...layer, brush: sanitizeVectorBrushstroke(brush, user) ?? layer.brush, ...colour ? { paint: colour } : {}, ...patch.opacity !== void 0 ? { opacity: patch.opacity } : {} };
         return stack.map((l, i) => i === index ? next : l);
@@ -8275,7 +8606,20 @@ var VectorEditorController = class _VectorEditorController {
   }
   /** Sets the colour scheme that picks the side of a brush's light / dark default colour. Existing strokes keep their colour. */
   setColorScheme(scheme) {
-    this.colorScheme = scheme;
+    const next = scheme === "dark" ? "dark" : "light";
+    if (this.colorScheme === next) return;
+    this.colorScheme = next;
+    this.notify();
+  }
+  /**
+   * Locks the brushstroke colour ("Keep my colour"): `addBrushstroke` and `setBrushstroke` with
+   * another brush keep the colour instead of taking the brush's default; an explicit `color` still
+   * applies. Existing strokes are unchanged. Editor state, not an undo step.
+   */
+  setColorLocked(locked) {
+    if (this.colorLocked === !!locked) return;
+    this.colorLocked = !!locked;
+    this.notify();
   }
   /** Removes layer `index` of the fill or stroke stack of the selected (or given) paths. */
   removePaintLayer(kind, index, options = {}) {
@@ -9098,7 +9442,7 @@ var VectorEditorController = class _VectorEditorController {
     if (!groups.length) return { ok: false, message: "Select a group to ungroup." };
     const set = new Set(groups.map((g) => g.id));
     this.change("Ungroup", () => {
-      const flatten = (list) => {
+      const flatten2 = (list) => {
         const out = [];
         let changed = false;
         for (const n2 of list) {
@@ -9110,14 +9454,14 @@ var VectorEditorController = class _VectorEditorController {
               ...n2.children.map((c) => c.blendStep ? (({ blendStep: _s, locked: _l, ...rest }) => rest)(c) : c).map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c).map((c) => n2.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (c.opacity ?? 1) * opacity } : c)
             );
           } else if (n2.type === "group") {
-            const children = flatten(n2.children);
+            const children = flatten2(n2.children);
             if (children !== n2.children) changed = true;
             out.push(children !== n2.children ? { ...n2, children } : n2);
           } else out.push(n2);
         }
         return changed ? out : list;
       };
-      this.setDoc(flatten(this.doc.nodes));
+      this.setDoc(flatten2(this.doc.nodes));
       this.selection = groups.flatMap((g) => g.children.map((c) => c.id));
     });
     return { ok: true };
@@ -9702,8 +10046,8 @@ var VectorEditorController = class _VectorEditorController {
       const parentM = this.parentMatrixOf(id);
       const r = project(node, parentM);
       if (typeof r === "string") return { ok: false, message: r };
-      const inv = invertMatrix(parentM);
-      next.set(id, isIdentityMatrix(inv) ? r : transformVectorNode(r, inv));
+      const inv2 = invertMatrix(parentM);
+      next.set(id, isIdentityMatrix(inv2) ? r : transformVectorNode(r, inv2));
     }
     this.change(`Attach to ${plane[0].toUpperCase()}${plane.slice(1)} Plane`, () => {
       this.setDoc(mapTree(this.doc.nodes, (n2) => next.get(n2.id) ?? n2));
@@ -11663,11 +12007,11 @@ var VectorEditorController = class _VectorEditorController {
     const nodes = mapTree(base.nodes, (n2) => {
       if (!targets.has(n2.id) || n2.type !== "path" || n2.locked) return n2;
       const world = vectorWorldMatrix(base.nodes, n2.id) ?? IDENTITY_MATRIX;
-      const inv = invertMatrix(world);
+      const inv2 = invertMatrix(world);
       const k = 1 / Math.sqrt(Math.abs(world[0] * world[3] - world[1] * world[2]) || 1);
       const local = dabs.map((d) => {
-        const c = applyMatrix(inv, d);
-        const moved = d.dx !== void 0 || d.dy !== void 0 ? applyMatrix(inv, { x: d.x + (d.dx ?? 0), y: d.y + (d.dy ?? 0) }) : null;
+        const c = applyMatrix(inv2, d);
+        const moved = d.dx !== void 0 || d.dy !== void 0 ? applyMatrix(inv2, { x: d.x + (d.dx ?? 0), y: d.y + (d.dy ?? 0) }) : null;
         return { ...d, x: c.x, y: c.y, radius: d.radius * k, ...moved ? { dx: moved.x - c.x, dy: moved.y - c.y } : {} };
       });
       const path = subpathsToBezier(n2.subpaths);
@@ -11712,8 +12056,8 @@ var VectorEditorController = class _VectorEditorController {
   }
   /** A stroke's points in node `id`'s own space. */
   localPoints(id, points) {
-    const inv = invertMatrix(this.worldOf(id));
-    return points.map((p) => toPoint2(applyMatrix(inv, p)));
+    const inv2 = invertMatrix(this.worldOf(id));
+    return points.map((p) => toPoint2(applyMatrix(inv2, p)));
   }
   /**
    * Knife: cuts closed paths along the polyline `points` (document space) wherever it crosses
@@ -12682,8 +13026,8 @@ var VectorEditorController = class _VectorEditorController {
         if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 3) return;
         drag.moved = true;
         const c = drag.widget.corner;
-        const inv = invertMatrix(this.worldOf(drag.widget.ref.nodeId, drag.base));
-        const d = applyMatrixLinear(inv, { x: p.x - drag.start.x, y: p.y - drag.start.y });
+        const inv2 = invertMatrix(this.worldOf(drag.widget.ref.nodeId, drag.base));
+        const d = applyMatrixLinear(inv2, { x: p.x - drag.start.x, y: p.y - drag.start.y });
         const radius = Math.max(0, Math.min(c.maxRadius, drag.widget.drawnRadius + cornerRadiusChange(c, d)));
         this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, radius));
         this.interaction = { type: "corner", ref: drag.widget.ref, radius };
@@ -15932,6 +16276,65 @@ function createVectorCommands(controller, options = {}) {
       }
     }
   ];
+  const BRUSH_PAINT = {
+    anyOf: [
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "color"],
+        description: "One colour instead of the layer colour (the layer colour still gives the alpha).",
+        properties: {
+          type: { type: "string", enum: ["color"], description: 'Always "color".' },
+          color: { type: "string", pattern: "^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$", description: "The colour as #rrggbb." }
+        }
+      },
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "stops"],
+        description: "Gradient paint: the brush samples it dab by dab along the path.",
+        properties: {
+          type: { type: "string", enum: ["gradient"], description: 'Always "gradient".' },
+          stops: {
+            type: "array",
+            minItems: 2,
+            maxItems: 16,
+            description: "2..16 stops sorted by offset.",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: ["offset", "color"],
+              properties: {
+                offset: { type: "number", minimum: 0, maximum: 1, description: "Position 0..1 along the gradient." },
+                color: { type: "string", description: 'The stop colour as #rrggbb, or "paint" (the layer colour) or "secondary" (white).', anyOf: [{ pattern: "^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$" }, { enum: ["paint", "secondary"] }] },
+                opacity: { type: "number", minimum: 0, maximum: 1, description: "Multiplies the brush flow where this colour is laid, 0..1 (default 1)." },
+                midpoint: { type: "number", minimum: 0.05, maximum: 0.95, description: "Where between this stop and the next the colours are half mixed, 0.05..0.95 (default 0.5)." }
+              }
+            }
+          },
+          space: { type: "string", enum: ["pigment", "oklab", "srgb"], description: "How neighbouring stops mix: pigment (default; like paint, blue to yellow passes green), oklab (perceptual) or srgb (plain numbers)." },
+          map: {
+            type: "object",
+            additionalProperties: false,
+            required: ["by"],
+            description: "What moves the stroke along the gradient (default distance, 300 document units, mirror).",
+            properties: {
+              by: {
+                type: "string",
+                enum: ["distance", "pressure", "tilt", "direction", "across-tip", "random"],
+                description: "distance: document units (or dabs) travelled along the path; pressure: the pressure profile 0..1; tilt: no tilt on paths, so the start of the gradient; direction: direction of travel, once round per 360\xB0; across-tip: left to right across the tip (a brush loaded with several colours); random: a seeded random point per dab (the layer seed). Paths have no timing, so velocity and time are not available."
+              },
+              length: { type: "number", minimum: 1, maximum: 1e5, description: 'distance: document units (or dabs, with unit "dabs") per run through the gradient (default 300).' },
+              repeat: { type: "string", enum: ["clamp", "repeat", "mirror"], description: "distance: past the end, clamp (hold the last colour), repeat (start again) or mirror (run back; default)." },
+              unit: { type: "string", enum: ["px", "dabs"], description: 'distance: document units ("px", default) or dabs.' },
+              every: { type: "integer", minimum: 1, maximum: 500, description: "random: dabs per random pick (default 1)." }
+            }
+          },
+          softness: { type: "number", minimum: 0, maximum: 1, description: "How softly neighbouring stops blend: 1 smooth (default) .. 0 hard steps." }
+        }
+      }
+    ]
+  };
   const BRUSH_SEED = { type: "integer", minimum: 0, maximum: VECTOR_BRUSHSTROKE_MAX_SEED };
   const BRUSH_PAPER = {
     type: "object",
@@ -15943,6 +16346,10 @@ function createVectorCommands(controller, options = {}) {
     },
     additionalProperties: false
   };
+  const brushColourResult = () => {
+    const st2 = controller.getState();
+    return { colorScheme: st2.colorScheme, colorLocked: st2.colorLocked };
+  };
   const brushstrokeCommands = () => [
     {
       ...base,
@@ -15950,16 +16357,16 @@ function createVectorCommands(controller, options = {}) {
       label: "Brushstroke Brushes",
       readOnly: true,
       keywords: ["brush", "brushstroke", "pencil", "pastel", "charcoal", "ink", "marker", "natural media"],
-      description: "Lists the brushes a brushstroke can use (the dry presets, then saved brushes from the brush library the vector profile admits): { brushes: [{ id, name, category, size, builtin }] } (size: the brush's own diameter in document units).",
+      description: "Lists the brushes a brushstroke can use (the dry presets, wet paint (watercolour, gouache, wet oils), the Mixer Brush, smudge and blender, then saved brushes from the brush library the vector profile admits): { brushes: [{ id, name, category, size, builtin }], colorScheme, colorLocked } (size: the brush's own diameter in document units; colorScheme picks the side of light / dark default colours; colorLocked: brushstrokes keep their colour, vector.setColorLocked).",
       params: { type: "object", properties: {}, additionalProperties: false },
-      run: () => ({ brushes: controller.listBrushstrokeBrushes().map((b) => ({ id: b.id, name: b.name, category: b.category, size: b.tip.size, builtin: vectorBrushstrokeBrush(b.id) !== null })) })
+      run: () => ({ brushes: controller.listBrushstrokeBrushes().map((b) => ({ id: b.id, name: b.name, category: b.category, size: b.tip.size, builtin: vectorBrushstrokeBrush(b.id) !== null })), ...brushColourResult() })
     },
     {
       ...base,
       id: `${prefix}addBrushstroke`,
       label: "Add Brushstroke\u2026",
       keywords: ["brushstroke", "brush", "natural media", "pencil line", "chalk", "sketchy", "hand-drawn", "ink stroke"],
-      description: "Paints paths (`ids`, default the selection; groups: every path inside) with a natural-media brush along their outline, as a stroke layer of kind brushstroke: `brushId` from vector.listBrushes, `size` (document units), an optional `pressure` profile (0\u20131 values spread from start to end, e.g. [0.2, 1, 0.2] for a tapered stroke), `color` and `opacity`. Pass a `seed` for the brush's character (seeded size, angle, opacity and scatter jitter plus a paper grain: what makes pencil, pastel and charcoal look real), with `paper` to choose the grain or null for none; without a seed the brush paints plain, even dabs. The path stays editable; the strokes follow it. One undo step. Returns { paths: [{ id, strokes }] } (the brushstroke is a stroke layer; change it with vector.setBrushstroke, remove it with vector.removeStroke).",
+      description: "Paints paths (`ids`, default the selection; groups: every path inside) with a natural-media brush along their outline, as a stroke layer of kind brushstroke: `brushId` from vector.listBrushes, `size` (document units), an optional `pressure` profile (0\u20131 values spread from start to end, e.g. [0.2, 1, 0.2] for a tapered stroke), `color`, `opacity` and gradient `paint` sampled dab by dab along the path. Wet paint (watercolour, gouache, wet oils) bleeds and dries; the scene shows it as laid until it settles, exports wait for it. The Mixer Brush, smudge and blender act on the shapes beneath the stroke (fills, strokes and brushstrokes; not text, images or effects). Pass a `seed` for the brush's character (seeded size, angle, opacity and scatter jitter plus a paper grain: what makes pencil, pastel and charcoal look real), with `paper` to choose the grain or null for none; without a seed the brush paints plain, even dabs. The path stays editable; the strokes follow it. One undo step. Returns { paths: [{ id, strokes }] } (the brushstroke is a stroke layer; change it with vector.setBrushstroke, remove it with vector.removeStroke).",
       params: {
         type: "object",
         properties: {
@@ -15972,7 +16379,8 @@ function createVectorCommands(controller, options = {}) {
           opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0\u20131 (default 1)." },
           index: { type: "integer", minimum: 0, description: "Position in the stroke stack, 0 the bottom (default: on top)." },
           seed: { ...BRUSH_SEED, description: "Character seed 0\u20132147483647: turns on the brush's jitter and paper grain; the same seed always renders the same stroke (default: none, plain dabs)." },
-          paper: { anyOf: [BRUSH_PAPER, { type: "null" }], description: "With `seed`: the paper the grain comes from { pattern, seed, scale, depth }, or null for jitter without grain (default: the sanded paper)." }
+          paper: { anyOf: [BRUSH_PAPER, { type: "null" }], description: "With `seed`: the paper the grain comes from { pattern, seed, scale, depth }, or null for jitter without grain (default: the sanded paper)." },
+          paint: { ...BRUSH_PAINT, description: 'Gradient paint sampled dab by dab along the path instead of the colour, e.g. { type: "gradient", stops: [{ offset: 0, color: "#e11d48" }, { offset: 1, color: "#2563eb" }], map: { by: "distance", length: 200, repeat: "clamp" } } (default: the colour; a gradient layer colour or a gradient brush paints its own gradient).' }
         },
         required: ["brushId"],
         additionalProperties: false
@@ -15988,7 +16396,8 @@ function createVectorCommands(controller, options = {}) {
               ...params.size !== void 0 ? { size: params.size } : {},
               ...params.pressure ? { pressure: params.pressure } : {},
               ...params.seed !== void 0 ? { seed: params.seed } : {},
-              ...params.paper !== void 0 ? { paper: params.paper } : {}
+              ...params.paper !== void 0 ? { paper: params.paper } : {},
+              ...params.paint !== void 0 ? { paint: params.paint } : {}
             },
             { ...params.ids ? { ids: params.ids } : {}, ...params.index !== void 0 ? { index: params.index } : {}, ...params.color ? { color: params.color } : {}, ...params.keepColour ? { keepColour: true } : {}, ...params.opacity !== void 0 ? { opacity: params.opacity } : {} }
           )
@@ -16006,7 +16415,7 @@ function createVectorCommands(controller, options = {}) {
       id: `${prefix}setBrushstroke`,
       label: "Edit Brushstroke\u2026",
       keywords: ["brushstroke", "brush", "size", "pressure", "taper"],
-      description: "Changes the brushstroke at stroke layer `index` of path `id` (vector.getAppearance lists strokes; 0 is the bottom): `brushId` (the same id again takes that saved brush as the library has it now), `size` (null: the brush's own), `pressure` (null: full pressure), `color`, `opacity`, `seed` (turns the brush's character on; null: plain dabs) and `paper` (replaced whole; null: no grain; {}: the default paper). Pass at least one. One undo step. Returns { id, strokes }.",
+      description: "Changes the brushstroke at stroke layer `index` of path `id` (vector.getAppearance lists strokes; 0 is the bottom): `brushId` (the same id again takes that saved brush as the library has it now), `size` (null: the brush's own), `pressure` (null: full pressure), `color`, `opacity`, `seed` (turns the brush's character on; null: plain dabs), `paper` (replaced whole; null: no grain; {}: the default paper) and gradient `paint` (null: the colour). Pass at least one. One undo step. Returns { id, strokes }.",
       params: {
         type: "object",
         properties: {
@@ -16019,7 +16428,8 @@ function createVectorCommands(controller, options = {}) {
           keepColour: { type: "boolean", description: "With another brushId: keep the layer's colour instead of taking the new brush's default colour (default false)." },
           opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0\u20131." },
           seed: { anyOf: [BRUSH_SEED, { type: "null" }], description: "Character seed 0\u20132147483647 (jitter and paper grain; a new seed gives a new take on the same stroke), or null for plain dabs." },
-          paper: { anyOf: [BRUSH_PAPER, { type: "null" }], description: "The paper the grain comes from { pattern, seed, scale, depth } (applies with a seed), null for no grain, or {} for the default sanded paper." }
+          paper: { anyOf: [BRUSH_PAPER, { type: "null" }], description: "The paper the grain comes from { pattern, seed, scale, depth } (applies with a seed), null for no grain, or {} for the default sanded paper." },
+          paint: { anyOf: [...BRUSH_PAINT.anyOf, { type: "null" }], description: "Gradient paint sampled dab by dab along the path (replaced whole), or null to paint the colour again." }
         },
         required: ["id", "index"],
         additionalProperties: false
@@ -16027,11 +16437,45 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const { id, index, ...patch } = params;
-        if (!Object.keys(patch).length) fail("Pass at least one of brushId, size, pressure, color, opacity, seed, paper.");
+        if (!Object.keys(patch).length) fail("Pass at least one of brushId, size, pressure, color, opacity, seed, paper, paint.");
         layerIndex(id, "stroke", index);
         check2(controller.setBrushstroke(index, patch, { ids: [id] }));
         return stackResult(id, "stroke");
       }
+    },
+    {
+      ...base,
+      id: `${prefix}setColorLocked`,
+      label: "Keep My Colour",
+      keywords: ["lock colour", "keep colour", "brush colour", "color lock", "brushstroke"],
+      description: `Locks or unlocks the brushstroke colour ("Keep my colour"): while locked, vector.addBrushstroke and vector.setBrushstroke with another brushId keep the colour (the path's stroke colour, or the layer's) instead of taking the brush's default colour; an explicit color still applies. Strokes already made are unchanged. Editor state, not an undo step. Returns { colorScheme, colorLocked }.`,
+      params: {
+        type: "object",
+        properties: { locked: { type: "boolean", description: "true locks the colour, false unlocks it (the editor starts unlocked)." } },
+        required: ["locked"],
+        additionalProperties: false
+      },
+      run: (_ctx, params) => {
+        controller.setColorLocked(params.locked);
+        return brushColourResult();
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}setColorScheme`,
+      label: "Brush Colours for Light / Dark",
+      keywords: ["colour scheme", "dark mode", "light mode", "theme", "brush colour"],
+      description: "Sets the colour scheme that picks the side of a brush's light / dark default colour for brushstrokes made from now on (white chalk in dark, dark chalk in light). Strokes already made keep their colour. The host usually sets it to match its theme. Editor state, not an undo step. Returns { colorScheme, colorLocked }.",
+      params: {
+        type: "object",
+        properties: { scheme: { type: "string", enum: ["light", "dark"], description: "light (dark chalk on a light background) or dark (light chalk on a dark one)." } },
+        required: ["scheme"],
+        additionalProperties: false
+      },
+      run: (_ctx, params) => {
+        controller.setColorScheme(params.scheme);
+        return brushColourResult();
+      }
     }
   ];
   const pdfCommands = () => [
@@ -16139,13 +16583,13 @@ function createVectorCommands(controller, options = {}) {
         const { image, ...options2 } = params;
         const parsed = parseDataUrl(image);
         if (!parsed || !isPng(parsed.bytes)) fail("image must be a PNG data URL (data:image/png;base64,\u2026).");
-        let decoded;
+        let decoded2;
         try {
-          decoded = decodePng(parsed.bytes, { maxPixels: VECTOR_TRACE_MAX_PIXELS });
+          decoded2 = decodePng(parsed.bytes, { maxPixels: VECTOR_TRACE_MAX_PIXELS });
         } catch (e) {
           return fail(`The PNG could not be read: ${e.message}`);
         }
-        const r = controller.traceImage(decoded, options2);
+        const r = controller.traceImage(decoded2, options2);
         check2(r);
         return {
           id: r.id,
@@ -18184,13 +18628,13 @@ function getVectorSymbolsPanel(state, options = {}) {
   const symbols = (host.symbols ?? []).map((s) => {
     const b = unionBounds(s.nodes.map((n2) => vectorNodeBounds(n2, IDENTITY_MATRIX))) ?? { x: -10, y: -10, width: 20, height: 20 };
     const pad = Math.max(b.width, b.height) * 0.08 + 1;
-    const scene = getVectorSceneRenderData({ document: { width: 0, height: 0, nodes: s.nodes }, viewport: { x: 0, y: 0, zoom: 1 } }, { idPrefix: `${prefix}${s.id}-` });
+    const scene2 = getVectorSceneRenderData({ document: { width: 0, height: 0, nodes: s.nodes }, viewport: { x: 0, y: 0, zoom: 1 } }, { idPrefix: `${prefix}${s.id}-` });
     return {
       id: s.id,
       name: s.name,
       instances: counts.get(s.id) ?? 0,
       viewBox: `${fmt3(b.x - pad)} ${fmt3(b.y - pad)} ${fmt3(b.width + 2 * pad)} ${fmt3(b.height + 2 * pad)}`,
-      scene,
+      scene: scene2,
       editing: state.symbolEdit?.symbolId === s.id
     };
   });
@@ -18207,9 +18651,9 @@ function getVectorSymbolEditBackground(state, options = {}) {
   const e = state.symbolEdit;
   if (!e || !e.hostTransform) return null;
   const drop = (list) => list.filter((n2) => n2.id !== e.instanceId).map((n2) => n2.type === "group" ? { ...n2, children: drop(n2.children) } : n2);
-  const scene = getVectorSceneRenderData({ document: { ...e.host, nodes: drop(e.host.nodes) }, viewport: state.viewport }, { idPrefix: options.idPrefix ?? "ve-host-" });
+  const scene2 = getVectorSceneRenderData({ document: { ...e.host, nodes: drop(e.host.nodes) }, viewport: state.viewport }, { idPrefix: options.idPrefix ?? "ve-host-" });
   const m = e.hostTransform;
-  return { ...scene, transform: `${scene.transform} matrix(${m.map((v) => Math.round(v * 1e6) / 1e6).join(" ")})`, name: e.name };
+  return { ...scene2, transform: `${scene2.transform} matrix(${m.map((v) => Math.round(v * 1e6) / 1e6).join(" ")})`, name: e.name };
 }
 
 // src/vector/effect-tools.ts
@@ -18705,6 +19149,7 @@ export {
   VECTOR_VERTICAL_RESIZING_LABELS,
   WARP_STYLES as VECTOR_WARP_STYLES,
   WARP_STYLE_LABELS as VECTOR_WARP_STYLE_LABELS,
+  VECTOR_WET_STEPS,
   VECTOR_WIDTH_PRESETS,
   VECTOR_WIDTH_PRESET_IDS,
   VECTOR_WIDTH_PROFILE_MAX_POINTS,
@@ -18717,6 +19162,7 @@ export {
   VectorRTree,
   VectorSnapTargets,
   VectorTextError,
+  WetBrushstrokeJob,
   activeVectorEffects,
   activeVectorFilters,
   addBuilderHit,
@@ -18877,6 +19323,7 @@ export {
   isValidVectorParameterName,
   isVectorBlendGroup,
   isVectorBlendMode,
+  isVectorBrushstrokeEngine,
   isVectorBrushstrokeLayer,
   isVectorConnector,
   isVectorFilterType,
@@ -18933,12 +19380,14 @@ export {
   normalizeVectorPaintStacks,
   normalizeVectorTextRuns,
   offsetPaths,
+  onVectorBrushstrokesSettled,
   orderQuad as orderVectorQuad,
   parseOpenTypeFont,
   parseSvgTransform,
   parseVectorColor,
   parseVectorLottie,
   parseVectorSvg,
+  parseVectorTransform,
   patchVectorCharacterStyle,
   patchVectorParagraphStyle,
   pathTextFrameFromBezier,
@@ -18956,6 +19405,8 @@ export {
   purgeVectorConstraints,
   quantizeVectorTraceColors,
   randomVectorBrushstrokeSeed,
+  rasterizeVectorBackdrop,
+  readVectorBrushstrokePaint,
   recognizeInkShape,
   rectSubpath,
   refineMorphContour,
@@ -18971,6 +19422,8 @@ export {
   removeWarpMeshSplitU as removeVectorMeshSplitU,
   removeWarpMeshSplitV as removeVectorMeshSplitV,
   removeWidthPoints,
+  renderBackdropBrushstroke,
+  renderWetBrushstroke,
   repeatPaths,
   replaceVectorText,
   rerouteVectorConnectors,
@@ -19018,9 +19471,11 @@ export {
   scaleVectorStrokeWidths,
   setAnchorCorner,
   setSubpathCorners,
+  setVectorBackdropSource,
   setVectorGradientVector,
   setVectorTextShaper,
   setWidthPoint,
+  settleVectorBrushstrokes,
   shadeVectorColor,
   simplifyPolyline,
   smoothSubpath,
@@ -19069,6 +19524,7 @@ export {
   turnMorphContour,
   twistPaths,
   unionBounds,
+  usesVectorBackdrop,
   validateVectorConstraint,
   variableStrokeOutline,
   variableStrokeRings,
@@ -19078,6 +19534,7 @@ export {
   vectorAppearanceShapes,
   vectorArtModels,
   vectorArtboards,
+  vectorBackdropRect,
   vectorBevelFaces,
   vectorBlendColorDistance,
   vectorBlendKeyTargets,
@@ -19098,7 +19555,9 @@ export {
   vectorBrushstrokeCharacterError,
   vectorBrushstrokeDefaultColour,
   vectorBrushstrokeImages,
+  vectorBrushstrokePaintError,
   vectorBrushstrokeReach,
+  vectorBrushstrokesSettling,
   vectorBuilderErasedEdges,
   vectorChildAppearanceShapes,
   vectorConnectionSites,
@@ -19191,6 +19650,7 @@ export {
   vectorMaskedShapes,
   vectorMasterArt,
   vectorMasterPages,
+  vectorMediaEngine,
   vectorMeshColorAt,
   warpMeshColumns as vectorMeshColumns,
   warpMeshControlBounds as vectorMeshControlBounds,