@weasel-js/core 1.7.0 → 1.7.2

package/dist/tools/builtin/line/useLineTool.js

@@ -0,0 +1,33 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/LineIcon.js";
+import { insertBindingBehaviors as n } from "../shared/insertToolOptions.js";
+import { useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+import { cursorFor as a } from "@weasel-js/cursor";
+//#region src/tools/builtin/line/useLineTool.tsx
+function o(o = {}) {
+	let { behaviors: s } = o;
+	return r(() => e({
+		id: "line",
+		capabilities: ["creates-shapes"],
+		hookName: "useLineTool",
+		cursor: a("crosshairLine", { fallback: "crosshair" }),
+		presentation: {
+			label: "Line",
+			group: "shape",
+			icon: /* @__PURE__ */ i(t, {})
+		},
+		bindings: [{
+			spec: { kind: "drag" },
+			actionId: "insert",
+			opts: {
+				params: { kind: "line" },
+				...n(s)
+			}
+		}]
+	}), [s]);
+}
+//#endregion
+export { o as useLineTool };
+
+//# sourceMappingURL=useLineTool.js.map

package/dist/tools/builtin/line/useLineTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLineTool.js","names":["LineIcon","useLineTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/line/useLineTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { LineIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** An endpoint of a line, in world coordinates. */\nexport interface LinePoint { x: number; y: number }\n\n/**\n * Click-down → drag → release line tool. The `drag` binding routes to\n * `insertAction`, which owns the live preview and commits through the\n * `insert` dep with `{ kind: 'line', a, b }` endpoints (not the AABB\n * diagonal), so the drag direction is preserved.\n *\n * Modifiers are applied by `insertAction`:\n *   - shift: constrain to 15° increments\n *   - alt: mirror the end around the start (the drag is treated as a\n *     half-line) — the line-specific reading of the action's\n *     corner ⇄ center origin toggle\n */\nexport function useLineTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'line',\n        capabilities: ['creates-shapes'],\n        hookName: 'useLineTool',\n        cursor: cursorFor('crosshairLine', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Line',\n          group: 'shape',\n          icon: <LineIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'line' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAsBA,SAAgBC,EAAY,IAA6B,CAAC,GAAe;CACvE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,iBAAiB,EAAE,UAAU,YAAY,CAAC;EAC5D,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAW,CAAA;EACnB;EACA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,OAAO;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC1E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}

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

@@ -0,0 +1,414 @@
+import { pxExtent as e, withinPxRadius as t } from "../../../core/viewport/pxExtent.js";
+import { defaultCommitAdapter as n } from "../../../interactions/actions/defaultCommitAdapter.js";
+import { createDeleteOp as r } from "../../../core/ops/delete.js";
+import { createInsertOp as i } from "../../../core/ops/create.js";
+import { anchorsToPath as a, pathToAnchors as o } from "../../../features/paths/anchors.js";
+import { defineTool as s } from "../../overlayBinding.js";
+import c from "../../../icons/PenIcon.js";
+import { nearestPathAnchor as l, reverseAnchors as u } from "../../../features/paths/nearestAnchor.js";
+import { constrainTo45 as d } from "../../../util/constrainTo45.js";
+import { createElement as f, useCallback as p, useMemo as m, useReducer as h, useRef as g } from "react";
+import { useLatest as _ } from "@weasel-js/react";
+import { ActionDisabledReason as v } from "@weasel-js/routing";
+import { cursorFor as y } from "@weasel-js/cursor";
+//#region src/tools/builtin/pen/usePenTool.ts
+function b() {
+	return {
+		finishedSubpaths: [],
+		current: null,
+		cursor: null,
+		draggingHandleAt: null,
+		closeHintActive: !1,
+		continuing: null
+	};
+}
+function x(e) {
+	e.finishedSubpaths = [], e.current = null, e.cursor = null, e.draggingHandleAt = null, e.closeHintActive = !1, e.continuing = null;
+}
+function S(e) {
+	return (e.current ? e.current.anchors.length : 0) + e.finishedSubpaths.reduce((e, t) => e + t.anchors.length, 0);
+}
+function C(e, t) {
+	let n = [...e];
+	return t && t.anchors.length > 0 && n.push(t), a(n.map((e) => e.anchors), n.map((e) => e.closed));
+}
+function w(e) {
+	let { wrapPath: d, adapter: w, autoSelect: k = !0, autoCommitOnClose: A = !0, closeHitRadius: j = 8, anchorSnapRadius: M = 8, snapPoint: N } = e, P = g(null);
+	P.current === null && (P.current = b());
+	let F = _({
+		wrapPath: d,
+		adapter: w,
+		autoSelect: k,
+		autoCommitOnClose: A,
+		closeHitRadius: j,
+		anchorSnapRadius: M,
+		snapPoint: N
+	}), [, I] = h((e) => e + 1, 0), L = p((e, t, n) => {
+		let r = e.continuing, i = [...e.finishedSubpaths, ...t ? [t] : []];
+		if (!n || i.length === 0) return;
+		let { anchors: s, closed: c } = o(C(i, null));
+		r.reversed && (s[0] = u(s[0]));
+		let l = o(r.original);
+		l.anchors.splice(r.sub, 1, s[0]), l.closed.splice(r.sub, 1, c[0]), l.anchors.push(...s.slice(1)), l.closed.push(...c.slice(1));
+		let d = {
+			...a(l.anchors, l.closed),
+			fillRule: r.original.fillRule
+		};
+		O(d, r.original) || (n.applyEdit(r.id, d, "Continue path"), F.current.autoSelect && F.current.adapter.setSelection([r.id]));
+	}, [F]), R = p((e, t) => {
+		let n = e.current && e.current.anchors.length > 0 ? e.current : null;
+		if (e.continuing) {
+			L(e, n, t.editAnchors), x(e);
+			return;
+		}
+		if (e.finishedSubpaths.length === 0 && !n) return;
+		let r = e.finishedSubpaths.every((e) => e.closed) && (n === null || n.closed), i = C(e.finishedSubpaths, n), a = F.current.wrapPath(i, { closed: r }), o = F.current.adapter.addNode(a);
+		F.current.autoSelect && F.current.adapter.setSelection([o]), x(e);
+	}, [L, F]), z = p((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 : F.current.adapter.makeNode) ? !1 : r?.id === n.id || i?.get(n.id) !== void 0;
+	}, [F]), B = p((e, t, s) => {
+		let c = t.editAnchors, l = t.scene, d = e.current, { anchors: f, closed: p } = o(C([...e.finishedSubpaths, d], null)), m = c.getEditablePath(s.id), h = o(m), g = s.end === "last" ? u(h.anchors[s.sub]) : h.anchors[s.sub], _ = f[f.length - 1], v = _[_.length - 1], y = d.anchors[d.anchors.length - 1].outHandle ?? g[0].outHandle;
+		y && (v.outHandle = { ...y }), _.push(...g.slice(1));
+		let b = e.continuing, S = b?.id === s.id, w = S ? {
+			anchors: [],
+			closed: []
+		} : {
+			anchors: h.anchors.filter((e, t) => t !== s.sub),
+			closed: h.closed.filter((e, t) => t !== s.sub)
+		}, T = "Join paths", E = [], D;
+		if (b) {
+			b.reversed && (f[0] = u(f[0]));
+			let e = o(b.original);
+			e.anchors.splice(b.sub, 1, f[0]), e.closed.splice(b.sub, 1, p[0]), e.anchors.push(...f.slice(1), ...w.anchors), e.closed.push(...p.slice(1), ...w.closed), S && (e.anchors.splice(s.sub, 1), e.closed.splice(s.sub, 1));
+			let t = {
+				...a(e.anchors, e.closed),
+				fillRule: b.original.fillRule
+			};
+			E.push(...c.editOps(b.id, t, T)), D = b.id;
+		} else {
+			let e = a([...f, ...w.anchors], [...p, ...w.closed]), t = F.current.adapter.makeNode(F.current.wrapPath(e, { closed: !1 }));
+			E.push(i({ node: t })), D = t.id;
+		}
+		S || E.push(r({ node: l.get(s.id) }));
+		let O = t.applyOps;
+		O ? O(E, T) : l.applyBatch(E, T, n(l)), F.current.autoSelect && F.current.adapter.setSelection([D]), x(e);
+	}, [F]), V = p((e, t, n) => {
+		let r = P.current;
+		if (r.current || r.finishedSubpaths.length > 0) return !1;
+		let i = F.current.closeHitRadius, a = E(e), s = l(D(e, t, n, i), {
+			x: t,
+			y: n
+		}, i, a, (e) => e.end !== null);
+		if (!s) return !1;
+		let c = e.editAnchors.getEditablePath(s.id), d = o(c).anchors[s.sub], f = s.end === "first" && d.length > 1;
+		return r.current = {
+			anchors: f ? u(d) : d,
+			closed: !1
+		}, r.continuing = {
+			id: s.id,
+			sub: s.sub,
+			reversed: f,
+			original: c
+		}, !0;
+	}, [F]), H = p((e, t) => {
+		let n = F.current.snapPoint;
+		return n ? n({
+			x: e,
+			y: t
+		}) : {
+			x: e,
+			y: t
+		};
+	}, [F]), U = p((e, t, n) => {
+		let r = F.current.anchorSnapRadius;
+		if (r > 0) {
+			let i = l(D(e, t, n, r), {
+				x: t,
+				y: n
+			}, r, E(e));
+			if (i) return {
+				x: i.x,
+				y: i.y,
+				hit: i
+			};
+		}
+		return {
+			...H(t, n),
+			hit: null
+		};
+	}, [H, F]), W = p((e, n, r, i, a) => t(n - i, r - a, F.current.closeHitRadius, E(e)), [F]), G = m(() => {
+		let e = () => P.current;
+		return [
+			{
+				id: "pen.placeAnchor",
+				label: "Pen — place anchor",
+				eligible: { capability: "creates-paths" },
+				requires: [
+					"view",
+					"areaSelect",
+					"editAnchors",
+					"scene",
+					"applyOps"
+				],
+				invoker: {
+					timing: "immediate",
+					run: (t, n) => {
+						let r = n;
+						if (r?.pressX === void 0 || r.pressY === void 0) return;
+						if (V(t, r.pressX, r.pressY)) {
+							I();
+							return;
+						}
+						let { x: i, y: a, hit: o } = U(t, r.pressX, r.pressY), s = e();
+						if (s.current && s.current.anchors.length >= 3) {
+							let e = s.current.anchors[0];
+							if (W(t, e.x, e.y, i, a)) {
+								s.current.closed = !0, s.finishedSubpaths.push(s.current), s.current = null, s.closeHintActive = !1, F.current.autoCommitOnClose && R(s, t), I();
+								return;
+							}
+						}
+						let c = z(s, t, o);
+						s.current ||= {
+							anchors: [],
+							closed: !1
+						}, s.current.anchors.push({
+							x: i,
+							y: a
+						}), c && B(s, t, o), I();
+					}
+				}
+			},
+			{
+				id: "pen.finishOpen",
+				label: "Pen — finish open path",
+				eligible: { capability: "creates-paths" },
+				requires: ["editAnchors"],
+				enabled: () => S(e()) >= 2 || v.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)), R(r, t), I();
+					}
+				}
+			},
+			{
+				id: "pen.dragHandle",
+				label: "Pen — drag out a bezier handle",
+				eligible: { capability: "creates-paths" },
+				requires: [
+					"view",
+					"areaSelect",
+					"editAnchors",
+					"scene",
+					"applyOps"
+				],
+				invoker: {
+					timing: "ongoing",
+					start: (t) => {
+						let n = e(), r = t.drag?.start ?? t.world, i = V(t.deps, r.x, r.y), a = null;
+						if (!i) {
+							let { x: e, y: i, hit: o } = U(t.deps, r.x, r.y);
+							z(n, t.deps, o) && (a = o), n.current ||= {
+								anchors: [],
+								closed: !1
+							}, n.current.anchors.push({
+								x: e,
+								y: i
+							});
+						}
+						n.draggingHandleAt = n.current.anchors.length - 1, t.modifiers.alt && (n.current.anchors[n.draggingHandleAt].altBroken = !0);
+						let o = !i;
+						return T(n, t.world, t.modifiers.shift, o, F.current.snapPoint), I(), {
+							onMove: (t) => {
+								let n = e();
+								n.draggingHandleAt !== null && (t.modifiers.alt && n.current && (n.current.anchors[n.draggingHandleAt].altBroken = !0), T(n, t.world, t.modifiers.shift, o, F.current.snapPoint), I());
+							},
+							onEnd: (n, r) => {
+								let s = e();
+								if (r === "cancel") {
+									i ? x(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, I();
+									return;
+								}
+								s.draggingHandleAt !== null && (n.modifiers.alt && s.current && (s.current.anchors[s.draggingHandleAt].altBroken = !0), T(s, n.world, n.modifiers.shift, o, F.current.snapPoint), s.draggingHandleAt = null), a && s.current && B(s, t.deps, a), I();
+							}
+						};
+					}
+				}
+			},
+			{
+				id: "pen.finish",
+				label: "Pen — finish path",
+				eligible: { capability: "creates-paths" },
+				requires: ["editAnchors"],
+				enabled: () => S(e()) > 0 || v.NotApplicable,
+				invoker: {
+					timing: "immediate",
+					run: (t) => {
+						R(e(), t), I();
+					}
+				}
+			},
+			{
+				id: "pen.cancel",
+				label: "Pen — discard path",
+				eligible: { capability: "creates-paths" },
+				enabled: () => {
+					let t = e();
+					return t.current !== null || t.finishedSubpaths.length > 0 || v.NotApplicable;
+				},
+				invoker: {
+					timing: "immediate",
+					run: () => {
+						x(e()), I();
+					}
+				}
+			}
+		];
+	}, [
+		R,
+		U,
+		W,
+		V,
+		z,
+		B,
+		F
+	]);
+	return m(() => s({
+		id: "pen",
+		capabilities: ["creates-paths"],
+		hookName: "usePenTool",
+		cursor: () => P.current?.closeHintActive ? "pointer" : y("pen", { fallback: "crosshair" }),
+		presentation: {
+			label: "Pen",
+			icon: f(c),
+			group: "draw"
+		},
+		initScratch: () => P.current,
+		actions: G,
+		onDeactivate: () => {
+			x(P.current), I();
+		},
+		bindings: [
+			{
+				spec: {
+					kind: "click",
+					mods: {
+						shift: "optional",
+						alt: "optional"
+					}
+				},
+				actionId: "pen.placeAnchor"
+			},
+			{
+				spec: {
+					kind: "click",
+					mods: {
+						mod: !0,
+						shift: "optional",
+						alt: "optional"
+					}
+				},
+				actionId: "pen.finishOpen"
+			},
+			{
+				spec: {
+					kind: "doubleClick",
+					mods: {
+						shift: "optional",
+						alt: "optional"
+					}
+				},
+				actionId: "pen.finishOpen",
+				opts: { params: { viaDoubleClick: !0 } }
+			},
+			{
+				spec: {
+					kind: "drag",
+					mods: {
+						shift: "optional",
+						alt: "optional"
+					}
+				},
+				actionId: "pen.dragHandle"
+			},
+			{
+				spec: {
+					kind: "key",
+					key: "Enter"
+				},
+				actionId: "pen.finish"
+			},
+			{
+				spec: {
+					kind: "key",
+					key: "Escape"
+				},
+				actionId: "pen.cancel"
+			}
+		]
+	}), [G]);
+}
+w.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
+	} }
+};
+function T(e, t, n, r, i) {
+	if (e.current === null || e.draggingHandleAt === null) return;
+	let a = e.current.anchors[e.draggingHandleAt], o = i ? i(t) : t, s = o.x - a.x, c = o.y - a.y;
+	if (n) {
+		let e = d(s, c);
+		s = e.dx, c = e.dy;
+	}
+	a.outHandle = {
+		x: a.x + s,
+		y: a.y + c
+	}, r && !a.altBroken && (a.inHandle = {
+		x: a.x - s,
+		y: a.y - c
+	});
+}
+function E(e) {
+	return e.view?.get().scale ?? {
+		x: 1,
+		y: 1
+	};
+}
+function D(t, n, r, i) {
+	let a = t.areaSelect, o = t.editAnchors;
+	if (!a || !o) return [];
+	let s = t.view, c = e(i, E(t)), l = a.hitTestArea({
+		x: n - c.x,
+		y: r - c.y,
+		width: 2 * c.x,
+		height: 2 * c.y
+	}, s), u = [];
+	for (let e of l) {
+		let t = o.getEditablePath(e);
+		t?.kind === "polygon" && u.push({
+			id: e,
+			path: t
+		});
+	}
+	return u;
+}
+function O(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;
+}
+//#endregion
+export { w as usePenTool };
+
+//# sourceMappingURL=usePenTool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePenTool.js","names":["p","PenIcon","freshScratch","resetScratch","anchorCount","s","n","sp","buildPath","all","subpaths","trailing","anchorsToPath","usePenTool","options","scratchRef","useRef","optsRef","useLatest","forceRender","useReducer","x","commitContinuation","useCallback","cont","drawn","edit","added","addedClosed","pathToAnchors","reverseAnchors","set","next","samePath","commit","deps","allClosed","path","pose","id","joinable","hit","scene","commitJoin","current","other","otherSet","tail","joined","joint","out","sameNode","rest","i","label","ops","keptId","node","createInsertOp","createDeleteOp","applyOps","defaultCommitAdapter","pickUpEndpoint","scratch","radius","scale","viewScale","nearestPathAnchor","pathsNear","wx","wy","h","original","picked","reversed","snap","fn","placeAt","y","withinCloseRadius","withinPxRadius","ax","ay","actions","useMemo","p","params","first","join","ActionDisabledReason","origin","ctx","pickedUp","joinHit","linked","applyOutHandle","sm","moveCtx","se","reason","endCtx","defineTool","cursorFor","createElement","anchor","to","target","dx","dy","shift","c","constrainTo45","area","view","e","pxExtent","px","ids","a","b"],"sources":["../../../../src/tools/builtin/pen/usePenTool.ts"],"sourcesContent":["import { useCallback, useMemo, useReducer, useRef, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport type { ToolPrefGroup } from '../../prefs';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ActionDeps, InvocationCtx } from '@weasel-js/routing';\nimport type { AreaSelectDep, EditAnchorsDep, ViewApi } from 'interactions/actions/depSchema';\nimport { pxExtent, withinPxRadius } from 'core/viewport/pxExtent';\nimport { PenIcon } from '../../../icons';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { anchorsToPath, pathToAnchors } from 'features/paths/anchors';\nimport { nearestPathAnchor, reverseAnchors, type PathAnchorHit } from 'features/paths/nearestAnchor';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport type { Scene } from 'core/scene/types';\nimport { defaultCommitAdapter } from 'interactions/actions/defaultCommitAdapter';\nimport { constrainTo45 } from '../../../util/constrainTo45';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * In-progress pen anchor. A click places a corner, with no handles. A drag\n * sets `outHandle` to the drag point and `inHandle` to its mirror through\n * the anchor, which shapes the segment coming into it.\n */\nexport interface PenAnchor {\n  x: number;\n  y: number;\n  outHandle?: { x: number; y: number };\n  inHandle?: { x: number; y: number };\n  /** True once Alt is held during the placement drag: from then on the\n   *  in-handle stays where it is, and an anchor dragged with Alt down from\n   *  the start gets none. */\n  altBroken?: boolean;\n}\n\n/** One in-progress subpath of the pen tool: its anchors so far, and whether\n *  the user has closed it. */\nexport interface PenSubpath {\n  anchors: PenAnchor[]; // LOCAL PenAnchor — in-progress\n  closed: boolean;\n}\n\n/**\n * Mutable scratch shared across pen-tool gestures. The hook keeps a stable\n * reference to a single instance and `initScratch` returns it on every call,\n * so click-by-click state survives gesture boundaries and the preview layer\n * can read the same object.\n *\n * ## The pen draws paths; it does not reshape them\n *\n * It draws new nodes, and extends an existing node's open subpath from one\n * of its ends (see `continuing`). Reshaping an existing path is anchor\n * editing: double-click a path to\n * enter edit mode, then use the `editAnchors` / `insertPathAnchor` /\n * `nudgeAnchors` / `deleteAnchors` / `marqueeAnchors` / `cutPathAtAnchor`\n * Actions.\n *\n * The pen used to carry a second, private implementation of all of that,\n * with its own scratch mode, hit-test override, overlay, and undo\n * plumbing. It was reachable only through a `getPathObj` option whose\n * contract required `pose.kind` to be `'polygon'` or `'rect'` — which no\n * kit-created node has, including the ones the pen itself creates. So it\n * was dead in every consumer while shadowing the live implementation, and\n * the two had drifted. Its geometry now lives in\n * `features/paths/anchorEdits.ts`, driven by those Actions.\n */\nexport interface PenScratch {\n  finishedSubpaths: PenSubpath[];\n  current: PenSubpath | null;\n  cursor: { x: number; y: number } | null;\n  draggingHandleAt: number | null;\n  closeHintActive: boolean;\n  /** Set while the pen is extending an existing node's open subpath rather\n   *  than drawing a new node. `current` then starts as that subpath (turned\n   *  around when it was picked up by its first anchor), and the commit\n   *  writes back into the node. */\n  continuing: PenContinuation | null;\n}\n\n/** Which existing subpath the pen picked up, and the node's path as it was. */\nexport interface PenContinuation {\n  id: string;\n  /** Index of the picked-up subpath within `original`. */\n  sub: number;\n  /** True when it was picked up by its first anchor, so `current` runs\n   *  backwards and is turned around again on commit. */\n  reversed: boolean;\n  /** The node's path in world coords at pick-up. */\n  original: PolygonPath;\n}\n\n/** Options for `usePenTool`: how a finished path becomes a pose, where it is\n *  inserted, and when a closed subpath commits. */\nexport interface UsePenToolOptions<TPose> {\n  /** Wrap a finished PolygonPath in the consumer's pose type. */\n  wrapPath: (path: PolygonPath, opts: { closed: boolean }) => TPose;\n  /** Insert + select adapter. */\n  adapter: {\n    addNode: (pose: TPose) => string;\n    setSelection: (ids: string[]) => void;\n    /** Build, without inserting, the node `addNode` would insert for `pose`,\n     *  so the pen can put it in a larger op batch — a new path finished on\n     *  another open path's endpoint is inserted and the other path deleted\n     *  in one undo step. Without it, that click only places an anchor. */\n    makeNode?: (pose: TPose) => { id: string };\n  };\n  /** Auto-select the new object after commit. Default `true`. */\n  autoSelect?: boolean;\n  /** When true (default), clicking the first anchor to close a subpath\n   *  commits immediately — the closed region renders with its fill right\n   *  away. When false, the closed subpath stays in scratch so the user can\n   *  start another subpath; commit then fires on Enter / tool-switch /\n   *  ⌘-click / double-click, producing a compound path. */\n  autoCommitOnClose?: boolean;\n  /** Screen-px hit radius for \"click first anchor to close\". Default `8`.\n   *  Measured as a screen-space circle, so it stays round under non-uniform\n   *  zoom; aligns with `useSelectTool.handleHitRadius`. */\n  closeHitRadius?: number;\n  /** Screen-px radius within which a placed anchor lands exactly on an\n   *  existing path's anchor. Default `8`; `0` turns it off. Takes precedence\n   *  over `snapPoint`, which applies only when no anchor is in range. */\n  anchorSnapRadius?: number;\n  /** Optional point snapper applied to every world-space coordinate the\n   *  pen records or previews — anchor positions (corner clicks, smooth-\n   *  drag base point), the rubber-band cursor, and the outgoing-handle\n   *  target. Receives raw world coords; returns snapped world coords.\n   *  Wire to `gridSnapStrategy`-style spacing via the consumer:\n   *\n   *      snapPoint: (p) => ({\n   *        x: Math.round(p.x / SPACING) * SPACING,\n   *        y: Math.round(p.y / SPACING) * SPACING,\n   *      })\n   *\n   *  Pen state (anchor handles, etc.) is computed AFTER snapping so the\n   *  visible geometry stays grid-aligned. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\nfunction freshScratch(): PenScratch {\n  return {\n    finishedSubpaths: [],\n    current: null,\n    cursor: null,\n    draggingHandleAt: null,\n    closeHintActive: false,\n    continuing: null,\n  };\n}\n\nfunction resetScratch(s: PenScratch): void {\n  s.finishedSubpaths = [];\n  s.current = null;\n  s.cursor = null;\n  s.draggingHandleAt = null;\n  s.closeHintActive = false;\n  s.continuing = null;\n}\n\n/** Total anchors across finished subpaths plus the in-progress one. */\nfunction anchorCount(s: PenScratch): number {\n  return (s.current ? s.current.anchors.length : 0)\n    + s.finishedSubpaths.reduce((n, sp) => n + sp.anchors.length, 0);\n}\n\n/** Build a PolygonPath from the pen's accumulated subpaths, by the same\n *  rule as any anchor set: segment A→B is a cubic through A's out-handle and\n *  B's in-handle when either exists, else a line. */\nfunction buildPath(\n  subpaths: PenSubpath[],\n  trailing: PenSubpath | null,\n): PolygonPath {\n  const all = [...subpaths];\n  if (trailing && trailing.anchors.length > 0) all.push(trailing);\n  return anchorsToPath(all.map((sp) => sp.anchors), all.map((sp) => sp.closed));\n}\n\n/**\n * Active-slot Tool: click + drag to build a `PolygonPath` Illustrator-style.\n *\n * State machine: Idle / Drawing / BetweenSubpaths (see design doc).\n * Click places a corner anchor; click-drag places an anchor with an\n * outgoing bezier handle; click-the-first-anchor closes the subpath; Enter\n * open-finishes; Esc discards; tool-switch commits if ≥2 anchors else\n * discards. Shift constrains the placement-drag handle to 0/45/90/135°;\n * Alt during drag breaks the handle mirror for the next segment.\n *\n * Reshaping an existing path is not this tool's job — see {@link PenScratch}.\n */\nexport function usePenTool<TPose>(\n  options: UsePenToolOptions<TPose>,\n): Tool<PenScratch> {\n  const { wrapPath, adapter, autoSelect = true, autoCommitOnClose = true, closeHitRadius = 8, anchorSnapRadius = 8, snapPoint } = options;\n\n  // Persistent scratch: single ref reused across gestures so multi-click\n  // state survives the dispatcher's per-gesture initScratch contract.\n  const scratchRef = useRef<PenScratch | null>(null);\n  if (scratchRef.current === null) scratchRef.current = freshScratch();\n\n  // Latest options stashed so handlers see fresh values without rebuilding\n  // the Tool record (which would lose scratch identity in the dispatcher).\n  const optsRef = useLatest({ wrapPath, adapter, autoSelect, autoCommitOnClose, closeHitRadius, anchorSnapRadius, snapPoint });\n\n  // Scratch is a mutable ref (so click-by-click state survives the\n  // dispatcher's per-gesture initScratch contract). Mutations alone don't\n  // trigger React re-renders, so Canvas never re-paints and the preview\n  // layer stays invisible until something else (e.g. commit) bumps host\n  // state. Force a render after every scratch mutation so the host's\n  // <Canvas layers={{...}}> literal gets a new identity and the paint\n  // useEffect fires. Pull the trigger via ref so the memoized Tool record\n  // doesn't need to rebuild.\n  const [, forceRender] = useReducer((x: number) => x + 1, 0);\n\n  // Geometry helpers shared by the actions below. They read `optsRef` so a\n  // re-render with new options is visible without rebuilding the actions\n  // (which would lose the scratch identity `penPreviewLayer` reads through\n  // `Tool.initScratch`).\n\n  /** Write the pen's subpaths back into the node it picked up: the first\n   *  replaces the subpath it continued, any later ones are appended. Skips\n   *  the write when nothing changed, so an empty pick-up leaves no undo\n   *  entry. */\n  const commitContinuation = useCallback(\n    (s: PenScratch, trailing: PenSubpath | null, edit: EditAnchorsDep | undefined): void => {\n      const cont = s.continuing!;\n      const drawn = [...s.finishedSubpaths, ...(trailing ? [trailing] : [])];\n      if (!edit || drawn.length === 0) return;\n      const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath(drawn, null));\n      if (cont.reversed) added[0] = reverseAnchors(added[0]);\n      const set = pathToAnchors(cont.original);\n      set.anchors.splice(cont.sub, 1, added[0]);\n      set.closed.splice(cont.sub, 1, addedClosed[0]);\n      set.anchors.push(...added.slice(1));\n      set.closed.push(...addedClosed.slice(1));\n      const next: PolygonPath = { ...anchorsToPath(set.anchors, set.closed), fillRule: cont.original.fillRule };\n      if (samePath(next, cont.original)) return;\n      edit.applyEdit(cont.id, next, 'Continue path');\n      if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([cont.id]);\n    },\n    [optsRef],\n  );\n\n  const commit = useCallback((s: PenScratch, deps: ActionDeps): void => {\n    const trailing = s.current && s.current.anchors.length > 0 ? s.current : null;\n    if (s.continuing) {\n      commitContinuation(s, trailing, deps.editAnchors as EditAnchorsDep | undefined);\n      resetScratch(s);\n      return;\n    }\n    if (s.finishedSubpaths.length === 0 && !trailing) return;\n    const allClosed =\n      s.finishedSubpaths.every((sp) => sp.closed) &&\n      (trailing === null || trailing.closed);\n    const path = buildPath(s.finishedSubpaths, trailing);\n    const pose = optsRef.current.wrapPath(path, { closed: allClosed });\n    const id = optsRef.current.adapter.addNode(pose);\n    if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([id]);\n    resetScratch(s);\n  }, [commitContinuation, optsRef]);\n\n  /** Whether an anchor about to land on `hit` finishes the path by joining\n   *  onto another open subpath. Its own continued subpath never counts —\n   *  reaching that one's far end is a close. Declines when the deps can't\n   *  commit the join as one op batch. */\n  const joinable = useCallback((s: PenScratch, deps: ActionDeps, hit: PathAnchorHit | null): hit is PathAnchorHit => {\n    if (!hit || hit.end === null || !s.current || s.current.anchors.length === 0) return false;\n    const cont = s.continuing;\n    if (cont && hit.id === cont.id && hit.sub === cont.sub) return false;\n    const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n    if (!scene && !deps.applyOps) return false;\n    if (!(cont ? (deps.editAnchors as EditAnchorsDep).editOps : optsRef.current.adapter.makeNode)) return false;\n    return cont?.id === hit.id || scene?.get(hit.id as never) !== undefined;\n  }, [optsRef]);\n\n  /** Finish the path onto `hit`, the endpoint its last anchor was just placed\n   *  on: the other subpath's anchors follow on from it, turned around when\n   *  `hit` is its last anchor, and its node is deleted. The path being drawn\n   *  keeps its identity — a continued node keeps its id and style, and a new\n   *  path is minted the way any pen path is. One op batch, so one undo. */\n  const commitJoin = useCallback((s: PenScratch, deps: ActionDeps, hit: PathAnchorHit): void => {\n    const edit = deps.editAnchors as EditAnchorsDep;\n    const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n    const current = s.current!;\n    const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath([...s.finishedSubpaths, current], null));\n\n    const other = edit.getEditablePath(hit.id) as PolygonPath;\n    const otherSet = pathToAnchors(other);\n    const tail = hit.end === 'last' ? reverseAnchors(otherSet.anchors[hit.sub]) : otherSet.anchors[hit.sub];\n    const joined = added[added.length - 1];\n    const joint = joined[joined.length - 1];\n    const out = current.anchors[current.anchors.length - 1].outHandle ?? tail[0].outHandle;\n    if (out) joint.outHandle = { ...out };\n    joined.push(...tail.slice(1));\n\n    const cont = s.continuing;\n    const sameNode = cont?.id === hit.id;\n    const rest = sameNode ? { anchors: [], closed: [] } : {\n      anchors: otherSet.anchors.filter((_, i) => i !== hit.sub),\n      closed: otherSet.closed.filter((_, i) => i !== hit.sub),\n    };\n    const label = 'Join paths';\n    const ops: Op[] = [];\n    let keptId: string;\n    if (cont) {\n      if (cont.reversed) added[0] = reverseAnchors(added[0]);\n      const set = pathToAnchors(cont.original);\n      set.anchors.splice(cont.sub, 1, added[0]);\n      set.closed.splice(cont.sub, 1, addedClosed[0]);\n      set.anchors.push(...added.slice(1), ...rest.anchors);\n      set.closed.push(...addedClosed.slice(1), ...rest.closed);\n      if (sameNode) {\n        set.anchors.splice(hit.sub, 1);\n        set.closed.splice(hit.sub, 1);\n      }\n      const next: PolygonPath = { ...anchorsToPath(set.anchors, set.closed), fillRule: cont.original.fillRule };\n      ops.push(...edit.editOps!(cont.id, next, label));\n      keptId = cont.id;\n    } else {\n      const path = anchorsToPath([...added, ...rest.anchors], [...addedClosed, ...rest.closed]);\n      const node = optsRef.current.adapter.makeNode!(optsRef.current.wrapPath(path, { closed: false }));\n      ops.push(createInsertOp({ node }));\n      keptId = node.id;\n    }\n    if (!sameNode) ops.push(createDeleteOp({ node: scene!.get(hit.id as never) as { id: string } }));\n\n    const applyOps = deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n    if (applyOps) applyOps(ops, label);\n    else scene!.applyBatch(ops, label, defaultCommitAdapter(scene!));\n    if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([keptId]);\n    resetScratch(s);\n  }, [optsRef]);\n\n  /** From idle, a press on an open subpath's end anchor picks that subpath\n   *  up: it becomes `current`, turned so the pressed end is last. Returns\n   *  whether it did. */\n  const pickUpEndpoint = useCallback((deps: ActionDeps, wx: number, wy: number): boolean => {\n    const scratch = scratchRef.current!;\n    if (scratch.current || scratch.finishedSubpaths.length > 0) return false;\n    const radius = optsRef.current.closeHitRadius;\n    const scale = viewScale(deps);\n    const hit = nearestPathAnchor(pathsNear(deps, wx, wy, radius), { x: wx, y: wy }, radius, scale, (h) => h.end !== null);\n    if (!hit) return false;\n    const original = (deps.editAnchors as EditAnchorsDep).getEditablePath(hit.id) as PolygonPath;\n    const picked = pathToAnchors(original).anchors[hit.sub];\n    const reversed = hit.end === 'first' && picked.length > 1;\n    scratch.current = { anchors: reversed ? reverseAnchors(picked) : picked, closed: false };\n    scratch.continuing = { id: hit.id, sub: hit.sub, reversed, original };\n    return true;\n  }, [optsRef]);\n\n  const snap = useCallback((x: number, y: number): { x: number; y: number } => {\n    const fn = optsRef.current.snapPoint;\n    return fn ? fn({ x, y }) : { x, y };\n  }, [optsRef]);\n\n  /** Where an anchor pressed at `(x, y)` lands: on an existing path's anchor\n   *  when one is within `anchorSnapRadius`, else wherever `snapPoint` puts it.\n   *  `hit` names the anchor it snapped to. */\n  const placeAt = useCallback((deps: ActionDeps, x: number, y: number): { x: number; y: number; hit: PathAnchorHit | null } => {\n    const radius = optsRef.current.anchorSnapRadius;\n    if (radius > 0) {\n      const hit = nearestPathAnchor(pathsNear(deps, x, y, radius), { x, y }, radius, viewScale(deps));\n      if (hit) return { x: hit.x, y: hit.y, hit };\n    }\n    return { ...snap(x, y), hit: null };\n  }, [snap, optsRef]);\n\n  /** Is a world point within the close-hit radius of `(ax, ay)`? Measured as a\n   *  screen-space circle, so the zone stays round under non-uniform zoom. */\n  const withinCloseRadius = useCallback(\n    (deps: ActionDeps, ax: number, ay: number, wx: number, wy: number): boolean => {\n      return withinPxRadius(ax - wx, ay - wy, optsRef.current.closeHitRadius, viewScale(deps));\n    },\n    [optsRef],\n  );\n\n  /**\n   * Actions the pen owns, registered by `useToolActions` from inside the\n   * ActionsProvider — see `ToolDef.actions`.\n   *\n   * They close over `scratchRef`, which is why the pen needs no `Selector`\n   * exposing tool scratch to the action layer: the state never leaves the\n   * hook. `useMemo([])` keeps their identity stable for the same reason\n   * `scratchRef` is a ref — the preview layer reads that one object.\n   */\n  const actions = useMemo<Action[]>(() => {\n    const s = () => scratchRef.current!;\n\n    return [\n      {\n        id: 'pen.placeAnchor',\n        label: 'Pen — place anchor',\n        eligible: { capability: 'creates-paths' },\n        requires: ['view', 'areaSelect', 'editAnchors', 'scene', 'applyOps'],\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps, params) => {\n            const p = params as { pressX?: number; pressY?: number } | undefined;\n            if (p?.pressX === undefined || p.pressY === undefined) return;\n            // The press point, not the release: a click may drift up to the\n            // drag threshold, and an anchor should land where you put the\n            // pointer down. Snapping happens here rather than at press time\n            // so the snapped value is what the geometry records.\n            if (pickUpEndpoint(deps, p.pressX, p.pressY)) {\n              forceRender();\n              return;\n            }\n            const { x: wx, y: wy, hit } = placeAt(deps, p.pressX, p.pressY);\n            const scratch = s();\n\n            // Close-on-first-anchor (>= 3 anchors). With `autoCommitOnClose`\n            // on (default) this commits right away so the closed region\n            // renders with its fill — Illustrator-style. With it off the\n            // closed subpath stays in scratch for compound-path builds and\n            // commits on Enter / tool switch.\n            if (scratch.current && scratch.current.anchors.length >= 3) {\n              const first = scratch.current.anchors[0];\n              if (withinCloseRadius(deps, first.x, first.y, wx, wy)) {\n                scratch.current.closed = true;\n                scratch.finishedSubpaths.push(scratch.current);\n                scratch.current = null;\n                scratch.closeHintActive = false;\n                if (optsRef.current.autoCommitOnClose) commit(scratch, deps);\n                forceRender();\n                return;\n              }\n            }\n\n            const join = joinable(scratch, deps, hit);\n            // Otherwise: append a corner anchor, starting a subpath if needed.\n            if (!scratch.current) scratch.current = { anchors: [], closed: false };\n            scratch.current.anchors.push({ x: wx, y: wy });\n            if (join) commitJoin(scratch, deps, hit);\n            forceRender();\n          },\n        },\n      },\n\n      {\n        id: 'pen.finishOpen',\n        label: 'Pen — finish open path',\n        eligible: { capability: 'creates-paths' },\n        requires: ['editAnchors'],\n        // Needs an actual path to commit. Declining also lets the gesture\n        // fall through: a ⌘-click with fewer than two anchors reaches the\n        // plain-click binding and places an anchor instead.\n        enabled: () => (anchorCount(s()) >= 2 ? true : ActionDisabledReason.NotApplicable),\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps, params) => {\n            const scratch = s();\n            const p = params as { viaDoubleClick?: boolean } | undefined;\n\n            // A double click arrives AFTER both of its clicks, so the second\n            // one has already appended an anchor. Undo exactly that before\n            // committing: pop it, and drop the subpath entirely if it was the\n            // only anchor in it (which happens when the FIRST click closed a\n            // subpath and the second started a fresh one). The net effect\n            // matches the pen's old private 300ms detector — one anchor\n            // placed, path finished — while using the dispatcher's single\n            // definition of a double click.\n            //\n            // No position check is needed: the anchor to drop is by\n            // construction the one the second click just appended.\n            if (p?.viaDoubleClick && scratch.current) {\n              scratch.current.anchors.pop();\n              if (scratch.current.anchors.length === 0) scratch.current = null;\n            }\n\n            commit(scratch, deps);\n            forceRender();\n          },\n        },\n      },\n\n      {\n        id: 'pen.dragHandle',\n        label: 'Pen — drag out a bezier handle',\n        eligible: { capability: 'creates-paths' },\n        requires: ['view', 'areaSelect', 'editAnchors', 'scene', 'applyOps'],\n        invoker: {\n          timing: 'ongoing' as const,\n          start: (ctx: InvocationCtx) => {\n            const scratch = s();\n            // `drag.start` is the pointerdown position — the dispatcher\n            // buffers the press and releases it at the drag threshold, so the\n            // anchor lands where the user pressed rather than where the\n            // threshold happened to be crossed.\n            const origin = ctx.drag?.start ?? ctx.world;\n            // Dragging from an open path's end picks the path up and pulls\n            // that end's own handle rather than placing a new anchor on it.\n            const pickedUp = pickUpEndpoint(ctx.deps, origin.x, origin.y);\n            // Dragging on another open path's endpoint joins onto it once\n            // the handle is set.\n            let joinHit: PathAnchorHit | null = null;\n            if (!pickedUp) {\n              const { x: ax, y: ay, hit } = placeAt(ctx.deps, origin.x, origin.y);\n              if (joinable(scratch, ctx.deps, hit)) joinHit = hit;\n              if (!scratch.current) scratch.current = { anchors: [], closed: false };\n              scratch.current.anchors.push({ x: ax, y: ay });\n            }\n            scratch.draggingHandleAt = scratch.current!.anchors.length - 1;\n            if (ctx.modifiers.alt) {\n              scratch.current!.anchors[scratch.draggingHandleAt].altBroken = true;\n            }\n            // A picked-up endpoint's in-handle belongs to the existing\n            // segment into it, which the pen does not reshape.\n            const linked = !pickedUp;\n            applyOutHandle(scratch, ctx.world, ctx.modifiers.shift, linked, optsRef.current.snapPoint);\n            forceRender();\n\n            return {\n              onMove: (moveCtx: InvocationCtx) => {\n                const sm = s();\n                if (sm.draggingHandleAt === null) return;\n                if (moveCtx.modifiers.alt && sm.current) {\n                  sm.current.anchors[sm.draggingHandleAt].altBroken = true;\n                }\n                applyOutHandle(sm, moveCtx.world, moveCtx.modifiers.shift, linked, optsRef.current.snapPoint);\n                forceRender();\n              },\n              onEnd: (endCtx: InvocationCtx, reason: 'commit' | 'cancel') => {\n                const se = s();\n                if (reason === 'cancel') {\n                  // `start` appended the anchor (or picked a path up); a\n                  // cancel (pointercancel is the reachable one — Escape and a\n                  // tool switch both reset the whole scratch first) has to\n                  // take it back out.\n                  if (pickedUp) {\n                    resetScratch(se);\n                  } else if (se.current && se.draggingHandleAt === se.current.anchors.length - 1) {\n                    se.current.anchors.pop();\n                    if (se.current.anchors.length === 0) se.current = null;\n                  }\n                  se.draggingHandleAt = null;\n                  forceRender();\n                  return;\n                }\n                if (se.draggingHandleAt !== null) {\n                  if (endCtx.modifiers.alt && se.current) {\n                    se.current.anchors[se.draggingHandleAt].altBroken = true;\n                  }\n                  applyOutHandle(se, endCtx.world, endCtx.modifiers.shift, linked, optsRef.current.snapPoint);\n                  se.draggingHandleAt = null;\n                }\n                if (joinHit && se.current) commitJoin(se, ctx.deps, joinHit);\n                forceRender();\n              },\n            };\n          },\n        },\n      },\n\n      {\n        id: 'pen.finish',\n        label: 'Pen — finish path',\n        eligible: { capability: 'creates-paths' },\n        requires: ['editAnchors'],\n        enabled: () => (anchorCount(s()) > 0 ? true : ActionDisabledReason.NotApplicable),\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps) => {\n            commit(s(), deps);\n            forceRender();\n          },\n        },\n      },\n\n      {\n        id: 'pen.cancel',\n        label: 'Pen — discard path',\n        eligible: { capability: 'creates-paths' },\n        // Declining with nothing drawn is what keeps Escape's first-match\n        // ladder intact: an empty pen passes the key to `escape`, which goes\n        // on to clear the selection / return to the default tool.\n        enabled: () => {\n          const scratch = s();\n          return scratch.current !== null || scratch.finishedSubpaths.length > 0\n            ? true\n            : ActionDisabledReason.NotApplicable;\n        },\n        invoker: {\n          timing: 'immediate' as const,\n          run: () => {\n            resetScratch(s());\n            forceRender();\n          },\n        },\n      },\n    ];\n  }, [commit, placeAt, withinCloseRadius, pickUpEndpoint, joinable, commitJoin, optsRef]);\n\n  return useMemo(() => {\n    return defineTool<PenScratch>({\n      id: 'pen',\n      capabilities: ['creates-paths'],\n      hookName: 'usePenTool',\n      // Reads the tool's own ref rather than a scratch handed in by a\n      // dispatcher — the pen owns this state and nothing else needs it.\n      cursor: () =>\n        scratchRef.current?.closeHintActive\n          ? 'pointer'\n          : cursorFor('pen', { fallback: 'crosshair' }),\n      presentation: {\n        label: 'Pen',\n        icon: createElement(PenIcon),\n        group: 'draw',\n      },\n      // Persistent-ref scratch. `penPreviewLayer` reads the in-progress path\n      // by calling `Tool.initScratch()` and getting this same object back, so\n      // the identity is load-bearing.\n      initScratch: () => scratchRef.current!,\n      actions,\n\n      onDeactivate: () => {\n        // Anything still in scratch is by definition incomplete — the user\n        // hasn't closed it (close-on-first-anchor), open-finished it\n        // (cmd-click), or pressed Enter. Switching tools mid-path should\n        // discard, not auto-commit a stub polyline that the user didn't\n        // ask for. Mirrors Escape's behavior so \"stop drawing\" is\n        // consistent across exits.\n        resetScratch(scratchRef.current!);\n        forceRender();\n      },\n\n      bindings: [\n        // Plain click places an anchor; ⌘/Ctrl-click open-finishes\n        // (Illustrator). Strict modifier matching keeps the two apart, and\n        // `mod` resolves to meta on mac / ctrl elsewhere — the tool-route\n        // grammar's modifier matcher accepted either key on either platform.\n        { spec: { kind: 'click' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.placeAnchor' },\n        { spec: { kind: 'click' as const, mods: { mod: true, shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.finishOpen' },\n        // Double-click on the last anchor also open-finishes. This used to be\n        // a private 300ms/radius check inside the click route — a fourth\n        // double-click detector in a codebase that had just collapsed three\n        // into one (audit 3.3).\n        {\n          spec: { kind: 'doubleClick' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } },\n          actionId: 'pen.finishOpen',\n          opts: { params: { viaDoubleClick: true } },\n        },\n        { spec: { kind: 'drag' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.dragHandle' },\n        { spec: { kind: 'key' as const, key: 'Enter' }, actionId: 'pen.finish' },\n        { spec: { kind: 'key' as const, key: 'Escape' }, actionId: 'pen.cancel' },\n      ],\n    });\n  }, [actions]);\n}\n\nusePenTool.prefs = {\n  name: 'Pen',\n  description: 'Pen-tool behavior.',\n  children: {\n    autoCommitOnClose: {\n      kind: 'boolean',\n      name: 'Auto-commit pen on close',\n      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).\",\n      default: true,\n    },\n  },\n} satisfies ToolPrefGroup;\n\n/** Point the anchor's outgoing handle at `target`, optionally snapped and\n *  optionally constrained to 45° steps. When `linked` and not Alt-broken,\n *  the in-handle follows as its mirror through the anchor. */\nfunction applyOutHandle<S extends PenScratch>(\n  s: S,\n  target: { x: number; y: number },\n  shift: boolean,\n  linked: boolean,\n  snap?: (p: { x: number; y: number }) => { x: number; y: number },\n): void {\n  if (s.current === null || s.draggingHandleAt === null) return;\n  const anchor = s.current.anchors[s.draggingHandleAt];\n  const to = snap ? snap(target) : target;\n  let dx = to.x - anchor.x;\n  let dy = to.y - anchor.y;\n  if (shift) {\n    const c = constrainTo45(dx, dy);\n    dx = c.dx;\n    dy = c.dy;\n  }\n  anchor.outHandle = { x: anchor.x + dx, y: anchor.y + dy };\n  if (linked && !anchor.altBroken) anchor.inHandle = { x: anchor.x - dx, y: anchor.y - dy };\n}\n\nfunction viewScale(deps: ActionDeps): { x: number; y: number } {\n  return (deps.view as ViewApi | undefined)?.get().scale ?? { x: 1, y: 1 };\n}\n\n/** Existing editable paths, world coords, with ink within `px` screen\n *  pixels of `(wx, wy)` — front-to-back, as the area query returns them.\n *  Empty when the host publishes no `areaSelect` or `editAnchors` dep. */\nfunction pathsNear(\n  deps: ActionDeps,\n  wx: number,\n  wy: number,\n  px: number,\n): Array<{ id: string; path: PolygonPath }> {\n  const area = deps.areaSelect as AreaSelectDep | undefined;\n  const edit = deps.editAnchors as EditAnchorsDep | undefined;\n  if (!area || !edit) return [];\n  const view = deps.view as ViewApi | undefined;\n  const e = pxExtent(px, viewScale(deps));\n  const ids = area.hitTestArea({ x: wx - e.x, y: wy - e.y, width: 2 * e.x, height: 2 * e.y }, view);\n  const out: Array<{ id: string; path: PolygonPath }> = [];\n  for (const id of ids) {\n    const path = edit.getEditablePath(id) as PolygonPath | null;\n    if (path?.kind === 'polygon') out.push({ id, path });\n  }\n  return out;\n}\n\nfunction samePath(a: PolygonPath, b: PolygonPath): boolean {\n  if (a.commands.length !== b.commands.length || a.coords.length !== b.coords.length) return false;\n  for (let i = 0; i < a.commands.length; i++) if (a.commands[i] !== b.commands[i]) return false;\n  for (let i = 0; i < a.coords.length; i++) if (a.coords[i] !== b.coords[i]) return false;\n  return true;\n}\n"],"mappings":"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"}

