@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/SceneViewCanvas.js

@@ -1,54 +1,50 @@
 import { normalizeView as e } from "../core/viewport/view.js";
-import { useLateContentRedraw as t } from "./useLateContentRedraw.js";
-import { useFrameLoop as n } from "./useFrameLoop.js";
-import { useCanvasRenderer as r } from "./useCanvasRenderer.js";
-import { sceneViewFrame as i } from "./sceneViewRender.js";
-import { useCallback as a, useEffect as o, useLayoutEffect as s, useRef as c, useSyncExternalStore as l } from "react";
-import { assignRef as u, useLatest as d } from "@weasel-js/react";
-import { jsx as f } from "react/jsx-runtime";
+import { useCanvasSurface as t } from "./useCanvasSurface.js";
+import { surfaceBox as n } from "./surfaceBox.js";
+import { sceneViewFrame as r } from "./sceneViewRender.js";
+import { useCallback as i, useEffect as a, useRef as o, useSyncExternalStore as s } from "react";
+import { assignRef as c } from "@weasel-js/react";
+import { jsx as l } from "react/jsx-runtime";
 //#region src/canvas/SceneViewCanvas.tsx
-function p(p) {
-	let { scene: m, width: h, height: g, drawOne: _, extraCommands: v, alphaFor: y, layerVisibility: b, layerOrder: x, animator: S, className: C, canvasRef: w, cull: T, paintBounds: E } = p, D = e(p.view);
-	l(m.subscribe, m.getVersion, m.getVersion);
-	let O = c(null), k = a((e) => {
-		O.current = e, u(w, e);
-	}, [w]), { paint: A } = r(), j = d(() => {
-		let e = O.current;
-		if (!e) return !1;
-		let t = i({
-			scene: m,
-			view: D,
-			width: h,
-			height: g,
-			drawOne: _,
-			extraCommands: v,
-			alphaFor: y,
-			layerVisibility: b,
-			layerOrder: x,
-			colorOverrides: S?.colorOverrides,
-			cull: T,
-			paintBounds: E
+function u(u) {
+	let { scene: d, width: f, height: p, drawOne: m, extraCommands: h, alphaFor: g, layerVisibility: _, layerOrder: v, animator: y, className: b, canvasRef: x, cull: S, paintBounds: C } = u, w = e(u.view);
+	s(d.subscribe, d.getVersion, d.getVersion);
+	let T = o(null), E = i((e) => {
+		T.current = e, c(x, e);
+	}, [x]), { requestRedraw: D } = t((e) => {
+		let t = T.current;
+		if (!t) return !1;
+		let n = r({
+			scene: d,
+			view: w,
+			width: f,
+			height: p,
+			drawOne: m,
+			extraCommands: h,
+			alphaFor: g,
+			layerVisibility: _,
+			layerOrder: v,
+			colorOverrides: y?.colorOverrides,
+			cull: S,
+			paintBounds: C
 		});
-		return A(e, t, D, {
-			width: h,
-			height: g
-		}), !0;
-	}), { requestRedraw: M } = n(a(() => j.current(), [j])), N = c(!1);
-	return s(() => {
-		if (N.current) {
-			M();
-			return;
-		}
-		N.current = j.current(), N.current || M();
-	}), o(() => m.overrides.subscribe(M), [m, M]), o(() => S?.onTick(M), [S, M]), t(M), /* @__PURE__ */ f("canvas", {
-		ref: k,
-		width: h,
-		height: g,
-		className: C
+		return e.paint(t, n, w, {
+			width: f,
+			height: p
+		});
+	}, {
+		target: T,
+		paintOnCommit: !0
+	});
+	return a(() => d.overrides.subscribe(D), [d, D]), a(() => y?.onTick(D), [y, D]), /* @__PURE__ */ l("canvas", {
+		ref: E,
+		width: f,
+		height: p,
+		...n(f, p, b)
 	});
 }
-var m = p;
+var d = u;
 //#endregion
-export { m as SceneViewCanvas };
+export { d as SceneViewCanvas };
 
 //# sourceMappingURL=SceneViewCanvas.js.map

package/dist/canvas/SceneViewCanvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"SceneViewCanvas.js","names":["SceneViewCanvasInner","props","view","normalizeView","scene","localRef","useRef","setCanvasRef","useCallback","el","assignRef","canvasRef","paintCanvas","useCanvasRenderer","paintRef","useLatest","canvas","commands","sceneViewFrame","animator","useFrameLoop","paintedRef","useLayoutEffect","requestRedraw","useEffect","useLateContentRedraw","SceneViewCanvas"],"sources":["../../src/canvas/SceneViewCanvas.tsx"],"sourcesContent":["/**\n * `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a\n * given `View` into its own `<canvas>` DOM element.\n *\n * The component:\n *   - mounts its own `<canvas>`,\n *   - subscribes to the scene via `useSyncExternalStore(scene.subscribe,\n *     scene.getVersion)` so any scene mutation triggers a re-render,\n *   - subscribes to `scene.overrides` as well, since override writes never\n *     bump the scene version — without this the view would paint document\n *     poses while `<SceneCanvas>` paints overridden ones,\n *   - paints through `useFrameLoop` rather than from React, so both a render\n *     (prop change or version bump) and an override commit just mark the\n *     surface dirty and one `requestAnimationFrame` coalesces them. The mount\n *     paint is synchronous so the first frame the user sees is the scene, not\n *     a blank canvas,\n *   - attaches **no** event listeners (consumers attach their own via\n *     `canvasRef`),\n *   - frees its renderer and every GL object it owns on unmount\n *     (`useCanvasRenderer`).\n *\n * Sizing follows `<SceneCanvas>`'s convention: the consumer passes `width` /\n * `height` in CSS pixels. The HTML `width` / `height` attributes of the\n * `<canvas>` (drawing-buffer size) are set to `width × dpr` and `height × dpr`\n * by the canvas renderer (via the underlying renderer's `resize`). The CSS\n * size — what the consumer sees on screen — is managed via the `className`\n * prop; no inline styles are emitted (per project rules).\n */\nimport {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport { assignRef, useLatest } from '@weasel-js/react';\nimport { useFrameLoop } from './useFrameLoop';\nimport { useLateContentRedraw } from './useLateContentRedraw';\nimport { useCanvasRenderer } from './useCanvasRenderer';\nimport { sceneViewFrame } from './sceneViewRender';\nimport type { RenderSceneToCanvasArgs, SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { Animator } from '../animation/types';\n\n/** Props for `<SceneViewCanvas>`. */\nexport interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {\n  /** Scene to render. Must be the same `Scene` instance passed to whoever\n   *  is mutating it; the component subscribes to its version stream and\n   *  repaints when the version advances. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera. Applied to scene + `extraCommands` via the renderer's group\n   *  transform. */\n  view: View;\n  /** CSS-pixel width. Drives both layout (via the rendered drawing-buffer\n   *  size) and the renderer's coordinate space. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n  /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is\n   *  responsible for what gets painted — there is no AABB-fill default. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional extra commands appended after scene commands, inside the same\n   *  view transform. Used by `<MinimapCanvas>` for its visible-window\n   *  indicator; available to other consumers that want to overlay a\n   *  world-space annotation. */\n  extraCommands?: ReadonlyArray<DrawCommand>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in this view only, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for this view, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Skip nodes and commands that cannot reach this view — the scene slot's\n   *  `cull`. Off by default; worth it when the view shows a small part of a\n   *  large scene. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach — the scene slot's\n   *  `paintBounds`. Defaults to `defaultPaintBounds` when `drawOne` is\n   *  `defaultDrawOne`. */\n  paintBounds?: RenderSceneToCanvasArgs<TData, TLayer, TPose>['paintBounds'];\n  /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks\n   *  and paints its `colorOverrides`. Pass the main canvas's animator so both\n   *  show the same colors. */\n  animator?: Animator;\n  /** Optional CSS class for sizing / positioning the `<canvas>`. The kit\n   *  does not emit inline styles for layout — use a class. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own\n   *  pointer listeners or call `toBlob` for snapshots through this. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n}\n\nfunction SceneViewCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneViewCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    animator, className, canvasRef, cull, paintBounds,\n  } = props;\n  const view = normalizeView(props.view);\n\n  // Subscribe to scene version. The snapshot value isn't used directly —\n  // we only need React to re-render the component when the scene mutates.\n  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);\n\n  const localRef = useRef<HTMLCanvasElement | null>(null);\n\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null): void => {\n    localRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n\n  // The frame loop paints, not React — so an override commit can repaint\n  // without a render. The thunk defers to `paintRef`, which every committed\n  // render republishes from an insertion effect — ahead of the layout effect\n  // below, and never from a render React abandoned.\n  const { paint: paintCanvas } = useCanvasRenderer();\n  const paint = (): boolean => {\n    const canvas = localRef.current;\n    if (!canvas) return false;\n    const commands = sceneViewFrame({\n      scene,\n      view,\n      width,\n      height,\n      drawOne,\n      extraCommands: extraCommands as DrawCommand[] | undefined,\n      alphaFor,\n      layerVisibility,\n      layerOrder,\n      colorOverrides: animator?.colorOverrides,\n      cull,\n      paintBounds,\n    });\n    paintCanvas(canvas, commands, view, { width, height });\n    return true;\n  };\n  const paintRef = useLatest(paint);\n\n  const { requestRedraw } = useFrameLoop(useCallback(() => paintRef.current(), [paintRef]));\n\n  // Every render — a prop change or a scene-version bump — marks the surface\n  // dirty. No dependency array: the paint reads all of them.\n  //\n  // The mount paint is the exception: it runs here, in the caller's stack, so\n  // the first frame the user sees is the scene rather than a blank canvas.\n  const paintedRef = useRef(false);\n  useLayoutEffect(() => {\n    if (paintedRef.current) { requestRedraw(); return; }\n    paintedRef.current = paintRef.current();\n    if (!paintedRef.current) requestRedraw();\n  });\n\n  // Override writes never bump the scene version, so the version subscription\n  // above cannot see them.\n  useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);\n  useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);\n  useLateContentRedraw(requestRedraw);\n\n  return (\n    <canvas\n      ref={setCanvasRef}\n      width={width}\n      height={height}\n      className={className}\n    />\n  );\n}\n\n/**\n * Pointer-inert read-only scene view. See `SceneViewCanvasProps` for the\n * full surface and the module docstring for the rendering model.\n *\n * `forwardRef` is not used because the component is generic over `<TData,\n * TLayer, TPose>` and React's `forwardRef` erases generics. The\n * `canvasRef` prop is the plain-prop equivalent (the spec calls it out as\n * the public surface).\n */\nexport const SceneViewCanvas = SceneViewCanvasInner;\n"],"mappings":";;;;;;;;;AAkGA,SAASA,EACP,GACA;CACA,IAAM,EACJ,UAAO,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eACzE,aAAU,cAAW,cAAW,SAAM,mBACpCC,GACEC,IAAOC,EAAcF,EAAM,IAAI;CAIrC,EAAqBG,EAAM,WAAWA,EAAM,YAAYA,EAAM,UAAU;CAExE,IAAMC,IAAWC,EAAiC,IAAI,GAEhDC,IAAeC,GAAa,MAAuC;EAEvE,AADA,EAAS,UAAUC,GACnBC,EAAUC,GAAWF,CAAE;CACzB,GAAG,CAACE,CAAS,CAAC,GAMR,EAAE,OAAOC,MAAgBC,EAAkB,GAqB3CC,IAAWC,QApBY;EAC3B,IAAMC,IAASX,EAAS;EACxB,IAAI,CAACW,GAAQ,OAAO;EACpB,IAAMC,IAAWC,EAAe;GAC9B;GACA;GACA;GACA;GACA;GACe;GACf;GACA;GACA;GACA,gBAAgBC,GAAU;GAC1B;GACA;EACF,CAAC;EAED,OADAP,EAAYI,GAAQC,GAAUf,GAAM;GAAE;GAAO;EAAO,CAAC,GAC9C;CACT,CACgC,GAE1B,EAAE,qBAAkBkB,EAAaZ,QAAkBM,EAAS,QAAQ,GAAG,CAACA,CAAQ,CAAC,CAAC,GAOlFO,IAAaf,EAAO,EAAK;CAa/B,OAZAgB,QAAsB;EACpB,IAAID,EAAW,SAAS;GAAE,EAAc;GAAG;EAAQ;EAEnD,AADA,EAAW,UAAUP,EAAS,QAAQ,GACjCO,EAAW,WAASE,EAAc;CACzC,CAAC,GAIDC,QAAgBpB,EAAM,UAAU,UAAUmB,CAAa,GAAG,CAACnB,GAAOmB,CAAa,CAAC,GAChFC,QAAgBL,GAAU,OAAOI,CAAa,GAAG,CAACJ,GAAUI,CAAa,CAAC,GAC1EE,EAAqBF,CAAa,GAGhC,kBAAC,UAAD;EACE,KAAKhB;EACE;EACC;EACG;CACZ,CAAA;AAEL;AAWA,IAAamB,IAAkB1B"}
+{"version":3,"file":"SceneViewCanvas.js","names":["SceneViewCanvasInner","props","view","normalizeView","scene","localRef","useRef","setCanvasRef","useCallback","el","assignRef","canvasRef","useCanvasSurface","canvas","commands","sceneViewFrame","animator","lease","useEffect","requestRedraw","surfaceBox","width","height","className","SceneViewCanvas"],"sources":["../../src/canvas/SceneViewCanvas.tsx"],"sourcesContent":["/**\n * `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a\n * given `View` into its own `<canvas>` DOM element.\n *\n * It paints through `useFrameLoop` rather than from React: a render and an\n * override commit both just mark the surface dirty. The mount paint is\n * synchronous, so the first frame the user sees is the scene, and nothing\n * paints while the canvas is off screen or the tab is hidden.\n */\nimport {\n  useCallback,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport { surfaceBox } from './surfaceBox';\nimport { sceneViewFrame } from './sceneViewRender';\nimport type { RenderSceneToCanvasArgs, SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { Animator } from '@weasel-js/animator';\n\n/** Props for `<SceneViewCanvas>`. */\nexport interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {\n  /** Scene to render. The component subscribes to it and repaints when it\n   *  changes. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera. Applied to scene + `extraCommands` via the renderer's group\n   *  transform. */\n  view: View;\n  /** CSS-pixel width. Drives both layout (via the rendered drawing-buffer\n   *  size) and the renderer's coordinate space. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n  /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is\n   *  responsible for what gets painted — there is no AABB-fill default. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional extra commands appended after scene commands, inside the same\n   *  view transform — a world-space annotation over the scene. */\n  extraCommands?: ReadonlyArray<DrawCommand>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in this view only, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for this view, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Skip nodes and commands that cannot reach this view — the scene slot's\n   *  `cull`. Off by default; worth it when the view shows a small part of a\n   *  large scene. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach — the scene slot's\n   *  `paintBounds`. Defaults to `defaultPaintBounds` when `drawOne` is\n   *  `defaultDrawOne`. */\n  paintBounds?: RenderSceneToCanvasArgs<TData, TLayer, TPose>['paintBounds'];\n  /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks\n   *  and paints its `colorOverrides`. Pass the main canvas's animator so both\n   *  show the same colors. */\n  animator?: Animator;\n  /** Optional CSS class for the `<canvas>`. Its size is `width` × `height`\n   *  unless a rule on this class sizes it. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own\n   *  pointer listeners or call `toBlob` for snapshots through this. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n}\n\nfunction SceneViewCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneViewCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    animator, className, canvasRef, cull, paintBounds,\n  } = props;\n  const view = normalizeView(props.view);\n\n  // Subscribe to scene version. The snapshot value isn't used directly —\n  // we only need React to re-render the component when the scene mutates.\n  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);\n\n  const localRef = useRef<HTMLCanvasElement | null>(null);\n\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null): void => {\n    localRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n\n  const paint = (lease: CanvasRendererLease): boolean => {\n    const canvas = localRef.current;\n    if (!canvas) return false;\n    const commands = sceneViewFrame({\n      scene,\n      view,\n      width,\n      height,\n      drawOne,\n      extraCommands: extraCommands as DrawCommand[] | undefined,\n      alphaFor,\n      layerVisibility,\n      layerOrder,\n      colorOverrides: animator?.colorOverrides,\n      cull,\n      paintBounds,\n    });\n    return lease.paint(canvas, commands, view, { width, height });\n  };\n  const { requestRedraw } = useCanvasSurface(paint, { target: localRef, paintOnCommit: true });\n\n  // Override writes never bump the scene version, so the version subscription\n  // above cannot see them.\n  useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);\n  useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);\n\n  return (\n    <canvas\n      ref={setCanvasRef}\n      width={width}\n      height={height}\n      {...surfaceBox(width, height, className)}\n    />\n  );\n}\n\n/**\n * Pointer-inert read-only scene view. It attaches no event listeners;\n * consumers attach their own through `canvasRef`, a plain prop because\n * `forwardRef` erases the component's generics. `width` and `height` are CSS\n * pixels and size the drawing buffer; a `className` rule that sizes the\n * element stretches that buffer to fit.\n */\nexport const SceneViewCanvas = SceneViewCanvasInner;\n"],"mappings":";;;;;;;;AA2EA,SAASA,EACP,GACA;CACA,IAAM,EACJ,UAAO,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eACzE,aAAU,cAAW,cAAW,SAAM,mBACpCC,GACEC,IAAOC,EAAcF,EAAM,IAAI;CAIrC,EAAqBG,EAAM,WAAWA,EAAM,YAAYA,EAAM,UAAU;CAExE,IAAMC,IAAWC,EAAiC,IAAI,GAEhDC,IAAeC,GAAa,MAAuC;EAEvE,AADA,EAAS,UAAUC,GACnBC,EAAUC,GAAWF,CAAE;CACzB,GAAG,CAACE,CAAS,CAAC,GAqBR,EAAE,qBAAkBC,GAnBX,MAAwC;EACrD,IAAMC,IAASR,EAAS;EACxB,IAAI,CAACQ,GAAQ,OAAO;EACpB,IAAMC,IAAWC,EAAe;GAC9B;GACA;GACA;GACA;GACA;GACe;GACf;GACA;GACA;GACA,gBAAgBC,GAAU;GAC1B;GACA;EACF,CAAC;EACD,OAAOC,EAAM,MAAMJ,GAAQC,GAAUZ,GAAM;GAAE;GAAO;EAAO,CAAC;CAC9D,GACkD;EAAE,QAAQG;EAAU,eAAe;CAAK,CAAC;CAO3F,OAHAa,QAAgBd,EAAM,UAAU,UAAUe,CAAa,GAAG,CAACf,GAAOe,CAAa,CAAC,GAChFD,QAAgBF,GAAU,OAAOG,CAAa,GAAG,CAACH,GAAUG,CAAa,CAAC,GAGxE,kBAAC,UAAD;EACE,KAAKZ;EACE;EACC;EACR,GAAIa,EAAWC,GAAOC,GAAQC,CAAS;CACxC,CAAA;AAEL;AASA,IAAaC,IAAkBxB"}

package/dist/canvas/adapterDerivedPath.js

@@ -0,0 +1,26 @@
+import { createNodeMemoScope as e } from "../core/scene/nodeMemo.js";
+import { resolveDerivedPath as t } from "../core/scene/derivedPath.js";
+//#region src/canvas/adapterDerivedPath.ts
+var n = /* @__PURE__ */ new WeakMap(), r = [];
+function i(i) {
+	let a = n.get(i);
+	a === void 0 && (a = e(), n.set(i, a));
+	let o = a, s = (e) => typeof i.getWorldPose == "function" ? i.getWorldPose(e) : i.getPose(e), c = (e) => i.getChildren?.(e) ?? r, l = (e) => {
+		let t = i.getNode(e);
+		if (t != null) return {
+			node: t,
+			pose: s(e),
+			get path() {
+				return u(e);
+			}
+		};
+	}, u = (e) => {
+		let n = i.getNode(e);
+		return !n || n.dependsOn === void 0 || n.derivePath === void 0 ? null : t(n, l, c, o);
+	};
+	return u;
+}
+//#endregion
+export { i as adapterDerivedPathOf };
+
+//# sourceMappingURL=adapterDerivedPath.js.map

package/dist/canvas/adapterDerivedPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapterDerivedPath.js","names":["scopes","NO_CHILDREN","adapterDerivedPathOf","scope","adapter","createNodeMemoScope","slot","poseOf","id","childrenOf","depOf","node","pathOf","resolveDerivedPath"],"sources":["../../src/canvas/adapterDerivedPath.ts"],"sourcesContent":["/**\n * A derived node's path, resolved through an adapter with no scene in scope.\n *\n * A derivation reads its dependencies' nodes and where they are drawn, and\n * every adapter already answers both by id. Nothing pushes an invalidation\n * here, so freshness is the memo's own re-check of what the adapter answers.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { resolveDerivedPath, type PathDerivingNode } from 'core/scene/derivedPath';\nimport { createNodeMemoScope, type NodeMemoScope } from 'core/scene/nodeMemo';\nimport type { DerivedDep, Node, NodeId } from 'core/scene/types';\n\n/** What deriving reads of an adapter. */\nexport interface DerivingAdapter<TPose> {\n  getNode(id: string): unknown;\n  getPose(id: string): TPose;\n  /** Where the node is drawn, when the adapter composes poses. */\n  getWorldPose?(id: string): TPose;\n  getChildren?(parentId: string | null): readonly string[];\n}\n\nconst scopes = new WeakMap<object, NodeMemoScope>();\nconst NO_CHILDREN: readonly NodeId[] = [];\n\n/**\n * The path the node `id` computes from its dependencies, or `null` when it\n * derives none. Memoized against `adapter`, so every reader of one adapter\n * shares a route.\n */\nexport function adapterDerivedPathOf<TPose>(\n  adapter: DerivingAdapter<TPose>,\n): (id: string) => Path | null {\n  let scope = scopes.get(adapter);\n  if (scope === undefined) {\n    scope = createNodeMemoScope();\n    scopes.set(adapter, scope);\n  }\n  const slot = scope;\n  const poseOf = (id: string): TPose =>\n    (typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id));\n  const childrenOf = (id: NodeId): readonly NodeId[] =>\n    (adapter.getChildren?.(id) as readonly NodeId[] | undefined) ?? NO_CHILDREN;\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const node = adapter.getNode(id);\n    if (node === undefined || node === null) return undefined;\n    return {\n      node: node as Node<unknown, string, TPose>,\n      pose: poseOf(id),\n      get path(): Path | null { return pathOf(id); },\n    };\n  };\n  const pathOf = (id: string): Path | null => {\n    const node = adapter.getNode(id) as PathDerivingNode<TPose> | undefined | null;\n    if (!node || node.dependsOn === undefined || node.derivePath === undefined) return null;\n    return resolveDerivedPath(node, depOf, childrenOf, slot);\n  };\n  return pathOf;\n}\n"],"mappings":";;;AAqBA,IAAMA,oBAAS,IAAI,QAA+B,GAC5CC,IAAiC,CAAC;AAOxC,SAAgBC,EACd,GAC6B;CAC7B,IAAIC,IAAQH,EAAO,IAAII,CAAO;CAC9B,AAAID,MAAU,KAAA,MACZ,IAAQE,EAAoB,GAC5BL,EAAO,IAAII,GAASD,CAAK;CAE3B,IAAMG,IAAOH,GACPI,KAAU,MACb,OAAOH,EAAQ,gBAAiB,aAAaA,EAAQ,aAAaI,CAAE,IAAIJ,EAAQ,QAAQI,CAAE,GACvFC,KAAc,MACjBL,EAAQ,cAAcI,CAAE,KAAuCP,GAC5DS,KAAS,MAA8C;EAC3D,IAAMC,IAAOP,EAAQ,QAAQI,CAAE;EAC/B,IAAIG,KAA+B,MACnC,OAAO;GACC;GACN,MAAMJ,EAAOC,CAAE;GACf,IAAI,OAAoB;IAAE,OAAOI,EAAOJ,CAAE;GAAG;EAC/C;CACF,GACMI,KAAU,MAA4B;EAC1C,IAAMD,IAAOP,EAAQ,QAAQI,CAAE;EAE/B,OADI,CAACG,KAAQA,EAAK,cAAc,KAAA,KAAaA,EAAK,eAAe,KAAA,IAAkB,OAC5EE,EAAmBF,GAAMD,GAAOD,GAAYH,CAAI;CACzD;CACA,OAAOM;AACT"}

package/dist/canvas/affordanceAt.js

@@ -57,7 +57,17 @@ function l(e, t, n) {
 		} : { body: "empty" };
 	};
 }
