@weasel-js/core 1.6.1 → 1.7.1

package/dist/interactions/actions/defaults/align.js

@@ -0,0 +1,71 @@
+import { translatePoseViaDescriptor as e, visualBoundsViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as n } from "../poseDescriptorDep.js";
+import { scenePoseFrame as r } from "../poseFrame.js";
+import { actionReferenceSources as i } from "../spatialReference.js";
+import { alignDeltaFor as a, alignTargetBounds as o } from "../align/align.js";
+import { AlignBottomIcon as s, AlignCenterXIcon as c, AlignCenterYIcon as l, AlignLeftIcon as u, AlignRightIcon as d, AlignTopIcon as f } from "./icons/alignIcons.js";
+import { ActionDisabledReason as p } from "@weasel-js/routing";
+import { jsx as m } from "react/jsx-runtime";
+//#region src/interactions/actions/defaults/align.tsx
+var h = {
+	left: "align.left",
+	right: "align.right",
+	top: "align.top",
+	bottom: "align.bottom",
+	"center-x": "align.centerX",
+	"center-y": "align.centerY"
+}, g = {
+	left: "Align Left",
+	right: "Align Right",
+	top: "Align Top",
+	bottom: "Align Bottom",
+	"center-x": "Align Centers Horizontally",
+	"center-y": "Align Centers Vertically"
+}, _ = {
+	left: /* @__PURE__ */ m(u, {}),
+	right: /* @__PURE__ */ m(d, {}),
+	top: /* @__PURE__ */ m(f, {}),
+	bottom: /* @__PURE__ */ m(s, {}),
+	"center-x": /* @__PURE__ */ m(c, {}),
+	"center-y": /* @__PURE__ */ m(l, {})
+};
+function v(n, s, c, l, u, d, f) {
+	let p = n.get(), m = r(s, u), h = p.map((e) => m.world(e)), g = h.map((e) => t(e, l)), _ = o(g, d?.to, i(d, f, s, m, l));
+	_ !== null && s.batch("Align", () => {
+		for (let t = 0; t < p.length; t++) {
+			let { dx: n, dy: r } = a(g[t], _, c);
+			if (n === 0 && r === 0) continue;
+			let i = e(h[t], n, r, l);
+			s.setPose(p[t], m.local(p[t], i));
+		}
+	});
+}
+function y(e) {
+	return {
+		id: h[e],
+		label: g[e],
+		icon: _[e],
+		group: "align",
+		eligible: { capability: "transforms-selection" },
+		requires: [
+			"selection",
+			"scene",
+			"poseDescriptor",
+			"poseComposition",
+			"pointer"
+		],
+		invoker: {
+			timing: "immediate",
+			run: (t, r) => {
+				let i = t.selection, a = t.scene;
+				i && a && v(i, a, e, n(t.poseDescriptor), t.poseComposition, r, t.pointer);
+			}
+		},
+		enabled: (e) => ((e?.selection)?.get().length ?? 0) >= 1 || p.SelectionRequired
+	};
+}
+var b = y("left"), x = y("right"), S = y("top"), C = y("bottom"), w = y("center-x"), T = y("center-y");
+//#endregion
+export { C as alignBottomAction, w as alignCenterXAction, T as alignCenterYAction, b as alignLeftAction, x as alignRightAction, S as alignTopAction };
+
+//# sourceMappingURL=align.js.map