package/dist/tools/builtin/pencil/usePencilTool.js

@@ -0,0 +1,36 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/PencilIcon.js";
+import { insertBindingBehaviors as n } from "../shared/insertToolOptions.js";
+import { useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+import { cursorFor as a } from "@weasel-js/cursor";
+//#region src/tools/builtin/pencil/usePencilTool.tsx
+function o(o = {}) {
+	let { behaviors: s } = o;
+	return r(() => e({
+		id: "pencil",
+		capabilities: ["creates-paths"],
+		hookName: "usePencilTool",
+		cursor: a("pencil", { fallback: "crosshair" }),
+		presentation: {
+			label: "Pencil",
+			group: "draw",
+			icon: /* @__PURE__ */ i(t, {})
+		},
+		bindings: [{
+			spec: {
+				kind: "drag",
+				target: "empty"
+			},
+			actionId: "insert",
+			opts: {
+				params: { kind: "pencil" },
+				...n(s)
+			}
+		}]
+	}), [s]);
+}
+//#endregion
+export { o as usePencilTool };
+
+//# sourceMappingURL=usePencilTool.js.map

package/dist/tools/builtin/pencil/usePencilTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePencilTool.js","names":["PencilIcon","usePencilTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/pencil/usePencilTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { PencilIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** A single pointer sample captured during a freehand pencil stroke.\n *\n *  `pressure` / `tiltX` / `tiltY` come straight from the underlying\n *  `PointerEvent` and let downstream consumers modulate stroke width or\n *  opacity by stylus input. Mouse and ordinary touch report\n *  `pressure: 0.5` while a button is held, `0` otherwise (per the Pointer\n *  Events spec), so a consumer that wants stylus-only modulation should\n *  gate on `pointerType` from the originating event — the kit exposes\n *  `usePointerStylus()` for that.\n *\n *  The dispatcher accumulates these on the drag trail and hands the whole\n *  array to `insertAction`, which forwards it as the `pencil` insert\n *  extras' `samples`. A consumer that wants pressure-driven\n *  `Stroke.vertexWidths` reads it off the samples in its own `insert` dep\n *  (`useDepSource('insert', …)`) — see `apps/site/demos/StrokeAndFillDemo.tsx`.\n */\nexport interface PencilPoint {\n  x: number;\n  y: number;\n  /** 0..1. Absent when the originating event carried no pressure. */\n  pressure?: number;\n  /** Degrees, ±90. Zero for mouse/touch. */\n  tiltX?: number;\n  /** Degrees, ±90. Zero for mouse/touch. */\n  tiltY?: number;\n}\n\n/**\n * Freehand pencil tool. The `drag` binding routes to `insertAction`,\n * which accumulates the pointer trail and commits it as\n * `{ kind: 'pencil', samples }`. The kit's default `insert` dep runs\n * `schneiderFit` over the samples to produce a cubic-Bezier path.\n */\nexport function usePencilTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'pencil',\n        capabilities: ['creates-paths'],\n        hookName: 'usePencilTool',\n        cursor: cursorFor('pencil', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Pencil',\n          group: 'draw',\n          icon: <PencilIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag', target: 'empty' },\n            actionId: 'insert',\n            opts: { params: { kind: 'pencil' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAwCA,SAAgBC,EAAc,IAA6B,CAAC,GAAe;CACzE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,eAAe;EAC9B,UAAU;EACV,QAAQC,EAAU,UAAU,EAAE,UAAU,YAAY,CAAC;EACrD,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAa,CAAA;EACrB;EACA,UAAU,CACR;GACE,MAAM;IAAE,MAAM;IAAQ,QAAQ;GAAQ;GACtC,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,SAAS;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC5E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}

package/dist/tools/builtin/pickTopMostHit.js

@@ -0,0 +1,45 @@
+//#region src/tools/builtin/pickTopMostHit.ts
+function e(e, n) {
+	if (e.length === 0) return null;
+	if (e.length === 1) return e[0];
+	let r = e, i = n?.getParent;
+	if (typeof i == "function") {
+		let t = new Set(e), n = /* @__PURE__ */ new Set();
+		for (let r of e) {
+			let e = i(r), a = 0;
+			for (; e != null && a++ < 1e4;) t.has(e) && n.add(e), e = i(e);
+		}
+		if (n.size > 0) {
+			let t = e.filter((e) => !n.has(e));
+			if (t.length === 1) return t[0];
+			t.length > 1 && (r = t);
+		}
+	}
+	return t(r, n);
+}
+function t(e, t) {
+	let r = t?.compareZ;
+	if (typeof r == "function") {
+		let t = e[0];
+		for (let n = 1; n < e.length; n++) r(e[n], t) >= 0 && (t = e[n]);
+		return t;
+	}
+	let i = t?.getZIndex;
+	if (typeof i == "function") {
+		let t = e[0], r = n(i, t);
+		for (let a = 1; a < e.length; a++) {
+			let o = n(i, e[a]);
+			o >= r && (t = e[a], r = o);
+		}
+		return t;
+	}
+	return e[e.length - 1];
+}
+function n(e, t) {
+	let n = e(t);
+	return typeof n == "number" && Number.isFinite(n) ? n : -Infinity;
+}
+//#endregion
+export { e as pickTopMostHit };
+
+//# sourceMappingURL=pickTopMostHit.js.map