+function u(e, t) {
+	return {
+		kind: `layer:${e}`,
+		owner: e,
+		strength: t.strength ?? "shared",
+		...t.claimedKinds === void 0 ? {} : { claimedKinds: t.claimedKinds },
+		...t.cursor === void 0 ? {} : { cursor: t.cursor },
+		...t.initialScratch === void 0 ? {} : { payload: t.initialScratch }
+	};
+}
 //#endregion
-export { o as anchorStateFrom, s as buildAffordanceAt, l as buildClassifyTarget, a as chromeAffordances };
+export { o as anchorStateFrom, s as buildAffordanceAt, l as buildClassifyTarget, a as chromeAffordances, u as layerAffordance };
 
 //# sourceMappingURL=affordanceAt.js.map

package/dist/canvas/affordanceAt.js.map

@@ -1 +1 @@
-{"version":3,"file":"affordanceAt.js","names":["chromeAffordances","sizes","targetSizesPx","opts","createRotationAffordance","rotateBandPx","rotationBadge","createCornerResizeAffordance","getAnchorState","createPathAnchorAffordances","anchorHitRadius","anchorStateFrom","dep","getRegistry","toCamera","id","buildAffordanceAt","affordances","wx","wy","hit","hitAffordanceRegions","getChromeState","getView","getIsVisible","toAffordanceHit","scratch","buildClassifyTarget","hitId","pickBest","getSelection","kindOfNode"],"sources":["../../src/canvas/affordanceAt.ts"],"sourcesContent":["/**\n * affordanceAt — the dispatcher-side affordance classifier.\n *\n * Answers \"what piece of selection chrome is under this world point?\" and\n * returns an `AffordanceHit`, which `GestureDispatcherMounter` packs onto\n * `InputEvent.pointerdown.affordance` so `resizeAction` / `rotateAction` /\n * `editAnchorsAction` can guard on affordance kind, and which the hover-cursor\n * pump reads `cursor` off of.\n *\n * It used to answer that question with its own geometry: its own corner\n * table, its own rotate-ring ellipse, its own anchor walk — all duplicating\n * the `Affordance` region declarations in `src/affordances/`, which had a\n * hit-tester of their own that nothing reached for kit chrome. Two\n * implementations of one question, and the declarative one was the dead\n * branch, which is why `AffordanceRegion.cursor` could be declared and set\n * and never consumed.\n *\n * Now this assembles the kit's affordances and runs the one shared walk\n * (`hitAffordanceRegions`). What remains here is the assembly and the\n * region-hit → `AffordanceHit` mapping.\n */\n\nimport type { BodyClassification } from '@weasel-js/gestures';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { View } from 'core/viewport/view';\nimport type { AffordanceHit } from '@weasel-js/routing';\nimport type { Affordance, CommonAffordanceScratch } from 'affordances/types';\nimport { hitAffordanceRegions, type AffordanceRegionHit } from 'affordances/hitAffordanceRegions';\nimport { createCornerResizeAffordance } from 'affordances/cornerResize';\nimport { createRotationAffordance } from 'affordances/rotationHandle';\nimport { createPathAnchorAffordances, type AnchorState } from 'affordances/pathAnchors';\nimport { targetSizesPx } from 'core/device/targets';\n\nexport type { AnchorState };\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/** What decides the kit's chrome affordances — their sizes and which ones\n *  exist. Shared by the hit-test and the slops overlay, which draws them. */\nexport interface ChromeAffordanceOptions {\n  /** Pointer-size multiplier from the live `DeviceProfile`. Every default\n   *  below is resolved through {@link targetSizesPx} at this scale, so the\n   *  grab zone tracks the painted chrome on a coarse pointer. Default 1. */\n  targetScale?: number;\n  /** Corner-handle hit radius in screen px. Overrides the device-scaled default. */\n  handleHitRadius?: number;\n  /** Anchor / control hit radius in screen px. Overrides the device-scaled default. */\n  anchorHitRadius?: number;\n  /** Minimum rotate-band thickness outside the selection AABB, in screen px.\n   *  Overrides the device-scaled default. */\n  rotateBandPx?: number;\n  /** The rotate badge the selection overlay paints (`rotationBadgeOf`), so\n   *  it can be grabbed where it is drawn. Omitted or null, only the rotate\n   *  ring is hit-tested. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Anchor-editing state. When omitted, anchors aren't hit-tested. */\n  getAnchorState?: () => AnchorState | null;\n}\n\nexport interface BuildAffordanceAtOptions extends ChromeAffordanceOptions {\n  /** Live ChromeState at call time — current selection plus effective bounds,\n   *  including in-flight move/resize ghost poses. */\n  getChromeState: () => ChromeState;\n  /** Live view. Needed because region hit radii and the rotate band are\n   *  declared in screen pixels and resolved against the current scale. */\n  getView: () => View;\n  /** The affordances to walk, when the caller built them itself to share\n   *  them (`chromeAffordances`). Otherwise built from these options. */\n  affordances?: readonly Affordance[];\n  /** Chrome-caps resolver. Keeps the hit-test and the renderer agreeing on\n   *  which chrome is live (resize handles gated by\n   *  `'selection.resize-handles'`, rotation by `'selection.rotation-handle'`,\n   *  anchors by `'path-edit.anchors'`). Omitting defaults to always-visible. */\n  getIsVisible?: () => (id: string) => boolean;\n}\n\n/**\n * The kit's selection chrome as affordances, bottom → top: rotate ring (and\n * badge), corner handles, then anchors and their controls — a corner handle\n * beats the rotate band it sits inside, and a control handle beats everything.\n */\nexport function chromeAffordances(opts: ChromeAffordanceOptions = {}): Affordance[] {\n  const sizes = targetSizesPx(opts.targetScale);\n  const {\n    handleHitRadius = sizes.handle,\n    anchorHitRadius = sizes.anchor,\n    rotateBandPx = sizes.rotationDistance,\n    getAnchorState,\n    rotationBadge,\n  } = opts;\n  return [\n    createRotationAffordance({\n      bandPx: rotateBandPx,\n      paint: null,\n      ...(rotationBadge\n        ? { handle: { distancePx: rotationBadge.distancePx, hitRadiusPx: rotationBadge.sizePx } }\n        : {}),\n    }),\n    createCornerResizeAffordance({ handleHitRadius }),\n    ...(getAnchorState\n      ? createPathAnchorAffordances(getAnchorState, { hitRadius: anchorHitRadius })\n      : []),\n  ];\n}\n\n/**\n * Read anchor-editing state off a dep registry, for\n * {@link BuildAffordanceAtOpts.getAnchorState}. Returns `null` while no\n * `editAnchors` dep is registered — nothing is in anchor-edit mode, so\n * anchors are not hit-tested.\n */\nexport function anchorStateFrom(\n  getRegistry: () => { get(name: 'editAnchors'): EditAnchorsDep | undefined } | null,\n  /** The editable path in the world the hit-test is asked in. A node on a\n   *  parallax plane stores its path in the plane's world; the surface carries\n   *  it into the asking camera's. Default: unchanged. */\n  toCamera?: (id: string, path: unknown) => unknown,\n): () => AnchorState | null {\n  return () => {\n    const dep = getRegistry()?.get('editAnchors');\n    if (!dep) return null;\n    return {\n      editingId: dep.editingId ?? null,\n      // The hit-test reads world-coord anchor positions, so route through\n      // `getEditablePath`: both pose-as-polygon and `data.path` consumers\n      // resolve correctly.\n      getPose: (id) => (toCamera ? toCamera(id, dep.getEditablePath(id)) : dep.getEditablePath(id)),\n    };\n  };\n}\n\n/**\n * Build the `affordanceAt` thunk for `GestureDispatcherMounter`.\n *\n * Returns `(worldPoint) => AffordanceHit | null`. The point is **world-space**;\n * callers convert from client coords first.\n *\n * Priority runs anchors → controls → resize handles → rotate ring, top to\n * bottom, matching how the chrome paints: a corner handle beats the rotate\n * band it sits inside, and a control handle beats everything.\n */\nexport function buildAffordanceAt(\n  opts: BuildAffordanceAtOptions,\n): (worldPoint: { x: number; y: number }) => AffordanceHit | null {\n  const { getChromeState, getView, getIsVisible } = opts;\n  const affordances = opts.affordances ?? chromeAffordances(opts);\n\n  return function affordanceAt({ x: wx, y: wy }) {\n    const hit = hitAffordanceRegions(\n      affordances,\n      wx,\n      wy,\n      getChromeState(),\n      getView(),\n      getIsVisible?.(),\n    );\n    return hit ? toAffordanceHit(hit) : null;\n  };\n}\n\n/**\n * Region hit → `AffordanceHit`.\n *\n * `hitKind` is the routing discriminator; the handful of scratch fields named\n * by {@link CommonAffordanceScratch} are lifted onto the hit because the\n * actions that consume them read them there. Everything else in scratch rides\n * along untouched as `payload`.\n */\nfunction toAffordanceHit(hit: AffordanceRegionHit): AffordanceHit {\n  const scratch = (hit.binding.initialScratch ?? {}) as CommonAffordanceScratch;\n  return {\n    kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,\n    owner: hit.affordanceId,\n    strength: 'shared',\n    ...(scratch.targetId !== undefined ? { targetIds: [scratch.targetId] } : {}),\n    ...(scratch.anchor !== undefined ? { anchor: scratch.anchor } : {}),\n    ...(scratch.fixedPoint !== undefined ? { fixedPoint: scratch.fixedPoint } : {}),\n    ...(hit.region.cursor !== undefined ? { cursor: hit.region.cursor } : {}),\n    ...(hit.binding.initialScratch !== undefined ? { payload: hit.binding.initialScratch } : {}),\n  } as AffordanceHit;\n}\n\n// ---------------------------------------------------------------------------\n// classifyTarget helper\n// ---------------------------------------------------------------------------\n\n/**\n * Classify a world-space point against the current selection:\n * - `'empty'`: no scene body hit.\n * - `'selected-body'`: hit a node that is currently selected.\n * - `'unselected-body'`: hit a node that is NOT selected.\n *\n * The caller supplies the hit-test function (already wired from\n * `useSceneSelectTool.pickEvery`).\n *\n * @param kindOfNode - Optional resolver from a hit node id to its semantic\n *   kind. `<SceneCanvas>` defaults it to the `data.kind` convention the kit\n *   already reads in `deps/textEdit` and the shape-tool inserts; consumers\n *   whose nodes name their kind elsewhere override it. Omitting it leaves\n *   `kind` undefined, which makes every `kind:` TargetSpec form no-match.\n */\nexport function buildClassifyTarget(\n  getSelection: () => readonly string[],\n  pickBest: (wx: number, wy: number) => string | null,\n  kindOfNode?: (id: string) => string | undefined,\n): (worldPoint: { x: number; y: number }) => BodyClassification {\n  return function classifyTarget({ x: wx, y: wy }) {\n    const hitId = pickBest(wx, wy);\n    if (!hitId) return { body: 'empty' };\n    const sel = getSelection();\n    return {\n      body: sel.includes(hitId) ? 'selected-body' : 'unselected-body',\n      kind: kindOfNode?.(hitId),\n    };\n  };\n}\n"],"mappings":";;;;;;AAoFA,SAAgBA,EAAkB,IAAgC,CAAC,GAAiB;CAClF,IAAMC,IAAQC,EAAcC,EAAK,WAAW,GACtC,EACJ,qBAAkBF,EAAM,QACxB,qBAAkBA,EAAM,QACxB,kBAAeA,EAAM,kBACrB,mBACA,qBACEE;CACJ,OAAO;EACLC,EAAyB;GACvB,QAAQC;GACR,OAAO;GACP,GAAIC,IACA,EAAE,QAAQ;IAAE,YAAYA,EAAc;IAAY,aAAaA,EAAc;GAAO,EAAE,IACtF,CAAC;EACP,CAAC;EACDC,EAA6B,EAAE,mBAAgB,CAAC;EAChD,GAAIC,IACAC,EAA4BD,GAAgB,EAAE,WAAWE,EAAgB,CAAC,IAC1E,CAAC;CACP;AACF;AAQA,SAAgBC,EACd,GAIA,GAC0B;CAC1B,aAAa;EACX,IAAMC,IAAMC,EAAY,CAAC,EAAE,IAAI,aAAa;EAE5C,OADKD,IACE;GACL,WAAWA,EAAI,aAAa;GAI5B,UAAU,MAAQE,IAAWA,EAASC,GAAIH,EAAI,gBAAgBG,CAAE,CAAC,IAAIH,EAAI,gBAAgBG,CAAE;EAC7F,IAPiB;CAQnB;AACF;AAYA,SAAgBC,EACd,GACgE;CAChE,IAAM,EAAE,mBAAgB,YAAS,oBAAiBb,GAC5Cc,IAAcd,EAAK,eAAeH,EAAkBG,CAAI;CAE9D,OAAO,SAAsB,EAAE,GAAGe,GAAI,GAAGC,KAAM;EAC7C,IAAMC,IAAMC,EACVJ,GACAC,GACAC,GACAG,EAAe,GACfC,EAAQ,GACRC,IAAe,CACjB;EACA,OAAOJ,IAAMK,EAAgBL,CAAG,IAAI;CACtC;AACF;AAUA,SAASK,EAAgB,GAAyC;CAChE,IAAMC,IAAWN,EAAI,QAAQ,kBAAkB,CAAC;CAChD,OAAO;EACL,MAAMA,EAAI,OAAO,WAAW,GAAGA,EAAI,aAAa,GAAGA,EAAI;EACvD,OAAOA,EAAI;EACX,UAAU;EACV,GAAIM,EAAQ,aAAa,KAAA,IAAgD,CAAC,IAArC,EAAE,WAAW,CAACA,EAAQ,QAAQ,EAAE;EACrE,GAAIA,EAAQ,WAAW,KAAA,IAAyC,CAAC,IAA9B,EAAE,QAAQA,EAAQ,OAAO;EAC5D,GAAIA,EAAQ,eAAe,KAAA,IAAiD,CAAC,IAAtC,EAAE,YAAYA,EAAQ,WAAW;EACxE,GAAIN,EAAI,OAAO,WAAW,KAAA,IAA4C,CAAC,IAAjC,EAAE,QAAQA,EAAI,OAAO,OAAO;EAClE,GAAIA,EAAI,QAAQ,mBAAmB,KAAA,IAAsD,CAAC,IAA3C,EAAE,SAASA,EAAI,QAAQ,eAAe;CACvF;AACF;AAqBA,SAAgBO,EACd,GACA,GACA,GAC8D;CAC9D,OAAO,SAAwB,EAAE,GAAGT,GAAI,GAAGC,KAAM;EAC/C,IAAMS,IAAQC,EAASX,GAAIC,CAAE;EAG7B,OAFKS,IAEE;GACL,MAFUE,EAEJ,CAAA,CAAI,SAASF,CAAK,IAAI,kBAAkB;GAC9C,MAAMG,IAAaH,CAAK;EAC1B,IALmB,EAAE,MAAM,QAAQ;CAMrC;AACF"}
+{"version":3,"file":"affordanceAt.js","names":["chromeAffordances","sizes","targetSizesPx","opts","createRotationAffordance","rotateBandPx","rotationBadge","createCornerResizeAffordance","getAnchorState","createPathAnchorAffordances","anchorHitRadius","anchorStateFrom","dep","getRegistry","toCamera","id","buildAffordanceAt","affordances","wx","wy","hit","hitAffordanceRegions","getChromeState","getView","getIsVisible","toAffordanceHit","scratch","buildClassifyTarget","hitId","pickBest","getSelection","kindOfNode","layerAffordance","layerId","claim"],"sources":["../../src/canvas/affordanceAt.ts"],"sourcesContent":["/**\n * The dispatcher-side affordance classifier: answers \"what piece of selection\n * chrome is under this world point?\" by assembling the kit's affordances and\n * running the one shared walk (`hitAffordanceRegions`).\n */\n\nimport type { BodyClassification } from '@weasel-js/gestures';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { View } from 'core/viewport/view';\nimport type { AffordanceHit } from '@weasel-js/routing';\nimport type { Affordance, CommonAffordanceScratch, LayerHit } from 'affordances/types';\nimport { hitAffordanceRegions, type AffordanceRegionHit } from 'affordances/hitAffordanceRegions';\nimport { createCornerResizeAffordance } from 'affordances/cornerResize';\nimport { createRotationAffordance } from 'affordances/rotationHandle';\nimport { createPathAnchorAffordances, type AnchorState } from 'affordances/pathAnchors';\nimport { targetSizesPx } from 'core/device/targets';\n\nexport type { AnchorState };\n\n/** What decides the kit's chrome affordances — their sizes and which ones\n *  exist. Shared by the hit-test and the slops overlay, which draws them. */\nexport interface ChromeAffordanceOptions {\n  /** Pointer-size multiplier from the live `DeviceProfile`. Every default\n   *  below is resolved through {@link targetSizesPx} at this scale, so the\n   *  grab zone tracks the painted chrome on a coarse pointer. Default 1. */\n  targetScale?: number;\n  /** Corner-handle hit radius in screen px. Overrides the device-scaled default. */\n  handleHitRadius?: number;\n  /** Anchor / control hit radius in screen px. Overrides the device-scaled default. */\n  anchorHitRadius?: number;\n  /** Minimum rotate-band thickness outside the selection AABB, in screen px.\n   *  Overrides the device-scaled default. */\n  rotateBandPx?: number;\n  /** The rotate badge the selection overlay paints (`rotationBadgeOf`), so\n   *  it can be grabbed where it is drawn. Omitted or null, only the rotate\n   *  ring is hit-tested. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Anchor-editing state. When omitted, anchors aren't hit-tested. */\n  getAnchorState?: () => AnchorState | null;\n}\n\nexport interface BuildAffordanceAtOptions extends ChromeAffordanceOptions {\n  /** Live ChromeState at call time — current selection plus effective bounds,\n   *  including in-flight move/resize ghost poses. */\n  getChromeState: () => ChromeState;\n  /** Live view. Needed because region hit radii and the rotate band are\n   *  declared in screen pixels and resolved against the current scale. */\n  getView: () => View;\n  /** The affordances to walk, when the caller built them itself to share\n   *  them (`chromeAffordances`). Otherwise built from these options. */\n  affordances?: readonly Affordance[];\n  /** Chrome-caps resolver. Keeps the hit-test and the renderer agreeing on\n   *  which chrome is live (resize handles gated by\n   *  `'selection.resize-handles'`, rotation by `'selection.rotation-handle'`,\n   *  anchors by `'path-edit.anchors'`). Omitting defaults to always-visible. */\n  getIsVisible?: () => (id: string) => boolean;\n}\n\n/**\n * The kit's selection chrome as affordances, bottom → top: rotate ring (and\n * badge), corner handles, then anchors and their controls — a corner handle\n * beats the rotate band it sits inside, and a control handle beats everything.\n */\nexport function chromeAffordances(opts: ChromeAffordanceOptions = {}): Affordance[] {\n  const sizes = targetSizesPx(opts.targetScale);\n  const {\n    handleHitRadius = sizes.handle,\n    anchorHitRadius = sizes.anchor,\n    rotateBandPx = sizes.rotationDistance,\n    getAnchorState,\n    rotationBadge,\n  } = opts;\n  return [\n    createRotationAffordance({\n      bandPx: rotateBandPx,\n      paint: null,\n      ...(rotationBadge\n        ? { handle: { distancePx: rotationBadge.distancePx, hitRadiusPx: rotationBadge.sizePx } }\n        : {}),\n    }),\n    createCornerResizeAffordance({ handleHitRadius }),\n    ...(getAnchorState\n      ? createPathAnchorAffordances(getAnchorState, { hitRadius: anchorHitRadius })\n      : []),\n  ];\n}\n\n/**\n * Read anchor-editing state off a dep registry, for\n * {@link ChromeAffordanceOptions.getAnchorState}. Returns `null` while no\n * `editAnchors` dep is registered, so anchors are not hit-tested.\n */\nexport function anchorStateFrom(\n  getRegistry: () => { get(name: 'editAnchors'): EditAnchorsDep | undefined } | null,\n  /** The editable path in the world the hit-test is asked in. A node on a\n   *  parallax plane stores its path in the plane's world; the surface carries\n   *  it into the asking camera's. Default: unchanged. */\n  toCamera?: (id: string, path: unknown) => unknown,\n): () => AnchorState | null {\n  return () => {\n    const dep = getRegistry()?.get('editAnchors');\n    if (!dep) return null;\n    return {\n      editingId: dep.editingId ?? null,\n      // The hit-test reads world-coord anchor positions, so route through\n      // `getEditablePath`: both pose-as-polygon and `data.path` consumers\n      // resolve correctly.\n      getPose: (id) => (toCamera ? toCamera(id, dep.getEditablePath(id)) : dep.getEditablePath(id)),\n    };\n  };\n}\n\n/**\n * Build the `affordanceAt` thunk for `GestureDispatcherMounter`. The point is\n * **world-space**; callers convert from client coords first. Priority follows\n * the order of {@link chromeAffordances}, topmost first.\n */\nexport function buildAffordanceAt(\n  opts: BuildAffordanceAtOptions,\n): (worldPoint: { x: number; y: number }) => AffordanceHit | null {\n  const { getChromeState, getView, getIsVisible } = opts;\n  const affordances = opts.affordances ?? chromeAffordances(opts);\n\n  return function affordanceAt({ x: wx, y: wy }) {\n    const hit = hitAffordanceRegions(\n      affordances,\n      wx,\n      wy,\n      getChromeState(),\n      getView(),\n      getIsVisible?.(),\n    );\n    return hit ? toAffordanceHit(hit) : null;\n  };\n}\n\n/**\n * Region hit → `AffordanceHit`. The scratch fields named by\n * {@link CommonAffordanceScratch} are lifted onto the hit because the actions\n * that consume them read them there; the whole scratch rides along as `payload`.\n */\nfunction toAffordanceHit(hit: AffordanceRegionHit): AffordanceHit {\n  const scratch = (hit.binding.initialScratch ?? {}) as CommonAffordanceScratch;\n  return {\n    kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,\n    owner: hit.affordanceId,\n    strength: 'shared',\n    ...(scratch.targetId !== undefined ? { targetIds: [scratch.targetId] } : {}),\n    ...(scratch.anchor !== undefined ? { anchor: scratch.anchor } : {}),\n    ...(scratch.fixedPoint !== undefined ? { fixedPoint: scratch.fixedPoint } : {}),\n    ...(hit.region.cursor !== undefined ? { cursor: hit.region.cursor } : {}),\n    ...(hit.binding.initialScratch !== undefined ? { payload: hit.binding.initialScratch } : {}),\n  } as AffordanceHit;\n}\n\n/**\n * Classify a world-space point against the current selection: `'empty'`,\n * `'selected-body'`, or `'unselected-body'`.\n *\n * @param kindOfNode - Resolver from a hit node id to its semantic kind.\n *   Omitting it leaves `kind` undefined, which makes every `kind:` TargetSpec\n *   form no-match.\n */\nexport function buildClassifyTarget(\n  getSelection: () => readonly string[],\n  pickBest: (wx: number, wy: number) => string | null,\n  kindOfNode?: (id: string) => string | undefined,\n): (worldPoint: { x: number; y: number }) => BodyClassification {\n  return function classifyTarget({ x: wx, y: wy }) {\n    const hitId = pickBest(wx, wy);\n    if (!hitId) return { body: 'empty' };\n    const sel = getSelection();\n    return {\n      body: sel.includes(hitId) ? 'selected-body' : 'unselected-body',\n      kind: kindOfNode?.(hitId),\n    };\n  };\n}\n\n/** A registered layer's claim on a point, as the affordance the dispatcher\n *  routes: its kind names the layer, and it carries what the layer's hit-test\n *  resolved. */\nexport function layerAffordance(layerId: string, claim: LayerHit): AffordanceHit {\n  return {\n    kind: `layer:${layerId}`,\n    owner: layerId,\n    strength: claim.strength ?? 'shared',\n    ...(claim.claimedKinds !== undefined ? { claimedKinds: claim.claimedKinds } : {}),\n    ...(claim.cursor !== undefined ? { cursor: claim.cursor } : {}),\n    ...(claim.initialScratch !== undefined ? { payload: claim.initialScratch } : {}),\n  };\n}\n"],"mappings":";;;;;;AAgEA,SAAgBA,EAAkB,IAAgC,CAAC,GAAiB;CAClF,IAAMC,IAAQC,EAAcC,EAAK,WAAW,GACtC,EACJ,qBAAkBF,EAAM,QACxB,qBAAkBA,EAAM,QACxB,kBAAeA,EAAM,kBACrB,mBACA,qBACEE;CACJ,OAAO;EACLC,EAAyB;GACvB,QAAQC;GACR,OAAO;GACP,GAAIC,IACA,EAAE,QAAQ;IAAE,YAAYA,EAAc;IAAY,aAAaA,EAAc;GAAO,EAAE,IACtF,CAAC;EACP,CAAC;EACDC,EAA6B,EAAE,mBAAgB,CAAC;EAChD,GAAIC,IACAC,EAA4BD,GAAgB,EAAE,WAAWE,EAAgB,CAAC,IAC1E,CAAC;CACP;AACF;AAOA,SAAgBC,EACd,GAIA,GAC0B;CAC1B,aAAa;EACX,IAAMC,IAAMC,EAAY,CAAC,EAAE,IAAI,aAAa;EAE5C,OADKD,IACE;GACL,WAAWA,EAAI,aAAa;GAI5B,UAAU,MAAQE,IAAWA,EAASC,GAAIH,EAAI,gBAAgBG,CAAE,CAAC,IAAIH,EAAI,gBAAgBG,CAAE;EAC7F,IAPiB;CAQnB;AACF;AAOA,SAAgBC,EACd,GACgE;CAChE,IAAM,EAAE,mBAAgB,YAAS,oBAAiBb,GAC5Cc,IAAcd,EAAK,eAAeH,EAAkBG,CAAI;CAE9D,OAAO,SAAsB,EAAE,GAAGe,GAAI,GAAGC,KAAM;EAC7C,IAAMC,IAAMC,EACVJ,GACAC,GACAC,GACAG,EAAe,GACfC,EAAQ,GACRC,IAAe,CACjB;EACA,OAAOJ,IAAMK,EAAgBL,CAAG,IAAI;CACtC;AACF;AAOA,SAASK,EAAgB,GAAyC;CAChE,IAAMC,IAAWN,EAAI,QAAQ,kBAAkB,CAAC;CAChD,OAAO;EACL,MAAMA,EAAI,OAAO,WAAW,GAAGA,EAAI,aAAa,GAAGA,EAAI;EACvD,OAAOA,EAAI;EACX,UAAU;EACV,GAAIM,EAAQ,aAAa,KAAA,IAAgD,CAAC,IAArC,EAAE,WAAW,CAACA,EAAQ,QAAQ,EAAE;EACrE,GAAIA,EAAQ,WAAW,KAAA,IAAyC,CAAC,IAA9B,EAAE,QAAQA,EAAQ,OAAO;EAC5D,GAAIA,EAAQ,eAAe,KAAA,IAAiD,CAAC,IAAtC,EAAE,YAAYA,EAAQ,WAAW;EACxE,GAAIN,EAAI,OAAO,WAAW,KAAA,IAA4C,CAAC,IAAjC,EAAE,QAAQA,EAAI,OAAO,OAAO;EAClE,GAAIA,EAAI,QAAQ,mBAAmB,KAAA,IAAsD,CAAC,IAA3C,EAAE,SAASA,EAAI,QAAQ,eAAe;CACvF;AACF;AAUA,SAAgBO,EACd,GACA,GACA,GAC8D;CAC9D,OAAO,SAAwB,EAAE,GAAGT,GAAI,GAAGC,KAAM;EAC/C,IAAMS,IAAQC,EAASX,GAAIC,CAAE;EAG7B,OAFKS,IAEE;GACL,MAFUE,EAEJ,CAAA,CAAI,SAASF,CAAK,IAAI,kBAAkB;GAC9C,MAAMG,IAAaH,CAAK;EAC1B,IALmB,EAAE,MAAM,QAAQ;CAMrC;AACF;AAKA,SAAgBI,EAAgB,GAAiB,GAAgC;CAC/E,OAAO;EACL,MAAM,SAASC;EACf,OAAOA;EACP,UAAUC,EAAM,YAAY;EAC5B,GAAIA,EAAM,iBAAiB,KAAA,IAAmD,CAAC,IAAxC,EAAE,cAAcA,EAAM,aAAa;EAC1E,GAAIA,EAAM,WAAW,KAAA,IAAuC,CAAC,IAA5B,EAAE,QAAQA,EAAM,OAAO;EACxD,GAAIA,EAAM,mBAAmB,KAAA,IAAgD,CAAC,IAArC,EAAE,SAASA,EAAM,eAAe;CAC3E;AACF"}

