@weasel-js/core 1.6.1 → 1.7.1

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

@@ -0,0 +1,332 @@
+import { fromPlane as e, toPlane as t } from "../../../core/viewport/parallax.js";
+import { dropPreviewOverrides as n, syncPreviewOverrides as r } from "../previewOverrides.js";
+import { poseRotationOf as i } from "../../../core/geometry/poseRotation.js";
+import { gesturePlaneReader as a, gestureViewReader as o } from "../../gestures/shared/screenTolerance.js";
+import { commitGestureOps as s, readGestureLifecycle as c, reduceBehaviorEnd as l, runBehaviorCancel as u } from "../gestureLifecycle.js";
+import { createTransformOp as d } from "../../../core/ops/transform.js";
+import { geometryDataOp as f } from "../geometryProjection.js";
+import { unionBounds as p } from "../../../core/geometry/unionBounds.js";
+import { remapRotatedLeaf as m, translatePoseViaDescriptor as h } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as g } from "../poseDescriptorDep.js";
+import { inPlane as _, selectionLayer as v } from "../planeInput.js";
+import { DEFAULT_RESIZE_BEHAVIORS as y } from "../resize/behaviors/index.js";
+import { fixedCornerOf as b } from "../resize/cornerHandles.js";
+import { rotatePoint as x } from "../rotate/geometry.js";
+import { defaultCommitAdapter as S } from "../defaultCommitAdapter.js";
+import { scenePoseFrame as C } from "../poseFrame.js";
+import { boxToBox as w } from "@weasel-js/geom";
+//#region src/interactions/actions/defaults/resize.ts
+var T = (e) => e, E = [];
+function D(e) {
+	let t = g(e.deps.poseDescriptor), n = e.deps.resizePolicy;
+	return n ? {
+		behaviors: n.constraints,
+		pointSnap: n.pointSnap,
+		expandIds: n.expandIds,
+		geometry: t,
+		policy: n
+	} : {
+		behaviors: y,
+		pointSnap: E,
+		expandIds: T,
+		geometry: t,
+		policy: void 0
+	};
+}
+function ee(e, t, n, r) {
+	let i = e.x + e.width / 2, a = e.y + e.height / 2, o = x(e.x, e.y, i, a, t), s = x(e.x + e.width, e.y, i, a, t), c = x(e.x + e.width, e.y + e.height, i, a, t), l = x(e.x, e.y + e.height, i, a, t), u = null, d = null;
+	if (n.x !== "free" && n.y !== "free") {
+		let e = n.x === "min" && n.y === "min" ? o : n.x === "max" && n.y === "min" ? s : n.x === "max" && n.y === "max" ? c : l, t = n.x === "min" && n.y === "min" ? c : n.x === "max" && n.y === "min" ? l : n.x === "max" && n.y === "max" ? o : s;
+		d = {
+			worldX: e.x,
+			worldY: e.y
+		}, u = {
+			worldX: t.x,
+			worldY: t.y
+		};
+	}
+	return {
+		draggedCorner: u,
+		fixedCorner: d,
+		center: {
+			worldX: i,
+			worldY: a
+		},
+		origin: {
+			worldX: o.x,
+			worldY: o.y
+		},
+		rotation: t,
+		anchor: n,
+		proposed: e,
+		modifiers: r
+	};
+}
+function te(e, t, n, r) {
+	if (n.frame === "center") {
+		let t = n.worldX - r.center.worldX, i = n.worldY - r.center.worldY;
+		return {
+			...e,
+			x: e.x + t,
+			y: e.y + i
+		};
+	}
+	if (n.frame === "origin") {
+		let t = n.worldX - r.origin.worldX, i = n.worldY - r.origin.worldY;
+		return {
+			...e,
+			x: e.x + t,
+			y: e.y + i
+		};
+	}
+	let i = n.frame === "dragged-corner" ? r.fixedCorner : r.draggedCorner;
+	if (!i) return e;
+	let a = n.worldX - i.worldX, o = n.worldY - i.worldY, s = Math.cos(t), c = Math.sin(t), l = a * s + o * c, u = -a * c + o * s, d = Math.abs(l), f = Math.abs(u), p = (i.worldX + n.worldX) / 2, m = (i.worldY + n.worldY) / 2;
+	return {
+		...e,
+		x: p - d / 2,
+		y: m - f / 2,
+		width: d,
+		height: f
+	};
+}
+function O(t, n) {
+	let r = (t) => {
+		let r = e(n, {
+			x: t.worldX,
+			y: t.worldY
+		});
+		return {
+			worldX: r.x,
+			worldY: r.y
+		};
+	};
+	return {
+		...t,
+		draggedCorner: t.draggedCorner && r(t.draggedCorner),
+		fixedCorner: t.fixedCorner && r(t.fixedCorner),
+		center: r(t.center),
+		origin: r(t.origin)
+	};
+}
+function k(e, n) {
+	if (!e) return e;
+	let r = t(n, {
+		x: e.worldX,
+		y: e.worldY
+	});
+	return {
+		...e,
+		worldX: r.x,
+		worldY: r.y
+	};
+}
+function A(e, t, n, r, i) {
+	if (i !== 0) {
+		let e = Math.cos(-i), t = Math.sin(-i), a = e * n - t * r, o = t * n + e * r;
+		n = a, r = o;
+	}
+	let a = e.x, o = e.y, s = e.width, c = e.height;
+	return t.x === "min" ? s = e.width + n : t.x === "max" && (a = e.x + n, s = e.width - n), t.y === "min" ? c = e.height + r : t.y === "max" && (o = e.y + r, c = e.height - r), {
+		x: a,
+		y: o,
+		width: s,
+		height: c
+	};
+}
+var j = _({
+	id: "resize",
+	label: "Resize",
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"resizePolicy",
+		"poseDescriptor",
+		"applyOps",
+		"geometryProjection",
+		"poseComposition",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(e, t) {
+			let g = e.deps.selection, _ = e.deps.scene, v = e.deps.applyOps, y = e.deps.geometryProjection;
+			if (!g || !_) return {};
+			let T = g.get();
+			if (T.length === 0) return {};
+			let E = e.drag?.affordance?.anchor;
+			if (!E) return {};
+			let { behaviors: j, pointSnap: M, expandIds: N, geometry: P, policy: F } = D(e), I = N(T);
+			if (I.length === 0) return {};
+			let L = T.length === 1 && (I.length !== 1 || I[0] !== T[0]), R = L ? I : T, z = C(_, e.deps.poseComposition), B = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map(), H = [];
+			for (let e of R) {
+				let t = _.get(e);
+				if (!t) continue;
+				B.set(e, t.pose);
+				let n = z.world(e);
+				V.set(e, n), H.push(P.getBounds(n));
+			}
+			if (B.size === 0) return {};
+			let U = H.length === 1 ? H[0] : p(H), W = !L && R.length === 1 ? V.get(R[0]) : U, G = L ? 0 : P.getRotation?.(W) ?? 0, K = b(U, E), q = G === 0 ? K : x(K.x, K.y, U.x + U.width / 2, U.y + U.height / 2, G), J = {
+				x: e.drag?.start.x ?? 0,
+				y: e.drag?.start.y ?? 0
+			}, Y = o(e.deps), X = a(e.deps), Z = {
+				draggedIds: T,
+				origin: /* @__PURE__ */ new Map([[T[0], W]]),
+				current: /* @__PURE__ */ new Map([[T[0], W]]),
+				snap: null,
+				modifiers: { ...e.modifiers },
+				pointer: {
+					worldX: J.x,
+					worldY: J.y,
+					clientX: 0,
+					clientY: 0
+				},
+				view: Y(),
+				plane: X(),
+				adapter: void 0,
+				scratch: {}
+			}, ne = Z;
+			for (let e of j) e.onStart?.(ne);
+			let Q = {
+				writeIds: R,
+				scene: _,
+				frame: z,
+				startPoses: B,
+				startWorlds: V,
+				originBounds: U,
+				anchor: E,
+				startWorld: J,
+				originRotation: G,
+				fixedWorld: q,
+				previews: /* @__PURE__ */ new Map(),
+				overrideEntries: /* @__PURE__ */ new Map(),
+				geometry: P,
+				behaviors: j,
+				pointSnap: M,
+				gestureCtx: Z,
+				applyOps: v,
+				geometryProjection: y,
+				lifecycle: c(F, "Resize", j)
+			}, { lifecycle: $ } = Q;
+			$.start(R);
+			let re = () => {
+				let e = {
+					scene: _,
+					applyOps: Q.applyOps,
+					adapter: S(_, g.adapterMethods)
+				}, t = l(Q.behaviors, Q.gestureCtx);
+				if (t === null) return !1;
+				if (t !== void 0) return s(e, $, t), !0;
+				if (Q.previews.size === 0) return !1;
+				let n = [];
+				for (let e of Q.writeIds) {
+					let t = Q.previews.get(e);
+					if (t === void 0) continue;
+					let r = Q.startPoses.get(e);
+					if (r === void 0) continue;
+					let i = t;
+					if (Q.geometryProjection) {
+						let a = Q.scene.get(e);
+						if (a) {
+							let o = Q.geometry.getBounds(r), s = Q.geometry.getBounds(t), c = w(o.x, o.y, o.width, o.height, s.x, s.y, s.width, s.height), l = f(Q.geometryProjection, {
+								id: e,
+								data: a.data,
+								pose: r
+							}, c, $.label);
+							if (l && (n.push(l), s.width < 0 || s.height < 0)) {
+								let e = {
+									...s,
+									x: s.width < 0 ? s.x + s.width : s.x,
+									y: s.height < 0 ? s.y + s.height : s.y,
+									width: Math.abs(s.width),
+									height: Math.abs(s.height)
+								};
+								i = Q.geometry.remapBounds(t, s, e);
+							}
+						}
+					}
+					n.push(d({
+						id: e,
+						from: r,
+						to: i,
+						label: $.label
+					}));
+				}
+				return n.length !== 0 && (s(e, $, n), !0);
+			};
+			return {
+				kind: "resize",
+				onMove(e) {
+					if (!e.drag) return;
+					let t = e.drag.current.x - Q.startWorld.x, n = e.drag.current.y - Q.startWorld.y;
+					Q.gestureCtx.modifiers = { ...e.modifiers }, Q.gestureCtx.pointer = {
+						worldX: e.drag.current.x,
+						worldY: e.drag.current.y,
+						clientX: 0,
+						clientY: 0
+					}, Q.gestureCtx.view = Y(), Q.gestureCtx.plane = X();
+					let a = A(Q.originBounds, Q.anchor, t, n, Q.originRotation), o = Q.gestureCtx;
+					for (let e of Q.behaviors) {
+						let t = e.onMove?.(o, {
+							pose: a,
+							anchor: Q.anchor
+						});
+						t && t.pose !== void 0 && (a = {
+							x: t.pose.x,
+							y: t.pose.y,
+							width: t.pose.width,
+							height: t.pose.height
+						});
+					}
+					let s = (e) => {
+						let t = Q.startWorlds.get(e);
+						if (t !== void 0) return L && i(t) !== null ? m(t, Q.originBounds, a) : Q.geometry.remapBounds(t, Q.originBounds, a);
+					};
+					if (Q.previews.clear(), !L && Q.writeIds.length === 1) {
+						let e = Q.writeIds[0], t = s(e);
+						if (t === void 0) {
+							r(Q);
+							return;
+						}
+						if (Q.originRotation !== 0) {
+							let e = a.x + a.width / 2, n = a.y + a.height / 2, r = b(a, Q.anchor), i = x(r.x, r.y, e, n, Q.originRotation), o = Q.fixedWorld.x - i.x, s = Q.fixedWorld.y - i.y;
+							t = h(t, o, s, Q.geometry);
+						}
+						if (Q.pointSnap.length > 0) {
+							let e = Q.originRotation, n = t, r = ee(n, e, Q.anchor, Q.gestureCtx.modifiers), i = Q.gestureCtx.plane ?? null;
+							for (let a of Q.pointSnap) {
+								let o = i ? k(a.onMove(O(r, i)), i) : a.onMove(r);
+								if (o) {
+									t = te(n, e, o, r);
+									break;
+								}
+							}
+						}
+						Q.previews.set(e, Q.frame.local(e, t)), Q.gestureCtx.current = /* @__PURE__ */ new Map([[e, t]]);
+					} else for (let e of Q.writeIds) {
+						let t = s(e);
+						t !== void 0 && Q.previews.set(e, Q.frame.local(e, t));
+					}
+					r(Q);
+				},
+				onEnd(e, t) {
+					let r = !1;
+					try {
+						t === "commit" ? r = re() : u(Q.behaviors, Q.gestureCtx);
+					} finally {
+						n(Q), Q.previews.clear(), $.end(r);
+					}
+				},
+				previewIds: () => Q.previews.keys(),
+				previewPose: (e) => Q.previews.get(e) ?? null
+			};
+		}
+	},
+	enabled: () => !0
+}, v);
+//#endregion
+export { j as resizeAction };
+
+//# sourceMappingURL=resize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resize.js","names":["IDENTITY_EXPAND","ids","EMPTY_POINT_SNAP","resolveDeps","geometry","poseDescriptorOf","ctx","dep","DEFAULT_RESIZE_BEHAVIORS","buildPointSnapContext","cx","pose","cy","tl","rotatePoint","rotation","tr","br","bl","draggedCorner","fixedCorner","anchor","fixedPt","draggedPt","applyPointSnap","result","dx","dy","pin","Dx","Dy","cos","sin","localW","localH","newWidth","newHeight","newCx","newCy","pointSnapToCamera","cam","w","fromPlane","m","p","pointSnapFromPlane","r","toPlane","computeProposedBounds","cs","sn","dxLocal","dyLocal","nx","ob","ny","nw","nh","resizeAction","inPlane","selection","scene","applyOps","geometryProjection","expanded","expandIds","isGroupPath","writeIds","frame","scenePoseFrame","startPoses","startWorlds","leafBounds","id","node","world","originBounds","unionBounds","originPose","originRotation","fixedLocal","fixedCornerOf","fixedWorld","startWorld","readView","gestureViewReader","readPlane","gesturePlaneReader","gestureCtx","ctxAsRect","b","behaviors","scratch","readGestureLifecycle","policy","commitResize","target","defaultCommitAdapter","reduceBehaviorEnd","commitGestureOps","lifecycle","ops","next","from","committed","sb","db","boxToBox","dataOp","geometryDataOp","nb","createTransformOp","mctx","proposedBounds","behaviorCtx","computePose","sp","poseRotationOf","remapRotatedLeaf","proposedPose","newCenterX","newCenterY","newFixedLocal","newFixedWorld","correctionX","correctionY","translatePoseViaDescriptor","poseAsRect","psCtx","plane","beh","reason","runBehaviorCancel","dropPreviewOverrides","selectionLayer"],"sources":["../../../../src/interactions/actions/defaults/resize.ts"],"sourcesContent":["/**\n * `resizeAction` — ongoing Action descriptor for anchor-relative drag resize.\n *\n * ## Status: REAL\n *\n * Performs real anchor-relative resize math for rect-shaped poses. Reads\n * `ctx.drag.affordance.anchor` to determine which corner is fixed, captures\n * start poses, applies per-frame bounds remapping, and commits one batch on\n * end — labeled, transient and observed per the `resizePolicy` dep's\n * lifecycle fields.\n *\n * ## Behaviors / point-snap / expandIds — via the `resizePolicy` dep\n *\n * The `resizePolicy` dep carries the behavior options the legacy `useResize`\n * hook exposed (`behaviors`, `pointSnapBehaviors`, `expandIds`). When the dep\n * is registered, this invoker:\n *\n *  - Calls `expandIds([id])` at start. When the result expands beyond the\n *    starting id, takes the group path (union-AABB origin, per-leaf remap).\n *  - Runs `behaviors[]` after the raw anchor-math bounds are computed.\n *    Behaviors return `{ pose? }` and rewrite the proposed bounds before\n *    they're projected back into pose space.\n *  - Runs `pointSnap[]` after the bounds→pose projection. The first non-null\n *    `PointSnapResult` wins; this invoker back-solves a pose so the chosen\n *    frame's world point lands on the snap target.\n *\n * When the dep is absent the invoker falls back to identity defaults\n * (no behaviors, no snap, `ids => ids` expansion).\n *\n * ## Pose geometry — via the `poseDescriptor` dep\n *\n * Every pose read and rewrite goes through the `poseDescriptor` dep, which\n * `<SceneCanvas>` sources from its `poseDescriptor` prop. Unsourced it is\n * `AUTO_POSE_DESCRIPTOR`, which dispatches per call to `pathPoseDescriptor`\n * for Path-shaped poses and to `RECT_POSE_DESCRIPTOR` for everything else.\n *\n * @see useResize — the React hook this descriptor mirrors.\n * @see src/interactions/actions/resize/geometry.ts — `PoseDescriptor`.\n */\n\nimport { gesturePlaneReader, gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { syncPreviewOverrides, dropPreviewOverrides } from '../previewOverrides';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type {\n  GestureContext,\n  ModifierState,\n  PointSnapBehavior,\n  PointSnapContext,\n  PointSnapResult,\n  ResizeAnchor,\n  BoundsConstraint,\n  RotatedPose,\n} from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { ResizePolicy } from '../depSchema';\nimport { DEFAULT_RESIZE_BEHAVIORS } from '../resize/behaviors';\nimport { remapRotatedLeaf, translatePoseViaDescriptor, type PoseDescriptor } from '../resize/geometry';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { fixedCornerOf } from '../resize/cornerHandles';\nimport { rotatePoint } from '../rotate/geometry';\nimport type { Op } from 'core/ops/types';\nimport type { Mat3 } from '@weasel-js/geom';\nimport { boxToBox } from '@weasel-js/geom';\nimport { createTransformOp } from 'core/ops/transform';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\nimport { unionBounds } from 'core/geometry/unionBounds';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel, type GestureLifecycle } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { fromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\n\n// ---------------------------------------------------------------------------\n// Defaults applied when `resizePolicy` dep is absent. Mirrors the\n// destructuring defaults in `useResize`.\n// ---------------------------------------------------------------------------\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY_POINT_SNAP: PointSnapBehavior<Bounds>[] = [];\n\nfunction resolveDeps(ctx: InvocationCtx): {\n  behaviors: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n  expandIds: (ids: string[]) => string[];\n  geometry: PoseDescriptor<unknown>;\n  policy: ResizePolicy<unknown> | undefined;\n} {\n  const geometry = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const dep = ctx.deps.resizePolicy as ResizePolicy<unknown> | undefined;\n  if (!dep) {\n    return {\n      // Standard kit behaviors (shift = aspect lock) apply even with no\n      // policy wired; consumers opt out via an explicit `behaviors: []`.\n      behaviors: DEFAULT_RESIZE_BEHAVIORS as BoundsConstraint<Bounds>[],\n      pointSnap: EMPTY_POINT_SNAP,\n      expandIds: IDENTITY_EXPAND,\n      geometry,\n      policy: undefined,\n    };\n  }\n  return {\n    behaviors: dep.constraints as unknown as BoundsConstraint<Bounds>[],\n    pointSnap: dep.pointSnap as unknown as PointSnapBehavior<Bounds>[],\n    expandIds: dep.expandIds,\n    geometry,\n    policy: dep,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Point-snap math (lifted from `useResize`).\n// ---------------------------------------------------------------------------\n\nfunction buildPointSnapContext<TPose extends Bounds>(\n  pose: TPose,\n  rotation: number,\n  anchor: ResizeAnchor,\n  modifiers: ModifierState,\n): PointSnapContext<TPose> {\n  const cx = pose.x + pose.width / 2;\n  const cy = pose.y + pose.height / 2;\n\n  const tl = rotatePoint(pose.x, pose.y, cx, cy, rotation);\n  const tr = rotatePoint(pose.x + pose.width, pose.y, cx, cy, rotation);\n  const br = rotatePoint(pose.x + pose.width, pose.y + pose.height, cx, cy, rotation);\n  const bl = rotatePoint(pose.x, pose.y + pose.height, cx, cy, rotation);\n\n  let draggedCorner: { worldX: number; worldY: number } | null = null;\n  let fixedCorner: { worldX: number; worldY: number } | null = null;\n\n  if (anchor.x !== 'free' && anchor.y !== 'free') {\n    const fixedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? tl :\n      anchor.x === 'max' && anchor.y === 'min' ? tr :\n      anchor.x === 'max' && anchor.y === 'max' ? br : bl;\n    const draggedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? br :\n      anchor.x === 'max' && anchor.y === 'min' ? bl :\n      anchor.x === 'max' && anchor.y === 'max' ? tl : tr;\n    fixedCorner = { worldX: fixedPt.x, worldY: fixedPt.y };\n    draggedCorner = { worldX: draggedPt.x, worldY: draggedPt.y };\n  }\n\n  return {\n    draggedCorner,\n    fixedCorner,\n    center: { worldX: cx, worldY: cy },\n    origin: { worldX: tl.x, worldY: tl.y },\n    rotation,\n    anchor,\n    proposed: pose,\n    modifiers,\n  };\n}\n\nfunction applyPointSnap<TPose extends Bounds>(\n  pose: TPose,\n  rotation: number,\n  result: PointSnapResult,\n  ctx: PointSnapContext<TPose>,\n): TPose {\n  if (result.frame === 'center') {\n    const dx = result.worldX - ctx.center.worldX;\n    const dy = result.worldY - ctx.center.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  if (result.frame === 'origin') {\n    const dx = result.worldX - ctx.origin.worldX;\n    const dy = result.worldY - ctx.origin.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  const pin = result.frame === 'dragged-corner' ? ctx.fixedCorner : ctx.draggedCorner;\n  if (!pin) return pose;\n  const Dx = result.worldX - pin.worldX;\n  const Dy = result.worldY - pin.worldY;\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const localW = Dx * cos + Dy * sin;\n  const localH = -Dx * sin + Dy * cos;\n  const newWidth = Math.abs(localW);\n  const newHeight = Math.abs(localH);\n  const newCx = (pin.worldX + result.worldX) / 2;\n  const newCy = (pin.worldY + result.worldY) / 2;\n  return { ...pose, x: newCx - newWidth / 2, y: newCy - newHeight / 2, width: newWidth, height: newHeight };\n}\n\n/** `ctx`'s points in the camera's world, for a snap rule written against it. */\nfunction pointSnapToCamera<TPose extends Bounds>(\n  ctx: PointSnapContext<TPose>,\n  m: PlaneMap,\n): PointSnapContext<TPose> {\n  const cam = (p: { worldX: number; worldY: number }) => {\n    const w = fromPlane(m, { x: p.worldX, y: p.worldY });\n    return { worldX: w.x, worldY: w.y };\n  };\n  return {\n    ...ctx,\n    draggedCorner: ctx.draggedCorner && cam(ctx.draggedCorner),\n    fixedCorner: ctx.fixedCorner && cam(ctx.fixedCorner),\n    center: cam(ctx.center),\n    origin: cam(ctx.origin),\n  };\n}\n\n/** A snap rule's answer, back in the plane the resize works in. */\nfunction pointSnapFromPlane(\n  r: PointSnapResult | null | undefined,\n  m: PlaneMap,\n): PointSnapResult | null | undefined {\n  if (!r) return r;\n  const p = toPlane(m, { x: r.worldX, y: r.worldY });\n  return { ...r, worldX: p.x, worldY: p.y };\n}\n\n// ---------------------------------------------------------------------------\n// Anchor math (rotated and unrotated).\n// ---------------------------------------------------------------------------\n\nfunction computeProposedBounds(\n  ob: Bounds,\n  anchor: ResizeAnchor,\n  dx: number,\n  dy: number,\n  rotation: number,\n): Bounds {\n  if (rotation !== 0) {\n    const cs = Math.cos(-rotation);\n    const sn = Math.sin(-rotation);\n    const dxLocal = cs * dx - sn * dy;\n    const dyLocal = sn * dx + cs * dy;\n    dx = dxLocal;\n    dy = dyLocal;\n  }\n  let nx = ob.x;\n  let ny = ob.y;\n  let nw = ob.width;\n  let nh = ob.height;\n  if (anchor.x === 'min') {\n    nw = ob.width + dx;\n  } else if (anchor.x === 'max') {\n    nx = ob.x + dx;\n    nw = ob.width - dx;\n  }\n  if (anchor.y === 'min') {\n    nh = ob.height + dy;\n  } else if (anchor.y === 'max') {\n    ny = ob.y + dy;\n    nh = ob.height - dy;\n  }\n  return { x: nx, y: ny, width: nw, height: nh };\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface ResizeScratch {\n  /** Ids the gesture writes to. For group expansion this is the leaf set;\n   *  for the single-id path it's the original selection. */\n  writeIds: NodeId[];\n  scene: Scene<unknown, string, unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  frame: PoseFrame<unknown>;\n  /** Start poses keyed by write id, as stored — the `from` of each op. */\n  startPoses: Map<NodeId, unknown>;\n  /** Start poses in world — the frame the anchor math and the drag share. */\n  startWorlds: Map<NodeId, unknown>;\n  /** Shared origin bounds (union for group/multi-select, own bounds for\n   *  single). Used as the `src` rect for `geometry.remapBounds`. */\n  originBounds: Bounds;\n  anchor: ResizeAnchor;\n  startWorld: { x: number; y: number };\n  /** Rotation captured at gesture start (from `geometry.getRotation?`). */\n  originRotation: number;\n  /** World-space position of the diagonally opposite corner at start. Used\n   *  for the rotated-resize fixed-corner pin correction. */\n  fixedWorld: { x: number; y: number };\n  /** In-flight preview poses buffered during drag. */\n  previews: Map<NodeId, unknown>;\n  overrideEntries: Map<NodeId, { pose: unknown }>;\n  geometry: PoseDescriptor<unknown>;\n  behaviors: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n  /** Gesture context handed to behaviors. Reused across move/end. */\n  gestureCtx: GestureContext<unknown>;\n  /** Optional consumer commit hook captured at gesture start. When present,\n   *  the final pose commit routes through it (consumer history) instead of\n   *  `scene.applyBatch`. Undefined → fall back to `scene.applyBatch`. */\n  applyOps?: (ops: Op[], label: string) => void;\n  /** Optional eager-sync seam captured at gesture start. When present, the\n   *  commit emits a `setData` op per leaf mapping its data-held geometry by\n   *  the box→box affine the pose underwent. Undefined → pose-only commit. */\n  geometryProjection?: GeometryProjection;\n  /** Label, history and callbacks from the `resizePolicy` dep. */\n  lifecycle: GestureLifecycle;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `resize` Action.\n *\n * Requires dep-schema entries: `selection`, `scene`.\n * Reads optional `resizePolicy` dep when present.\n * Requires `InvocationCtx.drag.affordance` with a `handle:*` kind.\n */\nexport const resizeAction: Action & { requires: string[] } = inPlane({\n  id: 'resize',\n  label: 'Resize',\n  // No default binding: a bare `{ kind: 'drag' }` claimed every drag at ambient\n  // scope, tying areaSelect's. The resize handles bind it\n  // (`selectionTransformBindings`, the `transform` preset).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'resizePolicy', 'poseDescriptor', 'applyOps', 'geometryProjection', 'poseComposition', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const selection = ctx.deps.selection as SelectionApi | undefined;\n      const scene = ctx.deps.scene as Scene<unknown, string, unknown> | undefined;\n      const applyOps = ctx.deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n      const geometryProjection = ctx.deps.geometryProjection as GeometryProjection | undefined;\n\n      if (!selection || !scene) return {};\n\n      const ids = selection.get() as NodeId[];\n      if (ids.length === 0) return {};\n\n      const affordance = ctx.drag?.affordance;\n      const anchor = affordance?.anchor;\n      if (!anchor) return {};\n\n      const { behaviors, pointSnap, expandIds, geometry, policy } = resolveDeps(ctx);\n\n      // Group expansion. When the starting selection is a single id but\n      // `expandIds` returns a different set, we're in the group path:\n      // every leaf is written, and origin bounds is the union AABB.\n      // When `expandIds` returns the same list (identity default or no-op),\n      // we write the selected ids directly.\n      const expanded = expandIds(ids as unknown as string[]);\n      if (expanded.length === 0) return {};\n\n      const isGroupPath =\n        ids.length === 1 && (expanded.length !== 1 || expanded[0] !== (ids[0] as string));\n      const writeIds = (isGroupPath ? expanded : (ids as unknown as string[])) as NodeId[];\n\n      // Capture start poses + per-leaf bounds. The drag delta is world, so\n      // the anchor math runs on world poses; each frame's result is stored\n      // back in the node's own parent frame.\n      const frame = scenePoseFrame(scene, ctx.deps.poseComposition);\n      const startPoses = new Map<NodeId, unknown>();\n      const startWorlds = new Map<NodeId, unknown>();\n      const leafBounds: Bounds[] = [];\n      for (const id of writeIds) {\n        const node = scene.get(id);\n        if (!node) continue;\n        startPoses.set(id, node.pose);\n        const world = frame.world(id);\n        startWorlds.set(id, world);\n        leafBounds.push(geometry.getBounds(world));\n      }\n      if (startPoses.size === 0) return {};\n\n      // `leafBounds` is non-empty here (startPoses.size === 0 guarded above),\n      // and the union branch only runs for length >= 2 → `!` is safe.\n      const originBounds = leafBounds.length === 1\n        ? leafBounds[0]\n        : unionBounds(leafBounds)!;\n\n      // Rotation captured only for the single-write-id path; group-resize\n      // takes the AABB-frame (unrotated) path even if leaves have rotation.\n      const originPose = !isGroupPath && writeIds.length === 1\n        ? startWorlds.get(writeIds[0])\n        : (originBounds as unknown);\n      const originRotation = !isGroupPath\n        ? (geometry.getRotation?.(originPose) ?? 0)\n        : 0;\n\n      const fixedLocal = fixedCornerOf(originBounds, anchor);\n      const fixedWorld = originRotation === 0\n        ? fixedLocal\n        : rotatePoint(\n            fixedLocal.x, fixedLocal.y,\n            originBounds.x + originBounds.width / 2,\n            originBounds.y + originBounds.height / 2,\n            originRotation,\n          );\n\n      const startWorld = { x: ctx.drag?.start.x ?? 0, y: ctx.drag?.start.y ?? 0 };\n\n      // Minimal GestureContext for behaviors. `draggedIds` matches the\n      // legacy hook: the starting id (not the expanded leaf set).\n      const readView = gestureViewReader(ctx.deps);\n      const readPlane = gesturePlaneReader(ctx.deps);\n      const gestureCtx: GestureContext<unknown> = {\n        draggedIds: ids as unknown as string[],\n        origin: new Map<string, unknown>([[ids[0] as string, originPose]]),\n        current: new Map<string, unknown>([[ids[0] as string, originPose]]),\n        snap: null,\n        modifiers: { ...ctx.modifiers },\n        pointer: { worldX: startWorld.x, worldY: startWorld.y, clientX: 0, clientY: 0 },\n        view: readView(),\n        plane: readPlane(),\n        // `adapter` is unused by the kit's behaviors; cast to satisfy the type.\n        adapter: undefined as unknown as GestureContext<unknown>['adapter'],\n        scratch: {},\n      };\n\n      // Fire behavior onStart hooks (parity with `useResize`).\n      const ctxAsRect = gestureCtx as unknown as GestureContext<Bounds>;\n      for (const b of behaviors) b.onStart?.(ctxAsRect);\n\n      const scratch: ResizeScratch = {\n        writeIds,\n        scene,\n        frame,\n        startPoses,\n        startWorlds,\n        originBounds,\n        anchor,\n        startWorld,\n        originRotation,\n        fixedWorld,\n        previews: new Map<NodeId, unknown>(),\n        overrideEntries: new Map<NodeId, { pose: unknown }>(),\n        geometry,\n        behaviors,\n        pointSnap,\n        gestureCtx,\n        applyOps,\n        geometryProjection,\n        lifecycle: readGestureLifecycle(policy, 'Resize', behaviors),\n      };\n      const { lifecycle } = scratch;\n      lifecycle.start(writeIds as string[]);\n\n      // Returns whether anything reached the document.\n      const commitResize = (): boolean => {\n        const target = {\n          scene,\n          applyOps: scratch.applyOps,\n          adapter: defaultCommitAdapter(scene, selection.adapterMethods),\n        };\n        const r = reduceBehaviorEnd(scratch.behaviors, scratch.gestureCtx as unknown as GestureContext<Bounds>);\n        if (r === null) return false;\n        if (r !== undefined) {\n          commitGestureOps(target, lifecycle, r);\n          return true;\n        }\n\n        if (scratch.previews.size === 0) return false;\n\n        // One transform op per write id (from = pre-drag start pose, to =\n        // final preview pose), committed as a single batch → one undo entry.\n        const ops: Op[] = [];\n        for (const id of scratch.writeIds) {\n          const next = scratch.previews.get(id);\n          if (next === undefined) continue;\n          const from = scratch.startPoses.get(id);\n          if (from === undefined) continue;\n          let committed = next;\n          // Eager-sync: map data-held geometry by the box→box affine the\n          // pose underwent (start-pose bounds → final-pose bounds). Opt-in\n          // via the geometryProjection seam; a no-op when the dep is absent.\n          if (scratch.geometryProjection) {\n            const node = scratch.scene.get(id);\n            if (node) {\n              const sb = scratch.geometry.getBounds(from);\n              const db = scratch.geometry.getBounds(next);\n              const m: Mat3 = boxToBox(\n                sb.x, sb.y, sb.width, sb.height,\n                db.x, db.y, db.width, db.height,\n              );\n              const dataOp = geometryDataOp(\n                scratch.geometryProjection,\n                { id: id as string, data: node.data, pose: from },\n                m,\n                lifecycle.label,\n              );\n              if (dataOp) {\n                ops.push(dataOp);\n                // The data absorbed the affine — including any mirror from a\n                // drag past the opposite edge — so the pose must commit as a\n                // normalized AABB. Leaving signed extents on the pose makes\n                // the node unhittable (hit-testing assumes normalized boxes).\n                // Without the seam the signed pose is kept: a bare-AABB pose\n                // is the only carrier of the flip there.\n                if (db.width < 0 || db.height < 0) {\n                  const nb = {\n                    ...db,\n                    x: db.width < 0 ? db.x + db.width : db.x,\n                    y: db.height < 0 ? db.y + db.height : db.y,\n                    width: Math.abs(db.width),\n                    height: Math.abs(db.height),\n                  };\n                  committed = scratch.geometry.remapBounds(next, db, nb) as typeof next;\n                }\n              }\n            }\n          }\n          ops.push(createTransformOp<unknown>({\n            id: id as string,\n            from,\n            to: committed,\n            label: lifecycle.label,\n          }));\n        }\n        if (ops.length === 0) return false;\n        commitGestureOps(target, lifecycle, ops);\n        return true;\n      };\n\n      return {\n        kind: 'resize',\n        onMove(mctx: InvocationCtx): void {\n          if (!mctx.drag) return;\n          const dx = mctx.drag.current.x - scratch.startWorld.x;\n          const dy = mctx.drag.current.y - scratch.startWorld.y;\n\n          // Refresh modifiers + pointer on the gesture ctx for behaviors.\n          scratch.gestureCtx.modifiers = { ...mctx.modifiers };\n          scratch.gestureCtx.pointer = {\n            worldX: mctx.drag.current.x,\n            worldY: mctx.drag.current.y,\n            clientX: 0,\n            clientY: 0,\n          };\n          scratch.gestureCtx.view = readView();\n          scratch.gestureCtx.plane = readPlane();\n\n          let proposedBounds = computeProposedBounds(\n            scratch.originBounds,\n            scratch.anchor,\n            dx,\n            dy,\n            scratch.originRotation,\n          );\n\n          // Behaviors run in bounds-space.\n          const behaviorCtx = scratch.gestureCtx as unknown as GestureContext<Bounds>;\n          for (const b of scratch.behaviors) {\n            const r = b.onMove?.(behaviorCtx, {\n              pose: proposedBounds,\n              anchor: scratch.anchor,\n            });\n            if (!r) continue;\n            if (r.pose !== undefined) {\n              proposedBounds = {\n                x: r.pose.x, y: r.pose.y, width: r.pose.width, height: r.pose.height,\n              };\n            }\n          }\n\n          // Project bounds → pose. For the group path, each leaf is remapped\n          // from its own startPose; for single, from the start pose directly.\n          //\n          // A rotated leaf in a group needs its own frame: `src`/`dst` are\n          // world-frame here, unlike the single path where the drag delta was\n          // already projected into the leaf's frame, so the naive affine\n          // scales the wrong pair of extents. See `remapRotatedLeaf`.\n          const computePose = (id: NodeId): unknown => {\n            const sp = scratch.startWorlds.get(id);\n            if (sp === undefined) return undefined;\n            if (isGroupPath && poseRotationOf(sp) !== null) {\n              return remapRotatedLeaf(\n                sp as RotatedPose, scratch.originBounds, proposedBounds,\n              );\n            }\n            return scratch.geometry.remapBounds(sp, scratch.originBounds, proposedBounds);\n          };\n\n          // Single-id path: apply rotation correction + point-snap, then\n          // store. Group path: rotation correction + point-snap don't apply\n          // (group resize is AABB-frame).\n          scratch.previews.clear();\n\n          if (!isGroupPath && scratch.writeIds.length === 1) {\n            const id = scratch.writeIds[0];\n            let proposedPose = computePose(id);\n            if (proposedPose === undefined) { syncPreviewOverrides(scratch); return; }\n\n            if (scratch.originRotation !== 0) {\n              const newCenterX = proposedBounds.x + proposedBounds.width / 2;\n              const newCenterY = proposedBounds.y + proposedBounds.height / 2;\n              const newFixedLocal = fixedCornerOf(proposedBounds, scratch.anchor);\n              const newFixedWorld = rotatePoint(\n                newFixedLocal.x, newFixedLocal.y,\n                newCenterX, newCenterY,\n                scratch.originRotation,\n              );\n              const correctionX = scratch.fixedWorld.x - newFixedWorld.x;\n              const correctionY = scratch.fixedWorld.y - newFixedWorld.y;\n              proposedPose = translatePoseViaDescriptor(proposedPose, correctionX, correctionY, scratch.geometry);\n            }\n\n            if (scratch.pointSnap.length > 0) {\n              const rotation = scratch.originRotation;\n              const poseAsRect = proposedPose as Bounds;\n              const psCtx = buildPointSnapContext(\n                poseAsRect,\n                rotation,\n                scratch.anchor,\n                scratch.gestureCtx.modifiers,\n              );\n              // Point snaps are the surface's rules over the camera's world, so\n              // on a plane their points cross at this boundary.\n              const plane = scratch.gestureCtx.plane ?? null;\n              for (const beh of scratch.pointSnap) {\n                const result = plane\n                  ? pointSnapFromPlane(beh.onMove(pointSnapToCamera(psCtx, plane)), plane)\n                  : beh.onMove(psCtx);\n                if (result) {\n                  proposedPose = applyPointSnap(poseAsRect, rotation, result, psCtx) as unknown;\n                  break;\n                }\n              }\n            }\n\n            scratch.previews.set(id, scratch.frame.local(id, proposedPose));\n            scratch.gestureCtx.current = new Map<string, unknown>([[id as string, proposedPose]]);\n          } else {\n            // Group / multi path: remap each leaf and store.\n            for (const id of scratch.writeIds) {\n              const next = computePose(id);\n              if (next === undefined) continue;\n              scratch.previews.set(id, scratch.frame.local(id, next));\n            }\n          }\n\n          syncPreviewOverrides(scratch);\n        },\n\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') committed = commitResize();\n            else runBehaviorCancel(scratch.behaviors, scratch.gestureCtx as unknown as GestureContext<Bounds>);\n          } finally {\n            dropPreviewOverrides(scratch);\n            scratch.previews.clear();\n            lifecycle.end(committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  /**\n   * Always enabled at the descriptor level. The dispatcher's\n   * specificity-fallthrough loop treats anything `!== true` as \"skip and\n   * try the next match\" — returning `ActionDisabledReason.SelectionRequired`\n   * here makes the resize binding silently lose to lower-specificity\n   * matches (e.g. ambient `insertAction`), inserting phantom nodes on\n   * every drag instead of resizing. The invoker self-guards on empty\n   * selection (returns `{}`), so a static `true` here is correct.\n   *\n   * Fix: previously `() => ActionDisabledReason.SelectionRequired`\n   * — that broke every dispatcher-routed resize. See git blame.\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":"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"}

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