package/dist/interactions/actions/defaults/align.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"align.js","names":["ID_FOR","\"left\"","\"right\"","\"top\"","\"bottom\"","LABEL_FOR","ICON_FOR","AlignLeftIcon","AlignRightIcon","AlignTopIcon","AlignBottomIcon","AlignCenterXIcon","AlignCenterYIcon","alignSelection","ids","selection","frame","scenePoseFrame","scene","poseComposition","poses","id","bounds","visualBoundsViaDescriptor","p","geom","target","alignTargetBounds","params","actionReferenceSources","pointer","i","alignDeltaFor","edge","dx","dy","to","translatePoseViaDescriptor","makeAlignAction","deps","poseDescriptorOf","ActionDisabledReason","alignLeftAction","alignRightAction","alignTopAction","alignBottomAction","alignCenterXAction","alignCenterYAction"],"sources":["../../../../src/interactions/actions/defaults/align.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from '../resize/geometry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport {\n  alignDeltaFor,\n  alignTargetBounds,\n  translatePoseViaDescriptor,\n  visualBoundsViaDescriptor,\n  type AlignEdge,\n  type AlignReference,\n} from '../align/align';\nimport { actionReferenceSources } from '../spatialReference';\nimport type { PointerContextValue } from 'features/pointer/PointerContext';\nimport { scenePoseFrame } from '../poseFrame';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport {\n  AlignLeftIcon,\n  AlignRightIcon,\n  AlignTopIcon,\n  AlignBottomIcon,\n  AlignCenterXIcon,\n  AlignCenterYIcon,\n} from './icons/alignIcons';\nconst ID_FOR: Record<AlignEdge, string> = {\n  'left': 'align.left',\n  'right': 'align.right',\n  'top': 'align.top',\n  'bottom': 'align.bottom',\n  'center-x': 'align.centerX',\n  'center-y': 'align.centerY',\n};\nconst LABEL_FOR: Record<AlignEdge, string> = {\n  'left': 'Align Left',\n  'right': 'Align Right',\n  'top': 'Align Top',\n  'bottom': 'Align Bottom',\n  'center-x': 'Align Centers Horizontally',\n  'center-y': 'Align Centers Vertically',\n};\nconst ICON_FOR: Record<AlignEdge, ReactNode> = {\n  'left': <AlignLeftIcon />,\n  'right': <AlignRightIcon />,\n  'top': <AlignTopIcon />,\n  'bottom': <AlignBottomIcon />,\n  'center-x': <AlignCenterXIcon />,\n  'center-y': <AlignCenterYIcon />,\n};\n\n// ---------------------------------------------------------------------------\n// Shared helper for descriptor invokers\n// ---------------------------------------------------------------------------\n\n/**\n * Apply an align operation to the current selection via the Scene API.\n * Reads poses through the `poseDescriptor` dep; what the selection aligns to\n * comes from `params.to` (an `AlignReference`, default `'union'`).\n *\n * The edge every member lines up on is a world edge, so the bounds are read\n * and translated in world and each result is stored back in its own parent's\n * frame.\n */\nfunction alignSelection(\n  selection: SelectionApi,\n  scene: Scene<unknown, string, unknown>,\n  edge: AlignEdge,\n  geom: PoseDescriptor<unknown>,\n  poseComposition: unknown,\n  params: Record<string, unknown> | undefined,\n  pointer: PointerContextValue | undefined,\n): void {\n  const ids = selection.get();\n  const frame = scenePoseFrame(scene, poseComposition);\n  const poses = ids.map((id) => frame.world(id));\n  const bounds = poses.map((p) => visualBoundsViaDescriptor(p, geom));\n  const target = alignTargetBounds(\n    bounds,\n    params?.to as AlignReference | undefined,\n    actionReferenceSources(params, pointer, scene, frame, geom),\n  );\n  if (target === null) return;\n  scene.batch('Align', () => {\n    for (let i = 0; i < ids.length; i++) {\n      const { dx, dy } = alignDeltaFor(bounds[i], target, edge);\n      if (dx === 0 && dy === 0) continue;\n      const to = translatePoseViaDescriptor(poses[i], dx, dy, geom);\n      scene.setPose(ids[i], frame.local(ids[i], to));\n    }\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Static descriptors\n// ---------------------------------------------------------------------------\n\nfunction makeAlignAction(edge: AlignEdge): Action {\n  return {\n    id: ID_FOR[edge],\n    label: LABEL_FOR[edge],\n    icon: ICON_FOR[edge],\n    group: 'align',\n    eligible: { capability: 'transforms-selection' },\n    requires: ['selection', 'scene', 'poseDescriptor', 'poseComposition', 'pointer'],\n    // No default keybindings — six edges/centers don't fit a clean default\n    // chord set. Wire bindings explicitly via the actions registry override map.\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const selection = deps.selection as SelectionApi | undefined;\n        const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n        if (!selection || !scene) return;\n        alignSelection(\n          selection, scene, edge, poseDescriptorOf(deps.poseDescriptor), deps.poseComposition,\n          params, deps.pointer as PointerContextValue | undefined,\n        );\n      },\n    } satisfies ImmediateInvoker,\n    // One item is enough: `enabled` cannot see the binding's `to`, and every\n    // reference but `'union'` aligns a single item. Deps-aware, since a\n    // constant disabled reason greys the entry out forever (see\n    // `requiresSelection`).\n    enabled: (deps) => {\n      const selection = deps?.selection as SelectionApi | undefined;\n      const count = selection?.get().length ?? 0;\n      return count >= 1 ? true : ActionDisabledReason.SelectionRequired;\n    },\n  };\n}\n\n/** @experimental Static descriptor for align-left. */\nexport const alignLeftAction    = makeAlignAction('left');\n/** @experimental Static descriptor for align-right. */\nexport const alignRightAction   = makeAlignAction('right');\n/** @experimental Static descriptor for align-top. */\nexport const alignTopAction     = makeAlignAction('top');\n/** @experimental Static descriptor for align-bottom. */\nexport const alignBottomAction  = makeAlignAction('bottom');\n/** @experimental Static descriptor for align-center-x. */\nexport const alignCenterXAction = makeAlignAction('center-x');\n/** @experimental Static descriptor for align-center-y. */\nexport const alignCenterYAction = makeAlignAction('center-y');\n\n"],"mappings":";;;;;;;;;AA2BA,IAAMA,IAAoC;CACxCC,MAAQ;CACRC,OAAS;CACTC,KAAO;CACPC,QAAU;CACV,YAAY;CACZ,YAAY;AACd,GACMC,IAAuC;CAC3CJ,MAAQ;CACRC,OAAS;CACTC,KAAO;CACPC,QAAU;CACV,YAAY;CACZ,YAAY;AACd,GACME,IAAyC;CAC7CL,MAAQ,kBAACM,GAAD,CAAgB,CAAA;CACxBL,OAAS,kBAACM,GAAD,CAAiB,CAAA;CAC1BL,KAAO,kBAACM,GAAD,CAAe,CAAA;CACtBL,QAAU,kBAACM,GAAD,CAAkB,CAAA;CAC5B,YAAY,kBAACC,GAAD,CAAmB,CAAA;CAC/B,YAAY,kBAACC,GAAD,CAAmB,CAAA;AACjC;AAeA,SAASC,EACP,GACA,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAMC,EAAU,IAAI,GACpBC,IAAQC,EAAeC,GAAOC,CAAe,GAC7CC,IAAQN,EAAI,KAAK,MAAOE,EAAM,MAAMK,CAAE,CAAC,GACvCC,IAASF,EAAM,KAAK,MAAMG,EAA0BC,GAAGC,CAAI,CAAC,GAC5DC,IAASC,EACbL,GACAM,GAAQ,IACRC,EAAuBD,GAAQE,GAASZ,GAAOF,GAAOS,CAAI,CAC5D;CACA,AAAIC,MAAW,QACfR,EAAM,MAAM,eAAe;EACzB,KAAK,IAAIa,IAAI,GAAGA,IAAIjB,EAAI,QAAQ,KAAK;GACnC,IAAM,EAAE,OAAI,UAAOkB,EAAcV,EAAOS,IAAIL,GAAQO,CAAI;GACxD,IAAIC,MAAO,KAAKC,MAAO,GAAG;GAC1B,IAAMC,IAAKC,EAA2BjB,EAAMW,IAAIG,GAAIC,GAAIV,CAAI;GAC5D,EAAM,QAAQX,EAAIiB,IAAIf,EAAM,MAAMF,EAAIiB,IAAIK,CAAE,CAAC;EAC/C;CACF,CAAC;AACH;AAMA,SAASE,EAAgB,GAAyB;CAChD,OAAO;EACL,IAAItC,EAAOiC;EACX,OAAO5B,EAAU4B;EACjB,MAAM3B,EAAS2B;EACf,OAAO;EACP,UAAU,EAAE,YAAY,uBAAuB;EAC/C,UAAU;GAAC;GAAa;GAAS;GAAkB;GAAmB;EAAS;EAG/E,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMlB,IAAYwB,EAAK,WACjBrB,IAAQqB,EAAK;IACnB,AAAKxB,KAAcG,KACnBL,EACEE,GAAWG,GAAOe,GAAMO,EAAiBD,EAAK,cAAc,GAAGA,EAAK,iBACpEX,GAAQW,EAAK,OACf;GACF;EACF;EAKA,UAAU,QACUA,GAAM,UAAA,EACC,IAAI,CAAC,CAAC,UAAU,MACzB,KAAWE,EAAqB;CAEpD;AACF;AAGA,IAAaC,IAAqBJ,EAAgB,MAAM,GAE3CK,IAAqBL,EAAgB,OAAO,GAE5CM,IAAqBN,EAAgB,KAAK,GAE1CO,IAAqBP,EAAgB,QAAQ,GAE7CQ,IAAqBR,EAAgB,UAAU,GAE/CS,IAAqBT,EAAgB,UAAU"}

package/dist/interactions/actions/defaults/anchorEditing.js

