@weasel-js/core 1.9.3 → 1.10.0

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

@@ -1 +1 @@
-{"version":3,"file":"regionHit.js","names":["rectRegion","w","h","r","regionOf","x","y","verts","flat","minX","minY","maxX","maxY","i","coords","bounds","polygonRegion","polygon","p","isSilhouettePose","pose","regionBoundsOf","nodeMemo","node","g","visualBoundsViaDescriptor","poseOutline","poseRotationOf","rotatePathAround","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","polygonIntersectsPath","drawn"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision shared by\n * `sceneToAdapter` (through `canvas/deps/hitTestArea`) and `arrayAdapter`.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { poseRotationOf, rotatePathAround } from './poseRotation';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './poseDescriptor';\n\n/** A closed selection area: a marquee rect or a lasso polygon. */\nexport interface SelectRegion {\n  /** The area's vertices; the closing edge back to the first is implicit. */\n  readonly verts: readonly Vec2[];\n  /** `verts` interleaved as `[x0, y0, x1, y1, …]`. */\n  readonly coords: readonly number[];\n  readonly bounds: Bounds;\n  /** True when the area is its own bounding rect, so a node inside `bounds`\n   *  is inside the area without further work. Never true for a lasso: a node\n   *  inside the hull's box can still miss the hull. */\n  readonly isRect: boolean;\n}\n\n/** A marquee's region. */\nexport function rectRegion(r: Bounds): SelectRegion {\n  const { x, y, width: w, height: h } = r;\n  return regionOf([x, y, x + w, y, x + w, y + h, x, y + h], { x, y, width: w, height: h }, true)!;\n}\n\n/** A region from interleaved coords. `bounds` is derived when omitted; `null`\n *  when there are no coords to bound. */\nexport function regionOf(\n  coords: ArrayLike<number>,\n  bounds?: Bounds,\n  isRect = false,\n): SelectRegion | null {\n  const verts: Vec2[] = [];\n  const flat: number[] = [];\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    verts.push({ x, y });\n    flat.push(x, y);\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  if (verts.length === 0) return null;\n  return {\n    verts,\n    coords: flat,\n    bounds: bounds ?? { x: minX, y: minY, width: maxX - minX, height: maxY - minY },\n    isRect,\n  };\n}\n\n/** A lasso's region, or `null` for fewer than three vertices. */\nexport function polygonRegion(polygon: ReadonlyArray<Vec2>): SelectRegion | null {\n  if (polygon.length < 3) return null;\n  const coords: number[] = [];\n  for (const p of polygon) coords.push(p.x, p.y);\n  return regionOf(coords);\n}\n\n/** A pose that is its own drawn outline. */\nexport function isSilhouettePose(pose: unknown): pose is PolygonPath {\n  return pose !== null && typeof pose === 'object' && (pose as Path).kind === 'polygon';\n}\n\n/**\n * The box a region fast-rejects a node against: a silhouette pose's own bounds,\n * else the pose's visual bounds — which for a rotated pose is the box of its\n * rotated ink, reaching past the pose box. `g` is the node's descriptor.\n */\nexport function regionBoundsOf(node: object, pose: unknown, g: PoseDescriptor<unknown>): Bounds {\n  // Memo is silhouettes-only: a rect pose's bounds are the pose itself, and\n  // memoizing it costs more than it saves. The result may be shared; never mutate it.\n  return isSilhouettePose(pose)\n    ? nodeMemo(node, 'aabb', pose, () => g.getBounds(pose))\n    : visualBoundsViaDescriptor(pose, g);\n}\n\n/** The outline of a node nothing paints: its pose rect, turned by the pose's\n *  rotation, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  const r = poseRotationOf(pose);\n  if (r) {\n    const p = pose as Bounds;\n    return rotatePathAround(\n      { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      r.cx, r.cy, r.rotation,\n    );\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A node sticking out of the region's box cannot be inside the region.\n    if (!inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  if (silhouette) return polygonIntersectsPath(region.verts, pose);\n  const drawn = outline();\n  // An axis-aligned rect overlapping a marquee's box already meets it.\n  if (drawn.kind === 'rect' && region.isRect) return true;\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":"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"}
+{"version":3,"file":"regionHit.js","names":["rectRegion","w","h","r","regionOf","x","y","verts","flat","minX","minY","maxX","maxY","i","coords","bounds","polygonRegion","polygon","p","isSilhouettePose","pose","regionBoundsOf","nodeMemo","node","g","visualBoundsViaDescriptor","poseOutline","poseFrameOf","pathThroughPoseFrame","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","drawn","filled","polygonIntersectsPath"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision the\n * scene's area walk (`canvas/deps/hitTestArea`) makes.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { pathThroughPoseFrame, poseFrameOf } from '@weasel-js/geom';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './poseDescriptor';\n\n/** A closed selection area: a marquee rect or a lasso polygon. */\nexport interface SelectRegion {\n  /** The area's vertices; the closing edge back to the first is implicit. */\n  readonly verts: readonly Vec2[];\n  /** `verts` interleaved as `[x0, y0, x1, y1, …]`. */\n  readonly coords: readonly number[];\n  readonly bounds: Bounds;\n  /** True when the area is its own bounding rect, so a node inside `bounds`\n   *  is inside the area without further work. Never true for a lasso: a node\n   *  inside the hull's box can still miss the hull. */\n  readonly isRect: boolean;\n}\n\n/** A marquee's region. */\nexport function rectRegion(r: Bounds): SelectRegion {\n  const { x, y, width: w, height: h } = r;\n  return regionOf([x, y, x + w, y, x + w, y + h, x, y + h], { x, y, width: w, height: h }, true)!;\n}\n\n/** A region from interleaved coords. `bounds` is derived when omitted; `null`\n *  when there are no coords to bound. */\nexport function regionOf(\n  coords: ArrayLike<number>,\n  bounds?: Bounds,\n  isRect = false,\n): SelectRegion | null {\n  const verts: Vec2[] = [];\n  const flat: number[] = [];\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    verts.push({ x, y });\n    flat.push(x, y);\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  if (verts.length === 0) return null;\n  return {\n    verts,\n    coords: flat,\n    bounds: bounds ?? { x: minX, y: minY, width: maxX - minX, height: maxY - minY },\n    isRect,\n  };\n}\n\n/** A lasso's region, or `null` for fewer than three vertices. */\nexport function polygonRegion(polygon: ReadonlyArray<Vec2>): SelectRegion | null {\n  if (polygon.length < 3) return null;\n  const coords: number[] = [];\n  for (const p of polygon) coords.push(p.x, p.y);\n  return regionOf(coords);\n}\n\n/** A pose that is its own drawn outline. */\nexport function isSilhouettePose(pose: unknown): pose is PolygonPath {\n  return pose !== null && typeof pose === 'object' && (pose as Path).kind === 'polygon';\n}\n\n/**\n * The box a region fast-rejects a node against: a silhouette pose's own bounds,\n * else the pose's visual bounds — which for a rotated pose is the box of its\n * rotated ink, reaching past the pose box. `g` is the node's descriptor.\n */\nexport function regionBoundsOf(node: object, pose: unknown, g: PoseDescriptor<unknown>): Bounds {\n  // Memo is silhouettes-only: a rect pose's bounds are the pose itself, and\n  // memoizing it costs more than it saves. The result may be shared; never mutate it.\n  return isSilhouettePose(pose)\n    ? nodeMemo(node, 'aabb', pose, () => g.getBounds(pose))\n    : visualBoundsViaDescriptor(pose, g);\n}\n\n/** The outline of a node nothing paints: its pose rect through the pose's\n *  frame, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  if (poseFrameOf(pose)) {\n    const p = pose as Bounds;\n    return pathThroughPoseFrame({ kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height }, pose);\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere: its interior too,\n *   unless `filled` says nothing paints it.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n  filled: () => boolean = () => true,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A node sticking out of the region's box cannot be inside the region.\n    if (!inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  const drawn = silhouette ? pose : outline();\n  if (!filled()) return polygonIntersectsPath(region.verts, drawn, { filled: false });\n  // An axis-aligned rect overlapping a marquee's box already meets it.\n  if (drawn.kind === 'rect' && region.isRect) return true;\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":";;;;AAsCA,SAAgBA,EAAW,GAAyB;CAClD,IAAM,EAAE,MAAG,MAAG,OAAOC,GAAG,QAAQC,MAAMC;CACtC,OAAOC,EAAS;EAACC;EAAGC;EAAGD,IAAIJ;EAAGK;EAAGD,IAAIJ;EAAGK,IAAIJ;EAAGG;EAAGC,IAAIJ;CAAC,GAAG;EAAE;EAAG;EAAG,OAAOD;EAAG,QAAQC;CAAE,GAAG,EAAI;AAC/F;AAIA,SAAgBE,EACd,GACA,GACA,IAAS,IACY;CACrB,IAAMG,IAAgB,CAAC,GACjBC,IAAiB,CAAC,GACpBC,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;CAC/D,KAAK,IAAIC,IAAI,GAAGA,IAAI,IAAIC,EAAO,QAAQ,KAAK,GAAG;EAC7C,IAAMT,IAAIS,EAAOD,IAAIP,IAAIQ,EAAOD,IAAI;EAMpC,AALAN,EAAM,KAAK;GAAE;GAAG;EAAE,CAAC,GACnBC,EAAK,KAAKH,GAAGC,CAAC,GACVD,IAAII,MAAM,IAAOJ,IACjBC,IAAII,MAAM,IAAOJ,IACjBD,IAAIM,MAAM,IAAON,IACjBC,IAAIM,MAAM,IAAON;CACvB;CAEA,OADIC,EAAM,WAAW,IAAU,OACxB;EACL;EACA,QAAQC;EACR,QAAQO,KAAU;GAAE,GAAGN;GAAM,GAAGC;GAAM,OAAOC,IAAOF;GAAM,QAAQG,IAAOF;EAAK;EAC9E;CACF;AACF;AAGA,SAAgBM,EAAc,GAAmD;CAC/E,IAAIC,EAAQ,SAAS,GAAG,OAAO;CAC/B,IAAMH,IAAmB,CAAC;CAC1B,KAAK,IAAMI,KAAKD,GAAS,EAAO,KAAKC,EAAE,GAAGA,EAAE,CAAC;CAC7C,OAAOd,EAASU,CAAM;AACxB;AAGA,SAAgBK,EAAiB,GAAoC;CACnE,OAAwB,OAAOC,KAAS,cAAjCA,KAA8CA,EAAc,SAAS;AAC9E;AAOA,SAAgBC,EAAe,GAAc,GAAe,GAAoC;CAG9F,OAAOF,EAAiBC,CAAI,IACxBE,EAASC,GAAM,QAAQH,SAAYI,EAAE,UAAUJ,CAAI,CAAC,IACpDK,EAA0BL,GAAMI,CAAC;AACvC;AAIA,SAAgBE,EAAY,GAAe,GAAiB;CAC1D,IAAIC,EAAYP,CAAI,GAAG;EACrB,IAAMF,IAAIE;EACV,OAAOQ,EAAqB;GAAE,MAAM;GAAQ,GAAGV,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO,GAAGE,CAAI;CACtG;CACA,OAAO;EAAE,MAAM;EAAQ,GAAGS,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;AAC1E;AAaA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,UAA8B,IACrB;CACT,IACE,CAAC,OAAO,SAASD,EAAE,CAAC,KAAK,CAAC,OAAO,SAASA,EAAE,CAAC,KAC7C,CAAC,OAAO,SAASA,EAAE,KAAK,KAAK,CAAC,OAAO,SAASA,EAAE,MAAM,GAEtD,OAAO;CAET,IAAME,IAAKC,EAAO;CAClB,IACEH,EAAE,KAAKE,EAAG,IAAIA,EAAG,SAASF,EAAE,IAAIA,EAAE,SAASE,EAAG,KAC9CF,EAAE,KAAKE,EAAG,IAAIA,EAAG,UAAUF,EAAE,IAAIA,EAAE,UAAUE,EAAG,GAEhD,OAAO;CAET,IAAIE,MAAS,WACX,OAAOC,EAAeF,EAAO,QAAQH,EAAE,IAAIA,EAAE,QAAQ,GAAGA,EAAE,IAAIA,EAAE,SAAS,CAAC;CAE5E,IAAMM,IAAQC,EACZ;EAACL,EAAG;EAAGA,EAAG;EAAGA,EAAG,IAAIA,EAAG;EAAOA,EAAG,IAAIA,EAAG;CAAM,GAC9C;EAACF,EAAE;EAAGA,EAAE;EAAGA,EAAE,IAAIA,EAAE;EAAOA,EAAE,IAAIA,EAAE;CAAM,CAC1C,GACMQ,IAAalB,EAAiBC,CAAI;CACxC,IAAIa,MAAS,YAGX,OADKE,IACEG,EAAoBN,EAAO,OAAOK,IAAajB,IAAOmB,EAAQ,CAAC,IADnD;CAIrB,IAAIP,EAAO,UAAUG,GAAO,OAAO;CACnC,IAAMK,IAAQH,IAAajB,IAAOmB,EAAQ;CAI1C,OAHKE,EAAO,IAERD,EAAM,SAAS,UAAUR,EAAO,SAAe,KAC5CU,EAAsBV,EAAO,OAAOQ,CAAK,IAH1BE,EAAsBV,EAAO,OAAOQ,GAAO,EAAE,QAAQ,GAAM,CAAC;AAIpF"}

package/dist/core/geometry/targetFrame.js

@@ -0,0 +1,94 @@
+import { applyToPoint as e, invert as t, poseFrameOf as n } from "@weasel-js/geom";
+//#region src/core/geometry/targetFrame.ts
+var r = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+], i = {
+	identity: !0,
+	toWorld: r,
+	toLocal: r
+};
+function a(e) {
+	let r = n(e);
+	return r ? {
+		identity: !1,
+		toWorld: r,
+		toLocal: t(r)
+	} : i;
+}
+function o(e) {
+	return e.identity ? 0 : Math.atan2(e.toWorld[1], e.toWorld[0]);
+}
+function s(e) {
+	if (e.identity) return !0;
+	let [t, n, r, i] = e.toWorld;
+	return Math.abs(t - i) < 1e-9 && Math.abs(n + r) < 1e-9 && Math.abs(t * t + n * n - 1) < 1e-9;
+}
+function c(t, n, r) {
+	if (t.identity) return {
+		x: n,
+		y: r
+	};
+	let [i, a] = e(t.toWorld, n, r);
+	return {
+		x: i,
+		y: a
+	};
+}
+function l(t, n, r) {
+	if (t.identity) return {
+		x: n,
+		y: r
+	};
+	if (!t.toLocal) return null;
+	let [i, a] = e(t.toLocal, n, r);
+	return {
+		x: i,
+		y: a
+	};
+}
+function u(e, t, n) {
+	if (e.identity) return {
+		x: t,
+		y: n
+	};
+	let r = e.toLocal;
+	return r && {
+		x: r[0] * t + r[2] * n,
+		y: r[1] * t + r[3] * n
+	};
+}
+function d(e, t) {
+	if (e.identity) return t;
+	let [n, r, i, a] = e.toWorld, o = Math.sign(n * a - r * i) || 1;
+	return {
+		x: (a * t.x - r * t.y) * o,
+		y: (n * t.y - i * t.x) * o
+	};
+}
+function f(e, t, n) {
+	let [r, i, a, o] = n.toWorld, s = r * t.x, c = i * t.y, l = a * t.x, u = o * t.y, d = Math.abs(s * u - c * l);
+	return d === 0 ? {
+		x: 0,
+		y: 0
+	} : {
+		x: e * Math.hypot(l, u) / d,
+		y: e * Math.hypot(s, c) / d
+	};
+}
+function p(e, t) {
+	return [
+		c(t, e.x, e.y),
+		c(t, e.x + e.width, e.y),
+		c(t, e.x + e.width, e.y + e.height),
+		c(t, e.x, e.y + e.height)
+	];
+}
+//#endregion
+export { i as IDENTITY_TARGET, o as angleOf, s as isRigid, c as localToWorld, d as normalToWorld, f as pxExtentIn, p as targetCorners, a as targetTransformOf, u as worldDeltaToLocal, l as worldToLocal };
+
+//# sourceMappingURL=targetFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"targetFrame.js","names":["IDENTITY","IDENTITY_TARGET","targetTransformOf","toWorld","poseFrameOf","bounds","invert","angleOf","xf","isRigid","a","b","c","d","localToWorld","lx","ly","x","y","applyToPoint","worldToLocal","wx","wy","worldDeltaToLocal","dx","dy","m","normalToWorld","n","k","pxExtentIn","ux","scale","uy","vx","vy","det","px","targetCorners"],"sources":["../../../src/core/geometry/targetFrame.ts"],"sourcesContent":["/**\n * The frame selection chrome reads a target in: `poseFrameOf` over the\n * target's bounds, with the helpers the outline, the handles, their hit\n * regions, and the resize and rotate actions all place themselves by.\n */\nimport { applyToPoint, invert, poseFrameOf, type Mat3, type Scale2 } from '@weasel-js/geom';\n\n/** Local↔world maps for a chrome target. Local is the target's unrotated box\n *  frame; world is where the node is drawn. */\nexport interface TargetTransform {\n  /** No rotation and no `transform`: local is world. */\n  identity: boolean;\n  /** Target box frame → world. */\n  toWorld: Mat3;\n  /** World → target box frame. `null` when the target's `transform` is\n   *  singular: it draws nothing, and no world point maps back. */\n  toLocal: Mat3 | null;\n}\n\nconst IDENTITY: Mat3 = [1, 0, 0, 1, 0, 0];\n\nexport const IDENTITY_TARGET: TargetTransform = { identity: true, toWorld: IDENTITY, toLocal: IDENTITY };\n\n/** The frame `bounds` is drawn in: its `rotation`, its `transform`, or both. */\nexport function targetTransformOf(bounds: unknown): TargetTransform {\n  const toWorld = poseFrameOf(bounds);\n  if (!toWorld) return IDENTITY_TARGET;\n  return { identity: false, toWorld, toLocal: invert(toWorld) };\n}\n\n/** How far the target's x axis is turned from world's, radians. */\nexport function angleOf(xf: TargetTransform): number {\n  return xf.identity ? 0 : Math.atan2(xf.toWorld[1], xf.toWorld[0]);\n}\n\n/** Whether the frame only turns the target: no skew, no stretch, no flip. */\nexport function isRigid(xf: TargetTransform): boolean {\n  if (xf.identity) return true;\n  const [a, b, c, d] = xf.toWorld;\n  return Math.abs(a - d) < 1e-9 && Math.abs(b + c) < 1e-9 && Math.abs(a * a + b * b - 1) < 1e-9;\n}\n\n/** local point → world point. */\nexport function localToWorld(xf: TargetTransform, lx: number, ly: number): { x: number; y: number } {\n  if (xf.identity) return { x: lx, y: ly };\n  const [x, y] = applyToPoint(xf.toWorld, lx, ly);\n  return { x, y };\n}\n\n/** world point → local point; `null` where nothing maps back. */\nexport function worldToLocal(xf: TargetTransform, wx: number, wy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: wx, y: wy };\n  if (!xf.toLocal) return null;\n  const [x, y] = applyToPoint(xf.toLocal, wx, wy);\n  return { x, y };\n}\n\n/** A world delta in the target's own axes; `null` where nothing maps back. */\nexport function worldDeltaToLocal(xf: TargetTransform, dx: number, dy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: dx, y: dy };\n  const m = xf.toLocal;\n  return m && { x: m[0] * dx + m[2] * dy, y: m[1] * dx + m[3] * dy };\n}\n\n/** A local edge's outward normal as a world direction, unnormalized. A normal\n *  goes through the inverse transpose, so it stays square to a skewed edge. */\nexport function normalToWorld(xf: TargetTransform, n: { x: number; y: number }): { x: number; y: number } {\n  if (xf.identity) return n;\n  const [a, b, c, d] = xf.toWorld;\n  const k = Math.sign(a * d - b * c) || 1;\n  return { x: (d * n.x - b * n.y) * k, y: (a * n.y - c * n.x) * k };\n}\n\n/** `pxExtent` along the target's own axes: how far along each an edge across\n *  it must move to move `px` on screen. */\nexport function pxExtentIn(px: number, scale: Scale2, xf: TargetTransform): { x: number; y: number } {\n  const [a, b, c, d] = xf.toWorld;\n  const ux = a * scale.x, uy = b * scale.y;\n  const vx = c * scale.x, vy = d * scale.y;\n  const det = Math.abs(ux * vy - uy * vx);\n  if (det === 0) return { x: 0, y: 0 };\n  return { x: (px * Math.hypot(vx, vy)) / det, y: (px * Math.hypot(ux, uy)) / det };\n}\n\n/** The target's box corners in world, TL/TR/BR/BL. */\nexport function targetCorners(\n  b: { x: number; y: number; width: number; height: number },\n  xf: TargetTransform,\n): { x: number; y: number }[] {\n  return [\n    localToWorld(xf, b.x, b.y),\n    localToWorld(xf, b.x + b.width, b.y),\n    localToWorld(xf, b.x + b.width, b.y + b.height),\n    localToWorld(xf, b.x, b.y + b.height),\n  ];\n}\n"],"mappings":"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"}

package/dist/core/geometry/unionBounds.js

@@ -1,5 +1,6 @@
+import { applyToPoint as e, poseFrameOf as t } from "@weasel-js/geom";
 //#region src/core/geometry/unionBounds.ts
-function e(e) {
+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);
@@ -13,48 +14,48 @@ function e(e) {
 		height: i - n
 	} : null;
 }
-function t(e) {
-	let t = e.rotation;
-	if (!t) return {
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height
+function r(n) {
+	let r = t(n);
+	if (!r) return {
+		x: n.x,
+		y: n.y,
+		width: n.width,
+		height: n.height
 	};
-	let n = Math.cos(t), r = Math.sin(t), i = e.x + e.width / 2, a = e.y + e.height / 2, o = Infinity, s = Infinity, c = -Infinity, l = -Infinity, u = [
-		[e.x, e.y],
-		[e.x + e.width, e.y],
-		[e.x + e.width, e.y + e.height],
-		[e.x, e.y + e.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]
 	];
-	for (let [e, t] of u) {
-		let u = e - i, d = t - a, f = i + u * n - d * r, p = a + u * r + d * n;
-		f < o && (o = f), f > c && (c = f), p < s && (s = p), p > l && (l = p);
+	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);
 	}
 	return {
-		x: o,
-		y: s,
-		width: c - o,
-		height: l - s
+		x: i,
+		y: a,
+		width: o - i,
+		height: s - a
 	};
 }
-function n(e) {
-	let n = Infinity, r = Infinity, i = -Infinity, a = -Infinity, o = !1;
+function i(e) {
+	let t = Infinity, n = Infinity, i = -Infinity, a = -Infinity, o = !1;
 	for (let s of e) {
 		if (!s) continue;
-		let e = t(s);
-		o = !0, e.x < n && (n = e.x), e.y < r && (r = e.y);
+		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);
 	}
 	return o ? {
-		x: n,
-		y: r,
-		width: i - n,
-		height: a - r
+		x: t,
+		y: n,
+		width: i - t,
+		height: a - n
 	} : null;
 }
 //#endregion
-export { t as axisAlignedBounds, n as unionAABB, e as unionBounds };
+export { r as axisAlignedBounds, i as unionAABB, n as 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","rotation","b","cos","sin","cx","cy","corners","px","py","dx","dy","rx","ry","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 type { RectPose } from 'core/scene/types';\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`: returns the AABB of the\n * rotated rectangle, with `rotation` dropped. Follows the kit's rotation\n * convention (`poseRotationOf`): rotate about the unrotated AABB center.\n *\n * Unrotated input is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const rotation = b.rotation;\n  if (!rotation) {\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  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const cx = b.x + b.width / 2;\n  const cy = b.y + b.height / 2;\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 dx = px - cx;\n    const dy = py - cy;\n    const rx = cx + dx * cos - dy * sin;\n    const ry = cy + dx * sin + dy * cos;\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":";AAkBA,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,IAAWC,EAAE;CACnB,IAAI,CAACD,GAGH,OAAO;EAAE,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CAE5D,IAAMC,IAAM,KAAK,IAAIF,CAAQ,GACvBG,IAAM,KAAK,IAAIH,CAAQ,GACvBI,IAAKH,EAAE,IAAIA,EAAE,QAAQ,GACrBI,IAAKJ,EAAE,IAAIA,EAAE,SAAS,GACxBX,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACLa,IAAoD;EACxD,CAACL,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,CAACM,GAAIC,MAAOF,GAAS;EAC9B,IAAMG,IAAKF,IAAKH,GACVM,IAAKF,IAAKH,GACVM,IAAKP,IAAKK,IAAKP,IAAMQ,IAAKP,GAC1BS,IAAKP,IAAKI,IAAKN,IAAMO,IAAKR;EAIhC,AAHIS,IAAKrB,MAAM,IAAOqB,IAClBA,IAAKnB,MAAM,IAAOmB,IAClBC,IAAKrB,MAAM,IAAOqB,IAClBA,IAAKnB,MAAM,IAAOmB;CACxB;CACA,OAAO;EAAE,GAAGtB;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE;AAUA,SAAgBsB,EACd,GACiB;CACjB,IAAIvB,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMoB,KAAQC,GAAO;EACxB,IAAI,CAACD,GAAM;EACX,IAAMb,IAAIF,EAAkBe,CAAI;EAGhC,AAFA,IAAM,IACFb,EAAE,IAAIX,MAAM,IAAOW,EAAE,IACrBA,EAAE,IAAIV,MAAM,IAAOU,EAAE;EACzB,IAAMJ,IAAQI,EAAE,IAAIA,EAAE,OAChBH,IAASG,EAAE,IAAIA,EAAE;EAEvB,AADIJ,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":["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"}

package/dist/core/isPlainObject.js

@@ -1,11 +1,2 @@
-//#region src/core/isPlainObject.ts
-function e(e) {
-	return e === Object.prototype || e === null || Object.getPrototypeOf(e) === null;
-}
-function t(t) {
-	return typeof t == "object" && !!t && e(Object.getPrototypeOf(t));
-}
-//#endregion
-export { t as isPlainObject, e as isPlainPrototype };
-
-//# sourceMappingURL=isPlainObject.js.map
+import { isPlainObject as e, isPlainPrototype as t } from "@weasel-js/registry";
+export { e as isPlainObject, t as isPlainPrototype };

package/dist/core/layers/backgroundFill.js

@@ -0,0 +1,31 @@
+import { commandPaint as e } from "@weasel-js/renderer";
+//#region src/core/layers/backgroundFill.ts
+var t = "scene-background-fill";
+function n(t, n) {
+	let r = {
+		x: 0,
+		y: 0,
+		width: n.width,
+		height: n.height
+	}, i = e(t, r);
+	return i ? [{
+		kind: "path",
+		path: {
+			kind: "rect",
+			...r
+		},
+		fill: { paint: i }
+	}] : [];
+}
+function r(e) {
+	return {
+		id: t,
+		label: "Background fill",
+		space: "screen",
+		draw: (t, r, i) => n(e, i)
+	};
+}
+//#endregion
+export { t as BACKGROUND_FILL_LAYER_ID, n as backgroundFillCommands, r as createBackgroundFillLayer };
+
+//# sourceMappingURL=backgroundFill.js.map

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

@@ -0,0 +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"}

package/dist/{features/groups → core/layers}/children.js

@@ -1,4 +1,4 @@
-//#region src/features/groups/children.ts
+//#region src/core/layers/children.ts
 function e(e) {
 	return {
 		id: e.id ?? "children",

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

@@ -0,0 +1 @@
+{"version":3,"file":"children.js","names":["createChildrenLayer","opts","getChildren","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). If the adapter doesn't\n * implement `getChildren`, the layer is a silent no-op.\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 getChildren = opts.adapter.getChildren;\n      if (!getChildren) return [];\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = 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":";AAgCA,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,IAAcD,EAAK,QAAQ;GACjC,IAAI,CAACC,GAAa,OAAO,CAAC;GAK1B,IAAMC,IAAMD,EAHV,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,IACO,GACxBG,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"}

package/dist/core/layers/gateLayer.js

@@ -0,0 +1,13 @@
+import { subscribeToSources as e } from "./render.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;
+}
+//#endregion
+export { t as gateLayer };
+
+//# sourceMappingURL=gateLayer.js.map

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

@@ -0,0 +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"}

package/dist/core/layers/layerGroup.js

@@ -0,0 +1,40 @@
+//#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);
+			}
+		}
+		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.`);
+	}
+	return r;
+}
+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;
+	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
+	}];
+}
+//#endregion
+export { e as groupMembership, t as wrapGroup };
+
+//# sourceMappingURL=layerGroup.js.map

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

