@pixerate/editor 0.33.0 → 0.35.0

package/dist/vector/index.js

@@ -4,21 +4,33 @@ import {
 import {
   bezierPathBounds,
   bezierPathToSvg,
+  closeContour,
+  contourSignedArea,
+  contoursToPath,
   distanceToBezierPath,
+  fitCubicWithTangents,
   fitCubics,
   formatNumber,
   gradientToSvgDef,
+  normalizeBezierPath,
+  outlineStroke,
   pathBoolean,
+  pathToContours,
   pointInBezierPath,
+  segmentBounds,
+  segmentDerivative,
+  segmentIntersections,
   segmentNearest,
   segmentPoint,
   splitSegment,
+  subSegment,
   toBezierPath,
-  transformBezierPath
-} from "../chunk-GQTXV2EQ.js";
+  transformBezierPath,
+  windingNumber
+} from "../chunk-EGPIVUEF.js";
 
 // src/vector/types.ts
-var VECTOR_TOOLS = ["select", "direct", "pen", "pencil", "rect", "ellipse", "polygon", "star", "line"];
+var VECTOR_TOOLS = ["select", "direct", "pen", "pencil", "rect", "ellipse", "polygon", "star", "line", "scissors", "knife", "eraser"];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 
 // src/vector/geometry.ts
@@ -850,7 +862,1719 @@ function parseVectorSvg(svg, options = {}) {
   return { width, height, nodes };
 }
 