@@ -0,0 +1,235 @@
+import { editingLayer as e, inPlane as t } from "../planeInput.js";
+import { pathToAnchors as n } from "../../../features/paths/anchors.js";
+import { anchorsInRect as r, deleteAnchorsAt as i, editAnchorSet as a, openSubpathAt as o, translateAnchorBy as s } from "../../../features/paths/anchorEdits.js";
+import { selectionAfterAnchorPress as c } from "./editAnchors.js";
+import { ActionDisabledReason as l } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/anchorEditing.ts
+var u = 1, d = 10, f = 10;
+function p(e) {
+	let t = e?.editAnchors;
+	return !t || !t.editingId ? null : t;
+}
+function m(e) {
+	let t = e.getEditablePath(e.editingId);
+	return !t || t.kind !== "polygon" ? null : t;
+}
+function h(e, t, n) {
+	let r = m(e);
+	if (!r) return !1;
+	let i = a(r, n);
+	return i ? (e.applyEdit(e.editingId, i, t), !0) : !1;
+}
+function g(e) {
+	let t = p(e);
+	return !t || t.selectedAnchors.size === 0 ? l.SelectionRequired : !0;
+}
+var _ = t({
+	id: "selectAnchor",
+	label: "Select anchor",
+	defaultBinding: [{
+		spec: {
+			kind: "click",
+			mods: {}
+		},
+		opts: { params: { additive: !1 } }
+	}, {
+		spec: {
+			kind: "click",
+			mods: { shift: !0 }
+		},
+		opts: { params: { additive: !0 } }
+	}],
+	eligible: { capability: "edits-anchors" },
+	requires: ["editAnchors"],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let n = p(e);
+			if (!n) return;
+			let r = t?.worldX, i = t?.worldY;
+			if (typeof r != "number" || typeof i != "number") return;
+			let a = m(n);
+			if (!a) return;
+			let o = O(a, r, i, f), s = t?.additive === !0;
+			if (o === -1) {
+				s || n.setSelectedAnchors([]);
+				return;
+			}
+			n.setSelectedAnchors(c(n.selectedAnchors, o, s));
+		}
+	},
+	enabled: (e) => p(e) ? !0 : l.SelectionRequired
+}, e), v = {
+	up: "ArrowUp",
+	down: "ArrowDown",
+	left: "ArrowLeft",
+	right: "ArrowRight"
+}, y = {
+	up: "Up",
+	down: "Down",
+	left: "Left",
+	right: "Right"
+};
+function b(e, t) {
+	switch (e) {
+		case "up": return {
+			dx: 0,
+			dy: -t
+		};
+		case "down": return {
+			dx: 0,
+			dy: t
+		};
+		case "left": return {
+			dx: -t,
+			dy: 0
+		};
+		case "right": return {
+			dx: t,
+			dy: 0
+		};
+	}
+}
+function x(e) {
+	return {
+		id: `nudgeAnchors.${e}`,
+		label: `Nudge Anchors ${y[e]}`,
+		group: "nudgeAnchors",
+		defaultBinding: [{
+			spec: {
+				kind: "key",
+				key: v[e]
+			},
+			opts: { params: { magnitude: "small" } }
+		}, {
+			spec: {
+				kind: "key",
+				key: v[e],
+				mods: { shift: !0 }
+			},
+			opts: { params: { magnitude: "big" } }
+		}],
+		eligible: { capability: "edits-anchors" },
+		requires: ["editAnchors"],
+		invoker: {
+			timing: "immediate",
+			run: (t, n) => {
+				let r = p(t);
+				if (!r || r.selectedAnchors.size === 0) return;
+				let { dx: i, dy: a } = b(e, n?.magnitude === "big" ? d : u), o = [...r.selectedAnchors];
+				h(r, "Nudge anchor", (e) => {
+					let t = !1;
+					for (let n of o) t = s(e, n, i, a) || t;
+					return t;
+				});
+			}
+		},
+		enabled: g
+	};
+}
+var S = x("up"), C = x("down"), w = x("left"), T = x("right"), E = {
+	id: "deleteAnchors",
+	label: "Delete Anchors",
+	defaultBinding: {
+		kind: "key",
+		key: ["Delete", "Backspace"],
+		phase: [{
+			channel: "*",
+			phase: "initial"
+		}]
+	},
+	eligible: { capability: "edits-anchors" },
+	requires: ["editAnchors"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let t = p(e);
+			if (!t || t.selectedAnchors.size === 0) return;
+			let n = [...t.selectedAnchors];
+			h(t, "Delete anchor", (e) => i(e, n)) && t.setSelectedAnchors([]);
+		}
+	},
+	enabled: g
+}, D = t({
+	id: "cutPathAtAnchor",
+	label: "Cut path at anchor",
+	defaultBinding: {
+		kind: "click",
+		mods: {
+			alt: !0,
+			shift: !0
+		}
+	},
+	eligible: { capability: "edits-anchors" },
+	requires: ["editAnchors"],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let n = p(e);
+			if (!n) return;
+			let r = t?.worldX, i = t?.worldY;
+			if (typeof r != "number" || typeof i != "number") return;
+			let a = m(n);
+			if (!a) return;
+			let s = O(a, r, i, f);
+			s !== -1 && h(n, "Cut path", (e) => o(e, s)) && n.setSelectedAnchors([]);
+		}
+	},
+	enabled: (e) => p(e) ? !0 : l.SelectionRequired
+}, e);
+function O(e, t, r, i) {
+	let a = -1, o = i * i, s = 0;
+	for (let i of n(e).anchors) for (let e of i) {
+		let n = e.x - t, i = e.y - r, c = n * n + i * i;
+		c <= o && (a === -1 || c < o) && (o = c, a = s), s++;
+	}
+	return a;
+}
+var k = t({
+	id: "marqueeAnchors",
+	label: "Marquee-select anchors",
+	defaultBinding: {
+		kind: "drag",
+		target: "empty"
+	},
+	eligible: { capability: "edits-anchors" },
+	requires: ["editAnchors"],
+	invoker: {
+		timing: "ongoing",
+		start(e) {
+			let t = p(e.deps);
+			if (!t) return {};
+			let n = m(t);
+			if (!n) return {};
+			let r = e.modifiers.shift, i = new Set(t.selectedAnchors), a = {
+				x: e.world.x,
+				y: e.world.y
+			}, o = (e, t) => ({
+				x: Math.min(a.x, e),
+				y: Math.min(a.y, t),
+				width: Math.abs(e - a.x),
+				height: Math.abs(t - a.y)
+			});
+			return {
+				kind: "marquee-anchors",
+				onMove(e) {
+					let a = o(e.world.x, e.world.y);
+					t.setMarquee(a);
+					let s = A(n, a);
+					t.setSelectedAnchors(r ? /* @__PURE__ */ new Set([...i, ...s]) : s);
+				},
+				onEnd(e, n) {
+					t.setMarquee(null), n === "cancel" && t.setSelectedAnchors(i);
+				}
+			};
+		}
+	},
+	enabled: () => !0
+}, e);
+function A(e, t) {
+	return r(n(e), t);
+}
+//#endregion
+export { D as cutPathAtAnchorAction, E as deleteAnchorsAction, k as marqueeAnchorsAction, C as nudgeAnchorsDownAction, w as nudgeAnchorsLeftAction, T as nudgeAnchorsRightAction, S as nudgeAnchorsUpAction, _ as selectAnchorAction };
+
+//# sourceMappingURL=anchorEditing.js.map

