@pixerate/editor 0.43.0 → 0.45.0

package/dist/vector/index.js

@@ -11,6 +11,7 @@ import {
   contoursToPath,
   cutOutPiece,
   distanceToBezierPath,
+  fitCubicRun,
   fitCubicWithTangents,
   fitCubics,
   flattenChain,
@@ -79,11 +80,12 @@ var VECTOR_TOOLS = [
   "shapeBuilder",
   "paintBucket",
   "blend",
-  "gradient"
+  "gradient",
+  "envelope"
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
-var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater"];
+var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope"];
 var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
 
 // src/vector/gradient.ts
@@ -482,6 +484,14 @@ function transformVectorGradient(g, m) {
   const p = vectorGradientPoints(g);
   return { ...g, start: apply(m, p.start), end: apply(m, p.end), width: apply(m, p.width), ...p.focal ? { focal: apply(m, p.focal) } : {} };
 }
+function mapVectorGradient(g, f) {
+  if (!hasExplicitGradientGeometry(g) || g.units !== "userSpaceOnUse") return g;
+  const p = vectorGradientPoints(g);
+  return { ...g, start: f(p.start), end: f(p.end), width: f(p.width), ...p.focal ? { focal: f(p.focal) } : {} };
+}
+function mapVectorPaint(paint, f) {
+  return isVectorGradient(paint) ? mapVectorGradient(paint, f) : paint;
+}
 function transformVectorPaint(paint, m) {
   return isVectorGradient(paint) ? transformVectorGradient(paint, m) : paint;
 }
@@ -1179,8 +1189,8 @@ function widthProfilePreset(id) {
 }
 function widthProfilePresetId(points) {
   if (isUniformWidthProfile(points)) return "uniform";
-  const same = (a, b) => a.length === b.length && a.every((p, i) => Math.abs(p.t - b[i].t) < 1e-9 && Math.abs(p.left - b[i].left) < 1e-9 && Math.abs(p.right - b[i].right) < 1e-9);
-  return VECTOR_WIDTH_PRESETS.find((p) => p.points.length && same(points, p.points))?.id ?? "custom";
+  const same2 = (a, b) => a.length === b.length && a.every((p, i) => Math.abs(p.t - b[i].t) < 1e-9 && Math.abs(p.left - b[i].left) < 1e-9 && Math.abs(p.right - b[i].right) < 1e-9);
+  return VECTOR_WIDTH_PRESETS.find((p) => p.points.length && same2(points, p.points))?.id ?? "custom";
 }
 function reverseWidthProfile(points) {
   return points.map((p) => ({ t: 1 - p.t, left: p.right, right: p.left })).reverse();
@@ -1200,10 +1210,10 @@ function insertWidthPoint(points, t, sides2 = {}, options = {}) {
     left: clean(sides2.left, VECTOR_WIDTH_PROFILE_MAX_SCALE) ?? here.left,
     right: clean(sides2.right, VECTOR_WIDTH_PROFILE_MAX_SCALE) ?? here.right
   };
-  const same = pts.findIndex((q) => Math.abs(q.t - tt) <= VECTOR_WIDTH_SAME_T);
-  if (same >= 0 && !options.step) {
-    pts[same] = { ...p, t: pts[same].t };
-    return { points: pts, index: same };
+  const same2 = pts.findIndex((q) => Math.abs(q.t - tt) <= VECTOR_WIDTH_SAME_T);
+  if (same2 >= 0 && !options.step) {
+    pts[same2] = { ...p, t: pts[same2].t };
+    return { points: pts, index: same2 };
   }
   let i = 0;
   while (i < pts.length && pts[i].t <= tt) i++;
@@ -1743,13 +1753,13 @@ function endOf(segs, atStart) {
   const last = segs[segs.length - 1];
   return { p: toVec(last[last.length - 1]), out: v(t[0], t[1]) };
 }
-function pointAlong(segs, fromStart, dist4) {
+function pointAlong(segs, fromStart, dist5) {
   const order = fromStart ? segs : [...segs].reverse();
   let acc = 0;
   for (const s of order) {
     const l = segLen(s);
-    if (acc + l >= dist4) {
-      const want = fromStart ? dist4 - acc : l - (dist4 - acc);
+    if (acc + l >= dist5) {
+      const want = fromStart ? dist5 - acc : l - (dist5 - acc);
       const pts = trimSegments([s], 0, want);
       const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
       return toVec(p);
@@ -2231,6 +2241,846 @@ function pathsCenter(paths) {
   return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
 }
 
+// src/vector/pathMap.ts
+var MAX_PIECES = 1 << 20;
+var MAX_DEPTH = 6;
+var PROBES = [0.25, 0.5, 0.75];
+var lerp2 = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+var dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var same = (a, b) => Math.abs(a.x - b.x) < 1e-9 && Math.abs(a.y - b.y) < 1e-9;
+function evalCubic(s, t) {
+  const ab = lerp2(s[0], s[1], t);
+  const bc = lerp2(s[1], s[2], t);
+  const cd = lerp2(s[2], s[3], t);
+  return lerp2(lerp2(ab, bc, t), lerp2(bc, cd, t), t);
+}
+function halves(s) {
+  const ab = lerp2(s[0], s[1], 0.5);
+  const bc = lerp2(s[1], s[2], 0.5);
+  const cd = lerp2(s[2], s[3], 0.5);
+  const abc = lerp2(ab, bc, 0.5);
+  const bcd = lerp2(bc, cd, 0.5);
+  const m = lerp2(abc, bcd, 0.5);
+  return [
+    [s[0], ab, abc, m],
+    [m, bcd, cd, s[3]]
+  ];
+}
+function offLine(p, a, b) {
+  const l = dist2(a, b);
+  return l < 1e-12 ? dist2(p, a) : Math.abs((b.x - a.x) * (a.y - p.y) - (a.x - p.x) * (b.y - a.y)) / l;
+}
+var mapAnchorPoints = (a, f) => {
+  const p = f(a);
+  return {
+    x: p.x,
+    y: p.y,
+    ...a.in ? { in: f(a.in) } : {},
+    ...a.out ? { out: f(a.out) } : {},
+    ...a.type && a.type !== "corner" ? { type: a.type } : {},
+    ...a.corner ? { corner: { ...a.corner } } : {}
+  };
+};
+function mapVectorPoints(subpaths, f) {
+  return subpaths.map((sp) => ({ closed: sp.closed, anchors: sp.anchors.map((a) => mapAnchorPoints(a, f)) }));
+}
+function splitMapped(seg, f, tol, depth, out) {
+  const mapped = seg.map(f);
+  const fits = PROBES.every((t) => dist2(f(evalCubic(seg, t)), evalCubic(mapped, t)) <= tol);
+  if (fits || depth === 0) {
+    out.push(mapped);
+    return;
+  }
+  const [a, b] = halves(seg);
+  splitMapped(a, f, tol, depth - 1, out);
+  splitMapped(b, f, tol, depth - 1, out);
+}
+var toPoint = (p) => [p.x, p.y];
+var toVec2 = (p) => ({ x: p[0], y: p[1] });
+function refit(seg, pieces, f, tol) {
+  if (pieces.length < 3) return pieces;
+  const n = pieces.length * 4;
+  const samples = [];
+  for (let i = 0; i <= n; i++) samples.push(toPoint(f(evalCubic(seg, i / n))));
+  const first = pieces[0];
+  const last = pieces[pieces.length - 1];
+  const t0 = !same(first[1], first[0]) ? first[1] : first[2];
+  const t1 = !same(last[2], last[3]) ? last[2] : last[1];
+  const fitted = fitCubicRun(samples, tol / 2, [t0.x - first[0].x, t0.y - first[0].y], [last[3].x - t1.x, last[3].y - t1.y]);
+  if (!fitted.length || fitted.length >= pieces.length) return pieces;
+  const chain = fitted.map((c) => [c.p0, c.p1, c.p2, c.p3]);
+  for (let i = 0; i < n; i++) {
+    const q = toPoint(f(evalCubic(seg, (i + 0.5) / n)));
+    let best = Infinity;
+    for (const c of chain) best = Math.min(best, segmentNearest(c, q).distance);
+    if (best > tol) return pieces;
+  }
+  return fitted.map((c) => [toVec2(c.p0), toVec2(c.p1), toVec2(c.p2), toVec2(c.p3)]);
+}
+function mapSegment(seg, f, tol, depth, fit) {
+  if (same(seg[1], seg[0]) && same(seg[2], seg[3])) {
+    const a = f(seg[0]);
+    const b = f(seg[3]);
+    if (PROBES.every((t) => offLine(f(lerp2(seg[0], seg[3], t)), a, b) <= tol)) return [[a, a, b, b]];
+    const line2 = [seg[0], lerp2(seg[0], seg[3], 1 / 3), lerp2(seg[0], seg[3], 2 / 3), seg[3]];
+    const out2 = [];
+    splitMapped(line2, f, tol, depth, out2);
+    return fit ? refit(line2, out2, f, tol) : out2;
+  }
+  const out = [];
+  splitMapped(seg, f, tol, depth, out);
+  return fit ? refit(seg, out, f, tol) : out;
+}
+function realign(a) {
+  if (!a.in || !a.out || same(a.in, a) || same(a.out, a)) return a;
+  const li = dist2(a.in, a);
+  const lo = dist2(a.out, a);
+  const dx = (a.x - a.in.x) / li + (a.out.x - a.x) / lo;
+  const dy = (a.y - a.in.y) / li + (a.out.y - a.y) / lo;
+  const l = Math.hypot(dx, dy);
+  if (l < 1e-12) return a;
+  const u = { x: dx / l, y: dy / l };
+  const type = a.type === "symmetric" && Math.abs(li - lo) > 1e-6 * Math.max(li, lo) ? "smooth" : a.type;
+  return { ...a, in: { x: a.x - u.x * li, y: a.y - u.y * li }, out: { x: a.x + u.x * lo, y: a.y + u.y * lo }, ...type ? { type } : {} };
+}
+var segmentOf = (sp, i) => {
+  const a = sp.anchors[i];
+  const b = sp.anchors[(i + 1) % sp.anchors.length];
+  return [{ x: a.x, y: a.y }, a.out ?? { x: a.x, y: a.y }, b.in ?? { x: b.x, y: b.y }, { x: b.x, y: b.y }];
+};
+function mapSubpath(sp, f, tol, depth, fit) {
+  const n = sp.anchors.length;
+  const count = n < 2 ? 0 : sp.closed ? n : n - 1;
+  if (!count) return mapVectorPoints([sp], f)[0];
+  const pieces = [];
+  for (let i = 0; i < count; i++) pieces.push(mapSegment(segmentOf(sp, i), f, tol, depth, fit));
+  const anchors = [];
+  const put = (a) => {
+    if (a.in && same(a.in, a)) delete a.in;
+    if (a.out && same(a.out, a)) delete a.out;
+    anchors.push(a.type === "smooth" || a.type === "symmetric" ? realign(a) : a);
+  };
+  sp.anchors.forEach((k, i) => {
+    const incoming = i > 0 ? pieces[i - 1] : sp.closed ? pieces[n - 1] : void 0;
+    const outgoing = pieces[i];
+    const p = f(k);
+    const a = { x: p.x, y: p.y };
+    const inCtrl = incoming ? incoming[incoming.length - 1][2] : k.in ? f(k.in) : null;
+    const outCtrl = outgoing ? outgoing[0][1] : k.out ? f(k.out) : null;
+    if (inCtrl) a.in = inCtrl;
+    if (outCtrl) a.out = outCtrl;
+    if (k.type && k.type !== "corner") a.type = k.type;
+    if (k.corner) a.corner = { ...k.corner };
+    put(a);
+    if (outgoing) for (let w = 1; w < outgoing.length; w++) put({ x: outgoing[w][0].x, y: outgoing[w][0].y, in: outgoing[w - 1][2], out: outgoing[w][1], type: "smooth" });
+  });
+  return { closed: sp.closed, anchors };
+}
+function mapVectorSubpaths(subpaths, f, tolerance = 0.1, options = {}) {
+  const tol = Number.isFinite(tolerance) && tolerance > 0 ? tolerance : 0.1;
+  const segments = subpaths.reduce((s, sp) => s + sp.anchors.length, 0);
+  let depth = MAX_DEPTH;
+  while (depth > 0 && segments * 2 ** depth > MAX_PIECES) depth--;
+  return subpaths.map((sp) => mapSubpath(sp, f, tol, depth, options.refit !== false));
+}
+function mapBezierPath(path, f, tolerance = 0.1, options = {}) {
+  return subpathsToBezier(mapVectorSubpaths(bezierToSubpaths(path), f, tolerance, options), { corners: false });
+}
+
+// src/vector/warp.ts
+var VECTOR_WARP_STYLES = [
+  "arc",
+  "arcLower",
+  "arcUpper",
+  "arch",
+  "bulge",
+  "shellLower",
+  "shellUpper",
+  "flag",
+  "wave",
+  "fish",
+  "rise",
+  "fisheye",
+  "inflate",
+  "squeeze",
+  "twist"
+];
+var VECTOR_WARP_STYLE_LABELS = {
+  arc: "Arc",
+  arcLower: "Arc Lower",
+  arcUpper: "Arc Upper",
+  arch: "Arch",
+  bulge: "Bulge",
+  shellLower: "Shell Lower",
+  shellUpper: "Shell Upper",
+  flag: "Flag",
+  wave: "Wave",
+  fish: "Fish",
+  rise: "Rise",
+  fisheye: "Fisheye",
+  inflate: "Inflate",
+  squeeze: "Squeeze",
+  twist: "Twist"
+};
+function restGrid() {
+  return [0, 1, 2, 3].map((j) => [0, 1, 2, 3].map((i) => [i / 3, j / 3]));
+}
+function edgeArc(y, b, up, h) {
+  if (Math.abs(b) < 1e-9) return [0, 1, 2, 3].map((i) => [i / 3, y]);
+  const th = Math.abs(b) * Math.PI;
+  const k = 4 / 3 * Math.tan(th / 4) * 0.5 / Math.sin(th / 2);
+  const s = b > 0 === up ? -1 : 1;
+  const c = Math.cos(th / 2);
+  const n = Math.sin(th / 2);
+  const dy = s * k * n / h;
+  return [
+    [0, y],
+    [k * c, y + dy],
+    [1 - k * c, y + dy],
+    [1, y]
+  ];
+}
+function arcGrid(b, h) {
+  if (Math.abs(b) < 1e-9) return restGrid();
+  const up = b > 0;
+  const th = Math.abs(b) * Math.PI;
+  const r = 0.5 / Math.sin(th / 2);
+  const k = 4 / 3 * Math.tan(th / 4);
+  const s = up ? -1 : 1;
+  const cy = up ? h + r * Math.cos(th / 2) : -r * Math.cos(th / 2);
+  return [0, 1, 2, 3].map((j) => {
+    const v2 = j / 3;
+    const big = r + h * (up ? 1 - v2 : v2);
+    const at2 = (a) => [0.5 + big * Math.sin(a), cy + s * big * Math.cos(a)];
+    const tangent2 = (a) => [Math.cos(a), -s * Math.sin(a)];
+    const p0 = at2(-th / 2);
+    const p3 = at2(th / 2);
+    const t0 = tangent2(-th / 2);
+    const t1 = tangent2(th / 2);
+    const l = k * big;
+    const pts = [p0, [p0[0] + l * t0[0], p0[1] + l * t0[1]], [p3[0] - l * t1[0], p3[1] - l * t1[1]], p3];
+    return pts.map((p) => [p[0], p[1] / h]);
+  });
+}
+function blendRows(top, bottom) {
+  return [0, 1, 2, 3].map((j) => {
+    const t = j / 3;
+    return [0, 1, 2, 3].map((i) => [top[i][0] + (bottom[i][0] - top[i][0]) * t, top[i][1] + (bottom[i][1] - top[i][1]) * t]);
+  });
+}
+var INNER = [
+  [1, 1, -1, -1],
+  [1, 2, 1, -1],
+  [2, 1, -1, 1],
+  [2, 2, 1, 1]
+];
+function vectorWarpPresetGrid(style, b, hd, vd, vertical, aspect) {
+  const h = vertical ? 1 / aspect : aspect;
+  if (vertical) [hd, vd] = [vd, hd];
+  let g = restGrid();
+  switch (style) {
+    case "arc":
+      g = arcGrid(b, h);
+      break;
+    case "arch":
+      g = [0, 1, 2, 3].map((j) => edgeArc(j / 3, b, true, h));
+      break;
+    case "bulge":
+      g = blendRows(edgeArc(0, b, true, h), edgeArc(1, b, false, h));
+      break;
+    case "arcLower":
+      g = blendRows(g[0], edgeArc(1, b, false, h));
+      break;
+    case "arcUpper":
+      g = blendRows(edgeArc(0, b, true, h), g[3]);
+      break;
+    // The bulging edge and the outer points of the row next to it come from Arc (bent the other
+    // way for Shell Lower); the rest stays put.
+    case "shellLower": {
+      const a = arcGrid(-b, h);
+      g[3] = a[3];
+      g[2][0] = a[2][0];
+      g[2][3] = a[2][3];
+      break;
+    }
+    case "shellUpper": {
+      const a = arcGrid(b, h);
+      g[0] = a[0];
+      g[1][0] = a[1][0];
+      g[1][3] = a[1][3];
+      break;
+    }
+    case "flag":
+      for (const row of g) {
+        row[1][1] -= 2 * b;
+        row[2][1] += 2 * b;
+      }
+      break;
+    case "wave":
+      for (const row of g.slice(1, 3)) {
+        row[1][1] += 4 / 3 * b;
+        row[2][1] -= 4 / 3 * b;
+      }
+      break;
+    case "fish":
+      [-2, -2 / 3, 2 / 3, 2].forEach((f, j) => {
+        g[j][1][1] += f * b;
+        g[j][2][1] -= f * b;
+      });
+      break;
+    case "rise":
+      for (const row of g) {
+        row[0][1] += 2 * b;
+        row[1][1] += 2 * b;
+      }
+      break;
+    case "fisheye":
+      for (const [j, i, dx, dy] of INNER) {
+        g[j][i][0] += dx * 2 * b / 3;
+        g[j][i][1] += dy * 2 * b / 3;
+      }
+      break;
+    // Edge midpoints move out (Inflate) or the sides in (Squeeze) by b/3, the inner points by b/9.
+    case "inflate":
+    case "squeeze": {
+      const s = style === "inflate" ? 1 : -1;
+      for (const p of g[0].slice(1, 3)) p[1] -= b / 3;
+      for (const p of g[3].slice(1, 3)) p[1] += b / 3;
+      for (const row of g.slice(1, 3)) {
+        row[0][0] -= s * b / 3;
+        row[3][0] += s * b / 3;
+      }
+      for (const [j, i, dx, dy] of INNER) {
+        g[j][i][0] += s * dx * b / 9;
+        g[j][i][1] += dy * b / 9;
+      }
+      break;
+    }
+    // The inner points turn round the centre (the other way for a negative bend).
+    case "twist": {
+      const a = Math.abs(b);
+      if (b >= 0) {
+        g[1][1][0] += a;
+        g[1][2][1] += a;
+        g[2][1][1] -= a;
+        g[2][2][0] -= a;
+      } else {
+        g[1][1][1] += a;
+        g[1][2][0] -= a;
+        g[2][1][0] += a;
+        g[2][2][1] -= a;
+      }
+      break;
+    }
+  }
+  if (vd !== 0) {
+    const moved = (row, s) => {
+      const m = [(row[0][0] + row[3][0]) / 2, (row[0][1] + row[3][1]) / 2];
+      return row.map((p) => [m[0] + (p[0] - m[0]) * s - p[0], m[1] + (p[1] - m[1]) * s - p[1]]);
+    };
+    const d0 = moved(g[0], 1 - vd);
+    const d3 = moved(g[3], 1 + vd);
+    g.forEach((row, j) => {
+      const t = j / 3;
+      row.forEach((p, i) => {
+        p[0] += d0[i][0] + (d3[i][0] - d0[i][0]) * t;
+        p[1] += d0[i][1] + (d3[i][1] - d0[i][1]) * t;
+      });
+    });
+  }
+  if (hd !== 0) {
+    for (let i = 0; i < 4; i++) {
+      const s = 1 + hd * (2 * i / 3 - 1);
+      const m = [(g[0][i][0] + g[3][i][0]) / 2, (g[0][i][1] + g[3][i][1]) / 2];
+      for (const row of g) row[i] = [m[0] + (row[i][0] - m[0]) * s, m[1] + (row[i][1] - m[1]) * s];
+    }
+  }
+  if (vertical) g = [0, 1, 2, 3].map((j) => [0, 1, 2, 3].map((i) => [g[i][j][1], g[i][j][0]]));
+  return g;
+}
+function bernstein(t) {
+  const s = 1 - t;
+  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];
+}
+var lerp3 = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+function splitCubic(p, t) {
+  const a = lerp3(p[0], p[1], t);
+  const b = lerp3(p[1], p[2], t);
+  const c = lerp3(p[2], p[3], t);
+  const d = lerp3(a, b, t);
+  const e = lerp3(b, c, t);
+  return [p[0], a, d, lerp3(d, e, t), e, c, p[3]];
+}
+var BERN_INV = [
+  [1, 0, 0, 0],
+  [-5 / 6, 3, -1.5, 1 / 3],
+  [1 / 3, -1.5, 3, -5 / 6],
+  [0, 0, 0, 1]
+];
+var pct = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(1, Math.max(-1, v2 / 100)) : 0;
+function vectorWarpPresetMesh(preset, bounds) {
+  if (!VECTOR_WARP_STYLES.includes(preset.style)) return null;
+  const { x, y, width: w, height: h } = bounds;
+  if (!(w > 0 && h > 0)) return null;
+  const b = pct(preset.bend);
+  const hd = pct(preset.horizontal);
+  const vd = pct(preset.vertical);
+  if (b === 0 && hd === 0 && vd === 0) return null;
+  const grid = vectorWarpPresetGrid(preset.style, b, hd, vd, preset.orientation === "vertical", h / w);
+  return { us: [0, 1], vs: [0, 1], points: grid.flat().map((p) => ({ x: x + p[0] * w, y: y + p[1] * h })) };
+}
+var vectorMeshColumns = (m) => 3 * (m.us.length - 1) + 1;
+var vectorMeshRows = (m) => 3 * (m.vs.length - 1) + 1;
+function isValidVectorMesh(m) {
+  if (!m || typeof m !== "object") return false;
+  const { us, vs, points } = m;
+  const knots = (k) => Array.isArray(k) && k.length >= 2 && k.length <= 65 && k[0] === 0 && k[k.length - 1] === 1 && k.every((v2, i) => typeof v2 === "number" && (i === 0 || v2 > k[i - 1]));
+  if (!knots(us) || !knots(vs) || !Array.isArray(points)) return false;
+  return points.length === (3 * (us.length - 1) + 1) * (3 * (vs.length - 1) + 1) && points.every((p) => !!p && Number.isFinite(p.x) && Number.isFinite(p.y));
+}
+function fitVectorMesh(f, us, vs) {
+  const pc = us.length - 1;
+  const pr = vs.length - 1;
+  const nx = 3 * pc + 1;
+  const points = new Array((3 * pr + 1) * nx);
+  for (let pj = 0; pj < pr; pj++) {
+    for (let pi = 0; pi < pc; pi++) {
+      const s = [0, 1, 2, 3].map(
+        (j) => [0, 1, 2, 3].map((i) => f(us[pi] + (us[pi + 1] - us[pi]) * i / 3, vs[pj] + (vs[pj + 1] - vs[pj]) * j / 3))
+      );
+      for (let j = 0; j < 4; j++) {
+        for (let i = 0; i < 4; i++) {
+          let x = 0;
+          let y = 0;
+          for (let a = 0; a < 4; a++) {
+            for (let b = 0; b < 4; b++) {
+              const k = BERN_INV[j][a] * BERN_INV[i][b];
+              x += k * s[a][b].x;
+              y += k * s[a][b].y;
+            }
+          }
+          points[(3 * pj + j) * nx + 3 * pi + i] = { x, y };
+        }
+      }
+    }
+  }
+  return { us: us.slice(), vs: vs.slice(), points };
+}
+var evenKnots = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
+var clampCount = (n) => Math.min(64, Math.max(1, Math.round(Number.isFinite(n) ? n : 1)));
+function vectorIdentityMesh(bounds, columns = 1, rows = 1) {
+  return fitVectorMesh((s, t) => ({ x: bounds.x + s * bounds.width, y: bounds.y + t * bounds.height }), evenKnots(clampCount(columns)), evenKnots(clampCount(rows)));
+}
+function locate(knots, s) {
+  const n = knots.length - 1;
+  let i = 0;
+  while (i + 1 < n && s > knots[i + 1]) i++;
+  const w = knots[i + 1] - knots[i];
+  return [i, w > 0 ? (s - knots[i]) / w : 0];
+}
+function evalVectorMesh(m, s, t) {
+  const [pi, a] = locate(m.us, s);
+  const [pj, b] = locate(m.vs, t);
+  const ba = bernstein(a);
+  const bb = bernstein(b);
+  const nx = vectorMeshColumns(m);
+  let x = 0;
+  let y = 0;
+  for (let j = 0; j < 4; j++) {
+    for (let i = 0; i < 4; i++) {
+      const p = m.points[(3 * pj + j) * nx + 3 * pi + i];
+      const k = ba[i] * bb[j];
+      x += p.x * k;
+      y += p.y * k;
+    }
+  }
+  return { x, y };
+}
+function transposeMesh(m) {
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const points = new Array(nx * ny);
+  for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) points[i * ny + j] = m.points[j * nx + i];
+  return { us: m.vs.slice(), vs: m.us.slice(), points };
+}
+function splitVectorMeshU(m, s) {
+  const [pi, a] = locate(m.us, s);
+  if (!(a >= 0.01 && a <= 0.99)) return null;
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const points = [];
+  for (let j = 0; j < ny; j++) {
+    const row = m.points.slice(j * nx, (j + 1) * nx);
+    points.push(...row.slice(0, 3 * pi), ...splitCubic(row.slice(3 * pi, 3 * pi + 4), a), ...row.slice(3 * pi + 4));
+  }
+  const us = m.us.slice();
+  us.splice(pi + 1, 0, Math.min(1, Math.max(0, s)));
+  return { us, vs: m.vs.slice(), points };
+}
+function splitVectorMeshV(m, t) {
+  const out = splitVectorMeshU(transposeMesh(m), t);
+  return out && transposeMesh(out);
+}
+function removeVectorMeshSplitU(m, k) {
+  if (k <= 0 || k + 1 >= m.us.length) return null;
+  const a = (m.us[k] - m.us[k - 1]) / (m.us[k + 1] - m.us[k - 1]);
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const c0 = 3 * (k - 1);
+  const points = [];
+  for (let j = 0; j < ny; j++) {
+    const row = m.points.slice(j * nx, (j + 1) * nx);
+    const [p0, q1, r2, p3] = [row[c0], row[c0 + 1], row[c0 + 5], row[c0 + 6]];
+    const p1 = { x: (q1.x - (1 - a) * p0.x) / a, y: (q1.y - (1 - a) * p0.y) / a };
+    const p2 = { x: (r2.x - a * p3.x) / (1 - a), y: (r2.y - a * p3.y) / (1 - a) };
+    points.push(...row.slice(0, c0), p0, p1, p2, p3, ...row.slice(c0 + 7));
+  }
+  const us = m.us.slice();
+  us.splice(k, 1);
+  return { us, vs: m.vs.slice(), points };
+}
+function removeVectorMeshSplitV(m, k) {
+  const out = removeVectorMeshSplitU(transposeMesh(m), k);
+  return out && transposeMesh(out);
+}
+function mapVectorMeshPoints(m, f) {
+  return { us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => f(p)) };
+}
+function resizeVectorMesh(m, columns, rows) {
+  const cols = clampCount(columns);
+  const rws = clampCount(rows);
+  if (m.us.length - 1 === cols && m.vs.length - 1 === rws) return m;
+  const us = evenKnots(cols);
+  const vs = evenKnots(rws);
+  const has = (list, v2) => list.some((k) => Math.abs(k - v2) < 1e-12);
+  if (m.us.every((u) => has(us, u)) && m.vs.every((v2) => has(vs, v2))) {
+    let out = m;
+    for (const u of us) if (!has(out.us, u)) out = splitVectorMeshU(out, u) ?? out;
+    for (const v2 of vs) if (!has(out.vs, v2)) out = splitVectorMeshV(out, v2) ?? out;
+    return out;
+  }
+  return fitVectorMesh((s, t) => evalVectorMesh(m, s, t), us, vs);
+}
+function vectorMeshControlBounds(m) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of m.points) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function vectorMeshParamAt(m, p) {
+  const n = 48;
+  let best = { s: 0.5, t: 0.5, d: Infinity };
+  for (let j = 0; j <= n; j++) {
+    for (let i = 0; i <= n; i++) {
+      const q2 = evalVectorMesh(m, i / n, j / n);
+      const d = (q2.x - p.x) ** 2 + (q2.y - p.y) ** 2;
+      if (d < best.d) best = { s: i / n, t: j / n, d };
+    }
+  }
+  let { s, t } = best;
+  for (let k = 0; k < 12; k++) {
+    const h = 1e-5;
+    const q2 = evalVectorMesh(m, s, t);
+    const qs = evalVectorMesh(m, s + h, t);
+    const qt = evalVectorMesh(m, s, t + h);
+    const a = (qs.x - q2.x) / h;
+    const b = (qt.x - q2.x) / h;
+    const c = (qs.y - q2.y) / h;
+    const d = (qt.y - q2.y) / h;
+    const det = a * d - b * c;
+    if (Math.abs(det) < 1e-12) break;
+    const ex = p.x - q2.x;
+    const ey = p.y - q2.y;
+    s = Math.min(1, Math.max(0, s + (d * ex - b * ey) / det));
+    t = Math.min(1, Math.max(0, t + (a * ey - c * ex) / det));
+  }
+  const q = evalVectorMesh(m, s, t);
+  return { s, t, distance: Math.hypot(q.x - p.x, q.y - p.y) };
+}
+function smoothLines(m, i0, i1, j0, j1) {
+  const nx = vectorMeshColumns(m);
+  i1 = Math.min(i1, nx);
+  j1 = Math.min(j1, vectorMeshRows(m));
+  const triples = [];
+  for (let a = 1; a < m.us.length - 1; a++) {
+    if (3 * a >= i0 && 3 * a < i1)
+      for (let j = j0; j < j1; j++) triples.push([j * nx + 3 * a - 1, j * nx + 3 * a, j * nx + 3 * a + 1, m.us[a] - m.us[a - 1], m.us[a + 1] - m.us[a]]);
+  }
+  for (let b = 1; b < m.vs.length - 1; b++) {
+    if (3 * b >= j0 && 3 * b < j1)
+      for (let i = i0; i < i1; i++) triples.push([(3 * b - 1) * nx + i, 3 * b * nx + i, (3 * b + 1) * nx + i, m.vs[b] - m.vs[b - 1], m.vs[b + 1] - m.vs[b]]);
+  }
+  for (const [l, c, r, hl, hr] of triples) {
+    const pl = m.points[l];
+    const pc = m.points[c];
+    const pr = m.points[r];
+    const tx = ((pc.x - pl.x) / hl + (pr.x - pc.x) / hr) / 2;
+    const ty = ((pc.y - pl.y) / hl + (pr.y - pc.y) / hr) / 2;
+    m.points[l] = { x: pc.x - tx * hl, y: pc.y - ty * hl };
+    m.points[r] = { x: pc.x + tx * hr, y: pc.y + ty * hr };
+  }
+}
+function dragVectorMeshPoint(base, index, d) {
+  if (index < 0 || index >= base.points.length || !Number.isFinite(d.x) || !Number.isFinite(d.y)) return base;
+  const out = { us: base.us.slice(), vs: base.vs.slice(), points: base.points.slice() };
+  const nx = vectorMeshColumns(base);
+  const ny = vectorMeshRows(base);
+  const i = index % nx;
+  const j = Math.floor(index / nx);
+  const shift = (ii, jj, v2) => {
+    if (ii < 0 || jj < 0 || ii >= nx || jj >= ny) return;
+    const p = out.points[jj * nx + ii];
+    out.points[jj * nx + ii] = { x: p.x + v2.x, y: p.y + v2.y };
+  };
+  const span = (knots, k) => k > 0 && k + 1 < knots.length ? [knots[k] - knots[k - 1], knots[k + 1] - knots[k]] : null;
+  const ri = i % 3;
+  const rj = j % 3;
+  if (ri === 0 && rj === 0) {
+    for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) shift(i + di, j + dj, d);
+  } else if (ri === 0) {
+    for (let di = -1; di <= 1; di++) shift(i + di, j, d);
+    const sp = span(base.vs, Math.floor(j / 3) + (rj === 2 ? 1 : 0));
+    if (sp) {
+      const [other, k] = rj === 1 ? [j - 2, sp[0] / sp[1]] : [j + 2, sp[1] / sp[0]];
+      for (let di = -1; di <= 1; di++) shift(i + di, other, { x: -d.x * k, y: -d.y * k });
+    }
+  } else if (rj === 0) {
+    for (let dj = -1; dj <= 1; dj++) shift(i, j + dj, d);
+    const sp = span(base.us, Math.floor(i / 3) + (ri === 2 ? 1 : 0));
+    if (sp) {
+      const [other, k] = ri === 1 ? [i - 2, sp[0] / sp[1]] : [i + 2, sp[1] / sp[0]];
+      for (let dj = -1; dj <= 1; dj++) shift(other, j + dj, { x: -d.x * k, y: -d.y * k });
+    }
+  } else shift(i, j, d);
+  return out;
+}
+function pullVectorMesh(base, s, t, d) {
+  const BORDER_ZONE = 0.12;
+  const REACH = 1.8;
+  if (!Number.isFinite(d.x) || !Number.isFinite(d.y)) return base;
+  const m = { us: base.us.slice(), vs: base.vs.slice(), points: base.points.slice() };
+  const cols = m.us.length - 1;
+  const rows = m.vs.length - 1;
+  const [pi, a] = locate(m.us, s);
+  const [pj, b] = locate(m.vs, t);
+  const ba = bernstein(a);
+  const bb = bernstein(b);
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const anchor = (ai, aj) => base.points[3 * aj * nx + 3 * ai] ?? { x: 0, y: 0 };
+  const at0 = evalVectorMesh(base, s, t);
+  const target = { x: at0.x + d.x, y: at0.y + d.y };
+  let size = 1;
+  for (const k of ["x", "y"]) {
+    const vals = [anchor(pi, pj)[k], anchor(pi + 1, pj)[k], anchor(pi, pj + 1)[k], anchor(pi + 1, pj + 1)[k]];
+    size = Math.max(size, Math.max(...vals) - Math.min(...vals));
+  }
+  const radius = REACH * size;
+  const innerW = (ba[1] + ba[2]) * (bb[1] + bb[2]);
+  const interior = Math.min(1, Math.max(0, innerW / 0.5625));
+  const toBorder = Math.min(s, 1 - s, t, 1 - t);
+  const nearBorder = Math.min(1, Math.max(0, 1 - toBorder / BORDER_ZONE));
+  const meshCorner = (ai, aj) => (ai === 0 || ai === cols) && (aj === 0 || aj === rows);
+  const onBorder = (ai, aj) => ai === 0 || ai === cols || aj === 0 || aj === rows;
+  const reach = (ai, aj, wa, wb) => meshCorner(ai, aj) ? 0 : wa * wb * (onBorder(ai, aj) ? nearBorder : 1);
+  const corner = [
+    [pi, pj, reach(pi, pj, ba[0] + ba[1], bb[0] + bb[1])],
+    [pi + 1, pj, reach(pi + 1, pj, ba[2] + ba[3], bb[0] + bb[1])],
+    [pi, pj + 1, reach(pi, pj + 1, ba[0] + ba[1], bb[2] + bb[3])],
+    [pi + 1, pj + 1, reach(pi + 1, pj + 1, ba[2] + ba[3], bb[2] + bb[3])]
+  ];
+  const share = new Array((cols + 1) * (rows + 1)).fill(0);
+  for (let aj = 0; aj <= rows; aj++) {
+    for (let ai = 0; ai <= cols; ai++) {
+      const p = anchor(ai, aj);
+      const x = Math.min(1, Math.max(0, Math.hypot(p.x - at0.x, p.y - at0.y) / radius));
+      const fall = 0.5 * (1 + Math.cos(Math.PI * x));
+      const edge = meshCorner(ai, aj) ? 0 : onBorder(ai, aj) ? nearBorder : 1;
+      share[aj * (cols + 1) + ai] = fall * edge;
+    }
+  }
+  for (const [ai, aj, w] of corner) share[aj * (cols + 1) + ai] = Math.max(share[aj * (cols + 1) + ai], (1 - interior) * w);
+  const move = (idx, k, v2) => {
+    const p = m.points[idx];
+    m.points[idx] = { x: p.x + v2.x * k, y: p.y + v2.y * k };
+  };
+  for (let j = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const ai = Math.min(cols, Math.floor((i + 1) / 3));
+      const aj = Math.min(rows, Math.floor((j + 1) / 3));
+      move(j * nx + i, share[aj * (cols + 1) + ai], d);
+    }
+  }
+  let norm = 0;
+  for (const j of [1, 2]) for (const i of [1, 2]) norm += (ba[i] * bb[j]) ** 2;
+  const cornerNorm = corner.reduce((acc, c) => acc + c[2] * c[2], 0);
+  const innerPart = cornerNorm > 1e-12 ? Math.min(1, innerW / 0.15) : 1;
+  const edgeHandles = [];
+  for (const k of [1, 2]) {
+    if (pi === 0) edgeHandles.push([(3 * pj + k) * nx + 3 * pi, ba[0] * bb[k]]);
+    if (pi + 1 === cols) edgeHandles.push([(3 * pj + k) * nx + 3 * pi + 3, ba[3] * bb[k]]);
+    if (pj === 0) edgeHandles.push([3 * pj * nx + 3 * pi + k, ba[k] * bb[0]]);
+    if (pj + 1 === rows) edgeHandles.push([(3 * pj + 3) * nx + 3 * pi + k, ba[k] * bb[3]]);
+  }
+  const edgeNorm = edgeHandles.reduce((acc, e) => acc + e[1] * e[1], 0);
+  const edgePart = edgeNorm > 1e-12 ? nearBorder : 0;
+  const innerShare = (1 - edgePart) * innerPart;
+  const cornerShare = (1 - edgePart) * (1 - innerPart);
+  for (let iter = 0; iter < 60; iter++) {
+    const now = evalVectorMesh(m, s, t);
+    const rem = { x: target.x - now.x, y: target.y - now.y };
+    if (Math.hypot(rem.x, rem.y) < 1e-9) break;
+    if (innerShare > 0 && norm > 0) for (const j of [1, 2]) for (const i of [1, 2]) move((3 * pj + j) * nx + 3 * pi + i, ba[i] * bb[j] / norm * innerShare, rem);
+    if (edgePart > 0) for (const [idx, w] of edgeHandles) move(idx, w / edgeNorm * edgePart, rem);
+    if (cornerShare > 0 && cornerNorm > 0) {
+      for (const [ai, aj, w] of corner) {
+        const k = w / cornerNorm * cornerShare;
+        for (let dj = -1; dj <= 1; dj++) {
+          for (let di = -1; di <= 1; di++) {
+            const i = 3 * ai + di;
+            const j = 3 * aj + dj;
+            if (i >= 0 && j >= 0 && i < nx && j < ny) move(j * nx + i, k, rem);
+          }
+        }
+      }
+    }
+    for (let k = 0; k < 3; k++) smoothLines(m, Math.max(0, 3 * pi - 3), 3 * pi + 7, Math.max(0, 3 * pj - 3), 3 * pj + 7);
+  }
+  return m;
+}
+function polylineAt(pts) {
+  const acc = [0];
+  for (let i = 1; i < pts.length; i++) acc.push(acc[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));
+  const total = acc[acc.length - 1];
+  return (u) => {
+    if (!(total > 0)) return pts[0];
+    const L = Math.min(1, Math.max(0, u)) * total;
+    let i = 1;
+    while (i < acc.length - 1 && acc[i] < L) i++;
+    const seg = acc[i] - acc[i - 1];
+    return lerp3(pts[i - 1], pts[i], seg > 0 ? (L - acc[i - 1]) / seg : 0);
+  };
+}
+function sampleSubpath(sp, per = 24) {
+  const n = sp.anchors.length;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const a = sp.anchors[i];
+    const b = sp.anchors[(i + 1) % n];
+    const c = [{ x: a.x, y: a.y }, a.out ?? a, b.in ?? b, { x: b.x, y: b.y }];
+    for (let k = 0; k < per; k++) {
+      const t = k / per;
+      const ab = lerp3(c[0], c[1], t);
+      const bc = lerp3(c[1], c[2], t);
+      const cd = lerp3(c[2], c[3], t);
+      out.push(lerp3(lerp3(ab, bc, t), lerp3(bc, cd, t), t));
+    }
+  }
+  return out;
+}
+function vectorMeshFromOutline(sp, columns = 4, rows = 4) {
+  if (!sp.closed || sp.anchors.length < 2) return null;
+  let ring = sampleSubpath(sp);
+  const xs = ring.map((p) => p.x);
+  const ys = ring.map((p) => p.y);
+  const box = { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) };
+  if (!(box.x1 - box.x0 > 1e-9 && box.y1 - box.y0 > 1e-9)) return null;
+  const nearest = (c2) => {
+    let best = 0;
+    for (let i = 1; i < ring.length; i++) if (Math.hypot(ring[i].x - c2.x, ring[i].y - c2.y) < Math.hypot(ring[best].x - c2.x, ring[best].y - c2.y)) best = i;
+    return best;
+  };
+  const cornersOf = () => [
+    { x: box.x0, y: box.y0 },
+    { x: box.x1, y: box.y0 },
+    { x: box.x1, y: box.y1 },
+    { x: box.x0, y: box.y1 }
+  ].map(nearest);
+  let c = cornersOf();
+  const n = ring.length;
+  const fwd = (from, to) => (to - from + n) % n;
+  if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) {
+    ring = ring.slice().reverse();
+    c = cornersOf();
+    if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) return null;
+  }
+  if (new Set(c).size < 4) return null;
+  const walk = (from, to) => {
+    const out = [];
+    for (let i = from; ; i = (i + 1) % n) {
+      out.push(ring[i]);
+      if (i === to) break;
+    }
+    return out;
+  };
+  const top = polylineAt(walk(c[0], c[1]));
+  const right = polylineAt(walk(c[1], c[2]));
+  const bottomLR = polylineAt(walk(c[2], c[3]).reverse());
+  const leftTB = polylineAt(walk(c[3], c[0]).reverse());
+  const p00 = top(0);
+  const p10 = top(1);
+  const p01 = bottomLR(0);
+  const p11 = bottomLR(1);
+  const coons = (s, t) => {
+    const T = top(s);
+    const B = bottomLR(s);
+    const L = leftTB(t);
+    const R = right(t);
+    return {
+      x: (1 - t) * T.x + t * B.x + (1 - s) * L.x + s * R.x - ((1 - s) * (1 - t) * p00.x + s * (1 - t) * p10.x + (1 - s) * t * p01.x + s * t * p11.x),
+      y: (1 - t) * T.y + t * B.y + (1 - s) * L.y + s * R.y - ((1 - s) * (1 - t) * p00.y + s * (1 - t) * p10.y + (1 - s) * t * p01.y + s * t * p11.y)
+    };
+  };
+  return fitVectorMesh(coons, evenKnots(clampCount(columns)), evenKnots(clampCount(rows)));
+}
+function vectorMeshOutline(m) {
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const pt2 = (i, j) => m.points[j * nx + i];
+  const runs = [];
+  for (let i = 0; i + 3 < nx; i += 3) runs.push([pt2(i, 0), pt2(i + 1, 0), pt2(i + 2, 0), pt2(i + 3, 0)]);
+  for (let j = 0; j + 3 < ny; j += 3) runs.push([pt2(nx - 1, j), pt2(nx - 1, j + 1), pt2(nx - 1, j + 2), pt2(nx - 1, j + 3)]);
+  for (let i = nx - 1; i - 3 >= 0; i -= 3) runs.push([pt2(i, ny - 1), pt2(i - 1, ny - 1), pt2(i - 2, ny - 1), pt2(i - 3, ny - 1)]);
+  for (let j = ny - 1; j - 3 >= 0; j -= 3) runs.push([pt2(0, j), pt2(0, j - 1), pt2(0, j - 2), pt2(0, j - 3)]);
+  const anchors = runs.map((r, k) => {
+    const prev = runs[(k + runs.length - 1) % runs.length];
+    return { x: r[0].x, y: r[0].y, in: { ...prev[2] }, out: { ...r[1] } };
+  });
+  return { closed: true, anchors };
+}
+function vectorMeshEditPoints(m) {
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const anchors = [];
+  const handles = [];
+  for (let j = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const ri = i % 3;
+      const rj = j % 3;
+      if (ri === 0 && rj === 0) anchors.push(j * nx + i);
+      else if (ri === 0) handles.push({ index: j * nx + i, anchor: (rj === 1 ? j - 1 : j + 1) * nx + i });
+      else if (rj === 0) handles.push({ index: j * nx + i, anchor: j * nx + (ri === 1 ? i - 1 : i + 1) });
+    }
+  }
+  return { anchors, handles };
+}
+function vectorMeshGridCurves(m) {
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(m);
+  const pt2 = (i, j) => m.points[j * nx + i];
+  const out = [];
+  for (let j = 0; j < ny; j += 3) for (let i = 0; i + 3 < nx; i += 3) out.push([pt2(i, j), pt2(i + 1, j), pt2(i + 2, j), pt2(i + 3, j)]);
+  for (let i = 0; i < nx; i += 3) for (let j = 0; j + 3 < ny; j += 3) out.push([pt2(i, j), pt2(i, j + 1), pt2(i, j + 2), pt2(i, j + 3)]);
+  return out;
+}
+
 // src/vector/appearance.ts
 var VECTOR_EFFECT_DEFAULTS = {
   trim: { start: 0, end: 50, offset: 0, mode: "simultaneous" },
@@ -2251,7 +3101,8 @@ var VECTOR_EFFECT_DEFAULTS = {
     startOpacity: 100,
     endOpacity: 100,
     composite: "below"
-  }
+  },
+  envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null }
 };
 var VECTOR_EFFECT_LABELS = {
   trim: "Trim Paths",
@@ -2262,7 +3113,8 @@ var VECTOR_EFFECT_LABELS = {
   wiggle: "Wiggle Paths",
   offset: "Offset Paths",
   merge: "Merge Paths",
-  repeater: "Repeater"
+  repeater: "Repeater",
+  envelope: "Envelope"
 };
 var VECTOR_EFFECT_PARAM_SPECS = {
   trim: [
@@ -2348,8 +3200,65 @@ var VECTOR_EFFECT_PARAM_SPECS = {
         { value: "above", label: "Above" }
       ]
     }
+  ],
+  envelope: [
+    {
+      key: "style",
+      label: "Warp",
+      kind: "select",
+      options: [...VECTOR_WARP_STYLES.map((value) => ({ value, label: VECTOR_WARP_STYLE_LABELS[value] })), { value: "mesh", label: "Mesh" }]
+    },
+    { key: "bend", label: "Bend %", kind: "number", min: -100, max: 100, step: 1, slider: true },
+    { key: "horizontal", label: "Horizontal distortion %", kind: "number", min: -100, max: 100, step: 1, slider: true },
+    { key: "vertical", label: "Vertical distortion %", kind: "number", min: -100, max: 100, step: 1, slider: true },
+    {
+      key: "orientation",
+      label: "Orientation",
+      kind: "select",
+      options: [
+        { value: "horizontal", label: "Horizontal" },
+        { value: "vertical", label: "Vertical" }
+      ]
+    },
+    { key: "rows", label: "Mesh rows", kind: "number", min: 1, max: 16, step: 1 },
+    { key: "columns", label: "Mesh columns", kind: "number", min: 1, max: 16, step: 1 }
   ]
 };