+// src/vector/snap.ts
+var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
+function constrainToLeave(leave, p) {
+  if (!leave?.constrain) return p;
+  const dx = p.x - leave.at.x;
+  const dy = p.y - leave.at.y;
+  switch (leave.constrain) {
+    case "axis":
+      return Math.abs(dx) > Math.abs(dy) ? { x: p.x, y: leave.at.y } : { x: leave.at.x, y: p.y };
+    case "square": {
+      const s = Math.max(Math.abs(dx), Math.abs(dy));
+      return { x: leave.at.x + Math.sign(dx || 1) * s, y: leave.at.y + Math.sign(dy || 1) * s };
+    }
+    default: {
+      const len = Math.hypot(dx, dy);
+      const a = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
+      return { x: leave.at.x + Math.cos(a) * len, y: leave.at.y + Math.sin(a) * len };
+    }
+  }
+}
+var BUDGET = 2e4;
+var CROSSING_PAIRS = 32;
+var CURVE_SAMPLES = 48;
+var BISECT = 50;
+var EQUAL = 1e-6;
+function bound(sorted, key, v, strict) {
+  let lo = 0;
+  let hi = sorted.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const k = key(sorted[mid]);
+    if (strict ? k <= v : k < v) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function within(sorted, key, v, tol) {
+  return sorted.slice(bound(sorted, key, v - tol, false), bound(sorted, key, v + tol, true));
+}
+var linesNear = (lines, v, tol) => within(lines, (l) => l.v, v, tol);
+var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var toPoint = (p) => [p.x, p.y];
+var toVec = (p) => ({ x: p[0], y: p[1] });
+var LABELS = {
+  anchor: "anchor",
+  centre: "centre",
+  intersect: "intersect",
+  perpendicular: "perpendicular",
+  tangent: "tangent",
+  path: "path",
+  construction: "angle",
+  align: "align",
+  spacing: "spacing",
+  size: "size"
+};
+var fmtLength = (n) => String(Math.round(n * 100) / 100);
+function nodeFrame(node, parent, aabb) {
+  const angle = matrixRotation(multiplyMatrices(nodeMatrix(node), parent));
+  const b = angle ? vectorNodeBounds(node, multiplyMatrices(parent, rotateMatrix(-angle))) : aabb !== void 0 ? aabb : vectorNodeBounds(node, parent);
+  if (!b) return null;
+  const c = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+  return { width: b.width, height: b.height, centre: angle ? applyMatrix(rotateMatrix(angle), c) : c };
+}
+function contains(node, ids) {
+  if (ids.has(node.id)) return true;
+  return node.type === "group" && node.children.some((c) => contains(c, ids));
+}
+var VectorSnapTargets = class _VectorSnapTargets {
+  points = [];
+  xs = [];
+  ys = [];
+  segments = [];
+  /** Bounds of the objects a moved box spaces itself evenly with. */
+  boxes = [];
+  /** Side lengths of the other objects (in their own frames), which a resize may match. */
+  sizes = [];
+  constructor() {
+  }
+  /** How many targets of each sort were gathered. */
+  get counts() {
+    return { points: this.points.length, lines: this.xs.length + this.ys.length, segments: this.segments.length, boxes: this.boxes.length };
+  }
+  /** Targets for moving nodes `ids`: the other art's anchors, bounds and centres, the artboard, and boxes to space evenly with. */
+  static forMove(doc, ids) {
+    return _VectorSnapTargets.collect(doc, new Set(ids), "bounds");
+  }
+  /** Targets for resizing nodes `ids`: as for a move, plus the other objects' sizes. */
+  static forResize(doc, ids) {
+    return _VectorSnapTargets.collect(doc, new Set(ids), "bounds");
+  }
+  /**
+   * Targets for a drawn point (pen, shape tools): the art but `exclude`, its anchors (as
+   * points and in line), centres, edges and segments. The anchors and segments of `exclude`
+   * (the path being drawn, whose bounds grow with it) stay targets.
+   */
+  static forDrawing(doc, exclude = []) {
+    const skip = new Set(exclude);
+    const t = _VectorSnapTargets.collect(doc, skip, "drawing", false);
+    t.pushPaths(doc, skip, () => false, true);
+    return t.index();
+  }
+  /**
+   * Targets for dragging anchors: the other art with its segments, and the anchors and
+   * segments that stay put on the paths being reshaped (their bounds move along, so they are
+   * no targets). The moving anchors are left out.
+   */
+  static forAnchorDrag(doc, anchors) {
+    const moving = /* @__PURE__ */ new Map();
+    for (const r of anchors) {
+      const set = moving.get(r.nodeId) ?? /* @__PURE__ */ new Set();
+      set.add(`${r.subpath}:${r.index}`);
+      moving.set(r.nodeId, set);
+    }
+    const t = _VectorSnapTargets.collect(doc, new Set(moving.keys()), "segments", false);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!moving.get(id)?.has(`${s}:${i}`), true);
+    return t.index();
+  }
+  /**
+   * Targets for dragging a handle of path `nodeId`: the other art and that path's anchors
+   * (its bounds and the segments through the handle move with it, so they would chase it).
+   */
+  static forHandle(doc, nodeId) {
+    const skip = /* @__PURE__ */ new Set([nodeId]);
+    const t = _VectorSnapTargets.collect(doc, skip, "bounds", false);
+    t.pushPaths(doc, skip, () => false, false);
+    return t.index();
+  }
+  /** The anchors of the paths `ids` as targets (on them and in line), and their segments when `segments`. */
+  pushPaths(doc, ids, moving, segments) {
+    let anchors = BUDGET;
+    let segmentBudget = segments ? BUDGET : 0;
+    const visit = (list, parent) => {
+      for (const n of list) {
+        const m = multiplyMatrices(nodeMatrix(n), parent);
+        if (n.type === "group") visit(n.children, m);
+        else if (ids.has(n.id) && n.visible !== false) {
+          n.subpaths.forEach((sp, s) => {
+            sp.anchors.forEach((a, i) => {
+              if (anchors <= 0 || moving(n.id, s, i)) return;
+              this.pushAnchor(applyMatrix(m, a));
+              anchors--;
+            });
+            segmentBudget = this.pushSegments(sp, m, (i) => moving(n.id, s, i), segmentBudget);
+          });
+        }
+      }
+    };
+    visit(doc.nodes, IDENTITY_MATRIX);
+  }
+  pushAnchor(p) {
+    this.points.push({ p, kind: "anchor" });
+    this.xs.push({ v: p.x, from: p, kind: "anchor" });
+    this.ys.push({ v: p.y, from: p, kind: "anchor" });
+  }
+  /** The segments of `sp` (mapped by `m`) that stay put while the anchors `moving` accepts move. */
+  pushSegments(sp, m, moving, budget) {
+    const n = sp.anchors.length;
+    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, toVec(q))));
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const [x, y] of seg) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+      }
+      this.segments.push({ seg, minX, minY, maxX, maxY });
+      budget--;
+    }
+    return budget;
+  }
+  pushRect(r, kind, centre) {
+    const corners2 = [
+      { x: r.x, y: r.y },
+      { x: r.x + r.width, y: r.y },
+      { x: r.x + r.width, y: r.y + r.height },
+      { x: r.x, y: r.y + r.height }
+    ];
+    for (const p of corners2) {
+      this.xs.push({ v: p.x, from: p, kind });
+      this.ys.push({ v: p.y, from: p, kind });
+    }
+    if (centre) {
+      this.points.push({ p: centre, kind: "centre" });
+      this.xs.push({ v: centre.x, from: centre, kind: "centre" });
+      this.ys.push({ v: centre.y, from: centre, kind: "centre" });
+    }
+  }
+  /** Sorts the targets for `within` (stable: of targets alike, the first gathered wins). */
+  index() {
+    this.points.sort((a, b) => a.p.x - b.p.x);
+    this.xs.sort((a, b) => a.v - b.v);
+    this.ys.sort((a, b) => a.v - b.v);
+    return this;
+  }
+  /**
+   * Gathers targets from the artboard and every visible node but `exclude` (and what is inside
+   * those): each leaf's anchors (also as lines for `drawing`), its segments (`segments`,
+   * `drawing`), its bounds' corners as lines and its centre; and the top-level objects' boxes and
+   * sizes (inside a group holding an excluded node, that group's other members).
+   */
+  static collect(doc, exclude, gather, sort = true) {
+    const self = new _VectorSnapTargets();
+    const artboard = { x: 0, y: 0, width: doc.width, height: doc.height };
+    self.pushRect(artboard, "artboard", { x: doc.width / 2, y: doc.height / 2 });
+    let anchors = BUDGET;
+    let segments = BUDGET;
+    const visit = (list, parent) => {
+      for (const n of list) {
+        if (exclude.has(n.id) || n.visible === false) continue;
+        const m = multiplyMatrices(nodeMatrix(n), parent);
+        if (n.type === "group") {
+          visit(n.children, m);
+          continue;
+        }
+        if (anchors <= 0) continue;
+        for (const sp of n.subpaths) {
+          for (const a of sp.anchors) {
+            if (anchors-- <= 0) break;
+            const p = applyMatrix(m, a);
+            if (gather === "drawing") self.pushAnchor(p);
+            else self.points.push({ p, kind: "anchor" });
+          }
+          if (gather !== "bounds") segments = self.pushSegments(sp, m, () => false, segments);
+        }
+        const b = vectorNodeBounds(n, parent);
+        const f = nodeFrame(n, parent, b);
+        if (b) self.pushRect(b, "edge", f?.centre ?? null);
+      }
+    };
+    visit(doc.nodes, IDENTITY_MATRIX);
+    const objects = (list, parent) => {
+      for (const n of list) {
+        if (exclude.has(n.id) || n.visible === false || self.boxes.length >= BUDGET) continue;
+        if (n.type === "group" && contains(n, exclude)) {
+          objects(n.children, multiplyMatrices(nodeMatrix(n), parent));
+          continue;
+        }
+        const b = vectorNodeBounds(n, parent);
+        if (b) self.boxes.push(b);
+        const f = nodeFrame(n, parent, b);
+        if (f) self.sizes.push(f.width, f.height);
+      }
+    };
+    objects(doc.nodes, IDENTITY_MATRIX);
+    return sort ? self.index() : self;
+  }
+  // -------------------------------------------------------------------------
+  // Points
+  // -------------------------------------------------------------------------
+  /** Snaps a single point (see `snapFrom`). */
+  snapPoint(p, tol) {
+    return this.snapFrom(p, null, tol);
+  }
+  /**
+   * Snaps a point `p`, drawn or dragged from `leave` when given. With `leave.constrain` it keeps
+   * to its angle round `leave.at`, sliding along that way into line with the nearest target.
+   * Otherwise it lands, in order, on an anchor or centre, an intersection of two paths, the
+   * perpendicular foot or a tangent point from `leave.at`, a path, a construction guide
+   * through `leave.at` (where a target's line crosses it if one does nearby), or else lines up
+   * with targets on x and y.
+   */
+  snapFrom(p, leave, tol) {
+    const none = (q) => ({ point: q, kind: null, x: false, y: false, lines: [], labels: [] });
+    const at = (q, kind, lines2 = []) => ({
+      point: q,
+      kind,
+      x: true,
+      y: true,
+      lines: lines2,
+      labels: [this.label(q, kind)]
+    });
+    if (leave?.constrain) {
+      const q = constrainToLeave(leave, p);
+      const hit = this.slide(leave.at, { x: q.x - leave.at.x, y: q.y - leave.at.y }, q, tol, true);
+      return hit ? { point: hit.point, x: true, y: true, ...this.linedUp(hit.point, hit.from) } : none(q);
+    }
+    const point = this.nearestPoint(p, tol);
+    if (point) return at(point.p, point.kind);
+    const near2 = this.segmentsNear(p, tol);
+    const crossing = this.crossing(near2, p, tol);
+    if (crossing) return at(crossing, "intersect");
+    if (leave && leave.curves !== false) {
+      const foot = this.curvePoint(near2, leave.at, p, tol);
+      if (foot) return at(foot.point, foot.kind, [line("construction", leave.at, foot.point)]);
+    }
+    const on = this.onSegment(near2);
+    if (on) return at(on, "path");
+    if (leave?.angles?.length) {
+      const c = construction(leave, p, tol);
+      if (c) {
+        const hit = this.slide(leave.at, c.dir, c.point, tol, false);
+        if (hit) {
+          const lined = this.linedUp(hit.point, hit.from);
+          return { point: hit.point, x: true, y: true, kind: lined.kind, lines: [line("construction", leave.at, hit.point), ...lined.lines], labels: lined.labels };
+        }
+        return { point: c.point, kind: "construction", x: true, y: true, lines: [line("construction", leave.at, c.point)], labels: [] };
+      }
+    }
+    const nearest = (lines2, v) => {
+      let best = null;
+      for (const l of linesNear(lines2, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.v - v)) best = l;
+      return best;
+    };
+    const bx = nearest(this.xs, p.x);
+    const by = nearest(this.ys, p.y);
+    if (!bx && !by) return none(p);
+    const out = { x: bx ? bx.v : p.x, y: by ? by.v : p.y };
+    const lines = [];
+    if (bx) lines.push(line("align", bx.from, { x: out.x, y: out.y }));
+    if (by) lines.push(line("align", by.from, { x: out.x, y: out.y }));
+    return { point: out, kind: "align", x: !!bx, y: !!by, lines, labels: [this.label(out, "align")] };
+  }
+  label(p, kind, text = LABELS[kind]) {
+    return { kind, x: p.x, y: p.y, text };
+  }
+  /** The anchor or centre nearest `p`, within `tol`. */
+  nearestPoint(p, tol) {
+    let best = null;
+    let bestD = Infinity;
+    for (const t of within(this.points, (e) => e.p.x, p.x, tol)) {
+      const d = distance(t.p, p);
+      if (d <= tol && d < bestD) {
+        best = t;
+        bestD = d;
+      }
+    }
+    return best;
+  }
+  /**
+   * Slides `q`, on the line through `at` along `dir` (beyond `at` only for a `ray`), to where
+   * the nearest target line crosses it, at most twice `tol` away: where it lands and the
+   * target point that line comes from.
+   */
+  slide(at, dir, q, tol, ray) {
+    const len2 = dir.x * dir.x + dir.y * dir.y;
+    if (!Number.isFinite(len2) || len2 <= 1e-18) return null;
+    const reach = 2 * tol;
+    let best = null;
+    for (const vertical of [true, false]) {
+      const d = vertical ? dir.x : dir.y;
+      if (Math.abs(d) <= 1e-9) continue;
+      const a = vertical ? at.x : at.y;
+      for (const l of linesNear(vertical ? this.xs : this.ys, vertical ? q.x : q.y, reach)) {
+        const s = (l.v - a) / d;
+        const hit = vertical ? { x: l.v, y: at.y + dir.y * s } : { x: at.x + dir.x * s, y: l.v };
+        const moved = distance(hit, q);
+        if (moved <= reach && (!ray || s > 0) && (!best || moved < best.moved)) best = { moved, point: hit, from: l.from };
+      }
+    }
+    return best && { point: best.point, from: best.from };
+  }
+  /** The guides of a point `q` slid into line with the target at `from`: the line and "align", or the target's own label when `q` sits on it. */
+  linedUp(q, from) {
+    const on = this.nearestPoint(q, 1e-9);
+    if (on) return { kind: on.kind, lines: [], labels: [this.label(on.p, on.kind)] };
+    return { kind: "align", lines: [line("align", from, q)], labels: [this.label(q, "align")] };
+  }
+  /** Target segments whose control box reaches `p` and which pass within `tol` of it, nearest first. */
+  segmentsNear(p, tol) {
+    const out = [];
+    const pt = toPoint(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, pt);
+      if (hit.distance <= tol) out.push({ seg: s.seg, t: hit.t, distance: hit.distance });
+    }
+    return out.sort((a, b) => a.distance - b.distance);
+  }
+  onSegment(near2) {
+    return near2.length ? toVec(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) {
+    const list = near2.slice(0, CROSSING_PAIRS);
+    let best = null;
+    let bestD = Infinity;
+    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 = toVec(hit.point);
+          const d = distance(q, p);
+          if (d <= tol && d < bestD) {
+            best = q;
+            bestD = d;
+          }
+        }
+      }
+    }
+    return best;
+  }
+  /**
+   * The foot of a perpendicular, or a tangent point, from `base` on a target segment near `p`
+   * (within `tol` of it): roots of `(B(t) − base) · B′(t)` and `(B(t) − base) × B′(t)`
+   * bracketed by sign changes of samples and narrowed by bisection.
+   */
+  curvePoint(near2, base, p, tol) {
+    let best = null;
+    for (const { seg } of near2) {
+      for (const kind of ["perpendicular", "tangent"]) {
+        if (kind === "tangent" && seg.length === 2) continue;
+        for (const q of solveOnSegment(seg, base, kind === "perpendicular" ? dotCondition : crossCondition)) {
+          const d = distance(q, p);
+          if (d <= tol && (!best || d < best.d)) best = { point: q, kind, d };
+        }
+      }
+    }
+    return best && { point: best.point, kind: best.kind };
+  }
+  // -------------------------------------------------------------------------
+  // Boxes
+  // -------------------------------------------------------------------------
+  /**
+   * Snaps a moving box `r` (the moved selection's bounds): its edge or centre nearest a target
+   * line on each axis (`axes` limits which may move). With `spacing`, an axis that lines up
+   * with nothing spaces the box evenly in its row or column. Returns the correction and guides.
+   */
+  snapRect(r, tol, options = {}) {
+    const axes = { x: options.axes?.x !== false, y: options.axes?.y !== false };
+    const nearest = (lines, values) => {
+      let best = null;
+      for (const v of values) for (const l of linesNear(lines, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.d)) best = { d: l.v - v, from: l.from };
+      return best;
+    };
+    const bx = axes.x ? nearest(this.xs, [r.x, r.x + r.width / 2, r.x + r.width]) : null;
+    const by = axes.y ? nearest(this.ys, [r.y, r.y + r.height / 2, r.y + r.height]) : null;
+    const out = { dx: bx?.d ?? 0, dy: by?.d ?? 0, x: !!bx, y: !!by, lines: [], labels: [] };
+    const done = { ...r, x: r.x + out.dx, y: r.y + out.dy };
+    if (bx) {
+      const x = bx.from.x;
+      out.lines.push({ kind: "align", x1: x, y1: Math.min(bx.from.y, done.y), x2: x, y2: Math.max(bx.from.y, done.y + done.height) });
+    }
+    if (by) {
+      const y = by.from.y;
+      out.lines.push({ kind: "align", x1: Math.min(by.from.x, done.x), y1: y, x2: Math.max(by.from.x, done.x + done.width), y2: y });
+    }
+    if (options.spacing && this.boxes.length) {
+      for (const horizontal of [true, false]) {
+        if (horizontal ? out.x || !axes.x : out.y || !axes.y) continue;
+        const moved = { ...r, x: r.x + out.dx, y: r.y + out.dy };
+        const even = this.evenSpacing(moved, horizontal, tol);
+        if (!even) continue;
+        if (horizontal) {
+          out.dx += even.shift;
+          out.x = true;
+        } else {
+          out.dy += even.shift;
+          out.y = true;
+        }
+        for (const gap of even.gaps) this.gapMarks(gap, horizontal, tol, out);
+      }
+    }
+    if (bx || by) out.labels.unshift(this.label({ x: r.x + out.dx + r.width / 2, y: r.y + out.dy + r.height / 2 }, "align"));
+    return out;
+  }
+  /**
+   * Equal spacing along x (`horizontal`) or y for the moved box `r`, among the objects of its
+   * row (column): the shift within `tol` that centres it between its neighbours, or leaves it
+   * as far from the neighbour before or after it as two other objects of the row are apart;
+   * and the gaps that are equal then, as (start, end, where across).
+   */
+  evenSpacing(r, horizontal, tol) {
+    const span = (b, x) => x ? [b.x, b.x + b.width] : [b.y, b.y + b.height];
+    const [r0, r1] = span(r, horizontal);
+    const len = r1 - r0;
+    const [c0, c1] = span(r, !horizontal);
+    const row = this.boxes.map((b) => ({ b, a0: span(b, horizontal)[0], a1: span(b, horizontal)[1] })).filter((e) => span(e.b, !horizontal)[0] < c1 && span(e.b, !horizontal)[1] > c0 && (e.a1 <= r0 + tol || e.a0 >= r1 - tol)).sort((a, b) => a.a0 - b.a0);
+    if (!row.length) return null;
+    const mid = (a, b) => (Math.max(span(a, !horizontal)[0], span(b, !horizontal)[0]) + Math.min(span(a, !horizontal)[1], span(b, !horizontal)[1])) / 2;
+    const pairs = [];
+    for (const p of row) {
+      const next = bound(row, (e) => e.a0, p.a1, false);
+      const q = row[next];
+      if (!q) continue;
+      const straddles = p.a1 <= r0 + tol && q.a0 >= r1 - tol;
+      if (q.a0 > p.a1 && !straddles) pairs.push({ g: q.a0 - p.a1, gap: [p.a1, q.a0, mid(p.b, q.b)] });
+    }
+    let before = null;
+    let after = null;
+    for (const e of row) {
+      if (e.a1 <= r0 + tol && (!before || e.a1 > before.a1)) before = e;
+      if (e.a0 >= r1 - tol && (!after || e.a0 < after.a0)) after = e;
+    }
+    const starts = [];
+    if (before && after && after.a0 - before.a1 > len) starts.push({ start: (before.a1 + after.a0 - len) / 2, repeats: null });
+    for (const { g } of pairs) {
+      if (before) starts.push({ start: before.a1 + g, repeats: g });
+      if (after) starts.push({ start: after.a0 - g - len, repeats: g });
+    }
+    let pick = null;
+    for (const s of starts) if (Math.abs(s.start - r0) <= tol && (!pick || Math.abs(s.start - r0) < Math.abs(pick.start - r0))) pick = s;
+    if (!pick) return null;
+    const { start, repeats } = pick;
+    const at = horizontal ? { ...r, x: start } : { ...r, y: start };
+    const end = start + len;
+    const gaps = [];
+    if (before && (repeats === null || Math.abs(start - before.a1 - repeats) <= EQUAL)) gaps.push([before.a1, start, mid(before.b, at)]);
+    if (after && (repeats === null || Math.abs(after.a0 - end - repeats) <= EQUAL)) gaps.push([end, after.a0, mid(after.b, at)]);
+    if (repeats !== null) {
+      for (const p of pairs) if (Math.abs(p.g - repeats) <= EQUAL) gaps.push(p.gap);
+    }
+    return { shift: start - r0, gaps };
+  }
+  /** A gap mark: a line across the gap with a tick at each end, and its length as a label. */
+  gapMarks([u0, u1, c], horizontal, tick, out) {
+    const pt = (u, v) => horizontal ? { x: u, y: v } : { x: v, y: u };
+    out.lines.push(line("spacing", pt(u0, c), pt(u1, c)), line("spacing", pt(u0, c - tick), pt(u0, c + tick)), line("spacing", pt(u1, c - tick), pt(u1, c + tick)));
+    out.labels.push(this.label(pt((u0 + u1) / 2, c), "spacing", fmtLength(u1 - u0)));
+  }
+  /** The other objects' side length nearest `length`, within `tol`, or null. */
+  matchSize(length2, tol) {
+    let best = null;
+    for (const s of this.sizes) if (Math.abs(s - length2) <= tol && (best === null || Math.abs(s - length2) < Math.abs(best - length2))) best = s;
+    return best;
+  }
+  /**
+   * Snaps a selection-box resize. `sx / sy` are the scale `scaleFor` gave for dragging
+   * `handle` of `frame` (in the box's own, possibly rotated frame), `mods.shift` keeps the
+   * proportions and `mods.alt` scales about the centre. The handle lands on an anchor or
+   * centre within `tol`, else the corner or the side it moves lines up with the nearest
+   * target, whatever the box's angle; a handle with one way to go (a side, or a proportional
+   * corner) slides along it until one of them is on a target. An axis that snaps to nothing
+   * may match another object's width or height instead.
+   */
+  snapScale(frame, handle, sx, sy, mods, tol) {
+    const toDoc = frame.angle ? rotateMatrix(frame.angle) : IDENTITY_MATRIX;
+    const toLocal = frame.angle ? rotateMatrix(-frame.angle) : IDENTITY_MATRIX;
+    const corner = handle.length === 2;
+    const proportional = !!mods.shift;
+    const centre = { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 };
+    const origin = mods.alt ? centre : handlePos(opposite(handle), frame);
+    const hp = handlePos(handle, frame);
+    const d0 = { x: hp.x - origin.x, y: hp.y - origin.y };
+    const valid = (n, s) => Number.isFinite(n) && n * s > 0;
+    const nearest = (v, lines) => {
+      let best = null;
+      for (const l of linesNear(lines, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.v - v)) best = l;
+      return best;
+    };
+    let nx = sx;
+    let ny = sy;
+    let snap = { hx: null, hy: null, on: null };
+    if (corner && !proportional) {
+      const p = applyMatrix(toDoc, { x: origin.x + d0.x * sx, y: origin.y + d0.y * sy });
+      const hx = nearest(p.x, this.xs);
+      const hy = nearest(p.y, this.ys);
+      const on = this.nearestPoint(p, tol);
+      const tries = [];
+      if (on) tries.push({ tx: on.p.x, ty: on.p.y, s: { hx: null, hy: null, on } });
+      tries.push({ tx: hx?.v ?? null, ty: hy?.v ?? null, s: { hx, hy, on: null } });
+      tries.push({ tx: hx?.v ?? null, ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: hy?.v ?? null, s: { hx: null, hy, on: null } });
+      for (const { tx, ty, s } of tries) {
+        if (tx === null && ty === null) continue;
+        const q = applyMatrix(toLocal, { x: tx ?? p.x, y: ty ?? p.y });
+        let cx = (q.x - origin.x) / d0.x;
+        let cy = (q.y - origin.y) / d0.y;
+        if (!frame.angle) {
+          if (tx === null) cx = sx;
+          if (ty === null) cy = sy;
+        }
+        if (valid(cx, sx) && valid(cy, sy)) {
+          nx = cx;
+          ny = cy;
+          snap = s;
+          break;
+        }
+      }
+    } else {
+      const movesX2 = handle === "e" || handle === "w";
+      let e;
+      let c;
+      let s0;
+      if (corner) [e, c, s0] = [{ x: Math.sign(sx), y: Math.sign(sy) }, { x: 0, y: 0 }, Math.abs(sx)];
+      else if (movesX2) [e, c, s0] = proportional ? [{ x: 1, y: Math.sign(sx) }, { x: 0, y: 0 }, sx] : [{ x: 1, y: 0 }, { x: 0, y: 1 }, sx];
+      else [e, c, s0] = proportional ? [{ x: Math.sign(sy), y: 1 }, { x: 0, y: 0 }, sy] : [{ x: 0, y: 1 }, { x: 1, y: 0 }, sy];
+      const i = RING.indexOf(handle);
+      const ends = corner ? [] : [RING[(i + 1) % 8], RING[(i + 7) % 8]];
+      const travel = Math.hypot(e.x * d0.x, e.y * d0.y);
+      let best = null;
+      const consider = (s, inLine, found2) => {
+        const moved = Math.abs(s - s0) * travel;
+        if (!valid(s, s0) || moved > 2 * tol) return;
+        if (!best || (inLine === best.inLine ? moved < best.moved : !inLine)) best = { s, inLine, moved, snap: found2 };
+      };
+      for (const h of [handle, ...ends]) {
+        const hv = handlePos(h, frame);
+        const v = { x: hv.x - origin.x, y: hv.y - origin.y };
+        const base = applyMatrix(toDoc, { x: origin.x + c.x * v.x, y: origin.y + c.y * v.y });
+        const dir = applyMatrix(toDoc, { x: e.x * v.x, y: e.y * v.y });
+        const p = { x: base.x + dir.x * s0, y: base.y + dir.y * s0 };
+        const l2 = dir.x * dir.x + dir.y * dir.y;
+        const on = l2 > 1e-18 ? this.nearestPoint(p, tol) : null;
+        if (on) consider(((on.p.x - base.x) * dir.x + (on.p.y - base.y) * dir.y) / l2, false, { hx: null, hy: null, on });
+        if (Math.abs(dir.x) > 1e-9) {
+          const hit = nearest(p.x, this.xs);
+          if (hit) consider((hit.v - base.x) / dir.x, true, { hx: hit, hy: null, on: null });
+        }
+        if (Math.abs(dir.y) > 1e-9) {
+          const hit = nearest(p.y, this.ys);
+          if (hit) consider((hit.v - base.y) / dir.y, true, { hx: null, hy: hit, on: null });
+        }
+      }
+      const found = best;
+      if (found) {
+        nx = c.x + found.s * e.x;
+        ny = c.y + found.s * e.y;
+        snap = found.snap;
+      }
+    }
+    const out = { sx: nx, sy: ny, snapped: false, lines: [], labels: [] };
+    const handleAt = () => applyMatrix(toDoc, { x: origin.x + d0.x * out.sx, y: origin.y + d0.y * out.sy });
+    if (snap.on) {
+      out.snapped = true;
+      out.labels.push(this.label(snap.on.p, snap.on.kind));
+      return out;
+    }
+    const movesX = handle !== "n" && handle !== "s";
+    const movesY = handle !== "e" && handle !== "w";
+    const sized = [];
+    if (!proportional) {
+      if (movesX && !snap.hx && !(frame.angle && snap.hy) && frame.width > 1e-9) {
+        const len = this.matchSize(Math.abs(out.sx) * frame.width, tol);
+        if (len !== null && len > 0) {
+          out.sx = Math.sign(out.sx || 1) * (len / frame.width);
+          sized.push("x");
+        }
+      }
+      if (movesY && !snap.hy && !(frame.angle && snap.hx) && frame.height > 1e-9) {
+        const len = this.matchSize(Math.abs(out.sy) * frame.height, tol);
+        if (len !== null && len > 0) {
+          out.sy = Math.sign(out.sy || 1) * (len / frame.height);
+          sized.push("y");
+        }
+      }
+    }
+    const x0 = origin.x + (frame.x - origin.x) * out.sx;
+    const x1 = origin.x + (frame.x + frame.width - origin.x) * out.sx;
+    const y0 = origin.y + (frame.y - origin.y) * out.sy;
+    const y1 = origin.y + (frame.y + frame.height - origin.y) * out.sy;
+    const box = { x0: Math.min(x0, x1), x1: Math.max(x0, x1), y0: Math.min(y0, y1), y1: Math.max(y0, y1) };
+    const page = [
+      { 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((q) => applyMatrix(toDoc, q));
+    const pminY = Math.min(...page.map((q) => q.y));
+    const pmaxY = Math.max(...page.map((q) => q.y));
+    const pminX = Math.min(...page.map((q) => q.x));
+    const pmaxX = Math.max(...page.map((q) => q.x));
+    if (snap.hx) out.lines.push({ kind: "align", x1: snap.hx.v, y1: Math.min(snap.hx.from.y, pminY), x2: snap.hx.v, y2: Math.max(snap.hx.from.y, pmaxY) });
+    if (snap.hy) out.lines.push({ kind: "align", x1: Math.min(snap.hy.from.x, pminX), y1: snap.hy.v, x2: Math.max(snap.hy.from.x, pmaxX), y2: snap.hy.v });
+    if (snap.hx || snap.hy) {
+      out.snapped = true;
+      out.labels.push(this.label(handleAt(), "align"));
+    }
+    for (const axis of sized) {
+      out.snapped = true;
+      const off = tol * 2;
+      const [a, b] = axis === "x" ? [{ x: box.x0, y: box.y1 + off }, { x: box.x1, y: box.y1 + off }] : [{ x: box.x1 + off, y: box.y0 }, { x: box.x1 + off, y: box.y1 }];
+      const pa = applyMatrix(toDoc, a);
+      const pb = applyMatrix(toDoc, b);
+      out.lines.push(line("size", pa, pb));
+      out.labels.push(this.label({ x: (pa.x + pb.x) / 2, y: (pa.y + pb.y) / 2 }, "size", `${axis === "x" ? "W" : "H"} ${fmtLength(axis === "x" ? box.x1 - box.x0 : box.y1 - box.y0)}`));
+    }
+    return out;
+  }
+};
+var RING = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+function opposite(h) {
+  return RING[(RING.indexOf(h) + 4) % 8];
+}
+function handlePos(h, r) {
+  const x = h.includes("w") ? r.x : h.includes("e") ? r.x + r.width : r.x + r.width / 2;
+  const y = h.startsWith("n") ? r.y : h.startsWith("s") ? r.y + r.height : r.y + r.height / 2;
+  return { x, y };
+}
+function line(kind, a, b) {
+  return { kind, x1: a.x, y1: a.y, x2: b.x, y2: b.y };
+}
+function construction(leave, p, tol) {
+  const v = { x: p.x - leave.at.x, y: p.y - leave.at.y };
+  if (Math.hypot(v.x, v.y) <= tol) return null;
+  let best = null;
+  for (const a of leave.angles ?? []) {
+    const r = a * Math.PI / 180;
+    const exact = (n) => Math.abs(n) < 1e-12 ? 0 : n;
+    const dir = { x: exact(Math.cos(r)), y: exact(-Math.sin(r)) };
+    const k = v.x * dir.x + v.y * dir.y;
+    const point = { x: leave.at.x + dir.x * k, y: leave.at.y + dir.y * k };
+    const d = distance(point, p);
+    if (d <= tol && (!best || d < best.d)) best = { dir, point, d };
+  }
+  return best && { dir: best.dir, point: best.point };
+}
+var dotCondition = (r, d) => r[0] * d[0] + r[1] * d[1];
+var crossCondition = (r, d) => r[0] * d[1] - r[1] * d[0];
+function solveOnSegment(seg, base, cond) {
+  const b = [base.x, base.y];
+  const g = (t) => {
+    const p = segmentPoint(seg, t);
+    return cond([p[0] - b[0], p[1] - b[1]], segmentDerivative(seg, t));
+  };
+  const vals = [];
+  let scale = 0;
+  for (let i = 0; i <= CURVE_SAMPLES; i++) {
+    const t = i / CURVE_SAMPLES;
+    const p = segmentPoint(seg, t);
+    const d = segmentDerivative(seg, t);
+    const r = [p[0] - b[0], p[1] - b[1]];
+    vals.push(cond(r, d));
+    scale = Math.max(scale, Math.hypot(r[0], r[1]) * Math.hypot(d[0], d[1]));
+  }
+  if (!(scale > 0) || vals.every((v) => Math.abs(v) <= scale * 1e-12)) return [];
+  const out = [];
+  for (let i = 0; i < CURVE_SAMPLES; i++) {
+    const ga = vals[i];
+    const gb = vals[i + 1];
+    if (!(Number.isFinite(ga) && Number.isFinite(gb)) || ga > 0 === gb > 0 && ga !== 0) continue;
+    let lo = i / CURVE_SAMPLES;
+    let hi = (i + 1) / CURVE_SAMPLES;
+    let flo = ga;
+    for (let k = 0; k < BISECT; k++) {
+      const m = (lo + hi) / 2;
+      const fm = g(m);
+      if (fm === 0) {
+        lo = hi = m;
+        break;
+      }
+      if (fm > 0 === flo > 0) {
+        lo = m;
+        flo = fm;
+      } else hi = m;
+    }
+    const t = (lo + hi) / 2;
+    const p = segmentPoint(seg, t);
+    const dv = segmentDerivative(seg, t);
+    const r = Math.hypot(p[0] - b[0], p[1] - b[1]);
+    const dl = Math.hypot(dv[0], dv[1]);
+    if (!(r > 1e-9 && dl > 0) || Math.abs(cond([p[0] - b[0], p[1] - b[1]], dv)) > 1e-6 * r * dl) continue;
+    if (!out.some((q) => Math.hypot(q.x - p[0], q.y - p[1]) <= 1e-9 * (1 + r))) out.push({ x: p[0], y: p[1] });
+  }
+  return out;
+}
+
+// src/vector/pathEdit.ts
+var EPS2 = 1e-9;
+var unit = (x, y) => {
+  const l = Math.hypot(x, y);
+  return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
+};
+function cubicOf(sp, i) {
+  const s = subpathSegment(sp, i);
+  if (s.length === 4) return s;
+  const [a, b] = s;
+  return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
+}
+var isLine = (sp, i) => subpathSegment(sp, i).length === 2;
+function startTangent(c) {
+  for (let k = 1; k < 4; k++) {
+    const u = unit(c[k][0] - c[0][0], c[k][1] - c[0][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function endTangent(c) {
+  for (let k = 2; k >= 0; k--) {
+    const u = unit(c[3][0] - c[k][0], c[3][1] - c[k][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function sample(c, n, out, withStart) {
+  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(segmentPoint(c, i / n));
+}
+var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS2 && Math.abs(h.y - a.y) < EPS2;
+function tidy(a, keepType = true) {
+  const next = cloneAnchor(a);
+  if (onAnchor(next, next.in)) delete next.in;
+  if (onAnchor(next, next.out)) delete next.out;
+  const shown = inferAnchorType(next);
+  const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
+  if (type === "corner") delete next.type;
+  else next.type = type;
+  return next;
+}
+function neighbours(sp, i) {
+  const n = sp.anchors.length;
+  const wrap = sp.closed && n > 1;
+  return [i > 0 ? i - 1 : wrap ? n - 1 : -1, i < n - 1 ? i + 1 : wrap ? 0 : -1];
+}
+function goldenMin(f, a, b) {
+  const R = 0.618033988749895;
+  let x1 = b - R * (b - a);
+  let x2 = a + R * (b - a);
+  let f1 = f(x1);
+  let f2 = f(x2);
+  for (let i = 0; i < 40; i++) {
+    if (f1.error < f2.error || Number.isNaN(f2.error)) {
+      b = x2;
+      x2 = x1;
+      f2 = f1;
+      x1 = b - R * (b - a);
+      f1 = f(x1);
+    } else {
+      a = x1;
+      x1 = x2;
+      f1 = f2;
+      x2 = a + R * (b - a);
+      f2 = f(x2);
+    }
+  }
+  return f1.error <= f2.error ? f1 : f2;
+}
+function fitAcross(pts, N, t0, t1) {
+  const fit = (k) => {
+    const u = [];
+    for (let i = 0; i <= N; i++) u.push(k * i / N);
+    for (let i = 1; i <= N; i++) u.push(k + (1 - k) * i / N);
+    return fitCubicWithTangents(pts, u, t0, t1);
+  };
+  return goldenMin(fit, 0, 1);
+}
+function removeAnchorKeepingShape(sp, index) {
+  const anchors = sp.anchors.map(cloneAnchor);
+  const n = anchors.length;
+  if (index < 0 || index >= n) return { anchors, closed: sp.closed };
+  if ((sp.closed || index > 0 && index < n - 1) && n >= 3) {
+    const pi = (index + n - 1) % n;
+    const ni = (index + 1) % n;
+    if (!(isLine(sp, pi) && isLine(sp, index))) {
+      const left = cubicOf(sp, pi);
+      const right = cubicOf(sp, index);
+      const N = 16;
+      const pts = [];
+      sample(left, N, pts, true);
+      sample(right, N, pts, false);
+      const t0 = startTangent(left);
+      const t1 = endTangent(right);
+      const { curve } = fitAcross(pts, N, t0, t1);
+      if ([curve.p1, curve.p2].every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]))) {
+        anchors[pi] = tidy({ ...anchors[pi], out: { x: curve.p1[0], y: curve.p1[1] } });
+        anchors[ni] = tidy({ ...anchors[ni], in: { x: curve.p2[0], y: curve.p2[1] } });
+      }
+    }
+  }
+  anchors.splice(index, 1);
+  let closed = sp.closed;
+  if (!closed && anchors.length) {
+    anchors[0] = tidy({ ...anchors[0], in: null });
+    const last = anchors.length - 1;
+    anchors[last] = tidy({ ...anchors[last], out: null });
+  }
+  if (anchors.length < 3) closed = closed && anchors.length === 2 && anchors.some((a) => a.in || a.out);
+  return { anchors, closed };
+}
+function removeAnchorsKeepingShape(sp, indices) {
+  const order = [...new Set(indices)].filter((i) => i >= 0 && i < sp.anchors.length).sort((a, b) => b - a);
+  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed });
+}
+function bendSegment(sp, segment, t, p) {
+  const anchors = sp.anchors.map(cloneAnchor);
+  const n = anchors.length;
+  if (segment < 0 || segment >= subpathSegmentCount(sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
+  const tc = Math.min(0.95, Math.max(0.05, t));
+  const ia = segment;
+  const ib = (segment + 1) % n;
+  const a = anchors[ia];
+  const b = anchors[ib];
+  const k = 3 * tc * (1 - tc);
+  const ox = (p.x - (a.x + (b.x - a.x) * tc)) / k;
+  const oy = (p.y - (a.y + (b.y - a.y) * tc)) / k;
+  const c1 = { x: a.x + (b.x - a.x) / 3 + ox, y: a.y + (b.y - a.y) / 3 + oy };
+  const c2 = { x: b.x + (a.x - b.x) / 3 + ox, y: b.y + (a.y - b.y) / 3 + oy };
+  anchors[ia] = moveAnchorHandle(a, "out", c1);
+  anchors[ib] = moveAnchorHandle(b, "in", c2);
+  return { anchors, closed: sp.closed };
+}
+function subpathPointAt(sp, segment, t) {
+  const [x, y] = segmentPoint(subpathSegment(sp, segment), t);
+  return { x, y };
+}
+function curvatureMoveAnchor(sp, index, q) {
+  const anchors = sp.anchors.map(cloneAnchor);
+  const a = sp.anchors[index];
+  if (!a) return { anchors, closed: sp.closed };
+  const own = [
+    a.in && !onAnchor(a, a.in) ? { x: a.in.x - a.x, y: a.in.y - a.y } : null,
+    a.out && !onAnchor(a, a.out) ? { x: a.out.x - a.x, y: a.out.y - a.y } : null
+  ];
+  const ends = [null, null];
+  neighbours(sp, index).forEach((j, side) => {
+    if (j < 0 || j === index) return;
+    const b = anchors[j];
+    const old = Math.hypot(a.x - b.x, a.y - b.y);
+    const s = old > 1e-9 ? Math.hypot(q.x - b.x, q.y - b.y) / old : 1;
+    const key = side === 0 ? "out" : "in";
+    const h = b[key];
+    if (h) b[key] = { x: b.x + (h.x - b.x) * s, y: b.y + (h.y - b.y) * s };
+    const o = own[side];
+    if (o) own[side] = { x: o.x * s, y: o.y * s };
+    ends[side] = { x: b.x, y: b.y };
+  });
+  const moved = { x: q.x, y: q.y };
+  if (own[0]) moved.in = { x: q.x + own[0].x, y: q.y + own[0].y };
+  if (own[1]) moved.out = { x: q.x + own[1].x, y: q.y + own[1].y };
+  if (a.type) moved.type = a.type;
+  const [prev, next] = ends;
+  if (a.type && a.type !== "corner" && prev && next) {
+    const dx = next.x - prev.x;
+    const dy = next.y - prev.y;
+    const l = Math.hypot(dx, dy);
+    if (l > 1e-9) {
+      const len = (h, to) => h ? Math.hypot(h.x, h.y) : Math.hypot(q.x - to.x, q.y - to.y) / 3;
+      let li = len(own[0], prev);
+      let lo = len(own[1], next);
+      if (a.type === "symmetric") li = lo = (li + lo) / 2;
+      moved.in = { x: q.x - dx * li / l, y: q.y - dy * li / l };
+      moved.out = { x: q.x + dx * lo / l, y: q.y + dy * lo / l };
+    }
+  }
+  anchors[index] = moved;
+  return { anchors, closed: sp.closed };
+}
+function cutSubpathAt(sp, at) {
+  const n = sp.anchors.length;
+  const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
+  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(cloneAnchor), closed: sp.closed }];
+  const first = cuts[0];
+  const run = sp.closed ? Array.from({ length: n + 1 }, (_, i) => sp.anchors[(first + i) % n]) : sp.anchors;
+  const cutSet = new Set(sp.closed ? [...cuts.map((c) => (c - first + n) % n), n] : cuts);
+  const pieces = [];
+  let cur = [];
+  run.forEach((a, i) => {
+    if (!cutSet.has(i)) {
+      cur.push(cloneAnchor(a));
+      return;
+    }
+    if (cur.length) {
+      cur.push(tidy({ ...a, out: null }, false));
+      pieces.push({ anchors: cur, closed: false });
+      cur = [];
+    }
+    if (i < n) cur.push(tidy({ ...a, in: null }, false));
+  });
+  if (cur.length > 1) pieces.push({ anchors: cur, closed: false });
+  return pieces;
+}
+function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
+  const n = sp.anchors.length;
+  if (segment < 0 || segment >= subpathSegmentCount(sp)) return [{ anchors: sp.anchors.map(cloneAnchor), closed: sp.closed }];
+  if (t <= endTolerance) return cutSubpathAt(sp, [segment]);
+  if (t >= 1 - endTolerance) return cutSubpathAt(sp, [(segment + 1) % n]);
+  const { subpath, index } = insertAnchor(sp, segment, t);
+  return cutSubpathAt(subpath, [index]);
+}
+var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
+var dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function reverse(sp) {
+  return {
+    closed: sp.closed,
+    anchors: sp.anchors.slice().reverse().map((a) => {
+      const next = { x: a.x, y: a.y };
+      if (a.out) next.in = { ...a.out };
+      if (a.in) next.out = { ...a.in };
+      if (a.type) next.type = a.type;
+      return next;
+    })
+  };
+}
+function joinSubpaths(subpaths, tolerance) {
+  const closed = [];
+  let open = [];
+  for (const sp of subpaths) {
+    const copy = { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed };
+    if (sp.closed || sp.anchors.length < 2) {
+      if (sp.anchors.length) closed.push(copy);
+    } else open.push(copy);
+  }
+  if (open.length === 1) {
+    const sp = open[0];
+    const first = sp.anchors[0];
+    const last = sp.anchors[sp.anchors.length - 1];
+    if (sp.anchors.length > 2 && dist(first, last) <= tolerance) {
+      sp.anchors.pop();
+      sp.anchors[0] = tidy({ ...first, in: last.in ?? null }, false);
+    } else {
+      sp.anchors[0] = tidy({ ...first, in: null }, false);
+      sp.anchors[sp.anchors.length - 1] = tidy({ ...sp.anchors[sp.anchors.length - 1], out: null }, false);
+    }
+    sp.closed = true;
+    return [...closed, sp];
+  }
+  while (open.length > 1) {
+    let best = { d: Infinity, i: 0, j: 1, ei: true, ej: false };
+    for (let i = 0; i < open.length; i++) {
+      for (let j = i + 1; j < open.length; j++) {
+        for (const ei of [false, true]) {
+          for (const ej of [false, true]) {
+            const d = dist(endOf(open[i], ei), endOf(open[j], ej));
+            if (d < best.d) best = { d, i, j, ei, ej };
+          }
+        }
+      }
+    }
+    let a = open[best.i];
+    let b = open[best.j];
+    open = open.filter((_, k) => k !== best.j);
+    if (!best.ei) a = reverse(a);
+    if (best.ej) b = reverse(b);
+    const anchors = a.anchors;
+    if (best.d <= tolerance) {
+      const [head, ...rest] = b.anchors;
+      const l = anchors[anchors.length - 1];
+      anchors[anchors.length - 1] = tidy({ ...l, out: head.out ?? null }, false);
+      anchors.push(...rest);
+    } else {
+      const l = anchors[anchors.length - 1];
+      anchors[anchors.length - 1] = tidy({ ...l, out: null }, false);
+      anchors.push(tidy({ ...b.anchors[0], in: null }, false), ...b.anchors.slice(1));
+    }
+    open[best.i > best.j ? best.i - 1 : best.i] = { anchors, closed: false };
+  }
+  return [...closed, ...open];
+}
+function smoothSubpath(sp, amount = 1, only) {
+  const t = Math.min(1, Math.max(0, amount));
+  const orig = sp.anchors;
+  const n = orig.length;
+  const anchors = orig.map(cloneAnchor);
+  if (n < 3 || t === 0) return { anchors, closed: sp.closed };
+  for (let i = 0; i < n; i++) {
+    if (!sp.closed && (i === 0 || i === n - 1)) continue;
+    if (only && !only.has(i)) continue;
+    const prev = orig[(i + n - 1) % n];
+    const next = orig[(i + 1) % n];
+    const p = orig[i];
+    const dir = unit(next.x - prev.x, next.y - prev.y);
+    if (!dir) continue;
+    const li = dist(p, prev) / 3;
+    const lo = dist(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 });
+    anchors[i] = tidy(
+      {
+        x: p.x,
+        y: p.y,
+        in: target(hin, p.x - dir[0] * li, p.y - dir[1] * li),
+        out: target(hout, p.x + dir[0] * lo, p.y + dir[1] * lo)
+      },
+      false
+    );
+  }
+  return { anchors, closed: sp.closed };
+}
+function segsOf(sp) {
+  const out = [];
+  for (let i = 0; i < subpathSegmentCount(sp); i++) {
+    const s = subpathSegment(sp, i);
+    out.push(s.length === 2 ? { c: s, line: true } : { c: s, line: false });
+  }
+  return out;
+}
+function segsToSubpath(segs, closed, types) {
+  if (!segs.length) return null;
+  const anchors = [];
+  const at = (p) => ({ x: p[0], y: p[1] });
+  anchors.push(at(segs[0].c[0]));
+  for (const s of segs) {
+    const end = s.c[s.c.length - 1];
+    if (!s.line) anchors[anchors.length - 1].out = { x: s.c[1][0], y: s.c[1][1] };
+    const next = at(end);
+    if (!s.line) next.in = { x: s.c[2][0], y: s.c[2][1] };
+    anchors.push(next);
+  }
+  if (closed) {
+    const last = anchors.pop();
+    if (last.in) anchors[0].in = last.in;
+  }
+  const typed = anchors.map((a) => {
+    const type = types.get(`${a.x},${a.y}`);
+    return tidy(type ? { ...a, type } : a, !!type);
+  });
+  return { anchors: typed, closed };
+}
+var isZeroSeg = (s) => s.c.every((p) => Math.abs(p[0] - s.c[0][0]) < 1e-9 && Math.abs(p[1] - s.c[0][1]) < 1e-9);
+function mergePair(a, b, tol) {
+  const a0 = a.c[0];
+  const a3 = a.c[a.c.length - 1];
+  const b3 = b.c[b.c.length - 1];
+  if (a.line && b.line) {
+    const cx = b3[0] - a0[0];
+    const cy = b3[1] - a0[1];
+    const len = Math.hypot(cx, cy);
+    if (len < 1e-12) return null;
+    const mx = a3[0] - a0[0];
+    const my = a3[1] - a0[1];
+    const along = (mx * cx + my * cy) / len;
+    return Math.abs((mx * cy - my * cx) / len) <= tol && along >= 0 && along <= len ? { c: [a0, b3], line: true } : null;
+  }
+  const ca = a.line ? [a0, a0, a3, a3] : a.c;
+  const cb = b.line ? [a3, a3, b3, b3] : b.c;
+  const ta = endTangent(ca);
+  const tb = startTangent(cb);
+  if (ta[0] * tb[0] + ta[1] * tb[1] < 0.99) return null;
+  const pts = [];
+  sample(ca, 16, pts, true);
+  sample(cb, 16, pts, false);
+  const { curve, error } = fitAcross(pts, 16, startTangent(ca), endTangent(cb));
+  return error <= tol ? { c: [curve.p0, curve.p1, curve.p2, curve.p3], line: false } : null;
+}
+function removeRedundantPoints(sp, tolerance) {
+  const tol = Math.max(tolerance, 1e-9);
+  const types = new Map(sp.anchors.filter((a) => a.type).map((a) => [`${a.x},${a.y}`, a.type]));
+  const segs = segsOf(sp).filter((s) => !isZeroSeg(s));
+  if (!segs.length) return { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed };
+  const minSegs = sp.closed ? 2 : 1;
+  let changed = true;
+  while (changed && segs.length > minSegs) {
+    changed = false;
+    const n = segs.length;
+    const joints = sp.closed ? n : n - 1;
+    for (let j = 0; j < joints; j++) {
+      const [i0, i1] = sp.closed ? [(j + n - 1) % n, j] : [j, j + 1];
+      const m = mergePair(segs[i0], segs[i1], tol);
+      if (!m) continue;
+      segs[i0] = m;
+      segs.splice(i1, 1);
+      if (sp.closed && i1 === 0) segs.unshift(segs.pop());
+      changed = true;
+      break;
+    }
+  }
+  return segsToSubpath(segs, sp.closed, types) ?? { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed };
+}
+
+// src/vector/pathCut.ts
+var loopArea = (l) => contourSignedArea(l.segs);
+function loopSample(l) {
+  const k = l.chord.findIndex((c) => !c);
+  return segmentPoint(l.segs[k >= 0 ? k : 0], 0.5);
+}
+var contains2 = (l, p) => windingNumber([l.segs], p) !== 0;
+function groupFaces(loops) {
+  const usable = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
+  if (!usable.length) return [];
+  const largest = usable.reduce((a, b) => Math.abs(loopArea(b)) > Math.abs(loopArea(a)) ? b : a);
+  const sign = Math.sign(loopArea(largest));
+  const outers = usable.filter((l) => Math.sign(loopArea(l)) === sign).sort((a, b) => Math.abs(loopArea(a)) - Math.abs(loopArea(b)));
+  const faces = new Map(outers.map((o) => [o, { loops: [o] }]));
+  for (const hole of usable.filter((l) => Math.sign(loopArea(l)) !== sign)) {
+    const p = loopSample(hole);
+    const parent = outers.find((o) => Math.abs(loopArea(o)) > Math.abs(loopArea(hole)) && contains2(o, p));
+    if (parent) faces.get(parent).loops.push(hole);
+  }
+  return outers.reverse().map((o) => faces.get(o));
+}
+function faceToPath(face) {
+  return contoursToPath(face.loops.map((l) => ({ segments: l.segs, closed: true })));
+}
+function facesOf(path, fillRule) {
+  const normalized = normalizeBezierPath(path, fillRule);
+  const loops = pathToContours(normalized).map((c) => {
+    const segs = closeContour(c, true).map((s) => s.slice());
+    return { segs, chord: segs.map(() => false) };
+  });
+  return groupFaces(loops);
+}
+function splitIntoFaces(path, fillRule = "nonzero") {
+  return facesOf(path, fillRule).map(faceToPath);
+}
+function rootsInUnit(a, b, c, d, scale) {
+  const f = (t) => ((a * t + b) * t + c) * t + d;
+  const tol = 1e-12 * Math.max(1, scale);
+  const cuts = [0];
+  const qa = 3 * a;
+  const qb = 2 * b;
+  if (Math.abs(qa) > 1e-18) {
+    const disc = qb * qb - 4 * qa * c;
+    if (disc >= 0) {
+      const r = Math.sqrt(disc);
+      for (const t of [(-qb - r) / (2 * qa), (-qb + r) / (2 * qa)].sort((x, y) => x - y)) if (t > 0 && t < 1) cuts.push(t);
+    }
+  } else if (Math.abs(qb) > 1e-18) {
+    const t = -c / qb;
+    if (t > 0 && t < 1) cuts.push(t);
+  }
+  cuts.push(1);
+  const roots = [];
+  const push = (t) => {
+    if (!roots.some((r) => Math.abs(r - t) < 1e-9)) roots.push(t);
+  };
+  for (let i = 0; i < cuts.length - 1; i++) {
+    let lo = cuts[i];
+    let hi = cuts[i + 1];
+    let flo = f(lo);
+    const fhi = f(hi);
+    if (Math.abs(flo) <= tol) push(lo);
+    if (Math.abs(fhi) <= tol) push(hi);
+    if (flo * fhi >= 0) continue;
+    for (let k = 0; k < 80; k++) {
+      const m = (lo + hi) / 2;
+      const fm = f(m);
+      if (fm === 0) {
+        lo = hi = m;
+        break;
+      }
+      if (fm * flo < 0) hi = m;
+      else {
+        lo = m;
+        flo = fm;
+      }
+    }
+    push((lo + hi) / 2);
+  }
+  return roots.sort((x, y) => x - y);
+}
+function lineHits(p, q, seg) {
+  const dx = q[0] - p[0];
+  const dy = q[1] - p[1];
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-24) return [];
+  const h = (pt) => (pt[0] - p[0]) * -dy + (pt[1] - p[1]) * dx;
+  let coeffs;
+  if (seg.length === 2) coeffs = [0, 0, h(seg[1]) - h(seg[0]), h(seg[0])];
+  else {
+    const [h0, h1, h2, h3] = seg.map(h);
+    coeffs = [-h0 + 3 * h1 - 3 * h2 + h3, 3 * h0 - 6 * h1 + 3 * h2, -3 * h0 + 3 * h1, h0];
+  }
+  if (coeffs.every((c) => Math.abs(c) < 1e-12 * Math.max(1, len2))) return [];
+  const scale = Math.sqrt(len2) * Math.max(1, ...seg.map((pt) => Math.abs(pt[0]) + Math.abs(pt[1])));
+  const out = [];
+  for (const t of rootsInUnit(...coeffs, scale)) {
+    const point = segmentPoint(seg, t);
+    const s = ((point[0] - p[0]) * dx + (point[1] - p[1]) * dy) / len2;
+    if (s >= -1e-9 && s <= 1 + 1e-9) out.push({ s: Math.min(1, Math.max(0, s)), t, point });
+  }
+  return out;
+}
+var near = (a, b, eps) => Math.abs(a[0] - b[0]) <= eps && Math.abs(a[1] - b[1]) <= eps;
+var degenerate = (seg, eps) => seg.every((p) => near(p, seg[0], eps));
+function arc(l, a, b, eps) {
+  const n = l.segs.length;
+  const segs = [];
+  const chord = [];
+  const push = (k, t0, t1) => {
+    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : subSegment(l.segs[k], t0, t1);
+    if (!degenerate(piece, eps)) {
+      segs.push(piece);
+      chord.push(l.chord[k]);
+    }
+  };
+  if (a.seg === b.seg && b.t >= a.t + 1e-12) {
+    push(a.seg, a.t, b.t);
+    return { segs, chord };
+  }
+  push(a.seg, a.t, 1);
+  for (let k = (a.seg + 1) % n; k !== b.seg; k = (k + 1) % n) push(k, 0, 1);
+  push(b.seg, 0, b.t);
+  return { segs, chord };
+}
+function polySegs(points, eps) {
+  const out = [];
+  for (let i = 1; i < points.length; i++) if (!near(points[i - 1], points[i], eps)) out.push([points[i - 1], points[i]]);
+  return out;
+}
+function knifePath(path, fillRule, knife) {
+  const pts = knife.filter((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]));
+  if (pts.length < 2) return null;
+  let faces = facesOf(path, fillRule);
+  if (!faces.length) return null;
+  const b = bezierPathBounds(path);
+  const size = b ? Math.max(b.maxX - b.minX, b.maxY - b.minY, 1) : 1;
+  const eps = size * 1e-9;
+  let cursor = -Infinity;
+  let cuts = 0;
+  for (let guard = 0; guard < 512; guard++) {
+    let best = null;
+    faces.forEach((face2, fi2) => {
+      const hits = [];
+      for (let m = 0; m < pts.length - 1; m++) {
+        if (m + 1 < cursor - 1e-9) continue;
+        const kb = { minX: Math.min(pts[m][0], pts[m + 1][0]), maxX: Math.max(pts[m][0], pts[m + 1][0]), minY: Math.min(pts[m][1], pts[m + 1][1]), maxY: Math.max(pts[m][1], pts[m + 1][1]) };
+        face2.loops.forEach(
+          (l, li) => l.segs.forEach((seg, si) => {
+            const sb = segmentBounds(seg);
+            if (sb.maxX < kb.minX - eps || sb.minX > kb.maxX + eps || sb.maxY < kb.minY - eps || sb.minY > kb.maxY + eps) return;
+            for (const h of lineHits(pts[m], pts[m + 1], seg)) {
+              const s = m + h.s;
+              if (s >= cursor - 1e-9) hits.push({ s, loop: li, seg: si, t: h.t, point: h.point });
+            }
+          })
+        );
+      }
+      hits.sort((x, y) => x.s - y.s);
+      const unique = hits.filter((h, i) => i === 0 || h.s - hits[i - 1].s > 1e-9 || !near(h.point, hits[i - 1].point, eps * 10));
+      const inside = (s) => {
+        const m = Math.min(pts.length - 2, Math.floor(s));
+        const u = s - m;
+        const q = [pts[m][0] + (pts[m + 1][0] - pts[m][0]) * u, pts[m][1] + (pts[m + 1][1] - pts[m][1]) * u];
+        return windingNumber(face2.loops.map((l) => l.segs), q) !== 0;
+      };
+      for (let i = 0; i < unique.length - 1; i++) {
+        const from2 = unique[i];
+        const to2 = unique[i + 1];
+        if (near(from2.point, to2.point, eps * 10) || !inside((from2.s + to2.s) / 2)) continue;
+        if (!best || from2.s < best.from.s) best = { face: fi2, from: from2, to: to2 };
+        break;
+      }
+    });
+    if (!best) break;
+    const { face: fi, from, to } = best;
+    const face = faces[fi];
+    const corners2 = [from.point];
+    for (let m = Math.floor(from.s) + 1; m <= to.s - 1e-12 && m < pts.length; m++) if (m > from.s) corners2.push(pts[m]);
+    corners2.push(to.point);
+    const forward = polySegs(corners2, eps);
+    const back = polySegs(corners2.slice().reverse(), eps);
+    const la = face.loops[from.loop];
+    const loops = face.loops.filter((_, i) => i !== from.loop && i !== to.loop);
+    if (from.loop === to.loop) {
+      const ab = arc(la, from, to, eps);
+      const ba = arc(la, to, from, eps);
+      loops.push(
+        { segs: [...ab.segs, ...back], chord: [...ab.chord, ...back.map(() => true)] },
+        { segs: [...ba.segs, ...forward], chord: [...ba.chord, ...forward.map(() => true)] }
+      );
+    } else {
+      const lb = face.loops[to.loop];
+      const roundA = arc(la, from, from, eps);
+      const roundB = arc(lb, to, to, eps);
+      loops.push({
+        segs: [...roundA.segs, ...forward, ...roundB.segs, ...back],
+        chord: [...roundA.chord, ...forward.map(() => true), ...roundB.chord, ...back.map(() => true)]
+      });
+    }
+    faces = [...faces.slice(0, fi), ...groupFaces(loops), ...faces.slice(fi + 1)];
+    cursor = to.s;
+    cuts++;
+  }
+  return cuts ? faces.map(faceToPath) : null;
+}
+function eraserRegion(points, width) {
+  const pts = points.filter((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]));
+  const r = width / 2;
+  if (!pts.length || !(r > 0)) return [];
+  const moved = pts.some((p) => !near(p, pts[0], 1e-9));
+  if (!moved) {
+    const [cx, cy] = pts[0];
+    const k = r * 0.5522847498307936;
+    return [
+      { type: "M", x: cx, y: cy - r },
+      { type: "C", x1: cx + k, y1: cy - r, x2: cx + r, y2: cy - k, x: cx + r, y: cy },
+      { type: "C", x1: cx + r, y1: cy + k, x2: cx + k, y2: cy + r, x: cx, y: cy + r },
+      { type: "C", x1: cx - k, y1: cy + r, x2: cx - r, y2: cy + k, x: cx - r, y: cy },
+      { type: "C", x1: cx - r, y1: cy - k, x2: cx - k, y2: cy - r, x: cx, y: cy - r },
+      { type: "Z" }
+    ];
+  }
+  const line2 = [{ type: "M", x: pts[0][0], y: pts[0][1] }, ...pts.slice(1).map((p) => ({ type: "L", x: p[0], y: p[1] }))];
+  return outlineStroke(line2, { width, cap: "round", join: "round" });
+}
+function eraseFromFill(path, fillRule, region) {
+  const overlap = pathBoolean("intersection", [{ path, fillRule }, { path: region }]).path;
+  if (!pathToContours(overlap).some((c) => Math.abs(contourSignedArea(closeContour(c, true))) > 1e-9)) return null;
+  const rest = pathBoolean("difference", [{ path, fillRule }, { path: region }]).path;
+  return splitIntoFaces(rest);
+}
+function eraseFromOutline(sp, region) {
+  const regionSegs = pathToContours(region).flatMap((c) => closeContour(c, true));
+  if (!regionSegs.length) return null;
+  const rb = bezierPathBounds(region);
+  const count = subpathSegmentCount(sp);
+  if (!rb || count === 0) return null;
+  const removed = (p) => pointInBezierPath(region, p, "nonzero");
+  const runs = [];
+  let cur = [];
+  let any = false;
+  for (let i = 0; i < count; i++) {
+    const seg = subpathSegment(sp, i);
+    const sb = segmentBounds(seg);
+    const ts = [0, 1];
+    if (!(sb.maxX < rb.minX || sb.minX > rb.maxX || sb.maxY < rb.minY || sb.minY > rb.maxY)) {
+      for (const r of regionSegs) {
+        const b = segmentBounds(r);
+        if (b.maxX < sb.minX || b.minX > sb.maxX || b.maxY < sb.minY || b.minY > sb.maxY) continue;
+        for (const hit of segmentIntersections(seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
+      }
+    }
+    ts.sort((a, b) => a - b);
+    for (let k = 0; k < ts.length - 1; k++) {
+      const t0 = ts[k];
+      const t1 = ts[k + 1];
+      if (t1 - t0 < 1e-9) continue;
+      if (removed(segmentPoint(seg, (t0 + t1) / 2))) {
+        any = true;
+        if (cur.length) runs.push(cur);
+        cur = [];
+      } else cur.push({ seg: i, t0, t1 });
+    }
+  }
+  if (cur.length) runs.push(cur);
+  if (!any) return null;
+  if (sp.closed && runs.length >= 2) {
+    const first = runs[0][0];
+    const lastRun = runs[runs.length - 1];
+    const last = lastRun[lastRun.length - 1];
+    if (first.seg === 0 && first.t0 === 0 && last.seg === count - 1 && last.t1 === 1) lastRun.push(...runs.shift());
+  }
+  const out = [];
+  for (const run of runs) {
+    const anchors = [];
+    for (const { seg, t0, t1 } of run) {
+      const c = subSegment(subpathSegment(sp, seg), t0, t1);
+      const line2 = c.length === 2;
+      const start = c[0];
+      const end = c[c.length - 1];
+      if (!anchors.length) anchors.push({ x: start[0], y: start[1] });
+      if (!line2) anchors[anchors.length - 1].out = { x: c[1][0], y: c[1][1] };
+      const next = { x: end[0], y: end[1] };
+      if (!line2) next.in = { x: c[2][0], y: c[2][1] };
+      anchors.push(next);
+    }
+    if (anchors.length < 2) continue;
+    for (const a of anchors) {
+      const type = inferAnchorType(a);
+      if (type !== "corner") a.type = type;
+    }
+    out.push({ anchors, closed: false });
+  }
+  return out;
+}
+function polylineBounds(points, pad = 0) {
+  if (!points.length) return null;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of points) {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  return { x: minX - pad, y: minY - pad, width: maxX - minX + 2 * pad, height: maxY - minY + 2 * pad };
+}
+function simplifyPolyline(points, tolerance) {
+  const n = points.length;
+  if (n < 3) return points.slice();
+  const keep = new Array(n).fill(false);
+  keep[0] = keep[n - 1] = true;
+  const stack = [[0, n - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    const [ax, ay] = points[a];
+    const dx = points[b][0] - ax;
+    const dy = points[b][1] - ay;
+    const len = Math.hypot(dx, dy);
+    let far = -1;
+    let farD = 0;
+    for (let i = a + 1; i < b; i++) {
+      const [px, py] = points[i];
+      const d = len < 1e-12 ? Math.hypot(px - ax, py - ay) : Math.abs((px - ax) * dy - (py - ay) * dx) / len;
+      if (d > farD) {
+        farD = d;
+        far = i;
+      }
+    }
+    if (far >= 0 && farD > tolerance) {
+      keep[far] = true;
+      stack.push([a, far], [far, b]);
+    }
+  }
+  return points.filter((_, i) => keep[i]);
+}
+
+// src/vector/ink.ts
+var LazyMouse = class {
+  /** `length` is the string length in the units of the points (0 turns smoothing off). */
+  constructor(length2) {
+    this.length = length2;
+  }
+  length;
+  pos = null;
+  last = null;
+  push(p) {
+    this.last = p;
+    if (!(this.length > 0)) return [p];
+    const pos = this.pos;
+    if (!pos) {
+      this.pos = p;
+      return [p];
+    }
+    const dx = p[0] - pos[0];
+    const dy = p[1] - pos[1];
+    const d = Math.hypot(dx, dy);
+    if (d <= this.length) return [];
+    const k = (d - this.length) / d;
+    const next = [pos[0] + dx * k, pos[1] + dy * k];
+    this.pos = next;
+    return [next];
+  }
+  /** The string from the pen to the pointer while they are apart, else null. */
+  string() {
+    const { pos, last } = this;
+    if (!(this.length > 0) || !pos || !last || pos[0] === last[0] && pos[1] === last[1]) return null;
+    return [pos, last];
+  }
+  /** End of stroke: the pen catches up with the pointer (the point to add, if it lagged). */
+  finish() {
+    const { pos, last } = this;
+    if (!(this.length > 0) || !pos || !last || pos[0] === last[0] && pos[1] === last[1]) return [];
+    this.pos = last;
+    return [last];
+  }
+};
+var VECTOR_INK_MAX_CORNERS = 8;
+var MAX_POINTS = 1e5;
+function vectorInkShapeName(shape) {
+  switch (shape.kind) {
+    case "line":
+      return "line";
+    case "rect":
+      return shape.width === shape.height ? "square" : "rectangle";
+    case "ellipse":
+      return shape.width === shape.height ? "circle" : "ellipse";
+    case "polygon":
+      return shape.points.length === 3 ? "triangle" : "polygon";
+  }
+}
+var dist2 = (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];
+  let [x1, y1] = pts[0];
+  for (const [x, y] of pts) {
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  }
+  return [x0, y0, x1 - x0, y1 - y0];
+}
+function segDistance(a, b, p) {
+  const dx = b[0] - a[0];
+  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 dist2([a[0] + t * dx, a[1] + t * dy], p);
+}
+function polygonDistance(c, p) {
+  let best = Infinity;
+  for (let i = 0; i < c.length; i++) best = Math.min(best, segDistance(c[i], c[(i + 1) % c.length], p));
+  return best;
+}
+function ellipseRms(p, x0, y0, w, h) {
+  const rx = w / 2;
+  const ry = h / 2;
+  if (rx <= 0 || ry <= 0 || !p.length) return Infinity;
+  const cx = x0 + rx;
+  const cy = y0 + ry;
+  let sum = 0;
+  for (const [x, y] of p) sum += (Math.hypot((x - cx) / rx, (y - cy) / ry) - 1) ** 2;
+  return Math.sqrt(sum / p.length);
+}
+function snapSquare(x, y, w, h) {
+  if (Math.abs(w - h) <= 0.12 * Math.max(w, h)) {
+    const s = (w + h) / 2;
+    return [x + (w - s) / 2, y + (h - s) / 2, s, s];
+  }
+  return [x, y, w, h];
+}
+function turning(a, b, c) {
+  const u = [b[0] - a[0], b[1] - a[1]];
+  const v = [c[0] - b[0], c[1] - b[1]];
+  const lu = Math.hypot(u[0], u[1]);
+  const lv = Math.hypot(v[0], v[1]);
+  if (lu <= 0 || lv <= 0) return 0;
+  return Math.acos(Math.min(1, Math.max(-1, (u[0] * v[0] + u[1] * v[1]) / (lu * lv)))) * 180 / Math.PI;
+}
+function rdp(p, eps) {
+  const n = p.length;
+  if (n < 3) return p.slice();
+  const keep = new Array(n).fill(false);
+  keep[0] = keep[n - 1] = true;
+  const stack = [[0, n - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    let far = a;
+    let farD = 0;
+    for (let i = a + 1; i < b; i++) {
+      const d = segDistance(p[a], p[b], p[i]);
+      if (d > farD) {
+        farD = d;
+        far = i;
+      }
+    }
+    if (farD > eps) {
+      keep[far] = true;
+      stack.push([a, far], [far, b]);
+    }
+  }
+  return p.filter((_, i) => keep[i]);
+}
+function corners(p, diag) {
+  const eps = 0.05 * diag;
+  const start = p[0];
+  let far = 0;
+  let farD = 0;
+  p.forEach((q, i) => {
+    const d = dist2(start, q);
+    if (d > farD) {
+      farD = d;
+      far = i;
+    }
+  });
+  const a = p.slice(0, far);
+  const b = p.slice(far);
+  const ring = rdp([...a, ...b.slice(0, 1)], eps);
+  const back = rdp([...b, start], eps);
+  ring.pop();
+  back.pop();
+  ring.push(...back);
+  while (ring.length > 3) {
+    const n = ring.length;
+    const turn = (i) => turning(ring[(i + n - 1) % n], ring[i], ring[(i + 1) % n]);
+    let flat = 0;
+    let flatT = Infinity;
+    for (let i = 0; i < n; i++) {
+      const t = turn(i);
+      if (t < flatT) {
+        flatT = t;
+        flat = i;
+      }
+    }
+    let short = -1;
+    for (let j = 0; j < n; j++) {
+      if (dist2(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
+        short = j;
+        break;
+      }
+    }
+    if (flatT < 30) ring.splice(flat, 1);
+    else if (short >= 0) {
+      const k = turn(short) < turn((short + 1) % n) ? short : (short + 1) % n;
+      ring.splice(k, 1);
+    } else break;
+  }
+  return ring;
+}
+function upright(c) {
+  const n = c.length;
+  const dirs = c.map((a, i) => {
+    const b = c[(i + 1) % n];
+    const deg = (Math.atan2(b[1] - a[1], b[0] - a[0]) * 180 / Math.PI % 180 + 180) % 180;
+    if (deg <= 15 || deg >= 165) return "across";
+    if (deg >= 75 && deg <= 105) return "down";
+    return null;
+  });
+  return dirs.every((d) => d !== null) && dirs.every((d, i) => d !== dirs[(i + 1) % n]);
+}
+function recognizeInkShape(points, options = {}) {
+  const minSize = options.minSize ?? 6;
+  const p = [];
+  for (const q of points.slice(0, MAX_POINTS)) {
+    if (!Number.isFinite(q[0]) || !Number.isFinite(q[1]) || Math.abs(q[0]) >= 1e9 || Math.abs(q[1]) >= 1e9) continue;
+    const last2 = p[p.length - 1];
+    if (!last2 || last2[0] !== q[0] || last2[1] !== q[1]) p.push([q[0], q[1]]);
+  }
+  if (p.length < 2) return null;
+  const first = p[0];
+  const last = p[p.length - 1];
+  const [x0, y0, w, h] = bbox(p);
+  const size = Math.max(w, h);
+  const diag = Math.hypot(w, h);
+  if (size < minSize) return null;
+  let length2 = 0;
+  for (let i = 1; i < p.length; i++) length2 += dist2(p[i - 1], p[i]);
+  const gap = dist2(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 };
+  }
+  if (gap > 0.2 * size || length2 < 2 * size) return null;
+  const rms = ellipseRms(p, x0, y0, w, h);
+  const roundish = w > 0.2 * size && h > 0.2 * size;
+  const ellipse = () => {
+    const [x, y, sw, sh] = snapSquare(x0, y0, w, h);
+    return { kind: "ellipse", x, y, width: sw, height: sh };
+  };
+  if (roundish && rms < 0.06) return ellipse();
+  const c = corners(p, diag);
+  const fits = c.length >= 3 && p.every((q) => polygonDistance(c, q) <= 0.08 * diag);
+  if (fits && c.length === 4 && upright(c)) {
+    const [bx, by, bw, bh] = bbox(c);
+    const [x, y, sw, sh] = snapSquare(bx, by, bw, bh);
+    return { kind: "rect", x, y, width: sw, height: sh };
+  }
+  if (fits && c.length <= VECTOR_INK_MAX_CORNERS) return { kind: "polygon", points: c };
+  return roundish && rms < 0.1 ? ellipse() : null;
+}
+
 // src/vector/controller.ts
+var DEFAULT_VECTOR_SNAP = { grid: 0, objects: true, guides: true, threshold: 5, angles: VECTOR_CONSTRUCTION_ANGLES };
+var DEFAULT_VECTOR_PATH_EDIT = { keepShapeOnDelete: true, curvatureMoves: false, pencilSmoothing: 0, recognizeShapes: false, eraserSize: 10 };
+var VECTOR_PENCIL_STRING_PX = 100;
 var VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 var DEFAULT_DEFAULTS = {
   fill: "#d4d4d8",
@@ -969,14 +2693,14 @@ function getVectorSelectionBoxGeometry(frame, viewport) {
   const rot = rotateMatrix(frame.angle, { x: viewport.x, y: viewport.y });
   const toScreen2 = (p) => frame.angle ? applyMatrix(rot, p) : { x: p.x, y: p.y };
   const handles = getTransformHandlePositions(box).map((h) => ({ ...h, screen: toScreen2(h) }));
-  const corners = [
+  const corners2 = [
     { x: box.x, y: box.y },
     { x: box.x + box.width, y: box.y },
     { x: box.x + box.width, y: box.y + box.height },
     { x: box.x, y: box.y + box.height }
   ].map(toScreen2);
   const r = (n) => Math.round(n * 1e3) / 1e3;
-  return { box, angle: frame.angle, transform: frame.angle ? `rotate(${r(frame.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners };
+  return { box, angle: frame.angle, transform: frame.angle ? `rotate(${r(frame.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners: corners2 };
 }
 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 };
@@ -994,9 +2718,12 @@ var TOOL_LABELS = {
   ellipse: "Ellipse",
   polygon: "Polygon",
   star: "Star",
-  line: "Line"
+  line: "Line",
+  scissors: "Scissors",
+  knife: "Knife",
+  eraser: "Eraser"
 };
-var TOOL_KEYS = { v: "select", a: "direct", p: "pen", n: "pencil", r: "rect", o: "ellipse", e: "ellipse", y: "polygon", s: "star", l: "line" };
+var TOOL_KEYS = { v: "select", a: "direct", p: "pen", n: "pencil", r: "rect", o: "ellipse", y: "polygon", s: "star", l: "line", c: "scissors", k: "knife", e: "eraser" };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
 }
@@ -1009,7 +2736,10 @@ var VECTOR_TOOL_SHORTCUTS = {
   ellipse: "O",
   polygon: "Y",
   star: "S",
-  line: "L"
+  line: "L",
+  scissors: "C",
+  knife: "K",
+  eraser: "E"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -1020,8 +2750,12 @@ var VECTOR_TOOL_GLYPHS = {
   ellipse: "\u25EF",
   polygon: "\u2B21",
   star: "\u2606",
-  line: "\u2571"
+  line: "\u2571",
+  scissors: "\u2702",
+  knife: "\u27CB",
+  eraser: "\u232B"
 };
+var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
   union: "union",
   subtract: "difference",
@@ -1043,6 +2777,28 @@ function mapTree(nodes, fn) {
   }
   return changed ? out : nodes;
 }
+function spliceTree(nodes, id, replacements) {
+  let changed = false;
+  const out = [];
+  for (const node of nodes) {
+    if (node.id === id) {
+      changed = true;
+      out.push(...replacements);
+      continue;
+    }
+    if (node.type === "group") {
+      const children = spliceTree(node.children, id, replacements);
+      if (children !== node.children) {
+        changed = true;
+        out.push({ ...node, children });
+        continue;
+      }
+    }
+    out.push(node);
+  }
+  return changed ? out : nodes;
+}
+var toPoint2 = (p) => [p.x, p.y];
 var isRoot = (m) => m === IDENTITY_MATRIX || m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
 var idCounter = 0;
 var defaultCreateId = () => `vn-${Date.now().toString(36)}${(++idCounter).toString(36)}`;
@@ -1057,11 +2813,17 @@ var VectorEditorController = class {
   defaults;
   viewport;
   snap;
+  editing;
   hitRadius;
   hover = null;
   pointer = null;
   drag = null;
   interaction = null;
+  guides = null;
+  /** Whether the last `snapDrawn` landed on an object (guides may be hidden). */
+  snappedToObject = false;
+  /** Drawing targets for hovering the pen and shape tools, kept while the document and the excluded path stay the same. */
+  hoverTargets = null;
   spaceHeld = false;
   clipboard = null;
   createId;
@@ -1079,7 +2841,8 @@ var VectorEditorController = class {
     this.tool = options.tool ?? "select";
     this.defaults = { ...DEFAULT_DEFAULTS, ...options.defaults ?? {} };
     this.viewport = { x: 0, y: 0, zoom: 1, ...options.viewport ?? {} };
-    this.snap = { grid: 0, ...options.snap ?? {} };
+    this.snap = { ...DEFAULT_VECTOR_SNAP, ...options.snap ?? {} };
+    this.editing = { ...DEFAULT_VECTOR_PATH_EDIT, ...options.editing ?? {} };
     this.hitRadius = options.hitRadius ?? 6;
     this.createId = options.createId ?? defaultCreateId;
     this.onChange = options.onChange;
@@ -1128,6 +2891,8 @@ var VectorEditorController = class {
       viewport: this.viewport,
       defaults: this.defaults,
       snap: this.snap,
+      editing: this.editing,
+      guides: this.guides,
       hitRadius: this.hitRadius,
       hover: this.hover,
       cursor: this.cursorFor(),
@@ -1312,6 +3077,7 @@ var VectorEditorController = class {
     this.cancelDrag();
     this.tool = tool;
     this.hover = null;
+    this.guides = null;
     if (tool !== "direct") {
       this.anchors = [];
       this.editingId = null;
@@ -1324,18 +3090,82 @@ var VectorEditorController = class {
   }
   setSnap(snap) {
     this.snap = { ...this.snap, ...snap };
+    if (!this.snap.guides || !this.snap.objects) this.guides = null;
+    this.notify();
+  }
+  /** Changes how deleting, dragging anchors, the pencil and the eraser behave. */
+  setEditing(editing) {
+    const next = { ...this.editing, ...editing };
+    next.pencilSmoothing = Math.min(1, Math.max(0, Number.isFinite(next.pencilSmoothing) ? next.pencilSmoothing : 0));
+    if (!(next.eraserSize > 0)) next.eraserSize = this.editing.eraserSize;
+    this.editing = next;
     this.notify();
   }
-  snapPoint(p) {
-    const g = this.snap.grid;
-    if (!g || g <= 0) return p;
-    return { x: Math.round(p.x / g) * g, y: Math.round(p.y / g) * g };
+  /** Turns object snapping on or off (the toolbar's snapping toggle). */
+  toggleSnapping(on = !this.snap.objects) {
+    this.setSnap({ objects: on });
   }
-  snapDelta(dx, dy, origin) {
+  gridValue(v) {
     const g = this.snap.grid;
-    if (!g || g <= 0 || !origin) return { dx, dy };
-    const target = this.snapPoint({ x: origin.x + dx, y: origin.y + dy });
-    return { dx: target.x - origin.x, dy: target.y - origin.y };
+    return g > 0 ? Math.round(v / g) * g : v;
+  }
+  snapPoint(p) {
+    return { x: this.gridValue(p.x), y: this.gridValue(p.y) };
+  }
+  /** The pull distance in document units. */
+  snapTolerance() {
+    return this.snap.threshold / this.viewport.zoom;
+  }
+  setGuides(guides) {
+    this.guides = guides && this.snap.guides && (guides.lines.length || guides.labels.length) ? guides : null;
+  }
+  /**
+   * Where a drawn or dragged point `p` goes: onto the smart guide `targets` (gathered by
+   * `gather` when missing), else onto the grid, kept to `leave`'s constraint. Cmd / Ctrl
+   * bypasses snapping.
+   */
+  snapDrawn(p, leave, input, targets) {
+    this.snappedToObject = false;
+    if (input.mod) {
+      this.setGuides(null);
+      return constrainToLeave(leave, p);
+    }
+    if (this.snap.objects) {
+      const withAngles = leave ? { ...leave, angles: this.snap.angles } : null;
+      const res = targets().snapFrom(p, withAngles, this.snapTolerance());
+      if (res.kind) {
+        this.snappedToObject = true;
+        this.setGuides(res);
+        return leave?.constrain ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
+      }
+    }
+    this.setGuides(null);
+    return constrainToLeave(leave, this.snapPoint(p));
+  }
+  /** Drawing targets for the pen and shape tools, reused while the document stays the same. */
+  drawingTargets(exclude) {
+    const key = exclude ?? "";
+    const cached = this.hoverTargets;
+    if (cached && cached.doc === this.doc && cached.exclude === key) return cached.targets;
+    const targets = VectorSnapTargets.forDrawing(this.doc, exclude ? [exclude] : []);
+    this.hoverTargets = { doc: this.doc, exclude: key, targets };
+    return targets;
+  }
+  /** Where the pointer at `p` would place a point with the pen or a shape tool (and the guides showing why). */
+  hoverSnap(p, input) {
+    if (this.tool === "pen") {
+      const sp = this.pen ? this.getNode(this.pen.nodeId)?.subpaths[this.pen.subpath] : void 0;
+      if (this.pen && sp && this.hover?.anchor) {
+        this.setGuides(null);
+        return p;
+      }
+      const last = this.pen && sp ? getAnchorWorld(this.doc, { nodeId: this.pen.nodeId, subpath: this.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
+      const leave = last ? { at: { x: last.x, y: last.y }, constrain: input.shift ? "angle" : null } : null;
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(this.pen?.nodeId ?? null));
+    }
+    if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
+    this.setGuides(null);
+    return p;
   }
   // -------------------------------------------------------------------------
   // Document
@@ -1936,12 +3766,47 @@ var VectorEditorController = class {
       return translateAnchor(a, d.x, d.y);
     });
   }
-  /** Moves one anchor to a document position (handles follow). */
-  moveAnchor(ref, to) {
+  /**
+   * Moves one anchor to a document position. Its handles follow; with `curvature` (default:
+   * the `curvatureMoves` setting) its two segments bend instead, as the Curvature tool does.
+   */
+  moveAnchor(ref, to, options = {}) {
     const a = getAnchorWorld(this.doc, ref);
     if (!a) return { ok: false, message: "There is no such anchor." };
+    const curvature = options.curvature ?? this.editing.curvatureMoves;
     this.change("Move Point", () => {
-      this.doc = this.movedAnchors(this.doc, [ref], to.x - a.x, to.y - a.y);
+      this.doc = curvature ? this.curvatureMoved(this.doc, ref, to) : this.movedAnchors(this.doc, [ref], to.x - a.x, to.y - a.y);
+    });
+    return { ok: true };
+  }
+  /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
+  curvatureMoved(doc, ref, to) {
+    const node = findVectorNode(doc.nodes, ref.nodeId);
+    if (node?.type !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    const q = this.toLocal(ref.nodeId, to, doc);
+    const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? curvatureMoveAnchor(sp, ref.index, q) : sp);
+    const nodes = mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n);
+    return { ...doc, nodes };
+  }
+  /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
+  bent(doc, ref, t, p) {
+    const node = findVectorNode(doc.nodes, ref.nodeId);
+    if (node?.type !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    const q = this.toLocal(ref.nodeId, p, doc);
+    const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? bendSegment(sp, ref.segment, t, q) : sp);
+    return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n) };
+  }
+  /**
+   * Bends a segment so the curve passes through document point `to` at parameter `t`
+   * (default 0.5, clamped to 0.05–0.95); see `bendSegment` in `pathEdit`.
+   */
+  bendSegment(ref, to, t = 0.5) {
+    const node = this.getNode(ref.nodeId);
+    const sp = node?.type === "path" ? node.subpaths[ref.subpath] : void 0;
+    if (!sp || ref.segment < 0 || ref.segment >= (sp.closed ? sp.anchors.length : sp.anchors.length - 1) || sp.anchors.length < 2) return { ok: false, message: "There is no such segment." };
+    if (node.locked) return { ok: false, message: "The path is locked." };
+    this.change("Bend Segment", () => {
+      this.doc = this.bent(this.doc, ref, t, to);
     });
     return { ok: true };
   }
@@ -1984,15 +3849,24 @@ var VectorEditorController = class {
     });
     return ref;
   }
-  /** Deletes the selected anchors; empty subpaths and paths go too. */
-  deleteAnchors(refs = this.anchors) {
+  /**
+   * Deletes the selected (or given) anchors; subpaths left with one anchor and empty paths go
+   * too. With `keepShape` (default: the `keepShapeOnDelete` setting, on) the neighbours'
+   * handles are refitted so the path keeps its shape; off, the neighbours are joined as they are.
+   */
+  deleteAnchors(refs = this.anchors, options = {}) {
     if (!refs.length) return { ok: false, message: "Select points to delete." };
+    const keepShape = options.keepShape ?? this.editing.keepShapeOnDelete;
     this.change("Delete Points", () => {
       const nodes = mapTree(this.doc.nodes, (n) => {
-        if (n.type !== "path") return n;
+        if (n.type !== "path" || n.locked) return n;
         const mine = refs.filter((r) => r.nodeId === n.id);
         if (!mine.length) return n;
-        const subpaths = n.subpaths.map((sp, s) => removeAnchors(sp, mine.filter((r) => r.subpath === s).map((r) => r.index))).filter((sp) => sp.anchors.length > 1);
+        const subpaths = n.subpaths.map((sp, s) => {
+          const indices = mine.filter((r) => r.subpath === s).map((r) => r.index);
+          if (!indices.length) return sp;
+          return keepShape ? removeAnchorsKeepingShape(sp, indices) : removeAnchors(sp, indices);
+        }).filter((sp) => sp.anchors.length > 1);
         return subpaths.length ? { ...n, subpaths } : null;
       });
       this.setDoc(nodes);
@@ -2030,6 +3904,269 @@ var VectorEditorController = class {
     });
     return { ok: true };
   }
+  // -------------------------------------------------------------------------
+  // Path clean-up, Scissors, Knife and Eraser
+  // -------------------------------------------------------------------------
+  /** Unlocked path nodes in the given roots (default: the paths being edited, else the selection). */
+  pathTargets(ids) {
+    const roots = ids ?? (this.tool === "direct" && this.anchors.length ? [...new Set(this.anchors.map((r) => r.nodeId))] : this.selection);
+    const out = /* @__PURE__ */ new Map();
+    for (const id of roots) {
+      const node = this.getNode(id);
+      if (node && !node.locked) {
+        for (const p of collectPathNodes(node)) if (!p.locked) out.set(p.id, p);
+      }
+    }
+    const order = [];
+    walkVectorNodes(this.doc.nodes, (n) => {
+      if (out.has(n.id)) order.push(n.id);
+    });
+    return order.map((id) => out.get(id));
+  }
+  /** Subpaths of node `from` mapped into node `to`'s own space. */
+  subpathsIn(from, to) {
+    const m = multiplyMatrices(this.worldOf(from.id), invertMatrix(this.worldOf(to)));
+    if (isRoot(m)) return from.subpaths;
+    const map = (p) => applyMatrix(m, p);
+    return from.subpaths.map((sp) => ({
+      closed: sp.closed,
+      anchors: sp.anchors.map((a) => ({ ...map(a), ...a.in ? { in: map(a.in) } : {}, ...a.out ? { out: map(a.out) } : {}, ...a.type ? { type: a.type } : {} }))
+    }));
+  }
+  /**
+   * Replaces a path with pieces: each entry becomes one path (the first keeps the node's id and
+   * place, the others go just above it with the same style). No pieces removes the path.
+   * Returns the ids of the paths now standing in for it.
+   */
+  replaceWithPieces(node, pieces) {
+    const nodes = pieces.filter((p) => p.length).map((subpaths, i) => ({ ...node, id: i === 0 ? node.id : this.newId(), subpaths }));
+    this.setDoc(spliceTree(this.doc.nodes, node.id, nodes));
+    return nodes.map((n) => n.id);
+  }
+  /** Clears anchor selections, editing and pen state that no longer point at anything. */
+  dropStaleRefs() {
+    this.selection = this.selection.filter((id) => this.getNode(id));
+    this.anchors = this.anchors.filter((r) => getAnchor(this.doc, r));
+    if (this.editingId && !this.getNode(this.editingId)) this.editingId = null;
+    if (this.pen && !this.getNode(this.pen.nodeId)) this.pen = null;
+  }
+  /**
+   * Join: the open subpaths of the selected (or given) paths become one open path, joined
+   * nearest endpoints first (ends within `tolerance` document units merge into one anchor,
+   * others get a straight segment); a single open subpath is closed. The result replaces the
+   * lowest path, in its space and style. Default tolerance: the pick distance.
+   */
+  joinPaths(options = {}) {
+    const paths = this.pathTargets(options.ids);
+    if (!paths.length) return { ok: false, message: "Select paths to join." };
+    const base = paths[0];
+    const all = paths.flatMap((p) => this.subpathsIn(p, base.id));
+    if (!all.some((sp) => !sp.closed && sp.anchors.length > 1)) return { ok: false, message: "There are no open paths to join." };
+    const subpaths = joinSubpaths(all, options.tolerance ?? this.tolerance());
+    const drop = new Set(paths.slice(1).map((p) => p.id));
+    this.change("Join", () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => n.id === base.id ? { ...base, subpaths } : drop.has(n.id) ? null : n));
+      this.selection = [base.id];
+      this.anchors = [];
+      if (this.editingId && drop.has(this.editingId)) this.editingId = base.id;
+      this.dropStaleRefs();
+    });
+    return { ok: true };
+  }
+  /** Average: moves the selected (or given) anchors onto their average position along `axis`, in document space. */
+  averageAnchors(axis = "both", refs = this.anchors) {
+    const points = refs.map((r) => ({ ref: r, at: getAnchorWorld(this.doc, r) })).filter((p) => !!p.at);
+    if (points.length < 2) return { ok: false, message: "Select at least two points to average." };
+    const cx = points.reduce((s, p) => s + p.at.x, 0) / points.length;
+    const cy = points.reduce((s, p) => s + p.at.y, 0) / points.length;
+    this.change("Average", () => {
+      for (const { ref, at } of points) {
+        const dx = axis === "horizontal" ? 0 : cx - at.x;
+        const dy = axis === "vertical" ? 0 : cy - at.y;
+        if (dx || dy) this.doc = this.movedAnchors(this.doc, [ref], dx, dy);
+      }
+    });
+    return { ok: true };
+  }
+  /** Applies `fn` to every subpath of the target paths as one undo step. */
+  editSubpaths(label, ids, fn) {
+    const paths = this.pathTargets(ids);
+    if (!paths.length) return { ok: false, message: "Select a path." };
+    const set = new Set(paths.map((p) => p.id));
+    this.change(label, () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map((sp, i) => fn(sp, n, i)) } : n));
+      this.dropStaleRefs();
+    });
+    return { ok: true };
+  }
+  /**
+   * Remove Redundant Points: drops anchors of the selected (or given) paths that can go
+   * without moving the outline more than `tolerance` document units (default 0.5).
+   */
+  removeRedundantPoints(options = {}) {
+    const tolerance = options.tolerance ?? 0.5;
+    return this.editSubpaths("Remove Redundant Points", options.ids, (sp) => removeRedundantPoints(sp, tolerance));
+  }
+  /**
+   * Smooth: pulls handles towards smooth tangents by `amount` (0–1, default 1). With the direct
+   * tool and points selected, only those points change.
+   */
+  smoothPaths(options = {}) {
+    const refs = options.refs ?? (!options.ids && this.tool === "direct" && this.anchors.length ? this.anchors : null);
+    const ids = options.ids ?? (refs ? [...new Set(refs.map((r) => r.nodeId))] : void 0);
+    return this.editSubpaths("Smooth", ids, (sp, node, i) => {
+      const only = refs ? new Set(refs.filter((r) => r.nodeId === node.id && r.subpath === i).map((r) => r.index)) : void 0;
+      return only && !only.size ? sp : smoothSubpath(sp, options.amount ?? 1, only);
+    });
+  }
+  /** Splits a cut subpath into pieces: separate paths for a one-subpath node, subpaths in place for a compound one. */
+  applyCuts(node, cut) {
+    const results = node.subpaths.map((sp, i) => cut(sp, i));
+    if (results.every((r) => !r)) return null;
+    const subpaths = node.subpaths.flatMap((sp, i) => results[i] ?? [sp]);
+    if (node.subpaths.length === 1) return this.replaceWithPieces(node, subpaths.map((sp) => [sp]));
+    this.replaceNode(node.id, { ...node, subpaths });
+    return [node.id];
+  }
+  /**
+   * Scissors: cuts path `nodeId` at the outline point nearest document point `point` (at an
+   * anchor when within the pick distance of one). A closed subpath opens there; an open one
+   * splits in two (a one-subpath path becomes two paths). Returns the ids of the paths.
+   */
+  cutPathAt(nodeId, point) {
+    const node = this.getNode(nodeId);
+    if (node?.type !== "path" || node.locked) return null;
+    const local = this.toLocal(nodeId, point);
+    const hit = nearestSegment(node, local);
+    if (!hit) return null;
+    const sp = node.subpaths[hit.subpath];
+    const n = sp.anchors.length;
+    const near2 = [hit.segment, (hit.segment + 1) % n].find((i) => Math.hypot(sp.anchors[i].x - hit.point.x, sp.anchors[i].y - hit.point.y) <= this.tolerance());
+    if (!sp.closed && n > 1 && (near2 === 0 || near2 === n - 1) && !(hit.t > 1e-6 && hit.t < 1 - 1e-6)) return null;
+    let ids = null;
+    this.change("Cut Path", () => {
+      ids = this.applyCuts(node, (s, i) => i !== hit.subpath ? null : near2 !== void 0 ? cutSubpathAt(s, [near2]) : splitSubpathAt(s, hit.segment, hit.t));
+      if (ids) {
+        this.selection = ids;
+        this.anchors = [];
+        if (this.editingId === nodeId) this.editingId = null;
+      }
+      this.dropStaleRefs();
+    });
+    return ids;
+  }
+  /** Scissors on the selected (or given) anchors: each cuts its subpath there (see `cutPathAt`). */
+  cutAtAnchors(refs = this.anchors) {
+    const byNode = /* @__PURE__ */ new Map();
+    for (const r of refs) if (getAnchor(this.doc, r)) byNode.set(r.nodeId, [...byNode.get(r.nodeId) ?? [], r]);
+    if (!byNode.size) return { ok: false, message: "Select points to cut at." };
+    const created = [];
+    this.change("Cut Path", () => {
+      for (const [id, list] of byNode) {
+        const node = this.getNode(id);
+        if (node.locked) continue;
+        const ids = this.applyCuts(node, (sp, i) => {
+          const at = list.filter((r) => r.subpath === i).map((r) => r.index);
+          const pieces = at.length ? cutSubpathAt(sp, at) : null;
+          return pieces && !(pieces.length === 1 && pieces[0].closed === sp.closed) ? pieces : null;
+        });
+        if (ids) created.push(...ids);
+      }
+      if (created.length) this.selection = created;
+      this.anchors = [];
+      this.dropStaleRefs();
+    });
+    return created.length ? { ok: true } : { ok: false, message: "Points at the ends of open paths do not cut." };
+  }
+  /** Visible, unlocked paths a stroke over `points` can reach: in `ids`, the selection, or (with neither) any whose bounds it crosses. */
+  strokeTargets(points, ids, pad) {
+    const blocked = /* @__PURE__ */ new Set();
+    walkVectorNodes(this.doc.nodes, (n, parent) => {
+      if (n.visible === false || n.locked || parent && blocked.has(parent.id)) blocked.add(n.id);
+    });
+    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);
+    if (!box) return [];
+    const out = [];
+    walkVectorNodes(this.doc.nodes, (n) => {
+      if (n.type !== "path" || !visible(n)) return;
+      const b = vectorNodeBounds(n, vectorParentMatrix(this.doc.nodes, n.id) ?? IDENTITY_MATRIX);
+      if (b && boundsIntersect(b, box)) out.push(n);
+    });
+    return out;
+  }
+  /** 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)));
+  }
+  /**
+   * Knife: cuts closed paths along the polyline `points` (document space) wherever it crosses
+   * them from edge to edge, with no gap between the pieces. It cuts the given paths, the
+   * selection, or (with neither) every path it crosses. Returns the ids of the pieces (empty
+   * when nothing was cut).
+   */
+  knife(points, options = {}) {
+    const pts = simplifyPolyline(points.map(toPoint2), 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)) {
+      const closed = node.subpaths.filter((sp) => sp.anchors.length > 1);
+      if (!closed.length || closed.some((sp) => !sp.closed)) continue;
+      const result = knifePath(subpathsToBezier(closed), node.fillRule ?? "nonzero", this.localPoints(node.id, pts));
+      if (result) plan.push({ node, pieces: result.map((path) => bezierToSubpaths(path)) });
+    }
+    if (!plan.length) return [];
+    const created = [];
+    this.change("Knife", () => {
+      for (const { node, pieces } of plan) created.push(...this.replaceWithPieces(node, pieces));
+      this.selection = created;
+      this.anchors = [];
+      this.dropStaleRefs();
+    });
+    return created;
+  }
+  /**
+   * Eraser: rubs out a round stroke of diameter `size` (default: the `eraserSize` setting)
+   * along `points` (document space). Filled closed paths lose that area (pieces that come
+   * apart become separate paths); outlines are cut where they pass under it. It erases from
+   * the given paths, the selection, or (with neither) every path it reaches. Returns the ids
+   * of the paths it changed or created.
+   */
+  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 region = eraserRegion(pts, width);
+    if (!region.length) return [];
+    const plan = [];
+    const rb = bezierPathBounds(region);
+    const reach = rb ? [{ x: rb.minX, y: rb.minY }, { x: rb.maxX, y: rb.maxY }] : points;
+    for (const node of this.strokeTargets(reach, options.ids, 0)) {
+      const local = transformBezierPath(region, invertMatrix(this.worldOf(node.id)));
+      const live = node.subpaths.filter((sp) => sp.anchors.length > 1);
+      if (!live.length) continue;
+      if (hasPaint(node.fill) && live.every((sp) => sp.closed)) {
+        const faces = eraseFromFill(subpathsToBezier(live), node.fillRule ?? "nonzero", local);
+        if (faces) plan.push({ node, pieces: faces.map((f) => bezierToSubpaths(f)) });
+        continue;
+      }
+      const results = live.map((sp) => eraseFromOutline(sp, local));
+      if (results.every((r) => !r)) continue;
+      const subpaths = live.flatMap((sp, i) => results[i] ?? [sp]);
+      plan.push({ node, pieces: live.length === 1 ? subpaths.map((sp) => [sp]) : [subpaths] });
+    }
+    if (!plan.length) return [];
+    const changed = [];
+    this.change("Erase", () => {
+      for (const { node, pieces } of plan) changed.push(...this.replaceWithPieces(node, pieces));
+      this.anchors = [];
+      this.dropStaleRefs();
+      if (this.selection.length || options.ids) this.selection = [.../* @__PURE__ */ new Set([...this.selection, ...changed.filter((id) => this.getNode(id))])];
+    });
+    return changed;
+  }
   /** Ends the pen path being drawn (a lone anchor is removed). */
   finishPath() {
     if (!this.pen) return;
@@ -2222,10 +4359,38 @@ var VectorEditorController = class {
         const anchor = this.hitAnchor(screen, refs);
         return anchor ? { nodeId: anchor.nodeId, anchor } : null;
       }
+      case "scissors": {
+        const seg = this.nearestOutline(p);
+        return seg ? { nodeId: seg.nodeId, segment: seg } : null;
+      }
       default:
         return null;
     }
   }
