@weasel-js/core 1.10.0 → 1.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"DepRegistryProviderIfRoot.js","names":["_Fragment","DepRegistryProviderIfRoot","useOptionalDepRegistry","Fragment","DepRegistryProvider"],"sources":["../../../src/canvas/SceneCanvas/DepRegistryProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<DepRegistryProvider>` wrapper: mounts one only when no registry\n * is in scope, and otherwise renders its children against the one there. Used\n * by a non-isolated `<WeaselProvider>`. Mirrors `ActionsProviderIfRoot`.\n */\nimport type { ReactNode } from 'react';\nimport { DepRegistryProvider, useOptionalDepRegistry } from '@weasel-js/routing/react';\n\n/** Mount a `<DepRegistryProvider>` only when none is already in scope, so a\n *  consumer's dep sources are not shadowed by a nested canvas. */\nexport function DepRegistryProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = useOptionalDepRegistry();\n  if (parent) return <>{children}</>;\n  return <DepRegistryProvider>{children}</DepRegistryProvider>;\n}\n"],"mappings":";;;AAUA,SAAgBC,EAA0B,EAAE,eAAqC;CAG/E,OAFeC,EACX,IAAe,kBAAAF,GAAA,EAAG,YAAW,CAAA,IAC1B,kBAACI,GAAD,EAAsB,YAA8B,CAAA;AAC7D"}
+{"version":3,"file":"DepRegistryProviderIfRoot.js","names":["_Fragment"],"sources":["../../../src/canvas/SceneCanvas/DepRegistryProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<DepRegistryProvider>` wrapper: mounts one only when no registry\n * is in scope, and otherwise renders its children against the one there. Used\n * by a non-isolated `<WeaselProvider>`. Mirrors `ActionsProviderIfRoot`.\n */\nimport type { ReactNode } from 'react';\nimport { DepRegistryProvider, useOptionalDepRegistry } from '@weasel-js/routing/react';\n\n/** Mount a `<DepRegistryProvider>` only when none is already in scope, so a\n *  consumer's dep sources are not shadowed by a nested canvas. */\nexport function DepRegistryProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = useOptionalDepRegistry();\n  if (parent) return <>{children}</>;\n  return <DepRegistryProvider>{children}</DepRegistryProvider>;\n}\n"],"mappings":";;;;;;AAUA,SAAgB,0BAA0B,EAAE,YAAqC;CAE/E,IADe,uBACX,GAAQ,OAAO,oBAAAA,UAAA,EAAG,SAAW,CAAA;CACjC,OAAO,oBAAC,qBAAD,EAAsB,SAA8B,CAAA;AAC7D"}

package/dist/canvas/SceneCanvas/DevHuds.js

@@ -1,40 +1,55 @@
-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";
+import { CursorCoordsHud } from "../CursorCoordsHud.js";
+import { ModalityHud } from "../ModalityHud.js";
+import { PickHud } from "../PickHud.js";
+import { useCallback } from "react";
+import { useLatest } from "@weasel-js/react";
+import { Fragment, jsx, jsxs } 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
+/**
+* `<SceneCanvas>`'s dev HUDs: the cursor readout, the pick list, and the
+* modality panel, each a fixed-position widget pinned to the canvas.
+*/
+function DevHuds(props) {
+	const { cursorCoords, pick, modality, canvasRef, canvasApiRef, detachedInput, viewRef } = props;
+	const toWorld = useCallback((clientX, clientY) => canvasApiRef.current?.clientToWorld(clientX, clientY) ?? [clientX, clientY], [canvasApiRef]);
+	const pickersRef = useLatest({
+		pickEvery: props.pickEvery,
+		pickBest: props.pickBest
+	});
+	const pickEvery = useCallback((wx, wy) => pickersRef.current.pickEvery(wx, wy), [pickersRef]);
+	const pickBest = useCallback((wx, wy) => pickersRef.current.pickBest(wx, wy), [pickersRef]);
+	if (detachedInput === null) return null;
+	const anchor = detachedInput ? { anchorRef: canvasRef } : {};
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		cursorCoords && /* @__PURE__ */ jsx(CursorCoordsHud, {
+			canvasRef,
+			...anchor,
+			viewRef,
+			toWorld
 		}),
-		u && /* @__PURE__ */ o(n, {
-			canvasRef: f,
-			...b,
-			viewRef: h,
-			toWorld: g,
-			pickEvery: v,
-			pickBest: y
+		pick && /* @__PURE__ */ jsx(PickHud, {
+			canvasRef,
+			...anchor,
+			viewRef,
+			toWorld,
+			pickEvery,
+			pickBest
 		}),
-		d && /* @__PURE__ */ o(t, {
-			canvasRef: f,
-			...b,
-			modeId: typeof d == "object" ? d.modeId : void 0
+		modality && /* @__PURE__ */ jsx(ModalityHud, {
+			canvasRef,
+			...anchor,
+			modeId: typeof modality === "object" ? modality.modeId : void 0
 		})
 	] });
 }
-//#endregion
-export { c as DevHuds };
+/** `<SceneCanvas debug>` minus the flag only SceneCanvas reads. */
+function canvasDebug(debug) {
+	if (debug === false) return false;
+	const { slops: _slops, ...rest } = debug;
+	return rest;
+}
 
+//#endregion
+export { DevHuds, canvasDebug };
 //# sourceMappingURL=DevHuds.js.map

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

@@ -1 +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"}
+{"version":3,"file":"DevHuds.js","names":["_Fragment"],"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 { DebugConfig } from '../../debug/types';\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\n/** `<SceneCanvas debug>` minus the flag only SceneCanvas reads. */\nexport function canvasDebug(debug: (DebugConfig & { slops?: boolean }) | false): DebugConfig | false {\n  if (debug === false) return false;\n  const { slops: _slops, ...rest } = debug;\n  return rest;\n}\n"],"mappings":";;;;;;;;;;;;AAkCA,SAAgB,QAAQ,OAAqB;CAC3C,MAAM,EAAE,cAAc,MAAM,UAAU,WAAW,cAAc,eAAe,YAAY;CAC1F,MAAM,UAAU,aACb,SAAiB,YAChB,aAAa,SAAS,cAAc,SAAS,OAAO,KAAK,CAAC,SAAS,OAAO,GAC5E,CAAC,YAAY,CACf;CAGA,MAAM,aAAa,UAAU;EAAE,WAAW,MAAM;EAAW,UAAU,MAAM;CAAS,CAAC;CACrF,MAAM,YAAY,aACf,IAAY,OAAkC,WAAW,QAAQ,UAAU,IAAI,EAAE,GAClF,CAAC,UAAU,CACb;CACA,MAAM,WAAW,aACd,IAAY,OAA8B,WAAW,QAAQ,SAAS,IAAI,EAAE,GAC7E,CAAC,UAAU,CACb;CAIA,IAAI,kBAAkB,MAAM,OAAO;CAEnC,MAAM,SAAS,gBAAgB,EAAE,WAAW,UAAU,IAAI,CAAC;CAC3D,OACE,qBAAAA,UAAA,EAAA,UAAA;EACG,gBACC,oBAAC,iBAAD;GAA4B;GAAW,GAAI;GAAiB;GAAkB;EAAU,CAAA;EAEzF,QACC,oBAAC,SAAD;GACa;GACX,GAAI;GACK;GACA;GACE;GACD;EACX,CAAA;EAEF,YACC,oBAAC,aAAD;GACa;GACX,GAAI;GACJ,QAAQ,OAAO,aAAa,WAAW,SAAS,SAAS;EAC1D,CAAA;CAEH,EAAA,CAAA;AAEN;;AAGA,SAAgB,YAAY,OAAyE;CACnG,IAAI,UAAU,OAAO,OAAO;CAC5B,MAAM,EAAE,OAAO,QAAQ,GAAG,SAAS;CACnC,OAAO;AACT"}

