@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/nodeShapes/memo.js

@@ -1,9 +1,20 @@
 //#region src/canvas/nodeShapes/memo.ts
-var e = "shape:paint";
-function t(e) {
-	return (e.dependsOn?.length ?? 0) > 0 && e.derivePath !== void 0;
+/**
+* Slot for a painter's memoized `paint` output.
+*
+* Distinct from the silhouette slot even though the two mostly invalidate
+* together: the silhouette bakes `pose.rotation` in (paint does not — the
+* render wrap applies it), and paint alone can depend on `NodePaintCtx` and on
+* ambient readiness.
+*
+* **Only for painters that are a pure function of `(node, pose, data)`.**
+* `kit:text` and `kit:image` do not qualify.
+*/
+var PAINT_SLOT = "shape:paint";
+function derivesPath(node) {
+	return (node.dependsOn?.length ?? 0) > 0 && node.derivePath !== void 0;
 }
-//#endregion
-export { e as PAINT_SLOT, t as derivesPath };
 
+//#endregion
+export { PAINT_SLOT, derivesPath };
 //# sourceMappingURL=memo.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"memo.js","names":["PAINT_SLOT","derivesPath","node"],"sources":["../../../src/canvas/nodeShapes/memo.ts"],"sourcesContent":["\n/**\n * Slot for a painter's memoized `paint` output.\n *\n * Distinct from the silhouette slot even though the two mostly invalidate\n * together: the silhouette bakes `pose.rotation` in (paint does not — the\n * render wrap applies it), and paint alone can depend on `NodePaintCtx` and on\n * ambient readiness.\n *\n * **Only for painters that are a pure function of `(node, pose, data)`.**\n * `kit:text` and `kit:image` do not qualify.\n */\nexport const PAINT_SLOT = 'shape:paint';\n\nexport function derivesPath(node: { dependsOn?: readonly unknown[] | 'children'; derivePath?: unknown }): boolean {\n  return (node.dependsOn?.length ?? 0) > 0 && node.derivePath !== undefined;\n}\n"],"mappings":";AAYA,IAAaA,IAAa;AAE1B,SAAgBC,EAAY,GAAsF;CAChH,QAAQC,EAAK,WAAW,UAAU,KAAK,KAAKA,EAAK,eAAe,KAAA;AAClE"}
+{"version":3,"file":"memo.js","names":[],"sources":["../../../src/canvas/nodeShapes/memo.ts"],"sourcesContent":["\n/**\n * Slot for a painter's memoized `paint` output.\n *\n * Distinct from the silhouette slot even though the two mostly invalidate\n * together: the silhouette bakes `pose.rotation` in (paint does not — the\n * render wrap applies it), and paint alone can depend on `NodePaintCtx` and on\n * ambient readiness.\n *\n * **Only for painters that are a pure function of `(node, pose, data)`.**\n * `kit:text` and `kit:image` do not qualify.\n */\nexport const PAINT_SLOT = 'shape:paint';\n\nexport function derivesPath(node: { dependsOn?: readonly unknown[] | 'children'; derivePath?: unknown }): boolean {\n  return (node.dependsOn?.length ?? 0) > 0 && node.derivePath !== undefined;\n}\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,aAAa;AAE1B,SAAgB,YAAY,MAAsF;CAChH,QAAQ,KAAK,WAAW,UAAU,KAAK,KAAK,KAAK,eAAe;AAClE"}

package/dist/canvas/nodeShapes/nodePaint.js

@@ -1,68 +1,147 @@
-import { bumpNodeMemoGeneration as e } from "../../core/scene/nodeMemo.js";
-import { DEFAULT_SHAPE_FILL as t } from "../../util/paint.js";
-import { paintDrawKindRegistry as n } from "@weasel-js/renderer";
-import { countPathAnchors as r } from "@weasel-js/geom";
-import { markerReach as i, resolveStrokeWidth as a } from "@weasel-js/stroke";
+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 { markerReach, resolveStrokeWidth, widestStrokeWidth } from "@weasel-js/stroke";
+
 //#region src/canvas/nodeShapes/nodePaint.ts
-n.subscribe(e);
-function o(e, t) {
-	let n = e === void 0 ? t : e;
-	return n?.paint == null ? null : n;
+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;
 }
-function s(e) {
-	return e?.paint == null ? null : e;
+/** 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;
 }
-function c(e, t) {
-	if (e === null) return {
+/** 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. */
+function inkReach(stroke, scale) {
+	if (stroke === null) return {
 		outset: 0,
 		inset: 0
 	};
-	let n = i(e), r = (t, n) => {
-		switch (e.align ?? "center") {
+	const heads = markerReach(stroke);
+	const sides = (width, headReach) => {
+		switch (stroke.align ?? "center") {
 			case "inner": return {
-				outset: n,
-				inset: t
+				outset: headReach,
+				inset: width
 			};
 			case "outer": return {
-				outset: t + n,
+				outset: width + headReach,
 				inset: 0
 			};
 			default: return {
-				outset: t / 2 + n,
-				inset: t / 2
+				outset: width / 2 + headReach,
+				inset: width / 2
 			};
 		}
-	}, o = e.width ?? 1, s = r(typeof o == "object" ? 0 : a(o, t ?? 1), n.world);
-	if (typeof o != "object" && !(n.px > 0)) return s;
-	let c = r(typeof o == "object" ? o.px : 0, n.px);
+	};
+	const width = stroke.width ?? 1;
+	const world = sides(widestStrokeWidth(typeof width === "object" ? 0 : resolveStrokeWidth(width, scale ?? 1), stroke.vertexWidths), heads.world);
+	if (typeof width !== "object" && !(heads.px > 0)) return world;
+	const px = sides(typeof width === "object" ? width.px : 0, heads.px);
 	return {
-		outset: s.outset,
-		inset: s.inset,
-		outsetPx: c.outset,
-		insetPx: c.inset
+		outset: world.outset,
+		inset: world.inset,
+		outsetPx: px.outset,
+		insetPx: px.inset
 	};
 }
-function l(e, t) {
-	let n = t?.vertexColors, i = e[0];
-	if (n === void 0 || i?.kind !== "path") return e;
-	let a = 4 * r(i.path), o = i.fill ? n("fill", i.vertexColors) : void 0, s = i.stroke ? n("stroke", i.stroke.vertexColors) : void 0, c = o?.length === a && o !== i.vertexColors, l = s?.length === a && s !== i.stroke?.vertexColors;
-	return !c && !l ? e : [{
-		...i,
-		...c ? { vertexColors: o } : {},
-		...l ? { stroke: {
-			...i.stroke,
-			vertexColors: s
-		} } : {}
-	}, ...e.slice(1)];
+/** How far `stroke` reaches outside its outline on every side, world units at
+*  `scale`: {@link inkReach}'s outset with its screen part resolved. */
+function strokeOutset(stroke, scale) {
+	const r = inkReach(stroke, scale);
+	return r.outset + (r.outsetPx ?? 0) / (scale > 0 ? scale : 1);
 }
-function u(e) {
-	let n = s(e.stroke), r = o(e.fill, n === null ? t : null);
-	return n === null ? { fill: r } : {
-		fill: r,
-		stroke: n
+/** {@link strokeOutset} per axis of the frame `ctx.screen` maps from: `x` past
+*  the left and right sides, `y` past the top and bottom. A `{ px }` reach
+*  is a disk on screen, and its extent along each axis of that frame is the
+*  support of the disk pulled back through the map. */
+function strokeOutsetPerAxis(stroke, ctx) {
+	const scale = ctx?.scale ?? 1;
+	const screen = ctx?.screen;
+	if (!screen) {
+		const r = strokeOutset(stroke, scale);
+		return {
+			x: r,
+			y: r
+		};
+	}
+	const r = inkReach(stroke, scale);
+	const px = r.outsetPx ?? 0;
+	if (px === 0) return {
+		x: r.outset,
+		y: r.outset
+	};
+	const [a, b, c, d] = screen;
+	const det = Math.abs(a * d - b * c);
+	if (!(det > 0)) return {
+		x: r.outset,
+		y: r.outset
+	};
+	return {
+		x: r.outset + px * Math.hypot(c, d) / det,
+		y: r.outset + px * Math.hypot(a, b) / det
 	};
 }
-//#endregion
-export { c as inkReach, u as pathPaintOf, o as resolveNodeFill, s as resolveNodeStroke, l as withAnimatedVertexColors };
+/** Apply {@link NodePaintCtx.vertexColors} to a path painter's body — its first
+*  command. Applied outside the paint memo, whose key
+*  cannot see an override: `cmds` comes back as-is when nothing changes, and
+*  otherwise as a copy, since a memoized list is not ours to edit. Colors whose
+*  length does not match the path's anchors are dropped. */
+function withAnimatedVertexColors(cmds, ctx) {
+	const resolve = ctx?.vertexColors;
+	const body = cmds[0];
+	if (resolve === void 0 || body?.kind !== "path") return cmds;
+	const expected = 4 * countPathAnchors(body.path);
+	const fill = body.fill ? resolve("fill", body.vertexColors) : void 0;
+	const stroke = body.stroke ? resolve("stroke", body.stroke.vertexColors) : void 0;
+	const fillChanged = fill?.length === expected && fill !== body.vertexColors;
+	const strokeChanged = stroke?.length === expected && stroke !== body.stroke?.vertexColors;
+	if (!fillChanged && !strokeChanged) return cmds;
+	return [{
+		...body,
+		...fillChanged ? { vertexColors: fill } : {},
+		...strokeChanged ? { stroke: {
+			...body.stroke,
+			vertexColors: stroke
+		} } : {}
+	}, ...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);
+	return stroke !== null ? {
+		fill,
+		stroke
+	} : { fill };
+}
 
+//#endregion
+export { inkReach, pathPaintOf, resolveNodeFill, resolveNodeStroke, strokeOutset, strokeOutsetPerAxis, withAnimatedVertexColors };
 //# sourceMappingURL=nodePaint.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodePaint.js","names":["paintDrawKindRegistry","bumpNodeMemoGeneration","resolveNodeFill","declared","fill","fallback","resolveNodeStroke","stroke","inkReach","heads","markerReach","sides","headReach","width","world","resolveStrokeWidth","scale","px","withAnimatedVertexColors","resolve","ctx","body","cmds","expected","countPathAnchors","fillChanged","strokeChanged","pathPaintOf","data","DEFAULT_SHAPE_FILL"],"sources":["../../../src/canvas/nodeShapes/nodePaint.ts"],"sourcesContent":["import type { Paint, Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeInk, NodePaintCtx } from 'canvas/NodeShape';\nimport { countPathAnchors } from '@weasel-js/geom';\nimport { markerReach } from '@weasel-js/stroke';\nimport { resolveStrokeWidth } 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  const world = sides(typeof width === 'object' ? 0 : resolveStrokeWidth(width, scale ?? 1), 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/** 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":";;;;;;AAYAA,EAAsB,UAAUC,CAAsB;AAWtD,SAAgBC,EACd,GACA,GACoB;CACpB,IAAMC,IAAWC,MAAS,KAAA,IAAYC,IAAWD;CACjD,OAAOD,GAAU,SAAS,OAAO,OAAQA;AAC3C;AAeA,SAAgBG,EAAkB,GAAyD;CAEzF,OADIC,GAAQ,SAAS,OAAa,OAC3BA;AACT;AASA,SAAgBC,EACd,GACA,GAC4D;CAC5D,IAAID,MAAW,MAAM,OAAO;EAAE,QAAQ;EAAG,OAAO;CAAE;CAGlD,IAAME,IAAQC,EAAYH,CAAM,GAC1BI,KAAS,GAAe,MAAsB;EAClD,QAAQJ,EAAO,SAAS,UAAxB;GACE,KAAK,SAAS,OAAO;IAAE,QAAQK;IAAW,OAAOC;GAAM;GACvD,KAAK,SAAS,OAAO;IAAE,QAAQA,IAAQD;IAAW,OAAO;GAAE;GAC3D,SAAS,OAAO;IAAE,QAAQC,IAAQ,IAAID;IAAW,OAAOC,IAAQ;GAAE;EACpE;CACF,GACMA,IAAQN,EAAO,SAAS,GACxBO,IAAQH,EAAM,OAAOE,KAAU,WAAW,IAAIE,EAAmBF,GAAOG,KAAS,CAAC,GAAGP,EAAM,KAAK;CACtG,IAAI,OAAOI,KAAU,YAAY,EAAEJ,EAAM,KAAK,IAAI,OAAOK;CACzD,IAAMG,IAAKN,EAAM,OAAOE,KAAU,WAAWA,EAAM,KAAK,GAAGJ,EAAM,EAAE;CACnE,OAAO;EAAE,QAAQK,EAAM;EAAQ,OAAOA,EAAM;EAAO,UAAUG,EAAG;EAAQ,SAASA,EAAG;CAAM;AAC5F;AAOA,SAAgBC,EAAyB,GAAqB,GAA8C;CAC1G,IAAMC,IAAUC,GAAK,cACfC,IAAOC,EAAK;CAClB,IAAIH,MAAY,KAAA,KAAaE,GAAM,SAAS,QAAQ,OAAOC;CAC3D,IAAMC,IAAW,IAAIC,EAAiBH,EAAK,IAAI,GACzCjB,IAAOiB,EAAK,OAAOF,EAAQ,QAAQE,EAAK,YAAY,IAAI,KAAA,GACxDd,IAASc,EAAK,SAASF,EAAQ,UAAUE,EAAK,OAAO,YAAY,IAAI,KAAA,GACrEI,IAAcrB,GAAM,WAAWmB,KAAYnB,MAASiB,EAAK,cACzDK,IAAgBnB,GAAQ,WAAWgB,KAAYhB,MAAWc,EAAK,QAAQ;CAO7E,OANI,CAACI,KAAe,CAACC,IAAsBJ,IAMpC,CAAC;EAJN,GAAGD;EACH,GAAII,IAAc,EAAE,cAAcrB,EAAiB,IAAI,CAAC;EACxD,GAAIsB,IAAgB,EAAE,QAAQ;GAAE,GAAGL,EAAK;GAAS,cAAcd;EAAmB,EAAE,IAAI,CAAC;CAEnF,GAAM,GAAGe,EAAK,MAAM,CAAC,CAAC;AAChC;AAeA,SAAgBK,EAAY,GAAiE;CAC3F,IAAMpB,IAASD,EAAkBsB,EAAK,MAAM,GACtCxB,IAAOF,EAAgB0B,EAAK,MAAMrB,MAAW,OAAcsB,IAAP,IAAyB;CACnF,OAAOtB,MAAW,OAA0B,EAAE,QAAK,IAA1B;EAAE;EAAM;CAAO;AAC1C"}
+{"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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"}

package/dist/canvas/nodeShapes/pathPainter.js

@@ -1,39 +1,54 @@
-import { nodeMemo as e } from "../../core/scene/nodeMemo.js";
-import { PAINT_SLOT as t } from "./memo.js";
-import { inkReach as n, pathPaintOf as r, resolveNodeStroke as i, withAnimatedVertexColors as a } from "./nodePaint.js";
-import { DERIVED_PAINTER as o } from "./derivedPainter.js";
-import { paintsPose as s, poseBoxBounds as c } from "./poseBox.js";
-import { commandFill as l, commandStroke as u } from "@weasel-js/renderer";
-import { pathInPoseFrame as d } from "@weasel-js/geom";
+import { nodeMemo } from "../../core/scene/nodeMemo.js";
+import { PAINT_SLOT } from "./memo.js";
+import { inkReach, pathPaintOf, resolveNodeStroke, 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";
+
 //#region src/canvas/nodeShapes/pathPainter.ts
-var f = {
+var PATH_PAINTER = {
 	id: "kit:path",
-	matches: (e) => s(e.pose) ? e.data?.path != null : !1,
-	paint: (n, i, s) => s?.derivedPath == null ? a(e(n, t, i, () => {
-		let e = n.data, t = d(e.path, i), { fill: a, stroke: o } = r(e), s = a && l(a, i), c = o && u(o, i);
+	matches: (node) => {
+		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, () => {
+		const d = node.data;
+		const projected = pathInPoseFrame(d.path, pose);
+		const { fill: declared, stroke: strokeSpec } = pathPaintOf(d);
+		const fill = declared && commandFill(declared, pose);
+		const stroke = strokeSpec && commandStroke(strokeSpec, pose);
 		return [{
 			kind: "path",
-			path: t,
-			...s ? { fill: s } : {},
-			...s && e.vertexColors ? { vertexColors: e.vertexColors } : {},
-			...c ? { stroke: c } : {}
+			path: projected,
+			...fill ? { fill } : {},
+			...fill && d.vertexColors ? { vertexColors: d.vertexColors } : {},
+			...stroke ? { stroke } : {}
 		}];
-	}), s) : o.paint(n, i, s),
-	silhouette: (e, t, n) => {
-		if (n?.derivedPath != null) return n.derivedPath;
-		let r = e.data;
-		return d(r.path, t);
+	}), ctx),
+	silhouette: (node, pose, ctx) => {
+		if (ctx?.derivedPath != null) return ctx.derivedPath;
+		const d = node.data;
+		return pathInPoseFrame(d.path, pose);
 	},
-	ink: (e, t, i) => {
-		let a = e.data, { fill: o, stroke: s } = r(a);
+	ink: (node, _pose, ctx) => {
+		const d = node.data;
+		const { fill, stroke } = pathPaintOf(d);
 		return {
-			filled: o !== null,
-			...n(s ?? null, i?.scale)
+			filled: fill !== null,
+			...inkReach(stroke ?? null, ctx?.scale)
 		};
 	},
-	bounds: (e, t, n) => c(t, i(e.data.stroke), n)
+	bounds: (node, pose, ctx) => poseBoxBounds(pose, resolveNodeStroke(node.data.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));
+	}
 };
-//#endregion
-export { f as PATH_PAINTER };
 
+//#endregion
+export { PATH_PAINTER };
 //# sourceMappingURL=pathPainter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"pathPainter.js","names":["PATH_PAINTER","paintsPose","node","ctx","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","projected","pathInPoseFrame","declared","strokeSpec","pathPaintOf","fill","commandFill","stroke","commandStroke","DERIVED_PAINTER","inkReach","poseBoxBounds","resolveNodeStroke"],"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';\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};\n"],"mappings":";;;;;;;;AAgBA,IAAaA,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAOrC,QAAQ,GAAM,GAAM,MAAQC,GAAK,eAAe,OAG5CC,EAAyBC,EAASH,GAAMI,GAAYC,SAAY;EAClE,IAAMC,IAAIN,EAAK,MAMTO,IAAYC,EAAgBF,EAAE,MAAMD,CAAI,GACxC,EAAE,MAAMI,GAAU,QAAQC,MAAeC,EAAYL,CAAC,GAItDM,IAAOH,KAAYI,EAAYJ,GAAUJ,CAAI,GAC7CS,IAASJ,KAAcK,EAAcL,GAAYL,CAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAME;GACN,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;GACvB,GAAIA,KAAQN,EAAE,eAAe,EAAE,cAAcA,EAAE,aAAa,IAAI,CAAC;GACjE,GAAIQ,IAAS,EAAE,UAAO,IAAI,CAAC;EAErB,CAAG;CACb,CAAC,GAAGb,CAAG,IAvBHe,EAAgB,MAAMhB,GAAMK,GAAMJ,CAAG;CAwBzC,aAAa,GAAM,GAAM,MAAQ;EAC/B,IAAIA,GAAK,eAAe,MAAM,OAAOA,EAAI;EACzC,IAAMK,IAAIN,EAAK;EACf,OAAOQ,EAAgBF,EAAE,MAAMD,CAAI;CACrC;CACA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIN,EAAK,MAIT,EAAE,SAAM,cAAWW,EAAYL,CAAC;EACtC,OAAO;GAAE,QAAQM,MAAS;GAAM,GAAGK,EAASH,KAAU,MAAMb,GAAK,KAAK;EAAE;CAC1E;CAEA,SAAS,GAAM,GAAM,MACnBiB,EAAcb,GAAMc,EAAmBnB,EAAK,KAAoC,MAAM,GAAGC,CAAG;AAChG"}
+{"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, derivedDrawnBounds } 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    if (ctx?.derivedPath != null) return derivedDrawnBounds(node, 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,IAAI,KAAK,eAAe,MAAM,OAAO,mBAAmB,MAAM,GAAG;EACjE,MAAM,IAAI,KAAK;EACf,OAAO,eAAe,MAAM,MAAM,kBAAkB,EAAE,MAAM,GAAG,MAAM,OAAO,gBAAgB,EAAE,MAAM,EAAE,CAAC;CACzG;AACF"}

package/dist/canvas/nodeShapes/poseBox.js

@@ -1,20 +1,27 @@
-import { isRectPose as e } from "../../core/geometry/autoPoseDescriptor.js";
-import { strokeReachAt as t } from "@weasel-js/renderer";
+import { isRectPose } from "../../core/geometry/autoPoseDescriptor.js";
+import { strokeReachAt } from "@weasel-js/renderer";
+
 //#region src/canvas/nodeShapes/poseBox.ts
-function n(t) {
-	return t === void 0 || e(t);
+/** Whether a built-in painter can read this pose. A node that declares none
+*  passes: the pose is then the caller's argument, not the node's. */
+function paintsPose(pose) {
+	return pose === void 0 || isRectPose(pose);
 }
-function r(n, r, i) {
-	if (!e(n)) return null;
-	let a = r ? t(r, i?.scale ?? 1, i?.leastScale) : 0, o = Math.min(n.x, n.x + n.width), s = Math.min(n.y, n.y + n.height);
+/** The pose rect grown by how far `stroke` can paint outside it — the paint
+*  box of every built-in painter whose geometry the pose box contains. */
+function poseBoxBounds(pose, stroke, ctx) {
+	if (!isRectPose(pose)) return null;
+	const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;
+	const x = Math.min(pose.x, pose.x + pose.width);
+	const y = Math.min(pose.y, pose.y + pose.height);
 	return {
-		x: o - a,
-		y: s - a,
-		width: Math.abs(n.width) + 2 * a,
-		height: Math.abs(n.height) + 2 * a
+		x: x - reach,
+		y: y - reach,
+		width: Math.abs(pose.width) + 2 * reach,
+		height: Math.abs(pose.height) + 2 * reach
 	};
 }
-//#endregion
-export { n as paintsPose, r as poseBoxBounds };
 
+//#endregion
+export { paintsPose, poseBoxBounds };
 //# sourceMappingURL=poseBox.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poseBox.js","names":["paintsPose","pose","isRectPose","poseBoxBounds","reach","stroke","strokeReachAt","ctx","x","y"],"sources":["../../../src/canvas/nodeShapes/poseBox.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport { strokeReachAt } from '@weasel-js/renderer';\n\n/** Whether a built-in painter can read this pose. A node that declares none\n *  passes: the pose is then the caller's argument, not the node's. */\nexport function paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\n\n/** The pose rect grown by how far `stroke` can paint outside it — the paint\n *  box of every built-in painter whose geometry the pose box contains. */\nexport function poseBoxBounds(pose: unknown, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;\n  const x = Math.min(pose.x, pose.x + pose.width);\n  const y = Math.min(pose.y, pose.y + pose.height);\n  return {\n    x: x - reach,\n    y: y - reach,\n    width: Math.abs(pose.width) + 2 * reach,\n    height: Math.abs(pose.height) + 2 * reach,\n  };\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAwB;CACjD,OAAOC,MAAS,KAAA,KAAaC,EAAWD,CAAI;AAC9C;AAIA,SAAgBE,EAAc,GAAe,GAAuB,GAA4C;CAC9G,IAAI,CAACD,EAAWD,CAAI,GAAG,OAAO;CAC9B,IAAMG,IAAQC,IAASC,EAAcD,GAAQE,GAAK,SAAS,GAAGA,GAAK,UAAU,IAAI,GAC3EC,IAAI,KAAK,IAAIP,EAAK,GAAGA,EAAK,IAAIA,EAAK,KAAK,GACxCQ,IAAI,KAAK,IAAIR,EAAK,GAAGA,EAAK,IAAIA,EAAK,MAAM;CAC/C,OAAO;EACL,GAAGO,IAAIJ;EACP,GAAGK,IAAIL;EACP,OAAO,KAAK,IAAIH,EAAK,KAAK,IAAI,IAAIG;EAClC,QAAQ,KAAK,IAAIH,EAAK,MAAM,IAAI,IAAIG;CACtC;AACF"}
+{"version":3,"file":"poseBox.js","names":[],"sources":["../../../src/canvas/nodeShapes/poseBox.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport { strokeReachAt } from '@weasel-js/renderer';\n\n/** Whether a built-in painter can read this pose. A node that declares none\n *  passes: the pose is then the caller's argument, not the node's. */\nexport function paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\n\n/** The pose rect grown by how far `stroke` can paint outside it — the paint\n *  box of every built-in painter whose geometry the pose box contains. */\nexport function poseBoxBounds(pose: unknown, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;\n  const x = Math.min(pose.x, pose.x + pose.width);\n  const y = Math.min(pose.y, pose.y + pose.height);\n  return {\n    x: x - reach,\n    y: y - reach,\n    width: Math.abs(pose.width) + 2 * reach,\n    height: Math.abs(pose.height) + 2 * reach,\n  };\n}\n"],"mappings":";;;;;;AAQA,SAAgB,WAAW,MAAwB;CACjD,OAAO,SAAS,UAAa,WAAW,IAAI;AAC9C;;;AAIA,SAAgB,cAAc,MAAe,QAAuB,KAA4C;CAC9G,IAAI,CAAC,WAAW,IAAI,GAAG,OAAO;CAC9B,MAAM,QAAQ,SAAS,cAAc,QAAQ,KAAK,SAAS,GAAG,KAAK,UAAU,IAAI;CACjF,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,KAAK,KAAK;CAC9C,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,KAAK,MAAM;CAC/C,OAAO;EACL,GAAG,IAAI;EACP,GAAG,IAAI;EACP,OAAO,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI;EAClC,QAAQ,KAAK,IAAI,KAAK,MAAM,IAAI,IAAI;CACtC;AACF"}

package/dist/canvas/nodeShapes/rectFallbackPainter.js

@@ -1,38 +1,42 @@
-import { DEFAULT_SHAPE_FILL as e } from "../../util/paint.js";
-import { resolveNodeFill as t } from "./nodePaint.js";
-import { paintsPose as n, poseBoxBounds as r } from "./poseBox.js";
-import { commandFill as i } from "@weasel-js/renderer";
+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";
+
 //#region src/canvas/nodeShapes/rectFallbackPainter.ts
-var a = {
+var RECT_FALLBACK_PAINTER = {
 	id: "kit:rect-fallback",
-	matches: (e) => n(e.pose),
-	paint: (n, r) => {
-		let a = n.data, o = r, s = t(a?.fill, e), c = s && i(s, o);
+	matches: (node) => paintsPose(node.pose),
+	paint: (node, pose) => {
+		const d = node.data;
+		const p = pose;
+		const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);
+		const fill = declared && commandFill(declared, p);
 		return [{
 			kind: "path",
 			path: {
 				kind: "rect",
-				x: o.x,
-				y: o.y,
-				width: o.width,
-				height: o.height
+				x: p.x,
+				y: p.y,
+				width: p.width,
+				height: p.height
 			},
-			...c ? { fill: c } : {}
+			...fill ? { fill } : {}
 		}];
 	},
-	silhouette: (e, t) => {
-		let n = t;
+	silhouette: (_node, pose) => {
+		const p = pose;
 		return {
 			kind: "rect",
-			x: n.x,
-			y: n.y,
-			width: n.width,
-			height: n.height
+			x: p.x,
+			y: p.y,
+			width: p.width,
+			height: p.height
 		};
 	},
-	bounds: (e, t) => r(t, null, void 0)
+	bounds: (_node, pose) => poseBoxBounds(pose, null, void 0)
 };
-//#endregion
-export { a as RECT_FALLBACK_PAINTER };
 
+//#endregion
+export { RECT_FALLBACK_PAINTER };
 //# sourceMappingURL=rectFallbackPainter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"rectFallbackPainter.js","names":["RECT_FALLBACK_PAINTER","paintsPose","node","d","p","pose","declared","resolveNodeFill","DEFAULT_SHAPE_FILL","fill","commandFill","poseBoxBounds"],"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,IAAaA,IAA2D;CAKtE,IAAI;CACJ,UAAU,MAASC,EAAWC,EAAK,IAAI;CACvC,QAAQ,GAAM,MAAS;EACrB,IAAMC,IAAID,EAAK,MACTE,IAAIC,GACJC,IAAWC,EAAgBJ,GAAG,MAAMK,CAAkB,GACtDC,IAAOH,KAAYI,EAAYJ,GAAUF,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAGA,EAAE;IAAG,GAAGA,EAAE;IAAG,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GACvE,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,GAAO,MAAS;EAC3B,IAAML,IAAIC;EACV,OAAO;GAAE,MAAM;GAAQ,GAAGD,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC1E;CACA,SAAS,GAAO,MAASO,EAAcN,GAAM,MAAM,KAAA,CAAS;AAC9D"}
+{"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"}