@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/device/targets.js.map

@@ -1 +1 @@
-{"version":3,"file":"targets.js","names":["BASE_PX","HANDLE_BASE_PX","ANCHOR_HIT_BASE_PX","ROTATION_HANDLE_BASE_PX","targetSizesPx","targetScale"],"sources":["../../../src/core/device/targets.ts"],"sourcesContent":["/**\n * Base sizes for grabbable chrome, in CSS pixels at `targetScale = 1`, and the\n * one accessor that resolves them for a live pointer type.\n *\n * Paint and hit-test MUST scale together: chrome you can see but cannot grab\n * is the exact failure `chrome-caps` exists to make impossible, and a literal\n * `8` copied into a fifth file is how that failure gets reintroduced. So every\n * kit-internal use site goes through {@link targetSizesPx} — the selection\n * overlay's handle size, `buildAffordanceAt`'s hit radii, and the slops debug\n * overlay all read the same object. The bare constants below stay exported for\n * consumers, who get the unscaled numbers they always got.\n */\n\nconst BASE_PX = {\n  handle: 8,\n  anchor: 8,\n  rotationDistance: 24,\n} as const;\n\n/** Selection corner-handle visual size and hit radius. */\nexport const HANDLE_BASE_PX = BASE_PX.handle;\n\n/** Path anchor / control-point hit radius. */\nexport const ANCHOR_HIT_BASE_PX = BASE_PX.anchor;\n\n/** Distance from a selection's top edge to the rotation handle's center. */\nexport const ROTATION_HANDLE_BASE_PX = BASE_PX.rotationDistance;\n\n/** Grabbable-chrome sizes resolved for one pointer type, in CSS pixels. */\nexport interface TargetSizesPx {\n  /** Corner-handle visual size and hit radius. */\n  handle: number;\n  /** Anchor / control-point hit radius. */\n  anchor: number;\n  /** Distance from a selection's top edge to the rotation handle's center,\n   *  which is also the rotate band's minimum thickness. */\n  rotationDistance: number;\n}\n\n/**\n * How big is grabbable chrome, in CSS pixels, for this pointer type?\n *\n * `targetScale` comes from the live {@link DeviceProfile} — 1 for a mouse,\n * {@link COARSE_TARGET_SCALE} for touch.\n */\nexport function targetSizesPx(targetScale = 1): TargetSizesPx {\n  return {\n    handle: BASE_PX.handle * targetScale,\n    anchor: BASE_PX.anchor * targetScale,\n    rotationDistance: BASE_PX.rotationDistance * targetScale,\n  };\n}\n"],"mappings":";AAaA,IAAMA,IAAU;CACd,QAAQ;CACR,QAAQ;CACR,kBAAkB;AACpB,GAGaC,IAAiBD,EAAQ,QAGzBE,IAAqBF,EAAQ,QAG7BG,IAA0BH,EAAQ;AAmB/C,SAAgBI,EAAc,IAAc,GAAkB;CAC5D,OAAO;EACL,QAAQJ,EAAQ,SAASK;EACzB,QAAQL,EAAQ,SAASK;EACzB,kBAAkBL,EAAQ,mBAAmBK;CAC/C;AACF"}
+{"version":3,"file":"targets.js","names":["BASE_PX","HANDLE_BASE_PX","ANCHOR_HIT_BASE_PX","ROTATION_HANDLE_BASE_PX","targetSizesPx","targetScale"],"sources":["../../../src/core/device/targets.ts"],"sourcesContent":["/**\n * Base sizes for grabbable chrome, in CSS pixels at `targetScale = 1`, and the\n * one accessor that resolves them for a live pointer type.\n *\n * Paint and hit-test MUST scale together, or chrome can be seen and not\n * grabbed, so every kit-internal use site goes through {@link targetSizesPx}.\n * The bare constants below are the unscaled numbers, exported for consumers.\n */\n\nconst BASE_PX = {\n  handle: 8,\n  anchor: 8,\n  rotationDistance: 24,\n} as const;\n\n/** Selection corner-handle visual size and hit radius. */\nexport const HANDLE_BASE_PX = BASE_PX.handle;\n\n/** Path anchor / control-point hit radius. */\nexport const ANCHOR_HIT_BASE_PX = BASE_PX.anchor;\n\n/** Distance from a selection's top edge to the rotation handle's center. */\nexport const ROTATION_HANDLE_BASE_PX = BASE_PX.rotationDistance;\n\n/** Grabbable-chrome sizes resolved for one pointer type, in CSS pixels. */\nexport interface TargetSizesPx {\n  /** Corner-handle visual size and hit radius. */\n  handle: number;\n  /** Anchor / control-point hit radius. */\n  anchor: number;\n  /** Distance from a selection's top edge to the rotation handle's center,\n   *  which is also the rotate band's minimum thickness. */\n  rotationDistance: number;\n}\n\n/**\n * How big is grabbable chrome, in CSS pixels, for this pointer type?\n *\n * `targetScale` comes from the live {@link DeviceProfile} — 1 for a mouse,\n * {@link COARSE_TARGET_SCALE} for touch.\n */\nexport function targetSizesPx(targetScale = 1): TargetSizesPx {\n  return {\n    handle: BASE_PX.handle * targetScale,\n    anchor: BASE_PX.anchor * targetScale,\n    rotationDistance: BASE_PX.rotationDistance * targetScale,\n  };\n}\n"],"mappings":";AASA,IAAMA,IAAU;CACd,QAAQ;CACR,QAAQ;CACR,kBAAkB;AACpB,GAGaC,IAAiBD,EAAQ,QAGzBE,IAAqBF,EAAQ,QAG7BG,IAA0BH,EAAQ;AAmB/C,SAAgBI,EAAc,IAAc,GAAkB;CAC5D,OAAO;EACL,QAAQJ,EAAQ,SAASK;EACzB,QAAQL,EAAQ,SAASK;EACzB,kBAAkBL,EAAQ,mBAAmBK;CAC/C;AACF"}

package/dist/core/device/useDeviceProfile.js

@@ -1,75 +1,69 @@
-import { createContext as e, createElement as t, useContext as n, useEffect as r, useMemo as i, useState as a } from "react";
-import { DEFAULT_DEVICE_PROFILE as o, resolveDeviceProfile as s } from "@weasel-js/routing";
+import { watchDevicePixelRatio as e } from "./watchDevicePixelRatio.js";
+import { createContext as t, createElement as n, useContext as r, useEffect as i, useMemo as a, useState as o } from "react";
+import { DEFAULT_DEVICE_PROFILE as s, resolveDeviceProfile as c } from "@weasel-js/routing";
 //#region src/core/device/useDeviceProfile.ts