package/dist/canvas/SceneCanvas/PointerProviderIfRoot.js

@@ -1,47 +1,83 @@
-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";
+import { useOptionalViewRegistry } from "../viewRegistry.js";
+import { worldPointAt } from "./worldPointAt.js";
+import { useEffect } from "react";
+import { heldPointers } from "@weasel-js/gestures";
+import { PointerContextProvider, usePointerContext } from "@weasel-js/routing/react";
+import { Fragment, jsx } from "react/jsx-runtime";
+
 //#region src/canvas/SceneCanvas/PointerProviderIfRoot.tsx
-function s({ children: e }) {
-	return i() ? /* @__PURE__ */ o(a, { children: e }) : /* @__PURE__ */ o(r, { children: e });
+/**
+* Conditional `<PointerContextProvider>` wrapper. Mounts a provider only
+* when no parent provider is in scope — otherwise renders children unwrapped
+* so SceneCanvas defers to the host's existing scope.
+*
+* Pairs with `usePointerPublisher`, which attaches native pointermove/leave
+* listeners to the canvas element and writes world-space coords into the
+* surrounding context's `pointerRef`.
+*/
+/** Mount a `<PointerContextProvider>` only when none is already in scope. */
+function PointerProviderIfRoot({ children }) {
+	if (usePointerContext()) return /* @__PURE__ */ jsx(Fragment, { children });
+	return /* @__PURE__ */ jsx(PointerContextProvider, { children });
 }
-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: c?.id ?? null
+/**
+* Attaches native `pointermove` / `pointerleave` listeners to the supplied
+* canvas element and publishes the world-space pointer coordinates into the
+* surrounding `<PointerContextProvider>`. No-op when no provider is in scope
+* (matches "publish if anyone is listening").
+*
+* Called inside the provider scope so it sees both consumer-mounted providers
+* and SceneCanvas's auto-mounted one.
+*/
+function usePointerPublisher(canvasRef, canvasApiRef) {
+	const ctx = usePointerContext();
+	const registry = useOptionalViewRegistry();
+	useEffect(() => {
+		if (!ctx) return;
+		const el = canvasRef.current;
+		if (!el) return;
+		const publish = (pointerId, clientX, clientY) => {
+			const api = canvasApiRef.current;
+			if (!api) return;
+			const target = registry?.resolver.at(pointerId, clientX, clientY);
+			const [worldX, worldY] = worldPointAt(api, target, clientX, clientY);
+			ctx.set({
+				worldX,
+				worldY,
+				viewId: target?.id ?? null
 			});
-		}, i = (e) => n(e.pointerId, e.clientX, e.clientY), c = (e) => {
-			if (e.buttons !== 0) {
-				n(e.pointerId, e.clientX, e.clientY);
+		};
+		const onMove = (e) => publish(e.pointerId, e.clientX, e.clientY);
+		const held = heldPointers(el);
+		const onLeave = (e) => {
+			if (held.count() > 0) {
+				publish(e.pointerId, e.clientX, e.clientY);
 				return;
 			}
-			o.set(null);
-		}, l = (t) => {
-			t.target !== e && t.buttons !== 0 && n(t.pointerId, t.clientX, t.clientY);
+			ctx.set(null);
+		};
+		const onDocMove = (e) => {
+			if (e.target === el) return;
+			if (held.count() === 0) return;
+			publish(e.pointerId, e.clientX, e.clientY);
 		};
-		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);
+		el.addEventListener("pointermove", onMove);
+		el.addEventListener("pointerleave", onLeave);
+		document.addEventListener("pointermove", onDocMove);
+		return () => {
+			el.removeEventListener("pointermove", onMove);
+			el.removeEventListener("pointerleave", onLeave);
+			document.removeEventListener("pointermove", onDocMove);
+			held.release();
 		};
 	}, [
-		o,
-		r,
-		a,
-		s
-	]), null;
+		ctx,
+		canvasRef,
+		canvasApiRef,
+		registry
+	]);
 }
