@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/layers/gateLayer.js

@@ -1,13 +1,28 @@
-import { subscribeToSources as e } from "./render.js";
+import { subscribeToSources } from "./redrawSource.js";
+
 //#region src/core/layers/gateLayer.ts
-function t(t) {
-	let { layer: n, visible: r } = t, i = {
-		...n,
-		draw: (e, t, i) => r() ? n.draw(e, t, i) : []
-	}, { deps: a, hitTest: o } = n;
-	return a && (i.deps = (e, t, n) => [r(), ...a(e, t, n)]), o && (i.hitTest = (...e) => r() ? o(...e) : null), n.subscribe && (i.subscribe = e([n])), i;
+/**
+* `RenderLayer` wrapper that conditionally emits draw commands based on a
+* predicate.
+*
+* A rule that chrome-caps can express belongs there, since it gates the
+* hit-test as well as the paint. This is for layers outside its vocabulary.
+*/
+/** Wrap a render layer so it only draws, and is only hit, while `visible()`
+*  is true. The predicate is consulted per frame. */
+function gateLayer(opts) {
+	const { layer, visible } = opts;
+	const wrapped = {
+		...layer,
+		draw: (data, view, dims) => visible() ? layer.draw(data, view, dims) : []
+	};
+	const { deps, hitTest } = layer;
+	if (deps) wrapped.deps = (data, view, dims) => [visible(), ...deps(data, view, dims)];
+	if (hitTest) wrapped.hitTest = (...args) => visible() ? hitTest(...args) : null;
+	if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);
+	return wrapped;
 }
-//#endregion
-export { t as gateLayer };
 
+//#endregion
+export { gateLayer };
 //# sourceMappingURL=gateLayer.js.map

package/dist/core/layers/gateLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"gateLayer.js","names":["gateLayer","opts","wrapped","layer","visible","data","view","dims","deps","hitTest","args","subscribeToSources"],"sources":["../../../src/core/layers/gateLayer.ts"],"sourcesContent":["/**\n * `RenderLayer` wrapper that conditionally emits draw commands based on a\n * predicate.\n *\n * A rule that chrome-caps can express belongs there, since it gates the\n * hit-test as well as the paint. This is for layers outside its vocabulary.\n */\nimport { subscribeToSources, type RenderLayer } from './render';\n\n/** Options for `gateLayer`. */\nexport interface GateLayerOptions<TData> {\n  /** The wrapped layer. Everything but `draw`, `hitTest`, and `deps` flows\n   *  through unchanged. */\n  layer: RenderLayer<TData>;\n  /** Returns `true` to render the layer this frame, `false` to skip. */\n  visible: () => boolean;\n}\n\n/** Wrap a render layer so it only draws, and is only hit, while `visible()`\n *  is true. The predicate is consulted per frame. */\nexport function gateLayer<TData>(opts: GateLayerOptions<TData>): RenderLayer<TData> {\n  const { layer, visible } = opts;\n  const wrapped: RenderLayer<TData> = {\n    ...layer,\n    draw: (data, view, dims) => (visible() ? layer.draw(data, view, dims) : []),\n  };\n  const { deps, hitTest } = layer;\n  if (deps) wrapped.deps = (data, view, dims) => [visible(), ...deps(data, view, dims)];\n  if (hitTest) wrapped.hitTest = (...args) => (visible() ? hitTest(...args) : null);\n  if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);\n  return wrapped;\n}\n"],"mappings":";;AAoBA,SAAgBA,EAAiB,GAAmD;CAClF,IAAM,EAAE,UAAO,eAAYC,GACrBC,IAA8B;EAClC,GAAGC;EACH,OAAO,GAAM,GAAM,MAAUC,EAAQ,IAAID,EAAM,KAAKE,GAAMC,GAAMC,CAAI,IAAI,CAAC;CAC3E,GACM,EAAE,SAAM,eAAYJ;CAI1B,OAHIK,MAAM,EAAQ,QAAQ,GAAM,GAAM,MAAS,CAACJ,EAAQ,GAAG,GAAGI,EAAKH,GAAMC,GAAMC,CAAI,CAAC,IAChFE,MAAS,EAAQ,WAAW,GAAGC,MAAUN,EAAQ,IAAIK,EAAQ,GAAGC,CAAI,IAAI,OACxEP,EAAM,cAAW,EAAQ,YAAYQ,EAAmB,CAACR,CAAK,CAAC,IAC5DD;AACT"}
+{"version":3,"file":"gateLayer.js","names":[],"sources":["../../../src/core/layers/gateLayer.ts"],"sourcesContent":["/**\n * `RenderLayer` wrapper that conditionally emits draw commands based on a\n * predicate.\n *\n * A rule that chrome-caps can express belongs there, since it gates the\n * hit-test as well as the paint. This is for layers outside its vocabulary.\n */\nimport { subscribeToSources, type RenderLayer } from './render';\n\n/** Options for `gateLayer`. */\nexport interface GateLayerOptions<TData> {\n  /** The wrapped layer. Everything but `draw`, `hitTest`, and `deps` flows\n   *  through unchanged. */\n  layer: RenderLayer<TData>;\n  /** Returns `true` to render the layer this frame, `false` to skip. */\n  visible: () => boolean;\n}\n\n/** Wrap a render layer so it only draws, and is only hit, while `visible()`\n *  is true. The predicate is consulted per frame. */\nexport function gateLayer<TData>(opts: GateLayerOptions<TData>): RenderLayer<TData> {\n  const { layer, visible } = opts;\n  const wrapped: RenderLayer<TData> = {\n    ...layer,\n    draw: (data, view, dims) => (visible() ? layer.draw(data, view, dims) : []),\n  };\n  const { deps, hitTest } = layer;\n  if (deps) wrapped.deps = (data, view, dims) => [visible(), ...deps(data, view, dims)];\n  if (hitTest) wrapped.hitTest = (...args) => (visible() ? hitTest(...args) : null);\n  if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);\n  return wrapped;\n}\n"],"mappings":";;;;;;;;;;;;AAoBA,SAAgB,UAAiB,MAAmD;CAClF,MAAM,EAAE,OAAO,YAAY;CAC3B,MAAM,UAA8B;EAClC,GAAG;EACH,OAAO,MAAM,MAAM,SAAU,QAAQ,IAAI,MAAM,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC;CAC3E;CACA,MAAM,EAAE,MAAM,YAAY;CAC1B,IAAI,MAAM,QAAQ,QAAQ,MAAM,MAAM,SAAS,CAAC,QAAQ,GAAG,GAAG,KAAK,MAAM,MAAM,IAAI,CAAC;CACpF,IAAI,SAAS,QAAQ,WAAW,GAAG,SAAU,QAAQ,IAAI,QAAQ,GAAG,IAAI,IAAI;CAC5E,IAAI,MAAM,WAAW,QAAQ,YAAY,mBAAmB,CAAC,KAAK,CAAC;CACnE,OAAO;AACT"}

package/dist/core/layers/layerGroup.js

@@ -1,40 +1,53 @@
 //#region src/core/layers/layerGroup.ts
