@pixerate/editor 0.35.0 → 0.36.0

package/dist/vector/index.js

@@ -20,27 +20,444 @@ import {
   segmentBounds,
   segmentDerivative,
   segmentIntersections,
+  segmentLength,
   segmentNearest,
+  segmentParamAtLength,
   segmentPoint,
+  segmentTangent,
   splitSegment,
   subSegment,
   toBezierPath,
   transformBezierPath,
+  trimSegments,
   windingNumber
 } from "../chunk-EGPIVUEF.js";
 
 // src/vector/types.ts
+var VECTOR_CORNER_KINDS = ["round", "inverted", "chamfer"];
+var VECTOR_ARROWHEADS = ["triangle", "arrow", "open", "circle", "square", "bar"];
 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
+// src/vector/corners.ts
 var EPS = 1e-9;
+var MIN_SINE = 1e-6;
+var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+var mul = (a, k) => ({ x: a.x * k, y: a.y * k });
+var dot = (a, b) => a.x * b.x + a.y * b.y;
+var cross = (a, b) => a.x * b.y - a.y * b.x;
+var len = (a) => Math.hypot(a.x, a.y);
+var pt = (p) => [p.x, p.y];
+var vec = (p) => ({ x: p[0], y: p[1] });
+var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
+var Side = class {
+  curve;
+  straight;
+  length;
+  constructor(a, h1, h2, b) {
+    this.straight = onAnchor(a, h1) && onAnchor(b, h2);
+    this.curve = this.straight ? [pt(a), pt(b)] : [pt(a), pt(h1 ?? a), pt(h2 ?? b), pt(b)];
+    this.length = this.straight ? Math.hypot(b.x - a.x, b.y - a.y) : segmentLength(this.curve);
+  }
+  /** Unit direction the side leaves the corner in (towards its first control point off the corner). */
+  direction() {
+    const p0 = vec(this.curve[0]);
+    for (const q of this.curve.slice(1)) {
+      const d = sub(vec(q), p0);
+      const l = len(d);
+      if (l > EPS) return mul(d, 1 / l);
+    }
+    return null;
+  }
+  /** The point `s` along the side from the corner: its parameter, position and the direction the side runs on in there. */
+  at(s, u) {
+    if (this.straight) {
+      const t2 = this.length > EPS ? Math.min(1, Math.max(0, s / this.length)) : 0;
+      return { t: t2, p: add(vec(this.curve[0]), mul(u, s)), dir: u };
+    }
+    const t = segmentParamAtLength(this.curve, s, this.length);
+    const d = vec(segmentDerivative(this.curve, t));
+    const l = len(d);
+    return { t, p: vec(segmentPoint(this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
+  }
+};
+function cornerOf(sp, s, i) {
+  const n = sp.anchors.length;
+  if (n < 2 || !sp.closed && (i === 0 || i === n - 1)) return null;
+  if (n === 2 && sp.closed) return null;
+  const a = sp.anchors[i];
+  if (a.type === "smooth" || a.type === "symmetric") return null;
+  const prev = sp.anchors[(i - 1 + n) % n];
+  const next = sp.anchors[(i + 1) % n];
+  const sideU = new Side(a, a.in, prev.out, prev);
+  const sideV = new Side(a, a.out, next.in, next);
+  const u = sideU.direction();
+  const v2 = sideV.direction();
+  if (!u || !v2) return null;
+  const lu = sideU.length;
+  const lv = sideV.length;
+  if (!(lu > EPS && lv > EPS) || !Number.isFinite(lu) || !Number.isFinite(lv)) return null;
+  const cos = Math.max(-1, Math.min(1, dot(u, v2)));
+  const sin = Math.abs(cross(u, v2));
+  if (sin <= MIN_SINE) return null;
+  return { subpath: s, index: i, at: { x: a.x, y: a.y }, u, v: v2, lu, lv, cos, sin, angle: Math.atan2(sin, cos) * 180 / Math.PI, maxRadius: Math.min(lu, lv) / 2 * sin / (1 + cos), sideU, sideV };
+}
+var strip = ({ sideU: _u, sideV: _v, ...info }) => info;
+function vectorCornerAt(sp, index, subpath = 0) {
+  const c = cornerOf(sp, subpath, index);
+  return c ? strip(c) : null;
+}
+function vectorCorners(subpaths) {
+  const out = [];
+  subpaths.forEach((sp, s) => {
+    for (let i = 0; i < sp.anchors.length; i++) {
+      const c = cornerOf(sp, s, i);
+      if (c) out.push(strip(c));
+    }
+  });
+  return out;
+}
+var cornerSetback = (c, r) => r * (1 + c.cos) / c.sin;
+var fitCornerRadius = (c, radius) => Number.isFinite(radius) ? Math.min(Math.max(0, radius), c.maxRadius) : 0;
+var cornerBisectorPoint = (c, k) => add(c.at, mul(add(c.u, c.v), k));
+var cornerRadiusChange = (c, d) => dot(d, add(c.u, c.v)) * c.sin / (2 + 2 * c.cos);
+function arcHandle(cos) {
+  const c = Math.max(-1, Math.min(1, cos));
+  const sinHalf = Math.sqrt(Math.max(0, (1 - c) / 2));
+  const cosHalf = Math.sqrt(Math.max(0, (1 + c) / 2));
+  return 4 / 3 * sinHalf / (1 + cosHalf);
+}
+function squareTo(a, b) {
+  const w = sub(b, mul(a, dot(a, b)));
+  const l = len(w);
+  return l > EPS ? mul(w, 1 / l) : { x: 0, y: 0 };
+}
+function cutCorner(c, radius, kind) {
+  const s = Math.min(cornerSetback(c, radius), Math.min(c.lu, c.lv) / 2);
+  if (!(s > EPS)) return null;
+  const a = c.sideU.at(s, c.u);
+  const b = c.sideV.at(s, c.v);
+  if (kind === "chamfer") return { tu: a.t, tv: b.t, start: a.p, out: null, in: null, end: b.p };
+  if (kind === "inverted") {
+    const h = s * arcHandle(dot(a.dir, b.dir));
+    return { tu: a.t, tv: b.t, start: a.p, out: add(a.p, mul(squareTo(a.dir, b.dir), h)), in: add(b.p, mul(squareTo(b.dir, a.dir), h)), end: b.p };
+  }
+  const d1 = mul(a.dir, -1);
+  const d2 = mul(b.dir, -1);
+  const turn = Math.acos(Math.max(-1, Math.min(1, -dot(d1, d2))));
+  const chord = len(sub(b.p, a.p));
+  const k = turn < 1e-9 ? chord / 3 : 4 / 3 * Math.tan(turn / 4) * chord / (2 * Math.sin(turn / 2));
+  if (!Number.isFinite(k)) return null;
+  return { tu: a.t, tv: b.t, start: a.p, out: add(a.p, mul(d1, k)), in: add(b.p, mul(d2, k)), end: b.p };
+}
+var radiusOf = (a) => {
+  const r = a.corner?.radius;
+  return typeof r === "number" && r > 0 && Number.isFinite(r) ? r : 0;
+};
+function hasVectorCorners(subpaths) {
+  return subpaths.some((sp) => sp.anchors.some((a) => radiusOf(a) > 0));
+}
+function expandVectorCornersOf(sp, subpath = 0) {
+  const n = sp.anchors.length;
+  const cuts = sp.anchors.map((a, i) => {
+    const r = radiusOf(a);
+    if (!r) return null;
+    const c = cornerOf(sp, subpath, i);
+    if (!c) return null;
+    const fitted = fitCornerRadius(c, r);
+    return fitted > EPS ? cutCorner(c, fitted, a.corner?.kind ?? "round") : null;
+  });
+  if (!cuts.some(Boolean)) return { subpath: { closed: sp.closed, anchors: sp.anchors.map(plain) }, sources: sp.anchors.map((_, i) => i) };
+  const trimmed = sp.anchors.map((a, j) => {
+    const k = (j + 1) % n;
+    if (k === 0 && !sp.closed) return void 0;
+    const b = sp.anchors[k];
+    const from = cuts[j];
+    const to = cuts[k];
+    if (!from && !to) return void 0;
+    if (onAnchor(a, a.out) && onAnchor(b, b.in)) return { out: null, in: null };
+    const s0 = from ? from.tv : 0;
+    const s1 = to ? 1 - to.tu : 1;
+    const seg = [pt(a), pt(a.out ?? a), pt(b.in ?? b), pt(b)];
+    const part = subSegment(seg, s0, Math.max(s0, s1));
+    return { out: vec(part[1]), in: vec(part[2]) };
+  });
+  const anchors = [];
+  const sources = [];
+  let closing = null;
+  const handleIn = (i, a) => {
+    const t = trimmed[(i - 1 + n) % n];
+    return t ? t.in : a.in ?? null;
+  };
+  const handleOut = (i, a) => {
+    const t = trimmed[i];
+    return t ? t.out : a.out ?? null;
+  };
+  sp.anchors.forEach((a, i) => {
+    const c = cuts[i];
+    if (!c) {
+      anchors.push(withHandles({ x: a.x, y: a.y, ...a.type ? { type: a.type } : {} }, handleIn(i, a), handleOut(i, a)));
+      sources.push(i);
+      return;
+    }
+    const start = withHandles({ x: c.start.x, y: c.start.y }, handleIn(i, a), c.out);
+    const end = withHandles({ x: c.end.x, y: c.end.y }, c.in, handleOut(i, a));
+    if (i === 0 && sp.closed) closing = start;
+    else {
+      anchors.push(start);
+      sources.push(i);
+    }
+    anchors.push(end);
+    sources.push(i);
+  });
+  if (closing) {
+    anchors.push(closing);
+    sources.push(0);
+  }
+  return { subpath: { closed: sp.closed, anchors }, sources };
+}
+function withHandles(a, hin, hout) {
+  if (hin && !onAnchor(a, hin)) a.in = { x: hin.x, y: hin.y };
+  if (hout && !onAnchor(a, hout)) a.out = { x: hout.x, y: hout.y };
+  return a;
+}
+function plain(a) {
+  if (!("corner" in a)) return a;
+  const { corner: _c, ...rest } = a;
+  return rest;
+}
+function expandVectorCorners(subpaths) {
+  if (!hasVectorCorners(subpaths)) return subpaths;
+  return subpaths.map((sp, s) => sp.anchors.some((a) => radiusOf(a) > 0) ? expandVectorCornersOf(sp, s).subpath : sp);
+}
+function setAnchorCorner(a, radius, kind) {
+  const { corner, ...rest } = a;
+  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
+  const k = kind ?? corner?.kind;
+  if (r <= 0 && !kind) return rest;
+  return { ...rest, corner: { radius: r, ...k && k !== "round" ? { kind: k } : {} } };
+}
+function nextVectorCornerKind(kind) {
+  return kind === "inverted" ? "chamfer" : kind === "chamfer" ? "round" : "inverted";
+}
+function setSubpathCorners(sp, radius, kind) {
+  return { closed: sp.closed, anchors: sp.anchors.map((a) => setAnchorCorner(a, radius, kind)) };
+}
+
+// src/vector/stroke.ts
+var KAPPA = 0.5522847498307936;
+var NOTCH = 0.7;
+function isClosedBezierShape(path) {
+  const contours = pathToContours(path).filter((c) => c.segments.length > 0);
+  return contours.length > 0 && contours.every((c) => c.closed);
+}
+function effectiveStrokeAlign(style, closedShape) {
+  const a = style.strokeAlign ?? "center";
+  return closedShape ? a : "center";
+}
+function hasStrokeExtras(style) {
+  return (style.strokeAlign ?? "center") !== "center" || !!style.startArrow || !!style.endArrow;
+}
+var capExtent = (style, width) => style.strokeLinecap === "round" || style.strokeLinecap === "square" ? width / 2 : 0;
+function arrowheadWeight(style, end) {
+  const scale = end === "start" ? style.startArrowScale : style.endArrowScale;
+  const s = typeof scale === "number" && scale > 0 && Number.isFinite(scale) ? scale : 1;
+  return Math.max(0.25, (style.strokeWidth ?? 1) * s);
+}
+function arrowheadInset(kind, hw, cap) {
+  const l = 4 * hw;
+  const solid = (back) => Math.max(back / 2, cap);
+  switch (kind) {
+    case "triangle":
+    case "circle":
+    case "square":
+      return solid(l);
+    case "arrow":
+      return solid(NOTCH * l);
+    case "bar":
+      return solid(0.75 * hw);
+    case "open":
+      return Math.max(hw * Math.sqrt(l * l + l * l / 4) / (l / 2), cap);
+  }
+}
+var v = (x, y) => ({ x, y });
+var plus = (a, b, k = 1) => ({ x: a.x + b.x * k, y: a.y + b.y * k });
+var unit = (a) => {
+  const l = Math.hypot(a.x, a.y);
+  return l > 0 ? { x: a.x / l, y: a.y / l } : { x: 1, y: 0 };
+};
+function polygon(pts) {
+  return [{ type: "M", x: pts[0].x, y: pts[0].y }, ...pts.slice(1).map((p) => ({ type: "L", x: p.x, y: p.y })), { type: "Z" }];
+}
+function circle(c, r) {
+  const k = r * KAPPA;
+  const { x, y } = c;
+  return [
+    { type: "M", x: x + r, y },
+    { type: "C", x1: x + r, y1: y + k, x2: x + k, y2: y + r, x, y: y + r },
+    { type: "C", x1: x - k, y1: y + r, x2: x - r, y2: y + k, x: x - r, y },
+    { type: "C", x1: x - r, y1: y - k, x2: x - k, y2: y - r, x, y: y - r },
+    { type: "C", x1: x + k, y1: y - r, x2: x + r, y2: y - k, x: x + r, y },
+    { type: "Z" }
+  ];
+}
+function arrowheadPath(kind, tip, dir, hw) {
+  const n = v(-dir.y, dir.x);
+  const l = 4 * hw;
+  const half = l / 2;
+  const base = plus(tip, dir, -l);
+  switch (kind) {
+    case "triangle":
+      return polygon([tip, plus(base, n, half), plus(base, n, -half)]);
+    case "arrow":
+      return polygon([tip, plus(base, n, half), plus(tip, dir, -NOTCH * l), plus(base, n, -half)]);
+    case "open": {
+      const t = hw;
+      const a = plus(base, n, half);
+      const b = plus(base, n, -half);
+      const ua = unit(plus(a, tip, -1));
+      const ub = unit(plus(b, tip, -1));
+      const na = v(-ua.y, ua.x);
+      const nb = v(ub.y, -ub.x);
+      const inner = plus(tip, dir, -(t * Math.hypot(a.x - tip.x, a.y - tip.y)) / half);
+      return polygon([tip, a, plus(a, na, t), inner, plus(b, nb, t), b]);
+    }
+    case "circle":
+      return circle(plus(tip, dir, -half), half);
+    case "square":
+      return polygon([plus(tip, n, half), plus(base, n, half), plus(base, n, -half), plus(tip, n, -half)]);
+    case "bar": {
+      const t = 0.75 * hw;
+      return polygon([plus(tip, n, half), plus(plus(tip, n, half), dir, -t), plus(plus(tip, n, -half), dir, -t), plus(tip, n, -half)]);
+    }
+  }
+}
+var toVec = (p) => ({ x: p[0], y: p[1] });
+var segLen = (s) => segmentLength(s);
+function endOf(segs, atStart) {
+  const long = (s2) => segLen(s2) > 1e-9;
+  if (atStart) {
+    const s2 = segs.find(long) ?? segs[0];
+    const t2 = segmentTangent(s2, 0);
+    return { p: toVec(segs[0][0]), out: v(-t2[0], -t2[1]) };
+  }
+  const s = [...segs].reverse().find(long) ?? segs[segs.length - 1];
+  const t = segmentTangent(s, 1);
+  const last = segs[segs.length - 1];
+  return { p: toVec(last[last.length - 1]), out: v(t[0], t[1]) };
+}
+function pointAlong(segs, fromStart, dist3) {
+  const order = fromStart ? segs : [...segs].reverse();
+  let acc = 0;
+  for (const s of order) {
+    const l = segLen(s);
+    if (acc + l >= dist3) {
+      const want = fromStart ? dist3 - acc : l - (dist3 - acc);
+      const pts = trimSegments([s], 0, want);
+      const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
+      return toVec(p);
+    }
+    acc += l;
+  }
+  return null;
+}
+function vectorStrokeParts(path, style) {
+  const width = style.strokeWidth ?? 1;
+  const contours = pathToContours(path).filter((c) => c.segments.length > 0);
+  const closedShape = contours.length > 0 && contours.every((c) => c.closed);
+  const align = effectiveStrokeAlign(style, closedShape);
+  const drawWidth = align === "center" ? width : width * 2;
+  const heads = [];
+  if (!contours.length || !style.startArrow && !style.endArrow) return { align, line: path, drawWidth, heads };
+  const first = contours[0];
+  const last = contours[contours.length - 1];
+  const cap = capExtent(style, width);
+  const tipMode = style.arrowAlign === "tip";
+  const trims = contours.map(() => [0, 0]);
+  const place = (end, contour, ci) => {
+    const kind = end === "start" ? style.startArrow : style.endArrow;
+    if (!kind || contour.closed) return;
+    const hw = arrowheadWeight(style, end);
+    const inset = arrowheadInset(kind, hw, cap);
+    const atStart = end === "start";
+    const { p, out } = endOf(contour.segments, atStart);
+    let tip;
+    let dir;
+    if (tipMode) {
+      const q = pointAlong(contour.segments, atStart, inset);
+      const d = q ? v(p.x - q.x, p.y - q.y) : null;
+      dir = d && Math.hypot(d.x, d.y) > 1e-9 ? unit(d) : out;
+      tip = p;
+      trims[ci][atStart ? 0 : 1] = inset;
+    } else {
+      tip = plus(p, out, inset);
+      dir = out;
+    }
+    heads.push({ end, kind, tip, dir, inset, path: arrowheadPath(kind, tip, dir, hw) });
+  };
+  place("start", first, 0);
+  place("end", last, contours.length - 1);
+  if (!tipMode || !heads.length) return { align, line: path, drawWidth, heads };
+  const trimmed = contours.map((c, i) => {
+    const [s0, s1] = trims[i];
+    if (!s0 && !s1) return c;
+    const lengths = c.segments.map(segLen);
+    const total = lengths.reduce((a, b) => a + b, 0);
+    return { closed: false, segments: total - s1 > s0 ? trimSegments(c.segments, s0, total - s1, lengths) : [] };
+  });
+  return { align, line: contoursToPath(trimmed), drawWidth, heads };
+}
+function vectorStrokeOutlinePath(path, style) {
+  const parts = vectorStrokeParts(path, style);
+  const stroke = outlineStroke(parts.line, {
+    width: parts.drawWidth,
+    join: style.strokeLinejoin ?? "miter",
+    cap: style.strokeLinecap ?? "butt",
+    ...style.strokeDasharray?.length ? { dash: style.strokeDasharray } : {}
+  });
+  const fill = { path, fillRule: style.fillRule ?? "nonzero" };
+  let area = stroke;
+  if (parts.align === "inside") area = pathBoolean("intersection", [stroke, fill]).path;
+  else if (parts.align === "outside") area = pathBoolean("difference", [stroke, fill]).path;
+  if (!parts.heads.length) return area;
+  return pathBoolean("union", [area, ...parts.heads.map((h) => h.path)]).path;
+}
+function hitTestVectorStroke(path, p, style, tolerance = 0) {
+  const parts = vectorStrokeParts(path, style);
+  const point = [p.x, p.y];
+  const width = style.strokeWidth ?? 1;
+  for (const h of parts.heads) {
+    if (pointInBezierPath(h.path, point) || tolerance > 0 && distanceToBezierPath(h.path, point) <= tolerance) return true;
+  }
+  if (!parts.line.length) return false;
+  const d = distanceToBezierPath(parts.line, point);
+  if (parts.align === "center") return d <= width / 2 + tolerance;
+  if (d > width + tolerance) return false;
+  if (d <= tolerance) return true;
+  const inside = pointInBezierPath(path, point, style.fillRule ?? "nonzero");
+  return parts.align === "inside" ? inside : !inside;
+}
+function vectorStrokeReach(style) {
+  const width = style.strokeWidth ?? 1;
+  const align = style.strokeAlign ?? "center";
+  let reach = align === "center" ? width / 2 : align === "outside" ? width : 0;
+  if (style.strokeLinejoin !== "round" && style.strokeLinejoin !== "bevel") reach *= 4;
+  for (const end of ["start", "end"]) {
+    if (end === "start" ? style.startArrow : style.endArrow) reach = Math.max(reach, 8 * arrowheadWeight(style, end) + width);
+  }
+  return reach;
+}
+
+// src/vector/geometry.ts
+var EPS2 = 1e-9;
 var cloneAnchor = (a) => ({
   x: a.x,
   y: a.y,
   ...a.in ? { in: { x: a.in.x, y: a.in.y } } : {},
   ...a.out ? { out: { x: a.out.x, y: a.out.y } } : {},
-  ...a.type && a.type !== "corner" ? { type: a.type } : {}
+  ...a.type && a.type !== "corner" ? { type: a.type } : {},
+  ...a.corner ? { corner: { ...a.corner } } : {}
 });
 var cloneSubpath = (s) => ({ anchors: s.anchors.map(cloneAnchor), closed: s.closed });
 function cloneVectorNode(node) {
@@ -58,7 +475,7 @@ function hasPaint(paint) {
   return true;
 }
 var handleOf = (a, side) => a[side] ?? { x: a.x, y: a.y };
-var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
+var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS2 && Math.abs(h.y - a.y) < EPS2;
 function subpathSegmentCount(sp) {
   const n = sp.anchors.length;
   if (n < 2) return 0;
@@ -72,9 +489,9 @@ function subpathSegment(sp, i) {
   const c2 = handleOf(b, "in");
   return [[a.x, a.y], [c1.x, c1.y], [c2.x, c2.y], [b.x, b.y]];
 }
-function subpathsToBezier(subpaths) {
+function subpathsToBezier(subpaths, options = {}) {
   const out = [];
-  for (const sp of subpaths) {
+  for (const sp of options.corners === false ? subpaths : expandVectorCorners(subpaths)) {
     if (sp.anchors.length === 0) continue;
     const first = sp.anchors[0];
     out.push({ type: "M", x: first.x, y: first.y });
@@ -104,9 +521,9 @@ function inferAnchorType(a) {
   const oy = a.out.y - a.y;
   const li = Math.hypot(ix, iy);
   const lo = Math.hypot(ox, oy);
-  const cross = (ix * oy - iy * ox) / (li * lo);
-  const dot = (ix * ox + iy * oy) / (li * lo);
-  if (Math.abs(cross) > 1e-3 || dot > 0) return "corner";
+  const cross2 = (ix * oy - iy * ox) / (li * lo);
+  const dot2 = (ix * ox + iy * oy) / (li * lo);
+  if (Math.abs(cross2) > 1e-3 || dot2 > 0) return "corner";
   return Math.abs(li - lo) <= 1e-3 * Math.max(li, lo) ? "symmetric" : "smooth";
 }
 function bezierToSubpaths(input) {
@@ -249,8 +666,12 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX) {
   if (path.length === 0) return false;
   const point = [p.x, p.y];
   if (hasPaint(node.fill) && pointInBezierPath(path, point, node.fillRule ?? "nonzero")) return true;
-  const reach = (hasPaint(node.stroke) ? (node.strokeWidth ?? 1) / 2 : 0) + tolerance;
-  return distanceToBezierPath(path, point) <= reach;
+  if (hasPaint(node.stroke)) return hitTestVectorStroke(path, p, node, tolerance);
+  return distanceToBezierPath(path, point) <= tolerance;
+}
+function vectorStrokeOutline(node, parent = IDENTITY_MATRIX) {
+  if (!hasPaint(node.stroke) || !((node.strokeWidth ?? 1) > 0)) return [];
+  return vectorStrokeOutlinePath(vectorPathWorldBezier(node, parent), node);
 }
 function hitTestVectorNodes(nodes, p, tolerance = 0) {
   for (let i = nodes.length - 1; i >= 0; i--) {
@@ -268,8 +689,8 @@ function nearestSegment(node, p) {
       const seg = subpathSegment(sp, i);
       const hit = segmentNearest(seg, [p.x, p.y]);
       if (!best || hit.distance < best.distance) {
-        const pt = segmentPoint(seg, hit.t);
-        best = { subpath: s, segment: i, t: hit.t, point: { x: pt[0], y: pt[1] }, distance: hit.distance };
+        const pt2 = segmentPoint(seg, hit.t);
+        best = { subpath: s, segment: i, t: hit.t, point: { x: pt2[0], y: pt2[1] }, distance: hit.distance };
       }
     }
   });
@@ -303,8 +724,8 @@ function invertMatrix(m) {
   if (!det || !Number.isFinite(det)) return IDENTITY_MATRIX;
   return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
 }
-function applyMatrixLinear(m, v) {
-  return { x: m[0] * v.x + m[2] * v.y, y: m[1] * v.x + m[3] * v.y };
+function applyMatrixLinear(m, v2) {
+  return { x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.y };
 }
 function matrixRotation(m) {
   const [a, b, c, d] = m;
@@ -338,6 +759,7 @@ function bakeIntoGeometry(node, m) {
         if (a.in) next.in = applyMatrix(m, a.in);
         if (a.out) next.out = applyMatrix(m, a.out);
         if (a.type) next.type = a.type;
+        if (a.corner) next.corner = { ...a.corner };
         return next;
       })
     }))
@@ -389,12 +811,12 @@ function moveAnchorHandle(a, side, pos, breakHandles = false) {
   if (breakHandles) delete next.type;
   const dx = pos.x - a.x;
   const dy = pos.y - a.y;
-  const len = Math.hypot(dx, dy);
+  const len2 = Math.hypot(dx, dy);
   if (type === "symmetric") next[other] = { x: a.x - dx, y: a.y - dy };
-  else if (type === "smooth" && len > EPS) {
+  else if (type === "smooth" && len2 > EPS2) {
     const o = a[other];
-    const olen = o ? Math.hypot(o.x - a.x, o.y - a.y) : len;
-    next[other] = { x: a.x - dx / len * olen, y: a.y - dy / len * olen };
+    const olen = o ? Math.hypot(o.x - a.x, o.y - a.y) : len2;
+    next[other] = { x: a.x - dx / len2 * olen, y: a.y - dy / len2 * olen };
   }
   if (isOnAnchor(next, next.in)) delete next.in;
   if (isOnAnchor(next, next.out)) delete next.out;
@@ -421,15 +843,15 @@ function convertAnchor(sp, index, type) {
   else if (prev && next) dir = { x: next.x - prev.x, y: next.y - prev.y };
   else if (next) dir = { x: next.x - a.x, y: next.y - a.y };
   else if (prev) dir = { x: a.x - prev.x, y: a.y - prev.y };
-  if (!dir || Math.hypot(dir.x, dir.y) < EPS) return { anchors, closed: sp.closed };
+  if (!dir || Math.hypot(dir.x, dir.y) < EPS2) return { anchors, closed: sp.closed };
   const dl = Math.hypot(dir.x, dir.y);
   const ux = dir.x / dl;
   const uy = dir.y / dl;
   lenIn = a.in && !isOnAnchor(a, a.in) ? Math.hypot(a.in.x - a.x, a.in.y - a.y) : prev ? Math.hypot(prev.x - a.x, prev.y - a.y) / 3 : 0;
   lenOut = a.out && !isOnAnchor(a, a.out) ? Math.hypot(a.out.x - a.x, a.out.y - a.y) : next ? Math.hypot(next.x - a.x, next.y - a.y) / 3 : 0;
   if (type === "symmetric") lenIn = lenOut = (lenIn + lenOut) / 2 || Math.max(lenIn, lenOut);
-  if (lenIn > EPS) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
-  if (lenOut > EPS) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
+  if (lenIn > EPS2) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
+  if (lenOut > EPS2) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
   a.type = type;
   return { anchors, closed: sp.closed };
 }
@@ -465,37 +887,24 @@ function reverseSubpath(sp) {
     if (a.out) next.in = { ...a.out };
     if (a.in) next.out = { ...a.in };
     if (a.type) next.type = a.type;
+    if (a.corner) next.corner = { ...a.corner };
     return next;
   });
   return { anchors, closed: sp.closed };
 }
-var KAPPA = 0.5522847498307936;
-function rectSubpath(b, radius = 0) {
+var KAPPA2 = 0.5522847498307936;
+function rectSubpath(b, radius = 0, kind) {
   const { x, y, width: w, height: h } = b;
-  const r = Math.max(0, Math.min(radius, w / 2, h / 2));
-  if (r <= EPS) {
-    return { anchors: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }], closed: true };
-  }
-  const k = r * KAPPA;
-  const anchors = [
-    { x: x + r, y, in: { x: x + r - k, y } },
-    { x: x + w - r, y, out: { x: x + w - r + k, y } },
-    { x: x + w, y: y + r, in: { x: x + w, y: y + r - k } },
-    { x: x + w, y: y + h - r, out: { x: x + w, y: y + h - r + k } },
-    { x: x + w - r, y: y + h, in: { x: x + w - r + k, y: y + h } },
-    { x: x + r, y: y + h, out: { x: x + r - k, y: y + h } },
-    { x, y: y + h - r, in: { x, y: y + h - r + k } },
-    { x, y: y + r, out: { x, y: y + r - k } }
-  ];
-  return { anchors, closed: true };
+  const sp = { anchors: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }], closed: true };
+  return radius > 0 ? setSubpathCorners(sp, radius, kind) : sp;
 }
 function ellipseSubpath(b) {
   const rx = b.width / 2;
   const ry = b.height / 2;
   const cx = b.x + rx;
   const cy = b.y + ry;
-  const kx = rx * KAPPA;
-  const ky = ry * KAPPA;
+  const kx = rx * KAPPA2;
+  const ky = ry * KAPPA2;
   return {
     closed: true,
     anchors: [
@@ -543,15 +952,52 @@ function roundSubpaths(subpaths, precision = 3) {
 }
 
 // src/vector/svg.ts
+function vectorCornersAttribute(subpaths, precision = 3) {
+  const out = [];
+  subpaths.forEach(
+    (sp, s) => sp.anchors.forEach((a, i) => {
+      if (!a.corner || !(a.corner.radius > 0)) return;
+      out.push(`${s}.${i}:${formatNumber(a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
+    })
+  );
+  return out.join(" ");
+}
+function applyVectorCornersAttribute(subpaths, value) {
+  for (const item of value.trim().split(/\s+/)) {
+    const m = /^(\d+)\.(\d+):([\d.eE+-]+)(?::([a-z]+))?$/.exec(item);
+    if (!m) continue;
+    const a = subpaths[+m[1]]?.anchors[+m[2]];
+    const radius = parseFloat(m[3]);
+    if (!a || !(radius > 0)) continue;
+    const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
+    a.corner = { radius, ...kind && kind !== "round" ? { kind } : {} };
+  }
+  return subpaths;
+}
 var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function vectorPaintToSvg(paint, gradientId) {
   if (!hasPaint(paint)) return { value: "none", gradient: null };
   if (typeof paint === "string") return { value: paint, gradient: null };
   return { value: `url(#${gradientId})`, gradient: gradientToSvgDef(paint, gradientId) };
 }
+function vectorStrokeSvgParts(node, clipId, precision = 3) {
+  if (!hasPaint(node.stroke) || !hasStrokeExtras(node)) return void 0;
+  const path = subpathsToBezier(node.subpaths);
+  const parts = vectorStrokeParts(path, node);
+  if (parts.align === "center" && !parts.heads.length) return void 0;
+  let clip = null;
+  if (parts.align !== "center") {
+    const b = bezierPathBounds(path);
+    const pad = vectorStrokeReach(node) + 1;
+    const bounds = b ? { x: round2(b.minX - pad), y: round2(b.minY - pad), width: round2(b.maxX - b.minX + 2 * pad), height: round2(b.maxY - b.minY + 2 * pad) } : { x: 0, y: 0, width: 0, height: 0 };
+    clip = { kind: parts.align === "inside" ? "clip" : "mask", id: clipId, bounds };
+  }
+  return { align: parts.align, d: bezierPathToSvg(parts.line, { precision }), width: parts.drawWidth, clip, heads: parts.heads.map((h) => bezierPathToSvg(h.path, { precision })) };
+}
+var round2 = (n) => Math.round(n * 100) / 100;
 function gradientMarkup(def) {
   const tag = def.type === "radial" ? "radialGradient" : "linearGradient";
-  const attrs = Object.entries(def.attrs).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
+  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr(String(v2))}"`).join("");
   const stops = def.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escapeAttr(s.stopColor)}"${s.stopOpacity !== void 0 ? ` stop-opacity="${s.stopOpacity}"` : ""}/>`).join("");
   return `<${tag} id="${escapeAttr(def.id)}"${attrs}>${stops}</${tag}>`;
 }
@@ -582,15 +1028,53 @@ function vectorDocumentToSvg(doc, options = {}) {
     const stroke = vectorPaintToSvg(node.stroke, `${prefix}stroke-${node.id}`);
     if (fill.gradient) defs.push(gradientMarkup(fill.gradient));
     if (stroke.gradient) defs.push(gradientMarkup(stroke.gradient));
-    let attrs = `${common(node)} d="${vectorPathData(node, precision)}" fill="${escapeAttr(fill.value)}"`;
-    if (node.fillRule === "evenodd") attrs += ` fill-rule="evenodd"`;
-    if (stroke.value !== "none") {
-      attrs += ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num(node.strokeWidth ?? 1)}"`;
-      if (node.strokeLinecap && node.strokeLinecap !== "butt") attrs += ` stroke-linecap="${node.strokeLinecap}"`;
-      if (node.strokeLinejoin && node.strokeLinejoin !== "miter") attrs += ` stroke-linejoin="${node.strokeLinejoin}"`;
-      if (node.strokeDasharray?.length) attrs += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
-    }
-    lines.push(`${indent(depth)}<path${attrs}/>`);
+    const d = vectorPathData(node, precision);
+    const corners2 = vectorCornersAttribute(node.subpaths, precision);
+    const live = corners2 ? ` data-vector-d="${bezierPathToSvg(subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners2}"` : "";
+    const fillAttrs = ` fill="${escapeAttr(fill.value)}"${node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : ""}`;
+    const lineAttrs = (width) => {
+      let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num(width)}"`;
+      if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
+      if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
+      if (node.strokeDasharray?.length) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      return out2;
+    };
+    const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
+    if (!parts) {
+      lines.push(`${indent(depth)}<path${common(node)} d="${d}"${fillAttrs}${stroke.value !== "none" ? lineAttrs(node.strokeWidth ?? 1) : ""}${live}/>`);
+      return;
+    }
+    let data = ` data-vector-path="" data-vector-stroke-width="${num(node.strokeWidth ?? 1)}"`;
+    if (parts.align !== "center") data += ` data-vector-stroke-align="${parts.align}"`;
+    if (node.startArrow) data += ` data-vector-start-arrow="${node.startArrow}"`;
+    if (node.endArrow) data += ` data-vector-end-arrow="${node.endArrow}"`;
+    if (node.arrowAlign && node.arrowAlign !== "extend") data += ` data-vector-arrow-align="${node.arrowAlign}"`;
+    if (node.startArrowScale !== void 0 && node.startArrowScale !== 1) data += ` data-vector-start-arrow-scale="${num(node.startArrowScale)}"`;
+    if (node.endArrowScale !== void 0 && node.endArrowScale !== 1) data += ` data-vector-end-arrow-scale="${num(node.endArrowScale)}"`;
+    lines.push(`${indent(depth)}<g${common(node)}${data}>`);
+    lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
+    if (options.strokes === "outline") {
+      const area = bezierPathToSvg(vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
+      lines.push(`${indent(depth + 1)}<path data-vector-part="stroke-outline" d="${area}" fill="${escapeAttr(stroke.value)}"/>`);
+    } else {
+      let clip = "";
+      if (parts.clip) {
+        const rule = node.fillRule === "evenodd" ? "evenodd" : "nonzero";
+        const id = escapeAttr(parts.clip.id);
+        if (parts.clip.kind === "clip") {
+          defs.push(`<clipPath id="${id}"><path d="${d}" clip-rule="${rule}"/></clipPath>`);
+          clip = ` clip-path="url(#${id})"`;
+        } else {
+          const b = parts.clip.bounds;
+          const box = `x="${num(b.x)}" y="${num(b.y)}" width="${num(b.width)}" height="${num(b.height)}"`;
+          defs.push(`<mask id="${id}" maskUnits="userSpaceOnUse" ${box}><rect ${box} fill="#fff"/><path d="${d}" fill="#000" fill-rule="${rule}"/></mask>`);
+          clip = ` mask="url(#${id})"`;
+        }
+      }
+      lines.push(`${indent(depth + 1)}<path data-vector-part="stroke" d="${parts.d}" fill="none"${lineAttrs(parts.width)}${clip}/>`);
+      for (const h2 of parts.heads) lines.push(`${indent(depth + 1)}<path data-vector-part="head" d="${h2}" fill="${escapeAttr(stroke.value)}"/>`);
+    }
+    lines.push(`${indent(depth)}</g>`);
   };
   for (const node of doc.nodes) emit(node, 1);
   const w = num(doc.width);
@@ -765,11 +1249,11 @@ function parseVectorSvg(svg, options = {}) {
   const rawGradients = /* @__PURE__ */ new Map();
   collectGradients(root, rawGradients);
   const paint = (value) => {
-    const v = value.trim();
-    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v);
+    const v2 = value.trim();
+    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v2);
     if (url) return resolveGradient(url[1], rawGradients) ?? null;
-    if (v === "none" || v === "") return null;
-    return v;
+    if (v2 === "none" || v2 === "") return null;
+    return v2;
   };
   const viewBox = numberList(root.attrs.viewBox);
   const width = viewBox.length === 4 ? viewBox[2] : length(root.attrs.width, 300);
@@ -779,8 +1263,13 @@ function parseVectorSvg(svg, options = {}) {
   const shapeOf = (el) => {
     const a = el.attrs;
     switch (el.name) {
-      case "path":
+      case "path": {
+        if (a["data-vector-d"] && a["data-vector-corners"]) {
+          const sharp = bezierToSubpaths(a["data-vector-d"]);
+          if (sharp.length) return applyVectorCornersAttribute(sharp, a["data-vector-corners"]);
+        }
         return a.d ? bezierToSubpaths(a.d) : null;
+      }
       case "rect": {
         const w = length(a.width);
         const h = length(a.height);
@@ -814,6 +1303,56 @@ function parseVectorSvg(svg, options = {}) {
     }
     return null;
   };
+  const strokeStyle = (s) => ({
+    ...s.strokeWidth ? { strokeWidth: length(s.strokeWidth, 1) } : {},
+    ...s.strokeLinecap ? { strokeLinecap: s.strokeLinecap } : {},
+    ...s.strokeLinejoin ? { strokeLinejoin: s.strokeLinejoin } : {},
+    ...s.strokeDasharray && s.strokeDasharray !== "none" ? { strokeDasharray: numberList(s.strokeDasharray) } : {},
+    ...s.fillRule === "evenodd" ? { fillRule: "evenodd" } : {}
+  });
+  const placed = (node, m) => {
+    if (m === IDENTITY_MATRIX) return node;
+    const next = transformVectorNode(node, m);
+    const strokeScale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+    if (hasPaint(next.stroke) && strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) next.strokeWidth = (next.strokeWidth ?? 1) * strokeScale;
+    return next;
+  };
+  const mergedPath = (g, style, m, meta) => {
+    const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
+    const fillEl = part("fill");
+    const subpaths = fillEl ? shapeOf(fillEl) : null;
+    if (!fillEl || !subpaths?.length) return null;
+    const a = g.attrs;
+    const fs = readStyle(fillEl, style);
+    const strokeEl = part("stroke");
+    const outlineEl = part("stroke-outline");
+    const ss = strokeEl ? readStyle(strokeEl, style) : null;
+    const width2 = length(a["data-vector-stroke-width"], ss ? length(ss.strokeWidth, 1) : 1);
+    const arrow = (v2) => VECTOR_ARROWHEADS.includes(v2) ? v2 : void 0;
+    const scale = (v2) => {
+      const n = v2 === void 0 ? NaN : parseFloat(v2);
+      return n > 0 ? n : void 0;
+    };
+    const align = a["data-vector-stroke-align"];
+    const node = {
+      id: idFor(g),
+      type: "path",
+      ...meta,
+      subpaths,
+      fill: paint(fs.fill),
+      stroke: ss ? paint(ss.stroke) : outlineEl ? paint(readStyle(outlineEl, style).fill) : null,
+      ...ss ? strokeStyle(ss) : {},
+      ...fs.fillRule === "evenodd" ? { fillRule: "evenodd" } : {},
+      strokeWidth: width2,
+      ...align === "inside" || align === "outside" ? { strokeAlign: align } : {},
+      ...arrow(a["data-vector-start-arrow"]) ? { startArrow: arrow(a["data-vector-start-arrow"]) } : {},
+      ...arrow(a["data-vector-end-arrow"]) ? { endArrow: arrow(a["data-vector-end-arrow"]) } : {},
+      ...a["data-vector-arrow-align"] === "tip" ? { arrowAlign: "tip" } : {},
+      ...scale(a["data-vector-start-arrow-scale"]) ? { startArrowScale: scale(a["data-vector-start-arrow-scale"]) } : {},
+      ...scale(a["data-vector-end-arrow-scale"]) ? { endArrowScale: scale(a["data-vector-end-arrow-scale"]) } : {}
+    };
+    return placed(node, m);
+  };
   const visit = (el, style, matrix) => {
     const out = [];
     for (const child of el.children) {
@@ -827,6 +1366,11 @@ function parseVectorSvg(svg, options = {}) {
         ...opacity !== void 0 && Number.isFinite(opacity) && opacity < 1 ? { opacity } : {},
         ...hidden ? { visible: false } : {}
       };
+      if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
+        const node2 = mergedPath(child, s, m, meta);
+        if (node2) out.push(node2);
+        continue;
+      }
       if (child.name === "g" || child.name === "svg" || child.name === "a" || child.name === "switch") {
         const children = visit(child, s, m);
         if (!children.length) continue;
@@ -836,24 +1380,18 @@ function parseVectorSvg(svg, options = {}) {
       }
       const subpaths = shapeOf(child);
       if (!subpaths || !subpaths.length) continue;
-      let node = {
-        id: idFor(child),
-        type: "path",
-        ...meta,
-        subpaths,
-        fill: child.name === "line" ? null : paint(s.fill),
-        stroke: paint(s.stroke),
-        ...s.strokeWidth ? { strokeWidth: length(s.strokeWidth, 1) } : {},
-        ...s.strokeLinecap ? { strokeLinecap: s.strokeLinecap } : {},
-        ...s.strokeLinejoin ? { strokeLinejoin: s.strokeLinejoin } : {},
-        ...s.strokeDasharray && s.strokeDasharray !== "none" ? { strokeDasharray: numberList(s.strokeDasharray) } : {},
-        ...s.fillRule === "evenodd" ? { fillRule: "evenodd" } : {}
-      };
-      if (m !== IDENTITY_MATRIX) {
-        node = transformVectorNode(node, m);
-        const strokeScale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
-        if (hasPaint(node.stroke) && strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) node.strokeWidth = (node.strokeWidth ?? 1) * strokeScale;
-      }
+      const node = placed(
+        {
+          id: idFor(child),
+          type: "path",
+          ...meta,
+          subpaths,
+          fill: child.name === "line" ? null : paint(s.fill),
+          stroke: paint(s.stroke),
+          ...strokeStyle(s)
+        },
+        m
+      );
       out.push(node);
     }
     return out;
@@ -876,9 +1414,9 @@ function constrainToLeave(leave, p) {
       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 len2 = 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 };
+      return { x: leave.at.x + Math.cos(a) * len2, y: leave.at.y + Math.sin(a) * len2 };
     }
   }
 }
@@ -887,24 +1425,24 @@ var CROSSING_PAIRS = 32;
 var CURVE_SAMPLES = 48;
 var BISECT = 50;
 var EQUAL = 1e-6;
-function bound(sorted, key, v, strict) {
+function bound(sorted, key, v2, 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;
+    if (strict ? k <= v2 : k < v2) 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));
+function within(sorted, key, v2, tol) {
+  return sorted.slice(bound(sorted, key, v2 - tol, false), bound(sorted, key, v2 + tol, true));
 }
-var linesNear = (lines, v, tol) => within(lines, (l) => l.v, v, tol);
+var linesNear = (lines, v2, tol) => within(lines, (l) => l.v, v2, tol);
 var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 var toPoint = (p) => [p.x, p.y];
-var toVec = (p) => ({ x: p[0], y: p[1] });
+var toVec2 = (p) => ({ x: p[0], y: p[1] });
 var LABELS = {
   anchor: "anchor",
   centre: "centre",
@@ -1022,7 +1560,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count && budget > 0; i++) {
       if (moving(i) || moving((i + 1) % n)) continue;
-      const seg = subpathSegment(sp, i).map((q) => toPoint(applyMatrix(m, toVec(q))));
+      const seg = subpathSegment(sp, i).map((q) => toPoint(applyMatrix(m, toVec2(q))));
       let minX = Infinity;
       let minY = Infinity;
       let maxX = -Infinity;
@@ -1166,9 +1704,9 @@ var VectorSnapTargets = class _VectorSnapTargets {
         return { point: c.point, kind: "construction", x: true, y: true, lines: [line("construction", leave.at, c.point)], labels: [] };
       }
     }
-    const nearest = (lines2, v) => {
+    const nearest = (lines2, v2) => {
       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;
+      for (const l of linesNear(lines2, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.v - v2)) best = l;
       return best;
     };
     const bx = nearest(this.xs, p.x);
@@ -1228,16 +1766,16 @@ var VectorSnapTargets = class _VectorSnapTargets {
   /** Target segments whose control box reaches `p` and which pass within `tol` of it, nearest first. */
   segmentsNear(p, tol) {
     const out = [];
-    const pt = toPoint(p);
+    const pt2 = 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);
+      const hit = segmentNearest(s.seg, pt2);
       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;
+    return near2.length ? toVec2(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) {
@@ -1247,7 +1785,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
     for (let i = 0; i < list.length; i++) {
       for (let j = i + 1; j < list.length; j++) {
         for (const hit of segmentIntersections(list[i].seg, list[j].seg)) {
-          const q = toVec(hit.point);
+          const q = toVec2(hit.point);
           const d = distance(q, p);
           if (d <= tol && d < bestD) {
             best = q;
@@ -1288,7 +1826,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
     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 };
+      for (const v2 of values) for (const l of linesNear(lines, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.d)) best = { d: l.v - v2, from: l.from };
       return best;
     };
     const bx = axes.x ? nearest(this.xs, [r.x, r.x + r.width / 2, r.x + r.width]) : null;
@@ -1331,7 +1869,7 @@ var VectorSnapTargets = class _VectorSnapTargets {
   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 len2 = 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;
@@ -1351,17 +1889,17 @@ var VectorSnapTargets = class _VectorSnapTargets {
       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 });
+    if (before && after && after.a0 - before.a1 > len2) starts.push({ start: (before.a1 + after.a0 - len2) / 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 });
+      if (after) starts.push({ start: after.a0 - g - len2, 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 end = start + len2;
     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)]);
@@ -1372,9 +1910,9 @@ var VectorSnapTargets = class _VectorSnapTargets {
   }
   /** 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)));
+    const pt2 = (u, v2) => horizontal ? { x: u, y: v2 } : { x: v2, y: u };
+    out.lines.push(line("spacing", pt2(u0, c), pt2(u1, c)), line("spacing", pt2(u0, c - tick), pt2(u0, c + tick)), line("spacing", pt2(u1, c - tick), pt2(u1, c + tick)));
+    out.labels.push(this.label(pt2((u0 + u1) / 2, c), "spacing", fmtLength(u1 - u0)));
   }
   /** The other objects' side length nearest `length`, within `tol`, or null. */
   matchSize(length2, tol) {
@@ -1401,9 +1939,9 @@ var VectorSnapTargets = class _VectorSnapTargets {
     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) => {
+    const nearest = (v2, 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;
+      for (const l of linesNear(lines, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.v - v2)) best = l;
       return best;
     };
     let nx = sx;
@@ -1454,9 +1992,9 @@ var VectorSnapTargets = class _VectorSnapTargets {
       };
       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 v2 = { x: hv.x - origin.x, y: hv.y - origin.y };
+        const base = applyMatrix(toDoc, { x: origin.x + c.x * v2.x, y: origin.y + c.y * v2.y });
+        const dir = applyMatrix(toDoc, { x: e.x * v2.x, y: e.y * v2.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;
@@ -1489,16 +2027,16 @@ var VectorSnapTargets = class _VectorSnapTargets {
     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);
+        const len2 = this.matchSize(Math.abs(out.sx) * frame.width, tol);
+        if (len2 !== null && len2 > 0) {
+          out.sx = Math.sign(out.sx || 1) * (len2 / 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);
+        const len2 = this.matchSize(Math.abs(out.sy) * frame.height, tol);
+        if (len2 !== null && len2 > 0) {
+          out.sy = Math.sign(out.sy || 1) * (len2 / frame.height);
           sized.push("y");
         }
       }
@@ -1549,14 +2087,14 @@ 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;
+  const v2 = { x: p.x - leave.at.x, y: p.y - leave.at.y };
+  if (Math.hypot(v2.x, v2.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 k = v2.x * dir.x + v2.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 };
@@ -1581,7 +2119,7 @@ function solveOnSegment(seg, base, cond) {
     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 [];
+  if (!(scale > 0) || vals.every((v2) => Math.abs(v2) <= scale * 1e-12)) return [];
   const out = [];
   for (let i = 0; i < CURVE_SAMPLES; i++) {
     const ga = vals[i];
@@ -1614,8 +2152,8 @@ function solveOnSegment(seg, base, cond) {
 }
 
 // src/vector/pathEdit.ts
-var EPS2 = 1e-9;
-var unit = (x, y) => {
+var EPS3 = 1e-9;
+var unit2 = (x, y) => {
   const l = Math.hypot(x, y);
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
@@ -1628,14 +2166,14 @@ function cubicOf(sp, i) {
 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]);
+    const u = unit2(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]);
+    const u = unit2(c[3][0] - c[k][0], c[3][1] - c[k][1]);
     if (u) return u;
   }
   return [1, 0];
@@ -1643,11 +2181,11 @@ function endTangent(c) {
 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;
+var onAnchor2 = (a, h) => !h || Math.abs(h.x - a.x) < EPS3 && Math.abs(h.y - a.y) < EPS3;
 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;
+  if (onAnchor2(next, next.in)) delete next.in;
+  if (onAnchor2(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;
@@ -1755,8 +2293,8 @@ function curvatureMoveAnchor(sp, index, q) {
   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
+    a.in && !onAnchor2(a, a.in) ? { x: a.in.x - a.x, y: a.in.y - a.y } : null,
+    a.out && !onAnchor2(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) => {
@@ -1775,15 +2313,16 @@ function curvatureMoveAnchor(sp, index, q) {
   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;
+  if (a.corner) moved.corner = { ...a.corner };
   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);
+      const len2 = (h, to) => h ? Math.hypot(h.x, h.y) : Math.hypot(q.x - to.x, q.y - to.y) / 3;
+      let li = len2(own[0], prev);
+      let lo = len2(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 };
@@ -1824,7 +2363,7 @@ function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   const { subpath, index } = insertAnchor(sp, segment, t);
   return cutSubpathAt(subpath, [index]);
 }
-var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
+var endOf2 = (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 {
@@ -1834,6 +2373,7 @@ function reverse(sp) {
       if (a.out) next.in = { ...a.out };
       if (a.in) next.out = { ...a.in };
       if (a.type) next.type = a.type;
+      if (a.corner) next.corner = { ...a.corner };
       return next;
     })
   };
@@ -1867,7 +2407,7 @@ function joinSubpaths(subpaths, tolerance) {
       for (let j = i + 1; j < open.length; j++) {
         for (const ei of [false, true]) {
           for (const ej of [false, true]) {
-            const d = dist(endOf(open[i], ei), endOf(open[j], ej));
+            const d = dist(endOf2(open[i], ei), endOf2(open[j], ej));
             if (d < best.d) best = { d, i, j, ei, ej };
           }
         }
@@ -1905,7 +2445,7 @@ function smoothSubpath(sp, amount = 1, only) {
     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);
+    const dir = unit2(next.x - prev.x, next.y - prev.y);
     if (!dir) continue;
     const li = dist(p, prev) / 3;
     const lo = dist(p, next) / 3;
@@ -1962,12 +2502,12 @@ function mergePair(a, b, tol) {
   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 len2 = Math.hypot(cx, cy);
+    if (len2 < 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 along = (mx * cx + my * cy) / len2;
+    return Math.abs((mx * cy - my * cx) / len2) <= tol && along >= 0 && along <= len2 ? { 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;
@@ -2091,7 +2631,7 @@ function lineHits(p, q, seg) {
   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;
+  const h = (pt2) => (pt2[0] - p[0]) * -dy + (pt2[1] - p[1]) * dx;
   let coeffs;
   if (seg.length === 2) coeffs = [0, 0, h(seg[1]) - h(seg[0]), h(seg[0])];
   else {
@@ -2099,7 +2639,7 @@ function lineHits(p, q, seg) {
     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 scale = Math.sqrt(len2) * Math.max(1, ...seg.map((pt2) => Math.abs(pt2[0]) + Math.abs(pt2[1])));
   const out = [];
   for (const t of rootsInUnit(...coeffs, scale)) {
     const point = segmentPoint(seg, t);
@@ -2326,12 +2866,12 @@ function simplifyPolyline(points, tolerance) {
     const [ax, ay] = points[a];
     const dx = points[b][0] - ax;
     const dy = points[b][1] - ay;
-    const len = Math.hypot(dx, dy);
+    const len2 = 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;
+      const d = len2 < 1e-12 ? Math.hypot(px - ax, py - ay) : Math.abs((px - ax) * dy - (py - ay) * dx) / len2;
       if (d > farD) {
         farD = d;
         far = i;
@@ -2443,11 +2983,11 @@ function snapSquare(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 v2 = [c[0] - b[0], c[1] - b[1]];
   const lu = Math.hypot(u[0], u[1]);
-  const lv = Math.hypot(v[0], v[1]);
+  const lv = Math.hypot(v2[0], v2[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;
+  return Math.acos(Math.min(1, Math.max(-1, (u[0] * v2[0] + u[1] * v2[1]) / (lu * lv)))) * 180 / Math.PI;
 }
 function rdp(p, eps) {
   const n = p.length;
@@ -2575,6 +3115,21 @@ function recognizeInkShape(points, options = {}) {
 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_STYLE_KEYS = [
+  "fill",
+  "stroke",
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "fillRule",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale"
+];
 var VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 var DEFAULT_DEFAULTS = {
   fill: "#d4d4d8",
@@ -2651,6 +3206,29 @@ function getVisibleHandles(state) {
   }
   return out;
 }
+var VECTOR_CORNER_WIDGET_INSET = 10;
+function getVectorCornerWidgets(state) {
+  if (state.tool !== "direct" || state.pen) return [];
+  const zoom = state.viewport.zoom;
+  const out = [];
+  for (const id of getEditablePathIds(state)) {
+    const node = findVectorNode(state.document.nodes, id);
+    const picked = state.selectedAnchors.filter((r) => r.nodeId === id);
+    const m = vectorWorldMatrix(state.document.nodes, id) ?? IDENTITY_MATRIX;
+    for (const c of vectorCorners(node.subpaths)) {
+      if (picked.length && !picked.some((r) => r.subpath === c.subpath && r.index === c.index)) continue;
+      const side = Math.min(c.lu, c.lv);
+      if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
+      const a = node.subpaths[c.subpath].anchors[c.index];
+      const radius = a.corner?.radius ?? 0;
+      const drawn = fitCornerRadius(c, radius);
+      const k = Math.min(Math.max(drawn / c.sin, VECTOR_CORNER_WIDGET_INSET / (zoom * Math.sqrt(1 + c.cos))), side / 2);
+      const p = applyMatrix(m, cornerBisectorPoint(c, k));
+      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: a.corner?.kind ?? "round", corner: c });
+    }
+  }
+  return out;
+}
 function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
   return node?.type === "path" ? node.subpaths[ref.subpath]?.anchors[ref.index] : void 0;
@@ -2948,7 +3526,7 @@ var VectorEditorController = class {
         if (h?.transformHandle) return vectorResizeCursor(h.transformHandle, this.frameOf(this.selectedRoots())?.angle ?? 0);
         return h?.nodeId ? "move" : "default";
       case "direct":
-        if (h?.anchor || h?.handle) return "pointer";
+        if (h?.anchor || h?.handle || h?.corner) return "pointer";
         if (h?.segment) return "copy";
         return h?.nodeId ? "move" : "default";
       case "pen":
@@ -3033,12 +3611,12 @@ var VectorEditorController = class {
   // Viewport
   // -------------------------------------------------------------------------
   screenToDocument(p) {
-    const v = this.viewport;
-    return { x: (p.x - v.x) / v.zoom, y: (p.y - v.y) / v.zoom };
+    const v2 = this.viewport;
+    return { x: (p.x - v2.x) / v2.zoom, y: (p.y - v2.y) / v2.zoom };
   }
   documentToScreen(p) {
-    const v = this.viewport;
-    return { x: p.x * v.zoom + v.x, y: p.y * v.zoom + v.y };
+    const v2 = this.viewport;
+    return { x: p.x * v2.zoom + v2.x, y: p.y * v2.zoom + v2.y };
   }
   setViewport(viewport) {
     const next = { ...this.viewport, ...viewport };
@@ -3105,9 +3683,9 @@ var VectorEditorController = class {
   toggleSnapping(on = !this.snap.objects) {
     this.setSnap({ objects: on });
   }
-  gridValue(v) {
+  gridValue(v2) {
     const g = this.snap.grid;
-    return g > 0 ? Math.round(v / g) * g : v;
+    return g > 0 ? Math.round(v2 / g) * g : v2;
   }
   snapPoint(p) {
     return { x: this.gridValue(p.x), y: this.gridValue(p.y) };
@@ -3263,7 +3841,7 @@ var VectorEditorController = class {
     let subpath;
     switch (input.kind) {
       case "rect":
-        subpath = rectSubpath(b, input.cornerRadius ?? d.cornerRadius);
+        subpath = rectSubpath(b);
         break;
       case "ellipse":
         subpath = ellipseSubpath(b);
@@ -3278,10 +3856,13 @@ var VectorEditorController = class {
         subpath = lineSubpath({ x: b.x, y: b.y }, { x: b.x + b.width, y: b.y + b.height });
         break;
     }
+    const radius = input.cornerRadius ?? d.cornerRadius;
+    const kind = input.cornerKind ?? d.cornerKind;
+    if ((input.kind === "rect" || input.kind === "polygon" || input.kind === "star") && radius > 0) subpath = setSubpathCorners(subpath, radius, kind);
     const names = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
     const style = this.styleFor(input.kind === "line");
     const own = {};
-    for (const key of ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule"]) {
+    for (const key of VECTOR_STYLE_KEYS) {
       if (input[key] !== void 0) own[key] = input[key];
     }
     return { id: this.newId(), type: "path", name: input.name ?? names[input.kind], ...style, ...own, subpaths: [subpath] };
@@ -3304,6 +3885,8 @@ var VectorEditorController = class {
     if (d.strokeLinejoin) out.strokeLinejoin = d.strokeLinejoin;
     if (d.strokeDasharray) out.strokeDasharray = d.strokeDasharray;
     if (d.fillRule) out.fillRule = d.fillRule;
+    if (d.strokeAlign && d.strokeAlign !== "center") out.strokeAlign = d.strokeAlign;
+    for (const key of ["startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"]) if (d[key]) out[key] = d[key];
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -3328,6 +3911,95 @@ var VectorEditorController = class {
     });
     return { ok: true };
   }
+  /**
+   * Sets the live corner radius (and optionally the kind) of anchors: `refs`, else the selected
+   * anchors (direct tool), else every anchor of the `ids` / selected paths. Radius 0 makes the
+   * corners sharp again. Corners shrink to fit when drawn, so any radius is accepted.
+   */
+  setCornerRadius(radius, options = {}) {
+    if (!Number.isFinite(radius) || radius < 0) return { ok: false, message: "The radius must be a number of at least 0." };
+    const refs = this.cornerTargets(options);
+    if (!refs.length) return { ok: false, message: "Nothing is selected." };
+    this.change(radius > 0 ? "Corner Radius" : "Sharpen Corners", () => {
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, radius, options.kind));
+    });
+    return { ok: true };
+  }
+  /** Sets the live corner kind of the same anchors as `setCornerRadius`, keeping their radii. */
+  setCornerKind(kind, options = {}) {
+    const refs = this.cornerTargets(options);
+    if (!refs.length) return { ok: false, message: "Nothing is selected." };
+    this.change("Corner Kind", () => {
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, a.corner?.radius ?? 0, kind));
+    });
+    return { ok: true };
+  }
+  /** Anchors a corner change applies to (see `setCornerRadius`). */
+  cornerTargets(options) {
+    if (options.refs) return options.refs.filter((r) => getAnchor(this.doc, r));
+    if (!options.ids && this.tool === "direct" && this.anchors.length) return this.anchors.slice();
+    const out = [];
+    for (const id of options.ids ?? this.selection) {
+      const node = this.getNode(id);
+      if (!node) continue;
+      for (const p of collectPathNodes(node)) {
+        if (p.locked) continue;
+        p.subpaths.forEach((sp, s) => sp.anchors.forEach((_, i) => out.push({ nodeId: p.id, subpath: s, index: i })));
+      }
+    }
+    return out;
+  }
+  /**
+   * Outline Stroke: replaces each selected (or given) path's stroke with a filled path of the
+   * area it paints (alignment, joins, caps, dashes and arrowheads included), placed above a copy
+   * of the path that keeps the fill (left out when there is none). Returns the new paths' ids.
+   */
+  outlineStroke(options = {}) {
+    const roots = options.ids ?? this.selectedRoots();
+    const paths = [];
+    for (const id of roots) {
+      const node = this.getNode(id);
+      if (node) {
+        for (const p of collectPathNodes(node)) if (!p.locked && hasPaint(p.stroke) && (p.strokeWidth ?? 1) > 0) paths.push(p);
+      }
+    }
+    if (!paths.length) return [];
+    const created = [];
+    const replace = /* @__PURE__ */ new Map();
+    for (const p of paths) {
+      const outline = bezierToSubpaths(vectorStrokeOutlinePath(subpathsToBezier(p.subpaths), p));
+      if (!outline.length) continue;
+      const {
+        stroke,
+        strokeWidth: _w,
+        strokeLinecap: _c,
+        strokeLinejoin: _j,
+        strokeDasharray: _d,
+        strokeAlign: _a,
+        startArrow: _s,
+        endArrow: _e,
+        arrowAlign: _al,
+        startArrowScale: _ss,
+        endArrowScale: _es,
+        ...rest
+      } = cloneVectorNode(p);
+      const id = this.newId();
+      const strokeNode = { ...rest, id, name: `${p.name ?? "Path"} Stroke`, subpaths: outline, fill: stroke ?? null, stroke: null, fillRule: "nonzero" };
+      const list = hasPaint(p.fill) ? [{ ...rest, stroke: null }, strokeNode] : [strokeNode];
+      created.push(id);
+      replace.set(p.id, list);
+    }
+    if (!created.length) return [];
+    this.change("Outline Stroke", () => {
+      let nodes = this.doc.nodes;
+      for (const [id, list] of replace) nodes = spliceTree(nodes, id, list);
+      this.setDoc(nodes);
+      this.selection = created;
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return created;
+  }
   rename(id, name) {
     return this.updateNode(id, { name }, { label: "Rename" });
   }
@@ -3930,7 +4602,7 @@ var VectorEditorController = class {
     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 } : {} }))
+      anchors: sp.anchors.map((a) => ({ ...map(a), ...a.in ? { in: map(a.in) } : {}, ...a.out ? { out: map(a.out) } : {}, ...a.type ? { type: a.type } : {}, ...a.corner ? { corner: { ...a.corner } } : {} }))
     }));
   }
   /**
@@ -4285,6 +4957,22 @@ var VectorEditorController = class {
     }
     return null;
   }
+  cornerView() {
+    return { ...this.view(), viewport: this.viewport };
+  }
+  hitCornerWidget(screen) {
+    let best = null;
+    let bestD = Infinity;
+    for (const w of getVectorCornerWidgets(this.cornerView())) {
+      const s = this.documentToScreen(w);
+      const d = Math.hypot(s.x - screen.x, s.y - screen.y);
+      if (d <= this.hitRadius && d < bestD) {
+        best = w;
+        bestD = d;
+      }
+    }
+    return best;
+  }
   hitAnchor(screen, refs) {
     let best = null;
     let bestD = Infinity;
@@ -4343,6 +5031,8 @@ var VectorEditorController = class {
         if (handle) return { nodeId: handle.nodeId, handle };
         const anchor = this.hitAnchor(screen, getVisibleAnchors(this.view()));
         if (anchor) return { nodeId: anchor.nodeId, anchor };
+        const widget = this.hitCornerWidget(screen);
+        if (widget) return { nodeId: widget.ref.nodeId, corner: widget.ref };
         for (const id of getEditablePathIds(this.view())) {
           const node = this.getNode(id);
           const seg = nearestSegment(node, this.toLocal(id, p));
@@ -4500,6 +5190,13 @@ var VectorEditorController = class {
       this.notify();
       return;
     }
+    const widget = this.hitCornerWidget(screen);
+    if (widget) {
+      const refs = getVectorCornerWidgets(this.cornerView()).map((w) => w.ref);
+      this.drag = { kind: "corner", widget, refs, start: p, before: this.snapshot(), base: this.doc, moved: false, alt: !!input.alt, shift: !!input.shift };
+      this.notify();
+      return;
+    }
     for (const id of getEditablePathIds(this.view())) {
       const node = this.getNode(id);
       const seg = nearestSegment(node, this.toLocal(id, p));
@@ -4557,10 +5254,10 @@ var VectorEditorController = class {
       }
       const last = getAnchorWorld(this.doc, { nodeId: pen.nodeId, subpath: pen.subpath, index: sp.anchors.length - 1 });
       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);
+      let pt3 = this.snapDrawn(p, leave, input, () => this.drawingTargets(pen.nodeId));
+      pt3 = this.toLocal(pen.nodeId, pt3);
       const node2 = this.getNode(pen.nodeId);
-      const anchors = [...sp.anchors, { x: pt2.x, y: pt2.y }];
+      const anchors = [...sp.anchors, { x: pt3.x, y: pt3.y }];
       this.replaceNode(pen.nodeId, { ...node2, subpaths: node2.subpaths.map((s, i) => i === pen.subpath ? { ...s, anchors } : s) });
       const ref2 = { nodeId: pen.nodeId, subpath: pen.subpath, index: anchors.length - 1 };
       this.anchors = [ref2];
@@ -4588,8 +5285,8 @@ var VectorEditorController = class {
       this.notify(this.doc !== before.doc);
       return;
     }
-    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 }] };
+    const pt2 = this.snapDrawn(p, null, input, () => this.drawingTargets(null));
+    const node = { id: this.newId(), type: "path", name: "Path", ...this.styleFor(true), subpaths: [{ anchors: [{ x: pt2.x, y: pt2.y }], closed: false }] };
     this.setDoc([...this.doc.nodes, node]);
     this.pen = { nodeId: node.id, subpath: 0 };
     this.selection = [node.id];
@@ -4737,13 +5434,25 @@ var VectorEditorController = class {
       case "handle": {
         const anchor = getAnchorWorld(drag.base, drag.ref);
         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);
+        const pt2 = this.snapDrawn(p, leave, input, () => drag.targets ??= VectorSnapTargets.forHandle(drag.base, drag.ref.nodeId));
+        const local = this.toLocal(drag.ref.nodeId, pt2, 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 "corner": {
+        if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 3) return;
+        drag.moved = true;
+        const c = drag.widget.corner;
+        const inv = invertMatrix(this.worldOf(drag.widget.ref.nodeId, drag.base));
+        const d = applyMatrixLinear(inv, { x: p.x - drag.start.x, y: p.y - drag.start.y });
+        const radius = Math.max(0, Math.min(c.maxRadius, drag.widget.drawnRadius + cornerRadiusChange(c, d)));
+        this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, radius));
+        this.interaction = { type: "corner", ref: drag.widget.ref, radius };
+        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;
@@ -4769,10 +5478,10 @@ var VectorEditorController = class {
           return;
         }
         this.guides = null;
-        let pt = p;
-        if (input.shift) pt = constrain45(anchor, pt);
+        let pt2 = p;
+        if (input.shift) pt2 = constrain45(anchor, pt2);
         const side = drag.closing ? "in" : "out";
-        const pos = this.toLocal(drag.ref.nodeId, drag.closing ? { x: 2 * anchor.x - pt.x, y: 2 * anchor.y - pt.y } : pt, drag.base);
+        const pos = this.toLocal(drag.ref.nodeId, drag.closing ? { x: 2 * anchor.x - pt2.x, y: 2 * anchor.y - pt2.y } : pt2, drag.base);
         this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => {
           if (drag.outOnly || drag.altBreaks && input.alt) return moveAnchorHandle(a, side, pos, true);
           return moveAnchorHandle({ ...a, type: "symmetric" }, side, pos);
@@ -4885,12 +5594,12 @@ var VectorEditorController = class {
     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 len2 = Math.abs(d) > 1e-9 ? targets.matchSize(Math.abs(d) * k, tol) : null;
+      if (len2 === null || len2 <= 0) continue;
+      out[axis] = start[axis] + Math.sign(d) * len2 / 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}` });
+      guides.labels.push({ kind: "size", x: (from.x + out.x) / 2, y: (from.y + out.y) / 2, text: `${axis === "x" ? "W" : "H"} ${Math.round(len2 * 100) / 100}` });
     }
     this.setGuides(guides);
     return out;
@@ -4935,6 +5644,20 @@ var VectorEditorController = class {
           return;
         }
         return this.commit("Bend Segment", drag.before);
+      case "corner": {
+        if (drag.moved) return this.commit("Corner Radius", drag.before);
+        if (drag.alt) {
+          const kind = nextVectorCornerKind(drag.widget.kind);
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, a.corner?.radius ?? 0, kind));
+          return this.commit("Corner Kind", drag.before);
+        }
+        const ref = drag.widget.ref;
+        const has = this.anchors.some((a) => sameRef(a, ref));
+        this.editingId = ref.nodeId;
+        this.anchors = drag.shift ? has ? this.anchors.filter((a) => !sameRef(a, ref)) : [...this.anchors, ref] : [ref];
+        this.notify();
+        return;
+      }
       case "stroke": {
         this.notify();
         if (drag.tool === "knife") this.knife(drag.points);
@@ -5179,9 +5902,9 @@ function inkShapeSubpath(shape) {
 function constrain45(origin, p) {
   const dx = p.x - origin.x;
   const dy = p.y - origin.y;
-  const len = Math.hypot(dx, dy);
+  const len2 = Math.hypot(dx, dy);
   const a = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
-  return { x: origin.x + Math.cos(a) * len, y: origin.y + Math.sin(a) * len };
+  return { x: origin.x + Math.cos(a) * len2, y: origin.y + Math.sin(a) * len2 };
 }
 function scaleFor(handle, b, p, mods = {}) {
   const west = handle.includes("w");
@@ -5218,10 +5941,12 @@ function renderNode(node, defs, idPrefix) {
   const stroke = vectorPaintToSvg(node.stroke, `${idPrefix}stroke-${node.id}`);
   if (fill.gradient) defs.push(fill.gradient);
   if (stroke.gradient) defs.push(stroke.gradient);
+  const strokeParts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${idPrefix}clip-${node.id}`) : void 0;
   return {
     kind: "path",
     id: node.id,
     ...node.transform ? { transform: fmtMatrix(node.transform) } : {},
+    ...strokeParts ? { strokeParts } : {},
     d: vectorPathData(node),
     fill: fill.value,
     stroke: stroke.value,
@@ -5237,9 +5962,9 @@ function getVectorSceneRenderData(state, options = {}) {
   const defs = [];
   const prefix = options.idPrefix ?? "ve-";
   const nodes = state.document.nodes.map((n) => renderNode(n, defs, prefix)).filter((n) => !!n);
-  const v = state.viewport;
+  const v2 = state.viewport;
   return {
-    transform: `translate(${fmt(v.x)} ${fmt(v.y)}) scale(${v.zoom})`,
+    transform: `translate(${fmt(v2.x)} ${fmt(v2.y)}) scale(${v2.zoom})`,
     width: state.document.width,
     height: state.document.height,
     ...state.document.background ? { background: state.document.background } : {},
@@ -5249,8 +5974,8 @@ function getVectorSceneRenderData(state, options = {}) {
 }
 var toScreen = (state, p) => ({ x: p.x * state.viewport.zoom + state.viewport.x, y: p.y * state.viewport.zoom + state.viewport.y });
 function screenOutline(state, node) {
-  const v = state.viewport;
-  const view = [v.zoom, 0, 0, v.zoom, v.x, v.y];
+  const v2 = state.viewport;
+  const view = [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y];
   const parent = vectorParentMatrix(state.document.nodes, node.id) ?? IDENTITY_MATRIX;
   return collectWithMatrix(node, parent).map(({ path, parent: m }) => bezierPathToSvg(transformBezierPath(vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
 }
@@ -5359,8 +6084,14 @@ function getVectorOverlayRenderData(state) {
     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 dragged = it?.type === "corner" ? it.ref : null;
+  const cornerWidgets = getVectorCornerWidgets(state).map((w) => {
+    const s = toScreen(state, w);
+    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(state.hover?.corner, w.ref), active: !!dragged };
+  });
+  if (it?.type === "corner") status = `R ${fmt(it.radius)}`;
   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 };
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets };
 }
 var VECTOR_OVERLAY_THEME = {
   accent: "#0ea5e9",
@@ -5372,7 +6103,9 @@ var VECTOR_OVERLAY_THEME = {
   eraserFill: "rgba(239, 68, 68, 0.25)",
   transformHandleSize: 8,
   anchorSize: 7,
-  handleRadius: 3.5
+  handleRadius: 3.5,
+  /** Radius of a live corner widget (a ring with a dot). */
+  cornerWidgetRadius: 4
 };
 function toVectorModifiers(event) {
   return { shift: !!event.shiftKey, alt: !!event.altKey, mod: !!(event.metaKey || event.ctrlKey) };
@@ -5396,18 +6129,68 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
+  const anchorMode = state.tool === "direct" && !!state.selectedAnchors?.length;
+  if (anchorMode) {
+    for (const r of state.selectedAnchors) {
+      if (paths.some((p) => p.id === r.nodeId)) continue;
+      const node = findVectorNode(state.document.nodes, r.nodeId);
+      if (node?.type === "path") paths.push(node);
+    }
+  }
   if (!paths.length) return null;
   const first = paths[0];
   const same = (get) => paths.every((p) => JSON.stringify(get(p) ?? null) === JSON.stringify(get(first) ?? null));
+  const corners2 = [];
+  for (const p of paths) {
+    for (const c of vectorCorners(p.subpaths)) {
+      if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
+      const corner = p.subpaths[c.subpath].anchors[c.index].corner;
+      corners2.push({ radius: corner?.radius ?? 0, kind: corner?.kind ?? "round" });
+    }
+  }
+  const c0 = corners2[0] ?? { radius: 0, kind: "round" };
   return {
     fill: first.fill ?? null,
     stroke: first.stroke ?? null,
     strokeWidth: first.strokeWidth ?? 1,
     opacity: first.opacity ?? 1,
-    mixed: { fill: !same((p) => p.fill), stroke: !same((p) => p.stroke), strokeWidth: !same((p) => p.strokeWidth ?? 1), opacity: !same((p) => p.opacity ?? 1) },
+    strokeAlign: first.strokeAlign ?? "center",
+    startArrow: first.startArrow ?? null,
+    endArrow: first.endArrow ?? null,
+    arrowAlign: first.arrowAlign ?? "extend",
+    startArrowScale: first.startArrowScale ?? 1,
+    endArrowScale: first.endArrowScale ?? 1,
+    cornerRadius: c0.radius,
+    cornerKind: c0.kind,
+    corners: corners2.length,
+    hasOpenPath: paths.some((p) => p.subpaths.some((sp) => !sp.closed && sp.anchors.length > 1)),
+    mixed: {
+      fill: !same((p) => p.fill),
+      stroke: !same((p) => p.stroke),
+      strokeWidth: !same((p) => p.strokeWidth ?? 1),
+      opacity: !same((p) => p.opacity ?? 1),
+      strokeAlign: !same((p) => p.strokeAlign ?? "center"),
+      startArrow: !same((p) => p.startArrow ?? null),
+      endArrow: !same((p) => p.endArrow ?? null),
+      arrowAlign: !same((p) => p.arrowAlign ?? "extend"),
+      startArrowScale: !same((p) => p.startArrowScale ?? 1),
+      endArrowScale: !same((p) => p.endArrowScale ?? 1),
+      cornerRadius: corners2.some((c) => c.radius !== c0.radius),
+      cornerKind: corners2.some((c) => c.kind !== c0.kind)
+    },
     pathIds: paths.map((p) => p.id)
   };
 }
+var VECTOR_STROKE_ALIGN_LABELS = { center: "Center", inside: "Inside", outside: "Outside" };
+var VECTOR_CORNER_KIND_LABELS = { round: "Round", inverted: "Inverted", chamfer: "Chamfer" };
+var VECTOR_ARROWHEAD_LABELS = {
+  triangle: "Triangle",
+  arrow: "Arrow",
+  open: "Open arrow",
+  circle: "Circle",
+  square: "Square",
+  bar: "Bar"
+};
 function vectorPaintToHex(paint) {
   if (typeof paint !== "string") return null;
   const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(paint.trim());
@@ -5420,7 +6203,8 @@ var VECTOR_PATH_ACTIONS = [
   { 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() }
+  { id: "smooth", label: "\u223F", title: "Smooth", enabled: (s, p) => s + p > 0, run: (c) => c.smoothPaths() },
+  { id: "outline", label: "\u22A1", title: "Outline Stroke", enabled: (s) => s > 0, run: (c) => c.outlineStroke() }
 ];
 var VECTOR_EDIT_TOGGLES = [
   { key: "keepShapeOnDelete", label: "Keep", title: "Keep shape when deleting points" },
@@ -5458,7 +6242,13 @@ var STYLE_PROPS = {
   strokeLinecap: { type: "string", enum: ["butt", "round", "square"] },
   strokeLinejoin: { type: "string", enum: ["miter", "round", "bevel"] },
   strokeDasharray: { type: "array", items: { type: "number" } },
-  fillRule: { type: "string", enum: ["nonzero", "evenodd"] }
+  fillRule: { type: "string", enum: ["nonzero", "evenodd"] },
+  strokeAlign: { type: "string", enum: ["center", "inside", "outside"], description: "Where the stroke sits on the outline (closed shapes only; open paths stroke centred)." },
+  startArrow: { type: ["string", "null"], enum: [...VECTOR_ARROWHEADS, null], description: "Head at the start of an open path, or null for none." },
+  endArrow: { type: ["string", "null"], enum: [...VECTOR_ARROWHEADS, null], description: "Head at the end of an open path, or null for none." },
+  arrowAlign: { type: "string", enum: ["extend", "tip"], description: "`extend`: the tip sits past the end point; `tip`: on it, the stroke shortened under the head." },
+  startArrowScale: { type: "number", exclusiveMinimum: 0, description: "Start head size as a multiple of the stroke width (default 1)." },
+  endArrowScale: { type: "number", exclusiveMinimum: 0, description: "End head size as a multiple of the stroke width (default 1)." }
 };
 var pickStyle = (params) => {
   const out = {};
@@ -5551,7 +6341,8 @@ function createVectorCommands(controller, options = {}) {
           y: { type: "number" },
           width: { type: "number", description: "For a line: the x offset of its end." },
           height: { type: "number", description: "For a line: the y offset of its end." },
-          cornerRadius: { type: "number", minimum: 0 },
+          cornerRadius: { type: "number", minimum: 0, description: "Live corner radius of a rect, polygon or star." },
+          cornerKind: { type: "string", enum: VECTOR_CORNER_KINDS },
           sides: { type: "integer", minimum: 3 },
           points: { type: "integer", minimum: 3 },
           innerRatio: { type: "number", minimum: 0, maximum: 1 },
@@ -5597,6 +6388,38 @@ function createVectorCommands(controller, options = {}) {
         return { ok: true };
       }
     },
+    {
+      ...base,
+      id: `${prefix}setCorners`,
+      label: "Corner Radius\u2026",
+      keywords: ["round", "rounded", "corners", "radius", "fillet", "chamfer", "live corners"],
+      description: "Sets the live corner radius (and optionally `kind`: round, inverted or chamfer) of `anchors`, else the selected points (direct tool), else every corner of `ids` / the selection. Radius 0 makes corners sharp; radii shrink to fit short sides. The anchors stay editable.",
+      params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        const refs = params?.anchors ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: params?.ids ? ids(params) : void 0 };
+        if (params?.radius !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (params?.kind) check(controller.setCornerKind(params.kind, target));
+        else fail("Pass `radius` and / or `kind`.");
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}outlineStroke`,
+      label: "Outline Stroke",
+      keywords: ["expand", "stroke to path", "outline", "convert stroke"],
+      description: "Turns the stroke of paths into filled shapes of the area it paints (alignment, caps, joins, dashes and arrowheads included). Returns the new ids.",
+      params: { type: "object", properties: { ids: IDS } },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        const created = controller.outlineStroke({ ids: params?.ids ? ids(params) : void 0 });
+        if (!created.length) fail("No selected path has a stroke.");
+        return { ids: created };
+      }
+    },
     {
       ...base,
       id: `${prefix}transform`,
@@ -5947,16 +6770,23 @@ export {
   DEFAULT_VECTOR_PATH_EDIT,
   DEFAULT_VECTOR_SNAP,
   IDENTITY_MATRIX,
-  KAPPA,
+  KAPPA2 as KAPPA,
   LazyMouse,
+  VECTOR_ARROWHEADS,
+  VECTOR_ARROWHEAD_LABELS,
   VECTOR_CLIPBOARD_TYPE,
   VECTOR_CONSTRUCTION_ANGLES,
+  VECTOR_CORNER_KINDS,
+  VECTOR_CORNER_KIND_LABELS,
+  VECTOR_CORNER_WIDGET_INSET,
   VECTOR_EDIT_TOGGLES,
   VECTOR_INK_MAX_CORNERS,
   VECTOR_OVERLAY_THEME,
   VECTOR_PATH_ACTIONS,
   VECTOR_PENCIL_STRING_PX,
   VECTOR_ROTATE_HANDLE_OFFSET,
+  VECTOR_STROKE_ALIGN_LABELS,
+  VECTOR_STYLE_KEYS,
   VECTOR_TOOLS,
   VECTOR_TOOL_GLYPHS,
   VECTOR_TOOL_SHORTCUTS,
@@ -5965,6 +6795,10 @@ export {
   VectorSnapTargets,
   applyMatrix,
   applyMatrixLinear,
+  applyVectorCornersAttribute,
+  arrowheadInset,
+  arrowheadPath,
+  arrowheadWeight,
   bendSegment,
   bezierToSubpaths,
   boundsFromPoints,
@@ -5976,19 +6810,27 @@ export {
   collectPathNodes,
   constrainToLeave,
   convertAnchor,
+  cornerBisectorPoint,
+  cornerRadiusChange,
+  cornerSetback,
   createVectorCommands,
   curvatureMoveAnchor,
   cutSubpathAt,
   decomposeRigid,
+  effectiveStrokeAlign,
   ellipseSubpath,
   eraseFromFill,
   eraseFromOutline,
   eraserRegion,
+  expandVectorCorners,
+  expandVectorCornersOf,
   findVectorNode,
+  fitCornerRadius,
   getAnchor,
   getAnchorWorld,
   getEditablePathIds,
   getTransformHandlePositions,
+  getVectorCornerWidgets,
   getVectorOverlayRenderData,
   getVectorSceneRenderData,
   getVectorSelectionBoxGeometry,
@@ -5997,11 +6839,15 @@ export {
   getVisibleAnchors,
   getVisibleHandles,
   hasPaint,
+  hasStrokeExtras,
+  hasVectorCorners,
   hitTestVectorNode,
   hitTestVectorNodes,
+  hitTestVectorStroke,
   inferAnchorType,
   insertAnchor,
   invertMatrix,
+  isClosedBezierShape,
   isIdentityMatrix,
   isVectorTextTarget,
   joinSubpaths,
@@ -6012,6 +6858,7 @@ export {
   moveAnchorHandle,
   multiplyMatrices,
   nearestSegment,
+  nextVectorCornerKind,
   nodeMatrix,
   parseSvgTransform,
   parseVectorSvg,
@@ -6028,6 +6875,8 @@ export {
   roundSubpaths,
   scaleFor,
   scaleMatrix,
+  setAnchorCorner,
+  setSubpathCorners,
   simplifyPolyline,
   smoothSubpath,
   splitIntoFaces,
@@ -6044,6 +6893,9 @@ export {
   translateAnchor,
   translateMatrix,
   unionBounds,
+  vectorCornerAt,
+  vectorCorners,
+  vectorCornersAttribute,
   vectorDocumentToSvg,
   vectorInkShapeName,
   vectorNodeBounds,
@@ -6055,6 +6907,11 @@ export {
   vectorPathData,
   vectorPathWorldBezier,
   vectorResizeCursor,
+  vectorStrokeOutline,
+  vectorStrokeOutlinePath,
+  vectorStrokeParts,
+  vectorStrokeReach,
+  vectorStrokeSvgParts,
   vectorToolLabel,
   vectorWorldMatrix,
   walkVectorNodes