@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/SceneCanvas/useNodeKinds.js

@@ -0,0 +1,26 @@
+import { createNodeRouting as e } from "../../core/scene/NodeRouting.js";
+import { inferredNodeRouting as t } from "./defaultNodeRouting.js";
+import { useMemo as n } from "react";
+//#region src/canvas/SceneCanvas/useNodeKinds.ts
+function r(r, i) {
+	let a = n(() => {
+		let n = i === void 0 ? t : i;
+		if (n.length === 0) return;
+		let r = e();
+		for (let e of n) r.register(e);
+		return (e) => r.classify(e);
+	}, [i]);
+	return {
+		kindOfData: a,
+		kindOfNode: n(() => {
+			if (a) return (e) => {
+				let t = r.get(e);
+				return t ? a(t.data) : void 0;
+			};
+		}, [a, r])
+	};
+}
+//#endregion
+export { r as useNodeKinds };
+
+//# sourceMappingURL=useNodeKinds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeKinds.js","names":["useNodeKinds","kindOfData","useMemo","effective","routing","inferredNodeRouting","registry","createNodeRouting","k","data","node","scene","id"],"sources":["../../../src/canvas/SceneCanvas/useNodeKinds.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { createNodeRouting, type NodeRoutingEntry } from 'core/scene/NodeRouting';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { inferredNodeRouting } from './defaultNodeRouting';\n\n/**\n * The canvas's routing-trait classifier, by node data and by node id, so\n * `target: 'kind:text'` on a binding speaks the vocabulary of `Hit.kind`.\n * Unset `routing` falls back to `inferredNodeRouting`. An explicit empty list\n * opts out: both are undefined, every hit is `kind: 'unknown'`, and no\n * `kind:` target form can match.\n */\nexport function useNodeKinds<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  routing: readonly NodeRoutingEntry[] | undefined,\n): {\n  kindOfData: ((data: TData) => string) | undefined;\n  kindOfNode: ((id: string) => string | undefined) | undefined;\n} {\n  const kindOfData = useMemo(() => {\n    const effective = routing === undefined ? inferredNodeRouting : routing;\n    if (effective.length === 0) return undefined;\n    const registry = createNodeRouting();\n    for (const k of effective) registry.register(k);\n    return (data: TData) => registry.classify(data);\n  }, [routing]);\n\n  const kindOfNode = useMemo(() => {\n    if (!kindOfData) return undefined;\n    return (id: string): string | undefined => {\n      const node = scene.get(id as NodeId);\n      return node ? kindOfData(node.data) : undefined;\n    };\n  }, [kindOfData, scene]);\n\n  return { kindOfData, kindOfNode };\n}\n"],"mappings":";;;;AAYA,SAAgBA,EACd,GACA,GAIA;CACA,IAAMC,IAAaC,QAAc;EAC/B,IAAMC,IAAYC,MAAY,KAAA,IAAYC,IAAsBD;EAChE,IAAID,EAAU,WAAW,GAAG;EAC5B,IAAMG,IAAWC,EAAkB;EACnC,KAAK,IAAMC,KAAKL,GAAW,EAAS,SAASK,CAAC;EAC9C,QAAQ,MAAgBF,EAAS,SAASG,CAAI;CAChD,GAAG,CAACL,CAAO,CAAC;CAUZ,OAAO;EAAE;EAAY,YARFF,QAAc;GAC/B,IAAKD,GACL,QAAQ,MAAmC;IACzC,IAAMS,IAAOC,EAAM,IAAIC,CAAY;IACnC,OAAOF,IAAOT,EAAWS,EAAK,IAAI,IAAI,KAAA;GACxC;EACF,GAAG,CAACT,GAAYU,CAAK,CAEA;CAAW;AAClC"}

package/dist/canvas/SceneCanvas/usePreviewGhostLayer.js

@@ -2,66 +2,76 @@ import { deriveParallaxView as e } from "../../core/viewport/parallax.js";
 import { planeTransform as t } from "../planeClips.js";
 import { wrapWithPoseRotation as n } from "../poseRotation.js";
 import { findShapeSilhouette as r } from "../NodeShape.js";
-import { scenePlaneOf as i } from "../pickWalk.js";
-import { previewSourcesFrom as a } from "../drawEnvelope.js";
-import { resolvePreviews as o } from "../../interactions/actions/resolvePreviews.js";
-import { useEffect as s, useMemo as c, useReducer as l } from "react";
-import { useLatest as u } from "@weasel-js/react";
+import { scenePaintedPoseOf as i } from "../derivedPath.js";
+import { scenePlaneOf as a } from "../pickWalk.js";
+import { copiesAbove as o } from "../copiesAbove.js";
+import { previewSourcesFrom as s } from "../drawEnvelope.js";
+import { isCustomEntry as c } from "../layerSlots.js";
+import { resolvePreviews as l } from "../../interactions/actions/resolvePreviews.js";
+import "@weasel-js/renderer";
+import { mat3 as u } from "@weasel-js/geom";
+import { useEffect as d, useMemo as f, useReducer as p } from "react";
+import { useLatest as m } from "@weasel-js/react";
 //#region src/canvas/SceneCanvas/usePreviewGhostLayer.ts