-var c = "(pointer: coarse)", l = "(hover: hover)";
-function u() {
+var l = "(pointer: coarse)", u = "(hover: hover)";
+function d() {
 	return typeof window < "u" && typeof window.matchMedia == "function";
 }
-function d() {
+function f() {
 	let e = typeof window < "u" && window.devicePixelRatio || 1;
-	return u() ? {
-		coarsePointer: window.matchMedia(c).matches,
-		canHover: window.matchMedia(l).matches,
+	return d() ? {
+		coarsePointer: window.matchMedia(l).matches,
+		canHover: window.matchMedia(u).matches,
 		dpr: e
 	} : {
-		coarsePointer: o.coarsePointer,
-		canHover: o.canHover,
+		coarsePointer: s.coarsePointer,
+		canHover: s.canHover,
 		dpr: e
 	};
 }
-function f() {
-	let [e, t] = a(d);
-	return r(() => {
-		if (!u()) return;
-		let e = window.matchMedia(c), n = window.matchMedia(l), r = (e) => t((t) => ({
+function p(t) {
+	let [n, r] = o(f);
+	return i(() => {
+		if (!t || !d()) return;
+		let n = window.matchMedia(l), i = window.matchMedia(u), a = (e) => r((t) => ({
 			...t,
 			coarsePointer: e.matches
-		})), i = (e) => t((t) => ({
+		})), o = (e) => r((t) => ({
 			...t,
 			canHover: e.matches
 		}));
-		e.addEventListener("change", r), n.addEventListener("change", i);
-		let a = !1, o = null, s = () => {
-			if (a) return;
-			let e = window.devicePixelRatio || 1;
-			t((t) => t.dpr === e ? t : {
-				...t,
-				dpr: e
-			}), d();
-		};
-		function d() {
-			a || (o?.removeEventListener("change", s), o = window.matchMedia(`(resolution: ${window.devicePixelRatio || 1}dppx)`), o.addEventListener("change", s));
-		}
-		return d(), t({
-			coarsePointer: e.matches,
-			canHover: n.matches,
+		n.addEventListener("change", a), i.addEventListener("change", o);
+		let s = e((e) => r((t) => t.dpr === e ? t : {
+			...t,
+			dpr: e
+		}));
+		return r({
+			coarsePointer: n.matches,
+			canHover: i.matches,
 			dpr: window.devicePixelRatio || 1
 		}), () => {
-			a = !0, e.removeEventListener("change", r), n.removeEventListener("change", i), o?.removeEventListener("change", s);
+			s(), n.removeEventListener("change", a), i.removeEventListener("change", o);
 		};
-	}, []), e;
+	}, [t]), n;
 }
-var p = e(null);
-function m(e) {
-	let t = n(p), r = f(), a = t ?? r, { coarsePointer: o, canHover: c, dpr: l, targetScale: u } = e ?? {};
-	return i(() => s(a, {
+var m = t(null);
+function h(e) {
+	let t = r(m), n = p(t === null), i = t ?? n, { coarsePointer: o, canHover: s, dpr: l, targetScale: u } = e ?? {};
+	return a(() => c(i, {
 		...o === void 0 ? {} : { coarsePointer: o },
-		...c === void 0 ? {} : { canHover: c },
+		...s === void 0 ? {} : { canHover: s },
 		...l === void 0 ? {} : { dpr: l },
 		...u === void 0 ? {} : { targetScale: u }
 	}), [
-		a,
+		i,
 		o,
-		c,
+		s,
 		l,
 		u
 	]);
 }
-function h({ value: e, children: n }) {
-	let r = m(e);
-	return t(p.Provider, { value: r }, n);
+function g({ value: e, children: t }) {
+	let r = h(e);
+	return n(m.Provider, { value: r }, t);
 }
 //#endregion
-export { h as DeviceProfileProvider, m as useDeviceProfile };
+export { g as DeviceProfileProvider, h as useDeviceProfile };
 
 //# sourceMappingURL=useDeviceProfile.js.map

package/dist/core/device/useDeviceProfile.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDeviceProfile.js","names":["COARSE_QUERY","HOVER_QUERY","hasMatchMedia","detectOnce","dpr","DEFAULT_DEVICE_PROFILE","useDetectedFacts","facts","setFacts","useState","useEffect","coarseMq","hoverMq","onCoarse","f","onHover","disposed","densityMq","onDensity","next","arm","DeviceProfileContext","createContext","useDeviceProfile","provided","useContext","detected","base","overrides","useMemo","resolveDeviceProfile","coarsePointer","canHover","targetScale","DeviceProfileProvider","profile","value","createElement","children"],"sources":["../../../src/core/device/useDeviceProfile.ts"],"sourcesContent":["import {\n  createContext,\n  createElement,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n  type ReactNode,\n} from 'react';\nimport type { DetectedDeviceFacts, DeviceProfile } from './types';\nimport { DEFAULT_DEVICE_PROFILE, resolveDeviceProfile } from '@weasel-js/routing';\n\nconst COARSE_QUERY = '(pointer: coarse)';\nconst HOVER_QUERY = '(hover: hover)';\n\nfunction hasMatchMedia(): boolean {\n  return typeof window !== 'undefined' && typeof window.matchMedia === 'function';\n}\n\nfunction detectOnce(): DetectedDeviceFacts {\n  // Density is read unconditionally: `devicePixelRatio` does not depend on\n  // `matchMedia` existing. Only *watching* density needs a media query.\n  // Gating this read behind `hasMatchMedia()` would report density 1 under\n  // any environment without matchMedia — including jsdom, which would\n  // silently break `useCanvasSize`'s existing DPR assertions.\n  const dpr = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n  if (!hasMatchMedia()) {\n    return {\n      coarsePointer: DEFAULT_DEVICE_PROFILE.coarsePointer,\n      canHover: DEFAULT_DEVICE_PROFILE.canHover,\n      dpr,\n    };\n  }\n  return {\n    coarsePointer: window.matchMedia(COARSE_QUERY).matches,\n    canHover: window.matchMedia(HOVER_QUERY).matches,\n    dpr,\n  };\n}\n\n/**\n * Detect device facts and keep them live.\n *\n * Three subscriptions: pointer coarseness, hover capability, and pixel\n * density. The density one is special — `(resolution: Ndppx)` stops matching\n * as soon as density changes, so a single listener fires once and goes dead.\n * We re-arm a fresh query at the new density on every change.\n */\nfunction useDetectedFacts(): DetectedDeviceFacts {\n  const [facts, setFacts] = useState<DetectedDeviceFacts>(detectOnce);\n\n  useEffect(() => {\n    if (!hasMatchMedia()) return;\n\n    const coarseMq = window.matchMedia(COARSE_QUERY);\n    const hoverMq = window.matchMedia(HOVER_QUERY);\n\n    const onCoarse = (e: MediaQueryListEvent | { matches: boolean }) =>\n      setFacts((f) => ({ ...f, coarsePointer: e.matches }));\n    const onHover = (e: MediaQueryListEvent | { matches: boolean }) =>\n      setFacts((f) => ({ ...f, canHover: e.matches }));\n\n    coarseMq.addEventListener('change', onCoarse as EventListener);\n    hoverMq.addEventListener('change', onHover as EventListener);\n\n    // Re-arming density watcher.\n    let disposed = false;\n    let densityMq: MediaQueryList | null = null;\n    const onDensity = () => {\n      if (disposed) return;\n      const next = window.devicePixelRatio || 1;\n      setFacts((f) => (f.dpr === next ? f : { ...f, dpr: next }));\n      arm();\n    };\n    function arm(): void {\n      if (disposed) return;\n      densityMq?.removeEventListener('change', onDensity as EventListener);\n      densityMq = window.matchMedia(\n        `(resolution: ${window.devicePixelRatio || 1}dppx)`,\n      );\n      densityMq.addEventListener('change', onDensity as EventListener);\n    }\n    arm();\n\n    // Re-sync once on mount: a query could have changed between the\n    // useState initializer and the effect running.\n    // eslint-disable-next-line react-hooks/set-state-in-effect -- re-syncs media queries that may have changed before subscribing\n    setFacts({\n      coarsePointer: coarseMq.matches,\n      canHover: hoverMq.matches,\n      dpr: window.devicePixelRatio || 1,\n    });\n\n    return () => {\n      disposed = true;\n      coarseMq.removeEventListener('change', onCoarse as EventListener);\n      hoverMq.removeEventListener('change', onHover as EventListener);\n      densityMq?.removeEventListener('change', onDensity as EventListener);\n    };\n  }, []);\n\n  return facts;\n}\n\nconst DeviceProfileContext = createContext<DeviceProfile | null>(null);\n\n/**\n * Read the ambient device profile.\n *\n * Uses the nearest {@link DeviceProfileProvider} when one exists, and\n * otherwise detects for itself — so a standalone overlay or a labkit panel\n * rendered outside a `<SceneCanvas>` still gets correct facts.\n *\n * `overrides` always wins over both, which is what makes tests and\n * force-touch-chrome demos possible without stubbing `matchMedia`.\n */\nexport function useDeviceProfile(overrides?: Partial<DeviceProfile>): DeviceProfile {\n  const provided = useContext(DeviceProfileContext);\n  const detected = useDetectedFacts();\n  const base: DetectedDeviceFacts = provided ?? detected;\n  const { coarsePointer, canHover, dpr, targetScale } = overrides ?? {};\n  return useMemo(\n    () =>\n      resolveDeviceProfile(base, {\n        ...(coarsePointer !== undefined ? { coarsePointer } : {}),\n        ...(canHover !== undefined ? { canHover } : {}),\n        ...(dpr !== undefined ? { dpr } : {}),\n        ...(targetScale !== undefined ? { targetScale } : {}),\n      }),\n    [base, coarsePointer, canHover, dpr, targetScale],\n  );\n}\n\n/** Props for `<DeviceProfileProvider>`. */\nexport interface DeviceProfileProviderProps {\n  /** Partial override folded over detected facts. */\n  value?: Partial<DeviceProfile>;\n  children: ReactNode;\n}\n\n/**\n * Publish one resolved profile to a subtree. `<SceneCanvas>` renders this so\n * overlays, affordances, and consumer chrome all read the same object.\n */\nexport function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps) {\n  const profile = useDeviceProfile(value);\n  return createElement(DeviceProfileContext.Provider, { value: profile }, children);\n}\n"],"mappings":";;;AAYA,IAAMA,IAAe,qBACfC,IAAc;AAEpB,SAASC,IAAyB;CAChC,OAAO,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe;AACvE;AAEA,SAASC,IAAkC;CAMzC,IAAMC,IAAO,OAAO,SAAW,OAAe,OAAO,oBAAqB;CAQ1E,OAPKF,EAAc,IAOZ;EACL,eAAe,OAAO,WAAWF,CAAY,CAAC,CAAC;EAC/C,UAAU,OAAO,WAAWC,CAAW,CAAC,CAAC;EACzC;CACF,IAVS;EACL,eAAeI,EAAuB;EACtC,UAAUA,EAAuB;EACjC;CACF;AAOJ;AAUA,SAASC,IAAwC;CAC/C,IAAM,CAACC,GAAOC,KAAYC,EAA8BN,CAAU;CAoDlE,OAlDAO,QAAgB;EACd,IAAI,CAACR,EAAc,GAAG;EAEtB,IAAMS,IAAW,OAAO,WAAWX,CAAY,GACzCY,IAAU,OAAO,WAAWX,CAAW,GAEvCY,KAAY,MAChBL,GAAU,OAAO;GAAE,GAAGM;GAAG,eAAe,EAAE;EAAQ,EAAE,GAChDC,KAAW,MACfP,GAAU,OAAO;GAAE,GAAGM;GAAG,UAAU,EAAE;EAAQ,EAAE;EAGjD,AADAH,EAAS,iBAAiB,UAAUE,CAAyB,GAC7DD,EAAQ,iBAAiB,UAAUG,CAAwB;EAG3D,IAAIC,IAAW,IACXC,IAAmC,MACjCC,UAAkB;GACtB,IAAIF,GAAU;GACd,IAAMG,IAAO,OAAO,oBAAoB;GAExC,AADAX,GAAU,MAAOM,EAAE,QAAQK,IAAOL,IAAI;IAAE,GAAGA;IAAG,KAAKK;GAAK,CAAE,GAC1DC,EAAI;EACN;EACA,SAASA,IAAY;GACnB,AAAIJ,MACJC,GAAW,oBAAoB,UAAUC,CAA0B,GACnE,IAAY,OAAO,WACjB,gBAAgB,OAAO,oBAAoB,EAAE,MAC/C,GACAD,EAAU,iBAAiB,UAAUC,CAA0B;EACjE;EAYA,OAXAE,EAAI,GAKJZ,EAAS;GACP,eAAeG,EAAS;GACxB,UAAUC,EAAQ;GAClB,KAAK,OAAO,oBAAoB;EAClC,CAAC,SAEY;GAIX,AAHA,IAAW,IACXD,EAAS,oBAAoB,UAAUE,CAAyB,GAChED,EAAQ,oBAAoB,UAAUG,CAAwB,GAC9DE,GAAW,oBAAoB,UAAUC,CAA0B;EACrE;CACF,GAAG,CAAC,CAAC,GAEEX;AACT;AAEA,IAAMc,IAAuBC,EAAoC,IAAI;AAYrE,SAAgBC,EAAiB,GAAmD;CAClF,IAAMC,IAAWC,EAAWJ,CAAoB,GAC1CK,IAAWpB,EAAiB,GAC5BqB,IAA4BH,KAAYE,GACxC,EAAE,kBAAe,aAAU,QAAK,mBAAgBE,KAAa,CAAC;CACpE,OAAOC,QAEHC,EAAqBH,GAAM;EACzB,GAAII,MAAkB,KAAA,IAAgC,CAAC,IAArB,EAAE,iBAAc;EAClD,GAAIC,MAAa,KAAA,IAA2B,CAAC,IAAhB,EAAE,YAAS;EACxC,GAAI5B,MAAQ,KAAA,IAAsB,CAAC,IAAX,EAAE,OAAI;EAC9B,GAAI6B,MAAgB,KAAA,IAA8B,CAAC,IAAnB,EAAE,eAAY;CAChD,CAAC,GACH;EAACN;EAAMI;EAAeC;EAAU5B;EAAK6B;CAAW,CAClD;AACF;AAaA,SAAgBC,EAAsB,EAAE,UAAO,eAAwC;CACrF,IAAMC,IAAUZ,EAAiBa,CAAK;CACtC,OAAOC,EAAchB,EAAqB,UAAU,EAAE,OAAOc,EAAQ,GAAGG,CAAQ;AAClF"}
+{"version":3,"file":"useDeviceProfile.js","names":["COARSE_QUERY","HOVER_QUERY","hasMatchMedia","detectOnce","dpr","DEFAULT_DEVICE_PROFILE","useDetectedFacts","facts","setFacts","useState","useEffect","watch","coarseMq","hoverMq","onCoarse","f","onHover","unwatchDensity","watchDevicePixelRatio","next","DeviceProfileContext","createContext","useDeviceProfile","provided","useContext","detected","base","overrides","useMemo","resolveDeviceProfile","coarsePointer","canHover","targetScale","DeviceProfileProvider","profile","value","createElement","children"],"sources":["../../../src/core/device/useDeviceProfile.ts"],"sourcesContent":["import {\n  createContext,\n  createElement,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n  type ReactNode,\n} from 'react';\nimport type { DetectedDeviceFacts, DeviceProfile } from './types';\nimport { DEFAULT_DEVICE_PROFILE, resolveDeviceProfile } from '@weasel-js/routing';\nimport { watchDevicePixelRatio } from './watchDevicePixelRatio';\n\nconst COARSE_QUERY = '(pointer: coarse)';\nconst HOVER_QUERY = '(hover: hover)';\n\nfunction hasMatchMedia(): boolean {\n  return typeof window !== 'undefined' && typeof window.matchMedia === 'function';\n}\n\nfunction detectOnce(): DetectedDeviceFacts {\n  // Density is read unconditionally: `devicePixelRatio` does not depend on\n  // `matchMedia` existing. Only *watching* density needs a media query.\n  // Gating this read behind `hasMatchMedia()` would report density 1 under\n  // any environment without matchMedia — including jsdom, which would\n  // silently break `useCanvasSize`'s existing DPR assertions.\n  const dpr = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n  if (!hasMatchMedia()) {\n    return {\n      coarsePointer: DEFAULT_DEVICE_PROFILE.coarsePointer,\n      canHover: DEFAULT_DEVICE_PROFILE.canHover,\n      dpr,\n    };\n  }\n  return {\n    coarsePointer: window.matchMedia(COARSE_QUERY).matches,\n    canHover: window.matchMedia(HOVER_QUERY).matches,\n    dpr,\n  };\n}\n\n/**\n * Detect device facts and keep them live.\n *\n * Three subscriptions: pointer coarseness, hover capability, and pixel\n * density. None while `watch` is false, and the facts then go stale.\n */\nfunction useDetectedFacts(watch: boolean): DetectedDeviceFacts {\n  const [facts, setFacts] = useState<DetectedDeviceFacts>(detectOnce);\n\n  useEffect(() => {\n    if (!watch || !hasMatchMedia()) return;\n\n    const coarseMq = window.matchMedia(COARSE_QUERY);\n    const hoverMq = window.matchMedia(HOVER_QUERY);\n\n    const onCoarse = (e: MediaQueryListEvent | { matches: boolean }) =>\n      setFacts((f) => ({ ...f, coarsePointer: e.matches }));\n    const onHover = (e: MediaQueryListEvent | { matches: boolean }) =>\n      setFacts((f) => ({ ...f, canHover: e.matches }));\n\n    coarseMq.addEventListener('change', onCoarse as EventListener);\n    hoverMq.addEventListener('change', onHover as EventListener);\n\n    const unwatchDensity = watchDevicePixelRatio((next) =>\n      setFacts((f) => (f.dpr === next ? f : { ...f, dpr: next })));\n\n    // Re-sync once on mount: a query could have changed between the\n    // useState initializer and the effect running.\n    // eslint-disable-next-line react-hooks/set-state-in-effect -- re-syncs media queries that may have changed before subscribing\n    setFacts({\n      coarsePointer: coarseMq.matches,\n      canHover: hoverMq.matches,\n      dpr: window.devicePixelRatio || 1,\n    });\n\n    return () => {\n      unwatchDensity();\n      coarseMq.removeEventListener('change', onCoarse as EventListener);\n      hoverMq.removeEventListener('change', onHover as EventListener);\n    };\n  }, [watch]);\n\n  return facts;\n}\n\nconst DeviceProfileContext = createContext<DeviceProfile | null>(null);\n\n/**\n * Read the ambient device profile.\n *\n * Uses the nearest {@link DeviceProfileProvider} when one exists, watching\n * nothing of its own, and otherwise detects for itself — so a standalone overlay or a labkit panel\n * rendered outside a `<SceneCanvas>` still gets correct facts.\n *\n * `overrides` always wins over both, which is what makes tests and\n * force-touch-chrome demos possible without stubbing `matchMedia`.\n */\nexport function useDeviceProfile(overrides?: Partial<DeviceProfile>): DeviceProfile {\n  const provided = useContext(DeviceProfileContext);\n  const detected = useDetectedFacts(provided === null);\n  const base: DetectedDeviceFacts = provided ?? detected;\n  const { coarsePointer, canHover, dpr, targetScale } = overrides ?? {};\n  return useMemo(\n    () =>\n      resolveDeviceProfile(base, {\n        ...(coarsePointer !== undefined ? { coarsePointer } : {}),\n        ...(canHover !== undefined ? { canHover } : {}),\n        ...(dpr !== undefined ? { dpr } : {}),\n        ...(targetScale !== undefined ? { targetScale } : {}),\n      }),\n    [base, coarsePointer, canHover, dpr, targetScale],\n  );\n}\n\n/** Props for `<DeviceProfileProvider>`. */\nexport interface DeviceProfileProviderProps {\n  /** Partial override folded over detected facts. */\n  value?: Partial<DeviceProfile>;\n  children: ReactNode;\n}\n\n/**\n * Publish one resolved profile to a subtree. `<SceneCanvas>` renders this so\n * overlays, affordances, and consumer chrome all read the same object.\n */\nexport function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps) {\n  const profile = useDeviceProfile(value);\n  return createElement(DeviceProfileContext.Provider, { value: profile }, children);\n}\n"],"mappings":";;;;AAaA,IAAMA,IAAe,qBACfC,IAAc;AAEpB,SAASC,IAAyB;CAChC,OAAO,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe;AACvE;AAEA,SAASC,IAAkC;CAMzC,IAAMC,IAAO,OAAO,SAAW,OAAe,OAAO,oBAAqB;CAQ1E,OAPKF,EAAc,IAOZ;EACL,eAAe,OAAO,WAAWF,CAAY,CAAC,CAAC;EAC/C,UAAU,OAAO,WAAWC,CAAW,CAAC,CAAC;EACzC;CACF,IAVS;EACL,eAAeI,EAAuB;EACtC,UAAUA,EAAuB;EACjC;CACF;AAOJ;AAQA,SAASC,EAAiB,GAAqC;CAC7D,IAAM,CAACC,GAAOC,KAAYC,EAA8BN,CAAU;CAmClE,OAjCAO,QAAgB;EACd,IAAI,CAACC,KAAS,CAACT,EAAc,GAAG;EAEhC,IAAMU,IAAW,OAAO,WAAWZ,CAAY,GACzCa,IAAU,OAAO,WAAWZ,CAAW,GAEvCa,KAAY,MAChBN,GAAU,OAAO;GAAE,GAAGO;GAAG,eAAe,EAAE;EAAQ,EAAE,GAChDC,KAAW,MACfR,GAAU,OAAO;GAAE,GAAGO;GAAG,UAAU,EAAE;EAAQ,EAAE;EAGjD,AADAH,EAAS,iBAAiB,UAAUE,CAAyB,GAC7DD,EAAQ,iBAAiB,UAAUG,CAAwB;EAE3D,IAAMC,IAAiBC,GAAuB,MAC5CV,GAAU,MAAOO,EAAE,QAAQI,IAAOJ,IAAI;GAAE,GAAGA;GAAG,KAAKI;EAAK,CAAE,CAAC;EAW7D,OANAX,EAAS;GACP,eAAeI,EAAS;GACxB,UAAUC,EAAQ;GAClB,KAAK,OAAO,oBAAoB;EAClC,CAAC,SAEY;GAGX,AAFAI,EAAe,GACfL,EAAS,oBAAoB,UAAUE,CAAyB,GAChED,EAAQ,oBAAoB,UAAUG,CAAwB;EAChE;CACF,GAAG,CAACL,CAAK,CAAC,GAEHJ;AACT;AAEA,IAAMa,IAAuBC,EAAoC,IAAI;AAYrE,SAAgBC,EAAiB,GAAmD;CAClF,IAAMC,IAAWC,EAAWJ,CAAoB,GAC1CK,IAAWnB,EAAiBiB,MAAa,IAAI,GAC7CG,IAA4BH,KAAYE,GACxC,EAAE,kBAAe,aAAU,QAAK,mBAAgBE,KAAa,CAAC;CACpE,OAAOC,QAEHC,EAAqBH,GAAM;EACzB,GAAII,MAAkB,KAAA,IAAgC,CAAC,IAArB,EAAE,iBAAc;EAClD,GAAIC,MAAa,KAAA,IAA2B,CAAC,IAAhB,EAAE,YAAS;EACxC,GAAI3B,MAAQ,KAAA,IAAsB,CAAC,IAAX,EAAE,OAAI;EAC9B,GAAI4B,MAAgB,KAAA,IAA8B,CAAC,IAAnB,EAAE,eAAY;CAChD,CAAC,GACH;EAACN;EAAMI;EAAeC;EAAU3B;EAAK4B;CAAW,CAClD;AACF;AAaA,SAAgBC,EAAsB,EAAE,UAAO,eAAwC;CACrF,IAAMC,IAAUZ,EAAiBa,CAAK;CACtC,OAAOC,EAAchB,EAAqB,UAAU,EAAE,OAAOc,EAAQ,GAAGG,CAAQ;AAClF"}

package/dist/core/device/watchDevicePixelRatio.js

@@ -0,0 +1,17 @@
+//#region src/core/device/watchDevicePixelRatio.ts
+function e(e) {
+	if (typeof window > "u" || typeof window.matchMedia != "function") return () => {};
+	let t = !1, n = null, r = () => {
+		t || (i(), e(window.devicePixelRatio || 1));
+	};
+	function i() {
+		n?.removeEventListener("change", r), n = window.matchMedia(`(resolution: ${window.devicePixelRatio || 1}dppx)`), n.addEventListener("change", r);
+	}
+	return i(), () => {
+		t = !0, n?.removeEventListener("change", r);
+	};
+}
+//#endregion
+export { e as watchDevicePixelRatio };
+
+//# sourceMappingURL=watchDevicePixelRatio.js.map

package/dist/core/device/watchDevicePixelRatio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchDevicePixelRatio.js","names":["watchDevicePixelRatio","disposed","query","onDensity","arm","onChange"],"sources":["../../../src/core/device/watchDevicePixelRatio.ts"],"sourcesContent":["/**\n * Call `onChange` each time `window.devicePixelRatio` changes: the window\n * moved to a display of another density, or the page zoomed. Returns the\n * unsubscribe. A no-op where `matchMedia` does not exist.\n *\n * `(resolution: Ndppx)` stops matching as soon as density changes, so one\n * listener fires once and goes dead; this arms a fresh query at the new\n * density on every change.\n */\nexport function watchDevicePixelRatio(onChange: (dpr: number) => void): () => void {\n  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return () => {};\n  let disposed = false;\n  let query: MediaQueryList | null = null;\n  const onDensity = (): void => {\n    if (disposed) return;\n    arm();\n    onChange(window.devicePixelRatio || 1);\n  };\n  function arm(): void {\n    query?.removeEventListener('change', onDensity);\n    query = window.matchMedia(`(resolution: ${window.devicePixelRatio || 1}dppx)`);\n    query.addEventListener('change', onDensity);\n  }\n  arm();\n  return () => {\n    disposed = true;\n    query?.removeEventListener('change', onDensity);\n  };\n}\n"],"mappings":";AASA,SAAgBA,EAAsB,GAA6C;CACjF,IAAI,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,YAAY,aAAa,CAAC;CAC5F,IAAIC,IAAW,IACXC,IAA+B,MAC7BC,UAAwB;EAC5B,AAAIF,MACJG,EAAI,GACJC,EAAS,OAAO,oBAAoB,CAAC;CACvC;CACA,SAASD,IAAY;EAGnB,AAFAF,GAAO,oBAAoB,UAAUC,CAAS,GAC9C,IAAQ,OAAO,WAAW,gBAAgB,OAAO,oBAAoB,EAAE,MAAM,GAC7ED,EAAM,iBAAiB,UAAUC,CAAS;CAC5C;CAEA,OADAC,EAAI,SACS;EAEX,AADA,IAAW,IACXF,GAAO,oBAAoB,UAAUC,CAAS;CAChD;AACF"}

package/dist/{interactions/actions/resize → core/geometry}/autoPoseDescriptor.js

@@ -1,6 +1,6 @@
-import { RECT_POSE_DESCRIPTOR as e } from "../../../core/geometry/poseDescriptor.js";
-import { pathPoseDescriptor as t } from "../../../features/paths/poseDescriptor.js";
-//#region src/interactions/actions/resize/autoPoseDescriptor.ts
+import { pathPoseDescriptor as e } from "./pathPoseDescriptor.js";
+import { RECT_POSE_DESCRIPTOR as t } from "./poseDescriptor.js";
+//#region src/core/geometry/autoPoseDescriptor.ts
 function n(e) {
 	return !!e && typeof e == "object" && "kind" in e && (e.kind === "polygon" || e.kind === "rect");
 }
@@ -10,10 +10,11 @@ function r(e) {
 	return typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number";
 }
 var i = {
-	getBounds: (r) => n(r) ? t.getBounds(r) : e.getBounds(r),
-	remapBounds: (r, i, a) => n(r) ? t.remapBounds(r, i, a) : e.remapBounds(r, i, a),
-	fromBounds: (r, i) => n(i) ? t.fromBounds(r, i) : e.fromBounds(r, i),
-	translate: (r, i, a) => n(r) ? t.translate(r, i, a) : e.translate(r, i, a),
+	getBounds: (r) => n(r) ? e.getBounds(r) : t.getBounds(r),
+	remapBounds: (r, i, a) => n(r) ? e.remapBounds(r, i, a) : t.remapBounds(r, i, a),
+	fromBounds: (r, i) => n(i) ? e.fromBounds(r, i) : t.fromBounds(r, i),
+	translate: (r, i, a) => n(r) ? e.translate(r, i, a) : t.translate(r, i, a),
+	axes: (i) => r(i) ? t.axes(i) : n(i) ? e.axes(i) : null,
 	getRotation: (e) => {
 		if (n(e)) return 0;
 		let t = e.rotation;

package/dist/core/geometry/autoPoseDescriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoPoseDescriptor.js","names":["isPathLike","p","isRectPose","r","AUTO_POSE_DESCRIPTOR","pathPoseDescriptor","RECT_POSE_DESCRIPTOR","src","dst","template","b","dx","dy"],"sources":["../../../src/core/geometry/autoPoseDescriptor.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { pathPoseDescriptor } from './pathPoseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from './poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire\n *  `poseDescriptor` explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only\n *  shape the rect descriptor and the kit's built-in painters can read. */\nexport function isRectPose(p: unknown): p is { x: number; y: number; width: number; height: number; rotation?: number } {\n  if (!p || typeof p !== 'object') return false;\n  const r = p as Record<string, unknown>;\n  return typeof r.x === 'number' && typeof r.y === 'number'\n    && typeof r.width === 'number' && typeof r.height === 'number';\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`\n *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses\n *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to\n *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated\n *  selection chrome and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  fromBounds: (b, template) => isPathLike(template)\n    ? pathPoseDescriptor.fromBounds(b, template)\n    : RECT_POSE_DESCRIPTOR.fromBounds(b, template as Bounds),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  axes: (p) => (isRectPose(p)\n    ? RECT_POSE_DESCRIPTOR.axes!(p) as never\n    : isPathLike(p) ? pathPoseDescriptor.axes!(p) as never : null),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n  withRotation: (p, rotation) => isPathLike(p) ? p : { ...(p as object), rotation },\n};\n"],"mappings":";;;AASA,SAAgBA,EAAW,GAAuB;CAChD,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,UAAUA,MAC1CA,EAAwB,SAAS,aAAcA,EAAwB,SAAS;AACzF;AAIA,SAAgBC,EAAW,GAA6F;CACtH,IAAI,CAACD,KAAK,OAAOA,KAAM,UAAU,OAAO;CACxC,IAAME,IAAIF;CACV,OAAO,OAAOE,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAC5C,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW;AAC1D;AASA,IAAaC,IAAgD;CAC3D,YAAY,MAAMJ,EAAWC,CAAC,IAC1BI,EAAmB,UAAUJ,CAAC,IAC9BK,EAAqB,UAAUL,CAA4D;CAC/F,cAAc,GAAG,GAAK,MAAQD,EAAWC,CAAC,IACtCI,EAAmB,YAAYJ,GAAGM,GAAKC,CAAG,IAC1CF,EAAqB,YAAYL,GAA8DM,GAAKC,CAAG;CAC3G,aAAa,GAAG,MAAaR,EAAWS,CAAQ,IAC5CJ,EAAmB,WAAWK,GAAGD,CAAQ,IACzCH,EAAqB,WAAWI,GAAGD,CAAkB;CACzD,YAAY,GAAG,GAAI,MAAOT,EAAWC,CAAC,IAClCI,EAAmB,UAAWJ,GAAGU,GAAIC,CAAE,IACvCN,EAAqB,UAAWL,GAA8DU,GAAIC,CAAE;CACxG,OAAO,MAAOV,EAAWD,CAAC,IACtBK,EAAqB,KAAML,CAAC,IAC5BD,EAAWC,CAAC,IAAII,EAAmB,KAAMJ,CAAC,IAAa;CAC3D,cAAc,MAAM;EAClB,IAAID,EAAWC,CAAC,GAAG,OAAO;EAC1B,IAAME,IAAKF,EAA6B;EACxC,OAAO,OAAOE,KAAM,WAAWA,IAAI;CACrC;CAKA,mBAAmB,MAAM,CAACH,EAAWC,CAAC;CACtC,eAAe,GAAG,MAAaD,EAAWC,CAAC,IAAIA,IAAI;EAAE,GAAIA;EAAc;CAAS;AAClF"}

package/dist/core/geometry/pathPoseDescriptor.js

@@ -0,0 +1,88 @@
+import { boundsOfPath as e, boxToBox as t, transformPath as n, translatePath as r } from "@weasel-js/geom";
+//#region src/core/geometry/pathPoseDescriptor.ts
+var i = {
+	getBounds: (t) => e(t),
+	remapBounds: (e, r, i) => n(e, t(r.x, r.y, r.width, r.height, i.x, i.y, i.width, i.height)),
+	fromBounds: (e) => ({
+		kind: "rect",
+		x: e.x,
+		y: e.y,
+		width: e.width,
+		height: e.height
+	}),
+	translate: (e, t, n) => r(e, t, n),
+	lerp: (e, t, n) => {
+		if (e.kind === "rect" && t.kind === "rect") return {
+			kind: "rect",
+			x: e.x + (t.x - e.x) * n,
+			y: e.y + (t.y - e.y) * n,
+			width: e.width + (t.width - e.width) * n,
+			height: e.height + (t.height - e.height) * n
+		};
+		if (e.kind === "polygon" && t.kind === "polygon" && e.coords.length === t.coords.length) {
+			let r = new Float32Array(e.coords.length);
+			for (let i = 0; i < e.coords.length; i++) r[i] = e.coords[i] + (t.coords[i] - e.coords[i]) * n;
+			return {
+				...e,
+				coords: r
+			};
+		}
+		throw Error("pathPoseDescriptor.lerp: incompatible path shapes");
+	},
+	axes: (e) => e.kind === "rect" ? {
+		count: 4,
+		names: [
+			"x",
+			"y",
+			"width",
+			"height"
+		],
+		to: (e) => e.kind === "rect" ? [
+			e.x,
+			e.y,
+			e.width,
+			e.height
+		] : [],
+		from: (e) => ({
+			kind: "rect",
+			x: e[0],
+			y: e[1],
+			width: e[2],
+			height: e[3]
+		}),
+		add: (e, t) => e.kind === "rect" ? {
+			kind: "rect",
+			x: e.x + t[0],
+			y: e.y + t[1],
+			width: e.width + t[2],
+			height: e.height + t[3]
+		} : e,
+		write: (e, t, n) => {
+			e.kind === "rect" && (t[n] = e.x, t[n + 1] = e.y, t[n + 2] = e.width, t[n + 3] = e.height);
+		}
+	} : {
+		count: e.coords.length,
+		to: (e) => e.kind === "polygon" ? Array.from(e.coords) : [],
+		from: (t) => ({
+			...e,
+			coords: Float32Array.from(t)
+		}),
+		add: (t, n) => {
+			if (t.kind !== "polygon") return t;
+			let r = new Float32Array(t.coords.length);
+			for (let e = 0; e < r.length; e++) r[e] = t.coords[e] + n[e];
+			return {
+				...e,
+				coords: r
+			};
+		},
+		write: (e, t, n) => {
+			if (e.kind === "polygon") for (let r = 0; r < e.coords.length; r++) t[n + r] = e.coords[r];
+		}
+	},
+	supportsRotation: () => !1
+};
+//#endregion
+export { i as pathPoseDescriptor };
+
+//# sourceMappingURL=pathPoseDescriptor.js.map

package/dist/core/geometry/pathPoseDescriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathPoseDescriptor.js","names":["pathPoseDescriptor","boundsOfPath","path","transformPath","boxToBox","src","dst","b","translatePath","dx","dy","a","t","next","like","p","d","at","coords","i"],"sources":["../../../src/core/geometry/pathPoseDescriptor.ts"],"sourcesContent":["import {\n  boxToBox,\n  boundsOfPath,\n  translatePath,\n  transformPath,\n  type Path,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { ...a, coords: next };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // A polygon's axes are its coordinates, so a move needs both ends to have as many points.\n  axes: (like) => {\n    if (like.kind === 'rect') {\n      return {\n        count: 4,\n        names: ['x', 'y', 'width', 'height'],\n        to: (p) => (p.kind === 'rect' ? [p.x, p.y, p.width, p.height] : []),\n        from: (a) => ({ kind: 'rect', x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! }),\n        add: (p, d) => (p.kind !== 'rect' ? p : {\n          kind: 'rect', x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]!,\n        }),\n        write: (p, out, at) => {\n          if (p.kind !== 'rect') return;\n          out[at] = p.x;\n          out[at + 1] = p.y;\n          out[at + 2] = p.width;\n          out[at + 3] = p.height;\n        },\n      };\n    }\n    return {\n      count: like.coords.length,\n      to: (p) => (p.kind === 'polygon' ? Array.from(p.coords) : []),\n      from: (a) => ({ ...like, coords: Float32Array.from(a as ArrayLike<number>) }),\n      add: (p, d) => {\n        if (p.kind !== 'polygon') return p;\n        const coords = new Float32Array(p.coords.length);\n        for (let i = 0; i < coords.length; i++) coords[i] = p.coords[i]! + d[i]!;\n        return { ...like, coords };\n      },\n      write: (p, out, at) => {\n        if (p.kind !== 'polygon') return;\n        for (let i = 0; i < p.coords.length; i++) out[at + i] = p.coords[i]!;\n      },\n    };\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n"],"mappings":"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"}

package/dist/core/geometry/poseDescriptor.js

@@ -1,9 +1,10 @@
 import { axisAlignedBounds as e } from "./unionBounds.js";
+import { poseLinearOf as t } from "@weasel-js/geom";
 //#region src/core/geometry/poseDescriptor.ts
-function t(e, t) {
+function n(e, t) {
 	return e.forNode?.(t) ?? e;
 }
-var n = {
+var r = {
 	getBounds: (e) => e,
 	remapBounds: (e, t, n) => {
 		let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height;
@@ -33,16 +34,63 @@ var n = {
 		width: e.width + (t.width - e.width) * n,
 		height: e.height + (t.height - e.height) * n
 	}),
+	axes: (e) => [
+		e.x,
+		e.y,
+		e.width,
+		e.height
+	].every((e) => typeof e == "number") ? {
+		count: 5,
+		names: [
+			"x",
+			"y",
+			"width",
+			"height",
+			"rotation"
+		],
+		angles: [4],
+		to: (e) => [
+			e.x,
+			e.y,
+			e.width,
+			e.height,
+			e.rotation ?? 0
+		],
+		from: (t) => {
+			let n = {
+				...e,
+				x: t[0],
+				y: t[1],
+				width: t[2],
+				height: t[3]
+			};
+			return (e.rotation !== void 0 || t[4] !== 0) && (n.rotation = t[4]), n;
+		},
+		add: (e, t) => {
+			let n = {
+				...e,
+				x: e.x + t[0],
+				y: e.y + t[1],
+				width: e.width + t[2],
+				height: e.height + t[3]
+			}, r = (e.rotation ?? 0) + t[4];
+			return (e.rotation !== void 0 || r !== 0) && (n.rotation = r), n;
+		},
+		write: (e, t, n) => {
+			t[n] = e.x, t[n + 1] = e.y, t[n + 2] = e.width, t[n + 3] = e.height, t[n + 4] = e.rotation ?? 0;
+		}
+	} : null,
 	getRotation: (e) => e.rotation ?? 0,
 	withRotation: (e, t) => ({
 		...e,
 		rotation: t
 	})
-}, r = {
-	getBounds: n.getBounds,
-	remapBounds: n.remapBounds,
-	translate: n.translate,
-	lerp: n.lerp,
+}, i = {
+	getBounds: r.getBounds,
+	remapBounds: r.remapBounds,
+	translate: r.translate,
+	lerp: r.lerp,
+	axes: r.axes,
 	fromBounds: (e) => ({
 		x: e.x,
 		y: e.y,
@@ -56,7 +104,7 @@ var n = {
 		rotation: t
 	})
 };
-function i(e, t, n) {
+function a(e, t, n) {
 	let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height, a = e.rotation ?? 0, o = Math.cos(a), s = Math.sin(a), c = r * o, l = i * s, u = -r * s, d = i * o, f = e.width * Math.hypot(c, l), p = e.height * Math.hypot(u, d), m = Math.atan2(l, c), h = n.x + (e.x + e.width / 2 - t.x) * r, g = n.y + (e.y + e.height / 2 - t.y) * i;
 	return {
 		...e,
@@ -67,17 +115,18 @@ function i(e, t, n) {
 		rotation: m
 	};
 }
-function a(t, n) {
-	let r = n.getBounds(t), i = n.getRotation?.(t) ?? r.rotation ?? 0;
-	return e({
-		x: r.x,
-		y: r.y,
-		width: r.width,
-		height: r.height,
-		rotation: i
-	});
+function o(t, n) {
+	return e(s(t, n));
 }
-function o(e, t, n, r) {
+function s(e, n) {
+	let r = n.getBounds(e), i = n.getRotation?.(e) ?? r.rotation ?? 0, a = t(e) ?? t(r);
+	return !i && !a ? r : {
+		...r,
+		...i ? { rotation: i } : {},
+		...a ? { transform: a } : {}
+	};
+}
+function c(e, t, n, r) {
 	if (r.translate) return r.translate(e, t, n);
 	let i = r.getBounds(e), a = {
 		x: i.x + t,
@@ -88,6 +137,6 @@ function o(e, t, n, r) {
 	return r.remapBounds(e, i, a);
 }
 //#endregion
-export { n as RECT_POSE_DESCRIPTOR, r as ROTATED_POSE_DESCRIPTOR, t as poseDescriptorForNode, i as remapRotatedLeaf, o as translatePoseViaDescriptor, a as visualBoundsViaDescriptor };
+export { r as RECT_POSE_DESCRIPTOR, i as ROTATED_POSE_DESCRIPTOR, s as framedBounds, n as poseDescriptorForNode, a as remapRotatedLeaf, c as translatePoseViaDescriptor, o as visualBoundsViaDescriptor };
 
 //# sourceMappingURL=poseDescriptor.js.map

package/dist/core/geometry/poseDescriptor.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseDescriptor.js","names":["poseDescriptorForNode","descriptor","node","RECT_POSE_DESCRIPTOR","p","sx","src","dst","sy","b","dx","dy","a","t","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","pose","cos","sin","ux","uy","vx","vy","width","height","rotation","cxNew","cyNew","visualBoundsViaDescriptor","geometry","axisAlignedBounds","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.\n * The hook reads bounds via `getBounds`, runs anchor-relative math on those\n * bounds, then asks `remapBounds` to project the result back into TPose.\n *\n * `remapBounds(pose, src, dst)` is a single operation that subsumes both\n * \"set my own AABB to dst\" (single-leaf resize) and \"scale me as a leaf\n * inside parent's src→dst rect\" (group resize) — they're the same affine\n * map. For rect-shaped poses the default geometry interprets the pose as\n * its own bounds; for Path or polygon poses the consumer supplies a\n * projection that knows how to read and rewrite the underlying geometry.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted — descriptor\n   *  declares \"this pose has no rotation.\" When supplied and non-zero,\n   *  `useResize` projects the drag delta into the leaf's local frame,\n   *  runs anchor math there, and translates the resulting pose so the\n   *  diagonally opposite world-space corner is pinned. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation. Consulted by the\n   *  rotation affordance to decide whether to render the rotate cursor /\n   *  drag-band over a selection. When omitted, the kit assumes `true` for\n   *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`\n   *  fields (e.g. polygon Paths) should return `false` so the affordance\n   *  hides instead of exposing a non-functional rotate cursor. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type — a sphere and a box both posed by\n   * position/rotation/scale — are indistinguishable to them. Implement this to\n   * read `node.data` once and hand back a descriptor that knows which shape it\n   * is describing.\n   *\n   * Callers reach it through {@link poseDescriptorForNode}, at whichever site\n   * holds the node; the specialized descriptor then travels into the bounds and\n   * hit-test helpers in place of this one. Sites with only an id keep using the\n   * unspecialized descriptor, which is why this is optional on both ends.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  // `Bounds` carries an optional `rotation`, and `withRotation` writes into\n  // it — so reading it back has to be the same channel, or a pose reports\n  // itself unrotated to `useResize` and to port placement while painting\n  // rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`. Inherits rect-shape projection\n *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends Bounds`\n *  subtype lets the rect descriptor's methods apply directly; `remapBounds`\n *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so\n *  `useResize` knows to take the rotation-aware math path. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are already expressed in the leaf's own frame — the\n * single-leaf resize path, where the drag delta was projected into that frame\n * before the anchor math ran. In a group resize they are world-frame, so the\n * leaf's local axes do not line up with the axes being scaled: at 90° a\n * horizontal stretch should grow the leaf's `height`, and the naive map grows\n * its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model is `{x, y, width, height, rotation}`\n * and cannot represent the parallelogram a non-uniform scale of a rotated box\n * actually produces. The center moves exactly; each local axis takes the\n * length of its own image; the rotation follows the image of the local x-axis.\n *\n * Degenerates to the naive map at `rotation === 0`, and to a plain uniform\n * scale when `sx === sy`, both exactly.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n\n/** The pose's visual bounds: its frame expanded to cover the rotated\n *  rectangle, so a turned shape reports the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation =\n    geometry.getRotation?.(pose) ?? (b as { rotation?: number }).rotation ?? 0;\n  return axisAlignedBounds({ x: b.x, y: b.y, width: b.width, height: b.height, rotation });\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":"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"}
+{"version":3,"file":"poseDescriptor.js","names":["poseDescriptorForNode","descriptor","node","RECT_POSE_DESCRIPTOR","p","sx","src","dst","sy","b","dx","dy","a","t","like","n","pose","d","rotation","at","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","cos","sin","ux","uy","vx","vy","width","height","cxNew","cyNew","visualBoundsViaDescriptor","axisAlignedBounds","framedBounds","geometry","transform","poseLinearOf","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport { poseLinearOf } from '@weasel-js/geom';\nimport type { TargetAxes } from '@weasel-js/animator';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the kit's bounds-driven math: bounds\n * are read via `getBounds`, and `remapBounds` projects a result back into\n * TPose.\n *\n * `remapBounds(pose, src, dst)` subsumes both \"set my own AABB to dst\"\n * (single-leaf resize) and \"scale me as a leaf inside parent's src→dst rect\"\n * (group resize) — they're the same affine map.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** How a pose of `like`'s kind maps to the flat numbers an animation moves, and which of them\n   *  are angles. `from` keeps the fields of `like` that are not axes. Null for a pose this\n   *  descriptor cannot map; absent, a pose animates by its flat numeric fields. */\n  axes?(like: TPose): TargetAxes<TPose> | null;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation; the rotation affordance\n   *  hides when it is `false`. When omitted, the kit assumes `true`, so a\n   *  descriptor whose poses cannot rotate (e.g. polygon Paths) should\n   *  return `false`. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type are indistinguishable to them.\n   * Implement this to read `node.data` once and hand back a descriptor that\n   * knows which shape it is describing. Callers reach it through\n   * {@link poseDescriptorForNode}; sites with only an id keep using the\n   * unspecialized descriptor.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  axes: (like) => {\n    const flat = [like.x, like.y, like.width, like.height];\n    if (!flat.every((n) => typeof n === 'number')) return null;\n    return {\n      count: 5,\n      names: ['x', 'y', 'width', 'height', 'rotation'],\n      angles: [4],\n      to: (p) => [p.x, p.y, p.width, p.height, p.rotation ?? 0],\n      from: (a) => {\n        const pose = { ...like, x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! };\n        if (like.rotation !== undefined || a[4] !== 0) pose.rotation = a[4]!;\n        return pose;\n      },\n      add: (p, d) => {\n        const pose = { ...p, x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]! };\n        const rotation = (p.rotation ?? 0) + d[4]!;\n        if (p.rotation !== undefined || rotation !== 0) pose.rotation = rotation;\n        return pose;\n      },\n      write: (p, out, at) => {\n        out[at] = p.x;\n        out[at + 1] = p.y;\n        out[at + 2] = p.width;\n        out[at + 3] = p.height;\n        out[at + 4] = p.rotation ?? 0;\n      },\n    };\n  },\n  // `withRotation` writes into `Bounds`' optional `rotation`, so this reads\n  // the same channel, or a pose reports itself unrotated while painting rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,\n *  with a required `rotation`. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  axes: RECT_POSE_DESCRIPTOR.axes as PoseDescriptor<RotatedPose>['axes'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are expressed in the leaf's own frame. In a group\n * resize they are world-frame: at 90° a horizontal stretch should grow the\n * leaf's `height`, and the naive map grows its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model cannot represent the parallelogram\n * a non-uniform scale of a rotated box produces. The center moves exactly;\n * each local axis takes the length of its own image; the rotation follows the\n * image of the local x-axis.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n\n/** The pose's visual bounds: its box expanded to cover the box as drawn\n *  under its rotation and `transform`, so a turned or skewed shape reports\n *  the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  return axisAlignedBounds(framedBounds(pose, geometry));\n}\n\n/** The pose's box with the rotation and `transform` it is drawn in: what\n *  `poseFrameOf` reads, for a pose only its descriptor can read. */\nexport function framedBounds<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;\n  const transform = poseLinearOf(pose) ?? poseLinearOf(b);\n  if (!rotation && !transform) return b;\n  return { ...b, ...(rotation ? { rotation } : {}), ...(transform ? { transform } : {}) };\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":"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"}

package/dist/core/geometry/regionHit.js

@@ -1,7 +1,6 @@
 import { nodeMemo as e } from "../scene/nodeMemo.js";
-import { poseRotationOf as t, rotatePathAround as n } from "./poseRotation.js";
-import { visualBoundsViaDescriptor as r } from "./poseDescriptor.js";
-import { boxContainsBox as i, pointInPolygon as a, polygonContainsPath as o, polygonIntersectsPath as s } from "@weasel-js/geom";
+import { visualBoundsViaDescriptor as t } from "./poseDescriptor.js";
+import { boxContainsBox as n, pathThroughPoseFrame as r, pointInPolygon as i, polygonContainsPath as a, polygonIntersectsPath as o, poseFrameOf as s } from "@weasel-js/geom";
 //#region src/core/geometry/regionHit.ts
 function c(e) {
 	let { x: t, y: n, width: r, height: i } = e;
@@ -51,50 +50,48 @@ function u(e) {
 function d(e) {
 	return typeof e == "object" && !!e && e.kind === "polygon";
 }
-function f(t, n, i) {
-	return d(n) ? e(t, "aabb", n, () => i.getBounds(n)) : r(n, i);
+function f(n, r, i) {
+	return d(r) ? e(n, "aabb", r, () => i.getBounds(r)) : t(r, i);
 }
-function p(e, r) {
-	let i = t(e);
-	if (i) {
+function p(e, t) {
+	if (s(e)) {
 		let t = e;
-		return n({
+		return r({
 			kind: "rect",
 			x: t.x,
 			y: t.y,
 			width: t.width,
 			height: t.height
-		}, i.cx, i.cy, i.rotation);
+		}, e);
 	}
 	return {
 		kind: "rect",
-		x: r.x,
-		y: r.y,
-		width: r.width,
-		height: r.height
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height
 	};
 }
-function m(e, t, n, r, c) {
-	if (!Number.isFinite(r.x) || !Number.isFinite(r.y) || !Number.isFinite(r.width) || !Number.isFinite(r.height)) return !1;
-	let l = e.bounds;
-	if (r.x >= l.x + l.width || r.x + r.width <= l.x || r.y >= l.y + l.height || r.y + r.height <= l.y) return !1;
-	if (t === "centers") return a(e.coords, r.x + r.width / 2, r.y + r.height / 2);
-	let u = i([
-		l.x,
-		l.y,
-		l.x + l.width,
-		l.y + l.height
+function m(e, t, r, s, c, l = () => !0) {
+	if (!Number.isFinite(s.x) || !Number.isFinite(s.y) || !Number.isFinite(s.width) || !Number.isFinite(s.height)) return !1;
+	let u = e.bounds;
+	if (s.x >= u.x + u.width || s.x + s.width <= u.x || s.y >= u.y + u.height || s.y + s.height <= u.y) return !1;
+	if (t === "centers") return i(e.coords, s.x + s.width / 2, s.y + s.height / 2);
+	let f = n([
+		u.x,
+		u.y,
+		u.x + u.width,
+		u.y + u.height
 	], [
-		r.x,
-		r.y,
-		r.x + r.width,
-		r.y + r.height
-	]), f = d(n);
-	if (t === "enclosed") return u ? o(e.verts, f ? n : c()) : !1;
-	if (e.isRect && u) return !0;
-	if (f) return s(e.verts, n);
-	let p = c();
-	return p.kind === "rect" && e.isRect ? !0 : s(e.verts, p);
+		s.x,
+		s.y,
+		s.x + s.width,
+		s.y + s.height
+	]), p = d(r);
+	if (t === "enclosed") return f ? a(e.verts, p ? r : c()) : !1;
+	if (e.isRect && f) return !0;
+	let m = p ? r : c();
+	return l() ? m.kind === "rect" && e.isRect ? !0 : o(e.verts, m) : o(e.verts, m, { filled: !1 });
 }
 //#endregion
 export { d as isSilhouettePose, u as polygonRegion, p as poseOutline, c as rectRegion, f as regionBoundsOf, l as regionOf, m as regionTakes };