package/dist/interactions/actions/defaults/anchorEditing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchorEditing.js","names":["SMALL_STEP","BIG_STEP","ANCHOR_CLICK_SLOP","depOf","dep","deps","worldPathOf","p","commitAnchorEdit","worldPath","next","editAnchorSet","edit","label","requiresAnchorSelection","ActionDisabledReason","selectAnchorAction","inPlane","wx","params","wy","hit","nearestAnchorIndex","additive","selectionAfterAnchorPress","editingLayer","KEY_FOR","LABEL_FOR","delta","dir","step","makeNudgeAnchorsAction","selected","any","flat","translateAnchorBy","set","dx","dy","nudgeAnchorsUpAction","nudgeAnchorsDownAction","nudgeAnchorsLeftAction","nudgeAnchorsRightAction","deleteAnchorsAction","doomed","deleteAnchorsAt","cutPathAtAnchorAction","nearest","openSubpathAt","best","bestD2","slop","sub","pathToAnchors","path","a","d2","marqueeAnchorsAction","ctx","base","start","rectFrom","cx","cy","rect","moveCtx","hits","anchorsOfPathInRect","reason","anchorsInRect"],"sources":["../../../../src/interactions/actions/defaults/anchorEditing.ts"],"sourcesContent":["/**\n * Anchor-editing Actions beyond the drag itself — the keyboard and\n * marquee half of path editing.\n *\n * These were previously only reachable through the pen tool's private\n * edit mode, which no consumer could actually enter (its `getPathObj`\n * hook needed a `pose.kind` that no kit-created node has). Porting them\n * onto the Action layer puts them behind the same `editAnchors` dep,\n * `edits-anchors` capability, and undo path as `editAnchorsAction`.\n *\n * ## Why these don't collide with their node-level counterparts\n *\n * Each has a node-level twin bound to the same gesture: `deleteAction`\n * (Delete/Backspace), `nudge.*` (arrows), `areaSelectAction` (drag on\n * empty). Two mechanisms keep them apart, and both are needed:\n *\n *   - **Capability eligibility**, when a mode registry is wired. The\n *     node-level twins gate on `edits-page` / `transforms-selection` /\n *     `creates-selection`, none of which `path-edit` mode allows, so the\n *     dispatcher filters them out before matching.\n *   - **`enabled` fall-through**, for the many consumers with no mode\n *     registry at all. There the eligibility filter is skipped entirely,\n *     so these actions report themselves disabled unless a path is\n *     actually being edited with anchors selected, and the dispatcher\n *     moves on to the node-level twin.\n *\n * Relying on eligibility alone would break every non-modal consumer;\n * relying on `enabled` alone would let a node-level action fire inside\n * path-edit mode. See `anchorEditing.test.ts`.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ActionDeps } from '@weasel-js/routing';\nimport type { ImmediateInvoker, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\nimport {\n  anchorsInRect,\n  deleteAnchorsAt,\n  editAnchorSet,\n  openSubpathAt,\n  translateAnchorBy,\n  type AnchorSet,\n} from 'features/paths/anchorEdits';\nimport { pathToAnchors } from 'features/paths/anchors';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { selectionAfterAnchorPress } from './editAnchors';\nimport { inPlane, editingLayer } from '../planeInput';\n\n// ---------------------------------------------------------------------------\n// Shared plumbing\n// ---------------------------------------------------------------------------\n\n/** Nudge step sizes — mirror `nudge.ts` so anchors and nodes move alike. */\nconst SMALL_STEP = 1;\nconst BIG_STEP = 10;\n\n/** World-unit radius for \"this click landed on an anchor\". Matches the\n *  affordance hit radius closely enough that anything the user can see as\n *  an anchor marker is cuttable. */\nconst ANCHOR_CLICK_SLOP = 10;\n\nfunction depOf(deps: ActionDeps | undefined): EditAnchorsDep | null {\n  const dep = deps?.editAnchors as EditAnchorsDep | undefined;\n  if (!dep || !dep.editingId) return null;\n  return dep;\n}\n\n/** The edited node's world-space polygon, or null when unavailable. */\nfunction worldPathOf(dep: EditAnchorsDep): PolygonPath | null {\n  const p = dep.getEditablePath(dep.editingId) as PolygonPath | undefined;\n  if (!p || p.kind !== 'polygon') return null;\n  return p;\n}\n\n/**\n * Decode → mutate → encode → commit, in one history entry. Returns false\n * when the edit changed nothing, so callers can skip the commit rather\n * than push an empty undo step.\n */\nfunction commitAnchorEdit(\n  dep: EditAnchorsDep,\n  label: string,\n  edit: (set: Parameters<Parameters<typeof editAnchorSet>[1]>[0]) => boolean | void,\n): boolean {\n  const worldPath = worldPathOf(dep);\n  if (!worldPath) return false;\n  const next = editAnchorSet(worldPath, edit);\n  if (!next) return false;\n  dep.applyEdit(dep.editingId, next, label);\n  return true;\n}\n\n/** Enabled only while a path is in edit mode with anchors selected. */\nfunction requiresAnchorSelection(deps?: ActionDeps): true | ActionDisabledReason {\n  const dep = depOf(deps);\n  if (!dep || dep.selectedAnchors.size === 0) return ActionDisabledReason.SelectionRequired;\n  return true;\n}\n\n// ---------------------------------------------------------------------------\n// selectAnchor\n// ---------------------------------------------------------------------------\n\n/**\n * Click an anchor to select it; Shift-click to toggle it in or out of the\n * selection. Clicking away from every anchor clears the anchor selection.\n *\n * ## Why this is a click action and not part of the drag\n *\n * The obvious home for \"pressing an anchor selects it\" is\n * `editAnchorsAction.start`, since that's the handler that receives the\n * anchor affordance. It can't live there: the dispatcher only dispatches\n * a drag binding once the pointer crosses the drag threshold, so a press\n * that never moves never reaches `start` at all. Verified in the running\n * app — down/up on an anchor logs a bare `click`, and down/move-3px/up\n * logs the same; only a real drag logs `pointerdown → editAnchors`.\n *\n * Clicks, in turn, carry no affordance (the dispatcher attaches those to\n * `pointerdown` only), so this resolves the anchor from the click's world\n * coords — the same thing `insertPathAnchorAction` does for segments.\n * `editAnchorsAction` still syncs the selection when a drag begins on an\n * unselected anchor, so drag-without-clicking-first behaves too.\n *\n * **Non-modal caveat:** `useSelectTool` binds `clearSelection` to\n * `{ click, target: 'empty', mods: {} }` at active scope, which outranks\n * this ambient binding. In path-edit mode that action is filtered out by\n * capability, so anchor clicks win. In a consumer with no mode registry\n * there's no filtering, so clicking an anchor that happens to sit over\n * empty canvas clears the node selection instead of selecting the anchor.\n * Anchors over the path body are unaffected.\n */\nexport const selectAnchorAction: Action & { requires: string[] } = inPlane({\n  id: 'selectAnchor',\n  label: 'Select anchor',\n  defaultBinding: [\n    { spec: { kind: 'click', mods: {} },              opts: { params: { additive: false } } },\n    { spec: { kind: 'click', mods: { shift: true } }, opts: { params: { additive: true } } },\n  ],\n  eligible: { capability: 'edits-anchors' },\n  requires: ['editAnchors'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const dep = depOf(deps);\n      if (!dep) return;\n      const wx = params?.worldX as number | undefined;\n      const wy = params?.worldY as number | undefined;\n      if (typeof wx !== 'number' || typeof wy !== 'number') return;\n      const worldPath = worldPathOf(dep);\n      if (!worldPath) return;\n\n      const hit = nearestAnchorIndex(worldPath, wx, wy, ANCHOR_CLICK_SLOP);\n      const additive = params?.additive === true;\n      if (hit === -1) {\n        // Missed every anchor. A bare click clears; a shift-click leaves\n        // the selection alone so a stray miss mid-multi-select doesn't\n        // undo the work.\n        if (!additive) dep.setSelectedAnchors([]);\n        return;\n      }\n      dep.setSelectedAnchors(selectionAfterAnchorPress(dep.selectedAnchors, hit, additive));\n    },\n  } as ImmediateInvoker,\n  enabled: (deps) => (depOf(deps) ? true : ActionDisabledReason.SelectionRequired),\n}, editingLayer);\n\n// ---------------------------------------------------------------------------\n// nudgeAnchors\n// ---------------------------------------------------------------------------\n\ntype Direction = 'up' | 'down' | 'left' | 'right';\nconst KEY_FOR: Record<Direction, string> = {\n  up: 'ArrowUp', down: 'ArrowDown', left: 'ArrowLeft', right: 'ArrowRight',\n};\nconst LABEL_FOR: Record<Direction, string> = {\n  up: 'Up', down: 'Down', left: 'Left', right: 'Right',\n};\nfunction delta(dir: Direction, step: number): { dx: number; dy: number } {\n  switch (dir) {\n    case 'up':    return { dx: 0,     dy: -step };\n    case 'down':  return { dx: 0,     dy:  step };\n    case 'left':  return { dx: -step, dy: 0     };\n    case 'right': return { dx:  step, dy: 0     };\n  }\n}\n\n/**\n * Move the selected anchors by one step. Shift multiplies the step, same\n * as node nudging.\n *\n * Every keystroke is its own history entry, matching node nudge — hold an\n * arrow down and undo walks back one step at a time rather than\n * collapsing the run.\n */\nfunction makeNudgeAnchorsAction(dir: Direction): Action & { requires: string[] } {\n  return {\n    id: `nudgeAnchors.${dir}`,\n    label: `Nudge Anchors ${LABEL_FOR[dir]}`,\n    group: 'nudgeAnchors',\n    defaultBinding: [\n      { spec: { kind: 'key', key: KEY_FOR[dir] },                        opts: { params: { magnitude: 'small' } } },\n      { spec: { kind: 'key', key: KEY_FOR[dir], mods: { shift: true } }, opts: { params: { magnitude: 'big' } } },\n    ],\n    eligible: { capability: 'edits-anchors' },\n    requires: ['editAnchors'],\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const dep = depOf(deps);\n        if (!dep || dep.selectedAnchors.size === 0) return;\n        const step = params?.magnitude === 'big' ? BIG_STEP : SMALL_STEP;\n        const { dx, dy } = delta(dir, step);\n        const selected = [...dep.selectedAnchors];\n        commitAnchorEdit(dep, 'Nudge anchor', (set) => {\n          let any = false;\n          for (const flat of selected) any = translateAnchorBy(set, flat, dx, dy) || any;\n          return any;\n        });\n      },\n    } as ImmediateInvoker,\n    enabled: requiresAnchorSelection,\n  };\n}\n\nexport const nudgeAnchorsUpAction    = makeNudgeAnchorsAction('up');\nexport const nudgeAnchorsDownAction  = makeNudgeAnchorsAction('down');\nexport const nudgeAnchorsLeftAction  = makeNudgeAnchorsAction('left');\nexport const nudgeAnchorsRightAction = makeNudgeAnchorsAction('right');\n\n// ---------------------------------------------------------------------------\n// deleteAnchors\n// ---------------------------------------------------------------------------\n\n/**\n * Delete the selected anchors, refitting the surrounding curve through\n * each gap so the path keeps its shape.\n *\n * Deleting renumbers every anchor after the lowest deleted index, so the\n * selection is cleared rather than left pointing at whatever slid into\n * those slots.\n */\nexport const deleteAnchorsAction: Action & { requires: string[] } = {\n  id: 'deleteAnchors',\n  label: 'Delete Anchors',\n  defaultBinding: {\n    kind: 'key',\n    key: ['Delete', 'Backspace'],\n    phase: [{ channel: '*', phase: 'initial' }],\n  },\n  eligible: { capability: 'edits-anchors' },\n  requires: ['editAnchors'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const dep = depOf(deps);\n      if (!dep || dep.selectedAnchors.size === 0) return;\n      const doomed = [...dep.selectedAnchors];\n      const changed = commitAnchorEdit(dep, 'Delete anchor', (set) =>\n        deleteAnchorsAt(set, doomed),\n      );\n      if (changed) dep.setSelectedAnchors([]);\n    },\n  } as ImmediateInvoker,\n  enabled: requiresAnchorSelection,\n};\n\n// ---------------------------------------------------------------------------\n// cutPathAtAnchor (scissors)\n// ---------------------------------------------------------------------------\n\n/**\n * Open a closed subpath at the alt+shift-clicked anchor — the scissors\n * operation the pen tool used to own.\n *\n * Bound to Alt+Shift+click rather than plain Alt+click so it doesn't\n * collide with `insertPathAnchorAction`, which is already Alt+click on\n * the same path. Both are \"alt-click surgery on the edited path\"; the\n * extra modifier picks which one, instead of the two actions racing on an\n * identical binding where only one could ever win.\n *\n * No-ops on an open subpath: there's nothing to cut.\n */\nexport const cutPathAtAnchorAction: Action & { requires: string[] } = inPlane({\n  id: 'cutPathAtAnchor',\n  label: 'Cut path at anchor',\n  defaultBinding: { kind: 'click', mods: { alt: true, shift: true } },\n  eligible: { capability: 'edits-anchors' },\n  requires: ['editAnchors'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const dep = depOf(deps);\n      if (!dep) return;\n      const wx = params?.worldX as number | undefined;\n      const wy = params?.worldY as number | undefined;\n      if (typeof wx !== 'number' || typeof wy !== 'number') return;\n      const worldPath = worldPathOf(dep);\n      if (!worldPath) return;\n\n      // Find the anchor under the click. Clicks carry no affordance (only\n      // pointerdown does), so this resolves the hit itself — the same\n      // approach insertPathAnchorAction takes for segments.\n      const nearest = nearestAnchorIndex(worldPath, wx, wy, ANCHOR_CLICK_SLOP);\n      if (nearest === -1) return;\n\n      const changed = commitAnchorEdit(dep, 'Cut path', (set) => openSubpathAt(set, nearest));\n      // Cutting rotates the subpath's anchor order, so held indices are stale.\n      if (changed) dep.setSelectedAnchors([]);\n    },\n  } as ImmediateInvoker,\n  enabled: (deps) => (depOf(deps) ? true : ActionDisabledReason.SelectionRequired),\n}, editingLayer);\n\n/** Flat index of the anchor nearest `(wx, wy)` within `slop`, else -1. */\nfunction nearestAnchorIndex(\n  path: PolygonPath,\n  wx: number,\n  wy: number,\n  slop: number,\n): number {\n  let best = -1;\n  let bestD2 = slop * slop;\n  let flat = 0;\n  for (const sub of (pathToAnchors(path) as AnchorSet).anchors) {\n    for (const a of sub) {\n      const dx = a.x - wx;\n      const dy = a.y - wy;\n      const d2 = dx * dx + dy * dy;\n      // `<=` so an exact-slop hit counts; ties go to the earlier anchor.\n      if (d2 <= bestD2 && (best === -1 || d2 < bestD2)) {\n        bestD2 = d2;\n        best = flat;\n      }\n      flat++;\n    }\n  }\n  return best;\n}\n\n// ---------------------------------------------------------------------------\n// marqueeAnchors\n// ---------------------------------------------------------------------------\n\n/**\n * Rubber-band select anchors by dragging on empty canvas while a path is\n * in edit mode.\n *\n * Shift adds to the existing anchor selection instead of replacing it.\n * The in-flight rect goes on the `editAnchors` dep so the path-editing\n * overlay can draw it — same \"ongoing action owns the state, chrome\n * draws it\" split the move ghosts and the node marquee use.\n */\nexport const marqueeAnchorsAction: Action & { requires: string[] } = inPlane({\n  id: 'marqueeAnchors',\n  label: 'Marquee-select anchors',\n  defaultBinding: { kind: 'drag', target: 'empty' },\n  eligible: { capability: 'edits-anchors' },\n  requires: ['editAnchors'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx): OngoingHandle {\n      const dep = depOf(ctx.deps);\n      // Not editing → decline so the dispatcher falls through to the\n      // node-level areaSelect. This is what keeps non-modal consumers\n      // (no eligibility filtering) behaving normally.\n      if (!dep) return {};\n      const worldPath = worldPathOf(dep);\n      if (!worldPath) return {};\n\n      const additive = ctx.modifiers.shift;\n      const base = new Set(dep.selectedAnchors);\n      const start = { x: ctx.world.x, y: ctx.world.y };\n\n      const rectFrom = (cx: number, cy: number) => ({\n        x: Math.min(start.x, cx),\n        y: Math.min(start.y, cy),\n        width: Math.abs(cx - start.x),\n        height: Math.abs(cy - start.y),\n      });\n\n      return {\n        kind: 'marquee-anchors',\n        onMove(moveCtx: InvocationCtx): void {\n          const rect = rectFrom(moveCtx.world.x, moveCtx.world.y);\n          dep.setMarquee(rect);\n          // Live selection preview: the user sees anchors light up as the\n          // band sweeps them, rather than only on release.\n          const hits = anchorsOfPathInRect(worldPath, rect);\n          dep.setSelectedAnchors(additive ? new Set([...base, ...hits]) : hits);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          dep.setMarquee(null);\n          if (reason === 'cancel') dep.setSelectedAnchors(base);\n        },\n      };\n    },\n  },\n  enabled: () => true,\n}, editingLayer);\n\n// ---------------------------------------------------------------------------\n// Local geometry helper\n// ---------------------------------------------------------------------------\n\n/** Flat indices of `path`'s anchors inside `rect`. */\nfunction anchorsOfPathInRect(\n  path: PolygonPath,\n  rect: { x: number; y: number; width: number; height: number },\n): number[] {\n  return anchorsInRect(pathToAnchors(path) as AnchorSet, rect);\n}\n"],"mappings":"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"}