@@ -0,0 +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"}

package/dist/core/layers/render.js

@@ -1,6 +1,7 @@
-import { viewToMat3 as e } from "../../renderer/math/viewToMat3.js";
+import { groupMembership as e, wrapGroup as t } from "./layerGroup.js";
+import { viewToMat3 as n } from "@weasel-js/renderer";
 //#region src/core/layers/render.ts
-var t = {
+var r = {
 	x: 0,
 	y: 0,
 	scale: {
@@ -8,10 +9,10 @@ var t = {
 		y: 1
 	}
 };
-function n({ layerId: e, error: t }) {
+function i({ layerId: e, error: t }) {
 	console.error(`[weasel] layer "${e}" threw while drawing; it painted nothing this frame.`, t);
 }
-function r(e) {
+function a(e) {
 	return (t) => {
 		let n = (typeof e == "function" ? e() : e).flatMap((e) => e.subscribe ? [e.subscribe(t)] : []);
 		return () => {
@@ -19,86 +20,54 @@ function r(e) {
 		};
 	};
 }
-function i() {
+function o() {
 	return typeof performance < "u" ? performance.now() : Date.now();
 }
-function a(e, r, a, l, d, f, p, m = n, h, g) {
-	let _ = new Map(e.map((e) => [e.id, e])), v = l ? l.map((e) => _.get(e)).filter((e) => e !== void 0) : e, y = d ?? t, b = [];
+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 x = o(h, _.keys()), S = /* @__PURE__ */ new Set(), C = null, w = () => {
-		if (!C) return;
-		let e = b.length, t = g ? i() : 0;
-		for (let e of s(C.group, C.children, y, f)) b.push(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: C.group.id,
+			id: S.group.id,
 			start: e,
-			end: b.length,
-			buildMs: C.buildMs + i() - t
-		}), C = null;
+			end: y.length,
+			buildMs: S.buildMs + o() - n
+		}), S = null;
 	};
-	for (let e of v) {
-		if (!c(e, a)) continue;
-		let t = g ? i() : 0, n = u(e, r, y, f, p, m), o = g ? i() - t : 0;
+	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: b.length,
-				end: b.length,
-				buildMs: o
+				start: y.length,
+				end: y.length,
+				buildMs: r
 			});
 			continue;
 		}
-		let s = x?.get(e.id);
-		if (C && C.group !== s && w(), !s) {
-			let t = b.length;
-			for (let e of n) b.push(e);
+		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: b.length,
-				buildMs: o
+				end: y.length,
+				buildMs: r
 			});
 			continue;
 		}
