@weasel-js/core 1.11.0 → 1.12.0

package/dist/canvas/drawnBounds.js

@@ -1,10 +1,11 @@
-import { axisAlignedBounds } from "../core/geometry/unionBounds.js";
+import { axisAlignedBounds, unionBounds } from "../core/geometry/unionBounds.js";
 import { framedBounds, poseDescriptorForNode } from "../core/geometry/poseDescriptor.js";
 import { AUTO_POSE_DESCRIPTOR } from "../core/geometry/autoPoseDescriptor.js";
+import { inheritedPaintIn } from "./inheritedPaints.js";
 import { targetCorners, targetTransformOf, worldToLocal } from "../core/geometry/targetFrame.js";
 import { NO_INK_EXTENTS, inkExtentsBetween, outsetBox } from "../core/geometry/inkExtents.js";
 import { findNodeShape } from "./NodeShape.js";
-import { meanScale } from "@weasel-js/geom";
+import { boundsOfPath, meanScale } from "@weasel-js/geom";
 
 //#region src/canvas/drawnBounds.ts
 /**
@@ -18,9 +19,12 @@ import { meanScale } from "@weasel-js/geom";
 * drawn in: a turned node's box comes back turned with it. A node with no
 * stroke, a painter that declares no {@link NodeShapeEntry.drawnBounds}, or
 * `includeStroke: false` answers `framedBounds` unchanged. A container's box
-* reaches as far as its members' boxes do.
+* reaches as far as its members' boxes do. A node showing a derived path is
+* boxed around that path, and its placeholder pose plays no part.
 */
 function drawnBoundsOf(scene, id, pose, opts = {}) {
+	const derived = scene.derivedPathOf?.(id) ?? null;
+	if (derived !== null) return derivedBoundsOf(scene, id, pose, derived, opts);
 	return outsetBox(framedBounds(pose, descriptorFor(scene, id, opts)), inkExtentsOf(scene, id, pose, opts));
 }
 /** How far `id`'s ink at `pose` reaches past its pose box on each side, in
@@ -38,9 +42,32 @@ function inkExtentsOf(scene, id, pose, opts = {}) {
 	};
 	const members = node.kind === "container" ? scene.childrenOf?.(id) ?? [] : [];
 	if (members.length > 0) return membersExtents(scene, members, own, opts);
-	const drawn = findShapeDrawnBounds(node, pose, inkCtx(opts.scale, own));
+	const drawn = findShapeDrawnBounds(node, pose, withInherited(scene, node, inkCtx(opts.scale, own)));
 	return drawn === null ? NO_INK_EXTENTS : inkExtentsBetween(normalized(unframed), drawn);
 }
+/** The box of a node drawn along `path`: the path's own, grown by the stroke
+*  its painter reports. */
+function derivedBoundsOf(scene, id, pose, path, opts) {
+	const { x, y, width, height } = boundsOfPath(path);
+	const own = {
+		x,
+		y,
+		width,
+		height
+	};
+	const node = scene.get(id);
+	if (opts.includeStroke === false || !node) return own;
+	const drawn = findShapeDrawnBounds(node, pose, {
+		...withInherited(scene, node, inkCtx(opts.scale, {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		})),
+		derivedPath: path
+	});
+	return drawn === null ? own : unionBounds([own, drawn]) ?? own;
+}
 /** A container's extents: its members' drawn boxes, taken into its own frame,
 *  past its own box. */
 function membersExtents(scene, members, own, opts) {
@@ -102,6 +129,13 @@ function inkCtx(scale, own) {
 		]
 	};
 }