package/dist/interactions/actions/defaults/areaSelect.js

@@ -0,0 +1,75 @@
+//#region src/interactions/actions/defaults/areaSelect.ts
+var e = {
+	id: "areaSelect",
+	label: "Area Select",
+	activeCursor: "crosshair",
+	eligible: { capability: "creates-selection" },
+	requires: [
+		"areaSelect",
+		"editAnchors",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(e, t) {
+			let n = e.deps.areaSelect;
+			if (!n) return {};
+			let r = e.drag?.affordance?.kind;
+			if (typeof r == "string" && /^(anchor|controlIn|controlOut):/.test(r) || e.deps.editAnchors?.editingId) return {};
+			let i = {
+				dep: n,
+				view: e.deps.view,
+				startX: e.world.x,
+				startY: e.world.y,
+				shiftHeld: e.modifiers.shift,
+				currentX: e.world.x,
+				currentY: e.world.y,
+				open: !0
+			};
+			return {
+				kind: "marquee",
+				onMove(e) {
+					i.currentX = e.world.x, i.currentY = e.world.y;
+				},
+				overlay() {
+					return i.open ? {
+						kind: "marquee",
+						start: {
+							x: i.startX,
+							y: i.startY
+						},
+						current: {
+							x: i.currentX,
+							y: i.currentY
+						},
+						shiftHeld: i.shiftHeld
+					} : null;
+				},
+				onEnd(e, t) {
+					if (i.open = !1, t === "cancel") return;
+					let { dep: n, view: r, startX: a, startY: o, currentX: s, currentY: c, shiftHeld: l } = i, u = Math.min(a, s), d = Math.min(o, c), f = Math.abs(s - a), p = Math.abs(c - o);
+					if (f === 0 || p === 0) {
+						l || n.setSelection([]);
+						return;
+					}
+					let m = n.hitTestArea({
+						x: u,
+						y: d,
+						width: f,
+						height: p
+					}, r);
+					if (l) {
+						let e = [...n.getSelection()];
+						for (let t of m) e.includes(t) || e.push(t);
+						n.setSelection(e);
+					} else n.setSelection(m);
+				}
+			};
+		}
+	},
+	enabled: () => !0
+};
+//#endregion
+export { e as areaSelectAction };
+
+//# sourceMappingURL=areaSelect.js.map