-		C ||= (S.has(s) && console.warn(`[weasel] layer group "${s.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.`), S.add(s), {
-			group: s,
+		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
-		}), C.buildMs += o;
-		for (let e of n) C.children.push(e);
+		}), S.buildMs += r;
+		for (let e of n) S.children.push(e);
 	}
-	return w(), b;
-}
-function o(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);
-			}
-		}
-		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.`);
-	}
-	return r;
-}
-function s(e, t, n, r) {
-	let i = typeof e.effects == "function" ? e.effects(n, r) : e.effects, a = i && i.length > 0 ? i : void 0;
-	return !a && e.alpha === void 0 && e.colorMatrix === void 0 ? t : [{
-		kind: "group",
-		...a ? { effects: a } : {},
-		...e.alpha === void 0 ? {} : { alpha: e.alpha },
-		...e.colorMatrix === void 0 ? {} : { colorMatrix: e.colorMatrix },
-		children: t
-	}];
+	return C(), y;
 }
 function c(e, t) {
 	return e.alwaysOn ? !0 : e.id in t ? t[e.id] : e.defaultVisible ?? !0;
@@ -106,45 +75,50 @@ function c(e, t) {
 function l(e, t, n) {
 	return n && !n.includes(e.id) ? !1 : c(e, t);
 }
-function u(t, r, i, a, o, s = n) {
+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));
+}
+function d(e, t, r, a, o, s = i) {
 	let c;
 	try {
-		c = d(t, r, i, a, o);
-	} catch (e) {
-		return o?.delete(t.id), s({
-			layerId: t.id,
-			error: e
+		c = f(e, t, r, a, o);
+	} catch (t) {
+		return o?.delete(e.id), s({
+			layerId: e.id,
+			error: t
 		}), [];
 	}
 	if (c.length === 0) return [];
-	let l = t.effects && t.effects.length > 0 ? t.effects : void 0;
-	return (t.space ?? "world") === "screen" ? l ? [{
+	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 : [{
 		kind: "group",
-		transform: e(i),
+		transform: n(r),
 		...l ? { effects: l } : {},
 		children: c
 	}];
 }
-function d(e, t, n, r, i) {
+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 && f(o.deps, a)) return o.cmds;
+	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;
 }
-function f(e, t) {
+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;
 }
 //#endregion
-export { f as depsUnchanged, a as drawLayers, u as drawOneLayer, l as isLayerPainted, c as isLayerVisible, r as subscribeToSources };
+export { p as depsUnchanged, s as drawLayers, d as drawOneLayer, l as isLayerPainted, c as isLayerVisible, u as paintedLayers, a as subscribeToSources };
 
 //# sourceMappingURL=render.js.map