@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/sceneLayerPaint.js

@@ -1,37 +1,66 @@
-import { paintedLayers as e } from "../core/layers/render.js";
+import { paintedLayers } from "../core/layers/render.js";
+
 //#region src/canvas/sceneLayerPaint.ts
-function t(e) {
-	return `scene:${e}`;
+/**
+* Which scene layers a view paints.
+*
+* A view's `layerVisibility` / `layerOrder` name render layers, and `<Canvas>`
+* paints a scene as one render layer per scene layer, keyed `scene:<layerId>`.
+* Picking, marquee and select-all ask about scene layers, so this is where one
+* namespace is read in terms of the other.
+*/
+/** The render-layer id a scene layer paints under. */
+function sceneLayerKey(layerId) {
+	return `scene:${layerId}`;
 }
-function n(t, n) {
-	let r = n.layers ? n.layers(t) : t;
-	return e(r, n.layerVisibility ?? {}, n.layerOrder);
+/** The layers a view draws, in the order it draws them: what `drawLayers`
+*  would paint of whatever `layers` narrowed to. */
+function viewPaintedLayers(surface, view) {
+	const narrowed = view.layers ? view.layers(surface) : surface;
+	return paintedLayers(narrowed, view.layerVisibility ?? {}, view.layerOrder);
 }
-function r() {
-	let e = null;
-	return (r, i) => {
-		let a = [
-			r,
-			i.layers,
-			i.layerVisibility,
-			i.layerOrder
+/**
+* A gate answering "does this scene layer reach the screen in this view",
+* rebuilt only when the surface's stack or the view's settings change — it is
+* asked once per pick candidate.
+*
+* A scene layer is painted when the render layer carrying it is: its own
+* `scene:<id>`, or the bundled `scene` layer an adapter without layers gets.
+* A surface carrying neither paints the scene some other way, which is not
+* this gate's to judge, so it passes.
+*/
+function createSceneLayerGate() {
+	let last = null;
+	return (surface, view) => {
+		const inputs = [
+			surface,
+			view.layers,
+			view.layerVisibility,
+			view.layerOrder
 		];
-		if (e && e.inputs.every((e, t) => e === a[t])) return e.gate;
-		let o = new Map(r.map((e) => [e.id, e])), s = new Set(n(r, i)), c = (e) => {
-			let n = o.get(t(e)) ?? o.get("scene");
-			return n === void 0 || s.has(n);
+		if (last && last.inputs.every((v, i) => v === inputs[i])) return last.gate;
+		const byId = new Map(surface.map((l) => [l.id, l]));
+		const drawn = new Set(viewPaintedLayers(surface, view));
+		const gate = (layerId) => {
+			const carrier = byId.get(sceneLayerKey(layerId)) ?? byId.get("scene");
+			return carrier === void 0 || drawn.has(carrier);
+		};
+		last = {
+			inputs,
+			gate
 		};
-		return e = {
-			inputs: a,
-			gate: c
-		}, c;
+		return gate;
 	};
 }
-function i(e, n) {
-	let { layerVisibility: r, layerOrder: i } = 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);
+/** Scene layers in the order a view paints them, for a view that walks the
+*  scene itself rather than a render-layer stack. Keyed as `<SceneCanvas>`
+*  keys them, so one map serves both. */
+function paintedSceneLayers(layers, view) {
+	const { layerVisibility, layerOrder } = view;
+	if (layerVisibility === void 0 && layerOrder === void 0) return layers;
+	return (layerOrder ? layerOrder.map((key) => layers.find((l) => sceneLayerKey(l.id) === key)).filter((l) => l !== void 0) : layers).filter((l) => layerVisibility?.[sceneLayerKey(l.id)] !== false);
 }
-//#endregion
-export { r as createSceneLayerGate, i as paintedSceneLayers, t as sceneLayerKey, n as viewPaintedLayers };
 
+//#endregion
+export { createSceneLayerGate, paintedSceneLayers, sceneLayerKey, viewPaintedLayers };
 //# sourceMappingURL=sceneLayerPaint.js.map

package/dist/canvas/sceneLayerPaint.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"sceneLayerPaint.js","names":[],"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,SAAgB,cAAc,SAAyB;CACrD,OAAO,SAAS;AAClB;;;AAYA,SAAgB,kBACd,SACA,MACiC;CACjC,MAAM,WAAW,KAAK,SAAS,KAAK,OAAO,OAAO,IAAI;CACtD,OAAO,cAAc,UAAU,KAAK,mBAAmB,CAAC,GAAG,KAAK,UAAU;AAC5E;;;;;;;;;;;AAYA,SAAgB,uBAGkB;CAChC,IAAI,OAAkF;CACtF,QAAQ,SAAS,SAAS;EACxB,MAAM,SAAS;GAAC;GAAS,KAAK;GAAQ,KAAK;GAAiB,KAAK;EAAU;EAC3E,IAAI,QAAQ,KAAK,OAAO,OAAO,GAAG,MAAM,MAAM,OAAO,EAAE,GAAG,OAAO,KAAK;EACtE,MAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;EAClD,MAAM,QAAQ,IAAI,IAAI,kBAAkB,SAAS,IAAI,CAAC;EACtD,MAAM,QAAQ,YAA6B;GACzC,MAAM,UAAU,KAAK,IAAI,cAAc,OAAO,CAAC,KAAK,KAAK,IAAI,OAAO;GACpE,OAAO,YAAY,UAAa,MAAM,IAAI,OAAO;EACnD;EACA,OAAO;GAAE;GAAQ;EAAK;EACtB,OAAO;CACT;AACF;;;;AAKA,SAAgB,mBACd,QACA,MACc;CACd,MAAM,EAAE,iBAAiB,eAAe;CACxC,IAAI,oBAAoB,UAAa,eAAe,QAAW,OAAO;CAMtE,QALiB,aACb,WACC,KAAK,QAAQ,OAAO,MAAM,MAAM,cAAc,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,CAC7D,QAAQ,MAAc,MAAM,MAAS,IACtC,OACG,CAAS,QAAQ,MAAM,kBAAkB,cAAc,EAAE,EAAE,OAAO,KAAK;AAChF"}

package/dist/canvas/sceneSlotWiring.js

@@ -1,21 +1,31 @@
-import { sceneDerivedPathOf as e, sceneShownToPose as t, withDerivedPaths as n } from "./derivedPath.js";
-import { withColorOverrides as r } from "./colorOverrides.js";
+import { sceneDerivedPathOf, sceneShownToPose, withDerivedPaths } from "./derivedPath.js";
+import { withColorOverrides } from "./colorOverrides.js";
+
 //#region src/canvas/sceneSlotWiring.ts
-function i(e, t) {
-	let n = (t) => e.overrides.read(t)?.alpha ?? 1;
-	return t ? (e) => t(e) * n(e) : n;
+/**
+* The alpha a view paints a node at: the view's own `alphaFor` times any
+* ephemeral override alpha.
+*
+* The hit path asks this too — a node painted at alpha 0 is not on screen and
+* must not claim clicks — so it is one function rather than the painter's and
+* picking's separate readings of the same two inputs.
+*/
+function composeAlphaFor(scene, alphaFor) {
+	const overrideAlphaFor = (id) => scene.overrides.read(id)?.alpha ?? 1;
+	return alphaFor ? (id) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;
 }
-function a(a, o, s, c) {
-	let l = n(o, a.drawOne, a.toPose), u = e(o, a.toPose);
+function wireSceneSlotToScene(slot, scene, alphaFor, colorOverrides) {
+	const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose);
+	const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose);
 	return {
-		...a,
-		...a.toPose ? { toPose: t(o, a.toPose) } : {},
-		drawOne: c ? r(c, l) : l,
-		derivedPathOf: u,
-		alphaFor: i(o, s)
+		...slot,
+		...slot.toPose ? { toPose: sceneShownToPose(scene, slot.toPose) } : {},
+		drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,
+		derivedPathOf,
+		alphaFor: composeAlphaFor(scene, alphaFor)
 	};
 }
-//#endregion
-export { i as composeAlphaFor, a as wireSceneSlotToScene };
 
+//#endregion
+export { composeAlphaFor, wireSceneSlotToScene };
 //# sourceMappingURL=sceneSlotWiring.js.map

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","sceneShownToPose","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, sceneShownToPose } 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    ...(slot.toPose ? { toPose: sceneShownToPose(scene, slot.toPose) } : {}),\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,GAAIA,EAAK,SAAS,EAAE,QAAQG,EAAiBT,GAAOM,EAAK,MAAM,EAAE,IAAI,CAAC;EACtE,SAASI,IAAiBC,EAAmBD,GAAgBN,CAAO,IAAIA;EACxE;EACA,UAAUN,EAAgBE,GAAOE,CAAQ;CAC3C;AACF"}
+{"version":3,"file":"sceneSlotWiring.js","names":[],"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, sceneShownToPose } 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    ...(slot.toPose ? { toPose: sceneShownToPose(scene, slot.toPose) } : {}),\n    drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,\n    derivedPathOf,\n    alphaFor: composeAlphaFor(scene, alphaFor),\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAuBA,SAAgB,gBACd,OACA,UACwB;CACxB,MAAM,oBAAoB,OAAe,MAAM,UAAU,KAAK,EAAY,CAAC,EAAE,SAAS;CACtF,OAAO,YAAY,OAAe,SAAS,EAAE,IAAI,iBAAiB,EAAE,IAAI;AAC1E;AAEA,SAAgB,qBACd,MACA,OACA,UACA,gBACoD;CACpD,MAAM,UAAU,iBAAiB,OAAO,KAAK,SAAS,KAAK,MAAM;CACjE,MAAM,gBAAgB,mBAAmB,OAAO,KAAK,MAAM;CAC3D,OAAO;EACL,GAAG;EACH,GAAI,KAAK,SAAS,EAAE,QAAQ,iBAAiB,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC;EACtE,SAAS,iBAAiB,mBAAmB,gBAAgB,OAAO,IAAI;EACxE;EACA,UAAU,gBAAgB,OAAO,QAAQ;CAC3C;AACF"}

package/dist/canvas/sceneViewRender.js

@@ -1,66 +1,102 @@
-import { paintedSceneLayers as e } from "./sceneLayerPaint.js";
-import { paintCanvas as t } from "./canvasRenderer.js";
-import { wrapNodeOutput as n } from "./wrapNodeOutput.js";
-import { sceneDerivedPathOf as r, withDerivedPaths as i } from "./derivedPath.js";
-import { buildSceneTree as a } from "./buildSceneTree.js";
-import { sceneToAdapter as o } from "./sceneAdapter.js";
-import { withColorOverrides as s } from "./colorOverrides.js";
-import { paintMissesView as c } from "./paintCull.js";
-import { paintBoundsFor as l } from "./defaultDrawOne.js";
-import { cullDrawCommands as u } from "@weasel-js/renderer";
-import { viewToMat3 as d } from "@weasel-js/geom";
+import { paintedSceneLayers } from "./sceneLayerPaint.js";
+import { paintCanvas } from "./canvasRenderer.js";
+import { wrapNodeOutput } from "./wrapNodeOutput.js";
+import { sceneDerivedPathOf, withDerivedPaths } from "./derivedPath.js";
+import { buildSceneTree } from "./buildSceneTree.js";
+import { sceneToAdapter } from "./sceneAdapter.js";
+import { withColorOverrides } from "./colorOverrides.js";
+import { paintMissesView } from "./paintCull.js";
+import { paintBoundsFor } from "./defaultDrawOne.js";
+import { cullDrawCommands } from "@weasel-js/renderer";
+import { viewToMat3 as viewToMat3$1 } from "@weasel-js/geom";
+
 //#region src/canvas/sceneViewRender.ts
-function f(t, n = {}) {
-	let { getNode: r, getChildren: i, getPose: a, composePose: s } = o(t);
+/**
+* Present a `Scene` as the reading surface `buildSceneTree` walks: the scene
+* adapter's own reads, under this view's layer list.
+*/
+function sceneAsHierarchy(scene, layers = {}) {
+	const { getNode, getChildren, getPose, composePose } = sceneToAdapter(scene);
 	return {
-		getLayers: () => e(t.layers, n).map((e) => ({
-			id: e.id,
-			visible: e.visible,
-			parallax: e.parallax
+		getLayers: () => paintedSceneLayers(scene.layers, layers).map((l) => ({
+			id: l.id,
+			visible: l.visible,
+			parallax: l.parallax
 		})),
-		getNode: r,
-		getChildren: i,
-		getPose: a,
-		...s ? { composePose: s } : {}
+		getNode,
+		getChildren,
+		getPose,
+		...composePose ? { composePose } : {}
 	};
 }
-function p(e, t, o, l, p, m, h, g) {
-	let _ = i(e, o), v = h ? s(h, _) : _, y = r(e), b = (t, r, i) => {
-		let a = e.overrides.read(t.id)?.alpha ?? 1;
-		return n(v(t, r, i), r, (p ? p(t.id) : 1) * a);
-	}, x = f(e, m), S = g ? {
+/**
+* Build the DrawCommand list that `renderSceneToCanvas` would dispatch, in
+* screen space. Pure — no GL, no DOM. Walks the scene through `buildSceneTree`,
+* the same walk `<SceneCanvas>` uses, which is what keeps hidden layers
+* unpainted and container clips applied here.
+*
+* Each node's commands go through `wrapNodeOutput` — pose rotation, then the
+* `alphaFor` multiplier — so a `drawOne` that rotates its own output rotates
+* twice; emit unrotated geometry and let the pose drive it.
+*
+* Output is one group per **visible** layer, in scene-layer order (or
+* `layers.layerOrder`), each holding one group per node on that layer.
+*/
+function buildSceneViewCommands(scene, view, drawOne, extraCommands, alphaFor, layers, colorOverrides, cull) {
+	const derivedOnly = withDerivedPaths(scene, drawOne);
+	const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;
+	const derivedPathOf = sceneDerivedPathOf(scene);
+	const wrappedDrawOne = (node, pose, v) => {
+		const overrideAlpha = scene.overrides.read(node.id)?.alpha ?? 1;
+		return wrapNodeOutput(derived(node, pose, v), pose, (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha);
+	};
+	const hierarchy = sceneAsHierarchy(scene, layers);
+	const cullRect = cull ? {
 		x: 0,
 		y: 0,
-		width: g.width,
-		height: g.height
-	} : void 0, C = S && g?.paintBounds ? c(g.paintBounds, t, S) : void 0, w = a(x, b, t, void 0, y, C), T = S ? u(w, d(t), S) : w;
-	if (l && l.length > 0) for (let e of l) T.push(e);
+		width: cull.width,
+		height: cull.height
+	} : void 0;
+	const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : void 0;
+	const tree = buildSceneTree(hierarchy, wrappedDrawOne, view, void 0, derivedPathOf, culled);
+	const children = cullRect ? cullDrawCommands(tree, viewToMat3$1(view), cullRect) : tree;
+	if (extraCommands && extraCommands.length > 0) for (const cmd of extraCommands) children.push(cmd);
 	return [{
 		kind: "group",
-		transform: d(t),
-		children: T
+		transform: viewToMat3$1(view),
+		children
 	}];
 }
-function m(e) {
-	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: o, alphaFor: s, layerVisibility: c, layerOrder: u, colorOverrides: d, cull: f } = e;
-	return p(t, n, a, o, s, {
-		layerVisibility: c,
-		layerOrder: u
-	}, d, f ? {
-		width: r,
-		height: i,
-		paintBounds: e.paintBounds ?? l(a)
+/**
+* The commands `renderSceneToCanvas` paints for one frame — everything in
+* `args` but the canvas. `<SceneViewCanvas>` paints these through its own
+* renderer lease.
+*/
+function sceneViewFrame(args) {
+	const { scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder, colorOverrides, cull } = args;
+	return buildSceneViewCommands(scene, view, drawOne, extraCommands, alphaFor, {
+		layerVisibility,
+		layerOrder
+	}, colorOverrides, cull ? {
+		width,
+		height,
+		paintBounds: args.paintBounds ?? paintBoundsFor(drawOne)
 	} : void 0);
 }
-function h(e) {
-	let { canvas: n, view: r, width: i, height: a, dpr: o } = e;
-	t(n, m(e), r, {
-		width: i,
-		height: a,
-		dpr: o
+/**
+* Render one frame of `scene` at `view` into `canvas`. Where no WebGL2
+* context is available (jsdom) the call paints nothing. The canvas's renderer
+* lives until `releaseCanvasRenderer(canvas)`.
+*/
+function renderSceneToCanvas(args) {
+	const { canvas, view, width, height, dpr } = args;
+	paintCanvas(canvas, sceneViewFrame(args), view, {
+		width,
+		height,
+		dpr
 	});
 }
-//#endregion
-export { p as buildSceneViewCommands, h as renderSceneToCanvas, m as sceneViewFrame };
 
+//#endregion
+export { buildSceneViewCommands, renderSceneToCanvas, sceneViewFrame };
 //# sourceMappingURL=sceneViewRender.js.map

package/dist/canvas/sceneViewRender.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneViewRender.js","names":["viewToMat3","viewToMat3$1","sceneAsHierarchy","sceneToAdapter","scene","paintedSceneLayers","layers","l","composePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","derived","colorOverrides","withColorOverrides","derivedPathOf","sceneDerivedPathOf","wrappedDrawOne","overrideAlpha","node","wrapNodeOutput","pose","v","alphaFor","hierarchy","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 { 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 { sceneToAdapter } from './sceneAdapter';\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: the scene\n * adapter's own reads, under this view's layer list.\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  const { getNode, getChildren, getPose, composePose } = sceneToAdapter(scene);\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode,\n    getChildren,\n    getPose,\n    ...(composePose ? { composePose } : {}),\n  };\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 = 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":";;;;;;;;;;;;AAoGA,SAASE,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,IAAM,EAAE,YAAS,gBAAa,YAAS,mBAAgBC,EAAeC,CAAK;CAC3E,OAAO;EACL,iBACEC,EAAmBD,EAAM,QAAQE,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE;EACA;EACA;EACA,GAAIC,IAAc,EAAE,eAAY,IAAI,CAAC;CACvC;AACF;AAeA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GAEA,GAEA,GAGA,GACe;CACf,IAAMC,IAAcC,EAAiBP,GAAOQ,CAAO,GAC7CC,IAAUC,IAAiBC,EAAmBD,GAAgBJ,CAAW,IAAIA,GAC7EM,IAAgBC,EAAmBb,CAAK,GACxCc,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBf,EAAM,UAAU,KAAKgB,EAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAOC,EACLR,EAAQO,GAAME,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAASJ,EAAK,EAAE,IAAI,KAAKD,CACvC;CACF,GAEMM,IAAYvB,EAAiBE,GAAOE,CAAM,GAE1CoB,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,GACAP,GACAY,GACA,KAAA,GACAd,GACAY,CACF,GACMK,IAAWP,IAAWQ,EAAiBH,GAAM/B,EAAW8B,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAII,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWpC,EAAW8B,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,EACLL,GAAO0B,GAAMlB,GAASuB,GAAeX,GAAU;EAAE;EAAiB;CAAW,GAAGV,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"}
+{"version":3,"file":"sceneViewRender.js","names":["viewToMat3"],"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 { 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 { sceneToAdapter } from './sceneAdapter';\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: the scene\n * adapter's own reads, under this view's layer list.\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  const { getNode, getChildren, getPose, composePose } = sceneToAdapter(scene);\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode,\n    getChildren,\n    getPose,\n    ...(composePose ? { composePose } : {}),\n  };\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 = 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":";;;;;;;;;;;;;;;;;AAoGA,SAAS,iBACP,OACA,SAA0B,CAAC,GAC6B;CACxD,MAAM,EAAE,SAAS,aAAa,SAAS,gBAAgB,eAAe,KAAK;CAC3E,OAAO;EACL,iBACE,mBAAmB,MAAM,QAAQ,MAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAI,EAAE;GAAI,SAAS,EAAE;GAAS,UAAU,EAAE;EAAS,EAAE;EACxE;EACA;EACA;EACA,GAAI,cAAc,EAAE,YAAY,IAAI,CAAC;CACvC;AACF;;;;;;;;;;;;;;AAeA,SAAgB,uBACd,OACA,MACA,SACA,eACA,UAEA,QAEA,gBAGA,MACe;CACf,MAAM,cAAc,iBAAiB,OAAO,OAAO;CACnD,MAAM,UAAU,iBAAiB,mBAAmB,gBAAgB,WAAW,IAAI;CACnF,MAAM,gBAAgB,mBAAmB,KAAK;CAC9C,MAAM,kBACJ,MACA,MACA,MACkB;EAClB,MAAM,gBAAgB,MAAM,UAAU,KAAK,KAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAO,eACL,QAAQ,MAAM,MAAM,CAAC,GACrB,OACC,WAAW,SAAS,KAAK,EAAE,IAAI,KAAK,aACvC;CACF;CAEA,MAAM,YAAY,iBAAiB,OAAO,MAAM;CAEhD,MAAM,WAAW,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAO,KAAK;EAAO,QAAQ,KAAK;CAAO,IAAI;CACjF,MAAM,SAAS,YAAY,MAAM,cAAc,gBAAgB,KAAK,aAAa,MAAM,QAAQ,IAAI;CACnG,MAAM,OAAsB,eAC1B,WACA,gBACA,MACA,QACA,eACA,MACF;CACA,MAAM,WAAW,WAAW,iBAAiB,MAAMA,aAAW,IAAI,GAAG,QAAQ,IAAI;CACjF,IAAI,iBAAiB,cAAc,SAAS,GAC1C,KAAK,MAAM,OAAO,eAAe,SAAS,KAAK,GAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWA,aAAW,IAAI;EAC1B;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,eACd,MACe;CACf,MAAM,EACJ,OAAO,MAAM,OAAO,QAAQ,SAAS,eAAe,UAAU,iBAAiB,YAC/E,gBAAgB,SACd;CACJ,OAAO,uBACL,OAAO,MAAM,SAAS,eAAe,UAAU;EAAE;EAAiB;CAAW,GAAG,gBAChF,OAAO;EAAE;EAAO;EAAQ,aAAa,KAAK,eAAe,eAAe,OAAO;CAAE,IAAI,MACvF;AACF;;;;;;AAOA,SAAgB,oBACd,MACM;CACN,MAAM,EAAE,QAAQ,MAAM,OAAO,QAAQ,QAAQ;CAC7C,YAAY,QAAQ,eAAe,IAAI,GAAG,MAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}

package/dist/canvas/slopsDebugLayer.js

@@ -1,61 +1,70 @@
-import { pointRegionScreenQuad as e, transformOf as t } from "../affordances/hitAffordanceRegions.js";
-import { chromeStateFrom as n, isVisibleFrom as r } from "./drawEnvelope.js";
-import { PATH_L as i, PATH_M as a, PATH_Z as o } from "@weasel-js/geom";
+import { pointRegionLive, pointRegionScreenQuad, transformOf } from "../affordances/hitAffordanceRegions.js";
+import { chromeStateFrom, isVisibleFrom } from "./drawEnvelope.js";
+import { PATH_L, PATH_M, PATH_Z } from "@weasel-js/geom";
+
 //#region src/canvas/slopsDebugLayer.ts
-var s = "rgba(255, 80, 140, 0.18)", c = "rgba(255, 80, 140, 0.55)";
-function l(l) {
+var SLOP_FILL = "rgba(255, 80, 140, 0.18)";
+var SLOP_STROKE = "rgba(255, 80, 140, 0.55)";
+function createSlopsDebugLayer(opts) {
 	return {
 		id: "slops-debug",
 		label: "Slops (debug)",
 		space: "screen",
-		draw: (u, d) => {
-			let f = n(u);
-			if (!f) return [];
-			let p = r(u), m = (e, t) => [(e - d.x) * d.scale.x, (t - d.y) * d.scale.y], h = [];
-			for (let n of l.getAffordances()) if (!p || p(n.id)) for (let r of n.regions(f)) {
-				if (r.shape.kind !== "point") continue;
-				let n = e(r.shape, t(f, r.targetId), d, m);
-				h.push({
-					kind: "path",
-					path: {
-						kind: "polygon",
-						commands: new Uint8Array([
-							a,
-							i,
-							i,
-							i,
-							o
-						]),
-						coords: new Float32Array([
-							n[0].x,
-							n[0].y,
-							n[1].x,
-							n[1].y,
-							n[2].x,
-							n[2].y,
-							n[3].x,
-							n[3].y
-						]),
-						fillRule: "nonzero"
-					},
-					fill: { paint: {
-						kind: "solid",
-						color: s
-					} },
-					stroke: {
-						paint: {
-							kind: "solid",
-							color: c
+		draw: (data, view) => {
+			const chrome = chromeStateFrom(data);
+			if (!chrome) return [];
+			const isVisible = isVisibleFrom(data);
+			const toScreen = (x, y) => [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];
+			const out = [];
+			for (const a of opts.getAffordances()) {
+				if (isVisible && !isVisible(a.id)) continue;
+				for (const region of a.regions(chrome)) {
+					if (region.shape.kind !== "point") continue;
+					const xf = transformOf(chrome, region.targetId);
+					if (!pointRegionLive(region.shape, xf, view)) continue;
+					const q = pointRegionScreenQuad(region.shape, xf, view, toScreen);
+					out.push({
+						kind: "path",
+						path: {
+							kind: "polygon",
+							commands: new Uint8Array([
+								PATH_M,
+								PATH_L,
+								PATH_L,
+								PATH_L,
+								PATH_Z
+							]),
+							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
+							]),
+							fillRule: "nonzero"
 						},
-						width: 1
-					}
-				});
+						fill: { paint: {
+							kind: "solid",
+							color: SLOP_FILL
+						} },
+						stroke: {
+							paint: {
+								kind: "solid",
+								color: SLOP_STROKE
+							},
+							width: 1
+						}
+					});
+				}
 			}
-			return h;
+			return out;
 		}
 	};
 }
-//#endregion
-export { l as createSlopsDebugLayer };
 
+//#endregion
+export { createSlopsDebugLayer };
 //# sourceMappingURL=slopsDebugLayer.js.map

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 '@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"}
+{"version":3,"file":"slopsDebugLayer.js","names":[],"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 { pointRegionLive, 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 xf = transformOf(chrome, region.targetId);\n          if (!pointRegionLive(region.shape, xf, view)) continue;\n          const q = pointRegionScreenQuad(region.shape, xf, view, toScreen);\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,IAAM,YAAY;AAClB,IAAM,cAAc;AAEpB,SAAgB,sBACd,MACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,MAAM,SAAS;GAGpB,MAAM,SAAS,gBAAgB,IAAI;GACnC,IAAI,CAAC,QAAQ,OAAO,CAAC;GACrB,MAAM,YAAY,cAAc,IAAI;GACpC,MAAM,YAAY,GAAW,MAC3B,EAAE,IAAI,KAAK,KAAK,KAAK,MAAM,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM,CAAC;GAC3D,MAAM,MAAqB,CAAC;GAC5B,KAAK,MAAM,KAAK,KAAK,eAAe,GAAG;IACrC,IAAI,aAAa,CAAC,UAAU,EAAE,EAAE,GAAG;IACnC,KAAK,MAAM,UAAU,EAAE,QAAQ,MAAM,GAAG;KACtC,IAAI,OAAO,MAAM,SAAS,SAAS;KACnC,MAAM,KAAK,YAAY,QAAQ,OAAO,QAAQ;KAC9C,IAAI,CAAC,gBAAgB,OAAO,OAAO,IAAI,IAAI,GAAG;KAC9C,MAAM,IAAI,sBAAsB,OAAO,OAAO,IAAI,MAAM,QAAQ;KAChE,IAAI,KAAK;MACP,MAAM;MACN,MAAM;OACJ,MAAM;OACN,UAAU,IAAI,WAAW;QAAC;QAAQ;QAAQ;QAAQ;QAAQ;OAAM,CAAC;OACjE,QAAQ,IAAI,aAAa;QAAC,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;OAAC,CAAC;OACzF,UAAU;MACZ;MACA,MAAM,EAAE,OAAO;OAAE,MAAM;OAAS,OAAO;MAAU,EAAE;MACnD,QAAQ;OAAE,OAAO;QAAE,MAAM;QAAS,OAAO;OAAY;OAAG,OAAO;MAAE;KACnE,CAAC;IACH;GACF;GACA,OAAO;EACT;CACF;AACF"}

package/dist/canvas/surfaceContribution.js

@@ -1,15 +1,27 @@
-import { mergeContributions as e } from "@weasel-js/routing";
+import { mergeContributions } from "@weasel-js/routing";
+
 //#region src/canvas/surfaceContribution.ts
-function t(...t) {
-	let n = e(...t), r = /* @__PURE__ */ new Map();
-	for (let e of n) for (let t of e.views ?? []) {
-		let n = r.get(t.id);
-		if (n !== void 0) throw Error(`mergeContributions: view "${t.id}" is added by both "${n}" and "${e.id}". View ids are unique per surface; rename one.`);
-		r.set(t.id, e.id);
+/**
+* The canvas's unit of extension: a routing `Contribution` plus the roles only
+* a surface can install — views on it, and whatever else needs the mounted
+* canvas.
+*/
+/**
+* Concatenate contribution bundles into one registry, preserving order. Throws
+* on a duplicate entry id, dep name or view id — two features answering for
+* the same name is a bug in whichever was added second.
+*/
+function mergeContributions$1(...bundles) {
+	const out = mergeContributions(...bundles);
+	const viewOwner = /* @__PURE__ */ new Map();
+	for (const entry of out) for (const view of entry.views ?? []) {
+		const owner = viewOwner.get(view.id);
+		if (owner !== void 0) throw new Error(`mergeContributions: view "${view.id}" is added by both "${owner}" and "${entry.id}". View ids are unique per surface; rename one.`);
+		viewOwner.set(view.id, entry.id);
 	}
-	return n;
+	return out;
 }
-//#endregion
-export { t as mergeContributions };
 
+//#endregion
+export { mergeContributions$1 as mergeContributions };
 //# sourceMappingURL=surfaceContribution.js.map

package/dist/canvas/surfaceContribution.js.map

@@ -1 +1 @@
-{"version":3,"file":"surfaceContribution.js","names":["mergeContributions","mergeRoutingContributions","mergeContributions$1","bundles","out","mergeContributions","viewOwner","entry","view","owner"],"sources":["../../src/canvas/surfaceContribution.ts"],"sourcesContent":["/**\n * The canvas's unit of extension: a routing `Contribution` plus the roles only\n * a surface can install — views on it, and whatever else needs the mounted\n * canvas.\n */\nimport { mergeContributions as mergeRoutingContributions } from '@weasel-js/routing';\nimport type { DepName, DepSchema } from 'interactions/actions/depSchema';\nimport type { Contribution } from '../tools/overlayBinding';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasViewProps } from './CanvasView';\nimport type { View } from '../core/viewport/view';\nimport type { KitRequirements } from './kitRequirements';\n\n/** Reads the surface's deps from inside `SurfaceContribution.attach`. */\nexport interface ContributionDepReader {\n  get<K extends DepName>(name: K): DepSchema[K] | undefined;\n}\n\n/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */\nexport interface ContributionFrameCtx {\n  /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one\n   *  frame see the same value. */\n  readonly time: number;\n  /** The surface camera this frame paints with. */\n  readonly view: View;\n  /** Ask for another frame. A hook animating something calls this every frame\n   *  it still has work for, and stops calling it to let the loop go idle. */\n  requestFrame(): void;\n  /** The surface's deps, as `attach` reads them. */\n  readonly deps: ContributionDepReader;\n}\n\n/**\n * A feature a surface installs in one step. Every role is optional: `bindings`,\n * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus\n * the ones below. Installing it installs every role it declares, and removing\n * it removes them.\n */\nexport interface SurfaceContribution extends Contribution {\n  /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */\n  views?: readonly CanvasViewProps[];\n  /**\n   * Runs once the surface mounts; returns its teardown. For what the roles\n   * above cannot say — a registered (hit-testable) layer, a subscription.\n   *\n   * Keyed by the function's identity, so a contribution built once (in a\n   * `useMemo`, or at module scope) attaches once however often the host\n   * re-renders.\n   */\n  attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;\n  /**\n   * Runs on every frame the surface paints, before the paint — for state the\n   * entry's layers read, advanced once per frame. Hooks run in the order the\n   * surface lists its entries (registered tools, then `ambient` in array\n   * order), and one that throws is reported and skipped without stopping the\n   * frame.\n   */\n  beforePaint?: (ctx: ContributionFrameCtx) => void;\n  /** Runs after a frame's pixels have landed, in the same order as\n   *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */\n  afterPaint?: (ctx: ContributionFrameCtx) => void;\n  /**\n   * The kit versions this entry was written against, as semver ranges:\n   * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the\n   * surface is set to `versionCheck=\"strict\"`.\n   */\n  requires?: KitRequirements;\n}\n\n/**\n * Concatenate contribution bundles into one registry, preserving order. Throws\n * on a duplicate entry id, dep name or view id — two features answering for\n * the same name is a bug in whichever was added second.\n */\nexport function mergeContributions<T extends SurfaceContribution>(\n  ...bundles: readonly (readonly T[])[]\n): T[] {\n  const out = mergeRoutingContributions<T>(...bundles);\n  const viewOwner = new Map<string, string>();\n  for (const entry of out) {\n    for (const view of entry.views ?? []) {\n      const owner = viewOwner.get(view.id);\n      if (owner !== undefined) {\n        throw new Error(\n          `mergeContributions: view \"${view.id}\" is added by both \"${owner}\" and \"${entry.id}\". `\n          + `View ids are unique per surface; rename one.`,\n        );\n      }\n      viewOwner.set(view.id, entry.id);\n    }\n  }\n  return out;\n}\n"],"mappings":";;AA0EA,SAAgBA,EACd,GAAGG,GACE;CACL,IAAMC,IAAMH,EAA6B,GAAGE,CAAO,GAC7CG,oBAAY,IAAI,IAAoB;CAC1C,KAAK,IAAMC,KAASH,GAClB,KAAK,IAAMI,KAAQD,EAAM,SAAS,CAAC,GAAG;EACpC,IAAME,IAAQH,EAAU,IAAIE,EAAK,EAAE;EACnC,IAAIC,MAAU,KAAA,GACZ,MAAU,MACR,6BAA6BD,EAAK,GAAG,sBAAsBC,EAAM,SAASF,EAAM,GAAG,gDAErF;EAEF,EAAU,IAAIC,EAAK,IAAID,EAAM,EAAE;CACjC;CAEF,OAAOH;AACT"}
+{"version":3,"file":"surfaceContribution.js","names":["mergeContributions","mergeRoutingContributions"],"sources":["../../src/canvas/surfaceContribution.ts"],"sourcesContent":["/**\n * The canvas's unit of extension: a routing `Contribution` plus the roles only\n * a surface can install — views on it, and whatever else needs the mounted\n * canvas.\n */\nimport { mergeContributions as mergeRoutingContributions } from '@weasel-js/routing';\nimport type { DepName, DepSchema } from 'interactions/actions/depSchema';\nimport type { Contribution } from '../tools/overlayBinding';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasViewProps } from './CanvasView';\nimport type { View } from '../core/viewport/view';\nimport type { KitRequirements } from './kitRequirements';\n\n/** Reads the surface's deps from inside `SurfaceContribution.attach`. */\nexport interface ContributionDepReader {\n  get<K extends DepName>(name: K): DepSchema[K] | undefined;\n}\n\n/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */\nexport interface ContributionFrameCtx {\n  /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one\n   *  frame see the same value. */\n  readonly time: number;\n  /** The surface camera this frame paints with. */\n  readonly view: View;\n  /** Ask for another frame. A hook animating something calls this every frame\n   *  it still has work for, and stops calling it to let the loop go idle. */\n  requestFrame(): void;\n  /** The surface's deps, as `attach` reads them. */\n  readonly deps: ContributionDepReader;\n}\n\n/**\n * A feature a surface installs in one step. Every role is optional: `bindings`,\n * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus\n * the ones below. Installing it installs every role it declares, and removing\n * it removes them.\n */\nexport interface SurfaceContribution extends Contribution {\n  /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */\n  views?: readonly CanvasViewProps[];\n  /**\n   * Runs once the surface mounts; returns its teardown. For what the roles\n   * above cannot say — a registered (hit-testable) layer, a subscription.\n   *\n   * Keyed by the function's identity, so a contribution built once (in a\n   * `useMemo`, or at module scope) attaches once however often the host\n   * re-renders.\n   */\n  attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;\n  /**\n   * Runs on every frame the surface paints, before the paint — for state the\n   * entry's layers read, advanced once per frame. Hooks run in the order the\n   * surface lists its entries (registered tools, then `ambient` in array\n   * order), and one that throws is reported and skipped without stopping the\n   * frame.\n   */\n  beforePaint?: (ctx: ContributionFrameCtx) => void;\n  /** Runs after a frame's pixels have landed, in the same order as\n   *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */\n  afterPaint?: (ctx: ContributionFrameCtx) => void;\n  /**\n   * The kit versions this entry was written against, as semver ranges:\n   * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the\n   * surface is set to `versionCheck=\"strict\"`.\n   */\n  requires?: KitRequirements;\n}\n\n/**\n * Concatenate contribution bundles into one registry, preserving order. Throws\n * on a duplicate entry id, dep name or view id — two features answering for\n * the same name is a bug in whichever was added second.\n */\nexport function mergeContributions<T extends SurfaceContribution>(\n  ...bundles: readonly (readonly T[])[]\n): T[] {\n  const out = mergeRoutingContributions<T>(...bundles);\n  const viewOwner = new Map<string, string>();\n  for (const entry of out) {\n    for (const view of entry.views ?? []) {\n      const owner = viewOwner.get(view.id);\n      if (owner !== undefined) {\n        throw new Error(\n          `mergeContributions: view \"${view.id}\" is added by both \"${owner}\" and \"${entry.id}\". `\n          + `View ids are unique per surface; rename one.`,\n        );\n      }\n      viewOwner.set(view.id, entry.id);\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;AA0EA,SAAgBA,qBACd,GAAG,SACE;CACL,MAAM,MAAMC,mBAA6B,GAAG,OAAO;CACnD,MAAM,4BAAY,IAAI,IAAoB;CAC1C,KAAK,MAAM,SAAS,KAClB,KAAK,MAAM,QAAQ,MAAM,SAAS,CAAC,GAAG;EACpC,MAAM,QAAQ,UAAU,IAAI,KAAK,EAAE;EACnC,IAAI,UAAU,QACZ,MAAM,IAAI,MACR,6BAA6B,KAAK,GAAG,sBAAsB,MAAM,SAAS,MAAM,GAAG,gDAErF;EAEF,UAAU,IAAI,KAAK,IAAI,MAAM,EAAE;CACjC;CAEF,OAAO;AACT"}