+  /** The nearest outline point of any visible, unlocked path within the pick distance of document point `p`. */
+  nearestOutline(p) {
+    let best = null;
+    const tol = this.tolerance();
+    const visit = (list, parent) => {
+      for (let i = list.length - 1; i >= 0; i--) {
+        const n = list[i];
+        if (n.visible === false || n.locked) continue;
+        const m = multiplyMatrices(nodeMatrix(n), parent);
+        if (n.type === "group") {
+          visit(n.children, m);
+          continue;
+        }
+        const hit = nearestSegment(n, applyMatrix(invertMatrix(m), p));
+        if (hit && hit.distance <= tol && (!best || hit.distance < best.distance - 1e-9)) {
+          best = { nodeId: n.id, subpath: hit.subpath, segment: hit.segment, t: hit.t, point: applyMatrix(m, hit.point), distance: hit.distance };
+        }
+      }
+    };
+    visit(this.doc.nodes, IDENTITY_MATRIX);
+    if (!best) return null;
+    const { distance: _d, ...seg } = best;
+    return seg;
+  }
   sameHover(a, b) {
     return JSON.stringify(a) === JSON.stringify(b);
   }
@@ -2250,8 +4415,19 @@ var VectorEditorController = class {
         return this.downPen(screen, p, input);
       case "pencil":
         return this.downPencil(p);
+      case "scissors": {
+        const seg = this.nearestOutline(p);
+        if (seg) this.cutPathAt(seg.nodeId, seg.point);
+        return;
+      }
+      case "knife":
+      case "eraser":
+        this.drag = { kind: "stroke", tool: this.tool, points: [p], before: this.snapshot() };
+        this.interaction = { type: "stroke", tool: this.tool, points: [p], width: this.tool === "eraser" ? this.editing.eraserSize : 0 };
+        this.notify();
+        return;
       default:
-        return this.downShape(p);
+        return this.downShape(p, input);
     }
   }
   downSelect(screen, p, input) {
@@ -2320,7 +4496,7 @@ var VectorEditorController = class {
           return;
         }
       } else if (!selected) this.anchors = [anchor];
