@weasel-js/core 1.6.1 → 1.7.1

package/dist/canvas/NodeShape.js

@@ -0,0 +1,391 @@
+import { bumpNodeMemoGeneration as e, nodeMemo as t } from "../core/scene/nodeMemo.js";
+import { resolveStrokeWidth as n } from "../features/paths/tessellate/stroke.js";
+import { markerReach as r } from "../features/paths/markerCommands.js";
+import { strokeReachAt as i } from "../renderer/cullDrawCommands.js";
+import { poseRotationOf as a, rotatePathAround as o } from "../core/geometry/poseRotation.js";
+import { isRectPose as s } from "../interactions/actions/resize/autoPoseDescriptor.js";
+import { countPathAnchors as c } from "../features/paths/anchors.js";
+import { pathInPoseFrame as l } from "../features/paths/pathInWorld.js";
+import { DEFAULT_SHAPE_FILL as u } from "../util/paint.js";
+import { fillInPoseFrame as d } from "../core/fillInPoseFrame.js";
+import { resolveFillPattern as f } from "../features/patterns/resolveSpec.js";
+import { textCommandFromPose as p } from "../features/text/textCommand.js";
+import { hasSlop as m, slopForStrokeHit as ee } from "../core/viewport/screenSlop.js";
+import { getImageBitmap as h, imageStatus as g } from "../features/images/imageCache.js";
+import { PATH_L as _, PATH_M as v, PATH_Z as y, boundsOfPath as b, ellipsePath as x, linePath as S, pathContainsPoint as C, regularPolygonPath as w, starPath as T, strokeHitTest as E } from "@weasel-js/geom";
+import { textLineBoxes as D } from "@weasel-js/text";
+//#region src/canvas/NodeShape.ts
+function O(e) {
+	return e === void 0 || s(e);
+}
+var k = Object.freeze({
+	filled: !0,
+	outset: 0,
+	inset: 0
+}), A = {
+	high: [],
+	normal: []
+};
+function j(t, n = {}) {
+	let r = n.priority === "high" ? A.high : A.normal;
+	return r.push(t), e(), () => {
+		let n = r.indexOf(t);
+		n >= 0 && r.splice(n, 1), e();
+	};
+}
+var M = "shape:painter", N = "shape:painter:nonrect", P = "shape:silhouette", F = "shape:paint";
+function I(e) {
+	let n = O(e.pose) ? M : N;
+	return t(e, n, void 0, () => L(e));
+}
+function L(e) {
+	for (let t of A.high) if (t.matches(e)) return t;
+	for (let t of A.normal) if (t.matches(e)) return t;
+}
+function R(e, n, r) {
+	let i = () => {
+		let t = I(e)?.silhouette?.(e, n, r) ?? null, i = t ? a(n) : null;
+		return t && i ? o(t, i.cx, i.cy, i.rotation) : t;
+	};
+	return r?.derivedPath == null ? t(e, P, n, i) : i();
+}
+function z(e, t, n) {
+	return I(e)?.ink?.(e, t, n) ?? null;
+}
+function B(e, t, n) {
+	return I(e)?.bounds?.(e, t, n) ?? null;
+}
+function V(e, t, n) {
+	if (!s(e)) return null;
+	let r = t ? i(t, n ?? 1) : 0, a = Math.min(e.x, e.x + e.width), o = Math.min(e.y, e.y + e.height);
+	return {
+		x: a - r,
+		y: o - r,
+		width: Math.abs(e.width) + 2 * r,
+		height: Math.abs(e.height) + 2 * r
+	};
+}
+function H(e, t, n, r, i = {}) {
+	let a = R(e, t, { derivedPath: i.derivedPath });
+	if (a === null) return !0;
+	let o = z(e, t, { scale: i.scale }) ?? k, s = C(a, n, r);
+	if (o.filled && s) return !0;
+	let { extra: c, opts: l } = ee(i.tolerance), u = (s ? o.inset : o.outset) + c;
+	return (u > 0 || m(i.tolerance)) && E(a, n, r, u, l);
+}
+function U() {
+	return [...A.high, ...A.normal];
+}
+function W(e, t) {
+	return {
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height,
+		text: e.text,
+		runs: e.runs,
+		style: e.style,
+		fill: e.fill,
+		stroke: q(e.stroke) ?? void 0,
+		verticalAlign: e.verticalAlign
+	};
+}
+var G = {
+	id: "kit:text",
+	matches: (e) => O(e.pose) ? e.data?.text != null : !1,
+	paint: (e, n) => t(e, F, n, () => [p(W(e.data, n))]),
+	silhouette: (e, t) => {
+		let n = D(W(e.data, t));
+		return n.length === 0 ? null : te(n);
+	},
+	ink: (e, t, n) => {
+		let r = e.data;
+		return {
+			filled: !0,
+			...Y(q(r.stroke), n?.scale)
+		};
+	}
+};
+function te(e) {
+	let t = new Uint8Array(e.length * 6), n = new Float32Array(e.length * 10), r = 0, i = 0;
+	for (let a of e) {
+		let { x: e, y: o, width: s, height: c } = a;
+		t[i++] = v, n[r++] = e, n[r++] = o, t[i++] = _, n[r++] = e + s, n[r++] = o, t[i++] = _, n[r++] = e + s, n[r++] = o + c, t[i++] = _, n[r++] = e, n[r++] = o + c, t[i++] = _, n[r++] = e, n[r++] = o, t[i++] = y;
+	}
+	return {
+		kind: "polygon",
+		commands: t,
+		coords: n,
+		fillRule: "nonzero"
+	};
+}
+function K(e, t) {
+	return e === void 0 ? t : e;
+}
+function q(e) {
+	return e?.paint == null ? null : e;
+}
+function J(e, t) {
+	let n = f(d(e.paint, t));
+	return n === null ? null : n === e.paint ? e : {
+		...e,
+		paint: n
+	};
+}
+function Y(e, t) {
+	if (e === null) return {
+		outset: 0,
+		inset: 0
+	};
+	let i = n(e.width ?? 1, t ?? 1), a = r(e, i, t);
+	switch (e.align ?? "center") {
+		case "inner": return {
+			outset: a,
+			inset: i
+		};
+		case "outer": return {
+			outset: i + a,
+			inset: 0
+		};
+		default: return {
+			outset: i / 2 + a,
+			inset: i / 2
+		};
+	}
+}
+function X(e, t) {
+	let n = t?.vertexColors, r = e[0];
+	if (n === void 0 || r?.kind !== "path") return e;
+	let i = 4 * c(r.path), a = r.fill ? n("fill", r.vertexColors) : void 0, o = r.stroke ? n("stroke", r.stroke.vertexColors) : void 0, s = a?.length === i && a !== r.vertexColors, l = o?.length === i && o !== r.stroke?.vertexColors;
+	return !s && !l ? e : [{
+		...r,
+		...s ? { vertexColors: a } : {},
+		...l ? { stroke: {
+			...r.stroke,
+			vertexColors: o
+		} } : {}
+	}, ...e.slice(1)];
+}
+var Z = {
+	id: "kit:path",
+	matches: (e) => O(e.pose) ? e.data?.path != null : !1,
+	paint: (e, n, r) => X(t(e, F, n, () => {
+		let t = e.data, r = l(t.path, n), i = q(t.stroke), a = i !== null, o = K(t.fill, a ? null : u), s = o && f(d(o, n)), c = i && J(i, n);
+		return [{
+			kind: "path",
+			path: r,
+			...s ? { fill: s } : {},
+			...s && t.vertexColors ? { vertexColors: t.vertexColors } : {},
+			...c ? { stroke: c } : {}
+		}];
+	}), r),
+	silhouette: (e, t) => {
+		let n = e.data;
+		return l(n.path, t);
+	},
+	ink: (e, t, n) => {
+		let r = e.data, i = q(r.stroke), a = i !== null;
+		return {
+			filled: K(r.fill, a ? null : u) !== null,
+			...Y(i, n?.scale)
+		};
+	},
+	bounds: (e, t, n) => V(t, q(e.data.stroke), n?.scale)
+}, Q = {
+	id: "kit:shape",
+	matches: (e) => {
+		if (!O(e.pose)) return !1;
+		let t = e.data?.shape;
+		return t != null && ne.has(t);
+	},
+	paint: (e, n, r) => X(t(e, F, n, () => {
+		let t = e.data, r = $(t, n), i = K(t.fill, u), a = i && f(d(i, n)), o = q(t.stroke), s = o && J(o, n);
+		return [{
+			kind: "path",
+			path: r,
+			...a ? { fill: a } : {},
+			...s ? { stroke: s } : {}
+		}];
+	}), r),
+	silhouette: (e, t) => {
+		let n = e.data;
+		return $(n, t);
+	},
+	ink: (e, t, n) => {
+		let r = e.data;
+		return {
+			filled: K(r.fill, u) !== null,
+			...Y(q(r.stroke), n?.scale)
+		};
+	},
+	bounds: (e, t, n) => V(t, q(e.data.stroke), n?.scale)
+}, ne = /* @__PURE__ */ new Set([
+	"rect",
+	"ellipse",
+	"polygon",
+	"star"
+]);
+function $(e, t) {
+	switch (e.shape) {
+		case "ellipse": return x(t);
+		case "polygon": {
+			let n = t.x + t.width / 2, r = t.y + t.height / 2, i = Math.min(t.width, t.height) / 2;
+			return w({
+				x: n,
+				y: r
+			}, i, e.sides ?? 6);
+		}
+		case "star": {
+			let n = t.x + t.width / 2, r = t.y + t.height / 2, i = Math.min(t.width, t.height) / 2;
+			return T({
+				x: n,
+				y: r
+			}, i, e.points ?? 5);
+		}
+		default: return {
+			kind: "rect",
+			x: t.x,
+			y: t.y,
+			width: t.width,
+			height: t.height
+		};
+	}
+}
+function re(e, t) {
+	return {
+		x: e.x * t.width,
+		y: e.y * t.height,
+		w: e.width * t.width,
+		h: e.height * t.height
+	};
+}
+function ie(e, t, n) {
+	if (n && n > 0) return {
+		width: Math.abs(e.width) * n / (t?.width || 1),
+		height: Math.abs(e.height) * n / (t?.height || 1)
+	};
+}
+var ae = {
+	id: "kit:image",
+	matches: (e) => {
+		if (!O(e.pose)) return !1;
+		let t = e.data?.image?.src;
+		return typeof t == "string" && t.length > 0;
+	},
+	paint: (e, t, n) => {
+		let r = e.data, i = t, a = n?.resolveImage ? n.resolveImage(e) : h(r.image.src, ie(i, r.image.source, n?.pixelScale));
+		if (a) return [{
+			kind: "image",
+			image: a,
+			x: i.x,
+			y: i.y,
+			w: i.width,
+			h: i.height,
+			...r.image.opacity === void 0 ? {} : { opacity: r.image.opacity },
+			...r.image.source ? { source: re(r.image.source, a) } : {},
+			...r.image.flipX ? { flipX: !0 } : {},
+			...r.image.flipY ? { flipY: !0 } : {}
+		}];
+		let o = !n?.resolveImage && g(r.image.src) === "error", s = o ? "#d08a8a" : "#bbbbbb", c = [{
+			kind: "path",
+			path: {
+				kind: "rect",
+				x: i.x,
+				y: i.y,
+				width: i.width,
+				height: i.height
+			},
+			stroke: {
+				paint: { color: s },
+				width: 1
+			}
+		}];
+		return o && c.push({
+			kind: "path",
+			path: S({
+				x: i.x,
+				y: i.y
+			}, {
+				x: i.x + i.width,
+				y: i.y + i.height
+			}),
+			stroke: {
+				paint: { color: s },
+				width: 1
+			}
+		}), c;
+	},
+	silhouette: (e, t) => {
+		let n = t;
+		return {
+			kind: "rect",
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height
+		};
+	},
+	bounds: (e, t, n) => V(t, oe, n?.scale)
+}, oe = {
+	paint: { color: "#000" },
+	width: 1
+}, se = {
+	id: "kit:derived",
+	matches: (e) => (e.dependsOn?.length ?? 0) > 0 && e.derivePath !== void 0,
+	paint: (e, t, n) => {
+		let r = n?.derivedPath;
+		if (r == null) return [];
+		let i = b(r), a = e.data, o = q(a?.stroke), s = K(a?.fill, o === null ? u : null), c = s && f(d(s, i)), l = o && J(o, i);
+		return X([{
+			kind: "path",
+			path: r,
+			...c ? { fill: c } : {},
+			...c && a?.vertexColors ? { vertexColors: a.vertexColors } : {},
+			...l ? { stroke: l } : {}
+		}], n);
+	},
+	silhouette: (e, t, n) => n?.derivedPath ?? null,
+	ink: (e, t, n) => {
+		let r = e.data, i = q(r?.stroke);
+		return {
+			filled: K(r?.fill, i === null ? u : null) !== null,
+			...Y(i, n?.scale)
+		};
+	}
+}, ce = {
+	id: "kit:rect-fallback",
+	matches: (e) => O(e.pose),
+	paint: (e, t) => {
+		let n = e.data, r = t, i = K(n?.fill, u);
+		return [{
+			kind: "path",
+			path: {
+				kind: "rect",
+				x: r.x,
+				y: r.y,
+				width: r.width,
+				height: r.height
+			},
+			...i ? { fill: i } : {}
+		}];
+	},
+	silhouette: (e, t) => {
+		let n = t;
+		return {
+			kind: "rect",
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height
+		};
+	},
+	bounds: (e, t) => V(t, null, void 0)
+};
+function le() {
+	j(G), j(se), j(Z), j(Q), j(ae), j(ce);
+}
+le();
+//#endregion
+export { k as DEFAULT_INK, I as findNodeShape, B as findShapeBounds, z as findShapeInk, R as findShapeSilhouette, U as getNodeShapes, j as registerNodeShape, H as shapeCoversPoint };
+
+//# sourceMappingURL=NodeShape.js.map

