@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/sceneLayerPaint.js

@@ -1,11 +1,11 @@
-import { isLayerVisible as e } from "../core/layers/render.js";
+import { paintedLayers as e } from "../core/layers/render.js";
 //#region src/canvas/sceneLayerPaint.ts
 function t(e) {
 	return `scene:${e}`;
 }
 function n(t, n) {
-	let r = n.layers ? n.layers(t) : t, i = n.layerOrder, a = i ? i.map((e) => r.find((t) => t.id === e)).filter((e) => e !== void 0) : r, o = n.layerVisibility ?? {};
-	return a.filter((t) => e(t, o));
+	let r = n.layers ? n.layers(t) : t;
+	return e(r, n.layerVisibility ?? {}, n.layerOrder);
 }
 function r() {
 	let e = null;
@@ -32,6 +32,6 @@ function i(e, n) {
 	return r === void 0 && i === void 0 ? e : (i ? i.map((n) => e.find((e) => t(e.id) === n)).filter((e) => e !== void 0) : e).filter((e) => r?.[t(e.id)] !== !1);
 }
 //#endregion
-export { r as createSceneLayerGate, n as paintedLayers, i as paintedSceneLayers, t as sceneLayerKey };
+export { r as createSceneLayerGate, i as paintedSceneLayers, t as sceneLayerKey, n as viewPaintedLayers };
 
 //# sourceMappingURL=sceneLayerPaint.js.map

package/dist/canvas/sceneLayerPaint.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneLayerPaint.js","names":["sceneLayerKey","layerId","paintedLayers","narrowed","view","surface","order","sequence","l","id","visibility","isLayerVisible","createSceneLayerGate","last","inputs","v","i","byId","drawn","gate","carrier","paintedSceneLayers","layerVisibility","layerOrder","layers","key"],"sources":["../../src/canvas/sceneLayerPaint.ts"],"sourcesContent":["/**\n * Which scene layers a view paints.\n *\n * A view's `layerVisibility` / `layerOrder` name render layers, and `<Canvas>`\n * paints a scene as one render layer per scene layer, keyed `scene:<layerId>`.\n * Picking, marquee and select-all ask about scene layers, so this is where one\n * namespace is read in terms of the other.\n */\nimport { isLayerVisible, type RenderLayer } from 'core/layers/render';\n\n/** The render-layer id a scene layer paints under. */\nexport function sceneLayerKey(layerId: string): string {\n  return `scene:${layerId}`;\n}\n\n/** Per-view layer settings, in `<Canvas>`'s vocabulary. */\nexport interface ViewLayerPaint {\n  /** Narrows the surface's stack before the other two apply. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  layerVisibility?: Record<string, boolean>;\n  layerOrder?: readonly string[];\n}\n\n/** The layers a view draws, in the order it draws them — the two gates\n *  `drawLayers` applies, over whatever `layers` narrowed to. */\nexport function paintedLayers(\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n): readonly RenderLayer<unknown>[] {\n  const narrowed = view.layers ? view.layers(surface) : surface;\n  const order = view.layerOrder;\n  const sequence = order\n    ? order\n      .map((id) => narrowed.find((l) => l.id === id))\n      .filter((l): l is RenderLayer<unknown> => l !== undefined)\n    : narrowed;\n  const visibility = view.layerVisibility ?? {};\n  return sequence.filter((l) => isLayerVisible(l, visibility));\n}\n\n/**\n * A gate answering \"does this scene layer reach the screen in this view\",\n * rebuilt only when the surface's stack or the view's settings change — it is\n * asked once per pick candidate.\n *\n * A scene layer is painted when the render layer carrying it is: its own\n * `scene:<id>`, or the bundled `scene` layer an adapter without layers gets.\n * A surface carrying neither paints the scene some other way, which is not\n * this gate's to judge, so it passes.\n */\nexport function createSceneLayerGate(): (\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n) => (layerId: string) => boolean {\n  let last: { inputs: readonly unknown[]; gate: (layerId: string) => boolean } | null = null;\n  return (surface, view) => {\n    const inputs = [surface, view.layers, view.layerVisibility, view.layerOrder];\n    if (last && last.inputs.every((v, i) => v === inputs[i])) return last.gate;\n    const byId = new Map(surface.map((l) => [l.id, l]));\n    const drawn = new Set(paintedLayers(surface, view));\n    const gate = (layerId: string): boolean => {\n      const carrier = byId.get(sceneLayerKey(layerId)) ?? byId.get('scene');\n      return carrier === undefined || drawn.has(carrier);\n    };\n    last = { inputs, gate };\n    return gate;\n  };\n}\n\n/** Scene layers in the order a view paints them, for a view that walks the\n *  scene itself rather than a render-layer stack. Keyed as `<SceneCanvas>`\n *  keys them, so one map serves both. */\nexport function paintedSceneLayers<T extends { id: string }>(\n  layers: readonly T[],\n  view: Pick<ViewLayerPaint, 'layerVisibility' | 'layerOrder'>,\n): readonly T[] {\n  const { layerVisibility, layerOrder } = view;\n  if (layerVisibility === undefined && layerOrder === undefined) return layers;\n  const sequence = layerOrder\n    ? layerOrder\n      .map((key) => layers.find((l) => sceneLayerKey(l.id) === key))\n      .filter((l): l is T => l !== undefined)\n    : layers;\n  return sequence.filter((l) => layerVisibility?.[sceneLayerKey(l.id)] !== false);\n}\n"],"mappings":";;AAWA,SAAgBA,EAAc,GAAyB;CACrD,OAAO,SAASC;AAClB;AAYA,SAAgBC,EACd,GACA,GACiC;CACjC,IAAMC,IAAWC,EAAK,SAASA,EAAK,OAAOC,CAAO,IAAIA,GAChDC,IAAQF,EAAK,YACbG,IAAWD,IACbA,EACC,KAAK,MAAOH,EAAS,MAAM,MAAMK,EAAE,OAAOC,CAAE,CAAC,CAAC,CAC9C,QAAQ,MAAiCD,MAAM,KAAA,CAAS,IACzDL,GACEO,IAAaN,EAAK,mBAAmB,CAAC;CAC5C,OAAOG,EAAS,QAAQ,MAAMI,EAAeH,GAAGE,CAAU,CAAC;AAC7D;AAYA,SAAgBE,IAGkB;CAChC,IAAIC,IAAkF;CACtF,QAAQ,GAAS,MAAS;EACxB,IAAMC,IAAS;GAACT;GAASD,EAAK;GAAQA,EAAK;GAAiBA,EAAK;EAAU;EAC3E,IAAIS,KAAQA,EAAK,OAAO,OAAO,GAAG,MAAME,MAAMD,EAAOE,EAAE,GAAG,OAAOH,EAAK;EACtE,IAAMI,IAAO,IAAI,IAAIZ,EAAQ,KAAK,MAAM,CAACG,EAAE,IAAIA,CAAC,CAAC,CAAC,GAC5CU,IAAQ,IAAI,IAAIhB,EAAcG,GAASD,CAAI,CAAC,GAC5Ce,KAAQ,MAA6B;GACzC,IAAMC,IAAUH,EAAK,IAAIjB,EAAcC,CAAO,CAAC,KAAKgB,EAAK,IAAI,OAAO;GACpE,OAAOG,MAAY,KAAA,KAAaF,EAAM,IAAIE,CAAO;EACnD;EAEA,OADA,IAAO;GAAE;GAAQ;EAAK,GACfD;CACT;AACF;AAKA,SAAgBE,EACd,GACA,GACc;CACd,IAAM,EAAE,oBAAiB,kBAAejB;CAOxC,OANIkB,MAAoB,KAAA,KAAaC,MAAe,KAAA,IAAkBC,KACrDD,IACbA,EACC,KAAK,MAAQC,EAAO,MAAM,MAAMxB,EAAcQ,EAAE,EAAE,MAAMiB,CAAG,CAAC,CAAC,CAC7D,QAAQ,MAAcjB,MAAM,KAAA,CAAS,IACtCgB,EAAA,CACY,QAAQ,MAAMF,IAAkBtB,EAAcQ,EAAE,EAAE,OAAO,EAAK;AAChF"}
+{"version":3,"file":"sceneLayerPaint.js","names":["sceneLayerKey","layerId","viewPaintedLayers","narrowed","view","surface","paintedLayers","createSceneLayerGate","last","inputs","v","i","byId","l","drawn","gate","carrier","paintedSceneLayers","layerVisibility","layerOrder","layers","key"],"sources":["../../src/canvas/sceneLayerPaint.ts"],"sourcesContent":["/**\n * Which scene layers a view paints.\n *\n * A view's `layerVisibility` / `layerOrder` name render layers, and `<Canvas>`\n * paints a scene as one render layer per scene layer, keyed `scene:<layerId>`.\n * Picking, marquee and select-all ask about scene layers, so this is where one\n * namespace is read in terms of the other.\n */\nimport { paintedLayers, type RenderLayer } from 'core/layers/render';\n\n/** The render-layer id a scene layer paints under. */\nexport function sceneLayerKey(layerId: string): string {\n  return `scene:${layerId}`;\n}\n\n/** Per-view layer settings, in `<Canvas>`'s vocabulary. */\nexport interface ViewLayerPaint {\n  /** Narrows the surface's stack before the other two apply. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  layerVisibility?: Record<string, boolean>;\n  layerOrder?: readonly string[];\n}\n\n/** The layers a view draws, in the order it draws them: what `drawLayers`\n *  would paint of whatever `layers` narrowed to. */\nexport function viewPaintedLayers(\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n): readonly RenderLayer<unknown>[] {\n  const narrowed = view.layers ? view.layers(surface) : surface;\n  return paintedLayers(narrowed, view.layerVisibility ?? {}, view.layerOrder);\n}\n\n/**\n * A gate answering \"does this scene layer reach the screen in this view\",\n * rebuilt only when the surface's stack or the view's settings change — it is\n * asked once per pick candidate.\n *\n * A scene layer is painted when the render layer carrying it is: its own\n * `scene:<id>`, or the bundled `scene` layer an adapter without layers gets.\n * A surface carrying neither paints the scene some other way, which is not\n * this gate's to judge, so it passes.\n */\nexport function createSceneLayerGate(): (\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n) => (layerId: string) => boolean {\n  let last: { inputs: readonly unknown[]; gate: (layerId: string) => boolean } | null = null;\n  return (surface, view) => {\n    const inputs = [surface, view.layers, view.layerVisibility, view.layerOrder];\n    if (last && last.inputs.every((v, i) => v === inputs[i])) return last.gate;\n    const byId = new Map(surface.map((l) => [l.id, l]));\n    const drawn = new Set(viewPaintedLayers(surface, view));\n    const gate = (layerId: string): boolean => {\n      const carrier = byId.get(sceneLayerKey(layerId)) ?? byId.get('scene');\n      return carrier === undefined || drawn.has(carrier);\n    };\n    last = { inputs, gate };\n    return gate;\n  };\n}\n\n/** Scene layers in the order a view paints them, for a view that walks the\n *  scene itself rather than a render-layer stack. Keyed as `<SceneCanvas>`\n *  keys them, so one map serves both. */\nexport function paintedSceneLayers<T extends { id: string }>(\n  layers: readonly T[],\n  view: Pick<ViewLayerPaint, 'layerVisibility' | 'layerOrder'>,\n): readonly T[] {\n  const { layerVisibility, layerOrder } = view;\n  if (layerVisibility === undefined && layerOrder === undefined) return layers;\n  const sequence = layerOrder\n    ? layerOrder\n      .map((key) => layers.find((l) => sceneLayerKey(l.id) === key))\n      .filter((l): l is T => l !== undefined)\n    : layers;\n  return sequence.filter((l) => layerVisibility?.[sceneLayerKey(l.id)] !== false);\n}\n"],"mappings":";;AAWA,SAAgBA,EAAc,GAAyB;CACrD,OAAO,SAASC;AAClB;AAYA,SAAgBC,EACd,GACA,GACiC;CACjC,IAAMC,IAAWC,EAAK,SAASA,EAAK,OAAOC,CAAO,IAAIA;CACtD,OAAOC,EAAcH,GAAUC,EAAK,mBAAmB,CAAC,GAAGA,EAAK,UAAU;AAC5E;AAYA,SAAgBG,IAGkB;CAChC,IAAIC,IAAkF;CACtF,QAAQ,GAAS,MAAS;EACxB,IAAMC,IAAS;GAACJ;GAASD,EAAK;GAAQA,EAAK;GAAiBA,EAAK;EAAU;EAC3E,IAAII,KAAQA,EAAK,OAAO,OAAO,GAAG,MAAME,MAAMD,EAAOE,EAAE,GAAG,OAAOH,EAAK;EACtE,IAAMI,IAAO,IAAI,IAAIP,EAAQ,KAAK,MAAM,CAACQ,EAAE,IAAIA,CAAC,CAAC,CAAC,GAC5CC,IAAQ,IAAI,IAAIZ,EAAkBG,GAASD,CAAI,CAAC,GAChDW,KAAQ,MAA6B;GACzC,IAAMC,IAAUJ,EAAK,IAAIZ,EAAcC,CAAO,CAAC,KAAKW,EAAK,IAAI,OAAO;GACpE,OAAOI,MAAY,KAAA,KAAaF,EAAM,IAAIE,CAAO;EACnD;EAEA,OADA,IAAO;GAAE;GAAQ;EAAK,GACfD;CACT;AACF;AAKA,SAAgBE,EACd,GACA,GACc;CACd,IAAM,EAAE,oBAAiB,kBAAeb;CAOxC,OANIc,MAAoB,KAAA,KAAaC,MAAe,KAAA,IAAkBC,KACrDD,IACbA,EACC,KAAK,MAAQC,EAAO,MAAM,MAAMpB,EAAca,EAAE,EAAE,MAAMQ,CAAG,CAAC,CAAC,CAC7D,QAAQ,MAAcR,MAAM,KAAA,CAAS,IACtCO,EAAA,CACY,QAAQ,MAAMF,IAAkBlB,EAAca,EAAE,EAAE,OAAO,EAAK;AAChF"}

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","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 './buildSceneLayer';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\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"}

package/dist/canvas/sceneViewRender.js

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

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":["viewToMat3","viewToMat3$1","sceneAsHierarchy","paintedSceneLayers","scene","layers","l","id","parentId","node","effectivePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","derived","colorOverrides","withColorOverrides","derivedPathOf","sceneDerivedPathOf","wrappedDrawOne","overrideAlpha","wrapNodeOutput","pose","v","alphaFor","hierarchy","composesFrames","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","children","cullDrawCommands","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\nimport type { WeaselRenderer } from '@weasel-js/renderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport { composesFrames } from 'core/scene/composePose';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { DrawCommand } from '@weasel-js/renderer';\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 '@weasel-js/animator';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '@weasel-js/renderer';\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 first call on a given canvas creates\n   *  its renderer and later calls reuse it;\n   *  `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene and `extraCommands` alike. */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; the element's CSS size is the caller's to set. */\n  width: number;\n  height: number;\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Commands appended after the scene-node output, wrapped in the same view\n   *  transform as scene commands. */\n  extraCommands?: DrawCommand[];\n  /** Per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. 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  /** Device-pixel ratio. Defaults to `window.devicePixelRatio || 1` when\n   *  available, otherwise 1. */\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, in\n * screen space. Pure — no GL, no DOM. Walks the scene through `buildSceneTree`,\n * the same walk `<SceneCanvas>` uses, which is what keeps hidden layers\n * unpainted and container clips applied here.\n *\n * Each node's commands go through `wrapNodeOutput` — pose rotation, then the\n * `alphaFor` multiplier — so a `drawOne` that rotates its own output rotates\n * twice; emit unrotated geometry and let the pose drive it.\n *\n * Output is one group per **visible** layer, in scene-layer order (or\n * `layers.layerOrder`), each holding one group per node on that layer.\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  /** 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  const derivedOnly = withDerivedPaths(scene, drawOne);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const derivedPathOf = sceneDerivedPathOf(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 hierarchy = composesFrames(scene.composition)\n    ? { ...sceneAsHierarchy(scene, layers), composePose: scene.composition.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, { 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`. Where no WebGL2\n * context is available (jsdom) the call paints nothing. The canvas's renderer\n * 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":";;;;;;;;;;;;;AAsGA,SAASE,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;AAeA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GAEA,GAEA,GAGA,GACe;CACf,IAAMC,IAAcC,EAAiBT,GAAOU,CAAO,GAC7CC,IAAUC,IAAiBC,EAAmBD,GAAgBJ,CAAW,IAAIA,GAC7EM,IAAgBC,EAAmBf,CAAK,GACxCgB,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,GAEMK,IAAYC,EAAevB,EAAM,WAAW,IAC9C;EAAE,GAAGF,EAAiBE,GAAOC,CAAM;EAAG,aAAaD,EAAM,YAAY;CAAQ,IAC7EF,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,GACAd,GACAY,CACF,GACMK,IAAWP,IAAWQ,EAAiBH,GAAMjC,EAAWgC,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAII,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWtC,EAAWgC,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBO,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO7B,EACLP,GAAO4B,GAAMlB,GAASuB,GAAeZ,GAAU;EAAE;EAAiB;CAAW,GAAGT,GAChFa,IAAO;EAAE;EAAO;EAAQ,aAAaW,EAAK,eAAeC,EAAe3B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAOA,SAAgB4B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGR,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}

package/dist/canvas/slopsDebugLayer.js

@@ -38,13 +38,13 @@ function l(l) {
 						]),
 						fillRule: "nonzero"
 					},
-					fill: {
-						fill: "solid",
+					fill: { paint: {
+						kind: "solid",
 						color: s
-					},
+					} },
 					stroke: {
 						paint: {
-							fill: "solid",
+							kind: "solid",
 							color: c
 						},
 						width: 1

package/dist/canvas/slopsDebugLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"slopsDebugLayer.js","names":["SLOP_FILL","SLOP_STROKE","createSlopsDebugLayer","chrome","chromeStateFrom","data","isVisible","isVisibleFrom","toScreen","x","view","y","out","a","opts","region","q","pointRegionScreenQuad","transformOf","PATH_M","PATH_L","PATH_Z"],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const q = pointRegionScreenQuad(\n            region.shape, transformOf(chrome, region.targetId), view, toScreen,\n          );\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { fill: 'solid', color: SLOP_FILL },\n            stroke: { paint: { fill: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;AAwBA,IAAMA,IAAY,4BACZC,IAAc;AAEpB,SAAgBC,EACd,GACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GAGpB,IAAMC,IAASC,EAAgBC,CAAI;GACnC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAYC,EAAcF,CAAI,GAC9BG,KAAY,GAAW,MAC3B,EAAEC,IAAIC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAID,EAAK,KAAKA,EAAK,MAAM,CAAC,GACrDE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAKC,EAAK,eAAe,GAClC,IAAI,MAAcR,EAAUO,EAAE,EAAE,GAChC,KAAK,IAAME,KAAUF,EAAE,QAAQV,CAAM,GAAG;IACtC,IAAIY,EAAO,MAAM,SAAS,SAAS;IACnC,IAAMC,IAAIC,EACRF,EAAO,OAAOG,EAAYf,GAAQY,EAAO,QAAQ,GAAGL,GAAMF,CAC5D;IACA,EAAI,KAAK;KACP,MAAM;KACN,MAAM;MACJ,MAAM;MACN,UAAU,IAAI,WAAW;OAACW;OAAQC;OAAQA;OAAQA;OAAQC;MAAM,CAAC;MACjE,QAAQ,IAAI,aAAa;OAACL,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;MAAC,CAAC;MACzF,UAAU;KACZ;KACA,MAAM;MAAE,MAAM;MAAS,OAAOhB;KAAU;KACxC,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOC;MAAY;MAAG,OAAO;KAAE;IACnE,CAAC;GACH;GAEF,OAAOW;EACT;CACF;AACF"}
+{"version":3,"file":"slopsDebugLayer.js","names":["SLOP_FILL","SLOP_STROKE","createSlopsDebugLayer","chrome","chromeStateFrom","data","isVisible","isVisibleFrom","toScreen","x","view","y","out","a","opts","region","q","pointRegionScreenQuad","transformOf","PATH_M","PATH_L","PATH_Z"],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const q = pointRegionScreenQuad(\n            region.shape, transformOf(chrome, region.targetId), view, toScreen,\n          );\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { paint: { kind: 'solid', color: SLOP_FILL } },\n            stroke: { paint: { kind: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;AAwBA,IAAMA,IAAY,4BACZC,IAAc;AAEpB,SAAgBC,EACd,GACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GAGpB,IAAMC,IAASC,EAAgBC,CAAI;GACnC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAYC,EAAcF,CAAI,GAC9BG,KAAY,GAAW,MAC3B,EAAEC,IAAIC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAID,EAAK,KAAKA,EAAK,MAAM,CAAC,GACrDE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAKC,EAAK,eAAe,GAClC,IAAI,MAAcR,EAAUO,EAAE,EAAE,GAChC,KAAK,IAAME,KAAUF,EAAE,QAAQV,CAAM,GAAG;IACtC,IAAIY,EAAO,MAAM,SAAS,SAAS;IACnC,IAAMC,IAAIC,EACRF,EAAO,OAAOG,EAAYf,GAAQY,EAAO,QAAQ,GAAGL,GAAMF,CAC5D;IACA,EAAI,KAAK;KACP,MAAM;KACN,MAAM;MACJ,MAAM;MACN,UAAU,IAAI,WAAW;OAACW;OAAQC;OAAQA;OAAQA;OAAQC;MAAM,CAAC;MACjE,QAAQ,IAAI,aAAa;OAACL,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;MAAC,CAAC;MACzF,UAAU;KACZ;KACA,MAAM,EAAE,OAAO;MAAE,MAAM;MAAS,OAAOhB;KAAU,EAAE;KACnD,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOC;MAAY;MAAG,OAAO;KAAE;IACnE,CAAC;GACH;GAEF,OAAOW;EACT;CACF;AACF"}

package/dist/canvas/surface.module.js

@@ -0,0 +1,6 @@
+//#region src/canvas/surface.module.css
+var e = "_surface_c2e145", t = { surface: e };
+//#endregion
+export { t as default, e as surface };
+
+//# sourceMappingURL=surface.module.js.map

package/dist/canvas/surface.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.module.js","names":["surface","surface_module_default"],"sources":["../../src/canvas/surface.module.css"],"sourcesContent":["/* The CSS size of a canvas the kit renders: its `width` and `height` props.\n   Zero specificity, so a class the consumer passes resizes the element. */\n:where(.surface) {\n  width: var(--wzl-surface-width);\n  height: var(--wzl-surface-height);\n}\n"],"mappings":""}

package/dist/canvas/surfaceBox.js

@@ -0,0 +1,16 @@
+import e from "./surface.module.js";
+//#region src/canvas/surfaceBox.ts
+function t(t, n, r, i) {
+	return {
+		className: r ? `${e.surface} ${r}` : e.surface,
+		style: {
+			...i,
+			"--wzl-surface-width": `${t}px`,
+			"--wzl-surface-height": `${n}px`
+		}
+	};
+}
+//#endregion
+export { t as surfaceBox };
+
+//# sourceMappingURL=surfaceBox.js.map

package/dist/canvas/surfaceBox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceBox.js","names":["s","surface_module_default","surfaceBox","className","style","width","height"],"sources":["../../src/canvas/surfaceBox.ts"],"sourcesContent":["/// <reference path=\"../css-modules.d.ts\" />\nimport type { CSSProperties } from 'react';\nimport s from './surface.module.css';\n\n/** The class and style for a `<canvas>` the kit renders at `width` × `height`\n *  CSS pixels. The renderer sizes only the drawing buffer, so without these\n *  the element is as large as its buffer: `dpr` times too big. */\nexport function surfaceBox(\n  width: number,\n  height: number,\n  className?: string,\n  style?: CSSProperties,\n): { className: string; style: CSSProperties } {\n  return {\n    className: className ? `${s.surface} ${className}` : s.surface,\n    style: { ...style, '--wzl-surface-width': `${width}px`, '--wzl-surface-height': `${height}px` } as CSSProperties,\n  };\n}\n"],"mappings":";;AAOA,SAAgBE,EACd,GACA,GACA,GACA,GAC6C;CAC7C,OAAO;EACL,WAAWC,IAAY,GAAGH,EAAE,QAAQ,GAAGG,MAAcH,EAAE;EACvD,OAAO;GAAE,GAAGI;GAAO,uBAAuB,GAAGC,EAAM;GAAK,wBAAwB,GAAGC,EAAO;EAAI;CAChG;AACF"}

package/dist/canvas/useCanvasRenderer.js

@@ -1,11 +1,31 @@
-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, shaderKeyOf as n } from "./canvasRenderer.js";
+import { getProgramSource as r, programSourceRegistry as i } from "@weasel-js/renderer";
+import { useEffect as a, useState as o } from "react";
 //#region src/canvas/useCanvasRenderer.ts
-function r() {
-	let [r] = n(e);
-	return t(() => () => r.release(), [r]), r;
+function s() {
+	let [e] = o(t);
+	return a(() => () => e.release(), [e]), e;
+}
+function c(e, t) {
+	a(() => e.subscribeRestored(t), [e, t]);
+}
+function l(t, n) {
+	let r = n === void 0;
+	a(() => r ? e(() => t()) : void 0, [r, t]);
+}
+function u(e, t) {
+	let o = n(e);
+	a(() => {
+		if (!o) return;
+		let e = o.split("|"), n = e.map(r);
+		return i.subscribe(() => {
+			let i = e.map(r), a = i.some((e, t) => e !== n[t]);
+			n = i, a && t();
+		});
+	}, [o, t]);
 }
 //#endregion
-export { r as useCanvasRenderer };
+export { s as useCanvasRenderer, l as useRedrawOnDensityChange, c as useRedrawOnRestore, u as useRedrawOnShaderSource };
 
 //# 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","useRedrawOnShaderSource","key","shaderKeyOf","shaders","ids","seen","getProgramSource","programSourceRegistry","now","changed","src","i"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { getProgramSource, programSourceRegistry, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { leaseCanvasRenderer, shaderKeyOf, 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\n/**\n * Repaint a surface when one of its custom programs is re-registered with new\n * source. The renderer recompiles on the frame that draws it, and nothing else\n * asks for that frame.\n */\nexport function useRedrawOnShaderSource(\n  shaders: readonly ShaderProgramHandle[] | undefined,\n  requestRedraw: () => void,\n): void {\n  const key = shaderKeyOf(shaders);\n  useEffect(() => {\n    if (!key) return;\n    const ids = key.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [key, requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,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;AAOA,SAAgBK,EACd,GACA,GACM;CACN,IAAMC,IAAMC,EAAYC,CAAO;CAC/B,QAAgB;EACd,IAAI,CAACF,GAAK;EACV,IAAMG,IAAMH,EAAI,MAAM,GAAG,GACrBI,IAAOD,EAAI,IAAIE,CAAgB;EACnC,OAAOC,EAAsB,gBAAgB;GAC3C,IAAMC,IAAMJ,EAAI,IAAIE,CAAgB,GAC9BG,IAAUD,EAAI,MAAM,GAAK,MAAME,MAAQL,EAAKM,EAAE;GAEpD,AADA,IAAOH,GACHC,KAASd,EAAc;EAC7B,CAAC;CACH,GAAG,CAACM,GAAKN,CAAa,CAAC;AACzB"}

package/dist/canvas/useCanvasSurface.js

@@ -0,0 +1,31 @@
+import { useCanvasRenderer as e, useRedrawOnDensityChange as t, useRedrawOnRestore as n, useRedrawOnShaderSource as r } from "./useCanvasRenderer.js";
+import { useFrameLoop as i } from "./useFrameLoop.js";
+import { useLateContentRedraw as a } from "./useLateContentRedraw.js";
+import { useRedrawOn as o } from "./useRedrawOn.js";
+import { useEffect as s, useLayoutEffect as c, useRef as l } from "react";
+//#region src/canvas/useCanvasSurface.ts
+function u(s, c = {}) {
+	let l = e(), u = i(() => s(l), c), { requestRedraw: f } = u;
+	return n(l, f), t(f, c.dpr), a(f), r(c.shaders, f), o(c.redrawOn, f), d(c.paintOnCommit === !0, () => s(l), f), {
+		...u,
+		lease: l
+	};
+}
+function d(e, t, n) {
+	let r = l(!1);
+	c(() => {
+		if (e) {
+			if (r.current) {
+				n();
+				return;
+			}
+			r.current = t(), r.current || n();
+		}
+	}), s(() => () => {
+		r.current = !1;
+	}, []);
+}
+//#endregion
+export { u as useCanvasSurface };
+
+//# sourceMappingURL=useCanvasSurface.js.map

package/dist/canvas/useCanvasSurface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasSurface.js","names":["useCanvasSurface","lease","useCanvasRenderer","loop","useFrameLoop","paint","options","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","useLateContentRedraw","useRedrawOnShaderSource","useRedrawOn","usePaintOnCommit","paintedRef","useRef","useLayoutEffect","on","paintNow","useEffect"],"sources":["../../src/canvas/useCanvasSurface.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef } from 'react';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { RedrawSource } from '../core/layers/render';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport {\n  useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource,\n} from './useCanvasRenderer';\nimport { useFrameLoop, type FrameLoop, type FrameLoopOptions } from './useFrameLoop';\nimport { useLateContentRedraw } from './useLateContentRedraw';\nimport { useRedrawOn } from './useRedrawOn';\n\n/** What a surface tells {@link useCanvasSurface} about itself, beyond its paint. */\nexport interface CanvasSurfaceOptions extends FrameLoopOptions {\n  /** The surface's own density. Omit to follow `devicePixelRatio`. */\n  dpr?: number;\n  /** External state the paint reads; each source repaints when it notifies. */\n  redrawOn?: readonly RedrawSource[];\n  /** Custom programs the paint draws with; new source for one repaints. */\n  shaders?: readonly ShaderProgramHandle[];\n  /** Mark the surface dirty on every committed render, and paint the first\n   *  one in place, in the caller's stack, so the first frame shown is the\n   *  content and not a blank canvas. For a surface whose paint reads its\n   *  props. */\n  paintOnCommit?: boolean;\n}\n\n/** A surface's frame loop and the renderer lease its paint draws through. */\nexport interface CanvasSurface extends FrameLoop {\n  lease: CanvasRendererLease;\n}\n\n/**\n * Everything a canvas surface in core needs around its paint: the renderer\n * lease, the frame loop, and a repaint for each thing that changes pixels with\n * no React render behind it — a restored GL context, a density change, late\n * content, a re-registered shader, and the caller's own `redrawOn` sources.\n *\n * @param paint As `useFrameLoop`'s, handed the lease to draw through.\n */\nexport function useCanvasSurface(\n  paint: (lease: CanvasRendererLease) => boolean,\n  options: CanvasSurfaceOptions = {},\n): CanvasSurface {\n  const lease = useCanvasRenderer();\n  const loop = useFrameLoop(() => paint(lease), options);\n  const { requestRedraw } = loop;\n  useRedrawOnRestore(lease, requestRedraw);\n  useRedrawOnDensityChange(requestRedraw, options.dpr);\n  useLateContentRedraw(requestRedraw);\n  useRedrawOnShaderSource(options.shaders, requestRedraw);\n  useRedrawOn(options.redrawOn, requestRedraw);\n  usePaintOnCommit(options.paintOnCommit === true, () => paint(lease), requestRedraw);\n  return { ...loop, lease };\n}\n\nfunction usePaintOnCommit(on: boolean, paintNow: () => boolean, requestRedraw: () => void): void {\n  const paintedRef = useRef(false);\n  // No dependency array: the paint reads whatever the render did.\n  useLayoutEffect(() => {\n    if (!on) return;\n    if (paintedRef.current) { requestRedraw(); return; }\n    paintedRef.current = paintNow();\n    if (!paintedRef.current) requestRedraw();\n  });\n  // The renderer is freed on unmount; a remount (StrictMode) paints its first\n  // frame in place again.\n  useEffect(() => () => { paintedRef.current = false; }, []);\n}\n"],"mappings":";;;;;;AAuCA,SAAgBA,EACd,GACA,IAAgC,CAAC,GAClB;CACf,IAAMC,IAAQC,EAAkB,GAC1BC,IAAOC,QAAmBC,EAAMJ,CAAK,GAAGK,CAAO,GAC/C,EAAE,qBAAkBH;CAO1B,OANAI,EAAmBN,GAAOO,CAAa,GACvCC,EAAyBD,GAAeF,EAAQ,GAAG,GACnDI,EAAqBF,CAAa,GAClCG,EAAwBL,EAAQ,SAASE,CAAa,GACtDI,EAAYN,EAAQ,UAAUE,CAAa,GAC3CK,EAAiBP,EAAQ,kBAAkB,UAAYD,EAAMJ,CAAK,GAAGO,CAAa,GAC3E;EAAE,GAAGL;EAAM;CAAM;AAC1B;AAEA,SAASU,EAAiB,GAAa,GAAyB,GAAiC;CAC/F,IAAMC,IAAaC,EAAO,EAAK;CAU/B,AARAC,QAAsB;EACpB,IAAKC,GACL;OAAIH,EAAW,SAAS;IAAE,EAAc;IAAG;GAAQ;GAEnD,AADA,EAAW,UAAUI,EAAS,GACzBJ,EAAW,WAASN,EAAc;EAFY;CAGrD,CAAC,GAGDW,cAAsB;EAAE,EAAW,UAAU;CAAO,GAAG,CAAC,CAAC;AAC3D"}

package/dist/canvas/useCanvasView.js

@@ -0,0 +1,67 @@
+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
+var a = {
+	x: 0,
+	y: 0,
+	scale: {
+		x: 1,
+		y: 1
+	}
+};
+function o(o) {
+	let { view: s, defaultView: c, onViewChange: l, viewBounds: u, dims: d, requestRedraw: f } = o, p = typeof s == "function" ? s : void 0, m = s === void 0 || p ? void 0 : e(s), h = r(m ?? e(c ?? a)), g = r(/* @__PURE__ */ new Set()), _ = i({
+		controlled: s !== void 0,
+		derived: p,
+		onViewChange: l,
+		viewBounds: u,
+		dims: d,
+		requestRedraw: f
+	}), v = r(!1), y = n(() => {
+		let t = _.current.derived;
+		return t ? e(t()) : h.current;
+	}, [_]), b = n((n, r) => {
+		let { controlled: i, derived: a, onViewChange: o, viewBounds: s, dims: c, requestRedraw: l } = _.current, u = e(n), d = s ? t(u, s, c()) : u;
+		if (i) {
+			r && !v.current && (v.current = !0, console.warn(o ? "[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.")), o?.(d), a && l();
+			return;
+		}
+		h.current = d;
+		for (let e of g.current) e(d);
+		o?.(d), l();
+	}, [_]), x = n((e) => {
+		b(typeof e == "function" ? e(y()) : e, !0);
+	}, [b, y]), S = n((e) => {
+		b(e, !1);
+	}, [b]), C = n((e) => (g.current.add(e), () => {
+		g.current.delete(e);
+	}), []), w = r(!1);
+	return {
+		viewRef: h,
+		controlled: m,
+		setView: x,
+		setViewFromInput: S,
+		getView: y,
+		subscribeView: C,
+		adoptControlled: () => {
+			if (!m) return;
+			let e = h.current;
+			w.current ||= e.x !== m.x || e.y !== m.y || e.scale.x !== m.scale.x || e.scale.y !== m.scale.y, h.current = m;
+		},
+		announceControlled: n(() => {
+			if (w.current) {
+				w.current = !1;
+				for (let e of g.current) e(h.current);
+			}
+		}, []),
+		clearSubscribers: n(() => {
+			g.current.clear();
+		}, [])
+	};
+}
+//#endregion
+export { o as useCanvasView };
+
+//# sourceMappingURL=useCanvasView.js.map

package/dist/canvas/useCanvasView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasView.js","names":["IDENTITY","useCanvasView","viewProp","opts","derived","controlledView","normalizeView","viewRef","useRef","defaultView","viewSubsRef","live","useLatest","controlledWarnedRef","getView","useCallback","thunk","write","forward","bounds","size","redraw","valid","next","clamped","clampView","controlled","imperative","fn","setView","setViewFromInput","subscribeView","controlledMovedRef","was"],"sources":["../../src/canvas/useCanvasView.ts"],"sourcesContent":["/**\n * A camera: held in a ref when uncontrolled, taken from the `view` option when\n * controlled, with one write path and one subscriber list over both.\n * `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each\n * `<CanvasView>` makes its own.\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/** The view props a canvas takes for its camera. */\nexport interface CameraProps {\n  /** Controlled viewport. When supplied, the canvas does not own the value —\n   *  the consumer must supply `onViewChange` and re-render with the new\n   *  view. See `View` JSDoc for the camera-position convention. */\n  view?: View;\n  /** Initial viewport for the uncontrolled path. Default `{x:0, y:0}`. */\n  defaultView?: View;\n  /** Fires whenever the viewport changes — in both controlled and\n   *  uncontrolled modes. */\n  onViewChange?: (next: View) => void;\n  /**\n   * Optional world-space rect that constrains pan: every write to the view passes through\n   * `clampView` first, keeping the visible rect inside `viewBounds`. An axis where the\n   * visible rect is larger than the bounds is centered. Has no effect on `scale`.\n   */\n  viewBounds?: { x: number; y: number; width: number; height: number };\n}\n\n/** Inputs to {@link useCanvasView}: the camera's view props and what a write\n *  needs from whatever the camera looks through. */\nexport interface CanvasViewOptions {\n  /** Supplied, the camera is controlled. A thunk is a camera derived from\n   *  something else, read fresh at every {@link CanvasViewState.getView}. */\n  view: View | (() => View) | undefined;\n  defaultView: View | undefined;\n  onViewChange: ((next: View) => void) | undefined;\n  viewBounds: Bounds | undefined;\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  dims: () => Dims;\n  requestRedraw: () => void;\n}\n\n/** What `useCanvasView` hands back. The owner 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 a write when uncontrolled and by\n   *  `adoptControlled` when controlled. A camera derived by a thunk is not\n   *  kept here: read `getView`. */\n  viewRef: MutableRefObject<View>;\n  /** This render's controlled view, absent when the camera is uncontrolled or\n   *  derived. A new object every render, so compare its numbers. */\n  controlled: View | undefined;\n  /** The imperative write. Controlled, it is forwarded to `onViewChange`\n   *  instead of applied, and says so once per mount. */\n  setView: (next: View | ((current: View) => View)) => void;\n  /** The write input makes. Controlled, forwarding it to `onViewChange` is how\n   *  the owner hears of a pan at all, so nothing is warned. */\n  setViewFromInput: (next: 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 write, so this is where they\n   *  hear of it. Call from a layout effect. */\n  announceControlled: () => void;\n  /** Drop every subscriber, on unmount. */\n  clearSubscribers: () => void;\n}\n\nconst IDENTITY: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\nexport function useCanvasView(opts: CanvasViewOptions): CanvasViewState {\n  const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;\n  const derived = typeof viewProp === 'function' ? viewProp : undefined;\n  const controlledView = viewProp === undefined || derived ? undefined : normalizeView(viewProp as View);\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>(controlledView ?? normalizeView(defaultView ?? IDENTITY));\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const live = useLatest({\n    controlled: viewProp !== undefined, derived, onViewChange, viewBounds, dims, requestRedraw,\n  });\n  const controlledWarnedRef = useRef(false);\n\n  const getView = useCallback((): View => {\n    const thunk = live.current.derived;\n    return thunk ? normalizeView(thunk()) : viewRef.current;\n  }, [live]);\n\n  const write = useCallback((next: View, imperative: boolean): void => {\n    const {\n      controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw,\n    } = live.current;\n    const valid = normalizeView(next);\n    const clamped = bounds ? clampView(valid, bounds, size()) : valid;\n    if (controlled) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      if (imperative && !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      // A derived camera has no prop to change, so nothing else repaints it.\n      if (derived) redraw();\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    forward?.(clamped);\n    redraw();\n  }, [live]);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    write(typeof next === 'function' ? next(getView()) : next, true);\n  }, [write, getView]);\n  const setViewFromInput = useCallback((next: View) => { write(next, false); }, [write]);\n\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 owner 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, controlled: controlledView, setView, setViewFromInput, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  };\n}\n"],"mappings":";;;;;AA0EA,IAAMA,IAAiB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;AAE3D,SAAgBC,EAAc,GAA0C;CACtE,IAAM,EAAE,MAAMC,GAAU,gBAAa,iBAAc,eAAY,SAAM,qBAAkBC,GACjFC,IAAU,OAAOF,KAAa,aAAaA,IAAW,KAAA,GACtDG,IAAiBH,MAAa,KAAA,KAAaE,IAAU,KAAA,IAAYE,EAAcJ,CAAgB,GAG/FK,IAAUC,EAAaH,KAAkBC,EAAcG,KAAeT,CAAQ,CAAC,GAC/EU,IAAcF,kBAA+B,IAAI,IAAI,CAAC,GACtDG,IAAOC,EAAU;EACrB,YAAYV,MAAa,KAAA;EAAW;EAAS;EAAc;EAAY;EAAM;CAC/E,CAAC,GACKW,IAAsBL,EAAO,EAAK,GAElCM,IAAUC,QAAwB;EACtC,IAAMC,IAAQL,EAAK,QAAQ;EAC3B,OAAOK,IAAQV,EAAcU,EAAM,CAAC,IAAIT,EAAQ;CAClD,GAAG,CAACI,CAAI,CAAC,GAEHM,IAAQF,GAAa,GAAY,MAA8B;EACnE,IAAM,EACJ,eAAY,YAAS,cAAcG,GAAS,YAAYC,GAAQ,MAAMC,GAAM,eAAeC,MACzFV,EAAK,SACHW,IAAQhB,EAAciB,CAAI,GAC1BC,IAAUL,IAASM,EAAUH,GAAOH,GAAQC,EAAK,CAAC,IAAIE;EAC5D,IAAII,GAAY;GAWd,AARIC,KAAc,CAACd,EAAoB,YACrC,EAAoB,UAAU,IAC9B,QAAQ,KAAKK,IACT,wMACA,4LAA4L,IAElMA,IAAUM,CAAO,GAEbpB,KAASiB,EAAO;GACpB;EACF;EACA,EAAQ,UAAUG;EAClB,KAAK,IAAMI,KAAMlB,EAAY,SAAS,EAAGc,CAAO;EAEhD,AADAN,IAAUM,CAAO,GACjBH,EAAO;CACT,GAAG,CAACV,CAAI,CAAC,GAEHkB,IAAUd,GAAa,MAA2C;EACtE,EAAM,OAAOQ,KAAS,aAAaA,EAAKT,EAAQ,CAAC,IAAIS,GAAM,EAAI;CACjE,GAAG,CAACN,GAAOH,CAAO,CAAC,GACbgB,IAAmBf,GAAa,MAAe;EAAE,EAAMQ,GAAM,EAAK;CAAG,GAAG,CAACN,CAAK,CAAC,GAE/Ec,IAAgBhB,GAAa,OACjCL,EAAY,QAAQ,IAAIkB,CAAE,SACb;EAAE,EAAY,QAAQ,OAAOA,CAAE;CAAG,IAC9C,CAAC,CAAC,GAECI,IAAqBxB,EAAO,EAAK;CAiBvC,OAAO;EACL;EAAS,YAAYH;EAAgB;EAAS;EAAkB;EAAS;EACzE,uBAhBkC;GAClC,IAAI,CAACA,GAAgB;GACrB,IAAM4B,IAAM1B,EAAQ;GAGpB,AAFA,EAAmB,YAAY0B,EAAI,MAAM5B,EAAe,KAAK4B,EAAI,MAAM5B,EAAe,KACjF4B,EAAI,MAAM,MAAM5B,EAAe,MAAM,KAAK4B,EAAI,MAAM,MAAM5B,EAAe,MAAM,GACpF,EAAQ,UAAUA;EACpB;EAUmB,oBATQU,QAAkB;GAC3C,IAAKiB,EAAmB,SACxB;MAAmB,UAAU;IAC7B,KAAK,IAAMJ,KAAMlB,EAAY,SAAS,EAAGH,EAAQ,OAAO;GAD3B;EAE/B,GAAG,CAAC,CAKe;EAAoB,kBAJdQ,QAAkB;GAAE,EAAY,QAAQ,MAAM;EAAG,GAAG,CAAC,CAIvC;CACvC;AACF"}

package/dist/canvas/useFrameLoop.js

@@ -1,57 +1,65 @@
-import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
-import { useCallback as t, useInsertionEffect as n, useLayoutEffect as r, useRef as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
+import { useCallback as e, useInsertionEffect as t, useLayoutEffect as n, useRef as r } from "react";
+import { useLatest as i, useVisibleRaf 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 = r(!0), l = r(!0), u = r(!1), d = i(o), f = i(s.syncPaint ?? !1), p = r(/* @__PURE__ */ new Set()), m = r(/* @__PURE__ */ new Set()), h = r(/* @__PURE__ */ new Set()), g = r(-Infinity), _ = r(!1), v = r(null), y = e((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 });
-	n(() => {
-		g.current = () => {
-			v.request();
+	}, [d]), b = a(e((e) => {
+		l.current && c.current && y(e);
+	}, [y]), {
+		target: s.target,
+		onResume: e(() => {
+			for (let e of h.current) e();
+		}, [])
+	});
+	t(() => {
+		v.current = () => {
+			b.request();
 		};
 	});
-	let y = t(() => {
-		if (c.current = !0, f.current && l.current && !u.current && v.isVisible()) {
-			_(performance.now());
+	let x = e(() => {
+		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 = e((e) => (p.current.add(e), () => {
 		p.current.delete(e);
-	}), []), x = t((e) => (m.current.add(e), () => {
+	}), []), C = e((e) => (m.current.add(e), () => {
 		m.current.delete(e);
+	}), []), w = e((e) => (h.current.add(e), () => {
+		h.current.delete(e);
 	}), []);
-	return r(() => {
+	return n(() => {
 		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