-      this.drag = { kind: "anchors", start: p, before: this.snapshot(), base: this.doc, moved: false, clickRef: selected && !input.shift ? anchor : null };
+      this.drag = { kind: "anchors", start: p, before: this.snapshot(), base: this.doc, moved: false, clickRef: selected && !input.shift ? anchor : null, lead: anchor };
       this.notify();
       return;
     }
@@ -2336,7 +4512,7 @@ var VectorEditorController = class {
         const ref = { nodeId: id, subpath: seg.subpath, index };
         this.anchors = [ref];
         this.editingId = id;
-        this.drag = { kind: "anchors", start: p, before, base: this.doc, moved: true, clickRef: null };
+        this.drag = { kind: "anchors", start: p, before, base: this.doc, moved: true, clickRef: null, lead: ref };
         this.notify(true);
         return;
       }
@@ -2344,7 +4520,7 @@ var VectorEditorController = class {
       const b = { nodeId: id, subpath: seg.subpath, index: (seg.segment + 1) % sp.anchors.length };
       this.anchors = input.shift ? [...this.anchors.filter((r) => !sameRef(r, a) && !sameRef(r, b)), a, b] : [a, b];
       this.editingId = id;
-      this.drag = { kind: "anchors", start: p, before: this.snapshot(), base: this.doc, moved: false, clickRef: null };
+      this.drag = { kind: "bend", ref: { nodeId: id, subpath: seg.subpath, segment: seg.segment }, t: seg.t, start: p, before: this.snapshot(), base: this.doc, moved: false };
       this.notify();
       return;
     }