+function withInherited(scene, node, ctx) {
+	const inherited = inheritedPaintIn(scene, node);
+	return inherited === void 0 ? ctx : {
+		...ctx,
+		inherited
+	};
+}
 function normalized(b) {
 	return {
 		x: Math.min(b.x, b.x + b.width),

package/dist/canvas/drawnBounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"drawnBounds.js","names":[],"sources":["../../src/canvas/drawnBounds.ts"],"sourcesContent":["/**\n * The box of a node as drawn — its pose box with the stroke included — which\n * is what selection chrome, resize, rotate, and alignment sit on. Places that\n * store geometry (a group's derived pose, booleans, export) keep reading the\n * pose box through `framedBounds`.\n */\nimport { framedBounds, poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport {\n  inkExtentsBetween,\n  NO_INK_EXTENTS,\n  outsetBox,\n  type InkExtents,\n} from 'core/geometry/inkExtents';\nimport { targetCorners, targetTransformOf, worldToLocal } from 'core/geometry/targetFrame';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport type { Node, NodeId } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { meanScale, type Scale2 } from '@weasel-js/geom';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { findNodeShape, type NodeInkCtx } from './NodeShape';\n\n/** The scene reads {@link drawnBoundsOf} makes. `childrenOf` absent: every\n *  node is a leaf. */\nexport interface DrawnBoundsScene {\n  get(id: NodeId): Node<unknown, string, unknown> | undefined;\n  childrenOf?(id: NodeId): readonly NodeId[];\n}\n\n/** How {@link drawnBoundsOf} reads a node. */\nexport interface DrawnBoundsOptions {\n  /** How poses are read. Default `AUTO_POSE_DESCRIPTOR`. */\n  descriptor?: PoseDescriptor<unknown>;\n  /** A member's world pose, for boxing a container around its members.\n   *  Default: its pose as stored, which is world unless containers compose. */\n  worldPoseOf?: (id: NodeId) => unknown;\n  /** `false` answers the pose box alone. Default `true`. */\n  includeStroke?: boolean;\n  /** View scale, which a screen-pixel stroke width is resolved at. Default 1. */\n  scale?: number | Scale2;\n}\n\n/**\n * The box of `id` drawn at `pose`, stroke included, in the frame the pose is\n * drawn in: a turned node's box comes back turned with it. A node with no\n * stroke, a painter that declares no {@link NodeShapeEntry.drawnBounds}, or\n * `includeStroke: false` answers `framedBounds` unchanged. A container's box\n * reaches as far as its members' boxes do.\n */\nexport function drawnBoundsOf(\n  scene: DrawnBoundsScene,\n  id: NodeId,\n  pose: unknown,\n  opts: DrawnBoundsOptions = {},\n): Bounds {\n  return outsetBox(framedBounds(pose, descriptorFor(scene, id, opts)), inkExtentsOf(scene, id, pose, opts));\n}\n\n/** How far `id`'s ink at `pose` reaches past its pose box on each side, in\n *  the box's own frame: what {@link drawnBoundsOf} grows the pose box by. */\nexport function inkExtentsOf(\n  scene: DrawnBoundsScene,\n  id: NodeId,\n  pose: unknown,\n  opts: DrawnBoundsOptions = {},\n): InkExtents {\n  if (opts.includeStroke === false) return NO_INK_EXTENTS;\n  const node = scene.get(id);\n  if (!node) return NO_INK_EXTENTS;\n  const own = framedBounds(pose, descriptorFor(scene, id, opts));\n  const unframed = { x: own.x, y: own.y, width: own.width, height: own.height };\n  const members = node.kind === 'container' ? scene.childrenOf?.(id) ?? [] : [];\n  if (members.length > 0) return membersExtents(scene, members, own, opts);\n  const drawn = findShapeDrawnBounds(node, pose, inkCtx(opts.scale, own));\n  return drawn === null ? NO_INK_EXTENTS : inkExtentsBetween(normalized(unframed), drawn);\n}\n\n/** A container's extents: its members' drawn boxes, taken into its own frame,\n *  past its own box. */\nfunction membersExtents(\n  scene: DrawnBoundsScene,\n  members: readonly NodeId[],\n  own: Bounds,\n  opts: DrawnBoundsOptions,\n): InkExtents {\n  const xf = targetTransformOf(own);\n  const worldPoseOf = opts.worldPoseOf ?? ((m: NodeId) => scene.get(m)?.pose);\n  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;\n  for (const m of members) {\n    const box = drawnBoundsOf(scene, m, worldPoseOf(m), opts);\n    for (const c of targetCorners(box, targetTransformOf(box))) {\n      const p = worldToLocal(xf, c.x, c.y);\n      if (!p) continue;\n      x0 = Math.min(x0, p.x); y0 = Math.min(y0, p.y);\n      x1 = Math.max(x1, p.x); y1 = Math.max(y1, p.y);\n    }\n  }\n  if (x0 === Infinity) return NO_INK_EXTENTS;\n  return inkExtentsBetween(normalized(own), { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });\n}\n\n/** {@link drawnBoundsOf} as an axis-aligned box: what a turned node covers. */\nexport function drawnAABBOf(\n  scene: DrawnBoundsScene,\n  id: NodeId,\n  pose: unknown,\n  opts: DrawnBoundsOptions = {},\n): Bounds {\n  return axisAlignedBounds(drawnBoundsOf(scene, id, pose, opts));\n}\n\n/** The painter's {@link NodeShapeEntry.drawnBounds} for `node`, or `null`\n *  when no painter matches or the one that does declares none. */\nexport function findShapeDrawnBounds<TData, TPose>(\n  node: Node<TData, string, TPose>,\n  pose: TPose,\n  ctx?: NodeInkCtx,\n): Bounds | null {\n  return findNodeShape(node)?.drawnBounds?.(node, pose, ctx) ?? null;\n}\n\nfunction descriptorFor(scene: DrawnBoundsScene, id: NodeId, opts: DrawnBoundsOptions): PoseDescriptor<unknown> {\n  const d = opts.descriptor ?? AUTO_POSE_DESCRIPTOR;\n  const node = scene.get(id);\n  return node ? poseDescriptorForNode(d, node) : d;\n}\n\n/** A per-axis view scale also carries the map from `own`'s frame to screen,\n *  so a `{ px }` stroke is measured there rather than at the mean. */\nfunction inkCtx(scale: number | Scale2 | undefined, own: Bounds): NodeInkCtx | undefined {\n  if (scale === undefined) return undefined;\n  if (typeof scale === 'number') return { scale };\n  const xf = targetTransformOf(own);\n  const [a, b, c, d] = xf.identity ? [1, 0, 0, 1] : xf.toWorld;\n  return { scale: meanScale(scale), screen: [scale.x * a, scale.y * b, scale.x * c, scale.y * d] };\n}\n\nfunction normalized(b: Bounds): Bounds {\n  return {\n    x: Math.min(b.x, b.x + b.width),\n    y: Math.min(b.y, b.y + b.height),\n    width: Math.abs(b.width),\n    height: Math.abs(b.height),\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"drawnBounds.js","names":[],"sources":["../../src/canvas/drawnBounds.ts"],"sourcesContent":["/**\n * The box of a node as drawn — its pose box with the stroke included — which\n * is what selection chrome, resize, rotate, and alignment sit on. Places that\n * store geometry (a group's derived pose, booleans, export) keep reading the\n * pose box through `framedBounds`.\n */\nimport { inheritedPaintIn } from './inheritedPaints';\nimport { framedBounds, poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport {\n  inkExtentsBetween,\n  NO_INK_EXTENTS,\n  outsetBox,\n  type InkExtents,\n} from 'core/geometry/inkExtents';\nimport { targetCorners, targetTransformOf, worldToLocal } from 'core/geometry/targetFrame';\nimport { axisAlignedBounds, unionBounds } from 'core/geometry/unionBounds';\nimport type { Node, NodeId } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { boundsOfPath, meanScale, type Path, type Scale2 } from '@weasel-js/geom';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { findNodeShape, type NodeInkCtx } from './NodeShape';\n\n/** The scene reads {@link drawnBoundsOf} makes. `childrenOf` absent: every\n *  node is a leaf. `derivedPathOf` absent: every node is measured by its pose,\n *  a path-derived one included — `drawnBoundsScene` supplies it for a `Scene`. */\nexport interface DrawnBoundsScene {\n  get(id: NodeId): Node<unknown, string, unknown> | undefined;\n  childrenOf?(id: NodeId): readonly NodeId[];\n  /** The path a node shows in place of its pose's, or `null` for one that shows its own. */\n  derivedPathOf?(id: NodeId): Path | null;\n}\n\n/** How {@link drawnBoundsOf} reads a node. */\nexport interface DrawnBoundsOptions {\n  /** How poses are read. Default `AUTO_POSE_DESCRIPTOR`. */\n  descriptor?: PoseDescriptor<unknown>;\n  /** A member's world pose, for boxing a container around its members.\n   *  Default: its pose as stored, which is world unless containers compose. */\n  worldPoseOf?: (id: NodeId) => unknown;\n  /** `false` answers the pose box alone. Default `true`. */\n  includeStroke?: boolean;\n  /** View scale, which a screen-pixel stroke width is resolved at. Default 1. */\n  scale?: number | Scale2;\n}\n\n/**\n * The box of `id` drawn at `pose`, stroke included, in the frame the pose is\n * drawn in: a turned node's box comes back turned with it. A node with no\n * stroke, a painter that declares no {@link NodeShapeEntry.drawnBounds}, or\n * `includeStroke: false` answers `framedBounds` unchanged. A container's box\n * reaches as far as its members' boxes do. A node showing a derived path is\n * boxed around that path, and its placeholder pose plays no part.\n */\nexport function drawnBoundsOf(\n  scene: DrawnBoundsScene,\n  id: NodeId,\n  pose: unknown,\n  opts: DrawnBoundsOptions = {},\n): Bounds {\n  const derived = scene.derivedPathOf?.(id) ?? null;\n  if (derived !== null) return derivedBoundsOf(scene, id, pose, derived, opts);\n  return outsetBox(framedBounds(pose, descriptorFor(scene, id, opts)), inkExtentsOf(scene, id, pose, opts));\n}\n\n/** How far `id`'s ink at `pose` reaches past its pose box on each side, in\n *  the box's own frame: what {@link drawnBoundsOf} grows the pose box by. */\nexport function inkExtentsOf(\n  scene: DrawnBoundsScene,\n  id: NodeId,\n  pose: unknown,\n  opts: DrawnBoundsOptions = {},\n): InkExtents {\n  if (opts.includeStroke === false) return NO_INK_EXTENTS;\n  const node = scene.get(id);\n  if (!node) return NO_INK_EXTENTS;\n  const own = framedBounds(pose, descriptorFor(scene, id, opts));\n  const unframed = { x: own.x, y: own.y, width: own.width, height: own.height };\n  const members = node.kind === 'container' ? scene.childrenOf?.(id) ?? [] : [];\n  if (members.length > 0) return membersExtents(scene, members, own, opts);\n  const drawn = findShapeDrawnBounds(node, pose, withInherited(scene, node, inkCtx(opts.scale, own)));\n  return drawn === null ? NO_INK_EXTENTS : inkExtentsBetween(normalized(unframed), drawn);\n}\n\n/** The box of a node drawn along `path`: the path's own, grown by the stroke\n *  its painter reports. */\nfunction derivedBoundsOf(scene: DrawnBoundsScene, id: NodeId, pose: unknown, path: Path, opts: DrawnBoundsOptions): Bounds {\n  const { x, y, width, height } = boundsOfPath(path);\n  const own = { x, y, width, height };\n  const node = scene.get(id);\n  if (opts.includeStroke === false || !node) return own;\n  const ctx = { ...withInherited(scene, node, inkCtx(opts.scale, { x: 0, y: 0, width: 0, height: 0 })), derivedPath: path };\n  const drawn = findShapeDrawnBounds(node, pose, ctx);\n  return drawn === null ? own : unionBounds([own, drawn]) ?? own;\n}\n\n/** A container's extents: its members' drawn boxes, taken into its own frame,\n *  past its own box. */\nfunction membersExtents(\n  scene: DrawnBoundsScene,\n  members: readonly NodeId[],\n  own: Bounds,\n  opts: DrawnBoundsOptions,\n): InkExtents {\n  const xf = targetTransformOf(own);\n  const worldPoseOf = opts.worldPoseOf ?? ((m: NodeId) => scene.get(m)?.pose);\n  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;\n  for (const m of members) {\n    const box = drawnBoundsOf(scene, m, worldPoseOf(m), opts);\n    for (const c of targetCorners(box, targetTransformOf(box))) {\n      const p = worldToLocal(xf, c.x, c.y);\n      if (!p) continue;\n      x0 = Math.min(x0, p.x); y0 = Math.min(y0, p.y);\n      x1 = Math.max(x1, p.x); y1 = Math.max(y1, p.y);\n    }\n  }\n  if (x0 === Infinity) return NO_INK_EXTENTS;\n  return inkExtentsBetween(normalized(own), { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });\n}\n\n/** {@link drawnBoundsOf} as an axis-aligned box: what a turned node covers. */\nexport function drawnAABBOf(\n  scene: DrawnBoundsScene,\n  id: NodeId,\n  pose: unknown,\n  opts: DrawnBoundsOptions = {},\n): Bounds {\n  return axisAlignedBounds(drawnBoundsOf(scene, id, pose, opts));\n}\n\n/** The painter's {@link NodeShapeEntry.drawnBounds} for `node`, or `null`\n *  when no painter matches or the one that does declares none. */\nexport function findShapeDrawnBounds<TData, TPose>(\n  node: Node<TData, string, TPose>,\n  pose: TPose,\n  ctx?: NodeInkCtx,\n): Bounds | null {\n  return findNodeShape(node)?.drawnBounds?.(node, pose, ctx) ?? null;\n}\n\nfunction descriptorFor(scene: DrawnBoundsScene, id: NodeId, opts: DrawnBoundsOptions): PoseDescriptor<unknown> {\n  const d = opts.descriptor ?? AUTO_POSE_DESCRIPTOR;\n  const node = scene.get(id);\n  return node ? poseDescriptorForNode(d, node) : d;\n}\n\n/** A per-axis view scale also carries the map from `own`'s frame to screen,\n *  so a `{ px }` stroke is measured there rather than at the mean. */\nfunction inkCtx(scale: number | Scale2 | undefined, own: Bounds): NodeInkCtx | undefined {\n  if (scale === undefined) return undefined;\n  if (typeof scale === 'number') return { scale };\n  const xf = targetTransformOf(own);\n  const [a, b, c, d] = xf.identity ? [1, 0, 0, 1] : xf.toWorld;\n  return { scale: meanScale(scale), screen: [scale.x * a, scale.y * b, scale.x * c, scale.y * d] };\n}\n\nfunction withInherited(\n  scene: DrawnBoundsScene,\n  node: Node<unknown, string, unknown>,\n  ctx: NodeInkCtx | undefined,\n): NodeInkCtx | undefined {\n  const inherited = inheritedPaintIn(scene, node);\n  return inherited === undefined ? ctx : { ...ctx, inherited };\n}\n\nfunction normalized(b: Bounds): Bounds {\n  return {\n    x: Math.min(b.x, b.x + b.width),\n    y: Math.min(b.y, b.y + b.height),\n    width: Math.abs(b.width),\n    height: Math.abs(b.height),\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/inheritedPaints.js

@@ -0,0 +1,44 @@
+import { inheritedPaintOf, inheritsPaint, sceneAncestors } from "../core/scene/inheritedPaint.js";
+import { INHERIT } from "@weasel-js/paint";
+
+//#region src/canvas/inheritedPaints.ts
+/** What `node`'s `'inherit'` fields take from its containers in `scene`, or
+*  `undefined` for a node that inherits nothing. */
+function inheritedPaintIn(scene, node) {
+	if (!inheritsPaint(node)) return void 0;
+	return inheritedPaintOf(node, sceneAncestors((id) => scene.get(id), node));
+}
+var INHERITS_BOTH = { data: {
+	fill: INHERIT,
+	stroke: INHERIT
+} };
+/** What an `'inherit'` fill and stroke on `node` would take from its
+*  containers in `scene`, whatever `node` holds now — what an editor offering
+*  the choice shows it would paint. */
+function paintAbove(scene, node) {
+	return inheritedPaintOf(INHERITS_BOTH, sceneAncestors((id) => scene.get(id), node));
+}
+/** {@link inheritedPaintIn} bound to `scene`. */
+function sceneInheritedPaintOf(scene) {
+	return (node) => inheritedPaintIn(scene, node);
+}
+/**
+* Wrap a `drawOne` so a node whose fill or stroke is `'inherit'` arrives at
+* the painter with its containers' paint on `ctx.inherited`, as
+* `withDerivedPaths` does for a derived path. Every other node passes the
+* caller's `ctx` through untouched.
+*/
+function withInheritedPaints(scene, drawOne) {
+	const inheritedOf = sceneInheritedPaintOf(scene);
+	return (node, pose, view, ctx) => {
+		const inherited = inheritedOf(node);
+		return inherited === void 0 ? drawOne(node, pose, view, ctx) : drawOne(node, pose, view, {
+			...ctx,
+			inherited
+		});
+	};
+}
+
+//#endregion
+export { inheritedPaintIn, paintAbove, sceneInheritedPaintOf, withInheritedPaints };
+//# sourceMappingURL=inheritedPaints.js.map

package/dist/canvas/inheritedPaints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritedPaints.js","names":[],"sources":["../../src/canvas/inheritedPaints.ts"],"sourcesContent":["import { INHERIT } from '@weasel-js/paint';\nimport type { Node, NodeId } from 'core/scene/types';\nimport { inheritedPaintOf, inheritsPaint, sceneAncestors, type InheritedPaint } from 'core/scene/inheritedPaint';\nimport type { SceneViewDrawOne } from './nodeShapeTypes';\n\n/** The part of a scene the lookup reads. */\ntype ParentLookup<TNode> = { get(id: NodeId): TNode | undefined };\n\ntype PaintedNode = { data?: unknown; parent?: NodeId | null };\n\n/** What `node`'s `'inherit'` fields take from its containers in `scene`, or\n *  `undefined` for a node that inherits nothing. */\nexport function inheritedPaintIn<TNode extends PaintedNode>(\n  scene: ParentLookup<TNode>,\n  node: TNode,\n): InheritedPaint | undefined {\n  if (!inheritsPaint(node)) return undefined;\n  return inheritedPaintOf(node, sceneAncestors((id: never) => scene.get(id), node));\n}\n\nconst INHERITS_BOTH = { data: { fill: INHERIT, stroke: INHERIT } };\n\n/** What an `'inherit'` fill and stroke on `node` would take from its\n *  containers in `scene`, whatever `node` holds now — what an editor offering\n *  the choice shows it would paint. */\nexport function paintAbove<TNode extends PaintedNode>(scene: ParentLookup<TNode>, node: TNode): InheritedPaint {\n  return inheritedPaintOf(INHERITS_BOTH, sceneAncestors((id: never) => scene.get(id), node));\n}\n\n/** {@link inheritedPaintIn} bound to `scene`. */\nexport function sceneInheritedPaintOf<TNode extends PaintedNode>(\n  scene: ParentLookup<TNode>,\n): (node: TNode) => InheritedPaint | undefined {\n  return (node) => inheritedPaintIn(scene, node);\n}\n\n/**\n * Wrap a `drawOne` so a node whose fill or stroke is `'inherit'` arrives at\n * the painter with its containers' paint on `ctx.inherited`, as\n * `withDerivedPaths` does for a derived path. Every other node passes the\n * caller's `ctx` through untouched.\n */\nexport function withInheritedPaints<TData, TLayer extends string, TPose>(\n  scene: ParentLookup<Node<TData, TLayer, TPose>>,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n): SceneViewDrawOne<TData, TLayer, TPose> {\n  const inheritedOf = sceneInheritedPaintOf(scene);\n  return (node, pose, view, ctx) => {\n    const inherited = inheritedOf(node);\n    return inherited === undefined ? drawOne(node, pose, view, ctx) : drawOne(node, pose, view, { ...ctx, inherited });\n  };\n}\n"],"mappings":";;;;;;AAYA,SAAgB,iBACd,OACA,MAC4B;CAC5B,IAAI,CAAC,cAAc,IAAI,GAAG,OAAO;CACjC,OAAO,iBAAiB,MAAM,gBAAgB,OAAc,MAAM,IAAI,EAAE,GAAG,IAAI,CAAC;AAClF;AAEA,IAAM,gBAAgB,EAAE,MAAM;CAAE,MAAM;CAAS,QAAQ;AAAQ,EAAE;;;;AAKjE,SAAgB,WAAsC,OAA4B,MAA6B;CAC7G,OAAO,iBAAiB,eAAe,gBAAgB,OAAc,MAAM,IAAI,EAAE,GAAG,IAAI,CAAC;AAC3F;;AAGA,SAAgB,sBACd,OAC6C;CAC7C,QAAQ,SAAS,iBAAiB,OAAO,IAAI;AAC/C;;;;;;;AAQA,SAAgB,oBACd,OACA,SACwC;CACxC,MAAM,cAAc,sBAAsB,KAAK;CAC/C,QAAQ,MAAM,MAAM,MAAM,QAAQ;EAChC,MAAM,YAAY,YAAY,IAAI;EAClC,OAAO,cAAc,SAAY,QAAQ,MAAM,MAAM,MAAM,GAAG,IAAI,QAAQ,MAAM,MAAM,MAAM;GAAE,GAAG;GAAK;EAAU,CAAC;CACnH;AACF"}

package/dist/canvas/nodeShapes/derivedPainter.js

@@ -1,9 +1,10 @@
-import { derivedPartsOf } from "../../core/scene/derivedParts.js";
-import { DEFAULT_SHAPE_FILL } from "../../util/paint.js";
+import { derivedPartsOf, resolvePartPaint } from "../../core/scene/derivedParts.js";
 import { derivesPath } from "./memo.js";
-import { inkReach, resolveNodeFill, resolveNodeStroke, withAnimatedVertexColors } from "./nodePaint.js";
+import { inkReach, withAnimatedVertexColors } from "./nodePaint.js";
+import { strokedBounds } from "./strokedBounds.js";
 import { commandFill, commandStroke } from "@weasel-js/renderer";
 import { boundsOfPath } from "@weasel-js/geom";
+import { resolveFill, resolveStroke } from "@weasel-js/paint";
 
 //#region src/canvas/nodeShapes/derivedPainter.ts
 function pathCommand(path, declared, strokeSpec, vertexColors) {
@@ -18,11 +19,16 @@ function pathCommand(path, declared, strokeSpec, vertexColors) {
 		...stroke ? { stroke } : {}
 	};
 }
-/** One part's command: its own paint where it names one, else the node's. */
-function partCommand(part, d) {
-	const strokeSpec = resolveNodeStroke(part.stroke === void 0 ? d?.stroke : part.stroke);
-	const declared = resolveNodeFill(part.fill === void 0 ? d?.fill : part.fill, strokeSpec === null ? DEFAULT_SHAPE_FILL : null);
-	return pathCommand(part.path, declared, strokeSpec, void 0);
+/** The stroked box of the path on `ctx`, or `null` with no path or no stroke. */
+function derivedDrawnBounds(node, ctx) {
+	const path = ctx?.derivedPath;
+	const stroke = resolveStroke(node.data?.stroke, ctx?.inherited?.stroke);
+	return path == null || stroke === null ? null : strokedBounds(path, stroke, ctx?.scale ?? 1, ctx?.screen);
+}
+/** One part's command, in its own paint; `INHERIT` takes the node's. */
+function partCommand(part, d, inherited) {
+	const { fill, stroke } = resolvePartPaint(part, d, inherited);
+	return pathCommand(part.path, fill, stroke, void 0);
 }
 /**
 * Built-in painter for nodes whose geometry is computed from other nodes'
@@ -42,8 +48,8 @@ function partCommand(part, d) {
 * Rotation still comes from the pose — `wrapNodeOutput` turns the output about
 * the pose AABB's center, which for a zero-sized pose is its origin.
 *
-* A path made by `pathFromParts` paints one command per part, each with the
-* part's own fill and stroke where it names them.
+* A path made by `pathFromParts` paints one command per part, each in the
+* part's own fill and stroke.
 */
 var DERIVED_PAINTER = {
 	id: "kit:derived",
@@ -53,22 +59,23 @@ var DERIVED_PAINTER = {
 		if (path == null) return [];
 		const d = node.data;
 		const parts = derivedPartsOf(path);
-		if (parts !== void 0) return parts.map((part) => partCommand(part, d));
-		const strokeSpec = resolveNodeStroke(d?.stroke);
-		const declared = resolveNodeFill(d?.fill, strokeSpec === null ? DEFAULT_SHAPE_FILL : null);
+		if (parts !== void 0) return parts.map((part) => partCommand(part, d, ctx?.inherited));
+		const strokeSpec = resolveStroke(d?.stroke, ctx?.inherited?.stroke);
+		const declared = resolveFill(d?.fill, ctx?.inherited?.fill);
 		return withAnimatedVertexColors([pathCommand(path, declared, strokeSpec, d?.vertexColors)], ctx);
 	},
 	silhouette: (_node, _pose, ctx) => ctx?.derivedPath ?? null,
+	drawnBounds: (node, _pose, ctx) => derivedDrawnBounds(node, ctx),
 	ink: (node, _pose, ctx) => {
 		const d = node.data;
-		const stroke = resolveNodeStroke(d?.stroke);
+		const stroke = resolveStroke(d?.stroke, ctx?.inherited?.stroke);
 		return {
-			filled: resolveNodeFill(d?.fill, stroke === null ? DEFAULT_SHAPE_FILL : null) !== null,
+			filled: resolveFill(d?.fill, ctx?.inherited?.fill) !== null,
 			...inkReach(stroke, ctx?.scale)
 		};
 	}
 };
 
 //#endregion
-export { DERIVED_PAINTER };
+export { DERIVED_PAINTER, derivedDrawnBounds };
 //# sourceMappingURL=derivedPainter.js.map

package/dist/canvas/nodeShapes/derivedPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"derivedPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/derivedPainter.ts"],"sourcesContent":["import { boundsOfPath, type Path } from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { derivedPartsOf, type DerivedPart } from 'core/scene/derivedParts';\nimport { derivesPath } from './memo';\nimport {\n  inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke, type PaintedFill, type PaintedStroke,\n} from './nodePaint';\n\ntype PaintData = { fill?: Fill | null; stroke?: Stroke | null; vertexColors?: number[] };\n\nfunction pathCommand(\n  path: Path,\n  declared: PaintedFill | null,\n  strokeSpec: PaintedStroke | null,\n  vertexColors: number[] | undefined,\n): DrawCommand {\n  const box = boundsOfPath(path);\n  const fill = declared && commandFill(declared, box);\n  const stroke = strokeSpec && commandStroke(strokeSpec, box);\n  return {\n    kind: 'path',\n    path,\n    ...(fill ? { fill } : {}),\n    ...(fill && vertexColors ? { vertexColors } : {}),\n    ...(stroke ? { stroke } : {}),\n  };\n}\n\n/** One part's command: its own paint where it names one, else the node's. */\nfunction partCommand(part: DerivedPart, d: PaintData | null): DrawCommand {\n  const strokeSpec = resolveNodeStroke(part.stroke === undefined ? d?.stroke : part.stroke);\n  const declared = resolveNodeFill(\n    part.fill === undefined ? d?.fill : part.fill,\n    strokeSpec === null ? DEFAULT_SHAPE_FILL : null,\n  );\n  return pathCommand(part.path, declared, strokeSpec, undefined);\n}\n\n/**\n * Built-in painter for nodes whose geometry is computed from other nodes'\n * poses. The path itself arrives on the paint context — see\n * {@link NodePaintCtx.derivedPath}.\n *\n * Fill and stroke resolve as `kit:path`'s do, but against the **derived path's\n * own bounds**, not the pose. `kit:path` projects its path into the pose frame\n * first, so there the two boxes are the same one; here the path is already\n * absolute and the pose is typically a zero-sized placeholder, which would\n * collapse a box-relative gradient onto a point.\n *\n * Not memoized on {@link PAINT_SLOT} on purpose: that key is `(node, pose,\n * data)` and cannot see `ctx.derivedPath`, so it would serve one caller's\n * commands to a caller that passed a different path.\n *\n * Rotation still comes from the pose — `wrapNodeOutput` turns the output about\n * the pose AABB's center, which for a zero-sized pose is its origin.\n *\n * A path made by `pathFromParts` paints one command per part, each with the\n * part's own fill and stroke where it names them.\n */\nexport const DERIVED_PAINTER: NodeShapeEntry = {\n  id: 'kit:derived',\n  // `dependsOn` alone is not enough: the two fields are independent optionals,\n  // and `kit:add` restores a node with its `dependsOn` intact when its\n  // `derivePath` key is missing from the registry. Claiming that node would paint\n  // nothing where the authored appearance is what the warning promises.\n  matches: derivesPath,\n  paint: (node, _pose, ctx) => {\n    const path = ctx?.derivedPath;\n    if (path == null) return [];\n    const d = node.data as PaintData | null;\n    const parts = derivedPartsOf(path);\n    if (parts !== undefined) return parts.map((part) => partCommand(part, d));\n    const strokeSpec = resolveNodeStroke(d?.stroke);\n    const declared = resolveNodeFill(d?.fill, strokeSpec === null ? DEFAULT_SHAPE_FILL : null);\n    return withAnimatedVertexColors([pathCommand(path, declared, strokeSpec, d?.vertexColors)], ctx);\n  },\n  // The derived path *is* the silhouette, and it is already absolute — the\n  // pose is a placeholder, so nothing here can be recovered from it. Without\n  // a `ctx` this reports null, which `shapeCoversPoint` reads as \"no\n  // opinion\": picking then falls back to that zero-sized pose.\n  silhouette: (_node, _pose, ctx) => ctx?.derivedPath ?? null,\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: Fill | null; stroke?: Stroke | null } | null;\n    const stroke = resolveNodeStroke(d?.stroke);\n    return {\n      filled: resolveNodeFill(d?.fill, stroke === null ? DEFAULT_SHAPE_FILL : null) !== null,\n      ...inkReach(stroke, ctx?.scale),\n    };\n  },\n};\n"],"mappings":";;;;;;;;AAcA,SAAS,YACP,MACA,UACA,YACA,cACa;CACb,MAAM,MAAM,aAAa,IAAI;CAC7B,MAAM,OAAO,YAAY,YAAY,UAAU,GAAG;CAClD,MAAM,SAAS,cAAc,cAAc,YAAY,GAAG;CAC1D,OAAO;EACL,MAAM;EACN;EACA,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;EACvB,GAAI,QAAQ,eAAe,EAAE,aAAa,IAAI,CAAC;EAC/C,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;CAC7B;AACF;;AAGA,SAAS,YAAY,MAAmB,GAAkC;CACxE,MAAM,aAAa,kBAAkB,KAAK,WAAW,SAAY,GAAG,SAAS,KAAK,MAAM;CACxF,MAAM,WAAW,gBACf,KAAK,SAAS,SAAY,GAAG,OAAO,KAAK,MACzC,eAAe,OAAO,qBAAqB,IAC7C;CACA,OAAO,YAAY,KAAK,MAAM,UAAU,YAAY,MAAS;AAC/D;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,kBAAkC;CAC7C,IAAI;CAKJ,SAAS;CACT,QAAQ,MAAM,OAAO,QAAQ;EAC3B,MAAM,OAAO,KAAK;EAClB,IAAI,QAAQ,MAAM,OAAO,CAAC;EAC1B,MAAM,IAAI,KAAK;EACf,MAAM,QAAQ,eAAe,IAAI;EACjC,IAAI,UAAU,QAAW,OAAO,MAAM,KAAK,SAAS,YAAY,MAAM,CAAC,CAAC;EACxE,MAAM,aAAa,kBAAkB,GAAG,MAAM;EAC9C,MAAM,WAAW,gBAAgB,GAAG,MAAM,eAAe,OAAO,qBAAqB,IAAI;EACzF,OAAO,yBAAyB,CAAC,YAAY,MAAM,UAAU,YAAY,GAAG,YAAY,CAAC,GAAG,GAAG;CACjG;CAKA,aAAa,OAAO,OAAO,QAAQ,KAAK,eAAe;CACvD,MAAM,MAAM,OAAO,QAAQ;EACzB,MAAM,IAAI,KAAK;EACf,MAAM,SAAS,kBAAkB,GAAG,MAAM;EAC1C,OAAO;GACL,QAAQ,gBAAgB,GAAG,MAAM,WAAW,OAAO,qBAAqB,IAAI,MAAM;GAClF,GAAG,SAAS,QAAQ,KAAK,KAAK;EAChC;CACF;AACF"}
+{"version":3,"file":"derivedPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/derivedPainter.ts"],"sourcesContent":["import { boundsOfPath, type Path } from '@weasel-js/geom';\nimport type { Stroke, Fill, Inherit } from '@weasel-js/paint';\nimport type { NodeInkCtx, NodeShapeEntry } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { derivedPartsOf, resolvePartPaint, type DerivedPart } from 'core/scene/derivedParts';\nimport { derivesPath } from './memo';\nimport type { InheritedPaint } from 'core/scene/inheritedPaint';\nimport { strokedBounds } from './strokedBounds';\nimport { inkReach, withAnimatedVertexColors } from './nodePaint';\nimport { resolveFill, resolveStroke, type PaintedFill, type PaintedStroke } from '@weasel-js/paint';\n\ntype PaintData = { fill?: Fill | Inherit | null; stroke?: Stroke | Inherit | null; vertexColors?: number[] };\n\nfunction pathCommand(\n  path: Path,\n  declared: PaintedFill | null,\n  strokeSpec: PaintedStroke | null,\n  vertexColors: number[] | undefined,\n): DrawCommand {\n  const box = boundsOfPath(path);\n  const fill = declared && commandFill(declared, box);\n  const stroke = strokeSpec && commandStroke(strokeSpec, box);\n  return {\n    kind: 'path',\n    path,\n    ...(fill ? { fill } : {}),\n    ...(fill && vertexColors ? { vertexColors } : {}),\n    ...(stroke ? { stroke } : {}),\n  };\n}\n\n/** The stroked box of the path on `ctx`, or `null` with no path or no stroke. */\nexport function derivedDrawnBounds(node: { data?: unknown }, ctx: NodeInkCtx | undefined): Bounds | null {\n  const path = ctx?.derivedPath;\n  const stroke = resolveStroke((node.data as PaintData | null)?.stroke, ctx?.inherited?.stroke);\n  return path == null || stroke === null ? null : strokedBounds(path, stroke, ctx?.scale ?? 1, ctx?.screen);\n}\n\n/** One part's command, in its own paint; `INHERIT` takes the node's. */\nfunction partCommand(part: DerivedPart, d: PaintData | null, inherited: InheritedPaint | undefined): DrawCommand {\n  const { fill, stroke } = resolvePartPaint(part, d, inherited);\n  return pathCommand(part.path, fill, stroke, undefined);\n}\n\n/**\n * Built-in painter for nodes whose geometry is computed from other nodes'\n * poses. The path itself arrives on the paint context — see\n * {@link NodePaintCtx.derivedPath}.\n *\n * Fill and stroke resolve as `kit:path`'s do, but against the **derived path's\n * own bounds**, not the pose. `kit:path` projects its path into the pose frame\n * first, so there the two boxes are the same one; here the path is already\n * absolute and the pose is typically a zero-sized placeholder, which would\n * collapse a box-relative gradient onto a point.\n *\n * Not memoized on {@link PAINT_SLOT} on purpose: that key is `(node, pose,\n * data)` and cannot see `ctx.derivedPath`, so it would serve one caller's\n * commands to a caller that passed a different path.\n *\n * Rotation still comes from the pose — `wrapNodeOutput` turns the output about\n * the pose AABB's center, which for a zero-sized pose is its origin.\n *\n * A path made by `pathFromParts` paints one command per part, each in the\n * part's own fill and stroke.\n */\nexport const DERIVED_PAINTER: NodeShapeEntry = {\n  id: 'kit:derived',\n  // `dependsOn` alone is not enough: the two fields are independent optionals,\n  // and `kit:add` restores a node with its `dependsOn` intact when its\n  // `derivePath` key is missing from the registry. Claiming that node would paint\n  // nothing where the authored appearance is what the warning promises.\n  matches: derivesPath,\n  paint: (node, _pose, ctx) => {\n    const path = ctx?.derivedPath;\n    if (path == null) return [];\n    const d = node.data as PaintData | null;\n    const parts = derivedPartsOf(path);\n    if (parts !== undefined) return parts.map((part) => partCommand(part, d, ctx?.inherited));\n    const strokeSpec = resolveStroke(d?.stroke, ctx?.inherited?.stroke);\n    const declared = resolveFill(d?.fill, ctx?.inherited?.fill);\n    return withAnimatedVertexColors([pathCommand(path, declared, strokeSpec, d?.vertexColors)], ctx);\n  },\n  // The derived path *is* the silhouette, and it is already absolute — the\n  // pose is a placeholder, so nothing here can be recovered from it. Without\n  // a `ctx` this reports null, which `shapeCoversPoint` reads as \"no\n  // opinion\": picking then falls back to that zero-sized pose.\n  silhouette: (_node, _pose, ctx) => ctx?.derivedPath ?? null,\n  drawnBounds: (node, _pose, ctx) => derivedDrawnBounds(node, ctx),\n  ink: (node, _pose, ctx) => {\n    const d = node.data as PaintData | null;\n    const stroke = resolveStroke(d?.stroke, ctx?.inherited?.stroke);\n    return {\n      filled: resolveFill(d?.fill, ctx?.inherited?.fill) !== null,\n      ...inkReach(stroke, ctx?.scale),\n    };\n  },\n};\n"],"mappings":";;;;;;;;;AAeA,SAAS,YACP,MACA,UACA,YACA,cACa;CACb,MAAM,MAAM,aAAa,IAAI;CAC7B,MAAM,OAAO,YAAY,YAAY,UAAU,GAAG;CAClD,MAAM,SAAS,cAAc,cAAc,YAAY,GAAG;CAC1D,OAAO;EACL,MAAM;EACN;EACA,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;EACvB,GAAI,QAAQ,eAAe,EAAE,aAAa,IAAI,CAAC;EAC/C,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;CAC7B;AACF;;AAGA,SAAgB,mBAAmB,MAA0B,KAA4C;CACvG,MAAM,OAAO,KAAK;CAClB,MAAM,SAAS,cAAe,KAAK,MAA2B,QAAQ,KAAK,WAAW,MAAM;CAC5F,OAAO,QAAQ,QAAQ,WAAW,OAAO,OAAO,cAAc,MAAM,QAAQ,KAAK,SAAS,GAAG,KAAK,MAAM;AAC1G;;AAGA,SAAS,YAAY,MAAmB,GAAqB,WAAoD;CAC/G,MAAM,EAAE,MAAM,WAAW,iBAAiB,MAAM,GAAG,SAAS;CAC5D,OAAO,YAAY,KAAK,MAAM,MAAM,QAAQ,MAAS;AACvD;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,kBAAkC;CAC7C,IAAI;CAKJ,SAAS;CACT,QAAQ,MAAM,OAAO,QAAQ;EAC3B,MAAM,OAAO,KAAK;EAClB,IAAI,QAAQ,MAAM,OAAO,CAAC;EAC1B,MAAM,IAAI,KAAK;EACf,MAAM,QAAQ,eAAe,IAAI;EACjC,IAAI,UAAU,QAAW,OAAO,MAAM,KAAK,SAAS,YAAY,MAAM,GAAG,KAAK,SAAS,CAAC;EACxF,MAAM,aAAa,cAAc,GAAG,QAAQ,KAAK,WAAW,MAAM;EAClE,MAAM,WAAW,YAAY,GAAG,MAAM,KAAK,WAAW,IAAI;EAC1D,OAAO,yBAAyB,CAAC,YAAY,MAAM,UAAU,YAAY,GAAG,YAAY,CAAC,GAAG,GAAG;CACjG;CAKA,aAAa,OAAO,OAAO,QAAQ,KAAK,eAAe;CACvD,cAAc,MAAM,OAAO,QAAQ,mBAAmB,MAAM,GAAG;CAC/D,MAAM,MAAM,OAAO,QAAQ;EACzB,MAAM,IAAI,KAAK;EACf,MAAM,SAAS,cAAc,GAAG,QAAQ,KAAK,WAAW,MAAM;EAC9D,OAAO;GACL,QAAQ,YAAY,GAAG,MAAM,KAAK,WAAW,IAAI,MAAM;GACvD,GAAG,SAAS,QAAQ,KAAK,KAAK;EAChC;CACF;AACF"}

package/dist/canvas/nodeShapes/nodePaint.js

@@ -1,37 +1,17 @@
 import { bumpNodeMemoGeneration } from "../../core/scene/nodeMemo.js";
-import { DEFAULT_SHAPE_FILL } from "../../util/paint.js";
 import { paintDrawKindRegistry } from "@weasel-js/renderer";
 import { countPathAnchors } from "@weasel-js/geom";
+import { resolveFill, resolveStroke } from "@weasel-js/paint";
 import { markerReach, resolveStrokeWidth, widestStrokeWidth } from "@weasel-js/stroke";
 
 //#region src/canvas/nodeShapes/nodePaint.ts
 paintDrawKindRegistry.subscribe(bumpNodeMemoGeneration);
-/**
-* What a node's `data.fill` means to the built-in painters.
-*
-* Its {@link Paint} is used as-is — which is how a gradient or a pattern
-* reaches the renderer without a consumer registering a painter of its own.
-* `null` is an explicit "no fill", and so is a fill carrying no `paint`;
-* `undefined` takes the painter's fallback. Write the paint with
-* {@link solid} rather than by hand when all you have is a color.
-*/
-function resolveNodeFill(fill, fallback) {
-	const declared = fill === void 0 ? fallback : fill;
-	return declared?.paint == null ? null : declared;
-}
-/** The stroke a built-in painter should emit, or `null` for "no stroke".
-*  `data.stroke` is a whole {@link Stroke} — width, cap, join, dash, miter
-*  limit, and align all reach the renderer. {@link strokeOf} builds one from a
-*  color.
-*
-*  A stroke carrying no `paint` reads as no stroke. The type requires `paint`,
-*  but a document is data, and a stroke assembled a field at a time arrives
-*  here without one; painting it throws out of the painter and takes the whole
-*  frame with it. */
-function resolveNodeStroke(stroke) {
-	if (stroke?.paint == null) return null;
-	return stroke;
-}
+/** How a container's silhouette is inked: not at all, since it paints nothing. */
+var CONTAINER_INK = Object.freeze({
+	filled: false,
+	outset: 0,
+	inset: 0
+});
 /** Per-side grab reach for a resolved stroke: world units for what the
 *  renderer builds in world, screen pixels for what it builds on screen — a
 *  `{ px }` width, and each head by its own size's units. */
@@ -130,12 +110,11 @@ function withAnimatedVertexColors(cmds, ctx) {
 	}, ...cmds.slice(1)];
 }
 /** {@link PathPaint} of a node that keeps its paint in `data.fill` and
-*  `data.stroke`, as the built-in path painter draws it: a stroke with no
-*  `paint` is none, and an undeclared fill is the default shape fill unless
-*  the node is stroked. */
-function pathPaintOf(data) {
-	const stroke = resolveNodeStroke(data.stroke);
-	const fill = resolveNodeFill(data.fill, stroke !== null ? null : DEFAULT_SHAPE_FILL);
+*  `data.stroke`, as the built-in path painter draws it: a stroke or a fill
+*  with no `paint` is none, and an `'inherit'` one is `inherited`'s. */
+function pathPaintOf(data, inherited) {
+	const stroke = resolveStroke(data.stroke, inherited?.stroke);
+	const fill = resolveFill(data.fill, inherited?.fill);
 	return stroke !== null ? {
 		fill,
 		stroke
@@ -143,5 +122,5 @@ function pathPaintOf(data) {
 }
 
 //#endregion
-export { inkReach, pathPaintOf, resolveNodeFill, resolveNodeStroke, strokeOutset, strokeOutsetPerAxis, withAnimatedVertexColors };
+export { CONTAINER_INK, inkReach, pathPaintOf, strokeOutset, strokeOutsetPerAxis, withAnimatedVertexColors };
 //# sourceMappingURL=nodePaint.js.map

package/dist/canvas/nodeShapes/nodePaint.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodePaint.js","names":[],"sources":["../../../src/canvas/nodeShapes/nodePaint.ts"],"sourcesContent":["import type { Paint, Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeInk, NodeInkCtx, NodePaintCtx } from 'canvas/NodeShape';\nimport { countPathAnchors } from '@weasel-js/geom';\nimport { markerReach } from '@weasel-js/stroke';\nimport { resolveStrokeWidth, widestStrokeWidth } from '@weasel-js/stroke';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport { paintDrawKindRegistry } from '@weasel-js/renderer';\nimport { bumpNodeMemoGeneration } from 'core/scene/nodeMemo';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\n\n// The painters memoize a node's paint and resolve a fill's frame inside the\n// memo, so the kind set is ambient state that memo cannot see change.\npaintDrawKindRegistry.subscribe(bumpNodeMemoGeneration);\n\n/**\n * What a node's `data.fill` means to the built-in painters.\n *\n * Its {@link Paint} is used as-is — which is how a gradient or a pattern\n * reaches the renderer without a consumer registering a painter of its own.\n * `null` is an explicit \"no fill\", and so is a fill carrying no `paint`;\n * `undefined` takes the painter's fallback. Write the paint with\n * {@link solid} rather than by hand when all you have is a color.\n */\nexport function resolveNodeFill(\n  fill: Fill | null | undefined,\n  fallback: Fill | null,\n): PaintedFill | null {\n  const declared = fill === undefined ? fallback : fill;\n  return declared?.paint == null ? null : (declared as PaintedFill);\n}\n\n/** A fill that paints — what everything downstream of `resolveNodeFill`\n *  works with. */\nexport type PaintedFill = Fill & { paint: Paint };\n\n/** The stroke a built-in painter should emit, or `null` for \"no stroke\".\n *  `data.stroke` is a whole {@link Stroke} — width, cap, join, dash, miter\n *  limit, and align all reach the renderer. {@link strokeOf} builds one from a\n *  color.\n *\n *  A stroke carrying no `paint` reads as no stroke. The type requires `paint`,\n *  but a document is data, and a stroke assembled a field at a time arrives\n *  here without one; painting it throws out of the painter and takes the whole\n *  frame with it. */\nexport function resolveNodeStroke(stroke: Stroke | null | undefined): PaintedStroke | null {\n  if (stroke?.paint == null) return null;\n  return stroke as PaintedStroke;\n}\n\n/** A stroke that paints — what everything downstream of `resolveNodeStroke`\n *  works with. */\nexport type PaintedStroke = Stroke & { paint: Paint };\n\n/** Per-side grab reach for a resolved stroke: world units for what the\n *  renderer builds in world, screen pixels for what it builds on screen — a\n *  `{ px }` width, and each head by its own size's units. */\nexport function inkReach(\n  stroke: Stroke | null,\n  scale: number | undefined,\n): Pick<NodeInk, 'outset' | 'inset' | 'outsetPx' | 'insetPx'> {\n  if (stroke === null) return { outset: 0, inset: 0 };\n  // A marker paints past the path's own end, and the kit's rule is that\n  // visible chrome is hittable — so the reach has to cover it.\n  const heads = markerReach(stroke);\n  const sides = (width: number, headReach: number) => {\n    switch (stroke.align ?? 'center') {\n      case 'inner': return { outset: headReach, inset: width };\n      case 'outer': return { outset: width + headReach, inset: 0 };\n      default: return { outset: width / 2 + headReach, inset: width / 2 };\n    }\n  };\n  const width = stroke.width ?? 1;\n  // Per-vertex widths are world units even on a `{ px }` stroke.\n  const worldWidth = widestStrokeWidth(typeof width === 'object' ? 0 : resolveStrokeWidth(width, scale ?? 1), stroke.vertexWidths);\n  const world = sides(worldWidth, heads.world);\n  if (typeof width !== 'object' && !(heads.px > 0)) return world;\n  const px = sides(typeof width === 'object' ? width.px : 0, heads.px);\n  return { outset: world.outset, inset: world.inset, outsetPx: px.outset, insetPx: px.inset };\n}\n\n/** How far `stroke` reaches outside its outline on every side, world units at\n *  `scale`: {@link inkReach}'s outset with its screen part resolved. */\nexport function strokeOutset(stroke: Stroke | null, scale: number): number {\n  const r = inkReach(stroke, scale);\n  return r.outset + (r.outsetPx ?? 0) / (scale > 0 ? scale : 1);\n}\n\n/** {@link strokeOutset} per axis of the frame `ctx.screen` maps from: `x` past\n *  the left and right sides, `y` past the top and bottom. A `{ px }` reach\n *  is a disk on screen, and its extent along each axis of that frame is the\n *  support of the disk pulled back through the map. */\nexport function strokeOutsetPerAxis(stroke: Stroke | null, ctx: NodeInkCtx | undefined): { x: number; y: number } {\n  const scale = ctx?.scale ?? 1;\n  const screen = ctx?.screen;\n  if (!screen) {\n    const r = strokeOutset(stroke, scale);\n    return { x: r, y: r };\n  }\n  const r = inkReach(stroke, scale);\n  const px = r.outsetPx ?? 0;\n  if (px === 0) return { x: r.outset, y: r.outset };\n  const [a, b, c, d] = screen;\n  const det = Math.abs(a * d - b * c);\n  if (!(det > 0)) return { x: r.outset, y: r.outset };\n  return { x: r.outset + (px * Math.hypot(c, d)) / det, y: r.outset + (px * Math.hypot(a, b)) / det };\n}\n\n/** Apply {@link NodePaintCtx.vertexColors} to a path painter's body — its first\n *  command. Applied outside the paint memo, whose key\n *  cannot see an override: `cmds` comes back as-is when nothing changes, and\n *  otherwise as a copy, since a memoized list is not ours to edit. Colors whose\n *  length does not match the path's anchors are dropped. */\nexport function withAnimatedVertexColors(cmds: DrawCommand[], ctx: NodePaintCtx | undefined): DrawCommand[] {\n  const resolve = ctx?.vertexColors;\n  const body = cmds[0];\n  if (resolve === undefined || body?.kind !== 'path') return cmds;\n  const expected = 4 * countPathAnchors(body.path);\n  const fill = body.fill ? resolve('fill', body.vertexColors) : undefined;\n  const stroke = body.stroke ? resolve('stroke', body.stroke.vertexColors) : undefined;\n  const fillChanged = fill?.length === expected && fill !== body.vertexColors;\n  const strokeChanged = stroke?.length === expected && stroke !== body.stroke?.vertexColors;\n  if (!fillChanged && !strokeChanged) return cmds;\n  const next: PathDrawCommand = {\n    ...body,\n    ...(fillChanged ? { vertexColors: fill as number[] } : {}),\n    ...(strokeChanged ? { stroke: { ...body.stroke!, vertexColors: stroke as number[] } } : {}),\n  };\n  return [next, ...cmds.slice(1)];\n}\n\n/** The paint a path node wears, resolved: what an action that turns ink into\n *  geometry reads from a node and tells a consumer to put on a result. */\nexport interface PathPaint {\n  /** `null` is no fill. */\n  fill: Fill | null;\n  /** Absent for no stroke. */\n  stroke?: Stroke;\n}\n\n/** {@link PathPaint} of a node that keeps its paint in `data.fill` and\n *  `data.stroke`, as the built-in path painter draws it: a stroke with no\n *  `paint` is none, and an undeclared fill is the default shape fill unless\n *  the node is stroked. */\nexport function pathPaintOf(data: { fill?: Fill | null; stroke?: Stroke | null }): PathPaint {\n  const stroke = resolveNodeStroke(data.stroke);\n  const fill = resolveNodeFill(data.fill, stroke !== null ? null : DEFAULT_SHAPE_FILL);\n  return stroke !== null ? { fill, stroke } : { fill };\n}\n"],"mappings":"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"}
+{"version":3,"file":"nodePaint.js","names":[],"sources":["../../../src/canvas/nodeShapes/nodePaint.ts"],"sourcesContent":["import type { Stroke, Fill, Inherit } from '@weasel-js/paint';\nimport { resolveFill, resolveStroke } from '@weasel-js/paint';\nimport type { NodeInk, NodeInkCtx, NodePaintCtx } from 'canvas/NodeShape';\nimport { countPathAnchors } from '@weasel-js/geom';\nimport { markerReach } from '@weasel-js/stroke';\nimport { resolveStrokeWidth, widestStrokeWidth } from '@weasel-js/stroke';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport { paintDrawKindRegistry } from '@weasel-js/renderer';\nimport { bumpNodeMemoGeneration } from 'core/scene/nodeMemo';\nimport type { InheritedPaint } from 'core/scene/inheritedPaint';\n\n// The painters memoize a node's paint and resolve a fill's frame inside the\n// memo, so the kind set is ambient state that memo cannot see change.\npaintDrawKindRegistry.subscribe(bumpNodeMemoGeneration);\n\n/** How a container's silhouette is inked: not at all, since it paints nothing. */\nexport const CONTAINER_INK: Readonly<NodeInk> = Object.freeze({ filled: false, outset: 0, inset: 0 });\n\n/** Per-side grab reach for a resolved stroke: world units for what the\n *  renderer builds in world, screen pixels for what it builds on screen — a\n *  `{ px }` width, and each head by its own size's units. */\nexport function inkReach(\n  stroke: Stroke | null,\n  scale: number | undefined,\n): Pick<NodeInk, 'outset' | 'inset' | 'outsetPx' | 'insetPx'> {\n  if (stroke === null) return { outset: 0, inset: 0 };\n  // A marker paints past the path's own end, and the kit's rule is that\n  // visible chrome is hittable — so the reach has to cover it.\n  const heads = markerReach(stroke);\n  const sides = (width: number, headReach: number) => {\n    switch (stroke.align ?? 'center') {\n      case 'inner': return { outset: headReach, inset: width };\n      case 'outer': return { outset: width + headReach, inset: 0 };\n      default: return { outset: width / 2 + headReach, inset: width / 2 };\n    }\n  };\n  const width = stroke.width ?? 1;\n  // Per-vertex widths are world units even on a `{ px }` stroke.\n  const worldWidth = widestStrokeWidth(typeof width === 'object' ? 0 : resolveStrokeWidth(width, scale ?? 1), stroke.vertexWidths);\n  const world = sides(worldWidth, heads.world);\n  if (typeof width !== 'object' && !(heads.px > 0)) return world;\n  const px = sides(typeof width === 'object' ? width.px : 0, heads.px);\n  return { outset: world.outset, inset: world.inset, outsetPx: px.outset, insetPx: px.inset };\n}\n\n/** How far `stroke` reaches outside its outline on every side, world units at\n *  `scale`: {@link inkReach}'s outset with its screen part resolved. */\nexport function strokeOutset(stroke: Stroke | null, scale: number): number {\n  const r = inkReach(stroke, scale);\n  return r.outset + (r.outsetPx ?? 0) / (scale > 0 ? scale : 1);\n}\n\n/** {@link strokeOutset} per axis of the frame `ctx.screen` maps from: `x` past\n *  the left and right sides, `y` past the top and bottom. A `{ px }` reach\n *  is a disk on screen, and its extent along each axis of that frame is the\n *  support of the disk pulled back through the map. */\nexport function strokeOutsetPerAxis(stroke: Stroke | null, ctx: NodeInkCtx | undefined): { x: number; y: number } {\n  const scale = ctx?.scale ?? 1;\n  const screen = ctx?.screen;\n  if (!screen) {\n    const r = strokeOutset(stroke, scale);\n    return { x: r, y: r };\n  }\n  const r = inkReach(stroke, scale);\n  const px = r.outsetPx ?? 0;\n  if (px === 0) return { x: r.outset, y: r.outset };\n  const [a, b, c, d] = screen;\n  const det = Math.abs(a * d - b * c);\n  if (!(det > 0)) return { x: r.outset, y: r.outset };\n  return { x: r.outset + (px * Math.hypot(c, d)) / det, y: r.outset + (px * Math.hypot(a, b)) / det };\n}\n\n/** Apply {@link NodePaintCtx.vertexColors} to a path painter's body — its first\n *  command. Applied outside the paint memo, whose key\n *  cannot see an override: `cmds` comes back as-is when nothing changes, and\n *  otherwise as a copy, since a memoized list is not ours to edit. Colors whose\n *  length does not match the path's anchors are dropped. */\nexport function withAnimatedVertexColors(cmds: DrawCommand[], ctx: NodePaintCtx | undefined): DrawCommand[] {\n  const resolve = ctx?.vertexColors;\n  const body = cmds[0];\n  if (resolve === undefined || body?.kind !== 'path') return cmds;\n  const expected = 4 * countPathAnchors(body.path);\n  const fill = body.fill ? resolve('fill', body.vertexColors) : undefined;\n  const stroke = body.stroke ? resolve('stroke', body.stroke.vertexColors) : undefined;\n  const fillChanged = fill?.length === expected && fill !== body.vertexColors;\n  const strokeChanged = stroke?.length === expected && stroke !== body.stroke?.vertexColors;\n  if (!fillChanged && !strokeChanged) return cmds;\n  const next: PathDrawCommand = {\n    ...body,\n    ...(fillChanged ? { vertexColors: fill as number[] } : {}),\n    ...(strokeChanged ? { stroke: { ...body.stroke!, vertexColors: stroke as number[] } } : {}),\n  };\n  return [next, ...cmds.slice(1)];\n}\n\n/** The paint a path node wears, resolved: what an action that turns ink into\n *  geometry reads from a node and tells a consumer to put on a result. */\nexport interface PathPaint {\n  /** `null` is no fill. */\n  fill: Fill | null;\n  /** Absent for no stroke. */\n  stroke?: Stroke;\n}\n\n/** {@link PathPaint} of a node that keeps its paint in `data.fill` and\n *  `data.stroke`, as the built-in path painter draws it: a stroke or a fill\n *  with no `paint` is none, and an `'inherit'` one is `inherited`'s. */\nexport function pathPaintOf(\n  data: { fill?: Fill | Inherit | null; stroke?: Stroke | Inherit | null },\n  inherited?: InheritedPaint,\n): PathPaint {\n  const stroke = resolveStroke(data.stroke, inherited?.stroke);\n  const fill = resolveFill(data.fill, inherited?.fill);\n  return stroke !== null ? { fill, stroke } : { fill };\n}\n"],"mappings":"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"}

package/dist/canvas/nodeShapes/pathPainter.js

@@ -1,11 +1,12 @@
 import { nodeMemo } from "../../core/scene/nodeMemo.js";
 import { PAINT_SLOT } from "./memo.js";
-import { inkReach, pathPaintOf, resolveNodeStroke, withAnimatedVertexColors } from "./nodePaint.js";
-import { DERIVED_PAINTER } from "./derivedPainter.js";
-import { paintsPose, poseBoxBounds } from "./poseBox.js";
+import { CONTAINER_INK, inkReach, pathPaintOf, withAnimatedVertexColors } from "./nodePaint.js";
 import { strokedPoseBox } from "./strokedBounds.js";
+import { DERIVED_PAINTER, derivedDrawnBounds } from "./derivedPainter.js";
+import { paintsPose, poseBoxBounds } from "./poseBox.js";
 import { commandFill, commandStroke } from "@weasel-js/renderer";
 import { pathInPoseFrame } from "@weasel-js/geom";
+import { resolveStroke } from "@weasel-js/paint";
 
 //#region src/canvas/nodeShapes/pathPainter.ts
 var PATH_PAINTER = {
@@ -14,10 +15,10 @@ var PATH_PAINTER = {
 		if (!paintsPose(node.pose)) return false;
 		return node.data?.path != null;
 	},
-	paint: (node, pose, ctx) => ctx?.derivedPath != null ? DERIVED_PAINTER.paint(node, pose, ctx) : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {
+	paint: (node, pose, ctx) => node.kind === "container" ? [] : ctx?.derivedPath != null ? DERIVED_PAINTER.paint(node, pose, ctx) : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {
 		const d = node.data;
 		const projected = pathInPoseFrame(d.path, pose);
-		const { fill: declared, stroke: strokeSpec } = pathPaintOf(d);
+		const { fill: declared, stroke: strokeSpec } = pathPaintOf(d, ctx?.inherited);
 		const fill = declared && commandFill(declared, pose);
 		const stroke = strokeSpec && commandStroke(strokeSpec, pose);
 		return [{
@@ -27,24 +28,25 @@ var PATH_PAINTER = {
 			...fill && d.vertexColors ? { vertexColors: d.vertexColors } : {},
 			...stroke ? { stroke } : {}
 		}];
-	}), ctx),
+	}, ctx?.inherited), ctx),
 	silhouette: (node, pose, ctx) => {
 		if (ctx?.derivedPath != null) return ctx.derivedPath;
 		const d = node.data;
 		return pathInPoseFrame(d.path, pose);
 	},
 	ink: (node, _pose, ctx) => {
-		const d = node.data;
-		const { fill, stroke } = pathPaintOf(d);
+		if (node.kind === "container") return CONTAINER_INK;
+		const { fill, stroke } = pathPaintOf(node.data, ctx?.inherited);
 		return {
 			filled: fill !== null,
 			...inkReach(stroke ?? null, ctx?.scale)
 		};
 	},
-	bounds: (node, pose, ctx) => poseBoxBounds(pose, resolveNodeStroke(node.data.stroke), ctx),
+	bounds: (node, pose, ctx) => poseBoxBounds(pose, resolveStroke(node.data.stroke, ctx?.inherited?.stroke), ctx),
 	drawnBounds: (node, pose, ctx) => {
+		if (ctx?.derivedPath != null) return derivedDrawnBounds(node, ctx);
 		const d = node.data;
-		return strokedPoseBox(node, pose, resolveNodeStroke(d.stroke), ctx, (at) => pathInPoseFrame(d.path, at));
+		return strokedPoseBox(node, pose, resolveStroke(d.stroke, ctx?.inherited?.stroke), ctx, (at) => pathInPoseFrame(d.path, at));
 	}
 };
 

package/dist/canvas/nodeShapes/pathPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/pathPainter.ts"],"sourcesContent":["import type {\n  Path\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { pathInPoseFrame } from '@weasel-js/geom';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DERIVED_PAINTER } from './derivedPainter';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, pathPaintOf, withAnimatedVertexColors, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\nimport { strokedPoseBox } from './strokedBounds';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const PATH_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:path',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { path?: Path } | null;\n    return d?.path != null;\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`\n  // allocates on every call but the identity (`kind: 'rect'`) branch. See\n  // PAINT_SLOT.\n  paint: (node, pose, ctx) => ctx?.derivedPath != null\n    // A pose override's path stands in for `data.path`, already where it is drawn.\n    ? DERIVED_PAINTER.paint(node, pose, ctx)\n    : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as {\n      path: Path;\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n      vertexColors?: number[];\n    };\n    const projected = pathInPoseFrame(d.path, pose);\n    const { fill: declared, stroke: strokeSpec } = pathPaintOf(d);\n    // The pose is baked into `projected` rather than emitted as a transform,\n    // so a box-relative gradient has to be baked onto the same box here or\n    // it would arrive in the renderer referring to a frame that never exists.\n    const fill = declared && commandFill(declared, pose);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path: projected,\n      ...(fill ? { fill } : {}),\n      ...(fill && d.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return [cmd];\n  }), ctx),\n  silhouette: (node, pose, ctx) => {\n    if (ctx?.derivedPath != null) return ctx.derivedPath;\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  ink: (node, _pose, ctx) => {\n    const d = node.data as {\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n    };\n    const { fill, stroke } = pathPaintOf(d);\n    return { filled: fill !== null, ...inkReach(stroke ?? null, ctx?.scale) };\n  },\n  // `pathInPoseFrame` fits the path's own bounds to the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n  drawnBounds: (node, pose, ctx) => {\n    const d = node.data as { path: Path; stroke?: Stroke | null };\n    return strokedPoseBox(node, pose, resolveNodeStroke(d.stroke), ctx, (at) => pathInPoseFrame(d.path, at));\n  },\n};\n"],"mappings":";;;;;;;;;;AAiBA,IAAa,eAAkD;CAC7D,IAAI;CACJ,UAAU,SAAS;EACjB,IAAI,CAAC,WAAW,KAAK,IAAI,GAAG,OAAO;EAEnC,OADU,KAAK,MACL,QAAQ;CACpB;CAIA,QAAQ,MAAM,MAAM,QAAQ,KAAK,eAAe,OAE5C,gBAAgB,MAAM,MAAM,MAAM,GAAG,IACrC,yBAAyB,SAAS,MAAM,YAAY,YAAY;EAClE,MAAM,IAAI,KAAK;EAMf,MAAM,YAAY,gBAAgB,EAAE,MAAM,IAAI;EAC9C,MAAM,EAAE,MAAM,UAAU,QAAQ,eAAe,YAAY,CAAC;EAI5D,MAAM,OAAO,YAAY,YAAY,UAAU,IAAI;EACnD,MAAM,SAAS,cAAc,cAAc,YAAY,IAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAM;GACN,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;GACvB,GAAI,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,IAAI,CAAC;GACjE,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAErB,CAAG;CACb,CAAC,GAAG,GAAG;CACP,aAAa,MAAM,MAAM,QAAQ;EAC/B,IAAI,KAAK,eAAe,MAAM,OAAO,IAAI;EACzC,MAAM,IAAI,KAAK;EACf,OAAO,gBAAgB,EAAE,MAAM,IAAI;CACrC;CACA,MAAM,MAAM,OAAO,QAAQ;EACzB,MAAM,IAAI,KAAK;EAIf,MAAM,EAAE,MAAM,WAAW,YAAY,CAAC;EACtC,OAAO;GAAE,QAAQ,SAAS;GAAM,GAAG,SAAS,UAAU,MAAM,KAAK,KAAK;EAAE;CAC1E;CAEA,SAAS,MAAM,MAAM,QACnB,cAAc,MAAM,kBAAmB,KAAK,KAAoC,MAAM,GAAG,GAAG;CAC9F,cAAc,MAAM,MAAM,QAAQ;EAChC,MAAM,IAAI,KAAK;EACf,OAAO,eAAe,MAAM,MAAM,kBAAkB,EAAE,MAAM,GAAG,MAAM,OAAO,gBAAgB,EAAE,MAAM,EAAE,CAAC;CACzG;AACF"}
+{"version":3,"file":"pathPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/pathPainter.ts"],"sourcesContent":["import type {\n  Path\n} from '@weasel-js/geom';\nimport type { Stroke, Fill, Inherit } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { pathInPoseFrame } from '@weasel-js/geom';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DERIVED_PAINTER, derivedDrawnBounds } from './derivedPainter';\nimport { PAINT_SLOT } from './memo';\nimport { CONTAINER_INK, inkReach, pathPaintOf, withAnimatedVertexColors } from './nodePaint';\nimport { resolveStroke } from '@weasel-js/paint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\nimport { strokedPoseBox } from './strokedBounds';\n\ntype PathData = { fill?: Fill | Inherit | null; stroke?: Stroke | Inherit | null; vertexColors?: number[] };\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const PATH_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:path',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { path?: Path } | null;\n    return d?.path != null;\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`\n  // allocates on every call but the identity (`kind: 'rect'`) branch. See\n  // PAINT_SLOT.\n  // As `kit:shape`, a container paints nothing of its own.\n  paint: (node, pose, ctx) => node.kind === 'container' ? [] : ctx?.derivedPath != null\n    // A pose override's path stands in for `data.path`, already where it is drawn.\n    ? DERIVED_PAINTER.paint(node, pose, ctx)\n    : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as PathData & { path: Path };\n    const projected = pathInPoseFrame(d.path, pose);\n    const { fill: declared, stroke: strokeSpec } = pathPaintOf(d, ctx?.inherited);\n    // The pose is baked into `projected` rather than emitted as a transform,\n    // so a box-relative gradient has to be baked onto the same box here or\n    // it would arrive in the renderer referring to a frame that never exists.\n    const fill = declared && commandFill(declared, pose);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path: projected,\n      ...(fill ? { fill } : {}),\n      ...(fill && d.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return [cmd];\n  }, ctx?.inherited), ctx),\n  silhouette: (node, pose, ctx) => {\n    if (ctx?.derivedPath != null) return ctx.derivedPath;\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  ink: (node, _pose, ctx) => {\n    if (node.kind === 'container') return CONTAINER_INK;\n    const { fill, stroke } = pathPaintOf(node.data as PathData, ctx?.inherited);\n    return { filled: fill !== null, ...inkReach(stroke ?? null, ctx?.scale) };\n  },\n  // `pathInPoseFrame` fits the path's own bounds to the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveStroke((node.data as PathData).stroke, ctx?.inherited?.stroke), ctx),\n  drawnBounds: (node, pose, ctx) => {\n    if (ctx?.derivedPath != null) return derivedDrawnBounds(node, ctx);\n    const d = node.data as PathData & { path: Path };\n    return strokedPoseBox(node, pose, resolveStroke(d.stroke, ctx?.inherited?.stroke), ctx, (at) => pathInPoseFrame(d.path, at));\n  },\n};\n"],"mappings":";;;;;;;;;;;AAoBA,IAAa,eAAkD;CAC7D,IAAI;CACJ,UAAU,SAAS;EACjB,IAAI,CAAC,WAAW,KAAK,IAAI,GAAG,OAAO;EAEnC,OADU,KAAK,MACL,QAAQ;CACpB;CAKA,QAAQ,MAAM,MAAM,QAAQ,KAAK,SAAS,cAAc,CAAC,IAAI,KAAK,eAAe,OAE7E,gBAAgB,MAAM,MAAM,MAAM,GAAG,IACrC,yBAAyB,SAAS,MAAM,YAAY,YAAY;EAClE,MAAM,IAAI,KAAK;EACf,MAAM,YAAY,gBAAgB,EAAE,MAAM,IAAI;EAC9C,MAAM,EAAE,MAAM,UAAU,QAAQ,eAAe,YAAY,GAAG,KAAK,SAAS;EAI5E,MAAM,OAAO,YAAY,YAAY,UAAU,IAAI;EACnD,MAAM,SAAS,cAAc,cAAc,YAAY,IAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAM;GACN,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;GACvB,GAAI,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,IAAI,CAAC;GACjE,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAErB,CAAG;CACb,GAAG,KAAK,SAAS,GAAG,GAAG;CACvB,aAAa,MAAM,MAAM,QAAQ;EAC/B,IAAI,KAAK,eAAe,MAAM,OAAO,IAAI;EACzC,MAAM,IAAI,KAAK;EACf,OAAO,gBAAgB,EAAE,MAAM,IAAI;CACrC;CACA,MAAM,MAAM,OAAO,QAAQ;EACzB,IAAI,KAAK,SAAS,aAAa,OAAO;EACtC,MAAM,EAAE,MAAM,WAAW,YAAY,KAAK,MAAkB,KAAK,SAAS;EAC1E,OAAO;GAAE,QAAQ,SAAS;GAAM,GAAG,SAAS,UAAU,MAAM,KAAK,KAAK;EAAE;CAC1E;CAEA,SAAS,MAAM,MAAM,QACnB,cAAc,MAAM,cAAe,KAAK,KAAkB,QAAQ,KAAK,WAAW,MAAM,GAAG,GAAG;CAChG,cAAc,MAAM,MAAM,QAAQ;EAChC,IAAI,KAAK,eAAe,MAAM,OAAO,mBAAmB,MAAM,GAAG;EACjE,MAAM,IAAI,KAAK;EACf,OAAO,eAAe,MAAM,MAAM,cAAc,EAAE,QAAQ,KAAK,WAAW,MAAM,GAAG,MAAM,OAAO,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC7H;AACF"}

package/dist/canvas/nodeShapes/rectFallbackPainter.js

@@ -1,16 +1,15 @@
-import { DEFAULT_SHAPE_FILL } from "../../util/paint.js";
-import { resolveNodeFill } from "./nodePaint.js";
 import { paintsPose, poseBoxBounds } from "./poseBox.js";
 import { commandFill } from "@weasel-js/renderer";
+import { resolveFill } from "@weasel-js/paint";
 
 //#region src/canvas/nodeShapes/rectFallbackPainter.ts
 var RECT_FALLBACK_PAINTER = {
 	id: "kit:rect-fallback",
-	matches: (node) => paintsPose(node.pose),
-	paint: (node, pose) => {
+	matches: (node) => node.kind !== "container" && paintsPose(node.pose),
+	paint: (node, pose, ctx) => {
 		const d = node.data;
 		const p = pose;
-		const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);
+		const declared = resolveFill(d?.fill, ctx?.inherited?.fill);
 		const fill = declared && commandFill(declared, p);
 		return [{
 			kind: "path",

package/dist/canvas/nodeShapes/rectFallbackPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"rectFallbackPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/rectFallbackPainter.ts"],"sourcesContent":["import type { Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { resolveNodeFill } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const RECT_FALLBACK_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  // Last-resort painter — matches any rect-posed node, so it must be\n  // registered last within `'normal'`. Consumers who want a different\n  // fallback should register their own painter at `'high'` priority and let\n  // this one never fire (or unregister it explicitly).\n  id: 'kit:rect-fallback',\n  matches: (node) => paintsPose(node.pose),\n  paint: (node, pose) => {\n    const d = node.data as { fill?: Fill | null } | null;\n    const p = pose;\n    const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);\n    const fill = declared && commandFill(declared, p);\n    return [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      ...(fill ? { fill } : {}),\n    }];\n  },\n  silhouette: (_node, pose) => {\n    const p = pose;\n    return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  },\n  bounds: (_node, pose) => poseBoxBounds(pose, null, undefined),\n};\n"],"mappings":";;;;;;AASA,IAAa,wBAA2D;CAKtE,IAAI;CACJ,UAAU,SAAS,WAAW,KAAK,IAAI;CACvC,QAAQ,MAAM,SAAS;EACrB,MAAM,IAAI,KAAK;EACf,MAAM,IAAI;EACV,MAAM,WAAW,gBAAgB,GAAG,MAAM,kBAAkB;EAC5D,MAAM,OAAO,YAAY,YAAY,UAAU,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAG,EAAE;IAAG,GAAG,EAAE;IAAG,OAAO,EAAE;IAAO,QAAQ,EAAE;GAAO;GACvE,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,OAAO,SAAS;EAC3B,MAAM,IAAI;EACV,OAAO;GAAE,MAAM;GAAQ,GAAG,EAAE;GAAG,GAAG,EAAE;GAAG,OAAO,EAAE;GAAO,QAAQ,EAAE;EAAO;CAC1E;CACA,SAAS,OAAO,SAAS,cAAc,MAAM,MAAM,MAAS;AAC9D"}
+{"version":3,"file":"rectFallbackPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/rectFallbackPainter.ts"],"sourcesContent":["import type { Fill, Inherit } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill } from '@weasel-js/renderer';\nimport { resolveFill } from '@weasel-js/paint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const RECT_FALLBACK_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  // Last-resort painter — matches any rect-posed leaf, so it must be\n  // registered last within `'normal'`. A container is a group, not a box: matching\n  // one would also hand it a silhouette, which clips its members. Consumers who want a different\n  // fallback should register their own painter at `'high'` priority and let\n  // this one never fire (or unregister it explicitly).\n  id: 'kit:rect-fallback',\n  matches: (node) => node.kind !== 'container' && paintsPose(node.pose),\n  paint: (node, pose, ctx) => {\n    const d = node.data as { fill?: Fill | Inherit | null } | null;\n    const p = pose;\n    const declared = resolveFill(d?.fill, ctx?.inherited?.fill);\n    const fill = declared && commandFill(declared, p);\n    return [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      ...(fill ? { fill } : {}),\n    }];\n  },\n  silhouette: (_node, pose) => {\n    const p = pose;\n    return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  },\n  bounds: (_node, pose) => poseBoxBounds(pose, null, undefined),\n};\n"],"mappings":";;;;;AAQA,IAAa,wBAA2D;CAMtE,IAAI;CACJ,UAAU,SAAS,KAAK,SAAS,eAAe,WAAW,KAAK,IAAI;CACpE,QAAQ,MAAM,MAAM,QAAQ;EAC1B,MAAM,IAAI,KAAK;EACf,MAAM,IAAI;EACV,MAAM,WAAW,YAAY,GAAG,MAAM,KAAK,WAAW,IAAI;EAC1D,MAAM,OAAO,YAAY,YAAY,UAAU,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAG,EAAE;IAAG,GAAG,EAAE;IAAG,OAAO,EAAE;IAAO,QAAQ,EAAE;GAAO;GACvE,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,OAAO,SAAS;EAC3B,MAAM,IAAI;EACV,OAAO;GAAE,MAAM;GAAQ,GAAG,EAAE;GAAG,GAAG,EAAE;GAAG,OAAO,EAAE;GAAO,QAAQ,EAAE;EAAO;CAC1E;CACA,SAAS,OAAO,SAAS,cAAc,MAAM,MAAM,MAAS;AAC9D"}

package/dist/canvas/nodeShapes/shapePainter.js

@@ -1,11 +1,11 @@
 import { nodeMemo } from "../../core/scene/nodeMemo.js";
-import { DEFAULT_SHAPE_FILL } from "../../util/paint.js";
 import { PAINT_SLOT } from "./memo.js";
-import { inkReach, resolveNodeFill, resolveNodeStroke, withAnimatedVertexColors } from "./nodePaint.js";
-import { paintsPose, poseBoxBounds } from "./poseBox.js";
+import { CONTAINER_INK, inkReach, withAnimatedVertexColors } from "./nodePaint.js";
 import { outsetPoseBox, strokedPoseBox } from "./strokedBounds.js";
+import { paintsPose, poseBoxBounds } from "./poseBox.js";
 import { commandFill, commandStroke } from "@weasel-js/renderer";
 import { ellipsePath, regularPolygonPath, starPath } from "@weasel-js/geom";
+import { resolveFill, resolveStroke } from "@weasel-js/paint";
 
 //#region src/canvas/nodeShapes/shapePainter.ts
 /** Built-in shape dispatcher — matches when `data.shape` names a kit-known
@@ -19,12 +19,12 @@ var SHAPE_PAINTER = {
 		const s = node.data?.shape;
 		return s != null && SHAPE_KINDS.has(s);
 	},
-	paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {
+	paint: (node, pose, ctx) => node.kind === "container" ? [] : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {
 		const d = node.data;
 		const path = pathForShape(d, pose);
-		const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);
+		const declaredFill = resolveFill(d.fill, ctx?.inherited?.fill);
 		const shapeFill = declaredFill && commandFill(declaredFill, pose);
-		const strokeSpec = resolveNodeStroke(d.stroke);
+		const strokeSpec = resolveStroke(d.stroke, ctx?.inherited?.stroke);
 		const stroke = strokeSpec && commandStroke(strokeSpec, pose);
 		return [{
 			kind: "path",
@@ -32,22 +32,23 @@ var SHAPE_PAINTER = {
 			...shapeFill ? { fill: shapeFill } : {},
 			...stroke ? { stroke } : {}
 		}];
-	}), ctx),
+	}, ctx?.inherited), ctx),
 	silhouette: (node, pose) => {
 		const d = node.data;
 		return pathForShape(d, pose);
 	},
 	ink: (node, _pose, ctx) => {
+		if (node.kind === "container") return CONTAINER_INK;
 		const d = node.data;
 		return {
-			filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,
-			...inkReach(resolveNodeStroke(d.stroke), ctx?.scale)
+			filled: resolveFill(d.fill, ctx?.inherited?.fill) !== null,
+			...inkReach(resolveStroke(d.stroke, ctx?.inherited?.stroke), ctx?.scale)
 		};
 	},
-	bounds: (node, pose, ctx) => poseBoxBounds(pose, resolveNodeStroke(node.data.stroke), ctx),
+	bounds: (node, pose, ctx) => poseBoxBounds(pose, resolveStroke(node.data.stroke, ctx?.inherited?.stroke), ctx),
 	drawnBounds: (node, pose, ctx) => {
 		const d = node.data;
-		const stroke = resolveNodeStroke(d.stroke);
+		const stroke = resolveStroke(d.stroke, ctx?.inherited?.stroke);
 		return d.shape === "polygon" || d.shape === "star" ? strokedPoseBox(node, pose, stroke, ctx, (at) => pathForShape(d, at)) : outsetPoseBox(pose, stroke, ctx);
 	}
 };