+var cloneMesh = (m) => ({ us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => ({ x: p.x, y: p.y })) });
+function vectorEnvelopeMesh(params, bounds) {
+  if (params.style === "mesh") return params.mesh ?? vectorIdentityMesh(bounds, params.columns, params.rows);
+  const preset = vectorWarpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
+  return preset ? resizeVectorMesh(preset, params.columns, params.rows) : vectorIdentityMesh(bounds, params.columns, params.rows);
+}
+function vectorEnvelopeMap(params, bounds) {
+  if (!bounds || !(bounds.width > 0 && bounds.height > 0)) return null;
+  const mesh = params.style === "mesh" ? params.mesh : vectorWarpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
+  if (!mesh) return null;
+  const { x, y, width, height } = bounds;
+  return (p) => evalVectorMesh(mesh, (p.x - x) / width, (p.y - y) / height);
+}
+function pathsBounds(paths) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of paths) {
+    const b = bezierPathBounds(p);
+    if (!b) continue;
+    minX = Math.min(minX, b.minX);
+    minY = Math.min(minY, b.minY);
+    maxX = Math.max(maxX, b.maxX);
+    maxY = Math.max(maxY, b.maxY);
+  }
+  return minX <= maxX ? { x: minX, y: minY, width: maxX - minX, height: maxY - minY } : null;
+}
+function envelopePaths(paths, params) {
+  const bounds = pathsBounds(paths);
+  const f = vectorEnvelopeMap(params, bounds);
+  if (!f || !bounds) return paths;
+  const tol = Math.min(0.25, Math.max(0.01, Math.hypot(bounds.width, bounds.height) / 2e3));
+  return paths.map((p) => p.length ? mapBezierPath(p, f, tol) : p);
+}
 var isVec2 = (v2) => !!v2 && typeof v2 === "object" && Number.isFinite(v2.x) && Number.isFinite(v2.y);
 function normalizeVectorEffectParams(type, params, base) {
   const defaults = VECTOR_EFFECT_DEFAULTS[type];
@@ -2363,6 +3272,19 @@ function normalizeVectorEffectParams(type, params, base) {
     else if (spec.kind === "vec2" && isVec2(v2)) out[spec.key] = { x: v2.x, y: v2.y };
     else if (spec.kind === "select" && spec.options.some((o) => o.value === v2)) out[spec.key] = v2;
   }
+  if (type === "envelope") {
+    const o = out;
+    o.rows = Math.round(o.rows);
+    o.columns = Math.round(o.columns);
+    const given = params?.mesh;
+    let mesh = given !== void 0 ? isValidVectorMesh(given) ? cloneMesh(given) : null : o.mesh;
+    if (o.style !== "mesh") mesh = null;
+    if (mesh && given !== void 0) {
+      o.columns = mesh.us.length - 1;
+      o.rows = mesh.vs.length - 1;
+    } else if (mesh) mesh = resizeVectorMesh(mesh, o.columns, o.rows);
+    o.mesh = mesh;
+  }
   return out;
 }
 function createVectorEffect(type, id, params) {
@@ -2543,6 +3465,11 @@ function applyVectorEffects(shapes, effects) {
         list = [{ ...first, path: mergePaths(list.map((s) => s.path), e.params.mode) }];
         break;
       }
+      case "envelope": {
+        const params = e.params;
+        list = mapPaths(list, (p) => envelopePaths(p, params));
+        break;
+      }
       case "repeater": {
         const r = e.params;
         const copies = repeatPaths(
@@ -2589,14 +3516,35 @@ function liveBooleanShapes(group) {
   return [{ source, path: foldVectorBooleanOperands(operands), opacity: 1, order: [0] }];
 }
 var shapeCache = /* @__PURE__ */ new WeakMap();
+function baseShapes(node) {
+  if (node.type === "path") return [{ source: node, path: subpathsToBezier(node.subpaths), opacity: 1, order: [] }];
+  if (node.liveBoolean) return liveBooleanShapes(node);
+  return node.children.flatMap((c, i) => childShapes(c, i));
+}
+function vectorEffectInputPaths(node, effectId) {
+  const list = node.effects ?? [];
+  const i = list.findIndex((e) => e.id === effectId);
+  if (i < 0) return null;
+  return applyVectorEffects(baseShapes(node), list.slice(0, i)).map((s) => s.path);
+}
+function vectorEffectInputBounds(node, effectId) {
+  const paths = vectorEffectInputPaths(node, effectId);
+  return paths ? pathsBounds(paths) : null;
+}
+function vectorNodeEnvelope(node) {
+  return node?.effects?.find((e) => e.type === "envelope" && e.enabled !== false) ?? null;
+}
+function vectorEnvelopeFrame(node, effectId) {
+  const e = effectId ? node.effects?.find((x) => x.id === effectId) : vectorNodeEnvelope(node);
+  if (!e || e.type !== "envelope") return null;
+  const bounds = vectorEffectInputBounds(node, e.id);
+  if (!bounds || !(bounds.width > 0 && bounds.height > 0)) return null;
+  return { effectId: e.id, bounds, mesh: vectorEnvelopeMesh(e.params, bounds) };
+}
 function vectorAppearanceShapes(node) {
   const hit = shapeCache.get(node);
   if (hit) return hit;
-  let base;
-  if (node.type === "path") base = [{ source: node, path: subpathsToBezier(node.subpaths), opacity: 1, order: [] }];
-  else if (node.liveBoolean) base = liveBooleanShapes(node);
-  else base = node.children.flatMap((c, i) => childShapes(c, i));
-  const out = applyVectorEffects(base, node.effects).sort((a, b) => compareOrder(a.order, b.order));
+  const out = applyVectorEffects(baseShapes(node), node.effects).sort((a, b) => compareOrder(a.order, b.order));
   shapeCache.set(node, out);
   return out;
 }
@@ -2693,10 +3641,19 @@ function sanitizeVectorEffects(value) {
   }
   return out;
 }
-function transformVectorEffects(effects, m) {
+function transformVectorEffects(effects, m, node) {
   const lin = (v2) => ({ x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.y });
+  const full = (v2) => ({ x: m[0] * v2.x + m[2] * v2.y + m[4], y: m[1] * v2.x + m[3] * v2.y + m[5] });
   const mirror = m[0] * m[3] - m[1] * m[2] < 0 ? -1 : 1;
+  const axisScale = Math.abs(m[1]) < 1e-12 && Math.abs(m[2]) < 1e-12 && m[0] > 0 && m[3] > 0;
   return effects.map((e) => {
+    if (e.type === "envelope") {
+      if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: mapVectorMeshPoints(e.params.mesh, full) } } : e;
+      if (axisScale || !node) return e;
+      const bounds = vectorEffectInputBounds(node, e.id);
+      if (!bounds || !vectorEnvelopeMap(e.params, bounds)) return e;
+      return { ...e, params: { ...e.params, style: "mesh", mesh: mapVectorMeshPoints(vectorEnvelopeMesh(e.params, bounds), full) } };
+    }
     if (e.type === "twist") return { ...e, params: { ...e.params, center: lin(e.params.center), angle: e.params.angle * mirror } };
     if (e.type === "repeater")
       return { ...e, params: { ...e.params, position: lin(e.params.position), anchor: lin(e.params.anchor), rotation: e.params.rotation * mirror } };
@@ -3030,7 +3987,7 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
-  if (node.effects?.length) node = { ...node, effects: transformVectorEffects(node.effects, m) };
+  if (node.effects?.length) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
@@ -3835,8 +4792,8 @@ function resolveGradient(id, raw) {
     const len2 = Math.hypot(x2 - x1, y2 - y1);
     const d = len2 > 0 ? { x: (x2 - x1) / len2, y: (y2 - y1) / len2 } : { x: 0, y: 1 };
     const along2 = (x, y) => x * d.x + y * d.y;
-    const same = len2 > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along2(c.x1, c.y1) - along2(x1, y1)) < 1e-3 && Math.abs(along2(c.x2, c.y2) - along2(x2, y2)) < 1e-3;
-    if (same) return { type: "linear", angle, stops, ...spread };
+    const same2 = len2 > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along2(c.x1, c.y1) - along2(x1, y1)) < 1e-3 && Math.abs(along2(c.x2, c.y2) - along2(x2, y2)) < 1e-3;
+    if (same2) return { type: "linear", angle, stops, ...spread };
   }
   const start = { x: x1, y: y1 };
   const end = { x: x2, y: y2 };
@@ -4893,8 +5850,8 @@ function vectorBlendStepCount(a, b, options, length2) {
     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)) : length2;
-    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist4 / 2)));
+    const dist5 = 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)) : length2;
+    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist5 / 2)));
   }
   return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(1, Math.round(Number.isFinite(o.steps) ? o.steps : DEFAULT_VECTOR_BLEND_STEPS)));
 }