package/dist/canvas/buildSceneLayer.js

@@ -0,0 +1,111 @@
+import { sceneLayerKey as e } from "./sceneLayerPaint.js";
+import { wrapNodeOutput as t } from "./wrapNodeOutput.js";
+import { adapterDerivedPathOf as n } from "./adapterDerivedPath.js";
+import { buildSceneTree as r } from "./buildSceneTree.js";
+import { paintMissesView as i } from "./paintCull.js";
+import { debugSinkFrom as a } from "./drawEnvelope.js";
+import { cullDrawCommands as o, viewToMat3 as s } from "@weasel-js/renderer";
+//#region src/canvas/buildSceneLayer.ts
+function c(e, t, r) {
+	let i = e.drawOne;
+	if (e.derivedPathOf !== void 0 || !i || !t) return e;
+	let a = n(e.toPose === void 0 ? t : {
+		getNode: (e) => t.getNode(e),
+		getPose: (e) => {
+			let n = t.getNode(e);
+			return n ? r(n) : t.getPose(e);
+		},
+		getChildren: (e) => t.getChildren(e)
+	});
+	return {
+		derivedPathOf: (e) => a(e.id),
+		drawOne: (e, t, n, r) => e.dependsOn === void 0 ? i(e, t, n, r) : i(e, t, n, {
+			...r,
+			derivedPath: a(e.id)
+		})
+	};
+}
+function l(e, n, l, u, d) {
+	let f = e.toPose ?? ((e) => n ? n.getPose(e.id) : e), { drawOne: p, derivedPathOf: m } = c(e, n, f), h = e.postProcess, g = e.cull ? (e, t, n) => o(e, s(t), {
+		x: 0,
+		y: 0,
+		width: n.width,
+		height: n.height
+	}) : (e) => e, _ = e.cull ? e.paintBounds : void 0, v = (e, t) => _ ? i(_, e, {
+		x: 0,
+		y: 0,
+		width: t.width,
+		height: t.height
+	}) : void 0;
+	return {
+		id: d?.id ?? "scene",
+		label: d ? `Scene: ${d.forLayer}` : "Scene",
+		draw: (i, o, s) => {
+			let c = a(i), _ = u(), y = n;
+			if (y && e.objects === void 0 && p) {
+				let n = (n, r, i) => {
+					if (_ && _.has(n.id)) return [];
+					let a = p(n, r, i);
+					if (c) {
+						let e = l ? l(n.id) : null;
+						e && c.recordBounds(n.id, e);
+						let t = r.x ?? (e ? e.x : 0), i = r.y ?? (e ? e.y : 0);
+						c.recordOrigin(n.id, {
+							x: t,
+							y: i
+						});
+					}
+					return t(a, r, e.alphaFor ? e.alphaFor(n.id) : 1);
+				}, i = e.toPose ? {
+					...y,
+					getPose: (e) => {
+						let t = y.getNode(e);
+						return t ? f(t) : y.getPose(e);
+					}
+				} : y, a = r(i, n, o, d?.forLayer, m, v(o, s));
+				return g(h ? h(a, o, s) : a, o, s);
+			}
+			let b = e.objects ?? [], x = [], S = v(o, s);
+			for (let n of b) {
+				if (_ && _.has(n.id)) continue;
+				let r = f(n);
+				if (p && !S?.(n, r)) {
+					let i = p(n, r, o), a = t(i, r, e.alphaFor ? e.alphaFor(n.id) : 1);
+					for (let e of a) x.push(e);
+				}
+				if (c) {
+					let e = l ? l(n.id) : null;
+					e && c.recordBounds(n.id, {
+						x: e.x,
+						y: e.y,
+						width: e.width,
+						height: e.height
+					});
+					let t = r.x ?? (e ? e.x : 0), i = r.y ?? (e ? e.y : 0);
+					c.recordOrigin(n.id, {
+						x: t,
+						y: i
+					});
+				}
+			}
+			return g(h ? h(x, o, s) : x, o, s);
+		}
+	};
+}
+function u(t, n, r, i) {
+	let a = t.objects === void 0 && n ? n.getLayers().map((e) => e.id) : null;
+	return !a || a.length === 0 ? [{
+		key: "scene",
+		layer: l(t, n, r, i)
+	}] : a.map((a) => ({
+		key: e(a),
+		layer: l(t, n, r, i, {
+			id: e(a),
+			forLayer: a
+		})
+	}));
+}
+//#endregion
+export { l as buildSceneLayer, u as buildSceneLayers };
+
+//# sourceMappingURL=buildSceneLayer.js.map

