@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/PickHud.js

@@ -1,93 +1,96 @@
-import e from "./hud.module.js";
-import { useHostAnchor as t } from "./useHostAnchor.js";
-import { useEffect as n, useState as r } from "react";
-import { jsx as i, jsxs as a } from "react/jsx-runtime";
+import { clientToWorld as e } from "../core/viewport/clientToWorld.js";
+import t from "./hud.module.js";
+import { useHostAnchor as n } from "./useHostAnchor.js";
+import { useEffect as r, useState as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
+import { jsx as o, jsxs as s } from "react/jsx-runtime";
 //#region src/canvas/PickHud.tsx
-function o({ canvasRef: o, anchorRef: s, viewRef: c, pickEvery: l, pickBest: u, offset: d }) {
-	let [f, p] = r({
+function c({ canvasRef: c, anchorRef: l, viewRef: u, toWorld: d, pickEvery: f, pickBest: p, offset: m }) {
+	let h = a(d), [g, _] = i({
 		ids: [],
 		best: null,
 		inCanvas: !1
-	}), { ref: m, style: h } = t(() => s?.current ?? o.current?.parentElement ?? o.current, {
+	}), { ref: v, style: y } = n(() => l?.current ?? c.current?.parentElement ?? c.current, {
 		align: {
 			x: "end",
 			y: "start"
 		},
 		offset: {
-			x: d?.right ?? 8,
-			y: d?.top ?? 76
+			x: m?.right ?? 8,
+			y: m?.top ?? 76
 		}
 	});
-	return n(() => {
-		let e = (e) => {
-			let t = o.current, n = c.current;
-			if (!t || !n) {
-				p({
+	return r(() => {
+		let t = (t) => {
+			let n = c.current, r = u.current;
+			if (!n || !r) {
+				_({
 					ids: [],
 					best: null,
 					inCanvas: !1
 				});
 				return;
 			}
-			let r = t.getBoundingClientRect();
-			if (!(e.clientX >= r.left && e.clientX <= r.right && e.clientY >= r.top && e.clientY <= r.bottom)) {
-				p({
+			let i = n.getBoundingClientRect();
+			if (!(t.clientX >= i.left && t.clientX <= i.right && t.clientY >= i.top && t.clientY <= i.bottom)) {
+				_({
 					ids: [],
 					best: null,
 					inCanvas: !1
 				});
 				return;
 			}
-			let i = (e.clientX - r.left) / n.scale.x + n.x, a = (e.clientY - r.top) / n.scale.y + n.y, s = [];
+			let [a, o] = h.current?.(t.clientX, t.clientY) ?? e(t.clientX, t.clientY, i, r), s = [];
 			try {
-				s = l(i, a);
+				s = f(a, o);
 			} catch {
 				s = [];
 			}
-			let d = null;
-			if (u) try {
-				d = u(i, a);
+			let l = null;
+			if (p) try {
+				l = p(a, o);
 			} catch {
-				d = null;
+				l = null;
 			}
-			p({
+			_({
 				ids: s,
-				best: d,
+				best: l,
 				inCanvas: !0
 			});
 		};
-		return document.addEventListener("pointermove", e), () => {
-			document.removeEventListener("pointermove", e);
+		return document.addEventListener("pointermove", t), () => {
+			document.removeEventListener("pointermove", t);
 		};
 	}, [
-		o,
 		c,
-		l,
-		u
-	]), h ? /* @__PURE__ */ a("div", {
-		ref: m,
-		className: `${e.hud} ${e.sized}`,
-		style: h,
-		children: [/* @__PURE__ */ a("div", {
-			className: `${e.header} ${e.muted}`,
+		u,
+		f,
+		p,
+		h
+	]), y ? /* @__PURE__ */ s("div", {
+		ref: v,
+		className: `${t.hud} ${t.sized}`,
+		style: y,
+		children: [/* @__PURE__ */ s("div", {
+			className: `${t.header} ${t.muted}`,
 			children: [
 				"pickEvery (",
-				f.ids.length,
+				g.ids.length,
 				")"
 			]
-		}), f.ids.length === 0 ? /* @__PURE__ */ i("div", {
-			className: e.absent,
-			children: f.inCanvas ? "—" : "off-canvas"
-		}) : /* @__PURE__ */ i("ul", {
-			className: e.list,
-			children: f.ids.slice().reverse().map((t) => /* @__PURE__ */ i("li", {
-				className: t === f.best ? `${e.item} ${e.itemBest}` : e.item,
-				children: t
-			}, t))
+		}), g.ids.length === 0 ? /* @__PURE__ */ o("div", {
+			className: t.absent,
+			children: g.inCanvas ? "—" : "off-canvas"
+		}) : /* @__PURE__ */ o("ul", {
+			className: t.list,
+			children: g.ids.slice().reverse().map((e) => /* @__PURE__ */ o("li", {
+				className: e === g.best ? `${t.item} ${t.itemBest}` : t.item,
+				children: e
+			}, e))
 		})]
 	}) : null;
 }
 //#endregion
-export { o as PickHud };
+export { c as PickHud };
 
 //# sourceMappingURL=PickHud.js.map

package/dist/canvas/PickHud.js.map

@@ -1 +1 @@
-{"version":3,"file":"PickHud.js","names":["s","hud_module_default","PickHud","state","setState","useState","useHostAnchor","anchorRef","canvasRef","offset","useEffect","onMove","canvas","view","viewRef","rect","worldX","worldY","ids","pickEvery","best","pickBest","style","id"],"sources":["../../src/canvas/PickHud.tsx"],"sourcesContent":["/**\n * Dev HUD listing the ids returned by `pickEvery(world)` under the cursor.\n *\n * Anchors to the canvas's top-right corner like `CursorCoordsHud`, offset\n * downward so it sits just below that HUD. Updates on `document`\n * pointermove. Refreshes its position on scroll / resize so it tracks the\n * canvas through layout changes.\n */\nimport { useEffect, useState } from 'react';\nimport type { View } from 'core/viewport/view';\nimport { useHostAnchor } from './useHostAnchor';\nimport s from './hud.module.css';\n\n/** Props for `<PickHud>`. */\nexport interface PickHudProps {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Element the HUD pins its corner to. Defaults to the canvas's parent — the\n   *  wrapper a bare `<canvas>` sits in. A detached canvas passes its own input\n   *  box, whose parent is the shared surface every pane sits in. */\n  anchorRef?: React.RefObject<HTMLElement | null>;\n  viewRef: React.RefObject<View>;\n  /** World-space hit-test. Same shape as `useSelectTool`'s `pickEvery`. */\n  pickEvery: (worldX: number, worldY: number) => readonly string[];\n  /** Optional single-best resolver — the id this point would select on a\n   *  bare click. When supplied, that id is rendered bold in the list. */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n  /** Inset from the canvas's top-right corner. Default `{ top: 76, right: 8 }`\n   *  so the HUD clears `CursorCoordsHud` (~64 px tall in its 3-line form). */\n  offset?: { top?: number; right?: number };\n}\n\ninterface HudState {\n  ids: readonly string[];\n  best: string | null;\n  inCanvas: boolean;\n}\n\n/** Debug overlay listing every node under the pointer, with the one a click\n *  would actually select shown in bold. */\nexport function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }: PickHudProps) {\n  const [state, setState] = useState<HudState>({\n    ids: [], best: null, inCanvas: false,\n  });\n  const { ref, style } = useHostAnchor(\n    () => anchorRef?.current ?? canvasRef.current?.parentElement ?? canvasRef.current,\n    {\n      align: { x: 'end', y: 'start' },\n      offset: { x: offset?.right ?? 8, y: offset?.top ?? 76 },\n    },\n  );\n\n  useEffect(() => {\n    const onMove = (e: PointerEvent) => {\n      const canvas = canvasRef.current;\n      const view = viewRef.current;\n      if (!canvas || !view) {\n        setState({ ids: [], best: null, inCanvas: false });\n        return;\n      }\n      const rect = canvas.getBoundingClientRect();\n      const inCanvas =\n        e.clientX >= rect.left && e.clientX <= rect.right &&\n        e.clientY >= rect.top  && e.clientY <= rect.bottom;\n      if (!inCanvas) {\n        setState({ ids: [], best: null, inCanvas: false });\n        return;\n      }\n      const worldX = (e.clientX - rect.left) / view.scale.x + view.x;\n      const worldY = (e.clientY - rect.top)  / view.scale.y + view.y;\n      let ids: readonly string[] = [];\n      try {\n        ids = pickEvery(worldX, worldY);\n      } catch {\n        ids = [];\n      }\n      let best: string | null = null;\n      if (pickBest) {\n        try { best = pickBest(worldX, worldY); } catch { best = null; }\n      }\n      setState({ ids, best, inCanvas: true });\n    };\n\n    document.addEventListener('pointermove', onMove);\n\n    return () => {\n      document.removeEventListener('pointermove', onMove);\n    };\n  }, [canvasRef, viewRef, pickEvery, pickBest]);\n\n  if (!style) return null;\n\n  return (\n    <div ref={ref} className={`${s.hud} ${s.sized}`} style={style}>\n      <div className={`${s.header} ${s.muted}`}>pickEvery ({state.ids.length})</div>\n      {state.ids.length === 0 ? (\n        <div className={s.absent}>{state.inCanvas ? '—' : 'off-canvas'}</div>\n      ) : (\n        <ul className={s.list}>\n          {/* pickEvery returns back-to-front (topmost last). Display top-first. */}\n          {state.ids.slice().reverse().map((id) => (\n            <li\n              key={id}\n              className={id === state.best ? `${s.item} ${s.itemBest}` : s.item}\n            >\n              {id}\n            </li>\n          ))}\n        </ul>\n      )}\n    </div>\n  );\n}\n"],"mappings":";;;;;AAuCA,SAAgBE,EAAQ,EAAE,cAAW,cAAW,YAAS,cAAW,aAAU,aAAwB;CACpG,IAAM,CAACC,GAAOC,KAAYC,EAAmB;EAC3C,KAAK,CAAC;EAAG,MAAM;EAAM,UAAU;CACjC,CAAC,GACK,EAAE,QAAK,aAAUC,QACfC,GAAW,WAAWC,EAAU,SAAS,iBAAiBA,EAAU,SAC1E;EACE,OAAO;GAAE,GAAG;GAAO,GAAG;EAAQ;EAC9B,QAAQ;GAAE,GAAGC,GAAQ,SAAS;GAAG,GAAGA,GAAQ,OAAO;EAAG;CACxD,CACF;CA0CA,OAxCAC,QAAgB;EACd,IAAMC,KAAU,MAAoB;GAClC,IAAMC,IAASJ,EAAU,SACnBK,IAAOC,EAAQ;GACrB,IAAI,CAACF,KAAU,CAACC,GAAM;IACpB,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAME,IAAOH,EAAO,sBAAsB;GAI1C,IAAI,EAFF,EAAE,WAAWG,EAAK,QAAQ,EAAE,WAAWA,EAAK,SAC5C,EAAE,WAAWA,EAAK,OAAQ,EAAE,WAAWA,EAAK,SAC/B;IACb,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAMC,KAAU,EAAE,UAAUD,EAAK,QAAQF,EAAK,MAAM,IAAIA,EAAK,GACvDI,KAAU,EAAE,UAAUF,EAAK,OAAQF,EAAK,MAAM,IAAIA,EAAK,GACzDK,IAAyB,CAAC;GAC9B,IAAI;IACF,IAAMC,EAAUH,GAAQC,CAAM;GAChC,QAAQ;IACN,IAAM,CAAC;GACT;GACA,IAAIG,IAAsB;GAC1B,IAAIC,GACF,IAAI;IAAE,IAAOA,EAASL,GAAQC,CAAM;GAAG,QAAQ;IAAE,IAAO;GAAM;GAEhE,EAAS;IAAE;IAAK;IAAM,UAAU;GAAK,CAAC;EACxC;EAIA,OAFA,SAAS,iBAAiB,eAAeN,CAAM,SAElC;GACX,SAAS,oBAAoB,eAAeA,CAAM;EACpD;CACF,GAAG;EAACH;EAAWM;EAASK;EAAWE;CAAQ,CAAC,GAEvCC,IAGH,kBAAC,OAAD;EAAU;EAAK,WAAW,GAAGtB,EAAE,IAAI,GAAGA,EAAE;EAAgB;EAAxD,UAAA,CACE,kBAAC,OAAD;GAAK,WAAW,GAAGA,EAAE,OAAO,GAAGA,EAAE;GAAjC,UAAA;IAA0C;IAAYG,EAAM,IAAI;IAAO;GAAM;EAC5E,CAAA,GAAAA,EAAM,IAAI,WAAW,IACpB,kBAAC,OAAD;GAAK,WAAWH,EAAE;GAAS,UAAAG,EAAM,WAAW,MAAM;EAAkB,CAAA,IAEpE,kBAAC,MAAD;GAAI,WAAWH,EAAE;GAEd,UAAAG,EAAM,IAAI,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,MAChC,kBAAC,MAAD;IAEE,WAAWoB,MAAOpB,EAAM,OAAO,GAAGH,EAAE,KAAK,GAAGA,EAAE,aAAaA,EAAE;IAE5D,UAAAuB;GACC,GAJGA,CAIH,CACL;EACC,CAAA,CAEH;MApBY;AAsBrB"}
+{"version":3,"file":"PickHud.js","names":["s","hud_module_default","PickHud","toWorldRef","useLatest","toWorld","state","setState","useState","useHostAnchor","anchorRef","canvasRef","offset","useEffect","onMove","canvas","view","viewRef","rect","e","worldX","worldY","clientToWorld","ids","pickEvery","best","pickBest","style","id"],"sources":["../../src/canvas/PickHud.tsx"],"sourcesContent":["/// <reference path=\"../css-modules.d.ts\" />\n/**\n * Dev HUD listing the ids returned by `pickEvery(world)` under the cursor.\n *\n * Anchors to the canvas's top-right corner like `CursorCoordsHud`, offset\n * downward so it sits just below that HUD. Updates on `document`\n * pointermove. Refreshes its position on scroll / resize so it tracks the\n * canvas through layout changes.\n */\nimport { useEffect, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\nimport { useHostAnchor } from './useHostAnchor';\nimport s from './hud.module.css';\n\n/** Props for `<PickHud>`. */\nexport interface PickHudProps {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Element the HUD pins its corner to. Defaults to the canvas's parent — the\n   *  wrapper a bare `<canvas>` sits in. A detached canvas passes its own input\n   *  box, whose parent is the shared surface every pane sits in. */\n  anchorRef?: React.RefObject<HTMLElement | null>;\n  viewRef: React.RefObject<View>;\n  /** Client coords to world. Defaults to the canvas's rect and `viewRef`. A\n   *  canvas whose routing converts some other way (a CSS transform, a 3D host)\n   *  passes that conversion, so the readout agrees with the picks. */\n  toWorld?: (clientX: number, clientY: number) => [number, number];\n  /** World-space hit-test. Same shape as `useSelectTool`'s `pickEvery`. */\n  pickEvery: (worldX: number, worldY: number) => readonly string[];\n  /** Optional single-best resolver — the id this point would select on a\n   *  bare click. When supplied, that id is rendered bold in the list. */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n  /** Inset from the canvas's top-right corner. Default `{ top: 76, right: 8 }`\n   *  so the HUD clears `CursorCoordsHud` (~64 px tall in its 3-line form). */\n  offset?: { top?: number; right?: number };\n}\n\ninterface HudState {\n  ids: readonly string[];\n  best: string | null;\n  inCanvas: boolean;\n}\n\n/** Debug overlay listing every node under the pointer, with the one a click\n *  would actually select shown in bold. */\nexport function PickHud({ canvasRef, anchorRef, viewRef, toWorld, pickEvery, pickBest, offset }: PickHudProps) {\n  const toWorldRef = useLatest(toWorld);\n  const [state, setState] = useState<HudState>({\n    ids: [], best: null, inCanvas: false,\n  });\n  const { ref, style } = useHostAnchor(\n    () => anchorRef?.current ?? canvasRef.current?.parentElement ?? canvasRef.current,\n    {\n      align: { x: 'end', y: 'start' },\n      offset: { x: offset?.right ?? 8, y: offset?.top ?? 76 },\n    },\n  );\n\n  useEffect(() => {\n    const onMove = (e: PointerEvent) => {\n      const canvas = canvasRef.current;\n      const view = viewRef.current;\n      if (!canvas || !view) {\n        setState({ ids: [], best: null, inCanvas: false });\n        return;\n      }\n      const rect = canvas.getBoundingClientRect();\n      const inCanvas =\n        e.clientX >= rect.left && e.clientX <= rect.right &&\n        e.clientY >= rect.top  && e.clientY <= rect.bottom;\n      if (!inCanvas) {\n        setState({ ids: [], best: null, inCanvas: false });\n        return;\n      }\n      const [worldX, worldY] = toWorldRef.current?.(e.clientX, e.clientY)\n        ?? clientToWorld(e.clientX, e.clientY, rect, view);\n      let ids: readonly string[] = [];\n      try {\n        ids = pickEvery(worldX, worldY);\n      } catch {\n        ids = [];\n      }\n      let best: string | null = null;\n      if (pickBest) {\n        try { best = pickBest(worldX, worldY); } catch { best = null; }\n      }\n      setState({ ids, best, inCanvas: true });\n    };\n\n    document.addEventListener('pointermove', onMove);\n\n    return () => {\n      document.removeEventListener('pointermove', onMove);\n    };\n  }, [canvasRef, viewRef, pickEvery, pickBest, toWorldRef]);\n\n  if (!style) return null;\n\n  return (\n    <div ref={ref} className={`${s.hud} ${s.sized}`} style={style}>\n      <div className={`${s.header} ${s.muted}`}>pickEvery ({state.ids.length})</div>\n      {state.ids.length === 0 ? (\n        <div className={s.absent}>{state.inCanvas ? '—' : 'off-canvas'}</div>\n      ) : (\n        <ul className={s.list}>\n          {/* pickEvery returns back-to-front (topmost last). Display top-first. */}\n          {state.ids.slice().reverse().map((id) => (\n            <li\n              key={id}\n              className={id === state.best ? `${s.item} ${s.itemBest}` : s.item}\n            >\n              {id}\n            </li>\n          ))}\n        </ul>\n      )}\n    </div>\n  );\n}\n"],"mappings":";;;;;;;AA8CA,SAAgBE,EAAQ,EAAE,cAAW,cAAW,YAAS,YAAS,cAAW,aAAU,aAAwB;CAC7G,IAAMC,IAAaC,EAAUC,CAAO,GAC9B,CAACC,GAAOC,KAAYC,EAAmB;EAC3C,KAAK,CAAC;EAAG,MAAM;EAAM,UAAU;CACjC,CAAC,GACK,EAAE,QAAK,aAAUC,QACfC,GAAW,WAAWC,EAAU,SAAS,iBAAiBA,EAAU,SAC1E;EACE,OAAO;GAAE,GAAG;GAAO,GAAG;EAAQ;EAC9B,QAAQ;GAAE,GAAGC,GAAQ,SAAS;GAAG,GAAGA,GAAQ,OAAO;EAAG;CACxD,CACF;CA0CA,OAxCAC,QAAgB;EACd,IAAMC,KAAU,MAAoB;GAClC,IAAMC,IAASJ,EAAU,SACnBK,IAAOC,EAAQ;GACrB,IAAI,CAACF,KAAU,CAACC,GAAM;IACpB,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAME,IAAOH,EAAO,sBAAsB;GAI1C,IAAI,EAFFI,EAAE,WAAWD,EAAK,QAAQC,EAAE,WAAWD,EAAK,SAC5CC,EAAE,WAAWD,EAAK,OAAQC,EAAE,WAAWD,EAAK,SAC/B;IACb,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAM,CAACE,GAAQC,KAAUlB,EAAW,UAAUgB,EAAE,SAASA,EAAE,OAAO,KAC7DG,EAAcH,EAAE,SAASA,EAAE,SAASD,GAAMF,CAAI,GAC/CO,IAAyB,CAAC;GAC9B,IAAI;IACF,IAAMC,EAAUJ,GAAQC,CAAM;GAChC,QAAQ;IACN,IAAM,CAAC;GACT;GACA,IAAII,IAAsB;GAC1B,IAAIC,GACF,IAAI;IAAE,IAAOA,EAASN,GAAQC,CAAM;GAAG,QAAQ;IAAE,IAAO;GAAM;GAEhE,EAAS;IAAE;IAAK;IAAM,UAAU;GAAK,CAAC;EACxC;EAIA,OAFA,SAAS,iBAAiB,eAAeP,CAAM,SAElC;GACX,SAAS,oBAAoB,eAAeA,CAAM;EACpD;CACF,GAAG;EAACH;EAAWM;EAASO;EAAWE;EAAUvB;CAAU,CAAC,GAEnDwB,IAGH,kBAAC,OAAD;EAAU;EAAK,WAAW,GAAG3B,EAAE,IAAI,GAAGA,EAAE;EAAgB;EAAxD,UAAA,CACE,kBAAC,OAAD;GAAK,WAAW,GAAGA,EAAE,OAAO,GAAGA,EAAE;GAAjC,UAAA;IAA0C;IAAYM,EAAM,IAAI;IAAO;GAAM;EAC5E,CAAA,GAAAA,EAAM,IAAI,WAAW,IACpB,kBAAC,OAAD;GAAK,WAAWN,EAAE;GAAS,UAAAM,EAAM,WAAW,MAAM;EAAkB,CAAA,IAEpE,kBAAC,MAAD;GAAI,WAAWN,EAAE;GAEd,UAAAM,EAAM,IAAI,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,MAChC,kBAAC,MAAD;IAEE,WAAWsB,MAAOtB,EAAM,OAAO,GAAGN,EAAE,KAAK,GAAGA,EAAE,aAAaA,EAAE;IAE5D,UAAA4B;GACC,GAJGA,CAIH,CACL;EACC,CAAA,CAEH;MApBY;AAsBrB"}

package/dist/canvas/SceneCanvas/DevHuds.js

@@ -0,0 +1,40 @@
+import { CursorCoordsHud as e } from "../CursorCoordsHud.js";
+import { ModalityHud as t } from "../ModalityHud.js";
+import { PickHud as n } from "../PickHud.js";
+import { useCallback as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+import { Fragment as a, jsx as o, jsxs as s } from "react/jsx-runtime";
+//#region src/canvas/SceneCanvas/DevHuds.tsx
+function c(c) {
+	let { cursorCoords: l, pick: u, modality: d, canvasRef: f, canvasApiRef: p, detachedInput: m, viewRef: h } = c, g = r((e, t) => p.current?.clientToWorld(e, t) ?? [e, t], [p]), _ = i({
+		pickEvery: c.pickEvery,
+		pickBest: c.pickBest
+	}), v = r((e, t) => _.current.pickEvery(e, t), [_]), y = r((e, t) => _.current.pickBest(e, t), [_]);
+	if (m === null) return null;
+	let b = m ? { anchorRef: f } : {};
+	return /* @__PURE__ */ s(a, { children: [
+		l && /* @__PURE__ */ o(e, {
+			canvasRef: f,
+			...b,
+			viewRef: h,
+			toWorld: g
+		}),
+		u && /* @__PURE__ */ o(n, {
+			canvasRef: f,
+			...b,
+			viewRef: h,
+			toWorld: g,
+			pickEvery: v,
+			pickBest: y
+		}),
+		d && /* @__PURE__ */ o(t, {
+			canvasRef: f,
+			...b,
+			modeId: typeof d == "object" ? d.modeId : void 0
+		})
+	] });
+}
+//#endregion
+export { c as DevHuds };
+
+//# sourceMappingURL=DevHuds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DevHuds.js","names":["_Fragment","DevHuds","props","toWorld","useCallback","canvasApiRef","clientX","clientY","pickersRef","useLatest","pickEvery","wx","wy","pickBest","detachedInput","anchor","canvasRef","Fragment","cursorCoords","CursorCoordsHud","pick","PickHud","modality","ModalityHud"],"sources":["../../../src/canvas/SceneCanvas/DevHuds.tsx"],"sourcesContent":["/**\n * `<SceneCanvas>`'s dev HUDs: the cursor readout, the pick list, and the\n * modality panel, each a fixed-position widget pinned to the canvas.\n */\nimport { useCallback, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { CursorCoordsHud } from '../CursorCoordsHud';\nimport { ModalityHud } from '../ModalityHud';\nimport { PickHud } from '../PickHud';\n\nexport interface DevHudsProps {\n  cursorCoords: boolean | undefined;\n  pick: boolean | undefined;\n  /** `true` leaves the mode line at `—`; an object supplies the mode id. */\n  modality: boolean | { modeId?: string } | undefined;\n  /** The element input comes from. */\n  canvasRef: RefObject<HTMLElement | null>;\n  /** Read for the canvas's own client→world conversion, so a readout agrees\n   *  with a pick. */\n  canvasApiRef: RefObject<Pick<CanvasExtensionApi, 'clientToWorld'> | null>;\n  /** Under `paintInto`, the caller's input element, `null` until it arrives;\n   *  `undefined` when the canvas renders its own. Each HUD of a detached\n   *  canvas pins to the input element itself, not to its parent, which every\n   *  pane of the shared surface sits in. */\n  detachedInput: HTMLElement | null | undefined;\n  viewRef: RefObject<View>;\n  pickEvery: (worldX: number, worldY: number) => readonly string[];\n  /** The id a bare click at this point would select. */\n  pickBest: (worldX: number, worldY: number) => string | null;\n}\n\nexport function DevHuds(props: DevHudsProps) {\n  const { cursorCoords, pick, modality, canvasRef, canvasApiRef, detachedInput, viewRef } = props;\n  const toWorld = useCallback(\n    (clientX: number, clientY: number): [number, number] =>\n      canvasApiRef.current?.clientToWorld(clientX, clientY) ?? [clientX, clientY],\n    [canvasApiRef],\n  );\n  // The pick HUD installs its pointer listener again whenever a picker's\n  // identity changes, so it gets two that never do.\n  const pickersRef = useLatest({ pickEvery: props.pickEvery, pickBest: props.pickBest });\n  const pickEvery = useCallback(\n    (wx: number, wy: number): readonly string[] => pickersRef.current.pickEvery(wx, wy),\n    [pickersRef],\n  );\n  const pickBest = useCallback(\n    (wx: number, wy: number): string | null => pickersRef.current.pickBest(wx, wy),\n    [pickersRef],\n  );\n\n  // `useHostAnchor` resolves its host on mount and again only when the panel\n  // or the window moves, so a HUD mounted against a null host would latch off.\n  if (detachedInput === null) return null;\n\n  const anchor = detachedInput ? { anchorRef: canvasRef } : {};\n  return (\n    <>\n      {cursorCoords && (\n        <CursorCoordsHud canvasRef={canvasRef} {...anchor} viewRef={viewRef} toWorld={toWorld} />\n      )}\n      {pick && (\n        <PickHud\n          canvasRef={canvasRef}\n          {...anchor}\n          viewRef={viewRef}\n          toWorld={toWorld}\n          pickEvery={pickEvery}\n          pickBest={pickBest}\n        />\n      )}\n      {modality && (\n        <ModalityHud\n          canvasRef={canvasRef}\n          {...anchor}\n          modeId={typeof modality === 'object' ? modality.modeId : undefined}\n        />\n      )}\n    </>\n  );\n}\n"],"mappings":";;;;;;;AAiCA,SAAgBC,EAAQ,GAAqB;CAC3C,IAAM,EAAE,iBAAc,SAAM,aAAU,cAAW,iBAAc,kBAAe,eAAYC,GACpFC,IAAUC,GACb,GAAiB,MAChBC,EAAa,SAAS,cAAcC,GAASC,CAAO,KAAK,CAACD,GAASC,CAAO,GAC5E,CAACF,CAAY,CACf,GAGMG,IAAaC,EAAU;EAAE,WAAWP,EAAM;EAAW,UAAUA,EAAM;CAAS,CAAC,GAC/EQ,IAAYN,GACf,GAAY,MAAkCI,EAAW,QAAQ,UAAUG,GAAIC,CAAE,GAClF,CAACJ,CAAU,CACb,GACMK,IAAWT,GACd,GAAY,MAA8BI,EAAW,QAAQ,SAASG,GAAIC,CAAE,GAC7E,CAACJ,CAAU,CACb;CAIA,IAAIM,MAAkB,MAAM,OAAO;CAEnC,IAAMC,IAASD,IAAgB,EAAE,WAAWE,EAAU,IAAI,CAAC;CAC3D,OACE,kBAAAhB,GAAA,EAAA,UAAA;EACGkB,KACC,kBAACC,GAAD;GAA4B;GAAW,GAAIJ;GAAiB;GAAkB;EAAU,CAAA;EAEzFK,KACC,kBAACC,GAAD;GACa;GACX,GAAIN;GACK;GACA;GACE;GACD;EACX,CAAA;EAEFO,KACC,kBAACC,GAAD;GACa;GACX,GAAIR;GACJ,QAAQ,OAAOO,KAAa,WAAWA,EAAS,SAAS,KAAA;EAC1D,CAAA;CAEH,EAAA,CAAA;AAEN"}

package/dist/canvas/SceneCanvas/GestureDispatcherMounter.js

@@ -0,0 +1,126 @@
+import { EMPTY_CHROME_STATE as e } from "../../core/selection/chromeState.js";
+import { anchorStateFrom as t, buildAffordanceAt as n, buildClassifyTarget as r, chromeAffordances as i, layerAffordance as a } from "../affordanceAt.js";
+import { pathFromPlane as o } from "../planeClips.js";
+import { useOptionalViewRegistry as s } from "../viewRegistry.js";
+import { traceConversion as c } from "./coordTrace.js";
+import { useCallback as l, useInsertionEffect as ee, useMemo as u, useState as d } from "react";
+import { useLatest as f } from "@weasel-js/react";
+import { createLongPressStore as p } from "@weasel-js/routing";
+import { useActionsRegistry as te, useDepRegistry as m, useDepSource as h, useGestureDispatcher as g } from "@weasel-js/routing/react";
+//#region src/canvas/SceneCanvas/GestureDispatcherMounter.tsx
+function _({ canvasRef: _, canvasApiRef: v, tools: y, contributions: b, enabled: ne, keyboard: x, claimKeys: S, selectionRef: C, boundsOf: w, planeOfNode: T, pickEvery: E, pickBest: D, kindOfNode: O, viewRef: k, dispatcher: A, getIsVisibleForCanvas: j, getRuleCtx: re, targetScale: M, handleHitRadius: N, rotationBadge: P, chromeAffordancesRef: F, onDoubleClick: I, onClick: L, longPress: { duration: R, haptics: z } = {} }) {
+	let B = te(), V = m(), H = s(), U = u(() => {
+		let e = /* @__PURE__ */ new Map();
+		for (let [t, n] of Object.entries(y.registry)) e.set(t, n);
+		for (let t of b) e.set(t.id, t);
+		for (let t of y.ambient) e.set(t.id, t);
+		return e;
+	}, [
+		y.registry,
+		y.ambient,
+		b
+	]), W = f(E), G = f(D), K = f(O), q = f(V), J = f(T), Y = u(() => t(() => q.current, (e, t) => o(t, J.current?.(e) ?? null)), [q, J]), X = u(() => i({
+		...M === void 0 ? {} : { targetScale: M },
+		...N === void 0 ? {} : { handleHitRadius: N },
+		rotationBadge: P,
+		getAnchorState: Y
+	}), [
+		M,
+		N,
+		P,
+		Y
+	]);
+	ee(() => {
+		F && (F.current = X);
+	});
+	let Z = u(() => {
+		if (C && w && k) return n({
+			getChromeState: () => H?.surface()?.chromeState() ?? e,
+			getView: () => k.current ?? {
+				x: 0,
+				y: 0,
+				scale: {
+					x: 1,
+					y: 1
+				}
+			},
+			affordances: X,
+			...j ? { getIsVisible: () => j() } : {}
+		});
+	}, [
+		C,
+		w,
+		k,
+		X,
+		j,
+		H
+	]), ie = u(() => {
+		if (C && E && k) return r(() => C.current?.current ?? [], (e, t) => {
+			if (G.current) return G.current(e, t);
+			let n = W.current?.(e, t) ?? [];
+			return n.length > 0 ? n[n.length - 1] : null;
+		}, (e) => K.current?.(e));
+	}, [
+		C,
+		E,
+		k,
+		G,
+		W,
+		K
+	]), ae = l((e, t) => {
+		let n = v.current, [r, i] = n ? n.clientToWorld(e, t) : [e, t], a = {
+			x: r,
+			y: i
+		};
+		return c(e, t, n ? _.current : null, k?.current, a), a;
+	}, [
+		_,
+		v,
+		k
+	]), oe = u(() => (e) => {
+		let t = v.current?.hitTestExtras?.(e.x, e.y);
+		return t ? a(t.layerId, t.hit) : Z ? Z(e) : null;
+	}, [Z, v]), se = l(() => {
+		v.current?.requestRedraw?.();
+	}, [v]), ce = l(() => v.current?.paintedCursor, [v]), le = l(() => v.current?.cursorSink, [v]), [Q] = d(p), ue = u(() => ({
+		state: Q,
+		...R === void 0 ? {} : { duration: R },
+		...z === void 0 ? {} : { haptics: z }
+	}), [
+		Q,
+		R,
+		z
+	]), $ = u(() => {
+		if (H) return {
+			targets: () => H.list().map((e) => ({
+				id: e.id,
+				...e.target
+			})),
+			resolver: H.resolver
+		};
+	}, [H]);
+	return g({
+		canvasRef: _,
+		actions: B,
+		entriesById: U,
+		enabled: ne,
+		keyboard: x,
+		claimKeys: S,
+		affordanceAt: oe,
+		classifyTarget: ie,
+		dispatcher: A,
+		clientToWorld: ae,
+		requestRedraw: se,
+		paintedCursor: ce,
+		cursorSink: le,
+		getRuleCtx: re,
+		onClick: L,
+		onDoubleClick: I,
+		longPress: ue,
+		...$ ? { views: $ } : {}
+	}), h("longPress", () => Q), null;
+}
+//#endregion
+export { _ as GestureDispatcherMounter };
+
+//# sourceMappingURL=GestureDispatcherMounter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GestureDispatcherMounter.js","names":["GestureDispatcherMounter","longPressDuration","longPressHaptics","registry","useActionsRegistry","depRegistry","useDepRegistry","viewRegistry","useOptionalViewRegistry","entriesById","useMemo","m","id","tool","tools","entry","contributions","pickEveryRef","useLatest","pickEvery","pickBestRef","pickBest","kindOfNodeRef","kindOfNode","depRegistryRef","planeOfNodeRef","planeOfNode","getAnchorState","anchorStateFrom","pathFromPlane","path","affordances","chromeAffordances","targetScale","handleHitRadius","rotationBadge","chromeAffordancesRef","affordanceAt","selectionRef","boundsOf","viewRef","buildAffordanceAt","EMPTY_CHROME_STATE","getIsVisibleForCanvas","classifyTarget","buildClassifyTarget","wx","wy","ids","clientToWorld","useCallback","api","canvasApiRef","x","y","clientX","clientY","world","traceConversion","canvasRef","affordanceWithLayers","extra","worldPoint","layerAffordance","requestRedraw","paintedCursor","cursorSink","longPressState","useState","createLongPressStore","longPress","views","r","useGestureDispatcher","useDepSource"],"sources":["../../../src/canvas/SceneCanvas/GestureDispatcherMounter.tsx"],"sourcesContent":["import { useLatest } from '@weasel-js/react';\nimport { createLongPressStore, type Dispatcher } from '@weasel-js/routing';\nimport { useActionsRegistry, useDepRegistry, useDepSource, useGestureDispatcher } from '@weasel-js/routing/react';\nimport type { Affordance } from 'affordances/types';\nimport { EMPTY_CHROME_STATE } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport type { RuleCtx } from 'features/chrome-caps';\nimport type React from 'react';\nimport { useCallback, useInsertionEffect, useMemo, useState } from 'react';\nimport type { Contribution } from '../../tools/overlayBinding';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport { anchorStateFrom, buildAffordanceAt, buildClassifyTarget, chromeAffordances, layerAffordance } from '../affordanceAt';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { pathFromPlane } from '../planeClips';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { traceConversion } from './coordTrace';\nimport type { SceneCanvasLongPress } from './props';\n\nexport function GestureDispatcherMounter({\n  canvasRef,\n  canvasApiRef,\n  tools,\n  contributions,\n  enabled,\n  keyboard,\n  claimKeys,\n  selectionRef,\n  boundsOf,\n  planeOfNode,\n  pickEvery,\n  pickBest,\n  kindOfNode,\n  viewRef,\n  dispatcher,\n  getIsVisibleForCanvas,\n  getRuleCtx,\n  targetScale,\n  handleHitRadius,\n  rotationBadge,\n  chromeAffordancesRef,\n  onDoubleClick,\n  onClick,\n  longPress: { duration: longPressDuration, haptics: longPressHaptics } = {},\n}: {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Holds the full `CanvasExtensionApi` so the gesture dispatcher can call\n   *  `requestRedraw()` between pointer events. */\n  canvasApiRef: React.RefObject<CanvasExtensionApi | null>;\n  tools: ToolsApi;\n  /** Always-live entries the canvas installs beside `tools` — the selection's\n   *  `move` / `transform` bindings. Ahead of the tools' ambient entries, so a\n   *  tie at one specificity goes to the kit's. */\n  contributions: readonly Contribution[];\n  enabled: boolean;\n  /** When false, the dispatcher leaves keyboard listeners unattached so\n   *  keyboard-bound actions never fire. Wired to `enableKeybindings`. */\n  keyboard: boolean;\n  /** Take the keyboard on mount. Wired to `claimKeys`. */\n  claimKeys: boolean;\n  selectionRef?: React.RefObject<import('core/selection/useSelection').SelectionApi>;\n  boundsOf?: (id: string) => import('core/viewport/fitViewToBounds').Bounds | null;\n  /** The parallax plane a node is drawn through, under the surface's camera —\n   *  so path anchors are hit where the plane draws them. */\n  planeOfNode?: (id: string) => import('core/viewport/parallax').PlaneMap | null;\n  pickEvery?: (worldX: number, worldY: number) => string[];\n  /** Single topmost hit (collapses parent/child via `pickTopMostHit`), used to\n   *  classify the body under the pointer. Must match the select tool's own\n   *  resolution so a child node isn't misclassified by its parent's selection.\n   *  Falls back to `pickEvery`'s last id when absent. */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n  /** Resolves a hit node id to its routing-trait kind, so the body\n   *  classification carries `kind` alongside `bodyTarget` and the\n   *  `kind:<k>` / `kind:<k>:selected` target forms can match. Absent when\n   *  the consumer opted out of routing (`routing={[]}`). */\n  kindOfNode?: (id: string) => string | undefined;\n  viewRef?: React.RefObject<View>;\n  /** Pre-created dispatcher to pump events into. When omitted,\n   *  `useGestureDispatcher` creates one internally (legacy path). */\n  dispatcher?: Dispatcher;\n  /** Chrome-caps visibility resolver factory. Threaded into\n   *  `buildAffordanceAt` so the hit-test pipeline gates corner / rotate /\n   *  anchor affordances on the same chrome ids the renderer uses. */\n  getIsVisibleForCanvas?: () => (id: string) => boolean;\n  /** Live RuleCtx factory. Threaded into `useGestureDispatcher` so the\n   *  dispatcher's eligibility filter sees the same mode/capabilities/selection\n   *  view of the world that chrome-caps does. */\n  getRuleCtx?: () => RuleCtx | undefined;\n  /** `DeviceProfile.targetScale`, so the affordance grab zones resolve to the\n   *  same sizes the chrome paints at. */\n  targetScale?: number;\n  /** Consumer override for the corner-handle grab radius\n   *  (`selectTool.handleHitRadius`). Undefined takes the device-scaled size. */\n  handleHitRadius?: number;\n  /** The rotate badge the selection overlay paints, grabbable where drawn. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Receives the affordances this mounter hit-tests, for the slops overlay. */\n  chromeAffordancesRef?: React.MutableRefObject<readonly Affordance[]>;\n  /** Fires on every synthesized double click, in world coords. Backs the\n   *  `onDoubleClick` prop — see the option's doc on\n   *  `UseGestureDispatcherOptions` for why it's an observer, not a binding. */\n  onDoubleClick?: (world: { x: number; y: number }) => void;\n  /** Fires after every synthesized click. Backs the `onClick` prop. */\n  onClick?: (world: { x: number; y: number }) => void;\n  /** Backs `<SceneCanvas longPress>`. */\n  longPress?: SceneCanvasLongPress;\n}) {\n  const registry = useActionsRegistry();\n  const depRegistry = useDepRegistry();\n  const viewRegistry = useOptionalViewRegistry();\n  const entriesById = useMemo<ReadonlyMap<string, Contribution>>(() => {\n    const m = new Map<string, Contribution>();\n    for (const [id, tool] of Object.entries(tools.registry)) {\n      m.set(id, tool);\n    }\n    for (const entry of contributions) m.set(entry.id, entry);\n    // Ambient entries too — their bindings assemble at ambient scope, and the\n    // dispatcher resolves them through this same map.\n    for (const entry of tools.ambient) m.set(entry.id, entry);\n    return m;\n  }, [tools.registry, tools.ambient, contributions]);\n\n\n  // Stable refs for the optional thunk inputs so the thunks themselves are\n  // stable function identities across renders (no need to pass them as deps).\n  const pickEveryRef = useLatest(pickEvery);\n  const pickBestRef = useLatest(pickBest);\n  const kindOfNodeRef = useLatest(kindOfNode);\n\n  // `getAnchorState` thunk for `buildAffordanceAt` — reads the live\n  // `editAnchors` dep from the registry at call time.\n  const depRegistryRef = useLatest(depRegistry);\n  const planeOfNodeRef = useLatest(planeOfNode);\n  const getAnchorState = useMemo(() => anchorStateFrom(\n    () => depRegistryRef.current,\n    (id, path) => pathFromPlane(path, planeOfNodeRef.current?.(id) ?? null),\n  ), [depRegistryRef, planeOfNodeRef]);\n\n  // Build the `affordanceAt` thunk. Takes world coords and delegates to\n  // `buildAffordanceAt` for handle hit-testing.\n  const affordances = useMemo(() => chromeAffordances({\n    ...(targetScale !== undefined ? { targetScale } : {}),\n    ...(handleHitRadius !== undefined ? { handleHitRadius } : {}),\n    rotationBadge,\n    getAnchorState,\n  }), [targetScale, handleHitRadius, rotationBadge, getAnchorState]);\n  useInsertionEffect(() => {\n    if (chromeAffordancesRef) chromeAffordancesRef.current = affordances;\n  });\n  const affordanceAt = useMemo(() => {\n    if (!selectionRef || !boundsOf || !viewRef) return undefined;\n    return buildAffordanceAt({\n      // The canvas's own view chrome, built once by its helpers — not a\n      // second construction here that has to agree with the painted one.\n      getChromeState: () => viewRegistry?.surface()?.chromeState() ?? EMPTY_CHROME_STATE,\n      // Radii are declared in screen pixels and converted against this view.\n      getView: () => viewRef.current ?? { x: 0, y: 0, scale: { x: 1, y: 1 } },\n      affordances,\n      // Chrome-caps resolver: keep the affordance hit-test in sync with what\n      // the renderer is actually painting. Without this, a click on a (no\n      // longer visible) resize handle position still classifies as a resize\n      // handle — e.g. an anchor drag in path-edit mode resizes the path's\n      // bounding box instead of moving the anchor.\n      ...(getIsVisibleForCanvas ? { getIsVisible: () => getIsVisibleForCanvas() } : {}),\n    });\n  }, [selectionRef, boundsOf, viewRef, affordances, getIsVisibleForCanvas, viewRegistry]);\n\n  // Build the `classifyTarget` thunk. Takes world coords and delegates to\n  // `buildClassifyTarget`.\n  const classifyTarget = useMemo(() => {\n    if (!selectionRef || !pickEvery || !viewRef) return undefined;\n    return buildClassifyTarget(\n      () => selectionRef.current?.current ?? [],\n      // Use the select tool's own topmost-hit resolution (`pickTopMostHit`,\n      // which collapses parent/child) so a child body is classified by ITS\n      // OWN selection — not its parent's.\n      (wx: number, wy: number) => {\n        if (pickBestRef.current) return pickBestRef.current(wx, wy);\n        const ids = pickEveryRef.current?.(wx, wy) ?? [];\n        return ids.length > 0 ? ids[ids.length - 1] : null;\n      },\n      // Node kind comes from the routing trait — the same classifier that\n      // names `Hit.kind` — so `target: 'kind:text'` on a binding speaks the\n      // vocabulary the consumer already declared in `routing`, rather than a\n      // second one invented for bindings. `routing={[]}` opts out and leaves\n      // every `kind:` target unmatchable.\n      (id: string) => kindOfNodeRef.current?.(id),\n    );\n  }, [selectionRef, pickEvery, viewRef, pickBestRef, pickEveryRef, kindOfNodeRef]);\n\n  // Through the handle, so a `clientToWorld` override on the canvas applies.\n  const clientToWorld = useCallback((clientX: number, clientY: number): { x: number; y: number } => {\n    const api = canvasApiRef.current;\n    const [x, y] = api ? api.clientToWorld(clientX, clientY) : [clientX, clientY];\n    const world = { x, y };\n    traceConversion(clientX, clientY, api ? canvasRef.current : null, viewRef?.current, world);\n    return world;\n  }, [canvasRef, canvasApiRef, viewRef]);\n\n  const affordanceWithLayers = useMemo(() => {\n    // Note this is NOT gated on `affordanceAt` being built: registered layers\n    // produce affordances of their own, and a consumer with no selection\n    // chrome (a canvas that is nothing but a HUD, say) still needs those.\n    return (worldPoint: { x: number; y: number }) => {\n      // Registered layers first: they draw on top of the kit's own chrome, so\n      // they get first refusal on the point. A hit becomes an `AffordanceHit`\n      // whose kind names the layer, carrying whatever the layer's hit-test\n      // resolved — which is how `@weasel-js/hud` routes a press on one of its\n      // widgets to its own action instead of the active tool.\n      const extra = canvasApiRef.current?.hitTestExtras?.(worldPoint.x, worldPoint.y);\n      if (extra) return layerAffordance(extra.layerId, extra.hit);\n      return affordanceAt ? affordanceAt(worldPoint) : null;\n    };\n  }, [affordanceAt, canvasApiRef]);\n\n  // Stable callback that asks the canvas to redraw. Reads via ref so the\n  // identity stays stable while the underlying API binds after mount.\n  const requestRedraw = useCallback(() => {\n    canvasApiRef.current?.requestRedraw?.();\n  }, [canvasApiRef]);\n\n  // The painted tier's channel, read live for the same reason — the handle it\n  // lives on binds after mount.\n  const paintedCursor = useCallback(() => canvasApiRef.current?.paintedCursor, [canvasApiRef]);\n  const cursorSink = useCallback(() => canvasApiRef.current?.cursorSink, [canvasApiRef]);\n\n  // The pending long-press, published as the `longPress` dep for feedback.\n  const [longPressState] = useState(createLongPressStore);\n  const longPress = useMemo(() => ({\n    state: longPressState,\n    ...(longPressDuration !== undefined ? { duration: longPressDuration } : {}),\n    ...(longPressHaptics !== undefined ? { haptics: longPressHaptics } : {}),\n  }), [longPressState, longPressDuration, longPressHaptics]);\n\n  // Input routing to registered views. Rebuilt per event from the registry, so\n  // a view that mounts or moves mid-session is routable on the next event; with\n  // nothing registered every point resolves to the canvas, as before.\n  const views = useMemo(() => {\n    if (!viewRegistry) return undefined;\n    return {\n      targets: () => viewRegistry.list().map((r) => ({ id: r.id, ...r.target })),\n      resolver: viewRegistry.resolver,\n    };\n  }, [viewRegistry]);\n\n  // Hover cursors live in `useGestureDispatcher`'s hover-cursor pump:\n  // affordance hits carry `AffordanceHit.cursor` (set by `buildAffordanceAt`),\n  // and everything else is predicted via `Dispatcher.resolveOnly` +\n  // `Action.cursor`. Nothing SceneCanvas-specific remains here.\n  useGestureDispatcher({\n    canvasRef,\n    actions: registry!,\n    entriesById,\n    enabled,\n    keyboard,\n    claimKeys,\n    affordanceAt: affordanceWithLayers,\n    classifyTarget,\n    dispatcher,\n    clientToWorld,\n    requestRedraw,\n    paintedCursor,\n    cursorSink,\n    getRuleCtx,\n    onClick,\n    onDoubleClick,\n    longPress,\n    ...(views ? { views } : {}),\n  });\n  useDepSource('longPress', () => longPressState);\n  return null;\n}\n"],"mappings":";;;;;;;;;;AAkBA,SAAgBA,EAAyB,EACvC,cACA,iBACA,UACA,kBACA,aACA,aACA,cACA,iBACA,aACA,gBACA,cACA,aACA,eACA,YACA,eACA,0BACA,gBACA,gBACA,oBACA,kBACA,yBACA,kBACA,YACA,WAAW,EAAE,UAAUC,GAAmB,SAASC,MAAqB,CAAC,KA+DxE;CACD,IAAMC,IAAWC,GAAmB,GAC9BC,IAAcC,EAAe,GAC7BC,IAAeC,EAAwB,GACvCC,IAAcC,QAAiD;EACnE,IAAMC,oBAAI,IAAI,IAA0B;EACxC,KAAK,IAAM,CAACC,GAAIC,MAAS,OAAO,QAAQC,EAAM,QAAQ,GACpD,EAAE,IAAIF,GAAIC,CAAI;EAEhB,KAAK,IAAME,KAASC,GAAe,EAAE,IAAID,EAAM,IAAIA,CAAK;EAGxD,KAAK,IAAMA,KAASD,EAAM,SAAS,EAAE,IAAIC,EAAM,IAAIA,CAAK;EACxD,OAAOJ;CACT,GAAG;EAACG,EAAM;EAAUA,EAAM;EAASE;CAAa,CAAC,GAK3CC,IAAeC,EAAUC,CAAS,GAClCC,IAAcF,EAAUG,CAAQ,GAChCC,IAAgBJ,EAAUK,CAAU,GAIpCC,IAAiBN,EAAUb,CAAW,GACtCoB,IAAiBP,EAAUQ,CAAW,GACtCC,IAAiBjB,QAAckB,QAC7BJ,EAAe,UACpB,GAAI,MAASK,EAAcC,GAAML,EAAe,UAAUb,CAAE,KAAK,IAAI,CACxE,GAAG,CAACY,GAAgBC,CAAc,CAAC,GAI7BM,IAAcrB,QAAcsB,EAAkB;EAClD,GAAIC,MAAgB,KAAA,IAA8B,CAAC,IAAnB,EAAE,eAAY;EAC9C,GAAIC,MAAoB,KAAA,IAAkC,CAAC,IAAvB,EAAE,mBAAgB;EACtD;EACA;CACF,CAAC,GAAG;EAACD;EAAaC;EAAiBC;EAAeR;CAAc,CAAC;CACjE,SAAyB;EACvB,AAAIS,MAAsB,EAAqB,UAAUL;CAC3D,CAAC;CACD,IAAMM,IAAe3B,QAAc;EACjC,IAAK4B,KAAiBC,KAAaC,GACnC,OAAOC,EAAkB;GAGvB,sBAAsBlC,GAAc,QAAQ,CAAC,EAAE,YAAY,KAAKmC;GAEhE,eAAeF,EAAQ,WAAW;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;KAAE,GAAG;KAAG,GAAG;IAAE;GAAE;GACtE;GAMA,GAAIG,IAAwB,EAAE,oBAAoBA,EAAsB,EAAE,IAAI,CAAC;EACjF,CAAC;CACH,GAAG;EAACL;EAAcC;EAAUC;EAAST;EAAaY;EAAuBpC;CAAY,CAAC,GAIhFqC,KAAiBlC,QAAc;EACnC,IAAK4B,KAAiBnB,KAAcqB,GACpC,OAAOK,QACCP,EAAa,SAAS,WAAW,CAAC,IAIvC,GAAY,MAAe;GAC1B,IAAIlB,EAAY,SAAS,OAAOA,EAAY,QAAQ0B,GAAIC,CAAE;GAC1D,IAAMC,IAAM/B,EAAa,UAAU6B,GAAIC,CAAE,KAAK,CAAC;GAC/C,OAAOC,EAAI,SAAS,IAAIA,EAAIA,EAAI,SAAS,KAAK;EAChD,IAMC,MAAe1B,EAAc,UAAUV,CAAE,CAC5C;CACF,GAAG;EAAC0B;EAAcnB;EAAWqB;EAASpB;EAAaH;EAAcK;CAAa,CAAC,GAGzE2B,KAAgBC,GAAa,GAAiB,MAA8C;EAChG,IAAMC,IAAMC,EAAa,SACnB,CAACC,GAAGC,KAAKH,IAAMA,EAAI,cAAcI,GAASC,CAAO,IAAI,CAACD,GAASC,CAAO,GACtEC,IAAQ;GAAE;GAAG;EAAE;EAErB,OADAC,EAAgBH,GAASC,GAASL,IAAMQ,EAAU,UAAU,MAAMnB,GAAS,SAASiB,CAAK,GAClFA;CACT,GAAG;EAACE;EAAWP;EAAcZ;CAAO,CAAC,GAE/BoB,KAAuBlD,SAInB,MAAyC;EAM/C,IAAMmD,IAAQT,EAAa,SAAS,gBAAgBU,EAAW,GAAGA,EAAW,CAAC;EAE9E,OADID,IAAcE,EAAgBF,EAAM,SAASA,EAAM,GAAG,IACnDxB,IAAeA,EAAayB,CAAU,IAAI;CACnD,GACC,CAACzB,GAAce,CAAY,CAAC,GAIzBY,KAAgBd,QAAkB;EACtC,EAAa,SAAS,gBAAgB;CACxC,GAAG,CAACE,CAAY,CAAC,GAIXa,KAAgBf,QAAkBE,EAAa,SAAS,eAAe,CAACA,CAAY,CAAC,GACrFc,KAAahB,QAAkBE,EAAa,SAAS,YAAY,CAACA,CAAY,CAAC,GAG/E,CAACe,KAAkBC,EAASC,CAAoB,GAChDC,KAAY5D,SAAe;EAC/B,OAAOyD;EACP,GAAIlE,MAAsB,KAAA,IAA8C,CAAC,IAAnC,EAAE,UAAUA,EAAkB;EACpE,GAAIC,MAAqB,KAAA,IAA4C,CAAC,IAAjC,EAAE,SAASA,EAAiB;CACnE,IAAI;EAACiE;EAAgBlE;EAAmBC;CAAgB,CAAC,GAKnDqE,IAAQ7D,QAAc;EAC1B,IAAKH,GACL,OAAO;GACL,eAAeA,EAAa,KAAK,CAAC,CAAC,KAAK,OAAO;IAAE,IAAIiE,EAAE;IAAI,GAAGA,EAAE;GAAO,EAAE;GACzE,UAAUjE,EAAa;EACzB;CACF,GAAG,CAACA,CAAY,CAAC;CA2BjB,OArBAkE,EAAqB;EACnB;EACA,SAAStE;EACT;EACA;EACA;EACA;EACA,cAAcyD;EACd;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,GAAIW,IAAQ,EAAE,SAAM,IAAI,CAAC;CAC3B,CAAC,GACDG,EAAa,mBAAmBP,CAAc,GACvC;AACT"}

package/dist/canvas/SceneCanvas/PointerProviderIfRoot.js

@@ -1,48 +1,44 @@
-import { clientToWorld as e } from "../../core/viewport/clientToWorld.js";
-import { PointerContextProvider as t, usePointerContext as n } from "../../features/pointer/PointerContext.js";
-import { useOptionalViewRegistry as r } from "../viewRegistry.js";
-import { useEffect as i } from "react";
+import { useOptionalViewRegistry as e } from "../viewRegistry.js";
+import { worldPointAt as t } from "./worldPointAt.js";
+import { useEffect as n } from "react";
+import { PointerContextProvider as r, usePointerContext as i } from "@weasel-js/routing/react";
 import { Fragment as a, jsx as o } from "react/jsx-runtime";
 //#region src/canvas/SceneCanvas/PointerProviderIfRoot.tsx
 function s({ children: e }) {
-	return n() ? /* @__PURE__ */ o(a, { children: e }) : /* @__PURE__ */ o(t, { children: e });
+	return i() ? /* @__PURE__ */ o(a, { children: e }) : /* @__PURE__ */ o(r, { children: e });
 }
-function c({ canvasRef: t }) {
-	let a = n(), o = r();
-	return i(() => {
-		if (!a) return;
-		let n = t.current;
-		if (!n) return;
-		let r = (t, r, i) => {
-			let s = o?.resolver.at(t, r, i), c = n.getBoundingClientRect(), [l, u] = e(r, i, s?.origin ?? c, s?.view ?? {
-				x: 0,
-				y: 0,
-				scale: {
-					x: 1,
-					y: 1
-				}
-			});
-			a.set({
+function c({ canvasRef: r, canvasApiRef: a }) {
+	let o = i(), s = e();
+	return n(() => {
+		if (!o) return;
+		let e = r.current;
+		if (!e) return;
+		let n = (e, n, r) => {
+			let i = a.current;
+			if (!i) return;
+			let c = s?.resolver.at(e, n, r), [l, u] = t(i, c, n, r);
+			o.set({
 				worldX: l,
 				worldY: u,
-				viewId: s?.id ?? null
+				viewId: c?.id ?? null
 			});
-		}, i = (e) => r(e.pointerId, e.clientX, e.clientY), s = (e) => {
+		}, i = (e) => n(e.pointerId, e.clientX, e.clientY), c = (e) => {
 			if (e.buttons !== 0) {
-				r(e.pointerId, e.clientX, e.clientY);
+				n(e.pointerId, e.clientX, e.clientY);
 				return;
 			}
-			a.set(null);
-		}, c = (e) => {
-			e.target !== n && e.buttons !== 0 && r(e.pointerId, e.clientX, e.clientY);
+			o.set(null);
+		}, l = (t) => {
+			t.target !== e && t.buttons !== 0 && n(t.pointerId, t.clientX, t.clientY);
 		};
-		return n.addEventListener("pointermove", i), n.addEventListener("pointerleave", s), document.addEventListener("pointermove", c), () => {
-			n.removeEventListener("pointermove", i), n.removeEventListener("pointerleave", s), document.removeEventListener("pointermove", c);
+		return e.addEventListener("pointermove", i), e.addEventListener("pointerleave", c), document.addEventListener("pointermove", l), () => {
+			e.removeEventListener("pointermove", i), e.removeEventListener("pointerleave", c), document.removeEventListener("pointermove", l);
 		};
 	}, [
+		o,
+		r,
 		a,
-		t,
-		o
+		s
 	]), null;
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"PointerProviderIfRoot.js","names":["_Fragment","PointerProviderIfRoot","usePointerContext","Fragment","PointerContextProvider","PointerPublisher","ctx","registry","useOptionalViewRegistry","useEffect","el","canvasRef","publish","target","pointerId","clientX","clientY","rect","worldX","worldY","clientToWorld","onMove","onLeave","onDocMove"],"sources":["../../../src/canvas/SceneCanvas/PointerProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<PointerContextProvider>` wrapper. Mounts a provider only\n * when no parent provider is in scope — otherwise renders children unwrapped\n * so SceneCanvas defers to the host's existing scope.\n *\n * Pairs with `<PointerPublisher>` which attaches native pointermove/leave\n * listeners to the canvas element and writes world-space coords into the\n * surrounding context's `pointerRef`.\n */\nimport { useEffect, type MutableRefObject, type ReactNode } from 'react';\nimport { PointerContextProvider, usePointerContext } from 'features/pointer/PointerContext';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\nimport { useOptionalViewRegistry } from '../viewRegistry';\n\n/** Mount a `<PointerContextProvider>` only when none is already in scope. */\nexport function PointerProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = usePointerContext();\n  if (parent) return <>{children}</>;\n  return <PointerContextProvider>{children}</PointerContextProvider>;\n}\n\n/**\n * Attaches native `pointermove` / `pointerleave` listeners to the supplied\n * canvas element and publishes the world-space pointer coordinates into the\n * surrounding `<PointerContextProvider>`. Renders nothing. No-op when no\n * provider is in scope (matches \"publish if anyone is listening\").\n *\n * Lives inside the provider scope so it sees both consumer-mounted providers\n * and SceneCanvas's auto-mounted one.\n */\nexport function PointerPublisher({\n  canvasRef,\n}: {\n  canvasRef: MutableRefObject<HTMLElement | null>;\n}) {\n  const ctx = usePointerContext();\n  const registry = useOptionalViewRegistry();\n  useEffect(() => {\n    if (!ctx) return;\n    const el = canvasRef.current;\n    if (!el) return;\n    // The surface's one resolver answers which camera a client point belongs\n    // to, so paste-at-pointer lands in the panel the cursor is over. With no\n    // views declared it answers the canvas's own camera and rect.\n    const publish = (pointerId: number | null, clientX: number, clientY: number): void => {\n      const target = registry?.resolver.at(pointerId, clientX, clientY);\n      const rect = el.getBoundingClientRect();\n      const [worldX, worldY] = clientToWorld(\n        clientX, clientY,\n        target?.origin ?? rect,\n        target?.view ?? { x: 0, y: 0, scale: { x: 1, y: 1 } },\n      );\n      ctx.set({ worldX, worldY, viewId: target?.id ?? null });\n    };\n    const onMove = (e: PointerEvent): void => publish(e.pointerId, e.clientX, e.clientY);\n    const onLeave = (e: PointerEvent): void => {\n      // Don't clear coords mid-drag: any pointer button down means the user\n      // is still actively manipulating the canvas, and downstream consumers\n      // (resize/move/etc.) need the latest world position even when the\n      // cursor leaves the canvas rect. The `useGestureDispatcher`-side\n      // `setPointerCapture` keeps pointermove flowing in that case, so we\n      // get fresh values; this guard just prevents the leave event from\n      // racing in and nulling them between captured moves.\n      if (e.buttons !== 0) {\n        publish(e.pointerId, e.clientX, e.clientY);\n        return;\n      }\n      ctx.set(null);\n    };\n    // Document-level pointermove backstop so the HUD keeps updating when the\n    // pointer drifts off the canvas during a drag (pointer capture routes\n    // events back to the canvas, but the leave-window edge case is covered\n    // here too). Filter to events whose target isn't the canvas to avoid\n    // double-publishing.\n    const onDocMove = (e: PointerEvent): void => {\n      if (e.target === el) return;\n      // Only forward off-canvas moves during an active drag — idle hover\n      // outside the canvas shouldn't be reported as a canvas pointer position.\n      if (e.buttons === 0) return;\n      publish(e.pointerId, e.clientX, e.clientY);\n    };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    document.addEventListener('pointermove', onDocMove);\n    return () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n      document.removeEventListener('pointermove', onDocMove);\n    };\n    // canvasRef + registry + ctx identity are all stable across the lifetime\n    // of the surrounding provider; effect runs once per mount.\n  }, [ctx, canvasRef, registry]);\n  return null;\n}\n"],"mappings":";;;;;;AAeA,SAAgBC,EAAsB,EAAE,eAAqC;CAG3E,OAFeC,EACX,IAAe,kBAAAF,GAAA,EAAG,YAAW,CAAA,IAC1B,kBAACI,GAAD,EAAyB,YAAiC,CAAA;AACnE;AAWA,SAAgBC,EAAiB,EAC/B,gBAGC;CACD,IAAMC,IAAMJ,EAAkB,GACxBK,IAAWC,EAAwB;CAwDzC,OAvDAC,QAAgB;EACd,IAAI,CAACH,GAAK;EACV,IAAMI,IAAKC,EAAU;EACrB,IAAI,CAACD,GAAI;EAIT,IAAME,KAAW,GAA0B,GAAiB,MAA0B;GACpF,IAAMC,IAASN,GAAU,SAAS,GAAGO,GAAWC,GAASC,CAAO,GAC1DC,IAAOP,EAAG,sBAAsB,GAChC,CAACQ,GAAQC,KAAUC,EACvBL,GAASC,GACTH,GAAQ,UAAUI,GAClBJ,GAAQ,QAAQ;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;KAAE,GAAG;KAAG,GAAG;IAAE;GAAE,CACtD;GACA,EAAI,IAAI;IAAE;IAAQ;IAAQ,QAAQA,GAAQ,MAAM;GAAK,CAAC;EACxD,GACMQ,KAAU,MAA0BT,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,GAC7EU,KAAW,MAA0B;GAQzC,IAAI,EAAE,YAAY,GAAG;IACnB,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;IACzC;GACF;GACA,EAAI,IAAI,IAAI;EACd,GAMMC,KAAa,MAA0B;GAC3C,AAAI,EAAE,WAAWb,KAGb,EAAE,YAAY,KAClBE,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;EAC3C;EAIA,OAHAF,EAAG,iBAAiB,eAAeW,CAAM,GACzCX,EAAG,iBAAiB,gBAAgBY,CAAO,GAC3C,SAAS,iBAAiB,eAAeC,CAAS,SACrC;GAGX,AAFAb,EAAG,oBAAoB,eAAeW,CAAM,GAC5CX,EAAG,oBAAoB,gBAAgBY,CAAO,GAC9C,SAAS,oBAAoB,eAAeC,CAAS;EACvD;CAGF,GAAG;EAACjB;EAAKK;EAAWJ;CAAQ,CAAC,GACtB;AACT"}
+{"version":3,"file":"PointerProviderIfRoot.js","names":["_Fragment","PointerProviderIfRoot","usePointerContext","Fragment","PointerContextProvider","PointerPublisher","ctx","registry","useOptionalViewRegistry","useEffect","el","canvasRef","publish","api","canvasApiRef","target","pointerId","clientX","clientY","worldX","worldY","worldPointAt","onMove","onLeave","onDocMove","e"],"sources":["../../../src/canvas/SceneCanvas/PointerProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<PointerContextProvider>` wrapper. Mounts a provider only\n * when no parent provider is in scope — otherwise renders children unwrapped\n * so SceneCanvas defers to the host's existing scope.\n *\n * Pairs with `<PointerPublisher>` which attaches native pointermove/leave\n * listeners to the canvas element and writes world-space coords into the\n * surrounding context's `pointerRef`.\n */\nimport { useEffect, type MutableRefObject, type ReactNode, type RefObject } from 'react';\nimport { PointerContextProvider, usePointerContext } from '@weasel-js/routing/react';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { worldPointAt } from './worldPointAt';\n\n/** Mount a `<PointerContextProvider>` only when none is already in scope. */\nexport function PointerProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = usePointerContext();\n  if (parent) return <>{children}</>;\n  return <PointerContextProvider>{children}</PointerContextProvider>;\n}\n\n/**\n * Attaches native `pointermove` / `pointerleave` listeners to the supplied\n * canvas element and publishes the world-space pointer coordinates into the\n * surrounding `<PointerContextProvider>`. Renders nothing. No-op when no\n * provider is in scope (matches \"publish if anyone is listening\").\n *\n * Lives inside the provider scope so it sees both consumer-mounted providers\n * and SceneCanvas's auto-mounted one.\n */\nexport function PointerPublisher({\n  canvasRef,\n  canvasApiRef,\n}: {\n  canvasRef: MutableRefObject<HTMLElement | null>;\n  canvasApiRef: RefObject<CanvasExtensionApi | null>;\n}) {\n  const ctx = usePointerContext();\n  const registry = useOptionalViewRegistry();\n  useEffect(() => {\n    if (!ctx) return;\n    const el = canvasRef.current;\n    if (!el) return;\n    // The surface's one resolver answers which camera a client point belongs\n    // to, so paste-at-pointer lands in the panel the cursor is over. With no\n    // views declared it answers the canvas's own camera and rect.\n    const publish = (pointerId: number | null, clientX: number, clientY: number): void => {\n      const api = canvasApiRef.current;\n      if (!api) return;\n      const target = registry?.resolver.at(pointerId, clientX, clientY);\n      const [worldX, worldY] = worldPointAt(api, target, clientX, clientY);\n      ctx.set({ worldX, worldY, viewId: target?.id ?? null });\n    };\n    const onMove = (e: PointerEvent): void => publish(e.pointerId, e.clientX, e.clientY);\n    const onLeave = (e: PointerEvent): void => {\n      // Don't clear coords mid-drag: any pointer button down means the user\n      // is still actively manipulating the canvas, and downstream consumers\n      // (resize/move/etc.) need the latest world position even when the\n      // cursor leaves the canvas rect. The `useGestureDispatcher`-side\n      // `setPointerCapture` keeps pointermove flowing in that case, so we\n      // get fresh values; this guard just prevents the leave event from\n      // racing in and nulling them between captured moves.\n      if (e.buttons !== 0) {\n        publish(e.pointerId, e.clientX, e.clientY);\n        return;\n      }\n      ctx.set(null);\n    };\n    // Document-level pointermove backstop so the HUD keeps updating when the\n    // pointer drifts off the canvas during a drag (pointer capture routes\n    // events back to the canvas, but the leave-window edge case is covered\n    // here too). Filter to events whose target isn't the canvas to avoid\n    // double-publishing.\n    const onDocMove = (e: PointerEvent): void => {\n      if (e.target === el) return;\n      // Only forward off-canvas moves during an active drag — idle hover\n      // outside the canvas shouldn't be reported as a canvas pointer position.\n      if (e.buttons === 0) return;\n      publish(e.pointerId, e.clientX, e.clientY);\n    };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    document.addEventListener('pointermove', onDocMove);\n    return () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n      document.removeEventListener('pointermove', onDocMove);\n    };\n    // canvasRef + registry + ctx identity are all stable across the lifetime\n    // of the surrounding provider; effect runs once per mount.\n  }, [ctx, canvasRef, canvasApiRef, registry]);\n  return null;\n}\n"],"mappings":";;;;;;AAgBA,SAAgBC,EAAsB,EAAE,eAAqC;CAG3E,OAFeC,EACX,IAAe,kBAAAF,GAAA,EAAG,YAAW,CAAA,IAC1B,kBAACI,GAAD,EAAyB,YAAiC,CAAA;AACnE;AAWA,SAAgBC,EAAiB,EAC/B,cACA,mBAIC;CACD,IAAMC,IAAMJ,EAAkB,GACxBK,IAAWC,EAAwB;CAqDzC,OApDAC,QAAgB;EACd,IAAI,CAACH,GAAK;EACV,IAAMI,IAAKC,EAAU;EACrB,IAAI,CAACD,GAAI;EAIT,IAAME,KAAW,GAA0B,GAAiB,MAA0B;GACpF,IAAMC,IAAMC,EAAa;GACzB,IAAI,CAACD,GAAK;GACV,IAAME,IAASR,GAAU,SAAS,GAAGS,GAAWC,GAASC,CAAO,GAC1D,CAACC,GAAQC,KAAUC,EAAaR,GAAKE,GAAQE,GAASC,CAAO;GACnE,EAAI,IAAI;IAAE;IAAQ;IAAQ,QAAQH,GAAQ,MAAM;GAAK,CAAC;EACxD,GACMO,KAAU,MAA0BV,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,GAC7EW,KAAW,MAA0B;GAQzC,IAAI,EAAE,YAAY,GAAG;IACnB,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;IACzC;GACF;GACA,EAAI,IAAI,IAAI;EACd,GAMMC,KAAa,MAA0B;GAC3C,AAAIC,EAAE,WAAWf,KAGbe,EAAE,YAAY,KAClBb,EAAQa,EAAE,WAAWA,EAAE,SAASA,EAAE,OAAO;EAC3C;EAIA,OAHAf,EAAG,iBAAiB,eAAeY,CAAM,GACzCZ,EAAG,iBAAiB,gBAAgBa,CAAO,GAC3C,SAAS,iBAAiB,eAAeC,CAAS,SACrC;GAGX,AAFAd,EAAG,oBAAoB,eAAeY,CAAM,GAC5CZ,EAAG,oBAAoB,gBAAgBa,CAAO,GAC9C,SAAS,oBAAoB,eAAeC,CAAS;EACvD;CAGF,GAAG;EAAClB;EAAKK;EAAWG;EAAcP;CAAQ,CAAC,GACpC;AACT"}

package/dist/canvas/SceneCanvas/StandardActionsRegistrar.js

@@ -0,0 +1,64 @@
+import { useDecayLoop as e } from "../../core/viewport/useDecayLoop.js";
+import { useStandardActions as t } from "../../interactions/actions/useStandardActions.js";
+import { usePoseDescriptorDepSource as n } from "../deps/poseDescriptor.js";
+import { useSliceDepSource as r } from "../deps/slice.js";
+import { useLayoutArrivals as i } from "../../layout/arrivals.js";
+import { useViewDepSource as a } from "../deps/view.js";
+import { useAreaSelectDepSource as o } from "../deps/areaSelect.js";
+import { useNodeAtPointDepSource as s } from "../deps/nodeAtPoint.js";
+import { useLassoSelectDepSource as c } from "../deps/lassoSelect.js";
+import { useTextEditDepSource as l } from "../deps/textEdit.js";
+import { useEditAnchorsDepSource as u } from "../deps/editAnchors.js";
+import { useInsertDepSource as d } from "../deps/insert.js";
+import { useSnapDepSource as f } from "../deps/snap.js";
+import { useDebugDepSource as p } from "../deps/debug.js";
+import { useDepChangeNotices as m } from "../deps/changes.js";
+import { useDispatcherDepSource as h } from "../deps/dispatcher.js";
+import { useLayoutDepSource as g } from "../deps/layout.js";
+import { useIngestionDepSource as ee } from "../deps/ingestion.js";
+import { GeometryProjectionRegistrar as te, ResizePolicyRegistrar as ne } from "./poseRegistrars.js";
+import { useActionsPropResolver as re } from "./useActionsPropResolver.js";
+import { useViewportActions as ie } from "./useViewportActions.js";
+import { useEffect as _ } from "react";
+import { useActionsRegistry as v, useDepSource as y, usePointerContext as b } from "@weasel-js/routing/react";
+import { Fragment as x, jsx as S, jsxs as C } from "react/jsx-runtime";
+//#region src/canvas/SceneCanvas/StandardActionsRegistrar.tsx
+function w({ selection: w, scene: T, adapter: E, actions: D, excludeActions: O, currentViewRef: k, onViewChange: A, resizeOptions: j, poseDescriptor: M, geometryProjection: N, dispatcher: P, getActionRef: F, pickEvery: I, layerIsPainted: ae, alphaOf: L, viewportPanEnabled: R, viewportZoom: z, viewportPinchZoom: B, viewportRecenter: V, viewAnimation: H, editAnchorsExternalState: U, layouts: W, layoutDropTarget: G, reflowTransition: K, insertNodeFactories: q, insertPaint: J, snapPoint: oe, canvasRef: Y, canvasApiRef: se, ingestionResolveSrc: ce, ingestionSvg: le, ingestionClipboard: ue, actionsRegistryRef: X }) {
+	let Z = v();
+	_(() => (X.current = Z, () => {
+		X.current = null;
+	}), [Z, X]), _(() => {
+		if (Z) return Z.setDispatcher(P);
+	}, [Z, P]), _(() => {
+		if (Z) return F.current = (e) => Z.list().find((t) => t.id === e), () => {
+			F.current = null;
+		};
+	}, [Z, F]);
+	let Q = e(), $ = a(k, A, V, () => {
+		let e = Y.current;
+		return e ? {
+			width: e.clientWidth,
+			height: e.clientHeight
+		} : null;
+	}, H, Q, ae);
+	t({
+		selection: w,
+		scene: T,
+		view: $,
+		history: T.history,
+		exclude: O
+	}), y("rootView", () => $);
+	let de = b();
+	return y("pointer", () => de ?? void 0), ie({
+		pan: R,
+		zoom: z,
+		pinchZoom: B
+	}), o(T, w, M, L), s(I), g(T, W, G, K), i(T, {
+		layouts: W,
+		poseDescriptor: M
+	}), d(T, E, q, J), r(T, w, E, M), f(oe), p(se), m(T, w.current), ee(Y, () => k.current, ce, le, ue), c(T, w, M, L), l(T), u(T, w, E, U), h(P), n(M), re(D, O.join("|")), /* @__PURE__ */ C(x, { children: [j ? /* @__PURE__ */ S(ne, { options: j }) : null, N ? /* @__PURE__ */ S(te, { projection: N }) : null] });
+}
+//#endregion
+export { w as StandardActionsRegistrar };
+
+//# sourceMappingURL=StandardActionsRegistrar.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StandardActionsRegistrar.js","names":["_Fragment","StandardActionsRegistrar","registry","useActionsRegistry","useEffect","actionsRegistryRef","dispatcher","a","id","getActionRef","decayLoop","useDecayLoop","view","useViewDepSource","currentViewRef","onViewChange","viewportRecenter","el","canvasRef","viewAnimation","layerIsPainted","useStandardActions","scene","excludeActions","useDepSource","pointer","usePointerContext","useViewportActions","viewportPanEnabled","viewportZoom","viewportPinchZoom","useAreaSelectDepSource","selection","poseDescriptor","alphaOf","useNodeAtPointDepSource","pickEvery","useLayoutDepSource","layouts","layoutDropTarget","reflowTransition","useLayoutArrivals","useInsertDepSource","adapter","insertNodeFactories","insertPaint","useSliceDepSource","useSnapDepSource","snapPoint","useDebugDepSource","canvasApiRef","useDepChangeNotices","useIngestionDepSource","ingestionResolveSrc","ingestionSvg","ingestionClipboard","useLassoSelectDepSource","useTextEditDepSource","useEditAnchorsDepSource","editAnchorsExternalState","useDispatcherDepSource","usePoseDescriptorDepSource","useActionsPropResolver","actions","Fragment","resizeOptions","ResizePolicyRegistrar","geometryProjection","GeometryProjectionRegistrar"],"sources":["../../../src/canvas/SceneCanvas/StandardActionsRegistrar.tsx"],"sourcesContent":["import type { Action, ActionsProp, ActionsRegistry } from '@weasel-js/routing';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { useActionsRegistry, useDepSource, usePointerContext } from '@weasel-js/routing/react';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { useDecayLoop } from 'core/viewport/useDecayLoop';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { View } from 'core/viewport/view';\nimport type { PinchZoomOptions } from 'interactions/actions/defaults/pinchZoom';\nimport type { WheelPanOptions } from 'interactions/actions/defaults/viewportWheelPan';\nimport type { ViewportZoomOptions } from 'interactions/actions/defaults/viewportZoom';\nimport type { ClipboardIngestCtx, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport { useStandardActions } from 'interactions/actions/useStandardActions';\nimport type React from 'react';\nimport { useEffect } from 'react';\nimport { useLayoutArrivals } from '../../layout/arrivals';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport {\n  useAreaSelectDepSource,\n  useDebugDepSource,\n  useDepChangeNotices,\n  useDispatcherDepSource,\n  useEditAnchorsDepSource,\n  useIngestionDepSource,\n  useInsertDepSource,\n  useLassoSelectDepSource,\n  useLayoutDepSource,\n  useNodeAtPointDepSource,\n  usePoseDescriptorDepSource,\n  useSliceDepSource,\n  useSnapDepSource,\n  useTextEditDepSource,\n  useViewDepSource,\n  type InsertNodeFactory,\n  type InsertPaint\n} from '../deps';\nimport { GeometryProjectionRegistrar, ResizePolicyRegistrar } from './poseRegistrars';\nimport type { BridgeAdapter, SceneCanvasProps } from './props';\nimport { useActionsPropResolver } from './useActionsPropResolver';\nimport { useViewportActions } from './useViewportActions';\n\n/**\n * Registers the kit's default action set into this canvas's input scope.\n *\n * For `delete`, `duplicate`, `group`, and `ungroup` the descriptor's\n * invoker is a stub (those deps aren't in `DepSchema` yet — Phase 4 T8\n * TODO). This component registers legacy bridge overrides for them so the\n * consumer-facing `run` path is functional. The overrides land after the\n * descriptor registrations (last-writer-wins) and use the same id, so the\n * dispatcher and keybinding system see a real `run` body.\n */\nexport function StandardActionsRegistrar({\n  selection,\n  scene,\n  adapter,\n  actions,\n  excludeActions,\n  currentViewRef,\n  onViewChange,\n  resizeOptions,\n  poseDescriptor,\n  geometryProjection,\n  dispatcher,\n  getActionRef,\n  pickEvery,\n  layerIsPainted,\n  alphaOf,\n  viewportPanEnabled,\n  viewportZoom,\n  viewportPinchZoom,\n  viewportRecenter,\n  viewAnimation,\n  editAnchorsExternalState,\n  layouts,\n  layoutDropTarget,\n  reflowTransition,\n  insertNodeFactories,\n  insertPaint,\n  snapPoint,\n  canvasRef,\n  canvasApiRef,\n  ingestionResolveSrc,\n  ingestionSvg,\n  ingestionClipboard,\n  actionsRegistryRef,\n}: {\n  selection: SelectionApi;\n  scene: Scene<unknown, string, unknown>;\n  adapter: BridgeAdapter;\n  actions?: ActionsProp;\n  /** Kit-standard action ids this canvas's presets and tools leave out. */\n  excludeActions: readonly string[];\n  currentViewRef: React.RefObject<View>;\n  onViewChange: (v: View) => void;\n  /** Forwarded from `selectTool.resize` — wires the `resizePolicy` dep\n   *  consumed by the dispatcher-path `resizeAction`. The legacy\n   *  `useResizeTool` consumes the same options separately (both paths run\n   *  in parallel during the dispatcher migration). */\n  resizeOptions?: UseResizeOptions<unknown>;\n  /** Forwarded from `SceneCanvasProps.poseDescriptor` — wires the\n   *  `poseDescriptor` dep every built-in pose-touching action reads. */\n  poseDescriptor: PoseDescriptor<unknown>;\n  /** Forwarded from `SceneCanvasProps.geometryProjection` — wires the\n   *  `geometryProjection` dep consumed by pose-transform actions (move,\n   *  resize, nudge, flip). Conditionally mounted so absent → dep undefined. */\n  geometryProjection?: GeometryProjection;\n  /** Forwarded so `cancelGestureAction` and other actions that need to\n   *  abort in-flight handles can read the dispatcher's control surface. */\n  dispatcher: Dispatcher;\n  /** Ref populated with a live action-lookup function so the dispatcher's\n   *  `getAction` closure can resolve action ids after the registry is\n   *  mounted. Set on first render; cleared on unmount. */\n  getActionRef: React.MutableRefObject<((id: string) => Action | undefined) | null>;\n  /** World-space picker forwarded so the `nodeAtPoint` dep source can\n   *  reuse the same hit-test plumbing the tool dispatcher uses. */\n  pickEvery: (worldX: number, worldY: number) => string[];\n  /** This canvas's own view gate for scene layers, published on the `view`\n   *  dep and read by the selecting actions. Absent when it hides nothing. */\n  layerIsPainted?: (layerId: string) => boolean;\n  /** The composed paint alpha, when the consumer fades anything, so a region\n   *  select passes over what is painted at zero. */\n  alphaOf?: (id: string) => number;\n  /** Resolved `viewport.pan` flag — default true, false to disable. */\n  viewportPanEnabled: boolean | WheelPanOptions;\n  /** Resolved `viewport.zoom` setting — `true` (default Cmd+wheel zoom),\n   *  `false` (disabled), or a {@link ViewportZoomOptions} config. */\n  viewportZoom: boolean | ViewportZoomOptions;\n  /** Resolved `viewport.pinchZoom` setting — `true` (default two-finger pinch),\n   *  `false` (disabled), or a {@link PinchZoomOptions} scale clamp. */\n  viewportPinchZoom: boolean | PinchZoomOptions;\n  /** Optional recenter callback. When supplied, wires through to the\n   *  `view` dep so `viewport.zoom` reset (Cmd-0) calls it instead of\n   *  snapping to identity. A returned `View` is a target the kit may\n   *  animate to; `void` means the callback dispatched it itself. */\n  viewportRecenter?: () => View | void;\n  /** The canvas's camera runner, published on the `view` dep so\n   *  `viewport.zoom`'s discrete branches can animate. */\n  viewAnimation: ViewAnimationApi;\n  /** Lifted edit-mode state so the `pathEditingOverlay` chrome (rendered\n   *  outside this subtree) can read the same `editingId` the dep does. */\n  editAnchorsExternalState: import('../deps/editAnchors').EditAnchorsStateRef;\n  /** Forwarded from `SceneCanvasProps` so the `layout` dep source can wire\n   *  the per-container layout strategy lookup consumed by `moveAction`. */\n  layouts?: SceneCanvasProps<unknown, string, unknown>['layouts'];\n  layoutDropTarget?: LayoutDropTargetMode;\n  reflowTransition?: ReflowTransition<unknown> | null;\n  /** Forwarded from `SceneCanvasProps` so `useInsertDepSource` can wire the\n   *  consumer's per-kind node factories into the `insert` dep. */\n  insertNodeFactories?: Record<string, InsertNodeFactory>;\n  insertPaint?: InsertPaint;\n  /** Forwarded from `SceneCanvasProps.toolOptions.snapPoint` so the `snap`\n   *  dep source can expose grid snapping to `insertAction`. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n  /** The canvas element ref, so `useIngestionDepSource` can compute the\n   *  visible world rect from the client rect + current view. */\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** The canvas handle, whose debug sink backs the `debug` dep. */\n  canvasApiRef: React.RefObject<CanvasExtensionApi | null>;\n  /** Forwarded from `SceneCanvasProps.ingestion.resolveSrc` — consumer\n   *  file→src override for the kit image handler. */\n  ingestionResolveSrc?: (file: File) => Promise<string>;\n  /** Forwarded from `SceneCanvasProps.ingestion.svg` — kit SVG-handler\n   *  options (`unpack`). */\n  ingestionSvg?: SvgIngestOptions;\n  /** Clipboard-paste ctx (this canvas's adapter + the consumer's reviver)\n   *  for the kit weasel-JSON handler, from `useCanvasIngestion`; absent\n   *  when disabled. */\n  ingestionClipboard?: ClipboardIngestCtx;\n  /** Populated with the live registry so `CanvasExtensionApi.ingest`\n   *  (assembled in SceneCanvasInner, OUTSIDE the actions provider) can call\n   *  `registry.trigger('ingest', …)`. Cleared on unmount. */\n  actionsRegistryRef: React.MutableRefObject<ActionsRegistry | null>;\n}) {\n  const registry = useActionsRegistry();\n\n  // Stash the registry for SceneCanvasInner's imperative `ingest` handle.\n  useEffect(() => {\n    actionsRegistryRef.current = registry;\n    return () => { actionsRegistryRef.current = null; };\n  }, [registry, actionsRegistryRef]);\n\n  // Wire the dispatcher into the registry so registry.begin() can delegate\n  // to dispatcher.beginUiOngoing() for UI-driven ongoing actions (color,\n  // opacity).\n  useEffect(() => {\n    if (!registry) return;\n    return registry.setDispatcher(dispatcher);\n  }, [registry, dispatcher]);\n\n  // Populate the action-lookup ref so the dispatcher's getAction closure\n  // can resolve action ids once the registry is in scope.\n  useEffect(() => {\n    if (!registry) return;\n    getActionRef.current = (id: string) => registry.list().find((a) => a.id === id);\n    return () => { getActionRef.current = null; };\n  }, [registry, getActionRef]);\n\n  // Momentum for `viewport.dragPan`. The loop must be a hook (it owns a\n  // `useVisibleRaf`), so it is built here and republished on the view dep.\n  const decayLoop = useDecayLoop();\n\n  // Build the ViewApi (stable identity, refreshed closures) and hand it to\n  // useStandardActions (which publishes the `view` dep along with selection,\n  // scene, history, pointer, activeTool). `hostSize` reads the live canvas\n  // element so keyboard zoom (Cmd+=/-) can anchor at the visible center.\n  const view = useViewDepSource(\n    currentViewRef,\n    onViewChange,\n    viewportRecenter,\n    () => {\n      const el = canvasRef.current;\n      return el ? { width: el.clientWidth, height: el.clientHeight } : null;\n    },\n    viewAnimation,\n    decayLoop,\n    layerIsPainted,\n  );\n  useStandardActions({ selection, scene, view, history: scene.history, exclude: excludeActions });\n  // A view overlays `view` with its own camera; this name it leaves alone.\n  useDepSource('rootView', () => view);\n  const pointer = usePointerContext();\n  useDepSource('pointer', () => pointer ?? undefined);\n\n  // viewport.pan / viewport.zoom are SceneCanvas-coupled (need the `view` dep\n  // published just above), so they're registered here rather than in\n  // KIT_STANDARD_DESCRIPTORS. Both default ON; consumer opts out via\n  // `viewport={{ pan: false }}` / `viewport={{ zoom: false }}`.\n  useViewportActions({ pan: viewportPanEnabled, zoom: viewportZoom, pinchZoom: viewportPinchZoom });\n\n  // Per-dep wiring modules under `src/canvas/deps/`. See each file for the\n  // dep's contract and trade-offs.\n  useAreaSelectDepSource(scene, selection, poseDescriptor, alphaOf);\n  useNodeAtPointDepSource(pickEvery);\n  useLayoutDepSource(scene, layouts, layoutDropTarget, reflowTransition);\n  useLayoutArrivals(scene, { layouts, poseDescriptor });\n  useInsertDepSource(scene, adapter, insertNodeFactories, insertPaint);\n  useSliceDepSource(scene, selection, adapter, poseDescriptor);\n  useSnapDepSource(snapPoint);\n  useDebugDepSource(canvasApiRef);\n  useDepChangeNotices(scene, selection.current);\n  useIngestionDepSource(canvasRef, () => currentViewRef.current, ingestionResolveSrc, ingestionSvg, ingestionClipboard);\n  useLassoSelectDepSource(scene, selection, poseDescriptor, alphaOf);\n  useTextEditDepSource(scene);\n  useEditAnchorsDepSource(scene, selection, adapter, editAnchorsExternalState);\n  useDispatcherDepSource(dispatcher);\n  usePoseDescriptorDepSource(poseDescriptor);\n\n  // Keyed on the exclusion too: a re-registration of the standard set would\n  // otherwise land over the overrides applied on top of it.\n  useActionsPropResolver(actions, excludeActions.join('|'));\n\n  // Gate the `resizePolicy` dep registration on the consumer having\n  // passed `selectTool.resize`. When absent, consumers wire it via a child\n  // component (see PointSnapDemo / GroupsDemo). Registering empty defaults\n  // here would race with child-component registrations — React runs child\n  // effects before parent effects, so the parent's empty default would\n  // overwrite the child's real value. The conditional mount avoids that.\n  //\n  // Same pattern for `geometryProjection`: only mount when the consumer\n  // passed the prop so absent → dep undefined → actions stay pose-only.\n  return (\n    <>\n      {resizeOptions ? <ResizePolicyRegistrar options={resizeOptions} /> : null}\n      {geometryProjection ? <GeometryProjectionRegistrar projection={geometryProjection} /> : null}\n    </>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgBC,EAAyB,EACvC,cACA,UACA,YACA,YACA,mBACA,mBACA,iBACA,kBACA,mBACA,uBACA,eACA,iBACA,cACA,oBACA,YACA,uBACA,iBACA,sBACA,qBACA,kBACA,6BACA,YACA,qBACA,qBACA,wBACA,gBACA,eACA,cACA,kBACA,yBACA,kBACA,wBACA,yBAwFC;CACD,IAAMC,IAAWC,EAAmB;CAkBpC,AAfAC,SACE,EAAmB,UAAUF,SAChB;EAAE,EAAmB,UAAU;CAAM,IACjD,CAACA,GAAUG,CAAkB,CAAC,GAKjCD,QAAgB;EACd,IAAKF,GACL,OAAOA,EAAS,cAAcI,CAAU;CAC1C,GAAG,CAACJ,GAAUI,CAAU,CAAC,GAIzBF,QAAgB;EACd,IAAKF,GAEL,OADA,EAAa,WAAW,MAAeA,EAAS,KAAK,CAAC,CAAC,MAAM,MAAMK,EAAE,OAAOC,CAAE,SACjE;GAAE,EAAa,UAAU;EAAM;CAC9C,GAAG,CAACN,GAAUO,CAAY,CAAC;CAI3B,IAAMC,IAAYC,EAAa,GAMzBC,IAAOC,EACXC,GACAC,GACAC,SACM;EACJ,IAAMC,IAAKC,EAAU;EACrB,OAAOD,IAAK;GAAE,OAAOA,EAAG;GAAa,QAAQA,EAAG;EAAa,IAAI;CACnE,GACAE,GACAT,GACAU,EACF;CAGA,AAFAC,EAAmB;EAAE;EAAW;EAAO;EAAM,SAASC,EAAM;EAAS,SAASC;CAAe,CAAC,GAE9FC,EAAa,kBAAkBZ,CAAI;CACnC,IAAMa,KAAUC,EAAkB;CAwClC,OAvCAF,EAAa,iBAAiBC,MAAW,KAAA,CAAS,GAMlDE,GAAmB;EAAE,KAAKC;EAAoB,MAAMC;EAAc,WAAWC;CAAkB,CAAC,GAIhGC,EAAuBT,GAAOU,GAAWC,GAAgBC,CAAO,GAChEC,EAAwBC,CAAS,GACjCC,EAAmBf,GAAOgB,GAASC,GAAkBC,CAAgB,GACrEC,EAAkBnB,GAAO;EAAE;EAAS;CAAe,CAAC,GACpDoB,EAAmBpB,GAAOqB,GAASC,GAAqBC,CAAW,GACnEC,EAAkBxB,GAAOU,GAAWW,GAASV,CAAc,GAC3Dc,EAAiBC,EAAS,GAC1BC,EAAkBC,EAAY,GAC9BC,EAAoB7B,GAAOU,EAAU,OAAO,GAC5CoB,GAAsBlC,SAAiBJ,EAAe,SAASuC,IAAqBC,IAAcC,EAAkB,GACpHC,EAAwBlC,GAAOU,GAAWC,GAAgBC,CAAO,GACjEuB,EAAqBnC,CAAK,GAC1BoC,EAAwBpC,GAAOU,GAAWW,GAASgB,CAAwB,GAC3EC,EAAuBtD,CAAU,GACjCuD,EAA2B5B,CAAc,GAIzC6B,GAAuBC,GAASxC,EAAe,KAAK,GAAG,CAAC,GAYtD,kBAAAvB,GAAA,EAAA,UAAA,CACGiE,IAAgB,kBAACC,IAAD,EAAuB,SAASD,EAAgB,CAAA,IAAI,MACpEE,IAAqB,kBAACC,IAAD,EAA6B,YAAYD,EAAqB,CAAA,IAAI,IACxF,EAAA,CAAA;AAEN"}