package/dist/interactions/actions/defaults/areaSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"areaSelect.js","names":["areaSelectAction","dep","ctx","affordanceKind","scratch","moveCtx","reason","d","x","startX","currentX","y","startY","currentY","width","height","shiftHeld","hits","view","merged","id"],"sources":["../../../../src/interactions/actions/defaults/areaSelect.ts"],"sourcesContent":["/**\n * `areaSelectAction` — ongoing Action descriptor for marquee area selection.\n *\n * ## Status: REAL\n *\n * Implements the marquee selection logic from `useAreaSelect`:\n *   - `start`: records the drag start world point and shift state.\n *   - `onMove`: tracks the current drag corner (no scene writes).\n *   - `onEnd('commit')`: derives the marquee bounds from start + current;\n *     calls `deps.areaSelect.hitTestArea(bounds)` to find overlapping nodes;\n *     calls `deps.areaSelect.setSelection(ids)` to update selection (extending\n *     with shift held). This is a **transient** write (no undo entry) matching\n *     `useAreaSelect`'s `defaultTransient: true` convention from\n *     `selectFromMarquee`.\n *   - `onEnd('cancel')`: no-op.\n *\n * ## Dependencies\n *\n * Requires `areaSelect` dep from DepSchema:\n *   `{ hitTestArea(bounds): NodeId[], getSelection(): NodeId[], setSelection(ids): void }`\n *\n * `<SceneCanvas>` / `<StandardActionsRegistrar>` should source this dep by\n * iterating scene nodes and checking AABB overlap. The dep is intentionally\n * simple — consumers override it for custom hit-testing (contain-mode,\n * layer-aware filtering, etc.).\n *\n * ## What this does NOT wire (vs `useAreaSelect`)\n *\n * - Live marquee overlay rendering — deferred to Phase 7 overlay surface.\n * - `AreaSelectBehavior` pipeline — omitted; only the default replace/extend\n *   semantics are implemented.\n * - Debug sink recording — not available in the descriptor model.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, OngoingOverlay } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport type { AreaSelectDep, ViewApi } from '../depSchema';\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface AreaSelectScratch {\n  dep: AreaSelectDep;\n  /** The view the marquee started in: what it does not paint is not taken. */\n  view: ViewApi | undefined;\n  startX: number;\n  startY: number;\n  shiftHeld: boolean;\n  currentX: number;\n  currentY: number;\n  /** Cleared once `onEnd` runs so subsequent `overlay()` calls report no\n   *  in-flight marquee (the dispatcher releases the handle after onEnd so\n   *  this is belt-and-suspenders for any consumer that retains a handle). */\n  open: boolean;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `areaSelect` Action.\n *\n * Requires dep-schema entry: `areaSelect`.\n *\n * The invoker implements replace/extend marquee selection via the `areaSelect`\n * dep. Hit-testing and selection writes are delegated to the dep; the invoker\n * contains only the bounds-derivation and shift-extend logic.\n *\n * @see useAreaSelect — the React hook this descriptor mirrors for the default case.\n */\nexport const areaSelectAction: Action & { requires: string[] } = {\n  id: 'areaSelect',\n  label: 'Area Select',\n  // Crosshair while the marquee is being pulled — the select tool used to\n  // read this off its own gesture scratch.\n  activeCursor: 'crosshair',\n  eligible: { capability: 'creates-selection' },\n  requires: ['areaSelect', 'editAnchors', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const dep = ctx.deps.areaSelect as AreaSelectDep | undefined;\n      if (!dep) return {};\n\n      // Decline on anchor / control-handle affordances: the select tool's\n      // active-scope binding for this action is `{ kind: 'drag', target: 'empty' }`,\n      // which matches whenever `bodyTarget === 'empty'` — including drags\n      // where an anchor was hit on top of empty body. Without this opt-out\n      // areaSelect would beat editAnchors via scope priority. The\n      // dispatcher's empty-handle fallthrough then forwards the gesture.\n      const affordanceKind = ctx.drag?.affordance?.kind;\n      if (\n        typeof affordanceKind === 'string'\n        && /^(anchor|controlIn|controlOut):/.test(affordanceKind)\n      ) {\n        return {};\n      }\n\n      // Decline for the same reason while a path is in anchor-edit mode:\n      // an empty-canvas drag there means \"rubber-band some anchors\", which\n      // is `marqueeAnchorsAction`'s job. Capability eligibility already\n      // filters this action out in path-edit mode, but only for consumers\n      // that wired a mode registry — without one the dispatcher skips\n      // eligibility entirely and areaSelect's active scope would beat\n      // marqueeAnchors' ambient scope. Declining here covers both.\n      const editAnchors = ctx.deps.editAnchors as { editingId?: string } | undefined;\n      if (editAnchors?.editingId) return {};\n\n      // Drag start is the world point at the moment start() is called.\n      const scratch: AreaSelectScratch = {\n        dep,\n        view: ctx.deps.view as ViewApi | undefined,\n        startX: ctx.world.x,\n        startY: ctx.world.y,\n        shiftHeld: ctx.modifiers.shift,\n        currentX: ctx.world.x,\n        currentY: ctx.world.y,\n        open: true,\n      };\n\n      return {\n        kind: 'marquee',\n        onMove(moveCtx: InvocationCtx): void {\n          scratch.currentX = moveCtx.world.x;\n          scratch.currentY = moveCtx.world.y;\n        },\n        overlay(): OngoingOverlay | null {\n          if (!scratch.open) return null;\n          return {\n            kind: 'marquee',\n            start: { x: scratch.startX, y: scratch.startY },\n            current: { x: scratch.currentX, y: scratch.currentY },\n            shiftHeld: scratch.shiftHeld,\n          };\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          scratch.open = false;\n          if (reason === 'cancel') return;\n\n          const { dep: d, view, startX, startY, currentX, currentY, shiftHeld } = scratch;\n\n          // Derive the marquee AABB from the two world-space corners.\n          const x = Math.min(startX, currentX);\n          const y = Math.min(startY, currentY);\n          const width = Math.abs(currentX - startX);\n          const height = Math.abs(currentY - startY);\n\n          // Zero-size marquee (click without drag) → clear selection (or no-op with shift).\n          if (width === 0 || height === 0) {\n            if (!shiftHeld) d.setSelection([]);\n            return;\n          }\n\n          const hits = d.hitTestArea({ x, y, width, height }, view) as NodeId[];\n\n          if (shiftHeld) {\n            const current = d.getSelection();\n            // Extend: merge current + hits (deduplicated).\n            const merged = [...current];\n            for (const id of hits) {\n              if (!merged.includes(id)) merged.push(id);\n            }\n            d.setSelection(merged);\n          } else {\n            d.setSelection(hits);\n          }\n        },\n      };\n    },\n  },\n  /**\n   * Always enabled at the dispatcher level. The dispatcher's\n   * specificity-fallthrough loop treats anything `!== true` as \"skip this\n   * match\" — returning a disabled reason would let lower-specificity\n   * ambient bindings win. The invoker has no preconditions to guard.\n   */\n  enabled: () => true,\n};\n"],"mappings":";AA0EA,IAAaA,IAAoD;CAC/D,IAAI;CACJ,OAAO;CAGP,cAAc;CACd,UAAU,EAAE,YAAY,oBAAoB;CAC5C,UAAU;EAAC;EAAc;EAAe;CAAM;CAC9C,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAsB;GAC9C,IAAMC,IAAMC,EAAI,KAAK;GACrB,IAAI,CAACD,GAAK,OAAO,CAAC;GAQlB,IAAME,IAAiBD,EAAI,MAAM,YAAY;GAgB7C,IAdE,OAAOC,KAAmB,YACvB,kCAAkC,KAAKA,CAAc,KAYtCD,EAAI,KAAK,aACZ,WAAW,OAAO,CAAC;GAGpC,IAAME,IAA6B;IACjC;IACA,MAAMF,EAAI,KAAK;IACf,QAAQA,EAAI,MAAM;IAClB,QAAQA,EAAI,MAAM;IAClB,WAAWA,EAAI,UAAU;IACzB,UAAUA,EAAI,MAAM;IACpB,UAAUA,EAAI,MAAM;IACpB,MAAM;GACR;GAEA,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KAEnC,AADA,EAAQ,WAAWG,EAAQ,MAAM,GACjC,EAAQ,WAAWA,EAAQ,MAAM;IACnC;IACA,UAAiC;KAE/B,OADKD,EAAQ,OACN;MACL,MAAM;MACN,OAAO;OAAE,GAAGA,EAAQ;OAAQ,GAAGA,EAAQ;MAAO;MAC9C,SAAS;OAAE,GAAGA,EAAQ;OAAU,GAAGA,EAAQ;MAAS;MACpD,WAAWA,EAAQ;KACrB,IAN0B;IAO5B;IACA,MAAM,GAAwB,GAAmC;KAE/D,IADA,EAAQ,OAAO,IACXE,MAAW,UAAU;KAEzB,IAAM,EAAE,KAAKC,GAAG,SAAM,WAAQ,WAAQ,aAAU,aAAU,iBAAcH,GAGlEI,IAAI,KAAK,IAAIC,GAAQC,CAAQ,GAC7BC,IAAI,KAAK,IAAIC,GAAQC,CAAQ,GAC7BC,IAAQ,KAAK,IAAIJ,IAAWD,CAAM,GAClCM,IAAS,KAAK,IAAIF,IAAWD,CAAM;KAGzC,IAAIE,MAAU,KAAKC,MAAW,GAAG;MAC/B,AAAKC,KAAWT,EAAE,aAAa,CAAC,CAAC;MACjC;KACF;KAEA,IAAMU,IAAOV,EAAE,YAAY;MAAE;MAAG;MAAG;MAAO;KAAO,GAAGW,CAAI;KAExD,IAAIF,GAAW;MAGb,IAAMG,IAAS,CAAC,GAFAZ,EAAE,aAEC,CAAO;MAC1B,KAAK,IAAMa,KAAMH,GACf,AAAKE,EAAO,SAASC,CAAE,KAAGD,EAAO,KAAKC,CAAE;MAE1C,EAAE,aAAaD,CAAM;KACvB,OACE,EAAE,aAAaF,CAAI;IAEvB;GACF;EACF;CACF;CAOA,eAAe;AACjB"}