@@ -2354,7 +4530,7 @@ var VectorEditorController = class {
       if (!input.shift) this.selection = [path.id];
       else if (!this.selection.includes(path.id)) this.selection = [...this.selection, path.id];
       this.anchors = path.subpaths.flatMap((sp, s) => sp.anchors.map((_, i) => ({ nodeId: path.id, subpath: s, index: i })));
-      this.drag = { kind: "anchors", start: p, before: this.snapshot(), base: this.doc, moved: false, clickRef: null };
+      this.drag = { kind: "anchors", start: p, before: this.snapshot(), base: this.doc, moved: false, clickRef: null, lead: null };
       this.notify();
       return;
     }
@@ -2379,9 +4555,9 @@ var VectorEditorController = class {
         this.notify(true);
         return;
       }
-      let pt2 = this.snapPoint(p);
       const last = getAnchorWorld(this.doc, { nodeId: pen.nodeId, subpath: pen.subpath, index: sp.anchors.length - 1 });
-      if (input.shift) pt2 = constrain45(last, pt2);
+      const leave = { at: { x: last.x, y: last.y }, constrain: input.shift ? "angle" : null };
+      let pt2 = this.snapDrawn(p, leave, input, () => this.drawingTargets(pen.nodeId));
       pt2 = this.toLocal(pen.nodeId, pt2);
       const node2 = this.getNode(pen.nodeId);
       const anchors = [...sp.anchors, { x: pt2.x, y: pt2.y }];