-var d = .85;
-function f(f) {
-	let { scene: p, sceneSlot: m, dispatcher: h } = f, g = u(p), _ = u(m), [, v] = l((e) => e + 1, 0);
-	return s(() => {
-		if (h) return h.subscribe(v);
-	}, [h]), c(() => ({
+var h = .85;
+function g(g) {
+	let { scene: _, sceneSlot: v, dispatcher: y } = g, b = m(_), x = m(v), [, S] = p((e) => e + 1, 0);
+	return d(() => {
+		if (y) return y.subscribe(S);
+	}, [y]), f(() => ({
 		id: "preview-ghost",
 		label: "Preview ghost",
-		draw: (s, c) => {
-			let l = _.current, u = l?.drawOne;
-			if (!l || !u) return [];
-			let f = a(s), p = g.current, m = o(f, p);
-			if (m.length === 0) return [];
-			let h = i(p.layers, c), v = (e) => h?.(e) ?? null, y = (t) => {
-				let n = h ? p.layers.find((e) => e.id === t)?.parallax : void 0;
-				return n ? e(c, n) : c;
-			}, b = (e, i) => {
+		draw: (d, f) => {
+			let p = x.current;
+			if (!p || c(p) || !p.drawOne) return [];
+			let m = p.drawOne, g = s(d), _ = b.current, v = l(g, _);
+			if (v.length === 0) return [];
+			let y = a(_.layers, f), S = (e) => y?.(e) ?? null, C = (t) => {
+				let n = y ? _.layers.find((e) => e.id === t)?.parallax : void 0;
+				return n ? e(f, n) : f;
+			}, w = (e, i) => {
 				let a = e.data === e.node.data ? e.node : {
 					...e.node,
 					data: e.data
-				}, o = v(e.node.layer), s = u(a, e.pose, y(e.node.layer)), c = [...n(s, e.pose)];
-				for (let t of e.children) for (let e of b(t, o)) c.push(e);
-				let d = t(o, i), f = d ? {
+				}, o = S(e.node.layer), s = m(a, e.pose, C(e.node.layer)), c = [...n(s, e.pose)];
+				for (let t of e.children) for (let e of w(t, o)) c.push(e);
+				let l = t(o, i), u = l ? {
 					kind: "group",
-					transform: d,
+					transform: l,
 					children: c
 				} : {
 					kind: "group",
 					children: c
 				};
 				if (a.kind === "container") {
-					let t = r(a, e.pose, { derivedPath: l.derivedPathOf?.(a, e.pose) ?? null });
-					t && (f.clip = t);
+					let t = r(a, e.pose, { derivedPath: p.derivedPathOf?.(a, e.pose) ?? null });
+					t && (u.clip = t);
 				}
-				return [f];
-			}, x = [], S = [];
-			for (let e of m) {
-				let t = e.opaque ? S : x;
-				for (let n of b(e, null)) t.push(n);
+				return [u];
+			}, T = [], E = [], D = i(_);
+			for (let e of v) {
+				let t = e.opaque ? E : T, n = w(e, null);
+				for (let e of n) t.push(e);
+				for (let r of o(_, e.node.id, D)) t.push({
+					kind: "group",
+					transform: u.fromAffine(r),
+					children: n
+				});
 			}
-			if (x.length === 0 && S.length === 0) return [];
-			let C = [];
-			return S.length > 0 && C.push({
+			if (T.length === 0 && E.length === 0) return [];
+			let O = [];
+			return E.length > 0 && O.push({
 				kind: "group",
-				children: S
-			}), x.length > 0 && C.push({
+				children: E
+			}), T.length > 0 && O.push({
 				kind: "group",
-				alpha: d,
-				children: x
-			}), C;
+				alpha: h,
+				children: T
+			}), O;
 		}
-	}), [g, _]);
+	}), [b, x]);
 }
 //#endregion
-export { f as usePreviewGhostLayer };
+export { g as usePreviewGhostLayer };
 
 //# sourceMappingURL=usePreviewGhostLayer.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePreviewGhostLayer.js","names":["GHOST_ALPHA","usePreviewGhostLayer","args","sceneRef","useLatest","scene","sceneSlotRef","sceneSlot","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","slot","drawOne","sources","previewSourcesFrom","data","sc","roots","resolvePreviews","planeOf","scenePlaneOf","view","mapOf","layer","viewOf","parallax","l","deriveParallaxView","drawEntry","effNode","entry","plane","self","children","wrapWithPoseRotation","child","cmd","transform","planeTransform","parentPlane","group","clip","findShapeSilhouette","ghosted","settled","root","sink","out"],"sources":["../../../src/canvas/SceneCanvas/usePreviewGhostLayer.ts"],"sourcesContent":["/**\n * Preview-ghost render layer for `<SceneCanvas>`. Renders in-flight gesture\n * poses on top of the committed scene by reusing the scene slot's `drawOne`.\n * Which ids are displaced (`previewIds`) and where (`previewPose`) comes from\n * the drawing view's preview sources on the draw envelope — tools first, then\n * that view's in-flight handles.\n *\n * This replaces the per-tool `drawGhost` fold-in — a single SceneCanvas\n * concern instead of every consumer wiring it.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { type DrawCommand, type GroupDrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { LayersMap } from '../Canvas';\nimport type { Node, Scene } from 'core/scene/types';\nimport { findShapeSilhouette } from '../NodeShape';\nimport { wrapWithPoseRotation } from '../poseRotation';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { previewSourcesFrom } from '../drawEnvelope';\nimport { resolvePreviews, type PreviewNode } from 'interactions/actions/resolvePreviews';\nimport { scenePlaneOf } from '../pickWalk';\nimport { planeTransform } from '../planeClips';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { PlaneMap } from 'core/viewport/parallax';\n\nconst GHOST_ALPHA = 0.85;\n\nexport function usePreviewGhostLayer<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  sceneSlot: LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n  /**\n   * The surface's dispatcher, subscribed to only so a pump repaints — preview\n   * poses mutate silently inside handles otherwise. What gets *painted* is the\n   * drawing view's own `getPreviewSources()`, off the draw envelope.\n   */\n  dispatcher?: Dispatcher | null;\n}): RenderLayer<unknown> {\n  const { scene, sceneSlot, dispatcher } = args;\n\n  // Refs let the layer body read the last committed scene/slot without\n  // re-creating the layer on every host render.\n  const sceneRef = useLatest(scene);\n  const sceneSlotRef = useLatest(sceneSlot);\n\n  // Subscribe to dispatcher state changes so the canvas re-renders on every\n  // ongoing-action pump (preview poses mutate silently inside handles\n  // otherwise — single-frame ghost stuck on the start pose).\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    const unsub = dispatcher.subscribe(forceRerender);\n    return unsub;\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(() => ({\n    id: 'preview-ghost',\n    label: 'Preview ghost',\n    draw: (data, view) => {\n      const slot = sceneSlotRef.current;\n      const drawOne = slot?.drawOne;\n      if (!slot || !drawOne) return [];\n      // Whose gesture this frame is showing belongs to the view being drawn,\n      // not to the surface that built the layer.\n      const sources = previewSourcesFrom(data);\n      const sc = sceneRef.current;\n      const roots = resolvePreviews(sources, sc);\n      if (roots.length === 0) return [];\n\n      // A node on a parallax layer ghosts where its plane draws it: through\n      // the plane's view, inside a group carrying it into its parent's world.\n      const planeOf = scenePlaneOf(sc.layers, view);\n      const mapOf = (layer: string): PlaneMap | null => planeOf?.(layer) ?? null;\n      const viewOf = (layer: string) => {\n        const parallax = planeOf ? sc.layers.find((l) => l.id === layer)?.parallax : undefined;\n        return parallax ? deriveParallaxView(view, parallax) : view;\n      };\n\n      // Mirrors buildSceneTree's structure — a container group carries a clip\n      // from its painter's silhouette — but drawn from the previewed pose and\n      // data, so children are clipped to the shape the container is taking.\n      const drawEntry = (\n        entry: PreviewNode<TData, TLayer, TPose>,\n        parentPlane: PlaneMap | null,\n      ): DrawCommand[] => {\n        const effNode = entry.data === entry.node.data\n          ? entry.node\n          : ({ ...entry.node, data: entry.data } as typeof entry.node);\n        const plane = mapOf(entry.node.layer);\n        const self = drawOne(effNode, entry.pose, viewOf(entry.node.layer));\n        const children: DrawCommand[] = [...wrapWithPoseRotation(self, entry.pose as unknown)];\n        for (const child of entry.children) {\n          for (const cmd of drawEntry(child, plane)) children.push(cmd);\n        }\n        const transform = planeTransform(plane, parentPlane);\n        const group: GroupDrawCommand = transform ? { kind: 'group', transform, children } : { kind: 'group', children };\n        if (effNode.kind === 'container') {\n          const clip = findShapeSilhouette(\n            effNode as unknown as Node<unknown, string, TPose>,\n            entry.pose,\n            { derivedPath: slot.derivedPathOf?.(effNode, entry.pose) ?? null },\n          );\n          if (clip) group.clip = clip;\n        }\n        return [group];\n      };\n\n      // Opaque is honored at subtree-root granularity, as it always was: a\n      // sibling reflowing into place brings its own contents with it.\n      const ghosted: DrawCommand[] = [];\n      const settled: DrawCommand[] = [];\n      for (const root of roots) {\n        const sink = root.opaque ? settled : ghosted;\n        for (const cmd of drawEntry(root, null)) sink.push(cmd);\n      }\n      if (ghosted.length === 0 && settled.length === 0) return [];\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      const out: DrawCommand[] = [];\n      if (settled.length > 0) out.push({ kind: 'group', children: settled });\n      if (ghosted.length > 0) out.push({ kind: 'group', alpha: GHOST_ALPHA, children: ghosted });\n      return out;\n    },\n  }), [sceneRef, sceneSlotRef]);\n}\n"],"mappings":";;;;;;;;;;AA0BA,IAAMA,IAAc;AAEpB,SAAgBC,EAA0D,GASjD;CACvB,IAAM,EAAE,UAAO,cAAW,kBAAeC,GAInCC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAKlC,GAAGC,KAAiBC,GAAY,MAAcC,IAAI,GAAG,CAAC;CAO5D,OANAC,QAAgB;EACd,IAAKC,GAEL,OADcA,EAAW,UAAUJ,CAC5B;CACT,GAAG,CAACI,CAAU,CAAC,GAERC,SAAqC;EAC1C,IAAI;EACJ,OAAO;EACP,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAOR,EAAa,SACpBS,IAAUD,GAAM;GACtB,IAAI,CAACA,KAAQ,CAACC,GAAS,OAAO,CAAC;GAG/B,IAAMC,IAAUC,EAAmBC,CAAI,GACjCC,IAAKhB,EAAS,SACdiB,IAAQC,EAAgBL,GAASG,CAAE;GACzC,IAAIC,EAAM,WAAW,GAAG,OAAO,CAAC;GAIhC,IAAME,IAAUC,EAAaJ,EAAG,QAAQK,CAAI,GACtCC,KAAS,MAAmCH,IAAUI,CAAK,KAAK,MAChEC,KAAU,MAAkB;IAChC,IAAMC,IAAWN,IAAUH,EAAG,OAAO,MAAM,MAAMU,EAAE,OAAOH,CAAK,CAAC,EAAE,WAAW,KAAA;IAC7E,OAAOE,IAAWE,EAAmBN,GAAMI,CAAQ,IAAIJ;GACzD,GAKMO,KACJ,GACA,MACkB;IAClB,IAAMC,IAAUC,EAAM,SAASA,EAAM,KAAK,OACtCA,EAAM,OACL;KAAE,GAAGA,EAAM;KAAM,MAAMA,EAAM;IAAK,GACjCC,IAAQT,EAAMQ,EAAM,KAAK,KAAK,GAC9BE,IAAOpB,EAAQiB,GAASC,EAAM,MAAMN,EAAOM,EAAM,KAAK,KAAK,CAAC,GAC5DG,IAA0B,CAAC,GAAGC,EAAqBF,GAAMF,EAAM,IAAe,CAAC;IACrF,KAAK,IAAMK,KAASL,EAAM,UACxB,KAAK,IAAMM,KAAOR,EAAUO,GAAOJ,CAAK,GAAG,EAAS,KAAKK,CAAG;IAE9D,IAAMC,IAAYC,EAAeP,GAAOQ,CAAW,GAC7CC,IAA0BH,IAAY;KAAE,MAAM;KAAS;KAAW;IAAS,IAAI;KAAE,MAAM;KAAS;IAAS;IAC/G,IAAIR,EAAQ,SAAS,aAAa;KAChC,IAAMY,IAAOC,EACXb,GACAC,EAAM,MACN,EAAE,aAAanB,EAAK,gBAAgBkB,GAASC,EAAM,IAAI,KAAK,KAAK,CACnE;KACA,AAAIW,MAAM,EAAM,OAAOA;IACzB;IACA,OAAO,CAACD,CAAK;GACf,GAIMG,IAAyB,CAAC,GAC1BC,IAAyB,CAAC;GAChC,KAAK,IAAMC,KAAQ5B,GAAO;IACxB,IAAM6B,IAAOD,EAAK,SAASD,IAAUD;IACrC,KAAK,IAAMP,KAAOR,EAAUiB,GAAM,IAAI,GAAG,EAAK,KAAKT,CAAG;GACxD;GACA,IAAIO,EAAQ,WAAW,KAAKC,EAAQ,WAAW,GAAG,OAAO,CAAC;GAE1D,IAAMG,IAAqB,CAAC;GAG5B,OAFIH,EAAQ,SAAS,KAAGG,EAAI,KAAK;IAAE,MAAM;IAAS,UAAUH;GAAQ,CAAC,GACjED,EAAQ,SAAS,KAAGI,EAAI,KAAK;IAAE,MAAM;IAAS,OAAOlD;IAAa,UAAU8C;GAAQ,CAAC,GAClFI;EACT;CACF,IAAI,CAAC/C,GAAUG,CAAY,CAAC;AAC9B"}
+{"version":3,"file":"usePreviewGhostLayer.js","names":["mat3","mat3$1","GHOST_ALPHA","usePreviewGhostLayer","args","sceneRef","useLatest","scene","sceneSlotRef","sceneSlot","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","slot","isCustomEntry","drawOne","sources","previewSourcesFrom","data","sc","roots","resolvePreviews","planeOf","scenePlaneOf","view","mapOf","layer","viewOf","parallax","l","deriveParallaxView","drawEntry","effNode","entry","plane","self","children","wrapWithPoseRotation","child","cmd","transform","planeTransform","parentPlane","group","clip","findShapeSilhouette","ghosted","settled","paintedPose","scenePaintedPoseOf","root","sink","cmds","m","copiesAbove","out"],"sources":["../../../src/canvas/SceneCanvas/usePreviewGhostLayer.ts"],"sourcesContent":["/**\n * Preview-ghost render layer for `<SceneCanvas>`. Renders in-flight gesture\n * poses on top of the committed scene by reusing the scene slot's `drawOne`.\n * Which ids are displaced (`previewIds`) and where (`previewPose`) comes from\n * the drawing view's preview sources on the draw envelope: that view's\n * in-flight handles.\n *\n * This replaces the per-tool `drawGhost` fold-in — a single SceneCanvas\n * concern instead of every consumer wiring it.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { type DrawCommand, type GroupDrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\nimport type { Node, Scene } from 'core/scene/types';\nimport { findShapeSilhouette } from '../NodeShape';\nimport { wrapWithPoseRotation } from '../poseRotation';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { previewSourcesFrom } from '../drawEnvelope';\nimport { resolvePreviews, type PreviewNode } from 'interactions/actions/resolvePreviews';\nimport { scenePlaneOf } from '../pickWalk';\nimport { planeTransform } from '../planeClips';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport { mat3 } from '@weasel-js/geom';\nimport { copiesAbove } from '../copiesAbove';\nimport { scenePaintedPoseOf } from '../derivedPath';\n\nconst GHOST_ALPHA = 0.85;\n\nexport function usePreviewGhostLayer<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  sceneSlot: LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n  /**\n   * The surface's dispatcher, subscribed to only so a pump repaints — preview\n   * poses mutate silently inside handles otherwise. What gets *painted* is the\n   * drawing view's own `getPreviewSources()`, off the draw envelope.\n   */\n  dispatcher?: Dispatcher | null;\n}): RenderLayer<unknown> {\n  const { scene, sceneSlot, dispatcher } = args;\n\n  // Refs let the layer body read the last committed scene/slot without\n  // re-creating the layer on every host render.\n  const sceneRef = useLatest(scene);\n  const sceneSlotRef = useLatest(sceneSlot);\n\n  // Subscribe to dispatcher state changes so the canvas re-renders on every\n  // ongoing-action pump (preview poses mutate silently inside handles\n  // otherwise — single-frame ghost stuck on the start pose).\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    const unsub = dispatcher.subscribe(forceRerender);\n    return unsub;\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(() => ({\n    id: 'preview-ghost',\n    label: 'Preview ghost',\n    draw: (data, view) => {\n      const slot = sceneSlotRef.current;\n      if (!slot || isCustomEntry(slot) || !slot.drawOne) return [];\n      const drawOne = slot.drawOne;\n      // Whose gesture this frame is showing belongs to the view being drawn,\n      // not to the surface that built the layer.\n      const sources = previewSourcesFrom(data);\n      const sc = sceneRef.current;\n      const roots = resolvePreviews(sources, sc);\n      if (roots.length === 0) return [];\n\n      // A node on a parallax layer ghosts where its plane draws it: through\n      // the plane's view, inside a group carrying it into its parent's world.\n      const planeOf = scenePlaneOf(sc.layers, view);\n      const mapOf = (layer: string): PlaneMap | null => planeOf?.(layer) ?? null;\n      const viewOf = (layer: string) => {\n        const parallax = planeOf ? sc.layers.find((l) => l.id === layer)?.parallax : undefined;\n        return parallax ? deriveParallaxView(view, parallax) : view;\n      };\n\n      // Mirrors buildSceneTree's structure — a container group carries a clip\n      // from its painter's silhouette — but drawn from the previewed pose and\n      // data, so children are clipped to the shape the container is taking.\n      const drawEntry = (\n        entry: PreviewNode<TData, TLayer, TPose>,\n        parentPlane: PlaneMap | null,\n      ): DrawCommand[] => {\n        const effNode = entry.data === entry.node.data\n          ? entry.node\n          : ({ ...entry.node, data: entry.data } as typeof entry.node);\n        const plane = mapOf(entry.node.layer);\n        const self = drawOne(effNode, entry.pose, viewOf(entry.node.layer));\n        const children: DrawCommand[] = [...wrapWithPoseRotation(self, entry.pose as unknown)];\n        for (const child of entry.children) {\n          for (const cmd of drawEntry(child, plane)) children.push(cmd);\n        }\n        const transform = planeTransform(plane, parentPlane);\n        const group: GroupDrawCommand = transform ? { kind: 'group', transform, children } : { kind: 'group', children };\n        if (effNode.kind === 'container') {\n          const clip = findShapeSilhouette(\n            effNode as unknown as Node<unknown, string, TPose>,\n            entry.pose,\n            { derivedPath: slot.derivedPathOf?.(effNode, entry.pose) ?? null },\n          );\n          if (clip) group.clip = clip;\n        }\n        return [group];\n      };\n\n      // Opaque is honored at subtree-root granularity, as it always was: a\n      // sibling reflowing into place brings its own contents with it.\n      const ghosted: DrawCommand[] = [];\n      const settled: DrawCommand[] = [];\n      // A node an ancestor draws copies of is ghosted in each copy too, or\n      // the copies vanish for the length of the gesture.\n      const paintedPose = scenePaintedPoseOf(sc);\n      for (const root of roots) {\n        const sink = root.opaque ? settled : ghosted;\n        const cmds = drawEntry(root, null);\n        for (const cmd of cmds) sink.push(cmd);\n        for (const m of copiesAbove(sc, root.node.id, paintedPose)) {\n          sink.push({ kind: 'group', transform: mat3.fromAffine(m), children: cmds });\n        }\n      }\n      if (ghosted.length === 0 && settled.length === 0) return [];\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      const out: DrawCommand[] = [];\n      if (settled.length > 0) out.push({ kind: 'group', children: settled });\n      if (ghosted.length > 0) out.push({ kind: 'group', alpha: GHOST_ALPHA, children: ghosted });\n      return out;\n    },\n  }), [sceneRef, sceneSlotRef]);\n}\n"],"mappings":";;;;;;;;;;;;;;;AA6BA,IAAME,IAAc;AAEpB,SAAgBC,EAA0D,GASjD;CACvB,IAAM,EAAE,UAAO,cAAW,kBAAeC,GAInCC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAKlC,GAAGC,KAAiBC,GAAY,MAAcC,IAAI,GAAG,CAAC;CAO5D,OANAC,QAAgB;EACd,IAAKC,GAEL,OADcA,EAAW,UAAUJ,CAC5B;CACT,GAAG,CAACI,CAAU,CAAC,GAERC,SAAqC;EAC1C,IAAI;EACJ,OAAO;EACP,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAOR,EAAa;GAC1B,IAAI,CAACQ,KAAQC,EAAcD,CAAI,KAAK,CAACA,EAAK,SAAS,OAAO,CAAC;GAC3D,IAAME,IAAUF,EAAK,SAGfG,IAAUC,EAAmBC,CAAI,GACjCC,IAAKjB,EAAS,SACdkB,IAAQC,EAAgBL,GAASG,CAAE;GACzC,IAAIC,EAAM,WAAW,GAAG,OAAO,CAAC;GAIhC,IAAME,IAAUC,EAAaJ,EAAG,QAAQK,CAAI,GACtCC,KAAS,MAAmCH,IAAUI,CAAK,KAAK,MAChEC,KAAU,MAAkB;IAChC,IAAMC,IAAWN,IAAUH,EAAG,OAAO,MAAM,MAAMU,EAAE,OAAOH,CAAK,CAAC,EAAE,WAAW,KAAA;IAC7E,OAAOE,IAAWE,EAAmBN,GAAMI,CAAQ,IAAIJ;GACzD,GAKMO,KACJ,GACA,MACkB;IAClB,IAAMC,IAAUC,EAAM,SAASA,EAAM,KAAK,OACtCA,EAAM,OACL;KAAE,GAAGA,EAAM;KAAM,MAAMA,EAAM;IAAK,GACjCC,IAAQT,EAAMQ,EAAM,KAAK,KAAK,GAC9BE,IAAOpB,EAAQiB,GAASC,EAAM,MAAMN,EAAOM,EAAM,KAAK,KAAK,CAAC,GAC5DG,IAA0B,CAAC,GAAGC,EAAqBF,GAAMF,EAAM,IAAe,CAAC;IACrF,KAAK,IAAMK,KAASL,EAAM,UACxB,KAAK,IAAMM,KAAOR,EAAUO,GAAOJ,CAAK,GAAG,EAAS,KAAKK,CAAG;IAE9D,IAAMC,IAAYC,EAAeP,GAAOQ,CAAW,GAC7CC,IAA0BH,IAAY;KAAE,MAAM;KAAS;KAAW;IAAS,IAAI;KAAE,MAAM;KAAS;IAAS;IAC/G,IAAIR,EAAQ,SAAS,aAAa;KAChC,IAAMY,IAAOC,EACXb,GACAC,EAAM,MACN,EAAE,aAAapB,EAAK,gBAAgBmB,GAASC,EAAM,IAAI,KAAK,KAAK,CACnE;KACA,AAAIW,MAAM,EAAM,OAAOA;IACzB;IACA,OAAO,CAACD,CAAK;GACf,GAIMG,IAAyB,CAAC,GAC1BC,IAAyB,CAAC,GAG1BC,IAAcC,EAAmB9B,CAAE;GACzC,KAAK,IAAM+B,KAAQ9B,GAAO;IACxB,IAAM+B,IAAOD,EAAK,SAASH,IAAUD,GAC/BM,IAAOrB,EAAUmB,GAAM,IAAI;IACjC,KAAK,IAAMX,KAAOa,GAAM,EAAK,KAAKb,CAAG;IACrC,KAAK,IAAMc,KAAKC,EAAYnC,GAAI+B,EAAK,KAAK,IAAIF,CAAW,GACvD,EAAK,KAAK;KAAE,MAAM;KAAS,WAAWnD,EAAK,WAAWwD,CAAC;KAAG,UAAUD;IAAK,CAAC;GAE9E;GACA,IAAIN,EAAQ,WAAW,KAAKC,EAAQ,WAAW,GAAG,OAAO,CAAC;GAE1D,IAAMQ,IAAqB,CAAC;GAG5B,OAFIR,EAAQ,SAAS,KAAGQ,EAAI,KAAK;IAAE,MAAM;IAAS,UAAUR;GAAQ,CAAC,GACjED,EAAQ,SAAS,KAAGS,EAAI,KAAK;IAAE,MAAM;IAAS,OAAOxD;IAAa,UAAU+C;GAAQ,CAAC,GAClFS;EACT;CACF,IAAI,CAACrD,GAAUG,CAAY,CAAC;AAC9B"}

package/dist/canvas/SceneCanvas/useSceneCanvasHandle.js

@@ -0,0 +1,47 @@
+import { useOptionalViewRegistry as e } from "../viewRegistry.js";
+import { useCallback as t, useState as n } from "react";
+import { assignRef as r } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useSceneCanvasHandle.ts
+function i() {
+	let r = e(), [i, a] = n([]);
+	return {
+		views: i,
+		addView: t((e) => (a((t) => [...t.filter((t) => t.id !== e.id), e]), {
+			id: e.id,
+			draw: (t, n, i) => r?.list().find((t) => t.id === e.id)?.layer.draw(t, n, i) ?? [],
+			remove: () => a((t) => t.filter((t) => t !== e))
+		}), [r])
+	};
+}
+function a(e) {
+	let { ref: i, elementRef: a, apiRef: o, onElement: s, ingest: c, viewAnimation: l, camera: u, addView: d } = e, [f, p] = n(!1);
+	return {
+		handleRef: t((e) => {
+			a.current = e?.element ?? null, s(a.current);
+			let t = e ? {
+				...e,
+				ingest: c,
+				animateView: l.animate,
+				stopViewAnimation: l.stop,
+				isViewAnimating: l.isAnimating,
+				camera: u,
+				addView: d
+			} : null;
+			o.current = t, p(t !== null), r(i, t);
+		}, [
+			i,
+			a,
+			o,
+			c,
+			l,
+			u,
+			d,
+			s
+		]),
+		ready: f
+	};
+}
+//#endregion
+export { i as useAddedViews, a as useSceneCanvasHandle };
+
+//# sourceMappingURL=useSceneCanvasHandle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneCanvasHandle.js","names":["useAddedViews","surfaceViewRegistry","useOptionalViewRegistry","views","setViews","useState","useCallback","list","v","props","r","data","outer","dims","useSceneCanvasHandle","args","ready","setReady","node","onElement","elementRef","extended","viewAnimation","assignRef","ref","apiRef","ingest","camera","addView"],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasHandle.ts"],"sourcesContent":["import { useCallback, useState, type ForwardedRef, type MutableRefObject } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { CanvasViewProps } from '../CanvasView';\nimport type { CanvasExtensionApi, CanvasViewHandle, SceneCanvasApi } from '../canvasExtension';\nimport { useOptionalViewRegistry } from '../viewRegistry';\n\n/** Views added through the handle rather than declared as props or children. */\nexport function useAddedViews(): {\n  views: readonly CanvasViewProps[];\n  addView: SceneCanvasApi['addView'];\n} {\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  const [views, setViews] = useState<readonly CanvasViewProps[]>([]);\n  const addView = useCallback((props: CanvasViewProps): CanvasViewHandle => {\n    setViews((list) => [...list.filter((v) => v.id !== props.id), props]);\n    return {\n      id: props.id,\n      draw: (data, outer, dims) =>\n        surfaceViewRegistry?.list().find((r) => r.id === props.id)?.layer.draw(data, outer, dims) ?? [],\n      remove: () => setViews((list) => list.filter((v) => v !== props)),\n    };\n  }, [surfaceViewRegistry]);\n  return { views, addView };\n}\n\n/**\n * The ref callback `<SceneCanvas>` hands `<Canvas>`. It extends the\n * primitive's handle into the `SceneCanvasApi` the consumer's ref receives,\n * and keeps the canvas's own copies of the element and the handle current.\n */\nexport function useSceneCanvasHandle(args: {\n  ref: ForwardedRef<SceneCanvasApi>;\n  /** Written with the canvas element, for the input listeners. */\n  elementRef: MutableRefObject<HTMLElement | null>;\n  /** Written with the extended handle, for `requestRedraw` and point conversion. */\n  apiRef: MutableRefObject<CanvasExtensionApi | null>;\n  /** Told the element whenever it attaches or detaches. */\n  onElement: (element: HTMLElement | null) => void;\n  ingest: SceneCanvasApi['ingest'];\n  viewAnimation: Pick<ViewAnimationApi, 'animate' | 'stop' | 'isAnimating'>;\n  camera: SceneCanvasApi['camera'];\n  addView: SceneCanvasApi['addView'];\n}): {\n  handleRef: (node: CanvasExtensionApi | null) => void;\n  /** Whether the handle is attached, as state: an effect needing the handle\n   *  keys off this instead of assuming when React attaches it. */\n  ready: boolean;\n} {\n  const { ref, elementRef, apiRef, onElement, ingest, viewAnimation, camera, addView } = args;\n  const [ready, setReady] = useState(false);\n  const handleRef = useCallback(\n    (node: CanvasExtensionApi | null) => {\n      elementRef.current = node?.element ?? null;\n      onElement(elementRef.current);\n      const extended: SceneCanvasApi | null = node\n        ? {\n            ...node,\n            ingest,\n            animateView: viewAnimation.animate,\n            stopViewAnimation: viewAnimation.stop,\n            isViewAnimating: viewAnimation.isAnimating,\n            camera,\n            addView,\n          }\n        : null;\n      apiRef.current = extended;\n      setReady(extended !== null);\n      assignRef(ref, extended);\n    },\n    [ref, elementRef, apiRef, ingest, viewAnimation, camera, addView, onElement],\n  );\n  return { handleRef, ready };\n}\n"],"mappings":";;;;AAQA,SAAgBA,IAGd;CACA,IAAMC,IAAsBC,EAAwB,GAC9C,CAACC,GAAOC,KAAYC,EAAqC,CAAC,CAAC;CAUjE,OAAO;EAAE;EAAO,SATAC,GAAa,OAC3BF,GAAU,MAAS,CAAC,GAAGG,EAAK,QAAQ,MAAMC,EAAE,OAAOC,EAAM,EAAE,GAAGA,CAAK,CAAC,GAC7D;GACL,IAAIA,EAAM;GACV,OAAO,GAAM,GAAO,MAClBR,GAAqB,KAAK,CAAC,CAAC,MAAM,MAAMS,EAAE,OAAOD,EAAM,EAAE,CAAC,EAAE,MAAM,KAAKE,GAAMC,GAAOC,CAAI,KAAK,CAAC;GAChG,cAAcT,GAAU,MAASG,EAAK,QAAQ,MAAMC,MAAMC,CAAK,CAAC;EAClE,IACC,CAACR,CAAmB,CACP;CAAQ;AAC1B;AAOA,SAAgBa,EAAqB,GAiBnC;CACA,IAAM,EAAE,QAAK,eAAY,WAAQ,cAAW,WAAQ,kBAAe,WAAQ,eAAYC,GACjF,CAACC,GAAOC,KAAYZ,EAAS,EAAK;CAsBxC,OAAO;EAAE,WArBSC,GACf,MAAoC;GAEnC,AADA,EAAW,UAAUY,GAAM,WAAW,MACtCC,EAAUC,EAAW,OAAO;GAC5B,IAAMC,IAAkCH,IACpC;IACE,GAAGA;IACH;IACA,aAAaI,EAAc;IAC3B,mBAAmBA,EAAc;IACjC,iBAAiBA,EAAc;IAC/B;IACA;GACF,IACA;GAGJ,AAFA,EAAO,UAAUD,GACjBJ,EAASI,MAAa,IAAI,GAC1BE,EAAUC,GAAKH,CAAQ;EACzB,GACA;GAACG;GAAKJ;GAAYK;GAAQC;GAAQJ;GAAeK;GAAQC;GAAST;EAAS,CAEpE;EAAW;CAAM;AAC5B"}

package/dist/canvas/SceneCanvas/useSceneCanvasLayers.js

@@ -0,0 +1,66 @@
+import { usePathEditOverlayLayer as e } from "../../features/paths/usePathEdit.js";
+import { builtLayersOf as t } from "../layerSlots.js";
+import { mergeLayersWithDefaults as n } from "./props.js";
+import { createSlopsDebugLayer as r } from "../slopsDebugLayer.js";
+import { useDispatcherOverlayLayer as i } from "./useDispatcherOverlayLayer.js";
+import { usePreviewGhostLayer as a } from "./usePreviewGhostLayer.js";
+import { useSceneSlotLayers as o } from "./useSceneSlotLayers.js";
+import { useSelectionOverlayLayer as s } from "./useSelectionOverlayLayer.js";
+import { useMemo as c, useRef as l } from "react";
+//#region src/canvas/SceneCanvas/useSceneCanvasLayers.ts
+function u(u) {
+	let { scene: d, adapter: f, poseDescriptor: p, alphaFor: m, dispatcher: h, pathEditState: g, slops: _, targetScale: v } = u, y = c(() => n(u.layers, v), [u.layers, v]), { config: b, layers: x } = o({
+		slot: y.scene,
+		scene: d,
+		adapter: f,
+		alphaFor: m,
+		colorOverrides: u.colorOverrides,
+		boundsOf: u.boundsOf,
+		previewIds: u.previewIds
+	}), S = a({
+		scene: d,
+		sceneSlot: b,
+		dispatcher: h
+	}), C = i({ dispatcher: h }), w = l([]), T = c(() => r({ getAffordances: () => w.current }), []), E = e(g, {
+		nodeOf: (e) => d.get(e),
+		planeOfNode: u.planeOfNode
+	}), { layer: D, rotationBadge: O } = s(y.selectionOverlay, g.getEditingIds, p);
+	return {
+		layers: c(() => ({
+			...t(y),
+			scene: x,
+			selectionOverlay: D ? { layer: D } : null,
+			previewGhost: {
+				layer: S,
+				after: "scene"
+			},
+			dispatcherOverlay: {
+				layer: C,
+				after: "previewGhost"
+			},
+			pathEditingOverlay: {
+				layer: E,
+				after: "selectionOverlay"
+			},
+			..._ ? { slopsDebug: {
+				layer: T,
+				after: "pathEditingOverlay"
+			} } : {}
+		}), [
+			y,
+			x,
+			D,
+			S,
+			C,
+			E,
+			_,
+			T
+		]),
+		rotationBadge: O,
+		chromeAffordancesRef: w
+	};
+}
+//#endregion
+export { u as useSceneCanvasLayers };
+
+//# sourceMappingURL=useSceneCanvasLayers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneCanvasLayers.js","names":["useSceneCanvasLayers","args","merged","useMemo","mergeLayersWithDefaults","targetScale","sceneSlot","sceneLayers","useSceneSlotLayers","previewLayer","usePreviewGhostLayer","dispatcherOverlay","useDispatcherOverlayLayer","chromeAffordancesRef","useRef","slopsLayer","createSlopsDebugLayer","pathEditingOverlayLayer","usePathEditOverlayLayer","pathEditState","scene","id","selectionOverlayLayer","useSelectionOverlayLayer","poseDescriptor","builtLayersOf","slops"],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasLayers.ts"],"sourcesContent":["import { useMemo, useRef, type MutableRefObject } from 'react';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport type { Affordance } from 'affordances/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport type { PathEditState } from 'features/paths/pathEditState';\nimport { usePathEditOverlayLayer } from 'features/paths/usePathEdit';\nimport type { rotationBadgeOf } from 'features/selection/overlay';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { HierarchicalAdapter } from '../buildSceneTree';\nimport { builtLayersOf, type CanvasLayers } from '../layerSlots';\nimport { createSlopsDebugLayer } from '../slopsDebugLayer';\nimport { mergeLayersWithDefaults, type SceneCanvasLayers } from './props';\nimport { useDispatcherOverlayLayer } from './useDispatcherOverlayLayer';\nimport { usePreviewGhostLayer } from './usePreviewGhostLayer';\nimport { useSceneSlotLayers } from './useSceneSlotLayers';\nimport { useSelectionOverlayLayer } from './useSelectionOverlayLayer';\n\n/**\n * The layer map `<SceneCanvas>` hands `<Canvas>`: the caller's `layers` over\n * the kit defaults, with the scene and selection-overlay slots built, and the\n * canvas's own layers anchored around them. The preview ghost sits above the\n * scene, the dispatcher's overlay (marquee, lasso) above the ghost, and the\n * anchor overlay above the selection chrome.\n */\nexport function useSceneCanvasLayers<TData, TLayer extends string, TPose>(args: {\n  /** `<SceneCanvas layers>`. Omitted, the result is the full default set. */\n  layers: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined;\n  /** The device profile's, which sizes the default handles. */\n  targetScale: number;\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n  poseDescriptor: PoseDescriptor<TPose>;\n  alphaFor: ((id: string) => number) | undefined;\n  colorOverrides: ColorOverrideRegistry | undefined;\n  boundsOf: (id: string) => Bounds | null;\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n  /** Ids an in-flight gesture is ghosting. */\n  previewIds: () => Iterable<string> | null;\n  dispatcher: Dispatcher;\n  pathEditState: PathEditState;\n  /** `debug.slops`: paint the hit regions of the chrome affordances. */\n  slops: boolean;\n}): {\n  layers: CanvasLayers;\n  /** Where the selection overlay paints its rotate badge, or null. */\n  rotationBadge: ReturnType<typeof rotationBadgeOf>;\n  /** The affordances the gesture mounter hit-tests, which it publishes here\n   *  so the slops halos are the hit regions rather than a copy of them. */\n  chromeAffordancesRef: MutableRefObject<readonly Affordance[]>;\n} {\n  const { scene, adapter, poseDescriptor, alphaFor, dispatcher, pathEditState, slops, targetScale } = args;\n\n  const merged = useMemo(\n    () => mergeLayersWithDefaults(args.layers, targetScale),\n    [args.layers, targetScale],\n  );\n\n  const { config: sceneSlot, layers: sceneLayers } = useSceneSlotLayers({\n    slot: merged.scene,\n    scene,\n    adapter,\n    alphaFor,\n    colorOverrides: args.colorOverrides,\n    boundsOf: args.boundsOf,\n    previewIds: args.previewIds,\n  });\n  // Takes the scene-wired slot, so a ghosted derived node still resolves its path.\n  const previewLayer = usePreviewGhostLayer<TData, TLayer, TPose>({ scene, sceneSlot, dispatcher });\n  const dispatcherOverlay = useDispatcherOverlayLayer({ dispatcher });\n\n  const chromeAffordancesRef = useRef<readonly Affordance[]>([]);\n  const slopsLayer = useMemo(\n    () => createSlopsDebugLayer({ getAffordances: () => chromeAffordancesRef.current }),\n    [],\n  );\n\n  const pathEditingOverlayLayer = usePathEditOverlayLayer(pathEditState, {\n    nodeOf: (id) => scene.get(id as NodeId),\n    planeOfNode: args.planeOfNode,\n  });\n\n  const { layer: selectionOverlayLayer, rotationBadge } = useSelectionOverlayLayer<TPose>(\n    merged.selectionOverlay,\n    pathEditState.getEditingIds,\n    poseDescriptor,\n  );\n\n  const layers = useMemo<CanvasLayers>(() => ({\n    ...builtLayersOf(merged),\n    scene: sceneLayers,\n    selectionOverlay: selectionOverlayLayer ? { layer: selectionOverlayLayer } : null,\n    previewGhost: { layer: previewLayer, after: 'scene' },\n    dispatcherOverlay: { layer: dispatcherOverlay, after: 'previewGhost' },\n    pathEditingOverlay: { layer: pathEditingOverlayLayer, after: 'selectionOverlay' },\n    ...(slops ? { slopsDebug: { layer: slopsLayer, after: 'pathEditingOverlay' } } : {}),\n  }), [merged, sceneLayers, selectionOverlayLayer, previewLayer, dispatcherOverlay, pathEditingOverlayLayer, slops, slopsLayer]);\n\n  return { layers, rotationBadge, chromeAffordancesRef };\n}\n"],"mappings":";;;;;;;;;;AA4BA,SAAgBA,EAA0D,GAyBxE;CACA,IAAM,EAAE,UAAO,YAAS,mBAAgB,aAAU,eAAY,kBAAe,UAAO,mBAAgBC,GAE9FC,IAASC,QACPC,EAAwBH,EAAK,QAAQI,CAAW,GACtD,CAACJ,EAAK,QAAQI,CAAW,CAC3B,GAEM,EAAE,QAAQC,GAAW,QAAQC,MAAgBC,EAAmB;EACpE,MAAMN,EAAO;EACb;EACA;EACA;EACA,gBAAgBD,EAAK;EACrB,UAAUA,EAAK;EACf,YAAYA,EAAK;CACnB,CAAC,GAEKQ,IAAeC,EAA2C;EAAE;EAAO;EAAW;CAAW,CAAC,GAC1FC,IAAoBC,EAA0B,EAAE,cAAW,CAAC,GAE5DC,IAAuBC,EAA8B,CAAC,CAAC,GACvDC,IAAaZ,QACXa,EAAsB,EAAE,sBAAsBH,EAAqB,QAAQ,CAAC,GAClF,CAAC,CACH,GAEMI,IAA0BC,EAAwBC,GAAe;EACrE,SAAS,MAAOC,EAAM,IAAIC,CAAY;EACtC,aAAapB,EAAK;CACpB,CAAC,GAEK,EAAE,OAAOqB,GAAuB,qBAAkBC,EACtDrB,EAAO,kBACPiB,EAAc,eACdK,CACF;CAYA,OAAO;EAAE,QAVMrB,SAA6B;GAC1C,GAAGsB,EAAcvB,CAAM;GACvB,OAAOK;GACP,kBAAkBe,IAAwB,EAAE,OAAOA,EAAsB,IAAI;GAC7E,cAAc;IAAE,OAAOb;IAAc,OAAO;GAAQ;GACpD,mBAAmB;IAAE,OAAOE;IAAmB,OAAO;GAAe;GACrE,oBAAoB;IAAE,OAAOM;IAAyB,OAAO;GAAmB;GAChF,GAAIS,IAAQ,EAAE,YAAY;IAAE,OAAOX;IAAY,OAAO;GAAqB,EAAE,IAAI,CAAC;EACpF,IAAI;GAACb;GAAQK;GAAae;GAAuBb;GAAcE;GAAmBM;GAAyBS;GAAOX;EAAU,CAEnH;EAAQ;EAAe;CAAqB;AACvD"}

package/dist/canvas/SceneCanvas/useSceneChrome.js

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

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

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

package/dist/canvas/SceneCanvas/useSceneRedrawSources.js

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

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

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