package/dist/canvas/buildSceneLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSceneLayer.js","names":["withAdapterDerivedPaths","drawOne","cfg","adapter","pathOf","adapterDerivedPathOf","id","obj","toPose","pose","view","ctx","buildSceneLayer","postProcess","finish","cullDrawCommands","cmds","viewToMat3","dims","paintBounds","culledIn","paintMissesView","slot","debugSink","debugSinkFrom","data","hidden","hideIds","a","filteredDrawOne","v","b","boundsOfFn","ox","oy","wrapNodeOutput","hierarchicalAdapter","tree","buildSceneTree","derivedPathOf","objects","children","culled","wrapped","cmd","buildSceneLayers","sceneLayerIds","l","sceneLayerKey"],"sources":["../../src/canvas/buildSceneLayer.ts"],"sourcesContent":["/**\n * The scene slot: an adapter's tree as render layers, one per scene layer.\n */\nimport type { Path } from '@weasel-js/geom';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { View } from 'core/viewport/view';\nimport { cullDrawCommands, viewToMat3, type DrawCommand } from '@weasel-js/renderer';\nimport { adapterDerivedPathOf } from './adapterDerivedPath';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { debugSinkFrom } from './drawEnvelope';\nimport type { NodePaintCtx } from './NodeShape';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { sceneLayerKey } from './sceneLayerPaint';\nimport { wrapNodeOutput } from './wrapNodeOutput';\n\n/** Scene slot config — describes how to draw one object with its effective pose. */\nexport interface SceneSlotConfig<TNode extends { id: string }, TPose> {\n  /** Paint these, in this order, in place of the adapter's tree: one flat run with no\n   *  scene layers, no container clips, and no pose composition. */\n  objects?: TNode[];\n  /** Project an object to its committed pose. Defaults to `adapter.getPose(obj.id)`. */\n  toPose?: (obj: TNode) => TPose;\n  /** Draw a single object as a `DrawCommand` tree. `ctx` carries a derived\n   *  node's path: `<SceneCanvas>` resolves it from the scene, and\n   *  `buildSceneLayer` called without one from its adapter. */\n  drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];\n  /** The path a container derives from its dependencies' poses, for the clip\n   *  it imposes on its subtree — `drawOne`'s `ctx` carries the derived path a\n   *  node *paints*, this one the clip it *imposes*. A scene-aware caller\n   *  supplies it; left out, both are resolved off the adapter. */\n  derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;\n  /** Default ghost alpha for the move-overlay slot. Default 0.85. */\n  ghostAlpha?: number;\n  /** Per-id alpha multiplier. A node's emitted `DrawCommand[]` is wrapped in a\n   *  `{ kind: 'group', alpha }` when the returned value is not 1. */\n  alphaFor?: (id: string) => number;\n  /**\n   * Post-processor for the scene slot's emitted commands: called with the final\n   * world-space `DrawCommand[]` each time a scene canvas layer draws (after per-node\n   * rotation wrapping and `alphaFor`), once per layer when the slot is split into\n   * `scene:<layerId>` layers. Its return value replaces the array handed to the renderer.\n   *\n   * Commands are world-space — `drawLayers` applies the view transform afterward. Clip\n   * nesting is capped at 7 levels; a wrapping group with `clip` consumes one. The\n   * move-overlay ghost (drag preview) is not post-processed.\n   */\n  postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Skip what cannot reach the view. A node `paintBounds` places outside the\n   * `dims` rectangle under `view` is not painted at all; then, after\n   * `postProcess`, `cullDrawCommands` drops any remaining command that cannot\n   * reach it — see there for what it can and cannot bound. So `postProcess`\n   * sees an empty group where a culled node would have painted.\n   *\n   * Off by default because it makes the layer's world-space output depend on\n   * the view: anything that draws this layer once and shows the result under\n   * another view — a cache keyed without `view`, a consumer re-wrapping the\n   * commands — would show the first view's cull.\n   */\n  cull?: boolean;\n  /**\n   * Where `drawOne`'s output for a node can reach, in the frame it paints in\n   * — before the pose rotation the slot wraps it in. `null` for a node it\n   * cannot bound cheaply. Read only under `cull`, which skips `drawOne` for a\n   * node whose box misses the view, so it must enclose everything `drawOne`\n   * paints: a box too small makes a node vanish before it leaves the screen.\n   *\n   * `<SceneCanvas>` supplies `defaultPaintBounds` while `drawOne` is\n   * `defaultDrawOne`. Omit it with any other `drawOne` and culling only\n   * trims commands after painting.\n   */\n  paintBounds?: PaintBoundsFn<TNode, TPose>;\n}\n\n/**\n * `cfg`'s `drawOne` and clip lookup, resolving derived paths off the adapter\n * when nothing scene-aware filled `derivedPathOf` in.\n */\nfunction withAdapterDerivedPaths<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: HierarchicalAdapter<TNode, TPose> | undefined,\n  toPose: (obj: TNode) => TPose,\n): Pick<SceneSlotConfig<TNode, TPose>, 'drawOne' | 'derivedPathOf'> {\n  const drawOne = cfg.drawOne;\n  if (cfg.derivedPathOf !== undefined || !drawOne || !adapter) return cfg;\n  const pathOf = adapterDerivedPathOf<TPose>(cfg.toPose === undefined ? adapter : {\n    getNode: (id) => adapter.getNode(id),\n    getPose: (id) => {\n      const obj = adapter.getNode(id);\n      return obj ? toPose(obj) : adapter.getPose(id);\n    },\n    getChildren: (id) => adapter.getChildren(id),\n  });\n  return {\n    derivedPathOf: (obj) => pathOf(obj.id),\n    drawOne: (obj, pose, view, ctx) => ((obj as { dependsOn?: unknown }).dependsOn === undefined\n      ? drawOne(obj, pose, view, ctx)\n      : drawOne(obj, pose, view, { ...ctx, derivedPath: pathOf(obj.id) })),\n  };\n}\n\n/**\n * Build the scene layer, which draws committed poses. `hideIds()` skips the committed paint\n * of ids the active tool is currently ghosting so the source doesn't show through. With a\n * debug sink on its draw envelope, it records each node's bounds and origin there.\n */\nexport function buildSceneLayer<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: HierarchicalAdapter<TNode, TPose> | undefined,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n  /** When set, the returned layer carries this `id` and paints ONLY the named\n   *  scene layer (the rest are walked for ancestor clips). Omit for the single\n   *  bundled `scene` layer. */\n  slot?: { id: string; forLayer: string },\n): RenderLayer<unknown> {\n  const toPose =\n    cfg.toPose ??\n    ((obj: TNode) => (adapter ? adapter.getPose(obj.id) : (obj as unknown as TPose)));\n  const { drawOne, derivedPathOf } = withAdapterDerivedPaths(cfg, adapter, toPose);\n  const postProcess = cfg.postProcess;\n  const finish = cfg.cull\n    ? (cmds: DrawCommand[], view: View, dims: Dims): DrawCommand[] =>\n      cullDrawCommands(cmds, viewToMat3(view), { x: 0, y: 0, width: dims.width, height: dims.height })\n    : (cmds: DrawCommand[]): DrawCommand[] => cmds;\n  const paintBounds = cfg.cull ? cfg.paintBounds : undefined;\n  const culledIn = (view: View, dims: Dims) => paintBounds\n    ? paintMissesView(paintBounds, view, { x: 0, y: 0, width: dims.width, height: dims.height })\n    : undefined;\n  return {\n    id: slot?.id ?? 'scene',\n    label: slot ? `Scene: ${slot.forLayer}` : 'Scene',\n    draw: (data, view, dims) => {\n      const debugSink = debugSinkFrom(data);\n      const hidden = hideIds();\n      const a = adapter;\n      if (a && cfg.objects === undefined && drawOne) {\n        const filteredDrawOne = (obj: TNode, pose: TPose, v: View): DrawCommand[] => {\n          if (hidden && hidden.has(obj.id)) return [];\n          const cmds = drawOne(obj, pose, v);\n          if (debugSink) {\n            const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n            if (b) debugSink.recordBounds(obj.id, b);\n            const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n            const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n            debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n          }\n          return wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n        };\n        // Honor cfg.toPose on the hierarchical path by shimming getPose on the\n        // adapter so buildSceneTree routes through it instead of the raw adapter.\n        const hierarchicalAdapter = cfg.toPose\n          ? {\n              ...a,\n              getPose: (id: string) => {\n                const obj = a.getNode(id);\n                return obj ? toPose(obj) : a.getPose(id);\n              },\n            }\n          : a;\n        // World-space commands; drawLayers wraps in viewToMat3 automatically.\n        const tree = buildSceneTree(\n          hierarchicalAdapter as unknown as Parameters<typeof buildSceneTree>[0],\n          filteredDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n          view,\n          slot?.forLayer,\n          derivedPathOf as Parameters<typeof buildSceneTree>[4],\n          culledIn(view, dims) as Parameters<typeof buildSceneTree>[5],\n        );\n        return finish(postProcess ? postProcess(tree, view, dims) : tree, view, dims);\n      }\n      // `cfg.objects`: the caller's own list, which has no scene layers to split by.\n      const objects = cfg.objects ?? [];\n      const children: DrawCommand[] = [];\n      const culled = culledIn(view, dims);\n      for (const obj of objects) {\n        if (hidden && hidden.has(obj.id)) continue;\n        const pose: TPose = toPose(obj);\n        if (drawOne && !culled?.(obj, pose)) {\n          const cmds = drawOne(obj, pose, view);\n          const wrapped = wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n          for (const cmd of wrapped) children.push(cmd);\n        }\n        if (debugSink) {\n          const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n          if (b) debugSink.recordBounds(obj.id, { x: b.x, y: b.y, width: b.width, height: b.height });\n          const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n          const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n          debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n        }\n      }\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      return finish(postProcess ? postProcess(children, view, dims) : children, view, dims);\n    },\n  };\n}\n\n/**\n * The scene slot as one canvas layer **per scene layer** — keyed `scene:<layerId>` — so\n * consumers can interleave custom layers *between* scene layers via the standard slot\n * anchoring (`before: 'scene:plantings'`). A single `scene` layer when `cfg.objects` replaces\n * the tree, or the adapter declares no layers.\n */\nexport function buildSceneLayers<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: HierarchicalAdapter<TNode, TPose> | undefined,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n): Array<{ key: string; layer: RenderLayer<unknown> }> {\n  const sceneLayerIds =\n    cfg.objects === undefined && adapter ? adapter.getLayers().map((l) => l.id) : null;\n  if (!sceneLayerIds || sceneLayerIds.length === 0) {\n    return [{ key: 'scene', layer: buildSceneLayer(cfg, adapter, boundsOfFn, hideIds) }];\n  }\n  return sceneLayerIds.map((id) => ({\n    key: sceneLayerKey(id),\n    layer: buildSceneLayer(cfg, adapter, boundsOfFn, hideIds, {\n      id: sceneLayerKey(id),\n      forLayer: id,\n    }),\n  }));\n}\n"],"mappings":";;;;;;;;AA+EA,SAASA,EACP,GACA,GACA,GACkE;CAClE,IAAMC,IAAUC,EAAI;CACpB,IAAIA,EAAI,kBAAkB,KAAA,KAAa,CAACD,KAAW,CAACE,GAAS,OAAOD;CACpE,IAAME,IAASC,EAA4BH,EAAI,WAAW,KAAA,IAAYC,IAAU;EAC9E,UAAU,MAAOA,EAAQ,QAAQG,CAAE;EACnC,UAAU,MAAO;GACf,IAAMC,IAAMJ,EAAQ,QAAQG,CAAE;GAC9B,OAAOC,IAAMC,EAAOD,CAAG,IAAIJ,EAAQ,QAAQG,CAAE;EAC/C;EACA,cAAc,MAAOH,EAAQ,YAAYG,CAAE;CAC7C,CAAC;CACD,OAAO;EACL,gBAAgB,MAAQF,EAAOG,EAAI,EAAE;EACrC,UAAU,GAAK,GAAM,GAAM,MAAUA,EAAgC,cAAc,KAAA,IAC/EN,EAAQM,GAAKE,GAAMC,GAAMC,CAAG,IAC5BV,EAAQM,GAAKE,GAAMC,GAAM;GAAE,GAAGC;GAAK,aAAaP,EAAOG,EAAI,EAAE;EAAE,CAAC;CACtE;AACF;AAOA,SAAgBK,EACd,GACA,GACA,GACA,GAIA,GACsB;CACtB,IAAMJ,IACJN,EAAI,YACF,MAAgBC,IAAUA,EAAQ,QAAQI,EAAI,EAAE,IAAKA,IACnD,EAAE,YAAS,qBAAkBP,EAAwBE,GAAKC,GAASK,CAAM,GACzEK,IAAcX,EAAI,aAClBY,IAASZ,EAAI,QACd,GAAqB,GAAY,MAClCa,EAAiBC,GAAMC,EAAWP,CAAI,GAAG;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOQ,EAAK;EAAO,QAAQA,EAAK;CAAO,CAAC,KAC9F,MAAuCF,GACtCG,IAAcjB,EAAI,OAAOA,EAAI,cAAc,KAAA,GAC3CkB,KAAY,GAAY,MAAeD,IACzCE,EAAgBF,GAAaT,GAAM;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOQ,EAAK;EAAO,QAAQA,EAAK;CAAO,CAAC,IACzF,KAAA;CACJ,OAAO;EACL,IAAII,GAAM,MAAM;EAChB,OAAOA,IAAO,UAAUA,EAAK,aAAa;EAC1C,OAAO,GAAM,GAAM,MAAS;GAC1B,IAAMC,IAAYC,EAAcC,CAAI,GAC9BC,IAASC,EAAQ,GACjBC,IAAIzB;GACV,IAAIyB,KAAK1B,EAAI,YAAY,KAAA,KAAaD,GAAS;IAC7C,IAAM4B,KAAmB,GAAY,GAAa,MAA2B;KAC3E,IAAIH,KAAUA,EAAO,IAAInB,EAAI,EAAE,GAAG,OAAO,CAAC;KAC1C,IAAMS,IAAOf,EAAQM,GAAKE,GAAMqB,CAAC;KACjC,IAAIP,GAAW;MACb,IAAMQ,IAAIC,IAAaA,EAAWzB,EAAI,EAAE,IAAI;MAC5C,AAAIwB,KAAGR,EAAU,aAAahB,EAAI,IAAIwB,CAAC;MACvC,IAAME,IAAMxB,EAAwB,MAAMsB,IAAIA,EAAE,IAAI,IAC9CG,IAAMzB,EAAwB,MAAMsB,IAAIA,EAAE,IAAI;MACpD,EAAU,aAAaxB,EAAI,IAAI;OAAE,GAAG0B;OAAI,GAAGC;MAAG,CAAC;KACjD;KACA,OAAOC,EAAenB,GAAMP,GAAMP,EAAI,WAAWA,EAAI,SAASK,EAAI,EAAE,IAAI,CAAC;IAC3E,GAGM6B,IAAsBlC,EAAI,SAC5B;KACE,GAAG0B;KACH,UAAU,MAAe;MACvB,IAAMrB,IAAMqB,EAAE,QAAQtB,CAAE;MACxB,OAAOC,IAAMC,EAAOD,CAAG,IAAIqB,EAAE,QAAQtB,CAAE;KACzC;IACF,IACAsB,GAEES,IAAOC,EACXF,GACAP,GACAnB,GACAY,GAAM,UACNiB,GACAnB,EAASV,GAAMQ,CAAI,CACrB;IACA,OAAOJ,EAAOD,IAAcA,EAAYwB,GAAM3B,GAAMQ,CAAI,IAAImB,GAAM3B,GAAMQ,CAAI;GAC9E;GAEA,IAAMsB,IAAUtC,EAAI,WAAW,CAAC,GAC1BuC,IAA0B,CAAC,GAC3BC,IAAStB,EAASV,GAAMQ,CAAI;GAClC,KAAK,IAAMX,KAAOiC,GAAS;IACzB,IAAId,KAAUA,EAAO,IAAInB,EAAI,EAAE,GAAG;IAClC,IAAME,IAAcD,EAAOD,CAAG;IAC9B,IAAIN,KAAW,CAACyC,IAASnC,GAAKE,CAAI,GAAG;KACnC,IAAMO,IAAOf,EAAQM,GAAKE,GAAMC,CAAI,GAC9BiC,IAAUR,EAAenB,GAAMP,GAAMP,EAAI,WAAWA,EAAI,SAASK,EAAI,EAAE,IAAI,CAAC;KAClF,KAAK,IAAMqC,KAAOD,GAAS,EAAS,KAAKC,CAAG;IAC9C;IACA,IAAIrB,GAAW;KACb,IAAMQ,IAAIC,IAAaA,EAAWzB,EAAI,EAAE,IAAI;KAC5C,AAAIwB,KAAGR,EAAU,aAAahB,EAAI,IAAI;MAAE,GAAGwB,EAAE;MAAG,GAAGA,EAAE;MAAG,OAAOA,EAAE;MAAO,QAAQA,EAAE;KAAO,CAAC;KAC1F,IAAME,IAAMxB,EAAwB,MAAMsB,IAAIA,EAAE,IAAI,IAC9CG,IAAMzB,EAAwB,MAAMsB,IAAIA,EAAE,IAAI;KACpD,EAAU,aAAaxB,EAAI,IAAI;MAAE,GAAG0B;MAAI,GAAGC;KAAG,CAAC;IACjD;GACF;GAEA,OAAOpB,EAAOD,IAAcA,EAAY4B,GAAU/B,GAAMQ,CAAI,IAAIuB,GAAU/B,GAAMQ,CAAI;EACtF;CACF;AACF;AAQA,SAAgB2B,EACd,GACA,GACA,GACA,GACqD;CACrD,IAAMC,IACJ5C,EAAI,YAAY,KAAA,KAAaC,IAAUA,EAAQ,UAAU,CAAC,CAAC,KAAK,MAAM4C,EAAE,EAAE,IAAI;CAIhF,OAHI,CAACD,KAAiBA,EAAc,WAAW,IACtC,CAAC;EAAE,KAAK;EAAS,OAAOlC,EAAgBV,GAAKC,GAAS6B,GAAYL,CAAO;CAAE,CAAC,IAE9EmB,EAAc,KAAK,OAAQ;EAChC,KAAKE,EAAc1C,CAAE;EACrB,OAAOM,EAAgBV,GAAKC,GAAS6B,GAAYL,GAAS;GACxD,IAAIqB,EAAc1C,CAAE;GACpB,UAAUA;EACZ,CAAC;CACH,EAAE;AACJ"}

package/dist/canvas/buildSceneTree.js

@@ -1,7 +1,7 @@
 import { deriveParallaxView as e, planeMap as t } from "../core/viewport/parallax.js";
 import { definesFrame as n } from "../core/scene/effectivePose.js";
-import { findShapeSilhouette as r } from "./NodeShape.js";
-import { clipCarrier as i, planeTransform as a } from "./planeClips.js";
+import { clipCarrier as r, planeTransform as i } from "./planeClips.js";
+import { findShapeSilhouette as a } from "./NodeShape.js";
 import { scenePlaneOf as o } from "./pickWalk.js";
 //#region src/canvas/buildSceneTree.ts
 function s(e, t, n, r) {
@@ -18,36 +18,33 @@ function s(e, t, n, r) {
 }
 function c(c, l, u, d, f, p) {
 	let m = c.getLayers(), h = /* @__PURE__ */ new Map();
-	for (let e of m) h.set(e.id, []);
+	for (let e of m) e.visible && h.set(e.id, []);
 	let g = null;
 	for (let t of m) t.parallax && (g ??= /* @__PURE__ */ new Map()).set(t.id, e(u, t.parallax));
-	let _ = c.composePose?.bind(c), v = i(g ? o(m, u) : null);
-	function y(e, t, i) {
-		let a = c.getNode(e);
-		if (!a) return;
-		let o = c.getPose(e), m = _ && i !== null ? _(i, o) : o, b = d === void 0 || a.layer === d, x = g?.get(a.layer) ?? u, S = b && !p?.(a, m, x) ? l(a, m, x) : [], C = t, w = a;
+	let _ = c.composePose?.bind(c), v = r(g ? o(m, u) : null);
+	function y(e, t, r) {
+		let i = c.getNode(e);
+		if (!i) return;
+		let o = c.getPose(e), m = _ && r !== null ? _(r, o) : o, b = d === void 0 || i.layer === d ? h.get(i.layer) : void 0, x = g?.get(i.layer) ?? u, S = b && !p?.(i, m, x) ? l(i, m, x) : [], C = t, w = i;
 		if (w.kind === "container") {
 			let e;
-			e = typeof w.clipFromPose == "function" ? w.clipFromPose(m) : r(a, m, { derivedPath: f?.(a, m) }), e && (C = [...t, {
+			e = typeof w.clipFromPose == "function" ? w.clipFromPose(m) : a(i, m, { derivedPath: f?.(i, m) }), e && (C = [...t, {
 				path: e,
-				layer: a.layer
+				layer: i.layer
 			}]);
 		}
-		if (b) {
-			let e = h.get(a.layer);
-			e && e.push(C.length > 0 ? s(S, C, a.layer, v) : {
-				kind: "group",
-				children: S
-			});
-		}
-		let T = n(a) ? m : i;
+		b && b.push(C.length > 0 ? s(S, C, i.layer, v) : {
+			kind: "group",
+			children: S
+		});
+		let T = n(i) ? m : r;
 		for (let t of c.getChildren(e)) y(t, C, T);
 	}
 	for (let e of c.getChildren(null)) y(e, [], null);
 	let b = [];
 	for (let e of m) {
 		if (!e.visible || d !== void 0 && e.id !== d) continue;
-		let n = h.get(e.id) ?? [], r = e.parallax ? a(t(u, e.parallax), null) : void 0;
+		let n = h.get(e.id) ?? [], r = e.parallax ? i(t(u, e.parallax), null) : void 0;
 		b.push(r ? {
 			kind: "group",
 			transform: r,

package/dist/canvas/buildSceneTree.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildSceneTree.js","names":["wrapInClips","node","cmds","i","clips","carry","toLayer","buildSceneTree","layers","adapter","buckets","l","planeViews","deriveParallaxView","view","compose","clipCarrier","scenePlaneOf","visit","id","local","pose","parentFrame","paints","forLayer","v","self","culled","drawOne","ownClips","ancestorClips","maybeContainer","clip","findShapeSilhouette","derivedPathOf","bucket","childFrame","definesFrame","cid","rootId","out","layer","children","transform","planeTransform","planeMap"],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '../renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport type { Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\n\n/**\n * The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter`\n * satisfies this; flat (non-hierarchical) adapters don't. Canvas exposes these\n * as *optional* methods on `CanvasProps.adapter` (see `OptionalSceneHierarchy`)\n * and feature-detects them at draw time.\n */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in. */\ninterface ChainClip { path: Path; layer: string }\n\n/** Wrap `cmds` in one nested group per clip so the renderer intersects them.\n *  Outermost group carries the ancestor-most clip; innermost holds `cmds`. */\nfunction wrapInClips(\n  cmds: DrawCommand[],\n  clips: readonly ChainClip[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = clips.length - 1; i >= 0; i--) {\n    node = { kind: 'group', children: [node], clip: carry(clips[i].path, clips[i].layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the\n * bucket for **that node's own `layer`** — not its parent's. So a child whose\n * `layer` differs from its parent (e.g. a planting tagged into a top-most\n * `plantings` layer while remaining a scene child of its container) draws in\n * its own layer's pass, on top of every container body, while staying a tree\n * child for hit-testing / move / reparent.\n *\n * Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * **Positioning** is world-space: `drawOne` returns world-coord commands (the\n * caller wraps the whole thing in the view transform). Because a node may be\n * drawn outside its parent's group, the tree nesting cannot carry geometry as\n * renderer state; instead the walk folds each node's pose into its parent's\n * frame on the way down and hands the painter a **world** pose. Clips are\n * accumulated the same way and are world-space for the same reason — each in\n * its container's plane, carried into the plane of the node it clips.\n *\n * With no `composePose` on the adapter the fold is the identity, every node\n * paints at its stored pose, and this is the absolute-pose behavior the kit\n * shipped before frames existed.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the\n * view derived for it, and its group carries the transform from its world to\n * the camera's, so the caller's single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. Used to render\n   *  scene layers as separate, individually-orderable canvas slots. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses. Only a\n   *  scene-backed caller can answer — deriving needs the dependencies' poses —\n   *  so the bare-adapter path omits it and a derived container contributes no\n   *  clip there, exactly as before. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainClip[],\n    parentFrame: TPose | null,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const paints = forLayer === undefined || node.layer === forLayer;\n    const v = planeViews?.get(node.layer) ?? view;\n    const self = paints && !culled?.(node, pose, v) ? drawOne(node, pose, v) : [];\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    const maybeContainer = node as { kind?: string; clipFromPose?: (pose: TPose) => unknown };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → fall back to the painter silhouette for the\n        // container's shape kind. Built-ins give rect-fallback containers\n        // their own AABB as a clip; consumer painters can provide arbitrary\n        // closed shapes (ellipse, polygon, …) without per-node wiring.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) ownClips = [...ancestorClips, { path: clip as Path, layer: node.layer }];\n    }\n\n    // Emit this node's own paint into its own layer's bucket, clipped by the\n    // accumulated chain (ancestors + own). Every node emits a wrapper group\n    // even with empty paint, keeping the per-node tree shape stable.\n    if (paints) {\n      const bucket = buckets.get(node.layer);\n      if (bucket) {\n        bucket.push(ownClips.length > 0 ? wrapInClips(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n      }\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    for (const cid of adapter.getChildren(id)) visit(cid, ownClips, childFrame);\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":";;;;;;AAgCA,SAASA,EACP,GACA,GACA,GACA,GACa;CACb,IAAIC,IAAyB;EAAE,MAAM;EAAS,UAAUC;CAAK;CAC7D,KAAK,IAAIC,IAAIC,EAAM,SAAS,GAAGD,KAAK,GAAG,KACrC,IAAO;EAAE,MAAM;EAAS,UAAU,CAACF,CAAI;EAAG,MAAMI,EAAMD,EAAMD,EAAE,CAAC,MAAMC,EAAMD,EAAE,CAAC,OAAOG,CAAO;CAAE;CAEhG,OAAOL;AACT;AA4BA,SAAgBM,EAId,GACA,GACA,GAIA,GAKA,GAGA,GACe;CACf,IAAMC,IAASC,EAAQ,UAAU,GAC3BC,oBAAU,IAAI,IAA2B;CAC/C,KAAK,IAAMC,KAAKH,GAAQ,EAAQ,IAAIG,EAAE,IAAI,CAAC,CAAC;CAC5C,IAAIC,IAAuC;CAC3C,KAAK,IAAMD,KAAKH,GACd,AAAIG,EAAE,aAAW,sBAAe,IAAI,IAAI,EAAA,CAAG,IAAIA,EAAE,IAAIE,EAAmBC,GAAMH,EAAE,QAAQ,CAAC;CAG3F,IAAMI,IAAUN,EAAQ,aAAa,KAAKA,CAAO,GAC3CJ,IAAQW,EAAYJ,IAAaK,EAAaT,GAAQM,CAAI,IAAI,IAAI;CAExE,SAASI,EACP,GACA,GACA,GACM;EACN,IAAMjB,IAAOQ,EAAQ,QAAQU,CAAE;EAC/B,IAAI,CAAClB,GAAM;EACX,IAAMmB,IAAQX,EAAQ,QAAQU,CAAE,GAG1BE,IAAON,KAAWO,MAAgB,OAAOP,EAAQO,GAAaF,CAAK,IAAIA,GAGvEG,IAASC,MAAa,KAAA,KAAavB,EAAK,UAAUuB,GAClDC,IAAIb,GAAY,IAAIX,EAAK,KAAK,KAAKa,GACnCY,IAAOH,KAAU,CAACI,IAAS1B,GAAMoB,GAAMI,CAAC,IAAIG,EAAQ3B,GAAMoB,GAAMI,CAAC,IAAI,CAAC,GAGxEI,IAAWC,GACTC,IAAiB9B;EACvB,IAAI8B,EAAe,SAAS,aAAa;GACvC,IAAIC;GAeJ,AAdA,AAQEA,IARE,OAAOD,EAAe,gBAAiB,aAElCA,EAAe,aAAaV,CAAI,IAMhCY,EACLhC,GACAoB,GACA,EAAE,aAAaa,IAAgBjC,GAAMoB,CAAI,EAAE,CAC7C,GAEEW,MAAM,IAAW,CAAC,GAAGF,GAAe;IAAE,MAAME;IAAc,OAAO/B,EAAK;GAAM,CAAC;EACnF;EAKA,IAAIsB,GAAQ;GACV,IAAMY,IAASzB,EAAQ,IAAIT,EAAK,KAAK;GACrC,AAAIkC,KACFA,EAAO,KAAKN,EAAS,SAAS,IAAI7B,EAAY0B,GAAMG,GAAU5B,EAAK,OAAOI,CAAK,IAAI;IAAE,MAAM;IAAS,UAAUqB;GAAK,CAAC;EAExH;EAGA,IAAMU,IAAaC,EAAapC,CAAa,IAAIoB,IAAOC;EACxD,KAAK,IAAMgB,KAAO7B,EAAQ,YAAYU,CAAE,GAAG,EAAMmB,GAAKT,GAAUO,CAAU;CAC5E;CAEA,KAAK,IAAMG,KAAU9B,EAAQ,YAAY,IAAI,GAAG,EAAM8B,GAAQ,CAAC,GAAG,IAAI;CAEtE,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAASjC,GAAQ;EAE1B,IADI,CAACiC,EAAM,WACPjB,MAAa,KAAA,KAAaiB,EAAM,OAAOjB,GAAU;EACrD,IAAMkB,IAAWhC,EAAQ,IAAI+B,EAAM,EAAE,KAAK,CAAC,GACrCE,IAAYF,EAAM,WAAWG,EAAeC,EAAS/B,GAAM2B,EAAM,QAAQ,GAAG,IAAI,IAAI,KAAA;EAC1F,EAAI,KAAKE,IAAY;GAAE,MAAM;GAAS;GAAW;EAAS,IAAI;GAAE,MAAM;GAAS;EAAS,CAAC;CAC3F;CACA,OAAOH;AACT"}
+{"version":3,"file":"buildSceneTree.js","names":["wrapInClips","node","cmds","i","clips","carry","toLayer","buildSceneTree","layers","adapter","buckets","l","planeViews","deriveParallaxView","view","compose","clipCarrier","scenePlaneOf","visit","id","local","pose","parentFrame","bucket","forLayer","v","self","culled","drawOne","ownClips","ancestorClips","maybeContainer","clip","findShapeSilhouette","derivedPathOf","childFrame","definesFrame","cid","rootId","out","layer","children","transform","planeTransform","planeMap"],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport type { Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\n\n/** The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter` is one. */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in. */\ninterface ChainClip { path: Path; layer: string }\n\n/** Wrap `cmds` in one nested group per clip so the renderer intersects them.\n *  Outermost group carries the ancestor-most clip; innermost holds `cmds`. */\nfunction wrapInClips(\n  cmds: DrawCommand[],\n  clips: readonly ChainClip[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = clips.length - 1; i >= 0; i--) {\n    node = { kind: 'group', children: [node], clip: carry(clips[i].path, clips[i].layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the bucket for\n * **that node's own `layer`** — not its parent's. So a child whose `layer` differs from its\n * parent draws in its own layer's pass while staying a tree child for hit-testing / move /\n * reparent. Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * `drawOne` returns world-coord commands. Because a node may be drawn outside its parent's\n * group, the tree nesting cannot carry geometry as renderer state; the walk folds each node's\n * pose into its parent's frame on the way down and hands the painter a **world** pose. Clips\n * are accumulated the same way — each in its container's plane, carried into the plane of the\n * node it clips. With no `composePose` on the adapter the fold is the identity.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the view derived for\n * it, and its group carries the transform from its world to the camera's, so the caller's\n * single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses: the scene's\n   *  lookup, or `adapterDerivedPathOf` for an adapter with no scene. Left out,\n   *  a derived container contributes no clip. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  // A hidden layer gets no bucket, and a node with no bucket is not painted.\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) if (l.visible) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainClip[],\n    parentFrame: TPose | null,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const bucket = forLayer === undefined || node.layer === forLayer\n      ? buckets.get(node.layer) : undefined;\n    const v = planeViews?.get(node.layer) ?? view;\n    const self = bucket && !culled?.(node, pose, v) ? drawOne(node, pose, v) : [];\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    const maybeContainer = node as { kind?: string; clipFromPose?: (pose: TPose) => unknown };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → the painter silhouette for the container's shape kind.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) ownClips = [...ancestorClips, { path: clip as Path, layer: node.layer }];\n    }\n\n    // Every node emits a wrapper group even with empty paint, keeping the per-node tree\n    // shape stable.\n    if (bucket) {\n      bucket.push(ownClips.length > 0 ? wrapInClips(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    for (const cid of adapter.getChildren(id)) visit(cid, ownClips, childFrame);\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":";;;;;;AA2BA,SAASA,EACP,GACA,GACA,GACA,GACa;CACb,IAAIC,IAAyB;EAAE,MAAM;EAAS,UAAUC;CAAK;CAC7D,KAAK,IAAIC,IAAIC,EAAM,SAAS,GAAGD,KAAK,GAAG,KACrC,IAAO;EAAE,MAAM;EAAS,UAAU,CAACF,CAAI;EAAG,MAAMI,EAAMD,EAAMD,EAAE,CAAC,MAAMC,EAAMD,EAAE,CAAC,OAAOG,CAAO;CAAE;CAEhG,OAAOL;AACT;AAkBA,SAAgBM,EAId,GACA,GACA,GAGA,GAIA,GAGA,GACe;CACf,IAAMC,IAASC,EAAQ,UAAU,GAE3BC,oBAAU,IAAI,IAA2B;CAC/C,KAAK,IAAMC,KAAKH,GAAQ,AAAIG,EAAE,WAASD,EAAQ,IAAIC,EAAE,IAAI,CAAC,CAAC;CAC3D,IAAIC,IAAuC;CAC3C,KAAK,IAAMD,KAAKH,GACd,AAAIG,EAAE,aAAW,sBAAe,IAAI,IAAI,EAAA,CAAG,IAAIA,EAAE,IAAIE,EAAmBC,GAAMH,EAAE,QAAQ,CAAC;CAG3F,IAAMI,IAAUN,EAAQ,aAAa,KAAKA,CAAO,GAC3CJ,IAAQW,EAAYJ,IAAaK,EAAaT,GAAQM,CAAI,IAAI,IAAI;CAExE,SAASI,EACP,GACA,GACA,GACM;EACN,IAAMjB,IAAOQ,EAAQ,QAAQU,CAAE;EAC/B,IAAI,CAAClB,GAAM;EACX,IAAMmB,IAAQX,EAAQ,QAAQU,CAAE,GAG1BE,IAAON,KAAWO,MAAgB,OAAOP,EAAQO,GAAaF,CAAK,IAAIA,GAGvEG,IAASC,MAAa,KAAA,KAAavB,EAAK,UAAUuB,IACpDd,EAAQ,IAAIT,EAAK,KAAK,IAAI,KAAA,GACxBwB,IAAIb,GAAY,IAAIX,EAAK,KAAK,KAAKa,GACnCY,IAAOH,KAAU,CAACI,IAAS1B,GAAMoB,GAAMI,CAAC,IAAIG,EAAQ3B,GAAMoB,GAAMI,CAAC,IAAI,CAAC,GAGxEI,IAAWC,GACTC,IAAiB9B;EACvB,IAAI8B,EAAe,SAAS,aAAa;GACvC,IAAIC;GAYJ,AAXA,AAKEA,IALE,OAAOD,EAAe,gBAAiB,aAElCA,EAAe,aAAaV,CAAI,IAGhCY,EACLhC,GACAoB,GACA,EAAE,aAAaa,IAAgBjC,GAAMoB,CAAI,EAAE,CAC7C,GAEEW,MAAM,IAAW,CAAC,GAAGF,GAAe;IAAE,MAAME;IAAc,OAAO/B,EAAK;GAAM,CAAC;EACnF;EAIA,AAAIsB,KACFA,EAAO,KAAKM,EAAS,SAAS,IAAI7B,EAAY0B,GAAMG,GAAU5B,EAAK,OAAOI,CAAK,IAAI;GAAE,MAAM;GAAS,UAAUqB;EAAK,CAAC;EAItH,IAAMS,IAAaC,EAAanC,CAAa,IAAIoB,IAAOC;EACxD,KAAK,IAAMe,KAAO5B,EAAQ,YAAYU,CAAE,GAAG,EAAMkB,GAAKR,GAAUM,CAAU;CAC5E;CAEA,KAAK,IAAMG,KAAU7B,EAAQ,YAAY,IAAI,GAAG,EAAM6B,GAAQ,CAAC,GAAG,IAAI;CAEtE,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAAShC,GAAQ;EAE1B,IADI,CAACgC,EAAM,WACPhB,MAAa,KAAA,KAAagB,EAAM,OAAOhB,GAAU;EACrD,IAAMiB,IAAW/B,EAAQ,IAAI8B,EAAM,EAAE,KAAK,CAAC,GACrCE,IAAYF,EAAM,WAAWG,EAAeC,EAAS9B,GAAM0B,EAAM,QAAQ,GAAG,IAAI,IAAI,KAAA;EAC1F,EAAI,KAAKE,IAAY;GAAE,MAAM;GAAS;GAAW;EAAS,IAAI;GAAE,MAAM;GAAS;EAAS,CAAC;CAC3F;CACA,OAAOH;AACT"}