package/dist/interactions/actions/defaults/booleans.js

@@ -0,0 +1,52 @@
+import { applyBooleanOp as e } from "../booleans/booleans.js";
+import { CropIcon as t, DivideIcon as n, ExcludeIcon as r, IntersectIcon as i, SubtractIcon as a, UnionIcon as o } from "./icons/booleanIcons.js";
+import { ActionDisabledReason as s } from "@weasel-js/routing";
+import { jsx as c } from "react/jsx-runtime";
+//#region src/interactions/actions/defaults/booleans.tsx
+var l = {
+	union: "pathfinder.union",
+	intersect: "pathfinder.intersect",
+	subtract: "pathfinder.subtract",
+	exclude: "pathfinder.exclude",
+	divide: "pathfinder.divide",
+	crop: "pathfinder.crop"
+}, u = {
+	union: "Unite",
+	intersect: "Intersect",
+	subtract: "Minus Front",
+	exclude: "Exclude",
+	divide: "Divide",
+	crop: "Crop"
+}, d = {
+	union: /* @__PURE__ */ c(o, {}),
+	intersect: /* @__PURE__ */ c(i, {}),
+	subtract: /* @__PURE__ */ c(a, {}),
+	exclude: /* @__PURE__ */ c(r, {}),
+	divide: /* @__PURE__ */ c(n, {}),
+	crop: /* @__PURE__ */ c(t, {})
+};
+function f(t) {
+	return {
+		id: l[t],
+		label: u[t],
+		icon: d[t],
+		group: "pathfinder",
+		eligible: { capability: "creates-shapes" },
+		requires: ["selection", "booleansAdapter"],
+		invoker: {
+			timing: "immediate",
+			run: (n) => {
+				let r = n.booleansAdapter;
+				if (!r) return;
+				let i = e(r, t);
+				i.kind === "failed" && console.warn(`[pathfinder] ${i.error.message}`);
+			}
+		},
+		enabled: (e) => ((e?.selection)?.get().length ?? 0) >= 2 || s.SelectionRequired
+	};
+}
+var p = f("union"), m = f("subtract"), h = f("intersect"), g = f("exclude"), _ = f("divide"), v = f("crop");
+//#endregion
+export { v as pathfinderCropAction, _ as pathfinderDivideAction, g as pathfinderExcludeAction, h as pathfinderIntersectAction, m as pathfinderSubtractAction, p as pathfinderUnionAction };
+
+//# sourceMappingURL=booleans.js.map

package/dist/interactions/actions/defaults/booleans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleans.js","names":["ID_FOR","LABEL_FOR","ICON_FOR","UnionIcon","IntersectIcon","SubtractIcon","ExcludeIcon","DivideIcon","CropIcon","makePathfinderAction","op","adapter","deps","result","applyBooleanOp","ActionDisabledReason","pathfinderUnionAction","pathfinderSubtractAction","pathfinderIntersectAction","pathfinderExcludeAction","pathfinderDivideAction","pathfinderCropAction"],"sources":["../../../../src/interactions/actions/defaults/booleans.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport { applyBooleanOp, type BooleanOp, type BooleansAdapter } from '../booleans/booleans';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport {\n  UnionIcon,\n  IntersectIcon,\n  SubtractIcon,\n  ExcludeIcon,\n  DivideIcon,\n  CropIcon,\n} from './icons/booleanIcons';\n\nconst ID_FOR: Record<BooleanOp, string> = {\n  union: 'pathfinder.union',\n  intersect: 'pathfinder.intersect',\n  subtract: 'pathfinder.subtract',\n  exclude: 'pathfinder.exclude',\n  divide: 'pathfinder.divide',\n  crop: 'pathfinder.crop',\n};\n\nconst LABEL_FOR: Record<BooleanOp, string> = {\n  union: 'Unite',\n  intersect: 'Intersect',\n  subtract: 'Minus Front',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n};\n\nconst ICON_FOR: Record<BooleanOp, ReactNode> = {\n  union: <UnionIcon />,\n  intersect: <IntersectIcon />,\n  subtract: <SubtractIcon />,\n  exclude: <ExcludeIcon />,\n  divide: <DivideIcon />,\n  crop: <CropIcon />,\n};\n\n// ---------------------------------------------------------------------------\n// Static descriptors\n// ---------------------------------------------------------------------------\n\nfunction makePathfinderAction(op: BooleanOp): Action {\n  return {\n    id: ID_FOR[op],\n    label: LABEL_FOR[op],\n    icon: ICON_FOR[op],\n    group: 'pathfinder',\n    eligible: { capability: 'creates-shapes' },\n    requires: ['selection', 'booleansAdapter'],\n    // No default keybindings — there's no industry-standard chord set for\n    // boolean ops. Wire bindings explicitly via the actions registry override map.\n    invoker: {\n      timing: 'immediate',\n      run: (deps) => {\n        const adapter = deps.booleansAdapter as BooleansAdapter | undefined;\n        if (!adapter) return;\n        const result = applyBooleanOp(adapter, op);\n        if (result.kind === 'failed') console.warn(`[pathfinder] ${result.error.message}`);\n      },\n    } satisfies ImmediateInvoker,\n    enabled: (deps) => {\n      const selection = deps?.selection as SelectionApi | undefined;\n      const count = selection?.get().length ?? 0;\n      return count >= 2 ? true : ActionDisabledReason.SelectionRequired;\n    },\n  };\n}\n\n/** @experimental Static descriptor for pathfinder-union. */\nexport const pathfinderUnionAction     = makePathfinderAction('union');\n/** @experimental Static descriptor for pathfinder-subtract. */\nexport const pathfinderSubtractAction  = makePathfinderAction('subtract');\n/** @experimental Static descriptor for pathfinder-intersect. */\nexport const pathfinderIntersectAction = makePathfinderAction('intersect');\n/** @experimental Static descriptor for pathfinder-exclude. */\nexport const pathfinderExcludeAction   = makePathfinderAction('exclude');\n/** @experimental Static descriptor for pathfinder-divide. */\nexport const pathfinderDivideAction    = makePathfinderAction('divide');\n/** @experimental Static descriptor for pathfinder-crop. */\nexport const pathfinderCropAction      = makePathfinderAction('crop');\n\n"],"mappings":";;;;;AAeA,IAAMA,IAAoC;CACxC,OAAO;CACP,WAAW;CACX,UAAU;CACV,SAAS;CACT,QAAQ;CACR,MAAM;AACR,GAEMC,IAAuC;CAC3C,OAAO;CACP,WAAW;CACX,UAAU;CACV,SAAS;CACT,QAAQ;CACR,MAAM;AACR,GAEMC,IAAyC;CAC7C,OAAO,kBAACC,GAAD,CAAY,CAAA;CACnB,WAAW,kBAACC,GAAD,CAAgB,CAAA;CAC3B,UAAU,kBAACC,GAAD,CAAe,CAAA;CACzB,SAAS,kBAACC,GAAD,CAAc,CAAA;CACvB,QAAQ,kBAACC,GAAD,CAAa,CAAA;CACrB,MAAM,kBAACC,GAAD,CAAW,CAAA;AACnB;AAMA,SAASC,EAAqB,GAAuB;CACnD,OAAO;EACL,IAAIT,EAAOU;EACX,OAAOT,EAAUS;EACjB,MAAMR,EAASQ;EACf,OAAO;EACP,UAAU,EAAE,YAAY,iBAAiB;EACzC,UAAU,CAAC,aAAa,iBAAiB;EAGzC,SAAS;GACP,QAAQ;GACR,MAAM,MAAS;IACb,IAAMC,IAAUC,EAAK;IACrB,IAAI,CAACD,GAAS;IACd,IAAME,IAASC,EAAeH,GAASD,CAAE;IACzC,AAAIG,EAAO,SAAS,YAAU,QAAQ,KAAK,gBAAgBA,EAAO,MAAM,SAAS;GACnF;EACF;EACA,UAAU,QACUD,GAAM,UAAA,EACC,IAAI,CAAC,CAAC,UAAU,MACzB,KAAWG,EAAqB;CAEpD;AACF;AAGA,IAAaC,IAA4BP,EAAqB,OAAO,GAExDQ,IAA4BR,EAAqB,UAAU,GAE3DS,IAA4BT,EAAqB,WAAW,GAE5DU,IAA4BV,EAAqB,SAAS,GAE1DW,IAA4BX,EAAqB,QAAQ,GAEzDY,IAA4BZ,EAAqB,MAAM"}