package/dist/canvas/NodeShape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeShape.js","names":["paintsPose","pose","isRectPose","DEFAULT_INK","PAINTERS","registerNodeShape","list","opts","painter","bumpNodeMemoGeneration","i","PAINTER_SLOT","PAINTER_SLOT_NONRECT","SILHOUETTE_SLOT","PAINT_SLOT","findNodeShape","slot","node","nodeMemo","matchNodeShape","p","findShapeSilhouette","build","sil","ctx","r","poseRotationOf","rotatePathAround","findShapeInk","findShapeBounds","poseBoxBounds","reach","stroke","strokeReachAt","scale","x","y","shapeCoversPoint","ink","inside","pathContainsPoint","hit","slopForStrokeHit","extra","hasSlop","strokeHitTest","getNodeShapes","textPoseOf","d","resolveNodeStroke","TEXT_PAINTER","textCommandFromPose","boxes","textLineBoxes","rectsToPath","inkReach","commands","rects","coords","ci","cmd","w","h","PATH_M","PATH_L","PATH_Z","resolveNodeFill","fill","fallback","strokeInPoseFrame","paint","resolveFillPattern","fillInPoseFrame","box","resolveStrokeWidth","markerReach","withAnimatedVertexColors","resolve","body","cmds","expected","countPathAnchors","fillChanged","strokeChanged","PATH_PAINTER","projected","pathInPoseFrame","strokeSpec","hasStroke","declared","DEFAULT_SHAPE_FILL","SHAPE_PAINTER","s","SHAPE_KINDS","path","pathForShape","declaredFill","shapeFill","ellipsePath","cx","cy","regularPolygonPath","starPath","sourceInPixels","bmp","drawnSize","pixelScale","source","IMAGE_PAINTER","src","getImageBitmap","error","imageStatus","color","linePath","IMAGE_PLACEHOLDER_STROKE","DERIVED_PAINTER","boundsOfPath","RECT_FALLBACK_PAINTER","registerBuiltInShapePainters"],"sources":["../../src/canvas/NodeShape.ts"],"sourcesContent":["/**\n * NodeShape — the **shape trait's** registry. Each trait of a node\n * (shape, routing, label, icon, affordances, …) is its own registry;\n * this one holds the per-kind `paint` + `silhouette` (and future\n * fields) used by `defaultDrawOne`, clipping, non-rect hit-testing,\n * and lasso/area-select.\n *\n * Teaching the kit about a new kind of shape goes through this registry\n * rather than by overriding `drawOne`. Overrides are still possible but\n * shouldn't be the default seam: most consumers want the same dispatch\n * logic, just extended with their own shape kinds (images, custom paths,\n * SVG fragments, etc.).\n *\n * Built-in entries (`kit:text`, `kit:path`, `kit:rect-fallback`) are\n * registered at module load. Consumer entries added via\n * `registerNodeShape` join the chain; the first entry whose\n * `matches` predicate returns true paints the node. Every built-in but\n * `kit:derived` additionally requires a rect-shaped pose — a scene whose\n * poses are some other shape matches none of them, and paints through a\n * consumer painter or not at all.\n *\n * Two priority tiers:\n *   - `'high'` — checked before all `'normal'` entries. Use this to\n *     override a kit built-in for a specific data shape (e.g. a custom\n *     text renderer that wins over `kit:text`).\n *   - `'normal'` (default) — appended after the built-ins.\n *\n * Within a tier, entries run in registration order. Each\n * `registerNodeShape` call returns a disposer that removes the\n * entry — useful for tests, for plugin lifecycles, and for swapping\n * implementations at runtime.\n *\n * See `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`\n * for the trait taxonomy.\n */\nimport type { Node, RectPose } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport { isRectPose } from 'interactions/actions/resize/autoPoseDescriptor';\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. */\nfunction paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\nimport type { DrawCommand, PathDrawCommand } from '../renderer';\nimport type { VertexColorChannel } from '../animation/colorRegistry';\nimport { countPathAnchors } from 'features/paths/anchors';\nimport { textCommandFromPose } from 'features/text/textCommand';\nimport type { TextPose, TextStyle } from '@weasel-js/text';\nimport type { StyledRun, TextVerticalAlign } from '@weasel-js/text';\nimport { textLineBoxes } from '@weasel-js/text';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { DEFAULT_SHAPE_FILL } from '../util/paint';\nimport {\n  type Path,\n  type PolygonPath,\n  PATH_M,\n  PATH_L,\n  PATH_Z,\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  linePath,\n  pathContainsPoint,\n  strokeHitTest,\n  boundsOfPath,\n} from '@weasel-js/geom';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { markerReach } from 'features/paths/markerCommands';\nimport { strokeReachAt } from '../renderer/cullDrawCommands';\nimport { hasSlop, slopForStrokeHit, type PickSlop } from 'core/viewport/screenSlop';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseRotationOf, rotatePathAround } from 'core/geometry/poseRotation';\nimport { pathInPoseFrame } from 'features/paths/pathInWorld';\nimport { fillInPoseFrame, type FillPoseBox } from '../core/fillInPoseFrame';\nimport { resolveFillPattern } from '../features/patterns/resolveSpec';\nimport {\n  getImageBitmap, imageStatus, type ImageNodeData, type ImageRasterSize,\n} from 'features/images/imageCache';\nimport { nodeMemo, bumpNodeMemoGeneration } from 'core/scene/nodeMemo';\n\n/** Optional per-call paint context, threaded through `defaultDrawOne`'s third\n *  argument. Lets a rendering entry point override ambient environment reads\n *  — the headless `renderSceneToPixels` path supplies its own bitmap resolver\n *  here so consumers reuse their own decode caches. Custom painters may\n *  ignore it entirely. */\nexport interface NodePaintCtx {\n  /** Override bitmap resolution for image nodes. When set it is authoritative:\n   *  the global `imageCache` is not consulted, and an `undefined` result\n   *  paints the deterministic grey placeholder outline (never the ambient\n   *  load-status error variant). */\n  resolveImage?: (node: Node<unknown, string, unknown>) => ImageBitmap | undefined;\n  /** Device pixels per world unit where this paint will land — the view's\n   *  scale times the device-pixel ratio. `defaultDrawOne` fills it from its\n   *  view when absent. Lets a painter size resolution-dependent work, such as\n   *  re-rasterizing an SVG image; one that has no such work ignores it. */\n  pixelScale?: number;\n  /** The node's derived path, resolved by the scene-aware `drawOne` wrapper\n   *  before painting: `paint` has no scene handle, and deriving needs the\n   *  dependencies' poses. **Absent** for a node that derives from nothing —\n   *  the wrapper hands such a node the caller's own ctx untouched. `null`\n   *  means the node derives but has nothing to draw. */\n  derivedPath?: Path | null;\n  /** A node's animated per-anchor colors: given the colors a painter would paint\n   *  on `channel`, the colors to paint instead. **Absent** when nothing animates\n   *  the node. The kit's path painters apply it; see `withColorOverrides`. */\n  vertexColors?: (\n    channel: VertexColorChannel,\n    base: readonly number[] | undefined,\n  ) => readonly number[] | undefined;\n}\n\n/**\n * Per-node draw function — the scene-slot `drawOne` signature shared by\n * `<SceneCanvas>`, `renderSceneToCanvas` and `renderSceneToPixels`, so a\n * consumer can reuse one callback across a main canvas and a detached view.\n *\n * Called once per node in the walk. Returned commands are world-space; the\n * caller applies the view transform at the group level. `ctx` is supplied by\n * the scene-aware wrappers — see {@link NodePaintCtx}.\n */\nexport type SceneViewDrawOne<TData, TLayer extends string, TPose> = (\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view: View,\n  ctx?: NodePaintCtx,\n) => DrawCommand[];\n\n/** A painter for one kind of node: which nodes it claims, and the draw\n *  commands it emits for them. Registering one is how a consumer teaches the\n *  default renderer to draw its own node kinds. */\nexport interface NodeShapeEntry<TData = unknown, TPose = unknown> {\n  /** Stable identifier — used for unregistration and debugging. Pick\n   *  something descriptive: `'kit:text'`, `'app:image'`, etc. */\n  id: string;\n  /** Returns true when this painter renders the node. The first matching\n   *  painter (`'high'` tier first, then `'normal'`) wins. The kit's own\n   *  painters also require a rect-shaped pose, since their geometry reads\n   *  `x`/`y`/`width`/`height` off it. */\n  matches(node: Node<TData, string, TPose>): boolean;\n  /** Emits the draw commands for the node's primary visual. `ctx` is an\n   *  optional per-call paint context (see `NodePaintCtx`); painters that\n   *  don't need it can keep a two-argument signature.\n   *\n   *  **The returned array belongs to the painter.** Callers must treat it as\n   *  immutable and copy before appending — a painter is free to memoize its\n   *  command list (`kit:shape` and `kit:path` do), and an in-place `push`\n   *  would grow that list on every frame. `defaultDrawOne` copies before\n   *  adding its label overlay for exactly this reason. */\n  paint(node: Node<TData, string, TPose>, pose: TPose, ctx?: NodePaintCtx): DrawCommand[];\n  /** Optional: derive the node's silhouette path from its pose.\n   *  Used by clipping (when the container has no explicit\n   *  `clipFromPose`), by non-rect hit-testing, and by lasso/area-select.\n   *  Painters whose visual has no meaningful closed silhouette (e.g. text)\n   *  leave this undefined. */\n  silhouette?(\n    node: Node<TData, string, TPose>,\n    pose: TPose,\n    ctx?: NodeSilhouetteCtx,\n  ): Path | null;\n  /** Optional: how the silhouette is inked — whether the interior is filled,\n   *  and how wide the outline is. Read by picking, so that an unfilled shape\n   *  is grabbable by its outline rather than by its empty middle.\n   *\n   *  This is declared separately from `paint` rather than read back off the\n   *  emitted draw commands because picking runs on every pointer move, and\n   *  `paint` is allowed to be expensive (`kit:text` lays out glyphs). Keep it\n   *  to cheap field reads.\n   *\n   *  Painters that leave it undefined are treated as {@link DEFAULT_INK} —\n   *  the pre-`ink` behavior, where the whole silhouette interior is grabbable\n   *  and the outline adds nothing.\n   *\n   *  `ctx.scale` carries the view scale so a `{ px }` stroke width resolves to\n   *  world units; without it a screen-pixel width is read as world units. */\n  ink?(node: Node<TData, string, TPose>, pose: TPose, ctx?: NodeInkCtx): NodeInk | null;\n  /** Optional: a box enclosing every pixel `paint` can put down for this node,\n   *  stroke, markers and miter spikes included, in the frame `paint` emits in\n   *  — before the pose's rotation is applied around it.\n   *\n   *  Culling reads it to skip `paint` for a node outside the view, so a box\n   *  that is too small makes the node vanish before it reaches the screen\n   *  edge. Leave it undefined, or return `null`, when no cheap conservative\n   *  answer exists (`kit:text` has none short of laying out its glyphs); such\n   *  a node is always painted. Same cheap-reads rule as `ink`. */\n  bounds?(node: Node<TData, string, TPose>, pose: TPose, ctx?: NodeInkCtx): Bounds | null;\n}\n\n/** How a painter inks its silhouette. See {@link NodeShapeEntry.ink}.\n *\n *  Reach is per-side because `align` decides which side the ribbon lands on:\n *  a centered stroke straddles the outline, `'inner'` puts nothing outside it,\n *  `'outer'` nothing inside. */\nexport interface NodeInk {\n  /** True when the silhouette's interior is painted, and so grabbable. */\n  filled: boolean;\n  /** How far the ink reaches outside the outline, world units. */\n  outset: number;\n  /** How far it reaches inside. */\n  inset: number;\n}\n\n/** Per-call context for {@link NodeShapeEntry.silhouette}. */\nexport interface NodeSilhouetteCtx {\n  /** The node's derived path, resolved by the caller — a painter has no scene\n   *  handle and deriving needs the dependencies' poses. Same convention as\n   *  {@link NodePaintCtx.derivedPath}: absent for a node that derives from\n   *  nothing, `null` when it derives but has nothing to draw. */\n  derivedPath?: Path | null;\n}\n\n/** Per-call context for {@link NodeShapeEntry.ink}. */\nexport interface NodeInkCtx {\n  /** View scale, for resolving `{ px }` stroke widths to world units. */\n  scale?: number;\n}\n\n/** What a painter that declares no `ink` is assumed to do. */\nexport const DEFAULT_INK: Readonly<NodeInk> = Object.freeze({ filled: true, outset: 0, inset: 0 });\n\n/** Options for `registerNodeShape`. */\nexport interface RegisterNodeShapeOptions {\n  /** `'high'` puts the painter ahead of all normally-registered ones (so\n   *  it can win over a kit built-in). `'normal'` appends at the end. */\n  priority?: 'high' | 'normal';\n}\n\nconst PAINTERS: { high: NodeShapeEntry[]; normal: NodeShapeEntry[] } = {\n  high: [],\n  normal: [],\n};\n\n/** Register a shape painter. Returns a disposer that removes it. */\nexport function registerNodeShape<TData, TPose>(\n  painter: NodeShapeEntry<TData, TPose>,\n  opts: RegisterNodeShapeOptions = {},\n): () => void {\n  const list = opts.priority === 'high' ? PAINTERS.high : PAINTERS.normal;\n  list.push(painter as NodeShapeEntry);\n  // The painter set is exactly the ambient state `findNodeShape` reads, and a\n  // memo keyed on the node alone cannot see it change. See `nodeMemo`.\n  bumpNodeMemoGeneration();\n  return () => {\n    const i = list.indexOf(painter as NodeShapeEntry);\n    if (i >= 0) list.splice(i, 1);\n    bumpNodeMemoGeneration();\n  };\n}\n\n// ─── Per-node shape memo ────────────────────────────────────────────────────\n\n/**\n * Slot names for the two things picking asks per node per pointer move: which\n * painter matches, and that painter's silhouette path. Both go through\n * {@link nodeMemo}, so they invalidate on `data` (and, for the silhouette,\n * `pose`) reference changes and on a painter registration.\n *\n * Worth memoizing because both are hot and neither is free. `findNodeShape`\n * runs every registered painter's `matches` predicate; `silhouette` *builds*\n * a path — `pathForShape` allocates a fresh `Float32Array` for every ellipse,\n * polygon and star. Picking runs on every pointermove through both the\n * hover-cursor pump and `classifyTarget`, so that's two rebuilds per move per\n * node under the pointer, and shape-accurate picking is now the default.\n *\n * Separate slots rather than one entry: they mostly invalidate together, but\n * not always, and a shared entry would force the stricter key on both.\n */\nconst PAINTER_SLOT = 'shape:painter';\nconst PAINTER_SLOT_NONRECT = 'shape:painter:nonrect';\nconst SILHOUETTE_SLOT = 'shape:silhouette';\n\n/**\n * Slot for a painter's memoized `paint` output.\n *\n * Distinct from {@link 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. One entry keyed the same way for both would be wrong in\n * both directions.\n *\n * **Only for painters that are a pure function of `(node, pose, data)`.**\n * `kit:shape` and `kit:path` qualify and are also precisely the painters that\n * allocated a fresh `Path` per frame, defeating the tessellation cache in\n * `renderer/cache/cache.ts` (`WeakMap<Path, Mesh>`, keyed on Path identity).\n * `kit:text` and `kit:image` do not qualify — see the tests in\n * `NodeShape.cache.test.ts` that pin their opt-out.\n */\nconst PAINT_SLOT = 'shape:paint';\n\n/** Find the painter that will render `node` — first match in priority\n *  order. Returns undefined if no painter (including the built-in\n *  fallback) accepts the node. */\nexport function findNodeShape<TData, TPose>(\n  node: Node<TData, string, TPose>,\n): NodeShapeEntry<TData, TPose> | undefined {\n  // Built-in painters also gate on pose shape, so the key carries it too.\n  const slot = paintsPose(node.pose) ? PAINTER_SLOT : PAINTER_SLOT_NONRECT;\n  return nodeMemo(node as { data?: unknown }, slot, undefined, () =>\n    matchNodeShape(node),\n  );\n}\n\nfunction matchNodeShape<TData, TPose>(\n  node: Node<TData, string, TPose>,\n): NodeShapeEntry<TData, TPose> | undefined {\n  for (const p of PAINTERS.high) {\n    if (p.matches(node as Node<unknown, string, unknown>)) {\n      return p as NodeShapeEntry<TData, TPose>;\n    }\n  }\n  for (const p of PAINTERS.normal) {\n    if (p.matches(node as Node<unknown, string, unknown>)) {\n      return p as NodeShapeEntry<TData, TPose>;\n    }\n  }\n  return undefined;\n}\n\n/** Find the painter for `node` and ask it for the node's silhouette path,\n *  in **world** coords. Returns null if no painter matches, or the matching\n *  painter has no `silhouette` method, or the method returns null. Used by\n *  clipping, generic non-rect hit-testing and lasso/area-select — anywhere\n *  the kit needs the \"closed boundary\" of whatever this kind of node draws as.\n *\n *  Painters return their silhouette in the pose's local (unrotated) frame;\n *  this bakes `pose.rotation` on top via the shared rotation convention, so\n *  clips/area-select of a rotated node use the rotated boundary the renderer\n *  draws. (`paint()` is unaffected — it applies rotation via the render wrap,\n *  not the silhouette, so there is no double-rotation.) */\nexport function findShapeSilhouette<TData, TPose>(\n  node: Node<TData, string, TPose>,\n  pose: TPose,\n  ctx?: NodeSilhouetteCtx,\n): Path | null {\n  const build = (): Path | null => {\n    const sil = findNodeShape(node)?.silhouette?.(node, pose, ctx) ?? null;\n    const r = sil ? poseRotationOf(pose) : null;\n    return sil && r ? rotatePathAround(sil, r.cx, r.cy, r.rotation) : sil;\n  };\n  // `SILHOUETTE_SLOT`'s key is (node, pose, data) and cannot see\n  // `ctx.derivedPath` — the same reason `kit:derived` skips `PAINT_SLOT`.\n  // Memoizing here would serve one caller's silhouette to a caller that\n  // passed a different path. Only an actual path skips it: a scene-backed\n  // source answers `null` for every ordinary node, and treating that as a\n  // reason to bypass would retire the memo for the whole scene.\n  if (ctx?.derivedPath != null) return build();\n  return nodeMemo(node as { data?: unknown }, SILHOUETTE_SLOT, pose, build);\n}\n\n/** Find the painter for `node` and ask how it inks its silhouette. Returns\n *  the painter's declared {@link NodeInk}, or `null` when no painter matches\n *  or it declares none — callers substitute {@link DEFAULT_INK}. */\nexport function findShapeInk<TData, TPose>(\n  node: Node<TData, string, TPose>,\n  pose: TPose,\n  ctx?: NodeInkCtx,\n): NodeInk | null {\n  return findNodeShape(node)?.ink?.(node, pose, ctx) ?? null;\n}\n\n/** Find the painter for `node` and ask for the box its paint fits in. `null`\n *  when no painter matches, or the one that does cannot say — see\n *  {@link NodeShapeEntry.bounds}. */\nexport function findShapeBounds<TData, TPose>(\n  node: Node<TData, string, TPose>,\n  pose: TPose,\n  ctx?: NodeInkCtx,\n): Bounds | null {\n  return findNodeShape(node)?.bounds?.(node, pose, ctx) ?? null;\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. */\nfunction poseBoxBounds(pose: unknown, stroke: Stroke | null, scale: number | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, scale ?? 1) : 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\n/** Options for {@link shapeCoversPoint}. */\nexport interface ShapeCoversPointOptions {\n  /** Extra grab distance around the outline: **world** units as a number,\n   *  or screen pixels under a view scale (`{ px, scale }`), which is measured\n   *  on screen and so stays exact under non-uniform zoom.\n   *\n   *  Without slop a hairline is a mathematically zero-width target: the\n   *  stroke of a 1px outline is half a world unit wide at scale 1, which no\n   *  one can hit. Defaults to `0` so a caller that hasn't thought about the\n   *  view still gets exact geometry rather than a wrong guess. */\n  tolerance?: PickSlop;\n  /** View scale, passed to the painter's `ink` so a `{ px }` stroke width\n   *  resolves to world units. Defaults to 1. */\n  scale?: number;\n  /** The node's derived path — see {@link NodeSilhouetteCtx.derivedPath}.\n   *  Without it a derived node reports no silhouette and this answers `true`\n   *  everywhere, which degrades picking to the caller's AABB: for an edge,\n   *  a zero-sized pose. */\n  derivedPath?: Path | null;\n}\n\n/**\n * Does the shape `node` actually paints cover the world point?\n *\n * The pose rect says a node covers its whole bounding box. That is wrong for\n * everything that is not a rectangle: the concave notch of a star, the corner\n * outside an ellipse, the blank right half of a text box. This asks the\n * painter's silhouette instead, which is the same boundary used for clipping\n * and area-select, so \"what you can click\" and \"what is drawn\" answer\n * together.\n *\n * \"What is drawn\" includes the *ink*, not just the boundary. A shape whose\n * interior isn't filled — an outlined rect, a pencil stroke, a bare line — is\n * grabbable along its outline and not through its empty middle, which is the\n * opposite of what a fill test alone answers. The outline's grab width is the\n * stroke's half-width plus `tolerance`.\n *\n * A painter with no `silhouette`, or one that returns `null` for this node\n * (`kit:text` does, for a node with no non-blank lines), reports `true` —\n * \"no opinion\", leaving the caller's own AABB test as the answer. Callers\n * should keep that AABB test as a cheap pre-filter; this is the refinement,\n * not a replacement.\n *\n * Rotation is already baked by `findShapeSilhouette`, so the point is in\n * plain world coordinates.\n */\nexport function shapeCoversPoint<TData, TPose>(\n  node: Node<TData, string, TPose>,\n  pose: TPose,\n  x: number,\n  y: number,\n  opts: ShapeCoversPointOptions = {},\n): boolean {\n  const sil = findShapeSilhouette(node, pose, { derivedPath: opts.derivedPath });\n  if (sil === null) return true;\n  const ink = findShapeInk(node, pose, { scale: opts.scale }) ?? DEFAULT_INK;\n  const inside = pathContainsPoint(sil, x, y);\n  if (ink.filled && inside) return true;\n  // The stroke reaches a different distance on each side, so which side the\n  // point is on picks the reach. `tolerance` widens it to something a pointer\n  // can actually land on, and also makes a filled shape grabbable a few pixels\n  // outside its edge — which is what every editor does and what makes\n  // edge-dragging feel possible.\n  const { extra, opts: hit } = slopForStrokeHit(opts.tolerance);\n  const reach = (inside ? ink.inset : ink.outset) + extra;\n  return (reach > 0 || hasSlop(opts.tolerance)) && strokeHitTest(sil, x, y, reach, hit);\n}\n\n/** Snapshot of the current painters in evaluation order — `'high'` tier\n *  first, then `'normal'`. Useful for debugging which painter handles a\n *  given node. */\nexport function getNodeShapes(): readonly NodeShapeEntry[] {\n  return [...PAINTERS.high, ...PAINTERS.normal];\n}\n\n/** Test-only: clear the registry and re-register the built-ins. */\nexport function _resetShapePaintersForTests(): void {\n  PAINTERS.high.length = 0;\n  PAINTERS.normal.length = 0;\n  registerBuiltInShapePainters();\n  // Swapping the painter set out from under a node invalidates anything\n  // memoized against the old one. (`registerNodeShape` already bumps, but the\n  // clearing above happens without one.)\n  bumpNodeMemoGeneration();\n}\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n\n/** The `data` a `kit:text` node carries. */\ninterface TextNodeData {\n  text: string;\n  style?: TextStyle;\n  runs?: readonly StyledRun[];\n  fill?: FillStyle | null;\n  stroke?: Stroke | null;\n  verticalAlign?: TextVerticalAlign;\n}\n\n/** A `kit:text` node as the `TextPose` every text consumer reads. The stroke\n *  goes through the same resolver every other node kind's does, so one\n *  carrying no paint is dropped here rather than throwing in the renderer. */\nfunction textPoseOf(d: TextNodeData, p: RectPose): TextPose {\n  return {\n    x: p.x, y: p.y, width: p.width, height: p.height,\n    text: d.text,\n    runs: d.runs as StyledRun[] | undefined,\n    style: d.style,\n    fill: d.fill,\n    stroke: resolveNodeStroke(d.stroke) ?? undefined,\n    verticalAlign: d.verticalAlign,\n  };\n}\n\nconst TEXT_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:text',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { text?: string } | null;\n    return d?.text != null;\n  },\n  // Memoized, and not for its own sake — `resolveTextStyle` + `resolveRuns`\n  // are cheap (0.14 ms/frame at 1000 text nodes). It is the enabler: the\n  // renderer's layout cache keys on the `ResolvedRun[]` array identity, and\n  // `layoutRuns` costs 25.9 ms/frame for 200 wrapped paragraphs. Handing back\n  // a fresh runs array per frame would leave that cache missing on every\n  // draw, exactly as a fresh `Path` per frame defeated the mesh cache. Both\n  // resolvers are pure style merging — no font reads — so `(data, pose)` is\n  // the whole key. See PAINT_SLOT.\n  //\n  // `y` is the top of the first line box, not a baseline — see\n  // `TextDrawCommand.y`. Wrap, alignment and run resolution are\n  // `textCommandFromPose`'s, which `createTextLayer`, picking, the caret and\n  // the edit overlay all share.\n  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => [\n    textCommandFromPose(textPoseOf(node.data as TextNodeData, pose)),\n  ]),\n  // The pose is a layout box, not a bounding box — \"Away\" in a 300-unit box\n  // leaves most of it empty, and a pose-rect silhouette claims all of it. The\n  // union of the line boxes is what the node actually covers, so picking,\n  // lasso and clipping stop grabbing blank space.\n  //\n  // `null` rather than an empty path when there are no non-blank lines: an\n  // empty text node would otherwise become unpickable, and a caller reading\n  // \"no silhouette\" falls back to the pose rect, which is the behavior an\n  // empty box wants.\n  silhouette: (node, pose) => {\n    const boxes = textLineBoxes(textPoseOf(node.data as TextNodeData, pose));\n    if (boxes.length === 0) return null;\n    return rectsToPath(boxes);\n  },\n  // `filled` is unconditional, `data.fill: null` included: the silhouette\n  // above is line boxes, not glyph ink, so reporting outline-only text as\n  // unfilled would leave it grabbable within a stroke width of a box edge and\n  // nowhere near the letters. The reach still matters — a heavily outlined\n  // glyph was unpickable across the width of its own outline.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { stroke?: Stroke | null };\n    return { filled: true, ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale) };\n  },\n};\n\n/**\n * Union of axis-aligned rects as one multi-contour `PolygonPath`.\n *\n * Every contour winds the same way, so `'nonzero'` reads overlapping rects as\n * covered rather than punching a hole where two lines happen to overlap —\n * which they do the moment `lineHeight` drops below 1.\n */\nfunction rectsToPath(rects: readonly { x: number; y: number; width: number; height: number }[]): PolygonPath {\n  const commands = new Uint8Array(rects.length * 6);\n  const coords = new Float32Array(rects.length * 10);\n  let ci = 0;\n  let cmd = 0;\n  for (const r of rects) {\n    const { x, y, width: w, height: h } = r;\n    commands[cmd++] = PATH_M; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_Z;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n\n/**\n * What a node's `data.fill` means to the built-in painters.\n *\n * A {@link FillStyle} 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\"; `undefined` takes the painter's fallback.\n * Write one with {@link solid} rather than by hand when all you have is a\n * color.\n */\nfunction resolveNodeFill(\n  fill: FillStyle | null | undefined,\n  fallback: FillStyle | null,\n): FillStyle | null {\n  return fill === undefined ? fallback : fill;\n}\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. `Stroke.paint` is\n *  required by the type, so this is unreachable from well-formed data — but a\n *  document is data, and a stroke assembled a field at a time (a width\n *  written onto a node that had none) arrives here without one. Painting it\n *  threw out of `fillInPoseFrame`, and the throw escapes the painter and\n *  takes the whole frame with it: the page and every other node vanish, and\n *  the canvas stays stale until something unrelated requests a redraw. One\n *  malformed node must not be able to blank the document. */\nfunction 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. */\ntype PaintedStroke = Stroke & { paint: FillStyle };\n\n/** Bake a bounds-relative stroke paint onto the given box, the way a fill is\n *  baked. The box is the frame the path was projected into, so a paint left in\n *  `'bounds'` units would reach the renderer describing a frame that never\n *  exists. `null` when a pattern spec fails to resolve. */\nfunction strokeInPoseFrame(stroke: PaintedStroke, box: FillPoseBox): Stroke | null {\n  const paint = resolveFillPattern(fillInPoseFrame(stroke.paint, box));\n  if (paint === null) return null;\n  return paint === stroke.paint ? stroke : { ...stroke, paint };\n}\n\n/** Per-side grab reach for a resolved stroke, in world units. */\nfunction inkReach(\n  stroke: Stroke | null,\n  scale: number | undefined,\n): { outset: number; inset: number } {\n  if (stroke === null) return { outset: 0, inset: 0 };\n  const w = resolveStrokeWidth(stroke.width ?? 1, scale ?? 1);\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 reach = markerReach(stroke, w, scale);\n  switch (stroke.align ?? 'center') {\n    case 'inner':\n      return { outset: reach, inset: w };\n    case 'outer':\n      return { outset: w + reach, inset: 0 };\n    default:\n      return { outset: w / 2 + reach, inset: w / 2 };\n  }\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. */\nfunction 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\nconst 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) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as {\n      path: Path;\n      fill?: FillStyle | null;\n      stroke?: Stroke | null;\n      vertexColors?: number[];\n    };\n    const projected = pathInPoseFrame(d.path, pose);\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const hasStroke = strokeSpec !== null;\n    // An undeclared fill falls back to the default one only if there's no\n    // stroke — otherwise the path is stroke-only (e.g. pencil) and a default\n    // fill would be wrong.\n    const declared = resolveNodeFill(d.fill, hasStroke ? null : DEFAULT_SHAPE_FILL);\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 && resolveFillPattern(fillInPoseFrame(declared, pose));\n    const stroke = strokeSpec && strokeInPoseFrame(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) => {\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  // Mirrors the fill/stroke decisions `paint` makes above — same reads, same\n  // 'none' handling, same \"no fill declared and a stroke present means\n  // stroke-only\" fallback. Kept in step with `paint` by\n  // `NodeShape.ink.test.ts`, which asserts the two agree.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as {\n      fill?: FillStyle | null;\n      stroke?: Stroke | null;\n    };\n    const stroke = resolveNodeStroke(d.stroke);\n    const hasStroke = stroke !== null;\n    return {\n      filled: resolveNodeFill(d.fill, hasStroke ? null : DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(stroke, ctx?.scale),\n    };\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?.scale),\n};\n\n/** Built-in shape dispatcher — matches when `data.shape` names a kit-known\n *  shape kind. Computes both paint and silhouette from the pose so consumer\n *  scenes can declare clipping/rendering directly in JSON without\n *  registering a custom painter. */\nconst SHAPE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:shape',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const s = (node.data as { shape?: string } | null)?.shape;\n    return s != null && SHAPE_KINDS.has(s);\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathForShape` builds a\n  // fresh `Uint8Array` + `Float32Array` for every ellipse, polygon and star.\n  // See PAINT_SLOT.\n  paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as { shape: string; fill?: FillStyle | null; stroke?: Stroke | null; sides?: number; points?: number };\n    const path = pathForShape(d, pose);\n    const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);\n    const shapeFill = declaredFill && resolveFillPattern(fillInPoseFrame(declaredFill, pose));\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const stroke = strokeSpec && strokeInPoseFrame(strokeSpec, pose);\n    return [{\n      kind: 'path',\n      path,\n      ...(shapeFill ? { fill: shapeFill } : {}),\n      ...(stroke ? { stroke } : {}),\n    }];\n  }), ctx),\n  silhouette: (node, pose) => {\n    const d = node.data as { shape: string; sides?: number; points?: number };\n    return pathForShape(d, pose);\n  },\n  // `paint` above emits the default fill when none is declared, so a shape\n  // is filled unless it declares `fill: null` — unlike `kit:path`, it has no\n  // implicit stroke-only form.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: FillStyle | null; stroke?: Stroke | null };\n    return {\n      filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale),\n    };\n  },\n  // Every shape kind is inscribed in the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx?.scale),\n};\n\nconst SHAPE_KINDS = new Set(['rect', 'ellipse', 'polygon', 'star']);\n\nfunction pathForShape(\n  d: { shape: string; sides?: number; points?: number },\n  p: RectPose,\n): Path {\n  switch (d.shape) {\n    case 'ellipse':\n      return ellipsePath(p);\n    case 'polygon': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return regularPolygonPath({ x: cx, y: cy }, r, d.sides ?? 6);\n    }\n    case 'star': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return starPath({ x: cx, y: cy }, r, d.points ?? 5);\n    }\n    case 'rect':\n    default:\n      return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  }\n}\n\nfunction sourceInPixels(\n  s: NonNullable<ImageNodeData['image']['source']>,\n  bmp: ImageBitmap,\n): { x: number; y: number; w: number; h: number } {\n  return {\n    x: s.x * bmp.width, y: s.y * bmp.height, w: s.width * bmp.width, h: s.height * bmp.height,\n  };\n}\n\n/** The whole bitmap's size in device pixels when `source` of it fills `pose`. */\nfunction drawnSize(\n  pose: RectPose,\n  source: ImageNodeData['image']['source'],\n  pixelScale: number | undefined,\n): ImageRasterSize | undefined {\n  if (!(pixelScale && pixelScale > 0)) return undefined;\n  return {\n    width: Math.abs(pose.width) * pixelScale / (source?.width || 1),\n    height: Math.abs(pose.height) * pixelScale / (source?.height || 1),\n  };\n}\n\n/** Raster-image painter. Renders `data.image.src` (URL / blob: / data-URI)\n *  via an `ImageDrawCommand` once the bitmap has decoded; until then it paints\n *  a faint placeholder outline so the node stays visible + selectable (a\n *  reddish outline + slash marks a failed load). The decoded bitmap is owned\n *  by `imageCache`, keyed on `src`; the node holds only the serializable `src`.\n *  Registered before `kit:rect-fallback` so image nodes don't fall through. */\nconst IMAGE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:image',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const src = (node.data as { image?: { src?: unknown } } | null)?.image?.src;\n    return typeof src === 'string' && src.length > 0;\n  },\n  paint: (node, pose, ctx) => {\n    const d = node.data as ImageNodeData;\n    const p = pose;\n    const bmp = ctx?.resolveImage\n      ? ctx.resolveImage(node as unknown as Node<unknown, string, unknown>)\n      : getImageBitmap(d.image.src, drawnSize(p, d.image.source, ctx?.pixelScale));\n    if (bmp) {\n      return [{\n        kind: 'image',\n        image: bmp,\n        x: p.x, y: p.y, w: p.width, h: p.height,\n        ...(d.image.opacity !== undefined ? { opacity: d.image.opacity } : {}),\n        ...(d.image.source ? { source: sourceInPixels(d.image.source, bmp) } : {}),\n        ...(d.image.flipX ? { flipX: true } : {}),\n        ...(d.image.flipY ? { flipY: true } : {}),\n      }];\n    }\n    // Not ready — faint placeholder (grey while loading, reddish + slash on\n    // error). With a caller-supplied resolver the fallback is deterministic:\n    // always the plain grey outline, no ambient load-status read.\n    const error = ctx?.resolveImage ? false : imageStatus(d.image.src) === 'error';\n    const color = error ? '#d08a8a' : '#bbbbbb';\n    const cmds: DrawCommand[] = [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      stroke: { paint: { color }, width: 1 },\n    }];\n    if (error) {\n      cmds.push({\n        kind: 'path',\n        path: linePath({ x: p.x, y: p.y }, { x: p.x + p.width, y: p.y + p.height }),\n        stroke: { paint: { color }, width: 1 },\n      });\n    }\n    return cmds;\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  // The placeholder's 1-unit outline is the only thing that leaves the box.\n  bounds: (_node, pose, ctx) => poseBoxBounds(pose, IMAGE_PLACEHOLDER_STROKE, ctx?.scale),\n};\n\nconst IMAGE_PLACEHOLDER_STROKE: Stroke = { paint: { color: '#000' }, width: 1 };\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 */\nconst 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: (node) => (node.dependsOn?.length ?? 0) > 0 && node.derivePath !== undefined,\n  paint: (node, _pose, ctx) => {\n    const path = ctx?.derivedPath;\n    if (path == null) return [];\n    const box = boundsOfPath(path);\n    const d = node.data as { fill?: FillStyle | null; stroke?: Stroke | null; vertexColors?: number[] } | null;\n    const strokeSpec = resolveNodeStroke(d?.stroke);\n    const declared = resolveNodeFill(d?.fill, strokeSpec === null ? DEFAULT_SHAPE_FILL : null);\n    const fill = declared && resolveFillPattern(fillInPoseFrame(declared, box));\n    const stroke = strokeSpec && strokeInPoseFrame(strokeSpec, box);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path,\n      ...(fill ? { fill } : {}),\n      ...(fill && d?.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return withAnimatedVertexColors([cmd], 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?: FillStyle | 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\nconst 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?: FillStyle | null } | null;\n    const p = pose;\n    const fill = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);\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\nfunction registerBuiltInShapePainters(): void {\n  registerNodeShape(TEXT_PAINTER);\n  // Ahead of path/shape/image: a derived node whose `data` also carries a\n  // `path`, `shape` or `image` means the derived path, and those three match\n  // on the presence of the field alone.\n  registerNodeShape(DERIVED_PAINTER);\n  registerNodeShape(PATH_PAINTER);\n  registerNodeShape(SHAPE_PAINTER);\n  registerNodeShape(IMAGE_PAINTER);\n  registerNodeShape(RECT_FALLBACK_PAINTER);\n}\n\nregisterBuiltInShapePainters();\n"],"mappings":"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"}

package/dist/canvas/PickHud.js

@@ -0,0 +1,93 @@
+import e from "./hud.module.js";
+import { useHostAnchor as t } from "./useHostAnchor.js";
+import { useEffect as n, useState as r } from "react";
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+//#region src/canvas/PickHud.tsx
+function o({ canvasRef: o, anchorRef: s, viewRef: c, pickEvery: l, pickBest: u, offset: d }) {
+	let [f, p] = r({
+		ids: [],
+		best: null,
+		inCanvas: !1
+	}), { ref: m, style: h } = t(() => s?.current ?? o.current?.parentElement ?? o.current, {
+		align: {
+			x: "end",
+			y: "start"
+		},
+		offset: {
+			x: d?.right ?? 8,
+			y: d?.top ?? 76
+		}
+	});
+	return n(() => {
+		let e = (e) => {
+			let t = o.current, n = c.current;
+			if (!t || !n) {
+				p({
+					ids: [],
+					best: null,
+					inCanvas: !1
+				});
+				return;
+			}
+			let r = t.getBoundingClientRect();
+			if (!(e.clientX >= r.left && e.clientX <= r.right && e.clientY >= r.top && e.clientY <= r.bottom)) {
+				p({
+					ids: [],
+					best: null,
+					inCanvas: !1
+				});
+				return;
+			}
+			let i = (e.clientX - r.left) / n.scale.x + n.x, a = (e.clientY - r.top) / n.scale.y + n.y, s = [];
+			try {
+				s = l(i, a);
+			} catch {
+				s = [];
+			}
+			let d = null;
+			if (u) try {
+				d = u(i, a);
+			} catch {
+				d = null;
+			}
+			p({
+				ids: s,
+				best: d,
+				inCanvas: !0
+			});
+		};
+		return document.addEventListener("pointermove", e), () => {
+			document.removeEventListener("pointermove", e);
+		};
+	}, [
+		o,
+		c,
+		l,
+		u
+	]), h ? /* @__PURE__ */ a("div", {
+		ref: m,
+		className: `${e.hud} ${e.sized}`,
+		style: h,
+		children: [/* @__PURE__ */ a("div", {
+			className: `${e.header} ${e.muted}`,
+			children: [
+				"pickEvery (",
+				f.ids.length,
+				")"
+			]
+		}), f.ids.length === 0 ? /* @__PURE__ */ i("div", {
+			className: e.absent,
+			children: f.inCanvas ? "—" : "off-canvas"
+		}) : /* @__PURE__ */ i("ul", {
+			className: e.list,
+			children: f.ids.slice().reverse().map((t) => /* @__PURE__ */ i("li", {
+				className: t === f.best ? `${e.item} ${e.itemBest}` : e.item,
+				children: t
+			}, t))
+		})]
+	}) : null;
+}
+//#endregion
+export { o as PickHud };
+
+//# sourceMappingURL=PickHud.js.map

package/dist/canvas/PickHud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PickHud.js","names":["s","hud_module_default","PickHud","state","setState","useState","useHostAnchor","anchorRef","canvasRef","offset","useEffect","onMove","canvas","view","viewRef","rect","worldX","worldY","ids","pickEvery","best","pickBest","style","id"],"sources":["../../src/canvas/PickHud.tsx"],"sourcesContent":["/**\n * Dev HUD listing the ids returned by `pickEvery(world)` under the cursor.\n *\n * Anchors to the canvas's top-right corner like `CursorCoordsHud`, offset\n * downward so it sits just below that HUD. Updates on `document`\n * pointermove. Refreshes its position on scroll / resize so it tracks the\n * canvas through layout changes.\n */\nimport { useEffect, useState } from 'react';\nimport type { View } from 'core/viewport/view';\nimport { useHostAnchor } from './useHostAnchor';\nimport s from './hud.module.css';\n\n/** Props for `<PickHud>`. */\nexport interface PickHudProps {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Element the HUD pins its corner to. Defaults to the canvas's parent — the\n   *  wrapper a bare `<canvas>` sits in. A detached canvas passes its own input\n   *  box, whose parent is the shared surface every pane sits in. */\n  anchorRef?: React.RefObject<HTMLElement | null>;\n  viewRef: React.RefObject<View>;\n  /** World-space hit-test. Same shape as `useSelectTool`'s `pickEvery`. */\n  pickEvery: (worldX: number, worldY: number) => readonly string[];\n  /** Optional single-best resolver — the id this point would select on a\n   *  bare click. When supplied, that id is rendered bold in the list. */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n  /** Inset from the canvas's top-right corner. Default `{ top: 76, right: 8 }`\n   *  so the HUD clears `CursorCoordsHud` (~64 px tall in its 3-line form). */\n  offset?: { top?: number; right?: number };\n}\n\ninterface HudState {\n  ids: readonly string[];\n  best: string | null;\n  inCanvas: boolean;\n}\n\n/** Debug overlay listing every node under the pointer, with the one a click\n *  would actually select shown in bold. */\nexport function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }: PickHudProps) {\n  const [state, setState] = useState<HudState>({\n    ids: [], best: null, inCanvas: false,\n  });\n  const { ref, style } = useHostAnchor(\n    () => anchorRef?.current ?? canvasRef.current?.parentElement ?? canvasRef.current,\n    {\n      align: { x: 'end', y: 'start' },\n      offset: { x: offset?.right ?? 8, y: offset?.top ?? 76 },\n    },\n  );\n\n  useEffect(() => {\n    const onMove = (e: PointerEvent) => {\n      const canvas = canvasRef.current;\n      const view = viewRef.current;\n      if (!canvas || !view) {\n        setState({ ids: [], best: null, inCanvas: false });\n        return;\n      }\n      const rect = canvas.getBoundingClientRect();\n      const inCanvas =\n        e.clientX >= rect.left && e.clientX <= rect.right &&\n        e.clientY >= rect.top  && e.clientY <= rect.bottom;\n      if (!inCanvas) {\n        setState({ ids: [], best: null, inCanvas: false });\n        return;\n      }\n      const worldX = (e.clientX - rect.left) / view.scale.x + view.x;\n      const worldY = (e.clientY - rect.top)  / view.scale.y + view.y;\n      let ids: readonly string[] = [];\n      try {\n        ids = pickEvery(worldX, worldY);\n      } catch {\n        ids = [];\n      }\n      let best: string | null = null;\n      if (pickBest) {\n        try { best = pickBest(worldX, worldY); } catch { best = null; }\n      }\n      setState({ ids, best, inCanvas: true });\n    };\n\n    document.addEventListener('pointermove', onMove);\n\n    return () => {\n      document.removeEventListener('pointermove', onMove);\n    };\n  }, [canvasRef, viewRef, pickEvery, pickBest]);\n\n  if (!style) return null;\n\n  return (\n    <div ref={ref} className={`${s.hud} ${s.sized}`} style={style}>\n      <div className={`${s.header} ${s.muted}`}>pickEvery ({state.ids.length})</div>\n      {state.ids.length === 0 ? (\n        <div className={s.absent}>{state.inCanvas ? '—' : 'off-canvas'}</div>\n      ) : (\n        <ul className={s.list}>\n          {/* pickEvery returns back-to-front (topmost last). Display top-first. */}\n          {state.ids.slice().reverse().map((id) => (\n            <li\n              key={id}\n              className={id === state.best ? `${s.item} ${s.itemBest}` : s.item}\n            >\n              {id}\n            </li>\n          ))}\n        </ul>\n      )}\n    </div>\n  );\n}\n"],"mappings":";;;;;AAuCA,SAAgBE,EAAQ,EAAE,cAAW,cAAW,YAAS,cAAW,aAAU,aAAwB;CACpG,IAAM,CAACC,GAAOC,KAAYC,EAAmB;EAC3C,KAAK,CAAC;EAAG,MAAM;EAAM,UAAU;CACjC,CAAC,GACK,EAAE,QAAK,aAAUC,QACfC,GAAW,WAAWC,EAAU,SAAS,iBAAiBA,EAAU,SAC1E;EACE,OAAO;GAAE,GAAG;GAAO,GAAG;EAAQ;EAC9B,QAAQ;GAAE,GAAGC,GAAQ,SAAS;GAAG,GAAGA,GAAQ,OAAO;EAAG;CACxD,CACF;CA0CA,OAxCAC,QAAgB;EACd,IAAMC,KAAU,MAAoB;GAClC,IAAMC,IAASJ,EAAU,SACnBK,IAAOC,EAAQ;GACrB,IAAI,CAACF,KAAU,CAACC,GAAM;IACpB,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAME,IAAOH,EAAO,sBAAsB;GAI1C,IAAI,EAFF,EAAE,WAAWG,EAAK,QAAQ,EAAE,WAAWA,EAAK,SAC5C,EAAE,WAAWA,EAAK,OAAQ,EAAE,WAAWA,EAAK,SAC/B;IACb,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAMC,KAAU,EAAE,UAAUD,EAAK,QAAQF,EAAK,MAAM,IAAIA,EAAK,GACvDI,KAAU,EAAE,UAAUF,EAAK,OAAQF,EAAK,MAAM,IAAIA,EAAK,GACzDK,IAAyB,CAAC;GAC9B,IAAI;IACF,IAAMC,EAAUH,GAAQC,CAAM;GAChC,QAAQ;IACN,IAAM,CAAC;GACT;GACA,IAAIG,IAAsB;GAC1B,IAAIC,GACF,IAAI;IAAE,IAAOA,EAASL,GAAQC,CAAM;GAAG,QAAQ;IAAE,IAAO;GAAM;GAEhE,EAAS;IAAE;IAAK;IAAM,UAAU;GAAK,CAAC;EACxC;EAIA,OAFA,SAAS,iBAAiB,eAAeN,CAAM,SAElC;GACX,SAAS,oBAAoB,eAAeA,CAAM;EACpD;CACF,GAAG;EAACH;EAAWM;EAASK;EAAWE;CAAQ,CAAC,GAEvCC,IAGH,kBAAC,OAAD;EAAU;EAAK,WAAW,GAAGtB,EAAE,IAAI,GAAGA,EAAE;EAAgB;EAAxD,UAAA,CACE,kBAAC,OAAD;GAAK,WAAW,GAAGA,EAAE,OAAO,GAAGA,EAAE;GAAjC,UAAA;IAA0C;IAAYG,EAAM,IAAI;IAAO;GAAM;EAC5E,CAAA,GAAAA,EAAM,IAAI,WAAW,IACpB,kBAAC,OAAD;GAAK,WAAWH,EAAE;GAAS,UAAAG,EAAM,WAAW,MAAM;EAAkB,CAAA,IAEpE,kBAAC,MAAD;GAAI,WAAWH,EAAE;GAEd,UAAAG,EAAM,IAAI,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,MAChC,kBAAC,MAAD;IAEE,WAAWoB,MAAOpB,EAAM,OAAO,GAAGH,EAAE,KAAK,GAAGA,EAAE,aAAaA,EAAE;IAE5D,UAAAuB;GACC,GAJGA,CAIH,CACL;EACC,CAAA,CAEH;MApBY;AAsBrB"}

