@weasel-js/core 1.6.1 → 1.7.1

package/dist/features/selection/overlay.js

@@ -0,0 +1,442 @@
+import { mat3 as e } from "../../renderer/math/mat3.js";
+import { resolveStrokeWidth as t } from "../paths/tessellate/stroke.js";
+import { viewToTransform as n } from "../../core/viewport/view.js";
+import { poseRotationOf as r } from "../../core/geometry/poseRotation.js";
+import { worldToScreen as i } from "../../core/viewport/viewTransform.js";
+import { screenAngleOf as a } from "../../core/viewport/pxExtent.js";
+import { HANDLE_BASE_PX as o } from "../../core/device/targets.js";
+import { unionAABB as s } from "../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor as c } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as l } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { rectCorners as u, rotatePoint as d } from "../../interactions/actions/rotate/geometry.js";
+import { MULTI_RESIZE_TARGET_ID as f } from "../../core/selection/selectionTarget.js";
+import { DEFAULT_ROTATION_HANDLE_DISTANCE as p, rotationHandle as m } from "../../interactions/actions/rotate/handle.js";
+import { alignedStrokeRect as h } from "@weasel-js/paint";
+import { PATH_L as g, PATH_M as _, PATH_Z as v } from "@weasel-js/geom";
+//#region src/features/selection/overlay.ts
+function y(e, t) {
+	let r = n(t), [a, o] = i(e.x, e.y, r);
+	return {
+		...e,
+		x: a,
+		y: o,
+		width: e.width * t.scale.x,
+		height: e.height * t.scale.y
+	};
+}
+function b(e, t, n) {
+	if (!n(e)) return [e];
+	let r = [], i = (e) => {
+		let a = t(e);
+		if (a.length === 0) {
+			n(e) || r.push(e);
+			return;
+		}
+		for (let e of a) i(e);
+	};
+	return i(e), r;
+}
+function x(e) {
+	let { moveOverlay: t, resizeOverlay: n, getStoredPose: r, getChildren: i, isContainer: a } = e, o = e.poseDescriptor ?? l, u = (e) => i && a ? b(e, i, a) : [e], d = (e) => {
+		let i = t?.poses.get(e);
+		return i === void 0 ? n && n.id === e ? n.currentPose : r(e) : i;
+	};
+	return (e) => {
+		if (a?.(e)) {
+			let i = u(e);
+			if (i.length === 0) return null;
+			let a = n && n.id === e ? n.leafPoses : void 0, l = [];
+			for (let e of i) {
+				let n = t?.poses.get(e);
+				if (n !== void 0) {
+					l.push(c(n, o));
+					continue;
+				}
+				let i = a?.get(e);
+				if (i !== void 0) {
+					l.push(c(i, o));
+					continue;
+				}
+				l.push(c(r(e), o));
+			}
+			let d = s(l);
+			return d === null ? null : o.fromBounds(d, r(i[0]));
+		}
+		return d(e);
+	};
+}
+function S(e, t, n, r) {
+	let i = (e) => {
+		let n = t.getBounds(e), r = t.getRotation?.(e);
+		return r ? {
+			...n,
+			rotation: r
+		} : n;
+	};
+	return n === void 0 || r === void 0 ? (t) => {
+		let n = e(t);
+		return n === null ? null : i(n);
+	} : (a) => {
+		if (!r(a)) {
+			let t = e(a);
+			return t === null ? null : i(t);
+		}
+		let o = b(a, n, r);
+		if (o.length === 0) return null;
+		let l = [];
+		for (let n of o) {
+			let r = e(n);
+			r !== null && l.push(c(r, t));
+		}
+		return l.length === 0 ? null : s(l);
+	};
+}
+var C = {
+	paint: {
+		fill: "solid",
+		color: "#f0e0a8"
+	},
+	width: 2,
+	pad: 1
+}, w = {
+	fill: "solid",
+	color: "#d4c4a8"
+}, T = {
+	paint: {
+		fill: "solid",
+		color: "#1a130d"
+	},
+	width: 1
+}, E = o;
+function D(e) {
+	return [
+		{
+			x: e.x,
+			y: e.y
+		},
+		{
+			x: e.x + e.width,
+			y: e.y
+		},
+		{
+			x: e.x,
+			y: e.y + e.height
+		},
+		{
+			x: e.x + e.width,
+			y: e.y + e.height
+		}
+	];
+}
+function O(e) {
+	return e ? {
+		stroke: {
+			paint: e.paint,
+			width: e.width ?? C.width,
+			dash: e.dash,
+			cap: e.cap,
+			join: e.join,
+			align: e.align
+		},
+		pad: e.pad ?? C.pad
+	} : {
+		stroke: {
+			paint: C.paint,
+			width: C.width
+		},
+		pad: C.pad
+	};
+}
+function k(e) {
+	return {
+		size: e?.size ?? E,
+		fill: e?.fill ?? w,
+		outline: e?.outline ?? T
+	};
+}
+function A(e, t, n) {
+	let r = Math.cos(n), i = Math.sin(n), a = e - r * e + i * t, o = t - i * e - r * t;
+	return new Float32Array([
+		r,
+		i,
+		0,
+		-i,
+		r,
+		0,
+		a,
+		o,
+		1
+	]);
+}
+function j(e, t, n, r) {
+	return {
+		kind: "rect",
+		x: e,
+		y: t,
+		width: n,
+		height: r
+	};
+}
+function M(e, n, i, a, o) {
+	let s = [], c = i.align ?? "center", l = t(i.width ?? 1, 1);
+	for (let t of e) {
+		let e = n(t);
+		if (!e) continue;
+		let u = y(e, o), d = {
+			x: u.x - a,
+			y: u.y - a,
+			width: u.width + a * 2,
+			height: u.height + a * 2
+		}, f = r(e);
+		if (!f) {
+			let e = h(d, c, l);
+			s.push({
+				kind: "path",
+				path: j(e.x, e.y, e.width, e.height),
+				stroke: i
+			});
+			continue;
+		}
+		let p = N(e, f, o, a + (c === "outer" ? l / 2 : c === "inner" ? -l / 2 : 0));
+		s.push({
+			kind: "path",
+			path: {
+				kind: "polygon",
+				commands: new Uint8Array([
+					_,
+					g,
+					g,
+					g,
+					v
+				]),
+				coords: new Float32Array([
+					p[0].x,
+					p[0].y,
+					p[1].x,
+					p[1].y,
+					p[2].x,
+					p[2].y,
+					p[3].x,
+					p[3].y
+				]),
+				fillRule: "nonzero"
+			},
+			stroke: {
+				...i,
+				align: "center"
+			}
+		});
+	}
+	return s;
+}
+function N(e, t, r, a) {
+	let o = n(r), s = u(e).map((e) => {
+		let n = d(e.x, e.y, t.cx, t.cy, t.rotation), [r, a] = i(n.x, n.y, o);
+		return {
+			x: r,
+			y: a
+		};
+	});
+	if (a === 0) return s;
+	let [c, l] = i(t.cx, t.cy, o), f = (e, t) => {
+		let n = -(t.y - e.y), r = t.x - e.x, i = Math.hypot(n, r) || 1;
+		n /= i, r /= i;
+		let a = (e.x + t.x) / 2 - c, o = (e.y + t.y) / 2 - l;
+		return n * a + r * o < 0 ? {
+			x: -n,
+			y: -r
+		} : {
+			x: n,
+			y: r
+		};
+	};
+	return s.map((e, t) => {
+		let n = f(s[(t + 3) % 4], e), r = f(e, s[(t + 1) % 4]), i = a / (1 + n.x * r.x + n.y * r.y);
+		return {
+			x: e.x + (n.x + r.x) * i,
+			y: e.y + (n.y + r.y) * i
+		};
+	});
+}
+function P(e, o, s, c, l) {
+	let u = [], f = s.size / 2, p = s.outline.align ?? "center", m = t(s.outline.width ?? 1, 1);
+	for (let t of e) {
+		let e = o(t);
+		if (!e) continue;
+		let g = r(e), _ = n(l), v = g ? a(g.rotation, l.scale) : 0;
+		for (let t of c(e)) {
+			let e = g ? d(t.x, t.y, g.cx, g.cy, g.rotation) : t, [n, r] = i(e.x, e.y, _), a = {
+				x: n,
+				y: r
+			}, o = {
+				x: a.x - f,
+				y: a.y - f,
+				width: s.size,
+				height: s.size
+			}, c = h(o, p, m), l = {
+				kind: "path",
+				path: j(o.x, o.y, o.width, o.height),
+				fill: s.fill
+			}, y = {
+				kind: "path",
+				path: j(c.x, c.y, c.width, c.height),
+				stroke: s.outline
+			};
+			g ? u.push({
+				kind: "group",
+				transform: A(a.x, a.y, v),
+				children: [l, y]
+			}) : u.push(l, y);
+		}
+	}
+	return u;
+}
+function F(r, a, o, s) {
+	let c = m(r, o, s.scale), l = c.angle, u = n(s), [d, f] = i(c.cx, c.cy, u), p = a.size, h = p, v = Math.PI * 240 / 360 / 2, y = t(a.outline.width ?? 1, 1) * 1.5, b = {
+		paint: a.fill,
+		width: y,
+		cap: "round",
+		join: "round"
+	}, x = [_], S = [], C = [];
+	for (let e = 0; e <= 18; e++) {
+		let t = v - e / 18 * v * 2;
+		S.push(h * Math.sin(t)), C.push(-h * Math.cos(t)), e > 0 && x.push(g);
+	}
+	let w = [];
+	for (let e = 0; e < S.length; e++) w.push(S[e], C[e]);
+	let T = {
+		kind: "polygon",
+		commands: new Uint8Array(x),
+		coords: new Float32Array(w),
+		fillRule: "nonzero"
+	}, E = p * .6, D = p * .4, O = (e, t, n, r) => {
+		let i = Math.hypot(n, r) || 1, a = n / i, o = r / i, s = -o, c = a, l = e + a * E, u = t + o * E, d = e + D / 2 * s, f = t + D / 2 * c, p = e - D / 2 * s, m = t - D / 2 * c;
+		return {
+			kind: "polygon",
+			commands: new Uint8Array([
+				_,
+				g,
+				g,
+				g
+			]),
+			coords: new Float32Array([
+				l,
+				u,
+				d,
+				f,
+				p,
+				m,
+				l,
+				u
+			]),
+			fillRule: "nonzero"
+		};
+	}, k = v, A = h * Math.sin(k), j = -h * Math.cos(k), M = Math.cos(k), N = Math.sin(k), P = -v, F = h * Math.sin(P), I = -h * Math.cos(P), L = -Math.cos(P), R = -Math.sin(P), z = O(A, j, M, N), B = O(F, I, L, R), V = a.fill, H = e.translated(e.identity(), d, f);
+	if (l !== 0) {
+		let t = Math.cos(l), n = Math.sin(l), r = new Float32Array([
+			t,
+			n,
+			0,
+			-n,
+			t,
+			0,
+			0,
+			0,
+			1
+		]);
+		H = e.multiply(H, r);
+	}
+	return [{
+		kind: "group",
+		transform: H,
+		children: [
+			{
+				kind: "path",
+				path: T,
+				stroke: b
+			},
+			{
+				kind: "path",
+				path: z,
+				fill: V
+			},
+			{
+				kind: "path",
+				path: B,
+				fill: V
+			}
+		]
+	}];
+}
+function I(e, t) {
+	let { stroke: n, pad: r } = O(e.outline), i = t.handles && e.handles !== !1 ? k(e.handles || void 0) : null, a = e.handlesOf ?? D, o = e.poseDescriptor ?? l, s = e.getPose, c = s ? S(s, o, e.getChildren, e.isContainer) : null, u = t.handles ? L(e)?.distancePx ?? null : null;
+	return {
+		id: t.id,
+		label: t.label,
+		space: "screen",
+		draw: (o, s) => {
+			let l = U(o), d = e.getSelection ? e.getSelection() : H(l);
+			if (d.length === 0) return [];
+			let p = e.getSuppressedIds?.(), m = p && p.size > 0 ? d.filter((e) => !p.has(e)) : d;
+			if (m.length === 0) return [];
+			let h = V(o), g = t.outline && (!h || h("selection.outline")), _ = !h || h("selection.resize-handles"), v = !h || h("selection.rotation-handle"), y = c ?? ((e) => l?.boundsOf(e) ?? null), b = (e) => e === f && l?.unionBounds != null ? l.unionBounds : y(e), x = [];
+			if (g) {
+				let t = e.getOutlineIds ? e.getOutlineIds() : e.getSelection ? m : l?.selection ?? m, i = p && p.size > 0 ? t.filter((e) => !p.has(e)) : t;
+				for (let e of M(i, b, n, r, s)) x.push(e);
+			}
+			if (!i) return x;
+			if (_) for (let e of P(m, b, i, a, s)) x.push(e);
+			if (v && u !== null) for (let e of m) {
+				let t = b(e);
+				if (t) for (let e of F(t, i, u, s)) x.push(e);
+			}
+			return x;
+		}
+	};
+}
+function L(e) {
+	let t = e.rotationHandle;
+	return !t || e.handles === !1 ? null : {
+		distancePx: t === !0 ? p : t.distance ?? p,
+		sizePx: k(e.handles || void 0).size
+	};
+}
+function R(e) {
+	return I(e, {
+		id: "selection-outline",
+		label: "Selection outline",
+		outline: !0,
+		handles: !1
+	});
+}
+function z(e) {
+	return I(e, {
+		id: "selection-handles",
+		label: "Selection handles",
+		outline: !1,
+		handles: !0
+	});
+}
+function B(e) {
+	return I(e, {
+		id: "selection-overlay",
+		label: "Selection",
+		outline: !0,
+		handles: !0
+	});
+}
+function V(e) {
+	let t = e;
+	return typeof t?.getIsVisible == "function" ? t.getIsVisible() : null;
+}
+function H(e) {
+	return e ? e.multiActive ? [f] : e.selection : [];
+}
+function U(e) {
+	let t = e;
+	return typeof t?.getChromeState == "function" ? t.getChromeState() : null;
+}
+//#endregion
+export { x as composeSelectionPose, z as createSelectionHandlesLayer, R as createSelectionOutlineLayer, B as createSelectionOverlayLayer, L as rotationBadgeOf };
+
+//# sourceMappingURL=overlay.js.map

