@weasel-js/core 1.10.1 → 1.11.0

package/dist/tools/builtin/pen/usePenTool.js

@@ -1,173 +1,283 @@
-import { asNodeId as e } from "../../../core/scene/types.js";
-import { defaultCommitAdapter as t } from "../../../interactions/actions/defaultCommitAdapter.js";
-import { createDeleteOp as n } from "../../../core/ops/delete.js";
-import { defineTool as r } from "../../overlayBinding.js";
-import i from "../../../icons/PenIcon.js";
-import { createPenPreviewLayer as a } from "../../../features/paths/penPreviewLayer.js";
-import { constrainTo45 as o } from "../../../util/constrainTo45.js";
-import { createPointerFollower as s } from "../shared/pointerFollower.js";
-import { anchorsToPath as c, boundsOfPath as l, editAnchorSetTracked as u, nearestPathAnchor as d, pathToAnchors as f, pxExtent as p, reverseAnchors as m, withinPxRadius as h } from "@weasel-js/geom";
-import { createElement as g, useCallback as _, useMemo as v, useReducer as y, useRef as b, useState as x } from "react";
-import { useLatest as S } from "@weasel-js/react";
-import { ActionDisabledReason as C } from "@weasel-js/routing";
-import { cursorFor as w } from "@weasel-js/cursor";
+import { asNodeId } from "../../../core/scene/types.js";
+import { defaultCommitAdapter } from "../../../interactions/actions/defaultCommitAdapter.js";
+import { snapMods } from "../../../features/snap/roles.js";
+import { createDeleteOp } from "../../../core/ops/delete.js";
+import { resolveEditablePathOf } from "../../../features/paths/editablePath.js";
+import { defineTool } from "../../overlayBinding.js";
+import { createPenPreviewLayer, penReachOf } from "../../../features/paths/penPreviewLayer.js";
+import { PEN_HANDLE_ROLES, pullHandle } from "./penHandle.js";
+import { pointSnap } from "../../../features/snap/pointSnap.js";
+import { createPointerFollower } from "../shared/pointerFollower.js";
+import { anchorsToPath, boundsOfPath, editAnchorSetTracked, nearestPathAnchor, pathToAnchors, pxExtent, reverseAnchors, withinPxRadius } from "@weasel-js/geom";
+import { useCallback, useMemo, useReducer, useRef, useState } from "react";
+import { useKitSettings, useLatest } from "@weasel-js/react";
+import { ActionDisabledReason } from "@weasel-js/routing";
+import { cursorFor } from "@weasel-js/cursor";
+
 //#region src/tools/builtin/pen/usePenTool.ts
