@weasel-js/core 1.9.3 → 1.9.4

package/dist/canvas/sceneSlotWiring.js

@@ -5,12 +5,12 @@ function r(e, t) {
 	let n = (t) => e.overrides.read(t)?.alpha ?? 1;
 	return t ? (e) => t(e) * n(e) : n;
 }
-function i(i, a, o, s) {
-	let c = t(a, i.drawOne, i.toPose), l = e(a, i.toPose);
+function i(i, a, o, s, c) {
+	let l = t(a, i.drawOne, i.toPose, c), u = e(a, i.toPose, c);
 	return {
 		...i,
-		drawOne: s ? n(s, c) : c,
-		derivedPathOf: l,
+		drawOne: s ? n(s, l) : l,
+		derivedPathOf: u,
 		alphaFor: r(a, o)
 	};
 }

package/dist/canvas/sceneSlotWiring.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneSlotWiring.js","names":["composeAlphaFor","overrideAlphaFor","scene","id","alphaFor","wireSceneSlotToScene","derived","withDerivedPaths","slot","derivedPathOf","sceneDerivedPathOf","colorOverrides","withColorOverrides"],"sources":["../../src/canvas/sceneSlotWiring.ts"],"sourcesContent":["/**\n * What the scene slot needs from the `Scene` that `<Canvas>` cannot see.\n *\n * `<Canvas>` is scene-agnostic: it walks an adapter. Three things a node is\n * painted with are therefore invisible to it — an ephemeral override's alpha, a\n * derived path, which needs other nodes' poses to resolve, and animated vertex\n * colors, which live in an animator. `<SceneCanvas>` folds them into the slot\n * here; `buildSceneViewCommands` does the same for the headless walk.\n */\nimport type { SceneSlotConfig } from './Canvas';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\n\n/**\n * The alpha a view paints a node at: the view's own `alphaFor` times any\n * ephemeral override alpha.\n *\n * The hit path asks this too — a node painted at alpha 0 is not on screen and\n * must not claim clicks — so it is one function rather than the painter's and\n * picking's separate readings of the same two inputs.\n */\nexport function composeAlphaFor<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n): (id: string) => number {\n  const overrideAlphaFor = (id: string) => scene.overrides.read(id as NodeId)?.alpha ?? 1;\n  return alphaFor ? (id: string) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;\n}\n\nexport function wireSceneSlotToScene<TData, TLayer extends string, TPose>(\n  slot: SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n  colorOverrides?: ColorOverrideRegistry,\n): SceneSlotConfig<Node<TData, TLayer, TPose>, TPose> {\n  const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose);\n  const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose);\n  return {\n    ...slot,\n    drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,\n    derivedPathOf,\n    alphaFor: composeAlphaFor(scene, alphaFor),\n  };\n}\n"],"mappings":";;;AAuBA,SAAgBA,EACd,GACA,GACwB;CACxB,IAAMC,KAAoB,MAAeC,EAAM,UAAU,KAAKC,CAAY,CAAC,EAAE,SAAS;CACtF,OAAOC,KAAY,MAAeA,EAASD,CAAE,IAAIF,EAAiBE,CAAE,IAAIF;AAC1E;AAEA,SAAgBI,EACd,GACA,GACA,GACA,GACoD;CACpD,IAAMC,IAAUC,EAAiBL,GAAOM,EAAK,SAASA,EAAK,MAAM,GAC3DC,IAAgBC,EAAmBR,GAAOM,EAAK,MAAM;CAC3D,OAAO;EACL,GAAGA;EACH,SAASG,IAAiBC,EAAmBD,GAAgBL,CAAO,IAAIA;EACxE;EACA,UAAUN,EAAgBE,GAAOE,CAAQ;CAC3C;AACF"}
+{"version":3,"file":"sceneSlotWiring.js","names":["composeAlphaFor","overrideAlphaFor","scene","id","alphaFor","wireSceneSlotToScene","derived","withDerivedPaths","slot","poseComposition","derivedPathOf","sceneDerivedPathOf","colorOverrides","withColorOverrides"],"sources":["../../src/canvas/sceneSlotWiring.ts"],"sourcesContent":["/**\n * What the scene slot needs from the `Scene` that `<Canvas>` cannot see.\n *\n * `<Canvas>` is scene-agnostic: it walks an adapter. Three things a node is\n * painted with are therefore invisible to it — an ephemeral override's alpha, a\n * derived path, which needs other nodes' poses to resolve, and animated vertex\n * colors, which live in an animator. `<SceneCanvas>` folds them into the slot\n * here; `buildSceneViewCommands` does the same for the headless walk.\n */\nimport type { SceneSlotConfig } from './Canvas';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { PoseComposition } from 'core/scene/composeFrame';\n\n/**\n * The alpha a view paints a node at: the view's own `alphaFor` times any\n * ephemeral override alpha.\n *\n * The hit path asks this too — a node painted at alpha 0 is not on screen and\n * must not claim clicks — so it is one function rather than the painter's and\n * picking's separate readings of the same two inputs.\n */\nexport function composeAlphaFor<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n): (id: string) => number {\n  const overrideAlphaFor = (id: string) => scene.overrides.read(id as NodeId)?.alpha ?? 1;\n  return alphaFor ? (id: string) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;\n}\n\nexport function wireSceneSlotToScene<TData, TLayer extends string, TPose>(\n  slot: SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n  colorOverrides?: ColorOverrideRegistry,\n  /** How the canvas folds a stored pose into its container's frame, so a\n   *  derived path is drawn between its dependencies' composed poses. */\n  poseComposition?: PoseComposition<TPose>,\n): SceneSlotConfig<Node<TData, TLayer, TPose>, TPose> {\n  const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose, poseComposition);\n  const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose, poseComposition);\n  return {\n    ...slot,\n    drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,\n    derivedPathOf,\n    alphaFor: composeAlphaFor(scene, alphaFor),\n  };\n}\n"],"mappings":";;;AAwBA,SAAgBA,EACd,GACA,GACwB;CACxB,IAAMC,KAAoB,MAAeC,EAAM,UAAU,KAAKC,CAAY,CAAC,EAAE,SAAS;CACtF,OAAOC,KAAY,MAAeA,EAASD,CAAE,IAAIF,EAAiBE,CAAE,IAAIF;AAC1E;AAEA,SAAgBI,EACd,GACA,GACA,GACA,GAGA,GACoD;CACpD,IAAMC,IAAUC,EAAiBL,GAAOM,EAAK,SAASA,EAAK,QAAQC,CAAe,GAC5EC,IAAgBC,EAAmBT,GAAOM,EAAK,QAAQC,CAAe;CAC5E,OAAO;EACL,GAAGD;EACH,SAASI,IAAiBC,EAAmBD,GAAgBN,CAAO,IAAIA;EACxE;EACA,UAAUN,EAAgBE,GAAOE,CAAQ;CAC3C;AACF"}

package/dist/canvas/sceneViewRender.js

@@ -1,19 +1,18 @@
 import { viewToMat3 as e } from "../renderer/math/viewToMat3.js";
 import { cullDrawCommands as t } from "../renderer/cullDrawCommands.js";
-import { resolveDerivedPath as n } from "../core/scene/derivedPath.js";
-import { effectivePose as r } from "../core/scene/effectivePose.js";
-import { sceneDepLookup as i, withDerivedPaths as a } from "./derivedPath.js";
-import { paintBoundsFor as o } from "./defaultDrawOne.js";
-import { paintedSceneLayers as s } from "./sceneLayerPaint.js";
-import { paintCanvas as c } from "./canvasRenderer.js";
-import { buildSceneTree as l } from "./buildSceneTree.js";
-import { wrapNodeOutput as u } from "./wrapNodeOutput.js";
-import { paintMissesView as d } from "./paintCull.js";
-import { withColorOverrides as f } from "./colorOverrides.js";
+import { effectivePose as n } from "../core/scene/effectivePose.js";
+import { paintedSceneLayers as r } from "./sceneLayerPaint.js";
+import { paintCanvas as i } from "./canvasRenderer.js";
+import { wrapNodeOutput as a } from "./wrapNodeOutput.js";
+import { sceneDerivedPathOf as o, withDerivedPaths as s } from "./derivedPath.js";
+import { buildSceneTree as c } from "./buildSceneTree.js";
+import { withColorOverrides as l } from "./colorOverrides.js";
+import { paintMissesView as u } from "./paintCull.js";
+import { paintBoundsFor as d } from "./defaultDrawOne.js";
 //#region src/canvas/sceneViewRender.ts
