@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/SceneCanvas/useSceneChrome.js

@@ -0,0 +1,59 @@
+import { useOptionalViewRegistry as e } from "../viewRegistry.js";
+import { worldPointAt as t } from "./worldPointAt.js";
+import { never as n } from "../../features/chrome-caps/conditions.js";
+import { featureChromeRules as r } from "./features.js";
+import { useHoverTracking as i } from "../../features/chrome-caps/useHoverTracking.js";
+import { useChromeCaps as a } from "../../features/chrome-caps/useChromeCaps.js";
+import { useCallback as o, useMemo as s } from "react";
+import { useLatest as c } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useSceneChrome.ts
+function l(n) {
+	let { canvasApiRef: r, viewRef: a, nodeAtPointRef: o, enabled: s } = n, c = e();
+	return i({
+		nodeAtClientPoint: (e, n) => {
+			let i = r.current;
+			if (!i) return null;
+			let s = c?.resolver.at(null, e, n), l = s?.view ?? a.current, [u, d] = t(i, s, e, n), f = s?.id == null ? void 0 : c?.list().find((e) => e.id === s.id), p = o.current?.(u, d, f ? {
+				scale: l.scale,
+				layerIsPainted: f.layerIsPainted
+			} : l);
+			return p ? { id: p.id } : null;
+		},
+		enabled: s
+	});
+}
+function u(e) {
+	let { enabled: t, selectable: i, rotateOff: a, chromeVisibility: o } = e;
+	return s(() => {
+		let e = r(t);
+		return i || (e["action.marquee"] = n, e["action.lasso"] = n), a && (e["selection.rotation-handle"] = n), {
+			...e,
+			...o
+		};
+	}, [
+		o,
+		i,
+		a,
+		t
+	]);
+}
+function d(e) {
+	let { viewRef: t, dispatcher: n } = e, r = a(e.source), i = c(e.selection), s = o(() => ({
+		selection: i.current,
+		view: t.current,
+		action: n.getActiveAction()
+	}), [
+		n,
+		i,
+		t
+	]);
+	return {
+		chromeCaps: r,
+		getIsVisible: o(() => r.isVisible(s()), [r, s]),
+		getRuleCtx: o(() => r.ruleCtx(s()), [r, s])
+	};
+}
+//#endregion
+export { u as useChromeRules, l as useSceneHover, d as useSurfaceChromeCaps };
+
+//# sourceMappingURL=useSceneChrome.js.map