@@ -5065,6 +6022,169 @@ function releaseVectorBlend(group, newId) {
   return [...keys, group.transform ? transformVectorNode(path, m) : path];
 }
 
+// src/vector/perspective.ts
+function solve8(rows) {
+  const m = rows.map((r) => r.slice());
+  for (let col = 0; col < 8; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < 8; r++) if (Math.abs(m[r][col]) > Math.abs(m[pivot][col])) pivot = r;
+    if (!(Math.abs(m[pivot][col]) >= 1e-12)) return null;
+    [m[col], m[pivot]] = [m[pivot], m[col]];
+    const p = m[col];
+    for (let r = 0; r < 8; r++) {
+      if (r === col) continue;
+      const f = m[r][col] / p[col];
+      if (f !== 0) for (let k = 0; k < 9; k++) m[r][k] -= f * p[k];
+    }
+  }
+  const out = [];
+  for (let i = 0; i < 8; i++) {
+    const v2 = m[i][8] / m[i][i];
+    if (!Number.isFinite(v2)) return null;
+    out.push(v2);
+  }
+  return out;
+}
+function applyVectorHomography(h, p) {
+  const w = h[6] * p.x + h[7] * p.y + h[8];
+  if (!Number.isFinite(w) || Math.abs(w) < 1e-12) return null;
+  const x = (h[0] * p.x + h[1] * p.y + h[2]) / w;
+  const y = (h[3] * p.x + h[4] * p.y + h[5]) / w;
+  return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+}
+var finite = (p) => Number.isFinite(p.x) && Number.isFinite(p.y);
+function vectorHomography(from, to) {
+  if (from.length !== 4 || to.length !== 4 || ![...from, ...to].every(finite)) return null;
+  const rows = [];
+  for (let i = 0; i < 4; i++) {
+    const { x, y } = from[i];
+    const { x: u, y: v2 } = to[i];
+    rows.push([x, y, 1, 0, 0, 0, -u * x, -u * y, u]);
+    rows.push([0, 0, 0, x, y, 1, -v2 * x, -v2 * y, v2]);
+  }
+  const h = solve8(rows);
+  if (!h) return null;
+  const out = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7], 1];
+  for (let i = 0; i < 4; i++) {
+    const r = applyVectorHomography(out, from[i]);
+    const q = to[i];
+    const scale3 = 1 + Math.max(Math.abs(q.x), Math.abs(q.y));
+    if (!r || Math.abs(r.x - q.x) > 1e-6 * scale3 || Math.abs(r.y - q.y) > 1e-6 * scale3) return null;
+  }
+  return out;
+}
+function vectorHomographyKeepsQuad(h, quad) {
+  const ws = quad.map((p) => h[6] * p.x + h[7] * p.y + h[8]);
+  return ws.every((w) => w > 1e-9) || ws.every((w) => w < -1e-9);
+}
+function orderVectorQuad(points) {
+  if (points.length !== 4 || !points.every(finite)) return null;
+  const cx = points.reduce((s, p) => s + p.x, 0) / 4;
+  const cy = points.reduce((s, p) => s + p.y, 0) / 4;
+  const q = points.slice().sort((a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx));
+  let first = 0;
+  for (let i = 1; i < 4; i++) if (q[i].x + q[i].y < q[first].x + q[first].y) first = i;
+  const ordered = [...q.slice(first), ...q.slice(0, first)];
+  const cross2 = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+  const turns = ordered.map((_, i) => cross2(ordered[i], ordered[(i + 1) % 4], ordered[(i + 2) % 4]));
+  const area = turns.reduce((s, t) => s + t, 0) / 2;
+  const xs = ordered.map((p) => p.x);
+  const ys = ordered.map((p) => p.y);
+  const size = Math.max(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys));
+  const convex = turns.every((t) => t > 1e-9 * size * size);
+  return convex && area > 1e-6 * size * size ? ordered : null;
+}
+
+// src/vector/distort.ts
+var VECTOR_DISTORT_TOLERANCE = 0.05;
+var CORNER_INDEX = { nw: 0, ne: 1, se: 2, sw: 3 };
+var SIDE_CORNERS = { n: [0, 1], e: [1, 2], s: [2, 3], w: [3, 0] };
+var vectorBoxCorners = (b) => [
+  { x: b.x, y: b.y },
+  { x: b.x + b.width, y: b.y },
+  { x: b.x + b.width, y: b.y + b.height },
+  { x: b.x, y: b.y + b.height }
+];
+function vectorDistortQuad(b, handle, d, mode = "distort") {
+  const q = vectorBoxCorners(b);
+  const i = CORNER_INDEX[handle];
+  if (i !== void 0) {
+    if (mode === "perspective") {
+      if (Math.abs(d.x) >= Math.abs(d.y)) {
+        const partner = [1, 0, 3, 2][i];
+        q[i].x += d.x;
+        q[partner].x -= d.x;
+      } else {
+        const partner = [3, 2, 1, 0][i];
+        q[i].y += d.y;
+        q[partner].y -= d.y;
+      }
+    } else {
+      q[i].x += d.x;
+      q[i].y += d.y;
+    }
+    return q;
+  }
+  const side = SIDE_CORNERS[handle];
+  if (side) for (const k of side) q[k] = { x: q[k].x + d.x, y: q[k].y + d.y };
+  return q;
+}
+var about = (o, m) => multiplyMatrices(multiplyMatrices([1, 0, 0, 1, -o.x, -o.y], m), [1, 0, 0, 1, o.x, o.y]);
+function vectorShearForSide(b, handle, d, fromCenter = false) {
+  const center = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+  if (handle === "n" || handle === "s") {
+    const o = fromCenter ? center : { x: center.x, y: handle === "n" ? b.y + b.height : b.y };
+    const lever = (handle === "n" ? b.y : b.y + b.height) - o.y;
+    return about(o, [1, 0, Math.abs(lever) > 1e-9 ? d.x / lever : 0, 1, 0, 0]);
+  }
+  if (handle === "e" || handle === "w") {
+    const o = fromCenter ? center : { x: handle === "w" ? b.x + b.width : b.x, y: center.y };
+    const lever = (handle === "w" ? b.x : b.x + b.width) - o.x;
+    return about(o, [1, Math.abs(lever) > 1e-9 ? d.y / lever : 0, 0, 1, 0, 0]);
+  }
+  return [1, 0, 0, 1, 0, 0];
+}
+function vectorSkewMatrix(ax, ay, origin = { x: 0, y: 0 }) {
+  const tx = Math.tan(ax * Math.PI / 180);
+  const ty = Math.tan(ay * Math.PI / 180);
+  return about(origin, [1, ty, tx, 1, 0, 0]);
+}
+function mapEffects(node, f) {
+  if (!node.effects?.length) return void 0;
+  return node.effects.map((e) => {
+    if (e.type !== "envelope") return e;
+    if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: mapVectorMeshPoints(e.params.mesh, f) } } : e;
+    const bounds = vectorEffectInputBounds(node, e.id);
+    if (!bounds || !vectorEnvelopeMap(e.params, bounds)) return e;
+    return { ...e, params: { ...e.params, style: "mesh", mesh: mapVectorMeshPoints(vectorEnvelopeMesh(e.params, bounds), f) } };
+  });
+}
+function distortVectorNode(node, parentToDoc, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
+  const toDoc = multiplyMatrices(nodeMatrix(node), parentToDoc);
+  const inv = invertMatrix(toDoc);
+  const local = (p) => applyMatrix(inv, f(applyMatrix(toDoc, p)));
+  const effects = mapEffects(node, local);
+  if (node.type === "group") {
+    const group = node;
+    const children = group.children.map((c) => distortVectorNode(c, toDoc, f, tolerance));
+    const spine = group.blend?.spine;
+    return {
+      ...group,
+      children,
+      ...effects ? { effects } : {},
+      ...spine ? { blend: { ...group.blend, spine: mapVectorSubpaths([spine], local, tolerance)[0] } } : {}
+    };
+  }
+  const path = node;
+  return {
+    ...path,
+    ...effects ? { effects } : {},
+    ...path.fill !== void 0 ? { fill: mapVectorPaint(path.fill, local) } : {},
+    ...path.stroke !== void 0 ? { stroke: mapVectorPaint(path.stroke, local) } : {},
+    subpaths: mapVectorSubpaths(path.subpaths, local, tolerance)
+  };
+}
+
 // src/vector/snap.ts
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
@@ -5106,8 +6226,8 @@ function within(sorted, key, v2, tol) {
 }
 var linesNear = (lines, v2, tol) => within(lines, (l) => l.v, v2, tol);
 var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
