@weasel-js/core 1.9.3 → 1.9.4

package/dist/canvas/SceneViewCanvas.js

@@ -1,54 +1,56 @@
 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 { useFrameLoop as t } from "./useFrameLoop.js";
+import { useLateContentRedraw as n } from "./useLateContentRedraw.js";
+import { useCanvasRenderer as r, useRedrawOnDensityChange as i, useRedrawOnRestore as a } from "./useCanvasRenderer.js";
+import { sceneViewFrame as o } from "./sceneViewRender.js";
+import { useCallback as s, useEffect as c, useLayoutEffect as l, useRef as u, useSyncExternalStore as d } from "react";
+import { assignRef as f, useLatest as p } from "@weasel-js/react";
+import { jsx as m } 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;
+function h(h) {
+	let { scene: g, width: _, height: v, drawOne: y, extraCommands: b, alphaFor: x, layerVisibility: S, layerOrder: C, animator: w, className: T, canvasRef: E, cull: D, paintBounds: O } = h, k = e(h.view);
+	d(g.subscribe, g.getVersion, g.getVersion);
+	let A = u(null), j = s((e) => {
+		A.current = e, f(E, e);
+	}, [E]), M = r(), N = p(() => {
+		let e = A.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
+		let t = o({
+			scene: g,
+			view: k,
+			width: _,
+			height: v,
+			drawOne: y,
+			extraCommands: b,
+			alphaFor: x,
+			layerVisibility: S,
+			layerOrder: C,
+			colorOverrides: w?.colorOverrides,
+			cull: D,
+			paintBounds: O
 		});
-		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 M.paint(e, t, k, {
+			width: _,
+			height: v
+		});
+	}), { requestRedraw: P } = t(s(() => N.current(), [N]), { target: A }), F = u(!1);
+	return l(() => {
+		if (F.current) {
+			P();
 			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
+		F.current = N.current(), F.current || P();
+	}), c(() => g.overrides.subscribe(P), [g, P]), c(() => w?.onTick(P), [w, P]), n(P), a(M, P), i(P), c(() => () => {
+		F.current = !1;
+	}, []), /* @__PURE__ */ m("canvas", {
+		ref: j,
+		width: _,
+		height: v,
+		className: T
 	});
 }
-var m = p;
+var g = h;
 //#endregion
-export { m as SceneViewCanvas };
+export { g 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","lease","useCanvasRenderer","paintRef","useLatest","canvas","commands","sceneViewFrame","animator","useFrameLoop","paintedRef","useLayoutEffect","requestRedraw","useEffect","useLateContentRedraw","useRedrawOnRestore","useRedrawOnDensityChange","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, and nothing paints while the canvas is off screen or the\n *     tab is hidden,\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`), which also\n * writes the element's inline `width` and `height` style in CSS pixels. That\n * beats a size set through `className`, so the class positions the canvas and\n * the `width` / `height` props size it.\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, useRedrawOnDensityChange, useRedrawOnRestore } 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 positioning the `<canvas>`. Its size is `width` ×\n   *  `height`, which the renderer writes as inline style. */\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 lease = 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    return lease.paint(canvas, commands, view, { width, height });\n  };\n  const paintRef = useLatest(paint);\n\n  const { requestRedraw } = useFrameLoop(\n    useCallback(() => paintRef.current(), [paintRef]),\n    { target: localRef },\n  );\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  useRedrawOnRestore(lease, requestRedraw);\n  useRedrawOnDensityChange(requestRedraw);\n\n  // A remount (StrictMode) paints its first frame in place again.\n  useEffect(() => () => { paintedRef.current = false; }, []);\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":";;;;;;;;;AAoGA,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,GAMRC,IAAQC,EAAkB,GAoB1BC,IAAWC,QAnBY;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;EACD,OAAOP,EAAM,MAAMI,GAAQC,GAAUf,GAAM;GAAE;GAAO;EAAO,CAAC;CAC9D,CACgC,GAE1B,EAAE,qBAAkBkB,EACxBZ,QAAkBM,EAAS,QAAQ,GAAG,CAACA,CAAQ,CAAC,GAChD,EAAE,QAAQT,EAAS,CACrB,GAOMgB,IAAaf,EAAO,EAAK;CAkB/B,OAjBAgB,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,GAClCG,EAAmBd,GAAOW,CAAa,GACvCI,EAAyBJ,CAAa,GAGtCC,cAAsB;EAAE,EAAW,UAAU;CAAO,GAAG,CAAC,CAAC,GAGvD,kBAAC,UAAD;EACE,KAAKjB;EACE;EACC;EACG;CACZ,CAAA;AAEL;AAWA,IAAaqB,IAAkB5B"}

package/dist/canvas/buildSceneLayer.js

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

package/dist/canvas/buildSceneLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSceneLayer.js","names":["buildSceneLayer","toPose","cfg","adapter","obj","drawOne","postProcess","finish","cullDrawCommands","cmds","viewToMat3","view","dims","paintBounds","culledIn","paintMissesView","slot","hidden","hideIds","a","filteredDrawOne","pose","v","debugSink","b","boundsOfFn","ox","oy","wrapNodeOutput","hierarchicalAdapter","id","tree","buildSceneTree","objects","children","culled","wrapped","cmd","buildSceneLayers","sceneLayerIds","l","sceneLayerKey"],"sources":["../../src/canvas/buildSceneLayer.ts"],"sourcesContent":["/**\n * The scene slot: how `<Canvas>` turns an adapter's nodes into render layers.\n * One layer for a flat adapter, one per scene layer for a hierarchical one.\n */\nimport type { Path } from '@weasel-js/geom';\nimport type { MoveAdapter, ResizeAdapter, RotateAdapter } from 'core/adapters/types';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { View } from 'core/viewport/view';\nimport type { DebugSink } from '../debug/types';\nimport { cullDrawCommands, viewToMat3, type DrawCommand } from '../renderer';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport type { NodePaintCtx } from './NodeShape';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { sceneLayerKey } from './sceneLayerPaint';\nimport { wrapNodeOutput } from './wrapNodeOutput';\n\n/**\n * The scene-tree reading methods Canvas feature-detects at draw time, as an\n * *optional* mixin. A `SceneCanvasAdapter` supplies them; flat / bare-Canvas\n * adapters don't. `getPose` already lives on the base move adapter, so only the\n * three tree-walk methods are added here.\n */\ntype OptionalSceneHierarchy<TNode, TPose> = Partial<\n  Pick<HierarchicalAdapter<TNode, TPose>, 'getLayers' | 'getNode' | 'getChildren'>\n>;\n\n/** The full adapter shape Canvas threads through layers + gesture hooks: the\n *  move/resize/rotate intersection plus the optional scene-tree methods. */\nexport type CanvasAdapter<TNode extends { id: string }, TPose> = MoveAdapter<TNode, TPose> &\n  ResizeAdapter<TNode, TPose> &\n  RotateAdapter<TNode, TPose> &\n  OptionalSceneHierarchy<TNode, TPose>;\n\n/** Scene slot config — describes how to draw one object with its effective pose. */\nexport interface SceneSlotConfig<TNode extends { id: string }, TPose> {\n  /** Override `adapter.getNodes()` for the object iteration. */\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 what only a\n   *  scene-aware caller can supply (a node's derived path); `<SceneCanvas>`\n   *  fills it in, bare `<Canvas>` never does. */\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. The other half of what only a scene-aware\n   *  caller can supply — `drawOne`'s `ctx` carries the derived path a node\n   *  *paints*, this one the clip it *imposes*. */\n  derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;\n  /** Default ghost alpha for the move-overlay slot. Default 0.85. */\n  ghostAlpha?: number;\n  /**\n   * Optional per-id alpha multiplier. When supplied, each node's emitted\n   * `DrawCommand[]` is wrapped in a `{ kind: 'group', alpha }` when the\n   * returned value is not 1. The scoping-dim integration supplies this to\n   * dim non-active nodes during a mode transition.\n   *\n   * Defaults to `() => 1` (no effect).\n   */\n  alphaFor?: (id: string) => number;\n  /**\n   * Optional post-processor for the scene slot's emitted commands. Called\n   * with the final world-space `DrawCommand[]` each time a scene canvas\n   * layer draws (after per-node rotation wrapping and `alphaFor`); the\n   * return value replaces the array handed to the renderer. When the scene\n   * slot is split into per-scene-layer canvas layers (`scene:<layerId>`),\n   * it runs once per layer. Identity by default.\n   *\n   * Commands are world-space — `drawLayers` applies the view transform\n   * afterward, so e.g. a `clip` path in a wrapping group is authored in\n   * world coordinates. Note clip nesting is capped at 7 levels; a wrapping\n   * group with `clip` consumes one.\n   *\n   * The 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 * Build the scene layer. Tool ghosts (in-flight drag/resize/rotate poses) are\n * published via the active tool's `previewPose`/`previewIds` and rendered on\n * top of this layer (see SceneCanvas's preview-ghost layer); we draw committed\n * poses here, and `hideIds()` lets us skip the committed paint of ids the\n * active tool is currently ghosting so the source doesn't show through.\n */\nexport function buildSceneLayer<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: CanvasAdapter<TNode, TPose> | undefined,\n  debugSink: DebugSink | null,\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). Used to split the\n   *  scene slot into per-scene-layer, individually-orderable canvas layers\n   *  (`scene:<layerId>`) so consumers can interleave custom layers between\n   *  them. Omit for the single 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 = cfg.drawOne;\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 hidden = hideIds();\n      const a = adapter;\n      if (\n        a &&\n        cfg.objects === undefined &&\n        typeof a.getLayers === 'function' &&\n        typeof a.getNode === 'function' &&\n        typeof a.getChildren === 'function' &&\n        drawOne\n      ) {\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 Parameters<typeof buildSceneTree>[0],\n          filteredDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n          view,\n          slot?.forLayer,\n          cfg.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      // Flat fallback — keep existing body verbatim. (Per-layer slotting only\n      // applies on the hierarchical path; a flat adapter has no scene layers,\n      // so the `scene:<layer>` split is a no-op and we emit the whole scene.)\n      const objects = cfg.objects ?? adapter?.getNodes() ?? [];\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 * Build the scene slot as one canvas layer **per scene layer** — keyed\n * `scene:<layerId>` — when the adapter is hierarchical (exposes `getLayers`).\n * This lets consumers interleave custom layers *between* scene layers via the\n * standard slot anchoring (`before: 'scene:plantings'`). Each per-layer canvas\n * layer re-runs the scene walk for its own layer only (others are still walked\n * for ancestor clips). Falls back to a single `scene` layer for flat adapters\n * or adapters with no declared layers.\n */\nexport function buildSceneLayers<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: CanvasAdapter<TNode, TPose> | undefined,\n  debugSink: DebugSink | null,\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 && typeof adapter?.getLayers === 'function'\n      ? adapter.getLayers().map((l) => l.id)\n      : null;\n  if (!sceneLayerIds || sceneLayerIds.length === 0) {\n    return [{ key: 'scene', layer: buildSceneLayer(cfg, adapter, debugSink, boundsOfFn, hideIds) }];\n  }\n  return sceneLayerIds.map((id) => ({\n    key: sceneLayerKey(id),\n    layer: buildSceneLayer(cfg, adapter, debugSink, boundsOfFn, hideIds, {\n      id: sceneLayerKey(id),\n      forLayer: id,\n    }),\n  }));\n}\n"],"mappings":";;;;;;;AA8GA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GAMA,GACsB;CACtB,IAAMC,IACJC,EAAI,YACF,MAAgBC,IAAUA,EAAQ,QAAQC,EAAI,EAAE,IAAKA,IACnDC,IAAUH,EAAI,SACdI,IAAcJ,EAAI,aAClBK,IAASL,EAAI,QACd,GAAqB,GAAY,MAClCM,EAAiBC,GAAMC,EAAWC,CAAI,GAAG;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOC,EAAK;EAAO,QAAQA,EAAK;CAAO,CAAC,KAC9F,MAAuCH,GACtCI,IAAcX,EAAI,OAAOA,EAAI,cAAc,KAAA,GAC3CY,KAAY,GAAY,MAAeD,IACzCE,EAAgBF,GAAaF,GAAM;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOC,EAAK;EAAO,QAAQA,EAAK;CAAO,CAAC,IACzF,KAAA;CACJ,OAAO;EACL,IAAII,GAAM,MAAM;EAChB,OAAOA,IAAO,UAAUA,EAAK,aAAa;EAC1C,OAAO,GAAO,GAAM,MAAS;GAC3B,IAAMC,IAASC,EAAQ,GACjBC,IAAIhB;GACV,IACEgB,KACAjB,EAAI,YAAY,KAAA,KAChB,OAAOiB,EAAE,aAAc,cACvB,OAAOA,EAAE,WAAY,cACrB,OAAOA,EAAE,eAAgB,cACzBd,GACA;IACA,IAAMe,KAAmB,GAAY,GAAa,MAA2B;KAC3E,IAAIH,KAAUA,EAAO,IAAIb,EAAI,EAAE,GAAG,OAAO,CAAC;KAC1C,IAAMK,IAAOJ,EAAQD,GAAKiB,GAAMC,CAAC;KACjC,IAAIC,GAAW;MACb,IAAMC,IAAIC,IAAaA,EAAWrB,EAAI,EAAE,IAAI;MAC5C,AAAIoB,KAAGD,EAAU,aAAanB,EAAI,IAAIoB,CAAC;MACvC,IAAME,IAAML,EAAwB,MAAMG,IAAIA,EAAE,IAAI,IAC9CG,IAAMN,EAAwB,MAAMG,IAAIA,EAAE,IAAI;MACpD,EAAU,aAAapB,EAAI,IAAI;OAAE,GAAGsB;OAAI,GAAGC;MAAG,CAAC;KACjD;KACA,OAAOC,EAAenB,GAAMY,GAAMnB,EAAI,WAAWA,EAAI,SAASE,EAAI,EAAE,IAAI,CAAC;IAC3E,GAGMyB,IAAsB3B,EAAI,SAC5B;KACE,GAAGiB;KACH,UAAU,MAAe;MACvB,IAAMf,IAAMe,EAAE,QAASW,CAAE;MACzB,OAAO1B,IAAMH,EAAOG,CAAG,IAAIe,EAAE,QAAQW,CAAE;KACzC;IACF,IACAX,GAEEY,IAAOC,EACXH,GACAT,GACAT,GACAK,GAAM,UACNd,EAAI,eACJY,EAASH,GAAMC,CAAI,CACrB;IACA,OAAOL,EAAOD,IAAcA,EAAYyB,GAAMpB,GAAMC,CAAI,IAAImB,GAAMpB,GAAMC,CAAI;GAC9E;GAIA,IAAMqB,IAAU/B,EAAI,WAAWC,GAAS,SAAS,KAAK,CAAC,GACjD+B,IAA0B,CAAC,GAC3BC,IAASrB,EAASH,GAAMC,CAAI;GAClC,KAAK,IAAMR,KAAO6B,GAAS;IACzB,IAAIhB,KAAUA,EAAO,IAAIb,EAAI,EAAE,GAAG;IAClC,IAAMiB,IAAcpB,EAAOG,CAAG;IAC9B,IAAIC,KAAW,CAAC8B,IAAS/B,GAAKiB,CAAI,GAAG;KACnC,IAAMZ,IAAOJ,EAAQD,GAAKiB,GAAMV,CAAI,GAC9ByB,IAAUR,EAAenB,GAAMY,GAAMnB,EAAI,WAAWA,EAAI,SAASE,EAAI,EAAE,IAAI,CAAC;KAClF,KAAK,IAAMiC,KAAOD,GAAS,EAAS,KAAKC,CAAG;IAC9C;IACA,IAAId,GAAW;KACb,IAAMC,IAAIC,IAAaA,EAAWrB,EAAI,EAAE,IAAI;KAC5C,AAAIoB,KAAGD,EAAU,aAAanB,EAAI,IAAI;MAAE,GAAGoB,EAAE;MAAG,GAAGA,EAAE;MAAG,OAAOA,EAAE;MAAO,QAAQA,EAAE;KAAO,CAAC;KAC1F,IAAME,IAAML,EAAwB,MAAMG,IAAIA,EAAE,IAAI,IAC9CG,IAAMN,EAAwB,MAAMG,IAAIA,EAAE,IAAI;KACpD,EAAU,aAAapB,EAAI,IAAI;MAAE,GAAGsB;MAAI,GAAGC;KAAG,CAAC;IACjD;GACF;GAEA,OAAOpB,EAAOD,IAAcA,EAAY4B,GAAUvB,GAAMC,CAAI,IAAIsB,GAAUvB,GAAMC,CAAI;EACtF;CACF;AACF;AAWA,SAAgB0B,EACd,GACA,GACA,GACA,GACA,GACqD;CACrD,IAAMC,IACJrC,EAAI,YAAY,KAAA,KAAa,OAAOC,GAAS,aAAc,aACvDA,EAAQ,UAAU,CAAC,CAAC,KAAK,MAAMqC,EAAE,EAAE,IACnC;CAIN,OAHI,CAACD,KAAiBA,EAAc,WAAW,IACtC,CAAC;EAAE,KAAK;EAAS,OAAOvC,EAAgBE,GAAKC,GAASoB,GAAWE,GAAYP,CAAO;CAAE,CAAC,IAEzFqB,EAAc,KAAK,OAAQ;EAChC,KAAKE,EAAcX,CAAE;EACrB,OAAO9B,EAAgBE,GAAKC,GAASoB,GAAWE,GAAYP,GAAS;GACnE,IAAIuB,EAAcX,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 '../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  // 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 → 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 (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":";;;;;;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,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;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,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"}

package/dist/canvas/canvasRenderer.js

@@ -1,89 +1,105 @@
 import { WeaselRenderer as e } from "../renderer/WeaselRenderer.js";
 import { viewToMat3 as t } from "../renderer/math/viewToMat3.js";
 //#region src/canvas/canvasRenderer.ts
-var n = /* @__PURE__ */ new WeakMap(), r = (e) => e?.map((e) => e.id).join("|") ?? "";
-function i(e, t) {
+var n = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakSet(), i = (e) => e?.map((e) => e.id).join("|") ?? "";
+function a(e, t) {
 	if (t) for (let n of t) try {
 		e.registerProgram(n);
 	} catch (e) {
 		console.warn(`weasel: failed to register shader "${n.id}":`, e);
 	}
 }
-function a(e) {
+function o(e) {
 	let t = n.get(e.canvas);
-	t?.delete(e.renderer), t && t.size === 0 && n.delete(e.canvas), e.renderer.dispose();
+	t?.delete(e.renderer), e.canvas.removeEventListener("webglcontextlost", e.onLost), e.canvas.removeEventListener("webglcontextrestored", e.onRestored), t && t.size === 0 && n.delete(e.canvas), e.renderer.dispose();
 }
-function o() {
-	let o = null, s = (t, s, c = {}) => {
-		let { width: l, height: u } = s, d = s.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), f = c.tile ?? null, p = f !== null;
-		if (o && (o.canvas !== t || o.shared !== p) && (a(o), o = null), o) (o.width !== l || o.height !== u || o.dpr !== d) && (o.renderer.resize({
-			width: l,
-			height: u,
-			dpr: d
-		}), o.width = l, o.height = u, o.dpr = d), o.flattenTolerance !== c.flattenTolerance && (o.renderer.setFlattenTolerance(c.flattenTolerance), o.flattenTolerance = c.flattenTolerance);
+function s() {
+	let s = null, c = /* @__PURE__ */ new Set(), l = (t, l, u = {}) => {
+		let { width: d, height: f } = l, p = l.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), m = u.tile ?? null, h = m !== null;
+		if (s && (s.canvas !== t || s.shared !== h) && (o(s), s = null), s) (!h && (t.width !== Math.round(d * p) || t.height !== Math.round(f * p)) || s.width !== d || s.height !== f || s.dpr !== p) && (s.renderer.resize({
+			width: d,
+			height: f,
+			dpr: p
+		}), s.width = d, s.height = f, s.dpr = p), s.flattenTolerance !== u.flattenTolerance && (s.renderer.setFlattenTolerance(u.flattenTolerance), s.flattenTolerance = u.flattenTolerance);
 		else {
-			let r = t.getContext("webgl2", {
+			if (r.has(t)) return null;
+			let i = t.getContext("webgl2", {
 				preserveDrawingBuffer: !0,
 				stencil: !0
 			});
-			if (!r || typeof r.enable != "function") return null;
-			let i;
+			if (!i || typeof i.enable != "function") return null;
+			let a;
 			try {
-				i = new e({
-					gl: r,
-					...p ? {} : { canvas: t },
-					width: l,
-					height: u,
-					dpr: d,
-					flattenTolerance: c.flattenTolerance
+				a = new e({
+					gl: i,
+					...h ? {} : { canvas: t },
+					width: d,
+					height: f,
+					dpr: p,
+					flattenTolerance: u.flattenTolerance
 				});
-			} catch {
-				return null;
+			} catch (e) {
+				return i.isContextLost?.() || (r.add(t), console.warn("weasel: this canvas cannot be painted:", e)), null;
 			}
-			o = {
+			let o = s = {
 				canvas: t,
-				renderer: i,
-				shared: p,
-				width: l,
-				height: u,
-				dpr: d,
+				renderer: a,
+				shared: h,
+				width: d,
+				height: f,
+				dpr: p,
 				tileX: null,
 				tileY: null,
-				flattenTolerance: c.flattenTolerance,
-				shaderKey: ""
+				flattenTolerance: u.flattenTolerance,
+				shaderKey: "",
+				lost: !1,
+				onLost: () => {
+					o.lost = !0;
+				},
+				onRestored: () => {
+					o.lost = !1;
+					for (let e of [...c]) e();
+				}
 			};
-			let a = n.get(t);
-			a || (a = /* @__PURE__ */ new Set(), n.set(t, a)), a.add(i);
+			t.addEventListener("webglcontextlost", s.onLost), t.addEventListener("webglcontextrestored", s.onRestored);
+			let l = n.get(t);
+			l || (l = /* @__PURE__ */ new Set(), n.set(t, l)), l.add(a);
 		}
-		let { renderer: m } = o, h = r(c.shaders);
-		h !== o.shaderKey && (i(m, c.shaders), o.shaderKey = h);
-		let g = f?.x ?? null, _ = f?.y ?? null;
-		return (g !== o.tileX || _ !== o.tileY) && (m.setTarget(f ? { origin: {
-			x: f.x,
-			y: f.y
-		} } : null), o.tileX = g, o.tileY = _), m;
+		if (s.lost) return null;
+		let { renderer: g } = s, _ = i(u.shaders);
+		_ !== s.shaderKey && (a(g, u.shaders), s.shaderKey = _);
+		let v = m?.x ?? null, y = m?.y ?? null;
+		return (v !== s.tileX || y !== s.tileY) && (g.setTarget(m ? { origin: {
+			x: m.x,
+			y: m.y
+		} } : null), s.tileX = v, s.tileY = y), g;
 	};
 	return {
-		bind: s,
+		bind: l,
 		paint(e, n, r, i, a) {
-			let o = s(e, i, a);
+			let o = l(e, i, a);
 			return o ? (o.render(n, t(r), a?.render), !0) : !1;
 		},
+		subscribeRestored(e) {
+			return c.add(e), () => {
+				c.delete(e);
+			};
+		},
 		release() {
-			o && a(o), o = null;
+			s && o(s), s = null;
 		}
 	};
 }
-var s = /* @__PURE__ */ new WeakMap();
-function c(e, t, n, r) {
-	let i = s.get(e);
-	return i || (i = o(), s.set(e, i)), i.paint(e, t, n, r);
+var c = /* @__PURE__ */ new WeakMap();
+function l(e, t, n, r) {
+	let i = c.get(e);
+	return i || (i = s(), c.set(e, i)), i.paint(e, t, n, r);
 }
-function l(e) {
-	let t = s.get(e);
-	t && (s.delete(e), t.release());
+function u(e) {
+	let t = c.get(e);
+	t && (c.delete(e), t.release());
 }
 //#endregion
-export { o as leaseCanvasRenderer, c as paintCanvas, l as releaseCanvasRenderer };
+export { s as leaseCanvasRenderer, l as paintCanvas, u as releaseCanvasRenderer };
 
 //# sourceMappingURL=canvasRenderer.js.map