-//#endregion
-export { s as PointerProviderIfRoot, c as PointerPublisher };
 
+//#endregion
+export { PointerProviderIfRoot, usePointerPublisher };
 //# sourceMappingURL=PointerProviderIfRoot.js.map

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","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"}
+{"version":3,"file":"PointerProviderIfRoot.js","names":["_Fragment"],"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 `usePointerPublisher`, 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 { heldPointers } from '@weasel-js/gestures';\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>`. No-op when no provider is in scope\n * (matches \"publish if anyone is listening\").\n *\n * Called inside the provider scope so it sees both consumer-mounted providers\n * and SceneCanvas's auto-mounted one.\n */\nexport function usePointerPublisher(\n  canvasRef: MutableRefObject<HTMLElement | null>,\n  canvasApiRef: RefObject<CanvasExtensionApi | null>,\n): void {\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 held = heldPointers(el);\n    const onLeave = (e: PointerEvent): void => {\n      // A pointer held on the canvas is still working it once it leaves the\n      // rect, and what it drives needs the latest world position.\n      if (held.count() > 0) {\n        publish(e.pointerId, e.clientX, e.clientY);\n        return;\n      }\n      ctx.set(null);\n    };\n    // A drag that began on the canvas keeps reporting once it is off it; the\n    // canvas's own listener has the moves that still target it.\n    const onDocMove = (e: PointerEvent): void => {\n      if (e.target === el) return;\n      if (held.count() === 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      held.release();\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}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,SAAgB,sBAAsB,EAAE,YAAqC;CAE3E,IADe,kBACX,GAAQ,OAAO,oBAAAA,UAAA,EAAG,SAAW,CAAA;CACjC,OAAO,oBAAC,wBAAD,EAAyB,SAAiC,CAAA;AACnE;;;;;;;;;;AAWA,SAAgB,oBACd,WACA,cACM;CACN,MAAM,MAAM,kBAAkB;CAC9B,MAAM,WAAW,wBAAwB;CACzC,gBAAgB;EACd,IAAI,CAAC,KAAK;EACV,MAAM,KAAK,UAAU;EACrB,IAAI,CAAC,IAAI;EAIT,MAAM,WAAW,WAA0B,SAAiB,YAA0B;GACpF,MAAM,MAAM,aAAa;GACzB,IAAI,CAAC,KAAK;GACV,MAAM,SAAS,UAAU,SAAS,GAAG,WAAW,SAAS,OAAO;GAChE,MAAM,CAAC,QAAQ,UAAU,aAAa,KAAK,QAAQ,SAAS,OAAO;GACnE,IAAI,IAAI;IAAE;IAAQ;IAAQ,QAAQ,QAAQ,MAAM;GAAK,CAAC;EACxD;EACA,MAAM,UAAU,MAA0B,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;EACnF,MAAM,OAAO,aAAa,EAAE;EAC5B,MAAM,WAAW,MAA0B;GAGzC,IAAI,KAAK,MAAM,IAAI,GAAG;IACpB,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;IACzC;GACF;GACA,IAAI,IAAI,IAAI;EACd;EAGA,MAAM,aAAa,MAA0B;GAC3C,IAAI,EAAE,WAAW,IAAI;GACrB,IAAI,KAAK,MAAM,MAAM,GAAG;GACxB,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;EAC3C;EACA,GAAG,iBAAiB,eAAe,MAAM;EACzC,GAAG,iBAAiB,gBAAgB,OAAO;EAC3C,SAAS,iBAAiB,eAAe,SAAS;EAClD,aAAa;GACX,GAAG,oBAAoB,eAAe,MAAM;GAC5C,GAAG,oBAAoB,gBAAgB,OAAO;GAC9C,SAAS,oBAAoB,eAAe,SAAS;GACrD,KAAK,QAAQ;EACf;CAGF,GAAG;EAAC;EAAK;EAAW;EAAc;CAAQ,CAAC;AAC7C"}

package/dist/canvas/SceneCanvas/SceneCanvasInput.js

