@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/geometry/unionBounds.js

@@ -1,61 +1,116 @@
-import { applyToPoint as e, poseFrameOf as t } from "@weasel-js/geom";
+import { applyToPoint, poseFrameOf } from "@weasel-js/geom";
+
 //#region src/core/geometry/unionBounds.ts
-function n(e) {
-	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity, a = !1;
-	for (let o of e) {
-		a = !0, o.x < t && (t = o.x), o.y < n && (n = o.y);
-		let e = o.x + o.width, s = o.y + o.height;
-		e > r && (r = e), s > i && (i = s);
+/**
+* Union math over rect-shaped poses.
+*
+* Two answers, deliberately distinct. `unionBounds` folds the *unrotated*
+* boxes and is what commit-time actions want, because they go on to write
+* poses back in that same frame. `unionAABB` expands each rotated member to
+* the extent of its ink first, and is what anything a user looks at or clicks
+* wants — selection chrome, gesture bounds, an export viewBox. Folding the
+* unrotated box there under-reports the extent of a rotated member exactly
+* when the consumer is watching it move.
+*/
+/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any
+*  rotation they carry. See the module docstring before reaching for this
+*  over {@link unionAABB}. */
+function unionBounds(poses) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let any = false;
+	for (const p of poses) {
+		any = true;
+		if (p.x < minX) minX = p.x;
+		if (p.y < minY) minY = p.y;
+		const right = p.x + p.width;
+		const bottom = p.y + p.height;
+		if (right > maxX) maxX = right;
+		if (bottom > maxY) maxY = bottom;
 	}
-	return a ? {
-		x: t,
-		y: n,
-		width: r - t,
-		height: i - n
-	} : null;
+	if (!any) return null;
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
 }
-function r(n) {
-	let r = t(n);
-	if (!r) return {
-		x: n.x,
-		y: n.y,
-		width: n.width,
-		height: n.height
+/**
+* Axis-align a pose that carries a `rotation` or a `transform`: returns the
+* AABB of the box as drawn, its four corners through `poseFrameOf`, with both
+* fields dropped.
+*
+* A pose with neither is returned as-is.
+*/
+function axisAlignedBounds(b) {
+	const frame = poseFrameOf(b);
+	if (!frame) return {
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
 	};
-	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity, c = [
-		[n.x, n.y],
-		[n.x + n.width, n.y],
-		[n.x + n.width, n.y + n.height],
-		[n.x, n.y + n.height]
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const corners = [
+		[b.x, b.y],
+		[b.x + b.width, b.y],
+		[b.x + b.width, b.y + b.height],
+		[b.x, b.y + b.height]
 	];
-	for (let [t, n] of c) {
-		let [c, l] = e(r, t, n);
-		c < i && (i = c), c > o && (o = c), l < a && (a = l), l > s && (s = l);
+	for (const [px, py] of corners) {
+		const [rx, ry] = applyToPoint(frame, px, py);
+		if (rx < minX) minX = rx;
+		if (rx > maxX) maxX = rx;
+		if (ry < minY) minY = ry;
+		if (ry > maxY) maxY = ry;
 	}
 	return {
-		x: i,
-		y: a,
-		width: o - i,
-		height: s - a
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
 	};
 }
-function i(e) {
-	let t = Infinity, n = Infinity, i = -Infinity, a = -Infinity, o = !1;
-	for (let s of e) {
-		if (!s) continue;
-		let e = r(s);
-		o = !0, e.x < t && (t = e.x), e.y < n && (n = e.y);
-		let c = e.x + e.width, l = e.y + e.height;
-		c > i && (i = c), l > a && (a = l);
+/**
+* Fold every part into one world-space AABB, skipping `null` / `undefined`
+* entries. Rotated parts are expanded via {@link axisAlignedBounds} first;
+* the result never carries a `rotation` (a union of several oriented boxes
+* has no single orientation to report).
+*
+* Returns `null` when nothing was contributed.
+*/
+function unionAABB(parts) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let any = false;
+	for (const part of parts) {
+		if (!part) continue;
+		const b = axisAlignedBounds(part);
+		any = true;
+		if (b.x < minX) minX = b.x;
+		if (b.y < minY) minY = b.y;
+		const right = b.x + b.width;
+		const bottom = b.y + b.height;
+		if (right > maxX) maxX = right;
+		if (bottom > maxY) maxY = bottom;
 	}
-	return o ? {
-		x: t,
-		y: n,
-		width: i - t,
-		height: a - n
-	} : null;
+	if (!any) return null;
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
 }
-//#endregion
-export { r as axisAlignedBounds, i as unionAABB, n as unionBounds };
 
+//#endregion
+export { axisAlignedBounds, unionAABB, unionBounds };
 //# sourceMappingURL=unionBounds.js.map

package/dist/core/geometry/unionBounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"unionBounds.js","names":["unionBounds","minX","minY","maxX","maxY","any","p","poses","right","bottom","axisAlignedBounds","frame","poseFrameOf","b","corners","px","py","rx","ry","applyToPoint","unionAABB","part","parts"],"sources":["../../../src/core/geometry/unionBounds.ts"],"sourcesContent":["/**\n * Union math over rect-shaped poses.\n *\n * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*\n * boxes and is what commit-time actions want, because they go on to write\n * poses back in that same frame. `unionAABB` expands each rotated member to\n * the extent of its ink first, and is what anything a user looks at or clicks\n * wants — selection chrome, gesture bounds, an export viewBox. Folding the\n * unrotated box there under-reports the extent of a rotated member exactly\n * when the consumer is watching it move.\n */\n\nimport { applyToPoint } from '@weasel-js/geom';\nimport type { RectPose } from 'core/scene/types';\nimport { poseFrameOf } from '@weasel-js/geom';\nexport type { RectPose };\n\n/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any\n *  rotation they carry. See the module docstring before reaching for this\n *  over {@link unionAABB}. */\nexport function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const p of poses) {\n    any = true;\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    const right = p.x + p.width;\n    const bottom = p.y + p.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Axis-align a pose that carries a `rotation` or a `transform`: returns the\n * AABB of the box as drawn, its four corners through `poseFrameOf`, with both\n * fields dropped.\n *\n * A pose with neither is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const frame = poseFrameOf(b);\n  if (!frame) {\n    // Strip an explicit `rotation: 0` so callers can rely on the absence of\n    // the field meaning \"axis-aligned\".\n    return { x: b.x, y: b.y, width: b.width, height: b.height };\n  }\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  const corners: ReadonlyArray<readonly [number, number]> = [\n    [b.x, b.y],\n    [b.x + b.width, b.y],\n    [b.x + b.width, b.y + b.height],\n    [b.x, b.y + b.height],\n  ];\n  for (const [px, py] of corners) {\n    const [rx, ry] = applyToPoint(frame, px, py);\n    if (rx < minX) minX = rx;\n    if (rx > maxX) maxX = rx;\n    if (ry < minY) minY = ry;\n    if (ry > maxY) maxY = ry;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Fold every part into one world-space AABB, skipping `null` / `undefined`\n * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;\n * the result never carries a `rotation` (a union of several oriented boxes\n * has no single orientation to report).\n *\n * Returns `null` when nothing was contributed.\n */\nexport function unionAABB<TPose extends RectPose>(\n  parts: Iterable<TPose | null | undefined>,\n): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const part of parts) {\n    if (!part) continue;\n    const b = axisAlignedBounds(part);\n    any = true;\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":";;AAoBA,SAAgBA,EAAoC,GAAyC;CAC3F,IAAIC,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMC,KAAKC,GAAO;EAGrB,AAFA,IAAM,IACFD,EAAE,IAAIL,MAAM,IAAOK,EAAE,IACrBA,EAAE,IAAIJ,MAAM,IAAOI,EAAE;EACzB,IAAME,IAAQF,EAAE,IAAIA,EAAE,OAChBG,IAASH,EAAE,IAAIA,EAAE;EAEvB,AADIE,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB;AASA,SAAgBQ,EAA0C,GAAoB;CAC5E,IAAMC,IAAQC,EAAYC,CAAC;CAC3B,IAAI,CAACF,GAGH,OAAO;EAAE,GAAGE,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CAE5D,IAAIZ,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACLU,IAAoD;EACxD,CAACD,EAAE,GAAGA,EAAE,CAAC;EACT,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,CAAC;EACnB,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,IAAIA,EAAE,MAAM;EAC9B,CAACA,EAAE,GAAGA,EAAE,IAAIA,EAAE,MAAM;CACtB;CACA,KAAK,IAAM,CAACE,GAAIC,MAAOF,GAAS;EAC9B,IAAM,CAACG,GAAIC,KAAMC,EAAaR,GAAOI,GAAIC,CAAE;EAI3C,AAHIC,IAAKhB,MAAM,IAAOgB,IAClBA,IAAKd,MAAM,IAAOc,IAClBC,IAAKhB,MAAM,IAAOgB,IAClBA,IAAKd,MAAM,IAAOc;CACxB;CACA,OAAO;EAAE,GAAGjB;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE;AAUA,SAAgBkB,EACd,GACiB;CACjB,IAAInB,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMgB,KAAQC,GAAO;EACxB,IAAI,CAACD,GAAM;EACX,IAAMR,IAAIH,EAAkBW,CAAI;EAGhC,AAFA,IAAM,IACFR,EAAE,IAAIZ,MAAM,IAAOY,EAAE,IACrBA,EAAE,IAAIX,MAAM,IAAOW,EAAE;EACzB,IAAML,IAAQK,EAAE,IAAIA,EAAE,OAChBJ,IAASI,EAAE,IAAIA,EAAE;EAEvB,AADIL,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB"}
+{"version":3,"file":"unionBounds.js","names":[],"sources":["../../../src/core/geometry/unionBounds.ts"],"sourcesContent":["/**\n * Union math over rect-shaped poses.\n *\n * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*\n * boxes and is what commit-time actions want, because they go on to write\n * poses back in that same frame. `unionAABB` expands each rotated member to\n * the extent of its ink first, and is what anything a user looks at or clicks\n * wants — selection chrome, gesture bounds, an export viewBox. Folding the\n * unrotated box there under-reports the extent of a rotated member exactly\n * when the consumer is watching it move.\n */\n\nimport { applyToPoint } from '@weasel-js/geom';\nimport type { RectPose } from 'core/geometry/rectPose';\nimport { poseFrameOf } from '@weasel-js/geom';\nexport type { RectPose };\n\n/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any\n *  rotation they carry. See the module docstring before reaching for this\n *  over {@link unionAABB}. */\nexport function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const p of poses) {\n    any = true;\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    const right = p.x + p.width;\n    const bottom = p.y + p.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Axis-align a pose that carries a `rotation` or a `transform`: returns the\n * AABB of the box as drawn, its four corners through `poseFrameOf`, with both\n * fields dropped.\n *\n * A pose with neither is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const frame = poseFrameOf(b);\n  if (!frame) {\n    // Strip an explicit `rotation: 0` so callers can rely on the absence of\n    // the field meaning \"axis-aligned\".\n    return { x: b.x, y: b.y, width: b.width, height: b.height };\n  }\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  const corners: ReadonlyArray<readonly [number, number]> = [\n    [b.x, b.y],\n    [b.x + b.width, b.y],\n    [b.x + b.width, b.y + b.height],\n    [b.x, b.y + b.height],\n  ];\n  for (const [px, py] of corners) {\n    const [rx, ry] = applyToPoint(frame, px, py);\n    if (rx < minX) minX = rx;\n    if (rx > maxX) maxX = rx;\n    if (ry < minY) minY = ry;\n    if (ry > maxY) maxY = ry;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Fold every part into one world-space AABB, skipping `null` / `undefined`\n * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;\n * the result never carries a `rotation` (a union of several oriented boxes\n * has no single orientation to report).\n *\n * Returns `null` when nothing was contributed.\n */\nexport function unionAABB<TPose extends RectPose>(\n  parts: Iterable<TPose | null | undefined>,\n): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const part of parts) {\n    if (!part) continue;\n    const b = axisAlignedBounds(part);\n    any = true;\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,YAAoC,OAAyC;CAC3F,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,MAAM;CACV,KAAK,MAAM,KAAK,OAAO;EACrB,MAAM;EACN,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,MAAM,QAAQ,EAAE,IAAI,EAAE;EACtB,MAAM,SAAS,EAAE,IAAI,EAAE;EACvB,IAAI,QAAQ,MAAM,OAAO;EACzB,IAAI,SAAS,MAAM,OAAO;CAC5B;CACA,IAAI,CAAC,KAAK,OAAO;CACjB,OAAO;EAAE,GAAG;EAAM,GAAG;EAAM,OAAO,OAAO;EAAM,QAAQ,OAAO;CAAK;AACrE;;;;;;;;AASA,SAAgB,kBAA0C,GAAoB;CAC5E,MAAM,QAAQ,YAAY,CAAC;CAC3B,IAAI,CAAC,OAGH,OAAO;EAAE,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG,OAAO,EAAE;EAAO,QAAQ,EAAE;CAAO;CAE5D,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,MAAM,UAAoD;EACxD,CAAC,EAAE,GAAG,EAAE,CAAC;EACT,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;EACnB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM;EAC9B,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM;CACtB;CACA,KAAK,MAAM,CAAC,IAAI,OAAO,SAAS;EAC9B,MAAM,CAAC,IAAI,MAAM,aAAa,OAAO,IAAI,EAAE;EAC3C,IAAI,KAAK,MAAM,OAAO;EACtB,IAAI,KAAK,MAAM,OAAO;EACtB,IAAI,KAAK,MAAM,OAAO;EACtB,IAAI,KAAK,MAAM,OAAO;CACxB;CACA,OAAO;EAAE,GAAG;EAAM,GAAG;EAAM,OAAO,OAAO;EAAM,QAAQ,OAAO;CAAK;AACrE;;;;;;;;;AAUA,SAAgB,UACd,OACiB;CACjB,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,MAAM;CACV,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,CAAC,MAAM;EACX,MAAM,IAAI,kBAAkB,IAAI;EAChC,MAAM;EACN,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,MAAM,QAAQ,EAAE,IAAI,EAAE;EACtB,MAAM,SAAS,EAAE,IAAI,EAAE;EACvB,IAAI,QAAQ,MAAM,OAAO;EACzB,IAAI,SAAS,MAAM,OAAO;CAC5B;CACA,IAAI,CAAC,KAAK,OAAO;CACjB,OAAO;EAAE,GAAG;EAAM,GAAG;EAAM,OAAO,OAAO;EAAM,QAAQ,OAAO;CAAK;AACrE"}

package/dist/core/isPlainObject.js

@@ -1,2 +1,3 @@
-import { isPlainObject as e, isPlainPrototype as t } from "@weasel-js/registry";
-export { e as isPlainObject, t as isPlainPrototype };
+import { isPlainObject, isPlainPrototype } from "@weasel-js/registry";
+
+export { isPlainObject, isPlainPrototype };

package/dist/core/layers/backgroundFill.js

@@ -1,31 +1,39 @@
-import { commandPaint as e } from "@weasel-js/renderer";
+import { commandPaint } from "@weasel-js/renderer";
+
 //#region src/core/layers/backgroundFill.ts
-var t = "scene-background-fill";
-function n(t, n) {
-	let r = {
+/** The id of the layer {@link createBackgroundFillLayer} builds. */
+var BACKGROUND_FILL_LAYER_ID = "scene-background-fill";
+/**
+* `paint` filling a `size` rect at the origin, with `'bounds'` units resolved
+* against that rect. Empty when the paint cannot be drawn yet.
+*/
+function backgroundFillCommands(paint, size) {
+	const rect = {
 		x: 0,
 		y: 0,
-		width: n.width,
-		height: n.height
-	}, i = e(t, r);
-	return i ? [{
+		width: size.width,
+		height: size.height
+	};
+	const fill = commandPaint(paint, rect);
+	return fill ? [{
 		kind: "path",
 		path: {
 			kind: "rect",
-			...r
+			...rect
 		},
-		fill: { paint: i }
+		fill: { paint: fill }
 	}] : [];
 }
-function r(e) {
+/** A screen-space layer filling the whole surface, whatever the camera. */
+function createBackgroundFillLayer(paint) {
 	return {
-		id: t,
+		id: BACKGROUND_FILL_LAYER_ID,
 		label: "Background fill",
 		space: "screen",
-		draw: (t, r, i) => n(e, i)
+		draw: (_data, _view, dims) => backgroundFillCommands(paint, dims)
 	};
 }
-//#endregion
-export { t as BACKGROUND_FILL_LAYER_ID, n as backgroundFillCommands, r as createBackgroundFillLayer };
 
+//#endregion
+export { BACKGROUND_FILL_LAYER_ID, backgroundFillCommands, createBackgroundFillLayer };
 //# sourceMappingURL=backgroundFill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"backgroundFill.js","names":["BACKGROUND_FILL_LAYER_ID","backgroundFillCommands","rect","size","fill","commandPaint","paint","createBackgroundFillLayer","dims"],"sources":["../../../src/core/layers/backgroundFill.ts"],"sourcesContent":["import { commandPaint, type DrawCommand } from '@weasel-js/renderer';\nimport type { Paint } from '@weasel-js/paint';\nimport type { Dims, RenderLayer } from './render';\n\n/** The id of the layer {@link createBackgroundFillLayer} builds. */\nexport const BACKGROUND_FILL_LAYER_ID = 'scene-background-fill';\n\n/**\n * `paint` filling a `size` rect at the origin, with `'bounds'` units resolved\n * against that rect. Empty when the paint cannot be drawn yet.\n */\nexport function backgroundFillCommands(paint: Paint, size: Dims): DrawCommand[] {\n  const rect = { x: 0, y: 0, width: size.width, height: size.height };\n  const fill = commandPaint(paint, rect);\n  return fill ? [{ kind: 'path', path: { kind: 'rect', ...rect }, fill: { paint: fill } }] : [];\n}\n\n/** A screen-space layer filling the whole surface, whatever the camera. */\nexport function createBackgroundFillLayer(paint: Paint): RenderLayer<unknown> {\n  return {\n    id: BACKGROUND_FILL_LAYER_ID,\n    label: 'Background fill',\n    space: 'screen',\n    draw: (_data, _view, dims) => backgroundFillCommands(paint, dims),\n  };\n}\n"],"mappings":";;AAKA,IAAaA,IAA2B;AAMxC,SAAgBC,EAAuB,GAAc,GAA2B;CAC9E,IAAMC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOC,EAAK;EAAO,QAAQA,EAAK;CAAO,GAC5DC,IAAOC,EAAaC,GAAOJ,CAAI;CACrC,OAAOE,IAAO,CAAC;EAAE,MAAM;EAAQ,MAAM;GAAE,MAAM;GAAQ,GAAGF;EAAK;EAAG,MAAM,EAAE,OAAOE,EAAK;CAAE,CAAC,IAAI,CAAC;AAC9F;AAGA,SAAgBG,EAA0B,GAAoC;CAC5E,OAAO;EACL,IAAIP;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAO,GAAO,MAASC,EAAuBK,GAAOE,CAAI;CAClE;AACF"}
+{"version":3,"file":"backgroundFill.js","names":[],"sources":["../../../src/core/layers/backgroundFill.ts"],"sourcesContent":["import { commandPaint, type DrawCommand } from '@weasel-js/renderer';\nimport type { Paint } from '@weasel-js/paint';\nimport type { Dims, RenderLayer } from './render';\n\n/** The id of the layer {@link createBackgroundFillLayer} builds. */\nexport const BACKGROUND_FILL_LAYER_ID = 'scene-background-fill';\n\n/**\n * `paint` filling a `size` rect at the origin, with `'bounds'` units resolved\n * against that rect. Empty when the paint cannot be drawn yet.\n */\nexport function backgroundFillCommands(paint: Paint, size: Dims): DrawCommand[] {\n  const rect = { x: 0, y: 0, width: size.width, height: size.height };\n  const fill = commandPaint(paint, rect);\n  return fill ? [{ kind: 'path', path: { kind: 'rect', ...rect }, fill: { paint: fill } }] : [];\n}\n\n/** A screen-space layer filling the whole surface, whatever the camera. */\nexport function createBackgroundFillLayer(paint: Paint): RenderLayer<unknown> {\n  return {\n    id: BACKGROUND_FILL_LAYER_ID,\n    label: 'Background fill',\n    space: 'screen',\n    draw: (_data, _view, dims) => backgroundFillCommands(paint, dims),\n  };\n}\n"],"mappings":";;;;AAKA,IAAa,2BAA2B;;;;;AAMxC,SAAgB,uBAAuB,OAAc,MAA2B;CAC9E,MAAM,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAO,KAAK;EAAO,QAAQ,KAAK;CAAO;CAClE,MAAM,OAAO,aAAa,OAAO,IAAI;CACrC,OAAO,OAAO,CAAC;EAAE,MAAM;EAAQ,MAAM;GAAE,MAAM;GAAQ,GAAG;EAAK;EAAG,MAAM,EAAE,OAAO,KAAK;CAAE,CAAC,IAAI,CAAC;AAC9F;;AAGA,SAAgB,0BAA0B,OAAoC;CAC5E,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,OAAO,OAAO,SAAS,uBAAuB,OAAO,IAAI;CAClE;AACF"}

package/dist/core/layers/children.js

@@ -1,21 +1,24 @@
 //#region src/core/layers/children.ts
-function e(e) {
+/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */
+function createChildrenLayer(opts) {
 	return {
-		id: e.id ?? "children",
-		label: e.label ?? "Children",
-		defaultVisible: e.defaultVisible,
-		alwaysOn: e.alwaysOn,
-		draw: (t, n) => {
-			let r = typeof e.parentId == "function" ? e.parentId() : e.parentId ?? null, i = e.adapter.getChildren(r), a = [];
-			for (let r of i) {
-				let i = e.drawChild(r, t, n);
-				for (let e of i) a.push(e);
+		id: opts.id ?? "children",
+		label: opts.label ?? "Children",
+		defaultVisible: opts.defaultVisible,
+		alwaysOn: opts.alwaysOn,
+		draw: (data, view) => {
+			const parent = typeof opts.parentId === "function" ? opts.parentId() : opts.parentId ?? null;
+			const ids = opts.adapter.getChildren(parent);
+			const out = [];
+			for (const id of ids) {
+				const sub = opts.drawChild(id, data, view);
+				for (const cmd of sub) out.push(cmd);
 			}
-			return a;
+			return out;
 		}
 	};
 }
-//#endregion
-export { e as createChildrenLayer };
 
+//#endregion
+export { createChildrenLayer };
 //# sourceMappingURL=children.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"children.js","names":["createChildrenLayer","opts","parent","ids","out","id","sub","data","view","cmd"],"sources":["../../../src/core/layers/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer: a `RenderLayer` factory over an `OrderedAdapter`.\n * Children are drawn in z-order (index 0 = bottom).\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = opts.adapter.getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AA+BA,SAAgBA,EACd,GACoB;CACpB,OAAO;EACL,IAAIC,EAAK,MAAM;EACf,OAAOA,EAAK,SAAS;EACrB,gBAAgBA,EAAK;EACrB,UAAUA,EAAK;EACf,OAAO,GAAM,MAAS;GACpB,IAAMC,IACJ,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,MACjBE,IAAMF,EAAK,QAAQ,YAAYC,CAAM,GACrCE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAMF,GAAK;IACpB,IAAMG,IAAML,EAAK,UAAUI,GAAIE,GAAMC,CAAI;IACzC,KAAK,IAAMC,KAAOH,GAAK,EAAI,KAAKG,CAAG;GACrC;GACA,OAAOL;EACT;CACF;AACF"}
+{"version":3,"file":"children.js","names":[],"sources":["../../../src/core/layers/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer: a `RenderLayer` factory over an `OrderedAdapter`.\n * Children are drawn in z-order (index 0 = bottom).\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = opts.adapter.getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;AA+BA,SAAgB,oBACd,MACoB;CACpB,OAAO;EACL,IAAI,KAAK,MAAM;EACf,OAAO,KAAK,SAAS;EACrB,gBAAgB,KAAK;EACrB,UAAU,KAAK;EACf,OAAO,MAAM,SAAS;GACpB,MAAM,SACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,IACd,KAAK,YAAY;GACvB,MAAM,MAAM,KAAK,QAAQ,YAAY,MAAM;GAC3C,MAAM,MAAqB,CAAC;GAC5B,KAAK,MAAM,MAAM,KAAK;IACpB,MAAM,MAAM,KAAK,UAAU,IAAI,MAAM,IAAI;IACzC,KAAK,MAAM,OAAO,KAAK,IAAI,KAAK,GAAG;GACrC;GACA,OAAO;EACT;CACF;AACF"}

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"}