-function e(e, t) {
-	if (!e || e.length === 0) return null;
-	let n = [...t], r = /* @__PURE__ */ new Map();
-	for (let t of e) for (let e of t.layers) {
-		let i = !1;
-		for (let a of n) {
-			if (a !== e && !a.startsWith(`${e}:`)) continue;
-			i = !0;
-			let n = r.get(a);
-			if (n !== t) {
-				if (n) {
-					console.warn(`[weasel] layer "${a}" is claimed by layer groups "${n.id}" and "${t.id}"; it stays in "${n.id}".`);
-					continue;
-				}
-				r.set(a, t);
+/**
+* Layer id → the group that owns it. First claim wins across groups, with a
+* warning for the second; the same group naming a layer twice — `['scene',
+* 'scene:tiles']` — passes quietly.
+*/
+function groupMembership(groups, layerIds) {
+	if (!groups || groups.length === 0) return null;
+	const stack = [...layerIds];
+	const byLayer = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const name of group.layers) {
+		let matched = false;
+		for (const id of stack) {
+			if (id !== name && !id.startsWith(`${name}:`)) continue;
+			matched = true;
+			const claimed = byLayer.get(id);
+			if (claimed === group) continue;
+			if (claimed) {
+				console.warn(`[weasel] layer "${id}" is claimed by layer groups "${claimed.id}" and "${group.id}"; it stays in "${claimed.id}".`);
+				continue;
 			}
+			byLayer.set(id, group);
 		}
-		i || console.warn(`[weasel] layer group "${t.id}" names "${e}", which matches no layer being drawn, so it groups nothing. Check the id against the layer stack — a scene with declared layers draws as "scene:<layerId>", which "scene" covers.`);
+		if (!matched) console.warn(`[weasel] layer group "${group.id}" names "${name}", which matches no layer being drawn, so it groups nothing. Check the id against the layer stack — a scene with declared layers draws as "scene:<layerId>", which "scene" covers.`);
 	}
-	return r;
+	return byLayer;
 }
-function t(e, t, n, r) {
-	let i = typeof e.effects == "function" ? e.effects(n, r) : e.effects, a = i && i.length > 0 ? i : void 0;
-	if (!a && e.alpha === void 0 && e.colorMatrix === void 0 && e.composite === void 0) return t;
-	let o = e.alpha !== void 0 && e.alpha < 1;
+/**
+* Put one run of a group's commands under its shared compositing.
+*
+* No transform: every member already carries its own space wrap, so a second
+* one here would apply the view twice to world layers and once to screen ones.
+* A group that composites plainly gets no wrapper at all.
+*/
+function wrapGroup(group, children, view, dims) {
+	const declared = typeof group.effects === "function" ? group.effects(view, dims) : group.effects;
+	const effects = declared && declared.length > 0 ? declared : void 0;
+	if (!effects && group.alpha === void 0 && group.colorMatrix === void 0 && group.composite === void 0) return children;
+	const fades = group.alpha !== void 0 && group.alpha < 1;
 	return [{
 		kind: "group",
-		...a ? { effects: a } : {},
-		...!a && (o || e.colorMatrix !== void 0) ? { isolate: !0 } : {},
-		...e.alpha === void 0 ? {} : { alpha: e.alpha },
-		...e.colorMatrix === void 0 ? {} : { colorMatrix: e.colorMatrix },
-		...e.composite === void 0 ? {} : { composite: e.composite },
-		children: t
+		...effects ? { effects } : {},
+		...!effects && (fades || group.colorMatrix !== void 0) ? { isolate: true } : {},
+		...group.alpha !== void 0 ? { alpha: group.alpha } : {},
+		...group.colorMatrix !== void 0 ? { colorMatrix: group.colorMatrix } : {},
+		...group.composite !== void 0 ? { composite: group.composite } : {},
+		children
 	}];
 }
-//#endregion
-export { e as groupMembership, t as wrapGroup };
 
+//#endregion
+export { groupMembership, wrapGroup };
 //# sourceMappingURL=layerGroup.js.map

package/dist/core/layers/layerGroup.js.map

@@ -1 +1 @@
-{"version":3,"file":"layerGroup.js","names":["groupMembership","groups","stack","layerIds","byLayer","group","name","matched","id","claimed","wrapGroup","declared","view","dims","effects","children","fades"],"sources":["../../../src/core/layers/layerGroup.ts"],"sourcesContent":["import type { BlendFactors, CompositeOp, DrawCommand, Effect } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport type { Dims } from './render';\n\n/**\n * Several consecutive layers composited as one.\n *\n * A layer's own `effects` run over that layer alone, which is the wrong\n * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not\n * `blur(A) over blur(B)`. A group draws its members into one buffer, runs one\n * chain over it, and composites the result back once.\n *\n * Membership is by `RenderLayer.id` — the same names `layerOrder` and\n * `layerVisibility` use, not the `layers` map's slot keys.\n *\n * Only *consecutive* members share a buffer. A group whose members are\n * separated in the render order is drawn as one bracket per run, with a\n * warning.\n *\n * This is a render-stack bracket, not a scene `ContainerNode`.\n */\nexport interface LayerGroup {\n  /** Names the group in warnings; not a layer id and never drawn. */\n  id: string;\n  /**\n   * Member layer ids. Order here is ignored — the render order decides.\n   *\n   * A name claims that layer and every layer under it in the `:` namespace, so\n   * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers\n   * draws as. The separator is required: `'scene'` does not reach `scenery`.\n   * A name matching no layer being drawn is warned about.\n   */\n  layers: readonly string[];\n  /** Passes over the group's combined pixels, in order. A thunk is re-read on\n   *  every frame, so an animating radius costs no React render. */\n  effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);\n  /** Opacity applied to the group's composited result, not to each member. */\n  alpha?: number;\n  /** 4×5 color matrix (row-major, 20 numbers) applied to the composited\n   *  result. See `GroupDrawCommand.colorMatrix`. */\n  colorMatrix?: number[];\n  /** How the composited result joins the layers under it. Default\n   *  `source-over`. See `GroupDrawCommand.composite`. */\n  composite?: CompositeOp | BlendFactors;\n}\n\n/**\n * Layer id → the group that owns it. First claim wins across groups, with a\n * warning for the second; the same group naming a layer twice — `['scene',\n * 'scene:tiles']` — passes quietly.\n */\nexport function groupMembership(\n  groups: readonly LayerGroup[] | undefined,\n  layerIds: Iterable<string>,\n): Map<string, LayerGroup> | null {\n  if (!groups || groups.length === 0) return null;\n  const stack = [...layerIds];\n  const byLayer = new Map<string, LayerGroup>();\n  for (const group of groups) {\n    for (const name of group.layers) {\n      let matched = false;\n      for (const id of stack) {\n        if (id !== name && !id.startsWith(`${name}:`)) continue;\n        matched = true;\n        const claimed = byLayer.get(id);\n        if (claimed === group) continue;\n        if (claimed) {\n          console.warn(\n            `[weasel] layer \"${id}\" is claimed by layer groups \"${claimed.id}\" and ` +\n            `\"${group.id}\"; it stays in \"${claimed.id}\".`,\n          );\n          continue;\n        }\n        byLayer.set(id, group);\n      }\n      if (!matched) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" names \"${name}\", which matches no layer ` +\n          'being drawn, so it groups nothing. Check the id against the layer stack — a ' +\n          'scene with declared layers draws as \"scene:<layerId>\", which \"scene\" covers.',\n        );\n      }\n    }\n  }\n  return byLayer;\n}\n\n/**\n * Put one run of a group's commands under its shared compositing.\n *\n * No transform: every member already carries its own space wrap, so a second\n * one here would apply the view twice to world layers and once to screen ones.\n * A group that composites plainly gets no wrapper at all.\n */\nexport function wrapGroup(\n  group: LayerGroup,\n  children: DrawCommand[],\n  view: View,\n  dims: Dims,\n): DrawCommand[] {\n  const declared = typeof group.effects === 'function'\n    ? group.effects(view, dims)\n    : group.effects;\n  const effects = declared && declared.length > 0 ? declared : undefined;\n  if (!effects && group.alpha === undefined && group.colorMatrix === undefined\n      && group.composite === undefined) return children;\n  const fades = group.alpha !== undefined && group.alpha < 1;\n  return [{\n    kind: 'group',\n    ...(effects ? { effects } : {}),\n    ...(!effects && (fades || group.colorMatrix !== undefined) ? { isolate: true } : {}),\n    ...(group.alpha !== undefined ? { alpha: group.alpha } : {}),\n    ...(group.colorMatrix !== undefined ? { colorMatrix: group.colorMatrix } : {}),\n    ...(group.composite !== undefined ? { composite: group.composite } : {}),\n    children,\n  }];\n}\n"],"mappings":";AAmDA,SAAgBA,EACd,GACA,GACgC;CAChC,IAAI,CAACC,KAAUA,EAAO,WAAW,GAAG,OAAO;CAC3C,IAAMC,IAAQ,CAAC,GAAGC,CAAQ,GACpBC,oBAAU,IAAI,IAAwB;CAC5C,KAAK,IAAMC,KAASJ,GAClB,KAAK,IAAMK,KAAQD,EAAM,QAAQ;EAC/B,IAAIE,IAAU;EACd,KAAK,IAAMC,KAAMN,GAAO;GACtB,IAAIM,MAAOF,KAAQ,CAACE,EAAG,WAAW,GAAGF,EAAK,EAAE,GAAG;GAC/C,IAAU;GACV,IAAMG,IAAUL,EAAQ,IAAII,CAAE;GAC9B,IAAIC,MAAYJ,GAChB;QAAII,GAAS;KACX,QAAQ,KACN,mBAAmBD,EAAG,gCAAgCC,EAAQ,GAAG,SAC7DJ,EAAM,GAAG,kBAAkBI,EAAQ,GAAG,GAC5C;KACA;IACF;IACA,EAAQ,IAAID,GAAIH,CAAK;GADrB;EAEF;EACA,AAAKE,KACH,QAAQ,KACN,yBAAyBF,EAAM,GAAG,WAAWC,EAAK,mLAGpD;CAEJ;CAEF,OAAOF;AACT;AASA,SAAgBM,EACd,GACA,GACA,GACA,GACe;CACf,IAAMC,IAAW,OAAON,EAAM,WAAY,aACtCA,EAAM,QAAQO,GAAMC,CAAI,IACxBR,EAAM,SACJS,IAAUH,KAAYA,EAAS,SAAS,IAAIA,IAAW,KAAA;CAC7D,IAAI,CAACG,KAAWT,EAAM,UAAU,KAAA,KAAaA,EAAM,gBAAgB,KAAA,KAC5DA,EAAM,cAAc,KAAA,GAAW,OAAOU;CAC7C,IAAMC,IAAQX,EAAM,UAAU,KAAA,KAAaA,EAAM,QAAQ;CACzD,OAAO,CAAC;EACN,MAAM;EACN,GAAIS,IAAU,EAAE,WAAQ,IAAI,CAAC;EAC7B,GAAI,CAACA,MAAYE,KAASX,EAAM,gBAAgB,KAAA,KAAa,EAAE,SAAS,GAAK,IAAI,CAAC;EAClF,GAAIA,EAAM,UAAU,KAAA,IAAqC,CAAC,IAA1B,EAAE,OAAOA,EAAM,MAAM;EACrD,GAAIA,EAAM,gBAAgB,KAAA,IAAiD,CAAC,IAAtC,EAAE,aAAaA,EAAM,YAAY;EACvE,GAAIA,EAAM,cAAc,KAAA,IAA6C,CAAC,IAAlC,EAAE,WAAWA,EAAM,UAAU;EACjE;CACF,CAAC;AACH"}
+{"version":3,"file":"layerGroup.js","names":[],"sources":["../../../src/core/layers/layerGroup.ts"],"sourcesContent":["import type { BlendFactors, CompositeOp, DrawCommand, Effect } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport type { Dims } from './render';\n\n/**\n * Several consecutive layers composited as one.\n *\n * A layer's own `effects` run over that layer alone, which is the wrong\n * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not\n * `blur(A) over blur(B)`. A group draws its members into one buffer, runs one\n * chain over it, and composites the result back once.\n *\n * Membership is by `RenderLayer.id` — the same names `layerOrder` and\n * `layerVisibility` use, not the `layers` map's slot keys.\n *\n * Only *consecutive* members share a buffer. A group whose members are\n * separated in the render order is drawn as one bracket per run, with a\n * warning.\n *\n * This is a render-stack bracket, not a scene `ContainerNode`.\n */\nexport interface LayerGroup {\n  /** Names the group in warnings; not a layer id and never drawn. */\n  id: string;\n  /**\n   * Member layer ids. Order here is ignored — the render order decides.\n   *\n   * A name claims that layer and every layer under it in the `:` namespace, so\n   * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers\n   * draws as. The separator is required: `'scene'` does not reach `scenery`.\n   * A name matching no layer being drawn is warned about.\n   */\n  layers: readonly string[];\n  /** Passes over the group's combined pixels, in order. A thunk is re-read on\n   *  every frame, so an animating radius costs no React render. */\n  effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);\n  /** Opacity applied to the group's composited result, not to each member. */\n  alpha?: number;\n  /** 4×5 color matrix (row-major, 20 numbers) applied to the composited\n   *  result. See `GroupDrawCommand.colorMatrix`. */\n  colorMatrix?: number[];\n  /** How the composited result joins the layers under it. Default\n   *  `source-over`. See `GroupDrawCommand.composite`. */\n  composite?: CompositeOp | BlendFactors;\n}\n\n/**\n * Layer id → the group that owns it. First claim wins across groups, with a\n * warning for the second; the same group naming a layer twice — `['scene',\n * 'scene:tiles']` — passes quietly.\n */\nexport function groupMembership(\n  groups: readonly LayerGroup[] | undefined,\n  layerIds: Iterable<string>,\n): Map<string, LayerGroup> | null {\n  if (!groups || groups.length === 0) return null;\n  const stack = [...layerIds];\n  const byLayer = new Map<string, LayerGroup>();\n  for (const group of groups) {\n    for (const name of group.layers) {\n      let matched = false;\n      for (const id of stack) {\n        if (id !== name && !id.startsWith(`${name}:`)) continue;\n        matched = true;\n        const claimed = byLayer.get(id);\n        if (claimed === group) continue;\n        if (claimed) {\n          console.warn(\n            `[weasel] layer \"${id}\" is claimed by layer groups \"${claimed.id}\" and ` +\n            `\"${group.id}\"; it stays in \"${claimed.id}\".`,\n          );\n          continue;\n        }\n        byLayer.set(id, group);\n      }\n      if (!matched) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" names \"${name}\", which matches no layer ` +\n          'being drawn, so it groups nothing. Check the id against the layer stack — a ' +\n          'scene with declared layers draws as \"scene:<layerId>\", which \"scene\" covers.',\n        );\n      }\n    }\n  }\n  return byLayer;\n}\n\n/**\n * Put one run of a group's commands under its shared compositing.\n *\n * No transform: every member already carries its own space wrap, so a second\n * one here would apply the view twice to world layers and once to screen ones.\n * A group that composites plainly gets no wrapper at all.\n */\nexport function wrapGroup(\n  group: LayerGroup,\n  children: DrawCommand[],\n  view: View,\n  dims: Dims,\n): DrawCommand[] {\n  const declared = typeof group.effects === 'function'\n    ? group.effects(view, dims)\n    : group.effects;\n  const effects = declared && declared.length > 0 ? declared : undefined;\n  if (!effects && group.alpha === undefined && group.colorMatrix === undefined\n      && group.composite === undefined) return children;\n  const fades = group.alpha !== undefined && group.alpha < 1;\n  return [{\n    kind: 'group',\n    ...(effects ? { effects } : {}),\n    ...(!effects && (fades || group.colorMatrix !== undefined) ? { isolate: true } : {}),\n    ...(group.alpha !== undefined ? { alpha: group.alpha } : {}),\n    ...(group.colorMatrix !== undefined ? { colorMatrix: group.colorMatrix } : {}),\n    ...(group.composite !== undefined ? { composite: group.composite } : {}),\n    children,\n  }];\n}\n"],"mappings":";;;;;;AAmDA,SAAgB,gBACd,QACA,UACgC;CAChC,IAAI,CAAC,UAAU,OAAO,WAAW,GAAG,OAAO;CAC3C,MAAM,QAAQ,CAAC,GAAG,QAAQ;CAC1B,MAAM,0BAAU,IAAI,IAAwB;CAC5C,KAAK,MAAM,SAAS,QAClB,KAAK,MAAM,QAAQ,MAAM,QAAQ;EAC/B,IAAI,UAAU;EACd,KAAK,MAAM,MAAM,OAAO;GACtB,IAAI,OAAO,QAAQ,CAAC,GAAG,WAAW,GAAG,KAAK,EAAE,GAAG;GAC/C,UAAU;GACV,MAAM,UAAU,QAAQ,IAAI,EAAE;GAC9B,IAAI,YAAY,OAAO;GACvB,IAAI,SAAS;IACX,QAAQ,KACN,mBAAmB,GAAG,gCAAgC,QAAQ,GAAG,SAC7D,MAAM,GAAG,kBAAkB,QAAQ,GAAG,GAC5C;IACA;GACF;GACA,QAAQ,IAAI,IAAI,KAAK;EACvB;EACA,IAAI,CAAC,SACH,QAAQ,KACN,yBAAyB,MAAM,GAAG,WAAW,KAAK,mLAGpD;CAEJ;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,UACd,OACA,UACA,MACA,MACe;CACf,MAAM,WAAW,OAAO,MAAM,YAAY,aACtC,MAAM,QAAQ,MAAM,IAAI,IACxB,MAAM;CACV,MAAM,UAAU,YAAY,SAAS,SAAS,IAAI,WAAW;CAC7D,IAAI,CAAC,WAAW,MAAM,UAAU,UAAa,MAAM,gBAAgB,UAC5D,MAAM,cAAc,QAAW,OAAO;CAC7C,MAAM,QAAQ,MAAM,UAAU,UAAa,MAAM,QAAQ;CACzD,OAAO,CAAC;EACN,MAAM;EACN,GAAI,UAAU,EAAE,QAAQ,IAAI,CAAC;EAC7B,GAAI,CAAC,YAAY,SAAS,MAAM,gBAAgB,UAAa,EAAE,SAAS,KAAK,IAAI,CAAC;EAClF,GAAI,MAAM,UAAU,SAAY,EAAE,OAAO,MAAM,MAAM,IAAI,CAAC;EAC1D,GAAI,MAAM,gBAAgB,SAAY,EAAE,aAAa,MAAM,YAAY,IAAI,CAAC;EAC5E,GAAI,MAAM,cAAc,SAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;EACtE;CACF,CAAC;AACH"}

package/dist/core/layers/redrawSource.js

@@ -0,0 +1,15 @@
+//#region src/core/layers/redrawSource.ts
+/** The `subscribe` for a layer that draws `sources`: it notifies whenever any
+*  of them does. A thunk is read when the subscription is made. */
+function subscribeToSources(sources) {
+	return (listener) => {
+		const offs = (typeof sources === "function" ? sources() : sources).flatMap((l) => l.subscribe ? [l.subscribe(listener)] : []);
+		return () => {
+			for (const off of offs) off();
+		};
+	};
+}
+
+//#endregion
+export { subscribeToSources };
+//# sourceMappingURL=redrawSource.js.map

package/dist/core/layers/redrawSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redrawSource.js","names":[],"sources":["../../../src/core/layers/redrawSource.ts"],"sourcesContent":["/** Something outside React whose changes a paint reads — a mode registry, a\n *  scoping lookup. A notification repaints the canvas; the listener takes no\n *  arguments and the returned function unsubscribes. */\nexport interface RedrawSource {\n  subscribe(listener: () => void): () => void;\n}\n\n/** The `subscribe` for a layer that draws `sources`: it notifies whenever any\n *  of them does. A thunk is read when the subscription is made. */\nexport function subscribeToSources(\n  sources: readonly { subscribe?: RedrawSource['subscribe'] }[]\n    | (() => readonly { subscribe?: RedrawSource['subscribe'] }[]),\n): RedrawSource['subscribe'] {\n  return (listener) => {\n    const list = typeof sources === 'function' ? sources() : sources;\n    const offs = list.flatMap((l) => (l.subscribe ? [l.subscribe(listener)] : []));\n    return () => { for (const off of offs) off(); };\n  };\n}\n"],"mappings":";;;AASA,SAAgB,mBACd,SAE2B;CAC3B,QAAQ,aAAa;EAEnB,MAAM,QADO,OAAO,YAAY,aAAa,QAAQ,IAAI,QAC5C,CAAK,SAAS,MAAO,EAAE,YAAY,CAAC,EAAE,UAAU,QAAQ,CAAC,IAAI,CAAC,CAAE;EAC7E,aAAa;GAAE,KAAK,MAAM,OAAO,MAAM,IAAI;EAAG;CAChD;AACF"}

package/dist/core/layers/render.js

@@ -1,7 +1,10 @@
-import { groupMembership as e, wrapGroup as t } from "./layerGroup.js";
-import { viewToMat3 as n } from "@weasel-js/renderer";
+import { groupMembership, wrapGroup } from "./layerGroup.js";
+import { DEFAULT_LAYER_RETAIN, retainedId } from "./retain.js";
+import { subscribeToSources } from "./redrawSource.js";
+import { viewToMat3 } from "@weasel-js/renderer";
+
 //#region src/core/layers/render.ts
-var r = {
+var IDENTITY_VIEW = {
 	x: 0,
 	y: 0,
 	scale: {
@@ -9,116 +12,203 @@ var r = {
 		y: 1
 	}
 };
-function i({ layerId: e, error: t }) {
-	console.error(`[weasel] layer "${e}" threw while drawing; it painted nothing this frame.`, t);
-}
-function a(e) {
-	return (t) => {
-		let n = (typeof e == "function" ? e() : e).flatMap((e) => e.subscribe ? [e.subscribe(t)] : []);
-		return () => {
-			for (let e of n) e();
-		};
-	};
+/** Default report: name the layer, keep the frame. */
+function reportLayerFailure({ layerId, error }) {
+	console.error(`[weasel] layer "${layerId}" threw while drawing; it painted nothing this frame.`, error);
 }
-function o() {
-	return typeof performance < "u" ? performance.now() : Date.now();
+function clockMs() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
-function s(n, a, s, c, l, f, p, m = i, h, g) {
-	let _ = new Map(n.map((e) => [e.id, e])), v = l ?? r, y = [];
-	if (p) for (let e of [...p.keys()]) _.has(e) || p.delete(e);
-	let b = e(h, _.keys()), x = /* @__PURE__ */ new Set(), S = null, C = () => {
-		if (!S) return;
-		let e = y.length, n = g ? o() : 0;
-		for (let e of t(S.group, S.children, v, f)) y.push(e);
-		g?.push({
-			id: S.group.id,
-			start: e,
-			end: y.length,
-			buildMs: S.buildMs + o() - n
-		}), S = null;
+/**
+* Walk visible layers and concatenate their emitted DrawCommand arrays into
+* one flat list, ready to feed to `WeaselRenderer.render(commands)`.
+*
+* A layer whose `draw` throws is dropped for the frame and reported through
+* `onLayerError` — the rest of the frame still paints.
+*
+* `groups` brackets runs of consecutive layers so they composite as one — see
+* `LayerGroup`. `spans`, when passed, receives one {@link LayerDrawSpan} per
+* layer drawn. `retain` decides which unchanged layers the renderer keeps
+* as pixels between frames; `false` keeps none.
+*/
+function drawLayers(layers, data, visibility, order, view, dims, cache, onLayerError = reportLayerFailure, groups, spans, retain = DEFAULT_LAYER_RETAIN) {
+	const layerById = new Map(layers.map((l) => [l.id, l]));
+	const v = view ?? IDENTITY_VIEW;
+	const out = [];
+	if (cache) {
+		for (const id of [...cache.keys()]) if (!layerById.has(id)) cache.delete(id);
+	}
+	const groupOf = groupMembership(groups, layerById.keys());
+	const bracketed = /* @__PURE__ */ new Set();
+	let run = null;
+	const closeRun = () => {
+		if (!run) return;
+		const start = out.length;
+		const t0 = spans ? clockMs() : 0;
+		for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);
+		spans?.push({
+			id: run.group.id,
+			start,
+			end: out.length,
+			buildMs: run.buildMs + clockMs() - t0
+		});
+		run = null;
 	};
-	for (let e of u(n, s, c)) {
-		let t = g ? o() : 0, n = d(e, a, v, f, p, m), r = g ? o() - t : 0;
-		if (n.length === 0) {
-			g?.push({
-				id: e.id,
-				start: y.length,
-				end: y.length,
-				buildMs: r
+	for (const layer of paintedLayers(layers, visibility, order)) {
+		const t0 = spans ? clockMs() : 0;
+		const cmds = drawLayerOnce(layer, data, v, dims, cache, onLayerError, retain);
+		const buildMs = spans ? clockMs() - t0 : 0;
+		if (cmds.length === 0) {
+			spans?.push({
+				id: layer.id,
+				start: out.length,
+				end: out.length,
+				buildMs
 			});
 			continue;
 		}
-		let i = b?.get(e.id);
-		if (S && S.group !== i && C(), !i) {
-			let t = y.length;
-			for (let e of n) y.push(e);
-			g?.push({
-				id: e.id,
-				start: t,
-				end: y.length,
-				buildMs: r
+		const group = groupOf?.get(layer.id);
+		if (run && run.group !== group) closeRun();
+		if (!group) {
+			const start = out.length;
+			for (const c of cmds) out.push(c);
+			spans?.push({
+				id: layer.id,
+				start,
+				end: out.length,
+				buildMs
 			});
 			continue;
 		}
-		S ||= (x.has(i) && console.warn(`[weasel] layer group "${i.id}" is not one run — another layer is drawn between its members, so it composites as more than one pass over more than one buffer. Move its members together in the layer order.`), x.add(i), {
-			group: i,
-			children: [],
-			buildMs: 0
-		}), S.buildMs += r;
-		for (let e of n) S.children.push(e);
+		if (!run) {
+			if (bracketed.has(group)) console.warn(`[weasel] layer group "${group.id}" is not one run — another layer is drawn between its members, so it composites as more than one pass over more than one buffer. Move its members together in the layer order.`);
+			bracketed.add(group);
+			run = {
+				group,
+				children: [],
+				buildMs: 0
+			};
+		}
+		run.buildMs += buildMs;
+		for (const c of cmds) run.children.push(c);
 	}
-	return C(), y;
+	closeRun();
+	return out;
+}
+/**
+* Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in
+* `visibility`, then `defaultVisible`, defaulting to shown.
+*/
+function isLayerVisible(layer, visibility) {
+	if (layer.alwaysOn) return true;
+	if (layer.id in visibility) return visibility[layer.id];
+	return layer.defaultVisible ?? true;
 }
-function c(e, t) {
-	return e.alwaysOn ? !0 : e.id in t ? t[e.id] : e.defaultVisible ?? !0;
+/**
+* Does this layer reach the screen at all — membership of
+* {@link paintedLayers}, asked of one layer.
+*
+* **A listed `order` is the whole list**, so omission from it drops a layer
+* that `visibility` would have shown, and `alwaysOn` does not rescue it.
+* Hit-testing asks this, not `isLayerVisible`.
+*/
+function isLayerPainted(layer, visibility, order) {
+	if (order && !order.includes(layer.id)) return false;
+	return isLayerVisible(layer, visibility);
 }
-function l(e, t, n) {
-	return n && !n.includes(e.id) ? !1 : c(e, t);
+/**
+* The layers that reach the screen, in the order they are drawn: `order`
+* sequences them and drops what it leaves out, then `visibility` drops what is
+* hidden. What `drawLayers` paints, and what a view narrows its stack with.
+*/
+function paintedLayers(layers, visibility, order) {
+	if (!order) return layers.filter((l) => isLayerVisible(l, visibility));
+	const byId = new Map(layers.map((l) => [l.id, l]));
+	return order.map((id) => byId.get(id)).filter((l) => l !== void 0 && isLayerVisible(l, visibility));
 }
-function u(e, t, n) {
-	if (!n) return e.filter((e) => c(e, t));
-	let r = new Map(e.map((e) => [e.id, e]));
-	return n.map((e) => r.get(e)).filter((e) => e !== void 0 && c(e, t));
+/**
+* Draw one layer and put its commands in the space its `space` declares:
+* world-space output wrapped in a `viewToMat3(view)` group, screen-space
+* output passed through.
+*
+* Anything rendering layers through a view goes through here.
+*
+* A `draw` that throws yields no commands, and `onLayerError` is told which
+* layer it was. The layer's cache entry goes with it, so the next frame is a
+* real re-attempt.
+*/
+function drawOneLayer(layer, data, view, dims, cache, onLayerError = reportLayerFailure) {
+	return drawLayerOnce(layer, data, view, dims, cache, onLayerError, false);
 }
-function d(e, t, r, a, o, s = i) {
-	let c;
+function drawLayerOnce(layer, data, view, dims, cache, onLayerError, retain) {
+	let cmds;
 	try {
-		c = f(e, t, r, a, o);
-	} catch (t) {
-		return o?.delete(e.id), s({
-			layerId: e.id,
-			error: t
-		}), [];
+		cmds = layerCommands(layer, data, view, dims, cache);
+	} catch (error) {
+		cache?.delete(layer.id);
+		onLayerError({
+			layerId: layer.id,
+			error
+		});
+		return [];
 	}
-	if (c.length === 0) return [];
-	let l = e.effects && e.effects.length > 0 ? e.effects : void 0;
-	return (e.space ?? "world") === "screen" ? l ? [{
-		kind: "group",
-		effects: l,
-		children: c
-	}] : c : [{
+	if (cmds.length === 0) return [];
+	const effects = layer.effects && layer.effects.length > 0 ? layer.effects : void 0;
+	const kept = retain && !effects && cache ? retainedId(layer, cache, view, retain) : void 0;
+	const marked = kept ? { retain: kept } : {};
+	if ((layer.space ?? "world") === "screen") {
+		if (effects) return [{
+			kind: "group",
+			effects,
+			children: cmds
+		}];
+		return kept ? [{
+			kind: "group",
+			...marked,
+			children: cmds
+		}] : cmds;
+	}
+	return [{
 		kind: "group",
-		transform: n(r),
-		...l ? { effects: l } : {},
-		children: c
+		transform: viewToMat3(view),
+		...effects ? { effects } : {},
+		...marked,
+		children: cmds
 	}];
 }
-function f(e, t, n, r, i) {
-	if (!i || !e.deps) return e.draw(t, n, r);
-	let a = e.deps(t, n, r), o = i.get(e.id);
-	if (o && p(o.deps, a)) return o.cmds;
-	let s = e.draw(t, n, r);
-	return i.set(e.id, {
-		deps: a,
-		cmds: s
-	}), s;
+/**
+* One layer's own commands, from cache when its deps are unchanged.
+*
+* What is cached is the layer's raw output, before the space wrap above. The
+* wrap is a function of `view`, and a layer whose content does not depend on
+* the camera is entitled to leave `view` out of its deps — caching the wrapped
+* group would then serve a stale transform the moment the camera moved.
+*/
+function layerCommands(layer, data, view, dims, cache) {
+	if (!cache || !layer.deps) return layer.draw(data, view, dims);
+	const deps = layer.deps(data, view, dims);
+	const entry = cache.get(layer.id);
+	if (entry && depsUnchanged(entry.deps, deps)) {
+		entry.reused = true;
+		return entry.cmds;
+	}
+	const cmds = layer.draw(data, view, dims);
+	cache.set(layer.id, {
+		deps,
+		cmds,
+		reused: false,
+		view: entry?.view
+	});
+	return cmds;
 }
-function p(e, t) {
-	if (e.length !== t.length) return !1;
-	for (let n = 0; n < e.length; n++) if (!Object.is(e[n], t[n])) return !1;
-	return !0;
+/** Whether `b` matches `a` entry for entry under `Object.is` — how
+*  `RenderLayer.deps` is compared, and any cache keyed the same way. */
+function depsUnchanged(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+	return true;
 }
-//#endregion
-export { p as depsUnchanged, s as drawLayers, d as drawOneLayer, l as isLayerPainted, c as isLayerVisible, u as paintedLayers, a as subscribeToSources };
 
+//#endregion
+export { DEFAULT_LAYER_RETAIN, depsUnchanged, drawLayers, drawOneLayer, isLayerPainted, isLayerVisible, paintedLayers, subscribeToSources };
 //# sourceMappingURL=render.js.map

package/dist/core/layers/render.js.map

@@ -1 +1 @@
-{"version":3,"file":"render.js","names":["IDENTITY_VIEW","reportLayerFailure","layerId","error","subscribeToSources","offs","sources","l","listener","off","clockMs","drawLayers","layerById","layers","view","out","cache","id","groupOf","groupMembership","groups","bracketed","run","closeRun","start","t0","spans","c","wrapGroup","dims","layer","paintedLayers","visibility","order","cmds","drawOneLayer","data","onLayerError","buildMs","group","isLayerVisible","isLayerPainted","byId","layerCommands","effects","viewToMat3","deps","entry","depsUnchanged","a","b","i"],"sources":["../../../src/core/layers/render.ts"],"sourcesContent":["import { viewToMat3, type DrawCommand } from '@weasel-js/renderer';\nimport type { Effect } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { groupMembership, wrapGroup, type LayerGroup } from './layerGroup';\n\nexport type { LayerGroup };\n\nconst IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/** Canvas size in CSS pixels, so layers don't have to know about DPR. */\nexport interface Dims {\n  width: number;\n  height: number;\n}\n\n/**\n * What a layer's `draw` threw, and which layer threw it. A throw that escaped\n * the frame loop would take the whole frame with it, every other layer\n * included.\n */\nexport interface LayerDrawFailure {\n  layerId: string;\n  error: unknown;\n}\n\n/** Default report: name the layer, keep the frame. */\nfunction reportLayerFailure({ layerId, error }: LayerDrawFailure): void {\n  console.error(\n    `[weasel] layer \"${layerId}\" threw while drawing; it painted nothing this frame.`,\n    error,\n  );\n}\n\n/** One layer's memoized output, keyed by layer id. Owned by the canvas that\n *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */\nexport type LayerCommandCache = Map<\n  string,\n  { deps: readonly unknown[]; cmds: DrawCommand[] }\n>;\n\n/** Something outside React whose changes a paint reads — a mode registry, a\n *  scoping lookup. A notification repaints the canvas; the listener takes no\n *  arguments and the returned function unsubscribes. */\nexport interface RedrawSource {\n  subscribe(listener: () => void): () => void;\n}\n\n/** The `subscribe` for a layer that draws `sources`: it notifies whenever any\n *  of them does. A thunk is read when the subscription is made. */\nexport function subscribeToSources(\n  sources: readonly { subscribe?: RedrawSource['subscribe'] }[]\n    | (() => readonly { subscribe?: RedrawSource['subscribe'] }[]),\n): RedrawSource['subscribe'] {\n  return (listener) => {\n    const list = typeof sources === 'function' ? sources() : sources;\n    const offs = list.flatMap((l) => (l.subscribe ? [l.subscribe(listener)] : []));\n    return () => { for (const off of offs) off(); };\n  };\n}\n\n/**\n * One layer of a canvas: `draw` turns `data` and the view into draw commands;\n * the other fields control caching, visibility, coordinate space and hit-testing.\n *\n * @template TData - The data object passed to each draw call.\n */\nexport interface RenderLayer<TData> {\n  /** Unique identifier used in visibility maps and ordering arrays. When a\n   *  cache is in use, an id must identify the same logical layer across\n   *  frames — reusing it for a different layer can serve cross-layer commands. */\n  id: string;\n  /** Human-readable name for UI toggles. */\n  label: string;\n  /**\n   * Emit a DrawCommand tree, in the coordinates `space` names. A world-space\n   * layer must NOT apply the view transform itself.\n   */\n  draw: (data: TData, view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Optional cache key. When present and a `LayerCommandCache` is supplied to\n   * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as\n   * every entry is `Object.is`-equal to the previous call's. A layer with no\n   * `deps` rebuilds on every frame.\n   *\n   * **The returned commands must be treated as immutable.** A cached tree is\n   * handed to the renderer again on later frames, so mutating a tree you\n   * previously returned corrupts the cache silently rather than erroring.\n   *\n   * **Screen-space layers are not protected against a stale `view`/`dims`\n   * the way world-space layers are** (see `space` below) — include them in\n   * `deps` if `draw` reads them.\n   */\n  deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];\n  /** Whether the layer is shown when no explicit visibility entry exists.\n   *  Defaults to `true` when absent. */\n  defaultVisible?: boolean;\n  /** When true, the layer is always drawn regardless of the visibility map. */\n  alwaysOn?: boolean;\n  /**\n   * Coordinate space the layer draws in.\n   *\n   * - `'world'` (default): the layer's `draw` returns world-space commands;\n   *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`\n   *   automatically.\n   * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)\n   *   commands; `drawLayers` passes them through unchanged. World-anchored\n   *   chrome inside a screen-space layer must call `worldToScreen` or wrap\n   *   the relevant subset with `viewToMat3(view)` manually.\n   */\n  space?: 'world' | 'screen';\n  /**\n   * Where the layer learns that state `draw` reads, outside the scene and the\n   * props, has changed. The canvas painting it subscribes while the layer is\n   * mounted and repaints on every notification.\n   */\n  subscribe?: RedrawSource['subscribe'];\n  /**\n   * Full-screen passes run over this layer's own pixels before it joins the\n   * frame. See `GroupDrawCommand.effects` for what a pass may read, and\n   * {@link LayerGroup} to run one chain over several layers at once.\n   */\n  effects?: readonly Effect[];\n  /**\n   * Optional hit-test for **consumer-attached** layers.\n   *\n   * Only layers registered through `CanvasExtensionApi.registerLayer` are\n   * hit-tested, last-registered-first, ahead of the kit's own selection\n   * chrome. First non-null result wins; null means \"I don't claim this hit,\n   * try the next layer.\"\n   *\n   * Layers that reach the draw stack some other way — a `Tool.overlay`, an\n   * entry in the `layers` map — are painted but never hit-tested, so defining\n   * `hitTest` on one has no effect.\n   *\n   * Coordinates are world-space.\n   */\n  hitTest?: (\n    worldX: number,\n    worldY: number,\n    data: TData,\n    view: View,\n    dims: Dims,\n    /** Chrome-caps visibility predicate. When supplied, the layer must\n     *  not return a hit from any chrome element whose id reports\n     *  `false`. Absent → every element is hittable. */\n    isVisible?: (id: string) => boolean,\n  ) => import('../../affordances/types').LayerHit | null;\n  /**\n   * Called on every pointermove when no gesture is currently captured, so a\n   * layer can track hover state. Coords are world-space, and the layer does\n   * its own throttling.\n   */\n  onUncapturedMove?: (\n    worldX: number,\n    worldY: number,\n    evt: PointerEvent,\n    view: View,\n    dims: Dims,\n  ) => void;\n  /** Called when the cursor leaves the canvas element. */\n  onUncapturedLeave?: () => void;\n}\n\n/** Where one layer's commands landed in {@link drawLayers}' output,\n *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's\n *  run is one span under the group's id. */\nexport interface LayerDrawSpan {\n  id: string;\n  start: number;\n  end: number;\n  buildMs: number;\n}\n\nfunction clockMs(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/**\n * Walk visible layers and concatenate their emitted DrawCommand arrays into\n * one flat list, ready to feed to `WeaselRenderer.render(commands)`.\n *\n * A layer whose `draw` throws is dropped for the frame and reported through\n * `onLayerError` — the rest of the frame still paints.\n *\n * `groups` brackets runs of consecutive layers so they composite as one — see\n * `LayerGroup`. `spans`, when passed, receives one {@link LayerDrawSpan} per\n * layer drawn.\n */\nexport function drawLayers<TData>(\n  layers: RenderLayer<TData>[],\n  data: TData,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n  view: View | undefined,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n  groups?: readonly LayerGroup[],\n  spans?: LayerDrawSpan[],\n): DrawCommand[] {\n  const layerById = new Map(layers.map((l) => [l.id, l]));\n  const v = view ?? IDENTITY_VIEW;\n  const out: DrawCommand[] = [];\n\n  if (cache) {\n    for (const id of [...cache.keys()]) {\n      if (!layerById.has(id)) cache.delete(id);\n    }\n  }\n\n  const groupOf = groupMembership(groups, layerById.keys());\n  const bracketed = new Set<LayerGroup>();\n  let run: { group: LayerGroup; children: DrawCommand[]; buildMs: number } | null = null;\n\n  const closeRun = () => {\n    if (!run) return;\n    const start = out.length;\n    const t0 = spans ? clockMs() : 0;\n    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);\n    spans?.push({ id: run.group.id, start, end: out.length, buildMs: run.buildMs + clockMs() - t0 });\n    run = null;\n  };\n\n  for (const layer of paintedLayers(layers, visibility, order)) {\n    const t0 = spans ? clockMs() : 0;\n    const cmds = drawOneLayer(layer, data, v, dims, cache, onLayerError);\n    const buildMs = spans ? clockMs() - t0 : 0;\n    // A layer that painted nothing neither joins a run nor breaks one.\n    if (cmds.length === 0) {\n      spans?.push({ id: layer.id, start: out.length, end: out.length, buildMs });\n      continue;\n    }\n\n    const group = groupOf?.get(layer.id);\n    if (run && run.group !== group) closeRun();\n    if (!group) {\n      const start = out.length;\n      for (const c of cmds) out.push(c);\n      spans?.push({ id: layer.id, start, end: out.length, buildMs });\n      continue;\n    }\n    if (!run) {\n      if (bracketed.has(group)) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" is not one run — another layer is drawn ` +\n          'between its members, so it composites as more than one pass over more than ' +\n          'one buffer. Move its members together in the layer order.',\n        );\n      }\n      bracketed.add(group);\n      run = { group, children: [], buildMs: 0 };\n    }\n    run.buildMs += buildMs;\n    for (const c of cmds) run.children.push(c);\n  }\n  closeRun();\n\n  return out;\n}\n\n/**\n * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in\n * `visibility`, then `defaultVisible`, defaulting to shown.\n */\nexport function isLayerVisible<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n): boolean {\n  if (layer.alwaysOn) return true;\n  if (layer.id in visibility) return visibility[layer.id]!;\n  return layer.defaultVisible ?? true;\n}\n\n/**\n * Does this layer reach the screen at all — membership of\n * {@link paintedLayers}, asked of one layer.\n *\n * **A listed `order` is the whole list**, so omission from it drops a layer\n * that `visibility` would have shown, and `alwaysOn` does not rescue it.\n * Hit-testing asks this, not `isLayerVisible`.\n */\nexport function isLayerPainted<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n  order: readonly string[] | undefined,\n): boolean {\n  if (order && !order.includes(layer.id)) return false;\n  return isLayerVisible(layer, visibility);\n}\n\n/**\n * The layers that reach the screen, in the order they are drawn: `order`\n * sequences them and drops what it leaves out, then `visibility` drops what is\n * hidden. What `drawLayers` paints, and what a view narrows its stack with.\n */\nexport function paintedLayers<TData>(\n  layers: readonly RenderLayer<TData>[],\n  visibility: Record<string, boolean>,\n  order: readonly string[] | undefined,\n): RenderLayer<TData>[] {\n  if (!order) return layers.filter((l) => isLayerVisible(l, visibility));\n  const byId = new Map(layers.map((l) => [l.id, l]));\n  return order\n    .map((id) => byId.get(id))\n    .filter((l): l is RenderLayer<TData> => l !== undefined && isLayerVisible(l, visibility));\n}\n\n/**\n * Draw one layer and put its commands in the space its `space` declares:\n * world-space output wrapped in a `viewToMat3(view)` group, screen-space\n * output passed through.\n *\n * Anything rendering layers through a view goes through here.\n *\n * A `draw` that throws yields no commands, and `onLayerError` is told which\n * layer it was. The layer's cache entry goes with it, so the next frame is a\n * real re-attempt.\n */\nexport function drawOneLayer<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n): DrawCommand[] {\n  let cmds: DrawCommand[];\n  try {\n    cmds = layerCommands(layer, data, view, dims, cache);\n  } catch (error) {\n    cache?.delete(layer.id);\n    onLayerError({ layerId: layer.id, error });\n    return [];\n  }\n  if (cmds.length === 0) return [];\n  const effects = layer.effects && layer.effects.length > 0 ? layer.effects : undefined;\n  if ((layer.space ?? 'world') === 'screen') {\n    return effects ? [{ kind: 'group', effects, children: cmds }] : cmds;\n  }\n  return [{ kind: 'group', transform: viewToMat3(view), ...(effects ? { effects } : {}), children: cmds }];\n}\n\n/**\n * One layer's own commands, from cache when its deps are unchanged.\n *\n * What is cached is the layer's raw output, before the space wrap above. The\n * wrap is a function of `view`, and a layer whose content does not depend on\n * the camera is entitled to leave `view` out of its deps — caching the wrapped\n * group would then serve a stale transform the moment the camera moved.\n */\nfunction layerCommands<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache: LayerCommandCache | undefined,\n): DrawCommand[] {\n  if (!cache || !layer.deps) return layer.draw(data, view, dims);\n\n  const deps = layer.deps(data, view, dims);\n  const entry = cache.get(layer.id);\n  if (entry && depsUnchanged(entry.deps, deps)) return entry.cmds;\n\n  const cmds = layer.draw(data, view, dims);\n  cache.set(layer.id, { deps, cmds });\n  return cmds;\n}\n\n/** Whether `b` matches `a` entry for entry under `Object.is` — how\n *  `RenderLayer.deps` is compared, and any cache keyed the same way. */\nexport function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"render.js","names":[],"sources":["../../../src/core/layers/render.ts"],"sourcesContent":["import { viewToMat3, type DrawCommand } from '@weasel-js/renderer';\nimport type { Effect } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { groupMembership, wrapGroup, type LayerGroup } from './layerGroup';\nimport { DEFAULT_LAYER_RETAIN, retainedId, type LayerRetainPolicy } from './retain';\nimport type { RedrawSource } from './redrawSource';\n\nexport type { LayerGroup, LayerRetainPolicy };\nexport { DEFAULT_LAYER_RETAIN };\nexport { subscribeToSources, type RedrawSource } from './redrawSource';\n\nconst IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/** Canvas size in CSS pixels, so layers don't have to know about DPR. */\nexport interface Dims {\n  width: number;\n  height: number;\n}\n\n/**\n * What a layer's `draw` threw, and which layer threw it. A throw that escaped\n * the frame loop would take the whole frame with it, every other layer\n * included.\n */\nexport interface LayerDrawFailure {\n  layerId: string;\n  error: unknown;\n}\n\n/** Default report: name the layer, keep the frame. */\nfunction reportLayerFailure({ layerId, error }: LayerDrawFailure): void {\n  console.error(\n    `[weasel] layer \"${layerId}\" threw while drawing; it painted nothing this frame.`,\n    error,\n  );\n}\n\n/** One layer's memoized output, keyed by layer id. Owned by the canvas that\n *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */\nexport type LayerCommandCache = Map<\n  string,\n  {\n    deps: readonly unknown[];\n    cmds: DrawCommand[];\n    /** Whether the last frame served `cmds` from here rather than drawing. */\n    reused?: boolean;\n    /** The view the last frame drew under. */\n    view?: View;\n  }\n>;\n\n/**\n * One layer of a canvas: `draw` turns `data` and the view into draw commands;\n * the other fields control caching, visibility, coordinate space and hit-testing.\n *\n * @template TData - The data object passed to each draw call.\n */\nexport interface RenderLayer<TData> {\n  /** Unique identifier used in visibility maps and ordering arrays. When a\n   *  cache is in use, an id must identify the same logical layer across\n   *  frames — reusing it for a different layer can serve cross-layer commands. */\n  id: string;\n  /** Human-readable name for UI toggles. */\n  label: string;\n  /**\n   * Emit a DrawCommand tree, in the coordinates `space` names. A world-space\n   * layer must NOT apply the view transform itself.\n   */\n  draw: (data: TData, view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Optional cache key. When present and a `LayerCommandCache` is supplied to\n   * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as\n   * every entry is `Object.is`-equal to the previous call's. A layer with no\n   * `deps` rebuilds on every frame.\n   *\n   * **The returned commands must be treated as immutable.** A cached tree is\n   * handed to the renderer again on later frames, so mutating a tree you\n   * previously returned corrupts the cache silently rather than erroring.\n   *\n   * **Screen-space layers are not protected against a stale `view`/`dims`\n   * the way world-space layers are** (see `space` below) — include them in\n   * `deps` if `draw` reads them.\n   */\n  deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];\n  /** Whether the layer is shown when no explicit visibility entry exists.\n   *  Defaults to `true` when absent. */\n  defaultVisible?: boolean;\n  /** When true, the layer is always drawn regardless of the visibility map. */\n  alwaysOn?: boolean;\n  /**\n   * Coordinate space the layer draws in.\n   *\n   * - `'world'` (default): the layer's `draw` returns world-space commands;\n   *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`\n   *   automatically.\n   * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)\n   *   commands; `drawLayers` passes them through unchanged. World-anchored\n   *   chrome inside a screen-space layer must call `worldToScreen` or wrap\n   *   the relevant subset with `viewToMat3(view)` manually.\n   */\n  space?: 'world' | 'screen';\n  /**\n   * Where the layer learns that state `draw` reads, outside the scene and the\n   * props, has changed. The canvas painting it subscribes while the layer is\n   * mounted and repaints on every notification.\n   */\n  subscribe?: RedrawSource['subscribe'];\n  /**\n   * Full-screen passes run over this layer's own pixels before it joins the\n   * frame. See `GroupDrawCommand.effects` for what a pass may read, and\n   * {@link LayerGroup} to run one chain over several layers at once.\n   */\n  effects?: readonly Effect[];\n  /**\n   * Whether the renderer may keep this layer's pixels between frames and\n   * composite them as one quad instead of drawing its commands again — see\n   * {@link LayerRetainPolicy} for when `drawLayers` does. `false` never\n   * retains it, `true` retains it whatever its size; either way only a layer\n   * with `deps`, drawn through a cache, and without `effects`.\n   */\n  retain?: boolean;\n  /**\n   * Optional hit-test for **consumer-attached** layers.\n   *\n   * Only layers registered through `CanvasExtensionApi.registerLayer` are\n   * hit-tested, last-registered-first, ahead of the kit's own selection\n   * chrome. First non-null result wins; null means \"I don't claim this hit,\n   * try the next layer.\"\n   *\n   * Layers that reach the draw stack some other way — a `Tool.overlay`, an\n   * entry in the `layers` map — are painted but never hit-tested, so defining\n   * `hitTest` on one has no effect.\n   *\n   * Coordinates are world-space.\n   */\n  hitTest?: (\n    worldX: number,\n    worldY: number,\n    data: TData,\n    view: View,\n    dims: Dims,\n    /** Chrome-caps visibility predicate. When supplied, the layer must\n     *  not return a hit from any chrome element whose id reports\n     *  `false`. Absent → every element is hittable. */\n    isVisible?: (id: string) => boolean,\n  ) => import('../../affordances/types').LayerHit | null;\n  /**\n   * Called on every pointermove when no gesture is currently captured, so a\n   * layer can track hover state. Coords are world-space, and the layer does\n   * its own throttling.\n   */\n  onUncapturedMove?: (\n    worldX: number,\n    worldY: number,\n    evt: PointerEvent,\n    view: View,\n    dims: Dims,\n  ) => void;\n  /** Called when the cursor leaves the canvas element. */\n  onUncapturedLeave?: () => void;\n}\n\n/** Where one layer's commands landed in {@link drawLayers}' output,\n *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's\n *  run is one span under the group's id. */\nexport interface LayerDrawSpan {\n  id: string;\n  start: number;\n  end: number;\n  buildMs: number;\n}\n\nfunction clockMs(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/**\n * Walk visible layers and concatenate their emitted DrawCommand arrays into\n * one flat list, ready to feed to `WeaselRenderer.render(commands)`.\n *\n * A layer whose `draw` throws is dropped for the frame and reported through\n * `onLayerError` — the rest of the frame still paints.\n *\n * `groups` brackets runs of consecutive layers so they composite as one — see\n * `LayerGroup`. `spans`, when passed, receives one {@link LayerDrawSpan} per\n * layer drawn. `retain` decides which unchanged layers the renderer keeps\n * as pixels between frames; `false` keeps none.\n */\nexport function drawLayers<TData>(\n  layers: RenderLayer<TData>[],\n  data: TData,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n  view: View | undefined,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n  groups?: readonly LayerGroup[],\n  spans?: LayerDrawSpan[],\n  retain: LayerRetainPolicy | false = DEFAULT_LAYER_RETAIN,\n): DrawCommand[] {\n  const layerById = new Map(layers.map((l) => [l.id, l]));\n  const v = view ?? IDENTITY_VIEW;\n  const out: DrawCommand[] = [];\n\n  if (cache) {\n    for (const id of [...cache.keys()]) {\n      if (!layerById.has(id)) cache.delete(id);\n    }\n  }\n\n  const groupOf = groupMembership(groups, layerById.keys());\n  const bracketed = new Set<LayerGroup>();\n  let run: { group: LayerGroup; children: DrawCommand[]; buildMs: number } | null = null;\n\n  const closeRun = () => {\n    if (!run) return;\n    const start = out.length;\n    const t0 = spans ? clockMs() : 0;\n    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);\n    spans?.push({ id: run.group.id, start, end: out.length, buildMs: run.buildMs + clockMs() - t0 });\n    run = null;\n  };\n\n  for (const layer of paintedLayers(layers, visibility, order)) {\n    const t0 = spans ? clockMs() : 0;\n    const cmds = drawLayerOnce(layer, data, v, dims, cache, onLayerError, retain);\n    const buildMs = spans ? clockMs() - t0 : 0;\n    // A layer that painted nothing neither joins a run nor breaks one.\n    if (cmds.length === 0) {\n      spans?.push({ id: layer.id, start: out.length, end: out.length, buildMs });\n      continue;\n    }\n\n    const group = groupOf?.get(layer.id);\n    if (run && run.group !== group) closeRun();\n    if (!group) {\n      const start = out.length;\n      for (const c of cmds) out.push(c);\n      spans?.push({ id: layer.id, start, end: out.length, buildMs });\n      continue;\n    }\n    if (!run) {\n      if (bracketed.has(group)) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" is not one run — another layer is drawn ` +\n          'between its members, so it composites as more than one pass over more than ' +\n          'one buffer. Move its members together in the layer order.',\n        );\n      }\n      bracketed.add(group);\n      run = { group, children: [], buildMs: 0 };\n    }\n    run.buildMs += buildMs;\n    for (const c of cmds) run.children.push(c);\n  }\n  closeRun();\n\n  return out;\n}\n\n/**\n * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in\n * `visibility`, then `defaultVisible`, defaulting to shown.\n */\nexport function isLayerVisible<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n): boolean {\n  if (layer.alwaysOn) return true;\n  if (layer.id in visibility) return visibility[layer.id]!;\n  return layer.defaultVisible ?? true;\n}\n\n/**\n * Does this layer reach the screen at all — membership of\n * {@link paintedLayers}, asked of one layer.\n *\n * **A listed `order` is the whole list**, so omission from it drops a layer\n * that `visibility` would have shown, and `alwaysOn` does not rescue it.\n * Hit-testing asks this, not `isLayerVisible`.\n */\nexport function isLayerPainted<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n  order: readonly string[] | undefined,\n): boolean {\n  if (order && !order.includes(layer.id)) return false;\n  return isLayerVisible(layer, visibility);\n}\n\n/**\n * The layers that reach the screen, in the order they are drawn: `order`\n * sequences them and drops what it leaves out, then `visibility` drops what is\n * hidden. What `drawLayers` paints, and what a view narrows its stack with.\n */\nexport function paintedLayers<TData>(\n  layers: readonly RenderLayer<TData>[],\n  visibility: Record<string, boolean>,\n  order: readonly string[] | undefined,\n): RenderLayer<TData>[] {\n  if (!order) return layers.filter((l) => isLayerVisible(l, visibility));\n  const byId = new Map(layers.map((l) => [l.id, l]));\n  return order\n    .map((id) => byId.get(id))\n    .filter((l): l is RenderLayer<TData> => l !== undefined && isLayerVisible(l, visibility));\n}\n\n/**\n * Draw one layer and put its commands in the space its `space` declares:\n * world-space output wrapped in a `viewToMat3(view)` group, screen-space\n * output passed through.\n *\n * Anything rendering layers through a view goes through here.\n *\n * A `draw` that throws yields no commands, and `onLayerError` is told which\n * layer it was. The layer's cache entry goes with it, so the next frame is a\n * real re-attempt.\n */\nexport function drawOneLayer<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n): DrawCommand[] {\n  return drawLayerOnce(layer, data, view, dims, cache, onLayerError, false);\n}\n\nfunction drawLayerOnce<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache: LayerCommandCache | undefined,\n  onLayerError: (failure: LayerDrawFailure) => void,\n  retain: LayerRetainPolicy | false,\n): DrawCommand[] {\n  let cmds: DrawCommand[];\n  try {\n    cmds = layerCommands(layer, data, view, dims, cache);\n  } catch (error) {\n    cache?.delete(layer.id);\n    onLayerError({ layerId: layer.id, error });\n    return [];\n  }\n  if (cmds.length === 0) return [];\n  const effects = layer.effects && layer.effects.length > 0 ? layer.effects : undefined;\n  const kept = retain && !effects && cache ? retainedId(layer, cache, view, retain) : undefined;\n  const marked = kept ? { retain: kept } : {};\n  if ((layer.space ?? 'world') === 'screen') {\n    if (effects) return [{ kind: 'group', effects, children: cmds }];\n    return kept ? [{ kind: 'group', ...marked, children: cmds }] : cmds;\n  }\n  return [{ kind: 'group', transform: viewToMat3(view), ...(effects ? { effects } : {}), ...marked, children: cmds }];\n}\n\n/**\n * One layer's own commands, from cache when its deps are unchanged.\n *\n * What is cached is the layer's raw output, before the space wrap above. The\n * wrap is a function of `view`, and a layer whose content does not depend on\n * the camera is entitled to leave `view` out of its deps — caching the wrapped\n * group would then serve a stale transform the moment the camera moved.\n */\nfunction layerCommands<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache: LayerCommandCache | undefined,\n): DrawCommand[] {\n  if (!cache || !layer.deps) return layer.draw(data, view, dims);\n\n  const deps = layer.deps(data, view, dims);\n  const entry = cache.get(layer.id);\n  if (entry && depsUnchanged(entry.deps, deps)) {\n    entry.reused = true;\n    return entry.cmds;\n  }\n\n  const cmds = layer.draw(data, view, dims);\n  cache.set(layer.id, { deps, cmds, reused: false, view: entry?.view });\n  return cmds;\n}\n\n/** Whether `b` matches `a` entry for entry under `Object.is` — how\n *  `RenderLayer.deps` is compared, and any cache keyed the same way. */\nexport function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}