@@ -0,0 +1,110 @@
+import { useDeviceProfile } from "../../core/device/useDeviceProfile.js";
+import { dlog } from "../../debug/flag.js";
+import { usePointerPublisher } from "./PointerProviderIfRoot.js";
+import { SnapSourceRegistryContext } from "../../features/snap/registry.js";
+import { useTestHook } from "../../test-hook/useTestHook.js";
+import { useHitObserver } from "../useHitObserver.js";
+import { GeometryProjectionRegistrar, ResizePolicyRegistrar } from "./poseRegistrars.js";
+import { useSceneGestureDispatcher } from "./useSceneGestureDispatcher.js";
+import { useSceneStandardActions } from "./useSceneStandardActions.js";
+import { useToolKeybindings } from "./useToolKeybindings.js";
+import { useContext, useEffect } from "react";
+import { useLatest } from "@weasel-js/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/canvas/SceneCanvas/SceneCanvasInput.tsx
+/**
+* The canvas's input wiring: the pointer publisher, the standard actions and their deps, the
+* gesture dispatcher, and the tool keybindings, in that order, then the test hook.
+*
+* A component of its own, mounted ahead of `<SceneCanvas>`'s children, rather than hooks in the
+* canvas's body: dep sources and actions stack newest-live in effect order, and a parent's
+* effects run after its children's, so a child overriding a kit dep would lose to it.
+*/
+function SceneCanvasInput(p) {
+	const { props, scene, selection, picking, chrome, overlay, canvas } = p;
+	const { viewState } = p.camera;
+	const { selectTool, enableKeybindings = true } = props;
+	useEffect(() => {
+		dlog("scene-canvas", "mount");
+		return () => dlog("scene-canvas", "unmount");
+	}, []);
+	usePointerPublisher(canvas.elementRef, canvas.apiRef);
+	useSceneStandardActions({
+		props,
+		rotateOff: p.rotateOff,
+		viewOn: p.viewOn,
+		selection,
+		scene,
+		adapter: picking.adapter,
+		standardActions: p.tools.standardActions,
+		currentViewRef: viewState.viewRef,
+		onViewChange: viewState.setViewFromInput,
+		poseDescriptor: p.descriptor,
+		dispatcher: p.dispatcher,
+		pickEvery: picking.pickEvery,
+		layerIsPainted: picking.viewLayerGate,
+		alphaOf: picking.alphaOf,
+		viewAnimation: p.camera.viewAnimation,
+		editAnchorsExternalState: p.pathEdit.state,
+		canvasRef: canvas.elementRef,
+		canvasApiRef: canvas.apiRef,
+		ingestionClipboard: p.ingestionClipboard,
+		snap: {
+			sources: [...props.snap?.sources ?? [], ...p.snapSources],
+			registry: useContext(SnapSourceRegistryContext),
+			store: p.snapStore
+		}
+	});
+	const onDoubleClick = useHitObserver(props.onDoubleClick, p.nodeAtPointRef);
+	const onClick = useHitObserver(props.onClick, p.nodeAtPointRef);
+	const selectionRef = useLatest(selection);
+	const { targetScale } = useDeviceProfile();
+	useSceneGestureDispatcher({
+		canvasRef: canvas.elementRef,
+		canvasApiRef: canvas.apiRef,
+		tools: p.tools.tools,
+		contributions: p.tools.contributions,
+		enabled: props.enableGestureDispatcher ?? true,
+		keyboard: enableKeybindings,
+		claimKeys: props.claimKeys ?? false,
+		selectionRef,
+		boundsOf: picking.boundsOf,
+		planeOfNode: picking.planeOfNode,
+		pickEvery: picking.pickEvery,
+		pickBest: picking.pickBest,
+		kindOfNode: picking.kindOfNode,
+		doubleClickNames: picking.doubleClickNames,
+		viewRef: viewState.viewRef,
+		dispatcher: p.dispatcher,
+		getIsVisibleForCanvas: chrome.getIsVisible,
+		getRuleCtx: chrome.getRuleCtx,
+		targetScale,
+		handleHitRadius: overlay.resizeHandles.hitRadiusPx,
+		edgeHandles: overlay.resizeHandles.edges,
+		rotationBadge: overlay.rotationBadge,
+		chromeAffordancesRef: overlay.chromeAffordancesRef,
+		onDoubleClick,
+		onClick,
+		longPress: props.longPress
+	});
+	useToolKeybindings({
+		internalTools: p.tools.internal,
+		toolsTakeover: p.tools.takeover ?? void 0,
+		enableKeybindings,
+		modes: props.modes,
+		canvasApi: canvas.ready ? canvas.apiRef.current : null,
+		versionCheck: props.versionCheck
+	});
+	useTestHook({
+		getScene: () => scene,
+		getSelectionIds: () => selection.current ?? [],
+		getView: () => viewState.viewRef.current,
+		getActiveToolId: () => p.tools.tools.active ?? null
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [selectTool?.resize ? /* @__PURE__ */ jsx(ResizePolicyRegistrar, { options: selectTool.resize }) : null, props.geometryProjection ? /* @__PURE__ */ jsx(GeometryProjectionRegistrar, { projection: props.geometryProjection }) : null] });
+}
+
+//#endregion
+export { SceneCanvasInput };
+//# sourceMappingURL=SceneCanvasInput.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneCanvasInput.js","names":["_Fragment"],"sources":["../../../src/canvas/SceneCanvas/SceneCanvasInput.tsx"],"sourcesContent":["import type { ResizeHandleLayout } from 'interactions/actions/resize/cornerHandles';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { RuleCtx } from 'features/chrome-caps';\nimport type { Affordance } from 'affordances/types';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport { useContext, useEffect, type MutableRefObject, type RefObject } from 'react';\nimport { SnapSourceRegistryContext } from 'features/snap/registry';\nimport type { SnapOutcomeStore } from 'features/snap/outcomeStore';\nimport type { SnapSource } from 'features/snap/types';\nimport { dlog } from '../../debug/flag';\nimport { useDeviceProfile } from '../../core/device/useDeviceProfile';\nimport { useTestHook } from '../../test-hook/useTestHook';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useHitObserver } from '../useHitObserver';\nimport type { CanvasViewState } from '../useCanvasView';\nimport { GeometryProjectionRegistrar, ResizePolicyRegistrar } from './poseRegistrars';\nimport { usePointerPublisher } from './PointerProviderIfRoot';\nimport type { BridgeAdapter, SceneCanvasProps } from './props';\nimport type { NodeAtPoint } from './useNodeAtPoint';\nimport type { useSceneCanvasTools } from './useSceneCanvasTools';\nimport { useSceneGestureDispatcher } from './useSceneGestureDispatcher';\nimport type { useScenePicking } from './useScenePicking';\nimport {\n  useSceneStandardActions, type SceneStandardActionsInputs, type StandardActionsProps,\n} from './useSceneStandardActions';\nimport { useToolKeybindings } from './useToolKeybindings';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\ntype Picking = ReturnType<typeof useScenePicking<unknown, string, unknown>>;\n\n/** The `<SceneCanvas>` props its input wiring reads. */\nexport type SceneCanvasInputOptions = StandardActionsProps & Pick<\n  Props,\n  | 'selectTool' | 'geometryProjection' | 'enableGestureDispatcher' | 'enableKeybindings'\n  | 'claimKeys' | 'longPress' | 'modes' | 'versionCheck' | 'onClick' | 'onDoubleClick'\n>;\n\n/** What `<SceneCanvas>` hands {@link SceneCanvasInput}. */\nexport interface SceneCanvasInputProps {\n  props: SceneCanvasInputOptions;\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  descriptor: PoseDescriptor<unknown>;\n  picking: Pick<\n    Picking, 'pickEvery' | 'pickBest' | 'boundsOf' | 'planeOfNode' | 'kindOfNode' | 'doubleClickNames' | 'viewLayerGate' | 'alphaOf'\n  > & { adapter: BridgeAdapter };\n  /** The node a hit resolves to, for the `onClick` / `onDoubleClick` observers. */\n  nodeAtPointRef: MutableRefObject<NodeAtPoint | undefined>;\n  tools: ReturnType<typeof useSceneCanvasTools>;\n  rotateOff: boolean;\n  viewOn: boolean;\n  camera: { viewState: CanvasViewState; viewAnimation: SceneStandardActionsInputs['viewAnimation'] };\n  dispatcher: Dispatcher;\n  pathEdit: {\n    state: SceneStandardActionsInputs['editAnchorsExternalState'];\n  };\n  chrome: { getIsVisible: () => (id: string) => boolean; getRuleCtx: () => RuleCtx | undefined };\n  /** The selection overlay's rotate badge, and where the dispatcher reports the affordances\n   *  it hit-tests, for the slops overlay. */\n  overlay: {\n    rotationBadge: { distancePx: number; sizePx: number } | null | undefined;\n    /** The resize-handle layout the overlay paints, so the hit-test grabs exactly those. */\n    resizeHandles: ResizeHandleLayout;\n    chromeAffordancesRef: MutableRefObject<readonly Affordance[]>;\n  };\n  canvas: {\n    elementRef: MutableRefObject<HTMLElement | null>;\n    apiRef: RefObject<CanvasExtensionApi | null>;\n    ready: boolean;\n  };\n  ingestionClipboard: SceneStandardActionsInputs['ingestionClipboard'];\n  /** The enabled presets' snap sources. */\n  snapSources: readonly SnapSource[];\n  /** The outcome store the canvas's readout layer draws. */\n  snapStore: SnapOutcomeStore;\n}\n\n/**\n * The canvas's input wiring: the pointer publisher, the standard actions and their deps, the\n * gesture dispatcher, and the tool keybindings, in that order, then the test hook.\n *\n * A component of its own, mounted ahead of `<SceneCanvas>`'s children, rather than hooks in the\n * canvas's body: dep sources and actions stack newest-live in effect order, and a parent's\n * effects run after its children's, so a child overriding a kit dep would lose to it.\n */\nexport function SceneCanvasInput(p: SceneCanvasInputProps) {\n  const { props, scene, selection, picking, chrome, overlay, canvas } = p;\n  const { viewState } = p.camera;\n  const { selectTool, enableKeybindings = true } = props;\n  useEffect(() => {\n    dlog('scene-canvas', 'mount');\n    return () => dlog('scene-canvas', 'unmount');\n  }, []);\n  usePointerPublisher(canvas.elementRef, canvas.apiRef);\n  useSceneStandardActions({\n    props, rotateOff: p.rotateOff, viewOn: p.viewOn,\n    selection, scene, adapter: picking.adapter, standardActions: p.tools.standardActions,\n    currentViewRef: viewState.viewRef, onViewChange: viewState.setViewFromInput,\n    poseDescriptor: p.descriptor, dispatcher: p.dispatcher,\n    pickEvery: picking.pickEvery, layerIsPainted: picking.viewLayerGate, alphaOf: picking.alphaOf,\n    viewAnimation: p.camera.viewAnimation, editAnchorsExternalState: p.pathEdit.state,\n    canvasRef: canvas.elementRef, canvasApiRef: canvas.apiRef, ingestionClipboard: p.ingestionClipboard,\n    snap: { sources: [...(props.snap?.sources ?? []), ...p.snapSources], registry: useContext(SnapSourceRegistryContext), store: p.snapStore },\n  });\n\n  // Rides the gesture dispatcher as an OBSERVER rather than an Action binding because the\n  // prop is a notification, not a behavior: as a binding it would lose first-match-wins to\n  // `enterPathEdit` on every body hit and silently stop firing.\n  const onDoubleClick = useHitObserver(props.onDoubleClick, p.nodeAtPointRef);\n  const onClick = useHitObserver(props.onClick, p.nodeAtPointRef);\n  const selectionRef = useLatest(selection);\n  const { targetScale } = useDeviceProfile();\n  useSceneGestureDispatcher({\n    canvasRef: canvas.elementRef, canvasApiRef: canvas.apiRef,\n    tools: p.tools.tools, contributions: p.tools.contributions,\n    enabled: props.enableGestureDispatcher ?? true, keyboard: enableKeybindings,\n    claimKeys: props.claimKeys ?? false,\n    selectionRef,\n    boundsOf: picking.boundsOf, planeOfNode: picking.planeOfNode,\n    pickEvery: picking.pickEvery, pickBest: picking.pickBest, kindOfNode: picking.kindOfNode,\n    doubleClickNames: picking.doubleClickNames,\n    viewRef: viewState.viewRef, dispatcher: p.dispatcher,\n    getIsVisibleForCanvas: chrome.getIsVisible, getRuleCtx: chrome.getRuleCtx,\n    targetScale, handleHitRadius: overlay.resizeHandles.hitRadiusPx,\n    edgeHandles: overlay.resizeHandles.edges,\n    rotationBadge: overlay.rotationBadge, chromeAffordancesRef: overlay.chromeAffordancesRef,\n    onDoubleClick, onClick, longPress: props.longPress,\n  });\n  useToolKeybindings({\n    internalTools: p.tools.internal,\n    toolsTakeover: p.tools.takeover ?? undefined,\n    enableKeybindings,\n    modes: props.modes,\n    canvasApi: canvas.ready ? canvas.apiRef.current : null,\n    versionCheck: props.versionCheck,\n  });\n  useTestHook({\n    getScene: () => scene as never,\n    getSelectionIds: () => (selection.current as readonly string[] | undefined) ?? [],\n    getView: () => viewState.viewRef.current,\n    getActiveToolId: () => p.tools.tools.active ?? null,\n  });\n\n  // Mounted only when passed: an empty default registered with the deps above would land\n  // after, and over, a dep one of these registered (child effects run first). Absent\n  // `geometryProjection` leaves the dep undefined.\n  return (\n    <>\n      {selectTool?.resize\n        ? <ResizePolicyRegistrar options={selectTool.resize as UseResizeOptions<unknown>} />\n        : null}\n      {props.geometryProjection ? <GeometryProjectionRegistrar projection={props.geometryProjection} /> : null}\n    </>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyFA,SAAgB,iBAAiB,GAA0B;CACzD,MAAM,EAAE,OAAO,OAAO,WAAW,SAAS,QAAQ,SAAS,WAAW;CACtE,MAAM,EAAE,cAAc,EAAE;CACxB,MAAM,EAAE,YAAY,oBAAoB,SAAS;CACjD,gBAAgB;EACd,KAAK,gBAAgB,OAAO;EAC5B,aAAa,KAAK,gBAAgB,SAAS;CAC7C,GAAG,CAAC,CAAC;CACL,oBAAoB,OAAO,YAAY,OAAO,MAAM;CACpD,wBAAwB;EACtB;EAAO,WAAW,EAAE;EAAW,QAAQ,EAAE;EACzC;EAAW;EAAO,SAAS,QAAQ;EAAS,iBAAiB,EAAE,MAAM;EACrE,gBAAgB,UAAU;EAAS,cAAc,UAAU;EAC3D,gBAAgB,EAAE;EAAY,YAAY,EAAE;EAC5C,WAAW,QAAQ;EAAW,gBAAgB,QAAQ;EAAe,SAAS,QAAQ;EACtF,eAAe,EAAE,OAAO;EAAe,0BAA0B,EAAE,SAAS;EAC5E,WAAW,OAAO;EAAY,cAAc,OAAO;EAAQ,oBAAoB,EAAE;EACjF,MAAM;GAAE,SAAS,CAAC,GAAI,MAAM,MAAM,WAAW,CAAC,GAAI,GAAG,EAAE,WAAW;GAAG,UAAU,WAAW,yBAAyB;GAAG,OAAO,EAAE;EAAU;CAC3I,CAAC;CAKD,MAAM,gBAAgB,eAAe,MAAM,eAAe,EAAE,cAAc;CAC1E,MAAM,UAAU,eAAe,MAAM,SAAS,EAAE,cAAc;CAC9D,MAAM,eAAe,UAAU,SAAS;CACxC,MAAM,EAAE,gBAAgB,iBAAiB;CACzC,0BAA0B;EACxB,WAAW,OAAO;EAAY,cAAc,OAAO;EACnD,OAAO,EAAE,MAAM;EAAO,eAAe,EAAE,MAAM;EAC7C,SAAS,MAAM,2BAA2B;EAAM,UAAU;EAC1D,WAAW,MAAM,aAAa;EAC9B;EACA,UAAU,QAAQ;EAAU,aAAa,QAAQ;EACjD,WAAW,QAAQ;EAAW,UAAU,QAAQ;EAAU,YAAY,QAAQ;EAC9E,kBAAkB,QAAQ;EAC1B,SAAS,UAAU;EAAS,YAAY,EAAE;EAC1C,uBAAuB,OAAO;EAAc,YAAY,OAAO;EAC/D;EAAa,iBAAiB,QAAQ,cAAc;EACpD,aAAa,QAAQ,cAAc;EACnC,eAAe,QAAQ;EAAe,sBAAsB,QAAQ;EACpE;EAAe;EAAS,WAAW,MAAM;CAC3C,CAAC;CACD,mBAAmB;EACjB,eAAe,EAAE,MAAM;EACvB,eAAe,EAAE,MAAM,YAAY;EACnC;EACA,OAAO,MAAM;EACb,WAAW,OAAO,QAAQ,OAAO,OAAO,UAAU;EAClD,cAAc,MAAM;CACtB,CAAC;CACD,YAAY;EACV,gBAAgB;EAChB,uBAAwB,UAAU,WAA6C,CAAC;EAChF,eAAe,UAAU,QAAQ;EACjC,uBAAuB,EAAE,MAAM,MAAM,UAAU;CACjD,CAAC;CAKD,OACE,qBAAAA,UAAA,EAAA,UAAA,CACG,YAAY,SACT,oBAAC,uBAAD,EAAuB,SAAS,WAAW,OAAsC,CAAA,IACjF,MACH,MAAM,qBAAqB,oBAAC,6BAAD,EAA6B,YAAY,MAAM,mBAAqB,CAAA,IAAI,IACpG,EAAA,CAAA;AAEN"}

