@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js

@@ -1,9 +1,9 @@
 import { viewToTransform as e } from "../../core/viewport/view.js";
 import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
-import { getImageBitmap as n } from "../../features/images/imageCache.js";
-import { OVERLAY_ROLE_STROKES as r } from "../overlayRoleStrokes.js";
-import { gestureOverlaysFrom as i, isVisibleFrom as a } from "../drawEnvelope.js";
-import { resolveOverlays as o } from "../../interactions/actions/resolveOverlays.js";
+import { OVERLAY_ROLE_STROKES as n } from "../overlayRoleStrokes.js";
+import { gestureOverlaysFrom as r, isVisibleFrom as i } from "../drawEnvelope.js";
+import { resolveOverlays as a } from "../../interactions/actions/resolveOverlays.js";
+import { getImageBitmap as o } from "@weasel-js/renderer";
 import { ellipsePath as s, linePath as c, polygonFromPoints as l, polylineFromPoints as u, rectPath as d, regularPolygonPath as f, starPath as p } from "@weasel-js/geom";
 import { useEffect as m, useMemo as h, useReducer as g } from "react";
 import { useLatest as _ } from "@weasel-js/react";
@@ -27,10 +27,10 @@ function b(b) {
 				...v,
 				...C.current ?? {}
 			}, _ = {
-				...r,
+				...n,
 				...C.current?.roles ?? {}
-			}, b = e(h), x = [], S = a(m), w = (e) => !S || S(e);
-			for (let e of o(i(m))) if (w(e.visibilityId)) {
+			}, b = e(h), x = [], S = i(m), w = (e) => !S || S(e);
+			for (let e of a(r(m))) if (w(e.visibilityId)) {
 				if (e.kind === "marquee") {
 					let n = e.bounds, [r, i] = t(n.x, n.y, b), a = {
 						kind: "path",
@@ -41,7 +41,7 @@ function b(b) {
 							width: n.width * h.scale.x,
 							height: n.height * h.scale.y
 						},
-						fill: { color: g.fill },
+						fill: { paint: { color: g.fill } },
 						stroke: {
 							paint: { color: g.stroke },
 							width: g.lineWidth,
@@ -52,52 +52,52 @@ function b(b) {
 					continue;
 				}
 				if (e.kind === "insertPreview") {
-					let r = e.bounds, i = (e, n) => {
+					let n = e.bounds, r = (e, n) => {
 						let [r, i] = t(e, n, b);
 						return {
 							x: r,
 							y: i
 						};
-					}, a = (e) => e.map((e) => i(e.x, e.y)), o = (h.scale.x + h.scale.y) / 2, l = null, m = e.geometry;
+					}, i = (e) => e.map((e) => r(e.x, e.y)), a = (h.scale.x + h.scale.y) / 2, l = null, m = e.geometry;
 					switch (m.kind) {
 						case "box": {
-							let [i, a] = t(r.x, r.y, b), o = r.width * h.scale.x, c = r.height * h.scale.y;
+							let [r, i] = t(n.x, n.y, b), a = n.width * h.scale.x, c = n.height * h.scale.y;
 							if (e.shape === "image") {
-								let t = e.extras, r = t.preview === "outline" || !t.src ? void 0 : n(t.src);
-								r && x.push({
+								let t = e.extras, n = t.preview === "outline" || !t.src ? void 0 : o(t.src);
+								n && x.push({
 									kind: "image",
-									image: r,
-									x: i,
-									y: a,
-									w: o,
+									image: n,
+									x: r,
+									y: i,
+									w: a,
 									h: c,
 									opacity: y
 								});
 							}
 							l = e.shape === "ellipse" ? s({
-								x: i,
-								y: a,
-								width: o,
+								x: r,
+								y: i,
+								width: a,
 								height: c
-							}) : d(i, a, o, c);
+							}) : d(r, i, a, c);
 							break;
 						}
 						case "line":
-							l = c(i(m.a.x, m.a.y), i(m.b.x, m.b.y));
+							l = c(r(m.a.x, m.a.y), r(m.b.x, m.b.y));
 							break;
 						case "polygon":
-							l = f(i(m.center.x, m.center.y), m.radius * o, m.sides, m.rotation);
+							l = f(r(m.center.x, m.center.y), m.radius * a, m.sides, m.rotation);
 							break;
 						case "star":
-							l = p(i(m.center.x, m.center.y), m.outerRadius * o, m.points, m.innerRadius * o, m.rotation);
+							l = p(r(m.center.x, m.center.y), m.outerRadius * a, m.points, m.innerRadius * a, m.rotation);
 							break;
-						case "pencil": l = u(a(m.samples));
+						case "pencil": l = u(i(m.samples));
 					}
 					if (!l) continue;
 					let _ = {
 						kind: "path",
 						path: l,
-						fill: e.shape === "line" || e.shape === "pencil" || e.shape === "image" ? void 0 : { color: g.fill },
+						fill: e.shape === "line" || e.shape === "pencil" || e.shape === "image" ? void 0 : { paint: { color: g.fill } },
 						stroke: {
 							paint: { color: g.stroke },
 							width: g.lineWidth,
@@ -105,7 +105,7 @@ function b(b) {
 						}
 					};
 					if (x.push(_), e.anchorPoint) {
-						let t = i(e.anchorPoint.x, e.anchorPoint.y);
+						let t = r(e.anchorPoint.x, e.anchorPoint.y);
 						x.push({
 							kind: "path",
 							path: s({
@@ -114,7 +114,7 @@ function b(b) {
 								width: 8,
 								height: 8
 							}),
-							fill: { color: g.stroke }
+							fill: { paint: { color: g.stroke } }
 						});
 					}
 					continue;
@@ -131,7 +131,7 @@ function b(b) {
 					let r = {
 						kind: "path",
 						path: l(n),
-						fill: { color: g.fill },
+						fill: { paint: { color: g.fill } },
 						stroke: {
 							paint: { color: g.stroke },
 							width: g.lineWidth,

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

@@ -1 +1 @@
-{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","PREVIEW_CONTENT_OPACITY","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","projectPoint","wx","wy","projectPoints","pts","p","radialScale","pathCmd","geom","sw","sh","e","bmp","getImageBitmap","ellipsePath","rectPath","linePath","regularPolygonPath","starPath","polylineFromPoints","anchorScreen","screenPts","v","polygonFromPoints","stroke","pt"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading — normalizing the drag,\n * sizing the nascent shape, dropping what is degenerate — and everything left\n * here is painting: projection into screen coordinates, the chrome-caps gate,\n * fill/stroke policy, the stroke each overlay role reads as, the anchor dot's\n * size, and the image bitmap.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes via `previewIds()` / `previewPose(id)`. The dispatcher\n * overlay layer is for gestures whose visual feedback isn't a moved scene\n * node — marquee rect (area-select), polyline + dashed close-line (lasso),\n * and any future overlay-only chrome an action wants to render.\n *\n * Replaces the per-tool `select-overlay` rendering for the same gestures\n * once the dispatcher path is the sole driver. Until\n * then both run side-by-side; the visuals overlap exactly so the\n * user-visible result is identical.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '../../renderer';\nimport type { Stroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport {\n  polygonFromPoints,\n  polylineFromPoints,\n  rectPath,\n  ellipsePath,\n  linePath,\n  regularPolygonPath,\n  starPath,\n} from '@weasel-js/geom';\nimport { getImageBitmap } from 'features/images/imageCache';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints.\n *  Defaults match the legacy `useSelectTool` `areaSelectOverlayStyle`\n *  defaults so the visual swap is invisible to users. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, Stroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n/** Alpha for content previewed inside an in-flight gesture. Matches the\n *  preview-ghost layer, so a dragged node and an uncommitted insert read as\n *  equally provisional. */\nconst PREVIEW_CONTENT_OPACITY = 0.85;\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Mirrors `composeAffordanceLayer` /\n        // `createSelectionOverlayLayer`: pull a visibility predicate off\n        // the data envelope and consult it per overlay before pushing draw\n        // commands. Absent envelope → every overlay paints. This stays on the\n        // painting side: the predicate is a property of the view's envelope,\n        // and two views of one surface may answer differently for the same\n        // in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            const b = ov.bounds;\n            const projectPoint = (wx: number, wy: number): { x: number; y: number } => {\n              const [sx, sy] = worldToScreen(wx, wy, t);\n              return { x: sx, y: sy };\n            };\n            const projectPoints = (\n              pts: ReadonlyArray<{ x: number; y: number }>,\n            ): { x: number; y: number }[] => pts.map((p) => projectPoint(p.x, p.y));\n            // Radial shapes inscribe in a square, so a single screen-space\n            // radius needs one scale factor; average the axes.\n            const radialScale = (view.scale.x + view.scale.y) / 2;\n\n            let pathCmd: PathDrawCommand['path'] | null = null;\n            const geom = ov.geometry;\n            switch (geom.kind) {\n              case 'box': {\n                const [sx, sy] = worldToScreen(b.x, b.y, t);\n                const sw = b.width * view.scale.x;\n                const sh = b.height * view.scale.y;\n                if (ov.shape === 'image') {\n                  const e = ov.extras as Partial<{ src: string; preview: string }>;\n                  // The bitmap when it has decoded, the bare outline until then\n                  // (or when the tool opted out) — the outline is drawn either\n                  // way, so the drag always has an edge to read.\n                  const bmp = e.preview === 'outline' || !e.src\n                    ? undefined\n                    : getImageBitmap(e.src);\n                  if (bmp) {\n                    out.push({\n                      kind: 'image',\n                      image: bmp,\n                      x: sx, y: sy, w: sw, h: sh,\n                      opacity: PREVIEW_CONTENT_OPACITY,\n                    });\n                  }\n                }\n                pathCmd = ov.shape === 'ellipse'\n                  ? ellipsePath({ x: sx, y: sy, width: sw, height: sh })\n                  : rectPath(sx, sy, sw, sh);\n                break;\n              }\n              case 'line':\n                pathCmd = linePath(projectPoint(geom.a.x, geom.a.y), projectPoint(geom.b.x, geom.b.y));\n                break;\n              case 'polygon':\n                pathCmd = regularPolygonPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.radius * radialScale,\n                  geom.sides,\n                  geom.rotation,\n                );\n                break;\n              case 'star':\n                pathCmd = starPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.outerRadius * radialScale,\n                  geom.points,\n                  geom.innerRadius * radialScale,\n                  geom.rotation,\n                );\n                break;\n              case 'pencil':\n                // Genuinely open: `polygonFromPoints` closes the path, and the\n                // closing edge from the last sample back to the first reads as\n                // a marquee rather than as the stroke being drawn.\n                pathCmd = polylineFromPoints(projectPoints(geom.samples));\n                break;\n            }\n\n            if (!pathCmd) continue;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: pathCmd,\n              fill: ov.shape === 'line' || ov.shape === 'pencil' || ov.shape === 'image'\n                ? undefined\n                : { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            // Anchor dot at the drag's click point. Sells the anchoring\n            // visually for radial shapes (polygon/star — no vertex sits\n            // at the AABB corner) and for center mode (dot marks the\n            // growth axis). 4 CSS-px radius, same stroke color as the\n            // ghost so it reads as part of the chrome.\n            if (ov.anchorPoint) {\n              const anchorScreen = projectPoint(ov.anchorPoint.x, ov.anchorPoint.y);\n              out.push({\n                kind: 'path',\n                path: ellipsePath({\n                  x: anchorScreen.x - 4,\n                  y: anchorScreen.y - 4,\n                  width: 8,\n                  height: 8,\n                }),\n                fill: { color: cfg.stroke },\n              });\n            }\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // Project every vertex to screen coords; build a single polygon\n            // path. The polygon already closes (polygonFromPoints adds Z),\n            // which renders as the dashed \"close-line\" implicit in the\n            // legacy hook's visual. Fill paints the would-be selection\n            // region; stroke paints the polyline + close-line.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        // Screen-space layer: emit commands directly. The worldToScreen\n        // projection above has already mapped every coord into CSS pixels.\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","PREVIEW_CONTENT_OPACITY","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","projectPoint","wx","wy","projectPoints","pts","p","radialScale","pathCmd","geom","sw","sh","e","bmp","getImageBitmap","ellipsePath","rectPath","linePath","regularPolygonPath","starPath","polylineFromPoints","anchorScreen","screenPts","v","polygonFromPoints","stroke","pt"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading; everything here is\n * painting.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes. This layer is for gestures whose visual feedback isn't a moved\n * scene node — a marquee rect, a lasso polyline, an insert preview.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport {\n  polygonFromPoints,\n  polylineFromPoints,\n  rectPath,\n  ellipsePath,\n  linePath,\n  regularPolygonPath,\n  starPath,\n} from '@weasel-js/geom';\nimport { getImageBitmap } from '@weasel-js/renderer';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n/** Alpha for content previewed inside an in-flight gesture. Matches the\n *  preview-ghost layer, so a dragged node and an uncommitted insert read as\n *  equally provisional. */\nconst PREVIEW_CONTENT_OPACITY = 0.85;\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Absent envelope → every overlay paints. This stays\n        // on the painting side: the predicate is a property of the view's\n        // envelope, and two views of one surface may answer differently for\n        // the same in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            const b = ov.bounds;\n            const projectPoint = (wx: number, wy: number): { x: number; y: number } => {\n              const [sx, sy] = worldToScreen(wx, wy, t);\n              return { x: sx, y: sy };\n            };\n            const projectPoints = (\n              pts: ReadonlyArray<{ x: number; y: number }>,\n            ): { x: number; y: number }[] => pts.map((p) => projectPoint(p.x, p.y));\n            // Radial shapes inscribe in a square, so a single screen-space\n            // radius needs one scale factor; average the axes.\n            const radialScale = (view.scale.x + view.scale.y) / 2;\n\n            let pathCmd: PathDrawCommand['path'] | null = null;\n            const geom = ov.geometry;\n            switch (geom.kind) {\n              case 'box': {\n                const [sx, sy] = worldToScreen(b.x, b.y, t);\n                const sw = b.width * view.scale.x;\n                const sh = b.height * view.scale.y;\n                if (ov.shape === 'image') {\n                  const e = ov.extras as Partial<{ src: string; preview: string }>;\n                  // The bitmap when it has decoded, the bare outline until then\n                  // (or when the tool opted out) — the outline is drawn either\n                  // way, so the drag always has an edge to read.\n                  const bmp = e.preview === 'outline' || !e.src\n                    ? undefined\n                    : getImageBitmap(e.src);\n                  if (bmp) {\n                    out.push({\n                      kind: 'image',\n                      image: bmp,\n                      x: sx, y: sy, w: sw, h: sh,\n                      opacity: PREVIEW_CONTENT_OPACITY,\n                    });\n                  }\n                }\n                pathCmd = ov.shape === 'ellipse'\n                  ? ellipsePath({ x: sx, y: sy, width: sw, height: sh })\n                  : rectPath(sx, sy, sw, sh);\n                break;\n              }\n              case 'line':\n                pathCmd = linePath(projectPoint(geom.a.x, geom.a.y), projectPoint(geom.b.x, geom.b.y));\n                break;\n              case 'polygon':\n                pathCmd = regularPolygonPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.radius * radialScale,\n                  geom.sides,\n                  geom.rotation,\n                );\n                break;\n              case 'star':\n                pathCmd = starPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.outerRadius * radialScale,\n                  geom.points,\n                  geom.innerRadius * radialScale,\n                  geom.rotation,\n                );\n                break;\n              case 'pencil':\n                // Genuinely open: `polygonFromPoints` closes the path, and the\n                // closing edge from the last sample back to the first reads as\n                // a marquee rather than as the stroke being drawn.\n                pathCmd = polylineFromPoints(projectPoints(geom.samples));\n                break;\n            }\n\n            if (!pathCmd) continue;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: pathCmd,\n              fill: ov.shape === 'line' || ov.shape === 'pencil' || ov.shape === 'image'\n                ? undefined\n                : { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            // Anchor dot at the drag's click point: for radial shapes no\n            // vertex sits at the AABB corner, and in center mode the dot marks\n            // the growth axis.\n            if (ov.anchorPoint) {\n              const anchorScreen = projectPoint(ov.anchorPoint.x, ov.anchorPoint.y);\n              out.push({\n                kind: 'path',\n                path: ellipsePath({\n                  x: anchorScreen.x - 4,\n                  y: anchorScreen.y - 4,\n                  width: 8,\n                  height: 8,\n                }),\n                fill: { paint: { color: cfg.stroke } },\n              });\n            }\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // `polygonFromPoints` closes the path, which draws the dashed\n            // close-line back to the first vertex.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useHeldModifiers.js

@@ -0,0 +1,20 @@
+import { useKeyState as e } from "../../input/useKeyState.js";
+import { useMemo as t } from "react";
+//#region src/canvas/SceneCanvas/useHeldModifiers.ts
+function n() {
+	let n = e({ skipInEditable: !1 });
+	return t(() => ({
+		get: n.modifiers,
+		subscribe(e) {
+			let t = n.modifiers();
+			return n.subscribe(() => {
+				let r = n.modifiers();
+				r !== t && (t = r, e());
+			});
+		}
+	}), [n]);
+}
+//#endregion
+export { n as useHeldModifiers };
+
+//# sourceMappingURL=useHeldModifiers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useHeldModifiers.js","names":["useHeldModifiers","keys","useKeyState","useMemo","held","now","listener"],"sources":["../../../src/canvas/SceneCanvas/useHeldModifiers.ts"],"sourcesContent":["/** The modifier keys held, for a surface's rule context. */\nimport { useMemo } from 'react';\nimport type { ModifierState } from '../../core/modifierState';\nimport type { RedrawSource } from '../../core/layers/render';\nimport { useKeyState } from '../../input/useKeyState';\n\nexport interface HeldModifiers extends RedrawSource {\n  /** Read when a rule is evaluated. The same object until a modifier changes. */\n  get(): ModifierState;\n}\n\n/** The modifiers held anywhere in the window, a text field included: a rule\n *  is asked about the keyboard, not about where focus is. `subscribe` reports\n *  a modifier going down or up and no other key. */\nexport function useHeldModifiers(): HeldModifiers {\n  const keys = useKeyState({ skipInEditable: false });\n  return useMemo(() => ({\n    get: keys.modifiers,\n    subscribe(listener) {\n      let held = keys.modifiers();\n      return keys.subscribe(() => {\n        const now = keys.modifiers();\n        if (now === held) return;\n        held = now;\n        listener();\n      });\n    },\n  }), [keys]);\n}\n"],"mappings":";;;AAcA,SAAgBA,IAAkC;CAChD,IAAMC,IAAOC,EAAY,EAAE,gBAAgB,GAAM,CAAC;CAClD,OAAOC,SAAe;EACpB,KAAKF,EAAK;EACV,UAAU,GAAU;GAClB,IAAIG,IAAOH,EAAK,UAAU;GAC1B,OAAOA,EAAK,gBAAgB;IAC1B,IAAMI,IAAMJ,EAAK,UAAU;IAC3B,AAAII,MAAQD,MACZ,IAAOC,GACPC,EAAS;GACX,CAAC;EACH;CACF,IAAI,CAACL,CAAI,CAAC;AACZ"}

package/dist/canvas/SceneCanvas/useNodeAtPoint.js

@@ -0,0 +1,26 @@
+import { makeGetNodeAtPoint as e } from "../getNodeAtPoint.js";
+import { useMemo as t } from "react";
+//#region src/canvas/SceneCanvas/useNodeAtPoint.ts
+function n(n) {
+	let { pickBest: r, nodes: i, kindOfData: a, isPointerInteractive: o } = n;
+	return t(() => {
+		if (!r) return;
+		let t = e(r, (e) => {
+			let t = i.getNode(e);
+			return t ? { kind: a ? a(t.data) : "unknown" } : null;
+		});
+		return o ? (e, n, r) => {
+			let i = t(e, n, r);
+			return i == null || o(i.id) === !1 ? null : i;
+		} : t;
+	}, [
+		i,
+		r,
+		o,
+		a
+	]);
+}
+//#endregion
+export { n as useNodeAtPoint };
+
+//# sourceMappingURL=useNodeAtPoint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeAtPoint.js","names":["useNodeAtPoint","args","useMemo","pickBest","base","makeGetNodeAtPoint","node","nodes","id","kindOfData","isPointerInteractive","hit","wx","wy","view"],"sources":["../../../src/canvas/SceneCanvas/useNodeAtPoint.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { makeGetNodeAtPoint, type NodeAtPointHit } from '../getNodeAtPoint';\nimport type { PickView } from './useSceneSelectTool';\n\nexport type NodeAtPoint = (wx: number, wy: number, view?: PickView | null) => NodeAtPointHit | null;\n\n/**\n * The node under a world point with its routing kind, resolved through the\n * select tool's own single-hit picker, so `onClick`, `onDoubleClick`, hover,\n * and tool routing all name the node a click selects. A hit whose id\n * `isPointerInteractive` rejects comes back null.\n */\nexport function useNodeAtPoint<TData>(args: {\n  pickBest: ((wx: number, wy: number, view?: PickView | null) => string | null) | undefined;\n  /** A caller's `geometry.pickEvery` can answer an id the scene does not hold. */\n  nodes: { getNode(id: string): { data: TData } | null | undefined };\n  kindOfData: ((data: TData) => string) | undefined;\n  isPointerInteractive: ((id: string) => boolean) | undefined;\n}): NodeAtPoint | undefined {\n  const { pickBest, nodes, kindOfData, isPointerInteractive } = args;\n  return useMemo(() => {\n    if (!pickBest) return undefined;\n    const base = makeGetNodeAtPoint(pickBest, (id) => {\n      const node = nodes.getNode(id);\n      if (!node) return null;\n      return { kind: kindOfData ? kindOfData(node.data) : 'unknown' };\n    });\n    if (!isPointerInteractive) return base;\n    return (wx, wy, view) => {\n      const hit = base(wx, wy, view);\n      if (hit == null) return null;\n      if (isPointerInteractive(hit.id) === false) return null;\n      return hit;\n    };\n  }, [nodes, pickBest, isPointerInteractive, kindOfData]);\n}\n"],"mappings":";;;AAYA,SAAgBA,EAAsB,GAMV;CAC1B,IAAM,EAAE,aAAU,UAAO,eAAY,4BAAyBC;CAC9D,OAAOC,QAAc;EACnB,IAAI,CAACC,GAAU;EACf,IAAMC,IAAOC,EAAmBF,IAAW,MAAO;GAChD,IAAMG,IAAOC,EAAM,QAAQC,CAAE;GAE7B,OADKF,IACE,EAAE,MAAMG,IAAaA,EAAWH,EAAK,IAAI,IAAI,UAAU,IAD5C;EAEpB,CAAC;EAED,OADKI,KACG,GAAI,GAAI,MAAS;GACvB,IAAMC,IAAMP,EAAKQ,GAAIC,GAAIC,CAAI;GAG7B,OAFIH,KAAO,QACPD,EAAqBC,EAAI,EAAE,MAAM,KAAc,OAC5CA;EACT,IANkCP;CAOpC,GAAG;EAACG;EAAOJ;EAAUO;EAAsBD;CAAU,CAAC;AACxD"}

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

@@ -1,69 +1,69 @@
 import { deriveParallaxView as e } from "../../core/viewport/parallax.js";
-import { resolveDerivedPath as t } from "../../core/scene/derivedPath.js";
-import { findShapeSilhouette as n } from "../NodeShape.js";
-import { sceneDepLookup as r } from "../derivedPath.js";
-import { planeTransform as i } from "../planeClips.js";
-import { scenePlaneOf as a } from "../pickWalk.js";
-import { wrapWithPoseRotation as o } from "../poseRotation.js";
-import { previewSourcesFrom as s } from "../drawEnvelope.js";
-import { resolvePreviews as c } from "../../interactions/actions/resolvePreviews.js";
-import { useEffect as l, useMemo as u, useReducer as d } from "react";
-import { useLatest as f } from "@weasel-js/react";
+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 { isCustomEntry as o } from "../layerSlots.js";
+import { resolvePreviews as s } from "../../interactions/actions/resolvePreviews.js";
+import "@weasel-js/renderer";
+import { useEffect as c, useMemo as l, useReducer as u } from "react";
+import { useLatest as d } from "@weasel-js/react";
 //#region src/canvas/SceneCanvas/usePreviewGhostLayer.ts
-var p = .85;
-function m(m) {
-	let { scene: h, sceneSlot: g, dispatcher: _ } = m, v = f(h), y = f(g), [, b] = d((e) => e + 1, 0);
-	return l(() => {
-		if (_) return _.subscribe(b);
-	}, [_]), u(() => ({
+var f = .85;
+function p(p) {
+	let { scene: m, sceneSlot: h, dispatcher: g } = p, _ = d(m), v = d(h), [, y] = u((e) => e + 1, 0);
+	return c(() => {
+		if (g) return g.subscribe(y);
+	}, [g]), l(() => ({
 		id: "preview-ghost",
 		label: "Preview ghost",
-		draw: (l, u) => {
-			let d = y.current, f = d?.drawOne;
-			if (!d || !f) return [];
-			let m = s(l), h = v.current, g = c(m, h);
-			if (g.length === 0) return [];
-			let _ = r(h), b = a(h.layers, u), x = (e) => b?.(e) ?? null, S = (t) => {
-				let n = b ? h.layers.find((e) => e.id === t)?.parallax : void 0;
-				return n ? e(u, n) : u;
-			}, C = (e, r) => {
+		draw: (c, l) => {
+			let u = v.current;
+			if (!u || o(u) || !u.drawOne) return [];
+			let d = u.drawOne, p = a(c), m = _.current, h = s(p, m);
+			if (h.length === 0) return [];
+			let g = i(m.layers, l), y = (e) => g?.(e) ?? null, b = (t) => {
+				let n = g ? m.layers.find((e) => e.id === t)?.parallax : void 0;
+				return n ? e(l, n) : l;
+			}, x = (e, i) => {
 				let a = e.data === e.node.data ? e.node : {
 					...e.node,
 					data: e.data
-				}, s = x(e.node.layer), c = f(a, e.pose, S(e.node.layer)), l = [...o(c, e.pose)];
-				for (let t of e.children) for (let e of C(t, s)) l.push(e);
-				let u = i(s, r), d = u ? {
+				}, o = y(e.node.layer), s = d(a, e.pose, b(e.node.layer)), c = [...n(s, e.pose)];
+				for (let t of e.children) for (let e of x(t, o)) c.push(e);
+				let l = t(o, i), f = l ? {
 					kind: "group",
-					transform: u,
-					children: l
+					transform: l,
+					children: c
 				} : {
 					kind: "group",
-					children: l
+					children: c
 				};
 				if (a.kind === "container") {
-					let r = n(a, e.pose, { derivedPath: t(a, _, (e) => h.childrenOf(e)) });
-					r && (d.clip = r);
+					let t = r(a, e.pose, { derivedPath: u.derivedPathOf?.(a, e.pose) ?? null });
+					t && (f.clip = t);
 				}
-				return [d];
-			}, w = [], T = [];
-			for (let e of g) {
-				let t = e.opaque ? T : w;
-				for (let n of C(e, null)) t.push(n);
+				return [f];
+			}, S = [], C = [];
+			for (let e of h) {
+				let t = e.opaque ? C : S;
+				for (let n of x(e, null)) t.push(n);
 			}
-			if (w.length === 0 && T.length === 0) return [];
-			let E = [];
-			return T.length > 0 && E.push({
+			if (S.length === 0 && C.length === 0) return [];
+			let w = [];
+			return C.length > 0 && w.push({
 				kind: "group",
-				children: T
-			}), w.length > 0 && E.push({
+				children: C
+			}), S.length > 0 && w.push({
 				kind: "group",
-				alpha: p,
-				children: w
-			}), E;
+				alpha: f,
+				children: S
+			}), w;
 		}
-	}), [v, y]);
+	}), [_, v]);
 }
 //#endregion
-export { m as usePreviewGhostLayer };
+export { p 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","depOf","sceneDepLookup","planeOf","scenePlaneOf","view","mapOf","layer","viewOf","parallax","l","deriveParallaxView","drawEntry","effNode","entry","plane","self","children","wrapWithPoseRotation","child","cmd","transform","planeTransform","parentPlane","group","clip","findShapeSilhouette","resolveDerivedPath","nid","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 { resolveDerivedPath, sceneDepLookup } from '../derivedPath';\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      // Reads the same overrides an in-flight gesture publishes, so a derived\n      // container ghosts with the clip it will actually impose.\n      const depOf = sceneDepLookup(sc);\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: resolveDerivedPath(effNode, depOf, (nid) => sc.childrenOf(nid)) },\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":";;;;;;;;;;;;AA2BA,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,IAAQC,EAAeJ,CAAE,GAIzBK,IAAUC,EAAaN,EAAG,QAAQO,CAAI,GACtCC,KAAS,MAAmCH,IAAUI,CAAK,KAAK,MAChEC,KAAU,MAAkB;IAChC,IAAMC,IAAWN,IAAUL,EAAG,OAAO,MAAM,MAAMY,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,IAAOtB,EAAQmB,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,aAAaa,EAAmBd,GAASZ,IAAQ,MAAQH,EAAG,WAAW8B,CAAG,CAAC,EAAE,CACjF;KACA,AAAIH,MAAM,EAAM,OAAOA;IACzB;IACA,OAAO,CAACD,CAAK;GACf,GAIMK,IAAyB,CAAC,GAC1BC,IAAyB,CAAC;GAChC,KAAK,IAAMC,KAAQhC,GAAO;IACxB,IAAMiC,IAAOD,EAAK,SAASD,IAAUD;IACrC,KAAK,IAAMT,KAAOR,EAAUmB,GAAM,IAAI,GAAG,EAAK,KAAKX,CAAG;GACxD;GACA,IAAIS,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,OAAOtD;IAAa,UAAUkD;GAAQ,CAAC,GAClFI;EACT;CACF,IAAI,CAACnD,GAAUG,CAAY,CAAC;AAC9B"}
+{"version":3,"file":"usePreviewGhostLayer.js","names":["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","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: 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';\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      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;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;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,OAAOnD;IAAa,UAAU+C;GAAQ,CAAC,GAClFI;EACT;CACF,IAAI,CAAChD,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"}