@@ -0,0 +1,181 @@
+import { dropPreviewOverrides as e, syncPreviewOverrides as t } from "../previewOverrides.js";
+import { gesturePlaneReader as n, gestureViewReader as r } from "../../gestures/shared/screenTolerance.js";
+import { commitGestureOps as i, readGestureLifecycle as a, reduceBehaviorEnd as o, runBehaviorCancel as s } from "../gestureLifecycle.js";
+import { createTransformOp as c } from "../../../core/ops/transform.js";
+import { unionAABB as l } from "../../../core/geometry/unionBounds.js";
+import { poseDescriptorForNode as u, translatePoseViaDescriptor as d, visualBoundsViaDescriptor as f } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as p } from "../poseDescriptorDep.js";
+import { moveGestureAdapter as m } from "../move/gestureAdapter.js";
+import { inPlane as h, selectionLayer as g } from "../planeInput.js";
+import { defaultCommitAdapter as _ } from "../defaultCommitAdapter.js";
+import { scenePoseFrame as v } from "../poseFrame.js";
+import { resolveParams as y } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/rotate.ts
+function b(e, t, n, r, i, a, o) {
+	let s = e.withRotation(t, n + r);
+	if (!o) return s;
+	let c = Math.cos(r), l = Math.sin(r), u = i.x - a.x, f = i.y - a.y, p = a.x + u * c - f * l, m = a.y + u * l + f * c;
+	return d(s, p - i.x, m - i.y, e);
+}
+var x = h({
+	id: "rotate",
+	label: "Rotate",
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps",
+		"poseDescriptor",
+		"poseComposition",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(d, h) {
+			let g = d.deps.selection, x = d.deps.scene, S = d.deps.applyOps, C = y(h?.params), w = h?.behaviors ?? [];
+			if (!g || !x) return {};
+			let T = g.get();
+			if (T.length === 0) return {};
+			let E = p(d.deps.poseDescriptor), D = v(x, d.deps.poseComposition), O = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Map(), M = [];
+			for (let e of T) {
+				let t = x.get(e);
+				if (!t) continue;
+				let n = u(E, t);
+				if (!n.withRotation || n.supportsRotation?.(t.pose) === !1) continue;
+				O.set(e, t.pose);
+				let r = D.world(e);
+				k.set(e, r);
+				let i = n.getBounds(r);
+				A.set(e, {
+					x: i.x + i.width / 2,
+					y: i.y + i.height / 2
+				}), j.set(e, n.getRotation?.(r) ?? 0), M.push(f(r, n));
+			}
+			if (O.size === 0) return {};
+			let N = l(M), P = {
+				x: N.x + N.width / 2,
+				y: N.y + N.height / 2
+			}, F = Math.atan2(d.world.y - P.y, d.world.x - P.x), I = r(d.deps), L = n(d.deps), R = {
+				ids: T,
+				scene: x,
+				descriptor: E,
+				frame: D,
+				originPoses: O,
+				originWorlds: k,
+				originCenters: A,
+				originRotations: j,
+				unionCenter: P,
+				startPointerAngle: F,
+				currentDelta: 0,
+				useUnionPivot: T.length > 1 && C?.pivot !== "each",
+				previews: /* @__PURE__ */ new Map(),
+				overrideEntries: /* @__PURE__ */ new Map(),
+				applyOps: S,
+				lifecycle: a(C, "Rotate", w),
+				behaviors: w,
+				gestureCtx: {
+					draggedIds: [...O.keys()],
+					origin: new Map([...k].map(([e, t]) => [e, t])),
+					current: new Map([...k].map(([e, t]) => [e, t])),
+					snap: null,
+					modifiers: { ...d.modifiers },
+					pointer: {
+						worldX: d.world.x,
+						worldY: d.world.y,
+						clientX: 0,
+						clientY: 0
+					},
+					view: I(),
+					plane: L(),
+					adapter: m(x),
+					scratch: {}
+				}
+			}, { lifecycle: z } = R, B = (e) => {
+				let t = /* @__PURE__ */ new Map();
+				for (let [n, r] of R.originWorlds) t.set(n, b(R.descriptor, r, R.originRotations.get(n) ?? 0, e, R.originCenters.get(n) ?? {
+					x: 0,
+					y: 0
+				}, R.unionCenter, R.useUnionPivot));
+				return t;
+			}, V = (e) => {
+				let t = B(e);
+				for (let [e, n] of t) R.gestureCtx.current.set(e, n);
+				return t;
+			}, H = (e, t) => {
+				let n = R.gestureCtx;
+				n.modifiers = { ...e.modifiers }, n.pointer = {
+					worldX: e.world.x,
+					worldY: e.world.y,
+					clientX: 0,
+					clientY: 0
+				}, n.view = I(), n.plane = L();
+				let r = R.originWorlds.keys().next().value, i = R.originRotations.get(r) ?? 0, a = t, o = {
+					pose: V(t).get(r),
+					rotation: i + t
+				};
+				for (let e of R.behaviors) {
+					let t = e.onMove?.(n, o);
+					if (!t || t.pose === void 0) continue;
+					let r = R.descriptor.getRotation?.(t.pose) ?? 0;
+					a = r - i, o = {
+						pose: t.pose,
+						rotation: r
+					};
+				}
+				return a;
+			}, U = () => {
+				let e = {
+					scene: x,
+					applyOps: R.applyOps,
+					adapter: _(x, g.adapterMethods)
+				};
+				if (R.behaviors.length > 0) {
+					V(R.currentDelta);
+					let t = o(R.behaviors, R.gestureCtx);
+					if (t === null) return !1;
+					if (t !== void 0) return i(e, z, t), !0;
+				}
+				if (R.currentDelta === 0) return !1;
+				let t = [];
+				for (let e of R.ids) {
+					let n = R.previews.get(e);
+					if (n === void 0) continue;
+					let r = R.originPoses.get(e);
+					r !== void 0 && t.push(c({
+						id: e,
+						from: r,
+						to: n,
+						label: z.label
+					}));
+				}
+				return t.length !== 0 && (i(e, z, t), !0);
+			}, W = (e) => {
+				if (R.previews.clear(), e !== 0) for (let [t, n] of B(e)) R.previews.set(t, R.frame.local(t, n));
+				t(R);
+			};
+			for (let e of w) e.onStart?.(R.gestureCtx);
+			return z.start(R.gestureCtx.draggedIds), {
+				kind: "rotate",
+				onMove(e) {
+					let t = Math.atan2(e.world.y - R.unionCenter.y, e.world.x - R.unionCenter.x) - R.startPointerAngle;
+					R.currentDelta = R.behaviors.length > 0 ? H(e, t) : t, W(R.currentDelta);
+				},
+				onEnd(t, n) {
+					let r = !1;
+					try {
+						n === "commit" ? r = U() : s(R.behaviors, R.gestureCtx);
+					} finally {
+						e(R), R.previews.clear(), z.end(r);
+					}
+				},
+				previewIds: () => R.previews.keys(),
+				previewPose: (e) => R.previews.get(e) ?? null
+			};
+		}
+	},
+	enabled: () => !0
+}, g);
+//#endregion
+export { x as rotateAction };
+
+//# sourceMappingURL=rotate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rotate.js","names":["applyRotationDelta","rotated","d","pose","originRotation","delta","useUnionPivot","cos","sin","ox","originCenter","unionCenter","oy","nx","ny","translatePoseViaDescriptor","rotateAction","inPlane","selection","ctx","scene","applyOps","params","resolveParams","opts","behaviors","ids","descriptor","poseDescriptorOf","frame","scenePoseFrame","originPoses","originWorlds","originCenters","originRotations","visual","id","node","g","poseDescriptorForNode","world","b","visualBoundsViaDescriptor","union","unionAABB","startPointerAngle","readView","gestureViewReader","readPlane","gesturePlaneReader","scratch","\"pivot\"","readGestureLifecycle","p","moveGestureAdapter","turnedWorlds","out","origin","syncGestureCurrent","turned","shapeDelta","gctx","moveCtx","primary","raw","proposed","r","rotation","commitRotate","target","defaultCommitAdapter","reduceBehaviorEnd","commitGestureOps","lifecycle","ops","next","from","createTransformOp","recomputePreviews","committed","reason","runBehaviorCancel","dropPreviewOverrides","selectionLayer"],"sources":["../../../../src/interactions/actions/defaults/rotate.ts"],"sourcesContent":["/**\n * `rotateAction` — ongoing Action descriptor for pointer-driven rotation.\n *\n * ## Status: REAL (unrotated-pivot path)\n *\n * Implements the core rotation math from `useRotate`:\n *   - `start`: captures origin poses + AABB centers; computes start pointer\n *     angle around the union center of selected nodes.\n *   - `onMove`: derives pointer angle delta from start, applies to each node's\n *     origin rotation. In union-pivot mode (multi-selection) orbits each item's\n *     center around the union center.\n *   - `onEnd('commit')`: builds one `createTransformOp` per node (from =\n *     pre-mutation origin pose, to = rotated pose) and commits them as a\n *     single batch → one undo entry for the whole drag. Routes through the\n *     optional `applyOps` dep (consumer history) when present, else\n *     `scene.applyBatch` + `defaultCommitAdapter`.\n *   - `onEnd('cancel')`: no scene writes (scene never mutated during drag).\n *\n * ## Constraints vs `useRotate`\n *\n * - Reads and writes poses through the `poseDescriptor` dep; a pose whose\n *   descriptor has no `withRotation`, or reports `supportsRotation` false, is\n *   left alone.\n * - Behaviors (`opts.behaviors`) see the first rotated node's turned pose; a\n *   pose one returns from `onMove` sets the rotation for the whole selection.\n * - No overlay rendering — deferred to Phase 7 overlay surface.\n * - Shift-snap (15° quantum) is NOT wired in this phase — omitted deliberately\n *   to keep the invoker self-contained (would need to read shift from onMove ctx).\n *   TODO: thread shift from InvocationCtx.modifiers.shift into snap logic.\n */\n\nimport { gesturePlaneReader, gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { syncPreviewOverrides, dropPreviewOverrides } from '../previewOverrides';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from '../resize/geometry';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel, type GestureLifecycle } from '../gestureLifecycle';\nimport { moveGestureAdapter } from '../move/gestureAdapter';\nimport type { GestureContext, RotateBehavior, RotateProposed } from '../../gestures/types';\nimport { inPlane, selectionLayer } from '../planeInput';\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/** Apply a rotation delta (radians) to a pose, optionally orbiting the item's\n *  center around a shared union center. */\nfunction applyRotationDelta(\n  d: PoseDescriptor<unknown>,\n  pose: unknown,\n  originRotation: number,\n  delta: number,\n  originCenter: { x: number; y: number },\n  unionCenter: { x: number; y: number },\n  useUnionPivot: boolean,\n): unknown {\n  const rotated = d.withRotation!(pose, originRotation + delta);\n  if (!useUnionPivot) return rotated;\n  const cos = Math.cos(delta);\n  const sin = Math.sin(delta);\n  const ox = originCenter.x - unionCenter.x;\n  const oy = originCenter.y - unionCenter.y;\n  const nx = unionCenter.x + ox * cos - oy * sin;\n  const ny = unionCenter.y + ox * sin + oy * cos;\n  return translatePoseViaDescriptor(rotated, nx - originCenter.x, ny - originCenter.y, d);\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface RotateScratch {\n  ids: NodeId[];\n  scene: Scene<unknown, string, unknown>;\n  descriptor: PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  frame: PoseFrame<unknown>;\n  /** Origin pose for each selected node as stored — the `from` of its op. */\n  originPoses: Map<NodeId, unknown>;\n  /** Origin pose for each selected node in world — what the gesture turns. */\n  originWorlds: Map<NodeId, unknown>;\n  /** AABB center for each selected node (from origin pose). */\n  originCenters: Map<NodeId, { x: number; y: number }>;\n  /** Per-node origin rotation (radians). */\n  originRotations: Map<NodeId, number>;\n  /** Union center of all selected nodes — the rotation pivot. */\n  unionCenter: { x: number; y: number };\n  /** Pointer angle around unionCenter at drag start. */\n  startPointerAngle: number;\n  /** Running delta — updated each onMove, applied once at commit. */\n  currentDelta: number;\n  /** Use union pivot (multi-select) vs each item's own center. */\n  useUnionPivot: boolean;\n  /** In-flight preview poses keyed by node id. */\n  previews: Map<NodeId, unknown>;\n  overrideEntries: Map<NodeId, { pose: unknown }>;\n  /** Optional consumer commit hook captured at gesture start. When present,\n   *  ops-based commits route through it (consumer history) instead of\n   *  `scene.applyBatch`. Undefined → fall back to `scene.applyBatch`. */\n  applyOps?: (ops: Op[], label: string) => void;\n  lifecycle: GestureLifecycle;\n  behaviors: RotateBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors across the drag. */\n  gestureCtx: GestureContext<unknown>;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `rotate` Action.\n *\n * Requires dep-schema entries: `selection`, `scene`.\n *\n * Implements the unrotated-pivot rotation path from `useRotate`.\n *\n * @see useRotate — the React hook this descriptor mirrors for the rect case.\n */\nexport const rotateAction: Action & { requires: string[] } = inPlane({\n  id: 'rotate',\n  label: 'Rotate',\n  // No default binding. It used to be a bare `{ kind: 'drag' }`, which made\n  // any drag no active tool claimed rotate a non-empty selection. The rotation\n  // handle binds it (`selectionTransformBindings`, the `transform` preset).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'applyOps', 'poseDescriptor', 'poseComposition', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts): OngoingHandle {\n      const selection = ctx.deps.selection as SelectionApi | undefined;\n      const scene = ctx.deps.scene as Scene<unknown, string, unknown> | undefined;\n      const applyOps = ctx.deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n      const params = resolveParams(opts?.params);\n      const behaviors = (opts?.behaviors ?? []) as RotateBehavior<unknown>[];\n\n      if (!selection || !scene) return {};\n\n      const ids = selection.get() as NodeId[];\n      if (ids.length === 0) return {};\n\n      const descriptor = poseDescriptorOf(ctx.deps.poseDescriptor);\n      // The pivot the pointer orbits is a world point, so every pose the\n      // gesture turns is a world pose. Each turned result is stored back in\n      // the node's own parent frame at preview and commit alike.\n      const frame = scenePoseFrame(scene, ctx.deps.poseComposition);\n      const originPoses = new Map<NodeId, unknown>();\n      const originWorlds = new Map<NodeId, unknown>();\n      const originCenters = new Map<NodeId, { x: number; y: number }>();\n      const originRotations = new Map<NodeId, number>();\n      const visual: Bounds[] = [];\n\n      for (const id of ids) {\n        const node = scene.get(id);\n        if (!node) continue;\n        const g = poseDescriptorForNode(descriptor, node);\n        if (!g.withRotation || g.supportsRotation?.(node.pose) === false) continue;\n        originPoses.set(id, node.pose);\n        // The pivot is a world point, so every measurement the gesture orbits\n        // is taken from the world pose, not the stored one.\n        const world = frame.world(id);\n        originWorlds.set(id, world);\n        const b = g.getBounds(world);\n        originCenters.set(id, { x: b.x + b.width / 2, y: b.y + b.height / 2 });\n        originRotations.set(id, g.getRotation?.(world) ?? 0);\n        visual.push(visualBoundsViaDescriptor(world, g));\n      }\n\n      if (originPoses.size === 0) return {};\n\n      const union = unionAABB(visual)!;\n      const unionCenter = { x: union.x + union.width / 2, y: union.y + union.height / 2 };\n      const startPointerAngle = Math.atan2(\n        ctx.world.y - unionCenter.y,\n        ctx.world.x - unionCenter.x,\n      );\n\n      const readView = gestureViewReader(ctx.deps);\n\n      const readPlane = gesturePlaneReader(ctx.deps);\n      const scratch: RotateScratch = {\n        ids,\n        scene,\n        descriptor,\n        frame,\n        originPoses,\n        originWorlds,\n        originCenters,\n        originRotations,\n        unionCenter,\n        startPointerAngle,\n        currentDelta: 0,\n        useUnionPivot: ids.length > 1 && params?.['pivot'] !== 'each',\n        previews: new Map<NodeId, unknown>(),\n        overrideEntries: new Map<NodeId, { pose: unknown }>(),\n        applyOps,\n        lifecycle: readGestureLifecycle(params, 'Rotate', behaviors),\n        behaviors,\n        gestureCtx: {\n          draggedIds: [...originPoses.keys()] as string[],\n          origin: new Map([...originWorlds].map(([id, p]) => [id as string, p])),\n          current: new Map([...originWorlds].map(([id, p]) => [id as string, p])),\n          snap: null,\n          modifiers: { ...ctx.modifiers },\n          pointer: { worldX: ctx.world.x, worldY: ctx.world.y, clientX: 0, clientY: 0 },\n          view: readView(),\n          plane: readPlane(),\n          adapter: moveGestureAdapter(scene) as unknown as GestureContext<unknown>['adapter'],\n          scratch: {},\n        },\n      };\n      const { lifecycle } = scratch;\n\n      /** Each rotated node's world pose turned by `delta`. */\n      const turnedWorlds = (delta: number): Map<NodeId, unknown> => {\n        const out = new Map<NodeId, unknown>();\n        for (const [id, origin] of scratch.originWorlds) {\n          out.set(id, applyRotationDelta(\n            scratch.descriptor,\n            origin,\n            scratch.originRotations.get(id) ?? 0,\n            delta,\n            scratch.originCenters.get(id) ?? { x: 0, y: 0 },\n            scratch.unionCenter,\n            scratch.useUnionPivot,\n          ));\n        }\n        return out;\n      };\n\n      const syncGestureCurrent = (delta: number): Map<NodeId, unknown> => {\n        const turned = turnedWorlds(delta);\n        for (const [id, pose] of turned) scratch.gestureCtx.current.set(id as string, pose);\n        return turned;\n      };\n\n      /** The pointer's delta as the behaviors reshape it. */\n      const shapeDelta = (moveCtx: InvocationCtx, raw: number): number => {\n        const gctx = scratch.gestureCtx;\n        gctx.modifiers = { ...moveCtx.modifiers };\n        gctx.pointer = { worldX: moveCtx.world.x, worldY: moveCtx.world.y, clientX: 0, clientY: 0 };\n        gctx.view = readView();\n        gctx.plane = readPlane();\n        const primary = scratch.originWorlds.keys().next().value as NodeId;\n        const originRotation = scratch.originRotations.get(primary) ?? 0;\n        let delta = raw;\n        let proposed: RotateProposed<unknown> = {\n          pose: syncGestureCurrent(raw).get(primary),\n          rotation: originRotation + raw,\n        };\n        for (const b of scratch.behaviors) {\n          const r = b.onMove?.(gctx, proposed);\n          if (!r || r.pose === undefined) continue;\n          const rotation = scratch.descriptor.getRotation?.(r.pose) ?? 0;\n          delta = rotation - originRotation;\n          proposed = { pose: r.pose, rotation };\n        }\n        return delta;\n      };\n\n      // Returns whether anything reached the document.\n      const commitRotate = (): boolean => {\n        const target = {\n          scene,\n          applyOps: scratch.applyOps,\n          adapter: defaultCommitAdapter(scene, selection.adapterMethods),\n        };\n        if (scratch.behaviors.length > 0) {\n          syncGestureCurrent(scratch.currentDelta);\n          const r = reduceBehaviorEnd(scratch.behaviors, scratch.gestureCtx);\n          if (r === null) return false;\n          if (r !== undefined) {\n            commitGestureOps(target, lifecycle, r);\n            return true;\n          }\n        }\n        if (scratch.currentDelta === 0) return false;\n        // One transform op per node: `from` is the origin pose captured at drag\n        // start, `to` the rotated preview. A single batch, so one undo entry.\n        const ops: Op[] = [];\n        for (const id of scratch.ids) {\n          const next = scratch.previews.get(id);\n          if (next === undefined) continue;\n          const from = scratch.originPoses.get(id);\n          if (from === undefined) continue;\n          ops.push(createTransformOp<unknown>({\n            id: id as string,\n            from,\n            to: next,\n            label: lifecycle.label,\n          }));\n        }\n        if (ops.length === 0) return false;\n        commitGestureOps(target, lifecycle, ops);\n        return true;\n      };\n\n      const recomputePreviews = (delta: number) => {\n        scratch.previews.clear();\n        if (delta !== 0) {\n          for (const [id, turned] of turnedWorlds(delta)) {\n            scratch.previews.set(id, scratch.frame.local(id, turned));\n          }\n        }\n        syncPreviewOverrides(scratch);\n      };\n\n      for (const b of behaviors) b.onStart?.(scratch.gestureCtx);\n      lifecycle.start(scratch.gestureCtx.draggedIds);\n\n      return {\n        kind: 'rotate',\n        onMove(moveCtx: InvocationCtx): void {\n          const pointerAngle = Math.atan2(\n            moveCtx.world.y - scratch.unionCenter.y,\n            moveCtx.world.x - scratch.unionCenter.x,\n          );\n          const raw = pointerAngle - scratch.startPointerAngle;\n          scratch.currentDelta = scratch.behaviors.length > 0 ? shapeDelta(moveCtx, raw) : raw;\n          recomputePreviews(scratch.currentDelta);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') committed = commitRotate();\n            else runBehaviorCancel(scratch.behaviors, scratch.gestureCtx);\n          } finally {\n            dropPreviewOverrides(scratch);\n            scratch.previews.clear();\n            lifecycle.end(committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":"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"}