@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/buildSceneTree.js

@@ -1,84 +1,126 @@
-import { deriveParallaxView as e, planeMap as t } from "../core/viewport/parallax.js";
-import { definesFrame as n } from "../core/scene/effectivePose.js";
-import { clipCarrier as r, planeTransform as i } from "./planeClips.js";
-import { splitOverChildren as a } from "./overChildren.js";
-import { findShapeSilhouette as o } from "./NodeShape.js";
-import { scenePlaneOf as s } from "./pickWalk.js";
-import { mat3 as c } from "@weasel-js/geom";
+import { deriveParallaxView, planeMap } from "../core/viewport/parallax.js";
+import { definesFrame } from "../core/scene/effectivePose.js";
+import { findShapeSilhouette } from "./NodeShape.js";
+import { clipCarrier, planeTransform } from "./planeClips.js";
+import { splitOverChildren } from "./overChildren.js";
+import { hidesSubtree } from "../core/scene/nodeGates.js";
+import { scenePlaneOf } from "./pickWalk.js";
+import { mat3 } from "@weasel-js/geom";
+
 //#region src/canvas/buildSceneTree.ts
-function l(e, t, n, r) {
-	let i = {
+/** Wrap `cmds` in one nested group per chain entry, so the renderer intersects
+*  the clips and applies each copy's transform to everything inside it.
+*  Outermost group carries the ancestor-most entry; innermost holds `cmds`. */
+function wrapInChain(cmds, chain, toLayer, carry) {
+	let node = {
 		kind: "group",
-		children: e
+		children: cmds
 	};
-	for (let e = t.length - 1; e >= 0; e--) {
-		let a = t[e];
-		i = "copy" in a ? {
+	for (let i = chain.length - 1; i >= 0; i--) {
+		const e = chain[i];
+		node = "copy" in e ? {
 			kind: "group",
-			children: [i],
-			transform: c.fromAffine(a.copy)
+			children: [node],
+			transform: mat3.fromAffine(e.copy)
 		} : {
 			kind: "group",
-			children: [i],
-			clip: r(a.path, a.layer, n)
+			children: [node],
+			clip: carry(e.path, e.layer, toLayer)
 		};
 	}
-	return i;
+	return node;
 }
-function u(c, u, d, f, p, m) {
-	let h = c.getLayers(), g = /* @__PURE__ */ new Map();
-	for (let e of h) e.visible && g.set(e.id, []);
-	let _ = null;
-	for (let t of h) t.parallax && (_ ??= /* @__PURE__ */ new Map()).set(t.id, e(d, t.parallax));
-	let v = c.composePose?.bind(c), y = r(_ ? s(h, d) : null);
-	function b(e, t, r, i) {
-		let s = c.getNode(e);
-		if (!s) return;
-		let h = c.getPose(e), x = v && r !== null ? v(r, h) : h, S = f === void 0 || s.layer === f ? g.get(s.layer) : void 0, C = _?.get(s.layer) ?? d, { under: w, over: T } = a(S && (i || !m?.(s, x, C)) ? u(s, x, C) : []), E = t, D = null, O = s;
-		if (O.kind === "container") {
-			let e;
-			e = typeof O.clipFromPose == "function" ? O.clipFromPose(x) : o(s, x, { derivedPath: p?.(s, x) }), e && (D = {
-				path: e,
-				layer: s.layer
-			}, E = [...t, D]);
+/**
+* Walk the adapter's scene tree once and emit each node's own paint into the bucket for
+* **that node's own `layer`** — not its parent's. A node carrying `hidden` is skipped with
+* its whole subtree; see `nodeGates`. So a child whose `layer` differs from its
+* parent draws in its own layer's pass while staying a tree child for hit-testing / move /
+* reparent. Output is one group per visible layer, in adapter (`getLayers`) order.
+*
+* A node paints before its children. What its `drawOne` wraps in `overChildren` paints after
+* them instead, in the node's own layer.
+*
+* `drawOne` returns world-coord commands. Because a node may be drawn outside its parent's
+* group, the tree nesting cannot carry geometry as renderer state; the walk folds each node's
+* pose into its parent's frame on the way down and hands the painter a **world** pose. Clips
+* are accumulated the same way — each in its container's plane, carried into the plane of the
+* node it clips. With no `composePose` on the adapter the fold is the identity.
+*
+* A layer carrying `parallax` is a plane: its painters and its cull see the view derived for
+* it, and its group carries the transform from its world to the camera's, so the caller's
+* single camera wrap still lands it right.
+*/
+function buildSceneTree(adapter, drawOne, view, forLayer, derivedPathOf, culled) {
+	const layers = adapter.getLayers();
+	const buckets = /* @__PURE__ */ new Map();
+	for (const l of layers) if (l.visible) buckets.set(l.id, []);
+	let planeViews = null;
+	for (const l of layers) if (l.parallax) (planeViews ??= /* @__PURE__ */ new Map()).set(l.id, deriveParallaxView(view, l.parallax));
+	const compose = adapter.composePose?.bind(adapter);
+	const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);
+	function visit(id, ancestorClips, parentFrame, copied) {
+		const node = adapter.getNode(id);
+		if (!node || hidesSubtree(node)) return;
+		const local = adapter.getPose(id);
+		const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;
+		const bucket = forLayer === void 0 || node.layer === forLayer ? buckets.get(node.layer) : void 0;
+		const v = planeViews?.get(node.layer) ?? view;
+		const { under: self, over } = splitOverChildren(bucket && (copied || !culled?.(node, pose, v)) ? drawOne(node, pose, v) : []);
+		let ownClips = ancestorClips;
+		let ownClip = null;
+		const maybeContainer = node;
+		if (maybeContainer.kind === "container") {
+			let clip;
+			if (typeof maybeContainer.clipFromPose === "function") clip = maybeContainer.clipFromPose(pose);
+			else clip = findShapeSilhouette(node, pose, { derivedPath: derivedPathOf?.(node, pose) });
+			if (clip) {
+				ownClip = {
+					path: clip,
+					layer: node.layer
+				};
+				ownClips = [...ancestorClips, ownClip];
+			}
 		}
-		S && S.push(E.length > 0 ? l(w, E, s.layer, y) : {
+		if (bucket) bucket.push(ownClips.length > 0 ? wrapInChain(self, ownClips, node.layer, carry) : {
 			kind: "group",
-			children: w
+			children: self
 		});
-		let k = n(s) ? x : r, A = c.getChildren(e);
-		for (let e of A) b(e, E, k, i);
-		let j = typeof O.copiesFromPose == "function" ? O.copiesFromPose(x, s) : null;
-		for (let e of j ?? []) {
-			let n = [
-				...t,
-				{ copy: e },
-				...D ? [D] : []
+		const childFrame = definesFrame(node) ? pose : parentFrame;
+		const children = adapter.getChildren(id);
+		for (const cid of children) visit(cid, ownClips, childFrame, copied);
+		const copies = typeof maybeContainer.copiesFromPose === "function" ? maybeContainer.copiesFromPose(pose, node) : null;
+		for (const copy of copies ?? []) {
+			const chain = [
+				...ancestorClips,
+				{ copy },
+				...ownClip ? [ownClip] : []
 			];
-			for (let e of A) b(e, n, k, !0);
+			for (const cid of children) visit(cid, chain, childFrame, true);
 		}
-		S && T.length > 0 && S.push(E.length > 0 ? l(T, E, s.layer, y) : {
+		if (bucket && over.length > 0) bucket.push(ownClips.length > 0 ? wrapInChain(over, ownClips, node.layer, carry) : {
 			kind: "group",
-			children: T
+			children: over
 		});
 	}
-	for (let e of c.getChildren(null)) b(e, [], null, !1);
-	let x = [];
-	for (let e of h) {
-		if (!e.visible || f !== void 0 && e.id !== f) continue;
-		let n = g.get(e.id) ?? [], r = e.parallax ? i(t(d, e.parallax), null) : void 0;
-		x.push(r ? {
+	for (const rootId of adapter.getChildren(null)) visit(rootId, [], null, false);
+	const out = [];
+	for (const layer of layers) {
+		if (!layer.visible) continue;
+		if (forLayer !== void 0 && layer.id !== forLayer) continue;
+		const children = buckets.get(layer.id) ?? [];
+		const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : void 0;
+		out.push(transform ? {
 			kind: "group",
-			transform: r,
-			children: n
+			transform,
+			children
 		} : {
 			kind: "group",
-			children: n
+			children
 		});
 	}
-	return x;
+	return out;
 }
-//#endregion
-export { u as buildSceneTree };
 
+//#endregion
+export { buildSceneTree };
 //# sourceMappingURL=buildSceneTree.js.map

package/dist/canvas/buildSceneTree.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildSceneTree.js","names":["wrapInChain","node","cmds","i","chain","e","mat3","carry","toLayer","buildSceneTree","layers","adapter","buckets","l","planeViews","deriveParallaxView","view","compose","clipCarrier","scenePlaneOf","visit","id","local","pose","parentFrame","bucket","forLayer","v","self","splitOverChildren","copied","culled","drawOne","ownClips","ancestorClips","ownClip","maybeContainer","clip","findShapeSilhouette","derivedPathOf","childFrame","definesFrame","children","cid","copies","copy","over","rootId","out","layer","transform","planeTransform","planeMap"],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport { mat3, type Affine, type Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\nimport { splitOverChildren } from './overChildren';\n\n/** The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter` is one. */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in, or the\n *  transform of a copy a container draws — see `ContainerNode.copiesFromPose`. */\ntype ChainEntry = { path: Path; layer: string } | { copy: Affine };\n\n/** Wrap `cmds` in one nested group per chain entry, so the renderer intersects\n *  the clips and applies each copy's transform to everything inside it.\n *  Outermost group carries the ancestor-most entry; innermost holds `cmds`. */\nfunction wrapInChain(\n  cmds: DrawCommand[],\n  chain: readonly ChainEntry[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = chain.length - 1; i >= 0; i--) {\n    const e = chain[i];\n    node = 'copy' in e\n      ? { kind: 'group', children: [node], transform: mat3.fromAffine(e.copy) }\n      : { kind: 'group', children: [node], clip: carry(e.path, e.layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the bucket for\n * **that node's own `layer`** — not its parent's. So a child whose `layer` differs from its\n * parent draws in its own layer's pass while staying a tree child for hit-testing / move /\n * reparent. Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * A node paints before its children. What its `drawOne` wraps in `overChildren` paints after\n * them instead, in the node's own layer.\n *\n * `drawOne` returns world-coord commands. Because a node may be drawn outside its parent's\n * group, the tree nesting cannot carry geometry as renderer state; the walk folds each node's\n * pose into its parent's frame on the way down and hands the painter a **world** pose. Clips\n * are accumulated the same way — each in its container's plane, carried into the plane of the\n * node it clips. With no `composePose` on the adapter the fold is the identity.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the view derived for\n * it, and its group carries the transform from its world to the camera's, so the caller's\n * single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses: the scene's\n   *  lookup, or `adapterDerivedPathOf` for an adapter with no scene. Left out,\n   *  a derived container contributes no clip. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  // A hidden layer gets no bucket, and a node with no bucket is not painted.\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) if (l.visible) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainEntry[],\n    parentFrame: TPose | null,\n    /** Under a copy: the pose is not where it paints, so the cull cannot judge it. */\n    copied: boolean,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const bucket = forLayer === undefined || node.layer === forLayer\n      ? buckets.get(node.layer) : undefined;\n    const v = planeViews?.get(node.layer) ?? view;\n    const { under: self, over } = splitOverChildren(\n      bucket && (copied || !culled?.(node, pose, v)) ? drawOne(node, pose, v) : [],\n    );\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    let ownClip: ChainEntry | null = null;\n    const maybeContainer = node as {\n      kind?: string;\n      clipFromPose?: (pose: TPose) => unknown;\n      copiesFromPose?: (pose: TPose, node: unknown) => readonly Affine[] | null;\n    };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → the painter silhouette for the container's shape kind.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) {\n        ownClip = { path: clip as Path, layer: node.layer };\n        ownClips = [...ancestorClips, ownClip];\n      }\n    }\n\n    // Every node emits a wrapper group even with empty paint, keeping the per-node tree\n    // shape stable.\n    if (bucket) {\n      bucket.push(ownClips.length > 0 ? wrapInChain(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    const children = adapter.getChildren(id);\n    for (const cid of children) visit(cid, ownClips, childFrame, copied);\n\n    // A copy is a copy of the clipped content, so its transform encloses the\n    // container's own clip and sits inside every clip above it.\n    const copies = typeof maybeContainer.copiesFromPose === 'function'\n      ? maybeContainer.copiesFromPose(pose, node) : null;\n    for (const copy of copies ?? []) {\n      const chain: ChainEntry[] = [...ancestorClips, { copy }, ...(ownClip ? [ownClip] : [])];\n      for (const cid of children) visit(cid, chain, childFrame, true);\n    }\n\n    if (bucket && over.length > 0) {\n      bucket.push(ownClips.length > 0 ? wrapInChain(over, ownClips, node.layer, carry) : { kind: 'group', children: over });\n    }\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null, false);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;AA8BA,SAASA,EACP,GACA,GACA,GACA,GACa;CACb,IAAIC,IAAyB;EAAE,MAAM;EAAS,UAAUC;CAAK;CAC7D,KAAK,IAAIC,IAAIC,EAAM,SAAS,GAAGD,KAAK,GAAG,KAAK;EAC1C,IAAME,IAAID,EAAMD;EAChB,IAAO,UAAUE,IACb;GAAE,MAAM;GAAS,UAAU,CAACJ,CAAI;GAAG,WAAWK,EAAK,WAAWD,EAAE,IAAI;EAAE,IACtE;GAAE,MAAM;GAAS,UAAU,CAACJ,CAAI;GAAG,MAAMM,EAAMF,EAAE,MAAMA,EAAE,OAAOG,CAAO;EAAE;CAC/E;CACA,OAAOP;AACT;AAqBA,SAAgBQ,EAId,GACA,GACA,GAGA,GAIA,GAGA,GACe;CACf,IAAMC,IAASC,EAAQ,UAAU,GAE3BC,oBAAU,IAAI,IAA2B;CAC/C,KAAK,IAAMC,KAAKH,GAAQ,AAAIG,EAAE,WAASD,EAAQ,IAAIC,EAAE,IAAI,CAAC,CAAC;CAC3D,IAAIC,IAAuC;CAC3C,KAAK,IAAMD,KAAKH,GACd,AAAIG,EAAE,aAAW,sBAAe,IAAI,IAAI,EAAA,CAAG,IAAIA,EAAE,IAAIE,EAAmBC,GAAMH,EAAE,QAAQ,CAAC;CAG3F,IAAMI,IAAUN,EAAQ,aAAa,KAAKA,CAAO,GAC3CJ,IAAQW,EAAYJ,IAAaK,EAAaT,GAAQM,CAAI,IAAI,IAAI;CAExE,SAASI,EACP,GACA,GACA,GAEA,GACM;EACN,IAAMnB,IAAOU,EAAQ,QAAQU,CAAE;EAC/B,IAAI,CAACpB,GAAM;EACX,IAAMqB,IAAQX,EAAQ,QAAQU,CAAE,GAG1BE,IAAON,KAAWO,MAAgB,OAAOP,EAAQO,GAAaF,CAAK,IAAIA,GAGvEG,IAASC,MAAa,KAAA,KAAazB,EAAK,UAAUyB,IACpDd,EAAQ,IAAIX,EAAK,KAAK,IAAI,KAAA,GACxB0B,IAAIb,GAAY,IAAIb,EAAK,KAAK,KAAKe,GACnC,EAAE,OAAOY,GAAM,YAASC,EAC5BJ,MAAWK,KAAU,CAACC,IAAS9B,GAAMsB,GAAMI,CAAC,KAAKK,EAAQ/B,GAAMsB,GAAMI,CAAC,IAAI,CAAC,CAC7E,GAGIM,IAAWC,GACXC,IAA6B,MAC3BC,IAAiBnC;EAKvB,IAAImC,EAAe,SAAS,aAAa;GACvC,IAAIC;GAYJ,AAXA,AAKEA,IALE,OAAOD,EAAe,gBAAiB,aAElCA,EAAe,aAAab,CAAI,IAGhCe,EACLrC,GACAsB,GACA,EAAE,aAAagB,IAAgBtC,GAAMsB,CAAI,EAAE,CAC7C,GAEEc,MACF,IAAU;IAAE,MAAMA;IAAc,OAAOpC,EAAK;GAAM,GAClD,IAAW,CAAC,GAAGiC,GAAeC,CAAO;EAEzC;EAIA,AAAIV,KACFA,EAAO,KAAKQ,EAAS,SAAS,IAAIjC,EAAY4B,GAAMK,GAAUhC,EAAK,OAAOM,CAAK,IAAI;GAAE,MAAM;GAAS,UAAUqB;EAAK,CAAC;EAItH,IAAMY,IAAaC,EAAaxC,CAAa,IAAIsB,IAAOC,GAClDkB,IAAW/B,EAAQ,YAAYU,CAAE;EACvC,KAAK,IAAMsB,KAAOD,GAAU,EAAMC,GAAKV,GAAUO,GAAYV,CAAM;EAInE,IAAMc,IAAS,OAAOR,EAAe,kBAAmB,aACpDA,EAAe,eAAeb,GAAMtB,CAAI,IAAI;EAChD,KAAK,IAAM4C,KAAQD,KAAU,CAAC,GAAG;GAC/B,IAAMxC,IAAsB;IAAC,GAAG8B;IAAe,EAAE,QAAK;IAAG,GAAIC,IAAU,CAACA,CAAO,IAAI,CAAC;GAAE;GACtF,KAAK,IAAMQ,KAAOD,GAAU,EAAMC,GAAKvC,GAAOoC,GAAY,EAAI;EAChE;EAEA,AAAIf,KAAUqB,EAAK,SAAS,KAC1BrB,EAAO,KAAKQ,EAAS,SAAS,IAAIjC,EAAY8C,GAAMb,GAAUhC,EAAK,OAAOM,CAAK,IAAI;GAAE,MAAM;GAAS,UAAUuC;EAAK,CAAC;CAExH;CAEA,KAAK,IAAMC,KAAUpC,EAAQ,YAAY,IAAI,GAAG,EAAMoC,GAAQ,CAAC,GAAG,MAAM,EAAK;CAE7E,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAASvC,GAAQ;EAE1B,IADI,CAACuC,EAAM,WACPvB,MAAa,KAAA,KAAauB,EAAM,OAAOvB,GAAU;EACrD,IAAMgB,IAAW9B,EAAQ,IAAIqC,EAAM,EAAE,KAAK,CAAC,GACrCC,IAAYD,EAAM,WAAWE,EAAeC,EAASpC,GAAMiC,EAAM,QAAQ,GAAG,IAAI,IAAI,KAAA;EAC1F,EAAI,KAAKC,IAAY;GAAE,MAAM;GAAS;GAAW;EAAS,IAAI;GAAE,MAAM;GAAS;EAAS,CAAC;CAC3F;CACA,OAAOF;AACT"}
+{"version":3,"file":"buildSceneTree.js","names":[],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport { mat3, type Affine, type Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\nimport { splitOverChildren } from './overChildren';\nimport { hidesSubtree } from 'core/scene/nodeGates';\n\n/** The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter` is one. */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in, or the\n *  transform of a copy a container draws — see `ContainerNode.copiesFromPose`. */\ntype ChainEntry = { path: Path; layer: string } | { copy: Affine };\n\n/** Wrap `cmds` in one nested group per chain entry, so the renderer intersects\n *  the clips and applies each copy's transform to everything inside it.\n *  Outermost group carries the ancestor-most entry; innermost holds `cmds`. */\nfunction wrapInChain(\n  cmds: DrawCommand[],\n  chain: readonly ChainEntry[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = chain.length - 1; i >= 0; i--) {\n    const e = chain[i];\n    node = 'copy' in e\n      ? { kind: 'group', children: [node], transform: mat3.fromAffine(e.copy) }\n      : { kind: 'group', children: [node], clip: carry(e.path, e.layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the bucket for\n * **that node's own `layer`** — not its parent's. A node carrying `hidden` is skipped with\n * its whole subtree; see `nodeGates`. So a child whose `layer` differs from its\n * parent draws in its own layer's pass while staying a tree child for hit-testing / move /\n * reparent. Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * A node paints before its children. What its `drawOne` wraps in `overChildren` paints after\n * them instead, in the node's own layer.\n *\n * `drawOne` returns world-coord commands. Because a node may be drawn outside its parent's\n * group, the tree nesting cannot carry geometry as renderer state; the walk folds each node's\n * pose into its parent's frame on the way down and hands the painter a **world** pose. Clips\n * are accumulated the same way — each in its container's plane, carried into the plane of the\n * node it clips. With no `composePose` on the adapter the fold is the identity.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the view derived for\n * it, and its group carries the transform from its world to the camera's, so the caller's\n * single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string; hidden?: boolean },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses: the scene's\n   *  lookup, or `adapterDerivedPathOf` for an adapter with no scene. Left out,\n   *  a derived container contributes no clip. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  // A hidden layer gets no bucket, and a node with no bucket is not painted.\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) if (l.visible) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainEntry[],\n    parentFrame: TPose | null,\n    /** Under a copy: the pose is not where it paints, so the cull cannot judge it. */\n    copied: boolean,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node || hidesSubtree(node)) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const bucket = forLayer === undefined || node.layer === forLayer\n      ? buckets.get(node.layer) : undefined;\n    const v = planeViews?.get(node.layer) ?? view;\n    const { under: self, over } = splitOverChildren(\n      bucket && (copied || !culled?.(node, pose, v)) ? drawOne(node, pose, v) : [],\n    );\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    let ownClip: ChainEntry | null = null;\n    const maybeContainer = node as {\n      kind?: string;\n      clipFromPose?: (pose: TPose) => unknown;\n      copiesFromPose?: (pose: TPose, node: unknown) => readonly Affine[] | null;\n    };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → the painter silhouette for the container's shape kind.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) {\n        ownClip = { path: clip as Path, layer: node.layer };\n        ownClips = [...ancestorClips, ownClip];\n      }\n    }\n\n    // Every node emits a wrapper group even with empty paint, keeping the per-node tree\n    // shape stable.\n    if (bucket) {\n      bucket.push(ownClips.length > 0 ? wrapInChain(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    const children = adapter.getChildren(id);\n    for (const cid of children) visit(cid, ownClips, childFrame, copied);\n\n    // A copy is a copy of the clipped content, so its transform encloses the\n    // container's own clip and sits inside every clip above it.\n    const copies = typeof maybeContainer.copiesFromPose === 'function'\n      ? maybeContainer.copiesFromPose(pose, node) : null;\n    for (const copy of copies ?? []) {\n      const chain: ChainEntry[] = [...ancestorClips, { copy }, ...(ownClip ? [ownClip] : [])];\n      for (const cid of children) visit(cid, chain, childFrame, true);\n    }\n\n    if (bucket && over.length > 0) {\n      bucket.push(ownClips.length > 0 ? wrapInChain(over, ownClips, node.layer, carry) : { kind: 'group', children: over });\n    }\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null, false);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":"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"}

package/dist/canvas/canvasRenderer.js

@@ -1,101 +1,190 @@
-import { WeaselRenderer as e } from "@weasel-js/renderer";
-import { viewToMat3 as t } from "@weasel-js/geom";
-import { createEmitter as n } from "@weasel-js/registry";
+import { CANVAS_CONTEXT_ATTRIBUTES } from "./contextAttributes.js";
+import { WeaselRenderer } from "@weasel-js/renderer";
+import { viewToMat3 as viewToMat3$1 } from "@weasel-js/geom";
+import { createEmitter } from "@weasel-js/registry";
+
 //#region src/canvas/canvasRenderer.ts
-var r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new WeakSet(), a = (e) => e?.map((e) => e.id).join("|") ?? "";
-function o(e, t) {
-	if (t) for (let n of t) try {
-		e.registerProgram(n);
+/**
+* The one renderer lifetime in core. Every on-screen surface holds its
+* `WeaselRenderer` through a `leaseCanvasRenderer` lease.
+*
+* A lease holds its own renderer, so several can share one element: each
+* tenant painting a `tile` of a shared buffer gets a renderer of its own on
+* the element's one context. Release frees only what that renderer created;
+* the context itself is never lost.
+*/
+/** The live renderers painting into each element, across every lease. */
+var TENANTS = /* @__PURE__ */ new WeakMap();
+/** Canvases whose context the renderer refused, so a redraw does not rebuild
+*  and fail again, and the reason is reported once. */
+var REFUSED = /* @__PURE__ */ new WeakSet();
+/** Identifies a set of custom programs by their ids, in order. */
+var shaderKeyOf = (shaders) => shaders?.map((h) => h.id).join("|") ?? "";
+function registerShaders(renderer, shaders) {
+	if (!shaders) return;
+	for (const handle of shaders) try {
+		renderer.registerProgram(handle);
 	} catch (e) {
-		console.warn(`weasel: failed to register shader "${n.id}":`, e);
+		console.warn(`weasel: failed to register shader "${handle.id}":`, e);
 	}
 }
-function s(e) {
-	let t = r.get(e.canvas);
-	t?.delete(e.renderer), e.canvas.removeEventListener("webglcontextlost", e.onLost), e.canvas.removeEventListener("webglcontextrestored", e.onRestored), t && t.size === 0 && r.delete(e.canvas), e.renderer.dispose();
+function free(held) {
+	const set = TENANTS.get(held.canvas);
+	set?.delete(held.renderer);
+	held.canvas.removeEventListener("webglcontextlost", held.onLost);
+	held.canvas.removeEventListener("webglcontextrestored", held.onRestored);
+	if (set && set.size === 0) TENANTS.delete(held.canvas);
+	held.renderer.dispose();
 }
-function c() {
-	let c = null, l = n(), u = (t, n, u = {}) => {
-		let { width: d, height: f } = n, p = n.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), m = u.tile ?? null, h = m !== null;
-		if (c && (c.canvas !== t || c.shared !== h) && (s(c), c = null), c) (!h && (t.width !== Math.round(d * p) || t.height !== Math.round(f * p)) || c.width !== d || c.height !== f || c.dpr !== p) && (c.renderer.resize({
-			width: d,
-			height: f,
-			dpr: p
-		}), c.width = d, c.height = f, c.dpr = p), c.flattenTolerance !== u.flattenTolerance && (c.renderer.setFlattenTolerance(u.flattenTolerance), c.flattenTolerance = u.flattenTolerance);
-		else {
-			if (i.has(t)) return null;
-			let n = t.getContext("webgl2", {
-				preserveDrawingBuffer: !0,
-				stencil: !0
-			});
-			if (!n || typeof n.enable != "function") return null;
-			let a;
+/** Hold the renderer of the canvas a surface paints into, until released. */
+function leaseCanvasRenderer() {
+	let held = null;
+	const restored = createEmitter();
+	const bind = (canvas, size, options = {}) => {
+		const { width, height } = size;
+		const dpr = size.dpr ?? (typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1);
+		const tile = options.tile ?? null;
+		const shared = tile !== null;
+		if (held && (held.canvas !== canvas || held.shared !== shared)) {
+			free(held);
+			held = null;
+		}
+		if (!held) {
+			if (REFUSED.has(canvas)) return null;
+			const gl = canvas.getContext("webgl2", CANVAS_CONTEXT_ATTRIBUTES);
+			if (!gl || typeof gl.enable !== "function") return null;
+			let renderer;
 			try {
-				a = new e({
-					gl: n,
-					...h ? {} : { canvas: t },
-					width: d,
-					height: f,
-					dpr: p,
-					flattenTolerance: u.flattenTolerance
+				renderer = new WeaselRenderer({
+					gl,
+					...shared ? {} : { canvas },
+					width,
+					height,
+					dpr,
+					flattenTolerance: options.flattenTolerance,
+					retainBudget: options.retainBudget,
+					imageMinification: options.imageMinification
 				});
 			} catch (e) {
-				return n.isContextLost?.() || (i.add(t), console.warn("weasel: this canvas cannot be painted:", e)), null;
+				if (!gl.isContextLost?.()) {
+					REFUSED.add(canvas);
+					console.warn("weasel: this canvas cannot be painted:", e);
+				}
+				return null;
 			}
-			let o = c = {
-				canvas: t,
-				renderer: a,
-				shared: h,
-				width: d,
-				height: f,
-				dpr: p,
+			const mine = held = {
+				canvas,
+				renderer,
+				shared,
+				width,
+				height,
+				dpr,
 				tileX: null,
 				tileY: null,
-				flattenTolerance: u.flattenTolerance,
+				flattenTolerance: options.flattenTolerance,
+				retainBudget: options.retainBudget,
+				imageMinification: options.imageMinification,
 				shaderKey: "",
-				lost: !1,
+				lost: false,
 				onLost: () => {
-					o.lost = !0;
+					mine.lost = true;
 				},
 				onRestored: () => {
-					o.lost = !1, l.emit();
+					mine.lost = false;
+					restored.emit();
 				}
 			};
-			t.addEventListener("webglcontextlost", c.onLost), t.addEventListener("webglcontextrestored", c.onRestored);
-			let s = r.get(t);
-			s || (s = /* @__PURE__ */ new Set(), r.set(t, s)), s.add(a);
+			canvas.addEventListener("webglcontextlost", held.onLost);
+			canvas.addEventListener("webglcontextrestored", held.onRestored);
+			let set = TENANTS.get(canvas);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				TENANTS.set(canvas, set);
+			}
+			set.add(renderer);
+		} else {
+			if (!shared && (canvas.width !== Math.round(width * dpr) || canvas.height !== Math.round(height * dpr)) || held.width !== width || held.height !== height || held.dpr !== dpr) {
+				held.renderer.resize({
+					width,
+					height,
+					dpr
+				});
+				held.width = width;
+				held.height = height;
+				held.dpr = dpr;
+			}
+			if (held.flattenTolerance !== options.flattenTolerance) {
+				held.renderer.setFlattenTolerance(options.flattenTolerance);
+				held.flattenTolerance = options.flattenTolerance;
+			}
+			if (held.retainBudget !== options.retainBudget) {
+				held.renderer.setRetainBudget(options.retainBudget);
+				held.retainBudget = options.retainBudget;
+			}
+			if (held.imageMinification !== options.imageMinification) {
+				held.renderer.setImageMinification(options.imageMinification);
+				held.imageMinification = options.imageMinification;
+			}
+		}
+		if (held.lost) return null;
+		const { renderer } = held;
+		const shaderKey = shaderKeyOf(options.shaders);
+		if (shaderKey !== held.shaderKey) {
+			registerShaders(renderer, options.shaders);
+			held.shaderKey = shaderKey;
+		}
+		const tileX = tile?.x ?? null;
+		const tileY = tile?.y ?? null;
+		if (tileX !== held.tileX || tileY !== held.tileY) {
+			renderer.setTarget(tile ? { origin: {
+				x: tile.x,
+				y: tile.y
+			} } : null);
+			held.tileX = tileX;
+			held.tileY = tileY;
 		}
-		if (c.lost) return null;
-		let { renderer: g } = c, _ = a(u.shaders);
-		_ !== c.shaderKey && (o(g, u.shaders), c.shaderKey = _);
-		let v = m?.x ?? null, y = m?.y ?? null;
-		return (v !== c.tileX || y !== c.tileY) && (g.setTarget(m ? { origin: {
-			x: m.x,
-			y: m.y
-		} } : null), c.tileX = v, c.tileY = y), g;
+		return renderer;
 	};
 	return {
-		bind: u,
-		paint(e, n, r, i, a) {
-			let o = u(e, i, a);
-			return o ? (o.render(n, t(r), a?.render), !0) : !1;
+		bind,
+		paint(canvas, commands, view, size, options) {
+			const renderer = bind(canvas, size, options);
+			if (!renderer) return false;
+			renderer.render(commands, viewToMat3$1(view), options?.render);
+			return true;
 		},
-		subscribeRestored: l.subscribe,
+		subscribeRestored: restored.subscribe,
 		release() {
-			c && s(c), c = null;
+			if (held) free(held);
+			held = null;
 		}
 	};
 }
-var l = /* @__PURE__ */ new WeakMap();
-function u(e, t, n, r) {
-	let i = l.get(e);
-	return i || (i = c(), l.set(e, i)), i.paint(e, t, n, r);
+/** Leases held on a canvas's behalf by `paintCanvas`, one per element. */
+var CANVAS_LEASES = /* @__PURE__ */ new WeakMap();
+/**
+* Paint `canvas` through a lease held for the element itself, for callers
+* with no component lifetime of their own. The renderer lives until
+* `releaseCanvasRenderer(canvas)`.
+*/
+function paintCanvas(canvas, commands, view, size) {
+	let lease = CANVAS_LEASES.get(canvas);
+	if (!lease) {
+		lease = leaseCanvasRenderer();
+		CANVAS_LEASES.set(canvas, lease);
+	}
+	return lease.paint(canvas, commands, view, size);
 }
-function d(e) {
-	let t = l.get(e);
-	t && (l.delete(e), t.release());
+/** Free the renderer `paintCanvas` holds for the canvas, and every GL object
+*  it owns. The next paint creates a fresh one. Renderers a surface component
+*  holds are that component's to free, on unmount. */
+function releaseCanvasRenderer(canvas) {
+	const lease = CANVAS_LEASES.get(canvas);
+	if (!lease) return;
+	CANVAS_LEASES.delete(canvas);
+	lease.release();
 }
-//#endregion
-export { c as leaseCanvasRenderer, u as paintCanvas, d as releaseCanvasRenderer, a as shaderKeyOf };
 
+//#endregion
+export { leaseCanvasRenderer, paintCanvas, releaseCanvasRenderer, shaderKeyOf };
 //# sourceMappingURL=canvasRenderer.js.map

package/dist/canvas/canvasRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"canvasRenderer.js","names":["viewToMat3","viewToMat3$1","TENANTS","REFUSED","shaderKeyOf","shaders","h","registerShaders","handle","free","set","held","leaseCanvasRenderer","restored","createEmitter","bind","size","dpr","tile","options","shared","canvas","width","height","gl","renderer","WeaselRenderer","mine","shaderKey","tileX","tileY","commands","view","CANVAS_LEASES","paintCanvas","lease","releaseCanvasRenderer"],"sources":["../../src/canvas/canvasRenderer.ts"],"sourcesContent":["/**\n * The one renderer lifetime in core. Every on-screen surface holds its\n * `WeaselRenderer` through a `leaseCanvasRenderer` lease.\n *\n * A lease holds its own renderer, so several can share one element: each\n * tenant painting a `tile` of a shared buffer gets a renderer of its own on\n * the element's one context. Release frees only what that renderer created;\n * the context itself is never lost.\n */\nimport { WeaselRenderer, type RenderOptions } from '@weasel-js/renderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport { createEmitter } from '@weasel-js/registry';\n\n/** The live renderers painting into each element, across every lease. */\nconst TENANTS: WeakMap<HTMLCanvasElement, Set<WeaselRenderer>> = new WeakMap();\n\n/** Canvases whose context the renderer refused, so a redraw does not rebuild\n *  and fail again, and the reason is reported once. */\nconst REFUSED: WeakSet<HTMLCanvasElement> = new WeakSet();\n\n/** A renderer painting into the canvas, if any lease holds one. Test seam. */\nexport function cachedCanvasRenderer(canvas: HTMLCanvasElement): WeaselRenderer | undefined {\n  const set = TENANTS.get(canvas);\n  return set ? set.values().next().value : undefined;\n}\n\n/** The size and density to paint a canvas at. `dpr` defaults to\n *  `window.devicePixelRatio`, read per paint. */\nexport interface CanvasPaintSize {\n  width: number;\n  height: number;\n  dpr?: number;\n}\n\n/** How one paint reaches the canvas, beyond its size. */\nexport interface CanvasPaintOptions {\n  /** Paint a `width × height` tile of a buffer other surfaces share, at this\n   *  origin in CSS pixels. The buffer is then the caller's to size: the\n   *  renderer never resizes the element, which would have every co-tenant\n   *  resize it to its own pane. Omit to own the whole element. */\n  tile?: { x: number; y: number } | null;\n  /** `WeaselRendererOptions.flattenTolerance`, applied from this paint on. */\n  flattenTolerance?: number;\n  /** Custom programs to compile on the renderer. Compiled when the renderer\n   *  is created, and again when the set of ids changes. */\n  shaders?: readonly ShaderProgramHandle[];\n}\n\n/** A paint's options, plus what `paint` hands `WeaselRenderer.render`. */\nexport interface CanvasRenderOptions extends CanvasPaintOptions {\n  render?: RenderOptions;\n}\n\n/** A canvas renderer held for a surface's lifetime. */\nexport interface CanvasRendererLease {\n  /** Draw `commands` into `canvas` — screen-space, one unit per CSS pixel,\n   *  with `view` passed on as the frame's world→screen transform. `bind`,\n   *  then render. Returns `false` without painting where `bind` finds no\n   *  renderer. */\n  paint(\n    canvas: HTMLCanvasElement,\n    commands: DrawCommand[],\n    view: View,\n    size: CanvasPaintSize,\n    options?: CanvasRenderOptions,\n  ): boolean;\n  /** The renderer that paints `canvas` at `size`, ready to render: created on\n   *  first use, resized, and given this paint's tile, tolerance, and shaders.\n   *  Frees the previous renderer first if the surface moved to another\n   *  element, or between owning it whole and painting a tile of it. `null`\n   *  where no WebGL2 context is available (jsdom, a failed context creation,\n   *  or a context that is lost for now). */\n  bind(canvas: HTMLCanvasElement, size: CanvasPaintSize, options?: CanvasPaintOptions): WeaselRenderer | null;\n  /** Run `fn` when the canvas gets a lost context back, after the renderer\n   *  has rebuilt itself on it. Nothing repaints a restored buffer on its own.\n   *  Returns an unsubscribe. */\n  subscribeRestored(fn: () => void): () => void;\n  /** Free the held renderer and every GL object it owns. A later `paint`\n   *  creates a fresh one. */\n  release(): void;\n}\n\ninterface Held {\n  canvas: HTMLCanvasElement;\n  renderer: WeaselRenderer;\n  shared: boolean;\n  lost: boolean;\n  onLost: () => void;\n  onRestored: () => void;\n  width: number;\n  height: number;\n  dpr: number;\n  tileX: number | null;\n  tileY: number | null;\n  flattenTolerance: number | undefined;\n  shaderKey: string;\n}\n\n/** Identifies a set of custom programs by their ids, in order. */\nexport const shaderKeyOf = (shaders: readonly ShaderProgramHandle[] | undefined): string =>\n  shaders?.map((h) => h.id).join('|') ?? '';\n\nfunction registerShaders(renderer: WeaselRenderer, shaders: readonly ShaderProgramHandle[] | undefined): void {\n  if (!shaders) return;\n  for (const handle of shaders) {\n    try {\n      renderer.registerProgram(handle);\n    } catch (e) {\n      console.warn(`weasel: failed to register shader \"${handle.id}\":`, e);\n    }\n  }\n}\n\nfunction free(held: Held): void {\n  const set = TENANTS.get(held.canvas);\n  set?.delete(held.renderer);\n  held.canvas.removeEventListener('webglcontextlost', held.onLost);\n  held.canvas.removeEventListener('webglcontextrestored', held.onRestored);\n  if (set && set.size === 0) TENANTS.delete(held.canvas);\n  held.renderer.dispose();\n}\n\n/** Hold the renderer of the canvas a surface paints into, until released. */\nexport function leaseCanvasRenderer(): CanvasRendererLease {\n  let held: Held | null = null;\n  const restored = createEmitter();\n  const bind = (canvas: HTMLCanvasElement, size: CanvasPaintSize, options: CanvasPaintOptions = {}): WeaselRenderer | null => {\n    const { width, height } = size;\n    const dpr = size.dpr ?? (typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1);\n    const tile = options.tile ?? null;\n    const shared = tile !== null;\n\n    if (held && (held.canvas !== canvas || held.shared !== shared)) {\n      free(held);\n      held = null;\n    }\n    if (!held) {\n      if (REFUSED.has(canvas)) return null;\n      const gl = canvas.getContext('webgl2', { preserveDrawingBuffer: true, stencil: true });\n      if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') return null;\n      let renderer: WeaselRenderer;\n      try {\n        renderer = new WeaselRenderer({\n          gl: gl as WebGL2RenderingContext,\n          ...(shared ? {} : { canvas }),\n          width, height, dpr,\n          flattenTolerance: options.flattenTolerance,\n        });\n      } catch (e) {\n        // A lost context fails to compile and may yet come back; anything\n        // else fails the same way next time.\n        if (!(gl as Partial<WebGL2RenderingContext>).isContextLost?.()) {\n          REFUSED.add(canvas);\n          console.warn('weasel: this canvas cannot be painted:', e);\n        }\n        return null;\n      }\n      // Added after the renderer's own listeners, so a subscriber runs against\n      // a renderer that has already recompiled.\n      const mine: Held = held = {\n        canvas, renderer, shared, width, height, dpr, tileX: null, tileY: null,\n        flattenTolerance: options.flattenTolerance, shaderKey: '',\n        lost: false,\n        onLost: () => { mine.lost = true; },\n        onRestored: () => {\n          mine.lost = false;\n          restored.emit();\n        },\n      };\n      canvas.addEventListener('webglcontextlost', held.onLost);\n      canvas.addEventListener('webglcontextrestored', held.onRestored);\n      let set = TENANTS.get(canvas);\n      if (!set) { set = new Set(); TENANTS.set(canvas, set); }\n      set.add(renderer);\n    } else {\n      // React writes the element's `width` and `height` attributes in CSS\n      // pixels on every size change, so a size that went away and came back\n      // matches the record while the buffer does not.\n      const stale = !shared\n        && (canvas.width !== Math.round(width * dpr) || canvas.height !== Math.round(height * dpr));\n      if (stale || held.width !== width || held.height !== height || held.dpr !== dpr) {\n        held.renderer.resize({ width, height, dpr });\n        held.width = width;\n        held.height = height;\n        held.dpr = dpr;\n      }\n      if (held.flattenTolerance !== options.flattenTolerance) {\n        held.renderer.setFlattenTolerance(options.flattenTolerance);\n        held.flattenTolerance = options.flattenTolerance;\n      }\n    }\n\n    if (held.lost) return null;\n    const { renderer } = held;\n    const shaderKey = shaderKeyOf(options.shaders);\n    if (shaderKey !== held.shaderKey) {\n      registerShaders(renderer, options.shaders);\n      held.shaderKey = shaderKey;\n    }\n    const tileX = tile?.x ?? null;\n    const tileY = tile?.y ?? null;\n    if (tileX !== held.tileX || tileY !== held.tileY) {\n      renderer.setTarget(tile ? { origin: { x: tile.x, y: tile.y } } : null);\n      held.tileX = tileX;\n      held.tileY = tileY;\n    }\n    return renderer;\n  };\n  return {\n    bind,\n    paint(canvas, commands, view, size, options) {\n      const renderer = bind(canvas, size, options);\n      if (!renderer) return false;\n      renderer.render(commands, viewToMat3(view), options?.render);\n      return true;\n    },\n    subscribeRestored: restored.subscribe,\n    release() {\n      if (held) free(held);\n      held = null;\n    },\n  };\n}\n\n/** Leases held on a canvas's behalf by `paintCanvas`, one per element. */\nconst CANVAS_LEASES: WeakMap<HTMLCanvasElement, CanvasRendererLease> = new WeakMap();\n\n/**\n * Paint `canvas` through a lease held for the element itself, for callers\n * with no component lifetime of their own. The renderer lives until\n * `releaseCanvasRenderer(canvas)`.\n */\nexport function paintCanvas(\n  canvas: HTMLCanvasElement,\n  commands: DrawCommand[],\n  view: View,\n  size: CanvasPaintSize,\n): boolean {\n  let lease = CANVAS_LEASES.get(canvas);\n  if (!lease) {\n    lease = leaseCanvasRenderer();\n    CANVAS_LEASES.set(canvas, lease);\n  }\n  return lease.paint(canvas, commands, view, size);\n}\n\n/** Free the renderer `paintCanvas` holds for the canvas, and every GL object\n *  it owns. The next paint creates a fresh one. Renderers a surface component\n *  holds are that component's to free, on unmount. */\nexport function releaseCanvasRenderer(canvas: HTMLCanvasElement): void {\n  const lease = CANVAS_LEASES.get(canvas);\n  if (!lease) return;\n  CANVAS_LEASES.delete(canvas);\n  lease.release();\n}\n"],"mappings":"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"}
+{"version":3,"file":"canvasRenderer.js","names":["viewToMat3"],"sources":["../../src/canvas/canvasRenderer.ts"],"sourcesContent":["/**\n * The one renderer lifetime in core. Every on-screen surface holds its\n * `WeaselRenderer` through a `leaseCanvasRenderer` lease.\n *\n * A lease holds its own renderer, so several can share one element: each\n * tenant painting a `tile` of a shared buffer gets a renderer of its own on\n * the element's one context. Release frees only what that renderer created;\n * the context itself is never lost.\n */\nimport { WeaselRenderer, type FlattenTolerance, type ImageMinification, type RenderOptions } from '@weasel-js/renderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport { createEmitter } from '@weasel-js/registry';\nimport { CANVAS_CONTEXT_ATTRIBUTES } from './contextAttributes';\n\n/** The live renderers painting into each element, across every lease. */\nconst TENANTS: WeakMap<HTMLCanvasElement, Set<WeaselRenderer>> = new WeakMap();\n\n/** Canvases whose context the renderer refused, so a redraw does not rebuild\n *  and fail again, and the reason is reported once. */\nconst REFUSED: WeakSet<HTMLCanvasElement> = new WeakSet();\n\n/** A renderer painting into the canvas, if any lease holds one. Test seam. */\nexport function cachedCanvasRenderer(canvas: HTMLCanvasElement): WeaselRenderer | undefined {\n  const set = TENANTS.get(canvas);\n  return set ? set.values().next().value : undefined;\n}\n\n/** The size and density to paint a canvas at. `dpr` defaults to\n *  `window.devicePixelRatio`, read per paint. */\nexport interface CanvasPaintSize {\n  width: number;\n  height: number;\n  dpr?: number;\n}\n\n/** How one paint reaches the canvas, beyond its size. */\nexport interface CanvasPaintOptions {\n  /** Paint a `width × height` tile of a buffer other surfaces share, at this\n   *  origin in CSS pixels. The buffer is then the caller's to size: the\n   *  renderer never resizes the element, which would have every co-tenant\n   *  resize it to its own pane. Omit to own the whole element. */\n  tile?: { x: number; y: number } | null;\n  /** `WeaselRendererOptions.flattenTolerance`, applied from this paint on. */\n  flattenTolerance?: FlattenTolerance;\n  /** `WeaselRendererOptions.retainBudget`, applied from this paint on. */\n  retainBudget?: number;\n  /** `WeaselRendererOptions.imageMinification`, applied from this paint on. */\n  imageMinification?: ImageMinification;\n  /** Custom programs to compile on the renderer. Compiled when the renderer\n   *  is created, and again when the set of ids changes. */\n  shaders?: readonly ShaderProgramHandle[];\n}\n\n/** A paint's options, plus what `paint` hands `WeaselRenderer.render`. */\nexport interface CanvasRenderOptions extends CanvasPaintOptions {\n  render?: RenderOptions;\n}\n\n/** A canvas renderer held for a surface's lifetime. */\nexport interface CanvasRendererLease {\n  /** Draw `commands` into `canvas` — screen-space, one unit per CSS pixel,\n   *  with `view` passed on as the frame's world→screen transform. `bind`,\n   *  then render. Returns `false` without painting where `bind` finds no\n   *  renderer. */\n  paint(\n    canvas: HTMLCanvasElement,\n    commands: DrawCommand[],\n    view: View,\n    size: CanvasPaintSize,\n    options?: CanvasRenderOptions,\n  ): boolean;\n  /** The renderer that paints `canvas` at `size`, ready to render: created on\n   *  first use, resized, and given this paint's tile, tolerance, retain\n   *  budget, and shaders.\n   *  Frees the previous renderer first if the surface moved to another\n   *  element, or between owning it whole and painting a tile of it. `null`\n   *  where no WebGL2 context is available (jsdom, a failed context creation,\n   *  or a context that is lost for now). */\n  bind(canvas: HTMLCanvasElement, size: CanvasPaintSize, options?: CanvasPaintOptions): WeaselRenderer | null;\n  /** Run `fn` when the canvas gets a lost context back, after the renderer\n   *  has rebuilt itself on it. Nothing repaints a restored buffer on its own.\n   *  Returns an unsubscribe. */\n  subscribeRestored(fn: () => void): () => void;\n  /** Free the held renderer and every GL object it owns. A later `paint`\n   *  creates a fresh one. */\n  release(): void;\n}\n\ninterface Held {\n  canvas: HTMLCanvasElement;\n  renderer: WeaselRenderer;\n  shared: boolean;\n  lost: boolean;\n  onLost: () => void;\n  onRestored: () => void;\n  width: number;\n  height: number;\n  dpr: number;\n  tileX: number | null;\n  tileY: number | null;\n  flattenTolerance: FlattenTolerance | undefined;\n  retainBudget: number | undefined;\n  imageMinification: ImageMinification | undefined;\n  shaderKey: string;\n}\n\n/** Identifies a set of custom programs by their ids, in order. */\nexport const shaderKeyOf = (shaders: readonly ShaderProgramHandle[] | undefined): string =>\n  shaders?.map((h) => h.id).join('|') ?? '';\n\nfunction registerShaders(renderer: WeaselRenderer, shaders: readonly ShaderProgramHandle[] | undefined): void {\n  if (!shaders) return;\n  for (const handle of shaders) {\n    try {\n      renderer.registerProgram(handle);\n    } catch (e) {\n      console.warn(`weasel: failed to register shader \"${handle.id}\":`, e);\n    }\n  }\n}\n\nfunction free(held: Held): void {\n  const set = TENANTS.get(held.canvas);\n  set?.delete(held.renderer);\n  held.canvas.removeEventListener('webglcontextlost', held.onLost);\n  held.canvas.removeEventListener('webglcontextrestored', held.onRestored);\n  if (set && set.size === 0) TENANTS.delete(held.canvas);\n  held.renderer.dispose();\n}\n\n/** Hold the renderer of the canvas a surface paints into, until released. */\nexport function leaseCanvasRenderer(): CanvasRendererLease {\n  let held: Held | null = null;\n  const restored = createEmitter();\n  const bind = (canvas: HTMLCanvasElement, size: CanvasPaintSize, options: CanvasPaintOptions = {}): WeaselRenderer | null => {\n    const { width, height } = size;\n    const dpr = size.dpr ?? (typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1);\n    const tile = options.tile ?? null;\n    const shared = tile !== null;\n\n    if (held && (held.canvas !== canvas || held.shared !== shared)) {\n      free(held);\n      held = null;\n    }\n    if (!held) {\n      if (REFUSED.has(canvas)) return null;\n      const gl = canvas.getContext('webgl2', CANVAS_CONTEXT_ATTRIBUTES);\n      if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') return null;\n      let renderer: WeaselRenderer;\n      try {\n        renderer = new WeaselRenderer({\n          gl: gl as WebGL2RenderingContext,\n          ...(shared ? {} : { canvas }),\n          width, height, dpr,\n          flattenTolerance: options.flattenTolerance,\n          retainBudget: options.retainBudget,\n          imageMinification: options.imageMinification,\n        });\n      } catch (e) {\n        // A lost context fails to compile and may yet come back; anything\n        // else fails the same way next time.\n        if (!(gl as Partial<WebGL2RenderingContext>).isContextLost?.()) {\n          REFUSED.add(canvas);\n          console.warn('weasel: this canvas cannot be painted:', e);\n        }\n        return null;\n      }\n      // Added after the renderer's own listeners, so a subscriber runs against\n      // a renderer that has already recompiled.\n      const mine: Held = held = {\n        canvas, renderer, shared, width, height, dpr, tileX: null, tileY: null,\n        flattenTolerance: options.flattenTolerance, retainBudget: options.retainBudget,\n        imageMinification: options.imageMinification, shaderKey: '',\n        lost: false,\n        onLost: () => { mine.lost = true; },\n        onRestored: () => {\n          mine.lost = false;\n          restored.emit();\n        },\n      };\n      canvas.addEventListener('webglcontextlost', held.onLost);\n      canvas.addEventListener('webglcontextrestored', held.onRestored);\n      let set = TENANTS.get(canvas);\n      if (!set) { set = new Set(); TENANTS.set(canvas, set); }\n      set.add(renderer);\n    } else {\n      // React writes the element's `width` and `height` attributes in CSS\n      // pixels on every size change, so a size that went away and came back\n      // matches the record while the buffer does not.\n      const stale = !shared\n        && (canvas.width !== Math.round(width * dpr) || canvas.height !== Math.round(height * dpr));\n      if (stale || held.width !== width || held.height !== height || held.dpr !== dpr) {\n        held.renderer.resize({ width, height, dpr });\n        held.width = width;\n        held.height = height;\n        held.dpr = dpr;\n      }\n      if (held.flattenTolerance !== options.flattenTolerance) {\n        held.renderer.setFlattenTolerance(options.flattenTolerance);\n        held.flattenTolerance = options.flattenTolerance;\n      }\n      if (held.retainBudget !== options.retainBudget) {\n        held.renderer.setRetainBudget(options.retainBudget);\n        held.retainBudget = options.retainBudget;\n      }\n      if (held.imageMinification !== options.imageMinification) {\n        held.renderer.setImageMinification(options.imageMinification);\n        held.imageMinification = options.imageMinification;\n      }\n    }\n\n    if (held.lost) return null;\n    const { renderer } = held;\n    const shaderKey = shaderKeyOf(options.shaders);\n    if (shaderKey !== held.shaderKey) {\n      registerShaders(renderer, options.shaders);\n      held.shaderKey = shaderKey;\n    }\n    const tileX = tile?.x ?? null;\n    const tileY = tile?.y ?? null;\n    if (tileX !== held.tileX || tileY !== held.tileY) {\n      renderer.setTarget(tile ? { origin: { x: tile.x, y: tile.y } } : null);\n      held.tileX = tileX;\n      held.tileY = tileY;\n    }\n    return renderer;\n  };\n  return {\n    bind,\n    paint(canvas, commands, view, size, options) {\n      const renderer = bind(canvas, size, options);\n      if (!renderer) return false;\n      renderer.render(commands, viewToMat3(view), options?.render);\n      return true;\n    },\n    subscribeRestored: restored.subscribe,\n    release() {\n      if (held) free(held);\n      held = null;\n    },\n  };\n}\n\n/** Leases held on a canvas's behalf by `paintCanvas`, one per element. */\nconst CANVAS_LEASES: WeakMap<HTMLCanvasElement, CanvasRendererLease> = new WeakMap();\n\n/**\n * Paint `canvas` through a lease held for the element itself, for callers\n * with no component lifetime of their own. The renderer lives until\n * `releaseCanvasRenderer(canvas)`.\n */\nexport function paintCanvas(\n  canvas: HTMLCanvasElement,\n  commands: DrawCommand[],\n  view: View,\n  size: CanvasPaintSize,\n): boolean {\n  let lease = CANVAS_LEASES.get(canvas);\n  if (!lease) {\n    lease = leaseCanvasRenderer();\n    CANVAS_LEASES.set(canvas, lease);\n  }\n  return lease.paint(canvas, commands, view, size);\n}\n\n/** Free the renderer `paintCanvas` holds for the canvas, and every GL object\n *  it owns. The next paint creates a fresh one. Renderers a surface component\n *  holds are that component's to free, on unmount. */\nexport function releaseCanvasRenderer(canvas: HTMLCanvasElement): void {\n  const lease = CANVAS_LEASES.get(canvas);\n  if (!lease) return;\n  CANVAS_LEASES.delete(canvas);\n  lease.release();\n}\n"],"mappings":"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"}

package/dist/canvas/colorOverrides.js

@@ -1,16 +1,24 @@
 //#region src/canvas/colorOverrides.ts
-var e = () => typeof performance < "u" ? performance.now() : Date.now();
-function t(t, n, r = e) {
-	return (e, i, a, o) => {
-		if (!t.has(e.id)) return n(e, i, a, o);
-		let s = r();
-		return n(e, i, a, {
-			...o,
-			vertexColors: (n, r) => t.resolve(e.id, n, r, s)
+var clock = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+/**
+* Wrap a `drawOne` so a node with a live color override reaches its painter
+* with {@link NodePaintCtx.vertexColors}. Both scene walks wrap here, and
+* `createPathLayer` resolves through the same `ColorOverrideRegistry.resolve`.
+*
+* A node nothing overrides passes the caller's `ctx` through untouched, so
+* the common case allocates nothing.
+*/
+function withColorOverrides(registry, drawOne, now = clock) {
+	return (node, pose, view, ctx) => {
+		if (!registry.has(node.id)) return drawOne(node, pose, view, ctx);
+		const tMs = now();
+		return drawOne(node, pose, view, {
+			...ctx,
+			vertexColors: (channel, base) => registry.resolve(node.id, channel, base, tMs)
 		});
 	};
 }
-//#endregion
-export { t as withColorOverrides };
 
+//#endregion
+export { withColorOverrides };
 //# sourceMappingURL=colorOverrides.js.map