package/dist/features/selection/overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.js","names":["projectBounds","t","viewToTransform","view","sx","sy","worldToScreen","b","leavesOf","isContainer","id","out","visit","kids","getChildren","nid","k","composeSelectionPose","opts","d","AUTO_POSE_DESCRIPTOR","selectionLeaves","resolveLeaf","moved","moveOverlay","resizeOverlay","getStoredPose","leaves","containerResizeLeafPoses","leafBounds","leafId","visualBoundsViaDescriptor","overlayLeaf","u","unionAABB","makeContainerAwareBoundsResolver","oriented","p","getPose","DEFAULT_OUTLINE","DEFAULT_HANDLE_FILL","DEFAULT_HANDLE_OUTLINE","DEFAULT_HANDLE_SIZE","HANDLE_BASE_PX","defaultHandlesOf","resolveOutlineStroke","resolveHandles","rotateAroundMat3","c","theta","s","tx","cx","cy","ty","rectPathFor","outlineCommandsFor","align","stroke","width","resolveStrokeWidth","ids","worldB","resolveBounds","padded","pad","rot","poseRotationOf","r","alignedStrokeRect","q","screenCorners","PATH_M","PATH_L","PATH_Z","rectCorners","w","rotatePoint","x","y","ccx","ccy","normal","nx","a","ny","l","mx","my","n1","i","n2","handleCommandsFor","half","handles","handleAlign","handleWidth","angle","screenAngleOf","hLocal","handlesOf","hWorld","hsx","hsy","center","baseRect","sr","fillCmd","strokeCmd","rotationHandleCommands","rotationHandle","distance","rotation","scx","scy","size","arcRadius","ARC_HALF_ANGLE","arcWidth","cmds","xs","ys","arcCoords","arcPath","headLen","headWidth","arrowHead","len","ux","uy","px","py","tipX","endX","tipY","endY","baseLeftX","baseLeftY","baseRightX","baseRightY","angleA","endAX","endAY","tangentAX","tangentAY","angleB","endBX","endBY","tangentBX","tangentBY","headA","headB","headFill","transform","mat3","buildSelectionLayer","passes","poseBounds","rotationHandleDistance","rotationBadgeOf","chromeState","asChromeState","data","allIds","chromeSelectionIds","suppressed","isVisible","asIsVisible","showOutline","showHandles","showRotation","resolveTargetBounds","MULTI_RESIZE_TARGET_ID","outlineIdsRaw","outlineIds","cmd","DEFAULT_ROTATION_HANDLE_DISTANCE","createSelectionOutlineLayer","createSelectionHandlesLayer","createSelectionOverlayLayer","maybe","state"],"sources":["../../../src/features/selection/overlay.ts"],"sourcesContent":["/**\n * Selection overlay primitives — render layers for drawing selection\n * outlines and corner resize handles in world space.\n *\n * Three pieces:\n *   - `composeSelectionPose` resolves the live pose for a selected id by\n *     consulting the move overlay first, then the resize overlay, then the\n *     stored pose. When `getChildren`/`isContainer` are supplied and the id\n *     resolves to a container, the returned pose is the union AABB of all\n *     transitive leaf poses (with the same precedence rules applied per leaf).\n *   - `createSelectionOutlineLayer` draws the outline rect for each selected\n *     id (container ids resolve to a union AABB via `getChildren`/`isContainer`).\n *   - `createSelectionHandlesLayer` draws resize-handle rects (default 4\n *     corners) for each selected id, with the same container-resolution rules.\n *\n * `createSelectionOverlayLayer` is a thin convenience that returns a single\n * `RenderLayer` whose draw runs the outline pass then the handles pass.\n *\n * **Pose shape:** TPose is generic; callers pass `poseDescriptor` for poses\n * `AUTO_POSE_DESCRIPTOR` can't read. Container ids reduce via `unionAABB`\n * over the projected AABBs.\n */\n\nimport type { DrawCommand } from '../../renderer';\nimport { mat3, type GlMat3 } from '../../renderer';\nimport type { NodeId } from 'core/scene/types';\nimport type { RenderLayer } from 'core/layers/render';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport {\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { alignedStrokeRect, type FillStyle, type Stroke } from '@weasel-js/paint';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport {\n  rotationHandle,\n  DEFAULT_ROTATION_HANDLE_DISTANCE,\n} from 'interactions/actions/rotate/handle';\nimport { rectCorners, rotatePoint } from 'interactions/actions/rotate/geometry';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport type { View } from 'core/viewport/view';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { screenAngleOf } from 'core/viewport/pxExtent';\nimport { PATH_L, PATH_M, PATH_Z, type PolygonPath } from '@weasel-js/geom';\nimport { HANDLE_BASE_PX } from 'core/device/targets';\n\n/** Project world AABB into screen-space AABB using the active view. */\nfunction projectBounds<B extends Bounds>(b: B, view: View): B {\n  const t = viewToTransform(view);\n  const [sx, sy] = worldToScreen(b.x, b.y, t);\n  return { ...b, x: sx, y: sy, width: b.width * view.scale.x, height: b.height * view.scale.y };\n}\n\n\n/**\n * Transitive leaf ids under `id`. A childless node is a leaf only if it is not\n * itself a container: an empty container contributes no bounds, and its own\n * stored pose is at its most stale when no children are left to have moved it.\n */\nfunction leavesOf(\n  id: string,\n  getChildren: (id: string) => readonly string[],\n  isContainer: (id: string) => boolean,\n): string[] {\n  if (!isContainer(id)) return [id];\n  const out: string[] = [];\n  const visit = (nid: string) => {\n    const kids = getChildren(nid);\n    if (kids.length === 0) { if (!isContainer(nid)) out.push(nid); return; }\n    for (const k of kids) visit(k);\n  };\n  visit(id);\n  return out;\n}\n\n/** Options for `composeSelectionPose`. */\nexport interface ComposeSelectionPoseOpts<TPose> {\n  /** Move overlay; when present its `poses` map wins over everything else. */\n  moveOverlay?: { poses: Map<string, TPose> } | null;\n  /**\n   * Resize overlay; consulted only when move overlay does not own the id.\n   * For container resize, `leafPoses` (when present) maps each leaf id under\n   * the container to its overlay pose. If absent the container falls back to\n   * stored leaf poses (defensive — container-resize integration is in flight).\n   */\n  resizeOverlay?: {\n    id: string;\n    currentPose: TPose;\n    leafPoses?: Map<string, TPose>;\n  } | null;\n  /** Fallback pose lookup (typically the stored/committed pose). */\n  getStoredPose: (id: string) => TPose;\n  /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Walk a container's direct children (e.g. `scene.childrenOf`). With\n   *  `isContainer`, a selected container resolves to the union AABB of its\n   *  transitive leaf poses instead of its own stored pose. */\n  getChildren?: (id: string) => readonly string[];\n  /** True when `id` is a structural container. */\n  isContainer?: (id: string) => boolean;\n}\n\n/**\n * Build a pose resolver for a selection. Precedence per id:\n * move overlay > resize overlay > stored. When `getChildren`/`isContainer`\n * are supplied and the id resolves to a container, the resolver returns the\n * union AABB of all transitive leaf poses (each leaf still subject to the\n * precedence rules). Containers with no leaves resolve to `null`.\n */\nexport function composeSelectionPose<TPose>(\n  opts: ComposeSelectionPoseOpts<TPose>,\n): (id: string) => TPose | null {\n  const { moveOverlay, resizeOverlay, getStoredPose, getChildren, isContainer } = opts;\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const selectionLeaves = (id: string): string[] =>\n    getChildren && isContainer ? leavesOf(id, getChildren, isContainer) : [id];\n\n  const resolveLeaf = (id: string): TPose => {\n    const moved = moveOverlay?.poses.get(id);\n    if (moved !== undefined) return moved;\n    if (resizeOverlay && resizeOverlay.id === id) return resizeOverlay.currentPose;\n    return getStoredPose(id);\n  };\n\n  return (id: string): TPose | null => {\n    if (isContainer?.(id)) {\n      const leaves = selectionLeaves(id);\n      if (leaves.length === 0) return null;\n      const containerResizeLeafPoses =\n        resizeOverlay && resizeOverlay.id === id ? resizeOverlay.leafPoses : undefined;\n      const leafBounds: Bounds[] = [];\n      for (const leafId of leaves) {\n        const moved = moveOverlay?.poses.get(leafId);\n        if (moved !== undefined) {\n          leafBounds.push(visualBoundsViaDescriptor(moved, d));\n          continue;\n        }\n        const overlayLeaf = containerResizeLeafPoses?.get(leafId);\n        if (overlayLeaf !== undefined) {\n          leafBounds.push(visualBoundsViaDescriptor(overlayLeaf, d));\n          continue;\n        }\n        leafBounds.push(visualBoundsViaDescriptor(getStoredPose(leafId), d));\n      }\n      const u = unionAABB(leafBounds);\n      if (u === null) return null;\n      return d.fromBounds(u, getStoredPose(leaves[0]!));\n    }\n    return resolveLeaf(id);\n  };\n}\n\n/**\n * Build a pose resolver that handles container ids by computing the union\n * AABB of every leaf's bounds. Non-container ids pass through directly. When\n * `getChildren`/`isContainer` are omitted, every id is treated as a leaf.\n */\nfunction makeContainerAwareBoundsResolver<TPose>(\n  getPose: (id: string) => TPose | null,\n  d: PoseDescriptor<TPose>,\n  getChildren?: (id: string) => readonly string[],\n  isContainer?: (id: string) => boolean,\n): (id: string) => Bounds | null {\n  const oriented = (p: TPose): Bounds => {\n    const b = d.getBounds(p);\n    const r = d.getRotation?.(p);\n    return r ? { ...b, rotation: r } : b;\n  };\n  if (getChildren === undefined || isContainer === undefined) {\n    return (id: string) => {\n      const p = getPose(id);\n      return p === null ? null : oriented(p);\n    };\n  }\n  return (id: string): Bounds | null => {\n    if (!isContainer(id)) {\n      const p = getPose(id);\n      return p === null ? null : oriented(p);\n    }\n    const leaves = leavesOf(id, getChildren, isContainer);\n    if (leaves.length === 0) return null;\n    const leafBounds: Bounds[] = [];\n    for (const leafId of leaves) {\n      const p = getPose(leafId);\n      if (p !== null) leafBounds.push(visualBoundsViaDescriptor(p, d));\n    }\n    if (leafBounds.length === 0) return null;\n    return unionAABB(leafBounds);\n  };\n}\n\n/** Options every selection layer shares. `getSelection` and `getPose` are\n *  declared on {@link SelectionOverlayLayerOpts}, which makes both optional —\n *  omitted, they come off the draw envelope. */\ninterface SelectionLayerCommon<TPose> {\n  /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Walk a container's direct children (e.g. `scene.childrenOf`). When\n   *  supplied with `isContainer`, any id that resolves to a container is\n   *  rendered using the union bounds of all its transitive leaves. */\n  getChildren?: (id: string) => readonly string[];\n  /** True when `id` is a structural container. */\n  isContainer?: (id: string) => boolean;\n}\n\n/** Options for `createSelectionOutlineLayer`. The overlay layer's options\n *  minus the handle visuals — the two run the same body. */\nexport type SelectionOutlineLayerOpts<TPose> =\n  Omit<SelectionOverlayLayerOpts<TPose>, 'handles' | 'handlesOf' | 'rotationHandle'>;\n\n/** Options for `createSelectionHandlesLayer`. The overlay layer's options\n *  minus the outline stroke — the two run the same body. */\nexport type SelectionHandlesLayerOpts<TPose> =\n  Omit<SelectionOverlayLayerOpts<TPose>, 'outline'>;\n\n/** Options for `createSelectionOverlayLayer`. */\nexport interface SelectionOverlayLayerOpts<TPose>\n  extends SelectionLayerCommon<TPose> {\n  /**\n   * Which ids to draw chrome for. Omit to take them from the `ChromeState` on\n   * the draw envelope, which is what makes one canvas's several views each\n   * outline their own selection — the layer is shared, the envelope is not.\n   *\n   * A multi-selection resolves to the synthetic union id, with the real\n   * members going to the outline pass, exactly as the explicit form does.\n   */\n  getSelection?: () => readonly NodeId[];\n  /**\n   * Resolve an id to the pose to draw chrome around. Return null to skip an\n   * id. Omit to take bounds from the same envelope `getSelection` omitted\n   * takes ids from — one cascade, the one the chrome state was built with,\n   * rather than a second one here that has to agree with it.\n   *\n   * Takes `string` rather than `NodeId` because the container-aware resolver\n   * walks expanded leaf ids via `getChildren`, which is generic over strings.\n   */\n  getPose?: (id: string) => TPose | null;\n  outline?: Stroke & { pad?: number };\n  /** Pass `false` to render outlines only. */\n  handles?: SelectionHandleStyle | false;\n  handlesOf?: (bounds: Bounds) => { x: number; y: number }[];\n  /** Draw a rotate badge above the selection's top edge. `true` places it at\n   *  the default offset; `distance` sets the offset in screen pixels. Off by\n   *  default. */\n  rotationHandle?:\n    | boolean\n    | {\n        distance?: number;\n      };\n  /** Optional separate id list for the per-item outline pass. Use this in\n   *  multi-selection contexts where the handle pass works against a synthetic\n   *  union id (e.g. `MULTI_RESIZE_TARGET_ID`) but consumers still want to\n   *  see outlines around each real member. When omitted, the outline pass\n   *  uses the same `getSelection` ids as the handle pass. */\n  getOutlineIds?: () => readonly NodeId[];\n  /** Optional set of ids to suppress entirely — both outline and handles\n   *  are skipped. Used by SceneCanvas to hide the standard selection\n   *  chrome on the node currently in path-anchor edit mode, where the\n   *  per-anchor chrome takes over. */\n  getSuppressedIds?: () => ReadonlySet<string>;\n}\n\nconst DEFAULT_OUTLINE: Required<Pick<Stroke, 'paint' | 'width'>> & { pad: number } = {\n  paint: { fill: 'solid', color: '#f0e0a8' },\n  width: 2,\n  pad: 1,\n};\nconst DEFAULT_HANDLE_FILL: FillStyle = { fill: 'solid', color: '#d4c4a8' };\nconst DEFAULT_HANDLE_OUTLINE: Stroke = {\n  paint: { fill: 'solid', color: '#1a130d' },\n  width: 1,\n};\nconst DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;\n\nfunction defaultHandlesOf(b: Bounds): { x: number; y: number }[] {\n  return [\n    { x: b.x, y: b.y },\n    { x: b.x + b.width, y: b.y },\n    { x: b.x, y: b.y + b.height },\n    { x: b.x + b.width, y: b.y + b.height },\n  ];\n}\n\nfunction resolveOutlineStroke(opts?: Stroke & { pad?: number }): {\n  stroke: Stroke;\n  pad: number;\n} {\n  if (!opts) {\n    return {\n      stroke: { paint: DEFAULT_OUTLINE.paint, width: DEFAULT_OUTLINE.width },\n      pad: DEFAULT_OUTLINE.pad,\n    };\n  }\n  return {\n    stroke: {\n      paint: opts.paint,\n      width: opts.width ?? DEFAULT_OUTLINE.width,\n      dash: opts.dash,\n      cap: opts.cap,\n      join: opts.join,\n      align: opts.align,\n    },\n    pad: opts.pad ?? DEFAULT_OUTLINE.pad,\n  };\n}\n\n/** Handle visuals, as a consumer supplies them. */\nexport interface SelectionHandleStyle {\n  size?: number;\n  fill?: FillStyle;\n  outline?: Stroke;\n}\n\ninterface ResolvedHandles {\n  size: number;\n  fill: FillStyle;\n  outline: Stroke;\n}\n\nfunction resolveHandles(opts?: SelectionHandleStyle): ResolvedHandles {\n  return {\n    size: opts?.size ?? DEFAULT_HANDLE_SIZE,\n    fill: opts?.fill ?? DEFAULT_HANDLE_FILL,\n    outline: opts?.outline ?? DEFAULT_HANDLE_OUTLINE,\n  };\n}\n\n/**\n * GL helper: build the matrix `translate(cx, cy) * rotate(θ) * translate(-cx, -cy)`\n * used to wrap rotated outline / handle commands.\n */\nfunction rotateAroundMat3(cx: number, cy: number, theta: number): GlMat3 {\n  const c = Math.cos(theta);\n  const s = Math.sin(theta);\n  // Composed in column-major (matches mat3 helpers): T(cx,cy) · R(θ) · T(-cx,-cy).\n  // After expansion: a=c, b=s, c'=-s, d=c, tx=cx - c*cx + s*cy, ty=cy - s*cx - c*cy.\n  const tx = cx - c * cx + s * cy;\n  const ty = cy - s * cx - c * cy;\n  return new Float32Array([\n    c, s, 0,\n    -s, c, 0,\n    tx, ty, 1,\n  ]) as GlMat3;\n}\n\n/** GL helper: emit a closed rect path (kind:'rect'). */\nfunction rectPathFor(x: number, y: number, width: number, height: number): { kind: 'rect'; x: number; y: number; width: number; height: number } {\n  return { kind: 'rect', x, y, width, height };\n}\n\n/** GL helper: emit an outline command for one bounds entry. */\nfunction outlineCommandsFor(\n  ids: readonly string[],\n  resolveBounds: (id: string) => Bounds | null,\n  stroke: Stroke,\n  pad: number,\n  view: View,\n): DrawCommand[] {\n  const out: DrawCommand[] = [];\n  const align = stroke.align ?? 'center';\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  for (const id of ids) {\n    const worldB = resolveBounds(id);\n    if (!worldB) continue;\n    const b = projectBounds(worldB, view);\n    const padded = {\n      x: b.x - pad,\n      y: b.y - pad,\n      width: b.width + pad * 2,\n      height: b.height + pad * 2,\n    };\n    const rot = poseRotationOf(worldB);\n    if (!rot) {\n      const r = alignedStrokeRect(padded, align, width);\n      out.push({ kind: 'path', path: rectPathFor(r.x, r.y, r.width, r.height), stroke });\n      continue;\n    }\n    // Turned, the target lands on screen as a parallelogram whenever the zoom\n    // is non-uniform, so the outline is traced through its projected corners\n    // rather than drawn as a screen rect and turned. `alignedStrokeRect`'s\n    // shift is folded into the offset so the ribbon lands where it would.\n    const shift = align === 'outer' ? width / 2 : align === 'inner' ? -width / 2 : 0;\n    const q = screenCorners(worldB, rot, view, pad + shift);\n    out.push({\n      kind: 'path',\n      path: {\n        kind: 'polygon',\n        commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n        coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n        fillRule: 'nonzero',\n      },\n      stroke: { ...stroke, align: 'center' },\n    });\n  }\n  return out;\n}\n\n/**\n * A turned target's corners on screen, TL/TR/BR/BL, each pushed `pad` screen\n * pixels out from both edges that meet there.\n */\nfunction screenCorners(\n  worldB: Bounds,\n  rot: { cx: number; cy: number; rotation: number },\n  view: View,\n  pad: number,\n): { x: number; y: number }[] {\n  const t = viewToTransform(view);\n  const q = rectCorners(worldB).map((c) => {\n    const w = rotatePoint(c.x, c.y, rot.cx, rot.cy, rot.rotation);\n    const [x, y] = worldToScreen(w.x, w.y, t);\n    return { x, y };\n  });\n  if (pad === 0) return q;\n  const [ccx, ccy] = worldToScreen(rot.cx, rot.cy, t);\n  const normal = (a: { x: number; y: number }, b: { x: number; y: number }) => {\n    let nx = -(b.y - a.y), ny = b.x - a.x;\n    const l = Math.hypot(nx, ny) || 1;\n    nx /= l; ny /= l;\n    const mx = (a.x + b.x) / 2 - ccx, my = (a.y + b.y) / 2 - ccy;\n    return nx * mx + ny * my < 0 ? { x: -nx, y: -ny } : { x: nx, y: ny };\n  };\n  return q.map((c, i) => {\n    const n1 = normal(q[(i + 3) % 4], c);\n    const n2 = normal(c, q[(i + 1) % 4]);\n    // The point `pad` off both edge lines.\n    const k = pad / (1 + n1.x * n2.x + n1.y * n2.y);\n    return { x: c.x + (n1.x + n2.x) * k, y: c.y + (n1.y + n2.y) * k };\n  });\n}\n\n/** GL helper: emit handle fill+stroke commands for one bounds entry. */\nfunction handleCommandsFor(\n  ids: readonly string[],\n  resolveBounds: (id: string) => Bounds | null,\n  handles: ResolvedHandles,\n  handlesOf: (b: Bounds) => { x: number; y: number }[],\n  view: View,\n): DrawCommand[] {\n  const out: DrawCommand[] = [];\n  const half = handles.size / 2;\n  const handleAlign = handles.outline.align ?? 'center';\n  const handleWidth = resolveStrokeWidth(handles.outline.width ?? 1, 1);\n  for (const id of ids) {\n    const worldB = resolveBounds(id);\n    if (!worldB) continue;\n    // Rotation gate + angle from the kit's one convention. Turned in world,\n    // then projected: turning the projected point instead lands somewhere else\n    // under non-uniform zoom.\n    const r = poseRotationOf(worldB);\n    const t = viewToTransform(view);\n    const angle = r ? screenAngleOf(r.rotation, view.scale) : 0;\n    for (const hLocal of handlesOf(worldB)) {\n      const hWorld = r ? rotatePoint(hLocal.x, hLocal.y, r.cx, r.cy, r.rotation) : hLocal;\n      const [hsx, hsy] = worldToScreen(hWorld.x, hWorld.y, t);\n      const center = { x: hsx, y: hsy };\n      const baseRect = {\n        x: center.x - half,\n        y: center.y - half,\n        width: handles.size,\n        height: handles.size,\n      };\n      const sr = alignedStrokeRect(baseRect, handleAlign, handleWidth);\n      const fillCmd: DrawCommand = {\n        kind: 'path',\n        path: rectPathFor(baseRect.x, baseRect.y, baseRect.width, baseRect.height),\n        fill: handles.fill,\n      };\n      const strokeCmd: DrawCommand = {\n        kind: 'path',\n        path: rectPathFor(sr.x, sr.y, sr.width, sr.height),\n        stroke: handles.outline,\n      };\n      if (!r) {\n        out.push(fillCmd, strokeCmd);\n      } else {\n        out.push({\n          kind: 'group',\n          transform: rotateAroundMat3(center.x, center.y, angle),\n          children: [fillCmd, strokeCmd],\n        });\n      }\n    }\n  }\n  return out;\n}\n\n/** GL helper: emit a curved double-headed arrow indicating bidirectional\n *  rotation. The arc opens *toward* the object (apex on top, mouth pointing\n *  down) so the affordance reads as a small \"rotate\" badge sitting above\n *  the rect. Two arrowheads at the arc endpoints point along the tangent,\n *  signaling that rotation goes either direction. */\nfunction rotationHandleCommands(\n  worldB: Bounds,\n  handles: ResolvedHandles,\n  distance: number,\n  view: View,\n): DrawCommand[] {\n  const hWorld = rotationHandle(worldB, distance, view.scale);\n  const rotation = hWorld.angle;\n  const t = viewToTransform(view);\n  const [scx, scy] = worldToScreen(hWorld.cx, hWorld.cy, t);\n  const size = handles.size;\n  const arcRadius = size;\n  // Arc spans ~240° (from 150° to -30° measured from arc center, going\n  // CCW). The arc center is the handle anchor; the arc itself bulges\n  // *toward the rect* (downward, since the handle sits above the AABB).\n  const ARC_HALF_ANGLE = (Math.PI * 240) / 360 / 2; // 120°\n  const N_SEGS = 18;\n  const arcWidth = resolveStrokeWidth(handles.outline.width ?? 1, 1) * 1.5;\n  const stroke: Stroke = {\n    paint: handles.fill,\n    width: arcWidth,\n    cap: 'round',\n    join: 'round',\n  };\n  // Build the arc as a polyline in handle-local coords. Arc bulges *away*\n  // from the rect (upward in canvas space, since the handle sits above the\n  // AABB top edge): apex at -y, endpoints at +y near the rect side.\n  const cmds: number[] = [PATH_M];\n  const xs: number[] = [];\n  const ys: number[] = [];\n  for (let i = 0; i <= N_SEGS; i++) {\n    const t = i / N_SEGS;\n    const angle = ARC_HALF_ANGLE - t * ARC_HALF_ANGLE * 2;\n    xs.push(arcRadius * Math.sin(angle));\n    ys.push(-arcRadius * Math.cos(angle));\n    if (i > 0) cmds.push(PATH_L);\n  }\n  const arcCoords: number[] = [];\n  for (let i = 0; i < xs.length; i++) {\n    arcCoords.push(xs[i], ys[i]);\n  }\n  const arcPath: PolygonPath = {\n    kind: 'polygon',\n    commands: new Uint8Array(cmds),\n    coords: new Float32Array(arcCoords),\n    fillRule: 'nonzero',\n  };\n  // Arrowheads: small filled triangles at each endpoint, pointing along\n  // the tangent (away from the arc body). Tangent at endpoint = derivative\n  // of (sin(angle), cos(angle)) wrt angle = (cos(angle), -sin(angle)).\n  // At +ARC_HALF_ANGLE the tangent points \"outward and slightly up\"; at\n  // -ARC_HALF_ANGLE the tangent points the other way.\n  const headLen = size * 0.6;\n  const headWidth = size * 0.4;\n  const arrowHead = (endX: number, endY: number, tx: number, ty: number): PolygonPath => {\n    // Normalize tangent.\n    const len = Math.hypot(tx, ty) || 1;\n    const ux = tx / len;\n    const uy = ty / len;\n    // Perpendicular (rotate tangent 90° CCW).\n    const px = -uy;\n    const py = ux;\n    // Triangle: tip is endX+ux*headLen, base is endX (with +/- headWidth/2 along p).\n    const tipX = endX + ux * headLen;\n    const tipY = endY + uy * headLen;\n    const baseLeftX = endX + px * (headWidth / 2);\n    const baseLeftY = endY + py * (headWidth / 2);\n    const baseRightX = endX - px * (headWidth / 2);\n    const baseRightY = endY - py * (headWidth / 2);\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L]),\n      coords: new Float32Array([tipX, tipY, baseLeftX, baseLeftY, baseRightX, baseRightY, tipX, tipY]),\n      fillRule: 'nonzero',\n    };\n  };\n  // Endpoint A (right side, angle = +ARC_HALF_ANGLE). Arc point:\n  // (sin(a)·R, -cos(a)·R). Tangent (d/da) = (cos(a)·R, sin(a)·R) — points\n  // outward/down at the right end. Use as \"rotate further clockwise\" arrow.\n  const angleA = ARC_HALF_ANGLE;\n  const endAX = arcRadius * Math.sin(angleA);\n  const endAY = -arcRadius * Math.cos(angleA);\n  const tangentAX = Math.cos(angleA);\n  const tangentAY = Math.sin(angleA);\n  // Endpoint B (left side, angle = -ARC_HALF_ANGLE): tangent in the\n  // outward direction is the negation of the above.\n  const angleB = -ARC_HALF_ANGLE;\n  const endBX = arcRadius * Math.sin(angleB);\n  const endBY = -arcRadius * Math.cos(angleB);\n  const tangentBX = -Math.cos(angleB);\n  const tangentBY = -Math.sin(angleB);\n  const headA = arrowHead(endAX, endAY, tangentAX, tangentAY);\n  const headB = arrowHead(endBX, endBY, tangentBX, tangentBY);\n  const headFill: FillStyle = handles.fill;\n  // Build transform: translate(scx, scy) [* rotate(rotation)].\n  let transform = mat3.translated(mat3.identity(), scx, scy);\n  if (rotation !== 0) {\n    const c = Math.cos(rotation);\n    const s = Math.sin(rotation);\n    const rot = new Float32Array([c, s, 0, -s, c, 0, 0, 0, 1]) as GlMat3;\n    transform = mat3.multiply(transform, rot);\n  }\n  return [\n    {\n      kind: 'group',\n      transform,\n      children: [\n        { kind: 'path', path: arcPath, stroke },\n        { kind: 'path', path: headA, fill: headFill },\n        { kind: 'path', path: headB, fill: headFill },\n      ],\n    },\n  ];\n}\n\n/** Which passes a selection layer runs. The three exported factories differ\n *  only in this — everything else they do is shared, so a fix to one is a fix\n *  to all three. */\ninterface SelectionPasses {\n  readonly id: string;\n  readonly label: string;\n  readonly outline: boolean;\n  readonly handles: boolean;\n}\n\nfunction buildSelectionLayer<TPose>(\n  opts: SelectionOverlayLayerOpts<TPose>,\n  passes: SelectionPasses,\n): RenderLayer<unknown> {\n  const { stroke, pad } = resolveOutlineStroke(opts.outline);\n  const handlesEnabled = passes.handles && opts.handles !== false;\n  const handles = handlesEnabled ? resolveHandles(opts.handles || undefined) : null;\n  const handlesOf = opts.handlesOf ?? defaultHandlesOf;\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const getPose = opts.getPose;\n  const poseBounds = getPose\n    ? makeContainerAwareBoundsResolver(getPose, d, opts.getChildren, opts.isContainer)\n    : null;\n  const rotationHandleDistance = passes.handles\n    ? rotationBadgeOf(opts)?.distancePx ?? null\n    : null;\n\n  return {\n    id: passes.id,\n    label: passes.label,\n    space: 'screen',\n    draw: (data, view) => {\n      // The synthetic multi-resize id resolves to `ChromeState.unionBounds`,\n      // the single owner of the multi-selection union AABB — the same value\n      // the affordance hit-tester (`affordanceAt` / `composeAffordanceLayer`)\n      // reads, so painted chrome and its hit region stay in agreement. When\n      // no chromeState rides the draw envelope (bare/test callers), fall\n      // through to the supplied resolver so they can synthesize it via\n      // `getPose`.\n      const chromeState = asChromeState(data);\n      const allIds = opts.getSelection\n        ? opts.getSelection()\n        : chromeSelectionIds(chromeState);\n      if (allIds.length === 0) return [];\n      const suppressed = opts.getSuppressedIds?.();\n      const ids = suppressed && suppressed.size > 0\n        ? allIds.filter((id) => !suppressed.has(id as unknown as string))\n        : allIds;\n      if (ids.length === 0) return [];\n      // Chrome-caps: gate each of the three passes (outline, resize\n      // handles, rotation handle) on its canonical id. When no\n      // `getIsVisible` is wired (legacy callers / tests), every pass\n      // runs — preserving pre-chrome-caps behavior.\n      const isVisible = asIsVisible(data);\n      const showOutline = passes.outline && (isVisible ? isVisible('selection.outline') : true);\n      const showHandles = isVisible ? isVisible('selection.resize-handles') : true;\n      const showRotation = isVisible ? isVisible('selection.rotation-handle') : true;\n\n      const resolveBounds = poseBounds ?? ((id: string) => chromeState?.boundsOf(id) ?? null);\n      const resolveTargetBounds = (id: string): Bounds | null => {\n        if (id === MULTI_RESIZE_TARGET_ID && chromeState?.unionBounds != null) {\n          return chromeState.unionBounds;\n        }\n        return resolveBounds(id);\n      };\n\n      const out: DrawCommand[] = [];\n      if (showOutline) {\n        const outlineIdsRaw = opts.getOutlineIds\n          ? opts.getOutlineIds()\n          : (opts.getSelection ? ids : (chromeState?.selection ?? ids));\n        const outlineIds = suppressed && suppressed.size > 0\n          ? outlineIdsRaw.filter((id) => !suppressed.has(id as unknown as string))\n          : outlineIdsRaw;\n        for (const cmd of outlineCommandsFor(outlineIds, resolveTargetBounds, stroke, pad, view)) out.push(cmd);\n      }\n      if (!handles) return out;\n      if (showHandles) {\n        for (const cmd of handleCommandsFor(ids, resolveTargetBounds, handles, handlesOf, view)) out.push(cmd);\n      }\n      if (showRotation && rotationHandleDistance !== null) {\n        for (const id of ids) {\n          const b = resolveTargetBounds(id);\n          if (!b) continue;\n          for (const cmd of rotationHandleCommands(b, handles, rotationHandleDistance, view)) {\n            out.push(cmd);\n          }\n        }\n      }\n      return out;\n    },\n  };\n}\n\n/** Where the overlay paints its rotate badge and how big it is, in screen\n *  pixels, or `null` when it paints none. The badge's grab region and its\n *  slops halo read this too, so all three agree on it. */\nexport function rotationBadgeOf(\n  opts: Pick<SelectionOverlayLayerOpts<unknown>, 'handles' | 'rotationHandle'>,\n): { distancePx: number; sizePx: number } | null {\n  const r = opts.rotationHandle;\n  if (!r || opts.handles === false) return null;\n  return {\n    distancePx: r === true ? DEFAULT_ROTATION_HANDLE_DISTANCE : r.distance ?? DEFAULT_ROTATION_HANDLE_DISTANCE,\n    sizePx: resolveHandles(opts.handles || undefined).size,\n  };\n}\n/**\n * `RenderLayer` that draws selection outlines only. Stack alongside\n * `createSelectionHandlesLayer` (or use `createSelectionOverlayLayer`, which\n * runs both passes in one layer) when both are wanted.\n */\nexport function createSelectionOutlineLayer<TPose>(\n  opts: SelectionOutlineLayerOpts<TPose>,\n): RenderLayer<unknown> {\n  return buildSelectionLayer(opts, {\n    id: 'selection-outline',\n    label: 'Selection outline',\n    outline: true,\n    handles: false,\n  });\n}\n\n/**\n * `RenderLayer` that draws selection handles only. Stack on top of\n * `createSelectionOutlineLayer` (handles render on top of the outline).\n */\nexport function createSelectionHandlesLayer<TPose>(\n  opts: SelectionHandlesLayerOpts<TPose>,\n): RenderLayer<unknown> {\n  return buildSelectionLayer(opts, {\n    id: 'selection-handles',\n    label: 'Selection handles',\n    outline: false,\n    handles: true,\n  });\n}\n\n/**\n * Draws outlines then handles in a single layer. Exactly equivalent to\n * stacking `createSelectionOutlineLayer` and `createSelectionHandlesLayer` —\n * all three run the same body. Pass `handles: false` to render outlines only.\n */\nexport function createSelectionOverlayLayer<TPose>(\n  opts: SelectionOverlayLayerOpts<TPose>,\n): RenderLayer<unknown> {\n  return buildSelectionLayer(opts, {\n    id: 'selection-overlay',\n    label: 'Selection',\n    outline: true,\n    handles: true,\n  });\n}\n\n/** Pull a chrome-caps visibility predicate off the draw `data` envelope.\n *  Returns `null` when the caller passed bare data (no `getIsVisible`\n *  thunk) — the layer then renders unconditionally, matching pre-\n *  chrome-caps behavior. */\nfunction asIsVisible(data: unknown): ((id: string) => boolean) | null {\n  const maybe = data as { getIsVisible?: () => (id: string) => boolean };\n  if (typeof maybe?.getIsVisible === 'function') return maybe.getIsVisible();\n  return null;\n}\n\n/** The ids the handle pass works against when the layer takes its selection\n *  from the envelope: the synthetic union id for a multi-selection, the\n *  selection itself otherwise. */\nfunction chromeSelectionIds(state: ChromeState | null): readonly NodeId[] {\n  if (!state) return [];\n  if (state.multiActive) return [MULTI_RESIZE_TARGET_ID as NodeId];\n  return state.selection;\n}\n\n/** Pull live `ChromeState` off the draw `data` envelope (the same channel\n *  `composeAffordanceLayer` uses). Returns `null` for bare/test callers that\n *  pass plain data with no `getChromeState` thunk — the layer then resolves\n *  the multi-union via the supplied `getPose` resolver, preserving pre-\n *  chromeState behavior. */\nfunction asChromeState(data: unknown): ChromeState | null {\n  const maybe = data as { getChromeState?: () => ChromeState };\n  if (typeof maybe?.getChromeState === 'function') return maybe.getChromeState();\n  return null;\n}\n"],"mappings":"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"}

package/dist/features/simulation/createSimulation.js

@@ -0,0 +1,61 @@
+import { DEFAULT_ALPHA_DECAY as e, DEFAULT_ALPHA_MIN as t, DEFAULT_VELOCITY_DECAY as n } from "./types.js";
+//#region src/features/simulation/createSimulation.ts
+function r(r) {
+	let i = r.nodes, a = r.forces ?? [], o = r.alpha ?? 1, s = r.alphaMin ?? t, c = r.alphaDecay ?? e, l = r.alphaTarget ?? 0, u = r.velocityDecay ?? n, d = r.random ?? Math.random;
+	function f(e) {
+		e.forEach((e, t) => {
+			e.index = t, e.vx ??= 0, e.vy ??= 0;
+		});
+	}
+	f(i);
+	for (let e of a) e.initialize?.(i, d);
+	function p() {
+		o += (l - o) * c;
+		for (let e of a) e(o);
+		let e = 1 - u;
+		for (let t of i) t.fx == null ? (t.vx = (t.vx ?? 0) * e, Number.isFinite(t.vx) || (t.vx = 0), t.x += t.vx, Number.isFinite(t.x) || (t.x = 0)) : (t.x = t.fx, t.vx = 0), t.fy == null ? (t.vy = (t.vy ?? 0) * e, Number.isFinite(t.vy) || (t.vy = 0), t.y += t.vy, Number.isFinite(t.y) || (t.y = 0)) : (t.y = t.fy, t.vy = 0);
+	}
+	let m = {
+		get nodes() {
+			return i;
+		},
+		setNodes(e) {
+			i = e, f(i);
+			for (let e of a) e.initialize?.(i, d);
+			return m;
+		},
+		setForces(e) {
+			let t = a;
+			a = e;
+			for (let n of e) t.includes(n) || n.initialize?.(i, d);
+			return m;
+		},
+		alpha(e) {
+			return e === void 0 ? o : (o = e, m);
+		},
+		alphaTarget(e) {
+			return e === void 0 ? l : (l = e, m);
+		},
+		alphaDecay(e) {
+			return e === void 0 ? c : (c = e, m);
+		},
+		alphaMin(e) {
+			return e === void 0 ? s : (s = e, m);
+		},
+		velocityDecay(e) {
+			return e === void 0 ? u : (u = e, m);
+		},
+		tick(e = 1) {
+			for (let t = 0; t < e; t++) p();
+			return m;
+		},
+		isSettled() {
+			return o < s && l === 0;
+		}
+	};
+	return m;
+}
+//#endregion
+export { r as createSimulation };
+
+//# sourceMappingURL=createSimulation.js.map

package/dist/features/simulation/createSimulation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSimulation.js","names":["createSimulation","nodes","opts","forces","alpha","alphaMin","DEFAULT_ALPHA_MIN","alphaDecay","DEFAULT_ALPHA_DECAY","alphaTarget","velocityDecay","DEFAULT_VELOCITY_DECAY","random","prime","i","n","f","step","friction","core","next","old","value","iterations"],"sources":["../../../src/features/simulation/createSimulation.ts"],"sourcesContent":["/**\n * The integrator, with no clock attached.\n *\n * Velocity-Verlet over a pluggable force list, contract-compatible with\n * d3-force so d3's own bundled forces drop in untranslated. Nothing here\n * advances time: `tick()` is the only thing that moves a node, and the caller\n * decides how often to call it. `useSimulation` calls it once a frame; a\n * layout pass calls it a few hundred times in one go and reads the result.\n *\n * Splitting it out is what lets a *pure* function run a relaxation — a React\n * hook cannot, and the alternative was a second integrator drifting away from\n * this one.\n */\nimport {\n  DEFAULT_ALPHA_DECAY,\n  DEFAULT_ALPHA_MIN,\n  DEFAULT_VELOCITY_DECAY,\n  type SimulationCore,\n  type SimulationForce,\n  type SimulationNode,\n  type SimulationOptions,\n} from './types';\n\n/**\n * A d3-force-compatible simulation with no clock: nothing moves until `tick()`.\n * Nodes are mutated in place, and primed with `index`, `vx` and `vy` on creation.\n */\nexport function createSimulation<TNode extends SimulationNode>(\n  opts: SimulationOptions<TNode>,\n): SimulationCore<TNode> {\n  let nodes = opts.nodes;\n  let forces = opts.forces ?? [];\n  let alpha = opts.alpha ?? 1;\n  let alphaMin = opts.alphaMin ?? DEFAULT_ALPHA_MIN;\n  let alphaDecay = opts.alphaDecay ?? DEFAULT_ALPHA_DECAY;\n  let alphaTarget = opts.alphaTarget ?? 0;\n  let velocityDecay = opts.velocityDecay ?? DEFAULT_VELOCITY_DECAY;\n  const random = opts.random ?? Math.random;\n\n  /** `index` is what `forceLink` and friends address nodes by, and a d3 force\n   *  does `n.vx += …` without checking, so both must exist before the first\n   *  tick or the first tick produces NaN. */\n  function prime(list: TNode[]): void {\n    list.forEach((n, i) => {\n      n.index = i;\n      if (n.vx == null) n.vx = 0;\n      if (n.vy == null) n.vy = 0;\n    });\n  }\n\n  prime(nodes);\n  for (const f of forces) f.initialize?.(nodes, random);\n\n  function step(): void {\n    alpha += (alphaTarget - alpha) * alphaDecay;\n    for (const f of forces) f(alpha);\n\n    const friction = 1 - velocityDecay;\n    for (const n of nodes) {\n      if (n.fx == null) {\n        n.vx = (n.vx ?? 0) * friction;\n        // A non-finite velocity — force overflow, or two nodes exactly\n        // coincident — would reach the renderer as geometry and cost\n        // pathological tessellation work without throwing anywhere.\n        if (!Number.isFinite(n.vx)) n.vx = 0;\n        n.x += n.vx;\n        if (!Number.isFinite(n.x)) n.x = 0;\n      } else {\n        n.x = n.fx;\n        n.vx = 0;\n      }\n      if (n.fy == null) {\n        n.vy = (n.vy ?? 0) * friction;\n        if (!Number.isFinite(n.vy)) n.vy = 0;\n        n.y += n.vy;\n        if (!Number.isFinite(n.y)) n.y = 0;\n      } else {\n        n.y = n.fy;\n        n.vy = 0;\n      }\n    }\n  }\n\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  const core: any = {\n    get nodes() {\n      return nodes;\n    },\n    setNodes(next: TNode[]) {\n      nodes = next;\n      prime(nodes);\n      for (const f of forces) f.initialize?.(nodes, random);\n      return core;\n    },\n    setForces(next: SimulationForce<TNode>[]) {\n      const old = forces;\n      forces = next;\n      for (const f of next) {\n        if (!old.includes(f)) f.initialize?.(nodes, random);\n      }\n      return core;\n    },\n    alpha(value?: number) {\n      if (value === undefined) return alpha;\n      alpha = value;\n      return core;\n    },\n    alphaTarget(value?: number) {\n      if (value === undefined) return alphaTarget;\n      alphaTarget = value;\n      return core;\n    },\n    alphaDecay(value?: number) {\n      if (value === undefined) return alphaDecay;\n      alphaDecay = value;\n      return core;\n    },\n    alphaMin(value?: number) {\n      if (value === undefined) return alphaMin;\n      alphaMin = value;\n      return core;\n    },\n    velocityDecay(value?: number) {\n      if (value === undefined) return velocityDecay;\n      velocityDecay = value;\n      return core;\n    },\n    tick(iterations: number = 1) {\n      for (let i = 0; i < iterations; i++) step();\n      return core;\n    },\n    isSettled() {\n      return alpha < alphaMin && alphaTarget === 0;\n    },\n  };\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  return core as SimulationCore<TNode>;\n}\n"],"mappings":";;AA2BA,SAAgBA,EACd,GACuB;CACvB,IAAIC,IAAQC,EAAK,OACbC,IAASD,EAAK,UAAU,CAAC,GACzBE,IAAQF,EAAK,SAAS,GACtBG,IAAWH,EAAK,YAAYI,GAC5BC,IAAaL,EAAK,cAAcM,GAChCC,IAAcP,EAAK,eAAe,GAClCQ,IAAgBR,EAAK,iBAAiBS,GACpCC,IAASV,EAAK,UAAU,KAAK;CAKnC,SAASW,EAAM,GAAqB;EAClC,EAAK,SAAS,GAAG,MAAM;GAGrB,AAFA,EAAE,QAAQC,GACV,AAAkBC,EAAE,OAAK,GACzB,AAAkBA,EAAE,OAAK;EAC3B,CAAC;CACH;CAEA,EAAMd,CAAK;CACX,KAAK,IAAMe,KAAKb,GAAQ,EAAE,aAAaF,GAAOW,CAAM;CAEpD,SAASK,IAAa;EACpB,MAAUR,IAAcL,KAASG;EACjC,KAAK,IAAMS,KAAKb,GAAQ,EAAEC,CAAK;EAE/B,IAAMc,IAAW,IAAIR;EACrB,KAAK,IAAMK,KAAKd,GAad,AAZIc,EAAE,MAAM,QACV,EAAE,MAAMA,EAAE,MAAM,KAAKG,GAIhB,OAAO,SAASH,EAAE,EAAE,MAAG,EAAE,KAAK,IACnC,EAAE,KAAKA,EAAE,IACJ,OAAO,SAASA,EAAE,CAAC,MAAG,EAAE,IAAI,OAEjC,EAAE,IAAIA,EAAE,IACR,EAAE,KAAK,IAELA,EAAE,MAAM,QACV,EAAE,MAAMA,EAAE,MAAM,KAAKG,GAChB,OAAO,SAASH,EAAE,EAAE,MAAG,EAAE,KAAK,IACnC,EAAE,KAAKA,EAAE,IACJ,OAAO,SAASA,EAAE,CAAC,MAAG,EAAE,IAAI,OAEjC,EAAE,IAAIA,EAAE,IACR,EAAE,KAAK;CAGb;CAGA,IAAMI,IAAY;EAChB,IAAI,QAAQ;GACV,OAAOlB;EACT;EACA,SAAS,GAAe;GAEtB,AADA,IAAQmB,GACRP,EAAMZ,CAAK;GACX,KAAK,IAAMe,KAAKb,GAAQ,EAAE,aAAaF,GAAOW,CAAM;GACpD,OAAOO;EACT;EACA,UAAU,GAAgC;GACxC,IAAME,IAAMlB;GACZ,IAASiB;GACT,KAAK,IAAMJ,KAAKI,GACd,AAAKC,EAAI,SAASL,CAAC,KAAGA,EAAE,aAAaf,GAAOW,CAAM;GAEpD,OAAOO;EACT;EACA,MAAM,GAAgB;GAGpB,OAFIG,MAAU,KAAA,IAAkBlB,KAChC,IAAQkB,GACDH;EACT;EACA,YAAY,GAAgB;GAG1B,OAFIG,MAAU,KAAA,IAAkBb,KAChC,IAAca,GACPH;EACT;EACA,WAAW,GAAgB;GAGzB,OAFIG,MAAU,KAAA,IAAkBf,KAChC,IAAae,GACNH;EACT;EACA,SAAS,GAAgB;GAGvB,OAFIG,MAAU,KAAA,IAAkBjB,KAChC,IAAWiB,GACJH;EACT;EACA,cAAc,GAAgB;GAG5B,OAFIG,MAAU,KAAA,IAAkBZ,KAChC,IAAgBY,GACTH;EACT;EACA,KAAK,IAAqB,GAAG;GAC3B,KAAK,IAAIL,IAAI,GAAGA,IAAIS,GAAY,KAAK,EAAK;GAC1C,OAAOJ;EACT;EACA,YAAY;GACV,OAAOf,IAAQC,KAAYI,MAAgB;EAC7C;CACF;CAEA,OAAOU;AACT"}

package/dist/features/simulation/types.js

@@ -0,0 +1,6 @@
+//#region src/features/simulation/types.ts
+var e = 1 - .001 ** (1 / 300), t = .001, n = .4;
+//#endregion
+export { e as DEFAULT_ALPHA_DECAY, t as DEFAULT_ALPHA_MIN, n as DEFAULT_VELOCITY_DECAY };
+
+//# sourceMappingURL=types.js.map

package/dist/features/simulation/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":["DEFAULT_ALPHA_DECAY","DEFAULT_ALPHA_MIN","DEFAULT_VELOCITY_DECAY"],"sources":["../../../src/features/simulation/types.ts"],"sourcesContent":["/**\n * Minimal node interface for the simulation primitive. Matches d3-force's\n * node shape exactly so d3-force's bundled forces work without translation.\n *\n * Consumers extend this with arbitrary additional fields (id, label, etc.).\n */\nexport interface SimulationNode {\n  x: number;\n  y: number;\n  vx?: number;\n  vy?: number;\n  /** Pin x to this value when non-null. The integrator skips x/vx for the node. */\n  fx?: number | null;\n  fy?: number | null;\n  /** Array index, written by `initialize`. Some forces (e.g. forceLink) rely on it. */\n  index?: number;\n}\n\n/**\n * Force protocol — contract-compatible with d3-force. A force is a function\n * called once per tick with the current alpha; it mutates `vx`/`vy` on nodes.\n * Optional `initialize` lets the force compute setup (link indices, etc.).\n */\nexport interface SimulationForce<TNode extends SimulationNode = SimulationNode> {\n  (alpha: number): void;\n  initialize?(nodes: TNode[], random?: () => number): void;\n}\n\n/** Options for `useSimulation`: everything {@link SimulationOptions} carries,\n *  plus the loop's own callbacks and clock. */\nexport interface UseSimulationOptions<TNode extends SimulationNode>\n  extends SimulationOptions<TNode> {\n  /** Fired after each integration step. */\n  onTick?: (nodes: TNode[]) => void;\n  /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */\n  onEnd?: () => void;\n\n  // Test injection (mirrors useAnimator):\n  /** Optional rAF injection. Defaults to window.requestAnimationFrame. */\n  requestFrame?: (cb: (t: number) => void) => number;\n  cancelFrame?: (handle: number) => void;\n}\n\n/**\n * A force simulation over a set of nodes, with no clock of its own.\n *\n * Each tick applies every force and then integrates velocities, scaled by\n * `alpha` — a temperature that decays toward `alphaTarget` so the layout\n * settles instead of jittering forever. Raise `alphaTarget` to reheat it,\n * which is what a drag does.\n *\n * Nodes are mutated in place; the simulation holds the array, not a copy.\n *\n * Nothing here advances time. {@link Simulation} adds the frame loop; a caller\n * that wants the whole relaxation at once — a layout pass, a pre-warm, a test\n * — drives {@link SimulationCore.tick} itself.\n */\nexport interface SimulationCore<TNode extends SimulationNode> {\n  readonly nodes: TNode[];\n\n  setNodes(nodes: TNode[]): this;\n  setForces(forces: SimulationForce<TNode>[]): this;\n\n  alpha(): number;\n  alpha(value: number): this;\n  alphaTarget(): number;\n  alphaTarget(value: number): this;\n  alphaDecay(): number;\n  alphaDecay(value: number): this;\n  alphaMin(): number;\n  alphaMin(value: number): this;\n  velocityDecay(): number;\n  velocityDecay(value: number): this;\n\n  /**\n   * Run the tick body synchronously `iterations` times. Does NOT fire\n   * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.\n   */\n  tick(iterations?: number): this;\n\n  isSettled(): boolean;\n}\n\n/** A {@link SimulationCore} running on a frame loop. */\nexport interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {\n  /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */\n  restart(): this;\n  /** Cancel the RAF loop. Does not change alpha. */\n  stop(): this;\n}\n\n/** What {@link SimulationCore} needs: the nodes, the forces acting on them,\n *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */\nexport interface SimulationOptions<TNode extends SimulationNode> {\n  /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */\n  nodes: TNode[];\n  /** Forces applied per tick. Each may implement `initialize` for setup. */\n  forces?: SimulationForce<TNode>[];\n\n  /** Initial alpha. Default 1. */\n  alpha?: number;\n  /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */\n  alphaMin?: number;\n  /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */\n  alphaDecay?: number;\n  /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */\n  alphaTarget?: number;\n  /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */\n  velocityDecay?: number;\n  /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded\n   *  source to make a run reproducible. */\n  random?: () => number;\n}\n\n/** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */\nexport const DEFAULT_ALPHA_DECAY = 1 - Math.pow(0.001, 1 / 300);\n/** Alpha below which a cooling simulation is considered settled. */\nexport const DEFAULT_ALPHA_MIN = 0.001;\n/** Fraction of velocity shed each tick — friction. Higher settles sooner and\n *  overshoots less. */\nexport const DEFAULT_VELOCITY_DECAY = 0.4;\n"],"mappings":";AAmHA,IAAaA,IAAsB,IAAa,SAAO,IAAI,MAE9CC,IAAoB,MAGpBC,IAAyB"}