package/dist/canvas/SceneCanvas/brushOverlay.js

@@ -0,0 +1,36 @@
+import { circlePath, polylineFromPoints } from "@weasel-js/geom";
+
+//#region src/canvas/SceneCanvas/brushOverlay.ts
+/**
+* A `brush` overlay as screen-space commands: the area swept so far, and the
+* brush's rim where it is now. `points` are already on screen.
+*/
+function brushOverlayCommands(points, radiusPx, style) {
+	const head = points[points.length - 1];
+	if (!head) return [];
+	return [points.length === 1 ? {
+		kind: "path",
+		path: circlePath(head.x, head.y, radiusPx),
+		fill: { paint: { color: style.fill } }
+	} : {
+		kind: "path",
+		path: polylineFromPoints(points),
+		stroke: {
+			paint: { color: style.fill },
+			width: radiusPx * 2,
+			cap: "round",
+			join: "round"
+		}
+	}, {
+		kind: "path",
+		path: circlePath(head.x, head.y, radiusPx),
+		stroke: {
+			paint: { color: style.stroke },
+			width: style.lineWidth
+		}
+	}];
+}
+
+//#endregion
+export { brushOverlayCommands };
+//# sourceMappingURL=brushOverlay.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"brushOverlay.js","names":[],"sources":["../../../src/canvas/SceneCanvas/brushOverlay.ts"],"sourcesContent":["import type { PathDrawCommand } from '@weasel-js/renderer';\nimport { circlePath, polylineFromPoints } from '@weasel-js/geom';\n\ntype Point = { x: number; y: number };\n\n/** The colors a brush overlay paints with: `fill` for the area swept, `stroke`\n *  for the footprint's rim. */\nexport interface BrushOverlayStyle {\n  fill: string;\n  stroke: string;\n  lineWidth: number;\n}\n\n/**\n * A `brush` overlay as screen-space commands: the area swept so far, and the\n * brush's rim where it is now. `points` are already on screen.\n */\nexport function brushOverlayCommands(\n  points: readonly Point[],\n  radiusPx: number,\n  style: BrushOverlayStyle,\n): PathDrawCommand[] {\n  const head = points[points.length - 1];\n  if (!head) return [];\n  const swept: PathDrawCommand = points.length === 1\n    ? { kind: 'path', path: circlePath(head.x, head.y, radiusPx), fill: { paint: { color: style.fill } } }\n    : {\n        kind: 'path',\n        path: polylineFromPoints(points),\n        stroke: { paint: { color: style.fill }, width: radiusPx * 2, cap: 'round', join: 'round' },\n      };\n  return [\n    swept,\n    {\n      kind: 'path',\n      path: circlePath(head.x, head.y, radiusPx),\n      stroke: { paint: { color: style.stroke }, width: style.lineWidth },\n    },\n  ];\n}\n"],"mappings":";;;;;;;AAiBA,SAAgB,qBACd,QACA,UACA,OACmB;CACnB,MAAM,OAAO,OAAO,OAAO,SAAS;CACpC,IAAI,CAAC,MAAM,OAAO,CAAC;CAQnB,OAAO,CAPwB,OAAO,WAAW,IAC7C;EAAE,MAAM;EAAQ,MAAM,WAAW,KAAK,GAAG,KAAK,GAAG,QAAQ;EAAG,MAAM,EAAE,OAAO,EAAE,OAAO,MAAM,KAAK,EAAE;CAAE,IACnG;EACE,MAAM;EACN,MAAM,mBAAmB,MAAM;EAC/B,QAAQ;GAAE,OAAO,EAAE,OAAO,MAAM,KAAK;GAAG,OAAO,WAAW;GAAG,KAAK;GAAS,MAAM;EAAQ;CAC3F,GAGF;EACE,MAAM;EACN,MAAM,WAAW,KAAK,GAAG,KAAK,GAAG,QAAQ;EACzC,QAAQ;GAAE,OAAO,EAAE,OAAO,MAAM,OAAO;GAAG,OAAO,MAAM;EAAU;CACnE,CACF;AACF"}