package/dist/canvas/SceneCanvas/useSceneChrome.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneChrome.js","names":["useSceneHover","args","surfaceViewRegistry","useOptionalViewRegistry","useHoverTracking","api","canvasApiRef","target","clientX","clientY","view","viewRef","x","y","worldPointAt","reg","r","hit","nodeAtPointRef","useChromeRules","useMemo","defaults","featureChromeRules","enabled","selectable","never","rotateOff","chromeVisibility","useSurfaceChromeCaps","chromeCaps","useChromeCaps","committedSelectionRef","useLatest","currentRuleInputs","useCallback","dispatcher"],"sources":["../../../src/canvas/SceneCanvas/useSceneChrome.ts"],"sourcesContent":["import { useCallback, useMemo, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher, RuleCtx } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport { never, useHoverTracking, type HoverTracking, type VisibilityRules } from 'features/chrome-caps';\nimport {\n  useChromeCaps,\n  type ChromeCaps,\n  type ChromeCapsSource,\n  type ViewRuleInputs,\n} from 'features/chrome-caps/useChromeCaps';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { featureChromeRules, type BaseFeature } from './features';\nimport type { NodeAtPoint } from './useNodeAtPoint';\nimport { worldPointAt } from './worldPointAt';\n\n/**\n * The node under the pointer, for `RuleCtx.hover`. One lookup, not a\n * client-to-world thunk beside a picker: the point and the camera its\n * tolerance converts against have to come from the same view. Hover has no\n * pointer to capture, so whichever view is under the cursor owns the point.\n */\nexport function useSceneHover(args: {\n  canvasApiRef: RefObject<Pick<CanvasExtensionApi, 'clientToWorld'> | null>;\n  /** The surface's own camera, for a point no declared view claims. */\n  viewRef: { readonly current: View };\n  nodeAtPointRef: { readonly current: NodeAtPoint | undefined };\n  enabled: boolean;\n}): HoverTracking {\n  const { canvasApiRef, viewRef, nodeAtPointRef, enabled } = args;\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  return useHoverTracking({\n    nodeAtClientPoint: (clientX, clientY) => {\n      const api = canvasApiRef.current;\n      if (!api) return null;\n      const target = surfaceViewRegistry?.resolver.at(null, clientX, clientY);\n      const view = target?.view ?? viewRef.current;\n      const [x, y] = worldPointAt(api, target, clientX, clientY);\n      // A view judges its own layers; the surface's gate is the picker's default.\n      const reg = target?.id != null\n        ? surfaceViewRegistry?.list().find((r) => r.id === target.id)\n        : undefined;\n      const hit = nodeAtPointRef.current?.(\n        x, y, reg ? { scale: view.scale, layerIsPainted: reg.layerIsPainted } : view,\n      );\n      return hit ? { id: hit.id as NodeId } : null;\n    },\n    enabled,\n  });\n}\n\n/**\n * The surface's chrome-visibility rules: the presets' defaults under the\n * consumer's `chromeVisibility`, which wins.\n *\n * An unselectable canvas hides the marquee and lasso by default: every\n * selection write no-ops there, so the select tool's empty-drag binding still\n * claims the gesture, keeping it from falling through to an ambient drag such\n * as insert, but paints nothing. `rotateOff` hides the rotation handle.\n */\nexport function useChromeRules(args: {\n  enabled: ReadonlySet<BaseFeature>;\n  selectable: boolean;\n  /** `selectTool.rotate === false`. */\n  rotateOff: boolean;\n  chromeVisibility: VisibilityRules | undefined;\n}): VisibilityRules {\n  const { enabled, selectable, rotateOff, chromeVisibility } = args;\n  return useMemo(() => {\n    const defaults = featureChromeRules(enabled);\n    if (!selectable) {\n      defaults['action.marquee'] = never;\n      defaults['action.lasso'] = never;\n    }\n    if (rotateOff) defaults['selection.rotation-handle'] = never;\n    return { ...defaults, ...chromeVisibility };\n  }, [chromeVisibility, selectable, rotateOff, enabled]);\n}\n\n/** The chrome-caps answers for the surface's own view. */\nexport function useSurfaceChromeCaps(args: {\n  source: ChromeCapsSource;\n  /** The selection as rendered. `SelectionApi.current` can be a live getter\n   *  that runs ahead of the commit the painted chrome was built from. */\n  selection: readonly NodeId[];\n  viewRef: { readonly current: View };\n  dispatcher: Pick<Dispatcher, 'getActiveAction'>;\n}): {\n  chromeCaps: ChromeCaps;\n  getIsVisible: () => (id: string) => boolean;\n  getRuleCtx: () => RuleCtx | undefined;\n} {\n  const { viewRef, dispatcher } = args;\n  const chromeCaps = useChromeCaps(args.source);\n  const committedSelectionRef = useLatest(args.selection);\n  const currentRuleInputs = useCallback((): ViewRuleInputs => ({\n    selection: committedSelectionRef.current,\n    view: viewRef.current,\n    action: dispatcher.getActiveAction(),\n  }), [dispatcher, committedSelectionRef, viewRef]);\n  const getIsVisible = useCallback(\n    (): ((id: string) => boolean) => chromeCaps.isVisible(currentRuleInputs()),\n    [chromeCaps, currentRuleInputs],\n  );\n  const getRuleCtx = useCallback(\n    () => chromeCaps.ruleCtx(currentRuleInputs()),\n    [chromeCaps, currentRuleInputs],\n  );\n  return { chromeCaps, getIsVisible, getRuleCtx };\n}\n"],"mappings":";;;;;;;;;AAwBA,SAAgBA,EAAc,GAMZ;CAChB,IAAM,EAAE,iBAAc,YAAS,mBAAgB,eAAYC,GACrDC,IAAsBC,EAAwB;CACpD,OAAOC,EAAiB;EACtB,oBAAoB,GAAS,MAAY;GACvC,IAAMC,IAAMC,EAAa;GACzB,IAAI,CAACD,GAAK,OAAO;GACjB,IAAME,IAASL,GAAqB,SAAS,GAAG,MAAMM,GAASC,CAAO,GAChEC,IAAOH,GAAQ,QAAQI,EAAQ,SAC/B,CAACC,GAAGC,KAAKC,EAAaT,GAAKE,GAAQC,GAASC,CAAO,GAEnDM,IAAMR,GAAQ,MAAM,OAEtB,KAAA,IADAL,GAAqB,KAAK,CAAC,CAAC,MAAM,MAAMc,EAAE,OAAOT,EAAO,EAAE,GAExDU,IAAMC,EAAe,UACzBN,GAAGC,GAAGE,IAAM;IAAE,OAAOL,EAAK;IAAO,gBAAgBK,EAAI;GAAe,IAAIL,CAC1E;GACA,OAAOO,IAAM,EAAE,IAAIA,EAAI,GAAa,IAAI;EAC1C;EACA;CACF,CAAC;AACH;AAWA,SAAgBE,EAAe,GAMX;CAClB,IAAM,EAAE,YAAS,eAAY,cAAW,wBAAqBlB;CAC7D,OAAOmB,QAAc;EACnB,IAAMC,IAAWC,EAAmBC,CAAO;EAM3C,OALKC,MACH,EAAS,oBAAoBC,GAC7B,EAAS,kBAAkBA,IAEzBC,MAAW,EAAS,+BAA+BD,IAChD;GAAE,GAAGJ;GAAU,GAAGM;EAAiB;CAC5C,GAAG;EAACA;EAAkBH;EAAYE;EAAWH;CAAO,CAAC;AACvD;AAGA,SAAgBK,EAAqB,GAWnC;CACA,IAAM,EAAE,YAAS,kBAAe3B,GAC1B4B,IAAaC,EAAc7B,EAAK,MAAM,GACtC8B,IAAwBC,EAAU/B,EAAK,SAAS,GAChDgC,IAAoBC,SAAmC;EAC3D,WAAWH,EAAsB;EACjC,MAAMpB,EAAQ;EACd,QAAQwB,EAAW,gBAAgB;CACrC,IAAI;EAACA;EAAYJ;EAAuBpB;CAAO,CAAC;CAShD,OAAO;EAAE;EAAY,cARAuB,QACcL,EAAW,UAAUI,EAAkB,CAAC,GACzE,CAACJ,GAAYI,CAAiB,CAMX;EAAc,YAJhBC,QACXL,EAAW,QAAQI,EAAkB,CAAC,GAC5C,CAACJ,GAAYI,CAAiB,CAEG;CAAW;AAChD"}

package/dist/canvas/SceneCanvas/useSceneRedrawSources.js

@@ -0,0 +1,23 @@
+import { useMemo as e } from "react";
+//#region src/canvas/SceneCanvas/useSceneRedrawSources.ts
+function t(t) {
+	let { supplied: n, scene: r, heldModifiers: i, animator: a, modes: o } = t;
+	return e(() => [
+		...n ?? [],
+		r,
+		r.overrides,
+		i,
+		...a ? [{ subscribe: (e) => a.onTick(e) }] : [],
+		...o ? [o] : []
+	], [
+		r,
+		i,
+		a,
+		o,
+		n
+	]);
+}
+//#endregion
+export { t as useSceneRedrawSources };
+
+//# sourceMappingURL=useSceneRedrawSources.js.map

package/dist/canvas/SceneCanvas/useSceneRedrawSources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneRedrawSources.js","names":["useSceneRedrawSources","args","useMemo","supplied","scene","heldModifiers","animator","repaint","modes"],"sources":["../../../src/canvas/SceneCanvas/useSceneRedrawSources.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { RedrawSource } from '../../core/layers/render';\n\n/**\n * What repaints a `<SceneCanvas>` besides its own render: the caller's\n * sources, then the canvas's. Neither a scene write nor an override write\n * renders the component, and an override write does not bump the scene version\n * either. An animator frame repaints for a `drawOne` reading\n * `animator.colorOverrides`.\n */\nexport function useSceneRedrawSources(args: {\n  /** `<SceneCanvas redrawOn>`. */\n  supplied: readonly RedrawSource[] | undefined;\n  scene: RedrawSource & { overrides: RedrawSource };\n  heldModifiers: RedrawSource;\n  animator: { onTick(listener: () => void): () => void } | undefined;\n  modes: RedrawSource | undefined;\n}): readonly RedrawSource[] {\n  const { supplied, scene, heldModifiers, animator, modes } = args;\n  return useMemo((): readonly RedrawSource[] => [\n    ...(supplied ?? []),\n    scene,\n    scene.overrides,\n    heldModifiers,\n    ...(animator ? [{ subscribe: (repaint: () => void) => animator.onTick(repaint) }] : []),\n    ...(modes ? [modes] : []),\n  ], [scene, heldModifiers, animator, modes, supplied]);\n}\n"],"mappings":";;AAUA,SAAgBA,EAAsB,GAOV;CAC1B,IAAM,EAAE,aAAU,UAAO,kBAAe,aAAU,aAAUC;CAC5D,OAAOC,QAAuC;EAC5C,GAAIC,KAAY,CAAC;EACjBC;EACAA,EAAM;EACNC;EACA,GAAIC,IAAW,CAAC,EAAE,YAAY,MAAwBA,EAAS,OAAOC,CAAO,EAAE,CAAC,IAAI,CAAC;EACrF,GAAIC,IAAQ,CAACA,CAAK,IAAI,CAAC;CACzB,GAAG;EAACJ;EAAOC;EAAeC;EAAUE;EAAOL;CAAQ,CAAC;AACtD"}

package/dist/canvas/SceneCanvas/useSceneSelectTool.js

@@ -1,128 +1,124 @@
 import { rectFromPlane as e, toPlane as t } from "../../core/viewport/parallax.js";
-import { meanScale as n } from "../../core/viewport/meanScale.js";
-import { asNodeId as r } from "../../core/scene/types.js";
-import { poseDescriptorForNode as i } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as a } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-import { findShapeInk as o, shapeCoversPoint as s } from "../NodeShape.js";
+import { framedBounds as n, poseDescriptorForNode as r } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as i } from "../../core/geometry/autoPoseDescriptor.js";
+import { findShapeInk as a, shapeCoversPoint as o } from "../NodeShape.js";
+import { asNodeId as s } from "../../core/scene/types.js";
 import { pickWalk as c, scenePickSource as l, scenePlaneOf as u } from "../pickWalk.js";
 import { pickTopMostHit as d } from "../../tools/builtin/pickTopMostHit.js";
 import { useSelectTool as f } from "../../tools/builtin/select/useSelectTool.js";
 import { snap as p } from "../../interactions/gestures/shared/snap.js";
 import { poseContains as m, poseContainsRotated as h } from "./poseGeometry.js";
-import { pathContainsPoint as g } from "@weasel-js/geom";
-import { useMemo as _ } from "react";
-import { useLatest as v } from "@weasel-js/react";
+import { meanScale as g, pathContainsPoint as _ } from "@weasel-js/geom";
+import { useMemo as v } from "react";
+import { useLatest as y } from "@weasel-js/react";
 //#region src/canvas/SceneCanvas/useSceneSelectTool.ts
-var y = 4;
-function b(e) {
+var b = 4;
+function x(e) {
 	return e && typeof e.x == "number" && typeof e.y == "number" ? {
 		x: e.x,
 		y: e.y,
 		scale: e.scale
 	} : null;
 }
-function x(x) {
-	let { scene: S, adapter: C, geometry: w, selectTool: T, getView: E, alphaOf: D, layerIsPainted: O } = x, k = x.poseDescriptor ?? a, A = w?.pickEvery, j = w?.boundsOf, M = (w?.picking ?? "shape") === "shape", N = w?.pickTolerancePx ?? y, P = T?.move, F = T?.snap, I = _(() => {
-		let e = { ...P ?? {} };
-		if (F) {
+function S(S) {
+	let { scene: C, adapter: w, geometry: T, selectTool: E, getView: D, alphaOf: O, layerIsPainted: k } = S, A = S.poseDescriptor ?? i, j = T?.pickEvery, M = T?.boundsOf, N = (T?.picking ?? "shape") === "shape", P = T?.pickTolerancePx ?? b, F = E?.move, I = E?.snap, L = v(() => {
+		let e = { ...F ?? {} };
+		if (I) {
 			let t = e.behaviors ?? [];
-			e.behaviors = [p(F), ...t];
+			e.behaviors = [p(I), ...t];
 		}
 		return e;
-	}, [P, F]), L = _(() => (e, r, i) => {
-		if (A) {
-			let t = A(e, r);
+	}, [F, I]), R = v(() => (e, n, r) => {
+		if (j) {
+			let t = j(e, n);
 			return t == null ? [] : Array.isArray(t) ? t : [t];
 		}
-		let a = i ?? E?.() ?? null, u = i?.alphaOf ?? D, d = i?.layerIsPainted ?? O, f = b(a), p = l(S, {
-			getPose: (e) => C.getWorldPose(e),
-			...u ? { alphaOf: u } : {},
-			...d ? { layerIsPainted: d } : {},
-			...f ? { camera: f } : {}
-		}), _ = (e, r, i) => {
-			let a = n(i), c = {
-				px: N,
-				scale: i
+		let i = r ?? D?.() ?? null, s = r?.alphaOf ?? O, u = r?.layerIsPainted ?? k, d = x(i), f = l(C, {
+			getPose: (e) => w.getWorldPose(e),
+			...s ? { alphaOf: s } : {},
+			...u ? { layerIsPainted: u } : {},
+			...d ? { camera: d } : {}
+		}), p = (e, n, r) => {
+			let i = g(r), s = {
+				px: P,
+				scale: r
 			};
 			return {
-				hits: (t, n, i) => {
-					let l = M ? o(t, n, { scale: a }) : null, u = {
-						...c,
-						px: c.px + (l?.outsetPx ?? 0),
+				hits: (t, r, c) => {
+					let l = N ? a(t, r, { scale: i }) : null, u = {
+						...s,
+						px: s.px + (l?.outsetPx ?? 0),
 						reach: l?.outset ?? 0
 					};
-					return (i ? m(i, e, r, u, k) : h(n, e, r, u, k)) ? !M || s(t, n, e, r, {
-						tolerance: c,
-						scale: a,
-						derivedPath: i
+					return (c ? m(c, e, n, u, A) : h(r, e, n, u, A)) ? !N || o(t, r, e, n, {
+						tolerance: s,
+						scale: i,
+						derivedPath: c
 					}) : !1;
 				},
-				clipAdmits: (t) => g(t, e, r),
-				inPlane: (n) => {
-					let a = t(n, {
+				clipAdmits: (t) => _(t, e, n),
+				inPlane: (i) => {
+					let a = t(i, {
 						x: e,
-						y: r
+						y: n
 					});
-					return _(a.x, a.y, {
-						x: i.x / n.scale.x,
-						y: i.y / n.scale.y
+					return p(a.x, a.y, {
+						x: r.x / i.scale.x,
+						y: r.y / i.scale.y
 					});
 				}
 			};
 		};
-		return c(p, _(e, r, a?.scale ?? {
+		return c(f, p(e, n, i?.scale ?? {
 			x: 1,
 			y: 1
 		}));
 	}, [
-		S,
 		C,
-		A,
-		M,
+		w,
+		j,
 		N,
-		E,
+		P,
 		D,
 		O,
-		k
-	]), R = v(E), z = _(() => (e, t) => {
-		let n = S.get(r(e)), i = b(t ?? R.current?.() ?? null);
-		return !n || !i ? null : u(S.layers, i)?.(n.layer) ?? null;
-	}, [S, R]), B = _(() => (t, n, a) => {
-		let o = S.get(r(t));
+		k,
+		A
+	]), z = y(D), B = v(() => (e, t) => {
+		let n = C.get(s(e)), r = x(t ?? z.current?.() ?? null);
+		return !n || !r ? null : u(C.layers, r)?.(n.layer) ?? null;
+	}, [C, z]), V = v(() => (t, i, a) => {
+		let o = C.get(s(t));
 		if (!o) return null;
-		let s = i(k, o), c = s.getBounds(n), l = s.getRotation?.(n) ?? c.rotation ?? 0, u = l ? {
-			...c,
-			rotation: l
-		} : c, d = z(t, a);
-		return d ? e(d, u) : u;
+		let c = n(i, r(A, o)), l = B(t, a);
+		return l ? e(l, c) : c;
 	}, [
-		S,
-		k,
-		z
-	]), V = _(() => (e, t) => j ? j(e) : S.get(r(e)) ? B(e, C.getWorldPose(e), t) : null, [
-		S,
 		C,
-		j,
+		A,
 		B
+	]), H = v(() => (e, t) => M ? M(e) : C.get(s(e)) ? V(e, w.getWorldPose(e), t) : null, [
+		C,
+		w,
+		M,
+		V
 	]);
 	return {
-		selectTool: f(C, {
-			pickEvery: L,
-			...T?.pickBest ? { pickBest: T.pickBest } : {},
-			...T?.extendClickLocked ? { extendClickLocked: T.extendClickLocked } : {}
+		selectTool: f(w, {
+			pickEvery: R,
+			...E?.pickBest ? { pickBest: E.pickBest } : {},
+			...E?.extendClickLocked ? { extendClickLocked: E.extendClickLocked } : {}
 		}),
-		pickEvery: L,
-		pickBest: _(() => (e, t, n) => {
-			let r = L(e, t, n);
-			return d(r, C);
-		}, [L, C]),
-		boundsOf: V,
-		boundsOfPose: B,
-		planeOfNode: z,
-		moveOptions: I
+		pickEvery: R,
+		pickBest: v(() => (e, t, n) => {
+			let r = R(e, t, n);
+			return d(r, w);
+		}, [R, w]),
+		boundsOf: H,
+		boundsOfPose: V,
+		planeOfNode: B,
+		moveOptions: L
 	};
 }
 //#endregion
-export { y as DEFAULT_PICK_TOLERANCE_PX, x as useSceneSelectTool };
+export { b as DEFAULT_PICK_TOLERANCE_PX, S as useSceneSelectTool };
 
 //# sourceMappingURL=useSceneSelectTool.js.map

package/dist/canvas/SceneCanvas/useSceneSelectTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSceneSelectTool.js","names":["snap","snapBehavior","DEFAULT_PICK_TOLERANCE_PX","cameraOf","v","useSceneSelectTool","opts","args","d","AUTO_POSE_DESCRIPTOR","pickEveryProp","geometry","boundsOfProp","shapePicking","pickTolerancePx","moveOptions","snap$1","wiredMoveOptions","useMemo","merged","existing","snap","wiredHitBody","r","wx","wy","asked","view","getView","viewAlpha","alphaOf","viewLayers","layerIsPainted","camera","src","scenePickSource","scene","adapter","id","pointQuery","scale","meanScale","s","tolerance","ink","findShapeInk","n","pose","slop","derived","poseContains","px","py","poseContainsRotated","shapeCoversPoint","pathContainsPoint","clip","p","toPlane","m","pickWalk","getViewRef","useLatest","wiredPlaneOfNode","asNodeId","scenePlaneOf","wiredBoundsOfPose","g","poseDescriptorForNode","b","rot","own","plane","rectFromPlane","wiredBoundsOf","useSelectTool","ids","pickTopMostHit"],"sources":["../../../src/canvas/SceneCanvas/useSceneSelectTool.ts"],"sourcesContent":["/**\n * Scene-aware select-tool synthesis for `<SceneCanvas>`: a `useSelectTool`\n * over the caller's scene adapter, configured with kit-default pickEvery /\n * boundsOf derived from pose shape. Caller-supplied `pickEvery` / `boundsOf`\n * overrides via the `geometry` arg take precedence.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\nimport { pickWalk, scenePickSource, scenePlaneOf, type PickQuery, type ViewPickGates } from 'canvas/pickWalk';\nimport { rectFromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { pathContainsPoint } from '@weasel-js/geom';\nimport { useSelectTool, type Bounds } from 'tools/builtin/select';\nimport { pickTopMostHit, type PickTopMostHitAdapter } from 'tools/builtin/pickTopMostHit';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport { snap as snapBehavior } from 'interactions/gestures/shared/snap';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { poseContains, poseContainsRotated } from './poseGeometry';\nimport { shapeCoversPoint, findShapeInk } from 'canvas/NodeShape';\nimport { meanScale } from 'core/viewport/meanScale';\n\n/**\n * Default grab slop around a shape's outline, in screen pixels.\n *\n * Four is the same number the path-pose stroke test has always used, and it's\n * the difference between a hairline being clickable and not: a 1px stroke is\n * half a world unit of reach at scale 1, which no pointing device can hit\n * reliably. It also lets a filled shape be grabbed a few pixels outside its\n * edge, which is what makes edge-adjacent dragging feel possible.\n */\nexport const DEFAULT_PICK_TOLERANCE_PX = 4;\n\n/** The view a pick is asked for. A world point carries neither the scale it\n *  was produced under nor what that view paints, so a caller picking for a\n *  view other than the surface's says both. A gate left out is the one this\n *  hook was built with. */\nexport interface PickView extends ViewPickGates {\n  scale: { x: number; y: number };\n  /** The rest of the asking camera. Supplied, it lets a parallax layer be\n   *  picked through its plane; left out, every layer is taken to move with\n   *  the camera. */\n  x?: number;\n  y?: number;\n}\n\n/** A pick view that names a whole camera, or null. */\nfunction cameraOf(v: Pick<PickView, 'scale' | 'x' | 'y'> | null): View | null {\n  return v && typeof v.x === 'number' && typeof v.y === 'number'\n    ? { x: v.x, y: v.y, scale: v.scale }\n    : null;\n}\n\nexport interface UseSceneSelectToolArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** The adapter the select tool drives, built over `scene` with the same\n   *  `poseDescriptor`. Its world poses are what picking and bounds read. */\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  geometry?: {\n    pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n    boundsOf?: (id: string) => Bounds | null;\n    /** How the default body-pick decides a node covers the pointer. Defaults\n     *  to `'shape'`; `'pose'` opts back down to the bare pose rect. See\n     *  `SceneCanvasProps.geometry.picking`. Ignored when `pickEvery` is\n     *  supplied — that override owns the whole test. */\n    picking?: 'pose' | 'shape';\n    /** Grab slop around a shape's outline, in screen pixels. See\n     *  `SceneCanvasProps.geometry.pickTolerancePx`. */\n    pickTolerancePx?: number;\n  };\n  /** The surface's camera, for converting the screen-pixel pick tolerance into\n   *  world units. A caller picking for another view passes that view's camera\n   *  to `pickEvery` / `pickBest` instead. Omitted in tests and non-viewport\n   *  hosts, where scale is 1. */\n  getView?: () => Pick<PickView, 'scale' | 'x' | 'y'> | null;\n  /** The asking view's painted alpha per node — its `alphaFor` times any\n   *  per-node override alpha. A node the view paints at alpha 0 is not on\n   *  screen, so picking must not answer for it. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\".\n   *  `layerVisibility` and `layerOrder` both gate a layer out of the paint\n   *  (`drawLayers` drops any layer missing from a supplied order), and an\n   *  undrawn layer must not claim clicks. */\n  layerIsPainted?: (layer: string) => boolean;\n  selectTool?: {\n    move?: UseMoveOptions<TPose>;\n    resize?: UseResizeOptions<TPose>;\n    snap?: SnapStrategy<TPose>;\n    /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n     *  the live alt state + current selection so consumers can implement\n     *  alt-cycling through an overlapping stack. Default: top-most hit\n     *  (alt ignored). Forwarded verbatim to `useSelectTool`. */\n    pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    /** Forwarded verbatim to `useSelectTool`. See\n     *  `UseSelectToolOptions.extendClickLocked`. */\n    extendClickLocked?: () => boolean;\n  };\n}\n\nexport interface UseSceneSelectToolReturn<TData, TLayer extends string, TPose> {\n  selectTool: ReturnType<typeof useSelectTool<Node<TData, TLayer, TPose>, TPose>>;\n  /** Hit-test resolved with the caller's `geometry.pickEvery` (or the\n   *  pose-walk default). Forward this to `<Canvas pickEvery={...}>` so the\n   *  dispatcher's `getNodeAtPoint` returns the same node the select tool\n   *  picked — drag routes keyed on `target.kind` then resolve to `'*'`\n   *  (move) instead of `'empty'` (marquee). */\n  pickEvery: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** Single-best hit under the world point, or null. Runs `pickEvery` then\n   *  collapses parent/child overlap via `pickTopMostHit` — matches the id\n   *  the select tool's pointerdown classifier would settle on for a bare\n   *  click. Exposed so debug HUDs can highlight the would-be selection. */\n  pickBest: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** World-space AABB of `id`, or null. Same as what the selection overlay +\n   *  affordance hit-test need. Exposed so SceneCanvas can pass it to the\n   *  `affordanceAt` thunk without re-deriving it. `view` is the camera the\n   *  box is drawn under — a plane node sits somewhere else in each — and\n   *  defaults to the surface's. */\n  boundsOf: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** How `view`'s world (the surface's camera by default) maps into the plane\n   *  `id` is drawn through, or null when its layer moves with the camera. */\n  planeOfNode: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) => PlaneMap | null;\n  /** `boundsOf` for `id` drawn at `pose` rather than its own — how chrome\n   *  boxes an in-flight preview. Ignores a `geometry.boundsOf` override, which\n   *  answers only for a node's own pose. */\n  boundsOfPose: (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** `selectTool.move` with `selectTool.snap` folded into its behaviors — what\n   *  the `move` preset's bindings carry. */\n  moveOptions: UseMoveOptions<TPose>;\n}\n\nexport function useSceneSelectTool<TData, TLayer extends string, TPose>(\n  args: UseSceneSelectToolArgs<TData, TLayer, TPose>,\n): UseSceneSelectToolReturn<TData, TLayer, TPose> {\n  const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted } = args;\n  const d = (args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const pickEveryProp = geometry?.pickEvery;\n  const boundsOfProp = geometry?.boundsOf;\n  // Default. The pose rect is the wrong answer for anything that isn't a\n  // rectangle, so `'pose'` is the opt-out rather than the baseline. Cheap to\n  // leave on: the rect pre-filter runs first and rejects every node the\n  // pointer isn't over, and the survivors' silhouettes are memoized per node.\n  const shapePicking = (geometry?.picking ?? 'shape') === 'shape';\n  const pickTolerancePx = geometry?.pickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;\n  const moveOptions = opts?.move;\n  const snap = opts?.snap;\n\n  const wiredMoveOptions = useMemo<UseMoveOptions<TPose>>(() => {\n    const merged: UseMoveOptions<TPose> = { ...(moveOptions ?? {}) };\n    if (snap) {\n      const existing = merged.behaviors ?? [];\n      merged.behaviors = [snapBehavior(snap), ...existing];\n    }\n    return merged;\n  }, [moveOptions, snap]);\n\n  // Default pickEvery: walk renderOrder() forward (back-to-front) and collect\n  // every node whose pose contains the world point. Order matches the\n  // `useSelectTool` contract — last element is the topmost — so `pickTopMostHit`\n  // picks correctly. Wraps the caller's `pickEvery` (string-or-null) into the\n  // array form `useSelectTool` expects. `poseContainsRotated` reads\n  // `pose.rotation` directly (the kit's one rotation convention), so rotated\n  // shapes pick against their rendered, rotated body without a per-demo override.\n  const wiredHitBody = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string[] => {\n      if (pickEveryProp) {\n        const r = pickEveryProp(wx, wy);\n        if (r == null) return [];\n        return Array.isArray(r) ? r : [r];\n      }\n      const asked = view ?? getView?.() ?? null;\n      const viewAlpha = view?.alphaOf ?? alphaOf;\n      const viewLayers = view?.layerIsPainted ?? layerIsPainted;\n      const camera = cameraOf(asked);\n      // Through the adapter, not `n.pose`: an ephemeral override is the pose\n      // the renderer draws, so it has to be the one picking tests. World, not\n      // local, for the same reason — a framed child is drawn in its parent's\n      // frame, not where its own pose says.\n      const src = scenePickSource<TData, TLayer, TPose>(scene, {\n        getPose: (id) => adapter.getWorldPose(id),\n        ...(viewAlpha ? { alphaOf: viewAlpha } : {}),\n        ...(viewLayers ? { layerIsPainted: viewLayers } : {}),\n        ...(camera ? { camera } : {}),\n      });\n      // `s` makes the slop a screen distance, so the grab zone stays the same\n      // apparent thickness at any zoom and on every axis. A `{ px }` stroke's\n      // reach is on screen too, and joins the slop there.\n      const pointQuery = (px: number, py: number, s: { x: number; y: number }): PickQuery<TPose> => {\n        const scale = meanScale(s);\n        const tolerance = { px: pickTolerancePx, scale: s };\n        return {\n          hits: (n, pose, derived) => {\n            // The pre-filter has to be at least as generous as the refinement\n            // that follows it, or it rejects points the refinement would have\n            // claimed. A stroke reaches past the pose box by `outset` — a whole\n            // stroke width for an outer align — on top of the pointer slop.\n            const ink = shapePicking ? findShapeInk(n as never, pose, { scale }) : null;\n            // A derived node's pose is a placeholder — typically zero-sized at\n            // the origin — so its own box rejects every point the path covers.\n            // The path is the region to test instead, and `poseContains` already\n            // reads a path-like pose as one.\n            const slop = { ...tolerance, px: tolerance.px + (ink?.outsetPx ?? 0), reach: ink?.outset ?? 0 };\n            const admitted = derived\n              ? poseContains(derived as never, px, py, slop, d as PoseDescriptor<unknown>)\n              : poseContainsRotated(pose, px, py, slop, d as PoseDescriptor<unknown>);\n            if (!admitted) return false;\n            // `shapeCoversPoint` narrows the rect to the ink the painter actually\n            // lays down (and answers `true` for painters that have no silhouette,\n            // so nothing becomes unpickable).\n            return !shapePicking\n              || shapeCoversPoint(n as never, pose, px, py, {\n                tolerance, scale, derivedPath: derived,\n              });\n          },\n          clipAdmits: (clip) => pathContainsPoint(clip, px, py),\n          inPlane: (m) => {\n            const p = toPlane(m, { x: px, y: py });\n            return pointQuery(p.x, p.y, { x: s.x / m.scale.x, y: s.y / m.scale.y });\n          },\n        };\n      };\n      return pickWalk<TPose>(src, pointQuery(wx, wy, asked?.scale ?? { x: 1, y: 1 }));\n    };\n  }, [scene, adapter, pickEveryProp, shapePicking, pickTolerancePx, getView,\n      alphaOf, layerIsPainted, d]);\n\n  // Read through a ref: this is the chrome's bounds source, and a caller's\n  // inline `getView` would otherwise rebuild it, and everything keyed on it,\n  // every render.\n  const getViewRef = useLatest(getView);\n  const wiredPlaneOfNode = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): PlaneMap | null => {\n      const n = scene.get(asNodeId(id));\n      const camera = cameraOf(view ?? getViewRef.current?.() ?? null);\n      if (!n || !camera) return null;\n      return scenePlaneOf(scene.layers, camera)?.(n.layer) ?? null;\n    };\n  }, [scene, getViewRef]);\n\n  const wiredBoundsOfPose = useMemo(() => {\n    return (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      const n = scene.get(asNodeId(id));\n      if (!n) return null;\n      const g = poseDescriptorForNode(d, n);\n      const b = g.getBounds(pose);\n      const rot = g.getRotation?.(pose) ?? (b as { rotation?: number }).rotation ?? 0;\n      const own = rot ? { ...b, rotation: rot } : b;\n      // A plane node is drawn where its plane puts it, and the chrome has to\n      // follow it there.\n      const plane = wiredPlaneOfNode(id, view);\n      return plane ? rectFromPlane(plane, own) : own;\n    };\n  }, [scene, d, wiredPlaneOfNode]);\n\n  const wiredBoundsOf = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      if (boundsOfProp) return boundsOfProp(id);\n      if (!scene.get(asNodeId(id))) return null;\n      // World, not local: a framed child is drawn in its parent's frame, and\n      // the chrome has to land on the ink.\n      return wiredBoundsOfPose(id, adapter.getWorldPose(id), view);\n    };\n  }, [scene, adapter, boundsOfProp, wiredBoundsOfPose]);\n\n  const selectTool = useSelectTool<Node<TData, TLayer, TPose>, TPose>(adapter, {\n    pickEvery: wiredHitBody,\n    ...(opts?.pickBest ? { pickBest: opts.pickBest } : {}),\n    ...(opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}),\n  });\n\n\n  const wiredPickBest = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string | null => {\n      const ids = wiredHitBody(wx, wy, view);\n      return pickTopMostHit(ids, adapter as unknown as PickTopMostHitAdapter);\n    };\n  }, [wiredHitBody, adapter]);\n\n  return {\n    selectTool,\n    pickEvery: wiredHitBody,\n    pickBest: wiredPickBest,\n    boundsOf: wiredBoundsOf,\n    boundsOfPose: wiredBoundsOfPose,\n    planeOfNode: wiredPlaneOfNode,\n    moveOptions: wiredMoveOptions,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"useSceneSelectTool.js","names":["snap","snapBehavior","DEFAULT_PICK_TOLERANCE_PX","cameraOf","v","useSceneSelectTool","opts","args","d","AUTO_POSE_DESCRIPTOR","pickEveryProp","geometry","boundsOfProp","shapePicking","pickTolerancePx","moveOptions","snap$1","wiredMoveOptions","useMemo","merged","existing","snap","wiredHitBody","r","wx","wy","asked","view","getView","viewAlpha","alphaOf","viewLayers","layerIsPainted","camera","src","scenePickSource","scene","adapter","id","pointQuery","scale","meanScale","s","tolerance","ink","findShapeInk","n","pose","slop","derived","poseContains","px","py","poseContainsRotated","shapeCoversPoint","pathContainsPoint","clip","p","toPlane","m","pickWalk","getViewRef","useLatest","wiredPlaneOfNode","asNodeId","scenePlaneOf","wiredBoundsOfPose","own","framedBounds","poseDescriptorForNode","plane","rectFromPlane","wiredBoundsOf","useSelectTool","ids","pickTopMostHit"],"sources":["../../../src/canvas/SceneCanvas/useSceneSelectTool.ts"],"sourcesContent":["/**\n * Scene-aware select-tool synthesis for `<SceneCanvas>`: a `useSelectTool`\n * over the caller's scene adapter, configured with kit-default pickEvery /\n * boundsOf derived from pose shape. Caller-supplied `pickEvery` / `boundsOf`\n * overrides via the `geometry` arg take precedence.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\nimport { pickWalk, scenePickSource, scenePlaneOf, type PickQuery, type ViewPickGates } from 'canvas/pickWalk';\nimport { rectFromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { pathContainsPoint } from '@weasel-js/geom';\nimport { useSelectTool, type Bounds } from 'tools/builtin/select';\nimport { pickTopMostHit, type PickTopMostHitAdapter } from 'tools/builtin/pickTopMostHit';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport { snap as snapBehavior } from 'interactions/gestures/shared/snap';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { poseContains, poseContainsRotated } from './poseGeometry';\nimport { shapeCoversPoint, findShapeInk } from 'canvas/NodeShape';\nimport { meanScale } from '@weasel-js/geom';\n\n/**\n * Default grab slop around a shape's outline, in screen pixels.\n *\n * Four is the same number the path-pose stroke test has always used, and it's\n * the difference between a hairline being clickable and not: a 1px stroke is\n * half a world unit of reach at scale 1, which no pointing device can hit\n * reliably. It also lets a filled shape be grabbed a few pixels outside its\n * edge, which is what makes edge-adjacent dragging feel possible.\n */\nexport const DEFAULT_PICK_TOLERANCE_PX = 4;\n\n/** The view a pick is asked for. A world point carries neither the scale it\n *  was produced under nor what that view paints, so a caller picking for a\n *  view other than the surface's says both. A gate left out is the one this\n *  hook was built with. */\nexport interface PickView extends ViewPickGates {\n  scale: { x: number; y: number };\n  /** The rest of the asking camera. Supplied, it lets a parallax layer be\n   *  picked through its plane; left out, every layer is taken to move with\n   *  the camera. */\n  x?: number;\n  y?: number;\n}\n\n/** A pick view that names a whole camera, or null. */\nfunction cameraOf(v: Pick<PickView, 'scale' | 'x' | 'y'> | null): View | null {\n  return v && typeof v.x === 'number' && typeof v.y === 'number'\n    ? { x: v.x, y: v.y, scale: v.scale }\n    : null;\n}\n\nexport interface UseSceneSelectToolArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** The adapter the select tool drives, built over `scene` with the same\n   *  `poseDescriptor`. Its world poses are what picking and bounds read. */\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  geometry?: {\n    pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n    boundsOf?: (id: string) => Bounds | null;\n    /** How the default body-pick decides a node covers the pointer. Defaults\n     *  to `'shape'`; `'pose'` opts back down to the bare pose rect. See\n     *  `SceneCanvasProps.geometry.picking`. Ignored when `pickEvery` is\n     *  supplied — that override owns the whole test. */\n    picking?: 'pose' | 'shape';\n    /** Grab slop around a shape's outline, in screen pixels. See\n     *  `SceneCanvasProps.geometry.pickTolerancePx`. */\n    pickTolerancePx?: number;\n  };\n  /** The surface's camera, for converting the screen-pixel pick tolerance into\n   *  world units. A caller picking for another view passes that view's camera\n   *  to `pickEvery` / `pickBest` instead. Omitted in tests and non-viewport\n   *  hosts, where scale is 1. */\n  getView?: () => Pick<PickView, 'scale' | 'x' | 'y'> | null;\n  /** The asking view's painted alpha per node — its `alphaFor` times any\n   *  per-node override alpha. A node the view paints at alpha 0 is not on\n   *  screen, so picking must not answer for it. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\".\n   *  `layerVisibility` and `layerOrder` both gate a layer out of the paint\n   *  (`drawLayers` drops any layer missing from a supplied order), and an\n   *  undrawn layer must not claim clicks. */\n  layerIsPainted?: (layer: string) => boolean;\n  selectTool?: {\n    move?: UseMoveOptions<TPose>;\n    resize?: UseResizeOptions<TPose>;\n    snap?: SnapStrategy<TPose>;\n    /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n     *  the live alt state + current selection so consumers can implement\n     *  alt-cycling through an overlapping stack. Default: top-most hit\n     *  (alt ignored). Forwarded verbatim to `useSelectTool`. */\n    pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    /** Forwarded verbatim to `useSelectTool`. See\n     *  `UseSelectToolOptions.extendClickLocked`. */\n    extendClickLocked?: () => boolean;\n  };\n}\n\nexport interface UseSceneSelectToolReturn<TData, TLayer extends string, TPose> {\n  selectTool: ReturnType<typeof useSelectTool<Node<TData, TLayer, TPose>, TPose>>;\n  /** Every id under the world point, back-to-front (topmost last), from the\n   *  caller's `geometry.pickEvery` or the pose-walk default. */\n  pickEvery: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** Single-best hit under the world point, or null. Runs `pickEvery` then\n   *  collapses parent/child overlap via `pickTopMostHit` — matches the id\n   *  the select tool's pointerdown classifier would settle on for a bare\n   *  click. The canvas's `getNodeAtPoint` resolves through it. */\n  pickBest: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** World-space AABB of `id`, or null. Same as what the selection overlay +\n   *  affordance hit-test need. Exposed so SceneCanvas can pass it to the\n   *  `affordanceAt` thunk without re-deriving it. `view` is the camera the\n   *  box is drawn under — a plane node sits somewhere else in each — and\n   *  defaults to the surface's. */\n  boundsOf: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** How `view`'s world (the surface's camera by default) maps into the plane\n   *  `id` is drawn through, or null when its layer moves with the camera. */\n  planeOfNode: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) => PlaneMap | null;\n  /** `boundsOf` for `id` drawn at `pose` rather than its own — how chrome\n   *  boxes an in-flight preview. Ignores a `geometry.boundsOf` override, which\n   *  answers only for a node's own pose. */\n  boundsOfPose: (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** `selectTool.move` with `selectTool.snap` folded into its behaviors — what\n   *  the `move` preset's bindings carry. */\n  moveOptions: UseMoveOptions<TPose>;\n}\n\nexport function useSceneSelectTool<TData, TLayer extends string, TPose>(\n  args: UseSceneSelectToolArgs<TData, TLayer, TPose>,\n): UseSceneSelectToolReturn<TData, TLayer, TPose> {\n  const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted } = args;\n  const d = (args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const pickEveryProp = geometry?.pickEvery;\n  const boundsOfProp = geometry?.boundsOf;\n  // Default. The pose rect is the wrong answer for anything that isn't a\n  // rectangle, so `'pose'` is the opt-out rather than the baseline. Cheap to\n  // leave on: the rect pre-filter runs first and rejects every node the\n  // pointer isn't over, and the survivors' silhouettes are memoized per node.\n  const shapePicking = (geometry?.picking ?? 'shape') === 'shape';\n  const pickTolerancePx = geometry?.pickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;\n  const moveOptions = opts?.move;\n  const snap = opts?.snap;\n\n  const wiredMoveOptions = useMemo<UseMoveOptions<TPose>>(() => {\n    const merged: UseMoveOptions<TPose> = { ...(moveOptions ?? {}) };\n    if (snap) {\n      const existing = merged.behaviors ?? [];\n      merged.behaviors = [snapBehavior(snap), ...existing];\n    }\n    return merged;\n  }, [moveOptions, snap]);\n\n  // Default pickEvery: walk renderOrder() forward (back-to-front) and collect\n  // every node whose pose contains the world point. Order matches the\n  // `useSelectTool` contract — last element is the topmost — so `pickTopMostHit`\n  // picks correctly. Wraps the caller's `pickEvery` (string-or-null) into the\n  // array form `useSelectTool` expects. `poseContainsRotated` reads\n  // `pose.rotation` directly (the kit's one rotation convention), so rotated\n  // shapes pick against their rendered, rotated body without a per-demo override.\n  const wiredHitBody = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string[] => {\n      if (pickEveryProp) {\n        const r = pickEveryProp(wx, wy);\n        if (r == null) return [];\n        return Array.isArray(r) ? r : [r];\n      }\n      const asked = view ?? getView?.() ?? null;\n      const viewAlpha = view?.alphaOf ?? alphaOf;\n      const viewLayers = view?.layerIsPainted ?? layerIsPainted;\n      const camera = cameraOf(asked);\n      // Through the adapter, not `n.pose`: an ephemeral override is the pose\n      // the renderer draws, so it has to be the one picking tests. World, not\n      // local, for the same reason — a framed child is drawn in its parent's\n      // frame, not where its own pose says.\n      const src = scenePickSource<TData, TLayer, TPose>(scene, {\n        getPose: (id) => adapter.getWorldPose(id),\n        ...(viewAlpha ? { alphaOf: viewAlpha } : {}),\n        ...(viewLayers ? { layerIsPainted: viewLayers } : {}),\n        ...(camera ? { camera } : {}),\n      });\n      // `s` makes the slop a screen distance, so the grab zone stays the same\n      // apparent thickness at any zoom and on every axis. A `{ px }` stroke's\n      // reach is on screen too, and joins the slop there.\n      const pointQuery = (px: number, py: number, s: { x: number; y: number }): PickQuery<TPose> => {\n        const scale = meanScale(s);\n        const tolerance = { px: pickTolerancePx, scale: s };\n        return {\n          hits: (n, pose, derived) => {\n            // The pre-filter has to be at least as generous as the refinement\n            // that follows it, or it rejects points the refinement would have\n            // claimed. A stroke reaches past the pose box by `outset` — a whole\n            // stroke width for an outer align — on top of the pointer slop.\n            const ink = shapePicking ? findShapeInk(n as never, pose, { scale }) : null;\n            // A derived node's pose is a placeholder — typically zero-sized at\n            // the origin — so its own box rejects every point the path covers.\n            // The path is the region to test instead, and `poseContains` already\n            // reads a path-like pose as one.\n            const slop = { ...tolerance, px: tolerance.px + (ink?.outsetPx ?? 0), reach: ink?.outset ?? 0 };\n            const admitted = derived\n              ? poseContains(derived as never, px, py, slop, d as PoseDescriptor<unknown>)\n              : poseContainsRotated(pose, px, py, slop, d as PoseDescriptor<unknown>);\n            if (!admitted) return false;\n            // `shapeCoversPoint` narrows the rect to the ink the painter actually\n            // lays down (and answers `true` for painters that have no silhouette,\n            // so nothing becomes unpickable).\n            return !shapePicking\n              || shapeCoversPoint(n as never, pose, px, py, {\n                tolerance, scale, derivedPath: derived,\n              });\n          },\n          clipAdmits: (clip) => pathContainsPoint(clip, px, py),\n          inPlane: (m) => {\n            const p = toPlane(m, { x: px, y: py });\n            return pointQuery(p.x, p.y, { x: s.x / m.scale.x, y: s.y / m.scale.y });\n          },\n        };\n      };\n      return pickWalk<TPose>(src, pointQuery(wx, wy, asked?.scale ?? { x: 1, y: 1 }));\n    };\n  }, [scene, adapter, pickEveryProp, shapePicking, pickTolerancePx, getView,\n      alphaOf, layerIsPainted, d]);\n\n  // Read through a ref: this is the chrome's bounds source, and a caller's\n  // inline `getView` would otherwise rebuild it, and everything keyed on it,\n  // every render.\n  const getViewRef = useLatest(getView);\n  const wiredPlaneOfNode = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): PlaneMap | null => {\n      const n = scene.get(asNodeId(id));\n      const camera = cameraOf(view ?? getViewRef.current?.() ?? null);\n      if (!n || !camera) return null;\n      return scenePlaneOf(scene.layers, camera)?.(n.layer) ?? null;\n    };\n  }, [scene, getViewRef]);\n\n  const wiredBoundsOfPose = useMemo(() => {\n    return (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      const n = scene.get(asNodeId(id));\n      if (!n) return null;\n      const own = framedBounds(pose, poseDescriptorForNode(d, n));\n      // A plane node is drawn where its plane puts it, and the chrome has to\n      // follow it there.\n      const plane = wiredPlaneOfNode(id, view);\n      return plane ? rectFromPlane(plane, own) : own;\n    };\n  }, [scene, d, wiredPlaneOfNode]);\n\n  const wiredBoundsOf = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      if (boundsOfProp) return boundsOfProp(id);\n      if (!scene.get(asNodeId(id))) return null;\n      // World, not local: a framed child is drawn in its parent's frame, and\n      // the chrome has to land on the ink.\n      return wiredBoundsOfPose(id, adapter.getWorldPose(id), view);\n    };\n  }, [scene, adapter, boundsOfProp, wiredBoundsOfPose]);\n\n  const selectTool = useSelectTool<Node<TData, TLayer, TPose>, TPose>(adapter, {\n    pickEvery: wiredHitBody,\n    ...(opts?.pickBest ? { pickBest: opts.pickBest } : {}),\n    ...(opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}),\n  });\n\n\n  const wiredPickBest = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string | null => {\n      const ids = wiredHitBody(wx, wy, view);\n      return pickTopMostHit(ids, adapter as unknown as PickTopMostHitAdapter);\n    };\n  }, [wiredHitBody, adapter]);\n\n  return {\n    selectTool,\n    pickEvery: wiredHitBody,\n    pickBest: wiredPickBest,\n    boundsOf: wiredBoundsOf,\n    boundsOfPose: wiredBoundsOfPose,\n    planeOfNode: wiredPlaneOfNode,\n    moveOptions: wiredMoveOptions,\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useSceneSlotLayers.js

@@ -0,0 +1,37 @@
+import { isCustomEntry as e } from "../layerSlots.js";
+import { buildSceneLayers as t } from "../buildSceneLayer.js";
+import { wireSceneSlotToScene as n } from "../sceneSlotWiring.js";
+import { useSceneLayerList as r } from "../useSceneLayerList.js";
+import { useMemo as i } from "react";
+//#region src/canvas/SceneCanvas/useSceneSlotLayers.ts
+function a(a) {
+	let { slot: o, scene: s, adapter: c, alphaFor: l, colorOverrides: u, boundsOf: d, previewIds: f } = a, p = i(() => !o || e(o) ? o : n(o, s, l, u), [
+		o,
+		l,
+		s,
+		u
+	]), m = r(c);
+	return {
+		config: p,
+		layers: i(() => {
+			if (e(p)) return { layers: [{
+				key: "scene",
+				layer: p.layer
+			}] };
+			if (p && p.drawOne) return { layers: t(p, c, d, () => {
+				let e = new Set(f() ?? []);
+				return e.size > 0 ? e : null;
+			}) };
+		}, [
+			p,
+			c,
+			d,
+			f,
+			m
+		])
+	};
+}
+//#endregion
+export { a as useSceneSlotLayers };
+
+//# sourceMappingURL=useSceneSlotLayers.js.map

package/dist/canvas/SceneCanvas/useSceneSlotLayers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneSlotLayers.js","names":["useSceneSlotLayers","args","config","useMemo","slot","isCustomEntry","wireSceneSlotToScene","scene","alphaFor","colorOverrides","sceneLayersKey","useSceneLayerList","adapter","buildSceneLayers","boundsOf","ids","previewIds"],"sources":["../../../src/canvas/SceneCanvas/useSceneSlotLayers.ts"],"sourcesContent":["/**\n * The scene slot, built: the caller's config wired to the scene, and the\n * canvas layers it paints as. A hierarchical scene gets one canvas layer per\n * scene layer, so the list follows the scene's layers after mount.\n */\nimport { useMemo } from 'react';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { Node, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { buildSceneLayers, type SceneSlotConfig } from '../buildSceneLayer';\nimport type { HierarchicalAdapter } from '../buildSceneTree';\nimport { isCustomEntry, type LayersMap, type SceneSlotLayers } from '../layerSlots';\nimport { wireSceneSlotToScene } from '../sceneSlotWiring';\nimport { useSceneLayerList } from '../useSceneLayerList';\n\ntype SceneSlot<TData, TLayer extends string, TPose> =\n  LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n\nexport function useSceneSlotLayers<TData, TLayer extends string, TPose>(args: {\n  /** The slot after `mergeLayersWithDefaults`. */\n  slot: SceneSlot<TData, TLayer, TPose>;\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n  alphaFor: ((id: string) => number) | undefined;\n  colorOverrides: ColorOverrideRegistry | undefined;\n  /** Committed bounds of a node, for the debug overlay's record of it. */\n  boundsOf: (id: string) => Bounds | null;\n  /** Ids an in-flight gesture is ghosting; their committed paint is left out\n   *  so the source does not show through the ghost. */\n  previewIds: () => Iterable<string> | null;\n}): {\n  /** The scene-wired config, for whatever else paints with its `drawOne`. */\n  config: SceneSlot<TData, TLayer, TPose>;\n  /** Absent when the slot is empty or carries no `drawOne`; a pre-built layer is the whole slot. */\n  layers: SceneSlotLayers | undefined;\n} {\n  const { slot, scene, adapter, alphaFor, colorOverrides, boundsOf, previewIds } = args;\n\n  const config = useMemo(() => {\n    if (!slot || isCustomEntry(slot)) return slot;\n    return wireSceneSlotToScene(\n      slot as SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n      scene,\n      alphaFor,\n      colorOverrides,\n    );\n  }, [slot, alphaFor, scene, colorOverrides]);\n\n  const sceneLayersKey = useSceneLayerList(adapter);\n  const layers = useMemo<SceneSlotLayers | undefined>(() => {\n    if (isCustomEntry(config)) return { layers: [{ key: 'scene', layer: config.layer }] };\n    if (!config || !config.drawOne) return undefined;\n    return {\n      layers: buildSceneLayers(config, adapter, boundsOf, () => {\n        const ids = new Set(previewIds() ?? []);\n        return ids.size > 0 ? ids : null;\n      }),\n    };\n    // `sceneLayersKey` stands for `adapter.getLayers()`, which `buildSceneLayers` reads.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [config, adapter, boundsOf, previewIds, sceneLayersKey]);\n\n  return { config, layers };\n}\n"],"mappings":";;;;;;AAkBA,SAAgBA,EAAwD,GAiBtE;CACA,IAAM,EAAE,SAAM,UAAO,YAAS,aAAU,mBAAgB,aAAU,kBAAeC,GAE3EC,IAASC,QACT,CAACC,KAAQC,EAAcD,CAAI,IAAUA,IAClCE,EACLF,GACAG,GACAC,GACAC,CACF,GACC;EAACL;EAAMI;EAAUD;EAAOE;CAAc,CAAC,GAEpCC,IAAiBC,EAAkBC,CAAO;CAchD,OAAO;EAAE;EAAQ,QAbFT,QAA2C;GACxD,IAAIE,EAAcH,CAAM,GAAG,OAAO,EAAE,QAAQ,CAAC;IAAE,KAAK;IAAS,OAAOA,EAAO;GAAM,CAAC,EAAE;GACpF,IAAKA,KAAWA,EAAO,SACvB,OAAO,EACL,QAAQW,EAAiBX,GAAQU,GAASE,SAAgB;IACxD,IAAMC,IAAM,IAAI,IAAIC,EAAW,KAAK,CAAC,CAAC;IACtC,OAAOD,EAAI,OAAO,IAAIA,IAAM;GAC9B,CAAC,EACH;EAGF,GAAG;GAACb;GAAQU;GAASE;GAAUE;GAAYN;EAAc,CAExC;CAAO;AAC1B"}

package/dist/canvas/SceneCanvas/useSelectionOverlayLayer.js

@@ -0,0 +1,38 @@
+import { isCustomEntry as e } from "../layerSlots.js";
+import { createSelectionOverlayLayer as t, rotationBadgeOf as n } from "../../features/selection/overlay.js";
+import { useMemo as r } from "react";
+//#region src/canvas/SceneCanvas/useSelectionOverlayLayer.ts
+function i(i, a, o) {
+	let s = i && !e(i) ? n(i) : null, c = r(() => s, [s?.distancePx, s?.sizePx]);
+	return {
+		layer: r(() => {
+			if (i === null) return null;
+			if (e(i)) return i.layer;
+			let n = i ?? {}, r = n.getSuppressedIds, s = () => {
+				let e = a(), t = r?.();
+				if (!t || t.size === 0) return e;
+				if (e.size === 0) return t;
+				let n = new Set(t);
+				for (let t of e) n.add(t);
+				return n;
+			};
+			return t({
+				...n,
+				getSuppressedIds: s,
+				...n.poseById ? {
+					getPose: n.poseById,
+					poseDescriptor: n.poseDescriptor ?? o
+				} : {}
+			});
+		}, [
+			i,
+			a,
+			o
+		]),
+		rotationBadge: c
+	};
+}
+//#endregion
+export { i as useSelectionOverlayLayer };
+
+//# sourceMappingURL=useSelectionOverlayLayer.js.map

package/dist/canvas/SceneCanvas/useSelectionOverlayLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelectionOverlayLayer.js","names":["useSelectionOverlayLayer","badge","slot","isCustomEntry","rotationBadgeOf","rotationBadge","useMemo","cfg","callerSuppress","getSuppressedIds","own","getOwnSuppressedIds","caller","merged","id","createSelectionOverlayLayer","poseDescriptor"],"sources":["../../../src/canvas/SceneCanvas/useSelectionOverlayLayer.ts"],"sourcesContent":["/**\n * The selection-overlay slot, built, and where it paints its rotate badge.\n * Both are `null` when the slot is switched off, and a pre-built layer has no badge.\n */\nimport { useMemo } from 'react';\nimport type { RenderLayer } from 'core/layers/render';\nimport { createSelectionOverlayLayer, rotationBadgeOf } from 'features/selection/overlay';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { isCustomEntry, type CustomLayerEntry, type SelectionOverlaySlotConfig } from '../layerSlots';\n\nexport function useSelectionOverlayLayer<TPose>(\n  /** The slot after `mergeLayersWithDefaults`. */\n  slot: SelectionOverlaySlotConfig<TPose> | CustomLayerEntry | null | undefined,\n  /** Ids whose outline and handles other chrome replaces, on top of the\n   *  slot's own `getSuppressedIds`: the node whose anchors are being edited. */\n  getOwnSuppressedIds: () => ReadonlySet<string>,\n  /** What a slot's `poseById` is projected with when it names no descriptor. */\n  poseDescriptor: PoseDescriptor<TPose>,\n): {\n  layer: RenderLayer<unknown> | null;\n  rotationBadge: ReturnType<typeof rotationBadgeOf>;\n} {\n  const badge = slot && !isCustomEntry(slot) ? rotationBadgeOf(slot) : null;\n  // Kept by value so the layers and hit-testers keyed on it don't rebuild\n  // every render.\n  const rotationBadge = useMemo(\n    () => badge,\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [badge?.distancePx, badge?.sizePx],\n  );\n  const layer = useMemo(() => {\n    if (slot === null) return null;\n    if (isCustomEntry(slot)) return slot.layer;\n    const cfg = slot ?? {};\n    const callerSuppress = cfg.getSuppressedIds;\n    const getSuppressedIds = (): ReadonlySet<string> => {\n      const own = getOwnSuppressedIds();\n      const caller = callerSuppress?.();\n      if (!caller || caller.size === 0) return own;\n      if (own.size === 0) return caller;\n      const merged = new Set<string>(caller);\n      for (const id of own) merged.add(id);\n      return merged;\n    };\n    return createSelectionOverlayLayer<TPose>({\n      ...cfg,\n      getSuppressedIds,\n      // A caller's pose lookup still needs a geometry to project with; without\n      // one the layer reads bounds off the chrome state and calls neither.\n      ...(cfg.poseById\n        ? { getPose: cfg.poseById, poseDescriptor: cfg.poseDescriptor ?? poseDescriptor }\n        : {}),\n    });\n  }, [slot, getOwnSuppressedIds, poseDescriptor]);\n  return { layer, rotationBadge };\n}\n"],"mappings":";;;;AAUA,SAAgBA,EAEd,GAGA,GAEA,GAIA;CACA,IAAMC,IAAQC,KAAQ,CAACC,EAAcD,CAAI,IAAIE,EAAgBF,CAAI,IAAI,MAG/DG,IAAgBC,QACdL,GAEN,CAACA,GAAO,YAAYA,GAAO,MAAM,CACnC;CAyBA,OAAO;EAAE,OAxBKK,QAAc;GAC1B,IAAIJ,MAAS,MAAM,OAAO;GAC1B,IAAIC,EAAcD,CAAI,GAAG,OAAOA,EAAK;GACrC,IAAMK,IAAML,KAAQ,CAAC,GACfM,IAAiBD,EAAI,kBACrBE,UAA8C;IAClD,IAAMC,IAAMC,EAAoB,GAC1BC,IAASJ,IAAiB;IAChC,IAAI,CAACI,KAAUA,EAAO,SAAS,GAAG,OAAOF;IACzC,IAAIA,EAAI,SAAS,GAAG,OAAOE;IAC3B,IAAMC,IAAS,IAAI,IAAYD,CAAM;IACrC,KAAK,IAAME,KAAMJ,GAAK,EAAO,IAAII,CAAE;IACnC,OAAOD;GACT;GACA,OAAOE,EAAmC;IACxC,GAAGR;IACH;IAGA,GAAIA,EAAI,WACJ;KAAE,SAASA,EAAI;KAAU,gBAAgBA,EAAI,kBAAkBS;IAAe,IAC9E,CAAC;GACP,CAAC;EACH,GAAG;GAACd;GAAMS;GAAqBK;EAAc,CACpC;EAAO;CAAc;AAChC"}

package/dist/canvas/SceneCanvas/useViewLayerGate.js

@@ -0,0 +1,20 @@
+import { createSceneLayerGate as e } from "../sceneLayerPaint.js";
+import { useOptionalViewRegistry as t } from "../viewRegistry.js";
+import { useCallback as n, useState as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useViewLayerGate.ts
+function a(a, o) {
+	let s = t(), c = i({
+		layerVisibility: a,
+		layerOrder: o
+	}), [l] = r(e), u = n((e) => l(s?.surface()?.layers() ?? [], c.current)(e), [
+		s,
+		l,
+		c
+	]);
+	return a !== void 0 || o !== void 0 ? u : void 0;
+}
+//#endregion
+export { a as useViewLayerGate };
+
+//# sourceMappingURL=useViewLayerGate.js.map

package/dist/canvas/SceneCanvas/useViewLayerGate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewLayerGate.js","names":["useViewLayerGate","surfaceViewRegistry","useOptionalViewRegistry","layerPaintRef","useLatest","sceneLayerGate","useState","createSceneLayerGate","layerIsPainted","useCallback","layerId","layerVisibility","layerOrder"],"sources":["../../../src/canvas/SceneCanvas/useViewLayerGate.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { createSceneLayerGate, type ViewLayerPaint } from '../sceneLayerPaint';\nimport { useOptionalViewRegistry } from '../viewRegistry';\n\n/**\n * Whether the surface's own view paints a scene layer, judged against the\n * stack `<Canvas>` composed and read at pick time, so a consumer slot anchored\n * between scene layers is weighed the way paint weighs it. Undefined when the\n * view hides nothing, so a pick walk skips the gate.\n */\nexport function useViewLayerGate(\n  layerVisibility: ViewLayerPaint['layerVisibility'],\n  layerOrder: ViewLayerPaint['layerOrder'],\n): ((layerId: string) => boolean) | undefined {\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  const layerPaintRef = useLatest<ViewLayerPaint>({ layerVisibility, layerOrder });\n  const [sceneLayerGate] = useState(createSceneLayerGate);\n  const layerIsPainted = useCallback((layerId: string): boolean => (\n    sceneLayerGate(surfaceViewRegistry?.surface()?.layers() ?? [], layerPaintRef.current)(layerId)\n  ), [surfaceViewRegistry, sceneLayerGate, layerPaintRef]);\n  return layerVisibility !== undefined || layerOrder !== undefined ? layerIsPainted : undefined;\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EACd,GACA,GAC4C;CAC5C,IAAMC,IAAsBC,EAAwB,GAC9CC,IAAgBC,EAA0B;EAAE;EAAiB;CAAW,CAAC,GACzE,CAACC,KAAkBC,EAASC,CAAoB,GAChDC,IAAiBC,GAAa,MAClCJ,EAAeJ,GAAqB,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC,GAAGE,EAAc,OAAO,CAAC,CAACO,CAAO,GAC5F;EAACT;EAAqBI;EAAgBF;CAAa,CAAC;CACvD,OAAOQ,MAAoB,KAAA,KAAaC,MAAe,KAAA,IAAYJ,IAAiB,KAAA;AACtF"}

package/dist/canvas/SceneCanvas/useViewportActions.js

@@ -24,7 +24,15 @@ function o(o) {
 		m
 	]);
 }
+function s(e, t) {
+	if (e === !1) return !1;
+	let n = typeof e == "object" ? e : {};
+	return t ? {
+		...n,
+		animate: t === !0 ? {} : t
+	} : n;
+}
 //#endregion
-export { o as useViewportActions };
+export { o as useViewportActions, s as viewportZoomOption };
 
 //# sourceMappingURL=useViewportActions.js.map

package/dist/canvas/SceneCanvas/useViewportActions.js.map

@@ -1 +1 @@
-{"version":3,"file":"useViewportActions.js","names":["useViewportActions","args","reg","useActionsRegistry","regRef","useLatest","panKey","pan","zoomKey","zoom","pinchKey","pinchZoom","unregisters","makeViewportWheelPanAction","zoomAction","makeViewportZoomAction","makePinchZoomAction","u"],"sources":["../../../src/canvas/SceneCanvas/useViewportActions.ts"],"sourcesContent":["/**\n * `useViewportActions` — register the `viewport.pan`, `viewport.zoom` and\n * `viewport.pinchZoom` action descriptors from SceneCanvas's `viewport` prop.\n *\n * All three need the `view` dep that only SceneCanvas publishes via\n * `useViewDepSource`. `pan` and `zoom` live outside `KIT_STANDARD_DESCRIPTORS`\n * entirely and are registered here; `pinchZoom` is in that list (bare\n * `useStandardActions` consumers get it too), so this hook only re-registers a\n * clamp-configured one over it, or takes it away.\n *\n * Defaults: all three ON when omitted. Pass `pan: false` / `zoom: false` /\n * `pinchZoom: false` on the `viewport` prop to disable. Disabling mutes rather\n * than unregisters, so a sibling canvas sharing the registry keeps its own.\n *\n * Runs after `useStandardActions` in the same component, so the registry's\n * last-writer-wins ordering resolves the `pinchZoom` overlap.\n */\nimport { useEffect } from 'react';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport {\n  makeViewportWheelPanAction,\n  type WheelPanOptions,\n} from 'interactions/actions/defaults/viewportWheelPan';\nimport {\n  makeViewportZoomAction,\n  type ViewportZoomOptions,\n} from 'interactions/actions/defaults/viewportZoom';\nimport {\n  makePinchZoomAction,\n  type PinchZoomOptions,\n} from 'interactions/actions/defaults/pinchZoom';\n\nexport function useViewportActions(args: {\n  /** `true`/`false` toggles wheel pan; an object locks its axis (see\n   *  {@link WheelPanOptions}). */\n  pan: boolean | WheelPanOptions;\n  /** `true`/`false` toggles the default Cmd+wheel zoom; an object tunes the\n   *  wheel trigger + scale clamp (see {@link ViewportZoomOptions}). */\n  zoom: boolean | ViewportZoomOptions;\n  /** `true`/`false` toggles two-finger pinch zoom; an object sets its scale\n   *  clamp (see {@link PinchZoomOptions}). */\n  pinchZoom: boolean | PinchZoomOptions;\n}): void {\n  const { pan, zoom, pinchZoom } = args;\n  const reg = useActionsRegistry();\n  const regRef = useLatest(reg);\n\n  // Serialize the object configs so the effect re-runs when their fields change\n  // (object identity isn't stable across renders for inline literals).\n  // JSON.stringify drops function-valued fields, so changing only\n  // `animate.easing` does not re-register — pass a stable easing.\n  const panKey = typeof pan === 'object' ? JSON.stringify(pan) : String(pan);\n  const zoomKey = typeof zoom === 'object' ? JSON.stringify(zoom) : String(zoom);\n  const pinchKey = typeof pinchZoom === 'object' ? JSON.stringify(pinchZoom) : String(pinchZoom);\n\n  useEffect(() => {\n    const r = regRef.current;\n    if (!r) return;\n    const unregisters: Array<() => void> = [];\n    if (pan) {\n      unregisters.push(\n        r.register(makeViewportWheelPanAction(typeof pan === 'object' ? pan : {})),\n      );\n    }\n    if (zoom) {\n      const zoomAction =\n        typeof zoom === 'object' ? makeViewportZoomAction(zoom) : makeViewportZoomAction();\n      unregisters.push(r.register(zoomAction));\n    }\n    if (pinchZoom) {\n      unregisters.push(\n        r.register(makePinchZoomAction(typeof pinchZoom === 'object' ? pinchZoom : {})),\n      );\n    } else {\n      unregisters.push(r.mute('viewport.pinchZoom'));\n    }\n    return () => { for (const u of unregisters) u(); };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- configs tracked via zoomKey / pinchKey\n  }, [panKey, zoomKey, pinchKey]);\n}\n"],"mappings":";;;;;;;AAiCA,SAAgBA,EAAmB,GAU1B;CACP,IAAM,EAAE,QAAK,SAAM,iBAAcC,GAC3BC,IAAMC,EAAmB,GACzBC,IAASC,EAAUH,CAAG,GAMtBI,IAAS,OAAOC,KAAQ,WAAW,KAAK,UAAUA,CAAG,IAAI,OAAOA,CAAG,GACnEC,IAAU,OAAOC,KAAS,WAAW,KAAK,UAAUA,CAAI,IAAI,OAAOA,CAAI,GACvEC,IAAW,OAAOC,KAAc,WAAW,KAAK,UAAUA,CAAS,IAAI,OAAOA,CAAS;CAE7F,QAAgB;EACd,IAAM,IAAIP,EAAO;EACjB,IAAI,CAAC,GAAG;EACR,IAAMQ,IAAiC,CAAC;EAMxC,IALIL,KACFK,EAAY,KACV,EAAE,SAASC,EAA2B,OAAON,KAAQ,WAAWA,IAAM,CAAC,CAAC,CAAC,CAC3E,GAEEE,GAAM;GACR,IAAMK,IACJ,OAAOL,KAAS,WAAWM,EAAuBN,CAAI,IAAIM,EAAuB;GACnF,EAAY,KAAK,EAAE,SAASD,CAAU,CAAC;EACzC;EAQA,OAPIH,IACFC,EAAY,KACV,EAAE,SAASI,EAAoB,OAAOL,KAAc,WAAWA,IAAY,CAAC,CAAC,CAAC,CAChF,IAEAC,EAAY,KAAK,EAAE,KAAK,oBAAoB,CAAC,SAElC;GAAE,KAAK,IAAMK,KAAKL,GAAa,EAAE;EAAG;CAEnD,GAAG;EAACN;EAAQE;EAASE;CAAQ,CAAC;AAChC"}
+{"version":3,"file":"useViewportActions.js","names":["useViewportActions","args","reg","useActionsRegistry","regRef","useLatest","panKey","pan","zoomKey","zoom","pinchKey","pinchZoom","unregisters","makeViewportWheelPanAction","zoomAction","makeViewportZoomAction","makePinchZoomAction","u","viewportZoomOption","base","animatedZoom"],"sources":["../../../src/canvas/SceneCanvas/useViewportActions.ts"],"sourcesContent":["/**\n * Registers the wheel pan, zoom, and pinch zoom actions from SceneCanvas's\n * `viewport` prop.\n *\n * Wheel pan and zoom are registered only here. `pinchZoom` is also a kit\n * standard action, so this hook re-registers a configured one over it, or\n * mutes it — muting rather than unregistering, so a sibling canvas sharing the\n * registry keeps its own. That overlap is why this must run after\n * `useStandardActions`.\n */\nimport { useEffect } from 'react';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport {\n  makeViewportWheelPanAction,\n  type WheelPanOptions,\n} from 'interactions/actions/defaults/viewportWheelPan';\nimport {\n  makeViewportZoomAction,\n  type ViewportZoomOptions,\n} from 'interactions/actions/defaults/viewportZoom';\nimport {\n  makePinchZoomAction,\n  type PinchZoomOptions,\n} from 'interactions/actions/defaults/pinchZoom';\n\nexport function useViewportActions(args: {\n  /** `true`/`false` toggles wheel pan; an object locks its axis (see\n   *  {@link WheelPanOptions}). */\n  pan: boolean | WheelPanOptions;\n  /** `true`/`false` toggles the default Cmd+wheel zoom; an object tunes the\n   *  wheel trigger + scale clamp (see {@link ViewportZoomOptions}). */\n  zoom: boolean | ViewportZoomOptions;\n  /** `true`/`false` toggles two-finger pinch zoom; an object sets its scale\n   *  clamp (see {@link PinchZoomOptions}). */\n  pinchZoom: boolean | PinchZoomOptions;\n}): void {\n  const { pan, zoom, pinchZoom } = args;\n  const reg = useActionsRegistry();\n  const regRef = useLatest(reg);\n\n  // Serialized so the effect re-runs when a config's fields change, not its\n  // identity. JSON.stringify drops function-valued fields, so changing only\n  // `animate.easing` does not re-register — pass a stable easing.\n  const panKey = typeof pan === 'object' ? JSON.stringify(pan) : String(pan);\n  const zoomKey = typeof zoom === 'object' ? JSON.stringify(zoom) : String(zoom);\n  const pinchKey = typeof pinchZoom === 'object' ? JSON.stringify(pinchZoom) : String(pinchZoom);\n\n  useEffect(() => {\n    const r = regRef.current;\n    if (!r) return;\n    const unregisters: Array<() => void> = [];\n    if (pan) {\n      unregisters.push(\n        r.register(makeViewportWheelPanAction(typeof pan === 'object' ? pan : {})),\n      );\n    }\n    if (zoom) {\n      const zoomAction =\n        typeof zoom === 'object' ? makeViewportZoomAction(zoom) : makeViewportZoomAction();\n      unregisters.push(r.register(zoomAction));\n    }\n    if (pinchZoom) {\n      unregisters.push(\n        r.register(makePinchZoomAction(typeof pinchZoom === 'object' ? pinchZoom : {})),\n      );\n    } else {\n      unregisters.push(r.mute('viewport.pinchZoom'));\n    }\n    return () => { for (const u of unregisters) u(); };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- configs tracked via zoomKey / pinchKey\n  }, [panKey, zoomKey, pinchKey]);\n}\n\n/**\n * `viewport.zoom` with `viewport.animatedZoom` folded in as the zoom action's\n * `animate` option, the way `pinchZoom` carries the pinch tool's clamp.\n */\nexport function viewportZoomOption(\n  zoom: boolean | ViewportZoomOptions | undefined,\n  animatedZoom: ViewportZoomOptions['animate'] | undefined,\n): boolean | ViewportZoomOptions {\n  if (zoom === false) return false;\n  const base = typeof zoom === 'object' ? zoom : {};\n  if (!animatedZoom) return base;\n  return { ...base, animate: animatedZoom === true ? {} : animatedZoom };\n}\n"],"mappings":";;;;;;;AA0BA,SAAgBA,EAAmB,GAU1B;CACP,IAAM,EAAE,QAAK,SAAM,iBAAcC,GAC3BC,IAAMC,EAAmB,GACzBC,IAASC,EAAUH,CAAG,GAKtBI,IAAS,OAAOC,KAAQ,WAAW,KAAK,UAAUA,CAAG,IAAI,OAAOA,CAAG,GACnEC,IAAU,OAAOC,KAAS,WAAW,KAAK,UAAUA,CAAI,IAAI,OAAOA,CAAI,GACvEC,IAAW,OAAOC,KAAc,WAAW,KAAK,UAAUA,CAAS,IAAI,OAAOA,CAAS;CAE7F,QAAgB;EACd,IAAM,IAAIP,EAAO;EACjB,IAAI,CAAC,GAAG;EACR,IAAMQ,IAAiC,CAAC;EAMxC,IALIL,KACFK,EAAY,KACV,EAAE,SAASC,EAA2B,OAAON,KAAQ,WAAWA,IAAM,CAAC,CAAC,CAAC,CAC3E,GAEEE,GAAM;GACR,IAAMK,IACJ,OAAOL,KAAS,WAAWM,EAAuBN,CAAI,IAAIM,EAAuB;GACnF,EAAY,KAAK,EAAE,SAASD,CAAU,CAAC;EACzC;EAQA,OAPIH,IACFC,EAAY,KACV,EAAE,SAASI,EAAoB,OAAOL,KAAc,WAAWA,IAAY,CAAC,CAAC,CAAC,CAChF,IAEAC,EAAY,KAAK,EAAE,KAAK,oBAAoB,CAAC,SAElC;GAAE,KAAK,IAAMK,KAAKL,GAAa,EAAE;EAAG;CAEnD,GAAG;EAACN;EAAQE;EAASE;CAAQ,CAAC;AAChC;AAMA,SAAgBQ,EACd,GACA,GAC+B;CAC/B,IAAIT,MAAS,IAAO,OAAO;CAC3B,IAAMU,IAAO,OAAOV,KAAS,WAAWA,IAAO,CAAC;CAEhD,OADKW,IACE;EAAE,GAAGD;EAAM,SAASC,MAAiB,KAAO,CAAC,IAAIA;CAAa,IAD3CD;AAE5B"}

package/dist/canvas/SceneCanvas/worldPointAt.js

@@ -0,0 +1,9 @@
+import { clientToWorld as e } from "../../core/viewport/clientToWorld.js";
+//#region src/canvas/SceneCanvas/worldPointAt.ts
+function t(t, n, r, i) {
+	return !n || n.id === null ? t.clientToWorld(r, i) : e(r, i, n.origin, n.view);
+}
+//#endregion
+export { t as worldPointAt };
+
+//# sourceMappingURL=worldPointAt.js.map

package/dist/canvas/SceneCanvas/worldPointAt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldPointAt.js","names":["worldPointAt","target","api","clientX","clientY","clientToWorld"],"sources":["../../../src/canvas/SceneCanvas/worldPointAt.ts"],"sourcesContent":["import { clientToWorld } from 'core/viewport/clientToWorld';\nimport type { ViewTarget } from 'features/viewports/viewResolver';\nimport type { CanvasExtensionApi } from '../canvasExtension';\n\n/**\n * A client point in the world of the view it resolved to. The canvas's own\n * view converts through the handle, which honors a `clientToWorld` override;\n * a declared view has a rect and a camera of its own, which the override\n * knows nothing about.\n */\nexport function worldPointAt(\n  api: Pick<CanvasExtensionApi, 'clientToWorld'>,\n  target: ViewTarget | undefined,\n  clientX: number,\n  clientY: number,\n): [number, number] {\n  if (!target || target.id === null) return api.clientToWorld(clientX, clientY);\n  return clientToWorld(clientX, clientY, target.origin, target.view);\n}\n"],"mappings":";;AAUA,SAAgBA,EACd,GACA,GACA,GACA,GACkB;CAElB,OADI,CAACC,KAAUA,EAAO,OAAO,OAAaC,EAAI,cAAcC,GAASC,CAAO,IACrEC,EAAcF,GAASC,GAASH,EAAO,QAAQA,EAAO,IAAI;AACnE"}