@weasel-js/path-tools 0.0.0-stage → 1.11.0

package/dist/index.js

@@ -0,0 +1,3900 @@
+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 { 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) {
+  if (!dep?.editingId || !kind) return null;
+  const m = kind.match(/^balance:(\d+)$/);
+  if (!m) return null;
+  const path = dep.getEditablePath(dep.editingId);
+  if (!path || path.kind !== "polygon") return null;
+  const loc = locateAnchor(pathToAnchors(path), parseInt(m[1], 10));
+  return loc ? { dep, path, sub: loc.sub, segIdx: loc.idx } : null;
+}
+var NO_LOCKS = { angle: false, length: false };
+function gripEnabled(deps) {
+  if (!deps?.editAnchors?.editingId || pathEditToolActive(deps)) return ActionDisabledReason.NotApplicable;
+  return true;
+}
+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",
+    start(ctx) {
+      const target = gripTarget(ctx.deps.editAnchors, ctx.drag?.affordance?.kind);
+      if (!target) return {};
+      const { dep, path: originPath, sub, segIdx } = target;
+      const id = dep.editingId;
+      const origin = pathToAnchors(originPath);
+      const symmetries = editedPathSymmetries(ctx.deps.pathSymmetry, id, origin);
+      const press = { x: ctx.world.x, y: ctx.world.y };
+      const pressFactor = balanceFactorToward(origin, sub, segIdx, press);
+      let current = null;
+      const preview = pathEditPreview(dep, id, () => current?.path ?? null);
+      if (!preview) return {};
+      return {
+        kind: "balance-handles",
+        onMove(moveCtx) {
+          const held = (moveCtx.deps.editAnchors ?? dep).handleLocks ?? NO_LOCKS;
+          if (locksInForce(held, moveCtx).length) {
+            current = null;
+            return;
+          }
+          const at2 = balanceFactorToward(origin, sub, segIdx, moveCtx.world);
+          const factor = pressFactor > 0 ? at2 / pressFactor : at2;
+          current = editAnchorSetTracked(originPath, (set) => scaleSegmentHandles(set, sub, segIdx, factor, symmetries)) ?? current;
+        },
+        onEnd(_endCtx, reason) {
+          const done = current;
+          current = null;
+          if (reason === "cancel" || !done) return;
+          dep.applyEdit(id, done.path, "Balance handles", done.origins);
+        },
+        previewIds: preview.previewIds,
+        previewPose: preview.previewPose,
+        previewData: preview.previewData
+      };
+    }
+  },
+  enabled: gripEnabled
+}, editingLayer);
+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" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const kind = params?.affordance?.kind;
+      const target = gripTarget(deps.editAnchors, kind);
+      if (!target) return;
+      const { dep, sub, segIdx } = target;
+      commitAnchorEdit(dep, "Equalize handles", (set) => equalizeSegmentHandles(set, sub, segIdx));
+    }
+  },
+  enabled: gripEnabled
+};
+var PATH_BALANCE_CHROME_ID = "path-edit.balance";
+var BALANCE_DEFAULTS = {
+  color: "#9b6bd6",
+  gripFill: "#ffffff",
+  gripRadiusPx: 4
+};
+function balanceCommands(set, toScreen, style = {}) {
+  const { color, gripFill, gripRadiusPx } = { ...BALANCE_DEFAULTS, ...style };
+  const paint = { kind: "solid", color };
+  const out = [];
+  for (const line3 of handleBalances(set)) {
+    const grip = toScreen(line3.grip);
+    out.push({
+      kind: "path",
+      path: linePath(toScreen(line3.from), toScreen(line3.to)),
+      stroke: { paint, width: 1 }
+    });
+    out.push({
+      kind: "path",
+      path: circlePath(grip.x, grip.y, gripRadiusPx),
+      fill: { paint: { kind: "solid", color: gripFill } },
+      stroke: { paint, width: 1.5 }
+    });
+  }
+  return out;
+}
+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((line3) => ({
+      x: line3.grip.x,
+      y: line3.grip.y,
+      hitKind: `balance:${line3.flat}`,
+      chromeId: PATH_BALANCE_CHROME_ID
+    }))
+  };
+}
+var DEFAULT_BRIDGE_TENSION = 0.4;
+function bridgeTensionOf(params) {
+  const t = params?.tension;
+  return typeof t === "number" && Number.isFinite(t) ? Math.max(0, t) : DEFAULT_BRIDGE_TENSION;
+}
+var bridgePathsAction = joinPathsCommand(
+  {
+    id: "bridgePaths",
+    label: "Bridge",
+    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 } }
+  },
+  (params) => ({ tension: bridgeTensionOf(params) })
+);
+var join = joinSelectedAnchors({});
+var bridgeAnchorsAction = {
+  id: "bridgeAnchors",
+  label: "Bridge anchors",
+  tags: pathOperationTags("command"),
+  icon: (
+    /* @icon */
+    "core:bridge"
+  ),
+  group: "anchors",
+  defaultBinding: { kind: "key", key: "j", code: "KeyJ", mods: { mod: true, shift: true } },
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const dep = depOf(deps);
+      if (!dep || dep.selectedAnchors.size !== 2) return;
+      const selected = [...dep.selectedAnchors];
+      const bridge = joinSelectedAnchors({ tension: bridgeTensionOf(params) });
+      if (commitAnchorEdit(dep, "Bridge anchors", (set) => bridge(set, selected))) dep.setSelectedAnchors([]);
+    }
+  },
+  enabled: (deps) => {
+    const dep = depOf(deps);
+    if (!dep || dep.selectedAnchors.size !== 2) return ActionDisabledReason.SelectionRequired;
+    const selected = [...dep.selectedAnchors];
+    return anchorEditWouldChange(deps, (set) => join(set, selected)) ? true : ActionDisabledReason.NotApplicable;
+  }
+};
+var PATH_COMB_CHROME_ID = "path-edit.comb";
+var COMB_DEFAULTS = { scale: 2e3, samplesPerSegment: 24, color: "rgba(224, 102, 58, 0.75)" };
+function combCommands(set, toScreen, opts = {}) {
+  const { scale, samplesPerSegment, color } = { ...COMB_DEFAULTS, ...opts };
+  const paint = { kind: "solid", color };
+  const out = [];
+  for (const { teeth } of curvatureComb(set, { scale, samplesPerSegment })) {
+    const tips = teeth.map((t) => toScreen({ x: t.tipX, y: t.tipY }));
+    teeth.forEach((t, i) => {
+      out.push({ kind: "path", path: linePath(toScreen(t), tips[i]), stroke: { paint, width: 1 } });
+    });
+    out.push({ kind: "path", path: polylineFromPoints(tips), stroke: { paint, width: 1.5 } });
+  }
+  return out;
+}
+function createCombExtension(options = () => void 0) {
+  return {
+    id: "curvatureComb",
+    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;
+  return Array.isArray(list) ? list : NONE;
+}
+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 conflictsIn(path, constraints, constraintAxisOf(node));
+}
+function constrainNodeEdit(node, worldPath, origins) {
+  const constraints = constraintsOf(node?.data);
+  const before = constraints.length > 0 ? resolveEditablePathOf(node) : null;
+  if (!before) return { path: worldPath, constraints };
+  const edit = constrainPathEdit(before, worldPath, constraints, { origins, axisAngle: constraintAxisOf(node) });
+  if (!edit.converged) return null;
+  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, 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 });
+function line(b, p, q) {
+  b.moveTo(p.x, p.y).lineTo(q.x, q.y);
+}
+function centroidOf(points) {
+  const n = points.length || 1;
+  return { x: points.reduce((s, p) => s + p.x, 0) / n, y: points.reduce((s, p) => s + p.y, 0) / n };
+}
+function toward(p, to) {
+  const len = Math.hypot(to.x - p.x, to.y - p.y);
+  return len > 1e-9 ? { x: (to.x - p.x) / len, y: (to.y - p.y) / len } : { x: 0, y: 1 };
+}
+function frameOf(points, [i, j], inside) {
+  const a = points[i];
+  const c = points[j];
+  const len = Math.hypot(c.x - a.x, c.y - a.y);
+  const u = len > 1e-9 ? { x: (c.x - a.x) / len, y: (c.y - a.y) / len } : { x: 1, y: 0 };
+  const m = { x: (a.x + c.x) / 2, y: (a.y + c.y) / 2 };
+  const left = { x: -u.y, y: u.x };
+  const n = left.x * (inside.x - m.x) + left.y * (inside.y - m.y) < 0 ? { x: u.y, y: -u.x } : left;
+  return { m, u, n, o: at(m, n, OFFSET) };
+}
+function segmentsOf(c) {
+  switch (c.kind) {
+    case "fixed":
+    case "tangent":
+    case "onPath":
+    case "coincident":
+      return [];
+    case "horizontal":
+    case "vertical":
+    case "length":
+      return [c.segment];
+    default:
+      return c.segments;
+  }
+}
+function markCenters(points, c, inside) {
+  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) => {
+    const f = frameOf(points, s, inside);
+    return c.kind === "equalLength" ? f.m : f.o;
+  });
+}
+function letter(b, o, which) {
+  if (which === "H") {
+    line(b, { x: o.x - 3, y: o.y - 4 }, { x: o.x - 3, y: o.y + 4 });
+    line(b, { x: o.x + 3, y: o.y - 4 }, { x: o.x + 3, y: o.y + 4 });
+    line(b, { x: o.x - 3, y: o.y }, { x: o.x + 3, y: o.y });
+  } else {
+    b.moveTo(o.x - 3, o.y - 4).lineTo(o.x, o.y + 4).lineTo(o.x + 3, o.y - 4);
+  }
+}
+function segmentMark(b, points, kind, s, inside) {
+  const { m, u, n, o } = frameOf(points, s, inside);
+  switch (kind) {
+    case "parallel":
+      for (const k of [-2, 2]) line(b, at(at(o, n, k), u, -4), at(at(o, n, k), u, 4));
+      return;
+    case "perpendicular":
+      line(b, at(o, u, -4), at(o, u, 4));
+      line(b, o, at(o, n, 7));
+      return;
+    case "equalLength":
+      for (const k of [-2, 2]) line(b, at(at(m, u, k), n, -4), at(at(m, u, k), n, 4));
+      return;
+    case "length":
+      line(b, at(o, u, -8), at(o, u, 8));
+      for (const k of [-8, 8]) line(b, at(at(o, u, k), n, -3), at(at(o, u, k), n, 3));
+      return;
+    default:
+      letter(b, o, kind === "vertical" ? "V" : "H");
+  }
+}
+function glyphOf(b, points, c, inside) {
+  switch (c.kind) {
+    case "fixed": {
+      const p = points[c.anchor];
+      const d = toward(p, inside);
+      const side = { x: -d.y, y: d.x };
+      b.moveTo(...xy(at(p, d, 6))).lineTo(...xy(at(at(p, d, 14), side, -5))).lineTo(...xy(at(at(p, d, 14), side, 5))).close();
+      line(b, at(at(p, d, 17), side, -7), at(at(p, d, 17), side, 7));
+      return;
+    }
+    case "coincident": {
+      const p = points[c.anchors[0]];
+      const d = toward(p, inside);
+      const ring = at(p, d, 13);
+      line(b, at(p, d, 6), at(p, d, 9));
+      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);
+  const out = [];
+  constraints.forEach((c, i) => {
+    if (!constraintFits(c, points.length)) return;
+    const b = new PathBuilder();
+    glyphOf(b, points, c, inside);
+    const color = unsatisfied.has(i) ? style.conflictStroke : style.stroke;
+    out.push({ kind: "path", path: b.build(), stroke: { paint: { kind: "solid", color }, width: i === selected ? 3 : 1.5 } });
+  });
+  return out;
+}
+function constraintMarkAt(points, constraints, p, radius) {
+  const inside = centroidOf(points);
+  let best = -1;
+  let bestD = radius;
+  constraints.forEach((c, i) => {
+    if (!constraintFits(c, points.length)) return;
+    for (const m of markCenters(points, c, inside)) {
+      const d = Math.hypot(m.x - p.x, m.y - p.y);
+      if (d <= bestD) {
+        bestD = d;
+        best = i;
+      }
+    }
+  });
+  return best;
+}
+
+// src/constraints/constraintsExtension.ts
+var CONSTRAINTS_EXTENSION_ID = "constraints";
+var MARK_CLICK_PX = 8;
+var DEFAULT_STYLE = { stroke: "#0e9f8e", conflictStroke: "#e5484d" };
+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 null;
+  dep.setSelectedMark?.(null);
+  dep.store(dep.editingId, solved.path, label, { constraints: [...constraints] });
+  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;
+  return mark?.owner === CONSTRAINTS_EXTENSION_ID ? mark.index : null;
+}
+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 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);
+      if (constraints.length === 0) return -1;
+      return constraintMarkAt(screenPoints(target, toScreen), constraints, screen, MARK_CLICK_PX);
+    },
+    deleteMark(target, index, store) {
+      const current = constraintsOf(target.node.data);
+      if (index >= current.length) return;
+      const kept = current.filter((_, i) => i !== index);
+      const solved = solveNodeConstraints(target.node, kept);
+      if (solved) store(target.id, solved.path, "Delete constraint", { constraints: kept });
+    },
+    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 } };
+    }
+  };
+}
+
+// src/constraints/anchorConstraints.ts
+var pairsOf = (anchors) => anchors.slice(1).map((b, i) => [anchors[i], b]);
+function segmentPair(anchors) {
+  if (anchors.length === 3) return [[anchors[0], anchors[1]], [anchors[1], anchors[2]]];
+  if (anchors.length === 4) return [[anchors[0], anchors[1]], [anchors[2], anchors[3]]];
+  return null;
+}
+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 }));
+    case "coincident":
+      return pairsOf(anchors).map((pair) => ({ kind, anchors: pair }));
+    case "length": {
+      const points = pathAnchorPoints(path);
+      return pairsOf(anchors).map((segment) => ({
+        kind,
+        segment,
+        length: length ?? Math.hypot(points[segment[1]].x - points[segment[0]].x, points[segment[1]].y - points[segment[0]].y)
+      }));
+    }
+    default: {
+      const segments = segmentPair(anchors);
+      return segments ? [{ kind, segments }] : [];
+    }
+  }
+}
+var sameConstraint = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function withAdded(dep, params) {
+  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)));
+  return added.length > 0 ? [...current, ...added] : null;
+}
+function withRemoved(dep, kind) {
+  const current = constraintsOf(dep.getNodeShape(dep.editingId)?.data);
+  const kept = current.filter((c) => kind !== void 0 && c.kind !== kind || !constraintAnchors(c).every((a) => dep.selectedAnchors.has(a)));
+  return kept.length < current.length ? kept : null;
+}
+function constraintCommand(id, label, next) {
+  const ready = (deps) => {
+    const dep = depOf(deps);
+    return dep?.store && dep.selectedAnchors.size > 0 ? dep : null;
+  };
+  return {
+    id,
+    label,
+    group: "anchors",
+    tags: pathOperationTags("drag"),
+    eligible: { capability: "edits-anchors" },
+    requires: ["editAnchors"],
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const dep = ready(deps);
+        const list = dep && next(dep, params);
+        if (dep && list) setConstraints(dep, list, label);
+      }
+    },
+    enabled: (deps) => ready(deps) ? true : ActionDisabledReason.SelectionRequired
+  };
+}
+var deleteConstraintAction = {
+  id: "deleteConstraint",
+  label: "Delete constraint",
+  icon: (
+    /* @icon */
+    "core:delete"
+  ),
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const dep = depOf(deps);
+      if (dep && selectedConstraintOf(dep) !== null) deleteSelectedMark(dep);
+    }
+  },
+  enabled: (deps) => {
+    const dep = depOf(deps);
+    return dep?.store && selectedConstraintOf(dep) !== null ? true : ActionDisabledReason.SelectionRequired;
+  }
+};
+var constrainAnchorsAction = constraintCommand(
+  "constrainAnchors",
+  "Constrain anchors",
+  (dep, params) => withAdded(dep, params)
+);
+var unconstrainAnchorsAction = constraintCommand(
+  "unconstrainAnchors",
+  "Remove constraints",
+  (dep, params) => withRemoved(dep, params?.kind)
+);
+var DEFAULT_STROKE_REACH_PX = 6;
+function pressOf(deps, params) {
+  const p = params;
+  const x = p?.pressX ?? p?.worldX, y = p?.pressY ?? p?.worldY;
+  if (x === void 0 || y === void 0) return null;
+  const scale = deps.view?.get().scale ?? { x: 1, y: 1 };
+  const radius = (p?.radiusPx ?? DEFAULT_STROKE_REACH_PX) / Math.max(Math.abs(scale.x), Math.abs(scale.y));
+  return { at: { x, y }, radius };
+}
+function renderOrder(deps) {
+  const scene = deps?.scene;
+  return scene?.renderOrderNodes?.() ?? [];
+}
+function scenePathNodes(deps) {
+  const out = [];
+  for (const node of renderOrder(deps)) {
+    if (node.kind !== "leaf") continue;
+    const path = resolveEditablePathOf(node);
+    if (path) out.push({ id: node.id, node, path });
+  }
+  return out;
+}
+function strokesBesides(deps, id) {
+  const out = [];
+  for (const node of renderOrder(deps)) {
+    if (node.kind !== "leaf" || node.id === id) continue;
+    const outline = nodeOutline(node);
+    if (outline) out.push(outline);
+  }
+  return out;
+}
+
+// src/extend/extendToMeet.ts
+var EXTEND_LABEL = "Extend to next path";
+function endsAt(path, anchors) {
+  const ends = openPathEnds(path);
+  if (anchors.size === 0) return ends;
+  const set = pathToAnchors(path);
+  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);
+function endNearPress(all, press) {
+  for (let i = all.length - 1; i >= 0; i--) {
+    const node = all[i];
+    if (pathDistanceToPoint(node.path, press.at.x, press.at.y) > press.radius) continue;
+    const near = openPathEnds(node.path).map((end) => ({ end, ray: openEndRay(node.path, end) })).filter((e) => e.ray).sort((a, b) => dist(a.ray.at, press.at) - dist(b.ray.at, press.at))[0];
+    if (near) return [{ node, ends: [near.end] }];
+  }
+  return [];
+}
+function planExtend(deps, params) {
+  const out = /* @__PURE__ */ new Map();
+  const all = scenePathNodes(deps);
+  const editing = deps?.editAnchors?.editingId;
+  const press = deps ? pressOf(deps, params) : null;
+  const subjects = press ? endNearPress(all, press) : editing ? all.filter((n) => n.id === editing).map((node) => ({ node, ends: endsAt(node.path, deps.editAnchors.selectedAnchors) })) : selectedPathNodes(deps).map((node) => ({ node, ends: openPathEnds(node.path) }));
+  for (const { node, ends } of subjects) {
+    const boundaries = strokesBesides(deps, node.id);
+    let path = node.path;
+    for (const end of ends) path = extendToMeet(path, boundaries, end)?.path ?? path;
+    if (path !== node.path) out.set(node.id, { node, path });
+  }
+  return out;
+}
+var extendToMeetAction = {
+  id: "extendToMeet",
+  icon: (
+    /* @icon */
+    "path-tools:extend"
+  ),
+  label: EXTEND_LABEL,
+  tags: pathOperationTags("click"),
+  group: "path",
+  eligible: { capability: "creates-shapes" },
+  requires: ["selection", "scene", "applyOps", "editAnchors", "view"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const ops = [];
+      for (const { node, path } of planExtend(deps, params).values()) ops.push(...reshapeOps(node.node, path, EXTEND_LABEL));
+      commitOps(deps, ops, EXTEND_LABEL);
+    }
+  },
+  // A click's point arrives here without the binding's reach, so `run` decides there.
+  enabled: (deps, at2) => at2 || planExtend(deps).size > 0 ? true : ActionDisabledReason.NotApplicable
+};
+function makeHandleLockToggle(lock, label, icon) {
+  return {
+    id: `handleLock.${lock}`,
+    label,
+    tags: pathOperationTags("drag"),
+    icon,
+    group: "anchors",
+    requires: ["editAnchors"],
+    active: (deps) => deps?.editAnchors?.handleLocks?.[lock] === true,
+    enabled: (deps) => deps?.editAnchors?.setHandleLocks ? true : ActionDisabledReason.NotApplicable,
+    invoker: {
+      timing: "immediate",
+      run: (deps) => {
+        const dep = deps?.editAnchors;
+        if (!dep?.setHandleLocks) return;
+        const held = dep.handleLocks ?? { angle: false, length: false };
+        dep.setHandleLocks({ ...held, [lock]: !held[lock] });
+      }
+    }
+  };
+}
+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",
+  /* @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 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) {
+  return Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== void 0));
+}
+function effectSettings(kind, params) {
+  const p = params ?? {};
+  switch (kind) {
+    case "blend":
+      return defined({
+        steps: num2(p.steps) === void 0 ? void 0 : Math.max(Math.round(num2(p.steps)), 0),
+        autoAlign: bool(p.autoAlign),
+        startOffset: num2(p.startOffset) === void 0 ? void 0 : Math.round(num2(p.startOffset)),
+        reverse: bool(p.reverse),
+        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: num2(p.baseline),
+        flip: bool(p.flip),
+        tolerance: num2(p.tolerance) === void 0 ? void 0 : Math.max(num2(p.tolerance), 0.01)
+      });
+    case "repeatAlong":
+      return defined({
+        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: num2(p.offset),
+        orient: bool(p.orient)
+      });
+  }
+}
+function withEffectSettings(effect, params) {
+  const next = { ...effect, ...effectSettings(effect.kind, params) };
+  if (next.kind === "blend" && params?.reverse === "auto") delete next.reverse;
+  return next;
+}
+var EFFECT_DEFAULTS = {
+  blend: { kind: "blend", steps: 4 },
+  bendAlong: { kind: "bendAlong" },
+  repeatAlong: { kind: "repeatAlong" }
+};
+
+// src/pathEffects/actions.ts
+var PATH_EFFECTS_GROUP = "pathEffects";
+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 : null;
+}
+function selectedEffects(deps, ids) {
+  const scene = deps?.scene;
+  if (!scene) return [];
+  return (ids ?? deps?.selection?.get() ?? []).map((id) => scene.get(id)).filter((n) => n !== void 0 && pathEffectOf(n) !== null);
+}
+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
+    // `BROWSER_RESERVED_CHORDS`); `code` too, since with Alt held on a Mac the
+    // key reads as another glyph.
+    defaultBinding: { kind: "key", key: spec.key, code: spec.code, mods: { alt: true, shift: true } },
+    eligible: { capability: "creates-shapes" },
+    requires: ["selection", "scene", "applyOps"],
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const scene = deps.scene;
+        const leaves = selectedLeaves(deps);
+        if (!scene || !leaves) return;
+        const derivations = registeredPathEffects(scene.registry);
+        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, sources, a.layer, derivations),
+          id: scene.mintId(),
+          parent: sameParent ? a.parent : null
+        };
+        commitOps(deps, [insertAt(node, index, spec.label)], spec.label);
+        deps.selection?.set([node.id]);
+      }
+    },
+    enabled: (deps) => {
+      const scene = deps?.scene;
+      if (scene && registeredPathEffects(scene.registry) === null) return ActionDisabledReason.NotApplicable;
+      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,
+  third: true
+});
+var bendAlongAction = createEffectAction({
+  id: "bendAlong",
+  label: "Bend Along Path",
+  icon: (
+    /* @icon */
+    "path-tools:bendAlong"
+  ),
+  kind: "bendAlong",
+  key: "w",
+  code: "KeyW",
+  between: false
+});
+var repeatAlongAction = createEffectAction({
+  id: "repeatAlong",
+  label: "Repeat Along Path",
+  icon: (
+    /* @icon */
+    "path-tools:repeatAlong"
+  ),
+  kind: "repeatAlong",
+  key: "r",
+  code: "KeyR",
+  between: false
+});
+var EDIT_LABEL = "Edit Path Effect";
+var editPathEffectAction = {
+  id: "editPathEffect",
+  label: EDIT_LABEL,
+  icon: (
+    /* @icon */
+    "core:tune"
+  ),
+  requires: ["scene", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const p = params;
+      const ids = Array.isArray(p?.ids) ? p.ids : void 0;
+      const ops = [];
+      for (const node of selectedEffects(deps, ids)) {
+        const effect = pathEffectOf(node);
+        const next = withEffectSettings(effect, p);
+        if (sameEffect(effect, next)) continue;
+        ops.push(createSetDataOp({
+          id: node.id,
+          from: node.data,
+          to: { ...node.data, pathEffect: next },
+          label: EDIT_LABEL,
+          coalesceKey: `${EDIT_LABEL}:${node.id}`
+        }));
+      }
+      commitOps(deps, ops, EDIT_LABEL);
+    }
+  }
+};
+function sameEffect(a, b) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const k of keys) {
+    if (a[k] !== b[k]) return false;
+  }
+  return true;
+}
+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" },
+  requires: ["selection", "scene", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const scene = deps.scene;
+      if (!scene) return;
+      const effects = selectedEffects(deps).map((node) => ({ node, at: slotOf(scene, node.id) })).sort((x, y) => y.at - x.at);
+      const ops = [];
+      const made = [];
+      for (const { node, at: at2 } of effects) {
+        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) => {
+          const { pose, path } = worldEditToStorage({ x: 0, y: 0, width: 0, height: 0 }, part.path);
+          const data = {
+            path,
+            ...part.fill === void 0 ? {} : { fill: part.fill },
+            ...part.stroke === void 0 ? {} : { stroke: part.stroke }
+          };
+          const copy = { id: scene.mintId(), kind: "leaf", layer: node.layer, parent: node.parent, pose, data };
+          ops.push(insertAt(copy, at2 < 0 ? at2 : at2 + k, EXPAND_LABEL));
+          made.push(copy.id);
+        });
+      }
+      if (ops.length === 0) return;
+      commitOps(deps, ops, EXPAND_LABEL);
+      deps.selection?.set(made);
+    }
+  },
+  enabled: (deps) => selectedEffects(deps).length > 0 ? true : ActionDisabledReason.SelectionRequired
+};
+var SIMPLIFY_BRUSH_TOOL = "simplifyBrush";
+var SIMPLIFY_BRUSH_RADIUS_PX = 12;
+function brushRingCursor(radiusPx) {
+  return { glyph: "brush", size: Math.round(radiusPx * 24 / 9.9), fallback: "crosshair" };
+}
+var brushing = (deps) => depOf(deps)?.tool === SIMPLIFY_BRUSH_TOOL;
+function radiusOf(params) {
+  const r = params?.radiusPx;
+  return typeof r === "number" && r > 0 ? r : SIMPLIFY_BRUSH_RADIUS_PX;
+}
+function toleranceOf(params) {
+  const t = params?.tolerance;
+  return typeof t === "number" && t >= 0 ? t : DEFAULT_SIMPLIFY_TOLERANCE;
+}
+var simplifyBrushAction = inPlane({
+  id: "simplifyBrush",
+  label: "Simplify brush",
+  tags: pathOperationTags("brush"),
+  // Declines through `enabled` unless its tool is on.
+  defaultBinding: [{ spec: { kind: "drag" }, opts: { yields: true } }],
+  cursor: (params) => brushRingCursor(radiusOf(params)),
+  eligible: { capability: "edits-anchors" },
+  requires: ["editAnchors", "view"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx, opts) {
+      const dep = depOf(ctx.deps);
+      if (!dep || dep.tool !== SIMPLIFY_BRUSH_TOOL) return {};
+      const id = dep.editingId;
+      const origin = dep.getEditablePath(id);
+      if (!origin || origin.kind !== "polygon") return {};
+      const originSet = pathToAnchors(origin);
+      const params = () => resolveParams(opts?.params);
+      const radiusPx = () => radiusOf(params());
+      const tolerance = () => toleranceOf(params());
+      const scale = () => ctx.deps.view?.get().scale;
+      const trail = [];
+      const gathered = /* @__PURE__ */ new Set();
+      let current = null;
+      const sweepTo = (p) => {
+        const from = trail[trail.length - 1] ?? p;
+        trail.push({ x: p.x, y: p.y });
+        const before = gathered.size;
+        for (const i of anchorsUnderBrush(originSet, from, p, { radiusPx: radiusPx(), scale: scale() })) {
+          gathered.add(i);
+        }
+        if (gathered.size === before) return;
+        current = editAnchorSetTracked(origin, (set) => simplifyAnchorsAt(set, gathered, tolerance()));
+      };
+      const preview = pathEditPreview(dep, id, () => current?.path ?? null);
+      if (!preview) return {};
+      sweepTo(ctx.world);
+      return {
+        kind: "simplify-brush",
+        cursor: () => brushRingCursor(radiusPx()),
+        onMove(moveCtx) {
+          sweepTo(moveCtx.world);
+        },
+        onEnd(_endCtx, reason) {
+          if (reason === "cancel") {
+            current = null;
+            return;
+          }
+          const done = gathered.size > 0 ? editAnchorSetTracked(origin, (set) => simplifyAnchorsAt(set, gathered, tolerance())) : null;
+          current = null;
+          if (!done) return;
+          dep.applyEdit(id, done.path, "Simplify brush", done.origins);
+          dep.setSelectedAnchors([]);
+        },
+        overlay: () => ({ kind: "brush", points: trail.slice(), radiusPx: radiusPx() }),
+        previewIds: preview.previewIds,
+        previewPose: preview.previewPose,
+        previewData: preview.previewData
+      };
+    }
+  },
+  enabled: (deps) => brushing(deps) ? true : ActionDisabledReason.NotApplicable
+}, editingLayer);
+var simplifyBrushToolAction = pathEditToolAction(
+  SIMPLIFY_BRUSH_TOOL,
+  "Simplify brush",
+  /* @icon */
+  "core:simplifyBrush"
+);
+var DEFAULT_SMUDGE_RADIUS_PX = 40;
+var DEFAULT_SMUDGE_STRENGTH = 0.6;
+var LABEL4 = "Smudge brush";
+var num3 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function radiusOf2(params) {
+  return Math.max(1, num3(params?.radiusPx, DEFAULT_SMUDGE_RADIUS_PX));
+}
+function strengthOf(params) {
+  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 });
+  return Math.max(reach.x, reach.y);
+}
+var smudgeBrushAction = {
+  id: "smudgeBrush",
+  label: LABEL4,
+  icon: (
+    /* @icon */
+    "path-tools:smudgeBrush"
+  ),
+  tags: pathOperationTags("brush"),
+  group: "path",
+  eligible: { capability: "creates-shapes" },
+  cursor: (params) => brushRingCursor(radiusOf2(params)),
+  requires: ["selection", "scene", "view", "applyOps"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx, opts) {
+      const nodes = selectedPathNodes(ctx.deps);
+      if (nodes.length === 0) return {};
+      const { deps } = ctx;
+      const params = (move) => ({ ...resolveParams(opts?.params), ...move.params });
+      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 shapeOf2 = (id) => {
+        const entry = current.get(id);
+        return entry ? withPath(entry.node.node, entry.path) : null;
+      };
+      return {
+        kind: "smudge-brush",
+        cursor: () => brushRingCursor(radiusPx),
+        onMove(move) {
+          const p = params(move);
+          radiusPx = radiusOf2(p);
+          const to = { x: move.world.x, y: move.world.y };
+          const radius = worldRadius(deps, radiusPx);
+          for (const node of nodes) {
+            const from = current.get(node.id)?.path ?? node.path;
+            const next = smudgePath(from, {
+              center: at2,
+              delta: { x: to.x - at2.x, y: to.y - at2.y },
+              radius,
+              strength: strengthOf(p)
+            });
+            if (next !== from) current.set(node.id, { node, path: next });
+          }
+          at2 = to;
+        },
+        onEnd(_end, reason) {
+          const done = [...current.values()];
+          current.clear();
+          if (reason === "cancel" || done.length === 0) return;
+          commitOps(deps, done.flatMap(({ node, path }) => reshapeOps(node.node, path, LABEL4)), LABEL4);
+        },
+        previewIds: () => current.size > 0 ? [...current.keys()] : 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);
+  if (!press) return null;
+  const all = scenePathNodes(deps);
+  for (let i = all.length - 1; i >= 0; i--) {
+    const target = all[i];
+    const result = trimPathAt(target.path, strokesBesides(deps, target.id), press.at, { radius: press.radius });
+    if (result) return { target, result };
+  }
+  return null;
+}
+var trimPathAction = {
+  id: "trimPath",
+  icon: (
+    /* @icon */
+    "path-tools:trim"
+  ),
+  label: TRIM_LABEL,
+  tags: pathOperationTags("click"),
+  group: "path",
+  eligible: { capability: "creates-shapes" },
+  requires: ["scene", "applyOps", "selection", "view"],
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const plan = deps.scene ? planTrim(deps, params) : null;
+      if (!plan) return;
+      const { target, result } = plan;
+      const gone = result.path.commands.length === 0;
+      const ops = gone ? [deleteNode(deps.scene, target.node, TRIM_LABEL)] : reshapeOps(target.node, result.path, TRIM_LABEL);
+      commitOps(deps, ops, TRIM_LABEL);
+      if (gone) deps.selection?.set((deps.selection.get() ?? []).filter((id) => id !== target.id));
+    }
+  },
+  enabled: () => true
+};
+var results = /* @__PURE__ */ new WeakMap();
+function heldWarpResult(held) {
+  let out = results.get(held);
+  if (!out) {
+    out = applyPathWarp(held.source, held.warp, held.tolerance);
+    results.set(held, out);
+  }
+  return out;
+}
+function rememberWarpResult(held, result) {
+  results.set(held, result);
+}
+function isHeldWarp(v) {
+  if (v === null || typeof v !== "object") return false;
+  const h = v;
+  return typeof h.id === "string" && typeof h.tolerance === "number" && h.source?.kind === "polygon" && typeof h.warp?.kind === "string" && Array.isArray(h.frame) && h.frame.length === 6;
+}
+function heldPathWarpOf(data) {
+  const w = data?.warp;
+  return isHeldWarp(w) ? w : null;
+}
+function withoutPathWarp(data) {
+  if (data === null || typeof data !== "object" || !("warp" in data)) return data;
+  const { warp: _dropped, ...rest } = data;
+  return rest;
+}
+function storedPathOf(node) {
+  const storage = classifyPathStorage(node);
+  if (!storage) return null;
+  if (storage.kind === "pose") return { path: node.pose, toWorld: identity() };
+  const { pose, data } = storage;
+  const b = boundsOfPath(data.path);
+  const box = boxToBox(b.x, b.y, b.width, b.height, pose.x, pose.y, pose.width, pose.height);
+  return { path: data.path, toWorld: multiply(poseFrameOf(pose) ?? identity(), box) };
+}
+function sameUnder(a, m, b) {
+  if (a.coords.length !== b.coords.length || a.commands.length !== b.commands.length) return false;
+  const bb = boundsOfPath(b);
+  const tol = 1e-3 * Math.max(1, Math.abs(bb.x) + bb.width, Math.abs(bb.y) + bb.height);
+  for (let i = 0; i + 1 < a.coords.length; i += 2) {
+    const x = m[0] * a.coords[i] + m[2] * a.coords[i + 1] + m[4];
+    const y = m[1] * a.coords[i] + m[3] * a.coords[i + 1] + m[5];
+    if (Math.abs(x - b.coords[i]) > tol || Math.abs(y - b.coords[i + 1]) > tol) return false;
+  }
+  return true;
+}
+function resolvePathWarp(node) {
+  if (!node) return null;
+  const held = heldPathWarpOf(node.data);
+  if (!held) return null;
+  const stored = storedPathOf(node);
+  if (!stored) return null;
+  const made = heldWarpResult(held);
+  let toStorage = held.frame;
+  if (!sameUnder(made, toStorage, stored.path)) {
+    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) };
+}
+function warpFrameFor(node, toWorld2) {
+  const stored = storedPathOf(node);
+  const back = stored && invert(stored.toWorld);
+  return back ? multiply(back, toWorld2) : null;
+}
+var WARP_LABELS = { distort: "Distort", envelope: "Envelope", puppet: "Puppet Warp" };
+var DEFAULT_WARP_TOLERANCE = 0.5;
+var DEFAULT_ENVELOPE_SIZE = 3;
+var count = (v, fallback) => Math.min(16, Math.max(1, Math.round(v ?? fallback)));
+function freshWarp(kind, box, settings) {
+  switch (kind) {
+    case "distort":
+      return distortOver(box, settings.mode ?? "free");
+    case "envelope":
+      return envelopeOver(
+        box,
+        count(settings.rows, DEFAULT_ENVELOPE_SIZE),
+        count(settings.cols, DEFAULT_ENVELOPE_SIZE),
+        settings.mapping ?? "bicubic"
+      );
+    case "puppet":
+      return { kind: "puppet", pins: [] };
+  }
+}
+function withWarpSettings(held, settings) {
+  const { warp } = held;
+  let next = warp;
+  if (warp.kind === "distort" && settings.mode && settings.mode !== warp.mode) next = { ...warp, mode: settings.mode };
+  if (warp.kind === "envelope") {
+    const sized = resizeEnvelope(
+      warp,
+      count(settings.rows, warp.mesh.rows),
+      count(settings.cols, warp.mesh.cols)
+    );
+    next = settings.mapping && settings.mapping !== sized.mapping ? { ...sized, mapping: settings.mapping } : sized;
+  }
+  const tolerance = settings.tolerance !== void 0 && settings.tolerance > 0 ? settings.tolerance : held.tolerance;
+  if (next === warp && tolerance === held.tolerance) return held;
+  return { ...held, warp: next, tolerance };
+}
+function worldBoxOf(nodes) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const { path } of nodes) {
+    const b = boundsOfPath(path);
+    x0 = Math.min(x0, b.x);
+    y0 = Math.min(y0, b.y);
+    x1 = Math.max(x1, b.x + b.width);
+    y1 = Math.max(y1, b.y + b.height);
+  }
+  return x0 <= x1 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
+}
+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) {
+      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) };
+}
+function warpTargets(deps, kind, settings) {
+  const { held: out, bare, box } = splitByWarp(selectedPathNodes(deps), kind);
+  if (!box) return out;
+  const id = freshWarpId();
+  const warp = freshWarp(kind, box, settings);
+  const tolerance = settings.tolerance !== void 0 && settings.tolerance > 0 ? settings.tolerance : DEFAULT_WARP_TOLERANCE;
+  for (const node of bare) {
+    const frame = warpFrameFor(node.node, identity());
+    if (!frame) continue;
+    out.push({ node, held: { id, source: node.path, warp, tolerance, frame }, toWorld: identity(), fresh: true });
+  }
+  return out;
+}
+function withPathWarp(shape, warp, opts = {}) {
+  const source = resolveEditablePathOf(shape);
+  if (!source) return null;
+  const held = {
+    id: opts.id ?? freshWarpId(),
+    source,
+    warp,
+    tolerance: opts.tolerance ?? DEFAULT_WARP_TOLERANCE,
+    frame: identity()
+  };
+  return storeWarp(shape, held, identity());
+}
+function storeWarp(node, held, toWorld2) {
+  const made = heldWarpResult(held);
+  const next = withPath(node, transformPath(made, toWorld2));
+  if (!next) return null;
+  const frame = warpFrameFor(next, toWorld2);
+  if (!frame) return null;
+  const kept = { ...held, frame };
+  rememberWarpResult(kept, made);
+  return { pose: next.pose, data: { ...next.data, warp: kept } };
+}
+
+// src/warp/warpActions.ts
+function createWarpLive() {
+  let current = null;
+  const changed = createEmitter();
+  return {
+    get: (id) => current?.get(id),
+    set: (next) => {
+      current = next;
+      changed.emit();
+    },
+    subscribe: changed.subscribe
+  };
+}
+function warpHandleScratchOf(hit) {
+  const payload = hit?.payload;
+  return payload && typeof payload.index === "number" && payload.warpId !== void 0 ? payload : null;
+}
+var REQUIRES = ["selection", "scene", "applyOps"];
+function commitTargets(deps, next, label) {
+  const ops = [];
+  for (const { target, shape } of next.values()) ops.push(...reshapeTo(target.node.node, shape, label));
+  commitOps(deps, ops, label);
+}
+function createWarpDragAction(kind, live) {
+  const label = WARP_LABELS[kind];
+  return {
+    id: `${kind}.drag`,
+    label: `${label} \u2014 drag control`,
+    tags: pathOperationTags(kind === "puppet" ? "brush" : "box"),
+    requires: REQUIRES,
+    invoker: {
+      timing: "ongoing",
+      start(ctx, opts) {
+        const scratch = warpHandleScratchOf(ctx.drag?.affordance);
+        if (!scratch) return {};
+        const settings = resolveParams(opts?.params) ?? {};
+        const targets = warpTargets(ctx.deps, kind, settings).filter((t) => scratch.warpId === null ? t.fresh : t.held.id === scratch.warpId);
+        const first = targets[0];
+        const control = first && warpControls(first.held.warp)[scratch.index];
+        if (!control) return {};
+        const deps = ctx.deps;
+        const [cx, cy] = applyToPoint(first.toWorld, control.x, control.y);
+        const press = ctx.drag?.start ?? ctx.world;
+        let current = /* @__PURE__ */ new Map();
+        const publish = () => live?.set(new Map([...current].map(([id, e]) => [id, e.shape])));
+        return {
+          kind: `${kind}.drag`,
+          onMove(m) {
+            const at2 = m.drag?.current ?? m.world;
+            const world = { x: cx + at2.x - press.x, y: cy + at2.y - press.y };
+            current = /* @__PURE__ */ new Map();
+            for (const target of targets) {
+              const back = invert(target.toWorld);
+              if (!back) continue;
+              const [lx, ly] = applyToPoint(back, world.x, world.y);
+              const held = { ...target.held, warp: moveWarpControl(target.held.warp, scratch.index, { x: lx, y: ly }) };
+              const shape = storeWarp(target.node.node, held, target.toWorld);
+              if (shape) current.set(target.node.id, { target, shape });
+            }
+            publish();
+          },
+          onEnd(_end, reason) {
+            const done = current;
+            current = /* @__PURE__ */ new Map();
+            live?.set(null);
+            if (reason === "commit" && done.size > 0) commitTargets(deps, done, label);
+          },
+          previewIds: () => current.size > 0 ? [...current.keys()] : null,
+          previewPose: (id) => current.get(id)?.shape.pose ?? null,
+          previewData: (id) => current.get(id)?.shape.data ?? null
+        };
+      }
+    }
+  };
+}
+function clickPoint(params) {
+  const x = params?.pressX ?? params?.worldX;
+  const y = params?.pressY ?? params?.worldY;
+  return typeof x === "number" && typeof y === "number" ? { x, y } : null;
+}
+function createAddPinAction() {
+  return {
+    id: "puppet.addPin",
+    label: `${WARP_LABELS.puppet} \u2014 add pin`,
+    tags: pathOperationTags("brush"),
+    requires: REQUIRES,
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const at2 = clickPoint(params);
+        if (!at2) return;
+        const next = /* @__PURE__ */ new Map();
+        for (const target of warpTargets(deps, "puppet", params ?? {})) {
+          const { warp } = target.held;
+          const back = invert(target.toWorld);
+          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, 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 });
+        }
+        commitTargets(deps, next, "Add Pin");
+      }
+    },
+    enabled: (deps) => selectedPathNodes(deps).length > 0 ? true : ActionDisabledReason.SelectionRequired
+  };
+}
+function createRemovePinAction() {
+  return {
+    id: "puppet.removePin",
+    label: `${WARP_LABELS.puppet} \u2014 remove pin`,
+    tags: pathOperationTags("brush"),
+    requires: REQUIRES,
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const scratch = warpHandleScratchOf(params?.affordance);
+        if (!scratch || scratch.warpId === null) return;
+        const next = /* @__PURE__ */ new Map();
+        for (const target of warpTargets(deps, "puppet", {})) {
+          const { warp } = target.held;
+          if (target.held.id !== scratch.warpId || warp.kind !== "puppet") continue;
+          const held = { ...target.held, warp: { ...warp, pins: warp.pins.filter((_, i) => i !== scratch.index) } };
+          const shape = storeWarp(target.node.node, held, target.toWorld);
+          if (shape) next.set(target.node.id, { target, shape });
+        }
+        commitTargets(deps, next, "Remove Pin");
+      }
+    }
+  };
+}
+function createWarpGrabAction(kind) {
+  return {
+    id: `${kind}.grab`,
+    label: `${WARP_LABELS[kind]} \u2014 grab control`,
+    invoker: { timing: "immediate", run: () => {
+    } }
+  };
+}
+var expandWarpAction = {
+  id: "expandWarp",
+  label: "Expand Warp",
+  icon: (
+    /* @icon */
+    "path-tools:expand"
+  ),
+  tags: pathOperationTags("command"),
+  group: "path",
+  requires: REQUIRES,
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const ops = [];
+      for (const { node } of selectedPathNodes(deps)) {
+        if (!heldPathWarpOf(node.data)) continue;
+        ops.push(createSetDataOp({ id: node.id, from: node.data, to: withoutPathWarp(node.data), label: "Expand Warp" }));
+      }
+      commitOps(deps, ops, "Expand Warp");
+    }
+  },
+  enabled: (deps) => selectedPathNodes(deps).some(({ node }) => heldPathWarpOf(node.data)) ? true : ActionDisabledReason.NotApplicable
+};
+var configureWarpAction = {
+  id: "configureWarp",
+  label: "Warp Settings",
+  icon: (
+    /* @icon */
+    "core:tune"
+  ),
+  tags: pathOperationTags("command"),
+  group: "path",
+  requires: REQUIRES,
+  invoker: {
+    timing: "immediate",
+    run: (deps, params) => {
+      const settings = params ?? {};
+      const next = /* @__PURE__ */ new Map();
+      for (const node of selectedPathNodes(deps)) {
+        const resolved = resolvePathWarp(node.node);
+        if (!resolved || settings.kind && resolved.held.warp.kind !== settings.kind) continue;
+        const held = withWarpSettings(resolved.held, settings);
+        if (held === resolved.held) continue;
+        const shape = storeWarp(node.node, held, resolved.toWorld);
+        if (shape) next.set(node.id, { target: { node, ...resolved, fresh: false }, shape });
+      }
+      commitTargets(deps, next, "Warp Settings");
+    }
+  }
+};
+
+// src/presets.ts
+var simplifyBrushPreset = {
+  id: "simplifyBrush",
+  actions: [simplifyBrushAction, simplifyBrushToolAction]
+};
+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",
+    chromeRules: { [PATH_COMB_CHROME_ID]: never },
+    pathEdit: [createCombExtension(options)]
+  };
+}
+var curvatureCombPreset = createCurvatureCombPreset();
+function createBalancePreset(style = {}) {
+  return {
+    id: "balance",
+    refines: ["paths"],
+    actions: [equalizeHandlesAction, balanceHandlesAction],
+    chromeRules: { [PATH_BALANCE_CHROME_ID]: never },
+    pathEdit: [createBalanceExtension(style)]
+  };
+}
+var balancePreset = createBalancePreset();
+function createConstraintsPreset(style = {}) {
+  return {
+    id: "constraints",
+    actions: [constrainAnchorsAction, unconstrainAnchorsAction, deleteConstraintAction],
+    pathEdit: [createConstraintsExtension(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]
+};
+var warpPreset = {
+  id: "warp",
+  actions: [expandWarpAction, configureWarpAction]
+};
+var pathTools = {
+  id: "pathTools",
+  includes: [
+    simplifyBrushPreset,
+    handleLocksPreset,
+    bridgePreset,
+    spiroPreset,
+    trimPreset,
+    extendPreset,
+    lengthenPreset,
+    smudgePreset,
+    harmonizePreset,
+    anchorSelectionPreset,
+    resamplePreset,
+    addExtremesPreset,
+    curvatureCombPreset,
+    balancePreset,
+    constraintsPreset,
+    pathStructurePreset,
+    segmentTypePreset,
+    cornerShapePreset,
+    pathEffectsPreset,
+    warpPreset
+  ]
+};
+function useStrokeClickTool(spec, options, extras = {}) {
+  const { keybinding = spec.keybinding, radiusPx } = options;
+  const { id, label, icon, hookName, actionId } = spec;
+  return useMemo(() => {
+    const opts = radiusPx !== void 0 ? { opts: { params: () => ({ radiusPx: typeof radiusPx === "function" ? radiusPx() : radiusPx }) } } : {};
+    return defineTool({
+      id,
+      ...keybinding ? { keybinding } : {},
+      capabilities: ["creates-shapes"],
+      hookName,
+      cursor: "crosshair",
+      presentation: { label, group: "path", icon },
+      ...extras.actions ? { actions: extras.actions } : {},
+      ...extras.overlay ? { overlay: extras.overlay } : {},
+      ...extras.onDeactivate ? { onDeactivate: extras.onDeactivate } : {},
+      bindings: [
+        { spec: { kind: "click" }, actionId, ...opts },
+        ...(extras.bindings ?? []).map((b) => ({ ...b, ...opts }))
+      ]
+    });
+  }, [id, label, icon, hookName, actionId, keybinding, radiusPx, extras.actions, extras.bindings, extras.overlay, extras.onDeactivate]);
+}
+function createPiecePreview() {
+  const changed = createEmitter();
+  let state = null;
+  const current = () => state && state.piece.scene.getVersion() === state.version ? state.piece : null;
+  return {
+    show(next) {
+      if (!next && !state) return;
+      if (next && state && next.path === state.piece.path) return;
+      state = next ? { piece: next, version: next.scene.getVersion() } : null;
+      changed.emit();
+    },
+    current,
+    layer: {
+      id: "stroke-piece-preview",
+      label: "Piece a click would cut",
+      space: "screen",
+      subscribe: (repaint) => changed.subscribe(repaint),
+      draw: (_data, view) => {
+        const piece = current();
+        if (!piece) return [];
+        const t = viewToTransform(view);
+        const stroke = { ...OVERLAY_ROLE_STROKES["cut"], width: 3 };
+        return [{ kind: "path", path: transformPath(piece.path, [t.zoom.x, 0, 0, t.zoom.y, t.panX, t.panY]), stroke }];
+      }
+    }
+  };
+}
+
+// src/trim/useTrimTool.ts
+var TRIM_KEY = { key: "Y" };
+var TRIM_PREVIEW_ID = "trim.preview";
+function useTrimTool(options = {}) {
+  const extras = useMemo(() => {
+    const preview = createPiecePreview();
+    const action = {
+      id: TRIM_PREVIEW_ID,
+      label: "Trim segment: show the piece under the pointer",
+      eligible: { capability: "creates-shapes" },
+      requires: ["scene", "view"],
+      invoker: {
+        timing: "immediate",
+        run: (deps, params) => {
+          const plan = deps.scene ? planTrim(deps, params) : null;
+          const scene = deps.scene;
+          preview.show(plan && scene ? { path: plan.result.removed, scene } : null);
+        }
+      }
+    };
+    return {
+      actions: [action],
+      bindings: [{ spec: { kind: "hover" }, actionId: TRIM_PREVIEW_ID }],
+      overlay: preview.layer,
+      onDeactivate: () => preview.show(null)
+    };
+  }, []);
+  return useStrokeClickTool(
+    { id: "trim", label: "Trim segment", icon: (
+      /* @icon */
+      "path-tools:trim"
+    ), hookName: "useTrimTool", actionId: "trimPath", keybinding: TRIM_KEY },
+    options,
+    extras
+  );
+}
+var EXTEND_KEY = { key: "U" };
+function useExtendTool(options = {}) {
+  return useStrokeClickTool(
+    {
+      id: "extend",
+      label: "Extend to next path",
+      icon: (
+        /* @icon */
+        "path-tools:extend"
+      ),
+      hookName: "useExtendTool",
+      actionId: "extendToMeet",
+      keybinding: EXTEND_KEY
+    },
+    options
+  );
+}
+var SMUDGE_KEY = { key: "S" };
+function useSmudgeBrushTool(options = {}) {
+  const { keybinding = SMUDGE_KEY } = options;
+  return useMemo(() => defineTool({
+    id: "smudgeBrush",
+    ...keybinding ? { keybinding } : {},
+    capabilities: ["creates-shapes"],
+    hookName: "useSmudgeBrushTool",
+    cursor: "crosshair",
+    presentation: { label: "Smudge brush", group: "path", icon: (
+      /* @icon */
+      "path-tools:smudgeBrush"
+    ) },
+    bindings: [{ spec: { kind: "drag" }, actionId: "smudgeBrush" }]
+  }), [keybinding]);
+}
+var warpLayerId = (kind) => `warp-${kind}`;
+var HIT_PX = 8;
+var SIZE_PX = DEFAULT_OVERLAY_STYLE.anchorSizePx;
+var PIN_RADIUS_PX = DEFAULT_OVERLAY_STYLE.handleDotRadiusPx;
+var ACCENT = DEFAULT_OVERLAY_STYLE.anchorStroke;
+var LINE = { paint: { kind: "solid", color: ACCENT }, width: 1 };
+var LINE_SAMPLES = 12;
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+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, 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, source: t.held.source, toWorld: t.toWorld });
+  }
+  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) => {
+  const [x, y] = applyToPoint(m, p.x, p.y);
+  return { x, y };
+};
+function pinPaint(view, at2) {
+  const [x, y] = worldToScreen(at2.x, at2.y, viewToTransform(view));
+  const r = PIN_RADIUS_PX;
+  return [{
+    kind: "path",
+    path: ellipsePath({ x: x - r, y: y - r, width: 2 * r, height: 2 * r }),
+    fill: { paint: { kind: "solid", color: "#ffffff" } },
+    stroke: { paint: { kind: "solid", color: ACCENT }, width: 2 }
+  }];
+}
+function guideLines(group) {
+  const { warp, toWorld: m } = group;
+  if (warp.kind === "distort") {
+    const c = warp.corners.map((p) => toWorld(m, p));
+    return [[...c, c[0]]];
+  }
+  if (warp.kind !== "envelope") return [];
+  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 = [];
+  for (let i = 0; i <= mesh.rows; i++) {
+    const n = mesh.cols * LINE_SAMPLES;
+    lines.push(Array.from({ length: n + 1 }, (_, k) => at2(k / n, i / mesh.rows)));
+  }
+  for (let j = 0; j <= mesh.cols; j++) {
+    const n = mesh.rows * LINE_SAMPLES;
+    lines.push(Array.from({ length: n + 1 }, (_, k) => at2(j / mesh.cols, k / n)));
+  }
+  return lines;
+}
+function warpAffordance(src) {
+  const id = warpLayerId(src.kind);
+  return {
+    id,
+    regions(state) {
+      const out = [];
+      for (const group of groupsOf(src, state)) {
+        warpControls(group.warp).forEach((local, index) => {
+          const p = toWorld(group.toWorld, local);
+          out.push({
+            id: `${group.warpId ?? "fresh"}:${index}`,
+            targetId: null,
+            shape: { kind: "point", x: p.x, y: p.y, hitRadiusPx: HIT_PX },
+            paint: group.warp.kind === "puppet" ? { kind: "custom", draw: ({ world, view }) => pinPaint(view, world) } : {
+              kind: "square",
+              sizePx: SIZE_PX,
+              fill: { paint: { kind: "solid", color: "#ffffff" } },
+              stroke: { paint: { kind: "solid", color: ACCENT }, width: 1 }
+            },
+            cursor: "move",
+            strength: "exclusive",
+            claimedKinds: ["pointer"],
+            bind: () => ({ initialScratch: { warpId: group.warpId, index } })
+          });
+        });
+      }
+      return out;
+    },
+    decorate(state, view) {
+      const t = viewToTransform(view);
+      const out = [];
+      for (const group of groupsOf(src, state)) {
+        for (const line3 of guideLines(group)) {
+          const screen = line3.map((p) => {
+            const [x, y] = worldToScreen(p.x, p.y, t);
+            return { x, y };
+          });
+          out.push({ kind: "path", path: polylineFromPoints(screen), stroke: LINE });
+        }
+      }
+      return out;
+    }
+  };
+}
+function createWarpHandleLayer(src) {
+  const lines = { id: `${warpLayerId(src.kind)}:lines`, regions: () => [], decorate: warpAffordance(src).decorate };
+  const controls = { ...warpAffordance(src), decorate: void 0 };
+  return composeAffordanceLayer(warpLayerId(src.kind), "Warp controls", [lines, controls]);
+}
+
+// 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)}`;
+  const out = [];
+  if (kind === "puppet") {
+    out.push({ spec: { kind: "click", target, mods: { alt: true } }, actionId: "puppet.removePin" });
+    out.push({ spec: { kind: "click", target: "selected-body" }, actionId: "puppet.addPin", opts: { params: settings } });
+  }
+  out.push(
+    { spec: { kind: "drag", target }, actionId: `${kind}.drag`, opts: { params: settings } },
+    { spec: { kind: "pointerDown", target, mods: ANY_MODS }, actionId: `${kind}.grab` },
+    { spec: { kind: "click", target }, actionId: `${kind}.grab` }
+  );
+  return out;
+}
+function definedOf(settings) {
+  return Object.fromEntries(Object.entries(settings).filter(([, v]) => v !== void 0));
+}
+var KEYS = { distort: { key: "F" }, envelope: { key: "F", shift: true }, puppet: { key: "B" } };
+function createWarpToolState() {
+  let active = false;
+  let api = null;
+  let deps = null;
+  const live = createWarpLive();
+  return {
+    live,
+    active: () => active,
+    scene: () => deps?.get("scene"),
+    /** What an invocation of `actionId` passing `given` starts with here,
+     *  its tunings included. */
+    paramsOf: (actionId, given) => deps?.get("actionParams")?.(actionId, given) ?? given,
+    setActive(next) {
+      active = next;
+      api?.requestRedraw();
+    },
+    attachTo(nextApi, nextDeps) {
+      api = nextApi;
+      deps = nextDeps;
+    }
+  };
+}
+function useWarpTool(kind, options, settings) {
+  const { label, keybinding = KEYS[kind] } = options;
+  const settingsRef = useLatest(settings);
+  const state = useMemo(() => createWarpToolState(), []);
+  const attach = useMemo(() => {
+    const layer = createWarpHandleLayer({
+      kind,
+      active: state.active,
+      settings: () => state.paramsOf(`${kind}.drag`, definedOf(settingsRef.current)),
+      scene: state.scene,
+      live: state.live
+    });
+    return (api, deps) => {
+      state.attachTo(api, deps);
+      const unregister = api.registerLayer(layer);
+      const unlisten = state.live.subscribe(() => api.requestRedraw());
+      return () => {
+        unlisten();
+        unregister();
+        state.attachTo(null, null);
+      };
+    };
+  }, [kind, settingsRef, state]);
+  const actions = useMemo(() => [
+    createWarpDragAction(kind, state.live),
+    createWarpGrabAction(kind),
+    ...kind === "puppet" ? [createAddPinAction(), createRemovePinAction()] : []
+  ], [kind, state]);
+  return useMemo(() => {
+    const tool = defineTool({
+      id: kind,
+      ...keybinding ? { keybinding } : {},
+      hookName: `use${kind[0].toUpperCase()}${kind.slice(1)}Tool`,
+      capabilities: ["creates-shapes"],
+      cursor: kind === "puppet" ? "crosshair" : "default",
+      actions,
+      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))
+    });
+    return Object.assign(tool, { attach });
+  }, [actions, attach, keybinding, kind, label, settingsRef, state]);
+}
+function useDistortTool(options = {}) {
+  const { mode, tolerance } = options;
+  return useWarpTool("distort", options, { mode, tolerance });
+}
+function useEnvelopeTool(options = {}) {
+  const { rows, cols, mapping, tolerance } = options;
+  return useWarpTool("envelope", options, { rows, cols, mapping, tolerance });
+}
+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 { 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