@@ -2412,7 +4588,7 @@ var VectorEditorController = class {
       this.notify(this.doc !== before.doc);
       return;
     }
-    const pt = this.snapPoint(p);
+    const pt = this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     const node = { id: this.newId(), type: "path", name: "Path", ...this.styleFor(true), subpaths: [{ anchors: [{ x: pt.x, y: pt.y }], closed: false }] };
     this.setDoc([...this.doc.nodes, node]);
     this.pen = { nodeId: node.id, subpath: 0 };
@@ -2436,17 +4612,20 @@ var VectorEditorController = class {
       subpaths: [{ anchors: [{ x: p.x, y: p.y }], closed: false }]
     };
     this.setDoc([...this.doc.nodes, node]);
-    this.drag = { kind: "pencil", nodeId: node.id, points: [[p.x, p.y]], before };
+    const lazy = new LazyMouse(this.editing.pencilSmoothing * VECTOR_PENCIL_STRING_PX / this.viewport.zoom);
+    lazy.push([p.x, p.y]);
+    this.drag = { kind: "pencil", nodeId: node.id, points: [[p.x, p.y]], before, lazy };
     this.interaction = { type: "draw", tool: "pencil", nodeId: node.id, bounds: { x: p.x, y: p.y, width: 0, height: 0 } };
     this.notify(true);
   }
