@weasel-js/path-tools 1.10.1 → 1.11.0

package/dist/index.js

@@ -1,10 +1,15 @@
-import { inPlane, editedPathSymmetries, pathEditPreview, locksInForce, pathOperationTags, editingLayer, joinPathsCommand, BridgeIcon, joinSelectedAnchors, makeHandleCommand, HarmonizeIcon, depOf, pathEditToolAction, SimplifyBrushIcon, DEFAULT_OVERLAY_STYLE, pathEditToolActive, registeredPathEffects, slotOf, pathEffectNode, commitOps, insertAt, DEFAULT_SIMPLIFY_TOLERANCE, deleteSelectedMark, resolveEditablePathOf, classifyPathStorage, commitAnchorEdit, anchorEditWouldChange, reshapeOps, HoldHandleAngleIcon, HoldHandleLengthIcon, pathEffectOf, createSetDataOp, derivedDepOf, pathEffectParts, deleteNode, selectedPathNodes, withPath, never, defineTool, nodeOutline, reshapeTo, composeAffordanceLayer, viewToTransform, worldToScreen, pathNodesOf, OVERLAY_ROLE_STROKES, SliceIcon } from '@weasel-js/core';
-import { isBalanceGrip, ActionDisabledReason, resolveParams } from '@weasel-js/routing';
-import { pathToAnchors, balanceFactorToward, editAnchorSetTracked, scaleSegmentHandles, harmonizeAnchors, simplifyAnchorsAt, locateAnchor, anchorsUnderBrush, pathAnchorPoints, unsatisfiedConstraints, solvePathConstraints, constraintAnchors, constrainPathEdit, constraintFits, PathBuilder, equalizeSegmentHandles, handleBalances, linePath, circlePath, curvatureComb, polylineFromPoints, worldEditToStorage, smudgePath, trimPathAt, boundsOfPath, transformPath, multiply, boxToBox, identity, openPathEnds, extendToMeet, pxExtent, poseFrameOf, applyPathWarp, invert, resizeEnvelope, pathDistanceToPoint, openEndRay, warpControls, applyToPoint, moveWarpControl, unwarpPoint, pathWarpMap, envelopeOver, distortOver, ellipsePath } from '@weasel-js/geom';
-import { jsx } from 'react/jsx-runtime';
+import { inPlane, HANDLE_LOCK_ROLES, editedPathSymmetries, pathEditPreview, locksInForce, pathOperationTags, editingLayer, joinPathsCommand, joinSelectedAnchors, makeHandleCommand, depOf, pathEditToolAction, segmentUnder, livePathEdit, reshapeOps, DEFAULT_OVERLAY_STYLE, pathEditToolActive, requiresAnchorSelection, registeredPathEffects, slotOf, pathEffectNode, commitOps, insertAt, DEFAULT_SIMPLIFY_TOLERANCE, deleteSelectedMark, resolveEditablePathOf, registerNodeShape, classifyPathStorage, commitAnchorEdit, anchorEditWouldChange, stepAngles, pathEffectOf, createSetDataOp, derivedDepOf, pathEffectParts, deleteNode, selectedPathNodes, withPath, never, defineTool, resolveBooleanOperands, commitBooleanPieces, PATHFINDER_STROKES, createPathOverlay, viewToTransform, worldToScreen, storeEditablePath, reshapeTo, nodeOutline, pointSnap, createPointerFollower, snapMods, composeAffordanceLayer, pathNodesOf, OVERLAY_ROLE_STROKES } from '@weasel-js/core';
+import { isBalanceGrip, isCornerWidget, isAnchor, ActionDisabledReason, resolveParams } from '@weasel-js/routing';
+import { pathToAnchors, balanceFactorToward, editAnchorSetTracked, scaleSegmentHandles, cornerFrames, cornerSpecAt, harmonizeAnchors, openEndAt, pathEndFrame, pathEndAnchorIndex, lengthToward, lengthenPathEnd, convertSegments, resamplePath, simplifyAnchorsAt, SPIRO_KINDS, CORNER_KEYWORDS, locateAnchor, withCorner, nearestPathAnchor, anchorsUnderBrush, pathAnchorPoints, solvePathConstraints, constraintAnchors, constrainPathsEdit, constrainPathEdit, constraintFits, PathBuilder, unsatisfiedConstraints, conflictingConstraints, segmentBetween, equalizeSegmentHandles, handleBalances, linePath, circlePath, curvatureComb, polylineFromPoints, isCornerShape, cornerShapeK, anchorAt, measureAnchorPath, softSelectionWeights, softSelectionBand, directionMarks, polygonFromPoints, setSubpathStart, reverseSubpaths, segmentsBetweenAnchors, growAnchorSelection, shrinkAnchorSelection, everyNthAnchor, cornerAnchors, smoothAnchors, invertAnchorSelection, worldEditToStorage, smudgePath, isSpiroKind, spiroToPath, spiroContoursOf, spiroControlPath, spiroContoursFromControl, squarePath, trimPathAt, fitAffine, multiply, identity, transformPath, pointInPath, cornerKeywordOf, standoff, cornerShapePieces, openPathEnds, extendToMeet, subpathsOfAnchors, flatIndexesAfterReverse, addExtremaAnchors, pxExtent, nearestSegmentT, cubicPointAt, withinPxRadius, flatAnchorIndex, boundsOfPath, boxToBox, poseFrameOf, invert, meanScale, ellipsePath, pathDistanceToPoint, openEndRay, segmentEnds, applyToPoint, insertAnchorOnSegment, nextCornerShape } from '@weasel-js/geom';
 import { createEmitter } from '@weasel-js/registry';
-import { useMemo, createElement } from 'react';
+import { applyPathWarp, resizeEnvelope, warpControls, moveWarpControl, unwarpPoint, pathWarpMap, envelopeOver, distortOver } from '@weasel-js/geom/warp';
+import { useMemo, useRef, useReducer, useState, useCallback, useSyncExternalStore } from 'react';
 import { useLatest } from '@weasel-js/react';