package/dist/canvas/SceneCanvas/canvasPassThrough.js

@@ -0,0 +1,72 @@
+//#region src/canvas/SceneCanvas/canvasPassThrough.ts
+/** Every prop `<SceneCanvas>` reads itself instead of handing to `<Canvas>`. */
+var OWN_PROPS = [
+	"scene",
+	"geometry",
+	"poseDescriptor",
+	"selectTool",
+	"insertNodeFactories",
+	"insertPaint",
+	"ingestion",
+	"layoutDropTarget",
+	"reflowTransition",
+	"poseTransition",
+	"geometryProjection",
+	"routing",
+	"selection",
+	"selectionOptions",
+	"selectable",
+	"tools",
+	"features",
+	"enableKeybindings",
+	"claimKeys",
+	"enableGestureDispatcher",
+	"onToolsCreated",
+	"defaultTools",
+	"toolOptions",
+	"initialActiveTool",
+	"ambient",
+	"versionCheck",
+	"longPress",
+	"viewport",
+	"layers",
+	"actions",
+	"tune",
+	"describeKind",
+	"animator",
+	"views",
+	"children",
+	"debug",
+	"alphaFor",
+	"layerVisibility",
+	"layerOrder",
+	"isPointerInteractive",
+	"isolatedGroup",
+	"onDoubleClick",
+	"onClick",
+	"chromeVisibility",
+	"modes",
+	"pathEdit",
+	"defaultPathEdit",
+	"getFocused",
+	"cursorCoordsHud",
+	"pickHud",
+	"modalityHud",
+	"view",
+	"onViewChange",
+	"defaultView",
+	"viewBounds",
+	"redrawOn",
+	"snap"
+];
+/** The props `<SceneCanvas>` passes through to its `<Canvas>`: all but its own. */
+function canvasPassThrough(props) {
+	const rest = { ...props };
+	for (const key of OWN_PROPS) delete rest[key];
+	delete rest.presetSource;
+	return rest;
+}
+
+//#endregion
+export { canvasPassThrough };
+//# sourceMappingURL=canvasPassThrough.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canvasPassThrough.js","names":[],"sources":["../../../src/canvas/SceneCanvas/canvasPassThrough.ts"],"sourcesContent":["import type { SceneCanvasProps } from './props';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\n\n/** Every prop `<SceneCanvas>` reads itself instead of handing to `<Canvas>`. */\nconst OWN_PROPS = [\n  'scene', 'geometry', 'poseDescriptor', 'selectTool', 'insertNodeFactories', 'insertPaint',\n  'ingestion', 'layoutDropTarget', 'reflowTransition', 'poseTransition', 'geometryProjection', 'routing',\n  'selection', 'selectionOptions', 'selectable', 'tools', 'features', 'enableKeybindings',\n  'claimKeys', 'enableGestureDispatcher', 'onToolsCreated', 'defaultTools', 'toolOptions',\n  'initialActiveTool', 'ambient', 'versionCheck', 'longPress', 'viewport', 'layers', 'actions',\n  'tune', 'describeKind', 'animator', 'views', 'children', 'debug', 'alphaFor', 'layerVisibility',\n  'layerOrder', 'isPointerInteractive', 'isolatedGroup', 'onDoubleClick', 'onClick', 'chromeVisibility', 'modes',\n  'pathEdit', 'defaultPathEdit', 'getFocused', 'cursorCoordsHud', 'pickHud', 'modalityHud', 'view',\n  'onViewChange', 'defaultView', 'viewBounds', 'redrawOn', 'snap',\n] as const satisfies readonly (keyof Props)[];\n\n/** The props `<SceneCanvas>` passes through to its `<Canvas>`: all but its own. */\nexport function canvasPassThrough<P extends object>(props: P): Omit<P, (typeof OWN_PROPS)[number] | 'presetSource'> {\n  const rest = { ...props } as Record<string, unknown>;\n  for (const key of OWN_PROPS) delete rest[key];\n  delete rest.presetSource;\n  return rest as Omit<P, (typeof OWN_PROPS)[number] | 'presetSource'>;\n}\n"],"mappings":";;AAKA,IAAM,YAAY;CAChB;CAAS;CAAY;CAAkB;CAAc;CAAuB;CAC5E;CAAa;CAAoB;CAAoB;CAAkB;CAAsB;CAC7F;CAAa;CAAoB;CAAc;CAAS;CAAY;CACpE;CAAa;CAA2B;CAAkB;CAAgB;CAC1E;CAAqB;CAAW;CAAgB;CAAa;CAAY;CAAU;CACnF;CAAQ;CAAgB;CAAY;CAAS;CAAY;CAAS;CAAY;CAC9E;CAAc;CAAwB;CAAiB;CAAiB;CAAW;CAAoB;CACvG;CAAY;CAAmB;CAAc;CAAmB;CAAW;CAAe;CAC1F;CAAgB;CAAe;CAAc;CAAY;AAC3D;;AAGA,SAAgB,kBAAoC,OAAgE;CAClH,MAAM,OAAO,EAAE,GAAG,MAAM;CACxB,KAAK,MAAM,OAAO,WAAW,OAAO,KAAK;CACzC,OAAO,KAAK;CACZ,OAAO;AACT"}