package/dist/canvas/SceneCanvas/ActionsProviderIfRoot.js

@@ -0,0 +1,10 @@
+import { ActionsProvider as e, useActionsRegistry as t } from "@weasel-js/routing/react";
+import { Fragment as n, jsx as r } from "react/jsx-runtime";
+//#region src/canvas/SceneCanvas/ActionsProviderIfRoot.tsx
+function i({ children: i }) {
+	return t() ? /* @__PURE__ */ r(n, { children: i }) : /* @__PURE__ */ r(e, { children: i });
+}
+//#endregion
+export { i as ActionsProviderIfRoot };
+
+//# sourceMappingURL=ActionsProviderIfRoot.js.map

package/dist/canvas/SceneCanvas/ActionsProviderIfRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionsProviderIfRoot.js","names":["_Fragment","ActionsProviderIfRoot","useActionsRegistry","Fragment","ActionsProvider"],"sources":["../../../src/canvas/SceneCanvas/ActionsProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<ActionsProvider>` wrapper: mounts one only when no registry is\n * in scope, and otherwise renders its children against the one there. Used by\n * a non-isolated `<WeaselProvider>`.\n */\nimport type { ReactNode } from 'react';\nimport { ActionsProvider, useActionsRegistry } from '@weasel-js/routing/react';\n\n/** Mount an `<ActionsProvider>` only when none is already in scope. */\nexport function ActionsProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = useActionsRegistry();\n  if (parent) return <>{children}</>;\n  return <ActionsProvider>{children}</ActionsProvider>;\n}\n"],"mappings":";;;AASA,SAAgBC,EAAsB,EAAE,eAAqC;CAG3E,OAFeC,EACX,IAAe,kBAAAF,GAAA,EAAG,YAAW,CAAA,IAC1B,kBAACI,GAAD,EAAkB,YAA0B,CAAA;AACrD"}

package/dist/canvas/SceneCanvas/DepRegistryProviderIfRoot.js

@@ -0,0 +1,10 @@
+import { DepRegistryProvider as e, useOptionalDepRegistry as t } from "@weasel-js/routing/react";
+import { Fragment as n, jsx as r } from "react/jsx-runtime";
+//#region src/canvas/SceneCanvas/DepRegistryProviderIfRoot.tsx
+function i({ children: i }) {
+	return t() ? /* @__PURE__ */ r(n, { children: i }) : /* @__PURE__ */ r(e, { children: i });
+}
+//#endregion
+export { i as DepRegistryProviderIfRoot };
+
+//# sourceMappingURL=DepRegistryProviderIfRoot.js.map