-function p(e, t = {}) {
+function f(e, t = {}) {
 	return {
-		getLayers: () => s(e.layers, t).map((e) => ({
+		getLayers: () => r(e.layers, t).map((e) => ({
 			id: e.id,
 			visible: e.visible,
 			parallax: e.parallax
@@ -24,49 +23,49 @@ function p(e, t = {}) {
 			let n = e.get(t);
 			return n && n.kind === "container" ? n.children : [];
 		},
-		getPose: (t) => r(e, e.get(t))
+		getPose: (t) => n(e, e.get(t))
 	};
 }
-function m(r, o, s, c, m, h, g, _, v) {
-	let y = a(r, s), b = _ ? f(_, y) : y, x = i(r), S = (e, t, n) => {
-		let i = r.overrides.read(e.id)?.alpha ?? 1;
-		return u(b(e, t, n), t, (m ? m(e.id) : 1) * i);
-	}, C = h !== void 0 && h.closure !== "identity" ? {
-		...p(r, g),
-		composePose: h.compose
-	} : p(r, g), w = v ? {
+function p(n, r, i, d, p, m, h, g, _) {
+	let v = s(n, i, void 0, m), y = g ? l(g, v) : v, b = o(n, void 0, m), x = (e, t, r) => {
+		let i = n.overrides.read(e.id)?.alpha ?? 1;
+		return a(y(e, t, r), t, (p ? p(e.id) : 1) * i);
+	}, S = m !== void 0 && m.closure !== "identity" ? {
+		...f(n, h),
+		composePose: m.compose
+	} : f(n, h), C = _ ? {
 		x: 0,
 		y: 0,
-		width: v.width,
-		height: v.height
-	} : void 0, T = w && v?.paintBounds ? d(v.paintBounds, o, w) : void 0, E = l(C, S, o, void 0, ((e) => n(e, x, (e) => r.childrenOf(e))), T), D = w ? t(E, e(o), w) : E;
-	if (c && c.length > 0) for (let e of c) D.push(e);
+		width: _.width,
+		height: _.height
+	} : void 0, w = C && _?.paintBounds ? u(_.paintBounds, r, C) : void 0, T = c(S, x, r, void 0, b, w), E = C ? t(T, e(r), C) : T;
+	if (d && d.length > 0) for (let e of d) E.push(e);
 	return [{
 		kind: "group",
-		transform: e(o),
-		children: D
+		transform: e(r),
+		children: E
 	}];
 }
-function h(e) {
-	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: s, alphaFor: c, layerVisibility: l, layerOrder: u, colorOverrides: d, cull: f } = e;
-	return m(t, n, a, s, c, void 0, {
-		layerVisibility: l,
-		layerOrder: u
-	}, d, f ? {
+function m(e) {
+	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: o, alphaFor: s, layerVisibility: c, layerOrder: l, colorOverrides: u, cull: f } = e;
+	return p(t, n, a, o, s, void 0, {
+		layerVisibility: c,
+		layerOrder: l
+	}, u, f ? {
 		width: r,
 		height: i,
-		paintBounds: e.paintBounds ?? o(a)
+		paintBounds: e.paintBounds ?? d(a)
 	} : void 0);
 }
-function g(e) {
-	let { canvas: t, view: n, width: r, height: i, dpr: a } = e;
-	c(t, h(e), n, {
+function h(e) {
+	let { canvas: t, view: n, width: r, height: a, dpr: o } = e;
+	i(t, m(e), n, {
 		width: r,
-		height: i,
-		dpr: a
+		height: a,
+		dpr: o
 	});
 }
 //#endregion
-export { m as buildSceneViewCommands, g as renderSceneToCanvas, h as sceneViewFrame };
+export { p as buildSceneViewCommands, h as renderSceneToCanvas, m as sceneViewFrame };
 
 //# sourceMappingURL=sceneViewRender.js.map

package/dist/canvas/sceneViewRender.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneViewRender.js","names":["sceneAsHierarchy","paintedSceneLayers","scene","layers","l","id","parentId","node","effectivePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","derived","colorOverrides","withColorOverrides","depLookup","sceneDepLookup","wrappedDrawOne","overrideAlpha","wrapNodeOutput","pose","v","alphaFor","hierarchy","poseComposition","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","resolveDerivedPath","children","cullDrawCommands","viewToMat3","extraCommands","cmd","sceneViewFrame","args","paintBoundsFor","renderSceneToCanvas","canvas"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n *\n * The full `<SceneCanvas>` render pipeline does much more than this (slots, layer\n * ordering, debug sinks, tool overlays). The helper deliberately re-implements\n * the small subset needed for a non-interactive scene view rather than\n * refactoring `<SceneCanvas>` to share code — the spec calls for that\n * dedupe as a follow-up.\n *\n * Note: this duplicates `<SceneCanvas>`'s GL setup + view-wrap pattern in\n * miniature. When `<SceneCanvas>` is eventually migrated onto this helper,\n * the duplication collapses; until then, keep the two render paths\n * in sync by hand where it matters (DPR handling, viewToMat3 wrap).\n */\n\nimport type { WeaselRenderer } from '../renderer/WeaselRenderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport type { PoseComposition } from 'features/groups/composePose';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { withDerivedPaths, resolveDerivedPath, sceneDepLookup } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '../renderer/cullDrawCommands';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The helper owns its WebGL2 context: the\n   *  first call on a given canvas creates a renderer and stashes it; subsequent\n   *  calls reuse the same renderer (and resize the drawing buffer on dim\n   *  changes). `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  /** Scene to walk. `scene.renderOrder()` provides the per-node order. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene + extras (both ride the same world→screen\n   *  transform; extras living in screen space should be supplied via a\n   *  separately-prepared `extraCommands` group or rendered outside this\n   *  helper). */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; CSS size to `width` / `height`. */\n  width: number;\n  height: number;\n  /** Per-node draw callback. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional commands appended after the scene-node output. Used for the\n   *  minimap's visible-window indicator. Wrapped in the same view transform\n   *  as scene commands. */\n  extraCommands?: 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  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`\n   *  when available, otherwise 1. Tests typically pin this to 1 or 2. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks. Built\n * inline rather than via `sceneToAdapter` so this module stays free of React\n * — `renderSceneToPixels` runs headless.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode: (id) => scene.get(id as NodeId),\n    getChildren: (parentId) => {\n      if (parentId === null) return scene.roots as readonly string[];\n      const node = scene.get(parentId as NodeId);\n      return node && node.kind === 'container' ? (node.children as readonly string[]) : [];\n    },\n    getPose: (id) => effectivePose(scene, scene.get(id as NodeId)!),\n  } as HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch.\n *\n * Pure — no GL, no DOM, no side effects. Walks the scene through\n * `buildSceneTree` — the same walk `<SceneCanvas>`'s `buildSceneLayer` uses —\n * appends any `extraCommands`, and wraps the result in a single\n * `{ kind: 'group', transform: viewToMat3(view) }` so the output is in screen\n * space. Sharing the walk is what keeps hidden layers unpainted and container\n * clips applied here; a hand-rolled `renderOrder()` loop silently dropped both.\n *\n * Each node's commands additionally go through `wrapNodeOutput` — pose\n * rotation, then the `alphaFor` multiplier — exactly as `buildSceneLayer`\n * does, so a `drawOne` shared between the two paints the same thing in both.\n * A `drawOne` that rotates its own output will therefore rotate twice here;\n * emit unrotated geometry and let the pose drive it.\n *\n * Output shape follows `buildSceneTree`: one group per **visible** layer, in\n * scene-layer order (or `layers.layerOrder`), each holding one group per node\n * on that layer.\n *\n * Exported for tests and for callers that want to render into something\n * other than a real `<canvas>` (e.g. an offscreen renderer or a\n * snapshot fixture).\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** How a child's stored pose folds into its parent's frame. Omit for the\n   *  absolute-pose model. */\n  poseComposition?: PoseComposition<TPose>,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  // The scene is in scope here, so this is where the override's alpha and the\n  // derived paths are applied on the headless path; `SceneCanvas` does the same\n  // for the live one. `Canvas` itself never sees a scene, so it can't and doesn't.\n  const derivedOnly = withDerivedPaths(scene, drawOne);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const depLookup = sceneDepLookup(scene);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.read(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const composes = poseComposition !== undefined && poseComposition.closure !== 'identity';\n  const hierarchy = composes\n    ? { ...sceneAsHierarchy(scene, layers), composePose: poseComposition!.compose }\n    : sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    ((node: unknown) =>\n      resolveDerivedPath(\n        node as Node<TData, TLayer, TPose>, depLookup, (id) => scene.childrenOf(id),\n      )) as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, undefined, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. See module docstring\n * for the design context.\n *\n * Paints through `paintCanvas` (`./canvasRenderer`): one renderer per canvas,\n * created on the first call and resized when `width` / `height` / `dpr`\n * change. Where no WebGL2 context is available (jsdom) the call paints\n * nothing. The renderer lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;;AAyHA,SAASA,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,OAAO;EACL,iBACEC,EAAmBC,EAAM,QAAQC,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE,UAAU,MAAOF,EAAM,IAAIG,CAAY;EACvC,cAAc,MAAa;GACzB,IAAIC,MAAa,MAAM,OAAOJ,EAAM;GACpC,IAAMK,IAAOL,EAAM,IAAII,CAAkB;GACzC,OAAOC,KAAQA,EAAK,SAAS,cAAeA,EAAK,WAAiC,CAAC;EACrF;EACA,UAAU,MAAOC,EAAcN,GAAOA,EAAM,IAAIG,CAAY,CAAE;CAChE;AACF;AA0BA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GAGA,GAEA,GAEA,GAGA,GACe;CAIf,IAAMC,IAAcC,EAAiBT,GAAOU,CAAO,GAC7CC,IAAUC,IAAiBC,EAAmBD,GAAgBJ,CAAW,IAAIA,GAC7EM,IAAYC,EAAef,CAAK,GAChCgB,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBjB,EAAM,UAAU,KAAKK,EAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAOa,EACLP,EAAQN,GAAMc,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAAShB,EAAK,EAAE,IAAI,KAAKY,CACvC;CACF,GAGMK,IADWC,MAAoB,KAAA,KAAaA,EAAgB,YAAY,aAE1E;EAAE,GAAGzB,EAAiBE,GAAOC,CAAM;EAAG,aAAasB,EAAiB;CAAQ,IAC5EzB,EAAiBE,GAAOC,CAAM,GAE5BuB,IAAWC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO,IAAI,KAAA,GAC3EC,IAASF,KAAYC,GAAM,cAAcE,EAAgBF,EAAK,aAAaG,GAAMJ,CAAQ,IAAI,KAAA,GAC7FK,IAAsBC,EAC1BR,GACAN,GACAY,GACA,KAAA,KACE,MACAG,EACE1B,GAAoCS,IAAY,MAAOd,EAAM,WAAWG,CAAE,CAC5E,IACFuB,CACF,GACMM,IAAWR,IAAWS,EAAiBJ,GAAMK,EAAWN,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAIM,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWF,EAAWN,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBS,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO/B,EACLP,GAAO4B,GAAMlB,GAASyB,GAAed,GAAU,KAAA,GAAW;EAAE;EAAiB;CAAW,GAAGT,GAC3Fa,IAAO;EAAE;EAAO;EAAQ,aAAaa,EAAK,eAAeC,EAAe7B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAWA,SAAgB8B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGV,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}
+{"version":3,"file":"sceneViewRender.js","names":["sceneAsHierarchy","paintedSceneLayers","scene","layers","l","id","parentId","node","effectivePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","poseComposition","derived","colorOverrides","withColorOverrides","derivedPathOf","sceneDerivedPathOf","wrappedDrawOne","overrideAlpha","wrapNodeOutput","pose","v","alphaFor","hierarchy","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","children","cullDrawCommands","viewToMat3","extraCommands","cmd","sceneViewFrame","args","paintBoundsFor","renderSceneToCanvas","canvas"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n *\n * The full `<SceneCanvas>` render pipeline does much more than this (slots, layer\n * ordering, debug sinks, tool overlays). The helper deliberately re-implements\n * the small subset needed for a non-interactive scene view rather than\n * refactoring `<SceneCanvas>` to share code — the spec calls for that\n * dedupe as a follow-up.\n *\n * Note: this duplicates `<SceneCanvas>`'s GL setup + view-wrap pattern in\n * miniature. When `<SceneCanvas>` is eventually migrated onto this helper,\n * the duplication collapses; until then, keep the two render paths\n * in sync by hand where it matters (DPR handling, viewToMat3 wrap).\n */\n\nimport type { WeaselRenderer } from '../renderer/WeaselRenderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport type { PoseComposition } from 'features/groups/composePose';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '../renderer/cullDrawCommands';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The helper owns its WebGL2 context: the\n   *  first call on a given canvas creates a renderer and stashes it; subsequent\n   *  calls reuse the same renderer (and resize the drawing buffer on dim\n   *  changes). `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  /** Scene to walk. `scene.renderOrder()` provides the per-node order. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene + extras (both ride the same world→screen\n   *  transform; extras living in screen space should be supplied via a\n   *  separately-prepared `extraCommands` group or rendered outside this\n   *  helper). */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; CSS size to `width` / `height`. */\n  width: number;\n  height: number;\n  /** Per-node draw callback. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional commands appended after the scene-node output. Used for the\n   *  minimap's visible-window indicator. Wrapped in the same view transform\n   *  as scene commands. */\n  extraCommands?: 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  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`\n   *  when available, otherwise 1. Tests typically pin this to 1 or 2. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks. Built\n * inline rather than via `sceneToAdapter` so this module stays free of React\n * — `renderSceneToPixels` runs headless.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode: (id) => scene.get(id as NodeId),\n    getChildren: (parentId) => {\n      if (parentId === null) return scene.roots as readonly string[];\n      const node = scene.get(parentId as NodeId);\n      return node && node.kind === 'container' ? (node.children as readonly string[]) : [];\n    },\n    getPose: (id) => effectivePose(scene, scene.get(id as NodeId)!),\n  } as HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch.\n *\n * Pure — no GL, no DOM, no side effects. Walks the scene through\n * `buildSceneTree` — the same walk `<SceneCanvas>`'s `buildSceneLayer` uses —\n * appends any `extraCommands`, and wraps the result in a single\n * `{ kind: 'group', transform: viewToMat3(view) }` so the output is in screen\n * space. Sharing the walk is what keeps hidden layers unpainted and container\n * clips applied here; a hand-rolled `renderOrder()` loop silently dropped both.\n *\n * Each node's commands additionally go through `wrapNodeOutput` — pose\n * rotation, then the `alphaFor` multiplier — exactly as `buildSceneLayer`\n * does, so a `drawOne` shared between the two paints the same thing in both.\n * A `drawOne` that rotates its own output will therefore rotate twice here;\n * emit unrotated geometry and let the pose drive it.\n *\n * Output shape follows `buildSceneTree`: one group per **visible** layer, in\n * scene-layer order (or `layers.layerOrder`), each holding one group per node\n * on that layer.\n *\n * Exported for tests and for callers that want to render into something\n * other than a real `<canvas>` (e.g. an offscreen renderer or a\n * snapshot fixture).\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** How a child's stored pose folds into its parent's frame. Omit for the\n   *  absolute-pose model. */\n  poseComposition?: PoseComposition<TPose>,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  // The scene is in scope here, so this is where the override's alpha and the\n  // derived paths are applied on the headless path; `SceneCanvas` does the same\n  // for the live one. `Canvas` itself never sees a scene, so it can't and doesn't.\n  const derivedOnly = withDerivedPaths(scene, drawOne, undefined, poseComposition);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const derivedPathOf = sceneDerivedPathOf(scene, undefined, poseComposition);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.read(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const composes = poseComposition !== undefined && poseComposition.closure !== 'identity';\n  const hierarchy = composes\n    ? { ...sceneAsHierarchy(scene, layers), composePose: poseComposition!.compose }\n    : sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    derivedPathOf as unknown as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, undefined, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. See module docstring\n * for the design context.\n *\n * Paints through `paintCanvas` (`./canvasRenderer`): one renderer per canvas,\n * created on the first call and resized when `width` / `height` / `dpr`\n * change. Where no WebGL2 context is available (jsdom) the call paints\n * nothing. The renderer lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;AAyHA,SAASA,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,OAAO;EACL,iBACEC,EAAmBC,EAAM,QAAQC,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE,UAAU,MAAOF,EAAM,IAAIG,CAAY;EACvC,cAAc,MAAa;GACzB,IAAIC,MAAa,MAAM,OAAOJ,EAAM;GACpC,IAAMK,IAAOL,EAAM,IAAII,CAAkB;GACzC,OAAOC,KAAQA,EAAK,SAAS,cAAeA,EAAK,WAAiC,CAAC;EACrF;EACA,UAAU,MAAOC,EAAcN,GAAOA,EAAM,IAAIG,CAAY,CAAE;CAChE;AACF;AA0BA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GAGA,GAEA,GAEA,GAGA,GACe;CAIf,IAAMC,IAAcC,EAAiBT,GAAOU,GAAS,KAAA,GAAWC,CAAe,GACzEC,IAAUC,IAAiBC,EAAmBD,GAAgBL,CAAW,IAAIA,GAC7EO,IAAgBC,EAAmBhB,GAAO,KAAA,GAAWW,CAAe,GACpEM,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBlB,EAAM,UAAU,KAAKK,EAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAOc,EACLP,EAAQP,GAAMe,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAASjB,EAAK,EAAE,IAAI,KAAKa,CACvC;CACF,GAGMK,IADWZ,MAAoB,KAAA,KAAaA,EAAgB,YAAY,aAE1E;EAAE,GAAGb,EAAiBE,GAAOC,CAAM;EAAG,aAAaU,EAAiB;CAAQ,IAC5Eb,EAAiBE,GAAOC,CAAM,GAE5BuB,IAAWC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO,IAAI,KAAA,GAC3EC,IAASF,KAAYC,GAAM,cAAcE,EAAgBF,EAAK,aAAaG,GAAMJ,CAAQ,IAAI,KAAA,GAC7FK,IAAsBC,EAC1BP,GACAN,GACAW,GACA,KAAA,GACAb,GACAW,CACF,GACMK,IAAWP,IAAWQ,EAAiBH,GAAMI,EAAWL,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAIK,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWF,EAAWL,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBQ,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO9B,EACLP,GAAO4B,GAAMlB,GAASwB,GAAeZ,GAAU,KAAA,GAAW;EAAE;EAAiB;CAAW,GAAGT,GAC3FY,IAAO;EAAE;EAAO;EAAQ,aAAaY,EAAK,eAAeC,EAAe5B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAWA,SAAgB6B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGT,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}

package/dist/canvas/useCanvasRenderer.js

@@ -1,11 +1,19 @@
-import { leaseCanvasRenderer as e } from "./canvasRenderer.js";
-import { useEffect as t, useState as n } from "react";
+import { watchDevicePixelRatio as e } from "../core/device/watchDevicePixelRatio.js";
+import { leaseCanvasRenderer as t } from "./canvasRenderer.js";
+import { useEffect as n, useState as r } from "react";
 //#region src/canvas/useCanvasRenderer.ts
-function r() {
-	let [r] = n(e);
-	return t(() => () => r.release(), [r]), r;
+function i() {
+	let [e] = r(t);
+	return n(() => () => e.release(), [e]), e;
+}
+function a(e, t) {
+	n(() => e.subscribeRestored(t), [e, t]);
+}
+function o(t, r) {
+	let i = r === void 0;
+	n(() => i ? e(() => t()) : void 0, [i, t]);
 }
 //#endregion
-export { r as useCanvasRenderer };
+export { i as useCanvasRenderer, o as useRedrawOnDensityChange, a as useRedrawOnRestore };
 
 //# sourceMappingURL=useCanvasRenderer.js.map

package/dist/canvas/useCanvasRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { leaseCanvasRenderer, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n"],"mappings":";;;AASA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT"}
+{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","ambient","dpr","watchDevicePixelRatio"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { leaseCanvasRenderer, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n"],"mappings":";;;;AAUA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT;AAGA,SAAgBI,EAAmB,GAA4B,GAAiC;CAC9F,QAAgBJ,EAAM,kBAAkBK,CAAa,GAAG,CAACL,GAAOK,CAAa,CAAC;AAChF;AAOA,SAAgBC,EAAyB,GAA2B,GAAoB;CACtF,IAAMC,IAAUC,MAAQ,KAAA;CACxB,QAAiBD,IAAUE,QAA4BJ,EAAc,CAAC,IAAI,KAAA,GAAY,CAACE,GAASF,CAAa,CAAC;AAChH"}

package/dist/canvas/useCanvasView.js

@@ -0,0 +1,58 @@
+import { normalizeView as e } from "../core/viewport/view.js";
+import { clampView as t } from "../core/viewport/clampView.js";
+import { useCallback as n, useRef as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+//#region src/canvas/useCanvasView.ts
+function a(a) {
+	let { view: o, defaultView: s, onViewChange: c, viewBounds: l, dimsRef: u, requestRedraw: d } = a, f = r(e(o ?? s ?? {
+		x: 0,
+		y: 0,
+		scale: {
+			x: 1,
+			y: 1
+		}
+	})), p = o !== void 0, m = p ? e(o) : void 0, h = r(/* @__PURE__ */ new Set()), g = i(c), _ = i(l), v = i(p), y = r(!1), b = n((n) => {
+		let r = e(typeof n == "function" ? n(f.current) : n), i = _.current, a = i ? t(r, i, u.current) : r;
+		if (v.current) {
+			let e = g.current;
+			y.current || (y.current = !0, console.warn(e ? "[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path." : "[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.")), e?.(a);
+			return;
+		}
+		f.current = a;
+		for (let e of h.current) e(a);
+		g.current?.(a), d();
+	}, [
+		d,
+		u,
+		v,
+		g,
+		_
+	]), x = n(() => f.current, []), S = n((e) => (h.current.add(e), () => {
+		h.current.delete(e);
+	}), []), C = r(!1);
+	return {
+		viewRef: f,
+		controlledView: m,
+		setView: b,
+		getView: x,
+		subscribeView: S,
+		adoptControlled: () => {
+			if (!m) return;
+			let e = f.current;
+			C.current ||= e.x !== m.x || e.y !== m.y || e.scale.x !== m.scale.x || e.scale.y !== m.scale.y, f.current = m;
+		},
+		announceControlled: n(() => {
+			if (C.current) {
+				C.current = !1;
+				for (let e of h.current) e(f.current);
+			}
+		}, []),
+		clearSubscribers: n(() => {
+			h.current.clear();
+		}, [])
+	};
+}
+//#endregion
+export { a as useCanvasView };
+
+//# sourceMappingURL=useCanvasView.js.map

package/dist/canvas/useCanvasView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasView.js","names":["useCanvasView","viewProp","opts","viewRef","useRef","normalizeView","defaultView","isControlled","controlledView","viewSubsRef","onViewChangeRef","useLatest","onViewChange","viewBoundsRef","viewBounds","isControlledRef","controlledWarnedRef","setView","useCallback","resolved","next","bounds","clamped","clampView","dimsRef","forward","fn","requestRedraw","getView","subscribeView","controlledMovedRef","was"],"sources":["../../src/canvas/useCanvasView.ts"],"sourcesContent":["/**\n * A `<Canvas>`'s view: held in a ref when uncontrolled, taken from the `view`\n * prop when controlled, with one `setView` and one subscriber list over both.\n */\nimport { useCallback, useRef, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dims } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { clampView } from 'core/viewport/clampView';\nimport { normalizeView, type View } from 'core/viewport/view';\n\n/** Inputs to {@link useCanvasView}: the canvas's view props and what a view\n *  write needs from the canvas around it. */\nexport interface CanvasViewOptions {\n  view: View | undefined;\n  defaultView: View | undefined;\n  onViewChange: ((next: View) => void) | undefined;\n  viewBounds: Bounds | undefined;\n  dimsRef: { readonly current: Dims };\n  requestRedraw: () => void;\n}\n\n/** What {@link useCanvasView} hands back. The canvas decides when in a commit\n *  the two controlled steps run, since they have to sit among its own effects. */\nexport interface CanvasViewState {\n  /** The view in effect. Written by `setView` when uncontrolled and by\n   *  `adoptControlled` when controlled. */\n  viewRef: MutableRefObject<View>;\n  /** The normalized `view` prop, or undefined when uncontrolled. */\n  controlledView: View | undefined;\n  setView: (next: View | ((current: View) => View)) => void;\n  getView: () => View;\n  subscribeView: (fn: (v: View) => void) => () => void;\n  /** Take this render's controlled view into `viewRef`. Call from an insertion effect. */\n  adoptControlled: () => void;\n  /** Tell subscribers of a controlled view that moved since the last call.\n   *  A controlled view reaches the ref with no `setView`, so this is where\n   *  they hear of it. Call from a layout effect. */\n  announceControlled: () => void;\n  /** Drop every subscriber, on unmount. */\n  clearSubscribers: () => void;\n}\n\nexport function useCanvasView(opts: CanvasViewOptions): CanvasViewState {\n  const { view: viewProp, defaultView, onViewChange, viewBounds, dimsRef, requestRedraw } = opts;\n  // The uncontrolled view lives in a ref, not `useState`, so a camera moving\n  // at 60 Hz costs no React render; DOM that mirrors it subscribes instead.\n  const viewRef = useRef<View>(normalizeView(viewProp ?? defaultView ?? { x: 0, y: 0, scale: { x: 1, y: 1 } }));\n  const isControlled = viewProp !== undefined;\n  const controlledView = isControlled ? normalizeView(viewProp) : undefined;\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const onViewChangeRef = useLatest(onViewChange);\n  const viewBoundsRef = useLatest(viewBounds);\n  const isControlledRef = useLatest(isControlled);\n  const controlledWarnedRef = useRef(false);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    const resolved = normalizeView(typeof next === 'function' ? next(viewRef.current) : next);\n    const bounds = viewBoundsRef.current;\n    const clamped = bounds ? clampView(resolved, bounds, dimsRef.current) : resolved;\n    if (isControlledRef.current) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      const forward = onViewChangeRef.current;\n      if (!controlledWarnedRef.current) {\n        controlledWarnedRef.current = true;\n        console.warn(forward\n          ? '[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path.'\n          : '[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.');\n      }\n      forward?.(clamped);\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    onViewChangeRef.current?.(clamped);\n    requestRedraw();\n  }, [requestRedraw, dimsRef, isControlledRef, onViewChangeRef, viewBoundsRef]);\n\n  const getView = useCallback(() => viewRef.current, []);\n  const subscribeView = useCallback((fn: (v: View) => void) => {\n    viewSubsRef.current.add(fn);\n    return () => { viewSubsRef.current.delete(fn); };\n  }, []);\n\n  const controlledMovedRef = useRef(false);\n  // A closure over this render's prop, not a ref read: the canvas calls it\n  // from the same render's insertion effect.\n  const adoptControlled = (): void => {\n    if (!controlledView) return;\n    const was = viewRef.current;\n    controlledMovedRef.current ||= was.x !== controlledView.x || was.y !== controlledView.y\n      || was.scale.x !== controlledView.scale.x || was.scale.y !== controlledView.scale.y;\n    viewRef.current = controlledView;\n  };\n  const announceControlled = useCallback(() => {\n    if (!controlledMovedRef.current) return;\n    controlledMovedRef.current = false;\n    for (const fn of viewSubsRef.current) fn(viewRef.current);\n  }, []);\n  const clearSubscribers = useCallback(() => { viewSubsRef.current.clear(); }, []);\n\n  return {\n    viewRef, controlledView, setView, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  };\n}\n"],"mappings":";;;;;AA2CA,SAAgBA,EAAc,GAA0C;CACtE,IAAM,EAAE,MAAMC,GAAU,gBAAa,iBAAc,eAAY,YAAS,qBAAkBC,GAGpFC,IAAUC,EAAaC,EAAcJ,KAAYK,KAAe;EAAE,GAAG;EAAG,GAAG;EAAG,OAAO;GAAE,GAAG;GAAG,GAAG;EAAE;CAAE,CAAC,CAAC,GACtGC,IAAeN,MAAa,KAAA,GAC5BO,IAAiBD,IAAeF,EAAcJ,CAAQ,IAAI,KAAA,GAC1DQ,IAAcL,kBAA+B,IAAI,IAAI,CAAC,GACtDM,IAAkBC,EAAUC,CAAY,GACxCC,IAAgBF,EAAUG,CAAU,GACpCC,IAAkBJ,EAAUJ,CAAY,GACxCS,IAAsBZ,EAAO,EAAK,GAElCa,IAAUC,GAAa,MAA2C;EACtE,IAAMC,IAAWd,EAAc,OAAOe,KAAS,aAAaA,EAAKjB,EAAQ,OAAO,IAAIiB,CAAI,GAClFC,IAASR,EAAc,SACvBS,IAAUD,IAASE,EAAUJ,GAAUE,GAAQG,EAAQ,OAAO,IAAIL;EACxE,IAAIJ,EAAgB,SAAS;GAG3B,IAAMU,IAAUf,EAAgB;GAOhC,AANKM,EAAoB,YACvB,EAAoB,UAAU,IAC9B,QAAQ,KAAKS,IACT,wMACA,4LAA4L,IAElMA,IAAUH,CAAO;GACjB;EACF;EACA,EAAQ,UAAUA;EAClB,KAAK,IAAMI,KAAMjB,EAAY,SAAS,EAAGa,CAAO;EAEhD,AADAZ,EAAgB,UAAUY,CAAO,GACjCK,EAAc;CAChB,GAAG;EAACA;EAAeH;EAAST;EAAiBL;EAAiBG;CAAa,CAAC,GAEtEe,IAAUV,QAAkBf,EAAQ,SAAS,CAAC,CAAC,GAC/C0B,IAAgBX,GAAa,OACjCT,EAAY,QAAQ,IAAIiB,CAAE,SACb;EAAE,EAAY,QAAQ,OAAOA,CAAE;CAAG,IAC9C,CAAC,CAAC,GAECI,IAAqB1B,EAAO,EAAK;CAiBvC,OAAO;EACL;EAAS;EAAgB;EAAS;EAAS;EAC3C,uBAhBkC;GAClC,IAAI,CAACI,GAAgB;GACrB,IAAMuB,IAAM5B,EAAQ;GAGpB,AAFA,EAAmB,YAAY4B,EAAI,MAAMvB,EAAe,KAAKuB,EAAI,MAAMvB,EAAe,KACjFuB,EAAI,MAAM,MAAMvB,EAAe,MAAM,KAAKuB,EAAI,MAAM,MAAMvB,EAAe,MAAM,GACpF,EAAQ,UAAUA;EACpB;EAUmB,oBATQU,QAAkB;GAC3C,IAAKY,EAAmB,SACxB;MAAmB,UAAU;IAC7B,KAAK,IAAMJ,KAAMjB,EAAY,SAAS,EAAGN,EAAQ,OAAO;GAD3B;EAE/B,GAAG,CAAC,CAKe;EAAoB,kBAJde,QAAkB;GAAE,EAAY,QAAQ,MAAM;EAAG,GAAG,CAAC,CAIvC;CACvC;AACF"}

package/dist/canvas/useFrameLoop.js

@@ -3,55 +3,64 @@ import { useCallback as t, useInsertionEffect as n, useLayoutEffect as r, useRef
 import { useLatest as a } from "@weasel-js/react";
 //#region src/canvas/useFrameLoop.ts
 function o(o, s = {}) {
-	let c = i(!0), l = i(!0), u = i(!1), d = a(o), f = a(s.syncPaint ?? !1), p = i(/* @__PURE__ */ new Set()), m = i(/* @__PURE__ */ new Set()), h = i(!1), g = i(null), _ = t((e) => {
-		c.current = !1, u.current = !0;
-		let t = !1;
+	let c = i(!0), l = i(!0), u = i(!1), d = a(o), f = a(s.syncPaint ?? !1), p = i(/* @__PURE__ */ new Set()), m = i(/* @__PURE__ */ new Set()), h = i(/* @__PURE__ */ new Set()), g = i(-Infinity), _ = i(!1), v = i(null), y = t((e) => {
+		let t = Math.max(e, g.current);
+		g.current = t, c.current = !1, u.current = !0;
+		let n = !1;
 		try {
-			for (let t of m.current) t(e);
-			if (t = d.current(), !t) {
+			for (let e of m.current) e(t);
+			if (n = d.current(), !n) {
 				c.current = !0;
 				return;
 			}
-			h.current = !1;
-			for (let t of p.current) t(e);
+			_.current = !1;
+			for (let e of p.current) e(t);
 		} catch (e) {
-			throw c.current = !0, h.current || (h.current = !0, g.current?.()), e;
+			throw c.current = !0, _.current || (_.current = !0, v.current?.()), e;
 		} finally {
 			u.current = !1;
 		}
-	}, [d]), v = e(t((e) => {
-		l.current && c.current && _(e);
-	}, [_]), { target: s.target });
+	}, [d]), b = e(t((e) => {
+		l.current && c.current && y(e);
+	}, [y]), {
+		target: s.target,
+		onResume: t(() => {
+			for (let e of h.current) e();
+		}, [])
+	});
 	n(() => {
-		g.current = () => {
-			v.request();
+		v.current = () => {
+			b.request();
 		};
 	});
-	let y = t(() => {
-		if (c.current = !0, f.current && l.current && !u.current && v.isVisible()) {
-			_(performance.now());
+	let x = t(() => {
+		if (c.current = !0, f.current && l.current && !u.current && b.isVisible()) {
+			y(performance.now());
 			return;
 		}
-		v.request();
+		b.request();
 	}, [
-		v,
-		_,
+		b,
+		y,
 		f
-	]), b = t((e) => (p.current.add(e), () => {
+	]), S = t((e) => (p.current.add(e), () => {
 		p.current.delete(e);
-	}), []), x = t((e) => (m.current.add(e), () => {
+	}), []), C = t((e) => (m.current.add(e), () => {
 		m.current.delete(e);
+	}), []), w = t((e) => (h.current.add(e), () => {
+		h.current.delete(e);
 	}), []);
 	return r(() => {
 		l.current = !0;
-		let e = p.current, t = m.current;
+		let e = p.current, t = m.current, n = h.current;
 		return () => {
-			l.current = !1, e.clear(), t.clear();
+			l.current = !1, e.clear(), t.clear(), n.clear();
 		};
 	}, []), {
-		requestRedraw: y,
-		subscribeFrame: b,
-		subscribeBeforePaint: x
+		requestRedraw: x,
+		subscribeFrame: S,
+		subscribeBeforePaint: C,
+		subscribeResume: w
 	};
 }
 //#endregion

package/dist/canvas/useFrameLoop.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFrameLoop.js","names":["useFrameLoop","dirtyRef","useRef","aliveRef","paintingRef","paintRef","useLatest","paint","syncRef","options","subsRef","beforeRef","retriedRef","rearmRef","runPaint","useCallback","landed","fn","time","err","frame","useVisibleRaf","requestRedraw","subscribeFrame","subscribeBeforePaint","useLayoutEffect","subs","before"],"sources":["../../src/canvas/useFrameLoop.ts"],"sourcesContent":["/**\n * The frame loop behind `<Canvas>`: a dirty flag, one frame in flight at a\n * time, and a subscriber set notified after a paint lands. When frames may run\n * at all is `useVisibleRaf`'s question, not this hook's — a redraw requested\n * while nothing can see the surface is held there and re-armed on resume.\n *\n * @internal Not consumer surface. Canvas exposes `requestRedraw` and\n *   `subscribeFrame` on its ref handle; this is how they are implemented.\n */\n\nimport { useCallback, useInsertionEffect, useLayoutEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf, type VisibleRafTarget } from '../scheduling/useVisibleRaf';\n\nexport interface FrameLoop {\n  /** Mark the surface dirty and schedule a frame. Identity is stable for the\n   *  lifetime of the component — consumers capture it. */\n  requestRedraw(): void;\n  /** Run `fn` after every landed paint, with the frame's time. Returns an\n   *  unsubscribe. */\n  subscribeFrame(fn: (time: number) => void): () => void;\n  /** Run `fn` on every frame just before its paint, with the frame's time.\n   *  Returns an unsubscribe. */\n  subscribeBeforePaint(fn: (time: number) => void): () => void;\n}\n\nexport interface FrameLoopOptions {\n  /** Paint in the caller's own stack — the commit or event that asked for the\n   *  redraw — instead of on the next animation frame. Read live, so toggling\n   *  it takes effect from the next `requestRedraw` on. */\n  syncPaint?: boolean;\n  /** The surface being painted. Given one, the loop also stops while that\n   *  element sits outside the viewport, not only while the tab is hidden. */\n  target?: VisibleRafTarget;\n}\n\n/**\n * @param paint Runs on the frame; returns whether pixels landed. A `false`\n *   leaves the surface dirty and notifies nobody, so the next request retries.\n */\nexport function useFrameLoop(paint: () => boolean, options: FrameLoopOptions = {}): FrameLoop {\n  const dirtyRef = useRef(true);\n  const aliveRef = useRef(true);\n  const paintingRef = useRef(false);\n  const paintRef = useLatest(paint);\n  const syncRef = useLatest(options.syncPaint ?? false);\n  const subsRef = useRef<Set<(time: number) => void>>(new Set());\n  const beforeRef = useRef<Set<(time: number) => void>>(new Set());\n\n  /** Set while recovering from a paint that threw, so one bad frame is retried\n   *  and a permanently throwing one still doesn't spin at frame rate. */\n  const retriedRef = useRef(false);\n  /** `frame.request`, which doesn't exist until after `runPaint` is built. */\n  const rearmRef = useRef<(() => void) | null>(null);\n\n  const runPaint = useCallback((time: number) => {\n    dirtyRef.current = false;\n    paintingRef.current = true;\n    let landed = false;\n    try {\n      for (const fn of beforeRef.current) fn(time);\n      landed = paintRef.current();\n      if (!landed) {\n        dirtyRef.current = true;\n        return;\n      }\n      retriedRef.current = false;\n      // Notified inside the guard: a subscriber calling `requestRedraw` under\n      // `syncPaint` would otherwise re-enter this synchronously, without bound.\n      for (const fn of subsRef.current) fn(time);\n    } catch (err) {\n      // A throw skips the `!landed` branch above, so without this the surface\n      // is left clean but unpainted — the pixels on screen are whatever the\n      // last landed frame left, and nothing repaints until something\n      // unrelated happens to request a redraw. That is how a single\n      // malformed node blanked a whole document until the pointer moved.\n      dirtyRef.current = true;\n      if (!retriedRef.current) {\n        retriedRef.current = true;\n        rearmRef.current?.();\n      }\n      throw err;\n    } finally {\n      paintingRef.current = false;\n    }\n  }, [paintRef]);\n\n  const frame = useVisibleRaf(\n    useCallback((time: number) => {\n      if (!aliveRef.current || !dirtyRef.current) return;\n      runPaint(time);\n    }, [runPaint]),\n    { target: options.target },\n  );\n  useInsertionEffect(() => {\n    rearmRef.current = () => { frame.request(); };\n  });\n\n  const requestRedraw = useCallback(() => {\n    dirtyRef.current = true;\n    // The gate suppresses the sync path too: a background tab still commits\n    // React updates, and that is the one paint browser throttling does not stop.\n    // A request made from inside a draw or a frame subscriber would recurse\n    // forever if it painted here, so re-entrant ones fall through to a frame.\n    if (syncRef.current && aliveRef.current && !paintingRef.current && frame.isVisible()) {\n      runPaint(performance.now());\n      return;\n    }\n    frame.request();\n  }, [frame, runPaint, syncRef]);\n\n  const subscribeFrame = useCallback((fn: (time: number) => void) => {\n    subsRef.current.add(fn);\n    return () => { subsRef.current.delete(fn); };\n  }, []);\n  const subscribeBeforePaint = useCallback((fn: (time: number) => void) => {\n    beforeRef.current.add(fn);\n    return () => { beforeRef.current.delete(fn); };\n  }, []);\n\n  // `requestRedraw` outlives the component: `@weasel-js/hud` calls it from a\n  // `.then()`, and `viewRegistry.attachSurface` hands it to the consumer.\n  // Re-armed in setup because refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes Canvas's own layout effects — the\n  // sync-paint path runs in one of those.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    const subs = subsRef.current;\n    const before = beforeRef.current;\n    return () => {\n      aliveRef.current = false;\n      subs.clear();\n      before.clear();\n    };\n  }, []);\n\n  return { requestRedraw, subscribeFrame, subscribeBeforePaint };\n}\n"],"mappings":";;;;AAwCA,SAAgBA,EAAa,GAAsB,IAA4B,CAAC,GAAc;CAC5F,IAAMC,IAAWC,EAAO,EAAI,GACtBC,IAAWD,EAAO,EAAI,GACtBE,IAAcF,EAAO,EAAK,GAC1BG,IAAWC,EAAUC,CAAK,GAC1BC,IAAUF,EAAUG,EAAQ,aAAa,EAAK,GAC9CC,IAAUR,kBAAoC,IAAI,IAAI,CAAC,GACvDS,IAAYT,kBAAoC,IAAI,IAAI,CAAC,GAIzDU,IAAaV,EAAO,EAAK,GAEzBW,IAAWX,EAA4B,IAAI,GAE3CY,IAAWC,GAAa,MAAiB;EAE7C,AADA,EAAS,UAAU,IACnB,EAAY,UAAU;EACtB,IAAIC,IAAS;EACb,IAAI;GACF,KAAK,IAAMC,KAAMN,EAAU,SAAS,EAAGO,CAAI;GAE3C,IADA,IAASb,EAAS,QAAQ,GACtB,CAACW,GAAQ;IACX,EAAS,UAAU;IACnB;GACF;GACA,EAAW,UAAU;GAGrB,KAAK,IAAMC,KAAMP,EAAQ,SAAS,EAAGQ,CAAI;EAC3C,SAASC,GAAK;GAWZ,MALA,EAAS,UAAU,IACdP,EAAW,YACd,EAAW,UAAU,IACrBC,EAAS,UAAU,IAEfM;EACR,UAAU;GACR,EAAY,UAAU;EACxB;CACF,GAAG,CAACd,CAAQ,CAAC,GAEPe,IAAQC,EACZN,GAAa,MAAiB;EAC5B,AAAKZ,EAAS,WAAYF,EAAS,WACnCa,EAASI,CAAI;CACf,GAAG,CAACJ,CAAQ,CAAC,GACb,EAAE,QAAQL,EAAQ,OAAO,CAC3B;CACA,QAAyB;EACvB,EAAS,gBAAgB;GAAE,EAAM,QAAQ;EAAG;CAC9C,CAAC;CAED,IAAMa,IAAgBP,QAAkB;EAMtC,IALA,EAAS,UAAU,IAKfP,EAAQ,WAAWL,EAAS,WAAW,CAACC,EAAY,WAAWgB,EAAM,UAAU,GAAG;GACpF,EAAS,YAAY,IAAI,CAAC;GAC1B;EACF;EACA,EAAM,QAAQ;CAChB,GAAG;EAACA;EAAON;EAAUN;CAAO,CAAC,GAEvBe,IAAiBR,GAAa,OAClCL,EAAQ,QAAQ,IAAIO,CAAE,SACT;EAAE,EAAQ,QAAQ,OAAOA,CAAE;CAAG,IAC1C,CAAC,CAAC,GACCO,IAAuBT,GAAa,OACxCJ,EAAU,QAAQ,IAAIM,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC;CAkBL,OAXAQ,QAAsB;EACpB,EAAS,UAAU;EACnB,IAAMC,IAAOhB,EAAQ,SACfiB,IAAShB,EAAU;EACzB,aAAa;GAGX,AAFA,EAAS,UAAU,IACnBe,EAAK,MAAM,GACXC,EAAO,MAAM;EACf;CACF,GAAG,CAAC,CAAC,GAEE;EAAE;EAAe;EAAgB;CAAqB;AAC/D"}
+{"version":3,"file":"useFrameLoop.js","names":["useFrameLoop","dirtyRef","useRef","aliveRef","paintingRef","paintRef","useLatest","paint","syncRef","options","subsRef","beforeRef","resumeRef","lastTimeRef","retriedRef","rearmRef","runPaint","useCallback","time","at","landed","fn","err","frame","useVisibleRaf","requestRedraw","subscribeFrame","subscribeBeforePaint","subscribeResume","useLayoutEffect","subs","before","resume"],"sources":["../../src/canvas/useFrameLoop.ts"],"sourcesContent":["/**\n * The frame loop behind `<Canvas>`: a dirty flag, one frame in flight at a\n * time, and a subscriber set notified after a paint lands. When frames may run\n * at all is `useVisibleRaf`'s question, not this hook's — a redraw requested\n * while nothing can see the surface is held there and re-armed on resume.\n *\n * @internal Not consumer surface. Canvas exposes `requestRedraw` and\n *   `subscribeFrame` on its ref handle; this is how they are implemented.\n */\n\nimport { useCallback, useInsertionEffect, useLayoutEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf, type VisibleRafTarget } from '../scheduling/useVisibleRaf';\n\nexport interface FrameLoop {\n  /** Mark the surface dirty and schedule a frame. Identity is stable for the\n   *  lifetime of the component — consumers capture it. */\n  requestRedraw(): void;\n  /** Run `fn` after every landed paint, with the frame's time. Returns an\n   *  unsubscribe. */\n  subscribeFrame(fn: (time: number) => void): () => void;\n  /** Run `fn` on every frame just before its paint, with the frame's time.\n   *  Returns an unsubscribe. */\n  subscribeBeforePaint(fn: (time: number) => void): () => void;\n  /** Run `fn` when the loop leaves suspension, before the frame that follows.\n   *  Returns an unsubscribe. */\n  subscribeResume(fn: () => void): () => void;\n}\n\nexport interface FrameLoopOptions {\n  /** Paint in the caller's own stack — the commit or event that asked for the\n   *  redraw — instead of on the next animation frame. Read live, so toggling\n   *  it takes effect from the next `requestRedraw` on. */\n  syncPaint?: boolean;\n  /** The surface being painted. Given one, the loop also stops while that\n   *  element sits outside the viewport, not only while the tab is hidden. */\n  target?: VisibleRafTarget;\n}\n\n/**\n * @param paint Runs on the frame; returns whether pixels landed. A `false`\n *   leaves the surface dirty and notifies nobody, so the next request retries.\n */\nexport function useFrameLoop(paint: () => boolean, options: FrameLoopOptions = {}): FrameLoop {\n  const dirtyRef = useRef(true);\n  const aliveRef = useRef(true);\n  const paintingRef = useRef(false);\n  const paintRef = useLatest(paint);\n  const syncRef = useLatest(options.syncPaint ?? false);\n  const subsRef = useRef<Set<(time: number) => void>>(new Set());\n  const beforeRef = useRef<Set<(time: number) => void>>(new Set());\n  const resumeRef = useRef<Set<() => void>>(new Set());\n  /** The last time handed to subscribers. A sync paint reads the clock at the\n   *  call and a rAF frame carries its frame's start, so within one animation\n   *  frame the second can be the earlier of the two. */\n  const lastTimeRef = useRef(-Infinity);\n\n  /** Set while recovering from a paint that threw, so one bad frame is retried\n   *  and a permanently throwing one still doesn't spin at frame rate. */\n  const retriedRef = useRef(false);\n  /** `frame.request`, which doesn't exist until after `runPaint` is built. */\n  const rearmRef = useRef<(() => void) | null>(null);\n\n  const runPaint = useCallback((at: number) => {\n    const time = Math.max(at, lastTimeRef.current);\n    lastTimeRef.current = time;\n    dirtyRef.current = false;\n    paintingRef.current = true;\n    let landed = false;\n    try {\n      for (const fn of beforeRef.current) fn(time);\n      landed = paintRef.current();\n      if (!landed) {\n        dirtyRef.current = true;\n        return;\n      }\n      retriedRef.current = false;\n      // Notified inside the guard: a subscriber calling `requestRedraw` under\n      // `syncPaint` would otherwise re-enter this synchronously, without bound.\n      for (const fn of subsRef.current) fn(time);\n    } catch (err) {\n      // A throw skips the `!landed` branch above, so without this the surface\n      // is left clean but unpainted — the pixels on screen are whatever the\n      // last landed frame left, and nothing repaints until something\n      // unrelated happens to request a redraw. That is how a single\n      // malformed node blanked a whole document until the pointer moved.\n      dirtyRef.current = true;\n      if (!retriedRef.current) {\n        retriedRef.current = true;\n        rearmRef.current?.();\n      }\n      throw err;\n    } finally {\n      paintingRef.current = false;\n    }\n  }, [paintRef]);\n\n  const frame = useVisibleRaf(\n    useCallback((time: number) => {\n      if (!aliveRef.current || !dirtyRef.current) return;\n      runPaint(time);\n    }, [runPaint]),\n    {\n      target: options.target,\n      onResume: useCallback(() => { for (const fn of resumeRef.current) fn(); }, []),\n    },\n  );\n  useInsertionEffect(() => {\n    rearmRef.current = () => { frame.request(); };\n  });\n\n  const requestRedraw = useCallback(() => {\n    dirtyRef.current = true;\n    // The gate suppresses the sync path too: a background tab still commits\n    // React updates, and that is the one paint browser throttling does not stop.\n    // A request made from inside a draw or a frame subscriber would recurse\n    // forever if it painted here, so re-entrant ones fall through to a frame.\n    if (syncRef.current && aliveRef.current && !paintingRef.current && frame.isVisible()) {\n      runPaint(performance.now());\n      return;\n    }\n    frame.request();\n  }, [frame, runPaint, syncRef]);\n\n  const subscribeFrame = useCallback((fn: (time: number) => void) => {\n    subsRef.current.add(fn);\n    return () => { subsRef.current.delete(fn); };\n  }, []);\n  const subscribeBeforePaint = useCallback((fn: (time: number) => void) => {\n    beforeRef.current.add(fn);\n    return () => { beforeRef.current.delete(fn); };\n  }, []);\n\n  const subscribeResume = useCallback((fn: () => void) => {\n    resumeRef.current.add(fn);\n    return () => { resumeRef.current.delete(fn); };\n  }, []);\n\n  // `requestRedraw` outlives the component: `@weasel-js/hud` calls it from a\n  // `.then()`, and `viewRegistry.attachSurface` hands it to the consumer.\n  // Re-armed in setup because refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes Canvas's own layout effects — the\n  // sync-paint path runs in one of those.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    const subs = subsRef.current;\n    const before = beforeRef.current;\n    const resume = resumeRef.current;\n    return () => {\n      aliveRef.current = false;\n      subs.clear();\n      before.clear();\n      resume.clear();\n    };\n  }, []);\n\n  return { requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume };\n}\n"],"mappings":";;;;AA2CA,SAAgBA,EAAa,GAAsB,IAA4B,CAAC,GAAc;CAC5F,IAAMC,IAAWC,EAAO,EAAI,GACtBC,IAAWD,EAAO,EAAI,GACtBE,IAAcF,EAAO,EAAK,GAC1BG,IAAWC,EAAUC,CAAK,GAC1BC,IAAUF,EAAUG,EAAQ,aAAa,EAAK,GAC9CC,IAAUR,kBAAoC,IAAI,IAAI,CAAC,GACvDS,IAAYT,kBAAoC,IAAI,IAAI,CAAC,GACzDU,IAAYV,kBAAwB,IAAI,IAAI,CAAC,GAI7CW,IAAcX,EAAO,SAAS,GAI9BY,IAAaZ,EAAO,EAAK,GAEzBa,IAAWb,EAA4B,IAAI,GAE3Cc,IAAWC,GAAa,MAAe;EAC3C,IAAMC,IAAO,KAAK,IAAIC,GAAIN,EAAY,OAAO;EAG7C,AAFA,EAAY,UAAUK,GACtB,EAAS,UAAU,IACnB,EAAY,UAAU;EACtB,IAAIE,IAAS;EACb,IAAI;GACF,KAAK,IAAMC,KAAMV,EAAU,SAAS,EAAGO,CAAI;GAE3C,IADA,IAASb,EAAS,QAAQ,GACtB,CAACe,GAAQ;IACX,EAAS,UAAU;IACnB;GACF;GACA,EAAW,UAAU;GAGrB,KAAK,IAAMC,KAAMX,EAAQ,SAAS,EAAGQ,CAAI;EAC3C,SAASI,GAAK;GAWZ,MALA,EAAS,UAAU,IACdR,EAAW,YACd,EAAW,UAAU,IACrBC,EAAS,UAAU,IAEfO;EACR,UAAU;GACR,EAAY,UAAU;EACxB;CACF,GAAG,CAACjB,CAAQ,CAAC,GAEPkB,IAAQC,EACZP,GAAa,MAAiB;EAC5B,AAAKd,EAAS,WAAYF,EAAS,WACnCe,EAASE,CAAI;CACf,GAAG,CAACF,CAAQ,CAAC,GACb;EACE,QAAQP,EAAQ;EAChB,UAAUQ,QAAkB;GAAE,KAAK,IAAMI,KAAMT,EAAU,SAAS,EAAG;EAAG,GAAG,CAAC,CAAC;CAC/E,CACF;CACA,QAAyB;EACvB,EAAS,gBAAgB;GAAE,EAAM,QAAQ;EAAG;CAC9C,CAAC;CAED,IAAMa,IAAgBR,QAAkB;EAMtC,IALA,EAAS,UAAU,IAKfT,EAAQ,WAAWL,EAAS,WAAW,CAACC,EAAY,WAAWmB,EAAM,UAAU,GAAG;GACpF,EAAS,YAAY,IAAI,CAAC;GAC1B;EACF;EACA,EAAM,QAAQ;CAChB,GAAG;EAACA;EAAOP;EAAUR;CAAO,CAAC,GAEvBkB,IAAiBT,GAAa,OAClCP,EAAQ,QAAQ,IAAIW,CAAE,SACT;EAAE,EAAQ,QAAQ,OAAOA,CAAE;CAAG,IAC1C,CAAC,CAAC,GACCM,IAAuBV,GAAa,OACxCN,EAAU,QAAQ,IAAIU,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC,GAECO,IAAkBX,GAAa,OACnCL,EAAU,QAAQ,IAAIS,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC;CAoBL,OAbAQ,QAAsB;EACpB,EAAS,UAAU;EACnB,IAAMC,IAAOpB,EAAQ,SACfqB,IAASpB,EAAU,SACnBqB,IAASpB,EAAU;EACzB,aAAa;GAIX,AAHA,EAAS,UAAU,IACnBkB,EAAK,MAAM,GACXC,EAAO,MAAM,GACbC,EAAO,MAAM;EACf;CACF,GAAG,CAAC,CAAC,GAEE;EAAE;EAAe;EAAgB;EAAsB;CAAgB;AAChF"}

package/dist/canvas/useSceneLayerList.js

@@ -0,0 +1,21 @@
+import { useCallback as e, useState as t } from "react";
+import { useLatest as n } from "@weasel-js/react";
+//#region src/canvas/useSceneLayerList.ts
+var r = (e) => typeof e?.getLayers == "function" ? e.getLayers().map((e) => e.id).join("\n") : "";
+function i(i) {
+	let [a, o] = t(() => r(i)), s = n({
+		adapter: i,
+		key: a
+	});
+	return {
+		key: a,
+		sync: e(() => {
+			let e = r(s.current.adapter);
+			return e !== s.current.key && (o(e), !0);
+		}, [s])
+	};
+}
+//#endregion
+export { i as useSceneLayerList };
+
+//# sourceMappingURL=useSceneLayerList.js.map

package/dist/canvas/useSceneLayerList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneLayerList.js","names":["read","adapter","l","useSceneLayerList","key","setKey","useState","live","useLatest","useCallback","now"],"sources":["../../src/canvas/useSceneLayerList.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\n\ninterface LayerListSource {\n  getLayers?: () => readonly { id: string }[];\n}\n\nconst read = (adapter: LayerListSource | undefined): string =>\n  typeof adapter?.getLayers === 'function' ? adapter.getLayers().map((l) => l.id).join('\\n') : '';\n\n/**\n * The adapter's scene-layer ids as a render input. A scene write repaints\n * without re-rendering, so nothing on the React side sees a layer added,\n * removed, or reordered; the paint calls `sync` to find out.\n */\nexport function useSceneLayerList(adapter: LayerListSource | undefined): {\n  /** Changes when the layer list does. A memo dependency. */\n  key: string;\n  /** Re-read the list. Returns `true`, having queued a render, when the\n   *  layers built from `key` no longer match it. */\n  sync(): boolean;\n} {\n  const [key, setKey] = useState(() => read(adapter));\n  const live = useLatest({ adapter, key });\n  const sync = useCallback((): boolean => {\n    const now = read(live.current.adapter);\n    if (now === live.current.key) return false;\n    setKey(now);\n    return true;\n  }, [live]);\n  return { key, sync };\n}\n"],"mappings":";;;AAOA,IAAMA,KAAQ,MACZ,OAAOC,GAAS,aAAc,aAAaA,EAAQ,UAAU,CAAC,CAAC,KAAK,MAAMC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI;AAO/F,SAAgBC,EAAkB,GAMhC;CACA,IAAM,CAACC,GAAKC,KAAUC,QAAeN,EAAKC,CAAO,CAAC,GAC5CM,IAAOC,EAAU;EAAE;EAAS;CAAI,CAAC;CAOvC,OAAO;EAAE;EAAK,MANDC,QAA2B;GACtC,IAAMC,IAAMV,EAAKO,EAAK,QAAQ,OAAO;GAGrC,OAFIG,MAAQH,EAAK,QAAQ,QACzBF,EAAOK,CAAG,GACH;EACT,GAAG,CAACH,CAAI,CACM;CAAK;AACrB"}

package/dist/clipboard.d.ts

@@ -1,5 +1,5 @@
 import { NodeId } from '@weasel-js/routing';
-import { j as ClipboardSnapshot, I as InsertAdapter } from './types-A37hYkeR.js';
+import { e as PasteOmission, k as ClipboardSnapshot, I as InsertAdapter } from './types-k-5Oqh-U.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 
@@ -11,6 +11,10 @@ interface UseClipboardOpsOptions {
     getSelection: () => NodeId[];
     /** Called after a successful paste with the ids of the newly inserted objects. */
     onPaste?: (newIds: NodeId[]) => void;
+    /** Called when a paste left copied nodes out, with each one and the reason
+     *  — an edge whose endpoints were not copied with it, say. Also called for
+     *  a paste that made nothing. */
+    onPasteOmitted?: (omitted: PasteOmission[]) => void;
     /** Label for the history entry produced by paste. Default 'Paste'. */
     pasteLabel?: string;
     /** Pulled once per paste() call. When non-null, threaded to commitPaste
@@ -58,11 +62,11 @@ type Replacer = (key: string, value: unknown) => unknown;
 type Reviver = (key: string, value: unknown) => unknown;
 /** Serialize snapshot items into the versioned wire text.
  *
- *  Function-valued fields (e.g. a container's `clipFromPose`) are dropped by
- *  JSON serialization — OS-pasted clip containers arrive unclipped.
- *  Consumers who need clips to survive the OS round-trip can translate
- *  function ↔ registry key in their `jsonReplacer`/reviver pair (the
- *  scene-serialization `clipFromPoseKey` precedent). */
+ *  JSON drops a function-valued field (a container's `clipFromPose`, a
+ *  node's `derivePath`). A scene adapter's snapshot also carries each one's
+ *  `SceneRegistry` key (`clipFromPoseKey`, `derivePathKey`, …), which does
+ *  cross, and its paste restores the function from the pasting scene's
+ *  registry. A function that is not registered does not survive. */
 declare function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string;
 /** Cheap check: could this text be a weasel clipboard payload? Substring
  *  pre-check, then a guarded parse + marker/version test. */

package/dist/clone.d.ts

@@ -1,10 +1,11 @@
-import { C as CloneBehavior } from './types-B_9g6hMM.js';
-import './types-A37hYkeR.js';
+import { C as CloneBehavior } from './types-B4iJRHC3.js';
+import './types-k-5Oqh-U.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 import '@weasel-js/routing';
 
-/** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */
+/** Clone-on-alt-drag behavior; activates when Alt/Option is held at drag start.
+ *  `cloneAction` runs no clone behaviors, so nothing in the kit calls this. */
 declare function cloneByAltDrag(): CloneBehavior;
 
 export { cloneByAltDrag };