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

package/dist/index.js

@@ -0,0 +1,1730 @@
+import { inPlane, editedPathSymmetries, pathEditPreview, locksInForce, pathOperationTags, editingLayer, joinPathsCommand, BridgeIcon, joinSelectedAnchors, makeHandleCommand, HarmonizeIcon, depOf, pathEditToolAction, SimplifyBrushIcon, DEFAULT_OVERLAY_STYLE, pathEditToolActive, registeredPathEffects, slotOf, pathEffectNode, commitOps, insertAt, DEFAULT_SIMPLIFY_TOLERANCE, deleteSelectedMark, resolveEditablePathOf, classifyPathStorage, commitAnchorEdit, anchorEditWouldChange, reshapeOps, HoldHandleAngleIcon, HoldHandleLengthIcon, pathEffectOf, createSetDataOp, derivedDepOf, pathEffectParts, deleteNode, selectedPathNodes, withPath, never, defineTool, nodeOutline, reshapeTo, composeAffordanceLayer, viewToTransform, worldToScreen, pathNodesOf, OVERLAY_ROLE_STROKES, SliceIcon } from '@weasel-js/core';
+import { isBalanceGrip, ActionDisabledReason, resolveParams } from '@weasel-js/routing';
+import { pathToAnchors, balanceFactorToward, editAnchorSetTracked, scaleSegmentHandles, harmonizeAnchors, simplifyAnchorsAt, locateAnchor, anchorsUnderBrush, pathAnchorPoints, unsatisfiedConstraints, solvePathConstraints, constraintAnchors, constrainPathEdit, constraintFits, PathBuilder, equalizeSegmentHandles, handleBalances, linePath, circlePath, curvatureComb, polylineFromPoints, worldEditToStorage, smudgePath, trimPathAt, boundsOfPath, transformPath, multiply, boxToBox, identity, openPathEnds, extendToMeet, pxExtent, poseFrameOf, applyPathWarp, invert, resizeEnvelope, pathDistanceToPoint, openEndRay, warpControls, applyToPoint, moveWarpControl, unwarpPoint, pathWarpMap, envelopeOver, distortOver, ellipsePath } from '@weasel-js/geom';
+import { jsx } from 'react/jsx-runtime';
+import { createEmitter } from '@weasel-js/registry';
+import { useMemo, createElement } from 'react';
+import { useLatest } from '@weasel-js/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",
+  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" },
+  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.modifiers).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",
+  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 line2 of handleBalances(set)) {
+    const grip = toScreen(line2.grip);
+    out.push({
+      kind: "path",
+      path: linePath(toScreen(line2.from), toScreen(line2.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((line2) => ({
+      x: line2.grip.x,
+      y: line2.grip.y,
+      hitKind: `balance:${line2.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: BridgeIcon,
+    // `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: BridgeIcon,
+  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 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 constraintConflictsOf(node) {
+  const constraints = constraintsOf(node?.data);
+  const path = constraints.length > 0 ? resolveEditablePathOf(node) : null;
+  if (!path) return [];
+  return unsatisfiedConstraints(pathAnchorPoints(path), constraints, { axisAngle: constraintAxisOf(node) });
+}
+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 same = edit.constraints.length === constraints.length && edit.constraints.every((c, i) => JSON.stringify(c) === JSON.stringify(constraints[i]));
+  return { path: edit.path, constraints: same ? constraints : edit.constraints };
+}
+function solveNodeConstraints(node, constraints) {
+  const path = resolveEditablePathOf(node);
+  if (!path) return null;
+  const axisAngle = constraintAxisOf(node);
+  const solved = solvePathConstraints(path, constraints, { axisAngle });
+  if (solved.converged) return { path: solved.path, unsatisfied: [] };
+  return { path, unsatisfied: unsatisfiedConstraints(pathAnchorPoints(path), constraints, { axisAngle }) };
+}
+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 "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 === "coincident") {
+    const p = points[c.kind === "fixed" ? c.anchor : c.anchors[0]];
+    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));
+      b.moveTo(ring.x + 4, ring.y);
+      for (let k = 1; k <= 12; k++) b.lineTo(ring.x + 4 * Math.cos(k * Math.PI / 6), ring.y + 4 * Math.sin(k * Math.PI / 6));
+      return;
+    }
+    default:
+      for (const s of segmentsOf(c)) segmentMark(b, points, c.kind, s, inside);
+  }
+}
+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 editedPath(dep) {
+  const p = dep.getEditablePath(dep.editingId);
+  return p?.kind === "polygon" ? p : null;
+}
+function setConstraints(dep, constraints, label) {
+  const node = dep.getNodeShape(dep.editingId);
+  const solved = node && dep.store ? solveNodeConstraints(node, constraints) : null;
+  if (!solved) return false;
+  dep.setSelectedMark?.(null);
+  dep.store(dep.editingId, solved.path, label, { constraints: [...constraints] });
+  return true;
+}
+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 };
+  return {
+    id: CONSTRAINTS_EXTENSION_ID,
+    marks(ctx) {
+      const constraints = constraintsOf(ctx.node.data);
+      if (constraints.length === 0) return [];
+      const world = pathAnchorPoints(ctx.path);
+      const axisAngle = constraintAxisOf(ctx.node);
+      const unsatisfied = new Set(unsatisfiedConstraints(world, constraints, { axisAngle }));
+      return constraintGlyphs(world.map(ctx.toScreen), constraints, unsatisfied, colors, ctx.selected);
+    },
+    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) {
+      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 "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 = editedPath(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",
+  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 picked = ends.filter((e) => [...anchors].some((flat) => {
+    const at2 = locateAnchor(set, flat);
+    if (!at2 || at2.sub !== e.sub) return false;
+    return e.end === "first" ? at2.idx === 0 : at2.idx === set.anchors[at2.sub].length - 1;
+  }));
+  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",
+  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", /* @__PURE__ */ jsx(HoldHandleAngleIcon, {}));
+var handleLockLengthAction = makeHandleLockToggle("length", "Hold handle length", /* @__PURE__ */ jsx(HoldHandleLengthIcon, {}));
+var harmonizeAnchorsAction = makeHandleCommand(
+  "harmonizeAnchors",
+  "Harmonize curvature",
+  /* @__PURE__ */ jsx(HarmonizeIcon, {}),
+  harmonizeAnchors,
+  "selectedOrAll"
+);
+
+// src/pathEffects/params.ts
+var num = (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: num(p.steps) === void 0 ? void 0 : Math.max(Math.round(num(p.steps)), 0),
+        autoAlign: bool(p.autoAlign),
+        startOffset: num(p.startOffset) === void 0 ? void 0 : Math.round(num(p.startOffset)),
+        reverse: bool(p.reverse),
+        rotate: bool(p.rotate)
+      });
+    case "bendAlong":
+      return defined({
+        fit: oneOf(p.fit, ["stretch", "natural"]),
+        baseline: num(p.baseline),
+        flip: bool(p.flip),
+        tolerance: num(p.tolerance) === void 0 ? void 0 : Math.max(num(p.tolerance), 0.01)
+      });
+    case "repeatAlong":
+      return defined({
+        count: num(p.count) === void 0 ? void 0 : Math.max(Math.round(num(p.count)), 0),
+        spacing: num(p.spacing) === void 0 ? void 0 : Math.max(num(p.spacing), 0),
+        align: oneOf(p.align, ["start", "center", "end"]),
+        offset: num(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 selectedPair(deps) {
+  const scene = deps?.scene;
+  if (!scene || registeredPathEffects(scene.registry) === null) return null;
+  const leaves = (deps?.selection?.get() ?? []).map((id) => scene.get(id)).filter((n) => n !== void 0 && n.kind === "leaf");
+  return leaves.length >= 2 ? [leaves[0], leaves[1]] : null;
+}
+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,
+    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 pair = selectedPair(deps);
+        if (!scene || !pair) return;
+        const derivations = registeredPathEffects(scene.registry);
+        const [a, b] = pair;
+        const effect = withEffectSettings(EFFECT_DEFAULTS[spec.kind], params);
+        const sameParent = a.parent === b.parent;
+        const slots = [slotOf(scene, a.id), slotOf(scene, b.id)];
+        const index = !sameParent ? -1 : spec.between ? Math.max(...slots) : Math.max(...slots) + 1;
+        const node = {
+          ...pathEffectNode(effect, [a.id, b.id], a.layer, derivations),
+          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 selectedPair(deps) ? true : ActionDisabledReason.SelectionRequired;
+    }
+  };
+}
+var blendAction = createEffectAction({
+  id: "blend",
+  label: "Blend",
+  kind: "blend",
+  key: "b",
+  code: "KeyB",
+  between: true
+});
+var bendAlongAction = createEffectAction({
+  id: "bendAlong",
+  label: "Bend Along Path",
+  kind: "bendAlong",
+  key: "w",
+  code: "KeyW",
+  between: false
+});
+var repeatAlongAction = createEffectAction({
+  id: "repeatAlong",
+  label: "Repeat Along Path",
+  kind: "repeatAlong",
+  key: "r",
+  code: "KeyR",
+  between: false
+});
+var EDIT_LABEL = "Edit Path Effect";
+var editPathEffectAction = {
+  id: "editPathEffect",
+  label: EDIT_LABEL,
+  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,
+  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));
+        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", SimplifyBrushIcon);
+var DEFAULT_SMUDGE_RADIUS_PX = 40;
+var DEFAULT_SMUDGE_STRENGTH = 0.6;
+var LABEL = "Smudge brush";
+var num2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function radiusOf2(params) {
+  return Math.max(1, num2(params?.radiusPx, DEFAULT_SMUDGE_RADIUS_PX));
+}
+function strengthOf(params) {
+  return Math.min(1, Math.max(0, num2(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: LABEL,
+  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 shapeOf = (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, LABEL)), LABEL);
+        },
+        previewIds: () => current.size > 0 ? [...current.keys()] : null,
+        previewPose: (id) => shapeOf(id)?.pose ?? null,
+        previewData: (id) => shapeOf(id)?.data ?? null
+      };
+    }
+  },
+  enabled: (deps) => selectedPathNodes(deps).length > 0 ? true : ActionDisabledReason.SelectionRequired
+};
+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",
+  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)) {
+    const a = boundsOfPath(transformPath(made, toStorage));
+    const b = boundsOfPath(stored.path);
+    toStorage = multiply(boxToBox(a.x, a.y, a.width, a.height, b.x, b.y, b.width, b.height), toStorage);
+    if (!sameUnder(made, toStorage, stored.path)) return null;
+  }
+  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 splitByWarp(nodes, kind) {
+  const held = [];
+  const bare = [];
+  for (const node of nodes) {
+    const resolved = resolvePathWarp(node.node);
+    if (resolved && resolved.held.warp.kind === kind) held.push({ node, ...resolved, fresh: false });
+    else bare.push(node);
+  }
+  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), 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",
+  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",
+  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]
+};
+var bridgePreset = {
+  id: "bridge",
+  actions: [bridgeAnchorsAction, bridgePathsAction]
+};
+var trimPreset = { id: "trim", actions: [trimPathAction] };
+var extendPreset = { id: "extend", actions: [extendToMeetAction] };
+var smudgePreset = { id: "smudge", actions: [smudgeBrushAction] };
+var harmonizePreset = { id: "harmonize", actions: [harmonizeAnchorsAction] };
+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();
+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,
+    trimPreset,
+    extendPreset,
+    smudgePreset,
+    harmonizePreset,
+    curvatureCombPreset,
+    balancePreset,
+    constraintsPreset,
+    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: createElement(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: SliceIcon, 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: SliceIcon,
+      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" },
+    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, box } = splitByWarp(nodes, src.kind);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of held) {
+    if (seen.has(t.held.id)) continue;
+    seen.add(t.held.id);
+    out.push({ warpId: t.held.id, warp: t.held.warp, toWorld: t.toWorld });
+  }
+  if (box) out.push({ warpId: null, warp: freshWarp(src.kind, box, src.settings()), 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);
+  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 line2 of guideLines(group)) {
+          const screen = line2.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 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: "M" }, 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" },
+      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 });
+}
+
+export { CONSTRAINTS_EXTENSION_ID, DEFAULT_BRIDGE_TENSION, DEFAULT_ENVELOPE_SIZE, DEFAULT_SMUDGE_RADIUS_PX, DEFAULT_SMUDGE_STRENGTH, DEFAULT_WARP_TOLERANCE, PATH_BALANCE_CHROME_ID, PATH_COMB_CHROME_ID, PATH_EFFECTS_GROUP, SIMPLIFY_BRUSH_RADIUS_PX, SIMPLIFY_BRUSH_TOOL, balanceCommands, balanceHandlesAction, balancePreset, bendAlongAction, blendAction, bridgeAnchorsAction, bridgePathsAction, bridgePreset, bridgeTensionOf, brushRingCursor, combCommands, configureWarpAction, constrainAnchorsAction, constraintAxisOf, constraintConflictsOf, constraintsForAnchors, constraintsOf, constraintsPreset, createBalanceExtension, createBalancePreset, createCombExtension, createConstraintsExtension, createConstraintsPreset, createCurvatureCombPreset, curvatureCombPreset, deleteConstraintAction, editPathEffectAction, equalizeHandlesAction, expandPathEffectAction, expandWarpAction, extendPreset, extendToMeetAction, handleLockAngleAction, handleLockLengthAction, handleLocksPreset, harmonizeAnchorsAction, harmonizePreset, heldPathWarpOf, pathEffectsPreset, pathTools, planTrim, repeatAlongAction, resolvePathWarp, selectedConstraintOf, setConstraints, simplifyBrushAction, simplifyBrushPreset, simplifyBrushToolAction, smudgeBrushAction, smudgePreset, trimPathAction, trimPreset, unconstrainAnchorsAction, useDistortTool, useEnvelopeTool, useExtendTool, usePuppetTool, useSmudgeBrushTool, useTrimTool, warpHandleScratchOf, warpLayerId, warpPreset, withPathWarp, withoutPathWarp };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map