-  downShape(p) {
+  downShape(p, input) {
     const before = this.snapshot();
-    const start = this.snapPoint(p);
+    const targets = this.drawingTargets(null);
+    const start = this.snapDrawn(p, null, input, () => targets);
     const kind = this.tool;
     const node = this.createShapeNode({ kind, x: start.x, y: start.y, width: 0, height: 0 });
     this.setDoc([...this.doc.nodes, node]);
-    this.drag = { kind: "shape", tool: this.tool, start, nodeId: node.id, before };
+    this.drag = { kind: "shape", tool: this.tool, start, nodeId: node.id, before, targets };
     this.interaction = { type: "draw", tool: this.tool, nodeId: node.id, bounds: { x: start.x, y: start.y, width: 0, height: 0 } };
     this.notify(true);
   }
@@ -2457,9 +4636,11 @@ var VectorEditorController = class {
     if (!drag) {
       const hover = this.computeHover(screen);
       const pointerMatters = this.tool === "pen" && !!this.pen;
-      if (this.sameHover(hover, this.hover) && !pointerMatters) return;
+      const guides = this.guides;
       this.hover = hover;
-      this.pointer = p;
+      const pointer = this.hoverSnap(p, input);
+      if (this.sameHover(hover, this.state.hover) && !pointerMatters && JSON.stringify(guides) === JSON.stringify(this.guides)) return;
+      this.pointer = pointer;
       this.notify();
       return;
     }
@@ -2480,8 +4661,9 @@ var VectorEditorController = class {
           const created = [];
           drag.base = this.withDuplicates(drag.base, this.selectedRoots(), { x: 0, y: 0 }, created);
           this.selection = created;
+          drag.targets = void 0;
         }
-        ({ dx, dy } = this.snapDelta(dx, dy, drag.origin));
+        ({ dx, dy } = this.snapMove(drag, dx, dy, input));
         this.doc = this.transformed(drag.base, new Set(this.selectedRoots()), translateMatrix(dx, dy));
         this.interaction = { type: "move", dx, dy };
         this.notify(true);
@@ -2490,7 +4672,13 @@ var VectorEditorController = class {
       case "scale": {
         const angle = drag.frame.angle;
         const q = angle ? applyMatrix(rotateMatrix(-angle), p) : p;
-        const { sx, sy, origin } = scaleFor(drag.handle, drag.frame, q, input);
+        let { sx, sy, origin } = scaleFor(drag.handle, drag.frame, q, input);
+        if (this.snap.objects && !input.mod && drag.handle !== "rotate") {
+          drag.targets ??= VectorSnapTargets.forResize(drag.base, this.selectedRoots());
+          const res = drag.targets.snapScale(drag.frame, drag.handle, sx, sy, input, this.snapTolerance());
+          ({ sx, sy } = res);
+          this.setGuides(res);
+        } else this.setGuides(null);
         const ids = new Set(this.selectedRoots());
         this.doc = this.transformed(drag.base, ids, this.inFrame(angle, scaleMatrix(sx, sy, origin)));
         this.interaction = { type: "scale", handle: drag.handle, sx, sy };
@@ -2531,24 +4719,47 @@ var VectorEditorController = class {
         let dy = p.y - drag.start.y;
         if (!drag.moved && Math.hypot(dx, dy) * this.viewport.zoom < 2) return;
         drag.moved = true;
-        if (input.shift) Math.abs(dx) > Math.abs(dy) ? dy = 0 : dx = 0;
-        const lead = this.anchors.length ? getAnchorWorld(drag.base, this.anchors[0]) : void 0;
-        ({ dx, dy } = this.snapDelta(dx, dy, lead ?? null));
-        this.doc = this.movedAnchors(drag.base, this.anchors, dx, dy);
+        const lead = this.leadAnchor(drag);
+        if (lead) {
+          const leave = input.shift ? { at: lead, constrain: "axis", curves: false } : null;
+          const q = this.snapDrawn({ x: lead.x + dx, y: lead.y + dy }, leave, input, () => drag.targets ??= VectorSnapTargets.forAnchorDrag(drag.base, this.anchors));
+          dx = q.x - lead.x;
+          dy = q.y - lead.y;
+        } else if (input.shift) Math.abs(dx) > Math.abs(dy) ? dy = 0 : dx = 0;
+        const single = this.anchors.length === 1 ? this.anchors[0] : null;
+        const from = single ? getAnchorWorld(drag.base, single) : void 0;
+        if (single && from && this.editing.curvatureMoves !== !!input.alt) this.doc = this.curvatureMoved(drag.base, single, { x: from.x + dx, y: from.y + dy });
+        else this.doc = this.movedAnchors(drag.base, this.anchors, dx, dy);
         this.interaction = { type: "anchors", dx, dy };
         this.notify(true);
         return;
       }
       case "handle": {
         const anchor = getAnchorWorld(drag.base, drag.ref);
-        let pt = this.snapPoint(p);
-        if (input.shift && anchor) pt = constrain45(anchor, pt);
+        const leave = anchor ? { at: { x: anchor.x, y: anchor.y }, constrain: input.shift ? "angle" : null } : null;
+        const pt = this.snapDrawn(p, leave, input, () => drag.targets ??= VectorSnapTargets.forHandle(drag.base, drag.ref.nodeId));
         const local = this.toLocal(drag.ref.nodeId, pt, drag.base);
         this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => moveAnchorHandle(a, drag.ref.handle, local, input.alt));
         this.interaction = { type: "handle", ref: drag.ref };
         this.notify(true);
         return;
       }
+      case "bend": {
+        if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 2) return;
+        drag.moved = true;
+        this.doc = this.bent(drag.base, drag.ref, drag.t, p);
+        this.interaction = { type: "bend", ref: drag.ref };
+        this.notify(true);
+        return;
+      }
+      case "stroke": {
+        const last = drag.points[drag.points.length - 1];
+        if (Math.hypot(p.x - last.x, p.y - last.y) * this.viewport.zoom < 1.5) return;
+        drag.points.push(p);
+        this.interaction = { type: "stroke", tool: drag.tool, points: drag.points.slice(), width: drag.tool === "eraser" ? this.editing.eraserSize : 0 };
+        this.notify();
+        return;
+      }
       case "pull": {
         const anchor = getAnchorWorld(drag.base, drag.ref);
         if (!anchor) return;
@@ -2557,6 +4768,7 @@ var VectorEditorController = class {
           this.notify(true);
           return;
         }
+        this.guides = null;
         let pt = p;
         if (input.shift) pt = constrain45(anchor, pt);
         const side = drag.closing ? "in" : "out";
@@ -2571,7 +4783,9 @@ var VectorEditorController = class {
       case "shape": {
         const node = this.getNode(drag.nodeId);
         if (node?.type !== "path") return;
-        let end = this.snapPoint(p);
+        const leave = { at: drag.start, constrain: input.shift ? drag.tool === "line" ? "angle" : "square" : null, curves: false };
+        let end = this.snapDrawn(p, leave, input, () => drag.targets ??= this.drawingTargets(null));
+        if (!this.snappedToObject && drag.tool !== "line" && !input.shift && !input.mod && this.snap.objects && drag.targets) end = this.matchShapeSize(drag.targets, drag.start, end, input.alt);
         let start = drag.start;
         let bounds;
         if (drag.tool === "line") {
@@ -2599,10 +4813,22 @@ var VectorEditorController = class {
       }
       case "pencil": {
         const last = drag.points[drag.points.length - 1];
-        if (Math.hypot(p.x - last[0], p.y - last[1]) * this.viewport.zoom < 1.5) return;
-        drag.points.push([p.x, p.y]);
+        let moved = false;
+        for (const q of drag.lazy.push([p.x, p.y])) {
+          if (Math.hypot(q[0] - last[0], q[1] - last[1]) * this.viewport.zoom < 1.5) continue;
+          drag.points.push(q);
+          moved = true;
+        }
+        const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
         if (node?.type !== "path") return;
+        if (!moved) {
+          if (string && this.interaction?.type === "draw") {
+            this.interaction = { ...this.interaction, string: [{ x: string[0][0], y: string[0][1] }, { x: string[1][0], y: string[1][1] }] };
+            this.notify();
+          }
+          return;
+        }
         this.replaceNode(drag.nodeId, { ...node, subpaths: [{ anchors: drag.points.map(([x, y]) => ({ x, y })), closed: false }] });
         const xs = drag.points.map((q) => q[0]);
         const ys = drag.points.map((q) => q[1]);
@@ -2610,19 +4836,72 @@ var VectorEditorController = class {
           type: "draw",
           tool: "pencil",
           nodeId: drag.nodeId,
-          bounds: { x: Math.min(...xs), y: Math.min(...ys), width: Math.max(...xs) - Math.min(...xs), height: Math.max(...ys) - Math.min(...ys) }
+          bounds: { x: Math.min(...xs), y: Math.min(...ys), width: Math.max(...xs) - Math.min(...xs), height: Math.max(...ys) - Math.min(...ys) },
+          ...string ? { string: [{ x: string[0][0], y: string[0][1] }, { x: string[1][0], y: string[1][1] }] } : {}
         };
         this.notify(true);
         return;
       }
     }
   }
+  /** Snaps a move of the selection by (dx, dy): its bounds line up with targets or space evenly, else go to the grid. */
+  snapMove(drag, dx, dy, input) {
+    const origin = drag.origin;
+    if (input.mod || !origin) {
+      this.setGuides(null);
+      return { dx, dy };
+    }
+    const axes = { x: !input.shift || dx !== 0, y: !input.shift || dy !== 0 };
+    let res = null;
+    if (this.snap.objects) {
+      drag.targets ??= VectorSnapTargets.forMove(drag.base, this.selectedRoots());
+      res = drag.targets.snapRect({ ...origin, x: origin.x + dx, y: origin.y + dy }, this.snapTolerance(), { spacing: true, axes });
+    }
+    this.setGuides(res);
+    return {
+      dx: res?.x ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: res?.y ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+    };
+  }
+  /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
+  leadAnchor(drag) {
+    const ref = drag.lead && this.anchors.some((a) => sameRef(a, drag.lead)) ? drag.lead : null;
+    if (ref) {
+      const a = getAnchorWorld(drag.base, ref);
+      return a ? { x: a.x, y: a.y } : null;
+    }
+    let best = null;
+    for (const r of this.anchors) {
+      const a = getAnchorWorld(drag.base, r);
+      if (a && (!best || Math.hypot(a.x - drag.start.x, a.y - drag.start.y) < Math.hypot(best.x - drag.start.x, best.y - drag.start.y))) best = { x: a.x, y: a.y };
+    }
+    return best;
+  }
+  /** A shape's dragged corner moved so its width or height matches another object's, when one is within reach. */
+  matchShapeSize(targets, start, end, fromCentre = false) {
+    const k = fromCentre ? 2 : 1;
+    const tol = this.snapTolerance() * k;
+    const out = { ...end };
+    const guides = { lines: [], labels: [] };
+    for (const axis of ["x", "y"]) {
+      const d = end[axis] - start[axis];
+      const len = Math.abs(d) > 1e-9 ? targets.matchSize(Math.abs(d) * k, tol) : null;
+      if (len === null || len <= 0) continue;
+      out[axis] = start[axis] + Math.sign(d) * len / k;
+      const from = { ...out, [axis]: fromCentre ? 2 * start[axis] - out[axis] : start[axis] };
+      guides.lines.push({ kind: "size", x1: from.x, y1: from.y, x2: out.x, y2: out.y });
+      guides.labels.push({ kind: "size", x: (from.x + out.x) / 2, y: (from.y + out.y) / 2, text: `${axis === "x" ? "W" : "H"} ${Math.round(len * 100) / 100}` });
+    }
+    this.setGuides(guides);
+    return out;
+  }
   /** Primary button released. */
   pointerUp(screen, input = {}) {
     if (screen && this.drag && this.drag.kind !== "pan") this.pointerMove(screen, input);
     const drag = this.drag;
     this.drag = null;
     this.interaction = null;
+    this.guides = null;
     if (!drag) return;
     switch (drag.kind) {
       case "pan":
@@ -2650,6 +4929,18 @@ var VectorEditorController = class {
         return this.commit(drag.before.doc !== drag.base ? "Add Point" : "Move Points", drag.before);
       case "handle":
         return this.commit("Move Handle", drag.before);
+      case "bend":
+        if (!drag.moved) {
+          this.notify();
+          return;
+        }
+        return this.commit("Bend Segment", drag.before);
+      case "stroke": {
+        this.notify();
+        if (drag.tool === "knife") this.knife(drag.points);
+        else this.erase(drag.points);
+        return;
+      }
       case "pull":
         if (drag.closing) this.pen = null;
         return this.commit(drag.label, drag.before);
@@ -2674,6 +4965,13 @@ var VectorEditorController = class {
           this.notify(true);
           return;
         }
+        for (const q of drag.lazy.finish()) drag.points.push(q);
+        const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
+        if (shape) {
+          this.replaceNode(drag.nodeId, { ...node, name: inkShapeLabel(shape), subpaths: [inkShapeSubpath(shape)] });
+          this.selection = [drag.nodeId];
+          return this.commit(`Draw ${inkShapeLabel(shape)}`, drag.before);
+        }
         const fitted = fitCubics(drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
         const anchors = [];
         for (const c of fitted) {
@@ -2691,9 +4989,10 @@ var VectorEditorController = class {
   /** The pointer left the canvas. */
   pointerLeave() {
     if (this.drag) return;
-    if (!this.hover && !this.pointer) return;
+    if (!this.hover && !this.pointer && !this.guides) return;
     this.hover = null;
     this.pointer = null;
+    this.guides = null;
     this.notify();
   }
   /** Abandons the drag in progress (Escape, lost capture). */
@@ -2702,6 +5001,7 @@ var VectorEditorController = class {
     if (!drag) return;
     this.drag = null;
     this.interaction = null;
+    this.guides = null;
     if (drag.kind === "pan") {
       this.notify();
       return;
@@ -2778,6 +5078,8 @@ var VectorEditorController = class {
         case "g":
           input.shift ? this.ungroup() : this.group();
           return true;
+        case "j":
+          return input.alt ? this.averageAnchors("both").ok : this.joinPaths().ok;
         case "]":
           this.arrange(input.alt ? "front" : "forward");
           return true;
@@ -2858,6 +5160,22 @@ var VectorEditorController = class {
     }
   }
 };
+function inkShapeLabel(shape) {
+  const name = vectorInkShapeName(shape);
+  return name[0].toUpperCase() + name.slice(1);
+}
+function inkShapeSubpath(shape) {
+  switch (shape.kind) {
+    case "line":
+      return lineSubpath({ x: shape.a[0], y: shape.a[1] }, { x: shape.b[0], y: shape.b[1] });
+    case "rect":
+      return rectSubpath(shape);
+    case "ellipse":
+      return ellipseSubpath(shape);
+    case "polygon":
+      return { anchors: shape.points.map(([x, y]) => ({ x, y })), closed: true };
+  }
+}
 function constrain45(origin, p) {
   const dx = p.x - origin.x;
   const dy = p.y - origin.y;
@@ -3017,12 +5335,41 @@ function getVectorOverlayRenderData(state) {
     const b = it.type === "draw" ? findVectorNode(doc.nodes, it.nodeId) ? vectorNodeBounds(findVectorNode(doc.nodes, it.nodeId)) : null : state.selectionFrame;
     if (b) status = `W ${fmt(b.width)} \xD7 H ${fmt(b.height)}`;
   }
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, status };
+  const guides = { lines: [], labels: [] };
+  if (state.guides) {
+    for (const l of state.guides.lines) {
+      const a = toScreen(state, { x: l.x1, y: l.y1 });
+      const b = toScreen(state, { x: l.x2, y: l.y2 });
+      guides.lines.push({ kind: l.kind, x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) });
+    }
+    for (const l of state.guides.labels) {
+      const p = toScreen(state, l);
+      guides.labels.push({ kind: l.kind, x: fmt(p.x), y: fmt(p.y), text: l.text });
+    }
+  }
+  let toolStroke = null;
+  if (it?.type === "stroke") {
+    const pts = it.points.map((q) => toScreen(state, q));
+    const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt(q.x)} ${fmt(q.y)}`).join("") + (pts.length === 1 ? `L${fmt(pts[0].x)} ${fmt(pts[0].y)}` : "");
+    toolStroke = { tool: it.tool, d, width: fmt(it.width * z) };
+  }
+  let pencilString = null;
+  if (it?.type === "draw" && it.string) {
+    const a = toScreen(state, it.string[0]);
+    const b = toScreen(state, it.string[1]);
+    pencilString = { x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) };
+  }
+  const cutPoint = state.tool === "scissors" && state.hover?.segment && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint };
 }
 var VECTOR_OVERLAY_THEME = {
   accent: "#0ea5e9",
+  /** Smart guide lines and labels. */
+  guide: "#ff3dfc",
   handleFill: "#ffffff",
   marqueeFill: "rgba(14, 165, 233, 0.08)",
+  /** The eraser's swath while it is dragged. */
+  eraserFill: "rgba(239, 68, 68, 0.25)",
   transformHandleSize: 8,
   anchorSize: 7,
   handleRadius: 3.5
@@ -3068,12 +5415,39 @@ function vectorPaintToHex(paint) {
   const hex = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
   return `#${hex.toLowerCase()}`;
 }
+var VECTOR_PATH_ACTIONS = [
+  { id: "join", label: "\u22C8", title: "Join", shortcut: "J", enabled: (s, p) => s + p > 0, run: (c) => c.joinPaths() },
+  { id: "average", label: "\u22B9", title: "Average Points", shortcut: "Alt+J", enabled: (_s, p) => p > 1, run: (c) => c.averageAnchors("both") },
+  { id: "cut", label: "\u2702\xB7", title: "Cut at Points", enabled: (_s, p) => p > 0, run: (c) => c.cutAtAnchors() },
+  { id: "clean", label: "\u2301", title: "Remove Redundant Points", enabled: (s, p) => s + p > 0, run: (c) => c.removeRedundantPoints() },
+  { id: "smooth", label: "\u223F", title: "Smooth", enabled: (s, p) => s + p > 0, run: (c) => c.smoothPaths() }
+];
+var VECTOR_EDIT_TOGGLES = [
+  { key: "keepShapeOnDelete", label: "Keep", title: "Keep shape when deleting points" },
+  { key: "curvatureMoves", label: "Curv", title: "Curvature point moves (Alt flips while dragging)" },
+  { key: "recognizeShapes", label: "Shapes", title: "Turn pencil scribbles into shapes" }
+];
 
 // src/vector/commands.ts
 var fail = (message) => {
   throw new Error(message);
 };
 var IDS = { type: "array", items: { type: "string" }, description: "Node ids (default: the selection)." };
+var ANCHORS = {
+  type: "array",
+  items: {
+    type: "object",
+    properties: { nodeId: { type: "string" }, subpath: { type: "integer", minimum: 0 }, index: { type: "integer", minimum: 0 } },
+    required: ["nodeId", "subpath", "index"]
+  },
+  description: "Anchors as { nodeId, subpath, index } (default: the selected points)."
+};
+var POINTS = {
+  type: "array",
+  items: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 },
+  minItems: 1,
+  description: "Polyline [[x, y], \u2026] in document units."
+};
 var PAINT = {
   description: 'A CSS colour, `null` for none, or a gradient `{ type: "linear", angle, stops: [{ offset, color }] }`.'
 };
@@ -3106,6 +5480,14 @@ function createVectorCommands(controller, options = {}) {
     return list2;
   };
   const enabledFor = (_, params) => params?.ids?.length ? true : hasSelection();
+  const anchorsOf = (refs) => {
+    if (!refs) return [...controller.getState().selectedAnchors];
+    for (const r of refs) {
+      const node = controller.getNode(r.nodeId);
+      if (node?.type !== "path" || !node.subpaths[r.subpath]?.anchors[r.index]) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+    }
+    return refs;
+  };
   const list = () => {
     const state = controller.getState();
     const out = [];
@@ -3344,6 +5726,186 @@ function createVectorCommands(controller, options = {}) {
         return { selection: controller.getState().selection };
       }
     },
+    {
+      ...base,
+      id: `${prefix}deleteAnchors`,
+      label: "Delete Points",
+      keywords: ["remove", "anchor", "point", "node"],
+      description: "Deletes anchors. With `keepShape` (default: the editor setting, on) the neighbouring handles are refitted so the outline keeps its shape; off, the neighbours are joined as they are.",
+      params: { type: "object", properties: { anchors: ANCHORS, keepShape: { type: "boolean" } } },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.deleteAnchors(anchorsOf(params?.anchors), { keepShape: params?.keepShape }));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}moveAnchor`,
+      label: "Move Point\u2026",
+      keywords: ["anchor", "drag", "curvature"],
+      description: "Moves one anchor to (x, y) in document units. `curvature: true` bends its two segments like the Curvature tool instead of carrying its handles along.",
+      params: {
+        type: "object",
+        properties: { nodeId: { type: "string" }, subpath: { type: "integer", minimum: 0 }, index: { type: "integer", minimum: 0 }, x: { type: "number" }, y: { type: "number" }, curvature: { type: "boolean" } },
+        required: ["nodeId", "subpath", "index", "x", "y"]
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.moveAnchor({ nodeId: params.nodeId, subpath: params.subpath, index: params.index }, { x: params.x, y: params.y }, { curvature: params.curvature }));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}bendSegment`,
+      label: "Bend Segment\u2026",
+      keywords: ["curve", "segment", "drag"],
+      description: "Bends segment `segment` (from anchor `segment` to the next) so the curve passes through (x, y) at parameter `t` (default 0.5).",
+      params: {
+        type: "object",
+        properties: {
+          nodeId: { type: "string" },
+          subpath: { type: "integer", minimum: 0 },
+          segment: { type: "integer", minimum: 0 },
+          x: { type: "number" },
+          y: { type: "number" },
+          t: { type: "number", minimum: 0, maximum: 1 }
+        },
+        required: ["nodeId", "subpath", "segment", "x", "y"]
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.bendSegment({ nodeId: params.nodeId, subpath: params.subpath, segment: params.segment }, { x: params.x, y: params.y }, params.t));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}join`,
+      label: "Join",
+      shortcut: "Mod+J",
+      keywords: ["connect", "close", "merge", "endpoints"],
+      description: "Joins the open subpaths of paths nearest endpoints first (ends within `tolerance` merge); a single open path is closed.",
+      params: { type: "object", properties: { ids: IDS, tolerance: { type: "number", minimum: 0 } } },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.joinPaths({ ids: params?.ids ? ids(params) : void 0, tolerance: params?.tolerance }));
+        return { selection: controller.getState().selection };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}average`,
+      label: "Average Points\u2026",
+      shortcut: "Mod+Alt+J",
+      keywords: ["align", "points", "anchors", "collapse"],
+      description: "Moves anchors onto their average position: the same y (`horizontal`), the same x (`vertical`) or the same point (`both`, default).",
+      params: { type: "object", properties: { axis: { type: "string", enum: ["horizontal", "vertical", "both"] }, anchors: ANCHORS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.averageAnchors(params?.axis ?? "both", anchorsOf(params?.anchors)));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}removeRedundantPoints`,
+      label: "Remove Redundant Points",
+      keywords: ["simplify", "clean up", "anchors", "collinear"],
+      description: "Drops anchors that can go without moving the outline more than `tolerance` document units (default 0.5).",
+      params: { type: "object", properties: { ids: IDS, tolerance: { type: "number", minimum: 0 } } },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.removeRedundantPoints({ ids: params?.ids ? ids(params) : void 0, tolerance: params?.tolerance }));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}smooth`,
+      label: "Smooth Path",
+      keywords: ["round", "soften", "handles", "curves"],
+      description: "Pulls the handles of paths (or of the selected points) towards smooth tangents by `amount` (0\u20131, default 1).",
+      params: { type: "object", properties: { ids: IDS, amount: { type: "number", minimum: 0, maximum: 1 }, anchors: ANCHORS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.smoothPaths({ ids: params?.ids ? ids(params) : void 0, amount: params?.amount, refs: params?.anchors }));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}cut`,
+      label: "Cut Path (Scissors)\u2026",
+      keywords: ["scissors", "split", "open", "break"],
+      description: "Scissors: cuts path `nodeId` at the outline point nearest (x, y), or cuts at `anchors`. A closed path opens; an open one splits in two.",
+      params: { type: "object", properties: { nodeId: { type: "string" }, x: { type: "number" }, y: { type: "number" }, anchors: ANCHORS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        if (params?.nodeId !== void 0) {
+          if (!controller.getNode(params.nodeId)) fail(`There is no node "${params.nodeId}".`);
+          if (params.x === void 0 || params.y === void 0) fail("Pass x and y with nodeId.");
+          const created = controller.cutPathAt(params.nodeId, { x: params.x, y: params.y });
+          if (!created) fail("Nothing to cut there (the end of an open path, or a locked path).");
+          return { ids: created };
+        }
+        check(controller.cutAtAnchors(anchorsOf(params?.anchors)));
+        return { ids: controller.getState().selection };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}knife`,
+      label: "Knife\u2026",
+      keywords: ["slice", "cut", "split", "divide"],
+      description: "Cuts closed paths along a polyline wherever it crosses them edge to edge (no gap between pieces). Cuts `ids`, else the selection, else every path the line crosses.",
+      params: { type: "object", properties: { points: { ...POINTS, minItems: 2 }, ids: IDS }, required: ["points"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        const created = controller.knife(params.points.map(([x, y]) => ({ x, y })), { ids: params.ids ? ids(params) : void 0 });
+        if (!created.length) fail("The knife did not cross any closed path from edge to edge.");
+        return { ids: created };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}erase`,
+      label: "Erase\u2026",
+      keywords: ["eraser", "rub out", "remove"],
+      description: "Erases a round stroke of diameter `size` (default: the eraser size setting) along a polyline: filled shapes lose the area, outlines are cut under it. Erases from `ids`, else the selection, else every path it reaches.",
+      params: { type: "object", properties: { points: POINTS, size: { type: "number", exclusiveMinimum: 0 }, ids: IDS }, required: ["points"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        const changed = controller.erase(params.points.map(([x, y]) => ({ x, y })), { size: params.size, ids: params.ids ? ids(params) : void 0 });
+        if (!changed.length) fail("The eraser did not touch any path.");
+        return { ids: changed.filter((id) => controller.getNode(id)) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}setEditing`,
+      label: "Path Editing Options\u2026",
+      keywords: ["settings", "curvature", "pencil", "smoothing", "lazy mouse", "shapes", "eraser"],
+      description: "Sets how editing behaves: `keepShapeOnDelete`, `curvatureMoves` (anchor drags bend like the Curvature tool), `pencilSmoothing` (lazy mouse, 0\u20131), `recognizeShapes` (pencil scribbles become lines, rectangles, ellipses, polygons) and `eraserSize`.",
+      params: {
+        type: "object",
+        properties: {
+          keepShapeOnDelete: { type: "boolean" },
+          curvatureMoves: { type: "boolean" },
+          pencilSmoothing: { type: "number", minimum: 0, maximum: 1 },
+          recognizeShapes: { type: "boolean" },
+          eraserSize: { type: "number", exclusiveMinimum: 0 }
+        }
+      },
+      run: (_ctx, params) => {
+        const patch = {};
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize"]) if (params?.[key] !== void 0) patch[key] = params[key];
+        controller.setEditing(patch);
+        return { editing: controller.getState().editing };
+      }
+    },
     {
       ...base,
       id: `${prefix}setTool`,
@@ -3382,18 +5944,28 @@ function createVectorCommands(controller, options = {}) {
   ];
 }
 export {
+  DEFAULT_VECTOR_PATH_EDIT,
+  DEFAULT_VECTOR_SNAP,
   IDENTITY_MATRIX,
   KAPPA,
+  LazyMouse,
   VECTOR_CLIPBOARD_TYPE,
+  VECTOR_CONSTRUCTION_ANGLES,
+  VECTOR_EDIT_TOGGLES,
+  VECTOR_INK_MAX_CORNERS,
   VECTOR_OVERLAY_THEME,
+  VECTOR_PATH_ACTIONS,
+  VECTOR_PENCIL_STRING_PX,
   VECTOR_ROTATE_HANDLE_OFFSET,
   VECTOR_TOOLS,
   VECTOR_TOOL_GLYPHS,
   VECTOR_TOOL_SHORTCUTS,
   VECTOR_TRANSFORM_HANDLES,
   VectorEditorController,
+  VectorSnapTargets,
   applyMatrix,
   applyMatrixLinear,
+  bendSegment,
   bezierToSubpaths,
   boundsFromPoints,
   boundsIntersect,
@@ -3402,10 +5974,16 @@ export {
   cloneVectorDocument,
   cloneVectorNode,
   collectPathNodes,
+  constrainToLeave,
   convertAnchor,
   createVectorCommands,
+  curvatureMoveAnchor,
+  cutSubpathAt,
   decomposeRigid,
   ellipseSubpath,
+  eraseFromFill,
+  eraseFromOutline,
+  eraserRegion,
   findVectorNode,
   getAnchor,
   getAnchorWorld,
@@ -3426,6 +6004,8 @@ export {
   invertMatrix,
   isIdentityMatrix,
   isVectorTextTarget,
+  joinSubpaths,
+  knifePath,
   lineSubpath,
   locateVectorNode,
   matrixRotation,
@@ -3436,14 +6016,24 @@ export {
   parseSvgTransform,
   parseVectorSvg,
   polygonSubpath,
+  polylineBounds,
+  recognizeInkShape,
   rectSubpath,
+  removeAnchorKeepingShape,
   removeAnchors,
+  removeAnchorsKeepingShape,
+  removeRedundantPoints,
   reverseSubpath,
   rotateMatrix,
   roundSubpaths,
   scaleFor,
   scaleMatrix,
+  simplifyPolyline,
+  smoothSubpath,
+  splitIntoFaces,
+  splitSubpathAt,
   starSubpath,
+  subpathPointAt,
   subpathSegment,
   subpathSegmentCount,
   subpathsToBezier,
@@ -3455,6 +6045,7 @@ export {
   translateMatrix,
   unionBounds,
   vectorDocumentToSvg,
+  vectorInkShapeName,
   vectorNodeBounds,
   vectorNodeRotation,
   vectorNodeToBezier,