-function T() {
+function freshScratch() {
 	return {
 		finishedSubpaths: [],
 		current: null,
 		cursor: null,
 		draggingHandleAt: null,
-		closeHintActive: !1,
+		closeHintActive: false,
 		continuing: null
 	};
 }
-function E(e) {
-	e.finishedSubpaths = [], e.current = null, e.cursor = null, e.draggingHandleAt = null, e.closeHintActive = !1, e.continuing = null;
+function resetScratch(s) {
+	s.finishedSubpaths = [];
+	s.current = null;
+	s.cursor = null;
+	s.draggingHandleAt = null;
+	s.closeHintActive = false;
+	s.continuing = null;
 }
-function D(e) {
-	return (e.current ? e.current.anchors.length : 0) + e.finishedSubpaths.reduce((e, t) => e + t.anchors.length, 0);
+/** Total anchors across finished subpaths plus the in-progress one. */
+function anchorCount(s) {
+	return (s.current ? s.current.anchors.length : 0) + s.finishedSubpaths.reduce((n, sp) => n + sp.anchors.length, 0);
 }
-function O(e, t) {
-	let n = [...e];
-	return t && t.anchors.length > 0 && n.push(t), c(n.map((e) => e.anchors), n.map((e) => e.closed));
+/** Build a PolygonPath from the pen's accumulated subpaths, by the same
+*  rule as any anchor set: segment A→B is a cubic through A's out-handle and
+*  B's in-handle when either exists, else a line. */
+function buildPath(subpaths, trailing) {
+	const all = [...subpaths];
+	if (trailing && trailing.anchors.length > 0) all.push(trailing);
+	return anchorsToPath(all.map((sp) => sp.anchors), all.map((sp) => sp.closed));
 }
-function k(o = {}) {
-	let { autoSelect: p = !0, autoCommitOnClose: k = !0, closeHitRadius: P = 8, anchorSnapRadius: F = 8, snapPoint: I } = o, L = b(null);
-	L.current === null && (L.current = T());
-	let R = S({
-		autoSelect: p,
-		autoCommitOnClose: k,
-		closeHitRadius: P,
-		anchorSnapRadius: F,
-		snapPoint: I
-	}), [, z] = y((e) => e + 1, 0), [B] = x(() => a({ state: L.current })), V = _((t, n, r) => {
-		let i = r.editAnchors, a = t.continuing, o = [...t.finishedSubpaths, ...n ? [n] : []];
-		if (!i || o.length === 0) return;
-		let { anchors: s, closed: c } = f(O(o, null));
-		a.reversed && (s[0] = m(s[0]));
-		let l = u(a.original, (e) => {
-			e.anchors.splice(a.sub, 1, s[0]), e.closed.splice(a.sub, 1, c[0]), e.anchors.push(...s.slice(1)), e.closed.push(...c.slice(1));
+/**
+* Active-slot Tool: click + drag to build a `PolygonPath` Illustrator-style.
+*
+* Click places a corner anchor; click-drag places an anchor with an
+* outgoing bezier handle; click-the-first-anchor closes the subpath; Enter
+* open-finishes; Esc discards, and so does a tool switch. Shift constrains the placement-drag handle to 0/45/90/135°;
+* Alt during drag breaks the handle mirror for the next segment.
+*
+* Reshaping an existing path is not this tool's job — see {@link PenScratch}.
+*/
+function usePenTool(options = {}) {
+	const { autoSelect = true, autoCommitOnClose = true, closeHitRadius } = options;
+	const scratchRef = useRef(null);
+	if (scratchRef.current === null) scratchRef.current = freshScratch();
+	const optsRef = useLatest({
+		autoSelect,
+		autoCommitOnClose,
+		closeHitRadius,
+		kitSettings: useKitSettings()
+	});
+	const [snaps] = useState(pointSnap);
+	const [, forceRender] = useReducer((x) => x + 1, 0);
+	const [overlay] = useState(() => createPenPreviewLayer({
+		state: scratchRef.current,
+		kitSettings: () => optsRef.current.kitSettings
+	}));
+	/** Write the pen's subpaths back into the node it picked up: the first
+	*  replaces the subpath it continued, any later ones are appended. Skips
+	*  the write when nothing changed, so an empty pick-up leaves no undo
+	*  entry. */
+	const commitContinuation = useCallback((s, trailing, deps) => {
+		const edit = deps.editAnchors;
+		const cont = s.continuing;
+		const drawn = [...s.finishedSubpaths, ...trailing ? [trailing] : []];
+		if (!edit || drawn.length === 0) return;
+		const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath(drawn, null));
+		if (cont.reversed) added[0] = reverseAnchors(added[0]);
+		const next = editAnchorSetTracked(cont.original, (set) => {
+			set.anchors.splice(cont.sub, 1, added[0]);
+			set.closed.splice(cont.sub, 1, addedClosed[0]);
+			set.anchors.push(...added.slice(1));
+			set.closed.push(...addedClosed.slice(1));
 		});
-		N(l.path, a.original) || (i.applyEdit(a.id, l.path, "Continue path", l.origins), R.current.autoSelect && r.selection?.set([e(a.id)]));
-	}, [R]), H = _((e, t) => {
-		let n = e.current && e.current.anchors.length > 0 ? e.current : null;
-		if (e.continuing) {
-			V(e, n, t), E(e);
+		if (samePath(next.path, cont.original)) return;
+		edit.applyEdit(cont.id, next.path, "Continue path", next.origins);
+		if (optsRef.current.autoSelect) deps.selection?.set([asNodeId(cont.id)]);
+	}, [optsRef]);
+	const commit = useCallback((s, deps) => {
+		const trailing = s.current && s.current.anchors.length > 0 ? s.current : null;
+		if (s.continuing) {
+			commitContinuation(s, trailing, deps);
+			resetScratch(s);
 			return;
 		}
-		let r = n && n.anchors.length >= 2 ? n : null;
-		if (e.finishedSubpaths.length === 0 && !r) {
-			E(e);
+		const open = trailing && trailing.anchors.length >= 2 ? trailing : null;
+		if (s.finishedSubpaths.length === 0 && !open) {
+			resetScratch(s);
 			return;
 		}
-		let i = e.finishedSubpaths.every((e) => e.closed) && (r === null || r.closed), a = O(e.finishedSubpaths, r), o = t.insert?.commit(l(a), {
+		const allClosed = s.finishedSubpaths.every((sp) => sp.closed) && (open === null || open.closed);
+		const path = buildPath(s.finishedSubpaths, open);
+		const id = deps.insert?.commit(boundsOfPath(path), {
 			kind: "path",
-			path: a,
-			closed: i
+			path,
+			closed: allClosed
 		}) ?? null;
-		o !== null && R.current.autoSelect && t.selection?.set([o]), E(e);
-	}, [V, R]), U = _((e, t, n) => {
-		if (!n || n.end === null || !e.current || e.current.anchors.length === 0) return !1;
-		let r = e.continuing;
-		if (r && n.id === r.id && n.sub === r.sub) return !1;
-		let i = t.scene;
-		return !i && !t.applyOps || !(r ? t.editAnchors?.editOps : t.insert?.build) ? !1 : r?.id === n.id || i?.get(n.id) !== void 0;
-	}, []), W = _((r, i, a) => {
-		let o = i.editAnchors, s = i.scene, d = r.current, { anchors: p, closed: h } = f(O([...r.finishedSubpaths, d], null)), g = o.getEditablePath(a.id), _ = f(g), v = a.end === "last" ? m(_.anchors[a.sub]) : _.anchors[a.sub], y = p[p.length - 1], b = y[y.length - 1], x = d.anchors[d.anchors.length - 1].outHandle ?? v[0].outHandle;
-		x && (b.outHandle = { ...x }), y.push(...v.slice(1));
-		let S = r.continuing, C = S?.id === a.id, w = C ? {
+		if (id !== null && optsRef.current.autoSelect) deps.selection?.set([id]);
+		resetScratch(s);
+	}, [commitContinuation, optsRef]);
+	/** Whether an anchor about to land on `hit` finishes the path by joining
+	*  onto another open subpath. Its own continued subpath never counts —
+	*  reaching that one's far end is a close. Declines when the deps can't
+	*  commit the join as one op batch. */
+	const joinable = useCallback((s, deps, hit) => {
+		if (!hit || hit.end === null || !s.current || s.current.anchors.length === 0) return false;
+		const cont = s.continuing;
+		if (cont && hit.id === cont.id && hit.sub === cont.sub) return false;
+		const scene = deps.scene;
+		if (!scene && !deps.applyOps) return false;
+		if (!(cont ? deps.editAnchors?.editOps : deps.insert?.build)) return false;
+		return cont?.id === hit.id || scene?.get(hit.id) !== void 0;
+	}, []);
+	/** Finish the path onto `hit`, the endpoint its last anchor was just placed
+	*  on: the other subpath's anchors follow on from it, turned around when
+	*  `hit` is its last anchor, and its node is deleted. The path being drawn
+	*  keeps its identity — a continued node keeps its id and style, and a new
+	*  path is minted the way any pen path is. One op batch, so one undo. */
+	const commitJoin = useCallback((s, deps, hit) => {
+		const edit = deps.editAnchors;
+		const scene = deps.scene;
+		const current = s.current;
+		const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath([...s.finishedSubpaths, current], null));
+		const other = resolveEditablePathOf(scene?.get(hit.id)) ?? edit.getEditablePath(hit.id);
+		const otherSet = pathToAnchors(other);
+		const tail = hit.end === "last" ? reverseAnchors(otherSet.anchors[hit.sub]) : otherSet.anchors[hit.sub];
+		const joined = added[added.length - 1];
+		const joint = joined[joined.length - 1];
+		const out = current.anchors[current.anchors.length - 1].outHandle ?? tail[0].outHandle;
+		if (out) joint.outHandle = { ...out };
+		joined.push(...tail.slice(1));
+		const cont = s.continuing;
+		const sameNode = cont?.id === hit.id;
+		const rest = sameNode ? {
 			anchors: [],
 			closed: []
 		} : {
-			anchors: _.anchors.filter((e, t) => t !== a.sub),
-			closed: _.closed.filter((e, t) => t !== a.sub)
-		}, T = "Join paths", D = [], k;
-		if (S) {
-			S.reversed && (p[0] = m(p[0]));
-			let e = u(S.original, (e) => {
-				e.anchors.splice(S.sub, 1, p[0]), e.closed.splice(S.sub, 1, h[0]), e.anchors.push(...p.slice(1), ...w.anchors), e.closed.push(...h.slice(1), ...w.closed), C && (e.anchors.splice(a.sub, 1), e.closed.splice(a.sub, 1));
+			anchors: otherSet.anchors.filter((_, i) => i !== hit.sub),
+			closed: otherSet.closed.filter((_, i) => i !== hit.sub)
+		};
+		const label = "Join paths";
+		const ops = [];
+		let keptId;
+		if (cont) {
+			if (cont.reversed) added[0] = reverseAnchors(added[0]);
+			const next = editAnchorSetTracked(cont.original, (set) => {
+				set.anchors.splice(cont.sub, 1, added[0]);
+				set.closed.splice(cont.sub, 1, addedClosed[0]);
+				set.anchors.push(...added.slice(1), ...rest.anchors);
+				set.closed.push(...addedClosed.slice(1), ...rest.closed);
+				if (!sameNode) return;
+				set.anchors.splice(hit.sub, 1);
+				set.closed.splice(hit.sub, 1);
 			});
-			D.push(...o.editOps(S.id, e.path, T, e.origins)), k = S.id;
+			ops.push(...edit.editOps(cont.id, next.path, label, next.origins));
+			keptId = cont.id;
 		} else {
-			let e = c([...p, ...w.anchors], [...h, ...w.closed]), t = i.insert.build(l(e), {
+			const path = anchorsToPath([...added, ...rest.anchors], [...addedClosed, ...rest.closed]);
+			const built = deps.insert.build(boundsOfPath(path), {
 				kind: "path",
-				path: e,
-				closed: !1
+				path,
+				closed: false
 			});
-			if (t === null) return;
-			D.push(...t.ops), k = t.id;
+			if (built === null) return;
+			ops.push(...built.ops);
+			keptId = built.id;
 		}
-		C || D.push(n({ node: s.get(a.id) }));
-		let A = i.applyOps;
-		A ? A(D, T) : s.applyBatch(D, T, t(s)), R.current.autoSelect && i.selection?.set([e(k)]), E(r);
-	}, [R]), G = _((e, t, n) => {
-		let r = L.current;
-		if (r.current || r.finishedSubpaths.length > 0) return !1;
-		let i = R.current.closeHitRadius, a = j(e), o = d(M(e, t, n, i), {
-			x: t,
-			y: n
-		}, i, a, (e) => e.end !== null);
-		if (!o) return !1;
-		let s = e.editAnchors.getEditablePath(o.id), c = f(s).anchors[o.sub], l = o.end === "first" && c.length > 1;
-		return r.current = {
-			anchors: l ? m(c) : c,
-			closed: !1
-		}, r.continuing = {
-			id: o.id,
-			sub: o.sub,
-			reversed: l,
-			original: s
-		}, !0;
-	}, [R]), K = _((e, t) => {
-		let n = R.current.snapPoint;
-		return n ? n({
-			x: e,
-			y: t
-		}) : {
-			x: e,
-			y: t
+		if (!sameNode) ops.push(createDeleteOp({ node: scene.get(hit.id) }));
+		const applyOps = deps.applyOps;
+		if (applyOps) applyOps(ops, label);
+		else scene.applyBatch(ops, label, defaultCommitAdapter(scene));
+		if (optsRef.current.autoSelect) deps.selection?.set([asNodeId(keptId)]);
+		resetScratch(s);
+	}, [optsRef]);
+	/** From idle, a press on an open subpath's end anchor picks that subpath
+	*  up: it becomes `current`, turned so the pressed end is last. Returns
+	*  whether it did. */
+	const pickUpEndpoint = useCallback((deps, wx, wy) => {
+		const scratch = scratchRef.current;
+		if (scratch.current || scratch.finishedSubpaths.length > 0) return false;
+		const hit = openEndNear(deps, wx, wy, penReachOf(optsRef.current).close);
+		if (!hit) return false;
+		const original = deps.editAnchors.getEditablePath(hit.id);
+		const picked = pathToAnchors(original).anchors[hit.sub];
+		const reversed = hit.end === "first" && picked.length > 1;
+		scratch.current = {
+			anchors: reversed ? reverseAnchors(picked) : picked,
+			closed: false
 		};
-	}, [R]), q = _((e, t, n) => {
-		let r = R.current.anchorSnapRadius;
-		if (r > 0) {
-			let i = d(M(e, t, n, r), {
-				x: t,
-				y: n
-			}, r, j(e));
-			if (i) return {
-				x: i.x,
-				y: i.y,
-				hit: i
-			};
-		}
+		scratch.continuing = {
+			id: hit.id,
+			sub: hit.sub,
+			reversed,
+			original
+		};
+		return true;
+	}, [optsRef]);
+	/** Where an anchor pressed at `(x, y)` lands: on an open subpath's end
+	*  within the close-hit radius of the press, which `hit` names, else
+	*  wherever the snap session puts it. */
+	const placeAt = useCallback((deps, x, y, mods) => {
+		const hit = openEndNear(deps, x, y, penReachOf(optsRef.current).close);
+		if (hit) return {
+			x: hit.x,
+			y: hit.y,
+			hit
+		};
+		const last = scratchRef.current.current?.anchors.at(-1);
 		return {
-			...K(t, n),
+			...snaps.place(deps.snap, {
+				x,
+				y
+			}, snapMods({ modifiers: mods }), last).point,
 			hit: null
 		};
-	}, [K, R]), J = _((e, t, n, r, i) => h(t - r, n - i, R.current.closeHitRadius, j(e)), [R]), Y = v(() => {
-		let e, t = s(() => n()), n = () => {
-			let n = L.current;
-			!n.current && n.finishedSubpaths.length === 0 && t.unfollow();
-			let r = n.current ? t.pointer()?.get() ?? null : null;
-			n.cursor = r ? K(r.worldX, r.worldY) : null;
-			let i = n.current && n.current.anchors.length >= 3 ? n.current.anchors[0] : null;
-			n.closeHintActive = i !== null && n.cursor !== null && h(i.x - n.cursor.x, i.y - n.cursor.y, R.current.closeHitRadius, e?.get().scale ?? {
+	}, [snaps, optsRef]);
+	/** Is a world point within the close-hit radius of `(ax, ay)`? Measured as a
+	*  screen-space circle, so the zone stays round under non-uniform zoom. */
+	const withinCloseRadius = useCallback((deps, ax, ay, wx, wy) => withinPxRadius(ax - wx, ay - wy, penReachOf(optsRef.current).close, viewScale(deps)), [optsRef]);
+	const trail = useMemo(() => {
+		let followed;
+		const follower = createPointerFollower(() => track());
+		const track = () => {
+			const s = scratchRef.current;
+			if (!s.current && s.finishedSubpaths.length === 0) follower.unfollow();
+			const at = s.current ? follower.pointer()?.get() ?? null : null;
+			if (!at || s.draggingHandleAt !== null) snaps.stop();
+			s.cursor = !at ? null : s.draggingHandleAt !== null ? {
+				x: at.worldX,
+				y: at.worldY
+			} : snaps.trail(followed?.snap, {
+				x: at.worldX,
+				y: at.worldY
+			}, s.current?.anchors.at(-1));
+			const first = s.current && s.current.anchors.length >= 3 ? s.current.anchors[0] : null;
+			s.closeHintActive = first !== null && s.cursor !== null && withinPxRadius(first.x - s.cursor.x, first.y - s.cursor.y, penReachOf(optsRef.current).close, followed?.view?.get().scale ?? {
 				x: 1,
 				y: 1
-			}), z();
+			});
+			forceRender();
 		};
 		return {
-			refresh: n,
-			update(r) {
-				e = r.view, t.follow(r.pointer), n();
+			/** Repaint after a scratch change. */
+			refresh: track,
+			/** The same, following `deps`' pointer from here on. */
+			update(deps) {
+				followed = deps;
+				follower.follow(deps.pointer);
+				track();
 			},
 			stop() {
-				t.unfollow(), z();
+				follower.unfollow();
+				snaps.stop();
+				forceRender();
 			}
 		};
-	}, [K, R]), X = v(() => {
-		let e = () => L.current;
+	}, [snaps, optsRef]);
+	/**
+	* Actions the pen owns, registered by `useToolActions` from inside the
+	* ActionsProvider — see `ToolDef.actions`. They close over `scratchRef`,
+	* so the state never leaves the hook.
+	*/
+	const actions = useMemo(() => {
+		const s = () => scratchRef.current;
 		return [
 			{
 				id: "pen.placeAnchor",
@@ -181,33 +291,43 @@ function k(o = {}) {
 					"scene",
 					"applyOps",
 					"insert",
-					"selection"
+					"selection",
+					"snap"
 				],
 				invoker: {
 					timing: "immediate",
-					run: (t, n) => {
-						let r = n;
-						if (r?.pressX === void 0 || r.pressY === void 0) return;
-						if (G(t, r.pressX, r.pressY)) {
-							Y.update(t);
+					run: (deps, params) => {
+						const p = params;
+						if (p?.pressX === void 0 || p.pressY === void 0) return;
+						if (pickUpEndpoint(deps, p.pressX, p.pressY)) {
+							trail.update(deps);
 							return;
 						}
-						let { x: i, y: a, hit: o } = q(t, r.pressX, r.pressY), s = e();
-						if (s.current && s.current.anchors.length >= 3) {
-							let e = s.current.anchors[0];
-							if (J(t, e.x, e.y, i, a)) {
-								s.current.closed = !0, s.finishedSubpaths.push(s.current), s.current = null, s.closeHintActive = !1, R.current.autoCommitOnClose && H(s, t), Y.update(t);
+						const { x: wx, y: wy, hit } = placeAt(deps, p.pressX, p.pressY, p.mods ?? NO_KEYS);
+						const scratch = s();
+						if (scratch.current && scratch.current.anchors.length >= 3) {
+							const first = scratch.current.anchors[0];
+							if (withinCloseRadius(deps, first.x, first.y, wx, wy)) {
+								scratch.current.closed = true;
+								scratch.finishedSubpaths.push(scratch.current);
+								scratch.current = null;
+								scratch.closeHintActive = false;
+								if (optsRef.current.autoCommitOnClose) commit(scratch, deps);
+								trail.update(deps);
 								return;
 							}
 						}
-						let c = U(s, t, o);
-						s.current ||= {
+						const join = joinable(scratch, deps, hit);
+						if (!scratch.current) scratch.current = {
 							anchors: [],
-							closed: !1
-						}, s.current.anchors.push({
-							x: i,
-							y: a
-						}), c && W(s, t, o), Y.update(t);
+							closed: false
+						};
+						scratch.current.anchors.push({
+							x: wx,
+							y: wy
+						});
+						if (join) commitJoin(scratch, deps, hit);
+						trail.update(deps);
 					}
 				}
 			},
@@ -220,12 +340,17 @@ function k(o = {}) {
 					"insert",
 					"selection"
 				],
-				enabled: () => D(e()) >= 2 || C.NotApplicable,
+				enabled: () => anchorCount(s()) >= 2 ? true : ActionDisabledReason.NotApplicable,
 				invoker: {
 					timing: "immediate",
-					run: (t, n) => {
-						let r = e();
-						n?.viaDoubleClick && r.current && (r.current.anchors.pop(), r.current.anchors.length === 0 && (r.current = null)), H(r, t), Y.refresh();
+					run: (deps, params) => {
+						const scratch = s();
+						if (params?.viaDoubleClick && scratch.current) {
+							scratch.current.anchors.pop();
+							if (scratch.current.anchors.length === 0) scratch.current = null;
+						}
+						commit(scratch, deps);
+						trail.refresh();
 					}
 				}
 			},
@@ -233,6 +358,7 @@ function k(o = {}) {
 				id: "pen.dragHandle",
 				label: "Pen — drag out a bezier handle",
 				eligible: { capability: "creates-paths" },
+				modifierRoles: PEN_HANDLE_ROLES,
 				requires: [
 					"view",
 					"pointer",
@@ -241,36 +367,56 @@ function k(o = {}) {
 					"scene",
 					"applyOps",
 					"insert",
-					"selection"
+					"selection",
+					"snap"
 				],
 				invoker: {
 					timing: "ongoing",
-					start: (t) => {
-						let n = e(), r = t.drag?.start ?? t.world, i = G(t.deps, r.x, r.y), a = null;
-						if (!i) {
-							let { x: e, y: i, hit: o } = q(t.deps, r.x, r.y);
-							U(n, t.deps, o) && (a = o), n.current ||= {
+					start: (ctx) => {
+						const scratch = s();
+						const origin = ctx.drag?.start ?? ctx.world;
+						const pickedUp = pickUpEndpoint(ctx.deps, origin.x, origin.y);
+						let joinHit = null;
+						if (!pickedUp) {
+							const { x: ax, y: ay, hit } = placeAt(ctx.deps, origin.x, origin.y, ctx.modifiers);
+							if (joinable(scratch, ctx.deps, hit)) joinHit = hit;
+							if (!scratch.current) scratch.current = {
 								anchors: [],
-								closed: !1
-							}, n.current.anchors.push({
-								x: e,
-								y: i
+								closed: false
+							};
+							scratch.current.anchors.push({
+								x: ax,
+								y: ay
 							});
 						}
-						n.draggingHandleAt = n.current.anchors.length - 1, t.modifiers.alt && (n.current.anchors[n.draggingHandleAt].altBroken = !0);
-						let o = !i;
-						return A(n, t.world, t.modifiers.shift, o, R.current.snapPoint), Y.update(t.deps), {
-							onMove: (t) => {
-								let n = e();
-								n.draggingHandleAt !== null && (t.modifiers.alt && n.current && (n.current.anchors[n.draggingHandleAt].altBroken = !0), A(n, t.world, t.modifiers.shift, o, R.current.snapPoint), z());
+						scratch.draggingHandleAt = scratch.current.anchors.length - 1;
+						const handle = pullHandle(scratch, ctx, !pickedUp);
+						handle.to(ctx);
+						trail.update(ctx.deps);
+						return {
+							onMove: (moveCtx) => {
+								handle.to(moveCtx);
+								forceRender();
 							},
-							onEnd: (n, r) => {
-								let s = e();
-								if (r === "cancel") {
-									i ? E(s) : s.current && s.draggingHandleAt === s.current.anchors.length - 1 && (s.current.anchors.pop(), s.current.anchors.length === 0 && (s.current = null)), s.draggingHandleAt = null, Y.refresh();
-									return;
+							onEnd: (endCtx, reason) => {
+								const se = s();
+								try {
+									if (reason === "cancel") {
+										if (pickedUp) resetScratch(se);
+										else if (se.current && se.draggingHandleAt === se.current.anchors.length - 1) {
+											se.current.anchors.pop();
+											if (se.current.anchors.length === 0) se.current = null;
+										}
+										se.draggingHandleAt = null;
+										return;
+									}
+									handle.to(endCtx);
+									se.draggingHandleAt = null;
+									if (joinHit && se.current) commitJoin(se, ctx.deps, joinHit);
+								} finally {
+									handle.end();
+									trail.refresh();
 								}
-								s.draggingHandleAt !== null && (n.modifiers.alt && s.current && (s.current.anchors[s.draggingHandleAt].altBroken = !0), A(s, n.world, n.modifiers.shift, o, R.current.snapPoint), s.draggingHandleAt = null), a && s.current && W(s, t.deps, a), Y.refresh();
 							}
 						};
 					}
@@ -285,11 +431,12 @@ function k(o = {}) {
 					"insert",
 					"selection"
 				],
-				enabled: () => D(e()) > 0 || C.NotApplicable,
+				enabled: () => anchorCount(s()) > 0 ? true : ActionDisabledReason.NotApplicable,
 				invoker: {
 					timing: "immediate",
-					run: (t) => {
-						H(e(), t), Y.refresh();
+					run: (deps) => {
+						commit(s(), deps);
+						trail.refresh();
 					}
 				}
 			},
@@ -298,165 +445,176 @@ function k(o = {}) {
 				label: "Pen — discard path",
 				eligible: { capability: "creates-paths" },
 				enabled: () => {
-					let t = e();
-					return t.current !== null || t.finishedSubpaths.length > 0 || C.NotApplicable;
+					const scratch = s();
+					return scratch.current !== null || scratch.finishedSubpaths.length > 0 ? true : ActionDisabledReason.NotApplicable;
 				},
 				invoker: {
 					timing: "immediate",
 					run: () => {
-						E(e()), Y.refresh();
+						resetScratch(s());
+						trail.refresh();
 					}
 				}
 			}
 		];
 	}, [
-		H,
-		q,
-		J,
-		G,
-		U,
-		W,
-		R,
-		Y,
-		z
+		commit,
+		placeAt,
+		withinCloseRadius,
+		pickUpEndpoint,
+		joinable,
+		commitJoin,
+		optsRef,
+		trail,
+		forceRender
 	]);
-	return v(() => r({
-		id: "pen",
-		keybinding: { key: "P" },
-		capabilities: ["creates-paths"],
-		hookName: "usePenTool",
-		cursor: () => L.current?.closeHintActive ? "pointer" : w("pen", { fallback: "crosshair" }),
-		presentation: {
-			label: "Pen",
-			icon: g(i),
-			group: "draw"
-		},
-		actions: X,
-		overlay: B,
-		overlayPosition: "before-selection",
-		onDeactivate: () => {
-			E(L.current), Y.stop();
-		},
-		bindings: [
-			{
-				spec: {
-					kind: "click",
-					mods: {
-						shift: "optional",
-						alt: "optional"
-					}
-				},
-				actionId: "pen.placeAnchor"
+	return useMemo(() => {
+		return defineTool({
+			id: "pen",
+			keybinding: { key: "P" },
+			capabilities: ["creates-paths"],
+			hookName: "usePenTool",
+			cursor: () => scratchRef.current?.closeHintActive ? "pointer" : cursorFor("pen", { fallback: "crosshair" }),
+			presentation: {
+				label: "Pen",
+				icon: /* @icon */ "core:pen",
+				group: "draw"
 			},
-			{
-				spec: {
-					kind: "click",
-					mods: {
-						mod: !0,
-						shift: "optional",
-						alt: "optional"
-					}
-				},
-				actionId: "pen.finishOpen"
+			actions,
+			overlay,
+			overlayPosition: "before-selection",
+			onDeactivate: () => {
+				resetScratch(scratchRef.current);
+				trail.stop();
 			},
-			{
-				spec: {
-					kind: "doubleClick",
-					mods: {
-						shift: "optional",
-						alt: "optional"
-					}
+			bindings: [
+				{
+					spec: {
+						kind: "click",
+						mods: {
+							shift: "optional",
+							alt: "optional"
+						}
+					},
+					actionId: "pen.placeAnchor"
 				},
-				actionId: "pen.finishOpen",
-				opts: { params: { viaDoubleClick: !0 } }
-			},
-			{
-				spec: {
-					kind: "drag",
-					mods: {
-						shift: "optional",
-						alt: "optional"
-					}
+				{
+					spec: {
+						kind: "click",
+						mods: {
+							mod: true,
+							shift: "optional",
+							alt: "optional"
+						}
+					},
+					actionId: "pen.finishOpen"
 				},
-				actionId: "pen.dragHandle"
-			},
-			{
-				spec: {
-					kind: "key",
-					key: "Enter"
+				{
+					spec: {
+						kind: "doubleClick",
+						mods: {
+							shift: "optional",
+							alt: "optional"
+						}
+					},
+					actionId: "pen.finishOpen",
+					opts: { params: { viaDoubleClick: true } }
 				},
-				actionId: "pen.finish"
-			},
-			{
-				spec: {
-					kind: "key",
-					key: "Escape"
+				{
+					spec: {
+						kind: "drag",
+						mods: {
+							shift: "optional",
+							alt: "optional",
+							ctrl: "optional"
+						}
+					},
+					actionId: "pen.dragHandle"
 				},
-				actionId: "pen.cancel"
-			}
-		]
-	}), [
-		X,
-		Y,
-		B
+				{
+					spec: {
+						kind: "key",
+						key: "Enter"
+					},
+					actionId: "pen.finish"
+				},
+				{
+					spec: {
+						kind: "key",
+						key: "Escape"
+					},
+					actionId: "pen.cancel"
+				}
+			]
+		});
+	}, [
+		actions,
+		trail,
+		overlay
 	]);
 }
-k.prefs = {
+usePenTool.prefs = {
 	name: "Pen",
 	description: "Pen-tool behavior.",
 	children: { autoCommitOnClose: {
 		kind: "boolean",
 		name: "Auto-commit pen on close",
 		description: "When you click the pen tool's first anchor to close a region, commit immediately so it renders with its fill. Off: keep the path in preview until you press Enter (lets you build a compound path from multiple closed subpaths).",
-		default: !0
+		default: true
 	} }
 };
-function A(e, t, n, r, i) {
-	if (e.current === null || e.draggingHandleAt === null) return;
-	let a = e.current.anchors[e.draggingHandleAt], s = i ? i(t) : t, c = s.x - a.x, l = s.y - a.y;
-	if (n) {
-		let e = o(c, l);
-		c = e.dx, l = e.dy;
-	}
-	a.outHandle = {
-		x: a.x + c,
-		y: a.y + l
-	}, r && !a.altBroken && (a.inHandle = {
-		x: a.x - c,
-		y: a.y - l
-	});
+var NO_KEYS = {
+	alt: false,
+	ctrl: false,
+	meta: false,
+	shift: false
+};
+/** The end anchor of an open subpath within `px` screen pixels of `(wx, wy)`,
+*  nearest first; null when there is none. */
+function openEndNear(deps, wx, wy, px) {
+	return nearestPathAnchor(pathsNear(deps, wx, wy, px), {
+		x: wx,
+		y: wy
+	}, px, viewScale(deps), (h) => h.end !== null);
 }
-function j(e) {
-	return e.view?.get().scale ?? {
+function viewScale(deps) {
+	return deps.view?.get().scale ?? {
 		x: 1,
 		y: 1
 	};
 }
-function M(e, t, n, r) {
-	let i = e.areaSelect, a = e.editAnchors;
-	if (!i || !a) return [];
-	let o = e.view, s = p(r, j(e)), c = i.hitTestArea({
-		x: t - s.x,
-		y: n - s.y,
-		width: 2 * s.x,
-		height: 2 * s.y
-	}, o), l = [];
-	for (let e of c) {
-		let t = a.getEditablePath(e);
-		t?.kind === "polygon" && l.push({
-			id: e,
-			path: t
+/** Existing editable paths, world coords, with ink within `px` screen
+*  pixels of `(wx, wy)` — front-to-back, as the area query returns them.
+*  Empty when the host publishes no `areaSelect` or `editAnchors` dep. */
+function pathsNear(deps, wx, wy, px) {
+	const area = deps.areaSelect;
+	const edit = deps.editAnchors;
+	if (!area || !edit) return [];
+	const view = deps.view;
+	const e = pxExtent(px, viewScale(deps));
+	const ids = area.hitTestArea({
+		x: wx - e.x,
+		y: wy - e.y,
+		width: 2 * e.x,
+		height: 2 * e.y
+	}, view);
+	const out = [];
+	for (const id of ids) {
+		const path = edit.getEditablePath(id);
+		if (path?.kind === "polygon") out.push({
+			id,
+			path
 		});
 	}
-	return l;
+	return out;
 }
-function N(e, t) {
-	if (e.commands.length !== t.commands.length || e.coords.length !== t.coords.length) return !1;
-	for (let n = 0; n < e.commands.length; n++) if (e.commands[n] !== t.commands[n]) return !1;
-	for (let n = 0; n < e.coords.length; n++) if (e.coords[n] !== t.coords[n]) return !1;
-	return !0;
+function samePath(a, b) {
+	if (a.commands.length !== b.commands.length || a.coords.length !== b.coords.length) return false;
+	for (let i = 0; i < a.commands.length; i++) if (a.commands[i] !== b.commands[i]) return false;
+	for (let i = 0; i < a.coords.length; i++) if (a.coords[i] !== b.coords[i]) return false;
+	return true;
 }
-//#endregion
-export { k as usePenTool };
 
+//#endregion
+export { usePenTool };
 //# sourceMappingURL=usePenTool.js.map