@pixerate/editor 0.135.0 → 0.137.0

package/dist/vector/index.js

@@ -1,3 +1,7 @@
+import {
+  planGenerationRequest,
+  stableStringify
+} from "../chunk-I52DRGGJ.js";
 import {
   PlanarMap,
   cutOutPiece,
@@ -16,15 +20,6 @@ import {
   orderQuad,
   solve8
 } from "../chunk-GX332W2C.js";
-import {
-  bytesToBase64,
-  decodePng,
-  isPng,
-  parseDataUrl
-} from "../chunk-7QN76ESJ.js";
-import {
-  deflate
-} from "../chunk-6FCKOS2B.js";
 import {
   correspondMorphContours,
   createVectorMorph,
@@ -43,7 +38,7 @@ import {
   reverseMorphContour,
   subpathToMorphContour,
   turnMorphContour
-} from "../chunk-7RJ6P7MI.js";
+} from "../chunk-6S6362D2.js";
 import {
   DEFAULT_VECTOR_FONT,
   IDENTITY_MATRIX,
@@ -52,6 +47,7 @@ import {
   VECTOR_BLEND_MODES,
   VECTOR_BLEND_MODE_LABELS,
   VECTOR_BLEND_SPACINGS,
+  VECTOR_BRUSHSTROKE_SCALE,
   VECTOR_CHARACTER_STYLE_KEYS,
   VECTOR_CONNECTOR_ROUTES,
   VECTOR_CONNECTOR_ROUTE_LABELS,
@@ -198,6 +194,7 @@ import {
   isUniformWidthProfile,
   isValidWarpMesh,
   isVectorBlendMode,
+  isVectorBrushstrokeLayer,
   isVectorConnector,
   isVectorFilterType,
   isVectorFrame,
@@ -288,6 +285,7 @@ import {
   sampleVectorGradient,
   sampleVectorGradientAt,
   sampleVectorPaintDefAt,
+  sanitizeVectorBrushstroke,
   sanitizeVectorConnector,
   sanitizeVectorEffects,
   sanitizeVectorFills,
@@ -356,6 +354,10 @@ import {
   vectorBlendModeFromCss,
   vectorBoundsInside,
   vectorBoxMatrix,
+  vectorBrushstrokeBrush,
+  vectorBrushstrokeBrushes,
+  vectorBrushstrokeImages,
+  vectorBrushstrokeReach,
   vectorChildAppearanceShapes,
   vectorConnectionSites,
   vectorConnectorTargetAt,
@@ -501,7 +503,11 @@ import {
   withVectorStrokes,
   withVectorTargetPaint,
   zigzagPaths
-} from "../chunk-HHTCDFZC.js";
+} from "../chunk-3D77LOBM.js";
+import "../chunk-HUO3TI4C.js";
+import {
+  createProvenance
+} from "../chunk-A3BVTI3G.js";
 import {
   bezierPathBounds,
   bezierPathToSvg,
@@ -509,6 +515,7 @@ import {
   contourSignedArea,
   contoursToPath,
   distanceToBezierPath,
+  flattenChain,
   pathBoolean,
   pathToContours,
   pointInBezierPath,
@@ -532,6 +539,19 @@ import {
   resolveEffectValues
 } from "../chunk-QFSTQHZY.js";
 import "../chunk-4FX5ACVG.js";
+import "../chunk-5FSRTP6E.js";
+import "../chunk-63AZAUSN.js";
+import {
+  bytesToBase64,
+  decodePng,
+  isPng,
+  parseDataUrl
+} from "../chunk-3G6J7UFV.js";
+import {
+  deflate
+} from "../chunk-6FCKOS2B.js";
+import "../chunk-FPENXAEJ.js";
+import "../chunk-P6ODPZ4W.js";
 import {
   HistoryManager
 } from "../chunk-QVZZGT4X.js";
@@ -541,225 +561,831 @@ import {
   hexToRgba
 } from "../chunk-TGD52FEZ.js";
 
-// src/vector/gradientTool.ts
-var VECTOR_GRADIENT_STOP_GAP = 12;
-var VECTOR_GRADIENT_MIDPOINT_GAP = 9;
-var VECTOR_GRADIENT_OFF_BAR = 24;
-var STOP_HIT = 6;
-var MIDPOINT_HIT = 5;
-var HANDLE_HIT = 6;
-var BAR_HIT = 5;
-var fmt = (n2) => Math.round(n2 * 100) / 100;
-var apply = (m, p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] });
-function vectorGradientTargetPath(doc, selection, target, layer = null) {
-  for (const id of selection) {
-    const node = findVectorNode(doc.nodes, id);
-    if (!node) continue;
-    const path = collectPathNodes(node).find((p) => isVectorGradient(vectorTargetPaint(p, target, layer)));
-    if (path) return path;
+// src/vector/trace.ts
+var VECTOR_TRACE_MAX_PIXELS = 4e6;
+function signedArea(p) {
+  let a = 0;
+  for (let i = 0; i < p.length; i++) {
+    const [x0, y0] = p[i];
+    const [x1, y1] = p[(i + 1) % p.length];
+    a += x0 * y1 - x1 * y0;
   }
-  return null;
+  return a / 2;
 }
-function getVectorGradientAnnotator(doc, selection, viewport, target, layer = null) {
-  const path = vectorGradientTargetPath(doc, selection, target, layer);
-  if (!path) return null;
-  const gradient = vectorTargetPaint(path, target, layer);
-  const world = vectorWorldMatrix(doc.nodes, path.id) ?? IDENTITY_MATRIX;
-  const screen = multiplyMatrices(world, [viewport.zoom, 0, 0, viewport.zoom, viewport.x, viewport.y]);
-  const bounds = vectorPathLocalBounds(path);
-  const h = vectorGradientHandles(gradient, bounds, screen);
-  const v = { x: h.end.x - h.start.x, y: h.end.y - h.start.y };
-  const len2 = Math.hypot(v.x, v.y);
-  const normal = len2 > 1e-9 ? { x: -v.y / len2, y: v.x / len2 } : { x: 0, y: 1 };
-  const at = (t, gap) => ({ x: h.start.x + v.x * t + normal.x * gap, y: h.start.y + v.y * t + normal.y * gap });
-  const sorted = sortedVectorGradientStops(gradient);
-  const stops = sorted.map((s, index) => ({ ...s, index, ...at(s.offset, VECTOR_GRADIENT_STOP_GAP) }));
-  const midpoints = sorted.slice(0, -1).flatMap((s, index) => {
-    const pos = vectorGradientMidpointPosition(sorted, index);
-    return pos === null || sorted[index + 1].offset - s.offset < 1e-6 ? [] : [{ index, midpoint: s.midpoint ?? 0.5, ...at(pos, -VECTOR_GRADIENT_MIDPOINT_GAP) }];
-  });
-  let extent = null;
-  if (isCentredVectorGradient(gradient.type)) {
-    const frame = multiplyMatrices(vectorGradientMatrix(gradient, bounds), screen);
-    const pts = gradient.type === "diamond" ? [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 0, y: -1 }] : Array.from({ length: 48 }, (_, k) => ({ x: Math.cos(k * Math.PI / 24), y: Math.sin(k * Math.PI / 24) }));
-    extent = `M${pts.map((p) => apply(frame, p)).map((p) => `${fmt(p.x)} ${fmt(p.y)}`).join("L")}Z`;
+function pointInPoly(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const [xi, yi] = poly[i];
+    const [xj, yj] = poly[j];
+    if (yi > p[1] !== yj > p[1] && p[0] < (xj - xi) * (p[1] - yi) / (yj - yi) + xi) inside = !inside;
   }
-  return { nodeId: path.id, target, gradient, bounds, world, start: h.start, end: h.end, aspect: h.aspect, focal: h.focal, normal, stops, midpoints, extent };
-}
-function vectorGradientBarPosition(a, p) {
-  const v = { x: a.end.x - a.start.x, y: a.end.y - a.start.y };
-  const l2 = v.x * v.x + v.y * v.y;
-  const d = { x: p.x - a.start.x, y: p.y - a.start.y };
-  if (l2 < 1e-12) return { offset: 0, across: Math.hypot(d.x, d.y) };
-  return { offset: (d.x * v.x + d.y * v.y) / l2, across: d.x * a.normal.x + d.y * a.normal.y };
-}
-function hitVectorGradientAnnotator(a, p) {
-  const near = (q, r) => !!q && Math.hypot(q.x - p.x, q.y - p.y) <= r;
-  for (let i = a.stops.length - 1; i >= 0; i--) if (near(a.stops[i], STOP_HIT)) return { kind: "stop", index: a.stops[i].index };
-  for (const m of a.midpoints) if (near(m, MIDPOINT_HIT)) return { kind: "midpoint", index: m.index };
-  const centred = isCentredVectorGradient(a.gradient.type);
-  if (near(a.end, HANDLE_HIT)) return { kind: "handle", handle: centred ? "radius" : "end" };
-  if (a.focal && near(a.focal, HANDLE_HIT) && !near(a.start, 1)) return { kind: "handle", handle: "focal" };
-  if (near(a.start, HANDLE_HIT)) return { kind: "handle", handle: "start" };
-  if (near(a.aspect, HANDLE_HIT)) return { kind: "handle", handle: "aspect" };
-  const { offset, across } = vectorGradientBarPosition(a, p);
-  if (offset >= 0 && offset <= 1 && across >= -BAR_HIT && across <= VECTOR_GRADIENT_STOP_GAP + STOP_HIT) return { kind: "bar", offset };
-  return null;
-}
-
-// src/vector/blendGroup.ts
-var DEFAULT_VECTOR_BLEND_STEPS = 5;
-var DEFAULT_VECTOR_BLEND_DISTANCE = 20;
-var VECTOR_BLEND_MAX_STEPS = 1e3;
-var VECTOR_BLEND_MAX_SMOOTH_STEPS = 256;
-function isVectorBlendGroup(node) {
-  return !!node && node.type === "group" && !!node.blend;
-}
-function vectorBlendKeys(group) {
-  return group.children.filter((c) => !c.blendStep);
+  return inside;
 }
-function resolveVectorBlendOptions(options) {
-  return {
-    spacing: options?.spacing ?? "steps",
-    steps: options?.steps ?? DEFAULT_VECTOR_BLEND_STEPS,
-    distance: options?.distance ?? DEFAULT_VECTOR_BLEND_DISTANCE,
-    orientToSpine: options?.orientToSpine ?? false,
-    linear: options?.linear ?? false
+function vectorTraceContours(field, w, h, threshold) {
+  const gw = w + 2;
+  const gh = h + 2;
+  const val = (i, j) => i === 0 || j === 0 || i > w || j > h ? -Infinity : field[(j - 1) * w + (i - 1)];
+  const inside = (i, j) => val(i, j) >= threshold;
+  const pos = (i, j) => [i - 0.5, j - 0.5];
+  const cross2 = (a, b) => {
+    const va = val(a[0], a[1]);
+    const vb = val(b[0], b[1]);
+    let t;
+    if (Number.isFinite(va) && Number.isFinite(vb) && Math.abs(vb - va) > 1e-12) t = Math.min(1, Math.max(0, (threshold - va) / (vb - va)));
+    else if (Number.isFinite(va)) t = va >= threshold ? 0.5 : 0;
+    else t = vb >= threshold ? 0.5 : 1;
+    const pa = pos(a[0], a[1]);
+    const pb = pos(b[0], b[1]);
+    return [pa[0] + (pb[0] - pa[0]) * t, pa[1] + (pb[1] - pa[1]) * t];
   };
-}
-function paintColors(p) {
-  if (typeof p === "string") return [p];
-  if (p && typeof p === "object") {
-    if (p.type === "mesh") return p.colors;
-    if (p.type === "freeform") return p.points.map((q) => q.color);
-    return p.stops.map((s) => s.color);
+  const hid = (i, j) => 2 * (j * gw + i);
+  const vid = (i, j) => 2 * (j * gw + i) + 1;
+  const next = /* @__PURE__ */ new Map();
+  const point = /* @__PURE__ */ new Map();
+  for (let j = 0; j < gh - 1; j++) {
+    for (let i = 0; i < gw - 1; i++) {
+      const tl = inside(i, j);
+      const tr = inside(i + 1, j);
+      const br = inside(i + 1, j + 1);
+      const bl = inside(i, j + 1);
+      const code = +tl << 3 | +tr << 2 | +br << 1 | +bl;
+      if (code === 0 || code === 15) continue;
+      const top = hid(i, j);
+      const bottom = hid(i, j + 1);
+      const left = vid(i, j);
+      const right = vid(i + 1, j);
+      const seg = (a, b) => next.set(a, b);
+      const mean = () => (val(i, j) + val(i + 1, j) + val(i + 1, j + 1) + val(i, j + 1)) / 4;
+      switch (code) {
+        case 1:
+          seg(left, bottom);
+          break;
+        case 2:
+          seg(bottom, right);
+          break;
+        case 3:
+          seg(left, right);
+          break;
+        case 4:
+          seg(right, top);
+          break;
+        case 5:
+          if (mean() >= threshold) {
+            seg(left, top);
+            seg(right, bottom);
+          } else {
+            seg(left, bottom);
+            seg(right, top);
+          }
+          break;
+        case 6:
+          seg(bottom, top);
+          break;
+        case 7:
+          seg(left, top);
+          break;
+        case 8:
+          seg(top, left);
+          break;
+        case 9:
+          seg(top, bottom);
+          break;
+        case 10:
+          if (mean() >= threshold) {
+            seg(top, right);
+            seg(bottom, left);
+          } else {
+            seg(top, left);
+            seg(bottom, right);
+          }
+          break;
+        case 11:
+          seg(top, right);
+          break;
+        case 12:
+          seg(right, left);
+          break;
+        case 13:
+          seg(right, bottom);
+          break;
+        case 14:
+          seg(bottom, left);
+          break;
+      }
+      const edges = [
+        [top, [i, j], [i + 1, j]],
+        [bottom, [i, j + 1], [i + 1, j + 1]],
+        [left, [i, j], [i, j + 1]],
+        [right, [i + 1, j], [i + 1, j + 1]]
+      ];
+      for (const [e, a, b] of edges) if (inside(a[0], a[1]) !== inside(b[0], b[1]) && !point.has(e)) point.set(e, cross2(a, b));
+    }
   }
-  return [];
-}
-function vectorBlendColorDistance(a, b) {
-  const pa = collectPathNodes(a)[0];
-  const pb = collectPathNodes(b)[0];
-  if (!pa || !pb) return 0;
-  let d = 0;
-  for (const key of ["fill", "stroke"]) {
-    const ca = paintColors(pa[key]);
-    const cb = paintColors(pb[key]);
-    ca.forEach((c, i) => {
-      const other = cb[i] ?? cb[0];
-      if (other === void 0) return;
-      const x = hexToRgba(c);
-      const y = hexToRgba(other);
-      if (!x || !y) return;
-      d = Math.max(d, Math.abs(x.r - y.r), Math.abs(x.g - y.g), Math.abs(x.b - y.b), Math.abs(x.a - y.a));
-    });
+  const out = [];
+  for (const start of [...next.keys()].sort((a, b) => a - b)) {
+    if (!next.has(start)) continue;
+    const poly = [];
+    let e = start;
+    for (; ; ) {
+      const n2 = next.get(e);
+      if (n2 === void 0) break;
+      next.delete(e);
+      const p = point.get(e);
+      if (p) poly.push(p);
+      e = n2;
+      if (e === start) break;
+    }
+    if (poly.length >= 3) out.push(poly);
   }
-  return d;
+  return out;
 }
-var centreOf = (n2) => {
-  const b = vectorNodeBounds(n2);
-  return b ? [b.x + b.width / 2, b.y + b.height / 2] : [0, 0];
-};
-function vectorBlendStepCount(a, b, options, length) {
-  const o = resolveVectorBlendOptions(options);
-  if (o.spacing === "distance") {
-    const d = Math.max(0.01, o.distance);
-    return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(0, Math.round(length / d) - 1));
-  }
-  if (o.spacing === "smoothColor") {
-    const cd = vectorBlendColorDistance(a, b);
-    if (cd > 1 / 255) return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(cd * 255 / 2)));
-    const ba = vectorNodeBounds(a);
-    const bb = vectorNodeBounds(b);
-    const dist4 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length;
-    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist4 / 2)));
+function loopsOf(field, w, h, threshold, tolerance, minArea) {
+  const loops = [];
+  for (const raw of vectorTraceContours(field, w, h, threshold)) {
+    const area = signedArea(raw);
+    if (Math.abs(area) < Math.max(0, minArea)) continue;
+    const simple = simplifyRing(raw, Math.max(0.01, tolerance));
+    if (simple.length < 3) continue;
+    loops.push({ raw, simple, area, depth: 0 });
   }
-  return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(1, Math.round(Number.isFinite(o.steps) ? o.steps : DEFAULT_VECTOR_BLEND_STEPS)));
+  for (const l of loops) l.depth = loops.filter((o) => o !== l && Math.abs(o.area) > Math.abs(l.area) && pointInPoly(l.simple[0], o.simple)).length;
+  return loops.sort((a, b) => a.depth - b.depth || Math.abs(b.area) - Math.abs(a.area));
 }
-function vectorBlendRail(sp) {
-  const pts = [];
-  const angles = [];
-  const push = (p, tangent) => {
-    const last = pts[pts.length - 1];
-    if (last && Math.hypot(p[0] - last[0], p[1] - last[1]) < 1e-9) return;
-    pts.push(p);
-    angles.push(Math.atan2(tangent[1], tangent[0]));
+function loopSubpath(l, tolerance, roundness) {
+  if (roundness <= 0) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
+  const cornerAngleDeg = 25 + roundness * 125;
+  const cubics = fitCubics(l.raw, Math.max(0.05, tolerance), {
+    closed: true,
+    cornerAngleDeg
+  });
+  if (!cubics.length) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
+  const anchors = cubics.map((c, k) => {
+    const prev = cubics[(k - 1 + cubics.length) % cubics.length];
+    return {
+      x: c.p0[0],
+      y: c.p0[1],
+      in: { x: prev.p2[0], y: prev.p2[1] },
+      out: { x: c.p1[0], y: c.p1[1] }
+    };
+  });
+  return { closed: true, anchors };
+}
+function traceField(field, w, h, threshold, o) {
+  const tolerance = o.tolerance ?? 1;
+  const roundness = Math.min(1, Math.max(0, o.cornerRoundness ?? 0.5));
+  return loopsOf(field, w, h, threshold, tolerance, o.minArea ?? 10).map((l) => loopSubpath(l, tolerance, roundness));
+}
+function quantizeVectorTraceColors(pixels, count) {
+  const n2 = pixels.width * pixels.height;
+  const d = pixels.data;
+  const opaque = [];
+  for (let i = 0; i < n2; i++) if (d[i * 4 + 3] >= 128) opaque.push(i);
+  const boxes = opaque.length ? [opaque] : [];
+  const range = (box, c) => {
+    let lo = 255;
+    let hi = 0;
+    for (const i of box) {
+      const v = d[i * 4 + c];
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    }
+    return hi - lo;
   };
-  const count = subpathSegmentCount(sp);
-  for (let i = 0; i < count; i++) {
-    const seg = subpathSegment(sp, i);
-    const samples = seg.length === 2 ? 1 : 32;
-    if (i === 0) push(seg[0], segmentTangent(seg, 0));
-    for (let k = 1; k <= samples; k++) push(segmentPoint(seg, k / samples), segmentTangent(seg, k / samples));
+  while (boxes.length < count) {
+    let best = -1;
+    let bestRange = 0;
+    let bestC = 0;
+    boxes.forEach((b, k) => {
+      if (b.length < 2) return;
+      for (let c = 0; c < 3; c++) {
+        const r = range(b, c);
+        if (r > bestRange) {
+          bestRange = r;
+          best = k;
+          bestC = c;
+        }
+      }
+    });
+    if (best < 0) break;
+    const box = boxes[best].slice().sort((a, b) => d[a * 4 + bestC] - d[b * 4 + bestC]);
+    const key = (k) => d[box[k] * 4 + bestC];
+    const v = key(box.length >> 1);
+    let mid = box.findIndex((_, k) => key(k) >= v);
+    if (mid <= 0) mid = box.findIndex((_, k) => key(k) > v);
+    boxes.splice(best, 1, box.slice(0, mid), box.slice(mid));
   }
-  if (pts.length < 2) return null;
-  const cum = [0];
-  for (let i = 1; i < pts.length; i++) cum.push(cum[i - 1] + Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]));
-  return { pts, cum, angles, total: cum[cum.length - 1], closed: sp.closed };
+  const palette = boxes.map((b) => {
+    const s = [0, 0, 0];
+    for (const i of b) for (let c = 0; c < 3; c++) s[c] += d[i * 4 + c];
+    return [Math.round(s[0] / b.length), Math.round(s[1] / b.length), Math.round(s[2] / b.length)];
+  });
+  const index = new Int16Array(n2).fill(-1);
+  const counts = palette.map(() => 0);
+  for (const i of opaque) {
+    let best = 0;
+    let bestD = Infinity;
+    palette.forEach((p, k) => {
+      const dd = (d[i * 4] - p[0]) ** 2 + (d[i * 4 + 1] - p[1]) ** 2 + (d[i * 4 + 2] - p[2]) ** 2;
+      if (dd < bestD) {
+        bestD = dd;
+        best = k;
+      }
+    });
+    index[i] = best;
+    counts[best]++;
+  }
+  return { palette, index, counts };
 }
-function vectorBlendRailAt(rail, s) {
-  let len2 = Number.isFinite(s) ? s : 0;
-  if (rail.closed && rail.total > 0) len2 = (len2 % rail.total + rail.total) % rail.total;
-  len2 = Math.min(rail.total, Math.max(0, len2));
-  let lo = 0;
-  let hi = rail.cum.length - 1;
-  while (hi - lo > 1) {
-    const mid = lo + hi >> 1;
-    if (rail.cum[mid] <= len2) lo = mid;
-    else hi = mid;
+var hex = (c) => `#${c.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
+function traceVectorImage(pixels, options = {}) {
+  const { width: w, height: h, data } = pixels;
+  if (!(w > 0 && h > 0) || data.length < w * h * 4) throw new Error("The image has no pixels (or fewer than width \xD7 height \xD7 4 values).");
+  if (w * h > VECTOR_TRACE_MAX_PIXELS) throw new Error(`The image has ${w * h} pixels; scale it down to at most ${VECTOR_TRACE_MAX_PIXELS} to trace it.`);
+  const n2 = w * h;
+  if ((options.mode ?? "threshold") === "threshold") {
+    const field = new Float32Array(n2);
+    const byAlpha = options.channel === "alpha";
+    for (let i = 0; i < n2; i++) {
+      const a = data[i * 4 + 3] / 255;
+      field[i] = byAlpha ? a : a * (1 - (0.2126 * data[i * 4] + 0.7152 * data[i * 4 + 1] + 0.0722 * data[i * 4 + 2]) / 255);
+    }
+    const subpaths = traceField(field, w, h, Math.min(1, Math.max(0, options.threshold ?? 0.5)), options);
+    return subpaths.length ? [
+      {
+        id: "trace-1",
+        type: "path",
+        name: "Trace",
+        fill: options.color ?? "#000000",
+        stroke: null,
+        fillRule: "evenodd",
+        subpaths
+      }
+    ] : [];
   }
-  const span = rail.cum[hi] - rail.cum[lo];
-  const u = span > 1e-12 ? (len2 - rail.cum[lo]) / span : 0;
-  const a = rail.pts[lo];
-  const b = rail.pts[hi];
-  return { point: [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u], angle: Math.atan2(b[1] - a[1], b[0] - a[0]) };
+  const count = Math.min(32, Math.max(2, Math.round(options.colors ?? 6)));
+  const q = quantizeVectorTraceColors(pixels, count);
+  const order = q.palette.map((_, k) => k).filter((k) => q.counts[k] > 0).sort((a, b) => q.counts[b] - q.counts[a]);
+  const rank = new Map(order.map((k, r) => [k, r]));
+  const out = [];
+  order.forEach((k, r) => {
+    const field = new Uint8Array(n2);
+    for (let i = 0; i < n2; i++) {
+      const ix = q.index[i];
+      field[i] = ix >= 0 && rank.get(ix) >= r ? 1 : 0;
+    }
+    const subpaths = traceField(field, w, h, 0.5, options);
+    if (subpaths.length)
+      out.push({
+        id: `trace-${out.length + 1}`,
+        type: "path",
+        name: hex(q.palette[k]),
+        fill: hex(q.palette[k]),
+        stroke: null,
+        fillRule: "evenodd",
+        subpaths
+      });
+  });
+  return out;
 }
-function vectorBlendSpine(group) {
-  const keys = vectorBlendKeys(group);
-  if (keys.length < 2) return null;
-  const stored = group.blend?.spine;
-  if (stored && stored.anchors.length >= 2) {
-    const rail2 = vectorBlendRail(stored);
-    if (rail2) {
-      const end = rail2.closed ? rail2.total * (1 - 1 / keys.length) : rail2.total;
-      return { spine: stored, rail: rail2, stops: keys.map((_, i) => end * i / (keys.length - 1)), replaced: true };
+
+// src/vector/stylize.ts
+var VECTOR_STYLIZE_STYLES = ["mosaic", "halftone", "lowPoly", "hatch"];
+var VECTOR_STYLIZE_LABELS = { mosaic: "Mosaic", halftone: "Halftone", lowPoly: "Low Poly", hatch: "Engraving" };
+var VECTOR_STYLIZE_MAX_SHAPES = 6e4;
+function sampleBox(px, cx, cy, size) {
+  const { width: w, height: h, data: d } = px;
+  const n2 = Math.max(1, Math.min(5, Math.round(size)));
+  const s = [0, 0, 0, 0];
+  let count = 0;
+  for (let j = 0; j < n2; j++) {
+    for (let i = 0; i < n2; i++) {
+      const x = Math.floor(cx - size / 2 + (i + 0.5) * size / n2);
+      const y = Math.floor(cy - size / 2 + (j + 0.5) * size / n2);
+      if (x < 0 || y < 0 || x >= w || y >= h) continue;
+      const k = (y * w + x) * 4;
+      const a = d[k + 3];
+      s[0] += d[k] * a;
+      s[1] += d[k + 1] * a;
+      s[2] += d[k + 2] * a;
+      s[3] += a;
+      count++;
+    }
+  }
+  if (!count || s[3] <= 0) return [0, 0, 0, 0];
+  return [s[0] / s[3], s[1] / s[3], s[2] / s[3], s[3] / count];
+}
+var darkness = (c) => (1 - (0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]) / 255) * (c[3] / 255);
+var hex2 = (c) => `#${c.slice(0, 3).map((v) => Math.round(Math.min(255, Math.max(0, v))).toString(16).padStart(2, "0")).join("")}`;
+function paletteOf(colors, count) {
+  const data = new Uint8ClampedArray(colors.length * 4);
+  colors.forEach((c, i) => {
+    data[i * 4] = c[0];
+    data[i * 4 + 1] = c[1];
+    data[i * 4 + 2] = c[2];
+    data[i * 4 + 3] = c[3];
+  });
+  const q = quantizeVectorTraceColors({ width: colors.length, height: 1, data }, Math.min(32, Math.max(2, Math.round(count))));
+  return { palette: q.palette.map(hex2), index: q.index };
+}
+function byColour(shapes, palette, index, name, extra = {}) {
+  const groups = palette.map(() => []);
+  shapes.forEach((s, i) => {
+    if (index[i] >= 0) groups[index[i]].push(...s);
+  });
+  return groups.map((subpaths, k) => ({ subpaths, k })).filter((g) => g.subpaths.length).sort((a, b) => b.subpaths.length - a.subpaths.length).map((g, n2) => ({ id: `stylize-${n2}`, type: "path", name: `${name} ${palette[g.k]}`, fill: palette[g.k], stroke: null, subpaths: g.subpaths, ...extra }));
+}
+function check(px, cell) {
+  const { width: w, height: h, data } = px;
+  if (!(w > 0 && h > 0) || data.length < w * h * 4) throw new Error("The image has no pixels (or fewer than width \xD7 height \xD7 4 values).");
+  if (w * h > VECTOR_TRACE_MAX_PIXELS) throw new Error(`The image has ${w * h} pixels; scale it down to at most ${VECTOR_TRACE_MAX_PIXELS}.`);
+  if (!(cell >= 1)) throw new Error("cell must be at least 1 pixel.");
+}
+function tooMany(count) {
+  if (count > VECTOR_STYLIZE_MAX_SHAPES) throw new Error(`That would draw about ${count} shapes (at most ${VECTOR_STYLIZE_MAX_SHAPES}): use a larger cell.`);
+}
+function turnedGrid(w, h, cell, angle) {
+  const a = angle * Math.PI / 180;
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  const cx = w / 2;
+  const cy = h / 2;
+  const reach = Math.ceil(Math.hypot(w, h) / 2 / cell) + 1;
+  tooMany((2 * reach + 1) ** 2 * 0.7);
+  const out = [];
+  for (let j = -reach; j <= reach; j++) {
+    for (let i = -reach; i <= reach; i++) {
+      const x = cx + (i * c - j * s) * cell;
+      const y = cy + (i * s + j * c) * cell;
+      if (x < -cell || y < -cell || x > w + cell || y > h + cell) continue;
+      out.push({ x, y, row: j, col: i });
     }
   }
-  const centres = keys.map(centreOf);
-  const spine = { closed: false, anchors: centres.map((c) => ({ x: c[0], y: c[1] })) };
-  const stops = [0];
-  for (let i = 1; i < centres.length; i++) stops.push(stops[i - 1] + Math.hypot(centres[i][0] - centres[i - 1][0], centres[i][1] - centres[i - 1][1]));
-  const rail = vectorBlendRail(spine) ?? { pts: centres, cum: stops, angles: centres.map(() => 0), total: stops[stops.length - 1], closed: false };
-  return { spine, rail, stops, replaced: false };
+  return out;
 }
-function vectorBlendKeyTargets(group) {
-  const s = vectorBlendSpine(group);
-  return s ? s.stops.map((stop) => vectorBlendRailAt(s.rail, stop).point) : [];
+function vectorMosaic(px, o = {}) {
+  const cell = o.cell ?? 12;
+  check(px, cell);
+  const cols = Math.ceil(px.width / cell);
+  const rows = Math.ceil(px.height / cell);
+  tooMany(cols * rows);
+  const gap = Math.min(0.9, Math.max(0, o.gap ?? 0.1)) * cell;
+  const colors = [];
+  const shapes = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const color = sampleBox(px, (c + 0.5) * cell, (r + 0.5) * cell, cell);
+      if (color[3] < 128) continue;
+      const box = { x: c * cell + gap / 2, y: r * cell + gap / 2, width: cell - gap, height: cell - gap };
+      colors.push(color);
+      shapes.push([o.shape === "circle" ? ellipseSubpath(box) : rectSubpath(box)]);
+    }
+  }
+  if (!shapes.length) return [];
+  const { palette, index } = paletteOf(colors, o.colors ?? 12);
+  return byColour(shapes, palette, index, "Mosaic");
+}
+function vectorHalftone(px, o = {}) {
+  const cell = o.cell ?? 8;
+  check(px, cell);
+  const colors = [];
+  const shapes = [];
+  for (const p of turnedGrid(px.width, px.height, cell, o.angle ?? 45)) {
+    if (p.x < 0 || p.y < 0 || p.x >= px.width || p.y >= px.height) continue;
+    const color = sampleBox(px, p.x, p.y, cell);
+    const r = cell / Math.SQRT2 * Math.sqrt(darkness(color));
+    if (r < cell * 0.04) continue;
+    colors.push(color);
+    shapes.push([ellipseSubpath({ x: p.x - r, y: p.y - r, width: 2 * r, height: 2 * r })]);
+  }
+  if (!shapes.length) return [];
+  if (o.color === null) {
+    const { palette, index } = paletteOf(colors, o.colors ?? 12);
+    return byColour(shapes, palette, index, "Halftone");
+  }
+  return [{ id: "stylize-0", type: "path", name: "Halftone", fill: o.color ?? "#000000", stroke: null, subpaths: shapes.flat() }];
+}
+function hash01(a, b, seed) {
+  let h = Math.imul(a ^ 2654435769, 2246822507) ^ Math.imul(b ^ 3266489909, 668265263) ^ Math.imul(seed, 374761393);
+  h ^= h >>> 15;
+  h = Math.imul(h, 739982445);
+  h ^= h >>> 12;
+  return (h >>> 0) / 4294967295;
+}
+function vectorLowPoly(px, o = {}) {
+  const cell = o.cell ?? 24;
+  check(px, cell);
+  const cols = Math.max(1, Math.round(px.width / cell));
+  const rows = Math.max(1, Math.round(px.height / cell));
+  tooMany(cols * rows * 2);
+  const sx = px.width / cols;
+  const sy = px.height / rows;
+  const jitter = Math.min(0.5, Math.max(0, o.jitter ?? 0.35));
+  const seed = Math.round(o.seed ?? 1);
+  const pt2 = (c, r) => {
+    const jx = c === 0 || c === cols ? 0 : (hash01(c, r, seed) * 2 - 1) * jitter * sx;
+    const jy = r === 0 || r === rows ? 0 : (hash01(c, r, seed + 7919) * 2 - 1) * jitter * sy;
+    return [c * sx + jx, r * sy + jy];
+  };
+  const colors = [];
+  const shapes = [];
+  const tri = (a, b, c) => {
+    const cx = (a[0] + b[0] + c[0]) / 3;
+    const cy = (a[1] + b[1] + c[1]) / 3;
+    const color = sampleBox(px, cx, cy, Math.min(sx, sy) * 0.6);
+    if (color[3] < 128) return;
+    colors.push(color);
+    shapes.push([{ closed: true, anchors: [a, b, c].map(([x, y]) => ({ x, y })) }]);
+  };
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const p00 = pt2(c, r);
+      const p10 = pt2(c + 1, r);
+      const p01 = pt2(c, r + 1);
+      const p11 = pt2(c + 1, r + 1);
+      if ((r + c) % 2) {
+        tri(p00, p10, p11);
+        tri(p00, p11, p01);
+      } else {
+        tri(p00, p10, p01);
+        tri(p10, p11, p01);
+      }
+    }
+  }
+  if (!shapes.length) return [];
+  const { palette, index } = paletteOf(colors, o.colors ?? 16);
+  return byColour(shapes, palette, index, "Low Poly").map((n2) => ({ ...n2, stroke: n2.fill, strokeWidth: 0.5, strokeLinejoin: "round" }));
+}
+function vectorHatch(px, o = {}) {
+  const cell = o.cell ?? 6;
+  check(px, cell);
+  const a = (o.angle ?? 45) * Math.PI / 180;
+  const dir = { x: Math.cos(a), y: Math.sin(a) };
+  const nrm = { x: -dir.y, y: dir.x };
+  const pts = turnedGrid(px.width, px.height, cell, o.angle ?? 45);
+  const rows = /* @__PURE__ */ new Map();
+  for (const p of pts) {
+    const list = rows.get(p.row);
+    if (list) list.push(p);
+    else rows.set(p.row, [p]);
+  }
+  const subpaths = [];
+  const min = cell * 0.04;
+  for (const list of rows.values()) {
+    list.sort((p, q) => p.col - q.col);
+    let run = [];
+    const flush = () => {
+      if (run.length >= 2) {
+        const top = run.map((p) => ({ x: p.x + nrm.x * p.t, y: p.y + nrm.y * p.t }));
+        const bottom = run.map((p) => ({ x: p.x - nrm.x * p.t, y: p.y - nrm.y * p.t })).reverse();
+        subpaths.push({ closed: true, anchors: [...top, ...bottom] });
+      }
+      run = [];
+    };
+    for (const p of list) {
+      const inside = p.x >= 0 && p.y >= 0 && p.x < px.width && p.y < px.height;
+      const t = inside ? cell * 0.45 * darkness(sampleBox(px, p.x, p.y, cell)) : 0;
+      if (t < min) {
+        if (run.length) run.push({ x: p.x, y: p.y, t: 0 });
+        flush();
+        continue;
+      }
+      if (!run.length) run.push({ x: p.x - dir.x * cell, y: p.y - dir.y * cell, t: 0 });
+      run.push({ x: p.x, y: p.y, t });
+    }
+    flush();
+  }
+  if (!subpaths.length) return [];
+  tooMany(subpaths.length);
+  return [{ id: "stylize-0", type: "path", name: "Hatch", fill: o.color ?? "#000000", stroke: null, subpaths }];
 }
-var morphCache = /* @__PURE__ */ new WeakMap();
-function morphFor(a, b, blend) {
-  const starts = [blend.starts?.[a.id] ?? null, blend.starts?.[b.id] ?? null];
-  const key = JSON.stringify([!!blend.linear, starts]);
-  let inner = morphCache.get(a);
-  if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
-  let byKey = inner.get(b);
-  if (!byKey) inner.set(b, byKey = /* @__PURE__ */ new Map());
-  let morph = byKey.get(key);
-  if (!morph) byKey.set(key, morph = createVectorMorph(a, b, { linear: blend.linear, starts }));
-  return morph;
+function stylizeVectorImage(px, style, options = {}) {
+  switch (style) {
+    case "mosaic":
+      return vectorMosaic(px, options);
+    case "halftone":
+      return vectorHalftone(px, options);
+    case "lowPoly":
+      return vectorLowPoly(px, options);
+    case "hatch":
+      return vectorHatch(px, options);
+  }
 }
-var wrapAngle = (a) => Math.atan2(Math.sin(a), Math.cos(a));
-function asStep(node, id) {
-  const rename = (n2, nid) => n2.type === "group" ? { ...n2, id: nid, children: n2.children.map((c, i) => rename(c, `${nid}.${i}`)) } : { ...n2, id: nid };
-  return { ...rename(node, id), blendStep: true, locked: true };
+
+// src/vector/distortBrush.ts
+var VECTOR_DISTORT_BRUSH_MODES = ["smudge", "twirl", "attract", "repel", "roughen"];
+function vectorDistortFalloff(d, r) {
+  if (!(r > 0) || d >= r) return 0;
+  const u = d / r;
+  const k = 1 - u * u;
+  return k * k;
+}
+function vectorDistortDabMap(mode, dab) {
+  const s = Math.min(1, Math.max(0, dab.strength));
+  return (p) => {
+    const dx = p.x - dab.x;
+    const dy = p.y - dab.y;
+    const f = vectorDistortFalloff(Math.hypot(dx, dy), dab.radius) * s;
+    if (f <= 0) return p;
+    switch (mode) {
+      case "smudge":
+        return { x: p.x + (dab.dx ?? 0) * f, y: p.y + (dab.dy ?? 0) * f };
+      case "twirl": {
+        const a = (dab.angle ?? 15) * Math.PI / 180 * f;
+        const c = Math.cos(a);
+        const sn = Math.sin(a);
+        return { x: dab.x + dx * c - dy * sn, y: dab.y + dx * sn + dy * c };
+      }
+      case "attract":
+        return { x: p.x - dx * f * 0.5, y: p.y - dy * f * 0.5 };
+      case "repel":
+        return { x: p.x + dx * f * 0.5, y: p.y + dy * f * 0.5 };
+    }
+  };
 }
-function generateVectorBlendChildren(group) {
-  const keys = vectorBlendKeys(group);
-  const blend = group.blend;
-  if (!blend || keys.length < 2) return keys;
-  const spine = vectorBlendSpine(group);
-  if (!spine) return keys;
-  const out = [];
-  let counter = 0;
+function noise(x, y, seed) {
+  let h = Math.imul(Math.round(x * 16) ^ 2654435769, 2246822507) ^ Math.imul(Math.round(y * 16) ^ 3266489909, 668265263) ^ Math.imul(seed | 0, 374761393);
+  h ^= h >>> 15;
+  h = Math.imul(h, 739982445);
+  h ^= h >>> 12;
+  return (h >>> 0) / 4294967295 * 2 - 1;
+}
+var reaches = (b, dab) => dab.x + dab.radius >= b.minX && dab.x - dab.radius <= b.maxX && dab.y + dab.radius >= b.minY && dab.y - dab.radius <= b.maxY;
+function roughen(path, dabs) {
+  const step = Math.max(0.5, Math.min(...dabs.map((d) => d.radius)) / 6);
+  const contours = pathToContours(path).map((c) => {
+    const b = bezierPathBounds(contoursToPath([c]));
+    if (!b || !dabs.some((d) => reaches(b, d))) return c;
+    const ring = flattenChain(closeContour(c, c.closed), Math.min(0.25, step / 8));
+    const pts = [];
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const nxt = ring[i + 1] ?? (c.closed ? ring[0] : null);
+      pts.push(a);
+      if (!nxt) continue;
+      const n2 = Math.floor(Math.hypot(nxt[0] - a[0], nxt[1] - a[1]) / step);
+      for (let k = 1; k < n2; k++) pts.push([a[0] + (nxt[0] - a[0]) * k / n2, a[1] + (nxt[1] - a[1]) * k / n2]);
+    }
+    const out = pts.map((p, i) => {
+      const prev = pts[i - 1] ?? (c.closed ? pts[pts.length - 1] : p);
+      const next = pts[i + 1] ?? (c.closed ? pts[0] : p);
+      const tx = next[0] - prev[0];
+      const ty = next[1] - prev[1];
+      const tl = Math.hypot(tx, ty) || 1;
+      let off = 0;
+      for (const dab of dabs) {
+        const f = vectorDistortFalloff(Math.hypot(p[0] - dab.x, p[1] - dab.y), dab.radius) * Math.min(1, Math.max(0, dab.strength));
+        if (f > 0) off += noise(p[0], p[1], dab.seed ?? 1) * f * dab.radius * 0.25 * (i % 2 ? 1 : -1);
+      }
+      return [p[0] - ty / tl * off, p[1] + tx / tl * off];
+    });
+    const segments = [];
+    for (let i = 0; i + 1 < out.length; i++) segments.push([out[i], out[i + 1]]);
+    if (c.closed && out.length > 1) segments.push([out[out.length - 1], out[0]]);
+    return { segments, closed: c.closed };
+  });
+  return contoursToPath(contours);
+}
+function distortVectorPath(path, mode, dabs) {
+  const b0 = bezierPathBounds(path);
+  const live = dabs.filter((d) => d.radius > 0 && d.strength > 0);
+  if (!b0 || !live.length) return path;
+  if (mode === "roughen") {
+    const reaching2 = live.filter((d) => reaches(b0, d));
+    return reaching2.length ? roughen(path, reaching2) : path;
+  }
+  let grow = 0;
+  const reaching = [];
+  for (const d of live) {
+    const b = { minX: b0.minX - grow, minY: b0.minY - grow, maxX: b0.maxX + grow, maxY: b0.maxY + grow };
+    if (reaches(b, d)) {
+      reaching.push(d);
+      grow += Math.hypot(d.dx ?? 0, d.dy ?? 0) + d.radius * 0.5;
+    }
+  }
+  if (!reaching.length) return path;
+  const maps = reaching.map((d) => vectorDistortDabMap(mode, d));
+  return mapBezierPath(path, (p) => maps.reduce((q, m) => m(q), p), 0.05);
+}
+
+// src/vector/gradientTool.ts
+var VECTOR_GRADIENT_STOP_GAP = 12;
+var VECTOR_GRADIENT_MIDPOINT_GAP = 9;
+var VECTOR_GRADIENT_OFF_BAR = 24;
+var STOP_HIT = 6;
+var MIDPOINT_HIT = 5;
+var HANDLE_HIT = 6;
+var BAR_HIT = 5;
+var fmt = (n2) => Math.round(n2 * 100) / 100;
+var apply = (m, p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] });
+function vectorGradientTargetPath(doc, selection, target, layer = null) {
+  for (const id of selection) {
+    const node = findVectorNode(doc.nodes, id);
+    if (!node) continue;
+    const path = collectPathNodes(node).find((p) => isVectorGradient(vectorTargetPaint(p, target, layer)));
+    if (path) return path;
+  }
+  return null;
+}
+function getVectorGradientAnnotator(doc, selection, viewport, target, layer = null) {
+  const path = vectorGradientTargetPath(doc, selection, target, layer);
+  if (!path) return null;
+  const gradient = vectorTargetPaint(path, target, layer);
+  const world = vectorWorldMatrix(doc.nodes, path.id) ?? IDENTITY_MATRIX;
+  const screen = multiplyMatrices(world, [viewport.zoom, 0, 0, viewport.zoom, viewport.x, viewport.y]);
+  const bounds = vectorPathLocalBounds(path);
+  const h = vectorGradientHandles(gradient, bounds, screen);
+  const v = { x: h.end.x - h.start.x, y: h.end.y - h.start.y };
+  const len2 = Math.hypot(v.x, v.y);
+  const normal = len2 > 1e-9 ? { x: -v.y / len2, y: v.x / len2 } : { x: 0, y: 1 };
+  const at = (t, gap) => ({ x: h.start.x + v.x * t + normal.x * gap, y: h.start.y + v.y * t + normal.y * gap });
+  const sorted = sortedVectorGradientStops(gradient);
+  const stops = sorted.map((s, index) => ({ ...s, index, ...at(s.offset, VECTOR_GRADIENT_STOP_GAP) }));
+  const midpoints = sorted.slice(0, -1).flatMap((s, index) => {
+    const pos = vectorGradientMidpointPosition(sorted, index);
+    return pos === null || sorted[index + 1].offset - s.offset < 1e-6 ? [] : [{ index, midpoint: s.midpoint ?? 0.5, ...at(pos, -VECTOR_GRADIENT_MIDPOINT_GAP) }];
+  });
+  let extent = null;
+  if (isCentredVectorGradient(gradient.type)) {
+    const frame = multiplyMatrices(vectorGradientMatrix(gradient, bounds), screen);
+    const pts = gradient.type === "diamond" ? [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 0, y: -1 }] : Array.from({ length: 48 }, (_, k) => ({ x: Math.cos(k * Math.PI / 24), y: Math.sin(k * Math.PI / 24) }));
+    extent = `M${pts.map((p) => apply(frame, p)).map((p) => `${fmt(p.x)} ${fmt(p.y)}`).join("L")}Z`;
+  }
+  return { nodeId: path.id, target, gradient, bounds, world, start: h.start, end: h.end, aspect: h.aspect, focal: h.focal, normal, stops, midpoints, extent };
+}
+function vectorGradientBarPosition(a, p) {
+  const v = { x: a.end.x - a.start.x, y: a.end.y - a.start.y };
+  const l2 = v.x * v.x + v.y * v.y;
+  const d = { x: p.x - a.start.x, y: p.y - a.start.y };
+  if (l2 < 1e-12) return { offset: 0, across: Math.hypot(d.x, d.y) };
+  return { offset: (d.x * v.x + d.y * v.y) / l2, across: d.x * a.normal.x + d.y * a.normal.y };
+}
+function hitVectorGradientAnnotator(a, p) {
+  const near = (q, r) => !!q && Math.hypot(q.x - p.x, q.y - p.y) <= r;
+  for (let i = a.stops.length - 1; i >= 0; i--) if (near(a.stops[i], STOP_HIT)) return { kind: "stop", index: a.stops[i].index };
+  for (const m of a.midpoints) if (near(m, MIDPOINT_HIT)) return { kind: "midpoint", index: m.index };
+  const centred = isCentredVectorGradient(a.gradient.type);
+  if (near(a.end, HANDLE_HIT)) return { kind: "handle", handle: centred ? "radius" : "end" };
+  if (a.focal && near(a.focal, HANDLE_HIT) && !near(a.start, 1)) return { kind: "handle", handle: "focal" };
+  if (near(a.start, HANDLE_HIT)) return { kind: "handle", handle: "start" };
+  if (near(a.aspect, HANDLE_HIT)) return { kind: "handle", handle: "aspect" };
+  const { offset, across } = vectorGradientBarPosition(a, p);
+  if (offset >= 0 && offset <= 1 && across >= -BAR_HIT && across <= VECTOR_GRADIENT_STOP_GAP + STOP_HIT) return { kind: "bar", offset };
+  return null;
+}
+
+// src/vector/blendGroup.ts
+var DEFAULT_VECTOR_BLEND_STEPS = 5;
+var DEFAULT_VECTOR_BLEND_DISTANCE = 20;
+var VECTOR_BLEND_MAX_STEPS = 1e3;
+var VECTOR_BLEND_MAX_SMOOTH_STEPS = 256;
+function isVectorBlendGroup(node) {
+  return !!node && node.type === "group" && !!node.blend;
+}
+function vectorBlendKeys(group) {
+  return group.children.filter((c) => !c.blendStep);
+}
+function resolveVectorBlendOptions(options) {
+  return {
+    spacing: options?.spacing ?? "steps",
+    steps: options?.steps ?? DEFAULT_VECTOR_BLEND_STEPS,
+    distance: options?.distance ?? DEFAULT_VECTOR_BLEND_DISTANCE,
+    orientToSpine: options?.orientToSpine ?? false,
+    linear: options?.linear ?? false
+  };
+}
+function paintColors(p) {
+  if (typeof p === "string") return [p];
+  if (p && typeof p === "object") {
+    if (p.type === "mesh") return p.colors;
+    if (p.type === "freeform") return p.points.map((q) => q.color);
+    return p.stops.map((s) => s.color);
+  }
+  return [];
+}
+function vectorBlendColorDistance(a, b) {
+  const pa = collectPathNodes(a)[0];
+  const pb = collectPathNodes(b)[0];
+  if (!pa || !pb) return 0;
+  let d = 0;
+  for (const key of ["fill", "stroke"]) {
+    const ca = paintColors(pa[key]);
+    const cb = paintColors(pb[key]);
+    ca.forEach((c, i) => {
+      const other = cb[i] ?? cb[0];
+      if (other === void 0) return;
+      const x = hexToRgba(c);
+      const y = hexToRgba(other);
+      if (!x || !y) return;
+      d = Math.max(d, Math.abs(x.r - y.r), Math.abs(x.g - y.g), Math.abs(x.b - y.b), Math.abs(x.a - y.a));
+    });
+  }
+  return d;
+}
+var centreOf = (n2) => {
+  const b = vectorNodeBounds(n2);
+  return b ? [b.x + b.width / 2, b.y + b.height / 2] : [0, 0];
+};
+function vectorBlendStepCount(a, b, options, length) {
+  const o = resolveVectorBlendOptions(options);
+  if (o.spacing === "distance") {
+    const d = Math.max(0.01, o.distance);
+    return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(0, Math.round(length / d) - 1));
+  }
+  if (o.spacing === "smoothColor") {
+    const cd = vectorBlendColorDistance(a, b);
+    if (cd > 1 / 255) return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(cd * 255 / 2)));
+    const ba = vectorNodeBounds(a);
+    const bb = vectorNodeBounds(b);
+    const dist4 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length;
+    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist4 / 2)));
+  }
+  return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(1, Math.round(Number.isFinite(o.steps) ? o.steps : DEFAULT_VECTOR_BLEND_STEPS)));
+}
+function vectorBlendRail(sp) {
+  const pts = [];
+  const angles = [];
+  const push = (p, tangent) => {
+    const last = pts[pts.length - 1];
+    if (last && Math.hypot(p[0] - last[0], p[1] - last[1]) < 1e-9) return;
+    pts.push(p);
+    angles.push(Math.atan2(tangent[1], tangent[0]));
+  };
+  const count = subpathSegmentCount(sp);
+  for (let i = 0; i < count; i++) {
+    const seg = subpathSegment(sp, i);
+    const samples = seg.length === 2 ? 1 : 32;
+    if (i === 0) push(seg[0], segmentTangent(seg, 0));
+    for (let k = 1; k <= samples; k++) push(segmentPoint(seg, k / samples), segmentTangent(seg, k / samples));
+  }
+  if (pts.length < 2) return null;
+  const cum = [0];
+  for (let i = 1; i < pts.length; i++) cum.push(cum[i - 1] + Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]));
+  return { pts, cum, angles, total: cum[cum.length - 1], closed: sp.closed };
+}
+function vectorBlendRailAt(rail, s) {
+  let len2 = Number.isFinite(s) ? s : 0;
+  if (rail.closed && rail.total > 0) len2 = (len2 % rail.total + rail.total) % rail.total;
+  len2 = Math.min(rail.total, Math.max(0, len2));
+  let lo = 0;
+  let hi = rail.cum.length - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (rail.cum[mid] <= len2) lo = mid;
+    else hi = mid;
+  }
+  const span = rail.cum[hi] - rail.cum[lo];
+  const u = span > 1e-12 ? (len2 - rail.cum[lo]) / span : 0;
+  const a = rail.pts[lo];
+  const b = rail.pts[hi];
+  return { point: [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u], angle: Math.atan2(b[1] - a[1], b[0] - a[0]) };
+}
+function vectorBlendSpine(group) {
+  const keys = vectorBlendKeys(group);
+  if (keys.length < 2) return null;
+  const stored = group.blend?.spine;
+  if (stored && stored.anchors.length >= 2) {
+    const rail2 = vectorBlendRail(stored);
+    if (rail2) {
+      const end = rail2.closed ? rail2.total * (1 - 1 / keys.length) : rail2.total;
+      return { spine: stored, rail: rail2, stops: keys.map((_, i) => end * i / (keys.length - 1)), replaced: true };
+    }
+  }
+  const centres = keys.map(centreOf);
+  const spine = { closed: false, anchors: centres.map((c) => ({ x: c[0], y: c[1] })) };
+  const stops = [0];
+  for (let i = 1; i < centres.length; i++) stops.push(stops[i - 1] + Math.hypot(centres[i][0] - centres[i - 1][0], centres[i][1] - centres[i - 1][1]));
+  const rail = vectorBlendRail(spine) ?? { pts: centres, cum: stops, angles: centres.map(() => 0), total: stops[stops.length - 1], closed: false };
+  return { spine, rail, stops, replaced: false };
+}
+function vectorBlendKeyTargets(group) {
+  const s = vectorBlendSpine(group);
+  return s ? s.stops.map((stop) => vectorBlendRailAt(s.rail, stop).point) : [];
+}
+var morphCache = /* @__PURE__ */ new WeakMap();
+function morphFor(a, b, blend) {
+  const starts = [blend.starts?.[a.id] ?? null, blend.starts?.[b.id] ?? null];
+  const key = JSON.stringify([!!blend.linear, starts]);
+  let inner = morphCache.get(a);
+  if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
+  let byKey = inner.get(b);
+  if (!byKey) inner.set(b, byKey = /* @__PURE__ */ new Map());
+  let morph = byKey.get(key);
+  if (!morph) byKey.set(key, morph = createVectorMorph(a, b, { linear: blend.linear, starts }));
+  return morph;
+}
+var wrapAngle = (a) => Math.atan2(Math.sin(a), Math.cos(a));
+function asStep(node, id) {
+  const rename = (n2, nid) => n2.type === "group" ? { ...n2, id: nid, children: n2.children.map((c, i) => rename(c, `${nid}.${i}`)) } : { ...n2, id: nid };
+  return { ...rename(node, id), blendStep: true, locked: true };
+}
+function generateVectorBlendChildren(group) {
+  const keys = vectorBlendKeys(group);
+  const blend = group.blend;
+  if (!blend || keys.length < 2) return keys;
+  const spine = vectorBlendSpine(group);
+  if (!spine) return keys;
+  const out = [];
+  let counter = 0;
   keys.forEach((a, i) => {
     out.push(a);
     const b = keys[i + 1];
@@ -2279,6 +2905,12 @@ function lineStyle(node) {
 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 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;
+    }
     if (!l.drawn) continue;
     const role = l.kind;
     const paint = vectorPaintToSvg(l.layer.paint, `${idPrefix}${role}-${node.id}-${l.index}`, { node: l.node, ...role === "stroke" ? { role } : {} });
@@ -2777,6 +3409,11 @@ function getVectorOverlayRenderData(state) {
     const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt2(q.x)} ${fmt2(q.y)}`).join("") + (pts.length === 1 ? `L${fmt2(pts[0].x)} ${fmt2(pts[0].y)}` : "");
     toolStroke = { tool: it.tool, d, width: fmt2(it.width * z) };
   }
+  let brush = null;
+  if (it?.type === "brush") {
+    const c = toScreen(state, it);
+    brush = { x: fmt2(c.x), y: fmt2(c.y), r: fmt2(it.radius * z) };
+  }
   let pencilString = null;
   if (it?.type === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
@@ -2858,6 +3495,7 @@ function getVectorOverlayRenderData(state) {
     guides,
     status,
     toolStroke,
+    brush,
     pencilString,
     cutPoint,
     cornerWidgets,
@@ -3183,8 +3821,8 @@ function vectorPaintToHex(paint) {
   if (typeof paint !== "string") return null;
   const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(paint.trim());
   if (!m) return null;
-  const hex2 = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
-  return `#${hex2.toLowerCase()}`;
+  const hex3 = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
+  return `#${hex3.toLowerCase()}`;
 }
 var VECTOR_GRADIENT_TYPE_LABELS = { linear: "Linear", radial: "Radial", conic: "Conic", reflected: "Reflected", diamond: "Diamond" };
 var VECTOR_GRADIENT_SPREAD_LABELS = { pad: "Pad", reflect: "Reflect", repeat: "Repeat" };
@@ -3297,7 +3935,11 @@ function getVectorAppearancePanel(state) {
     blendMode: l.blendMode ?? "normal",
     visible: l.visible !== false,
     ...kind === "stroke" ? { strokeWidth: l.strokeWidth ?? 1, strokeAlign: l.strokeAlign ?? "center" } : {},
-    ...(l.kind ?? "paint") !== "paint" ? { unknownKind: String(l.kind) } : {},
+    ...isVectorBrushstrokeLayer(l) ? (() => {
+      const b = l.brush;
+      const preset = vectorBrushstrokeBrush(b.brushId);
+      return { brushstroke: { brushId: b.brushId, name: preset.name, size: b.size ?? preset.tip.size } };
+    })() : (l.kind ?? "paint") !== "paint" ? { unknownKind: String(l.kind) } : {},
     editing: edit.target === kind && (edit.layer === null ? index === count - 1 : edit.layer === index)
   });
   const fills = first ? vectorFills(first) : [];
@@ -3450,6 +4092,7 @@ var Page = class {
   content = [];
   states = /* @__PURE__ */ new Map();
   shadings = /* @__PURE__ */ new Map();
+  images = /* @__PURE__ */ new Map();
   /** A graphics state with this fill / stroke alpha and blend mode, by name. */
   gs(alpha, strokeAlpha, blend) {
     const bm = blend ? BLEND[blend] : void 0;
@@ -3463,6 +4106,36 @@ var Page = class {
     }
     return name;
   }
+  /** An image (a PNG data URL) as an XObject with its alpha as a soft mask, by name; null when unreadable. */
+  image(href) {
+    const hit = this.images.get(href);
+    if (hit) return hit;
+    const parsed = parseDataUrl(href);
+    if (!parsed || !isPng(parsed.bytes)) return null;
+    let img;
+    try {
+      img = decodePng(parsed.bytes);
+    } catch {
+      return null;
+    }
+    const px = img.width * img.height;
+    const rgb = new Uint8Array(px * 3);
+    const alpha = new Uint8Array(px);
+    for (let i = 0; i < px; i++) {
+      rgb[i * 3] = img.data[i * 4];
+      rgb[i * 3 + 1] = img.data[i * 4 + 1];
+      rgb[i * 3 + 2] = img.data[i * 4 + 2];
+      alpha[i] = img.data[i * 4 + 3];
+    }
+    const w = this.writer;
+    const dims = `/Type /XObject /Subtype /Image /Width ${img.width} /Height ${img.height} /BitsPerComponent 8`;
+    const mask = w.add(w.stream(`${dims} /ColorSpace /DeviceGray`, alpha, true));
+    const id = w.add(w.stream(`${dims} /ColorSpace /DeviceRGB /SMask ${mask} 0 R`, rgb, true));
+    const name = `Im${this.images.size + 1}`;
+    this.images.set(href, name);
+    w.imageIds.set(`${w.pageIndex}:${name}`, id);
+    return name;
+  }
   /** Sets the fill colour (or prepares a paint server) for `paint`: returns its alpha, or a def to fill with by clipping. */
   paint(paint, stroking) {
     if (!paint || paint === "none") return null;
@@ -3608,6 +4281,14 @@ var Page = class {
     for (const l of layers) {
       const a = alpha * l.opacity;
       const blend = l.blendMode ?? p.blendMode;
+      if (l.kind === "brushstroke") {
+        for (const im of l.images ?? []) {
+          const name = this.image(im.href);
+          if (!name) continue;
+          this.content.push("q", `/${this.gs(a, a, blend)} gs`, `${n(im.width)} 0 0 ${n(-im.height)} ${n(im.x)} ${n(im.y + im.height)} cm`, `/${name} Do`, "Q");
+        }
+        continue;
+      }
       if (l.kind === "fill") {
         if (l.fill !== "none") this.fill(p.d, l.fill, a, evenodd, blend);
       } else if (l.stroke !== "none" && l.strokeWidth > 0) {
@@ -3625,6 +4306,7 @@ var PdfWriter = class {
   objects = [];
   gsDicts = /* @__PURE__ */ new Map();
   shadingDicts = /* @__PURE__ */ new Map();
+  imageIds = /* @__PURE__ */ new Map();
   pageIndex = 0;
   add(body) {
     this.objects.push(body);
@@ -3710,7 +4392,8 @@ function vectorDocumentToPdf(doc, options = {}) {
     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`);
-    const resources = `<< ${gsEntries.length ? `/ExtGState << ${gsEntries.join(" ")} >> ` : ""}${shEntries.length ? `/Shading << ${shEntries.join(" ")} >>` : ""} >>`;
+    const imEntries = [...page.images.values()].map((name) => `/${name} ${w.imageIds.get(`${k}:${name}`)} 0 R`);
+    const resources = `<< ${gsEntries.length ? `/ExtGState << ${gsEntries.join(" ")} >> ` : ""}${shEntries.length ? `/Shading << ${shEntries.join(" ")} >> ` : ""}${imEntries.length ? `/XObject << ${imEntries.join(" ")} >>` : ""} >>`;
     pageIds.push(w.add(`<< /Type /Page /Parent ${pagesId} 0 R /MediaBox [0 0 ${n(W)} ${n(H)}] /Resources ${resources} /Contents ${content} 0 R >>`));
   });
   w.set(catalog, `<< /Type /Catalog /Pages ${pagesId} 0 R >>`);
@@ -3895,6 +4578,7 @@ function pathItems(node, notes) {
 function nodeGroup(node, notes) {
   if (node.visible === false) return null;
   if (node.filters?.length) notes.push(`${label(node)}: filters (shadows, glows, blurs) are not part of Lottie (left out).`);
+  if (node.type === "path" && node.strokes?.some((l) => l.kind === "brushstroke" && l.visible !== false)) notes.push(`${label(node)}: brushstrokes are raster images, not part of Lottie (left out).`);
   const m = nodeMatrix(node);
   let items = [];
   const live = (node.effects ?? []).some((e) => e.enabled !== false && (e.type === "wiggle" || e.type === "envelope" || e.type === "contour" || e.type === "blockShadow" || e.type === "extrude" || e.type === "bevel"));
@@ -4030,8 +4714,8 @@ function subpathOf(prop, frame) {
 }
 function cssColor(c) {
   const k = c.slice(0, 3).some((v) => v > 1) ? 255 : 1;
-  const hex2 = (v) => Math.round(Math.min(1, Math.max(0, v / k)) * 255).toString(16).padStart(2, "0");
-  return `#${hex2(c[0] ?? 0)}${hex2(c[1] ?? 0)}${hex2(c[2] ?? 0)}`;
+  const hex3 = (v) => Math.round(Math.min(1, Math.max(0, v / k)) * 255).toString(16).padStart(2, "0");
+  return `#${hex3(c[0] ?? 0)}${hex3(c[1] ?? 0)}${hex3(c[2] ?? 0)}`;
 }
 function geometryOf(it, frame, notes) {
   switch (it.ty) {
@@ -4271,338 +4955,51 @@ function parseVectorLottie(input, options = {}) {
       if (!parent || seen.has(parent)) return own;
       seen.add(l);
       return multiplyMatrices(own, worldOf2(parent, seen));
-    };
-    const out = [];
-    for (const l of layers) {
-      const ty = Number(l.ty);
-      if (l.hd === true || frame < Number(l.ip ?? -Infinity) || frame >= Number(l.op ?? Infinity)) continue;
-      if (l.td === 1 || l.tt) notes.push(`Layer "${l.nm ?? ""}": track mattes are not imported.`);
-      if (l.ef) notes.push(`Layer "${l.nm ?? ""}": layer effects are not imported.`);
-      if (l.ks && JSON.stringify(l.ks).includes('"x":"')) notes.push("Expressions are not evaluated (their stored values are used).");
-      let children = [];
-      if (ty === 4) children = itemsToNodes(Array.isArray(l.shapes) ? l.shapes : [], { paints: [], modifiers: [] }, s);
-      else if (ty === 1) {
-        const w = Number(l.sw ?? 0);
-        const h = Number(l.sh ?? 0);
-        const c = typeof l.sc === "string" ? l.sc : "#000000";
-        children = [{ id: s.next(), type: "path", name: "Solid", subpaths: [rectSubpath({ x: 0, y: 0, width: w, height: h })], fill: c, stroke: null }];
-      } else if (ty === 0 && typeof l.refId === "string" && depth < 16) {
-        const asset = assets.get(l.refId);
-        const local = frame - Number(l.st ?? 0);
-        if (asset && Array.isArray(asset.layers)) children = layersToNodes(asset.layers, local, depth + 1);
-      } else if (ty !== 3) {
-        notes.push(`Layer "${l.nm ?? ""}" (type ${ty}) is not supported (skipped).`);
-        continue;
-      }
-      if (!children.length) continue;
-      const m = worldOf2(l);
-      const opacity = transformOf(l.ks, frame, notes).opacity;
-      let group = { id: s.next(), type: "group", ...typeof l.nm === "string" ? { name: l.nm } : {}, children };
-      group = transformVectorNode(group, m);
-      if (opacity < 1) group = { ...group, opacity };
-      const masks = (Array.isArray(l.masksProperties) ? l.masksProperties : []).filter((mk) => (mk.mode ?? "a") === "a" && !mk.inv);
-      if (Array.isArray(l.masksProperties) && masks.length !== l.masksProperties.length) notes.push(`Layer "${l.nm ?? ""}": only additive masks are imported.`);
-      if (masks.length) {
-        const subpaths = masks.map((mk) => subpathOf(mk.pt, frame)).filter((x) => !!x);
-        const clip = transformVectorNode({ id: s.next(), type: "path", name: "Mask", subpaths, fill: "#000000", stroke: null }, m);
-        const { transform: _t, opacity: _o, ...inner } = group;
-        group = { id: s.next(), type: "group", name: `${group.name ?? "Layer"} mask`, mask: { type: "clip" }, children: [clip, { ...inner, id: s.next() }], ...group.opacity !== void 0 ? { opacity: group.opacity } : {} };
-      }
-      out.push(group);
-    }
-    return out.reverse();
-  };
-  const nodes = layersToNodes(json.layers, s.frame, 0);
-  const width = Number(json.w ?? 512);
-  const height = Number(json.h ?? 512);
-  return { document: { width, height, nodes }, notes: [...new Set(notes)] };
-}
-
-// src/vector/trace.ts
-var VECTOR_TRACE_MAX_PIXELS = 4e6;
-function signedArea(p) {
-  let a = 0;
-  for (let i = 0; i < p.length; i++) {
-    const [x0, y0] = p[i];
-    const [x1, y1] = p[(i + 1) % p.length];
-    a += x0 * y1 - x1 * y0;
-  }
-  return a / 2;
-}
-function pointInPoly(p, poly) {
-  let inside = false;
-  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
-    const [xi, yi] = poly[i];
-    const [xj, yj] = poly[j];
-    if (yi > p[1] !== yj > p[1] && p[0] < (xj - xi) * (p[1] - yi) / (yj - yi) + xi) inside = !inside;
-  }
-  return inside;
-}
-function vectorTraceContours(field, w, h, threshold) {
-  const gw = w + 2;
-  const gh = h + 2;
-  const val = (i, j) => i === 0 || j === 0 || i > w || j > h ? -Infinity : field[(j - 1) * w + (i - 1)];
-  const inside = (i, j) => val(i, j) >= threshold;
-  const pos = (i, j) => [i - 0.5, j - 0.5];
-  const cross2 = (a, b) => {
-    const va = val(a[0], a[1]);
-    const vb = val(b[0], b[1]);
-    let t;
-    if (Number.isFinite(va) && Number.isFinite(vb) && Math.abs(vb - va) > 1e-12) t = Math.min(1, Math.max(0, (threshold - va) / (vb - va)));
-    else if (Number.isFinite(va)) t = va >= threshold ? 0.5 : 0;
-    else t = vb >= threshold ? 0.5 : 1;
-    const pa = pos(a[0], a[1]);
-    const pb = pos(b[0], b[1]);
-    return [pa[0] + (pb[0] - pa[0]) * t, pa[1] + (pb[1] - pa[1]) * t];
-  };
-  const hid = (i, j) => 2 * (j * gw + i);
-  const vid = (i, j) => 2 * (j * gw + i) + 1;
-  const next = /* @__PURE__ */ new Map();
-  const point = /* @__PURE__ */ new Map();
-  for (let j = 0; j < gh - 1; j++) {
-    for (let i = 0; i < gw - 1; i++) {
-      const tl = inside(i, j);
-      const tr = inside(i + 1, j);
-      const br = inside(i + 1, j + 1);
-      const bl = inside(i, j + 1);
-      const code = +tl << 3 | +tr << 2 | +br << 1 | +bl;
-      if (code === 0 || code === 15) continue;
-      const top = hid(i, j);
-      const bottom = hid(i, j + 1);
-      const left = vid(i, j);
-      const right = vid(i + 1, j);
-      const seg = (a, b) => next.set(a, b);
-      const mean = () => (val(i, j) + val(i + 1, j) + val(i + 1, j + 1) + val(i, j + 1)) / 4;
-      switch (code) {
-        case 1:
-          seg(left, bottom);
-          break;
-        case 2:
-          seg(bottom, right);
-          break;
-        case 3:
-          seg(left, right);
-          break;
-        case 4:
-          seg(right, top);
-          break;
-        case 5:
-          if (mean() >= threshold) {
-            seg(left, top);
-            seg(right, bottom);
-          } else {
-            seg(left, bottom);
-            seg(right, top);
-          }
-          break;
-        case 6:
-          seg(bottom, top);
-          break;
-        case 7:
-          seg(left, top);
-          break;
-        case 8:
-          seg(top, left);
-          break;
-        case 9:
-          seg(top, bottom);
-          break;
-        case 10:
-          if (mean() >= threshold) {
-            seg(top, right);
-            seg(bottom, left);
-          } else {
-            seg(top, left);
-            seg(bottom, right);
-          }
-          break;
-        case 11:
-          seg(top, right);
-          break;
-        case 12:
-          seg(right, left);
-          break;
-        case 13:
-          seg(right, bottom);
-          break;
-        case 14:
-          seg(bottom, left);
-          break;
-      }
-      const edges = [
-        [top, [i, j], [i + 1, j]],
-        [bottom, [i, j + 1], [i + 1, j + 1]],
-        [left, [i, j], [i, j + 1]],
-        [right, [i + 1, j], [i + 1, j + 1]]
-      ];
-      for (const [e, a, b] of edges) if (inside(a[0], a[1]) !== inside(b[0], b[1]) && !point.has(e)) point.set(e, cross2(a, b));
-    }
-  }
-  const out = [];
-  for (const start of [...next.keys()].sort((a, b) => a - b)) {
-    if (!next.has(start)) continue;
-    const poly = [];
-    let e = start;
-    for (; ; ) {
-      const n2 = next.get(e);
-      if (n2 === void 0) break;
-      next.delete(e);
-      const p = point.get(e);
-      if (p) poly.push(p);
-      e = n2;
-      if (e === start) break;
-    }
-    if (poly.length >= 3) out.push(poly);
-  }
-  return out;
-}
-function loopsOf(field, w, h, threshold, tolerance, minArea) {
-  const loops = [];
-  for (const raw of vectorTraceContours(field, w, h, threshold)) {
-    const area = signedArea(raw);
-    if (Math.abs(area) < Math.max(0, minArea)) continue;
-    const simple = simplifyRing(raw, Math.max(0.01, tolerance));
-    if (simple.length < 3) continue;
-    loops.push({ raw, simple, area, depth: 0 });
-  }
-  for (const l of loops) l.depth = loops.filter((o) => o !== l && Math.abs(o.area) > Math.abs(l.area) && pointInPoly(l.simple[0], o.simple)).length;
-  return loops.sort((a, b) => a.depth - b.depth || Math.abs(b.area) - Math.abs(a.area));
-}
-function loopSubpath(l, tolerance, roundness) {
-  if (roundness <= 0) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
-  const cornerAngleDeg = 25 + roundness * 125;
-  const cubics = fitCubics(l.raw, Math.max(0.05, tolerance), {
-    closed: true,
-    cornerAngleDeg
-  });
-  if (!cubics.length) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
-  const anchors = cubics.map((c, k) => {
-    const prev = cubics[(k - 1 + cubics.length) % cubics.length];
-    return {
-      x: c.p0[0],
-      y: c.p0[1],
-      in: { x: prev.p2[0], y: prev.p2[1] },
-      out: { x: c.p1[0], y: c.p1[1] }
-    };
-  });
-  return { closed: true, anchors };
-}
-function traceField(field, w, h, threshold, o) {
-  const tolerance = o.tolerance ?? 1;
-  const roundness = Math.min(1, Math.max(0, o.cornerRoundness ?? 0.5));
-  return loopsOf(field, w, h, threshold, tolerance, o.minArea ?? 10).map((l) => loopSubpath(l, tolerance, roundness));
-}
-function quantizeVectorTraceColors(pixels, count) {
-  const n2 = pixels.width * pixels.height;
-  const d = pixels.data;
-  const opaque = [];
-  for (let i = 0; i < n2; i++) if (d[i * 4 + 3] >= 128) opaque.push(i);
-  const boxes = opaque.length ? [opaque] : [];
-  const range = (box, c) => {
-    let lo = 255;
-    let hi = 0;
-    for (const i of box) {
-      const v = d[i * 4 + c];
-      if (v < lo) lo = v;
-      if (v > hi) hi = v;
-    }
-    return hi - lo;
-  };
-  while (boxes.length < count) {
-    let best = -1;
-    let bestRange = 0;
-    let bestC = 0;
-    boxes.forEach((b, k) => {
-      if (b.length < 2) return;
-      for (let c = 0; c < 3; c++) {
-        const r = range(b, c);
-        if (r > bestRange) {
-          bestRange = r;
-          best = k;
-          bestC = c;
-        }
-      }
-    });
-    if (best < 0) break;
-    const box = boxes[best].slice().sort((a, b) => d[a * 4 + bestC] - d[b * 4 + bestC]);
-    const key = (k) => d[box[k] * 4 + bestC];
-    const v = key(box.length >> 1);
-    let mid = box.findIndex((_, k) => key(k) >= v);
-    if (mid <= 0) mid = box.findIndex((_, k) => key(k) > v);
-    boxes.splice(best, 1, box.slice(0, mid), box.slice(mid));
-  }
-  const palette = boxes.map((b) => {
-    const s = [0, 0, 0];
-    for (const i of b) for (let c = 0; c < 3; c++) s[c] += d[i * 4 + c];
-    return [Math.round(s[0] / b.length), Math.round(s[1] / b.length), Math.round(s[2] / b.length)];
-  });
-  const index = new Int16Array(n2).fill(-1);
-  const counts = palette.map(() => 0);
-  for (const i of opaque) {
-    let best = 0;
-    let bestD = Infinity;
-    palette.forEach((p, k) => {
-      const dd = (d[i * 4] - p[0]) ** 2 + (d[i * 4 + 1] - p[1]) ** 2 + (d[i * 4 + 2] - p[2]) ** 2;
-      if (dd < bestD) {
-        bestD = dd;
-        best = k;
+    };
+    const out = [];
+    for (const l of layers) {
+      const ty = Number(l.ty);
+      if (l.hd === true || frame < Number(l.ip ?? -Infinity) || frame >= Number(l.op ?? Infinity)) continue;
+      if (l.td === 1 || l.tt) notes.push(`Layer "${l.nm ?? ""}": track mattes are not imported.`);
+      if (l.ef) notes.push(`Layer "${l.nm ?? ""}": layer effects are not imported.`);
+      if (l.ks && JSON.stringify(l.ks).includes('"x":"')) notes.push("Expressions are not evaluated (their stored values are used).");
+      let children = [];
+      if (ty === 4) children = itemsToNodes(Array.isArray(l.shapes) ? l.shapes : [], { paints: [], modifiers: [] }, s);
+      else if (ty === 1) {
+        const w = Number(l.sw ?? 0);
+        const h = Number(l.sh ?? 0);
+        const c = typeof l.sc === "string" ? l.sc : "#000000";
+        children = [{ id: s.next(), type: "path", name: "Solid", subpaths: [rectSubpath({ x: 0, y: 0, width: w, height: h })], fill: c, stroke: null }];
+      } else if (ty === 0 && typeof l.refId === "string" && depth < 16) {
+        const asset = assets.get(l.refId);
+        const local = frame - Number(l.st ?? 0);
+        if (asset && Array.isArray(asset.layers)) children = layersToNodes(asset.layers, local, depth + 1);
+      } else if (ty !== 3) {
+        notes.push(`Layer "${l.nm ?? ""}" (type ${ty}) is not supported (skipped).`);
+        continue;
       }
-    });
-    index[i] = best;
-    counts[best]++;
-  }
-  return { palette, index, counts };
-}
-var hex = (c) => `#${c.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
-function traceVectorImage(pixels, options = {}) {
-  const { width: w, height: h, data } = pixels;
-  if (!(w > 0 && h > 0) || data.length < w * h * 4) throw new Error("The image has no pixels (or fewer than width \xD7 height \xD7 4 values).");
-  if (w * h > VECTOR_TRACE_MAX_PIXELS) throw new Error(`The image has ${w * h} pixels; scale it down to at most ${VECTOR_TRACE_MAX_PIXELS} to trace it.`);
-  const n2 = w * h;
-  if ((options.mode ?? "threshold") === "threshold") {
-    const field = new Float32Array(n2);
-    const byAlpha = options.channel === "alpha";
-    for (let i = 0; i < n2; i++) {
-      const a = data[i * 4 + 3] / 255;
-      field[i] = byAlpha ? a : a * (1 - (0.2126 * data[i * 4] + 0.7152 * data[i * 4 + 1] + 0.0722 * data[i * 4 + 2]) / 255);
-    }
-    const subpaths = traceField(field, w, h, Math.min(1, Math.max(0, options.threshold ?? 0.5)), options);
-    return subpaths.length ? [
-      {
-        id: "trace-1",
-        type: "path",
-        name: "Trace",
-        fill: options.color ?? "#000000",
-        stroke: null,
-        fillRule: "evenodd",
-        subpaths
+      if (!children.length) continue;
+      const m = worldOf2(l);
+      const opacity = transformOf(l.ks, frame, notes).opacity;
+      let group = { id: s.next(), type: "group", ...typeof l.nm === "string" ? { name: l.nm } : {}, children };
+      group = transformVectorNode(group, m);
+      if (opacity < 1) group = { ...group, opacity };
+      const masks = (Array.isArray(l.masksProperties) ? l.masksProperties : []).filter((mk) => (mk.mode ?? "a") === "a" && !mk.inv);
+      if (Array.isArray(l.masksProperties) && masks.length !== l.masksProperties.length) notes.push(`Layer "${l.nm ?? ""}": only additive masks are imported.`);
+      if (masks.length) {
+        const subpaths = masks.map((mk) => subpathOf(mk.pt, frame)).filter((x) => !!x);
+        const clip = transformVectorNode({ id: s.next(), type: "path", name: "Mask", subpaths, fill: "#000000", stroke: null }, m);
+        const { transform: _t, opacity: _o, ...inner } = group;
+        group = { id: s.next(), type: "group", name: `${group.name ?? "Layer"} mask`, mask: { type: "clip" }, children: [clip, { ...inner, id: s.next() }], ...group.opacity !== void 0 ? { opacity: group.opacity } : {} };
       }
-    ] : [];
-  }
-  const count = Math.min(32, Math.max(2, Math.round(options.colors ?? 6)));
-  const q = quantizeVectorTraceColors(pixels, count);
-  const order = q.palette.map((_, k) => k).filter((k) => q.counts[k] > 0).sort((a, b) => q.counts[b] - q.counts[a]);
-  const rank = new Map(order.map((k, r) => [k, r]));
-  const out = [];
-  order.forEach((k, r) => {
-    const field = new Uint8Array(n2);
-    for (let i = 0; i < n2; i++) {
-      const ix = q.index[i];
-      field[i] = ix >= 0 && rank.get(ix) >= r ? 1 : 0;
+      out.push(group);
     }
-    const subpaths = traceField(field, w, h, 0.5, options);
-    if (subpaths.length)
-      out.push({
-        id: `trace-${out.length + 1}`,
-        type: "path",
-        name: hex(q.palette[k]),
-        fill: hex(q.palette[k]),
-        stroke: null,
-        fillRule: "evenodd",
-        subpaths
-      });
-  });
-  return out;
+    return out.reverse();
+  };
+  const nodes = layersToNodes(json.layers, s.frame, 0);
+  const width = Number(json.w ?? 512);
+  const height = Number(json.h ?? 512);
+  return { document: { width, height, nodes }, notes: [...new Set(notes)] };
 }
 
 // src/vector/constraints/auto.ts
@@ -6555,6 +6952,9 @@ var DEFAULT_VECTOR_PATH_EDIT = {
   pencilSmoothing: 0,
   recognizeShapes: false,
   eraserSize: 10,
+  distortMode: "smudge",
+  distortSize: 20,
+  distortStrength: 0.5,
   pencilPressure: "pen",
   fillGap: 0
 };
@@ -6827,8 +7227,10 @@ var TOOL_LABELS = {
   type: "Type",
   typePath: "Type on a Path",
   frame: "Frame",
-  connector: "Connector"
+  connector: "Connector",
+  distort: "Distort Brush"
 };
+var DISTORT_LABELS = { smudge: "Smudge", twirl: "Twirl", attract: "Attract", repel: "Repel", roughen: "Roughen" };
 var TOOL_KEYS = {
   v: "select",
   a: "direct",
@@ -6851,7 +7253,8 @@ var TOOL_KEYS = {
   t: "type",
   q: "typePath",
   f: "frame",
-  x: "connector"
+  x: "connector",
+  d: "distort"
 };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
@@ -6878,7 +7281,8 @@ var VECTOR_TOOL_SHORTCUTS = {
   type: "T",
   typePath: "Q",
   frame: "F",
-  connector: "X"
+  connector: "X",
+  distort: "D"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -6902,7 +7306,8 @@ var VECTOR_TOOL_GLYPHS = {
   type: "T",
   typePath: "\u{1D4AF}",
   frame: "\u2B1A",
-  connector: "\u2933"
+  connector: "\u2933",
+  distort: "\u2248"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line", "frame"]);
 var BOOLEAN_OPS = {
@@ -7433,6 +7838,9 @@ var VectorEditorController = class _VectorEditorController {
     const next = { ...this.editing, ...editing };
     next.pencilSmoothing = Math.min(1, Math.max(0, Number.isFinite(next.pencilSmoothing) ? next.pencilSmoothing : 0));
     if (!(next.eraserSize > 0)) next.eraserSize = this.editing.eraserSize;
+    if (!VECTOR_DISTORT_BRUSH_MODES.includes(next.distortMode)) next.distortMode = this.editing.distortMode;
+    if (!(next.distortSize > 0)) next.distortSize = this.editing.distortSize;
+    next.distortStrength = Math.min(1, Math.max(0, Number.isFinite(next.distortStrength) ? next.distortStrength : this.editing.distortStrength));
     this.editing = next;
     this.notify();
   }
@@ -7675,6 +8083,22 @@ var VectorEditorController = class _VectorEditorController {
     });
     return next.id;
   }
+  /**
+   * Replaces a generated group's art (its children) and provenance, in one undo step; used by
+   * `regenerateVectorArt`. The group keeps its id, name, transform and place.
+   */
+  replaceGeneratedArt(id, children, generation) {
+    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)));
+    this.change("Regenerate Art", () => {
+      this.replaceNode(id, { ...node, generation, children: placed });
+      this.anchors = [];
+    });
+    return { ok: true };
+  }
   /** Builds a path node for a shape with the current defaults (not added). */
   createShapeNode(input) {
     const b = { x: input.x, y: input.y, width: input.width, height: input.height };
@@ -8364,6 +8788,57 @@ var VectorEditorController = class _VectorEditorController {
       merge
     );
   }
+  /**
+   * Adds a brushstroke to the selected (or given) paths: a stroke layer that paints the path with
+   * brush `brushId` from the paint editor's library (`vectorBrushstrokeBrushes`), `size` document
+   * units across (default the brush's own), an optional `pressure` profile along the length, in
+   * `color` (default the top stroke's paint, else black) at `opacity`. At the top of the stroke
+   * stack or at `index`. One undo step.
+   */
+  addBrushstroke(brush, options = {}) {
+    const clean = sanitizeVectorBrushstroke(brush);
+    if (!clean) return { ok: false, message: `Unknown brush "${brush?.brushId}": use one of ${vectorBrushstrokeBrushes().map((b) => b.id).join(", ")}.` };
+    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)." };
+    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." };
+    return this.editStacks("stroke", options.ids, "Add Brushstroke", (stack, path) => {
+      const top = [...stack].reverse().find((l) => (l.kind ?? "paint") === "paint");
+      const paint = options.color ?? (typeof top?.paint === "string" && top.paint !== "none" ? top.paint : typeof path.stroke === "string" && path.stroke !== "none" ? path.stroke : "#000000");
+      const layer = { kind: "brushstroke", paint, brush: clean, ...options.opacity !== void 0 && options.opacity < 1 ? { opacity: options.opacity } : {} };
+      const at = options.index === void 0 ? stack.length : Math.min(stack.length, Math.max(0, Math.round(options.index)));
+      return [...stack.slice(0, at), layer, ...stack.slice(at)];
+    });
+  }
+  /**
+   * Changes brushstroke layer `index` (in the stroke stack, 0 is the bottom) of the selected (or
+   * given) paths: another brush, size, pressure profile (null removes it), colour or opacity.
+   * Fails, changing nothing, when that layer is not a brushstroke. With `merge`, consecutive edits
+   * fold into one undo step.
+   */
+  setBrushstroke(index, patch, options = {}) {
+    if (patch.brushId !== void 0 && !vectorBrushstrokeBrush(patch.brushId)) return { ok: false, message: `Unknown brush "${patch.brushId}": use one of ${vectorBrushstrokeBrushes().map((b) => b.id).join(", ")}.` };
+    if (patch.size !== void 0 && patch.size !== null && !(patch.size > 0 && patch.size <= 500)) return { ok: false, message: "size must be above 0 and at most 500 (document units)." };
+    if (patch.color !== void 0 && !parseVectorColor(patch.color)) return { ok: false, message: `"${patch.color}" is not a colour.` };
+    if (patch.opacity !== void 0 && !(patch.opacity >= 0 && patch.opacity <= 1)) return { ok: false, message: "opacity must be from 0 to 1." };
+    const merge = options.merge === true ? `brushstroke:${index}` : options.merge || void 0;
+    return this.editStacks(
+      "stroke",
+      options.ids,
+      "Edit Brushstroke",
+      (stack, path) => {
+        const layer = stack[index];
+        if (!layer || layer.kind !== "brushstroke" || !layer.brush) return `Path "${path.id}" has no brushstroke at stroke ${index} (vector.getAppearance lists its strokes; 0 is the bottom).`;
+        const brush = { ...layer.brush, ...patch.brushId ? { brushId: patch.brushId } : {} };
+        if (patch.size === null) delete brush.size;
+        else if (patch.size !== void 0) brush.size = patch.size;
+        if (patch.pressure === null) delete brush.pressure;
+        else if (patch.pressure !== void 0) brush.pressure = patch.pressure;
+        const next = { ...layer, brush: sanitizeVectorBrushstroke(brush) ?? layer.brush, ...patch.color ? { paint: patch.color } : {}, ...patch.opacity !== void 0 ? { opacity: patch.opacity } : {} };
+        return stack.map((l, i) => i === index ? next : l);
+      },
+      merge
+    );
+  }
   /** Removes layer `index` of the fill or stroke stack of the selected (or given) paths. */
   removePaintLayer(kind, index, options = {}) {
     return this.editStacks(
@@ -9844,6 +10319,38 @@ var VectorEditorController = class _VectorEditorController {
     });
     return { ok: true, id, ids: children.map((c) => c.id) };
   }
+  /**
+   * Bitmap-to-vector stylise: turns RGBA `pixels` into stylised vector art (see
+   * `stylizeVectorImage`: mosaic tiles, halftone dots, low-poly triangles or engraving lines) and
+   * adds it as one group, placed like Image Trace (top-left at `x, y`, `width` wide, default one
+   * unit per pixel). One undo step; selects the group. Returns its id and its paths' ids.
+   */
+  stylizeImage(pixels, style, options = {}) {
+    if (!VECTOR_STYLIZE_STYLES.includes(style)) return { ok: false, message: `Unknown style "${style}": use ${VECTOR_STYLIZE_STYLES.join(", ")}.` };
+    if (options.cell !== void 0 && !(options.cell >= 1)) return { ok: false, message: "cell must be at least 1 pixel." };
+    if (options.colors !== void 0 && !(Number.isInteger(options.colors) && options.colors >= 2 && options.colors <= 32)) return { ok: false, message: "colors must be a whole number from 2 to 32." };
+    if (options.width !== void 0 && !(options.width > 0)) return { ok: false, message: "width must be above 0." };
+    if (typeof options.color === "string" && !parseVectorColor(options.color)) return { ok: false, message: `"${options.color}" is not a colour.` };
+    let made;
+    try {
+      made = stylizeVectorImage(pixels, style, options);
+    } catch (e) {
+      return { ok: false, message: e.message };
+    }
+    if (!made.length) return { ok: false, message: "Nothing to draw: the picture is empty or too light for this style (try a smaller cell, or mosaic)." };
+    const k = (options.width ?? pixels.width) / pixels.width;
+    const m = [k, 0, 0, k, options.x ?? 0, options.y ?? 0];
+    const children = made.map((n2) => ({ ...transformVectorNode(n2, m), id: this.newId() }));
+    const id = this.newId();
+    const label2 = VECTOR_STYLIZE_LABELS[style];
+    this.change(label2, () => {
+      this.setDoc([...this.doc.nodes, { id, type: "group", name: options.name ?? label2, children }]);
+      this.selection = [id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return { ok: true, id, ids: children.map((c) => c.id) };
+  }
   // -----------------------------------------------------------------------------------------
   // Gradient meshes and freeform gradients
   /** The selected point of a mesh or freeform fill (Gradient tool), or null. */
@@ -11646,6 +12153,81 @@ var VectorEditorController = class _VectorEditorController {
     });
     return out;
   }
+  /** Starts a Distort Brush stroke at `p` (document space). */
+  downDistort(p) {
+    const before = this.snapshot();
+    const r = this.editing.distortSize;
+    const drag = { kind: "distort", mode: this.editing.distortMode, base: this.doc, before, targets: /* @__PURE__ */ new Set(), dabs: [], last: p };
+    this.addDistortDab(drag, p, true);
+    this.drag = drag;
+    this.interaction = { type: "brush", x: p.x, y: p.y, radius: r };
+    this.notify();
+  }
+  /** Adds the paths the brush reaches at `p` to the stroke's targets, and (unless `targetsOnly`) a dab there. */
+  addDistortDab(drag, p, targetsOnly = false) {
+    const radius = this.editing.distortSize;
+    const strength = this.editing.distortStrength;
+    const base = this.doc;
+    this.doc = drag.base;
+    for (const n2 of this.strokeTargets([p], void 0, radius)) drag.targets.add(n2.id);
+    this.doc = base;
+    if (targetsOnly) return;
+    if (drag.mode === "smudge") drag.dabs.push({ x: drag.last.x, y: drag.last.y, radius, strength, dx: p.x - drag.last.x, dy: p.y - drag.last.y });
+    else drag.dabs.push({ x: p.x, y: p.y, radius, strength, angle: 15, seed: drag.dabs.length + 1 });
+  }
+  /** `base` with the target paths distorted by the dabs (document space dabs, mapped into each path's own space). */
+  distortedDoc(base, targets, mode, dabs) {
+    if (!dabs.length || !targets.size) return base;
+    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 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;
+        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);
+      const out = distortVectorPath(path, mode, local);
+      return out === path ? n2 : { ...n2, subpaths: bezierToSubpaths(out) };
+    });
+    return nodes === base.nodes ? base : { ...base, nodes };
+  }
+  /**
+   * Distortion brush (CorelDRAW's Smudge, Twirl, Attract, Repel and Roughen tools): runs a round
+   * brush of `radius` (default: the `distortSize` setting) and `strength` 0–1 along `points`
+   * (document space). Smudge pushes the outlines along the stroke (needs two or more points),
+   * twirl turns them about each point by `angle` degrees (default 15) at full strength, attract
+   * pulls them toward each point, repel pushes them away, roughen spikes them. It acts on `ids`,
+   * the selection, or every path the brush reaches. One undo step. Returns the changed ids.
+   */
+  distortBrush(mode, points, options = {}) {
+    if (!VECTOR_DISTORT_BRUSH_MODES.includes(mode)) return { ok: false, message: `Unknown brush "${mode}": use ${VECTOR_DISTORT_BRUSH_MODES.join(", ")}.` };
+    if (!points.length || points.some((q) => !Number.isFinite(q?.x) || !Number.isFinite(q?.y))) return { ok: false, message: "points must be one or more { x, y } numbers." };
+    if (mode === "smudge" && points.length < 2) return { ok: false, message: "Smudge needs two or more points: the stroke pushes the outlines along it." };
+    const radius = options.radius ?? this.editing.distortSize;
+    const strength = options.strength ?? this.editing.distortStrength;
+    if (!(radius > 0)) return { ok: false, message: "radius must be more than 0." };
+    if (!(strength >= 0 && strength <= 1)) return { ok: false, message: "strength must be from 0 to 1." };
+    if (options.ids) {
+      for (const id of options.ids) {
+        const n2 = this.getNode(id);
+        if (!n2) return { ok: false, message: `There is no node "${id}".` };
+        if (n2.locked) return { ok: false, message: `"${id}" is locked; unlock it first.` };
+      }
+    }
+    const targets = new Set(this.strokeTargets(points, options.ids, radius).map((n2) => n2.id));
+    const dabs = mode === "smudge" ? points.slice(1).map((q, i) => ({ x: points[i].x, y: points[i].y, radius, strength, dx: q.x - points[i].x, dy: q.y - points[i].y })) : points.map((q, i) => ({ x: q.x, y: q.y, radius, strength, angle: options.angle ?? 15, seed: (options.seed ?? 1) + i }));
+    const next = this.distortedDoc(this.doc, targets, mode, dabs);
+    const changed = [...targets].filter((id) => findVectorNode(next.nodes, id) !== this.getNode(id));
+    if (!changed.length) return { ok: false, message: "The brush reached no outline: put the points within radius of a path (or pass its id)." };
+    this.change(DISTORT_LABELS[mode], () => {
+      this.doc = next;
+      this.anchors = [];
+    });
+    return { ok: true, ids: changed };
+  }
   /** A stroke's points in node `id`'s own space. */
   localPoints(id, points) {
     const inv = invertMatrix(this.worldOf(id));
@@ -12212,6 +12794,8 @@ var VectorEditorController = class _VectorEditorController {
         return;
       case "connector":
         return this.downConnector(p);
+      case "distort":
+        return this.downDistort(p);
       default:
         return this.downShape(p, input);
     }
@@ -12634,6 +13218,16 @@ var VectorEditorController = class _VectorEditorController {
       }
       case "builder":
         return this.moveBuilder(drag, p);
+      case "distort": {
+        const r = this.editing.distortSize;
+        if (Math.hypot(p.x - drag.last.x, p.y - drag.last.y) < r * 0.1) return;
+        this.addDistortDab(drag, p);
+        drag.last = p;
+        this.doc = this.distortedDoc(drag.base, drag.targets, drag.mode, drag.dabs);
+        this.interaction = { type: "brush", x: p.x, y: p.y, radius: r };
+        this.notify(true);
+        return;
+      }
       case "stroke": {
         const last = drag.points[drag.points.length - 1];
         if (Math.hypot(p.x - last.x, p.y - last.y) * this.viewport.zoom < 1.5) return;
@@ -12927,6 +13521,17 @@ var VectorEditorController = class _VectorEditorController {
         else this.erase(drag.points);
         return;
       }
+      case "distort": {
+        if (!drag.dabs.length && drag.mode !== "smudge") {
+          this.addDistortDab(drag, drag.last);
+          this.doc = this.distortedDoc(drag.base, drag.targets, drag.mode, drag.dabs);
+        }
+        if (this.doc === drag.base) {
+          this.notify(true);
+          return;
+        }
+        return this.commit(DISTORT_LABELS[drag.mode], drag.before);
+      }
       case "pull":
         if (drag.closing) this.pen = null;
         return this.commit(drag.label, drag.before);
@@ -12982,9 +13587,9 @@ var VectorEditorController = class _VectorEditorController {
           this.selection = [drag.nodeId];
           return this.commit(`Draw ${inkShapeLabel(shape)}`, drag.before);
         }
-        const fitted = fitCubics(drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
+        const fitted2 = fitCubics(drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
         const anchors = [];
-        for (const c of fitted) {
+        for (const c of fitted2) {
           if (!anchors.length) anchors.push({ x: c.p0[0], y: c.p0[1] });
           anchors[anchors.length - 1].out = { x: c.p1[0], y: c.p1[1] };
           anchors.push({ x: c.p3[0], y: c.p3[1], in: { x: c.p2[0], y: c.p2[1] } });
@@ -14493,7 +15098,7 @@ var pickStyle = (params) => {
   }
   return out;
 };
-var check = (result) => {
+var check2 = (result) => {
   if (!result.ok) fail(result.message ?? "The command failed.");
 };
 function createVectorCommands(controller, options = {}) {
@@ -14623,7 +15228,7 @@ function createVectorCommands(controller, options = {}) {
         enabled: enabledFor,
         run: (_ctx, params) => {
           const targets = ids(params);
-          check(controller.addPaintLayer(kind, layerPatchOf(params ?? {}, keys), { ids: targets, index: params?.index }));
+          check2(controller.addPaintLayer(kind, layerPatchOf(params ?? {}, keys), { ids: targets, index: params?.index }));
           return { nodes: pathsUnder(targets).map((id) => stackResult(id, kind)) };
         }
       },
@@ -14639,7 +15244,7 @@ function createVectorCommands(controller, options = {}) {
           layerIndex(params.nodeId, kind, params.index);
           const patch = layerPatchOf(params, keys);
           if (!Object.keys(patch).length) fail(`Pass at least one of: ${keys.join(", ")}.`);
-          check(controller.updatePaintLayer(kind, params.index, patch, { ids: [params.nodeId] }));
+          check2(controller.updatePaintLayer(kind, params.index, patch, { ids: [params.nodeId] }));
           return stackResult(params.nodeId, kind);
         }
       },
@@ -14653,7 +15258,7 @@ function createVectorCommands(controller, options = {}) {
         undoable: true,
         run: (_ctx, params) => {
           layerIndex(params.nodeId, kind, params.index);
-          check(controller.removePaintLayer(kind, params.index, { ids: [params.nodeId] }));
+          check2(controller.removePaintLayer(kind, params.index, { ids: [params.nodeId] }));
           return stackResult(params.nodeId, kind);
         }
       },
@@ -14672,7 +15277,7 @@ function createVectorCommands(controller, options = {}) {
         undoable: true,
         run: (_ctx, params) => {
           layerIndex(params.nodeId, kind, params.index);
-          check(controller.movePaintLayer(kind, params.index, params.to, { ids: [params.nodeId] }));
+          check2(controller.movePaintLayer(kind, params.index, params.to, { ids: [params.nodeId] }));
           return stackResult(params.nodeId, kind);
         }
       }
@@ -14780,7 +15385,7 @@ function createVectorCommands(controller, options = {}) {
         if (params?.type === void 0 && params?.invert === void 0 && params?.enabled === void 0) fail("Pass at least one of type, invert, enabled.");
         const groups = maskTargets(params);
         const patch = { ...params?.type ? { type: params.type } : {}, ...params?.invert !== void 0 ? { invert: params.invert } : {}, ...params?.enabled !== void 0 ? { enabled: params.enabled } : {} };
-        check(controller.setMaskOptions(patch, { ids: groups }));
+        check2(controller.setMaskOptions(patch, { ids: groups }));
         return { groups: groups.map(maskResult) };
       }
     },
@@ -14829,7 +15434,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const targets = ids(params);
-        check(controller.setBlendMode(params.blendMode, { ids: targets }));
+        check2(controller.setBlendMode(params.blendMode, { ids: targets }));
         return { nodes: targets.map((id) => ({ id, blendMode: controller.getNode(id)?.blendMode ?? "normal" })) };
       }
     },
@@ -14883,7 +15488,7 @@ function createVectorCommands(controller, options = {}) {
         const filter = filterOf(params.nodeId, params.filterId);
         checkFilterParams(filter.type, params.params);
         if (params.params === void 0 && params.enabled === void 0) fail("Pass params or enabled.");
-        check(controller.updateFilter(params.nodeId, params.filterId, { params: params.params, enabled: params.enabled }));
+        check2(controller.updateFilter(params.nodeId, params.filterId, { params: params.params, enabled: params.enabled }));
         return filtersResult(params.nodeId);
       }
     },
@@ -14902,7 +15507,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         filterOf(params.nodeId, params.filterId);
-        check(controller.removeFilter(params.nodeId, params.filterId));
+        check2(controller.removeFilter(params.nodeId, params.filterId));
         return filtersResult(params.nodeId);
       }
     },
@@ -14925,7 +15530,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         filterOf(params.nodeId, params.filterId);
-        check(controller.moveFilter(params.nodeId, params.filterId, params.index));
+        check2(controller.moveFilter(params.nodeId, params.filterId, params.index));
         return filtersResult(params.nodeId);
       }
     }
@@ -15081,7 +15686,7 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.setText(params.id, params.text, { start: params.start, end: params.end }));
+        check2(controller.setText(params.id, params.text, { start: params.start, end: params.end }));
         return textSummary(params.id);
       }
     },
@@ -15102,7 +15707,7 @@ function createVectorCommands(controller, options = {}) {
         const patch = pick(params, [...Object.keys(FONT_PROPS), "fill"]);
         if (!Object.keys(patch).length) fail(`Pass at least one of ${[...Object.keys(FONT_PROPS), "fill"].join(", ")}.`);
         if (patch.fill !== void 0) patch.fill = checkPaint(patch.fill, "fill");
-        check(controller.setTextStyle(params.id, patch, { start: params.start, end: params.end }));
+        check2(controller.setTextStyle(params.id, patch, { start: params.start, end: params.end }));
         return textSummary(params.id);
       }
     },
@@ -15117,7 +15722,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const patch = pick(params, Object.keys(PARAGRAPH_PROPS));
         if (!Object.keys(patch).length) fail(`Pass at least one of ${Object.keys(PARAGRAPH_PROPS).join(", ")}.`);
-        check(controller.setParagraphStyle(params.id, patch));
+        check2(controller.setParagraphStyle(params.id, patch));
         return textSummary(params.id);
       }
     },
@@ -15146,7 +15751,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { id, ...patch } = params;
         if (!Object.keys(patch).length) fail("Pass kind or a frame field to change.");
-        check(controller.setTextFrame(id, patch));
+        check2(controller.setTextFrame(id, patch));
         return textSummary(id);
       }
     },
@@ -15178,7 +15783,7 @@ function createVectorCommands(controller, options = {}) {
           pathOptions: pick(params, Object.keys(PATH_TEXT_PROPS)),
           ...params.fill !== void 0 ? { fill: checkPaint(params.fill, "fill") } : {}
         });
-        check(r);
+        check2(r);
         return textSummary(r.id);
       }
     },
@@ -15194,7 +15799,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const r = controller.createOutlines({ ids: ids(params) });
-        check(r);
+        check2(r);
         return { ids: r.ids };
       }
     }
@@ -15251,7 +15856,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const r = controller.makeSymbol({ ids: ids(params), ...params?.name ? { name: params.name } : {} });
-        check(r);
+        check2(r);
         return { symbolId: r.symbolId, instanceId: r.instanceId, symbol: symbolSummary(r.symbolId) };
       }
     },
@@ -15282,7 +15887,7 @@ function createVectorCommands(controller, options = {}) {
           ...params.transform ? { transform: params.transform } : {},
           ...params.name ? { name: params.name } : {}
         });
-        check(r);
+        check2(r);
         return { id: r.id };
       }
     },
@@ -15314,7 +15919,7 @@ function createVectorCommands(controller, options = {}) {
         };
         if (!Object.keys(patch).length) fail("Pass at least one of scaleStrokes, fill, stroke, hidden.");
         const targetIds = ids(params);
-        check(controller.setInstanceOptions(patch, { ids: targetIds }));
+        check2(controller.setInstanceOptions(patch, { ids: targetIds }));
         const listed = list().nodes;
         return { instances: targetIds.map((id) => listed.find((n2) => n2.id === id)) };
       }
@@ -15329,7 +15934,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const targetIds = ids(params);
-        check(controller.replaceSymbol(params.symbolId, { ids: targetIds }));
+        check2(controller.replaceSymbol(params.symbolId, { ids: targetIds }));
         return { ids: targetIds };
       }
     },
@@ -15344,7 +15949,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const r = controller.detachInstances({ ids: ids(params) });
-        check(r);
+        check2(r);
         return { ids: r.ids };
       }
     },
@@ -15357,7 +15962,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { symbolId: { type: "string", description: "The symbol (from vector.listSymbols)." }, name: { type: "string", minLength: 1, description: "Its new name." } }, required: ["symbolId", "name"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.renameSymbol(params.symbolId, params.name));
+        check2(controller.renameSymbol(params.symbolId, params.name));
         return symbolSummary(params.symbolId);
       }
     },
@@ -15370,7 +15975,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { symbolId: { type: "string", description: "The symbol (from vector.listSymbols)." }, detach: { type: "boolean", description: "Turn its instances into groups first (default false: fail when it is used)." } }, required: ["symbolId"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.deleteSymbol(params.symbolId, { detach: params.detach }));
+        check2(controller.deleteSymbol(params.symbolId, { detach: params.detach }));
         return { ok: true };
       }
     },
@@ -15382,7 +15987,7 @@ function createVectorCommands(controller, options = {}) {
       description: "Enters isolation mode on a symbol (`id` of the symbol, or of one of its instances): the document then holds the symbol's art in its own space (registration point at 0, 0), so every vector.* command edits the art and every instance follows. Call vector.exitSymbolEdit when done. Not an undo step itself. Returns { symbolId, nodes } (vector.list for the art).",
       params: { type: "object", properties: { id: { type: "string", description: "A symbol id (vector.listSymbols) or an instance id (vector.list)." } }, required: ["id"], additionalProperties: false },
       run: (_ctx, params) => {
-        check(controller.editSymbol(params.id));
+        check2(controller.editSymbol(params.id));
         return { symbolId: controller.getState().symbolEdit.symbolId, nodes: list().nodes };
       }
     },
@@ -15473,7 +16078,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { ids: list2, ...patch } = params ?? {};
         if (!Object.keys(patch).length) fail("Pass at least one of mode, center, rotation, copies, mirror.");
-        check(controller.setSymmetry(patch, list2 ? { ids: list2 } : {}));
+        check2(controller.setSymmetry(patch, list2 ? { ids: list2 } : {}));
         const ids2 = list2 ?? controller.getState().selection.filter((id) => controller.getNode(id)?.type === "group");
         return { groups: ids2.filter((id) => controller.getNode(id)?.symmetry).map(symmetryResult) };
       }
@@ -15489,7 +16094,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const r = controller.releaseSymmetry({ ...params?.ids ? { ids: params.ids } : {}, ...params?.expand ? { expand: true } : {} });
-        check(r);
+        check2(r);
         return { ids: r.ids ?? [] };
       }
     },
@@ -15501,7 +16106,7 @@ function createVectorCommands(controller, options = {}) {
       description: "Hands the canvas to the user drawing inside a top-level symmetry group: new pen, pencil, shape and text art goes into it, mirrored as it is drawn, until vector.exitSymmetry or Escape. Returns { id }.",
       params: { type: "object", properties: { id: { type: "string", description: "The symmetry group." } }, required: ["id"], additionalProperties: false },
       run: (_ctx, params) => {
-        check(controller.enterSymmetry(params.id));
+        check2(controller.enterSymmetry(params.id));
         return { id: params.id };
       }
     },
@@ -15542,7 +16147,7 @@ function createVectorCommands(controller, options = {}) {
         const { ids: list2, ...patch } = params ?? {};
         if (!Object.keys(patch).length) fail("Pass at least one of type, amount, color.");
         const r = controller.setLens(patch, list2 ? { ids: list2 } : {});
-        check(r);
+        check2(r);
         return { lenses: r.lenses ?? [] };
       }
     },
@@ -15557,11 +16162,43 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const r = controller.setLens(null, params?.ids ? { ids: params.ids } : {});
-        check(r);
+        check2(r);
         return { ids: (r.lenses ?? []).map((l) => l.id) };
       }
     }
   ];
+  const BRUSH_PROPS = {
+    ids: { ...IDS, description: "Paths to distort (default: the selection, else every path the brush reaches)." },
+    radius: { type: "number", exclusiveMinimum: 0, description: "Brush radius, document units (default: the distortSize setting, 20)." },
+    strength: { type: "number", minimum: 0, maximum: 1, description: "Strength at the brush centre, 0\u20131, fading to 0 at the rim (default: the distortStrength setting, 0.5)." }
+  };
+  const brushRun = (mode) => (_ctx, params) => {
+    const { points, ids: list2, ...rest } = params;
+    const r = controller.distortBrush(
+      mode,
+      points.map(([x, y]) => ({ x, y })),
+      { ...rest, ...list2 ? { ids: list2 } : {} }
+    );
+    check2(r);
+    return { ids: r.ids ?? [] };
+  };
+  const brush = (mode, label2, keywords, description, extra = {}, minPoints = 1) => ({
+    ...base,
+    id: `${prefix}${mode}Brush`,
+    label: label2,
+    keywords: ["distort", "brush", "corel", ...keywords],
+    description: `${description} One undo step. Returns { ids } of the changed paths; fails, changing nothing, when the brush reaches no outline.`,
+    params: { type: "object", properties: { points: { ...POINTS, minItems: minPoints, description: minPoints > 1 ? "The brush stroke [[x, y], \u2026] in document units: at least two points." : "Where the brush dabs [[x, y], \u2026], document units: one dab per point." }, ...BRUSH_PROPS, ...extra }, required: ["points"], additionalProperties: false },
+    undoable: true,
+    run: brushRun(mode)
+  });
+  const distortCommands = () => [
+    brush("smudge", "Smudge Brush\u2026", ["smudge", "push", "drag", "liquify"], "Smudges outlines along a stroke: what is under the brush is pushed the way it moves, most at its centre (CorelDRAW's Smudge).", {}, 2),
+    brush("twirl", "Twirl Brush\u2026", ["twirl", "swirl", "spiral", "twist"], "Twirls the outlines under the brush about each point (CorelDRAW's Twirl).", { angle: { type: "number", description: "Degrees turned at the brush centre per point, clockwise on screen; negative turns the other way (default 15)." } }),
+    brush("attract", "Attract Brush\u2026", ["attract", "pinch", "pull", "pucker"], "Pulls the outlines under the brush toward each point (CorelDRAW's Attract)."),
+    brush("repel", "Repel Brush\u2026", ["repel", "bloat", "push out", "inflate"], "Pushes the outlines under the brush away from each point (CorelDRAW's Repel)."),
+    brush("roughen", "Roughen Brush\u2026", ["roughen", "jagged", "spiky", "fur", "grass"], "Breaks the outlines under the brush into spikes (CorelDRAW's Roughen): use for fur, grass and torn edges.", { seed: { type: "integer", description: "Seed of the spikes (default 1): the same seed gives the same spikes." } })
+  ];
   const PLANE = { type: "string", enum: [...VECTOR_PERSPECTIVE_PLANES], description: "A plane of the grid: floor, left and right (2 or 3 vanishing points), or floor, side and front (1 point)." };
   const perspectiveResult = () => {
     const grid = controller.getPerspective();
@@ -15597,7 +16234,7 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.setPerspective(params));
+        check2(controller.setPerspective(params));
         return perspectiveResult();
       }
     },
@@ -15610,7 +16247,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: {}, additionalProperties: false },
       undoable: true,
       run: () => {
-        check(controller.setPerspective(null));
+        check2(controller.setPerspective(null));
         return { perspective: null };
       }
     },
@@ -15622,7 +16259,7 @@ function createVectorCommands(controller, options = {}) {
       description: "Makes the Rectangle, Ellipse, Polygon and Star tools draw on a plane of the grid (their drag box is taken on the plane, so shapes recede with it), or flat again with plane null. Not an undo step. Returns the grid as vector.getPerspective does.",
       params: { type: "object", properties: { plane: { ...PLANE, type: ["string", "null"], enum: [...VECTOR_PERSPECTIVE_PLANES, null], description: `${PLANE.description} null draws flat.` } }, required: ["plane"], additionalProperties: false },
       run: (_ctx, params) => {
-        check(controller.setPerspectivePlane(params.plane));
+        check2(controller.setPerspectivePlane(params.plane));
         return perspectiveResult();
       }
     },
@@ -15637,11 +16274,90 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const r = controller.attachToPerspective(params.plane, params.ids ? { ids: params.ids } : {});
-        check(r);
+        check2(r);
         return { ids: r.ids ?? [] };
       }
     }
   ];
+  const brushstrokeCommands = () => [
+    {
+      ...base,
+      id: `${prefix}listBrushes`,
+      label: "Brushstroke Brushes",
+      readOnly: true,
+      keywords: ["brush", "brushstroke", "pencil", "pastel", "charcoal", "ink", "marker", "natural media"],
+      description: "Lists the brushes a brushstroke can use (the paint editor's dry brushes): { brushes: [{ id, name, category, size }] } (size: the brush's own diameter in document units).",
+      params: { type: "object", properties: {}, additionalProperties: false },
+      run: () => ({ brushes: vectorBrushstrokeBrushes().map((b) => ({ id: b.id, name: b.name, category: b.category, size: b.tip.size })) })
+    },
+    {
+      ...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`. 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: {
+          ids: { ...IDS, description: "Paths or groups (default: the selection)." },
+          brushId: { type: "string", description: 'Brush id from vector.listBrushes, e.g. "pencil-hb".' },
+          size: { type: "number", exclusiveMinimum: 0, maximum: 500, description: "Brush diameter in document units (default: the brush's own)." },
+          pressure: { type: "array", items: { type: "number", minimum: 0, maximum: 1 }, minItems: 1, maxItems: 64, description: "Pressure 0\u20131 along the length, spread evenly from start to end (default: full pressure)." },
+          color: { type: "string", description: "CSS colour (default: the path's stroke colour, else black)." },
+          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)." }
+        },
+        required: ["brushId"],
+        additionalProperties: false
+      },
+      undoable: true,
+      enabled: enabledFor,
+      run: (_ctx, params) => {
+        const targets = params.ids ?? controller.getState().selection;
+        check2(
+          controller.addBrushstroke(
+            { brushId: params.brushId, ...params.size !== void 0 ? { size: params.size } : {}, ...params.pressure ? { pressure: params.pressure } : {} },
+            { ...params.ids ? { ids: params.ids } : {}, ...params.index !== void 0 ? { index: params.index } : {}, ...params.color ? { color: params.color } : {}, ...params.opacity !== void 0 ? { opacity: params.opacity } : {} }
+          )
+        );
+        const paths = [];
+        for (const id of targets) {
+          const n2 = controller.getNode(id);
+          if (n2?.type === "path") paths.push(stackResult(id, "stroke"));
+        }
+        return { paths };
+      }
+    },
+    {
+      ...base,
+      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`, `size` (null: the brush's own), `pressure` (null: full pressure), `color`, `opacity`. Pass at least one. One undo step. Returns { id, strokes }.",
+      params: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "The path." },
+          index: { type: "integer", minimum: 0, description: "Stroke layer index of the brushstroke." },
+          brushId: { type: "string", description: "Another brush from vector.listBrushes." },
+          size: { type: ["number", "null"], description: "Diameter in document units, or null for the brush's own." },
+          pressure: { type: ["array", "null"], items: { type: "number", minimum: 0, maximum: 1 }, description: "Pressure profile 0\u20131 from start to end, or null for full pressure." },
+          color: { type: "string", description: "CSS colour." },
+          opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0\u20131." }
+        },
+        required: ["id", "index"],
+        additionalProperties: false
+      },
+      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.");
+        layerIndex(id, "stroke", index);
+        check2(controller.setBrushstroke(index, patch, { ids: [id] }));
+        return stackResult(id, "stroke");
+      }
+    }
+  ];
   const pdfCommands = () => [
     {
       ...base,
@@ -15710,7 +16426,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const r = controller.importLottie(params.lottie, { ...params.frame !== void 0 ? { frame: params.frame } : {}, ...params.replace ? { replace: true } : {} });
-        check(r);
+        check2(r);
         return { ids: r.ids, notes: r.notes };
       }
     }
@@ -15754,7 +16470,7 @@ function createVectorCommands(controller, options = {}) {
           return fail(`The PNG could not be read: ${e.message}`);
         }
         const r = controller.traceImage(decoded, options2);
-        check(r);
+        check2(r);
         return {
           id: r.id,
           paths: r.ids.map((id) => {
@@ -15765,6 +16481,70 @@ function createVectorCommands(controller, options = {}) {
       }
     }
   ];
+  const IMAGE_PLACE = {
+    image: { type: "string", description: "The picture as a data:image/png;base64,\u2026 URL (up to 4 million pixels)." },
+    x: { type: "number", description: "Left edge in document units (default 0)." },
+    y: { type: "number", description: "Top edge in document units (default 0)." },
+    width: { type: "number", exclusiveMinimum: 0, description: "Width in document units (default: the image width in pixels)." },
+    name: { type: "string", description: "Group name (default: the style's name)." }
+  };
+  const decodeImage = (image) => {
+    const parsed = parseDataUrl(image);
+    if (!parsed || !isPng(parsed.bytes)) fail("image must be a PNG data URL (data:image/png;base64,\u2026).");
+    try {
+      return decodePng(parsed.bytes, { maxPixels: VECTOR_TRACE_MAX_PIXELS });
+    } catch (e) {
+      return fail(`The PNG could not be read: ${e.message}`);
+    }
+  };
+  const stylize = (style, label2, keywords, description, props) => ({
+    ...base,
+    id: `${prefix}${style}Image`,
+    label: label2,
+    keywords: ["stylize", "stylise", "bitmap to vector", "artistic", "png to svg", ...keywords],
+    description: `${description} Added as one group placed with its top-left at x, y and width wide; colours of one kind share a compound path. One undo step. Returns { id, paths: [{ id, name, fill, subpaths }] }.`,
+    params: { type: "object", properties: { ...IMAGE_PLACE, ...props }, required: ["image"], additionalProperties: false },
+    undoable: true,
+    run: (_ctx, params) => {
+      const { image, ...options2 } = params;
+      const r = controller.stylizeImage(decodeImage(image), style, options2);
+      check2(r);
+      return {
+        id: r.id,
+        paths: r.ids.map((id) => {
+          const n2 = controller.getNode(id);
+          return { id, name: n2.name, fill: n2.fill, subpaths: n2.subpaths.length };
+        })
+      };
+    }
+  });
+  const CELL = (dflt, what) => ({ type: "number", minimum: 1, description: `${what} in image pixels (default ${dflt}); larger draws fewer, bigger shapes.` });
+  const PALETTE = (dflt) => ({ type: "integer", minimum: 2, maximum: 32, description: `Palette size (default ${dflt}).` });
+  const stylizeCommands = () => [
+    stylize("mosaic", "Mosaic from Image\u2026", ["mosaic", "tiles", "pixelate", "pixel art"], "Turns a PNG into mosaic tiles: a square or round tile per cell in the colour under it.", {
+      cell: CELL(12, "Tile size"),
+      shape: { type: "string", enum: ["square", "circle"], description: "Tile shape (default square)." },
+      gap: { type: "number", minimum: 0, maximum: 0.9, description: "Grout between tiles as a fraction of the tile (default 0.1)." },
+      colors: PALETTE(12)
+    }),
+    stylize("halftone", "Halftone from Image\u2026", ["halftone", "dots", "comic", "pop art", "screen print"], "Turns a PNG into halftone dots on a turned grid, each dot's area following how dark the picture is there.", {
+      cell: CELL(8, "Dot spacing"),
+      angle: { type: "number", description: "Screen angle in degrees (default 45)." },
+      color: { type: ["string", "null"], description: "Ink colour (default black); null keeps the picture's colours, reduced to `colors`." },
+      colors: PALETTE(12)
+    }),
+    stylize("lowPoly", "Low Poly from Image\u2026", ["low poly", "triangles", "polygon art", "geometric", "faceted"], "Turns a PNG into low-poly art: a jittered grid of triangles, each in the colour under it.", {
+      cell: CELL(24, "Triangle size"),
+      jitter: { type: "number", minimum: 0, maximum: 0.5, description: "How far the grid points wander, as a fraction of a cell (default 0.35)." },
+      seed: { type: "integer", description: "Seed of the wandering (default 1): the same seed gives the same triangles." },
+      colors: PALETTE(16)
+    }),
+    stylize("hatch", "Engraving from Image\u2026", ["engraving", "hatch", "hatching", "line art", "woodcut", "banknote"], "Turns a PNG into an engraving: parallel lines on a turned grid that swell where the picture is dark and break where it is light.", {
+      cell: CELL(6, "Line spacing"),
+      angle: { type: "number", description: "Line angle in degrees (default 45)." },
+      color: { type: "string", description: "Ink colour (default black)." }
+    })
+  ];
   const shadingResult = (id) => ({ id, shading: controller.getShading(id) ?? fail(`"${id}" has no mesh or freeform fill.`) });
   const COLOR = { type: "string", description: "A CSS colour." };
   const FREEFORM_POINT = {
@@ -15813,7 +16593,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const list2 = ids(params);
-        check(controller.setMeshGradient({ rows: params.rows, columns: params.columns, ...params.colors ? { colors: params.colors } : {}, ...params.corners ? { corners: params.corners } : {} }, { ids: list2 }));
+        check2(controller.setMeshGradient({ rows: params.rows, columns: params.columns, ...params.colors ? { colors: params.colors } : {}, ...params.corners ? { corners: params.corners } : {} }, { ids: list2 }));
         return { meshes: list2.map(shadingResult) };
       }
     },
@@ -15840,7 +16620,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { id, index, ...patch } = params;
         if (!Object.keys(patch).length) fail("Pass at least one of x / y, color, opacity.");
-        check(controller.setMeshPoint(id, index, patch));
+        check2(controller.setMeshPoint(id, index, patch));
         return shadingResult(id);
       }
     },
@@ -15865,7 +16645,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { ids: _i, ...input } = params ?? {};
         const list2 = ids(params);
-        check(controller.setFreeformGradient(input, { ids: list2 }));
+        check2(controller.setFreeformGradient(input, { ids: list2 }));
         return { gradients: list2.map(shadingResult) };
       }
     },
@@ -15885,7 +16665,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { id, ...point } = params;
         const r = controller.addFreeformPoint(id, point);
-        check(r);
+        check2(r);
         return { ...shadingResult(id), index: r.index };
       }
     },
@@ -15913,7 +16693,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { id, index, ...patch } = params;
         if (!Object.keys(patch).length) fail("Pass at least one of x / y, color, opacity, spread.");
-        check(controller.setFreeformPoint(id, index, patch));
+        check2(controller.setFreeformPoint(id, index, patch));
         return shadingResult(id);
       }
     },
@@ -15926,7 +16706,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { id: { type: "string", description: "The path." }, index: { type: "integer", minimum: 0, description: "Point index." } }, required: ["id", "index"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeFreeformPoint(params.id, params.index));
+        check2(controller.removeFreeformPoint(params.id, params.index));
         return shadingResult(params.id);
       }
     },
@@ -15939,7 +16719,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { id: { type: "string", description: "The path." }, lines: LINES }, required: ["id", "lines"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.setFreeformLines(params.id, params.lines));
+        check2(controller.setFreeformLines(params.id, params.lines));
         return shadingResult(params.id);
       }
     }
@@ -16115,7 +16895,7 @@ function createVectorCommands(controller, options = {}) {
         const { ids: list2, ...patch } = params ?? {};
         if (!Object.keys(patch).length) fail("Pass at least one of start, end, route, radius, gap.");
         const targets = ids({ ids: list2 });
-        check(controller.setConnector(patch, { ids: targets }));
+        check2(controller.setConnector(patch, { ids: targets }));
         return { connectors: targets.map(connectorResult) };
       }
     }
@@ -16151,7 +16931,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const r = controller.addPage(params ?? {});
-        check(r);
+        check2(r);
         return { id: r.id, ...pagesResult() };
       }
     },
@@ -16172,7 +16952,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const r = controller.addMasterPage(params ?? {});
-        check(r);
+        check2(r);
         return { id: r.id, ...pagesResult() };
       }
     },
@@ -16185,7 +16965,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: { ...IDS, description: "Page ids (default: the selected pages)." }, masterId: { type: ["string", "null"], description: "Master page id, or null for none." } }, required: ["masterId"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.setPageMaster(params.masterId, params.ids ? { ids: params.ids } : {}));
+        check2(controller.setPageMaster(params.masterId, params.ids ? { ids: params.ids } : {}));
         return pagesResult();
       }
     },
@@ -16198,7 +16978,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { id: { type: "string", description: "The page." }, index: { type: "integer", minimum: 0, description: "New position, 0 for first." } }, required: ["id", "index"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.movePage(params.id, params.index));
+        check2(controller.movePage(params.id, params.index));
         return pagesResult();
       }
     },
@@ -16220,7 +17000,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const size = params.canvasWidth && params.canvasHeight ? { width: params.canvasWidth, height: params.canvasHeight } : void 0;
-        check(controller.goToPage(params.id, size ? { size } : {}));
+        check2(controller.goToPage(params.id, size ? { size } : {}));
         return { id: params.id };
       }
     }
@@ -16314,7 +17094,7 @@ function createVectorCommands(controller, options = {}) {
         const { ids: list2, ...patch } = params ?? {};
         if (!Object.keys(patch).length) fail("Pass at least one of x, y, width, height, fill, clip.");
         const before = new Set(controller.getFrames().map((f) => f.id));
-        check(controller.setFrame(patch, list2 ? { ids: list2 } : {}));
+        check2(controller.setFrame(patch, list2 ? { ids: list2 } : {}));
         const targets = list2 ?? controller.getFrames().filter((f) => before.has(f.id) && (controller.getState().selection.includes(f.id) || f.children.some((c) => controller.getState().selection.includes(c.id)))).map((f) => f.id);
         return { frames: targets.map(frameResult) };
       }
@@ -16338,7 +17118,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const list2 = ids(params);
-        check(controller.setResizing({ ...params?.horizontal ? { horizontal: params.horizontal } : {}, ...params?.vertical ? { vertical: params.vertical } : {} }, { ids: list2 }));
+        check2(controller.setResizing({ ...params?.horizontal ? { horizontal: params.horizontal } : {}, ...params?.vertical ? { vertical: params.vertical } : {} }, { ids: list2 }));
         return { nodes: list2.map((id) => ({ id, horizontal: controller.getNode(id)?.resizing?.horizontal ?? "left", vertical: controller.getNode(id)?.resizing?.vertical ?? "top" })) };
       }
     },
@@ -16397,7 +17177,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const r = controller.addConstraint(params);
-        check(r);
+        check2(r);
         return { id: r.id, constraint: controller.getConstraints().find((c) => c.id === r.id) };
       }
     },
@@ -16410,7 +17190,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: { type: "array", items: { type: "string" }, minItems: 1, description: "Constraint ids." } }, required: ["ids"], additionalProperties: false },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeConstraints(params.ids));
+        check2(controller.removeConstraints(params.ids));
         return { ids: params.ids };
       }
     },
@@ -16431,7 +17211,7 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.setConstraintValue(params.key, params.value));
+        check2(controller.setConstraintValue(params.key, params.value));
         return constraintsSummary();
       }
     },
@@ -16454,7 +17234,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const r = controller.autoConstrain(params ?? {});
-        check(r);
+        check2(r);
         return { ids: r.ids };
       }
     }
@@ -16544,7 +17324,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const style = pickStyle(params);
         if (!Object.keys(style).length) fail("Pass at least one style property.");
-        check(controller.setStyle(style, ids(params)));
+        check2(controller.setStyle(style, ids(params)));
         return { ok: true };
       }
     },
@@ -16561,7 +17341,7 @@ function createVectorCommands(controller, options = {}) {
         const { ids: _i, target, ...patch } = params ?? {};
         if (patch.type !== void 0 && !VECTOR_GRADIENT_TYPES.includes(patch.type)) fail(`Unknown gradient type "${patch.type}".`);
         if (patch.stops !== void 0 && !(Array.isArray(patch.stops) && patch.stops.length)) fail("stops needs at least one { offset, color }.");
-        check(controller.setGradient(patch, { ids: ids(params), target: target ?? "fill" }));
+        check2(controller.setGradient(patch, { ids: ids(params), target: target ?? "fill" }));
         const id = ids(params)[0];
         const node = id ? controller.getNode(id) : void 0;
         const path = node?.type === "path" ? node : void 0;
@@ -16582,6 +17362,8 @@ function createVectorCommands(controller, options = {}) {
     ...lottieCommands(),
     ...pdfCommands(),
     ...symmetryCommands(),
+    ...brushstrokeCommands(),
+    ...stylizeCommands(),
     ...perspectiveCommands(),
     ...lensCommands(),
     {
@@ -16604,9 +17386,9 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const refs = params?.anchors ? anchorsOf(params.anchors) : void 0;
         const target = { refs, ids: params?.ids ? ids(params) : void 0 };
-        if (params?.radius !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind, ...params.smoothing !== void 0 ? { smoothing: params.smoothing } : {} }));
-        else if (params?.kind) check(controller.setCornerKind(params.kind, target));
-        if (params?.radius === void 0 && params?.smoothing !== void 0) check(controller.setCornerSmoothing(params.smoothing, target));
+        if (params?.radius !== void 0) check2(controller.setCornerRadius(params.radius, { ...target, kind: params.kind, ...params.smoothing !== void 0 ? { smoothing: params.smoothing } : {} }));
+        else if (params?.kind) check2(controller.setCornerKind(params.kind, target));
+        if (params?.radius === void 0 && params?.smoothing !== void 0) check2(controller.setCornerSmoothing(params.smoothing, target));
         if (params?.radius === void 0 && !params?.kind && params?.smoothing === void 0) fail("Pass `radius`, `kind` and / or `smoothing`.");
         return { ok: true };
       }
@@ -16641,9 +17423,9 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (params?.preset) check(controller.setWidthProfile(params.preset, target));
-        else if (params?.points !== void 0) check(controller.setWidthProfile(params.points ?? null, target));
-        else if (params?.taper || params?.wave) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (params?.preset) check2(controller.setWidthProfile(params.preset, target));
+        else if (params?.points !== void 0) check2(controller.setWidthProfile(params.points ?? null, target));
+        else if (params?.taper || params?.wave) check2(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
         else fail("Pass `preset`, `points`, `taper` or `wave`.");
         const node = controller.getNode(target.ids[0]);
         return { ok: true, points: node?.type === "path" ? node.strokeWidthProfile ?? [] : [] };
@@ -16669,7 +17451,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         if (!params?.id) fail("Pass the path `id`.");
-        check(controller.setWidthPoint({ nodeId: params.id, index: params.index ?? null }, { t: params.t, left: params.left, right: params.right }));
+        check2(controller.setWidthPoint({ nodeId: params.id, index: params.index ?? null }, { t: params.t, left: params.left, right: params.right }));
         const node = controller.getNode(params.id);
         return { ok: true, points: node?.type === "path" ? node.strokeWidthProfile ?? [] : [] };
       }
@@ -16707,7 +17489,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.distort(params.corners, { ids: ids(params), tolerance: params.tolerance }));
+        check2(controller.distort(params.corners, { ids: ids(params), tolerance: params.tolerance }));
         const frame = controller.getState().selectionFrame;
         return { ok: true, bounds: frame ? { x: frame.x, y: frame.y, width: frame.width, height: frame.height } : null };
       }
@@ -16730,7 +17512,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.skew(params.ax ?? 0, params.ay ?? 0, { ids: ids(params), origin: params.origin }));
+        check2(controller.skew(params.ax ?? 0, params.ay ?? 0, { ids: ids(params), origin: params.origin }));
         return { ok: true };
       }
     },
@@ -16770,7 +17552,7 @@ function createVectorCommands(controller, options = {}) {
         if (params.expand) return { expanded: controller.expandAppearance({ ids: target }) };
         if (params.topObject) {
           const r = controller.makeEnvelopeWithTopObject({ ids: target, rows: params.mesh?.rows, columns: params.mesh?.columns });
-          check(r);
+          check2(r);
           return { nodeId: r.nodeId };
         }
         if (params.preset !== void 0 && !WARP_STYLES.includes(params.preset)) fail(`Unknown warp preset "${params.preset}".`);
@@ -16819,10 +17601,10 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = ids(params);
-        if (params.dx || params.dy) check(controller.translate(params.dx ?? 0, params.dy ?? 0, { ids: target }));
-        if (params.sx !== void 0 || params.sy !== void 0) check(controller.scale(params.sx ?? 1, params.sy ?? params.sx ?? 1, { ids: target }));
-        if (params.rotate) check(controller.rotate(params.rotate, { ids: target }));
-        if (params.angle !== void 0) check(controller.setRotation(params.angle, { ids: target }));
+        if (params.dx || params.dy) check2(controller.translate(params.dx ?? 0, params.dy ?? 0, { ids: target }));
+        if (params.sx !== void 0 || params.sy !== void 0) check2(controller.scale(params.sx ?? 1, params.sy ?? params.sx ?? 1, { ids: target }));
+        if (params.rotate) check2(controller.rotate(params.rotate, { ids: target }));
+        if (params.angle !== void 0) check2(controller.setRotation(params.angle, { ids: target }));
         return { ok: true };
       }
     },
@@ -16836,7 +17618,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeNodes(ids(params)));
+        check2(controller.removeNodes(ids(params)));
         return { ok: true };
       }
     },
@@ -16907,8 +17689,8 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        if (params.params !== void 0 || params.enabled !== void 0) check(controller.updateEffect(params.nodeId, params.effectId, { params: params.params, enabled: params.enabled }));
-        if (params.index !== void 0) check(controller.moveEffect(params.nodeId, params.effectId, params.index));
+        if (params.params !== void 0 || params.enabled !== void 0) check2(controller.updateEffect(params.nodeId, params.effectId, { params: params.params, enabled: params.enabled }));
+        if (params.index !== void 0) check2(controller.moveEffect(params.nodeId, params.effectId, params.index));
         return { effects: controller.getNode(params.nodeId)?.effects ?? [] };
       }
     },
@@ -16921,7 +17703,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { nodeId: { type: "string" }, effectId: { type: "string" } }, required: ["nodeId", "effectId"] },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeEffect(params.nodeId, params.effectId));
+        check2(controller.removeEffect(params.nodeId, params.effectId));
         return { ok: true };
       }
     },
@@ -17058,7 +17840,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const result = controller.shapeBuilder(params.points.map(([x, y]) => ({ x, y })), { ids: ids(params), erase: params.erase, tolerance: params.tolerance });
-        check(result);
+        check2(result);
         return { merged: result.merged, faces: result.faces, lines: result.lines, edges: result.edges };
       }
     },
@@ -17089,7 +17871,7 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.align(params.edge, { ids: ids(params), to: params.to }));
+        check2(controller.align(params.edge, { ids: ids(params), to: params.to }));
         return { ok: true };
       }
     },
@@ -17102,7 +17884,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { direction: { type: "string", enum: ["horizontal", "vertical"] }, ids: IDS }, required: ["direction"] },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.distribute(params.direction, { ids: ids(params) }));
+        check2(controller.distribute(params.direction, { ids: ids(params) }));
         return { ok: true };
       }
     },
@@ -17115,7 +17897,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { order: { type: "string", enum: ["front", "forward", "backward", "back"] }, ids: IDS }, required: ["order"] },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.arrange(params.order, { ids: ids(params) }));
+        check2(controller.arrange(params.order, { ids: ids(params) }));
         return { ok: true };
       }
     },
@@ -17144,7 +17926,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.ungroup({ ids: ids(params) }));
+        check2(controller.ungroup({ ids: ids(params) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -17157,7 +17939,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { anchors: ANCHORS, keepShape: { type: "boolean" } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.deleteAnchors(anchorsOf(params?.anchors), { keepShape: params?.keepShape }));
+        check2(controller.deleteAnchors(anchorsOf(params?.anchors), { keepShape: params?.keepShape }));
         return { ok: true };
       }
     },
@@ -17174,7 +17956,7 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.moveAnchor({ nodeId: params.nodeId, subpath: params.subpath, index: params.index }, { x: params.x, y: params.y }, { curvature: params.curvature }));
+        check2(controller.moveAnchor({ nodeId: params.nodeId, subpath: params.subpath, index: params.index }, { x: params.x, y: params.y }, { curvature: params.curvature }));
         return { ok: true };
       }
     },
@@ -17198,7 +17980,7 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.bendSegment({ nodeId: params.nodeId, subpath: params.subpath, segment: params.segment }, { x: params.x, y: params.y }, params.t));
+        check2(controller.bendSegment({ nodeId: params.nodeId, subpath: params.subpath, segment: params.segment }, { x: params.x, y: params.y }, params.t));
         return { ok: true };
       }
     },
@@ -17212,7 +17994,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, tolerance: { type: "number", minimum: 0 } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.joinPaths({ ids: params?.ids ? ids(params) : void 0, tolerance: params?.tolerance }));
+        check2(controller.joinPaths({ ids: params?.ids ? ids(params) : void 0, tolerance: params?.tolerance }));
         return { selection: controller.getState().selection };
       }
     },
@@ -17226,7 +18008,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { axis: { type: "string", enum: ["horizontal", "vertical", "both"] }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.averageAnchors(params?.axis ?? "both", anchorsOf(params?.anchors)));
+        check2(controller.averageAnchors(params?.axis ?? "both", anchorsOf(params?.anchors)));
         return { ok: true };
       }
     },
@@ -17240,7 +18022,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: params?.ids ? ids(params) : void 0, tolerance: params?.tolerance }));
+        check2(controller.removeRedundantPoints({ ids: params?.ids ? ids(params) : void 0, tolerance: params?.tolerance }));
         return { ok: true };
       }
     },
@@ -17253,7 +18035,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, amount: { type: "number", minimum: 0, maximum: 1 }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.smoothPaths({ ids: params?.ids ? ids(params) : void 0, amount: params?.amount, refs: params?.anchors }));
+        check2(controller.smoothPaths({ ids: params?.ids ? ids(params) : void 0, amount: params?.amount, refs: params?.anchors }));
         return { ok: true };
       }
     },
@@ -17273,7 +18055,7 @@ function createVectorCommands(controller, options = {}) {
           if (!created) fail("Nothing to cut there (the end of an open path, or a locked path).");
           return { ids: created };
         }
-        check(controller.cutAtAnchors(anchorsOf(params?.anchors)));
+        check2(controller.cutAtAnchors(anchorsOf(params?.anchors)));
         return { ids: controller.getState().selection };
       }
     },
@@ -17305,12 +18087,13 @@ function createVectorCommands(controller, options = {}) {
         return { ids: changed.filter((id) => controller.getNode(id)) };
       }
     },
+    ...distortCommands(),
     {
       ...base,
       id: `${prefix}setEditing`,
       label: "Path Editing Options\u2026",
       keywords: ["settings", "curvature", "pencil", "smoothing", "lazy mouse", "shapes", "eraser"],
-      description: "Sets how editing behaves: `keepShapeOnDelete`, `curvatureMoves` (anchor drags bend like the Curvature tool), `pencilSmoothing` (lazy mouse, 0\u20131), `recognizeShapes` (pencil scribbles become lines, rectangles, ellipses, polygons), `eraserSize` and `pencilPressure` (`pen`: record pen pressure on pencil strokes as a width profile, `all`: any pointer reporting pressure, `off`).",
+      description: "Sets how editing behaves: `keepShapeOnDelete`, `curvatureMoves` (anchor drags bend like the Curvature tool), `pencilSmoothing` (lazy mouse, 0\u20131), `recognizeShapes` (pencil scribbles become lines, rectangles, ellipses, polygons), `eraserSize`, the Distort Brush settings `distortMode` (smudge, twirl, attract, repel, roughen), `distortSize` (radius) and `distortStrength` (0\u20131), and `pencilPressure` (`pen`: record pen pressure on pencil strokes as a width profile, `all`: any pointer reporting pressure, `off`).",
       params: {
         type: "object",
         properties: {
@@ -17319,12 +18102,15 @@ function createVectorCommands(controller, options = {}) {
           pencilSmoothing: { type: "number", minimum: 0, maximum: 1 },
           recognizeShapes: { type: "boolean" },
           eraserSize: { type: "number", exclusiveMinimum: 0 },
-          pencilPressure: { type: "string", enum: ["pen", "all", "off"] }
+          pencilPressure: { type: "string", enum: ["pen", "all", "off"] },
+          distortMode: { type: "string", enum: [...VECTOR_DISTORT_BRUSH_MODES], description: "What the Distort Brush tool does when the user drags it." },
+          distortSize: { type: "number", exclusiveMinimum: 0, description: "Distort Brush radius, document units." },
+          distortStrength: { type: "number", minimum: 0, maximum: 1, description: "Distort Brush strength, 0\u20131." }
         }
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (params?.[key] !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure", "distortMode", "distortSize", "distortStrength"]) if (params?.[key] !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -17360,13 +18146,227 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { svg: { type: "string" }, replace: { type: "boolean" } }, required: ["svg"] },
       undoable: true,
       run: (_ctx, params) => {
-        check(params.replace ? controller.loadSvg(params.svg) : controller.importSvg(params.svg));
+        check2(params.replace ? controller.loadSvg(params.svg) : controller.importSvg(params.svg));
         return { nodes: controller.getState().document.nodes.length, selection: controller.getState().selection };
       }
     }
   ];
 }
 
+// src/vector/generate.ts
+var VECTOR_GENERATED_IMAGE_AS = ["color", "threshold", ...VECTOR_STYLIZE_STYLES];
+function vectorArtModels(models) {
+  return models.filter((m) => m.media === "image" || m.media === "text");
+}
+var listModels = (o) => vectorArtModels(typeof o.models === "function" ? o.models() : o.models);
+function artNodes(art, as, colors) {
+  if (!art || typeof art !== "object") return "The generator returned nothing usable (expected { svg }, { image } or { png }).";
+  if ("svg" in art && typeof art.svg === "string") {
+    let doc;
+    try {
+      doc = parseVectorSvg(art.svg);
+    } catch (e) {
+      return `The generated SVG could not be read: ${e.message}`;
+    }
+    if (!doc.nodes.length) return "The generated SVG has no shapes the editor can read.";
+    const drawn = unionBounds(doc.nodes.map((n2) => vectorNodeBounds(n2)));
+    const box = doc.width > 0 && doc.height > 0 ? { x: 0, y: 0, width: doc.width, height: doc.height } : drawn;
+    return box ? { nodes: doc.nodes, box } : "The generated SVG is empty.";
+  }
+  let pixels = null;
+  if ("image" in art) pixels = art.image;
+  else if ("png" in art && typeof art.png === "string") {
+    const parsed = parseDataUrl(art.png);
+    if (!parsed || !isPng(parsed.bytes)) return "The generated image is not a PNG data URL.";
+    try {
+      pixels = decodePng(parsed.bytes, { maxPixels: VECTOR_TRACE_MAX_PIXELS });
+    } catch (e) {
+      return `The generated PNG could not be read: ${e.message}`;
+    }
+  }
+  if (!pixels) return "The generator returned nothing usable (expected { svg }, { image } or { png }).";
+  let nodes;
+  try {
+    nodes = as === "color" || as === "threshold" ? traceVectorImage(pixels, { mode: as, colors }) : stylizeVectorImage(pixels, as, { colors });
+  } catch (e) {
+    return e.message;
+  }
+  if (!nodes.length) return "The generated image had nothing to trace (try another `as`).";
+  return { nodes, box: { x: 0, y: 0, width: pixels.width, height: pixels.height } };
+}
+function fitted(nodes, box, target) {
+  const k = Math.min(target.width / (box.width || 1), target.height / (box.height || 1));
+  const dx = target.x + (target.width - box.width * k) / 2 - box.x * k;
+  const dy = target.y + (target.height - box.height * k) / 2 - box.y * k;
+  return nodes.map((n2) => transformVectorNode(n2, [k, 0, 0, k, dx, dy]));
+}
+function ratioOf(w, h) {
+  const g = (a2, b2) => b2 < 1 ? a2 : g(b2, a2 % b2);
+  const a = Math.max(1, Math.round(w));
+  const b = Math.max(1, Math.round(h));
+  const d = g(a, b);
+  return `${a / d}:${b / d}`;
+}
+async function produce(request, model, target, as, colors, options, idempotencyKey, signal) {
+  const plan = planGenerationRequest(request, model, { strategy: "nearest" });
+  if (!plan.ok) return `The request cannot be sent to "${model.id}": ${plan.errors.map((e) => `${e.field}: ${e.message}`).join("; ")}`;
+  let art;
+  try {
+    art = await options.generate(plan.request, { model, plan, idempotencyKey, signal });
+  } catch (e) {
+    return `The generator failed: ${e.message}`;
+  }
+  const made = artNodes(art, as, colors);
+  if (typeof made === "string") return made;
+  return { nodes: fitted(made.nodes, made.box, target), plan };
+}
+var inFlight = /* @__PURE__ */ new WeakMap();
+function once(controller, key, args, fn) {
+  let map = inFlight.get(controller);
+  if (!map) inFlight.set(controller, map = /* @__PURE__ */ new Map());
+  const sig = stableStringify(args);
+  const hit = map.get(key);
+  if (hit) return hit.args === sig ? hit.result : Promise.resolve({ ok: false, message: `idempotencyKey "${key}" was already used with different input: pass a new key for a new request.` });
+  const result = fn().then((r) => {
+    if (!r.ok) map.delete(key);
+    return r;
+  });
+  map.set(key, { args: sig, result });
+  if (map.size > 500) map.delete(map.keys().next().value);
+  return result;
+}
+function generateVectorArt(controller, input, options) {
+  const { signal, ...args } = input;
+  return once(controller, input.idempotencyKey, args, async () => {
+    if (typeof input.prompt !== "string" || !input.prompt.trim()) return { ok: false, message: "prompt must be some text describing the art." };
+    if (!input.idempotencyKey) return { ok: false, message: "idempotencyKey is required (any unique string per request)." };
+    const models = listModels(options);
+    if (!models.length) return { ok: false, message: "No model can make vector art (an image model, or a text model that writes SVG)." };
+    const model = input.model ? models.find((m) => m.id === input.model) : models[0];
+    if (!model) return { ok: false, message: `Unknown model "${input.model}": use one of ${models.map((m) => m.id).join(", ")}.` };
+    const as = input.as ?? "color";
+    if (!VECTOR_GENERATED_IMAGE_AS.includes(as)) return { ok: false, message: `as must be one of ${VECTOR_GENERATED_IMAGE_AS.join(", ")}.` };
+    const doc = controller.getState().document;
+    const side = Math.min(doc.width, doc.height) * 0.6;
+    const target = {
+      x: input.x ?? (doc.width - (input.width ?? side)) / 2,
+      y: input.y ?? (doc.height - (input.height ?? side)) / 2,
+      width: input.width ?? side,
+      height: input.height ?? input.width ?? side
+    };
+    if (!(target.width > 0 && target.height > 0)) return { ok: false, message: "width and height must be above 0." };
+    const request = {
+      prompt: input.prompt,
+      mode: "generate",
+      aspectRatio: input.aspectRatio ?? ratioOf(target.width, target.height),
+      ...input.negativePrompt ? { negativePrompt: input.negativePrompt } : {},
+      ...input.seed !== void 0 ? { seed: input.seed } : {}
+    };
+    const made = await produce(request, model, target, as, input.colors ?? 8, options, input.idempotencyKey, signal);
+    if (typeof made === "string") return { ok: false, message: made };
+    const provenance = createProvenance({ rawPrompt: input.prompt, model, plan: made.plan, meta: { as, colors: input.colors ?? 8, box: target } });
+    const group = { id: "generated", type: "group", name: input.name ?? input.prompt.slice(0, 40), generation: provenance, children: made.nodes };
+    const id = controller.addNode(group, { label: "Generate Art" });
+    const added = controller.getNode(id);
+    return { ok: true, id, ids: added.children.map((c) => c.id), adjustments: made.plan.adjustments, model: model.id };
+  });
+}
+function regenerateVectorArt(controller, input, options) {
+  const { signal, ...args } = input;
+  return once(controller, input.idempotencyKey, args, async () => {
+    const node = controller.getNode(input.id);
+    const prov = node?.type === "group" ? node.generation : void 0;
+    if (!node || node.type !== "group" || !prov) return { ok: false, message: `"${input.id}" is not generated art (generate some with generate_vector_art).` };
+    if (node.locked) return { ok: false, message: `"${input.id}" is locked; unlock it first.` };
+    const models = listModels(options);
+    const model = models.find((m) => m.id === prov.modelId);
+    if (!model) return { ok: false, message: `The model "${prov.modelId}" it was made with is not available.` };
+    const meta = prov.meta ?? {};
+    const box = vectorNodeBounds(node) ?? meta.box ?? { x: 0, y: 0, width: 100, height: 100 };
+    const prompt = input.prompt ?? prov.rawPrompt;
+    const request = { ...prov.request, prompt, seed: input.seed ?? Math.floor(Math.random() * 2 ** 31) };
+    const made = await produce(request, model, box, meta.as ?? "color", meta.colors ?? 8, options, input.idempotencyKey, signal);
+    if (typeof made === "string") return { ok: false, message: made };
+    const provenance = createProvenance({ rawPrompt: prompt, model, plan: made.plan, meta: { ...meta, box } });
+    const r = controller.replaceGeneratedArt(input.id, made.nodes, provenance);
+    if (!r.ok) return { ok: false, message: r.message };
+    const now = controller.getNode(input.id);
+    return { ok: true, id: input.id, ids: now.children.map((c) => c.id), adjustments: made.plan.adjustments, model: model.id };
+  });
+}
+var IMAGE_AS_DESCRIPTION = "How an image result becomes vectors: color (traced, a path per colour; default), threshold (one colour), or stylised as mosaic, halftone, lowPoly or hatch. Ignored for SVG results.";
+function createVectorGenerationToolProvider(controller, options) {
+  const readOnly = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    return r ?? false;
+  };
+  const result = (r) => {
+    if (!r.ok) return { isError: true, content: [{ type: "text", text: r.message ?? "Generation failed." }] };
+    return { id: r.id, ids: r.ids, model: r.model, adjustments: r.adjustments };
+  };
+  const list = {
+    name: "list_vector_art_models",
+    title: "List vector art models",
+    description: "Lists the models generate_vector_art can use: { models: [{ id, name, media, aspectRatios, seed }] }. Image models give pictures that are traced or stylised; text models write SVG.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "List vector art models", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: () => ({
+      models: listModels(options).map((m) => ({ id: m.id, name: m.name ?? m.id, media: m.media, ...m.aspectRatios ? { aspectRatios: m.aspectRatios } : {}, seed: !!m.seed }))
+    })
+  };
+  const generate = {
+    name: "generate_vector_art",
+    title: "Generate vector art",
+    description: "Generates vector art from a text prompt with a model (list_vector_art_models) and adds it as one editable group fitted into a box on the artboard (one undo step). The request is adjusted to what the model supports. Costs money: pass a unique idempotencyKey; a retry with the same key and arguments returns the first result. Returns { id (the group), ids (its paths), model, adjustments }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", minLength: 1, description: 'What to draw, e.g. "a flat-style rocket, three colours".' },
+        model: { type: "string", description: "Model id from list_vector_art_models (default: the first)." },
+        negativePrompt: { type: "string", description: "What to avoid, for models that support it." },
+        seed: { type: "integer", description: "Seed for repeatable results, for models that support it." },
+        x: { type: "number", description: "Left of the box, document units (default: centred)." },
+        y: { type: "number", description: "Top of the box, document units (default: centred)." },
+        width: { type: "number", exclusiveMinimum: 0, description: "Box width, document units (default 60% of the artboard's smaller side)." },
+        height: { type: "number", exclusiveMinimum: 0, description: "Box height, document units (default: the width). The art keeps its proportions inside." },
+        as: { type: "string", enum: [...VECTOR_GENERATED_IMAGE_AS], description: IMAGE_AS_DESCRIPTION },
+        colors: { type: "integer", minimum: 2, maximum: 32, description: "Palette size when tracing or stylising in colour (default 8)." },
+        name: { type: "string", description: "Group name (default: the start of the prompt)." },
+        idempotencyKey: { type: "string", minLength: 1, description: "A unique string per request; reuse it only to retry the same request." }
+      },
+      required: ["prompt", "idempotencyKey"],
+      additionalProperties: false
+    },
+    annotations: { title: "Generate vector art", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    handler: async (args, ctx) => result(await generateVectorArt(controller, { ...args, signal: ctx.signal }, options))
+  };
+  const regenerate = {
+    name: "regenerate_vector_art",
+    title: "Regenerate vector art",
+    description: "Generates a generated group's art again (same model and settings, from its provenance) with a new seed (default random) and optionally a new prompt, replacing its paths in place (one undo step). Costs money: pass a unique idempotencyKey. Returns { id, ids, model, adjustments }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "A group generate_vector_art made." },
+        prompt: { type: "string", minLength: 1, description: "A new prompt (default: the one it was made with)." },
+        seed: { type: "integer", description: "Seed (default: a random one)." },
+        idempotencyKey: { type: "string", minLength: 1, description: "A unique string per request; reuse it only to retry the same request." }
+      },
+      required: ["id", "idempotencyKey"],
+      additionalProperties: false
+    },
+    annotations: { title: "Regenerate vector art", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    handler: async (args, ctx) => result(await regenerateVectorArt(controller, { ...args, signal: ctx.signal }, options))
+  };
+  return {
+    id: options.id ?? "vector-generation",
+    ...options.namespace ? { namespace: options.namespace } : {},
+    tools: () => readOnly() ? [list] : [list, generate, regenerate],
+    // The write tools come and go with a read-only state that can change.
+    ...typeof options.readOnly === "function" ? { subscribe: (notify) => controller.subscribe(() => notify()) } : {}
+  };
+}
+
 // src/vector/textPanel.ts
 var VECTOR_TEXT_ALIGN_LABELS = { left: "Left", center: "Centre", right: "Right", justify: "Justify" };
 var VECTOR_TEXT_ALIGN_OPTIONS = VECTOR_TEXT_ALIGNS.map((value) => ({ value, label: VECTOR_TEXT_ALIGN_LABELS[value] }));
@@ -17571,6 +18571,7 @@ export {
   VECTOR_BLEND_MODE_MENU,
   VECTOR_BLEND_SPACINGS,
   VECTOR_BLEND_SPACING_LABELS,
+  VECTOR_BRUSHSTROKE_SCALE,
   VECTOR_BUILDER_HATCH_GAP,
   VECTOR_CHARACTER_STYLE_KEYS,
   VECTOR_CLIPBOARD_TYPE,
@@ -17586,6 +18587,7 @@ export {
   VECTOR_CORNER_KIND_LABELS,
   VECTOR_CORNER_WIDGET_INSET,
   VECTOR_DIMENSIONAL_KINDS,
+  VECTOR_DISTORT_BRUSH_MODES,
   VECTOR_DISTORT_TOLERANCE,
   VECTOR_EDIT_TOGGLES,
   VECTOR_EFFECT_DEFAULTS,
@@ -17601,6 +18603,7 @@ export {
   VECTOR_FILTER_PARAM_SPECS,
   VECTOR_FILTER_TYPES,
   VECTOR_FONT_WEIGHTS,
+  VECTOR_GENERATED_IMAGE_AS,
   VECTOR_GRADIENT_INTERPOLATIONS,
   VECTOR_GRADIENT_INTERPOLATION_LABELS,
   VECTOR_GRADIENT_MAX_PERIODS,
@@ -17642,6 +18645,9 @@ export {
   VECTOR_STROKE_GRADIENT_MODE_LABELS,
   VECTOR_STROKE_SETTING_KEYS,
   VECTOR_STYLE_KEYS,
+  VECTOR_STYLIZE_LABELS,
+  VECTOR_STYLIZE_MAX_SHAPES,
+  VECTOR_STYLIZE_STYLES,
   VECTOR_SYMBOL_MAX_DEPTH,
   VECTOR_SYMMETRY_MODES,
   VECTOR_SYMMETRY_MODE_LABELS,
@@ -17716,6 +18722,7 @@ export {
   createVectorEffect,
   createVectorEffectsToolProvider,
   createVectorFilter,
+  createVectorGenerationToolProvider,
   createVectorMeshGradient,
   createVectorMorph,
   cssFontFamily,
@@ -17725,6 +18732,7 @@ export {
   decomposeRigid,
   defaultVectorGradient,
   distortVectorNode,
+  distortVectorPath,
   dragWarpMeshPoint as dragVectorMeshPoint,
   effectPathLength,
   effectPathVertexCount,
@@ -17751,6 +18759,7 @@ export {
   fitVectorTextRuns,
   foldVectorBooleanOperands,
   formatVectorValue,
+  generateVectorArt,
   generateVectorBlendChildren,
   generateWidthProfile,
   getAnchor,
@@ -17820,6 +18829,7 @@ export {
   isValidVectorParameterName,
   isVectorBlendGroup,
   isVectorBlendMode,
+  isVectorBrushstrokeLayer,
   isVectorConnector,
   isVectorFilterType,
   isVectorFrame,
@@ -17901,6 +18911,7 @@ export {
   rectSubpath,
   refineMorphContour,
   refreshVectorBlends,
+  regenerateVectorArt,
   releaseVectorBlend,
   removeAnchorKeepingShape,
   removeAnchors,
@@ -17934,6 +18945,7 @@ export {
   sampleVectorGradient,
   sampleVectorGradientAt,
   sampleVectorPaintDefAt,
+  sanitizeVectorBrushstroke,
   sanitizeVectorConnector,
   sanitizeVectorEffects,
   sanitizeVectorFills,
@@ -17977,6 +18989,7 @@ export {
   strokePositionPoint,
   strokeWidthProfileOf,
   styleVectorText,
+  stylizeVectorImage,
   subpathEnclosesArea,
   subpathPointAt,
   subpathSegment,
@@ -18011,6 +19024,7 @@ export {
   vectorAppearanceNodes,
   vectorAppearanceOutline,
   vectorAppearanceShapes,
+  vectorArtModels,
   vectorArtboards,
   vectorBevelFaces,
   vectorBlendColorDistance,
@@ -18025,6 +19039,10 @@ export {
   vectorBoundsInside,
   vectorBoxCorners,
   vectorBoxMatrix,
+  vectorBrushstrokeBrush,
+  vectorBrushstrokeBrushes,
+  vectorBrushstrokeImages,
+  vectorBrushstrokeReach,
   vectorBuilderErasedEdges,
   vectorChildAppearanceShapes,
   vectorConnectionSites,
@@ -18041,6 +19059,8 @@ export {
   vectorCorners,
   vectorCornersAttribute,
   vectorDiamondPath,
+  vectorDistortDabMap,
+  vectorDistortFalloff,
   vectorDistortQuad,
   vectorDocumentToLottie,
   vectorDocumentToPdf,
@@ -18083,6 +19103,8 @@ export {
   vectorGradientTAt,
   vectorGradientTargetPath,
   vectorGradientUnitsMatrix,
+  vectorHalftone,
+  vectorHatch,
   homographyFromPoints as vectorHomography,
   homographyKeepsQuad as vectorHomographyKeepsQuad,
   identityWarpMesh as vectorIdentityMesh,
@@ -18092,6 +19114,7 @@ export {
   vectorLensColorMap,
   vectorLensDrawn,
   vectorLiveBooleanSteps,
+  vectorLowPoly,
   vectorMaskContains,
   vectorMaskContentBounds,
   vectorMaskContents,
@@ -18118,6 +19141,7 @@ export {
   warpMeshParamAt as vectorMeshParamAt,
   vectorMeshPointAt,
   warpMeshRows as vectorMeshRows,
+  vectorMosaic,
   vectorNodeBounds,
   vectorNodeEnvelope,
   vectorNodeFilterSvg,