castle-web-cli 0.4.115 → 0.4.117

package/kits/physics-2d/editors/pathTools.js

@@ -0,0 +1,1906 @@
+import {
+  absoluteSegment,
+  bowForSegment,
+  bowToSegments,
+  closestParamOnEdge,
+  cubicPoint,
+  clonePathData,
+  cloneSubpath,
+  deCasteljauSplit,
+  deriveShape,
+  edgeObjectsForSubpath,
+  flattenSubpath,
+  isPrimitiveShape,
+  LATTICE,
+  magneticSnapPoint,
+  MIN_ELLIPSE_RADIUS,
+  pointsEqual,
+  normalizeSubpath,
+  primitiveHandleIndices,
+  roundCoord,
+  sampleEdgeCurve,
+  snapBow,
+  shapeContainsPoint,
+  straightSegment,
+  subpathClosesOnStart,
+  subpathEdgeCount,
+  subpathEdgeFrom,
+  subpathPointAt,
+  subpathPoints,
+  subpathVertexCount,
+  transformSegmentHandles,
+  translatePathData,
+} from '../engine/pxartPath.js';
+
+// Pure data operations + hit-testing for stacked-shape path layers (pen /
+// path-select / fill+stroke recolor). Mutators return a NEW path object; the editor
+// rebakes via withPathAt + history.commit(serializeModel(...)).
+
+const HIT_RADIUS = 0.75;
+/** Generous pick radius (cell units) for stroked outlines / edge bodies. */
+const EDGE_HIT = 1.25;
+const STROKE_HIT = EDGE_HIT;
+
+/** Screen-space hit targets — converted to cell units via hitRadiusCells. */
+export const HIT_RADIUS_SCREEN_PX = 12;
+export const EDGE_HIT_SCREEN_PX = 20;
+export const OPEN_END_HIT_SCREEN_PX = 10;
+
+export function hitRadiusCells(screenPx, cellPx) {
+  return cellPx > 0 ? screenPx / cellPx : screenPx / 16;
+}
+
+export function snapToWholeCell(x, y) {
+  return [Math.round(x), Math.round(y)];
+}
+
+export function snapToPixelCenter(x, y, width, height) {
+  const sx = Math.round(x - 0.5) + 0.5;
+  const sy = Math.round(y - 0.5) + 0.5;
+  if (width == null || height == null) return [sx, sy];
+  const maxX = Math.max(0.5, width - 0.5);
+  const maxY = Math.max(0.5, height - 0.5);
+  return [clamp(sx, 0.5, maxX), clamp(sy, 0.5, maxY)];
+}
+
+function clamp(value, lo, hi) {
+  return Math.min(hi, Math.max(lo, value));
+}
+
+// Path placement snap: magnetic pull toward the half-cell lattice (Alt → corners).
+// `cellPull` is in cell units (from magneticCellPull); omit for a tight default.
+export function snapPenAnchor(x, y, halfPixel = false, cellPull = LATTICE / 2) {
+  return magneticSnapPoint(x, y, cellPull, halfPixel);
+}
+
+export function snapPenAnchorClamped(x, y, halfPixel, cellPull, width, height) {
+  const [mx, my] = magneticSnapPoint(x, y, cellPull, halfPixel);
+  if (width == null || height == null) return [mx, my];
+  return [clamp(mx, 0, width), clamp(my, 0, height)];
+}
+
+/**
+ * Where a pen click would place/insert an anchor.
+ * Returns `{ point, edge }` — `edge` is the hit-test result when insert would
+ * fire (same shapeIndex/subIndex/edgeIndex as insertAnchorOnEdge), else null.
+ */
+export function previewPenLanding(path, soleShapeIndex, x, y, halfPixel = false, cellPull = LATTICE / 2) {
+  if (soleShapeIndex != null && soleShapeIndex >= 0) {
+    const hit = hitTestShapeEdge(path, soleShapeIndex, x, y);
+    if (hit) {
+      const ends = endpointsForEdge(path, hit.shapeIndex, hit.subIndex, hit.edgeIndex);
+      if (ends?.edge) {
+        const split = splitSegmentAtNearest(ends.edge.from, ends.edge.seg, x, y, cellPull);
+        // `hit`, not the segment: callers read shapeIndex/subIndex/edgeIndex off it.
+        if (split) return { point: split.mid, edge: hit };
+      }
+    }
+  }
+  return { point: snapPenAnchor(x, y, halfPixel, cellPull), edge: null };
+}
+
+/** Apply magnetic pull to an absolute position after a free drag. */
+export function snapDragPoint(x, y, halfPixel = false, cellPull = LATTICE / 2) {
+  return magneticSnapPoint(x, y, cellPull, halfPixel);
+}
+
+function magneticStep(n, step, cellPull) {
+  if (!(cellPull > 0) || !Number.isFinite(n)) return n;
+  const target = Math.round(n / step) * step;
+  return Math.abs(n - target) <= cellPull ? target + 0 : n;
+}
+
+/**
+ * Magnetize a translation rather than each point it carries.
+ *
+ * A group move has to be rigid. Magnetizing every point independently pulls
+ * on-lattice anchors and off-lattice ones — an arc's inserted midpoint, or
+ * imported SVG — by different amounts, so the outline deforms as it travels:
+ * a purely horizontal drag slides a curve's midpoint vertically. Snapping the
+ * delta instead preserves the shape's internal phase, which also matters
+ * because stroke and fill rasterize differently at different phases.
+ */
+export function snapDragDelta(dx, dy, halfPixel = false, cellPull = 0) {
+  const step = halfPixel ? LATTICE : 1;
+  return [magneticStep(dx, step, cellPull), magneticStep(dy, step, cellPull)];
+}
+
+function distSq(x0, y0, x1, y1) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  return dx * dx + dy * dy;
+}
+
+/** Squared distance from (x,y) to the closest sample on an edge curve. */
+function minDistSqToEdge(edge, verts, x, y) {
+  let best = Infinity;
+  for (const s of sampleEdgeCurve(edge, verts)) {
+    const d = distSq(s.x, s.y, x, y);
+    if (d < best) best = d;
+  }
+  return best;
+}
+
+function nearStrokedOutline(shape, x, y, radius = STROKE_HIT) {
+  if (!shape?.stroke) return false;
+  const r2 = radius * radius;
+  for (const sub of shape.subpaths ?? []) {
+    const { verts, edges } = edgeObjectsForSubpath(sub, shape.stroke);
+    for (const edge of edges) {
+      if (minDistSqToEdge(edge, verts, x, y) <= r2) return true;
+    }
+  }
+  return false;
+}
+
+/** Topmost shape whose fill contains (x,y) or whose stroke paints nearby, or -1. */
+export function hitTestShape(path, x, y, strokeRadius = STROKE_HIT) {
+  const shapes = path?.shapes ?? [];
+  for (let i = shapes.length - 1; i >= 0; i--) {
+    const shape = shapes[i];
+    const inFill = !!shape.fill && shapeContainsPoint(shape, x, y);
+    if (inFill || nearStrokedOutline(shape, x, y, strokeRadius)) return i;
+  }
+  return -1;
+}
+
+/** Closest anchor on one shape within HIT_RADIUS, or null. */
+export function hitTestShapeAnchor(path, shapeIndex, x, y, radius = HIT_RADIUS) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape) return null;
+  // A primitive's ring is regenerated from its parameters, so most of it is not
+  // grabbable — only the four axis anchors, which drag as radii.
+  const handles = isPrimitiveShape(shape) ? new Set(primitiveHandleIndices(shape)) : null;
+  const r2 = radius * radius;
+  let best = null;
+  let bestD = r2;
+  (shape.subpaths ?? []).forEach((sub, subIndex) => {
+    subpathPoints(sub).forEach((p, pointIndex) => {
+      if (handles && !handles.has(pointIndex)) return;
+      const d = distSq(p[0], p[1], x, y);
+      if (d <= bestD) {
+        bestD = d;
+        best = { shapeIndex, subIndex, pointIndex };
+      }
+    });
+  });
+  return best;
+}
+
+/** Closest edge body on one shape (not near an anchor), or null. */
+export function hitTestShapeEdge(path, shapeIndex, x, y, radiusPx = EDGE_HIT) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape) return null;
+  if (isPrimitiveShape(shape)) return null;
+  if (hitTestShapeAnchor(path, shapeIndex, x, y)) return null;
+  const r2 = radiusPx * radiusPx;
+  let best = null;
+  let bestD = r2;
+  (shape.subpaths ?? []).forEach((sub, subIndex) => {
+    const { verts, edges } = edgeObjectsForSubpath(sub, shape.stroke);
+    edges.forEach((edge, edgeIndex) => {
+      const d = minDistSqToEdge(edge, verts, x, y);
+      if (d <= bestD) {
+        bestD = d;
+        best = {
+          shapeIndex,
+          subIndex,
+          edgeIndex,
+          t: closestParamOnEdge(edge, verts, x, y),
+        };
+      }
+    });
+  });
+  return best;
+}
+
+/** Topmost shape (painter's order) with an edge body under (x, y), or null. */
+export function hitTestPathEdge(path, x, y, radiusPx = EDGE_HIT) {
+  const shapes = path?.shapes ?? [];
+  for (let i = shapes.length - 1; i >= 0; i--) {
+    const hit = hitTestShapeEdge(path, i, x, y, radiusPx);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+export function shapeFromPenDraft(points, { closed, activeKey }) {
+  const pts = points.map((p) => [p[0], p[1]]);
+  if (!pts.length) return null;
+  const start = pts[0];
+  const segs = [];
+  for (let i = 1; i < pts.length; i++) segs.push(straightSegment(pts[i]));
+  return {
+    fill: closed ? activeKey : null,
+    stroke: closed ? null : activeKey,
+    subpaths: [{ closed: !!closed, start, segs }],
+  };
+}
+
+/** Open single-subpath shape brush Pen mode can extend (in-file "live" stroke). */
+export function isOpenPenShape(shape) {
+  const subs = shape?.subpaths ?? [];
+  if (subs.length !== 1) return false;
+  return isOpenSubpath(subs[0]);
+}
+
+/** Any open subpath the pen can still extend — subpath 0 or a limb. */
+export function isOpenSubpath(sub) {
+  return !!sub && !sub.closed && subpathVertexCount(sub) >= 1;
+}
+
+/** Append a straight segment to an open subpath. */
+export function appendAnchorToSubpath(path, shapeIndex, subIndex, point) {
+  if (!isOpenSubpath(path?.shapes?.[shapeIndex]?.subpaths?.[subIndex])) return path;
+  return mapSubpath(path, shapeIndex, subIndex, (sub) => ({
+    closed: false,
+    start: [...sub.start],
+    segs: [...(sub.segs ?? []).map((s) => ({ ...s, to: [...s.to] })), straightSegment(point)],
+  }));
+}
+
+/**
+ * Root a new open subpath on a shape, at a point the shape already occupies.
+ *
+ * This is how a branch is made. The limb is a SIBLING of the shape's rings
+ * rather than an insertion into one, so the ring keeps its silhouette instead of
+ * being dragged out of shape to accommodate the spur — which is what went wrong
+ * the first time this was attempted. What ties the two together is the shared
+ * coordinate: withCoincidentAnchors makes the limb's root and the ring's vertex
+ * a single junction that drags as one.
+ *
+ * The shape's paint is left alone. A limb on a fill-only shape bakes to nothing
+ * until the creator gives the shape a stroke, but it is drawn in the overlay
+ * throughout, so this is a visible state rather than a silent one — and picking
+ * a stroke on their behalf would be the more surprising move.
+ */
+export function startLimbOnShape(path, shapeIndex, point) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || isPrimitiveShape(shape)) return null;
+  const subIndex = (shape.subpaths ?? []).length;
+  const next = mapShape(path, shapeIndex, (s) => ({
+    ...s,
+    subpaths: [
+      ...(s.subpaths ?? []),
+      { closed: false, start: [point[0], point[1]], segs: [] },
+    ],
+  }));
+  return { path: next, subIndex };
+}
+
+function cloneSeg(seg) {
+  const out = { to: [seg.to[0], seg.to[1]] };
+  if (seg.c1) out.c1 = [seg.c1[0], seg.c1[1]];
+  if (seg.c2) out.c2 = [seg.c2[0], seg.c2[1]];
+  return out;
+}
+
+/** Segments crossed walking a closed subpath forward from vertex `i` to `j`.
+ *  Goes through subpathEdgeFrom, so an implied closing edge materialises on the
+ *  way past instead of being skipped. */
+function loopRunSegments(loop, i, j) {
+  const n = subpathVertexCount(loop);
+  if (n < 2) return null;
+  const out = [];
+  for (let k = i; k !== j; k = (k + 1) % n) {
+    const edge = subpathEdgeFrom(loop, k);
+    if (!edge || out.length > n) return null;
+    out.push(cloneSeg(edge.seg));
+  }
+  return out;
+}
+
+/** The same run walked backwards. Both handles are already anchor-relative —
+ *  c1 to the previous anchor, c2 to its own — so reversal swaps them and needs
+ *  no arithmetic on the control points. */
+function reverseRun(start, segs) {
+  const pts = [start, ...segs.map((s) => s.to)];
+  const out = [];
+  for (let k = segs.length - 1; k >= 0; k--) {
+    const seg = { to: [pts[k][0], pts[k][1]] };
+    if (segs[k].c2) seg.c1 = [segs[k].c2[0], segs[k].c2[1]];
+    if (segs[k].c1) seg.c2 = [segs[k].c1[0], segs[k].c1[1]];
+    out.push(seg);
+  }
+  return out;
+}
+
+function subpathArea(sub) {
+  const poly = flattenSubpath(sub, 6);
+  let acc = 0;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    acc += (poly[j][0] + poly[i][0]) * (poly[j][1] - poly[i][1]);
+  }
+  return Math.abs(acc / 2);
+}
+
+/** The closed subpath carrying both of an open limb's endpoints, or -1. */
+export function loopSubIndexForLimb(shape, limbSubIndex) {
+  const subs = shape?.subpaths ?? [];
+  const limb = normalizeSubpath(subs[limbSubIndex]);
+  if (!limb || limb.closed) return -1;
+  const pts = subpathPoints(limb);
+  if (pts.length < 2) return -1;
+  const ends = [pts[0], pts[pts.length - 1]];
+  for (let i = 0; i < subs.length; i++) {
+    if (i === limbSubIndex) continue;
+    const sub = normalizeSubpath(subs[i]);
+    if (!sub?.closed) continue;
+    const loopPts = subpathPoints(sub);
+    if (ends.every((e) => loopPts.some((q) => pointsEqual(q, e)))) return i;
+  }
+  return -1;
+}
+
+/**
+ * Merge an open limb into the closed subpath it was drawn onto, replacing one
+ * of the two runs of that loop lying between the limb's endpoints. The result
+ * is a single closed subpath, which is what makes the stroke trace the new
+ * silhouette rather than painting the old boundary through the middle of it.
+ *
+ * Two runs connect those endpoints, so there are two possible results and the
+ * geometry alone cannot say which was meant. We keep the larger: a bulge drawn
+ * outward gets added, and a chord drawn across cuts off the smaller cap. The
+ * other reading is one undo away.
+ */
+function spliceParts(shape, loopSubIndex, limbSubIndex) {
+  const loop = normalizeSubpath(shape.subpaths[loopSubIndex]);
+  const limb = normalizeSubpath(shape.subpaths[limbSubIndex]);
+  const limbPts = subpathPoints(limb);
+  const loopPts = subpathPoints(loop);
+  const at = (p) => loopPts.findIndex((q) => pointsEqual(q, p));
+  const i = at(limbPts[0]);
+  const j = at(limbPts[limbPts.length - 1]);
+  // Both ends on the same vertex is a balloon hanging off the loop, not a
+  // splice — there is no run between them to replace.
+  if (i < 0 || j < 0 || i === j) return null;
+
+  const runToJ = loopRunSegments(loop, i, j);
+  const runToI = loopRunSegments(loop, j, i);
+  if (!runToJ || !runToI) return null;
+  return {
+    loopPts,
+    i,
+    j,
+    runToJ,
+    runToI,
+    limbStart: limbPts[0],
+    limbSegs: (limb.segs ?? []).map(cloneSeg),
+  };
+}
+
+/**
+ * Merge a run drawn from an outline back to itself into that outline. The
+ * gesture is ambiguous between reshaping the silhouette and drawing a line
+ * inside the shape, so it does both: the larger of the two closures becomes the
+ * new outline, and the run it displaced is kept as an open stroke rather than
+ * thrown away.
+ */
+export function spliceLimbIntoShape(path, shapeIndex, limbSubIndex) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || isPrimitiveShape(shape)) return null;
+  const loopSubIndex = loopSubIndexForLimb(shape, limbSubIndex);
+  if (loopSubIndex < 0) return null;
+  const parts = spliceParts(shape, loopSubIndex, limbSubIndex);
+  if (!parts) return null;
+  const { loopPts, i, j, runToJ, runToI, limbStart, limbSegs } = parts;
+
+  const start = [loopPts[i][0], loopPts[i][1]];
+  // Replacing one run leaves the limb joined to the other.
+  const keepRunToI = { closed: true, start, segs: [...limbSegs, ...runToI] };
+  const keepRunToJ = {
+    closed: true,
+    start,
+    segs: [...runToJ, ...reverseRun(limbStart, limbSegs)],
+  };
+  const keepingRunToI = subpathArea(keepRunToI) >= subpathArea(keepRunToJ);
+  const merged = keepingRunToI ? keepRunToI : keepRunToJ;
+
+  const spliced = (s) =>
+    (s.subpaths ?? [])
+      .map((sub, k) => (k === loopSubIndex ? normalizeSubpath(merged) : sub))
+      .filter((_, k) => k !== limbSubIndex);
+
+  // The displaced run is still a line that was drawn, so it is kept as an open
+  // stroked subpath. Open subpaths stroke without joining the fill, which is
+  // free where the run ends up interior to the fill and is a seam where it does
+  // not — a chord's bite comes out sealed shut by the edge it replaced.
+  const lost = keepingRunToI
+    ? { from: loopPts[i], segs: runToJ }
+    : { from: loopPts[j], segs: runToI };
+  const detail = {
+    closed: false,
+    start: [lost.from[0], lost.from[1]],
+    segs: lost.segs.map(cloneSeg),
+  };
+
+  return mapShape(path, shapeIndex, (s) => ({
+    ...s,
+    subpaths: spliced(s).concat([normalizeSubpath(detail)]),
+  }));
+}
+
+const handleOf = (h) => (h && Math.hypot(h[0], h[1]) > 1e-9 ? h : null);
+
+function segmentsMatch(a, b) {
+  if (!pointsEqual(a.to, b.to)) return false;
+  const pairs = [[handleOf(a.c1), handleOf(b.c1)], [handleOf(a.c2), handleOf(b.c2)]];
+  return pairs.every(([x, y]) => (x && y ? pointsEqual(x, y) : !x && !y));
+}
+
+function edgeList(sub) {
+  const out = [];
+  for (let e = 0; e < subpathEdgeCount(sub); e++) {
+    const edge = subpathEdgeFrom(sub, e);
+    if (!edge) return null;
+    out.push(edge);
+  }
+  return out;
+}
+
+function runMatchesAt(loopEdges, start, edges) {
+  return edges.every((want, k) => {
+    const got = loopEdges[(start + k) % loopEdges.length];
+    return pointsEqual(got.from, want.from) && segmentsMatch(got.seg, want.seg);
+  });
+}
+
+/** Whether a closed subpath walks the whole of `open`, either way round. */
+function outlineRetraces(loop, open) {
+  const loopEdges = edgeList(loop);
+  const edges = edgeList(open);
+  if (!loopEdges || !edges?.length || edges.length > loopEdges.length) return false;
+  const last = open.segs[open.segs.length - 1].to;
+  const back = edgeList({
+    closed: false,
+    start: [last[0], last[1]],
+    segs: reverseRun(open.start, open.segs),
+  });
+  for (let e = 0; e < loopEdges.length; e++) {
+    if (runMatchesAt(loopEdges, e, edges)) return true;
+    if (back && runMatchesAt(loopEdges, e, back)) return true;
+  }
+  return false;
+}
+
+/**
+ * Drop open subpaths that an outline already walks in full.
+ *
+ * This is the dual of splice. Splice lifts a run out of a loop and keeps it as
+ * an open subpath because it has become interior; this puts it back when the
+ * loop comes round to retrace it — after deleting the vertex that made it
+ * interior, say. Without the pair, splicing is a ratchet that accumulates edges
+ * drawn twice on top of each other.
+ *
+ * It leans on stroke colour being per-shape, so two coincident edges paint
+ * identically and nothing is lost by keeping one.
+ */
+export function absorbRetracedSubpaths(path) {
+  let changed = false;
+  const shapes = (path?.shapes ?? []).map((shape) => {
+    const subs = shape?.subpaths ?? [];
+    if (isPrimitiveShape(shape) || subs.length < 2) return shape;
+    const loops = subs.filter((s) => s?.closed).map(normalizeSubpath);
+    if (!loops.length) return shape;
+    const keep = subs.filter((sub) => {
+      if (sub?.closed) return true;
+      const open = normalizeSubpath(sub);
+      if (subpathVertexCount(open) < 2) return true;
+      if (!loops.some((loop) => outlineRetraces(loop, open))) return true;
+      changed = true;
+      return false;
+    });
+    return keep.length === subs.length ? shape : { ...shape, subpaths: keep };
+  });
+  return changed ? { shapes } : path;
+}
+
+/** Drop a subpath, and the shape with it when nothing is left. */
+export function removeSubpath(path, shapeIndex, subIndex) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape?.subpaths?.[subIndex]) return path;
+  const subpaths = shape.subpaths.filter((_, i) => i !== subIndex);
+  if (!subpaths.length) return removeShape(path, shapeIndex);
+  return mapShape(path, shapeIndex, (s) => ({ ...s, subpaths }));
+}
+
+export function appendShape(path, shape) {
+  return { shapes: [...(path?.shapes ?? []), shape] };
+}
+
+export function removeShape(path, shapeIndex) {
+  if (!path?.shapes || shapeIndex < 0 || shapeIndex >= path.shapes.length) return path;
+  return { shapes: path.shapes.filter((_, i) => i !== shapeIndex) };
+}
+
+export function moveShape(path, shapeIndex, delta) {
+  const shapes = path?.shapes ?? [];
+  if (shapeIndex < 0 || shapeIndex >= shapes.length || !delta) return path;
+  const next = shapeIndex + delta;
+  if (next < 0 || next >= shapes.length) return path;
+  const copy = shapes.slice();
+  const [item] = copy.splice(shapeIndex, 1);
+  copy.splice(next, 0, item);
+  return { shapes: copy };
+}
+
+export function setShapeFill(path, shapeIndex, key) {
+  return mapShape(path, shapeIndex, (shape) => ({ ...shape, fill: key }));
+}
+
+export function setShapeStroke(path, shapeIndex, key) {
+  return mapShape(path, shapeIndex, (shape) => ({ ...shape, stroke: key }));
+}
+
+function mapShape(path, shapeIndex, fn) {
+  const shapes = path?.shapes ?? [];
+  if (shapeIndex < 0 || shapeIndex >= shapes.length) return path;
+  return {
+    shapes: shapes.map((shape, i) => (i === shapeIndex ? fn(shape) : shape)),
+  };
+}
+
+/**
+ * The write funnel for one subpath, mirroring normalizeSubpath as the read
+ * funnel: edits see canonical input and their result is re-canonicalized, so an
+ * op that happens to produce a straight closing segment (straightening a bowed
+ * close, for one) does not leave a redundant one in editor state.
+ */
+function mapSubpath(path, shapeIndex, subIndex, fn) {
+  return mapShape(path, shapeIndex, (shape) => ({
+    ...shape,
+    subpaths: (shape.subpaths ?? []).map((sub, i) =>
+      i === subIndex ? normalizeSubpath(fn(normalizeSubpath(sub))) : sub
+    ),
+  }));
+}
+
+/**
+ * The runs of surviving edges, each of which becomes one open subpath.
+ *
+ * A closed subpath is walked starting just after a removed edge so a run that
+ * wraps past the end stays whole — otherwise cutting one edge out of a loop
+ * would come back as two pieces that happen to meet.
+ */
+function survivingEdgeRuns(sub, removed, count) {
+  const order = [];
+  if (sub.closed) {
+    const first = Math.min(...removed);
+    for (let k = 1; k <= count; k++) order.push((first + k) % count);
+  } else {
+    for (let e = 0; e < count; e++) order.push(e);
+  }
+  const runs = [];
+  let run = null;
+  for (const e of order) {
+    if (removed.has(e)) {
+      run = null;
+      continue;
+    }
+    if (!run) {
+      run = [];
+      runs.push(run);
+    }
+    run.push(e);
+  }
+  return runs;
+}
+
+/**
+ * Remove whole edges from a shape, as `[{ subIndex, edgeIndex }]`.
+ *
+ * There is no representation for a loop with a gap in it, so cutting an edge out
+ * of a closed subpath opens it: the survivors are rebuilt as an open subpath
+ * running from one side of the gap round to the other. Cutting from an open
+ * subpath splits it. Nothing is filled by an open subpath, so a shape that loses
+ * an outline edge stops filling until the loop is closed again — its colours are
+ * left alone so closing it back restores what it looked like.
+ */
+export function removeEdgesFromShape(path, shapeIndex, edges) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || !edges?.length || isPrimitiveShape(shape)) return path;
+  const bySub = new Map();
+  for (const { subIndex, edgeIndex } of edges) {
+    if (!bySub.has(subIndex)) bySub.set(subIndex, new Set());
+    bySub.get(subIndex).add(edgeIndex);
+  }
+  const subpaths = [];
+  (shape.subpaths ?? []).forEach((raw, subIndex) => {
+    const sub = normalizeSubpath(raw);
+    const removed = bySub.get(subIndex);
+    const count = subpathEdgeCount(sub);
+    if (!removed?.size || !count) {
+      subpaths.push(raw);
+      return;
+    }
+    for (const run of survivingEdgeRuns(sub, removed, count)) {
+      const first = subpathEdgeFrom(sub, run[0]);
+      if (!first) continue;
+      subpaths.push(
+        normalizeSubpath({
+          closed: false,
+          start: [first.from[0], first.from[1]],
+          segs: run.map((e) => cloneSeg(subpathEdgeFrom(sub, e).seg)),
+        })
+      );
+    }
+  });
+  if (!subpaths.length) return removeShape(path, shapeIndex);
+  return mapShape(path, shapeIndex, (s) => ({ ...s, subpaths }));
+}
+
+/**
+ * Turn an open subpath around, so the anchor it ends on becomes the one it
+ * starts from. The geometry is untouched — this rewrites storage order.
+ *
+ * The pen only ever grows a subpath from its tail, so picking one back up at
+ * the end the user actually clicked means walking it backwards first.
+ */
+export function reverseSubpath(path, shapeIndex, subIndex) {
+  return mapSubpath(path, shapeIndex, subIndex, (sub) => {
+    const segs = sub.segs ?? [];
+    if (sub.closed || !segs.length) return sub;
+    const last = segs[segs.length - 1].to;
+    return { closed: false, start: [last[0], last[1]], segs: reverseRun(sub.start, segs) };
+  });
+}
+
+/**
+ * The loose end of an open subpath near (x, y), as `{ subIndex, end }` where
+ * `end` is 'head' or 'tail'. Used to tell "carry on from here" apart from
+ * "start a limb here", which at a loose end would only stack a second anchor
+ * on top of the one already there.
+ */
+export function hitTestOpenEnd(path, shapeIndex, x, y, radius = 0.6) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || isPrimitiveShape(shape)) return null;
+  let best = null;
+  (shape.subpaths ?? []).forEach((raw, subIndex) => {
+    const sub = normalizeSubpath(raw);
+    if (sub.closed) return;
+    const pts = subpathPoints(sub);
+    if (pts.length < 2) return;
+    for (const [i, end] of [[0, 'head'], [pts.length - 1, 'tail']]) {
+      const dx = pts[i][0] - x;
+      const dy = pts[i][1] - y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist <= radius && (!best || dist < best.dist)) best = { subIndex, end, dist };
+    }
+  });
+  return best;
+}
+
+/** Phase-preserving (or Alt lattice) drag of one anchor. */
+export function applyAnchorDrag(path, anchorRef, start, dx, dy, halfPixel = false) {
+  if (!anchorRef || !start) return path;
+  return applyAnchorsDrag(
+    path,
+    anchorRef.shapeIndex,
+    [{ subIndex: anchorRef.subIndex, pointIndex: anchorRef.pointIndex }],
+    [start],
+    dx,
+    dy,
+    halfPixel
+  );
+}
+
+/**
+ * Where a primitive's centre was when the drag began, read back out of the
+ * anchor starts so this needs no extra bookkeeping at the call sites.
+ *
+ * The derived anchors are symmetric about the centre, so their mean is it. The
+ * mean carries rounding dust on the order of 1e-16; snapping clears it exactly,
+ * because a primitive's centre is always a lattice value to begin with.
+ */
+function primitiveCentreFromStarts(starts) {
+  const sum = starts.reduce((acc, s) => [acc[0] + s.start[0], acc[1] + s.start[1]], [0, 0]);
+  return [sum[0] / starts.length, sum[1] / starts.length];
+}
+
+/** Rigidly translate a shape, magnetizing the translation rather than its points. */
+export function applyShapeDrag(path, shapeIndex, pointStarts, dx, dy, halfPixel = false, cellPull = LATTICE / 2) {
+  if (!pointStarts?.length) return path;
+  const [sdx, sdy] = snapDragDelta(dx, dy, halfPixel, cellPull);
+  const target = path?.shapes?.[shapeIndex];
+  if (isPrimitiveShape(target)) {
+    // Same snapped delta as a subpath shape, so a mixed selection cannot drift
+    // apart: snapping the centre instead would move an ellipse by one amount
+    // and the paths beside it by another.
+    const [cx0, cy0] = primitiveCentreFromStarts(pointStarts);
+    return mapShape(path, shapeIndex, (shape) =>
+      deriveShape({ ...shape, cx: cx0 + sdx, cy: cy0 + sdy })
+    );
+  }
+  return mapShape(path, shapeIndex, (shape) => ({
+    ...shape,
+        subpaths: (shape.subpaths ?? []).map((sub, subIndex) => {
+          const norm = normalizeSubpath(sub);
+          const starts = pointStarts.filter((s) => s.subIndex === subIndex);
+          if (!starts.length) return norm;
+      const byPoint = new Map(starts.map((s) => [s.pointIndex, s.start]));
+      const segsIn = norm.segs ?? [];
+      const closingIndex = subpathClosesOnStart(norm) ? segsIn.length - 1 : -1;
+      const newStart = byPoint.has(0)
+        ? [byPoint.get(0)[0] + sdx, byPoint.get(0)[1] + sdy]
+        : [...norm.start];
+      const newSegs = segsIn.map((seg, segIndex) => {
+        const vertIndex = segIndex === closingIndex ? 0 : segIndex + 1;
+        const move = byPoint.get(vertIndex);
+        const to = move
+          ? [move[0] + sdx, move[1] + sdy]
+          : [...seg.to];
+        return { ...seg, to, c1: seg.c1 ? [...seg.c1] : undefined, c2: seg.c2 ? [...seg.c2] : undefined };
+      });
+      return { ...sub, start: newStart, segs: newSegs };
+    }),
+  }));
+}
+
+export function collectShapePointStarts(path, shapeIndex) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape) return [];
+  const out = [];
+  (shape.subpaths ?? []).forEach((sub, subIndex) => {
+    subpathPoints(sub).forEach((p, pointIndex) => {
+      out.push({ subIndex, pointIndex, start: [p[0], p[1]] });
+    });
+  });
+  return out;
+}
+
+export function bowFromPointer(pa, pb, x, y) {
+  const dx = pb[0] - pa[0];
+  const dy = pb[1] - pa[1];
+  const L = Math.hypot(dx, dy);
+  if (L < 1e-12) return 0;
+  const nx = -dy / L;
+  const ny = dx / L;
+  const mx = (pa[0] + pb[0]) / 2;
+  const my = (pa[1] + pb[1]) / 2;
+  return (x - mx) * nx + (y - my) * ny;
+}
+
+function endpointsForEdge(path, shapeIndex, subIndex, edgeIndex) {
+  const sub = path?.shapes?.[shapeIndex]?.subpaths?.[subIndex];
+  if (!sub) return null;
+  const edge = subpathEdgeFrom(sub, edgeIndex);
+  if (!edge) return null;
+  return { pa: edge.from, pb: edge.seg.to, sub, edge };
+}
+
+/** Ratio-detented circular-arc bend (default, non-Alt). */
+export function applyEdgeBow(path, shapeIndex, subIndex, edgeIndex, x, y) {
+  const ends = endpointsForEdge(path, shapeIndex, subIndex, edgeIndex);
+  if (!ends) return path;
+  const { pa, pb } = ends;
+  const L = Math.hypot(pb[0] - pa[0], pb[1] - pa[1]);
+  const bow = snapBow(bowFromPointer(pa, pb, x, y), L);
+  return setEdgeBow(path, shapeIndex, subIndex, edgeIndex, bow);
+}
+
+export function setEdgeBow(path, shapeIndex, subIndex, edgeIndex, bow) {
+  return mapSubpath(path, shapeIndex, subIndex, (sub) => {
+    const norm = normalizeSubpath(sub);
+    const edge = subpathEdgeFrom(norm, edgeIndex);
+    if (!edge) return sub;
+    const newParts = bowToSegments(edge.from, edge.seg.to, bow);
+    // Splicing at segs.length materializes an implied closing edge: nothing is
+    // removed and the bowed parts land at the end, ending on `start`. A bow of
+    // zero produces a straight one, which canonicalization then re-implies.
+    const segs = [...(norm.segs ?? [])];
+    segs.splice(edgeIndex, 1, ...newParts);
+    return { ...norm, segs };
+  });
+}
+
+export function hitTestFillToolTarget(path, x, y) {
+  const shapes = path?.shapes ?? [];
+  for (let i = shapes.length - 1; i >= 0; i--) {
+    const shape = shapes[i];
+    if (nearStrokedOutline(shape, x, y)) return { shapeIndex: i, slot: 'stroke' };
+    if (shape.fill && shapeContainsPoint(shape, x, y)) return { shapeIndex: i, slot: 'fill' };
+  }
+  return null;
+}
+
+export function recolorTopShapeAt(path, x, y, key) {
+  const target = hitTestFillToolTarget(path, x, y);
+  if (!target) return path;
+  return target.slot === 'fill'
+    ? setShapeFill(path, target.shapeIndex, key)
+    : setShapeStroke(path, target.shapeIndex, key);
+}
+
+function cloneShape(shape) {
+  return clonePathData({ shapes: [shape] }).shapes[0];
+}
+
+function translateShape(shape, dx, dy) {
+  return translatePathData({ shapes: [shape] }, dx, dy).shapes[0];
+}
+
+/** True when a shape's fill coverage or stroke cells intersect an axis-aligned cell rect. */
+export function shapeIntersectsRect(shape, rect) {
+  if (!shape || !rect || rect.w <= 0 || rect.h <= 0) return false;
+  const x0 = rect.x;
+  const y0 = rect.y;
+  const x1 = rect.x + rect.w;
+  const y1 = rect.y + rect.h;
+  const inRect = (x, y) => x >= x0 && x < x1 && y >= y0 && y < y1;
+  // Anchors / lattice points that land in or on the box (touch counts).
+  for (const sub of shape.subpaths ?? []) {
+    for (const p of subpathPoints(sub)) {
+      if (p[0] >= x0 && p[0] <= x1 && p[1] >= y0 && p[1] <= y1) return true;
+    }
+  }
+  if (shape.fill) {
+    for (let y = Math.floor(y0); y < y1; y++) {
+      for (let x = Math.floor(x0); x < x1; x++) {
+        if (shapeContainsPoint(shape, x + 0.5, y + 0.5)) return true;
+      }
+    }
+    // Small marquee entirely inside a large fill.
+    const samples = [
+      [x0, y0],
+      [x1, y0],
+      [x0, y1],
+      [x1, y1],
+      [(x0 + x1) / 2, (y0 + y1) / 2],
+    ];
+    for (const [sx, sy] of samples) {
+      if (shapeContainsPoint(shape, sx, sy)) return true;
+    }
+  }
+  if (shape.stroke) {
+    for (const sub of shape.subpaths ?? []) {
+      const { verts, edges } = edgeObjectsForSubpath(sub, shape.stroke);
+      for (const edge of edges) {
+        for (const s of sampleEdgeCurve(edge, verts)) {
+          if (inRect(s.x, s.y)) return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+export function hitTestShapesInRect(path, rect) {
+  const out = [];
+  (path?.shapes ?? []).forEach((shape, i) => {
+    if (shapeIntersectsRect(shape, rect)) out.push(i);
+  });
+  return out;
+}
+
+/** True when an anchor's lattice point lies inside or on an axis-aligned cell rect. */
+function anchorInRect(x, y, rect) {
+  if (!rect || rect.w <= 0 || rect.h <= 0) return false;
+  const x0 = rect.x;
+  const y0 = rect.y;
+  const x1 = rect.x + rect.w;
+  const y1 = rect.y + rect.h;
+  return x >= x0 && x <= x1 && y >= y0 && y <= y1;
+}
+
+/** Anchors on one shape whose points fall inside `rect` (inclusive edges). */
+export function hitTestAnchorsInRect(path, shapeIndex, rect) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || !rect || rect.w <= 0 || rect.h <= 0) return [];
+  // A marquee over an ellipse would otherwise catch several axis handles at
+  // once, and a radius drag only has one radius to set.
+  if (isPrimitiveShape(shape)) return [];
+  const out = [];
+  (shape.subpaths ?? []).forEach((sub, subIndex) => {
+    subpathPoints(sub).forEach((p, pointIndex) => {
+      if (anchorInRect(p[0], p[1], rect)) out.push({ subIndex, pointIndex });
+    });
+  });
+  return out;
+}
+
+/** Translate several shapes; each anchor keeps its own phase unless halfPixel. */
+export function applyShapesDrag(path, shapeIndices, pointStarts, dx, dy, halfPixel = false, cellPull = LATTICE / 2) {
+  if (!shapeIndices?.length || !pointStarts?.length) return path;
+  let next = path;
+  for (const shapeIndex of shapeIndices) {
+    const starts = pointStarts.filter((s) => s.shapeIndex === shapeIndex);
+    next = applyShapeDrag(next, shapeIndex, starts, dx, dy, halfPixel, cellPull);
+  }
+  return next;
+}
+
+export function collectShapesPointStarts(path, shapeIndices) {
+  const out = [];
+  for (const shapeIndex of shapeIndices ?? []) {
+    for (const s of collectShapePointStarts(path, shapeIndex)) {
+      out.push({ shapeIndex, ...s });
+    }
+  }
+  return out;
+}
+
+/**
+ * Drag an axis handle to resize. Only the axis the handle sits on responds, so
+ * the ellipse never shears or drifts out from under the gesture.
+ *
+ * By default the opposite edge holds still, as it does in Figma and
+ * Illustrator; Alt resizes about the centre instead, mirroring the drag. The
+ * two are not equivalent under the lattice, and the difference is felt rather
+ * than seen: a radius can only be a half-cell multiple, so the width always
+ * moves in whole cells. Anchoring the far edge spends that whole cell at the
+ * handle, which therefore jumps a full cell at a time; mirroring splits it
+ * across both sides, so the handle tracks the pointer twice as finely.
+ */
+function dragPrimitiveHandle(path, shapeIndex, anchors, starts, dx, dy, aboutCentre, cellPull = LATTICE / 2) {
+  const shape = path.shapes[shapeIndex];
+  const handles = primitiveHandleIndices(shape);
+  const anchor = anchors.find((a) => handles.includes(a.pointIndex));
+  const start = starts[anchors.indexOf(anchor)];
+  if (!anchor || !start) return path;
+
+  const vertical = handles.indexOf(anchor.pointIndex) % 2 === 1;
+  const axis = vertical ? 1 : 0;
+  const centre = vertical ? shape.cy : shape.cx;
+  const pointer = start[axis] + (vertical ? dy : dx);
+  const radiusKey = vertical ? 'ry' : 'rx';
+  const centreKey = vertical ? 'cy' : 'cx';
+
+  if (aboutCentre) {
+    const raw = Math.abs(pointer - centre);
+    const [snapped] = magneticSnapPoint(raw, 0, cellPull, true);
+    const radius = Math.max(MIN_ELLIPSE_RADIUS, snapped);
+    return mapShape(path, shapeIndex, (s) => deriveShape({ ...s, [radiusKey]: radius }));
+  }
+
+  const far = 2 * centre - start[axis];
+  const raw = Math.abs(pointer - far) / 2;
+  const [snapped] = magneticSnapPoint(raw, 0, cellPull, true);
+  const radius = Math.max(MIN_ELLIPSE_RADIUS, snapped);
+  const dir = Math.sign(pointer - far) || Math.sign(start[axis] - far) || 1;
+  const newCentre = far + dir * radius;
+  const [snappedCentre] = magneticSnapPoint(newCentre, 0, cellPull, true);
+  return mapShape(path, shapeIndex, (s) =>
+    deriveShape({ ...s, [radiusKey]: radius, [centreKey]: snappedCentre })
+  );
+}
+
+export function applyAnchorsDrag(
+  path,
+  shapeIndex,
+  anchors,
+  starts,
+  dx,
+  dy,
+  halfPixel = false,
+  cellPull = LATTICE / 2
+) {
+  if (shapeIndex == null || !anchors?.length || !starts?.length) return path;
+  if (isPrimitiveShape(path?.shapes?.[shapeIndex])) {
+    return dragPrimitiveHandle(path, shapeIndex, anchors, starts, dx, dy, halfPixel, cellPull);
+  }
+  const bySub = new Map();
+  anchors.forEach((anchor, i) => {
+    const start = starts[i];
+    if (!start) return;
+    if (!bySub.has(anchor.subIndex)) bySub.set(anchor.subIndex, []);
+    bySub.get(anchor.subIndex).push({ pointIndex: anchor.pointIndex, start });
+  });
+  // One site (an anchor, or a junction whose members share a coordinate) is
+  // being placed, so magnetize where it lands. Several distinct sites are being
+  // carried, so magnetize the delta and move them rigidly — otherwise the
+  // selection deforms, since points at different sub-cell phases snap by
+  // different amounts.
+  const siteCount = new Set(starts.filter(Boolean).map((s) => `${s[0]},${s[1]}`)).size;
+  const rigid = siteCount > 1;
+  const [sdx, sdy] = rigid ? snapDragDelta(dx, dy, halfPixel, cellPull) : [dx, dy];
+  const place = (p) =>
+    rigid ? [p[0] + sdx, p[1] + sdy] : snapDragPoint(p[0] + dx, p[1] + dy, halfPixel, cellPull);
+
+  let next = path;
+  for (const [subIndex, dragMoves] of bySub) {
+    next = mapSubpath(next, shapeIndex, subIndex, (sub) => {
+      const moved = new Map(dragMoves.map((m) => [m.pointIndex, m.start]));
+      const norm = normalizeSubpath(sub);
+      const segsIn = norm.segs ?? [];
+      const closingIndex = subpathClosesOnStart(norm) ? segsIn.length - 1 : -1;
+      const newStart = moved.has(0) ? place(moved.get(0)) : [...norm.start];
+      const newSegs = segsIn.map((seg, segIndex) => {
+        const vertIndex = segIndex === closingIndex ? 0 : segIndex + 1;
+        const start = moved.get(vertIndex);
+        const to = start ? place(start) : [...seg.to];
+        return {
+          ...seg,
+          to,
+          c1: seg.c1 ? [seg.c1[0], seg.c1[1]] : undefined,
+          c2: seg.c2 ? [seg.c2[0], seg.c2[1]] : undefined,
+        };
+      });
+      return { ...norm, start: newStart, segs: newSegs };
+    });
+  }
+  return next;
+}
+
+function siteKey(p) {
+  return p ? `${p[0]},${p[1]}` : null;
+}
+
+function eachShapePoint(shape, visit) {
+  (shape?.subpaths ?? []).forEach((sub, subIndex) => {
+    subpathPoints(sub).forEach((p, pointIndex) => visit(p, subIndex, pointIndex));
+  });
+}
+
+/**
+ * Sites carrying two or more of the shape's points — its junctions. The overlay
+ * draws these apart from ordinary anchors, because a join whose only evidence is
+ * geometry moving unexpectedly is a join discovered the wrong way round.
+ */
+export function coincidentSiteKeys(shape) {
+  const out = new Set();
+  if (!shape || isPrimitiveShape(shape)) return out;
+  const counts = new Map();
+  eachShapePoint(shape, (p) => {
+    const key = siteKey(p);
+    if (key) counts.set(key, (counts.get(key) ?? 0) + 1);
+  });
+  for (const [key, n] of counts) if (n > 1) out.add(key);
+  return out;
+}
+
+/**
+ * Grow an anchor selection to every point sharing its lattice site, so a
+ * junction drags as one. This is what keeps an open limb attached to the ring it
+ * was drawn onto: the two subpaths hold the same coordinate, and moving either
+ * end brings the other with it.
+ *
+ * The lattice is what makes this honest rather than fuzzy. Coincidence is exact,
+ * so a junction either exists or it does not — there is no tolerance to tune and
+ * no near-miss to arbitrate. The same manufactured coincidence that made welding
+ * hazardous is what makes joining unambiguous here, and unlike a weld this is
+ * only a drag, so an accident costs one undo rather than a change of topology.
+ *
+ * Scoped within one shape, as Figma scopes its merges. Shapes stacked in
+ * painter's order line up by coincidence constantly, and reaching across them
+ * would fuse art that merely happens to touch.
+ */
+function anchorSites(shape, anchors) {
+  const subpaths = shape.subpaths ?? [];
+  const sites = new Set();
+  for (const a of anchors) {
+    const key = siteKey(subpathPointAt(subpaths[a.subIndex], a.pointIndex));
+    if (key) sites.add(key);
+  }
+  return sites;
+}
+
+export function withCoincidentAnchors(path, shapeIndex, anchors) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || !anchors?.length || isPrimitiveShape(shape)) return anchors ?? [];
+  const sites = anchorSites(shape, anchors);
+  if (!sites.size) return anchors;
+  const out = anchors.slice();
+  const seen = new Set(anchors.map((a) => `${a.subIndex}:${a.pointIndex}`));
+  eachShapePoint(shape, (p, subIndex, pointIndex) => {
+    const id = `${subIndex}:${pointIndex}`;
+    if (seen.has(id) || !sites.has(siteKey(p))) return;
+    seen.add(id);
+    out.push({ subIndex, pointIndex });
+  });
+  return out;
+}
+
+export function collectAnchorStarts(path, shapeIndex, anchors) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape || !anchors?.length) return [];
+  return anchors.map((a) => {
+    const p = subpathPointAt(shape.subpaths?.[a.subIndex], a.pointIndex);
+    return p ? [p[0], p[1]] : null;
+  });
+}
+
+function subpathViable(sub) {
+  const n = subpathVertexCount(sub);
+  if (sub.closed) {
+    if (n >= 3) return true;
+    if (n === 2) {
+      const edge = subpathEdgeFrom(sub, 0);
+      return edge && Math.abs(bowForSegment(edge.from, edge.seg)) > 1e-12;
+    }
+    return false;
+  }
+  return n >= 2;
+}
+
+function removeVertexFromSubpath(sub, pointIndex) {
+  const norm = normalizeSubpath(sub);
+  const verts = subpathPoints(norm);
+  // Under implicit closure a closed subpath has one fewer segment than vertex,
+  // so segs[n - 1] is absent and the rebuilt closing edge falls through to
+  // straightSegment — which is what an implied close is.
+  const segs = norm.segs ?? [];
+  const closed = !!norm.closed;
+  const n = verts.length;
+  if (pointIndex < 0 || pointIndex >= n) return sub;
+
+  if (!closed && pointIndex === 0) {
+    if (!segs.length) return null;
+    return { closed: false, start: [...segs[0].to], segs: segs.slice(1).map((s) => ({ ...s, to: [...s.to], c1: s.c1 ? [...s.c1] : undefined, c2: s.c2 ? [...s.c2] : undefined })) };
+  }
+  if (!closed && pointIndex === n - 1) {
+    return { closed: false, start: [...norm.start], segs: segs.slice(0, -1).map((s) => ({ ...s, to: [...s.to] })) };
+  }
+
+  const keptIndices = verts.map((_, i) => i).filter((i) => i !== pointIndex);
+  const newVerts = keptIndices.map((i) => verts[i]);
+  const newStart = [newVerts[0][0], newVerts[0][1]];
+  const newN = newVerts.length;
+  const edgeCount = closed ? newN : Math.max(0, newN - 1);
+  const newSegs = [];
+
+  for (let e = 0; e < edgeCount; e++) {
+    const to = newVerts[(e + 1) % newN];
+    const oldFromIdx = keptIndices[e];
+    const oldToIdx = keptIndices[(e + 1) % newN];
+    const consecutive =
+      oldToIdx === oldFromIdx + 1 || (closed && oldFromIdx === n - 1 && oldToIdx === 0);
+    const touchesRemoved = oldFromIdx === pointIndex || oldToIdx === pointIndex;
+    if (consecutive && !touchesRemoved && segs[oldFromIdx]) {
+      newSegs.push({ ...segs[oldFromIdx], to: [to[0], to[1]] });
+    } else {
+      newSegs.push(straightSegment(to));
+    }
+  }
+  return { closed, start: newStart, segs: newSegs };
+}
+
+/** Remove one anchor; merged edges become straight. May drop subpath/shape. */
+export function removeAnchorFromShape(path, shapeIndex, subIndex, pointIndex) {
+  const shape = path?.shapes?.[shapeIndex];
+  const sub = shape?.subpaths?.[subIndex];
+  if (!sub) return path;
+  if (isPrimitiveShape(shape)) return path;
+  const nextSub = removeVertexFromSubpath(sub, pointIndex);
+  if (!nextSub || !subpathViable(nextSub)) {
+    const subpaths = (shape.subpaths ?? []).filter((_, i) => i !== subIndex);
+    if (!subpaths.length) return removeShape(path, shapeIndex);
+    return mapShape(path, shapeIndex, (s) => ({ ...s, subpaths }));
+  }
+  return mapSubpath(path, shapeIndex, subIndex, () => nextSub);
+}
+
+/**
+ * Survivor to select for a deleted index (Figma frontier rule):
+ * - Isolated delete (both neighbors remain): prefer the forward neighbor.
+ * - Run endpoint (only one neighbor remains): take that neighbor.
+ * - Run interior (both neighbors also deleted): skip.
+ * - Open-path endpoint whose only side is deleted: walk out of the run.
+ */
+function nextSurvivorIndex(n, closed, deleted, fromIndex) {
+  if (n <= 0 || fromIndex < 0 || fromIndex >= n) return null;
+  const prev = closed ? (fromIndex - 1 + n) % n : fromIndex - 1;
+  const next = closed ? (fromIndex + 1) % n : fromIndex + 1;
+  const prevOk = (closed || prev >= 0) && !deleted.has(prev);
+  const nextOk = (closed || next < n) && !deleted.has(next);
+
+  if (prevOk && nextOk) return next;
+  if (nextOk) return next;
+  if (prevOk) return prev;
+
+  // Open path: deleted run includes an endpoint — walk out the only way.
+  if (!closed && fromIndex === 0) {
+    for (let j = 1; j < n; j++) if (!deleted.has(j)) return j;
+    return null;
+  }
+  if (!closed && fromIndex === n - 1) {
+    for (let j = n - 2; j >= 0; j--) if (!deleted.has(j)) return j;
+    return null;
+  }
+  return null;
+}
+
+function subpathSurvivesDeletion(sub, deletedSet) {
+  if (!deletedSet.size) return subpathViable(sub);
+  let probe = {
+    shapes: [{ fill: 'x', stroke: null, subpaths: [cloneSubpath(sub)] }],
+  };
+  for (const pi of [...deletedSet].sort((a, b) => b - a)) {
+    probe = removeAnchorFromShape(probe, 0, 0, pi);
+    if (!probe?.shapes?.[0]?.subpaths?.[0]) return false;
+  }
+  return true;
+}
+
+/**
+ * Figma-style selection advance: each deleted anchor votes for a frontier
+ * survivor (see nextSurvivorIndex); remap to post-delete indices; dedupe.
+ * Empty when the shape (or every touched subpath) disappears.
+ */
+export function advanceAnchorsAfterRemoval(path, shapeIndex, anchors) {
+  const shape = path?.shapes?.[shapeIndex];
+  if (!shape?.subpaths?.length || !anchors?.length) return [];
+
+  const bySub = new Map();
+  for (const a of anchors) {
+    if (typeof a?.subIndex !== 'number' || typeof a?.pointIndex !== 'number') continue;
+    if (!bySub.has(a.subIndex)) bySub.set(a.subIndex, new Set());
+    bySub.get(a.subIndex).add(a.pointIndex);
+  }
+  if (!bySub.size) return [];
+
+  const oldToNewSub = new Map();
+  let newSub = 0;
+  for (let s = 0; s < shape.subpaths.length; s++) {
+    const deleted = bySub.get(s) ?? new Set();
+    if (subpathSurvivesDeletion(shape.subpaths[s], deleted)) {
+      oldToNewSub.set(s, newSub);
+      newSub += 1;
+    }
+  }
+  if (!oldToNewSub.size) return [];
+
+  const out = [];
+  const seen = new Set();
+  for (const [subIndex, deleted] of bySub) {
+    if (!oldToNewSub.has(subIndex)) continue;
+    const n = subpathVertexCount(shape.subpaths[subIndex]);
+    const closed = !!shape.subpaths[subIndex]?.closed;
+    const newSubIndex = oldToNewSub.get(subIndex);
+    for (const i of deleted) {
+      if (i < 0 || i >= n) continue;
+      const surv = nextSurvivorIndex(n, closed, deleted, i);
+      if (surv == null) continue;
+      let below = 0;
+      for (const d of deleted) if (d < surv) below += 1;
+      const pointIndex = surv - below;
+      const key = `${newSubIndex}:${pointIndex}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ subIndex: newSubIndex, pointIndex });
+    }
+  }
+  out.sort((a, b) => a.subIndex - b.subIndex || a.pointIndex - b.pointIndex);
+  return out;
+}
+
+/**
+ * Remove several anchors from one shape. Refs are {subIndex, pointIndex};
+ * processed high-index-first within each subpath so indices stay valid.
+ * Returns `{ path, anchors }` where `anchors` is the Figma-style advanced
+ * selection (empty if the shape was removed).
+ */
+export function removeAnchorsFromShape(path, shapeIndex, anchors) {
+  if (!anchors?.length) return { path, anchors: [] };
+  // A junction is every anchor sharing a site, which is already how dragging
+  // treats it. Deleting has to agree, or a subpath is left hanging off a vertex
+  // the outline no longer has.
+  const targets = withCoincidentAnchors(path, shapeIndex, anchors);
+  const nextAnchors = advanceAnchorsAfterRemoval(path, shapeIndex, targets);
+  const bySub = new Map();
+  for (const a of targets) {
+    if (!bySub.has(a.subIndex)) bySub.set(a.subIndex, []);
+    bySub.get(a.subIndex).push(a.pointIndex);
+  }
+  let next = path;
+  // Higher subpaths first so subpath deletion doesn't shift lower indices wrongly
+  // when an entire subpath vanishes — still process one sub at a time.
+  const subIndexes = [...bySub.keys()].sort((a, b) => b - a);
+  for (const subIndex of subIndexes) {
+    const points = bySub.get(subIndex).slice().sort((a, b) => b - a);
+    for (const pointIndex of points) {
+      // Re-resolve: shape may have shrunk; skip if gone.
+      if (!next?.shapes?.[shapeIndex]?.subpaths?.[subIndex]) break;
+      const n = subpathVertexCount(next.shapes[shapeIndex].subpaths[subIndex]);
+      if (pointIndex >= n) continue;
+      next = removeAnchorFromShape(next, shapeIndex, subIndex, pointIndex);
+      // If the shape itself was removed, stop.
+      if (!next?.shapes?.[shapeIndex]) return { path: next, anchors: [] };
+    }
+  }
+  // Keep only anchors that still resolve (belt-and-suspenders vs. advance plan).
+  const shape = next?.shapes?.[shapeIndex];
+  const valid = nextAnchors.filter((a) => {
+    const pts = shape?.subpaths?.[a.subIndex] ? subpathPoints(shape.subpaths[a.subIndex]) : null;
+    return !!pts && a.pointIndex >= 0 && a.pointIndex < pts.length;
+  });
+  return { path: next, anchors: valid };
+}
+
+export function removeShapes(path, shapeIndices) {
+  if (!shapeIndices?.length) return path;
+  const drop = new Set(shapeIndices);
+  return { shapes: (path?.shapes ?? []).filter((_, i) => !drop.has(i)) };
+}
+
+// ---------------------------------------------------------------------------
+// Punch Hole (multi-shape → multi-subpath even-odd)
+// ---------------------------------------------------------------------------
+// Extract / un-punch (pull a hole subpath back out as its own shape) is
+// deferred — undo covers the immediate reverse.
+
+const PUNCH_SAMPLE_SPACING = 0.25;
+
+/** Densify a flattened polyline to ~spacing cell steps along each segment. */
+function densifyPolyline(poly, spacing = PUNCH_SAMPLE_SPACING) {
+  if (!poly?.length) return [];
+  if (poly.length === 1) return [[poly[0][0], poly[0][1]]];
+  const out = [];
+  const push = (x, y) => {
+    const last = out[out.length - 1];
+    if (last && Math.abs(last[0] - x) < 1e-12 && Math.abs(last[1] - y) < 1e-12) return;
+    out.push([x, y]);
+  };
+  push(poly[0][0], poly[0][1]);
+  for (let i = 1; i < poly.length; i++) {
+    const [x0, y0] = poly[i - 1];
+    const [x1, y1] = poly[i];
+    const len = Math.hypot(x1 - x0, y1 - y0);
+    if (len < 1e-12) continue;
+    const steps = Math.max(1, Math.ceil(len / spacing));
+    for (let s = 1; s <= steps; s++) {
+      const t = s / steps;
+      push(x0 + (x1 - x0) * t, y0 + (y1 - y0) * t);
+    }
+  }
+  return out;
+}
+
+/** Dense outline samples (~0.25-cell) for one subpath (cubics flattened). */
+export function sampleSubpathOutline(sub, spacing = PUNCH_SAMPLE_SPACING) {
+  const stepsPerUnit = Math.max(4, Math.ceil(1 / spacing));
+  return densifyPolyline(flattenSubpath(sub, stepsPerUnit), spacing);
+}
+
+/**
+ * True when every dense outline sample of `inner` lies in `outer`'s even-odd
+ * filled region (shapeContainsPoint). Open inner subpaths → false.
+ */
+export function shapeOutlineContained(outer, inner, spacing = PUNCH_SAMPLE_SPACING) {
+  if (!outer || !inner) return false;
+  const subs = inner.subpaths ?? [];
+  if (!subs.length) return false;
+  for (const sub of subs) {
+    if (!sub.closed) return false;
+    const samples = sampleSubpathOutline(sub, spacing);
+    if (!samples.length) return false;
+    for (const [x, y] of samples) {
+      if (!shapeContainsPoint(outer, x, y)) return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Geometry-derived punch roles for a multi-selection, or null when the action
+ * does not qualify. Exactly one selected shape must strictly contain every
+ * other (inners); all inner subpaths must be closed.
+ */
+export function punchHoleRoles(path, shapeIndices) {
+  const idxs = [...new Set(shapeIndices ?? [])];
+  if (idxs.length < 2) return null;
+  const shapes = path?.shapes ?? [];
+  for (const i of idxs) {
+    if (!shapes[i]) return null;
+    // Punching merges rings into one shape, which a primitive cannot hold — it
+    // owns a single derived ring and would overwrite the result.
+    if (isPrimitiveShape(shapes[i])) return null;
+  }
+  let found = null;
+  for (const outerIndex of idxs) {
+    const outer = shapes[outerIndex];
+    const innerIndices = idxs.filter((i) => i !== outerIndex);
+    let ok = true;
+    for (const ii of innerIndices) {
+      const inner = shapes[ii];
+      const subs = inner.subpaths ?? [];
+      if (!subs.length || subs.some((s) => !s.closed)) {
+        ok = false;
+        break;
+      }
+      if (!shapeOutlineContained(outer, inner)) {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) continue;
+    if (found != null) return null; // more than one candidate outer
+    found = { outerIndex, innerIndices: innerIndices.slice().sort((a, b) => a - b) };
+  }
+  return found;
+}
+
+export function canPunchHole(path, shapeIndices) {
+  return punchHoleRoles(path, shapeIndices) != null;
+}
+
+/**
+ * Move every inner shape's subpaths into the outer (discarding inner fill/
+ * stroke). Inners are removed; outer keeps stack position. Returns
+ * `{ path, outerIndex }` or null when the selection does not qualify.
+ */
+export function punchHole(path, shapeIndices) {
+  const roles = punchHoleRoles(path, shapeIndices);
+  if (!roles) return null;
+  const { outerIndex, innerIndices } = roles;
+  const shapes = path?.shapes ?? [];
+  const outer = shapes[outerIndex];
+  const holeSubs = [];
+  for (const ii of innerIndices) {
+    for (const sub of shapes[ii].subpaths ?? []) {
+      holeSubs.push(cloneSubpath(sub));
+    }
+  }
+  const punched = {
+    ...outer,
+    fill: outer.fill ?? null,
+    stroke: outer.stroke ?? null,
+    subpaths: [...(outer.subpaths ?? []).map(cloneSubpath), ...holeSubs],
+  };
+  const drop = new Set(innerIndices);
+  const nextShapes = [];
+  let nextOuterIndex = -1;
+  shapes.forEach((shape, i) => {
+    if (drop.has(i)) return;
+    if (i === outerIndex) {
+      nextOuterIndex = nextShapes.length;
+      nextShapes.push(punched);
+    } else {
+      nextShapes.push(shape);
+    }
+  });
+  return { path: { shapes: nextShapes }, outerIndex: nextOuterIndex };
+}
+
+/**
+ * Step selected shapes one slot forward (]) preserving relative order:
+ * topmost-selected down, swap each with its unselected neighbor above.
+ */
+export function bringShapesForward(path, shapeIndices) {
+  const shapes = (path?.shapes ?? []).slice();
+  const selected = new Set(shapeIndices ?? []);
+  if (!selected.size) return { path, indices: [] };
+  for (let i = shapes.length - 1; i >= 0; i--) {
+    if (!selected.has(i) || i >= shapes.length - 1 || selected.has(i + 1)) continue;
+    const tmp = shapes[i];
+    shapes[i] = shapes[i + 1];
+    shapes[i + 1] = tmp;
+    selected.delete(i);
+    selected.add(i + 1);
+  }
+  return { path: { shapes }, indices: [...selected].sort((a, b) => a - b) };
+}
+
+/** Step selected shapes one slot backward ([) — bottommost-selected up. */
+export function sendShapesBackward(path, shapeIndices) {
+  const shapes = (path?.shapes ?? []).slice();
+  const selected = new Set(shapeIndices ?? []);
+  if (!selected.size) return { path, indices: [] };
+  for (let i = 0; i < shapes.length; i++) {
+    if (!selected.has(i) || i <= 0 || selected.has(i - 1)) continue;
+    const tmp = shapes[i];
+    shapes[i] = shapes[i - 1];
+    shapes[i - 1] = tmp;
+    selected.delete(i);
+    selected.add(i - 1);
+  }
+  return { path: { shapes }, indices: [...selected].sort((a, b) => a - b) };
+}
+
+export function canBringShapesForward(path, shapeIndices) {
+  const sel = new Set(shapeIndices ?? []);
+  const n = path?.shapes?.length ?? 0;
+  for (let i = n - 1; i >= 0; i--) {
+    if (sel.has(i) && i < n - 1 && !sel.has(i + 1)) return true;
+  }
+  return false;
+}
+
+export function canSendShapesBackward(path, shapeIndices) {
+  const sel = new Set(shapeIndices ?? []);
+  for (let i = 0; i < (path?.shapes?.length ?? 0); i++) {
+    if (sel.has(i) && i > 0 && !sel.has(i - 1)) return true;
+  }
+  return false;
+}
+
+/** Deep-copy selected shapes to the top of the stack, offset +1,+1 cell. */
+export function duplicateShapes(path, shapeIndices, dx = 1, dy = 1) {
+  const shapes = (path?.shapes ?? []).slice();
+  const ordered = [...(shapeIndices ?? [])].sort((a, b) => a - b);
+  const copies = ordered.map((i) => translateShape(cloneShape(shapes[i]), dx, dy));
+  const base = shapes.length;
+  return {
+    path: { shapes: [...shapes, ...copies] },
+    indices: copies.map((_, i) => base + i),
+  };
+}
+
+export function setShapesFill(path, shapeIndices, key) {
+  let next = path;
+  for (const i of shapeIndices ?? []) next = setShapeFill(next, i, key);
+  return next;
+}
+
+export function setShapesStroke(path, shapeIndices, key) {
+  let next = path;
+  for (const i of shapeIndices ?? []) next = setShapeStroke(next, i, key);
+  return next;
+}
+
+/** Shared slot value across indices, or the string 'mixed'. */
+export function sharedShapeSlot(path, shapeIndices, slot) {
+  const idxs = shapeIndices ?? [];
+  if (!idxs.length) return null;
+  const first = path?.shapes?.[idxs[0]]?.[slot] ?? null;
+  for (let i = 1; i < idxs.length; i++) {
+    const v = path?.shapes?.[idxs[i]]?.[slot] ?? null;
+    if (v !== first) return 'mixed';
+  }
+  return first;
+}
+
+export function anchorKey(a) {
+  return `${a.subIndex}:${a.pointIndex}`;
+}
+
+export function toggleAnchorInList(list, anchor) {
+  const key = anchorKey(anchor);
+  const has = list.some((a) => anchorKey(a) === key);
+  if (has) return list.filter((a) => anchorKey(a) !== key);
+  return [...list, { subIndex: anchor.subIndex, pointIndex: anchor.pointIndex }];
+}
+
+export function toggleIndexInList(list, index) {
+  if (list.includes(index)) return list.filter((i) => i !== index);
+  return [...list, index].sort((a, b) => a - b);
+}
+
+// ---------------------------------------------------------------------------
+// Anchor insertion (edge split)
+// ---------------------------------------------------------------------------
+
+const MIN_SPLIT_SEG = 0.5;
+const BOW_EPS_LOCAL = 1e-12;
+
+/**
+ * Sample one cubic segment as {t,x,y} points (t in [0,1]).
+ */
+function sampleSegmentCurve(from, seg, steps = 48) {
+  const edge = { a: 0, b: 1 };
+  if (seg.c1) edge.ha = [seg.c1[0], seg.c1[1]];
+  if (seg.c2) edge.hb = [seg.c2[0], seg.c2[1]];
+  const base = sampleEdgeCurve(edge, [from, seg.to]);
+  if (base.length >= steps) return base;
+  const n = Math.max(8, steps);
+  const out = [];
+  for (let i = 0; i <= n; i++) {
+    const t = i / n;
+    const idx = t * (base.length - 1);
+    const lo = Math.floor(idx);
+    const hi = Math.min(base.length - 1, lo + 1);
+    const f = idx - lo;
+    const a = base[lo];
+    const b = base[hi];
+    out.push({ t, x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f });
+  }
+  return out;
+}
+
+/**
+ * de Casteljau split of one segment at the curve point nearest (x,y).
+ * Returns null when either half would be shorter than MIN_SPLIT_SEG.
+ */
+function segPointAt(from, seg, t) {
+  const { from: p0, to: p3, c1, c2 } = absoluteSegment(from, seg);
+  if (!seg.c1 && !seg.c2) {
+    return [p0[0] + (p3[0] - p0[0]) * t, p0[1] + (p3[1] - p0[1]) * t];
+  }
+  return cubicPoint(p0, c1, c2, p3, t);
+}
+
+/** Ternary search for the t in [lo, hi] whose curve point is nearest (px, py). */
+function refineT(from, seg, px, py, lo, hi) {
+  let a = lo;
+  let b = hi;
+  for (let i = 0; i < 32; i++) {
+    const m1 = a + (b - a) / 3;
+    const m2 = b - (b - a) / 3;
+    const p1 = segPointAt(from, seg, m1);
+    const p2 = segPointAt(from, seg, m2);
+    if (distSq(p1[0], p1[1], px, py) < distSq(p2[0], p2[1], px, py)) b = m2;
+    else a = m1;
+  }
+  return (a + b) / 2;
+}
+
+export function splitSegmentAtNearest(from, seg, x, y, cellPull = 0) {
+  const samples = sampleSegmentCurve(from, seg, 64);
+  const nearestIndex = (px, py) => {
+    let best = 0;
+    let bestD = Infinity;
+    for (let i = 0; i < samples.length; i++) {
+      const d = distSq(samples[i].x, samples[i].y, px, py);
+      if (d < bestD) {
+        bestD = d;
+        best = i;
+      }
+    }
+    return best;
+  };
+
+  let t = samples[nearestIndex(x, y)].t;
+  // Magnetize the landing point, then re-solve for the parameter that reaches
+  // it. Splitting at a parameter keeps the anchor exactly on the curve, so a
+  // tidy coordinate is reached by sliding ALONG the edge rather than by pulling
+  // the outline off it. Refining beats picking a sample: at 64 samples a long
+  // edge cannot land on the lattice site the pull just chose.
+  if (cellPull > 0) {
+    const p = segPointAt(from, seg, t);
+    const [mx, my] = magneticSnapPoint(p[0], p[1], cellPull, true);
+    if (mx !== p[0] || my !== p[1]) {
+      const j = nearestIndex(mx, my);
+      const lo = samples[Math.max(0, j - 1)].t;
+      const hi = samples[Math.min(samples.length - 1, j + 1)].t;
+      t = refineT(from, seg, mx, my, lo, hi);
+    }
+  }
+
+  const split = deCasteljauSplit(from, seg, t);
+  // Round to serialization precision: the ternary search lands a hair off the
+  // magnetic target, and a point at 8.0000002 is not coincident with one at 8,
+  // so junction detection would miss it until the file round-tripped.
+  const mid = [roundCoord(split.mid[0]), roundCoord(split.mid[1])];
+  const lenLeft = Math.hypot(mid[0] - from[0], mid[1] - from[1]);
+  const lenRight = Math.hypot(seg.to[0] - mid[0], seg.to[1] - mid[1]);
+  if (lenLeft < MIN_SPLIT_SEG || lenRight < MIN_SPLIT_SEG) return null;
+  return { mid, left: { ...split.left, to: mid }, right: split.right, t };
+}
+
+/**
+ * Insert an anchor on the edge nearest (x,y). Returns
+ * `{ path, anchor: { subIndex, pointIndex } }` or null (no-op / degenerate).
+ * Splits along the cubic (`splitSegmentAtNearest`); with cellPull > 0 the
+ * landing point magnetizes toward the lattice by sliding along the curve.
+ */
+export function insertAnchorOnEdge(path, shapeIndex, subIndex, edgeIndex, x, y, cellPull = 0) {
+  const ends = endpointsForEdge(path, shapeIndex, subIndex, edgeIndex);
+  if (!ends) return null;
+  const { sub, edge } = ends;
+  if (edgeIndex < 0 || edgeIndex >= subpathEdgeCount(sub)) return null;
+  const split = splitSegmentAtNearest(edge.from, edge.seg, x, y, cellPull);
+  if (!split) return null;
+  const norm = normalizeSubpath(sub);
+  const segs = [...(norm.segs ?? [])];
+  segs.splice(edgeIndex, 1, split.left, split.right);
+  const nextPath = mapSubpath(path, shapeIndex, subIndex, () => ({
+    closed: !!norm.closed,
+    start: [...norm.start],
+    segs,
+  }));
+  return {
+    path: nextPath,
+    anchor: { subIndex, pointIndex: edgeIndex + 1 },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Close / open path
+// ---------------------------------------------------------------------------
+
+/**
+ * Close/open toggle is only for a single-subpath shape. Multi-subpath shapes
+ * are import-only donuts — disable the toggle rather than guessing which ring.
+ */
+export function shapeCloseOpenState(shape, subIndex = 0) {
+  // An ellipse is closed by definition; opening one would be undone the next
+  // time its geometry is derived.
+  if (isPrimitiveShape(shape)) return { mode: 'disabled', reason: 'primitive' };
+  const sub = shape?.subpaths?.[subIndex];
+  if (!sub) return { mode: 'disabled', reason: 'no-subpath' };
+  if (sub.closed) return { mode: 'open', closed: true };
+  return { mode: 'close', closed: false, canClose: canCloseSubpath(sub) };
+}
+
+function canCloseSubpath(sub) {
+  const n = subpathVertexCount(sub);
+  if (n < 2) return false;
+  if (n === 2) {
+    const edge = subpathEdgeFrom(sub, 0);
+    return edge && Math.abs(bowForSegment(edge.from, edge.seg)) > BOW_EPS_LOCAL;
+  }
+  return n >= 3;
+}
+
+export function closeShape(path, shapeIndex, subIndex = 0) {
+  const shape = path?.shapes?.[shapeIndex];
+  const state = shapeCloseOpenState(shape, subIndex);
+  if (state.mode !== 'close' || !state.canClose) return path;
+  return mapSubpath(path, shapeIndex, subIndex, (sub) => {
+    const start = [...sub.start];
+    // No closing segment is appended: the edge back to `start` is implied.
+    const segs = (sub.segs ?? []).map((s) => ({ ...s, to: [...s.to], c1: s.c1 ? [...s.c1] : undefined, c2: s.c2 ? [...s.c2] : undefined }));
+    return { closed: true, start, segs };
+  });
+}
+
+/**
+ * Close the subpath the pen is drawing (geometry only). Keeps stroke /
+ * transparent fill. Returns the path unchanged when close is refused (e.g.
+ * &lt;3 anchors). A limb is a subpath like any other, so which one to close is
+ * the caller's to say — closing subpath 0 by assumption sealed the outline a
+ * limb was drawn onto instead of the limb.
+ */
+export function closePenShape(path, shapeIndex, subIndex = 0) {
+  return closeShape(path, shapeIndex, subIndex);
+}
+
+export function openShape(path, shapeIndex, subIndex = 0) {
+  const shape = path?.shapes?.[shapeIndex];
+  const state = shapeCloseOpenState(shape, subIndex);
+  if (state.mode !== 'open') return path;
+  // Open-subpath fill policy: closedRings skips open subs, so a filled shape
+  // would vanish. If it has a fill and NO stroke, transfer fill→stroke and clear
+  // fill; if it already has a stroke, just clear the fill.
+  let next = mapSubpath(path, shapeIndex, subIndex, (sub) => {
+    const start = [...sub.start];
+    let segs = (sub.segs ?? []).map((s) => ({ ...s, to: [...s.to], c1: s.c1 ? [...s.c1] : undefined, c2: s.c2 ? [...s.c2] : undefined }));
+    // Drop the closing segment only when it is pure redundancy. A curved one
+    // ending on `start` carries the outline's geometry — a lens is two curved
+    // edges between two anchors, so stripping by coordinate match alone
+    // flattened one side of it.
+    const last = segs[segs.length - 1];
+    if (last && pointsEqual(last.to, start) && !last.c1 && !last.c2) segs = segs.slice(0, -1);
+    return { closed: false, start, segs };
+  });
+  const opened = next.shapes[shapeIndex];
+  if (opened.fill && !opened.stroke) {
+    next = mapShape(next, shapeIndex, (s) => ({ ...s, fill: null, stroke: s.fill }));
+  } else if (opened.fill) {
+    next = mapShape(next, shapeIndex, (s) => ({ ...s, fill: null }));
+  }
+  return next;
+}
+
+// ---------------------------------------------------------------------------
+// Flip + rotate 90° (selection bbox center)
+// ---------------------------------------------------------------------------
+
+/** Combined axis-aligned bounds of all anchors in the selected shapes. */
+export function selectionAnchorBounds(path, shapeIndices) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let any = false;
+  for (const si of shapeIndices ?? []) {
+    const shape = path?.shapes?.[si];
+    if (!shape) continue;
+    for (const sub of shape.subpaths ?? []) {
+      for (const p of subpathPoints(sub)) {
+        any = true;
+        if (p[0] < minX) minX = p[0];
+        if (p[1] < minY) minY = p[1];
+        if (p[0] > maxX) maxX = p[0];
+        if (p[1] > maxY) maxY = p[1];
+      }
+    }
+  }
+  if (!any) return null;
+  return { minX, minY, maxX, maxY, cx: (minX + maxX) / 2, cy: (minY + maxY) / 2 };
+}
+
+/**
+ * Carry a primitive through a flip or rotation by transforming its parameters.
+ *
+ * Every op routed through mapSelectedShapes is an axis-preserving affine map,
+ * so transforming the centre and the two axis tips is enough to recover the
+ * result: a flip returns the same radii, a quarter turn returns them swapped.
+ * Deriving that from mapPoint rather than branching per-op means a new op of
+ * the same family keeps working without touching this.
+ */
+function mapPrimitiveShape(shape, mapPoint) {
+  const c = mapPoint([shape.cx, shape.cy]);
+  const tipX = mapPoint([shape.cx + shape.rx, shape.cy]);
+  const tipY = mapPoint([shape.cx, shape.cy + shape.ry]);
+  return deriveShape({
+    ...shape,
+    cx: c[0],
+    cy: c[1],
+    rx: Math.max(Math.abs(tipX[0] - c[0]), Math.abs(tipY[0] - c[0])),
+    ry: Math.max(Math.abs(tipX[1] - c[1]), Math.abs(tipY[1] - c[1])),
+  });
+}
+
+function mapSelectedShapes(path, shapeIndices, mapPoint, mapVector) {
+  const sel = new Set(shapeIndices ?? []);
+  if (!sel.size) return path;
+  return {
+    shapes: (path?.shapes ?? []).map((shape, i) => {
+      if (!sel.has(i)) return shape;
+      if (isPrimitiveShape(shape)) return mapPrimitiveShape(shape, mapPoint);
+      return {
+        ...shape,
+        subpaths: (shape.subpaths ?? []).map((sub) => {
+          const norm = normalizeSubpath(sub);
+          return {
+            ...norm,
+            start: mapPoint(norm.start),
+            segs: (norm.segs ?? []).map((seg) => {
+              const to = mapPoint(seg.to);
+              const mapped = transformSegmentHandles(seg, mapVector);
+              return { to, c1: mapped.c1, c2: mapped.c2 };
+            }),
+          };
+        }),
+      };
+    }),
+  };
+}
+
+/**
+ * Flip selected shapes about the selection bbox center.
+ * Anchors reflect through the center; relative segment handles go through
+ * mapVector (x or y negated).
+ */
+export function flipShapesHorizontal(path, shapeIndices) {
+  const b = selectionAnchorBounds(path, shapeIndices);
+  if (!b) return path;
+  const { cx } = b;
+  return mapSelectedShapes(
+    path,
+    shapeIndices,
+    (p) => [2 * cx - p[0], p[1]],
+    ([dx, dy]) => [-dx, dy]
+  );
+}
+
+export function flipShapesVertical(path, shapeIndices) {
+  const b = selectionAnchorBounds(path, shapeIndices);
+  if (!b) return path;
+  const { cy } = b;
+  return mapSelectedShapes(
+    path,
+    shapeIndices,
+    (p) => [p[0], 2 * cy - p[1]],
+    ([dx, dy]) => [dx, -dy]
+  );
+}
+
+/**
+ * Rotate selected shapes 90° CW about the selection bbox center snapped to the
+ * nearest half-cell. An arbitrary center can take lattice points off-lattice;
+ * with cx,cy on the 0.5 lattice the map preserves it. Relative handles rotate
+ * via mapVector.
+ */
+export function rotateShapes90CW(path, shapeIndices) {
+  const b = selectionAnchorBounds(path, shapeIndices);
+  if (!b) return path;
+  const cx = Math.round(b.cx * 2) / 2;
+  const cy = Math.round(b.cy * 2) / 2;
+  return mapSelectedShapes(
+    path,
+    shapeIndices,
+    (p) => [cx + (p[1] - cy), cy - (p[0] - cx)],
+    ([dx, dy]) => [dy, -dx]
+  );
+}