package/dist/interactions/actions/defaults/cancelGesture.js

@@ -0,0 +1,24 @@
+//#region src/interactions/actions/defaults/cancelGesture.ts
+var e = {
+	id: "cancelGesture",
+	label: "Cancel gesture",
+	defaultBinding: {
+		kind: "key",
+		key: "Escape",
+		phase: [{
+			channel: "*",
+			phase: "engaged"
+		}]
+	},
+	requires: ["dispatcher"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			e.dispatcher?.cancelAll("cancel");
+		}
+	}
+};
+//#endregion
+export { e as cancelGestureAction };
+
+//# sourceMappingURL=cancelGesture.js.map

package/dist/interactions/actions/defaults/cancelGesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancelGesture.js","names":["cancelGestureAction"],"sources":["../../../../src/interactions/actions/defaults/cancelGesture.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\n\n/**\n * @experimental\n * Static descriptor for the `cancelGesture` Action — Escape mid-drag\n * tells the dispatcher to abort every in-flight handle (`onEnd('cancel')`\n * on each, scratch discarded, no scene mutation).\n *\n * Phase-gated to `[*:engaged]` so it fires only when at least one tool\n * has a handle in flight; the unmodified `escape` action retains its\n * idle-phase binding (clears selection) without conflict.\n */\n// No `eligible` field → always eligible. Cancelling an in-flight gesture\n// must work regardless of mode.\nexport const cancelGestureAction: Action & { requires: string[] } = {\n  id: 'cancelGesture',\n  label: 'Cancel gesture',\n  defaultBinding: {\n    kind: 'key',\n    key: 'Escape',\n    phase: [{ channel: '*', phase: 'engaged' }],\n  },\n  requires: ['dispatcher'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const d = deps.dispatcher as { cancelAll(reason: 'commit' | 'cancel'): void } | undefined;\n      d?.cancelAll('cancel');\n    },\n  },\n};\n"],"mappings":";AAcA,IAAaA,IAAuD;CAClE,IAAI;CACJ,OAAO;CACP,gBAAgB;EACd,MAAM;EACN,KAAK;EACL,OAAO,CAAC;GAAE,SAAS;GAAK,OAAO;EAAU,CAAC;CAC5C;CACA,UAAU,CAAC,YAAY;CACvB,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GAEb,EADe,YACZ,UAAU,QAAQ;EACvB;CACF;AACF"}

package/dist/interactions/actions/defaults/clearSelection.js

@@ -0,0 +1,19 @@
+import { ActionDisabledReason as e } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/clearSelection.ts
+var t = {
+	id: "clearSelection",
+	label: "Clear selection",
+	eligible: { capability: "creates-selection" },
+	requires: ["selection", "editAnchors"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			e.selection?.set([]);
+		}
+	},
+	enabled: (t) => !t?.editAnchors?.editingId || e.NotApplicable
+};
+//#endregion
+export { t as clearSelectionAction };
+
+//# sourceMappingURL=clearSelection.js.map

package/dist/interactions/actions/defaults/clearSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearSelection.js","names":["clearSelectionAction","deps","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/clearSelection.ts"],"sourcesContent":["/**\n * `clearSelectionAction` — immediate Action descriptor for click-on-empty\n * selection clearing.\n *\n * ## Status: REAL\n *\n * Fires via `useSelectTool.bindings` when the user clicks on empty canvas\n * with no modifier held. Clears the selection by calling `deps.selection.set([])`.\n *\n * ## No defaultBinding\n *\n * This action has no ambient `defaultBinding` / `defaultBinding` — it fires\n * ONLY via `useSelectTool`'s `Tool.bindings` entry:\n *   `{ spec: { kind: 'click', target: 'empty', mods: {} }, actionId: 'clearSelection' }`\n *\n * This avoids ambient double-fire and keeps the action scoped to select-tool\n * context where `classifyTarget` is wired.\n *\n * ## enabled — the anchor-editing fall-through\n *\n * There is no \"is anything selected?\" guard: clearing an already-empty\n * selection is a safe no-op, and the binding spec is the real gate for\n * where the click landed.\n *\n * What `enabled` *does* do is decline while a path is in anchor-edit mode,\n * so the dispatcher falls through to `selectAnchorAction`. This is the\n * click twin of the opt-out `areaSelectAction.start` already performs for\n * the drag gesture, and it exists for the same reason: `useSelectTool`\n * binds this action at **active** scope while `selectAnchor` is **ambient**,\n * so without the gate an anchor that happens to sit over empty canvas\n * clears the node selection instead of selecting the anchor.\n *\n * Capability eligibility (`creates-selection`, which `path-edit` does not\n * allow) already covers consumers that wired a mode registry. Consumers\n * without one get no eligibility filtering at all, so this gate is the only\n * thing separating the two. Both mechanisms are needed — see the header of\n * `anchorEditing.ts`.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ActionDeps } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\nimport type { NodeId } from 'core/scene/types';\n\n/**\n * @experimental\n * Static descriptor for the `clearSelection` Action.\n *\n * Requires dep-schema entries: `selection`, `editAnchors`.\n *\n * Registered via `useStandardActions`; bound via `useSelectTool.bindings`.\n */\nexport const clearSelectionAction: Action & { requires: string[] } = {\n  id: 'clearSelection',\n  label: 'Clear selection',\n  // No defaultBinding / defaultBinding — fires only via Tool.bindings.\n  eligible: { capability: 'creates-selection' },\n  // `editAnchors` is required for the `enabled` gate below, not for the run.\n  requires: ['selection', 'editAnchors'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      (deps.selection as { set(ids: NodeId[]): void } | undefined)?.set([]);\n    },\n  },\n  enabled: (deps?: ActionDeps) => {\n    const editAnchors = deps?.editAnchors as EditAnchorsDep | undefined;\n    // Absent dep means the consumer never wired anchor editing — nothing to\n    // defer to, so the click is ours.\n    if (editAnchors?.editingId) return ActionDisabledReason.NotApplicable;\n    return true;\n  },\n};\n"],"mappings":";;AAqDA,IAAaA,IAAwD;CACnE,IAAI;CACJ,OAAO;CAEP,UAAU,EAAE,YAAY,oBAAoB;CAE5C,UAAU,CAAC,aAAa,aAAa;CACrC,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,EAAM,WAAwD,IAAI,CAAC,CAAC;EACtE;CACF;CACA,UAAU,MAIR,CAHoBC,GAAM,aAGT,aAAkBC,EAAqB;AAG5D"}