-var toPoint = (p) => [p.x, p.y];
-var toVec2 = (p) => ({ x: p[0], y: p[1] });
+var toPoint2 = (p) => [p.x, p.y];
+var toVec3 = (p) => ({ x: p[0], y: p[1] });
 var LABELS = {
   anchor: "anchor",
   centre: "centre",
@@ -5225,7 +6345,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count && budget > 0; i++) {
       if (moving(i) || moving((i + 1) % n)) continue;
-      const seg = subpathSegment(sp, i).map((q) => toPoint(applyMatrix(m, toVec2(q))));
+      const seg = subpathSegment(sp, i).map((q) => toPoint2(applyMatrix(m, toVec3(q))));
       let minX = Infinity;
       let minY = Infinity;
       let maxX = -Infinity;
@@ -5432,7 +6552,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
   /** Target segments whose control box reaches `p` and which pass within `tol` of it, nearest first. */
   segmentsNear(p, tol) {
     const out = [];
-    const pt2 = toPoint(p);
+    const pt2 = toPoint2(p);
     for (const s of this.segments) {
       if (p.x < s.minX - tol || p.x > s.maxX + tol || p.y < s.minY - tol || p.y > s.maxY + tol) continue;
       const hit = segmentNearest(s.seg, pt2);
@@ -5441,7 +6561,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
     return out.sort((a, b) => a.distance - b.distance);
   }
   onSegment(near2) {
-    return near2.length ? toVec2(segmentPoint(near2[0].seg, near2[0].t)) : null;
+    return near2.length ? toVec3(segmentPoint(near2[0].seg, near2[0].t)) : null;
   }
   /** Where two of the target segments near `p` cross, the crossing nearest `p` within `tol`. */
   crossing(near2, p, tol) {
@@ -5451,7 +6571,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
     for (let i = 0; i < list.length; i++) {
       for (let j = i + 1; j < list.length; j++) {
         for (const hit of segmentIntersections(list[i].seg, list[j].seg)) {
-          const q = toVec2(hit.point);
+          const q = toVec3(hit.point);
           const d = distance(q, p);
           if (d <= tol && d < bestD) {
             best = q;
@@ -6030,7 +7150,7 @@ function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   return cutSubpathAt(subpath, [index]);
 }
 var endOf2 = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
-var dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var dist3 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 function reverse(sp) {
   return {
     closed: sp.closed,
@@ -6057,7 +7177,7 @@ function joinSubpaths(subpaths, tolerance) {
     const sp = open[0];
     const first = sp.anchors[0];
     const last = sp.anchors[sp.anchors.length - 1];
-    if (sp.anchors.length > 2 && dist2(first, last) <= tolerance) {
+    if (sp.anchors.length > 2 && dist3(first, last) <= tolerance) {
       sp.anchors.pop();
       sp.anchors[0] = tidy({ ...first, in: last.in ?? null }, false);
     } else {
@@ -6073,7 +7193,7 @@ function joinSubpaths(subpaths, tolerance) {
       for (let j = i + 1; j < open.length; j++) {
         for (const ei of [false, true]) {
           for (const ej of [false, true]) {
-            const d = dist2(endOf2(open[i], ei), endOf2(open[j], ej));
+            const d = dist3(endOf2(open[i], ei), endOf2(open[j], ej));
             if (d < best.d) best = { d, i, j, ei, ej };
           }
         }
@@ -6113,8 +7233,8 @@ function smoothSubpath(sp, amount = 1, only) {
     const p = orig[i];
     const dir = unit4(next.x - prev.x, next.y - prev.y);
     if (!dir) continue;
-    const li = dist2(p, prev) / 3;
-    const lo = dist2(p, next) / 3;
+    const li = dist3(p, prev) / 3;
+    const lo = dist3(p, next) / 3;
     const hin = p.in ?? p;
     const hout = p.out ?? p;
     const target = (h, x, y) => ({ x: h.x + (x - h.x) * t, y: h.y + (y - h.y) * t });
@@ -6605,7 +7725,7 @@ function vectorInkShapeName(shape) {
       return shape.points.length === 3 ? "triangle" : "polygon";
   }
 }
-var dist3 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+var dist4 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
 function bbox(pts) {
   if (!pts.length) return [0, 0, 0, 0];
   let [x0, y0] = pts[0];
@@ -6623,7 +7743,7 @@ function segDistance(a, b, p) {
   const dy = b[1] - a[1];
   const len2 = dx * dx + dy * dy;
   const t = len2 > 0 ? Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2)) : 0;
-  return dist3([a[0] + t * dx, a[1] + t * dy], p);
+  return dist4([a[0] + t * dx, a[1] + t * dy], p);
 }
 function polygonDistance(c, p) {
   let best = Infinity;
@@ -6685,7 +7805,7 @@ function corners(p, diag) {
   let far = 0;
   let farD = 0;
   p.forEach((q, i) => {
-    const d = dist3(start, q);
+    const d = dist4(start, q);
     if (d > farD) {
       farD = d;
       far = i;
@@ -6712,7 +7832,7 @@ function corners(p, diag) {
     }
     let short = -1;
     for (let j = 0; j < n; j++) {
-      if (dist3(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
+      if (dist4(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
         short = j;
         break;
       }
@@ -6752,8 +7872,8 @@ function recognizeInkShape(points, options = {}) {
   const diag = Math.hypot(w, h);
   if (size < minSize) return null;
   let length2 = 0;
-  for (let i = 1; i < p.length; i++) length2 += dist3(p[i - 1], p[i]);
-  const gap = dist3(first, last);
+  for (let i = 1; i < p.length; i++) length2 += dist4(p[i - 1], p[i]);
+  const gap = dist4(first, last);
   if (gap > 0.85 * length2 && gap >= minSize) {
     const off = Math.max(...p.map((q) => segDistance(first, last, q)));
     if (off <= Math.max(0.06 * gap, 1.5 * minSize / 6)) return { kind: "line", a: first, b: last };
@@ -7194,8 +8314,8 @@ function getVectorSelectionFrame(doc, ids) {
   const nodes = ids.map((id) => ({ node: findVectorNode(doc.nodes, id), parent: vectorParentMatrix(doc.nodes, id) ?? IDENTITY_MATRIX })).filter((n) => n.node);
   if (!nodes.length) return null;
   const angles = nodes.map((n) => matrixRotation(multiplyMatrices(nodeMatrix(n.node), n.parent)));
-  const same = angles.every((a) => Math.abs(normalizeAngle(a - angles[0])) < 1e-6);
-  const angle = same ? angles[0] : 0;
+  const same2 = angles.every((a) => Math.abs(normalizeAngle(a - angles[0])) < 1e-6);
+  const angle = same2 ? angles[0] : 0;
   const unrotate = rotateMatrix(-angle);
   const b = unionBounds(nodes.map((n) => vectorNodeBounds(n.node, multiplyMatrices(n.parent, unrotate))));
   return b ? { ...b, angle } : null;
@@ -7230,6 +8350,13 @@ function getVectorSelectionBoxGeometry(frame2, viewport) {
   const r = (n) => Math.round(n * 1e3) / 1e3;
   return { box, angle: frame2.angle, transform: frame2.angle ? `rotate(${r(frame2.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners: corners2 };
 }
+function getVectorEnvelopeTarget(doc, selection) {
+  if (selection.length !== 1) return null;
+  const node = findVectorNode(doc.nodes, selection[0]);
+  if (!node || !vectorNodeEnvelope(node)) return null;
+  const frame2 = vectorEnvelopeFrame(node);
+  return frame2 ? { node, frame: frame2, world: vectorWorldMatrix(doc.nodes, node.id) ?? IDENTITY_MATRIX } : null;
+}
 var RESIZE_CURSOR_ORDER = ["ew-resize", "nwse-resize", "ns-resize", "nesw-resize"];
 var HANDLE_ANGLES = { e: 0, se: 45, s: 90, sw: 135, w: 180, nw: 225, n: 270, ne: 315 };
 function vectorResizeCursor(handle, angle = 0) {
@@ -7254,7 +8381,8 @@ var TOOL_LABELS = {
   shapeBuilder: "Shape Builder",
   paintBucket: "Paint Bucket",
   blend: "Blend",
-  gradient: "Gradient"
+  gradient: "Gradient",
+  envelope: "Envelope Mesh"
 };
 var TOOL_KEYS = {
   v: "select",
@@ -7273,7 +8401,8 @@ var TOOL_KEYS = {
   m: "shapeBuilder",
   b: "paintBucket",
   j: "blend",
-  g: "gradient"
+  g: "gradient",
+  u: "envelope"
 };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
@@ -7295,7 +8424,8 @@ var VECTOR_TOOL_SHORTCUTS = {
   shapeBuilder: "M",
   paintBucket: "B",
   blend: "J",
-  gradient: "G"
+  gradient: "G",
+  envelope: "U"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -7314,7 +8444,8 @@ var VECTOR_TOOL_GLYPHS = {
   shapeBuilder: "\u2295",
   paintBucket: "\u25CD",
   blend: "\u29D3",
-  gradient: "\u25D0"
+  gradient: "\u25D0",
+  envelope: "\u2317"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -7367,7 +8498,7 @@ function spliceTree(nodes, id, replacements) {
   }
   return changed ? out : nodes;
 }
-var toPoint2 = (p) => [p.x, p.y];
+var toPoint3 = (p) => [p.x, p.y];
 var placementOf = (n) => ({
   ...n.transform ? { transform: n.transform } : {},
   ...n.visible === false ? { visible: false } : {},
@@ -7412,6 +8543,7 @@ var VectorEditorController = class {
   /** Options new blends get (the toolbars edit them along with the selected blend's). */
   blendDefaults = {};
   gradientEdit = { target: "fill", stop: null };
+  freeDistort = false;
   /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
   builderHoverKey = null;
   createId;
@@ -7435,6 +8567,7 @@ var VectorEditorController = class {
     this.hitRadius = options.hitRadius ?? 6;
     this.createId = options.createId ?? defaultCreateId;
     this.onChange = options.onChange;
+    this.freeDistort = !!options.freeDistort;
     this.state = this.computeState();
     this.connect();
   }
@@ -7506,6 +8639,7 @@ var VectorEditorController = class {
       blendStart: this.blendStart,
       blendDefaults: this.blendDefaults,
       gradientEdit: this.gradientEdit,
+      freeDistort: this.freeDistort,
       canUndo: h.canUndo,
       canRedo: h.canRedo,
       undoLabel: h.undoName,
@@ -7560,8 +8694,13 @@ var VectorEditorController = class {
     const h = this.hover;
     switch (this.tool) {
       case "select":
+        if (h?.transformHandle && this.freeDistort && h.transformHandle !== "rotate") return "crosshair";
         if (h?.transformHandle) return vectorResizeCursor(h.transformHandle, this.frameOf(this.selectedRoots())?.angle ?? 0);
         return h?.nodeId ? "move" : "default";
+      case "envelope":
+        if (this.drag?.kind === "envelope") return "grabbing";
+        if (h?.envelope) return h.envelope.index === null ? "grab" : "pointer";
+        return h?.nodeId ? "pointer" : "default";
       case "direct":
         if (h?.anchor || h?.handle || h?.corner) return "pointer";
         if (h?.segment) return "copy";
@@ -8521,7 +9660,8 @@ var VectorEditorController = class {
         const i = list.findIndex((e2) => e2.id === effectId);
         if (i < 0) return `Node "${nodeId}" has no effect "${effectId}".`;
         const e = list[i];
-        const params = patch.params ? normalizeVectorEffectParams(e.type, patch.params, e.params) : e.params;
+        const raw = patch.params && e.type === "envelope" && node ? this.envelopeParams(node, e, patch.params) : patch.params;
+        const params = raw ? normalizeVectorEffectParams(e.type, raw, e.params) : e.params;
         const next = { ...e, params, ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {} };
         if (next.enabled !== false) delete next.enabled;
         return list.map((x, j) => j === i ? next : x);
@@ -8661,6 +9801,318 @@ var VectorEditorController = class {
     if (!angle) return m;
     return multiplyMatrices(multiplyMatrices(rotateMatrix(-angle), m), rotateMatrix(angle));
   }
+  /** The selection frame's corners in document space, clockwise from the top left. */
+  frameCorners(frame2) {
+    const rot = rotateMatrix(frame2.angle);
+    return vectorBoxCorners(frame2).map((c) => frame2.angle ? applyMatrix(rot, c) : c);
+  }
+  /** `doc` with nodes `ids` sent through `f` (a map of document space), each in its own space (see `distortVectorNode`). */
+  distorted(doc, ids, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
+    const visit = (list, parent) => {
+      let changed = false;
+      const out = list.map((n) => {
+        let next = n;
+        if (ids.has(n.id) && !n.locked) next = distortVectorNode(n, parent, f, tolerance);
+        else if (n.type === "group") {
+          const children = visit(n.children, multiplyMatrices(nodeMatrix(n), parent));
+          if (children !== n.children) next = { ...n, children };
+        }
+        if (next !== n) changed = true;
+        return next;
+      });
+      return changed ? out : list;
+    };
+    const nodes = visit(doc.nodes, IDENTITY_MATRIX);
+    return nodes === doc.nodes ? doc : { ...doc, nodes };
+  }
+  /**
+   * Free Distort mode of the selection box (`state.freeDistort`): dragging a corner distorts the
+   * selection in perspective, each corner on its own (Shift+Alt+Mod: symmetric perspective, the
+   * corner beside it moving the other way); dragging a side moves its two corners; Mod-dragging a
+   * side skews along it (Alt: about the centre). Each drag is one undo step.
+   */
+  setFreeDistort(on) {
+    if (this.freeDistort === on) return;
+    this.freeDistort = on;
+    this.notify();
+  }
+  /**
+   * Distorts the selected (or given) nodes so the corners of their selection box (clockwise from
+   * the top left, in the box's own rotation) land on `corners` (document space): a projective map,
+   * so straight lines stay straight. Curves are followed within `tolerance` (document units).
+   * One undo step.
+   */
+  distort(corners2, options = {}) {
+    const ids = options.ids ?? this.selectedRoots();
+    const frame2 = this.frameOf(ids);
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    if (!(frame2.width > 0 && frame2.height > 0)) return { ok: false, message: "The selection has no area to distort." };
+    const from = this.frameCorners(frame2);
+    const h = corners2.length === 4 ? vectorHomography(from, corners2) : null;
+    if (!h || !vectorHomographyKeepsQuad(h, from)) return { ok: false, message: "The four corners must make a convex quadrilateral, clockwise from the top left." };
+    this.change("Distort", () => {
+      this.doc = this.distorted(this.doc, new Set(ids), (p) => applyVectorHomography(h, p) ?? p, options.tolerance);
+    });
+    return { ok: true };
+  }
+  /**
+   * Skews the selected (or given) nodes along the selection box's own axes by `ax` degrees
+   * horizontally (x' = x + tan(ax)·y: vertical lines lean right for positive angles) and `ay`
+   * vertically, about `origin` (default: the box centre, document space). One undo step.
+   */
+  skew(ax, ay = 0, options = {}) {
+    const frame2 = this.frameOf(options.ids ?? this.selectedRoots());
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    if (![ax, ay].every((v2) => Number.isFinite(v2) && Math.abs(v2) < 89.9)) return { ok: false, message: "Skew angles must be between \u221289.9\xB0 and 89.9\xB0." };
+    const origin = applyMatrix(rotateMatrix(-frame2.angle), options.origin ?? this.frameCenter(frame2));
+    return this.transform(this.inFrame(frame2.angle, vectorSkewMatrix(ax, ay, origin)), { ids: options.ids, label: "Skew" });
+  }
+  /** A selection box handle dragged in Free Distort mode. */
+  moveDistort(drag, p, input) {
+    const angle = drag.frame.angle;
+    const unrotate = (v2) => angle ? applyMatrix(rotateMatrix(-angle), v2) : v2;
+    const q = unrotate(p);
+    const q0 = unrotate(drag.start);
+    const d = { x: q.x - q0.x, y: q.y - q0.y };
+    const ids = new Set(this.selectedRoots());
+    const from = this.frameCorners(drag.frame);
+    const corner = drag.handle.length === 2;
+    this.setGuides(null);
+    if (!corner && input.mod) {
+      const m = this.inFrame(angle, vectorShearForSide(drag.frame, drag.handle, d, !!input.alt));
+      drag.op = "Skew";
+      this.doc = this.transformed(drag.base, ids, m);
+      this.interaction = { type: "distort", mode: "skew", corners: from.map((c) => applyMatrix(m, c)) };
+      this.notify(true);
+      return;
+    }
+    const mode = corner && input.mod && input.alt && input.shift ? "perspective" : "distort";
+    const rot = rotateMatrix(angle);
+    const quad = vectorDistortQuad(drag.frame, drag.handle, d, mode).map((c) => angle ? applyMatrix(rot, c) : c);
+    const h = vectorHomography(from, quad);
+    if (!h || !vectorHomographyKeepsQuad(h, from)) return;
+    drag.op = mode === "perspective" ? "Perspective" : "Distort";
+    this.doc = this.distorted(drag.base, ids, (pt2) => applyVectorHomography(h, pt2) ?? pt2);
+    this.interaction = { type: "distort", mode, corners: quad };
+    this.notify(true);
+  }
+  // -------------------------------------------------------------------------
+  // Envelopes
+  // -------------------------------------------------------------------------
+  /** Selected (or given) roots that can carry an envelope. */
+  envelopeTargets(ids) {
+    return this.effectTargets(ids).filter((n) => !n.locked);
+  }
+  /** Envelope parameters for `node` after `patch`: a preset switched to a mesh becomes the mesh it stood for. */
+  envelopeParams(node, current, patch) {
+    if (patch.style !== "mesh" || patch.mesh !== void 0 || !current || current.params.style === "mesh") return patch;
+    const frame2 = vectorEnvelopeFrame(node, current.id);
+    if (!frame2) return patch;
+    const rows = typeof patch.rows === "number" ? patch.rows : current.params.rows;
+    const columns = typeof patch.columns === "number" ? patch.columns : current.params.columns;
+    return { ...patch, mesh: resizeVectorMesh(frame2.mesh, columns, rows) };
+  }
+  /**
+   * Gives the selected (or given) nodes an envelope distortion, or changes the one they have: a
+   * warp preset (`style` with `bend`, `horizontal` and `vertical` in percent and `orientation`) or
+   * a mesh (`style: 'mesh'` with `rows` and `columns`, and optionally its `mesh` points). The
+   * envelope stays live (an `envelope` effect: edit it with the Envelope tool, Expand Appearance
+   * bakes it). One undo step (with `merge`, consecutive changes fold into one, as a slider drag
+   * should). Returns the envelope of each node.
+   */
+  envelope(params = {}, options = {}) {
+    const targets = this.envelopeTargets(options.ids);
+    if (!targets.length) return [];
+    const out = [];
+    const next = /* @__PURE__ */ new Map();
+    const raw = params;
+    for (const node of targets) {
+      const list = node.effects ?? [];
+      const current = list.find((e) => e.type === "envelope") ?? null;
+      if (current) {
+        const p = normalizeVectorEffectParams("envelope", this.envelopeParams(node, current, raw), current.params);
+        const { enabled: _e, ...rest } = current;
+        next.set(node.id, { ...node, effects: list.map((e) => e === current ? { ...rest, params: p } : e) });
+        out.push({ nodeId: node.id, effectId: current.id });
+      } else {
+        let k = list.length + 1;
+        while (list.some((e) => e.id === `fx${k}`)) k++;
+        const effect = createVectorEffect("envelope", `fx${k}`, raw);
+        next.set(node.id, { ...node, effects: [...list, effect] });
+        out.push({ nodeId: node.id, effectId: effect.id });
+      }
+    }
+    const made = out.some((o) => !targets.find((n) => n.id === o.nodeId)?.effects?.some((e) => e.id === o.effectId));
+    const merge = options.merge ? `envelope:${out.map((o) => o.nodeId).join(",")}` : void 0;
+    this.change(made ? params.style === "mesh" ? "Make Envelope with Mesh" : "Make Envelope with Warp" : "Edit Envelope", () => this.setDoc(mapTree(this.doc.nodes, (n) => next.get(n.id) ?? n)), merge);
+    return out;
+  }
+  /**
+   * Make with Top Object: the topmost selected object's outline (a closed path) becomes the envelope
+   * of the other selected objects (grouped when there are several; they must share a parent), as a
+   * mesh of `columns × rows` patches whose border follows the outline. The top object is used up.
+   * One undo step; returns the id of the enveloped node.
+   */
+  makeEnvelopeWithTopObject(options = {}) {
+    const ids = options.ids ?? this.selectedRoots();
+    if (ids.length < 2) return { ok: false, message: "Select the objects and, on top of them, the shape to use as the envelope." };
+    const order = /* @__PURE__ */ new Map();
+    walkVectorNodes(this.doc.nodes, (n) => order.set(n.id, order.size));
+    const sorted = ids.filter((id) => order.has(id)).sort((a, b) => order.get(a) - order.get(b));
+    const topId = sorted[sorted.length - 1];
+    const top = this.getNode(topId);
+    const outline = top?.type === "path" ? top.subpaths.find((sp) => sp.closed && sp.anchors.length > 1) : void 0;
+    if (!top || !outline) return { ok: false, message: "The top object must be a path with a closed outline." };
+    const contents = sorted.slice(0, -1).map((id) => this.getNode(id));
+    if (contents.some((n) => n.locked)) return { ok: false, message: "Locked objects cannot be enveloped." };
+    const parents = contents.map((n) => locateVectorNode(this.doc.nodes, n.id)?.parent?.id ?? null);
+    if (parents.some((p) => p !== parents[0])) return { ok: false, message: "The objects to envelope must be in the same group." };
+    const target = contents.length === 1 ? contents[0] : { id: this.newId(), type: "group", name: "Envelope", children: contents.map((n) => n) };
+    const parentToDoc = parents[0] ? this.worldOf(parents[0]) : IDENTITY_MATRIX;
+    const targetToDoc = multiplyMatrices(nodeMatrix(target), parentToDoc);
+    const toLocal = multiplyMatrices(this.worldOf(topId), invertMatrix(targetToDoc));
+    const local = {
+      closed: true,
+      anchors: outline.anchors.map((a) => ({
+        ...applyMatrix(toLocal, a),
+        ...a.in ? { in: applyMatrix(toLocal, a.in) } : {},
+        ...a.out ? { out: applyMatrix(toLocal, a.out) } : {}
+      }))
+    };
+    const mesh = vectorMeshFromOutline(local, options.columns ?? 4, options.rows ?? 4);
+    if (!mesh) return { ok: false, message: "The top object\u2019s outline is too small to use as an envelope." };
+    const list = target.effects ?? [];
+    let k = list.length + 1;
+    while (list.some((e) => e.id === `fx${k}`)) k++;
+    const effect = createVectorEffect("envelope", `fx${k}`, { style: "mesh", mesh });
+    const enveloped = { ...target, effects: [...list, effect] };
+    this.change("Make Envelope with Top Object", () => {
+      let nodes = spliceTree(this.doc.nodes, topId, []);
+      if (contents.length === 1) nodes = spliceTree(nodes, target.id, [enveloped]);
+      else {
+        const last = contents[contents.length - 1].id;
+        for (const n of contents.slice(0, -1)) nodes = spliceTree(nodes, n.id, []);
+        nodes = spliceTree(nodes, last, [enveloped]);
+      }
+      this.setDoc(nodes);
+      this.selection = [target.id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return { ok: true, nodeId: target.id };
+  }
+  /**
+   * Release: the selected (or given) nodes lose their envelope, and its shape (the mesh's border)
+   * comes back as a path above each of them. One undo step; returns the new paths' ids.
+   */
+  releaseEnvelope(options = {}) {
+    const targets = this.envelopeTargets(options.ids).filter((n) => n.effects?.some((e) => e.type === "envelope"));
+    if (!targets.length) return [];
+    const created = [];
+    const replace = /* @__PURE__ */ new Map();
+    for (const node of targets) {
+      const effect = node.effects.find((e) => e.type === "envelope");
+      const frame2 = vectorEnvelopeFrame(node, effect.id);
+      const rest = node.effects.filter((e) => e !== effect);
+      const { effects: _e, ...plain3 } = node;
+      const kept = rest.length ? { ...plain3, effects: rest } : plain3;
+      if (!frame2) {
+        replace.set(node.id, [kept]);
+        continue;
+      }
+      const id = this.newId();
+      created.push(id);
+      const shape = {
+        id,
+        type: "path",
+        name: "Envelope",
+        ...node.transform ? { transform: node.transform } : {},
+        subpaths: [vectorMeshOutline(frame2.mesh)],
+        fill: null,
+        stroke: "#808080",
+        strokeWidth: 1
+      };
+      replace.set(node.id, [kept, shape]);
+    }
+    this.change("Release Envelope", () => {
+      let nodes = this.doc.nodes;
+      for (const [id, list] of replace) nodes = spliceTree(nodes, id, list);
+      this.setDoc(nodes);
+      this.selection = [...targets.map((n) => n.id), ...created];
+      this.anchors = [];
+    });
+    return created;
+  }
+  /** The selected node the Envelope tool edits, with its mesh (node space) and node → document matrix. */
+  envelopeTarget() {
+    const target = getVectorEnvelopeTarget(this.doc, this.selection);
+    return target && !target.node.locked ? target : null;
+  }
+  /** The envelope mesh point under `screen` (handles first), or a spot inside the mesh. */
+  hitEnvelope(screen, p) {
+    const target = this.envelopeTarget();
+    if (!target) return null;
+    const { mesh } = target.frame;
+    const pts = vectorMeshEditPoints(mesh);
+    let best = null;
+    let bestD = Infinity;
+    for (const index of [...pts.handles.map((h) => h.index), ...pts.anchors]) {
+      const s = this.documentToScreen(applyMatrix(target.world, mesh.points[index]));
+      const d = Math.hypot(s.x - screen.x, s.y - screen.y);
+      if (d <= this.hitRadius && d < bestD - 0.5) {
+        best = index;
+        bestD = d;
+      }
+    }
+    if (best !== null) return { target, index: best, s: 0, t: 0 };
+    const local = applyMatrix(invertMatrix(target.world), p);
+    const at2 = vectorMeshParamAt(mesh, local);
+    if (at2.distance > this.tolerance()) return null;
+    return { target, index: null, s: at2.s, t: at2.t };
+  }
+  downEnvelope(screen, p, input) {
+    const hit = this.hitEnvelope(screen, p);
+    if (hit) {
+      const { node: node2, frame: frame2 } = hit.target;
+      this.drag = {
+        kind: "envelope",
+        nodeId: node2.id,
+        effectId: frame2.effectId,
+        base: frame2.mesh,
+        baseDoc: this.doc,
+        before: this.snapshot(),
+        index: hit.index,
+        s: hit.s,
+        t: hit.t,
+        start: this.toLocal(node2.id, p),
+        moved: false
+      };
+      this.interaction = { type: "envelope", nodeId: node2.id, index: hit.index };
+      this.notify();
+      return;
+    }
+    const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+    if (node) this.selection = input.shift ? this.selection.includes(node.id) ? this.selection.filter((id) => id !== node.id) : [...this.selection, node.id] : [node.id];
+    else if (!input.shift) this.selection = [];
+    this.anchors = [];
+    this.notify();
+  }
+  moveEnvelope(drag, p) {
+    const local = this.toLocal(drag.nodeId, p, drag.baseDoc);
+    const d = { x: local.x - drag.start.x, y: local.y - drag.start.y };
+    if (!drag.moved && Math.hypot(d.x, d.y) * this.viewport.zoom < 1) return;
+    drag.moved = true;
+    const mesh = drag.index !== null ? dragVectorMeshPoint(drag.base, drag.index, d) : pullVectorMesh(drag.base, drag.s, drag.t, d);
+    const nodes = mapTree(drag.baseDoc.nodes, (n) => {
+      if (n.id !== drag.nodeId) return n;
+      const effects = (n.effects ?? []).map(
+        (e) => e.id === drag.effectId && e.type === "envelope" ? { ...e, params: { ...e.params, style: "mesh", mesh, columns: mesh.us.length - 1, rows: mesh.vs.length - 1 } } : e
+      );
+      return { ...n, effects };
+    });
+    this.doc = { ...drag.baseDoc, nodes };
+    this.notify(true);
+  }
   /** Applies a matrix to the selected (or given) nodes as one undo step. */
   transform(matrix, options = {}) {
     const ids = new Set(options.ids ?? this.selectedRoots());
@@ -9809,7 +11261,7 @@ var VectorEditorController = class {
     });
     const visible = (p) => !blocked.has(p.id);
     if (ids?.length || this.selection.length) return this.pathTargets(ids ?? this.selection).filter(visible);
-    const box = polylineBounds(points.map(toPoint2), pad);
+    const box = polylineBounds(points.map(toPoint3), pad);
     if (!box) return [];
     const out = [];
     walkVectorNodes(this.doc.nodes, (n) => {
@@ -9822,7 +11274,7 @@ var VectorEditorController = class {
   /** A stroke's points in node `id`'s own space. */
   localPoints(id, points) {
     const inv = invertMatrix(this.worldOf(id));
-    return points.map((p) => toPoint2(applyMatrix(inv, p)));
+    return points.map((p) => toPoint3(applyMatrix(inv, p)));
   }
   /**
    * Knife: cuts closed paths along the polyline `points` (document space) wherever it crosses
@@ -9831,7 +11283,7 @@ var VectorEditorController = class {
    * when nothing was cut).
    */
   knife(points, options = {}) {
-    const pts = simplifyPolyline(points.map(toPoint2), 0.25 / this.viewport.zoom).map(([x, y]) => ({ x, y }));
+    const pts = simplifyPolyline(points.map(toPoint3), 0.25 / this.viewport.zoom).map(([x, y]) => ({ x, y }));
     if (pts.length < 2) return [];
     const plan = [];
     for (const node of this.strokeTargets(pts, options.ids, 0)) {
@@ -9860,7 +11312,7 @@ var VectorEditorController = class {
   erase(points, options = {}) {
     const width = options.size ?? this.editing.eraserSize;
     if (!(width > 0) || !points.length) return [];
-    const pts = simplifyPolyline(points.map(toPoint2), Math.min(width * 0.05, 0.25 / this.viewport.zoom));
+    const pts = simplifyPolyline(points.map(toPoint3), Math.min(width * 0.05, 0.25 / this.viewport.zoom));
     const region = eraserRegion(pts, width);
     if (!region.length) return [];
     const plan = [];
@@ -10128,6 +11580,12 @@ var VectorEditorController = class {
         const path = this.hitPath(p);
         return path ? { nodeId: path.id } : null;
       }
+      case "envelope": {
+        const hit = this.hitEnvelope(screen, p);
+        if (hit) return { nodeId: hit.target.node.id, envelope: { nodeId: hit.target.node.id, index: hit.index } };
+        const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+        return node ? { nodeId: node.id } : null;
+      }
       default:
         return null;
     }
@@ -10221,15 +11679,15 @@ var VectorEditorController = class {
       subpath = hit.ref.subpath;
       if (hit.ref.part === "center") mode = input.alt && profile.length < VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
       else if (input.alt) side = hit.ref.part;
-      const same = this.widthPoints.length > 0 && this.widthPoints[0].nodeId === node.id;
-      const selected = same && this.widthPoints.some((r) => r.index === ref.index);
+      const same2 = this.widthPoints.length > 0 && this.widthPoints[0].nodeId === node.id;
+      const selected = same2 && this.widthPoints.some((r) => r.index === ref.index);
       if (input.shift && mode !== "copy") {
         if (selected) {
           this.widthPoints = this.widthPoints.filter((r) => r.index !== ref.index);
           this.notify();
           return;
         }
-        this.widthPoints = same ? [...this.widthPoints, ref] : [ref];
+        this.widthPoints = same2 ? [...this.widthPoints, ref] : [ref];
         shift = true;
       } else if (mode === "copy" || !selected) this.widthPoints = [ref];
       if (mode !== "copy") group = this.widthPoints.filter((r) => r.index !== ref.index).map((r) => r.index);
@@ -10352,6 +11810,8 @@ var VectorEditorController = class {
         return this.downBlend(screen, p);
       case "gradient":
         return this.downGradient(screen, p, input);
+      case "envelope":
+        return this.downEnvelope(screen, p, input);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -10645,6 +12105,8 @@ var VectorEditorController = class {
         return;
       case "gradient":
         return this.moveGradient(drag, screen, p, input);
+      case "envelope":
+        return this.moveEnvelope(drag, p);
       case "move": {
         let dx = p.x - drag.start.x;
         let dy = p.y - drag.start.y;
@@ -10665,6 +12127,7 @@ var VectorEditorController = class {
         return;
       }
       case "scale": {
+        if (this.freeDistort && drag.handle !== "rotate") return this.moveDistort(drag, p, input);
         const angle = drag.frame.angle;
         const q = angle ? applyMatrix(rotateMatrix(-angle), p) : p;
         let { sx, sy, origin } = scaleFor(drag.handle, drag.frame, q, input);
@@ -10965,7 +12428,13 @@ var VectorEditorController = class {
         }
         return this.commit(drag.duplicated ? "Duplicate" : "Move", drag.before);
       case "scale":
-        return this.commit("Scale", drag.before);
+        return this.commit(drag.op ?? "Scale", drag.before);
+      case "envelope":
+        if (!drag.moved) {
+          this.notify();
+          return;
+        }
+        return this.commit("Edit Envelope", drag.before);
       case "rotate":
         return this.commit("Rotate", drag.before);
       case "anchors":
@@ -11426,9 +12895,9 @@ function getVectorOverlayRenderData(state) {
   if (state.editingId) outline(state.editingId, true);
   if (state.hover?.nodeId && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && state.interaction?.type !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && state.interaction?.type !== "marquee" && state.interaction?.type !== "distort") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
-    selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
+    selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles, freeDistort: state.freeDistort };
   }
   const selected = (r) => state.selectedAnchors.some((a) => a.nodeId === r.nodeId && a.subpath === r.subpath && a.index === r.index);
   const sameAnchor = (a, b) => !!a && a.nodeId === b.nodeId && a.subpath === b.subpath && a.index === b.index;
@@ -11555,7 +13024,61 @@ function getVectorOverlayRenderData(state) {
     if (!gradient && !it) status = "Drag across a shape to set a gradient";
     else if (it?.type === "gradient" && it.removing) status = "Release to delete the stop";
   }
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend, gradient };
+  let distort = null;
+  if (it?.type === "distort") {
+    const corners2 = it.corners.map(sc);
+    distort = { mode: it.mode, corners: corners2, d: corners2.map((c, i) => `${i ? "L" : "M"}${c.x} ${c.y}`).join("") + "Z" };
+    status = it.mode === "skew" ? "Skew" : it.mode === "perspective" ? "Perspective" : "Distort";
+  }
+  const envelope = state.tool === "envelope" ? envelopeOverlay(state) : null;
+  if (state.tool === "envelope" && !envelope && !it) status = "Select an object with an envelope to edit its mesh";
+  return { outlines, selectionBox, distort, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend, gradient, envelope };
+}
+function envelopeOverlay(state) {
+  const target = getVectorEnvelopeTarget(state.document, state.selection);
+  if (!target) return null;
+  const v2 = state.viewport;
+  const m = multiplyMatrices(target.world, [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y]);
+  const sc = (p) => ({ x: fmt4(m[0] * p.x + m[2] * p.y + m[4]), y: fmt4(m[1] * p.x + m[3] * p.y + m[5]) });
+  const { mesh } = target.frame;
+  const grid = vectorMeshGridCurves(mesh).map((c) => {
+    const [a, b, cc, d] = c.map(sc);
+    return `M${a.x} ${a.y}C${b.x} ${b.y} ${cc.x} ${cc.y} ${d.x} ${d.y}`;
+  }).join("");
+  const hover = state.hover?.envelope?.nodeId === target.node.id ? state.hover.envelope.index : void 0;
+  const it = state.interaction;
+  const active = it?.type === "envelope" && it.nodeId === target.node.id ? it.index : void 0;
+  const pts = vectorMeshEditPoints(mesh);
+  return {
+    nodeId: target.node.id,
+    grid,
+    anchors: pts.anchors.map((index) => ({ index, ...sc(mesh.points[index]), hovered: !it && hover === index, active: active === index })),
+    handles: pts.handles.map((h) => {
+      const a = sc(mesh.points[h.anchor]);
+      return { index: h.index, ...sc(mesh.points[h.index]), anchorX: a.x, anchorY: a.y, hovered: !it && hover === h.index, active: active === h.index };
+    })
+  };
+}
+var VECTOR_ENVELOPE_STYLE_OPTIONS = [
+  ...VECTOR_WARP_STYLES.map((value) => ({ value, label: VECTOR_WARP_STYLE_LABELS[value] })),
+  { value: "mesh", label: "Mesh" }
+];
+function getVectorEnvelopePanel(state) {
+  const nodes = state.selection.map((id) => findVectorNode(state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
+  if (!nodes.length) return null;
+  const one = nodes.length === 1 ? nodes[0] : null;
+  const first = one?.effects?.find((e) => e.type === "envelope");
+  const order = /* @__PURE__ */ new Map();
+  walkVectorNodes(state.document.nodes, (n) => order.set(n.id, order.size));
+  const top = nodes.length > 1 ? nodes.slice().sort((a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0))[nodes.length - 1] : null;
+  return {
+    nodeId: one?.id ?? null,
+    count: nodes.length,
+    envelope: first?.type === "envelope" ? { effectId: first.id, enabled: first.enabled !== false, params: first.params } : null,
+    canMake: nodes.some((n) => !n.locked),
+    canMakeWithTopObject: top?.type === "path" && top.subpaths.some((sp) => sp.closed && sp.anchors.length > 1),
+    canRelease: nodes.some((n) => !n.locked && !!n.effects?.some((e) => e.type === "envelope"))
+  };
 }
 function gradientOverlay(state) {
   const a = getVectorGradientAnnotator(state.document, state.selection, state.viewport, state.gradientEdit.target);
@@ -11719,7 +13242,7 @@ function getVectorSelectionStyle(state) {
   }
   if (!paths.length) return null;
   const first = paths[0];
-  const same = (get) => paths.every((p) => JSON.stringify(get(p) ?? null) === JSON.stringify(get(first) ?? null));
+  const same2 = (get) => paths.every((p) => JSON.stringify(get(p) ?? null) === JSON.stringify(get(first) ?? null));
   const corners2 = [];
   for (const p of paths) {
     for (const c of vectorCorners(p.subpaths)) {
@@ -11747,17 +13270,17 @@ function getVectorSelectionStyle(state) {
     corners: corners2.length,
     hasOpenPath: paths.some((p) => p.subpaths.some((sp) => !sp.closed && sp.anchors.length > 1)),
     mixed: {
-      fill: !same((p) => p.fill),
-      stroke: !same((p) => p.stroke),
-      strokeWidth: !same((p) => p.strokeWidth ?? 1),
-      opacity: !same((p) => p.opacity ?? 1),
-      strokeAlign: !same((p) => p.strokeAlign ?? "center"),
-      startArrow: !same((p) => p.startArrow ?? null),
-      endArrow: !same((p) => p.endArrow ?? null),
-      arrowAlign: !same((p) => p.arrowAlign ?? "extend"),
-      startArrowScale: !same((p) => p.startArrowScale ?? 1),
-      endArrowScale: !same((p) => p.endArrowScale ?? 1),
-      widthProfile: !same(profileOf),
+      fill: !same2((p) => p.fill),
+      stroke: !same2((p) => p.stroke),
+      strokeWidth: !same2((p) => p.strokeWidth ?? 1),
+      opacity: !same2((p) => p.opacity ?? 1),
+      strokeAlign: !same2((p) => p.strokeAlign ?? "center"),
+      startArrow: !same2((p) => p.startArrow ?? null),
+      endArrow: !same2((p) => p.endArrow ?? null),
+      arrowAlign: !same2((p) => p.arrowAlign ?? "extend"),
+      startArrowScale: !same2((p) => p.startArrowScale ?? 1),
+      endArrowScale: !same2((p) => p.endArrowScale ?? 1),
+      widthProfile: !same2(profileOf),
       cornerRadius: corners2.some((c) => c.radius !== c0.radius),
       cornerKind: corners2.some((c) => c.kind !== c0.kind)
     },
@@ -11859,14 +13382,15 @@ function getVectorEffectsPanel(state) {
       label: VECTOR_EFFECT_LABELS[e.type] ?? e.type,
       enabled: e.enabled !== false,
       params: e.params,
-      specs: VECTOR_EFFECT_PARAM_SPECS[e.type] ?? []
+      // The Envelope panel (`getVectorEnvelopePanel`) edits an envelope's warp and mesh.
+      specs: e.type === "envelope" ? [] : VECTOR_EFFECT_PARAM_SPECS[e.type] ?? []
     })),
     expandable: nodes.some(hasVectorAppearance)
   };
 }
 
 // src/vector/commands.ts
-var EFFECT_PARAMS_DESCRIPTION = "Effect parameters (missing ones keep their value or default). trim: start, end (percent), offset (degrees), mode simultaneous|individual. roundCorners: radius. puckerBloat: amount (\u2212100\u2026100). twist: angle, center {x, y} (offset from the middle). zigzag: size, ridges, smooth. wiggle: size, detail, smooth, speed, correlation, phase, seed, time (seconds). offset: amount, join miter|round|bevel, miterLimit, copies, copyOffset. merge: mode merge|add|subtract|intersect|exclude. repeater: copies (fractions fade the last), offset, position {x, y}, anchor {x, y} (offset from the middle), rotation, scale {x, y} (percent), startOpacity, endOpacity (percent), composite below|above.";
+var EFFECT_PARAMS_DESCRIPTION = "Effect parameters (missing ones keep their value or default). trim: start, end (percent), offset (degrees), mode simultaneous|individual. roundCorners: radius. puckerBloat: amount (\u2212100\u2026100). twist: angle, center {x, y} (offset from the middle). zigzag: size, ridges, smooth. wiggle: size, detail, smooth, speed, correlation, phase, seed, time (seconds). offset: amount, join miter|round|bevel, miterLimit, copies, copyOffset. merge: mode merge|add|subtract|intersect|exclude. repeater: copies (fractions fade the last), offset, position {x, y}, anchor {x, y} (offset from the middle), rotation, scale {x, y} (percent), startOpacity, endOpacity (percent), composite below|above. envelope: style (a warp preset: arc|arcLower|arcUpper|arch|bulge|shellLower|shellUpper|flag|wave|fish|rise|fisheye|inflate|squeeze|twist, or mesh), bend, horizontal, vertical (percent, \u2212100\u2026100), orientation horizontal|vertical, rows, columns, mesh { us, vs, points } (node space; prefer vector.envelope).";
 var fail = (message) => {
   throw new Error(message);
 };
@@ -12225,6 +13749,114 @@ function createVectorCommands(controller, options = {}) {
         return { ids: created };
       }
     },
+    {
+      ...base,
+      id: `${prefix}distort`,
+      label: "Free Distort\u2026",
+      keywords: ["distort", "perspective", "free distort", "corners", "projective", "keystone"],
+      description: "Free Distort: moves the four corners of the selection box (clockwise from the top left, in the box\u2019s own rotation) to `corners` in document units, distorting the nodes in perspective (straight lines stay straight; curves are followed within `tolerance`). The corners must make a convex quadrilateral. One undo step.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          corners: { type: "array", items: POINT, minItems: 4, maxItems: 4, description: "New top-left, top-right, bottom-right and bottom-left corners." },
+          tolerance: { type: "number", exclusiveMinimum: 0, description: "How closely curves follow the distortion (document units, default 0.05)." }
+        },
+        required: ["corners"]
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.distort(params.corners, { ids: ids(params), tolerance: params.tolerance }));
+        const frame2 = controller.getState().selectionFrame;
+        return { ok: true, bounds: frame2 ? { x: frame2.x, y: frame2.y, width: frame2.width, height: frame2.height } : null };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}skew`,
+      label: "Skew\u2026",
+      keywords: ["skew", "shear", "slant", "oblique"],
+      description: "Skews nodes along the selection box\u2019s axes: `ax` degrees horizontally (vertical lines lean right for positive angles) and `ay` degrees vertically, about the box centre or `origin`. One undo step.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          ax: { type: "number", minimum: -89.9, maximum: 89.9 },
+          ay: { type: "number", minimum: -89.9, maximum: 89.9 },
+          origin: POINT
+        }
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.skew(params.ax ?? 0, params.ay ?? 0, { ids: ids(params), origin: params.origin }));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}envelope`,
+      label: "Envelope Distort\u2026",
+      keywords: ["envelope", "warp", "mesh", "arc", "arch", "bulge", "flag", "wave", "fish", "rise", "fisheye", "inflate", "squeeze", "twist", "shell", "bend", "distort"],
+      description: "Envelope distortion that stays editable (a live `envelope` effect). Give `preset` (with `bend`, `horizontal`, `vertical` in percent, \u2212100\u2026100, and `orientation`) to warp, or `mesh` ({ rows, columns } and optionally `points`, the control grid row by row in the node\u2019s own space) for an editable mesh; a node that already has an envelope is changed. `topObject: true` uses the topmost selected closed path as the envelope of the others; `release: true` removes the envelope and gives back its shape as a path; `expand: true` bakes it (Expand Appearance). One undo step.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          preset: { type: "string", enum: VECTOR_WARP_STYLES },
+          bend: { type: "number", minimum: -100, maximum: 100 },
+          horizontal: { type: "number", minimum: -100, maximum: 100 },
+          vertical: { type: "number", minimum: -100, maximum: 100 },
+          orientation: { type: "string", enum: ["horizontal", "vertical"] },
+          mesh: {
+            type: "object",
+            properties: {
+              rows: { type: "integer", minimum: 1, maximum: 16 },
+              columns: { type: "integer", minimum: 1, maximum: 16 },
+              points: { type: "array", items: POINT, description: "(3\xB7columns + 1) \xD7 (3\xB7rows + 1) control points, row by row (node space)." }
+            }
+          },
+          topObject: { type: "boolean" },
+          release: { type: "boolean" },
+          expand: { type: "boolean" }
+        }
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        const target = ids(params);
+        if (params.release) return { released: target, shapes: controller.releaseEnvelope({ ids: target }) };
+        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);
+          return { nodeId: r.nodeId };
+        }
+        if (params.preset !== void 0 && !VECTOR_WARP_STYLES.includes(params.preset)) fail(`Unknown warp preset "${params.preset}".`);
+        const patch = {};
+        if (params.preset) patch.style = params.preset;
+        for (const k of ["bend", "horizontal", "vertical"]) if (params[k] !== void 0) patch[k] = params[k];
+        if (params.orientation) patch.orientation = params.orientation;
+        if (params.mesh) {
+          if (params.preset) fail("Give either `preset` or `mesh`, not both.");
+          patch.style = "mesh";
+          const columns = params.mesh.columns ?? 2;
+          const rows = params.mesh.rows ?? 2;
+          patch.columns = columns;
+          patch.rows = rows;
+          if (params.mesh.points) {
+            const even = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
+            const mesh = { us: even(columns), vs: even(rows), points: params.mesh.points.map((p) => ({ x: p.x, y: p.y })) };
+            if (!isValidVectorMesh(mesh)) fail(`A ${columns} \xD7 ${rows} mesh needs ${(3 * columns + 1) * (3 * rows + 1)} finite points.`);
+            patch.mesh = mesh;
+          }
+        }
+        const made = controller.envelope(patch, { ids: target });
+        if (!made.length) fail("Nothing to envelope.");
+        return { envelopes: made };
+      }
+    },
     {
       ...base,
       id: `${prefix}transform`,
@@ -12814,12 +14446,14 @@ export {
   VECTOR_CORNER_KINDS,
   VECTOR_CORNER_KIND_LABELS,
   VECTOR_CORNER_WIDGET_INSET,
+  VECTOR_DISTORT_TOLERANCE,
   VECTOR_EDIT_TOGGLES,
   VECTOR_EFFECT_DEFAULTS,
   VECTOR_EFFECT_LABELS,
   VECTOR_EFFECT_MENU,
   VECTOR_EFFECT_PARAM_SPECS,
   VECTOR_EFFECT_TYPES,
+  VECTOR_ENVELOPE_STYLE_OPTIONS,
   VECTOR_FILL_GAP,
   VECTOR_GRADIENT_INTERPOLATIONS,
   VECTOR_GRADIENT_INTERPOLATION_LABELS,
@@ -12850,6 +14484,8 @@ export {
   VECTOR_TOOL_GLYPHS,
   VECTOR_TOOL_SHORTCUTS,
   VECTOR_TRANSFORM_HANDLES,
+  VECTOR_WARP_STYLES,
+  VECTOR_WARP_STYLE_LABELS,
   VECTOR_WIDTH_PRESETS,
   VECTOR_WIDTH_PRESET_IDS,
   VECTOR_WIDTH_PROFILE_MAX_POINTS,
@@ -12866,6 +14502,7 @@ export {
   applyVectorEffects,
   applyVectorGradientPatch,
   applyVectorGradientSpread,
+  applyVectorHomography,
   arrowheadInset,
   arrowheadPath,
   arrowheadWeight,
@@ -12894,6 +14531,8 @@ export {
   dashIntervals,
   decomposeRigid,
   defaultVectorGradient,
+  distortVectorNode,
+  dragVectorMeshPoint,
   effectPathLength,
   effectPathVertexCount,
   effectiveStrokeAlign,
@@ -12901,6 +14540,7 @@ export {
   eraseFromFill,
   eraseFromOutline,
   eraserRegion,
+  evalVectorMesh,
   evaluateVectorPathKeyframes,
   expandVectorAppearance,
   expandVectorAppearances,
@@ -12912,6 +14552,7 @@ export {
   explicitVectorGradient,
   findVectorNode,
   fitCornerRadius,
+  fitVectorMesh,
   foldVectorBooleanOperands,
   generateVectorBlendChildren,
   generateWidthProfile,
@@ -12923,6 +14564,8 @@ export {
   getVectorCornerWidgets,
   getVectorEffectsPanel,
   getVectorEnteredGroups,
+  getVectorEnvelopePanel,
+  getVectorEnvelopeTarget,
   getVectorGradientAnnotator,
   getVectorGradientEditor,
   getVectorOverlayRenderData,
@@ -12960,6 +14603,7 @@ export {
   isClosedBezierShape,
   isIdentityMatrix,
   isUniformWidthProfile,
+  isValidVectorMesh,
   isVectorBlendGroup,
   isVectorGradient,
   isVectorLiveBoolean,
@@ -12968,6 +14612,12 @@ export {
   knifePath,
   lineSubpath,
   locateVectorNode,
+  mapBezierPath,
+  mapVectorGradient,
+  mapVectorMeshPoints,
+  mapVectorPaint,
+  mapVectorPoints,
+  mapVectorSubpaths,
   matrixRotation,
   mergePaths,
   mirrorWidthProfile,
@@ -12983,6 +14633,7 @@ export {
   nodeMatrix,
   normalizeVectorEffectParams,
   offsetPaths,
+  orderVectorQuad,
   parseSvgTransform,
   parseVectorColor,
   parseVectorSvg,
@@ -12995,6 +14646,7 @@ export {
   polylineBounds,
   pressureWidthProfile,
   puckerBloatPaths,
+  pullVectorMesh,
   recognizeInkShape,
   rectSubpath,
   refineMorphContour,
@@ -13005,9 +14657,12 @@ export {
   removeAnchorsKeepingShape,
   removeRedundantPoints,
   removeVectorGradientStop,
+  removeVectorMeshSplitU,
+  removeVectorMeshSplitV,
   removeWidthPoints,
   repeatPaths,
   resampleGradientStops,
+  resizeVectorMesh,
   resolveVectorBlendOptions,
   reverseMorphContour,
   reverseSubpath,
@@ -13032,10 +14687,13 @@ export {
   setWidthPoint,
   simplifyPolyline,
   smoothSubpath,
+  solve8,
   sortedVectorGradientStops,
   spanVectorGradientStops,
   splitIntoFaces,
   splitSubpathAt,
+  splitVectorMeshU,
+  splitVectorMeshV,
   starSubpath,
   strokePositionPoint,
   strokeWidthProfileOf,
@@ -13073,14 +14731,21 @@ export {
   vectorBlendRailAt,
   vectorBlendSpine,
   vectorBlendStepCount,
+  vectorBoxCorners,
   vectorBoxMatrix,
   vectorBuilderErasedEdges,
   vectorCornerAt,
   vectorCorners,
   vectorCornersAttribute,
   vectorDiamondPath,
+  vectorDistortQuad,
   vectorDocumentToSvg,
+  vectorEffectInputBounds,
+  vectorEffectInputPaths,
   vectorEnteredGroups,
+  vectorEnvelopeFrame,
+  vectorEnvelopeMap,
+  vectorEnvelopeMesh,
   vectorFillMap,
   vectorGradientArea,
   vectorGradientAspect,
@@ -13098,9 +14763,21 @@ export {
   vectorGradientTAt,
   vectorGradientTargetPath,
   vectorGradientUnitsMatrix,
+  vectorHomography,
+  vectorHomographyKeepsQuad,
+  vectorIdentityMesh,
   vectorInkShapeName,
   vectorLiveBooleanSteps,
+  vectorMeshColumns,
+  vectorMeshControlBounds,
+  vectorMeshEditPoints,
+  vectorMeshFromOutline,
+  vectorMeshGridCurves,
+  vectorMeshOutline,
+  vectorMeshParamAt,
+  vectorMeshRows,
   vectorNodeBounds,
+  vectorNodeEnvelope,
   vectorNodeRotation,
   vectorNodeToBezier,
   vectorOperandOperation,
@@ -13117,6 +14794,8 @@ export {
   vectorResultStyle,
   vectorShapeBuilderHit,
   vectorShapeBuilderMap,
+  vectorShearForSide,
+  vectorSkewMatrix,
   vectorStrokeGradientDefs,
   vectorStrokeLineArea,
   vectorStrokeOutline,
@@ -13126,6 +14805,8 @@ export {
   vectorStrokeSvgParts,
   vectorStrokeWidthGeometry,
   vectorToolLabel,
+  vectorWarpPresetGrid,
+  vectorWarpPresetMesh,
   vectorWorldMatrix,
   walkVectorNodes,
   widthProfileAt,