+import { pathFacePieces, pathUnion } from '@weasel-js/geom/booleans';
+import { vertexHalfWidths, vertexWidthFromSides } from '@weasel-js/paint';
+import { strokeEdgeNear, resolveStrokeWidth } from '@weasel-js/stroke';
+import { cursorFor } from '@weasel-js/cursor';
+import { useActionsRegistry } from '@weasel-js/routing/react';
 
 // src/presets.ts
 function gripTarget(dep, kind) {
@@ -24,12 +29,17 @@ function gripEnabled(deps) {
 var balanceHandlesAction = inPlane({
   id: "balanceHandles",
   label: "Balance handles",
+  icon: (
+    /* @icon */
+    "path-tools:balanceHandles"
+  ),
   tags: pathOperationTags("drag"),
   // Ties the marquee's `empty` and move's `selected-body` on specificity and
   // registers ahead of the marquee; move turns path-edit presses down itself.
   defaultBinding: { kind: "drag", target: { kindOf: isBalanceGrip } },
   cursor: "grab",
   eligible: { capability: "edits-anchors" },
+  modifierRoles: HANDLE_LOCK_ROLES,
   requires: ["editAnchors", "pathSymmetry"],
   invoker: {
     timing: "ongoing",
@@ -49,7 +59,7 @@ var balanceHandlesAction = inPlane({
         kind: "balance-handles",
         onMove(moveCtx) {
           const held = (moveCtx.deps.editAnchors ?? dep).handleLocks ?? NO_LOCKS;
-          if (locksInForce(held, moveCtx.modifiers).length) {
+          if (locksInForce(held, moveCtx).length) {
             current = null;
             return;
           }
@@ -74,6 +84,10 @@ var balanceHandlesAction = inPlane({
 var equalizeHandlesAction = {
   id: "equalizeHandles",
   label: "Equalize handles",
+  icon: (
+    /* @icon */
+    "path-tools:equalizeHandles"
+  ),
   tags: pathOperationTags("click"),
   defaultBinding: { kind: "doubleClick", target: { kindOf: isBalanceGrip } },
   eligible: { capability: "edits-anchors" },
@@ -100,11 +114,11 @@ function balanceCommands(set, toScreen, style = {}) {
   const { color, gripFill, gripRadiusPx } = { ...BALANCE_DEFAULTS, ...style };
   const paint = { kind: "solid", color };
   const out = [];
-  for (const line2 of handleBalances(set)) {
-    const grip = toScreen(line2.grip);
+  for (const line3 of handleBalances(set)) {
+    const grip = toScreen(line3.grip);
     out.push({
       kind: "path",
-      path: linePath(toScreen(line2.from), toScreen(line2.to)),
+      path: linePath(toScreen(line3.from), toScreen(line3.to)),
       stroke: { paint, width: 1 }
     });
     out.push({
@@ -120,10 +134,10 @@ function createBalanceExtension(style = {}) {
   return {
     id: "balance",
     marks: (ctx) => ctx.isVisible(PATH_BALANCE_CHROME_ID) ? balanceCommands(ctx.anchors, ctx.toScreen, style) : [],
-    parts: (target) => handleBalances(target.anchors).map((line2) => ({
-      x: line2.grip.x,
-      y: line2.grip.y,
-      hitKind: `balance:${line2.flat}`,
+    parts: (target) => handleBalances(target.anchors).map((line3) => ({
+      x: line3.grip.x,
+      y: line3.grip.y,
+      hitKind: `balance:${line3.flat}`,
       chromeId: PATH_BALANCE_CHROME_ID
     }))
   };
@@ -137,7 +151,10 @@ var bridgePathsAction = joinPathsCommand(
   {
     id: "bridgePaths",
     label: "Bridge",
-    icon: BridgeIcon,
+    icon: (
+      /* @icon */
+      "core:bridge"
+    ),
     // `code` too: with Shift held the key reads as `J`.
     defaultBinding: { kind: "key", key: "j", code: "KeyJ", mods: { mod: true, shift: true } }
   },
@@ -148,7 +165,10 @@ var bridgeAnchorsAction = {
   id: "bridgeAnchors",
   label: "Bridge anchors",
   tags: pathOperationTags("command"),
-  icon: BridgeIcon,
+  icon: (
+    /* @icon */
+    "core:bridge"
+  ),
   group: "anchors",
   defaultBinding: { kind: "key", key: "j", code: "KeyJ", mods: { mod: true, shift: true } },
   eligible: { capability: "edits-anchors" },
@@ -191,6 +211,222 @@ function createCombExtension(options = () => void 0) {
     marks: (ctx) => ctx.isVisible(PATH_COMB_CHROME_ID) ? combCommands(ctx.anchors, ctx.toScreen, options()) : []
   };
 }
+var DEFAULT_CORNER_SHAPE = "round";
+function cornerIndexOf(kind) {
+  const m = kind.match(/^corner:(\d+)$/);
+  return m ? parseInt(m[1], 10) : null;
+}
+function editedPath(dep) {
+  const p = dep.getEditablePath(dep.editingId);
+  return p && p.kind === "polygon" ? p : null;
+}
+function withRadius(path, targets, radius) {
+  let out = path;
+  for (const { frame, shape } of targets) {
+    out = withCorner(out, frame.index, { shape, radius: Math.max(0, Math.min(radius, frame.maxTrim)) });
+  }
+  return out;
+}
+function widgetEnabled(deps) {
+  if (!deps?.editAnchors?.editingId || pathEditToolActive(deps)) return ActionDisabledReason.NotApplicable;
+  return true;
+}
+var editCornerAction = inPlane({
+  id: "editCorner",
+  icon: (
+    /* @icon */
+    "path-tools:cornerRadius"
+  ),
+  label: "Corner radius",
+  tags: pathOperationTags("drag"),
+  // Ties the marquee's `empty` and move's `selected-body` on specificity and
+  // registers ahead of the marquee; move turns path-edit presses down itself.
+  defaultBinding: { kind: "drag", target: { kindOf: isCornerWidget } },
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx) {
+      const dep = ctx.deps.editAnchors;
+      const index = cornerIndexOf(ctx.drag?.affordance?.kind ?? "");
+      if (!dep?.editingId || index === null) return {};
+      const origin = editedPath(dep);
+      if (!origin) return {};
+      const frames = new Map(cornerFrames(origin).map((f) => [f.index, f]));
+      const pressed = frames.get(index);
+      if (!pressed) return {};
+      const indices = dep.selectedAnchors.has(index) ? [...dep.selectedAnchors] : [index];
+      const targets = [];
+      for (const i of indices) {
+        const frame = frames.get(i);
+        if (frame) targets.push({ frame, shape: cornerSpecAt(origin, i)?.shape ?? DEFAULT_CORNER_SHAPE });
+      }
+      const press = ctx.drag?.start ?? ctx.world;
+      let current = origin;
+      let active = false;
+      const preview = pathEditPreview(dep, dep.editingId, () => active ? current : null);
+      if (!preview) return {};
+      const id = dep.editingId;
+      return {
+        kind: "edit-corner",
+        onMove(move) {
+          const along2 = (move.world.x - press.x) * pressed.bisector.x + (move.world.y - press.y) * pressed.bisector.y;
+          const trim = Math.max(0, pressed.trim + along2 / Math.cos(pressed.halfAngle));
+          current = withRadius(origin, targets, trim);
+          active = true;
+        },
+        onEnd(_end, reason) {
+          active = false;
+          if (reason === "cancel" || current === origin) return;
+          dep.applyEdit(id, current, "Corner radius");
+        },
+        previewIds: preview.previewIds,
+        previewPose: preview.previewPose,
+        previewData: preview.previewData
+      };
+    }
+  },
+  enabled: widgetEnabled
+}, editingLayer);
+
+// src/cornerShape/cornerCommands.ts
+var DEFAULT_CORNER_TRIM_SHARE = 0.25;
+function selectedCorners(dep, path) {
+  return cornerFrames(path).filter((f) => dep.selectedAnchors.has(f.index));
+}
+function changeCorners(path, frames, change) {
+  let out = path;
+  for (const f of frames) {
+    const spec = cornerSpecAt(path, f.index);
+    const shape = change.shape ?? spec?.shape ?? DEFAULT_CORNER_SHAPE;
+    let radius = Math.max(0, change.radius ?? spec?.radius ?? 0);
+    if (change.shape !== void 0 && change.radius === void 0 && radius <= 0) {
+      radius = DEFAULT_CORNER_TRIM_SHARE * f.maxTrim;
+    }
+    out = withCorner(out, f.index, { shape, radius: Math.min(radius, f.maxTrim) });
+  }
+  return out;
+}
+function commitChange(deps, label, change) {
+  const dep = depOf(deps);
+  const path = dep && editedPath(dep);
+  if (!dep || !path) return;
+  const frames = selectedCorners(dep, path);
+  if (frames.length === 0) return;
+  dep.applyEdit(dep.editingId, changeCorners(path, frames, change(frames, path)), label);
+}
+function cornersSelected(deps) {
+  const selection = requiresAnchorSelection(deps);
+  if (selection !== true) return selection;
+  const dep = depOf(deps);
+  const path = dep && editedPath(dep);
+  return dep && path && selectedCorners(dep, path).length > 0 ? true : ActionDisabledReason.NotApplicable;
+}
+var setCornersAction = {
+  id: "setCorners",
+  icon: (
+    /* @icon */
+    "path-tools:cornerRadius"
+  ),
+  label: "Set corners",
+  tags: pathOperationTags("command"),
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const shape = isCornerShape(params?.shape) ? params.shape : void 0;
+      const radius = typeof params?.radius === "number" && Number.isFinite(params.radius) ? params.radius : void 0;
+      if (shape === void 0 && radius === void 0) return;
+      commitChange(deps, "Set corners", () => ({
+        ...shape !== void 0 ? { shape } : {},
+        ...radius !== void 0 ? { radius } : {}
+      }));
+    }
+  },
+  enabled: cornersSelected
+};
+var cycleCornerShapeAction = {
+  id: "cycleCornerShape",
+  icon: (
+    /* @icon */
+    "path-tools:cornerShape"
+  ),
+  label: "Next corner shape",
+  tags: pathOperationTags("command"),
+  group: "anchors",
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => commitChange(deps, "Next corner shape", (frames, path) => ({
+      shape: nextCornerShape(cornerSpecAt(path, frames[0].index)?.shape ?? DEFAULT_CORNER_SHAPE)
+    }))
+  },
+  enabled: cornersSelected
+};
+var PATH_CORNERS_CHROME_ID = "path-edit.corners";
+var CORNER_WIDGET_STANDOFF_PX = 14;
+var MIN_WIDGET_TURN = 0.05;
+function cornerWidgetFrames(path) {
+  return cornerFrames(path).filter((f) => f.halfAngle < Math.PI / 2 - MIN_WIDGET_TURN);
+}
+function cornerCutMiddle(frame) {
+  const d = frame.trim * Math.cos(frame.halfAngle);
+  return { x: frame.x + frame.bisector.x * d, y: frame.y + frame.bisector.y * d };
+}
+function cornerWidgetAt(frame, scale) {
+  const at2 = standoff(cornerCutMiddle(frame), frame.bisector, CORNER_WIDGET_STANDOFF_PX, scale);
+  return { x: at2.x, y: at2.y };
+}
+var GLYPH_HALF_PX = 4.5;
+var WIDGET_HIT_RADIUS_PX = 6;
+function cornerGlyph(c, toward2, k) {
+  const h = GLYPH_HALF_PX;
+  const r2 = Math.SQRT1_2;
+  const e1 = { x: (toward2.x - toward2.y) * r2, y: (toward2.x + toward2.y) * r2 };
+  const e2 = { x: (toward2.x + toward2.y) * r2, y: (toward2.y - toward2.x) * r2 };
+  const at2 = (a, b2) => ({ x: c.x + a * e1.x + b2 * e2.x, y: c.y + a * e1.y + b2 * e2.y });
+  const cut = 1.2 * h;
+  const outer = at2(h, h);
+  const b = new PathBuilder().moveTo(at2(-h, -h).x, at2(-h, -h).y).lineTo(at2(h, -h).x, at2(h, -h).y);
+  const start = at2(h, h - cut);
+  b.lineTo(start.x, start.y);
+  for (const piece of cornerShapePieces(k, { start, end: at2(h - cut, h), outer })) {
+    if (piece.kind === "line") b.lineTo(piece.to.x, piece.to.y);
+    else b.curveTo(piece.c1.x, piece.c1.y, piece.c2.x, piece.c2.y, piece.to.x, piece.to.y);
+  }
+  const last = at2(-h, h);
+  return b.lineTo(last.x, last.y).close().build();
+}
+function cornerWidgetCommands(path, view, style = {}) {
+  const out = [];
+  const fill = { paint: { kind: "solid", color: style.fill ?? DEFAULT_OVERLAY_STYLE.anchorFill } };
+  const stroke = { paint: { kind: "solid", color: style.stroke ?? DEFAULT_OVERLAY_STYLE.anchorStroke }, width: 1 };
+  for (const frame of cornerWidgetFrames(path)) {
+    const w = cornerWidgetAt(frame, view.scale);
+    const x = (w.x - view.x) * view.scale.x;
+    const y = (w.y - view.y) * view.scale.y;
+    const bx = -frame.bisector.x * view.scale.x, by = -frame.bisector.y * view.scale.y;
+    const bl = Math.hypot(bx, by) || 1;
+    const k = cornerShapeK(cornerSpecAt(path, frame.index)?.shape ?? "round");
+    out.push({ kind: "path", path: cornerGlyph({ x, y }, { x: bx / bl, y: by / bl }, k), fill, stroke });
+  }
+  return out;
+}
+function createCornerWidgetsExtension(style = {}) {
+  return {
+    id: "cornerShape",
+    marks: (ctx) => ctx.isVisible(PATH_CORNERS_CHROME_ID) ? cornerWidgetCommands(ctx.path, ctx.view, style) : [],
+    parts: (target) => cornerWidgetFrames(target.path).map((f) => ({
+      ...cornerCutMiddle(f),
+      hitKind: `corner:${f.index}`,
+      chromeId: PATH_CORNERS_CHROME_ID,
+      hitRadiusPx: WIDGET_HIT_RADIUS_PX,
+      standoff: { px: CORNER_WIDGET_STANDOFF_PX, normal: f.bisector }
+    }))
+  };
+}
 var NONE = [];
 function constraintsOf(data) {
   const list = data?.constraints;
@@ -200,11 +436,18 @@ function constraintAxisOf(node) {
   const storage = classifyPathStorage(node);
   return storage?.kind === "data" ? storage.pose.rotation ?? 0 : 0;
 }
+function conflictsIn(path, constraints, axisAngle) {
+  const points = pathAnchorPoints(path);
+  const failing = unsatisfiedConstraints(points, constraints, { axisAngle });
+  if (failing.length === 0) return [];
+  const set = /* @__PURE__ */ new Set([...failing, ...conflictingConstraints(points, constraints, { axisAngle })]);
+  return [...set].sort((a, b) => a - b);
+}
 function constraintConflictsOf(node) {
   const constraints = constraintsOf(node?.data);
   const path = constraints.length > 0 ? resolveEditablePathOf(node) : null;
   if (!path) return [];
-  return unsatisfiedConstraints(pathAnchorPoints(path), constraints, { axisAngle: constraintAxisOf(node) });
+  return conflictsIn(path, constraints, constraintAxisOf(node));
 }
 function constrainNodeEdit(node, worldPath, origins) {
   const constraints = constraintsOf(node?.data);
@@ -212,16 +455,103 @@ function constrainNodeEdit(node, worldPath, origins) {
   if (!before) return { path: worldPath, constraints };
   const edit = constrainPathEdit(before, worldPath, constraints, { origins, axisAngle: constraintAxisOf(node) });
   if (!edit.converged) return null;
-  const same = edit.constraints.length === constraints.length && edit.constraints.every((c, i) => JSON.stringify(c) === JSON.stringify(constraints[i]));
-  return { path: edit.path, constraints: same ? constraints : edit.constraints };
+  const same2 = edit.constraints.length === constraints.length && edit.constraints.every((c, i) => JSON.stringify(c) === JSON.stringify(constraints[i]));
+  return { path: edit.path, constraints: same2 ? constraints : edit.constraints };
 }
 function solveNodeConstraints(node, constraints) {
   const path = resolveEditablePathOf(node);
   if (!path) return null;
   const axisAngle = constraintAxisOf(node);
   const solved = solvePathConstraints(path, constraints, { axisAngle });
-  if (solved.converged) return { path: solved.path, unsatisfied: [] };
-  return { path, unsatisfied: unsatisfiedConstraints(pathAnchorPoints(path), constraints, { axisAngle }) };
+  if (solved.converged) return { path: solved.path, conflicts: [] };
+  return { path, conflicts: conflictsIn(path, constraints, axisAngle) };
+}
+function constraintLinkOf(data) {
+  const c = data?.constraintLink;
+  return c && typeof c === "object" && typeof c.kind === "string" ? c : null;
+}
+var CONSTRAINT_LINK_SHAPE = {
+  id: "path-tools:constraint-link",
+  matches: (node) => constraintLinkOf(node.data) !== null,
+  paint: () => [],
+  bounds: () => null
+};
+var linkShapeRegistered = false;
+function registerConstraintLinkShape() {
+  if (linkShapeRegistered) return;
+  linkShapeRegistered = true;
+  registerNodeShape(CONSTRAINT_LINK_SHAPE, { priority: "high" });
+}
+function constraintLinkNode(opts) {
+  registerConstraintLinkShape();
+  return {
+    kind: "leaf",
+    layer: opts.layer,
+    pose: opts.pose ?? { x: 0, y: 0, width: 0, height: 0 },
+    data: { constraintLink: opts.constraint },
+    dependsOn: opts.nodes,
+    pickable: false,
+    ...opts.id ? { id: opts.id } : {}
+  };
+}
+function linkAt(ctx, id) {
+  const node = ctx.node(id);
+  const constraint = constraintLinkOf(node?.data);
+  const nodes = node?.dependsOn;
+  return constraint && Array.isArray(nodes) ? { id, nodes, constraint } : null;
+}
+function linkedFrom(ctx, start) {
+  const nodes = [start];
+  const links = /* @__PURE__ */ new Map();
+  for (let k = 0; k < nodes.length; k++) {
+    for (const id of ctx.dependents(nodes[k])) {
+      const link = links.has(id) ? null : linkAt(ctx, id);
+      if (!link) continue;
+      links.set(id, link);
+      for (const n of link.nodes) if (!nodes.includes(n)) nodes.push(n);
+    }
+  }
+  return { nodes, links: [...links.values()] };
+}
+var same = (a, b) => a.length === b.length && a.every((c, i) => JSON.stringify(c) === JSON.stringify(b[i]));
+function finishLinkedEdit(ctx, worldPath, origins) {
+  const { nodes, links } = linkedFrom(ctx, ctx.id);
+  if (links.length === 0) return void 0;
+  const items = [];
+  for (const [k, id] of nodes.entries()) {
+    const node = ctx.node(id);
+    const before = ctx.path(id);
+    if (!node || !before) return void 0;
+    items.push({
+      before,
+      after: k === 0 ? worldPath : before,
+      constraints: constraintsOf(node.data),
+      axisAngle: constraintAxisOf(node),
+      ...k === 0 ? { origins } : {}
+    });
+  }
+  const pathLinks = links.map((l) => ({ constraint: l.constraint, paths: l.nodes.map((n) => nodes.indexOf(n)) }));
+  const done = constrainPathsEdit(items, pathLinks);
+  if (!done.converged) return null;
+  const others = [];
+  done.items.forEach((item, k) => {
+    if (k === 0) return;
+    const had = constraintsOf(ctx.node(nodes[k])?.data);
+    const changed = !same(had, item.constraints);
+    if (item.path !== items[k].after || changed) {
+      others.push({ id: nodes[k], path: item.path, ...changed ? { data: { constraints: item.constraints } } : {} });
+    }
+  });
+  done.links.forEach((l, k) => {
+    const link = links[k];
+    if (!l.constraint) others.push({ id: link.id, remove: true });
+    else if (JSON.stringify(l.constraint) !== JSON.stringify(link.constraint)) {
+      others.push({ id: link.id, data: { constraintLink: l.constraint } });
+    }
+  });
+  const own = constraintsOf(ctx.node(ctx.id)?.data);
+  const [first] = done.items;
+  return { path: first.path, constraints: same(own, first.constraints) ? own : first.constraints, others };
 }
 var OFFSET = 12;
 var at = (p, d, k) => ({ x: p.x + d.x * k, y: p.y + d.y * k });
@@ -249,6 +579,8 @@ function frameOf(points, [i, j], inside) {
 function segmentsOf(c) {
   switch (c.kind) {
     case "fixed":
+    case "tangent":
+    case "onPath":
     case "coincident":
       return [];
     case "horizontal":
@@ -260,8 +592,8 @@ function segmentsOf(c) {
   }
 }
 function markCenters(points, c, inside) {
-  if (c.kind === "fixed" || c.kind === "coincident") {
-    const p = points[c.kind === "fixed" ? c.anchor : c.anchors[0]];
+  if (c.kind === "fixed" || c.kind === "tangent" || c.kind === "onPath" || c.kind === "coincident") {
+    const p = points[c.kind === "coincident" ? c.anchors[0] : c.anchor];
     return [at(p, toward(p, inside), c.kind === "fixed" ? 11 : 13)];
   }
   return segmentsOf(c).map((s) => {
@@ -314,14 +646,36 @@ function glyphOf(b, points, c, inside) {
       const d = toward(p, inside);
       const ring = at(p, d, 13);
       line(b, at(p, d, 6), at(p, d, 9));
-      b.moveTo(ring.x + 4, ring.y);
-      for (let k = 1; k <= 12; k++) b.lineTo(ring.x + 4 * Math.cos(k * Math.PI / 6), ring.y + 4 * Math.sin(k * Math.PI / 6));
+      circle(b, ring, 4);
+      return;
+    }
+    case "tangent": {
+      const p = points[c.anchor];
+      const d = toward(p, inside);
+      const ring = at(p, d, 13);
+      const side = { x: -d.y, y: d.x };
+      const touch = at(ring, d, -4);
+      line(b, at(touch, side, -6), at(touch, side, 6));
+      circle(b, ring, 4);
+      return;
+    }
+    case "onPath": {
+      const p = points[c.anchor];
+      const d = toward(p, inside);
+      const dot = at(p, d, 13);
+      const side = { x: -d.y, y: d.x };
+      line(b, at(dot, side, -7), at(dot, side, 7));
+      circle(b, dot, 2.5);
       return;
     }
     default:
       for (const s of segmentsOf(c)) segmentMark(b, points, c.kind, s, inside);
   }
 }
+function circle(b, o, r) {
+  b.moveTo(o.x + r, o.y);
+  for (let k = 1; k <= 12; k++) b.lineTo(o.x + r * Math.cos(k * Math.PI / 6), o.y + r * Math.sin(k * Math.PI / 6));
+}
 var xy = (p) => [p.x, p.y];
 function constraintGlyphs(points, constraints, unsatisfied, style, selected = null) {
   const inside = centroidOf(points);
@@ -356,17 +710,26 @@ function constraintMarkAt(points, constraints, p, radius) {
 var CONSTRAINTS_EXTENSION_ID = "constraints";
 var MARK_CLICK_PX = 8;
 var DEFAULT_STYLE = { stroke: "#0e9f8e", conflictStroke: "#e5484d" };
-function editedPath(dep) {
+function editedPath2(dep) {
   const p = dep.getEditablePath(dep.editingId);
   return p?.kind === "polygon" ? p : null;
 }
 function setConstraints(dep, constraints, label) {
   const node = dep.getNodeShape(dep.editingId);
   const solved = node && dep.store ? solveNodeConstraints(node, constraints) : null;
-  if (!solved) return false;
+  if (!solved) return null;
   dep.setSelectedMark?.(null);
   dep.store(dep.editingId, solved.path, label, { constraints: [...constraints] });
-  return true;
+  return solved.conflicts;
+}
+var conflictCache = /* @__PURE__ */ new WeakMap();
+function conflictsOf(path, constraints, axisAngle) {
+  const key = `${axisAngle};${Array.from(path.commands).join(",")};${Array.from(path.coords).join(",")}`;
+  const hit = conflictCache.get(constraints);
+  if (hit?.key === key) return hit.conflicts;
+  const conflicts = new Set(conflictsIn(path, constraints, axisAngle));
+  conflictCache.set(constraints, { key, conflicts });
+  return conflicts;
 }
 function selectedConstraintOf(dep) {
   const mark = dep.selectedMark;
@@ -375,15 +738,15 @@ function selectedConstraintOf(dep) {
 var screenPoints = (target, toScreen) => pathAnchorPoints(target.path).map(toScreen);
 function createConstraintsExtension(style = {}) {
   const colors = { ...DEFAULT_STYLE, ...style };
+  registerConstraintLinkShape();
   return {
     id: CONSTRAINTS_EXTENSION_ID,
     marks(ctx) {
       const constraints = constraintsOf(ctx.node.data);
       if (constraints.length === 0) return [];
       const world = pathAnchorPoints(ctx.path);
-      const axisAngle = constraintAxisOf(ctx.node);
-      const unsatisfied = new Set(unsatisfiedConstraints(world, constraints, { axisAngle }));
-      return constraintGlyphs(world.map(ctx.toScreen), constraints, unsatisfied, colors, ctx.selected);
+      const conflicts = conflictsOf(ctx.path, constraints, constraintAxisOf(ctx.node));
+      return constraintGlyphs(world.map(ctx.toScreen), constraints, conflicts, colors, ctx.selected);
     },
     markAt(target, toScreen, screen) {
       const constraints = constraintsOf(target.node.data);
@@ -397,7 +760,12 @@ function createConstraintsExtension(style = {}) {
       const solved = solveNodeConstraints(target.node, kept);
       if (solved) store(target.id, solved.path, "Delete constraint", { constraints: kept });
     },
-    finishEdit(node, worldPath, origins) {
+    finishEdit(node, worldPath, origins, ctx) {
+      const linked = ctx ? finishLinkedEdit(ctx, worldPath, origins) : void 0;
+      if (linked === null) return null;
+      if (linked) {
+        return linked.constraints === constraintsOf(node.data) ? { path: linked.path, others: linked.others } : { path: linked.path, data: { constraints: linked.constraints }, others: linked.others };
+      }
       const done = constrainNodeEdit(node, worldPath, origins);
       if (!done) return null;
       return done.constraints === constraintsOf(node.data) ? { path: done.path } : { path: done.path, data: { constraints: done.constraints } };
@@ -416,6 +784,14 @@ function constraintsForAnchors(kind, anchors, path, length) {
   switch (kind) {
     case "fixed":
       return anchors.map((anchor) => ({ kind, anchor }));
+    case "onPath": {
+      const segment = anchors.length === 3 ? segmentBetween(path, anchors[1], anchors[2]) : null;
+      return segment ? [{ kind, anchor: anchors[0], segment }] : [];
+    }
+    case "tangent": {
+      const points = pathAnchorPoints(path);
+      return anchors.filter((a) => points[a]?.inHandle && points[a]?.outHandle).map((anchor) => ({ kind, anchor }));
+    }
     case "horizontal":
     case "vertical":
       return pairsOf(anchors).map((segment) => ({ kind, segment }));
@@ -437,7 +813,7 @@ function constraintsForAnchors(kind, anchors, path, length) {
 }
 var sameConstraint = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 function withAdded(dep, params) {
-  const path = editedPath(dep);
+  const path = editedPath2(dep);
   if (!path || !params?.kind) return null;
   const current = constraintsOf(dep.getNodeShape(dep.editingId)?.data);
   const added = constraintsForAnchors(params.kind, [...dep.selectedAnchors], path, params.length).filter((c) => !current.some((had) => sameConstraint(had, c)));
@@ -474,6 +850,10 @@ function constraintCommand(id, label, next) {
 var deleteConstraintAction = {
   id: "deleteConstraint",
   label: "Delete constraint",
+  icon: (
+    /* @icon */
+    "core:delete"
+  ),
   eligible: { capability: "edits-anchors" },
   requires: ["editAnchors"],
   invoker: {
@@ -536,11 +916,8 @@ function endsAt(path, anchors) {
   const ends = openPathEnds(path);
   if (anchors.size === 0) return ends;
   const set = pathToAnchors(path);
-  const picked = ends.filter((e) => [...anchors].some((flat) => {
-    const at2 = locateAnchor(set, flat);
-    if (!at2 || at2.sub !== e.sub) return false;
-    return e.end === "first" ? at2.idx === 0 : at2.idx === set.anchors[at2.sub].length - 1;
-  }));
+  const at2 = [...anchors].map((flat) => openEndAt(set, flat));
+  const picked = ends.filter((e) => at2.some((o) => o?.sub === e.sub && o.end === e.end));
   return picked.length > 0 ? picked : ends;
 }
 var dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
@@ -569,6 +946,10 @@ function planExtend(deps, params) {
 }
 var extendToMeetAction = {
   id: "extendToMeet",
+  icon: (
+    /* @icon */
+    "path-tools:extend"
+  ),
   label: EXTEND_LABEL,
   tags: pathOperationTags("click"),
   group: "path",
@@ -606,18 +987,552 @@ function makeHandleLockToggle(lock, label, icon) {
     }
   };
 }
-var handleLockAngleAction = makeHandleLockToggle("angle", "Hold handle angle", /* @__PURE__ */ jsx(HoldHandleAngleIcon, {}));
-var handleLockLengthAction = makeHandleLockToggle("length", "Hold handle length", /* @__PURE__ */ jsx(HoldHandleLengthIcon, {}));
+var handleLockAngleAction = makeHandleLockToggle(
+  "angle",
+  "Hold handle angle",
+  /* @icon */
+  "core:holdHandleAngle"
+);
+var handleLockLengthAction = makeHandleLockToggle(
+  "length",
+  "Hold handle length",
+  /* @icon */
+  "core:holdHandleLength"
+);
+var DEG = Math.PI / 180;
+var DEFAULT_STEP_DEG = 45;
+var DEFAULT_REACH_DEG = 6;
+var LINE_OVERSHOOT = 1.25;
+var reader = (options) => typeof options === "function" ? options : () => options;
+function handleSnapSource(options = {}) {
+  const read = reader(options);
+  return {
+    id: "handle",
+    roles: [],
+    gestures: ["handle"],
+    collect: () => [],
+    *angles(q) {
+      const opts = read();
+      if (!opts) return;
+      const { pivot } = q;
+      const reach = Math.hypot(q.press.x - pivot.x, q.press.y - pivot.y) * LINE_OVERSHOOT;
+      for (const other of opts.opposite === false ? [] : q.also?.anchors ?? []) {
+        if (other.x === pivot.x && other.y === pivot.y) continue;
+        const angle = Math.atan2(pivot.y - other.y, pivot.x - other.x);
+        yield { angle, mark: { kind: "line", from: other, to: along(pivot, angle, reach) } };
+      }
+      const step = (opts.stepDeg ?? DEFAULT_STEP_DEG) * DEG;
+      if (step <= 0) return;
+      for (const angle of stepAngles(q.theta, step)) yield { angle, mark: stepLine(pivot, angle, reach) };
+    }
+  };
+}
+function createHandleSnapExtension(options = {}) {
+  const read = reader(options);
+  return {
+    id: "handleSnap",
+    drag(start) {
+      if (start.part === "anchor") return null;
+      const pressed = anchorAt(start.anchors, start.anchorIndex);
+      const handle = start.part === "controlIn" ? pressed?.inHandle : pressed?.outHandle;
+      if (!pressed || !handle) return null;
+      const anchor = { x: pressed.x, y: pressed.y };
+      const other = start.part === "controlIn" ? pressed.outHandle : pressed.inHandle;
+      const session = start.snap?.begin({
+        gesture: "handle",
+        press: { x: handle.x, y: handle.y },
+        pivot: anchor,
+        ids: [start.id],
+        theta0: Math.atan2(handle.y - anchor.y, handle.x - anchor.x),
+        reachRad: (read()?.reachDeg ?? DEFAULT_REACH_DEG) * DEG,
+        ...other ? { also: { anchors: [{ x: other.x, y: other.y }] } } : {}
+      });
+      if (!session) return null;
+      return {
+        handle(to, { locks }) {
+          const dx = to.x - anchor.x;
+          const dy = to.y - anchor.y;
+          const len = Math.hypot(dx, dy);
+          const off = !read() || len === 0;
+          const { theta } = session.angle(Math.atan2(dy, dx), { suspend: off, constrain: false, hold: locks.angle });
+          if (off || locks.angle) return to;
+          return along(anchor, theta, len);
+        },
+        end: () => session.end()
+      };
+    }
+  };
+}
+function along(from, angle, len) {
+  return { x: from.x + Math.cos(angle) * len, y: from.y + Math.sin(angle) * len };
+}
+function stepLine(pivot, angle, reach) {
+  return { kind: "line", from: along(pivot, angle + Math.PI, reach), to: along(pivot, angle, reach) };
+}
+var MIN_RADIUS_PX = 2;
+var MAX_RADIUS_PX = 4e3;
+var WHEEL_GAIN = 15e-4;
+function createSoftSelectionExtension(options) {
+  return {
+    id: "softSelection",
+    drag(start) {
+      const opts = options();
+      if (!opts || start.part !== "anchor" || start.dragging.length === 0) return null;
+      return softDrag(start, opts);
+    }
+  };
+}
+function softDrag(start, opts) {
+  const measure = measureAnchorPath(start.anchors, start.scale ? { scale: start.scale } : {});
+  const falloff = opts.falloff ?? "smooth";
+  let radiusPx = clampRadius(opts.radiusPx);
+  let weights = softSelectionWeights(measure, start.dragging, radiusPx, falloff);
+  return {
+    weights: () => weights,
+    wheel({ deltaY }) {
+      radiusPx = clampRadius(radiusPx * Math.exp(-deltaY * WHEEL_GAIN));
+      weights = softSelectionWeights(measure, start.dragging, radiusPx, falloff);
+      opts.onRadius?.(radiusPx);
+      return true;
+    },
+    overlays: (current) => softSelectionBand(measure, current, start.dragging, radiusPx).map((points) => ({ kind: "polyline", points, role: "falloff" }))
+  };
+}
+function clampRadius(px) {
+  return Math.min(MAX_RADIUS_PX, Math.max(MIN_RADIUS_PX, Number.isFinite(px) ? px : MIN_RADIUS_PX));
+}
 var harmonizeAnchorsAction = makeHandleCommand(
   "harmonizeAnchors",
   "Harmonize curvature",
-  /* @__PURE__ */ jsx(HarmonizeIcon, {}),
+  /* @icon */
+  "core:harmonize",
   harmonizeAnchors,
   "selectedOrAll"
 );
+var LENGTHEN_TOOL = "lengthen";
+var LENGTHEN_CURSOR = { glyph: "penPlus", fallback: "crosshair" };
+var END_HIT_PX = 8;
+function editedPath3(deps) {
+  const dep = depOf(deps);
+  if (!dep || dep.tool !== LENGTHEN_TOOL) return null;
+  const path = dep.getEditablePath(dep.editingId);
+  return path?.kind === "polygon" ? { dep, path } : null;
+}
+function endUnder(deps, x, y) {
+  const edited = editedPath3(deps);
+  if (!edited) return false;
+  const scale = deps?.view?.get().scale ?? { x: 1, y: 1 };
+  const hit = nearestPathAnchor([{ id: edited.dep.editingId, path: edited.path }], { x, y }, END_HIT_PX, scale);
+  return !!hit && hit.end !== null && pathToAnchors(edited.path).anchors[hit.sub].length > 1;
+}
+function modeOf(opts, flip) {
+  const mode = resolveParams(opts?.params)?.mode;
+  const base = mode === "curvature" ? "curvature" : "tangent";
+  if (!flip) return base;
+  return base === "curvature" ? "tangent" : "curvature";
+}
+function pressedAnchor(ctx) {
+  const m = ctx.drag?.affordance?.kind.match(/^anchor:(\d+)$/);
+  return m ? parseInt(m[1], 10) : -1;
+}
+var lengthenPathAction = inPlane({
+  id: "lengthenPath",
+  label: "Lengthen path",
+  tags: pathOperationTags("drag"),
+  defaultBinding: { kind: "drag", target: { kindOf: isAnchor }, mods: { shift: "optional" } },
+  cursor: LENGTHEN_CURSOR,
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors", "view"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx, opts) {
+      const edited = editedPath3(ctx.deps);
+      if (!edited) return {};
+      const { dep, path: originPath } = edited;
+      const origin = pathToAnchors(originPath);
+      const end = openEndAt(origin, pressedAnchor(ctx));
+      const frame = end && pathEndFrame(origin, end);
+      if (!end || !frame) return {};
+      const id = dep.editingId;
+      const press = ctx.drag?.start ?? ctx.world;
+      let distance = 0;
+      let current = null;
+      const preview = pathEditPreview(dep, id, () => current?.path ?? null);
+      if (!preview) return {};
+      return {
+        kind: "lengthen-path",
+        onMove(moveCtx) {
+          const mode = modeOf(opts, moveCtx.modifiers.shift);
+          const toward2 = {
+            x: frame.point.x + moveCtx.world.x - press.x,
+            y: frame.point.y + moveCtx.world.y - press.y
+          };
+          distance = lengthToward(origin, end, mode, toward2, distance);
+          current = editAnchorSetTracked(originPath, (set) => lengthenPathEnd(set, end, distance, mode));
+        },
+        onEnd(_endCtx, reason) {
+          const done = current;
+          current = null;
+          if (reason === "cancel" || !done) return;
+          dep.applyEdit(id, done.path, distance < 0 ? "Shorten path" : "Lengthen path", done.origins);
+          const index = pathEndAnchorIndex(pathToAnchors(done.path), end);
+          if (index !== -1) dep.setSelectedAnchors([index]);
+        },
+        previewIds: preview.previewIds,
+        previewPose: preview.previewPose,
+        previewData: preview.previewData
+      };
+    }
+  },
+  enabled: (deps, at2) => {
+    if (depOf(deps)?.tool !== LENGTHEN_TOOL) return ActionDisabledReason.NotApplicable;
+    if (at2 && !endUnder(deps, at2.x, at2.y)) return ActionDisabledReason.NotApplicable;
+    return true;
+  }
+}, editingLayer);
+var lengthenToolAction = pathEditToolAction(
+  LENGTHEN_TOOL,
+  "Lengthen",
+  /* @icon */
+  "path-tools:lengthen"
+);
+var PATH_DIRECTION_CHROME_ID = "path-edit.direction";
+var DIRECTION_DEFAULTS = { color: "#e8590c", arrowPx: 9, ringPx: 8 };
+function directionCommands(set, toScreen, style = {}) {
+  const { color, arrowPx, ringPx } = { ...DIRECTION_DEFAULTS, ...style };
+  const paint = { kind: "solid", color };
+  const out = [];
+  for (const m of directionMarks(set)) {
+    const c = toScreen(m);
+    const ahead = toScreen({ x: m.x + m.dx, y: m.y + m.dy });
+    const k = Math.hypot(ahead.x - c.x, ahead.y - c.y);
+    if (k === 0) continue;
+    const ux = (ahead.x - c.x) / k, uy = (ahead.y - c.y) / k;
+    const tip = { x: c.x + ux * arrowPx / 2, y: c.y + uy * arrowPx / 2 };
+    const back = { x: c.x - ux * arrowPx / 2, y: c.y - uy * arrowPx / 2 };
+    const half = arrowPx * 0.45;
+    out.push({
+      kind: "path",
+      path: polygonFromPoints([tip, { x: back.x - uy * half, y: back.y + ux * half }, { x: back.x + uy * half, y: back.y - ux * half }]),
+      fill: { paint }
+    });
+  }
+  for (const sub of set.anchors) {
+    if (sub.length === 0) continue;
+    const start = toScreen(sub[0]);
+    out.push({ kind: "path", path: circlePath(start.x, start.y, ringPx), stroke: { paint, width: 2 } });
+  }
+  return out;
+}
+function createDirectionExtension(style = {}) {
+  return {
+    id: "pathDirection",
+    marks: (ctx) => ctx.isVisible(PATH_DIRECTION_CHROME_ID) ? directionCommands(ctx.anchors, ctx.toScreen, style) : []
+  };
+}
+var START_LABEL = "Make start point";
+var REVERSE_LABEL = "Reverse path direction";
+function loneAnchor(deps) {
+  const dep = depOf(deps);
+  return dep && dep.selectedAnchors.size === 1 ? [...dep.selectedAnchors][0] : null;
+}
+var setPathStartAction = {
+  id: "setPathStart",
+  icon: (
+    /* @icon */
+    "path-tools:setPathStart"
+  ),
+  label: START_LABEL,
+  tags: pathOperationTags("command"),
+  group: "anchors",
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const dep = depOf(deps);
+      const flat = loneAnchor(deps);
+      if (!dep || flat === null) return;
+      let start = -1;
+      const changed = commitAnchorEdit(dep, START_LABEL, (set) => {
+        const loc = locateAnchor(set, flat);
+        if (!loc) return false;
+        start = flat - loc.idx;
+        return setSubpathStart(set, flat);
+      });
+      if (changed) dep.setSelectedAnchors([start]);
+    }
+  },
+  enabled: (deps) => {
+    const flat = loneAnchor(deps);
+    if (flat === null) return ActionDisabledReason.SelectionRequired;
+    return anchorEditWouldChange(deps, (set) => setSubpathStart(set, flat)) ? true : ActionDisabledReason.NotApplicable;
+  }
+};
+function selectedPaths(deps) {
+  const dep = deps?.editAnchors;
+  if (!dep) return [];
+  return (deps?.selection?.get() ?? []).flatMap((id) => {
+    const path = dep.getEditablePath(id);
+    return path?.kind === "polygon" ? [{ id, path }] : [];
+  });
+}
+function reverseInPathEdit(deps) {
+  const dep = depOf(deps);
+  if (!dep) return false;
+  const selected = [...dep.selectedAnchors];
+  let after = [];
+  const changed = commitAnchorEdit(dep, REVERSE_LABEL, (set) => {
+    const subs = selected.length > 0 ? subpathsOfAnchors(set, selected) : void 0;
+    after = flatIndexesAfterReverse(set, selected, subs);
+    return reverseSubpaths(set, subs);
+  });
+  if (changed) dep.setSelectedAnchors(after);
+  return true;
+}
+var reversePathAction = {
+  id: "reversePath",
+  icon: (
+    /* @icon */
+    "path-tools:reversePath"
+  ),
+  label: REVERSE_LABEL,
+  tags: pathOperationTags("command"),
+  group: "path",
+  requires: ["editAnchors", "selection", "scene", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      if (reverseInPathEdit(deps)) return;
+      const edit = deps.editAnchors;
+      if (!edit?.editOps) return;
+      const ops = [];
+      for (const { id, path } of selectedPaths(deps)) {
+        const next = editAnchorSetTracked(path, (set) => reverseSubpaths(set));
+        if (next) ops.push(...edit.editOps(id, next.path, REVERSE_LABEL, next.origins));
+      }
+      commitOps(deps, ops, REVERSE_LABEL);
+    }
+  },
+  enabled: (deps) => {
+    if (depOf(deps)) return true;
+    return selectedPaths(deps).length > 0 ? true : ActionDisabledReason.SelectionRequired;
+  }
+};
+var LABEL = "Convert segments";
+var typeOf = (params) => params?.to === "line" || params?.to === "curve" ? params.to : void 0;
+var convertSegmentsAction = {
+  id: "convertSegments",
+  icon: (
+    /* @icon */
+    "path-tools:convertSegment"
+  ),
+  label: LABEL,
+  tags: pathOperationTags("command"),
+  group: "anchors",
+  variants: [
+    { key: "line", label: "Make segments straight", icon: (
+      /* @icon */
+      "path-tools:straightenSegment"
+    ), params: { to: "line" } },
+    { key: "curve", label: "Make segments curved", icon: (
+      /* @icon */
+      "path-tools:curveSegment"
+    ), params: { to: "curve" } }
+  ],
+  defaultBinding: { kind: "key", key: ["c", "C"], mods: { shift: true } },
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const dep = depOf(deps);
+      if (!dep) return;
+      const selected = [...dep.selectedAnchors];
+      commitAnchorEdit(dep, LABEL, (set) => convertSegments(set, segmentsBetweenAnchors(set, selected), typeOf(params)));
+    }
+  },
+  enabled: (deps) => {
+    const selected = [...depOf(deps)?.selectedAnchors ?? []];
+    const any = selected.length > 1 && anchorEditWouldChange(deps, (set) => convertSegments(set, segmentsBetweenAnchors(set, selected)));
+    return any ? true : ActionDisabledReason.SelectionRequired;
+  }
+};
+var convertSegmentAtAction = inPlane({
+  id: "convertSegmentAt",
+  icon: (
+    /* @icon */
+    "path-tools:convertSegment"
+  ),
+  label: "Convert segment",
+  tags: pathOperationTags("click"),
+  defaultBinding: { kind: "doubleClick", mods: { shift: true } },
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors", "view", "kitSettings"],
+  invoker: {
+    timing: "immediate",
+    run(deps, params) {
+      const wx = params?.worldX;
+      const wy = params?.worldY;
+      if (typeof wx !== "number" || typeof wy !== "number") return;
+      const under = segmentUnder(deps, wx, wy);
+      if (!under) return;
+      const { dep, path, hit } = under;
+      const next = editAnchorSetTracked(path, (set) => convertSegments(set, [hit], typeOf(params)));
+      if (next) dep.applyEdit(dep.editingId, next.path, "Convert segment", next.origins);
+    }
+  },
+  enabled: (deps, at2) => {
+    if (!deps?.editAnchors?.editingId) return ActionDisabledReason.NotApplicable;
+    if (at2 && !segmentUnder(deps, at2.x, at2.y)) return ActionDisabledReason.NotApplicable;
+    return true;
+  }
+}, editingLayer);
+var ANCHOR_SELECTION_GROUP = "anchorSelection";
+function editedSet(dep) {
+  const path = dep.getEditablePath(dep.editingId);
+  return path && path.kind === "polygon" ? pathToAnchors(path) : null;
+}
+var pathOpen = (deps) => depOf(deps) ? true : ActionDisabledReason.SelectionRequired;
+function makeSelectCommand(id, label, key, needsSelection, pick) {
+  const enabled = needsSelection ? requiresAnchorSelection : pathOpen;
+  return {
+    id,
+    label,
+    group: ANCHOR_SELECTION_GROUP,
+    tags: pathOperationTags("command"),
+    defaultBinding: key,
+    eligible: { capability: "edits-anchors" },
+    requires: ["editAnchors"],
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const dep = depOf(deps);
+        const set = dep && enabled(deps) === true ? editedSet(dep) : null;
+        if (set) dep.setSelectedAnchors(pick(set, [...dep.selectedAnchors], params));
+      }
+    },
+    enabled
+  };
+}
+var altKey = (key, code) => ({ kind: "key", key, code, mods: { alt: true } });
+var stepOf = (params) => {
+  const n = params?.n;
+  return typeof n === "number" && Number.isFinite(n) && n >= 1 ? Math.floor(n) : 2;
+};
+var growAnchorSelectionAction = makeSelectCommand(
+  "growAnchorSelection",
+  "Grow anchor selection",
+  { kind: "key", key: "]", code: "BracketRight" },
+  true,
+  (set, selected) => growAnchorSelection(set, selected)
+);
+var shrinkAnchorSelectionAction = makeSelectCommand(
+  "shrinkAnchorSelection",
+  "Shrink anchor selection",
+  { kind: "key", key: "[", code: "BracketLeft" },
+  true,
+  (set, selected) => shrinkAnchorSelection(set, selected)
+);
+var selectEveryNthAnchorAction = makeSelectCommand(
+  "selectEveryNthAnchor",
+  "Select every Nth anchor",
+  altKey("n", "KeyN"),
+  false,
+  (set, selected, params) => everyNthAnchor(set, stepOf(params), selected)
+);
+var selectCornerAnchorsAction = makeSelectCommand(
+  "selectCornerAnchors",
+  "Select corner anchors",
+  altKey("c", "KeyC"),
+  false,
+  (set) => cornerAnchors(set)
+);
+var selectSmoothAnchorsAction = makeSelectCommand(
+  "selectSmoothAnchors",
+  "Select smooth anchors",
+  altKey("m", "KeyM"),
+  false,
+  (set) => smoothAnchors(set)
+);
+var invertAnchorSelectionAction = makeSelectCommand(
+  "invertAnchorSelection",
+  "Invert anchor selection",
+  altKey("i", "KeyI"),
+  false,
+  (set, selected) => invertAnchorSelection(set, selected)
+);
+var LABEL2 = "Add extremes";
+function selectedSegments(set, selected) {
+  if (selected.size === 0) return void 0;
+  const picked = /* @__PURE__ */ new Set();
+  for (const flat of selected) {
+    const anchor = anchorAt(set, flat);
+    if (anchor) picked.add(anchor);
+  }
+  return (sub, segIdx) => {
+    const ends = segmentEnds(set.anchors, set.closed, sub, segIdx);
+    return ends !== null && picked.has(ends.a) && picked.has(ends.b);
+  };
+}
+function addExtremesTo(set, selected) {
+  const kept = [...selected].flatMap((flat) => anchorAt(set, flat) ?? []);
+  const added = addExtremaAnchors(set, selectedSegments(set, selected));
+  if (added.length === 0) return null;
+  const flatOf = new Map(set.anchors.flat().map((a, k) => [a, k]));
+  return [...kept.map((a) => flatOf.get(a)), ...added];
+}
+var addExtremeAnchorsAction = {
+  id: "addExtremeAnchors",
+  icon: (
+    /* @icon */
+    "path-tools:extremeAnchors"
+  ),
+  label: LABEL2,
+  group: "anchors",
+  tags: pathOperationTags("command"),
+  // `code` too: with Alt held on a Mac the key reads as another glyph.
+  defaultBinding: { kind: "key", key: "x", code: "KeyX", mods: { alt: true } },
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const dep = depOf(deps);
+      if (!dep) return;
+      let next = null;
+      commitAnchorEdit(dep, LABEL2, (set) => (next = addExtremesTo(set, dep.selectedAnchors)) !== null);
+      if (next) dep.setSelectedAnchors(next);
+    }
+  },
+  enabled: (deps) => {
+    const dep = depOf(deps);
+    if (!dep) return ActionDisabledReason.SelectionRequired;
+    return anchorEditWouldChange(deps, (set) => addExtremesTo(set, dep.selectedAnchors) !== null) ? true : ActionDisabledReason.NotApplicable;
+  }
+};
+var LABEL3 = "Resample";
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+function resampleOptions(count2, params) {
+  const spacing = num(params.spacing);
+  const tolerance = num(params.tolerance);
+  return {
+    ...spacing !== void 0 && spacing > 0 ? { spacing } : count2 > 0 ? { count: count2 } : {},
+    ...tolerance !== void 0 ? { tolerance } : {},
+    keepCorners: params.keepCorners !== false
+  };
+}
+var resamplePathAction = livePathEdit({
+  id: "resamplePath",
+  label: LABEL3,
+  param: "count",
+  initial: 0,
+  edit: ({ path }, count2, params) => resamplePath(path, resampleOptions(count2, params)),
+  commit: (_deps, next) => [...next.values()].flatMap(({ node, path }) => reshapeOps(node.node, path, LABEL3))
+});
 
 // src/pathEffects/params.ts
-var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
 var bool = (v) => typeof v === "boolean" ? v : void 0;
 var oneOf = (v, options) => typeof v === "string" && options.includes(v) ? v : void 0;
 function defined(fields) {
@@ -628,25 +1543,28 @@ function effectSettings(kind, params) {
   switch (kind) {
     case "blend":
       return defined({
-        steps: num(p.steps) === void 0 ? void 0 : Math.max(Math.round(num(p.steps)), 0),
+        steps: num2(p.steps) === void 0 ? void 0 : Math.max(Math.round(num2(p.steps)), 0),
         autoAlign: bool(p.autoAlign),
-        startOffset: num(p.startOffset) === void 0 ? void 0 : Math.round(num(p.startOffset)),
+        startOffset: num2(p.startOffset) === void 0 ? void 0 : Math.round(num2(p.startOffset)),
         reverse: bool(p.reverse),
-        rotate: bool(p.rotate)
+        rotate: bool(p.rotate),
+        spaceBy: oneOf(p.spaceBy, ["count", "distance"]),
+        distance: num2(p.distance) === void 0 ? void 0 : Math.max(num2(p.distance), 0.01),
+        orient: bool(p.orient)
       });
     case "bendAlong":
       return defined({
         fit: oneOf(p.fit, ["stretch", "natural"]),
-        baseline: num(p.baseline),
+        baseline: num2(p.baseline),
         flip: bool(p.flip),
-        tolerance: num(p.tolerance) === void 0 ? void 0 : Math.max(num(p.tolerance), 0.01)
+        tolerance: num2(p.tolerance) === void 0 ? void 0 : Math.max(num2(p.tolerance), 0.01)
       });
     case "repeatAlong":
       return defined({
-        count: num(p.count) === void 0 ? void 0 : Math.max(Math.round(num(p.count)), 0),
-        spacing: num(p.spacing) === void 0 ? void 0 : Math.max(num(p.spacing), 0),
+        count: num2(p.count) === void 0 ? void 0 : Math.max(Math.round(num2(p.count)), 0),
+        spacing: num2(p.spacing) === void 0 ? void 0 : Math.max(num2(p.spacing), 0),
         align: oneOf(p.align, ["start", "center", "end"]),
-        offset: num(p.offset),
+        offset: num2(p.offset),
         orient: bool(p.orient)
       });
   }
@@ -664,11 +1582,11 @@ var EFFECT_DEFAULTS = {
 
 // src/pathEffects/actions.ts
 var PATH_EFFECTS_GROUP = "pathEffects";
-function selectedPair(deps) {
+function selectedLeaves(deps) {
   const scene = deps?.scene;
   if (!scene || registeredPathEffects(scene.registry) === null) return null;
   const leaves = (deps?.selection?.get() ?? []).map((id) => scene.get(id)).filter((n) => n !== void 0 && n.kind === "leaf");
-  return leaves.length >= 2 ? [leaves[0], leaves[1]] : null;
+  return leaves.length >= 2 ? leaves : null;
 }
 function selectedEffects(deps, ids) {
   const scene = deps?.scene;
@@ -679,6 +1597,7 @@ function createEffectAction(spec) {
   return {
     id: spec.id,
     label: spec.label,
+    icon: spec.icon,
     tags: pathOperationTags("command"),
     group: PATH_EFFECTS_GROUP,
     // Alt+Shift, which no major browser takes for these letters (see
@@ -691,16 +1610,17 @@ function createEffectAction(spec) {
       timing: "immediate",
       run: (deps, params) => {
         const scene = deps.scene;
-        const pair = selectedPair(deps);
-        if (!scene || !pair) return;
+        const leaves = selectedLeaves(deps);
+        if (!scene || !leaves) return;
         const derivations = registeredPathEffects(scene.registry);
-        const [a, b] = pair;
+        const [a, b, c] = leaves;
+        const sources = spec.third && c ? [a.id, b.id, c.id] : [a.id, b.id];
         const effect = withEffectSettings(EFFECT_DEFAULTS[spec.kind], params);
         const sameParent = a.parent === b.parent;
         const slots = [slotOf(scene, a.id), slotOf(scene, b.id)];
         const index = !sameParent ? -1 : spec.between ? Math.max(...slots) : Math.max(...slots) + 1;
         const node = {
-          ...pathEffectNode(effect, [a.id, b.id], a.layer, derivations),
+          ...pathEffectNode(effect, sources, a.layer, derivations),
           id: scene.mintId(),
           parent: sameParent ? a.parent : null
         };
@@ -711,21 +1631,30 @@ function createEffectAction(spec) {
     enabled: (deps) => {
       const scene = deps?.scene;
       if (scene && registeredPathEffects(scene.registry) === null) return ActionDisabledReason.NotApplicable;
-      return selectedPair(deps) ? true : ActionDisabledReason.SelectionRequired;
+      return selectedLeaves(deps) ? true : ActionDisabledReason.SelectionRequired;
     }
   };
 }
 var blendAction = createEffectAction({
   id: "blend",
   label: "Blend",
+  icon: (
+    /* @icon */
+    "path-tools:blend"
+  ),
   kind: "blend",
   key: "b",
   code: "KeyB",
-  between: true
+  between: true,
+  third: true
 });
 var bendAlongAction = createEffectAction({
   id: "bendAlong",
   label: "Bend Along Path",
+  icon: (
+    /* @icon */
+    "path-tools:bendAlong"
+  ),
   kind: "bendAlong",
   key: "w",
   code: "KeyW",
@@ -734,6 +1663,10 @@ var bendAlongAction = createEffectAction({
 var repeatAlongAction = createEffectAction({
   id: "repeatAlong",
   label: "Repeat Along Path",
+  icon: (
+    /* @icon */
+    "path-tools:repeatAlong"
+  ),
   kind: "repeatAlong",
   key: "r",
   code: "KeyR",
@@ -743,6 +1676,10 @@ var EDIT_LABEL = "Edit Path Effect";
 var editPathEffectAction = {
   id: "editPathEffect",
   label: EDIT_LABEL,
+  icon: (
+    /* @icon */
+    "core:tune"
+  ),
   requires: ["scene", "applyOps"],
   invoker: {
     timing: "immediate",
@@ -777,6 +1714,10 @@ var EXPAND_LABEL = "Expand to Paths";
 var expandPathEffectAction = {
   id: "expandPathEffect",
   label: EXPAND_LABEL,
+  icon: (
+    /* @icon */
+    "path-tools:expand"
+  ),
   group: PATH_EFFECTS_GROUP,
   defaultBinding: { kind: "key", key: "e", code: "KeyE", mods: { alt: true, shift: true } },
   eligible: { capability: "creates-shapes" },
@@ -790,7 +1731,7 @@ var expandPathEffectAction = {
       const ops = [];
       const made = [];
       for (const { node, at: at2 } of effects) {
-        const sources = (Array.isArray(node.dependsOn) ? node.dependsOn : []).map((id) => derivedDepOf(scene, id));
+        const sources = (Array.isArray(node.dependsOn) ? node.dependsOn : []).map((id) => derivedDepOf(scene, id, node));
         const parts = pathEffectParts(node, sources) ?? [];
         ops.push(deleteNode(scene, node, EXPAND_LABEL));
         parts.forEach((part, k) => {
@@ -890,16 +1831,21 @@ var simplifyBrushAction = inPlane({
   },
   enabled: (deps) => brushing(deps) ? true : ActionDisabledReason.NotApplicable
 }, editingLayer);
-var simplifyBrushToolAction = pathEditToolAction(SIMPLIFY_BRUSH_TOOL, "Simplify brush", SimplifyBrushIcon);
+var simplifyBrushToolAction = pathEditToolAction(
+  SIMPLIFY_BRUSH_TOOL,
+  "Simplify brush",
+  /* @icon */
+  "core:simplifyBrush"
+);
 var DEFAULT_SMUDGE_RADIUS_PX = 40;
 var DEFAULT_SMUDGE_STRENGTH = 0.6;
-var LABEL = "Smudge brush";
-var num2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+var LABEL4 = "Smudge brush";
+var num3 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
 function radiusOf2(params) {
-  return Math.max(1, num2(params?.radiusPx, DEFAULT_SMUDGE_RADIUS_PX));
+  return Math.max(1, num3(params?.radiusPx, DEFAULT_SMUDGE_RADIUS_PX));
 }
 function strengthOf(params) {
-  return Math.min(1, Math.max(0, num2(params?.strength, DEFAULT_SMUDGE_STRENGTH)));
+  return Math.min(1, Math.max(0, num3(params?.strength, DEFAULT_SMUDGE_STRENGTH)));
 }
 function worldRadius(deps, radiusPx) {
   const reach = pxExtent(radiusPx, deps.view?.get().scale ?? { x: 1, y: 1 });
@@ -907,7 +1853,11 @@ function worldRadius(deps, radiusPx) {
 }
 var smudgeBrushAction = {
   id: "smudgeBrush",
-  label: LABEL,
+  label: LABEL4,
+  icon: (
+    /* @icon */
+    "path-tools:smudgeBrush"
+  ),
   tags: pathOperationTags("brush"),
   group: "path",
   eligible: { capability: "creates-shapes" },
@@ -923,7 +1873,7 @@ var smudgeBrushAction = {
       let radiusPx = radiusOf2(params(ctx));
       let at2 = { x: ctx.drag?.start.x ?? ctx.world.x, y: ctx.drag?.start.y ?? ctx.world.y };
       const current = /* @__PURE__ */ new Map();
-      const shapeOf = (id) => {
+      const shapeOf2 = (id) => {
         const entry = current.get(id);
         return entry ? withPath(entry.node.node, entry.path) : null;
       };
@@ -951,16 +1901,259 @@ var smudgeBrushAction = {
           const done = [...current.values()];
           current.clear();
           if (reason === "cancel" || done.length === 0) return;
-          commitOps(deps, done.flatMap(({ node, path }) => reshapeOps(node.node, path, LABEL)), LABEL);
+          commitOps(deps, done.flatMap(({ node, path }) => reshapeOps(node.node, path, LABEL4)), LABEL4);
         },
         previewIds: () => current.size > 0 ? [...current.keys()] : null,
-        previewPose: (id) => shapeOf(id)?.pose ?? null,
-        previewData: (id) => shapeOf(id)?.data ?? null
+        previewPose: (id) => shapeOf2(id)?.pose ?? null,
+        previewData: (id) => shapeOf2(id)?.data ?? null
       };
     }
   },
   enabled: (deps) => selectedPathNodes(deps).length > 0 ? true : ActionDisabledReason.SelectionRequired
 };
+var SPIRO_FORM = "spiro";
+function asSpiro(form) {
+  const s = form;
+  if (!s || s.kind !== SPIRO_FORM || !Array.isArray(s.kinds) || !Array.isArray(s.at)) return null;
+  if (s.kinds.length !== s.at.length) return null;
+  if (!s.kinds.every(isSpiroKind) || !s.at.every((i) => Number.isInteger(i))) return null;
+  return s;
+}
+function spiroOf(data) {
+  return asSpiro(data?.representation);
+}
+function withoutSpiro(data) {
+  if (!spiroOf(data)) return data;
+  const { representation: _dropped, ...rest } = data;
+  return rest;
+}
+var shapeOf = (kinds, at2) => ({ kind: SPIRO_FORM, kinds, at: at2 });
+function spiroNodeData(contours, like) {
+  const { path, at: at2 } = spiroToPath(contours, { like });
+  return { path, representation: shapeOf(contours.flatMap((c) => c.points.map((p) => p.kind)), at2) };
+}
+function spiroContours(path, spiro) {
+  return spiroContoursOf(path, spiro.kinds, spiro.at);
+}
+function spiroEditPath(path, spiro) {
+  const contours = spiroContours(path, spiro);
+  return contours ? spiroControlPath(contours) : null;
+}
+function respiro(path, spiro, control) {
+  const before = spiroContours(path, spiro);
+  if (!before) return null;
+  const solved = spiroNodeData(spiroContoursFromControl(control, before), path);
+  return { path: solved.path, spiro: solved.representation };
+}
+function respiroWithKind(path, spiro, flatIndexes, kind) {
+  const contours = spiroContours(path, spiro);
+  if (!contours) return null;
+  const picked = new Set(flatIndexes);
+  let i = 0;
+  let changed = false;
+  const next = contours.map((c) => ({
+    closed: c.closed,
+    points: c.points.map((p) => {
+      const hit = picked.has(i++) && p.kind !== kind;
+      changed ||= hit;
+      return hit ? { ...p, kind } : p;
+    })
+  }));
+  if (!changed) return null;
+  const solved = spiroNodeData(next, path);
+  return { path: solved.path, spiro: solved.representation };
+}
+
+// src/spiro/spiroCommands.ts
+var KIND_LABELS = {
+  smooth: "Smooth spiro point",
+  g4: "Extra-smooth (G4) spiro point",
+  corner: "Corner spiro point",
+  left: "Spiro point after a line",
+  right: "Spiro point before a line"
+};
+var nodeOf = (deps, id) => deps?.scene?.get(id);
+function editedSpiro(deps) {
+  const id = deps?.editAnchors?.editingId;
+  const node = id ? nodeOf(deps, id) : void 0;
+  return node && spiroOf(node.data) ? node : null;
+}
+function setKindOps(deps, kind, label) {
+  const node = editedSpiro(deps);
+  const selected = deps?.editAnchors?.selectedAnchors;
+  const world = node ? resolveEditablePathOf(node) : null;
+  if (!node || !world || !selected || selected.size === 0) return null;
+  const solved = respiroWithKind(world, spiroOf(node.data), selected, kind);
+  if (!solved) return null;
+  const stored = storeEditablePath({ pose: node.pose, data: withoutSpiro(node.data) }, solved.path);
+  if (!stored) return null;
+  return reshapeTo(node, { pose: stored.pose, data: { ...stored.data, representation: solved.spiro } }, label);
+}
+var kindOf = (params) => isSpiroKind(params?.kind) ? params.kind : "smooth";
+var setSpiroKindAction = {
+  id: "setSpiroKind",
+  label: "Set spiro point kind",
+  tags: pathOperationTags("command"),
+  group: "spiro",
+  variants: SPIRO_KINDS.map((kind) => ({ key: kind, label: KIND_LABELS[kind], params: { kind } })),
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors", "scene", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const kind = kindOf(params);
+      const ops = setKindOps(deps, kind, KIND_LABELS[kind]);
+      if (ops) commitOps(deps, ops, KIND_LABELS[kind]);
+    }
+  },
+  enabled: (deps) => editedSpiro(deps) && deps?.editAnchors?.selectedAnchors.size ? true : ActionDisabledReason.SelectionRequired
+};
+function spiroTargets(deps) {
+  const edited = deps?.editAnchors?.editingId;
+  const ids = edited ? [edited] : deps?.selection?.get() ?? [];
+  return ids.flatMap((id) => {
+    const node = nodeOf(deps, id);
+    return node && spiroOf(node.data) ? [node] : [];
+  });
+}
+var RELEASE_LABEL = "Convert to path";
+var releaseSpiroAction = {
+  id: "releaseSpiro",
+  label: RELEASE_LABEL,
+  tags: pathOperationTags("command"),
+  group: "spiro",
+  requires: ["selection", "scene", "applyOps", "editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const nodes = spiroTargets(deps);
+      if (nodes.length === 0) return;
+      commitOps(deps, nodes.map((node) => createSetDataOp({
+        id: node.id,
+        from: node.data,
+        to: withoutSpiro(node.data),
+        label: RELEASE_LABEL
+      })), RELEASE_LABEL);
+      if (deps.editAnchors?.editingId) deps.editAnchors.setSelectedAnchors([]);
+    }
+  },
+  enabled: (deps) => spiroTargets(deps).length > 0 ? true : ActionDisabledReason.SelectionRequired
+};
+var HALF_DISC_STEPS = 12;
+function halfDisc(x, y, r, toward2) {
+  const mid = Math.atan2(toward2.y, toward2.x);
+  const pts = [];
+  for (let i = 0; i <= HALF_DISC_STEPS; i++) {
+    const a = mid - Math.PI / 2 + Math.PI * i / HALF_DISC_STEPS;
+    pts.push({ x: x + r * Math.cos(a), y: y + r * Math.sin(a) });
+  }
+  return polygonFromPoints(pts);
+}
+function spiroMarker(kind) {
+  if (kind === "smooth") return (at2, size) => circlePath(at2.x, at2.y, size / 2);
+  if (kind === "corner") return (at2, size) => squarePath(at2.x, at2.y, size);
+  if (kind === "g4") {
+    return (at2, size) => {
+      const r = size / 2 * 1.25;
+      return polygonFromPoints([
+        { x: at2.x, y: at2.y - r },
+        { x: at2.x + r, y: at2.y },
+        { x: at2.x, y: at2.y + r },
+        { x: at2.x - r, y: at2.y }
+      ]);
+    };
+  }
+  return (at2, size, prev, next) => {
+    const from = kind === "left" ? prev : next;
+    const away = from ? { x: at2.x - from.x, y: at2.y - from.y } : { x: 1, y: 0 };
+    const toward2 = away.x === 0 && away.y === 0 ? { x: 1, y: 0 } : away;
+    return halfDisc(at2.x, at2.y, size / 2 * 1.2, toward2);
+  };
+}
+var CURVE_HIT_PX = 8;
+function spiroInsertAt(deps, x, y) {
+  const dep = deps.editAnchors;
+  const spiro = dep?.editingId ? spiroOf(dep.getNodeShape(dep.editingId)?.data) : null;
+  const curve = spiro ? dep.getOutlinePath?.(dep.editingId) : null;
+  if (!dep || !spiro || !curve) return null;
+  const contours = spiroContours(curve, spiro);
+  if (!contours) return null;
+  const set = pathToAnchors(curve);
+  const hit = nearestSegmentT(set.anchors, x, y, set.closed);
+  if (!hit) return null;
+  const scale = deps.view?.get().scale ?? { x: 1, y: 1 };
+  const on = set.anchors[hit.sub];
+  const a = on[hit.segIdx];
+  const b = on[(hit.segIdx + 1) % on.length];
+  const p = cubicPointAt(a, a.outHandle ?? a, b.inHandle ?? b, b, hit.t);
+  if (!withinPxRadius(p.x - x, p.y - y, CURVE_HIT_PX, scale)) return null;
+  const points = contours[hit.sub].points;
+  if (points.some((q) => withinPxRadius(q.x - x, q.y - y, CURVE_HIT_PX, scale))) return null;
+  const flat = flatAnchorIndex(set, hit.sub, hit.segIdx);
+  const first = contours.slice(0, hit.sub).reduce((n, c) => n + c.points.length, 0);
+  const at2 = spiro.at.slice(first, first + points.length);
+  let from = 0;
+  while (from + 1 < at2.length && at2[from + 1] <= flat) from++;
+  return { dep, contours, sub: hit.sub, slot: from + 1 };
+}
+function spiroInsertDrag(insert) {
+  const { dep, contours, sub, slot } = insert;
+  const id = dep.editingId;
+  const flat = contours.slice(0, sub).reduce((n, c) => n + c.points.length, 0) + slot;
+  const control = (x, y) => spiroControlPath(contours.map((c, s) => s !== sub ? c : {
+    closed: c.closed,
+    points: [...c.points.slice(0, slot), { x, y, kind: "smooth" }, ...c.points.slice(slot)]
+  }));
+  let current = null;
+  const preview = pathEditPreview(dep, id, () => current);
+  if (!preview) return {};
+  dep.setSelectedAnchors([flat]);
+  return {
+    kind: "spiro-insert-point",
+    onMove(moveCtx) {
+      current = control(moveCtx.world.x, moveCtx.world.y);
+    },
+    onEnd(endCtx, reason) {
+      current = null;
+      if (reason === "cancel") {
+        dep.setSelectedAnchors([]);
+        return;
+      }
+      dep.applyEdit(id, control(endCtx.world.x, endCtx.world.y), "Add spiro point");
+    },
+    previewIds: preview.previewIds,
+    previewPose: preview.previewPose,
+    previewData: preview.previewData
+  };
+}
+function spiroSegmentPress(deps, at2) {
+  const insert = spiroInsertAt(deps, at2.x, at2.y);
+  return insert ? () => spiroInsertDrag(insert) : null;
+}
+
+// src/spiro/spiroRepresentation.ts
+var spiroRepresentation = {
+  kind: SPIRO_FORM,
+  editPath(path, form) {
+    const spiro = asSpiro(form);
+    return spiro && spiroEditPath(path, spiro);
+  },
+  store(path, form, edited) {
+    const spiro = asSpiro(form);
+    const solved = spiro && respiro(path, spiro, edited);
+    return solved && { path: solved.path, form: solved.spiro };
+  },
+  anchorMarkers: (form) => asSpiro(form)?.kinds.map(spiroMarker) ?? [],
+  segmentPress: spiroSegmentPress
+};
+var spiroExtension = { id: "spiro", representation: spiroRepresentation };
+
+// src/spiro/spiroPreset.ts
+var spiroPreset = {
+  id: "spiro",
+  actions: [setSpiroKindAction, releaseSpiroAction],
+  pathEdit: [spiroExtension]
+};
 var TRIM_LABEL = "Trim segment";
 function planTrim(deps, params) {
   const press = pressOf(deps, params);
@@ -975,6 +2168,10 @@ function planTrim(deps, params) {
 }
 var trimPathAction = {
   id: "trimPath",
+  icon: (
+    /* @icon */
+    "path-tools:trim"
+  ),
   label: TRIM_LABEL,
   tags: pathOperationTags("click"),
   group: "path",
@@ -1049,10 +2246,8 @@ function resolvePathWarp(node) {
   const made = heldWarpResult(held);
   let toStorage = held.frame;
   if (!sameUnder(made, toStorage, stored.path)) {
-    const a = boundsOfPath(transformPath(made, toStorage));
-    const b = boundsOfPath(stored.path);
-    toStorage = multiply(boxToBox(a.x, a.y, a.width, a.height, b.x, b.y, b.width, b.height), toStorage);
-    if (!sameUnder(made, toStorage, stored.path)) return null;
+    toStorage = made.coords.length === stored.path.coords.length ? fitAffine(made.coords, stored.path.coords) : null;
+    if (!toStorage || !sameUnder(made, toStorage, stored.path)) return null;
   }
   return { held, toWorld: multiply(stored.toWorld, toStorage) };
 }
@@ -1111,13 +2306,43 @@ var freshIds = 0;
 function freshWarpId() {
   return `warp-${Date.now().toString(36)}-${(++freshIds).toString(36)}`;
 }
+function samePlacement(a, b) {
+  const ca = warpControls(a.held.warp), cb = warpControls(b.held.warp);
+  if (ca.length !== cb.length) return false;
+  const m = a.toWorld, n = b.toWorld;
+  const scale = Math.max(1, Math.abs(m[0]) + Math.abs(m[1]) + Math.abs(m[2]) + Math.abs(m[3]));
+  for (let i = 0; i < 4; i++) if (Math.abs(m[i] - n[i]) > 1e-4 * scale) return false;
+  const box = worldBoxOf([a.node]);
+  const tol = 1e-3 * Math.max(1, box ? Math.abs(box.x) + box.width + Math.abs(box.y) + box.height : 1);
+  if (Math.hypot(m[4] - n[4], m[5] - n[5]) > tol * scale) return false;
+  return ca.every((p, i) => {
+    const [ax, ay] = applyToPoint(m, p.x, p.y);
+    const [bx, by] = applyToPoint(n, cb[i].x, cb[i].y);
+    return Math.hypot(ax - bx, ay - by) <= tol;
+  });
+}
 function splitByWarp(nodes, kind) {
   const held = [];
   const bare = [];
+  const groups = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     const resolved = resolvePathWarp(node.node);
-    if (resolved && resolved.held.warp.kind === kind) held.push({ node, ...resolved, fresh: false });
-    else bare.push(node);
+    if (!resolved || resolved.held.warp.kind !== kind) {
+      bare.push(node);
+      continue;
+    }
+    let target = { node, ...resolved, fresh: false };
+    const id = resolved.held.id;
+    const firsts = groups.get(id) ?? [];
+    const joined = firsts.find((f) => samePlacement(f, target));
+    const groupId = joined ? joined.held.id : firsts.length > 0 ? `${id}~${node.id}` : id;
+    if (groupId !== id) {
+      const parted = { ...resolved.held, id: groupId };
+      rememberWarpResult(parted, heldWarpResult(resolved.held));
+      target = { ...target, held: parted };
+    }
+    if (!joined) groups.set(id, [...firsts, target]);
+    held.push(target);
   }
   return { held, bare, box: worldBoxOf(bare) };
 }
@@ -1255,7 +2480,7 @@ function createAddPinAction() {
           if (warp.kind !== "puppet" || !back) continue;
           const [lx, ly] = applyToPoint(back, at2.x, at2.y);
           const to = { x: lx, y: ly };
-          const from = unwarpPoint(pathWarpMap(warp), to);
+          const from = unwarpPoint(pathWarpMap(warp, target.held.source), to);
           const held = { ...target.held, warp: { ...warp, pins: [...warp.pins, { from, to }] } };
           const shape = storeWarp(target.node.node, held, target.toWorld);
           if (shape) next.set(target.node.id, { target, shape });
@@ -1301,6 +2526,10 @@ function createWarpGrabAction(kind) {
 var expandWarpAction = {
   id: "expandWarp",
   label: "Expand Warp",
+  icon: (
+    /* @icon */
+    "path-tools:expand"
+  ),
   tags: pathOperationTags("command"),
   group: "path",
   requires: REQUIRES,
@@ -1320,6 +2549,10 @@ var expandWarpAction = {
 var configureWarpAction = {
   id: "configureWarp",
   label: "Warp Settings",
+  icon: (
+    /* @icon */
+    "core:tune"
+  ),
   tags: pathOperationTags("command"),
   group: "path",
   requires: REQUIRES,
@@ -1350,14 +2583,38 @@ var handleLocksPreset = {
   id: "handleLocks",
   actions: [handleLockAngleAction, handleLockLengthAction]
 };
+function createSoftSelectionPreset(options) {
+  return { id: "softSelection", pathEdit: [createSoftSelectionExtension(options)] };
+}
+function createHandleSnapPreset(options = {}) {
+  return { id: "handleSnap", pathEdit: [createHandleSnapExtension(options)], snapSources: [handleSnapSource(options)] };
+}
+var handleSnapPreset = createHandleSnapPreset();
 var bridgePreset = {
   id: "bridge",
   actions: [bridgeAnchorsAction, bridgePathsAction]
 };
 var trimPreset = { id: "trim", actions: [trimPathAction] };
 var extendPreset = { id: "extend", actions: [extendToMeetAction] };
+var lengthenPreset = {
+  id: "lengthen",
+  actions: [lengthenPathAction, lengthenToolAction]
+};
 var smudgePreset = { id: "smudge", actions: [smudgeBrushAction] };
 var harmonizePreset = { id: "harmonize", actions: [harmonizeAnchorsAction] };
+var anchorSelectionPreset = {
+  id: "anchorSelection",
+  actions: [
+    growAnchorSelectionAction,
+    shrinkAnchorSelectionAction,
+    selectEveryNthAnchorAction,
+    selectCornerAnchorsAction,
+    selectSmoothAnchorsAction,
+    invertAnchorSelectionAction
+  ]
+};
+var resamplePreset = { id: "resample", actions: [resamplePathAction] };
+var addExtremesPreset = { id: "addExtremes", actions: [addExtremeAnchorsAction] };
 function createCurvatureCombPreset(options = () => void 0) {
   return {
     id: "curvatureComb",
@@ -1384,6 +2641,29 @@ function createConstraintsPreset(style = {}) {
   };
 }
 var constraintsPreset = createConstraintsPreset();
+function createCornerShapePreset(style = {}) {
+  return {
+    id: "cornerShape",
+    refines: ["paths"],
+    actions: [editCornerAction, setCornersAction, cycleCornerShapeAction],
+    pathEdit: [createCornerWidgetsExtension(style)]
+  };
+}
+var cornerShapePreset = createCornerShapePreset();
+function createPathStructurePreset(style = {}) {
+  return {
+    id: "pathStructure",
+    actions: [setPathStartAction, reversePathAction],
+    chromeRules: { [PATH_DIRECTION_CHROME_ID]: never },
+    pathEdit: [createDirectionExtension(style)]
+  };
+}
+var pathStructurePreset = createPathStructurePreset();
+var segmentTypePreset = {
+  id: "segmentType",
+  refines: ["paths"],
+  actions: [convertSegmentsAction, convertSegmentAtAction]
+};
 var pathEffectsPreset = {
   id: "pathEffects",
   actions: [blendAction, bendAlongAction, repeatAlongAction, editPathEffectAction, expandPathEffectAction]
@@ -1398,13 +2678,21 @@ var pathTools = {
     simplifyBrushPreset,
     handleLocksPreset,
     bridgePreset,
+    spiroPreset,
     trimPreset,
     extendPreset,
+    lengthenPreset,
     smudgePreset,
     harmonizePreset,
+    anchorSelectionPreset,
+    resamplePreset,
+    addExtremesPreset,
     curvatureCombPreset,
     balancePreset,
     constraintsPreset,
+    pathStructurePreset,
+    segmentTypePreset,
+    cornerShapePreset,
     pathEffectsPreset,
     warpPreset
   ]
@@ -1420,7 +2708,7 @@ function useStrokeClickTool(spec, options, extras = {}) {
       capabilities: ["creates-shapes"],
       hookName,
       cursor: "crosshair",
-      presentation: { label, group: "path", icon: createElement(icon) },
+      presentation: { label, group: "path", icon },
       ...extras.actions ? { actions: extras.actions } : {},
       ...extras.overlay ? { overlay: extras.overlay } : {},
       ...extras.onDeactivate ? { onDeactivate: extras.onDeactivate } : {},
@@ -1487,7 +2775,10 @@ function useTrimTool(options = {}) {
     };
   }, []);
   return useStrokeClickTool(
-    { id: "trim", label: "Trim segment", icon: SliceIcon, hookName: "useTrimTool", actionId: "trimPath", keybinding: TRIM_KEY },
+    { id: "trim", label: "Trim segment", icon: (
+      /* @icon */
+      "path-tools:trim"
+    ), hookName: "useTrimTool", actionId: "trimPath", keybinding: TRIM_KEY },
     options,
     extras
   );
@@ -1498,7 +2789,10 @@ function useExtendTool(options = {}) {
     {
       id: "extend",
       label: "Extend to next path",
-      icon: SliceIcon,
+      icon: (
+        /* @icon */
+        "path-tools:extend"
+      ),
       hookName: "useExtendTool",
       actionId: "extendToMeet",
       keybinding: EXTEND_KEY
@@ -1515,7 +2809,10 @@ function useSmudgeBrushTool(options = {}) {
     capabilities: ["creates-shapes"],
     hookName: "useSmudgeBrushTool",
     cursor: "crosshair",
-    presentation: { label: "Smudge brush", group: "path" },
+    presentation: { label: "Smudge brush", group: "path", icon: (
+      /* @icon */
+      "path-tools:smudgeBrush"
+    ) },
     bindings: [{ spec: { kind: "drag" }, actionId: "smudgeBrush" }]
   }), [keybinding]);
 }
@@ -1531,15 +2828,15 @@ function groupsOf(src, state) {
   const scene = src.scene();
   if (!scene || !src.active()) return [];
   const nodes = pathNodesOf(scene, state.selection, (id) => src.live.get(id));
-  const { held, box } = splitByWarp(nodes, src.kind);
+  const { held, bare, box } = splitByWarp(nodes, src.kind);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const t of held) {
     if (seen.has(t.held.id)) continue;
     seen.add(t.held.id);
-    out.push({ warpId: t.held.id, warp: t.held.warp, toWorld: t.toWorld });
+    out.push({ warpId: t.held.id, warp: t.held.warp, source: t.held.source, toWorld: t.toWorld });
   }
-  if (box) out.push({ warpId: null, warp: freshWarp(src.kind, box, src.settings()), toWorld: IDENTITY });
+  if (box) out.push({ warpId: null, warp: freshWarp(src.kind, box, src.settings()), source: bare[0].path, toWorld: IDENTITY });
   return out;
 }
 var toWorld = (m, p) => {
@@ -1563,7 +2860,7 @@ function guideLines(group) {
     return [[...c, c[0]]];
   }
   if (warp.kind !== "envelope") return [];
-  const map = pathWarpMap(warp);
+  const map = pathWarpMap(warp, group.source);
   const { box, mesh } = warp;
   const at2 = (u, v) => toWorld(m, map({ x: box.x + u * box.width, y: box.y + v * box.height }));
   const lines = [];
@@ -1609,8 +2906,8 @@ function warpAffordance(src) {
       const t = viewToTransform(view);
       const out = [];
       for (const group of groupsOf(src, state)) {
-        for (const line2 of guideLines(group)) {
-          const screen = line2.map((p) => {
+        for (const line3 of guideLines(group)) {
+          const screen = line3.map((p) => {
             const [x, y] = worldToScreen(p.x, p.y, t);
             return { x, y };
           });
@@ -1628,6 +2925,16 @@ function createWarpHandleLayer(src) {
 }
 
 // src/warp/useWarpTool.ts
+var WARP_ICONS = { distort: (
+  /* @icon */
+  "path-tools:distort"
+), envelope: (
+  /* @icon */
+  "path-tools:envelope"
+), puppet: (
+  /* @icon */
+  "path-tools:puppetWarp"
+) };
 var ANY_MODS = { shift: "optional", alt: "optional", meta: "optional", ctrl: "optional" };
 function bindingsFor(kind, settings) {
   const target = `affordance:layer:${warpLayerId(kind)}`;
@@ -1646,7 +2953,7 @@ function bindingsFor(kind, settings) {
 function definedOf(settings) {
   return Object.fromEntries(Object.entries(settings).filter(([, v]) => v !== void 0));
 }
-var KEYS = { distort: { key: "F" }, envelope: { key: "M" }, puppet: { key: "B" } };
+var KEYS = { distort: { key: "F" }, envelope: { key: "F", shift: true }, puppet: { key: "B" } };
 function createWarpToolState() {
   let active = false;
   let api = null;
@@ -1705,7 +3012,7 @@ function useWarpTool(kind, options, settings) {
       capabilities: ["creates-shapes"],
       cursor: kind === "puppet" ? "crosshair" : "default",
       actions,
-      presentation: { label: label ?? WARP_LABELS[kind], group: "warp" },
+      presentation: { label: label ?? WARP_LABELS[kind], group: "warp", icon: WARP_ICONS[kind] },
       onActivate: () => state.setActive(true),
       onDeactivate: () => state.setActive(false),
       bindings: bindingsFor(kind, () => definedOf(settingsRef.current))
@@ -1724,7 +3031,870 @@ function useEnvelopeTool(options = {}) {
 function usePuppetTool(options = {}) {
   return useWarpTool("puppet", options, { tolerance: options.tolerance });
 }
+var LABEL5 = "Shape Builder";
+function planShapeBuilder(adapter, opts = {}) {
+  const operands = resolveBooleanOperands(adapter, opts);
+  if ("kind" in operands) return operands;
+  const { sources } = operands;
+  const cut = pathFacePieces(...sources.map((s) => s.path)).filter((p) => p.path.commands.length > 0).map((p) => ({ path: p.path, source: p.sources[p.sources.length - 1] }));
+  if (cut.length === 0) return { kind: "noop", reason: "empty-result" };
+  const faces = cut.map(({ path, source }) => {
+    const { id, paint } = sources[source];
+    return paint ? { path, sourceId: id, paint } : { path, sourceId: id };
+  });
+  return {
+    kind: "faces",
+    faces,
+    faceAt: (x, y) => faces.findIndex((f) => pointInPath(f.path, x, y)),
+    commit(picked, mode) {
+      const chosen = [...new Set(picked)].filter((i) => i >= 0 && i < cut.length);
+      if (chosen.length === 0) return { kind: "noop", reason: "empty-result" };
+      const taken = new Set(chosen);
+      const pieces = cut.flatMap((c, i) => taken.has(i) ? [] : [{ ...c, producedBy: "divide" }]);
+      if (mode === "merge") {
+        const first = cut[chosen[0]];
+        const path = chosen.length === 1 ? first.path : pathUnion(...chosen.map((i) => cut[i].path));
+        pieces.push({ path, source: first.source, producedBy: "union" });
+      }
+      pieces.sort((a, b) => a.source - b.source);
+      return commitBooleanPieces(adapter, operands, pieces, LABEL5);
+    }
+  };
+}
+function facesAlong(plan, run, step) {
+  const out = [];
+  const visit = (x, y) => {
+    const i = plan.faceAt(x, y);
+    if (i >= 0 && !out.includes(i)) out.push(i);
+  };
+  if (run.length === 1) visit(run[0].x, run[0].y);
+  for (let k = 1; k < run.length; k++) {
+    const a = run[k - 1];
+    const b = run[k];
+    const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / step));
+    for (let s = k === 1 ? 0 : 1; s <= n; s++) visit(a.x + (b.x - a.x) * s / n, a.y + (b.y - a.y) * s / n);
+  }
+  return out;
+}
+
+// src/shapeBuilder/shapeBuilderActions.ts
+var SAMPLE_PX = 2;
+function createPlanCache(opts) {
+  let key = null;
+  let plan = null;
+  return {
+    get(deps) {
+      const adapter = deps.booleansAdapter;
+      if (!adapter) return null;
+      const scale = deps.view?.get().scale;
+      const o = { ...opts(), ...scale ? { scale } : {} };
+      const sel = [...adapter.getSelection()];
+      const next = JSON.stringify([o, sel.map((id) => [
+        id,
+        adapter.getWorldPath(id) ?? adapter.getTextSource?.(id) ?? null,
+        adapter.getPaint?.(id) ?? null
+      ])]);
+      if (next !== key) {
+        key = next;
+        const planned = planShapeBuilder(adapter, o);
+        plan = planned.kind === "faces" ? planned : null;
+      }
+      return plan;
+    },
+    clear() {
+      key = null;
+      plan = null;
+    }
+  };
+}
+var enoughSelected = (deps) => {
+  if (!deps?.booleansAdapter) return ActionDisabledReason.NotApplicable;
+  return (deps.selection?.get().length ?? 0) >= 2 ? true : ActionDisabledReason.SelectionRequired;
+};
+var OTHER = { merge: "delete", delete: "merge" };
+function createShapeBuilderActions(overlay, settings) {
+  const plans = createPlanCache(() => settings().op);
+  const modeFor = (alt) => alt ? OTHER[settings().mode] : settings().mode;
+  const show = (plan, faces, role) => {
+    overlay.set(faces.map((i) => ({ path: plan.faces[i].path, role })));
+  };
+  const eligible = { capability: "edits-page" };
+  const requires = ["booleansAdapter", "selection", "view"];
+  const hover = {
+    id: "shapeBuilder.hover",
+    label: "Shape Builder \u2014 show the face under the pointer",
+    eligible,
+    requires,
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const p = params;
+        const plan = enoughSelected(deps) === true ? plans.get(deps) : null;
+        const at2 = plan && p?.worldX !== void 0 && p.worldY !== void 0 ? plan.faceAt(p.worldX, p.worldY) : -1;
+        if (!plan || at2 < 0) overlay.clear();
+        else show(plan, [at2], modeFor(p?.mods?.alt) === "delete" ? "remove" : "chrome");
+      }
+    }
+  };
+  const leave = {
+    id: "shapeBuilder.leave",
+    label: "Shape Builder \u2014 clear the shown face",
+    eligible,
+    invoker: { timing: "immediate", run: () => overlay.clear() }
+  };
+  const click = {
+    id: "shapeBuilder.click",
+    label: "Shape Builder \u2014 take the face clicked",
+    eligible,
+    requires,
+    enabled: enoughSelected,
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const p = params;
+        const plan = plans.get(deps);
+        if (!plan || p?.pressX === void 0 || p.pressY === void 0) return;
+        const at2 = plan.faceAt(p.pressX, p.pressY);
+        if (at2 < 0) return;
+        overlay.clear();
+        plans.clear();
+        plan.commit([at2], modeFor(p.mods?.alt));
+      }
+    }
+  };
+  const drag = {
+    id: "shapeBuilder",
+    label: "Shape Builder",
+    eligible,
+    requires,
+    enabled: enoughSelected,
+    invoker: {
+      timing: "ongoing",
+      start: (ctx) => {
+        const plan = plans.get(ctx.deps);
+        if (!plan) return {};
+        const scale = ctx.deps.view?.get().scale ?? { x: 1, y: 1 };
+        const step = SAMPLE_PX / Math.max(1e-9, (Math.abs(scale.x) + Math.abs(scale.y)) / 2);
+        let last = ctx.drag?.start ?? ctx.world;
+        const trail = [last];
+        const picked = facesAlong(plan, [last], step);
+        let alt = ctx.modifiers.alt;
+        const paint = () => show(plan, picked, modeFor(alt) === "delete" ? "remove" : "picked");
+        paint();
+        return {
+          kind: "shapeBuilder",
+          onMove: (c) => {
+            const at2 = c.drag?.current ?? c.world;
+            for (const i of facesAlong(plan, [last, at2], step)) if (!picked.includes(i)) picked.push(i);
+            last = at2;
+            trail.push(at2);
+            alt = c.modifiers.alt;
+            paint();
+          },
+          onEnd: (_c, reason) => {
+            overlay.clear();
+            plans.clear();
+            if (reason === "commit") plan.commit(picked, modeFor(alt));
+          },
+          overlay: () => trail.length >= 2 ? { kind: "polyline", points: trail } : null
+        };
+      }
+    }
+  };
+  return {
+    actions: [hover, leave, click, drag],
+    reset: () => {
+      overlay.clear();
+      plans.clear();
+    }
+  };
+}
+
+// src/shapeBuilder/useShapeBuilderTool.ts
+function useShapeBuilderTool(options = {}) {
+  const settingsRef = useLatest({ op: { strokes: options.strokes ?? PATHFINDER_STROKES }, mode: options.mode ?? "merge" });
+  const overlay = useMemo(() => createPathOverlay({ id: "shape-builder-faces", label: "Shape Builder \u2014 faces" }), []);
+  const built = useMemo(
+    () => createShapeBuilderActions(overlay, () => settingsRef.current),
+    [overlay, settingsRef]
+  );
+  const { keybinding } = options;
+  return useMemo(() => defineTool({
+    id: "shapeBuilder",
+    capabilities: ["edits-page"],
+    hookName: "useShapeBuilderTool",
+    cursor: "crosshair",
+    presentation: { label: "Shape Builder", icon: (
+      /* @icon */
+      "core:union"
+    ), group: "shape" },
+    ...keybinding === null ? {} : { keybinding: keybinding ?? { key: "M", shift: true } },
+    actions: built.actions,
+    overlay: overlay.layer,
+    onDeactivate: built.reset,
+    bindings: [
+      { spec: { kind: "hover", mods: { alt: "optional" } }, actionId: "shapeBuilder.hover" },
+      { spec: { kind: "hover", motion: "leave", mods: { alt: "optional" } }, actionId: "shapeBuilder.leave" },
+      { spec: { kind: "click", mods: { alt: "optional" } }, actionId: "shapeBuilder.click" },
+      // Alt is read live, so it can be pressed or let go mid-drag.
+      { spec: { kind: "drag", mods: { alt: "optional" } }, actionId: "shapeBuilder", opts: { yields: true } },
+      { spec: { kind: "drag", mods: { shift: "optional" } }, actionId: "areaSelect" }
+    ]
+  }), [built, overlay, keybinding]);
+}
+function anchorPoints(path) {
+  return pathToAnchors(path).anchors.flat().map((a) => ({ x: a.x, y: a.y }));
+}
+function isWidthSet(entry) {
+  const { left, right } = vertexHalfWidths(entry, NaN);
+  return !Number.isNaN(left) || !Number.isNaN(right);
+}
+function targetOf(scene, node, scale) {
+  if (node.kind !== "leaf" || node.derivePath || node.derivePose || scene.isLocked(node.id) || scene.isHidden(node.id)) return null;
+  const stroke = node.data?.stroke;
+  if (!stroke?.paint) return null;
+  const path = resolveEditablePathOf(node);
+  return path ? { id: node.id, node, path, stroke, fallback: resolveStrokeWidth(stroke.width ?? 1, scale) } : null;
+}
+function edgeAt(scene, x, y, scale, accept) {
+  const nodes = scene.renderOrderNodes();
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const target = targetOf(scene, nodes[i], scale);
+    if (!target) continue;
+    const edge = strokeEdgeNear(target.path, target.stroke, x, y, { scale });
+    if (edge && accept(edge)) return { target, edge };
+  }
+  return null;
+}
+function widthTargetAt(scene, x, y, scale, reach) {
+  return edgeAt(scene, x, y, scale, (edge) => edge.gap <= reach)?.target ?? null;
+}
+function widthEdgeAt(scene, x, y, scale, reach) {
+  const found2 = edgeAt(scene, x, y, scale, (edge2) => Math.abs(edge2.gap) <= reach);
+  if (!found2) return null;
+  const { edge } = found2;
+  let index = null;
+  let bestD = reach;
+  const anchors = anchorPoints(found2.target.path);
+  anchors.forEach((p, i) => {
+    const d = Math.hypot(p.x - edge.x, p.y - edge.y);
+    if (d <= bestD) {
+      bestD = d;
+      index = i;
+    }
+  });
+  return { ...found2, index, at: index === null ? { x: edge.x, y: edge.y } : anchors[index] };
+}
+function widthsOf(target, count2) {
+  const own = target.stroke.vertexWidths ?? [];
+  return Array.from({ length: count2 }, (_, i) => isWidthSet(own[i]) ? own[i] : NaN);
+}
+function anchorNormals(path) {
+  const set = pathToAnchors(path);
+  return set.anchors.flatMap((sub, s) => sub.map((a, i) => {
+    const closed = set.closed?.[s] ?? false;
+    const next = sub[i + 1] ?? (closed ? sub[0] : void 0);
+    const prev = sub[i - 1] ?? (closed ? sub[sub.length - 1] : void 0);
+    const out = a.outHandle ?? next;
+    const inn = a.inHandle ?? prev;
+    let tx = 0, ty = 0;
+    for (const [from, to] of [[a, out], [inn, a]]) {
+      if (!from || !to) continue;
+      const len2 = Math.hypot(to.x - from.x, to.y - from.y);
+      if (len2 > 0) {
+        tx += (to.x - from.x) / len2;
+        ty += (to.y - from.y) / len2;
+      }
+    }
+    const len = Math.hypot(tx, ty);
+    return len > 0 ? { x: -ty / len, y: tx / len } : { x: 0, y: 1 };
+  }));
+}
+function widthPointNear(target, x, y, reach) {
+  const anchors = anchorPoints(target.path);
+  const normals = anchorNormals(target.path);
+  const widths = widthsOf(target, anchors.length);
+  let best = -1;
+  let bestD = reach;
+  anchors.forEach((a, i) => {
+    if (!isWidthSet(widths[i])) return;
+    const { left, right } = vertexHalfWidths(widths[i], target.fallback);
+    const n = normals[i];
+    const along2 = Math.min(right, Math.max(-left, (x - a.x) * n.x + (y - a.y) * n.y));
+    const d = Math.hypot(x - (a.x + n.x * along2), y - (a.y + n.y * along2));
+    if (d <= bestD) {
+      bestD = d;
+      best = i;
+    }
+  });
+  return best;
+}
+function gripAt(hit) {
+  const { target, edge } = hit;
+  const count2 = anchorPoints(target.path).length;
+  const widths = widthsOf(target, count2);
+  const factor = edge.factor > 0.05 ? edge.factor : 1;
+  const base = { target, side: edge.side, normal: { x: edge.nx, y: edge.ny }, factor };
+  if (hit.index !== null) {
+    const start2 = vertexHalfWidths(widths[hit.index], target.fallback);
+    return { ...base, path: target.path, widths, index: hit.index, at: hit.at, inserted: false, start: start2 };
+  }
+  const set = pathToAnchors(target.path);
+  const seg = nearestSegmentT(set.anchors, edge.x, edge.y, set.closed);
+  if (!seg) return null;
+  let inserted = -1;
+  const next = editAnchorSetTracked(target.path, (s) => {
+    inserted = insertAnchorOnSegment(s, seg);
+    return inserted !== -1;
+  });
+  if (!next || inserted < 0) return null;
+  const start = { left: edge.left / factor, right: edge.right / factor };
+  widths.splice(inserted, 0, widths.some(isWidthSet) ? vertexWidthFromSides(start.left, start.right) : NaN);
+  return { ...base, path: next.path, widths, index: inserted, at: anchorPoints(next.path)[inserted], inserted: true, start };
+}
+function movedSide(grip, delta) {
+  return Math.max(0, grip.start[grip.side] + delta / grip.factor);
+}
+function draggedWidth(grip, moved, oneSided) {
+  if (!oneSided) return 2 * moved;
+  return grip.side === "left" ? vertexWidthFromSides(moved, grip.start.right) : vertexWidthFromSides(grip.start.left, moved);
+}
+function storedWith(grip, widths) {
+  const { node, stroke } = grip.target;
+  const shaped = grip.inserted ? withPath(node, grip.path) : { pose: node.pose, data: node.data };
+  if (!shaped) return null;
+  const { vertexWidths: _old, ...rest } = stroke;
+  const next = widths.some(isWidthSet) ? { ...rest, vertexWidths: [...widths] } : rest;
+  return { pose: shaped.pose, data: { ...shaped.data, stroke: next } };
+}
+
+// src/girth/girthActions.ts
+var GIRTH_DRAG_ID = "girth.drag";
+var GIRTH_CLEAR_ID = "girth.clear";
+var GIRTH_HOVER_ID = "girth.hover";
+var GIRTH_UNHOVER_ID = "girth.unhover";
+var LABEL6 = "Stroke width";
+var REQUIRES2 = ["scene", "view", "selection", "applyOps"];
+var found = (deps, env) => {
+  const scene = deps.scene;
+  if (!scene) return null;
+  const s = deps.view?.get().scale ?? { x: 1, y: 1 };
+  const e = pxExtent(env.reachPx(), s);
+  return { scene, scale: meanScale(s), reach: Math.max(e.x, e.y) };
+};
+var focusOf = (path, widths, fallback, grab) => ({
+  anchors: pathToAnchors(path).anchors.flat().map((a) => ({ x: a.x, y: a.y })),
+  normals: anchorNormals(path),
+  widths,
+  fallback,
+  ...grab ? { grab } : {}
+});
+var restingFocus = (target) => focusOf(target.path, widthsOf(target, pathToAnchors(target.path).anchors.flat().length), target.fallback);
+function dropGrab(env) {
+  const last = env.focus();
+  if (!last?.grab) return;
+  const { grab: _grab, ...rest } = last;
+  env.setFocus(rest);
+}
+function commit(deps, grip, widths) {
+  const next = storedWith(grip, widths);
+  if (next) commitOps(deps, reshapeTo(grip.target.node, next, LABEL6), LABEL6);
+}
+var edgeOf = (grip, moved) => ({
+  x: grip.at.x + grip.normal.x * moved * grip.factor,
+  y: grip.at.y + grip.normal.y * moved * grip.factor
+});
+function dragAction(env) {
+  return {
+    timing: "ongoing",
+    start: ({ deps, drag, world }) => {
+      const press = drag?.start ?? world;
+      const at2 = found(deps, env);
+      const hit = at2 && widthEdgeAt(at2.scene, press.x, press.y, at2.scale, at2.reach);
+      const grip = hit && gripAt(hit);
+      if (!grip) return {};
+      const { fallback } = grip.target;
+      let widths = null;
+      let preview = null;
+      env.setFocus(focusOf(grip.path, grip.widths, fallback, { edge: edgeOf(grip, grip.start[grip.side]), at: grip.at }));
+      return {
+        kind: GIRTH_DRAG_ID,
+        onMove: (move) => {
+          const p = move.drag?.current ?? move.world;
+          const moved = movedSide(grip, (p.x - press.x) * grip.normal.x + (p.y - press.y) * grip.normal.y);
+          widths = [...grip.widths];
+          widths[grip.index] = draggedWidth(grip, moved, move.modifiers.alt);
+          preview = storedWith(grip, widths);
+          env.setFocus(focusOf(grip.path, widths, fallback, { edge: edgeOf(grip, moved), at: grip.at }));
+        },
+        // The dispatcher hands `onEnd` a context with empty deps.
+        onEnd: (_end, reason) => {
+          const done = widths;
+          widths = null;
+          preview = null;
+          if (reason === "cancel" || done === null) {
+            env.setFocus(restingFocus(grip.target));
+            return;
+          }
+          commit(deps, grip, done);
+          env.setFocus(focusOf(grip.path, done, fallback));
+        },
+        previewIds: () => preview ? [grip.target.id] : null,
+        previewPose: (id) => preview && id === grip.target.id ? preview.pose : null,
+        previewData: (id) => preview && id === grip.target.id ? preview.data : null
+      };
+    }
+  };
+}
+function createGirthActions(env) {
+  const eligible = { capability: "edits-page" };
+  const hasScene = (deps) => deps?.scene ? true : ActionDisabledReason.NotApplicable;
+  const base = { eligible, requires: REQUIRES2, enabled: hasScene };
+  return [
+    { id: GIRTH_DRAG_ID, label: "Girth \u2014 drag a stroke's edge", ...base, invoker: dragAction(env) },
+    {
+      id: GIRTH_CLEAR_ID,
+      label: "Girth \u2014 clear the width point under the pointer",
+      ...base,
+      invoker: {
+        timing: "immediate",
+        run: (deps, params) => {
+          const p = params;
+          const at2 = found(deps, env);
+          if (!at2 || p?.pressX === void 0 || p.pressY === void 0) return;
+          const target = widthTargetAt(at2.scene, p.pressX, p.pressY, at2.scale, at2.reach);
+          if (!target) return;
+          const index = widthPointNear(target, p.pressX, p.pressY, at2.reach);
+          const widths = widthsOf(target, pathToAnchors(target.path).anchors.flat().length);
+          if (index < 0 || !isWidthSet(widths[index])) return;
+          widths[index] = NaN;
+          const grip = {
+            target,
+            path: target.path,
+            inserted: false};
+          commit(deps, grip, widths);
+          env.setFocus(focusOf(target.path, widths, target.fallback));
+        }
+      }
+    },
+    {
+      id: GIRTH_HOVER_ID,
+      label: "Girth \u2014 show the stroke edge under the pointer",
+      ...base,
+      invoker: {
+        timing: "immediate",
+        run: (deps, params) => {
+          const p = params;
+          const at2 = found(deps, env);
+          if (!at2 || p?.worldX === void 0 || p.worldY === void 0) return;
+          const hit = widthEdgeAt(at2.scene, p.worldX, p.worldY, at2.scale, at2.reach);
+          if (!hit) {
+            dropGrab(env);
+            return;
+          }
+          const { edge } = hit;
+          const half = edge.side === "right" ? edge.right : edge.left;
+          env.setFocus({
+            ...restingFocus(hit.target),
+            grab: { edge: { x: edge.x + edge.nx * half, y: edge.y + edge.ny * half }, at: hit.at }
+          });
+        }
+      }
+    },
+    {
+      id: GIRTH_UNHOVER_ID,
+      label: "Girth \u2014 hide the grab point",
+      ...base,
+      invoker: {
+        timing: "immediate",
+        run: () => dropGrab(env)
+      }
+    }
+  ];
+}
+var DOT_RADIUS_PX = 3.5;
+var GRAB_RADIUS_PX = 4.5;
+var RIM = "#10161d";
+var SET = "#ffffff";
+var UNSET = "#8a94a3";
+var ACCENT2 = "#2f80ed";
+var ACROSS = { paint: { color: ACCENT2 }, width: 1 };
+var circle2 = (x, y, r) => ellipsePath({ x: x - r, y: y - r, width: 2 * r, height: 2 * r });
+var line2 = (a, b) => ({
+  kind: "path",
+  path: polylineFromPoints([{ x: a[0], y: a[1] }, { x: b[0], y: b[1] }]),
+  stroke: ACROSS
+});
+function createGirthOverlay(source) {
+  return {
+    id: "width-tool-anchors",
+    label: "Width anchors",
+    space: "screen",
+    subscribe: source.subscribe,
+    draw: (_data, view) => {
+      const focus = source.focus();
+      if (!focus) return [];
+      const m = viewToTransform(view);
+      const at2 = (x, y) => worldToScreen(x, y, m);
+      const lines = [];
+      const dots = [];
+      focus.anchors.forEach((a, i) => {
+        const set = isWidthSet(focus.widths[i]);
+        if (set) {
+          const { left, right } = vertexHalfWidths(focus.widths[i], focus.fallback);
+          const n = focus.normals[i];
+          lines.push(line2(at2(a.x - n.x * left, a.y - n.y * left), at2(a.x + n.x * right, a.y + n.y * right)));
+        }
+        const [x, y] = at2(a.x, a.y);
+        dots.push({
+          kind: "path",
+          path: circle2(x, y, DOT_RADIUS_PX),
+          fill: { paint: { kind: "solid", color: set ? SET : UNSET } },
+          stroke: { paint: { color: RIM }, width: 1 }
+        });
+      });
+      const grab = [];
+      if (focus.grab) {
+        const w = at2(focus.grab.at.x, focus.grab.at.y);
+        const e = at2(focus.grab.edge.x, focus.grab.edge.y);
+        grab.push(
+          line2(w, e),
+          { kind: "path", path: circle2(w[0], w[1], GRAB_RADIUS_PX + 1.5), stroke: { paint: { color: ACCENT2 }, width: 1.5 } },
+          {
+            kind: "path",
+            path: circle2(e[0], e[1], GRAB_RADIUS_PX),
+            fill: { paint: { kind: "solid", color: ACCENT2 } },
+            stroke: { paint: { color: SET }, width: 1 }
+          }
+        );
+      }
+      return [...lines, ...dots, ...grab];
+    }
+  };
+}
+
+// src/girth/useGirthTool.ts
+function useGirthTool(options = {}) {
+  const opts = useLatest({ reach: options.reach ?? 6 });
+  const env = useMemo(() => {
+    const changed = createEmitter();
+    const held = { focus: null };
+    const value = {
+      focus: () => held.focus,
+      setFocus: (next) => {
+        held.focus = next;
+        changed.emit();
+      },
+      reachPx: () => opts.current.reach,
+      listen: changed.subscribe
+    };
+    return value;
+  }, [opts]);
+  const actions = useMemo(() => createGirthActions(env), [env]);
+  const overlay = useMemo(() => createGirthOverlay({ focus: env.focus, subscribe: env.listen }), [env]);
+  const { keybinding } = options;
+  return useMemo(() => defineTool({
+    id: "girth",
+    capabilities: ["edits-page"],
+    hookName: "useGirthTool",
+    cursor: "crosshair",
+    presentation: { label: "Girth", group: "shape", icon: (
+      /* @icon */
+      "path-tools:girth"
+    ) },
+    ...keybinding === null ? {} : { keybinding: keybinding ?? { key: "W", shift: true } },
+    actions,
+    overlay,
+    onDeactivate: () => env.setFocus(null),
+    bindings: [
+      { spec: { kind: "drag", mods: { shift: "optional", alt: "optional" } }, actionId: GIRTH_DRAG_ID },
+      { spec: { kind: "click", mods: { alt: true } }, actionId: GIRTH_CLEAR_ID },
+      { spec: { kind: "hover", mods: { alt: "optional", shift: "optional" } }, actionId: GIRTH_HOVER_ID },
+      { spec: { kind: "hover", motion: "leave" }, actionId: GIRTH_UNHOVER_ID }
+    ]
+  }), [actions, overlay, keybinding, env]);
+}
+var MARKER_PX = 8;
+var CLOSE_HINT_PX = 8;
+function createSpiroPreviewLayer(opts) {
+  const color = opts.color ?? "#d4c4a8";
+  const paint = { kind: "solid", color };
+  return {
+    id: "spiroPreview",
+    label: "Spiro preview",
+    space: "screen",
+    draw: (_data, view) => {
+      const { points, cursor, closeHint } = opts.state();
+      if (points.length === 0) return [];
+      const sx = (p) => (p.x - view.x) * view.scale.x;
+      const sy = (p) => (p.y - view.y) * view.scale.y;
+      const out = [];
+      const through = cursor && !closeHint ? [...points, cursor] : [...points];
+      if (through.length >= 2) {
+        const { path } = spiroToPath([{ points: through, closed: closeHint }]);
+        const toScreen = [view.scale.x, 0, 0, view.scale.y, -view.x * view.scale.x, -view.y * view.scale.y];
+        out.push({ kind: "path", path: transformPath(path, toScreen), stroke: { paint, width: 1 } });
+      }
+      const screen = points.map((p) => ({ x: sx(p), y: sy(p) }));
+      points.forEach((p, i) => {
+        const path = spiroMarker(p.kind)(screen[i], MARKER_PX, screen[i - 1] ?? null, screen[i + 1] ?? null);
+        out.push({ kind: "path", path, fill: { paint }, stroke: { paint, width: 1 } });
+      });
+      if (closeHint) {
+        out.push({ kind: "path", path: circlePath(sx(points[0]), sy(points[0]), CLOSE_HINT_PX), stroke: { paint, width: 1.5 } });
+      }
+      return out;
+    }
+  };
+}
+
+// src/spiro/useSpiroTool.ts
+var fresh = () => ({ points: [], cursor: null, closeHint: false });
+var NO_KEYS = { alt: false, ctrl: false, meta: false, shift: false };
+function spiroActions(host) {
+  const s = host.scratch;
+  let followed;
+  const snaps = pointSnap();
+  const nearFirst = (x, y) => {
+    const { points } = s();
+    if (points.length < 3) return false;
+    const scale = followed?.view?.get().scale ?? { x: 1, y: 1 };
+    return withinPxRadius(points[0].x - x, points[0].y - y, host.options().closeHitRadius, scale);
+  };
+  const follower = createPointerFollower(() => track());
+  const track = () => {
+    const scratch = s();
+    if (scratch.points.length === 0) follower.unfollow();
+    const at2 = scratch.points.length > 0 ? follower.pointer()?.get() ?? null : null;
+    if (!at2) snaps.stop();
+    const p = at2 ? snaps.trail(followed?.snap, { x: at2.worldX, y: at2.worldY }, scratch.points.at(-1)) : null;
+    scratch.cursor = p ? { ...p, kind: "smooth" } : null;
+    scratch.closeHint = p !== null && nearFirst(p.x, p.y);
+    host.repaint();
+  };
+  const commit2 = (deps, closed) => {
+    const { points } = s();
+    if (points.length >= 2) {
+      const { path, representation } = spiroNodeData([{ points, closed }]);
+      const id = deps.insert?.commit(boundsOfPath(path), { kind: "path", path, closed, data: { representation } }) ?? null;
+      if (id !== null && host.options().autoSelect) deps.selection?.set([id]);
+    }
+    host.reset();
+    track();
+  };
+  const placing = () => s().points.length > 0 ? true : ActionDisabledReason.NotApplicable;
+  return [
+    {
+      id: "spiro.placePoint",
+      label: "Spiro \u2014 place point",
+      eligible: { capability: "creates-paths" },
+      requires: ["view", "pointer", "insert", "selection", "snap"],
+      invoker: {
+        timing: "immediate",
+        run: (deps, params) => {
+          const p = params;
+          if (p?.pressX === void 0 || p.pressY === void 0) return;
+          followed = deps;
+          follower.follow(deps.pointer);
+          const mods = snapMods({ modifiers: p.mods ?? NO_KEYS });
+          const at2 = snaps.place(deps.snap, { x: p.pressX, y: p.pressY }, mods, s().points.at(-1)).point;
+          if (nearFirst(at2.x, at2.y)) return commit2(deps, true);
+          const kind = isSpiroKind(p.kind) ? p.kind : "smooth";
+          s().points.push({ x: at2.x, y: at2.y, kind });
+          track();
+        }
+      }
+    },
+    {
+      id: "spiro.finish",
+      label: "Spiro \u2014 finish open curve",
+      eligible: { capability: "creates-paths" },
+      requires: ["insert", "selection"],
+      enabled: placing,
+      invoker: {
+        timing: "immediate",
+        run: (deps, params) => {
+          if (params?.viaDoubleClick) s().points.pop();
+          commit2(deps, false);
+        }
+      }
+    },
+    {
+      id: "spiro.removeLast",
+      label: "Spiro \u2014 take back the last point",
+      eligible: { capability: "creates-paths" },
+      enabled: placing,
+      invoker: { timing: "immediate", run: () => {
+        s().points.pop();
+        track();
+      } }
+    },
+    {
+      id: "spiro.cancel",
+      label: "Spiro \u2014 discard curve",
+      eligible: { capability: "creates-paths" },
+      // Declining with nothing placed passes Escape on to `escape`.
+      enabled: placing,
+      invoker: { timing: "immediate", run: () => {
+        host.reset();
+        track();
+      } }
+    }
+  ];
+}
+function useSpiroTool(options = {}) {
+  const { autoSelect = true, closeHitRadius = 8 } = options;
+  const opts = useLatest({ autoSelect, closeHitRadius });
+  const scratchRef = useRef(null);
+  if (scratchRef.current === null) scratchRef.current = fresh();
+  const [, forceRender] = useReducer((n) => n + 1, 0);
+  const [overlay] = useState(() => createSpiroPreviewLayer({ state: () => scratchRef.current }));
+  const actions = useMemo(() => spiroActions({
+    scratch: () => scratchRef.current,
+    reset: () => {
+      scratchRef.current = fresh();
+    },
+    options: () => opts.current,
+    repaint: forceRender
+  }), [opts]);
+  return useMemo(() => defineTool({
+    id: "spiro",
+    keybinding: { key: "P", shift: true },
+    capabilities: ["creates-paths"],
+    hookName: "useSpiroTool",
+    cursor: () => scratchRef.current?.closeHint ? "pointer" : cursorFor("pen", { fallback: "crosshair" }),
+    presentation: { label: "Spiro", icon: (
+      /* @icon */
+      "path-tools:spiro"
+    ), group: "draw" },
+    actions,
+    overlay,
+    overlayPosition: "before-selection",
+    onDeactivate: () => {
+      scratchRef.current = fresh();
+      forceRender();
+    },
+    bindings: [
+      { spec: { kind: "click", mods: { shift: "optional" } }, actionId: "spiro.placePoint" },
+      { spec: { kind: "click", mods: { alt: true, shift: "optional" } }, actionId: "spiro.placePoint", opts: { params: { kind: "corner" } } },
+      { spec: { kind: "click", mods: { mod: true, shift: "optional" } }, actionId: "spiro.finish" },
+      { spec: { kind: "doubleClick", mods: { shift: "optional", alt: "optional" } }, actionId: "spiro.finish", opts: { params: { viaDoubleClick: true } } },
+      { spec: { kind: "key", key: "Enter" }, actionId: "spiro.finish" },
+      { spec: { kind: "key", key: "Backspace" }, actionId: "spiro.removeLast" },
+      { spec: { kind: "key", key: "Escape" }, actionId: "spiro.cancel" }
+    ]
+  }), [actions, overlay]);
+}
+var CORNER_K_SLIDER_RANGE = 4;
+var ENABLED = { path: "count", above: 0 };
+var CORNER_CONTROLS_PROMPT = "Click a corner anchor (Shift-click for more) to edit it";
+var CORNER_CONTROLS = {
+  name: "Corner shape",
+  children: {
+    count: { kind: "number", name: "Selected corners", description: "", default: 0, hidden: true },
+    shape: {
+      kind: "enum",
+      name: "Shape",
+      description: "",
+      default: "round",
+      control: "toggle",
+      enableIf: ENABLED,
+      options: CORNER_KEYWORDS.map((w) => ({ value: w, label: w })),
+      // A parameter between the keywords, or a sharp corner, presses none.
+      encoding: {
+        read: (stored) => CORNER_KEYWORDS.includes(stored) ? stored : void 0,
+        write: (option) => option
+      }
+    },
+    k: {
+      kind: "number",
+      name: "Curvature",
+      description: "The superellipse() parameter: 1 is round, 0 a bevel, -1 a scoop.",
+      default: 1,
+      min: -CORNER_K_SLIDER_RANGE,
+      max: CORNER_K_SLIDER_RANGE,
+      step: 0.05,
+      control: "slider",
+      enableIf: ENABLED
+    },
+    radius: {
+      kind: "number",
+      name: "Radius",
+      description: "How far along each edge the corner is cut.",
+      default: 0,
+      min: 0,
+      step: 1,
+      control: "input",
+      enableIf: ENABLED
+    }
+  }
+};
+var SHARP = /* @__PURE__ */ Symbol("sharp");
+function agreed(values) {
+  const first = values[0];
+  if (!values.every((v) => Object.is(v, first))) return { mixed: true };
+  return { value: first === SHARP ? void 0 : first, mixed: false };
+}
+function cornerControlsState(path, selected) {
+  if (!path) return { values: { count: 0, shape: null }, mixed: /* @__PURE__ */ new Set() };
+  const specs = cornerFrames(path).filter((f) => selected.has(f.index)).map((f) => cornerSpecAt(path, f.index));
+  const cut = specs.map((c) => c && c.radius > 0 ? c : SHARP);
+  const shape = agreed(cut.map((c) => c === SHARP ? SHARP : keywordOf(c.shape)));
+  const k = agreed(cut.map((c) => c === SHARP ? SHARP : clampK(cornerShapeK(c.shape))));
+  const radius = agreed(specs.map((c) => Math.round((c?.radius ?? 0) * 100) / 100));
+  const mixed = /* @__PURE__ */ new Set();
+  if (shape.mixed) mixed.add("shape");
+  if (k.mixed) mixed.add("k");
+  if (radius.mixed) mixed.add("radius");
+  return {
+    values: {
+      count: specs.length,
+      shape: shape.value ?? null,
+      ...k.value !== void 0 ? { k: k.value } : {},
+      ...radius.value !== void 0 ? { radius: radius.value } : {}
+    },
+    mixed
+  };
+}
+function keywordOf(shape) {
+  return typeof shape === "number" ? cornerKeywordOf(shape) : shape;
+}
+var clampK = (k) => Math.max(-CORNER_K_SLIDER_RANGE, Math.min(CORNER_K_SLIDER_RANGE, k));
+function cornerControlsParams(field, value) {
+  if (field === "shape" && CORNER_KEYWORDS.includes(value)) return { shape: value };
+  if (field === "k" && typeof value === "number" && Number.isFinite(value)) return { shape: value };
+  if (field === "radius" && typeof value === "number" && Number.isFinite(value)) return { radius: value };
+  return null;
+}
+function snapshot(scene, selection) {
+  const id = selection.editingId();
+  const path = id ? resolveEditablePathOf(scene.get(id)) : null;
+  const { values, mixed } = cornerControlsState(path, selection.selectedAnchors());
+  return JSON.stringify({ values, mixed: [...mixed] });
+}
+function useCornerControls(scene, selection) {
+  const actions = useActionsRegistry();
+  const subscribe = useCallback((l) => {
+    const offScene = scene.subscribe(l);
+    const offSelection = selection.subscribe(l);
+    return () => {
+      offScene();
+      offSelection();
+    };
+  }, [scene, selection]);
+  const key = useSyncExternalStore(subscribe, () => snapshot(scene, selection));
+  const shown = useMemo(() => {
+    const parsed = JSON.parse(key);
+    return { values: parsed.values, mixed: new Set(parsed.mixed) };
+  }, [key]);
+  const onChange = useCallback((field, value) => {
+    const params = cornerControlsParams(field, value);
+    if (params) actions?.trigger("setCorners", params);
+  }, [actions]);
+  const prompt = shown.values.count === 0 ? CORNER_CONTROLS_PROMPT : null;
+  return { schema: CORNER_CONTROLS, prompt, ...shown, onChange };
+}
 
-export { CONSTRAINTS_EXTENSION_ID, DEFAULT_BRIDGE_TENSION, DEFAULT_ENVELOPE_SIZE, DEFAULT_SMUDGE_RADIUS_PX, DEFAULT_SMUDGE_STRENGTH, DEFAULT_WARP_TOLERANCE, PATH_BALANCE_CHROME_ID, PATH_COMB_CHROME_ID, PATH_EFFECTS_GROUP, SIMPLIFY_BRUSH_RADIUS_PX, SIMPLIFY_BRUSH_TOOL, balanceCommands, balanceHandlesAction, balancePreset, bendAlongAction, blendAction, bridgeAnchorsAction, bridgePathsAction, bridgePreset, bridgeTensionOf, brushRingCursor, combCommands, configureWarpAction, constrainAnchorsAction, constraintAxisOf, constraintConflictsOf, constraintsForAnchors, constraintsOf, constraintsPreset, createBalanceExtension, createBalancePreset, createCombExtension, createConstraintsExtension, createConstraintsPreset, createCurvatureCombPreset, curvatureCombPreset, deleteConstraintAction, editPathEffectAction, equalizeHandlesAction, expandPathEffectAction, expandWarpAction, extendPreset, extendToMeetAction, handleLockAngleAction, handleLockLengthAction, handleLocksPreset, harmonizeAnchorsAction, harmonizePreset, heldPathWarpOf, pathEffectsPreset, pathTools, planTrim, repeatAlongAction, resolvePathWarp, selectedConstraintOf, setConstraints, simplifyBrushAction, simplifyBrushPreset, simplifyBrushToolAction, smudgeBrushAction, smudgePreset, trimPathAction, trimPreset, unconstrainAnchorsAction, useDistortTool, useEnvelopeTool, useExtendTool, usePuppetTool, useSmudgeBrushTool, useTrimTool, warpHandleScratchOf, warpLayerId, warpPreset, withPathWarp, withoutPathWarp };
+export { ANCHOR_SELECTION_GROUP, CONSTRAINTS_EXTENSION_ID, CORNER_CONTROLS, CORNER_CONTROLS_PROMPT, CORNER_K_SLIDER_RANGE, CORNER_WIDGET_STANDOFF_PX, DEFAULT_BRIDGE_TENSION, DEFAULT_CORNER_SHAPE, DEFAULT_CORNER_TRIM_SHARE, DEFAULT_ENVELOPE_SIZE, DEFAULT_SMUDGE_RADIUS_PX, DEFAULT_SMUDGE_STRENGTH, DEFAULT_WARP_TOLERANCE, GIRTH_CLEAR_ID, GIRTH_DRAG_ID, GIRTH_HOVER_ID, GIRTH_UNHOVER_ID, LENGTHEN_TOOL, PATH_BALANCE_CHROME_ID, PATH_COMB_CHROME_ID, PATH_CORNERS_CHROME_ID, PATH_DIRECTION_CHROME_ID, PATH_EFFECTS_GROUP, SIMPLIFY_BRUSH_RADIUS_PX, SIMPLIFY_BRUSH_TOOL, SPIRO_FORM, addExtremeAnchorsAction, addExtremesPreset, anchorSelectionPreset, asSpiro, balanceCommands, balanceHandlesAction, balancePreset, bendAlongAction, blendAction, bridgeAnchorsAction, bridgePathsAction, bridgePreset, bridgeTensionOf, brushRingCursor, combCommands, configureWarpAction, constrainAnchorsAction, constraintAxisOf, constraintConflictsOf, constraintLinkNode, constraintLinkOf, constraintsForAnchors, constraintsOf, constraintsPreset, convertSegmentAtAction, convertSegmentsAction, cornerControlsParams, cornerControlsState, cornerShapePreset, cornerWidgetCommands, cornerWidgetFrames, createBalanceExtension, createBalancePreset, createCombExtension, createConstraintsExtension, createConstraintsPreset, createCornerShapePreset, createCornerWidgetsExtension, createCurvatureCombPreset, createDirectionExtension, createGirthActions, createGirthOverlay, createHandleSnapExtension, createHandleSnapPreset, createPathStructurePreset, createSoftSelectionExtension, createSoftSelectionPreset, createSpiroPreviewLayer, curvatureCombPreset, cycleCornerShapeAction, deleteConstraintAction, directionCommands, editCornerAction, editPathEffectAction, equalizeHandlesAction, expandPathEffectAction, expandWarpAction, extendPreset, extendToMeetAction, facesAlong, growAnchorSelectionAction, handleLockAngleAction, handleLockLengthAction, handleLocksPreset, handleSnapPreset, handleSnapSource, harmonizeAnchorsAction, harmonizePreset, heldPathWarpOf, invertAnchorSelectionAction, lengthenPathAction, lengthenPreset, lengthenToolAction, pathEffectsPreset, pathStructurePreset, pathTools, planShapeBuilder, planTrim, releaseSpiroAction, repeatAlongAction, resamplePathAction, resamplePreset, resolvePathWarp, respiro, respiroWithKind, reversePathAction, segmentTypePreset, selectCornerAnchorsAction, selectEveryNthAnchorAction, selectSmoothAnchorsAction, selectedConstraintOf, setConstraints, setCornersAction, setPathStartAction, setSpiroKindAction, shrinkAnchorSelectionAction, simplifyBrushAction, simplifyBrushPreset, simplifyBrushToolAction, smudgeBrushAction, smudgePreset, spiroContours, spiroEditPath, spiroExtension, spiroMarker, spiroNodeData, spiroOf, spiroPreset, spiroRepresentation, trimPathAction, trimPreset, unconstrainAnchorsAction, useCornerControls, useDistortTool, useEnvelopeTool, useExtendTool, useGirthTool, usePuppetTool, useShapeBuilderTool, useSmudgeBrushTool, useSpiroTool, useTrimTool, warpHandleScratchOf, warpLayerId, warpPreset, withPathWarp, withoutPathWarp, withoutSpiro };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map