@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/NodeShape.js

@@ -1,81 +1,158 @@
-import { bumpNodeMemoGeneration as e, nodeMemo as t } from "../core/scene/nodeMemo.js";
-import { hasSlop as n, slopForStrokeHit as r, widenSlop as i } from "../core/viewport/screenSlop.js";
-import { derivesPath as a } from "./nodeShapes/memo.js";
-import { DERIVED_PAINTER as o } from "./nodeShapes/derivedPainter.js";
-import { paintsPose as s } from "./nodeShapes/poseBox.js";
-import { IMAGE_PAINTER as c } from "./nodeShapes/imagePainter.js";
-import { PATH_PAINTER as l } from "./nodeShapes/pathPainter.js";
-import { RECT_FALLBACK_PAINTER as u } from "./nodeShapes/rectFallbackPainter.js";
-import { SHAPE_PAINTER as d } from "./nodeShapes/shapePainter.js";
-import { TEXT_PAINTER as f } from "./nodeShapes/textPainter.js";
-import { pathContainsPoint as p, pathThroughPoseFrame as m, strokeHitTest as h } from "@weasel-js/geom";
-import { glyphGeneration as g } from "@weasel-js/font";
+import { bumpNodeMemoGeneration, nodeMemo } from "../core/scene/nodeMemo.js";
+import { hasSlop, slopForStrokeHit, widenSlop } from "../core/viewport/screenSlop.js";
+import { derivesPath } from "./nodeShapes/memo.js";
+import { DERIVED_PAINTER } from "./nodeShapes/derivedPainter.js";
+import { paintsPose } from "./nodeShapes/poseBox.js";
+import { IMAGE_PAINTER } from "./nodeShapes/imagePainter.js";
+import { MEASURE_PAINTER } from "./nodeShapes/measurePainter.js";
+import { PATH_PAINTER } from "./nodeShapes/pathPainter.js";
+import { RECT_FALLBACK_PAINTER } from "./nodeShapes/rectFallbackPainter.js";
+import { SHAPE_PAINTER } from "./nodeShapes/shapePainter.js";
+import { TEXT_PAINTER } from "./nodeShapes/textPainter.js";
+import { pathContainsPoint, pathThroughPoseFrame, strokeHitTest } from "@weasel-js/geom";
+import { glyphGeneration } from "@weasel-js/font";
+
 //#region src/canvas/NodeShape.ts
-var _ = Object.freeze({
-	filled: !0,
+/**
+* NodeShape — the **shape trait's** registry: the per-kind `paint` + `silhouette` used by
+* `defaultDrawOne`, clipping, non-rect hit-testing, and lasso/area-select. Teaching the kit
+* about a new kind of shape goes through this registry rather than by overriding `drawOne`.
+*
+* The first entry whose `matches` predicate returns true paints the node: `'high'` entries
+* first, then the built-ins, then `'normal'` ones, in registration order within a tier. Every
+* built-in but `kit:derived` additionally requires a rect-shaped pose — a scene whose poses are
+* some other shape matches none of them, and paints through a consumer painter or not at all.
+*/
+/** What a painter that declares no `ink` is assumed to do. */
+var DEFAULT_INK = Object.freeze({
+	filled: true,
 	outset: 0,
 	inset: 0
-}), v = {
+});
+var PAINTERS = {
 	high: [],
 	normal: []
-}, y = !1;
-function b() {
-	y || (y = !0, F());
+};
+var builtInsRegistered = false;
+function ensureBuiltIns() {
+	if (builtInsRegistered) return;
+	builtInsRegistered = true;
+	registerBuiltInShapePainters();
 }
-function x(t, n = {}) {
-	b();
-	let r = n.priority === "high" ? v.high : v.normal;
-	return r.push(t), e(), () => {
-		let n = r.indexOf(t);
-		n >= 0 && r.splice(n, 1), e();
+/** Register a shape painter. Returns a disposer that removes it. */
+function registerNodeShape(painter, opts = {}) {
+	ensureBuiltIns();
+	const list = opts.priority === "high" ? PAINTERS.high : PAINTERS.normal;
+	list.push(painter);
+	bumpNodeMemoGeneration();
+	return () => {
+		const i = list.indexOf(painter);
+		if (i >= 0) list.splice(i, 1);
+		bumpNodeMemoGeneration();
 	};
 }
-var S = "shape:painter", C = "shape:painter:nonrect", w = "shape:painter:derived", T = "shape:painter:derived:nonrect", E = "shape:silhouette", D = "shape:silhouette:text";
-function O(e) {
-	let n = s(e.pose), r = a(e) ? n ? w : T : n ? S : C;
-	return t(e, r, void 0, () => k(e));
+/**
+* Slot names for what picking asks per node per pointer move: which painter matches, and that
+* painter's silhouette path. Both go through {@link nodeMemo}, so they invalidate on `data`
+* (and, for the silhouette, `pose`) reference changes and on a painter registration.
+*
+* Separate slots rather than one entry: they mostly invalidate together, but not always, and a
+* shared entry would force the stricter key on both.
+*/
+var PAINTER_SLOT = "shape:painter";
+var PAINTER_SLOT_NONRECT = "shape:painter:nonrect";
+var PAINTER_SLOT_DERIVED = "shape:painter:derived";
+var PAINTER_SLOT_DERIVED_NONRECT = "shape:painter:derived:nonrect";
+var SILHOUETTE_SLOT = "shape:silhouette";
+var TEXT_SILHOUETTE_SLOT = "shape:silhouette:text";
+/** The painter that will render `node` — first match in priority order — or undefined if
+*  none accepts it. */
+function findNodeShape(node) {
+	const rect = paintsPose(node.pose);
+	const slot = derivesPath(node) ? rect ? PAINTER_SLOT_DERIVED : PAINTER_SLOT_DERIVED_NONRECT : rect ? PAINTER_SLOT : PAINTER_SLOT_NONRECT;
+	return nodeMemo(node, slot, void 0, () => matchNodeShape(node));
 }
-function k(e) {
-	b();
-	for (let t of v.high) if (t.matches(e)) return t;
-	for (let t of v.normal) if (t.matches(e)) return t;
+function matchNodeShape(node) {
+	ensureBuiltIns();
+	for (const p of PAINTERS.high) if (p.matches(node)) return p;
+	for (const p of PAINTERS.normal) if (p.matches(node)) return p;
 }
-function A(e, n, r) {
-	let i = () => {
-		let t = O(e)?.silhouette?.(e, n, r) ?? null;
-		return t && m(t, n);
+/** The silhouette path of `node`, in **world** coords, or null if no painter matches or the
+*  matching painter has none.
+*
+*  Painters return their silhouette in the pose's local (unrotated) frame;
+*  this bakes the pose's frame (`poseFrameOf`: its rotation and `transform`)
+*  on top, so clips/area-select of a turned or skewed node use the boundary
+*  the renderer draws. */
+function findShapeSilhouette(node, pose, ctx) {
+	const build = () => {
+		const sil = findNodeShape(node)?.silhouette?.(node, pose, ctx) ?? null;
+		return sil && pathThroughPoseFrame(sil, pose);
 	};
-	if (r?.derivedPath != null) return i();
-	if (O(e) === f) {
-		let r = g(), a = t(e, D, n, () => ({
-			epoch: r,
-			path: i()
+	if (ctx?.derivedPath != null) return build();
+	if (findNodeShape(node) === TEXT_PAINTER) {
+		const epoch = glyphGeneration();
+		const held = nodeMemo(node, TEXT_SILHOUETTE_SLOT, pose, () => ({
+			epoch,
+			path: build()
 		}));
-		return a.epoch !== r && (a.epoch = r, a.path = i()), a.path;
+		if (held.epoch !== epoch) {
+			held.epoch = epoch;
+			held.path = build();
+		}
+		return held.path;
 	}
-	return t(e, E, n, i);
+	return nodeMemo(node, SILHOUETTE_SLOT, pose, build);
 }
-function j(e, t, n) {
-	return O(e)?.ink?.(e, t, n) ?? null;
+/** Find the painter for `node` and ask how it inks its silhouette. Returns
+*  the painter's declared {@link NodeInk}, or `null` when no painter matches
+*  or it declares none — callers substitute {@link DEFAULT_INK}. */
+function findShapeInk(node, pose, ctx) {
+	return findNodeShape(node)?.ink?.(node, pose, ctx) ?? null;
 }
-function M(e, t, n) {
-	return O(e)?.bounds?.(e, t, n) ?? null;
+/** Find the painter for `node` and ask for the box its paint fits in. `null`
+*  when no painter matches, or the one that does cannot say — see
+*  {@link NodeShapeEntry.bounds}. */
+function findShapeBounds(node, pose, ctx) {
+	return findNodeShape(node)?.bounds?.(node, pose, ctx) ?? null;
 }
-function N(e, t, a, o, s = {}) {
-	let c = A(e, t, { derivedPath: s.derivedPath });
-	if (c === null) return !0;
-	let l = j(e, t, { scale: s.scale }) ?? _, u = p(c, a, o);
-	if (l.filled && u) return !0;
-	let d = i(s.tolerance, (u ? l.insetPx : l.outsetPx) ?? 0, s.scale), { extra: f, opts: m } = r(d), g = (u ? l.inset : l.outset) + f;
-	return (g > 0 || n(d)) && h(c, a, o, g, m);
+/**
+* Does the shape `node` actually paints cover the world point? Asks the painter's silhouette,
+* the same boundary used for clipping and area-select, rather than the pose rect.
+*
+* The ink counts too: a shape whose interior isn't filled is grabbable along its outline and
+* not through its empty middle. The outline's grab width is the stroke's half-width plus
+* `tolerance`.
+*
+* A painter with no `silhouette`, or one that returns `null` for this node, reports `true` —
+* "no opinion" — so callers should keep their own AABB test as a pre-filter.
+*/
+function shapeCoversPoint(node, pose, x, y, opts = {}) {
+	const sil = findShapeSilhouette(node, pose, { derivedPath: opts.derivedPath });
+	if (sil === null) return true;
+	const ink = findShapeInk(node, pose, { scale: opts.scale }) ?? DEFAULT_INK;
+	const inside = pathContainsPoint(sil, x, y);
+	if (ink.filled && inside) return true;
+	const slop = widenSlop(opts.tolerance, (inside ? ink.insetPx : ink.outsetPx) ?? 0, opts.scale);
+	const { extra, opts: hit } = slopForStrokeHit(slop);
+	const reach = (inside ? ink.inset : ink.outset) + extra;
+	return (reach > 0 || hasSlop(slop)) && strokeHitTest(sil, x, y, reach, hit);
 }
-function P() {
-	return b(), [...v.high, ...v.normal];
+/** The current painters in evaluation order — `'high'` tier first, then `'normal'`. */
+function getNodeShapes() {
+	ensureBuiltIns();
+	return [...PAINTERS.high, ...PAINTERS.normal];
 }
-function F() {
-	x(f), x(o), x(l), x(d), x(c), x(u);
+function registerBuiltInShapePainters() {
+	registerNodeShape(TEXT_PAINTER);
+	registerNodeShape(MEASURE_PAINTER);
+	registerNodeShape(DERIVED_PAINTER);
+	registerNodeShape(PATH_PAINTER);
+	registerNodeShape(SHAPE_PAINTER);
+	registerNodeShape(IMAGE_PAINTER);
+	registerNodeShape(RECT_FALLBACK_PAINTER);
 }
-//#endregion
-export { _ as DEFAULT_INK, O as findNodeShape, M as findShapeBounds, j as findShapeInk, A as findShapeSilhouette, P as getNodeShapes, x as registerNodeShape, N as shapeCoversPoint };
 
+//#endregion
+export { DEFAULT_INK, findNodeShape, findShapeBounds, findShapeInk, findShapeSilhouette, getNodeShapes, registerNodeShape, shapeCoversPoint };
 //# sourceMappingURL=NodeShape.js.map

package/dist/canvas/NodeShape.js.map

@@ -1 +1 @@
-{"version":3,"file":"NodeShape.js","names":["DEFAULT_INK","PAINTERS","builtInsRegistered","ensureBuiltIns","registerBuiltInShapePainters","registerNodeShape","list","opts","painter","bumpNodeMemoGeneration","i","PAINTER_SLOT","PAINTER_SLOT_NONRECT","PAINTER_SLOT_DERIVED","PAINTER_SLOT_DERIVED_NONRECT","SILHOUETTE_SLOT","TEXT_SILHOUETTE_SLOT","findNodeShape","rect","paintsPose","node","slot","derivesPath","nodeMemo","matchNodeShape","p","findShapeSilhouette","build","sil","pose","ctx","pathThroughPoseFrame","TEXT_PAINTER","epoch","glyphGeneration","held","findShapeInk","findShapeBounds","shapeCoversPoint","ink","inside","pathContainsPoint","x","y","slop","widenSlop","hit","slopForStrokeHit","reach","extra","hasSlop","strokeHitTest","getNodeShapes","DERIVED_PAINTER","PATH_PAINTER","SHAPE_PAINTER","IMAGE_PAINTER","RECT_FALLBACK_PAINTER"],"sources":["../../src/canvas/NodeShape.ts"],"sourcesContent":["/**\n * NodeShape — the **shape trait's** registry: the per-kind `paint` + `silhouette` used by\n * `defaultDrawOne`, clipping, non-rect hit-testing, and lasso/area-select. Teaching the kit\n * about a new kind of shape goes through this registry rather than by overriding `drawOne`.\n *\n * The first entry whose `matches` predicate returns true paints the node: `'high'` entries\n * first, then the built-ins, then `'normal'` ones, in registration order within a tier. Every\n * built-in but `kit:derived` additionally requires a rect-shaped pose — a scene whose poses are\n * some other shape matches none of them, and paints through a consumer painter or not at all.\n */\nimport { glyphGeneration } from '@weasel-js/font';\nimport {\n  pathContainsPoint,\n  strokeHitTest,\n  type Path\n} from '@weasel-js/geom';\nimport { pathThroughPoseFrame } from '@weasel-js/geom';\nimport { bumpNodeMemoGeneration, nodeMemo } from 'core/scene/nodeMemo';\nimport type { Node } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { hasSlop, slopForStrokeHit, widenSlop, type PickSlop } from 'core/viewport/screenSlop';\nimport type { View } from 'core/viewport/view';\nimport type { VertexColorChannel } from '@weasel-js/animator';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DERIVED_PAINTER } from './nodeShapes/derivedPainter';\nimport { IMAGE_PAINTER } from './nodeShapes/imagePainter';\nimport { derivesPath } from './nodeShapes/memo';\nimport { PATH_PAINTER } from './nodeShapes/pathPainter';\nimport { paintsPose } from './nodeShapes/poseBox';\nimport { RECT_FALLBACK_PAINTER } from './nodeShapes/rectFallbackPainter';\nimport { SHAPE_PAINTER } from './nodeShapes/shapePainter';\nimport { TEXT_PAINTER } from './nodeShapes/textPainter';\n\n/** Optional per-call paint context, threaded through `defaultDrawOne`'s third argument. Lets\n *  a rendering entry point override ambient environment reads; custom painters may ignore it\n *  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 before painting by the `drawOne`\n   *  wrapper of whichever scene or adapter is drawn: `paint` has no handle on\n   *  either, and deriving needs the 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.\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, and an in-place `push` would grow that list on every frame. */\n  paint(node: Node<TData, string, TPose>, pose: TPose, ctx?: NodePaintCtx): DrawCommand[];\n  /** Optional: the node's silhouette path from its pose. Used by clipping (when the\n   *  container has no explicit `clipFromPose`), by non-rect hit-testing, and by\n   *  lasso/area-select. Painters whose visual has no meaningful closed silhouette\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   *  Picking runs on every pointer move, so keep it to cheap field reads.\n   *  Painters that leave it undefined are treated as {@link DEFAULT_INK}: the\n   *  whole silhouette interior is grabbable 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  /** Reach past `outset` measured on screen, in pixels — a `{ px }` stroke's,\n   *  which the renderer holds exact in every direction, so no one world\n   *  distance stands for it under non-uniform zoom. */\n  outsetPx?: number;\n  /** Reach past `inset`, likewise. */\n  insetPx?: 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 }` lengths to world units — the mean of\n   *  the two axes' under non-uniform zoom. */\n  scale?: number;\n  /** The smaller axis's scale, where it differs from `scale`. A box bounding\n   *  a `{ px }` stroke reads its reach here, where a pixel is the most world. */\n  leastScale?: 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// The built-ins go in on first use, not at module load: a bundler may drop an\n// import kept only for its side effect, and the registry would come up empty.\nlet builtInsRegistered = false;\nfunction ensureBuiltIns(): void {\n  if (builtInsRegistered) return;\n  builtInsRegistered = true;\n  registerBuiltInShapePainters();\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  ensureBuiltIns();\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/**\n * Slot names for what picking asks per node per pointer move: which painter matches, and that\n * painter's silhouette path. Both go through {@link nodeMemo}, so they invalidate on `data`\n * (and, for the silhouette, `pose`) reference changes and on a painter registration.\n *\n * Separate slots rather than one entry: they mostly invalidate together, but not always, and a\n * shared entry would force the stricter key on both.\n */\nconst PAINTER_SLOT = 'shape:painter';\nconst PAINTER_SLOT_NONRECT = 'shape:painter:nonrect';\nconst PAINTER_SLOT_DERIVED = 'shape:painter:derived';\nconst PAINTER_SLOT_DERIVED_NONRECT = 'shape:painter:derived:nonrect';\nconst SILHOUETTE_SLOT = 'shape:silhouette';\nconst TEXT_SILHOUETTE_SLOT = 'shape:silhouette:text';\n\n/** The painter that will render `node` — first match in priority order — or undefined if\n *  none accepts it. */\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 and on whether the node derives\n  // its path, neither of which shows in `data`, so the key carries both.\n  const rect = paintsPose(node.pose);\n  const slot = derivesPath(node)\n    ? (rect ? PAINTER_SLOT_DERIVED : PAINTER_SLOT_DERIVED_NONRECT)\n    : (rect ? 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  ensureBuiltIns();\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/** The silhouette path of `node`, in **world** coords, or null if no painter matches or the\n *  matching painter has none.\n *\n *  Painters return their silhouette in the pose's local (unrotated) frame;\n *  this bakes the pose's frame (`poseFrameOf`: its rotation and `transform`)\n *  on top, so clips/area-select of a turned or skewed node use the boundary\n *  the renderer draws. */\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    return sil && pathThroughPoseFrame(sil, pose);\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  // Line boxes follow font metrics, and a face landing changes those with no\n  // change to the node, so the text entry is checked against the glyph epoch.\n  if (findNodeShape(node) === (TEXT_PAINTER as NodeShapeEntry<unknown, unknown>)) {\n    const epoch = glyphGeneration();\n    const held = nodeMemo(node as { data?: unknown }, TEXT_SILHOUETTE_SLOT, pose,\n      (): { epoch: number; path: Path | null } => ({ epoch, path: build() }));\n    if (held.epoch !== epoch) {\n      held.epoch = epoch;\n      held.path = build();\n    }\n    return held.path;\n  }\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/** 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. Defaults to `0`,\n   *  where a hairline is too thin a target to hit. */\n  tolerance?: PickSlop;\n  /** View scale, passed to the painter's `ink`, and what a screen reach is\n   *  read at under a world `tolerance`. 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? Asks the painter's silhouette,\n * the same boundary used for clipping and area-select, rather than the pose rect.\n *\n * The ink counts too: a shape whose interior isn't filled is grabbable along its outline and\n * not through its empty middle. The outline's grab width is the stroke's half-width plus\n * `tolerance`.\n *\n * A painter with no `silhouette`, or one that returns `null` for this node, reports `true` —\n * \"no opinion\" — so callers should keep their own AABB test as a pre-filter.\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 point is on\n  // picks the reach. `tolerance` also makes a filled shape grabbable a few pixels outside\n  // its edge.\n  const slop = widenSlop(opts.tolerance, (inside ? ink.insetPx : ink.outsetPx) ?? 0, opts.scale);\n  const { extra, opts: hit } = slopForStrokeHit(slop);\n  const reach = (inside ? ink.inset : ink.outset) + extra;\n  return (reach > 0 || hasSlop(slop)) && strokeHitTest(sil, x, y, reach, hit);\n}\n\n/** The current painters in evaluation order — `'high'` tier first, then `'normal'`. */\nexport function getNodeShapes(): readonly NodeShapeEntry[] {\n  ensureBuiltIns();\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  builtInsRegistered = false;\n  ensureBuiltIns();\n  // `registerNodeShape` already bumps, but the clearing above happens without one.\n  bumpNodeMemoGeneration();\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"],"mappings":"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"}
+{"version":3,"file":"NodeShape.js","names":[],"sources":["../../src/canvas/NodeShape.ts"],"sourcesContent":["/**\n * NodeShape — the **shape trait's** registry: the per-kind `paint` + `silhouette` used by\n * `defaultDrawOne`, clipping, non-rect hit-testing, and lasso/area-select. Teaching the kit\n * about a new kind of shape goes through this registry rather than by overriding `drawOne`.\n *\n * The first entry whose `matches` predicate returns true paints the node: `'high'` entries\n * first, then the built-ins, then `'normal'` ones, in registration order within a tier. Every\n * built-in but `kit:derived` additionally requires a rect-shaped pose — a scene whose poses are\n * some other shape matches none of them, and paints through a consumer painter or not at all.\n */\nimport { glyphGeneration } from '@weasel-js/font';\nimport {\n  pathContainsPoint,\n  strokeHitTest,\n  type Path\n} from '@weasel-js/geom';\nimport { pathThroughPoseFrame } from '@weasel-js/geom';\nimport { bumpNodeMemoGeneration, nodeMemo } from 'core/scene/nodeMemo';\nimport type { Node } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { hasSlop, slopForStrokeHit, widenSlop, type PickSlop } from 'core/viewport/screenSlop';\nimport { DERIVED_PAINTER } from './nodeShapes/derivedPainter';\nimport { IMAGE_PAINTER } from './nodeShapes/imagePainter';\nimport { MEASURE_PAINTER } from './nodeShapes/measurePainter';\nimport { derivesPath } from './nodeShapes/memo';\nimport { PATH_PAINTER } from './nodeShapes/pathPainter';\nimport { paintsPose } from './nodeShapes/poseBox';\nimport { RECT_FALLBACK_PAINTER } from './nodeShapes/rectFallbackPainter';\nimport { SHAPE_PAINTER } from './nodeShapes/shapePainter';\nimport { TEXT_PAINTER } from './nodeShapes/textPainter';\nimport type { NodeShapeEntry, NodeInk, NodeSilhouetteCtx, NodeInkCtx } from './nodeShapeTypes';\nexport type { NodePaintCtx, SceneViewDrawOne, NodeShapeEntry, NodeInk, NodeSilhouetteCtx, NodeInkCtx } from './nodeShapeTypes';\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// The built-ins go in on first use, not at module load: a bundler may drop an\n// import kept only for its side effect, and the registry would come up empty.\nlet builtInsRegistered = false;\nfunction ensureBuiltIns(): void {\n  if (builtInsRegistered) return;\n  builtInsRegistered = true;\n  registerBuiltInShapePainters();\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  ensureBuiltIns();\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/**\n * Slot names for what picking asks per node per pointer move: which painter matches, and that\n * painter's silhouette path. Both go through {@link nodeMemo}, so they invalidate on `data`\n * (and, for the silhouette, `pose`) reference changes and on a painter registration.\n *\n * Separate slots rather than one entry: they mostly invalidate together, but not always, and a\n * shared entry would force the stricter key on both.\n */\nconst PAINTER_SLOT = 'shape:painter';\nconst PAINTER_SLOT_NONRECT = 'shape:painter:nonrect';\nconst PAINTER_SLOT_DERIVED = 'shape:painter:derived';\nconst PAINTER_SLOT_DERIVED_NONRECT = 'shape:painter:derived:nonrect';\nconst SILHOUETTE_SLOT = 'shape:silhouette';\nconst TEXT_SILHOUETTE_SLOT = 'shape:silhouette:text';\n\n/** The painter that will render `node` — first match in priority order — or undefined if\n *  none accepts it. */\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 and on whether the node derives\n  // its path, neither of which shows in `data`, so the key carries both.\n  const rect = paintsPose(node.pose);\n  const slot = derivesPath(node)\n    ? (rect ? PAINTER_SLOT_DERIVED : PAINTER_SLOT_DERIVED_NONRECT)\n    : (rect ? 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  ensureBuiltIns();\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/** The silhouette path of `node`, in **world** coords, or null if no painter matches or the\n *  matching painter has none.\n *\n *  Painters return their silhouette in the pose's local (unrotated) frame;\n *  this bakes the pose's frame (`poseFrameOf`: its rotation and `transform`)\n *  on top, so clips/area-select of a turned or skewed node use the boundary\n *  the renderer draws. */\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    return sil && pathThroughPoseFrame(sil, pose);\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  // Line boxes follow font metrics, and a face landing changes those with no\n  // change to the node, so the text entry is checked against the glyph epoch.\n  if (findNodeShape(node) === (TEXT_PAINTER as NodeShapeEntry<unknown, unknown>)) {\n    const epoch = glyphGeneration();\n    const held = nodeMemo(node as { data?: unknown }, TEXT_SILHOUETTE_SLOT, pose,\n      (): { epoch: number; path: Path | null } => ({ epoch, path: build() }));\n    if (held.epoch !== epoch) {\n      held.epoch = epoch;\n      held.path = build();\n    }\n    return held.path;\n  }\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/** 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. Defaults to `0`,\n   *  where a hairline is too thin a target to hit. */\n  tolerance?: PickSlop;\n  /** View scale, passed to the painter's `ink`, and what a screen reach is\n   *  read at under a world `tolerance`. 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? Asks the painter's silhouette,\n * the same boundary used for clipping and area-select, rather than the pose rect.\n *\n * The ink counts too: a shape whose interior isn't filled is grabbable along its outline and\n * not through its empty middle. The outline's grab width is the stroke's half-width plus\n * `tolerance`.\n *\n * A painter with no `silhouette`, or one that returns `null` for this node, reports `true` —\n * \"no opinion\" — so callers should keep their own AABB test as a pre-filter.\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 point is on\n  // picks the reach. `tolerance` also makes a filled shape grabbable a few pixels outside\n  // its edge.\n  const slop = widenSlop(opts.tolerance, (inside ? ink.insetPx : ink.outsetPx) ?? 0, opts.scale);\n  const { extra, opts: hit } = slopForStrokeHit(slop);\n  const reach = (inside ? ink.inset : ink.outset) + extra;\n  return (reach > 0 || hasSlop(slop)) && strokeHitTest(sil, x, y, reach, hit);\n}\n\n/** The current painters in evaluation order — `'high'` tier first, then `'normal'`. */\nexport function getNodeShapes(): readonly NodeShapeEntry[] {\n  ensureBuiltIns();\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  builtInsRegistered = false;\n  ensureBuiltIns();\n  // `registerNodeShape` already bumps, but the clearing above happens without one.\n  bumpNodeMemoGeneration();\n}\n\nfunction registerBuiltInShapePainters(): void {\n  registerNodeShape(TEXT_PAINTER);\n  registerNodeShape(MEASURE_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"],"mappings":"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"}

package/dist/canvas/PickHud.js

@@ -1,96 +1,114 @@
-import { clientToWorld as e } from "../core/viewport/clientToWorld.js";
-import t from "./hud.module.js";
-import { useHostAnchor as n } from "./useHostAnchor.js";
-import { useEffect as r, useState as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
-import { jsx as o, jsxs as s } from "react/jsx-runtime";
+import { clientToWorld } from "../core/viewport/clientToWorld.js";
+import hud_module_default from "./hud.module.js";
+import { useHostAnchor } from "./useHostAnchor.js";
+import { useEffect, useState } from "react";
+import { useLatest } from "@weasel-js/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
 //#region src/canvas/PickHud.tsx
-function c({ canvasRef: c, anchorRef: l, viewRef: u, toWorld: d, pickEvery: f, pickBest: p, offset: m }) {
-	let h = a(d), [g, _] = i({
+/**
+* Dev HUD listing the ids returned by `pickEvery(world)` under the cursor.
+*
+* Anchors to the canvas's top-right corner like `CursorCoordsHud`, offset
+* downward so it sits just below that HUD. Updates on `document`
+* pointermove. Refreshes its position on scroll / resize so it tracks the
+* canvas through layout changes.
+*/
+/** Debug overlay listing every node under the pointer, with the one a click
+*  would actually select shown in bold. */
+function PickHud({ canvasRef, anchorRef, viewRef, toWorld, pickEvery, pickBest, offset }) {
+	const toWorldRef = useLatest(toWorld);
+	const [state, setState] = useState({
 		ids: [],
 		best: null,
-		inCanvas: !1
-	}), { ref: v, style: y } = n(() => l?.current ?? c.current?.parentElement ?? c.current, {
+		inCanvas: false
+	});
+	const { ref, style } = useHostAnchor(() => anchorRef?.current ?? canvasRef.current?.parentElement ?? canvasRef.current, {
 		align: {
 			x: "end",
 			y: "start"
 		},
 		offset: {
-			x: m?.right ?? 8,
-			y: m?.top ?? 76
+			x: offset?.right ?? 8,
+			y: offset?.top ?? 76
 		}
 	});
-	return r(() => {
-		let t = (t) => {
-			let n = c.current, r = u.current;
-			if (!n || !r) {
-				_({
+	useEffect(() => {
+		const onMove = (e) => {
+			const canvas = canvasRef.current;
+			const view = viewRef.current;
+			if (!canvas || !view) {
+				setState({
 					ids: [],
 					best: null,
-					inCanvas: !1
+					inCanvas: false
 				});
 				return;
 			}
-			let i = n.getBoundingClientRect();
-			if (!(t.clientX >= i.left && t.clientX <= i.right && t.clientY >= i.top && t.clientY <= i.bottom)) {
-				_({
+			const rect = canvas.getBoundingClientRect();
+			if (!(e.clientX >= rect.left && e.clientX <= rect.right && e.clientY >= rect.top && e.clientY <= rect.bottom)) {
+				setState({
 					ids: [],
 					best: null,
-					inCanvas: !1
+					inCanvas: false
 				});
 				return;
 			}
-			let [a, o] = h.current?.(t.clientX, t.clientY) ?? e(t.clientX, t.clientY, i, r), s = [];
+			const [worldX, worldY] = toWorldRef.current?.(e.clientX, e.clientY) ?? clientToWorld(e.clientX, e.clientY, rect, view);
+			let ids = [];
 			try {
-				s = f(a, o);
+				ids = pickEvery(worldX, worldY);
 			} catch {
-				s = [];
+				ids = [];
 			}
-			let l = null;
-			if (p) try {
-				l = p(a, o);
+			let best = null;
+			if (pickBest) try {
+				best = pickBest(worldX, worldY);
 			} catch {
-				l = null;
+				best = null;
 			}
-			_({
-				ids: s,
-				best: l,
-				inCanvas: !0
+			setState({
+				ids,
+				best,
+				inCanvas: true
 			});
 		};
-		return document.addEventListener("pointermove", t), () => {
-			document.removeEventListener("pointermove", t);
+		document.addEventListener("pointermove", onMove);
+		return () => {
+			document.removeEventListener("pointermove", onMove);
 		};
 	}, [
-		c,
-		u,
-		f,
-		p,
-		h
-	]), y ? /* @__PURE__ */ s("div", {
-		ref: v,
-		className: `${t.hud} ${t.sized}`,
-		style: y,
-		children: [/* @__PURE__ */ s("div", {
-			className: `${t.header} ${t.muted}`,
+		canvasRef,
+		viewRef,
+		pickEvery,
+		pickBest,
+		toWorldRef
+	]);
+	if (!style) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		ref,
+		className: `${hud_module_default.hud} ${hud_module_default.sized}`,
+		style,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: `${hud_module_default.header} ${hud_module_default.muted}`,
 			children: [
 				"pickEvery (",
-				g.ids.length,
+				state.ids.length,
 				")"
 			]
-		}), g.ids.length === 0 ? /* @__PURE__ */ o("div", {
-			className: t.absent,
-			children: g.inCanvas ? "—" : "off-canvas"
-		}) : /* @__PURE__ */ o("ul", {
-			className: t.list,
-			children: g.ids.slice().reverse().map((e) => /* @__PURE__ */ o("li", {
-				className: e === g.best ? `${t.item} ${t.itemBest}` : t.item,
-				children: e
-			}, e))
+		}), state.ids.length === 0 ? /* @__PURE__ */ jsx("div", {
+			className: hud_module_default.absent,
+			children: state.inCanvas ? "—" : "off-canvas"
+		}) : /* @__PURE__ */ jsx("ul", {
+			className: hud_module_default.list,
+			children: state.ids.slice().reverse().map((id) => /* @__PURE__ */ jsx("li", {
+				className: id === state.best ? `${hud_module_default.item} ${hud_module_default.itemBest}` : hud_module_default.item,
+				children: id
+			}, id))
 		})]
-	}) : null;
+	});
 }
-//#endregion
-export { c as PickHud };
 
+//#endregion
+export { PickHud };
 //# sourceMappingURL=PickHud.js.map

package/dist/canvas/PickHud.js.map

@@ -1 +1 @@
-{"version":3,"file":"PickHud.js","names":["s","hud_module_default","PickHud","toWorldRef","useLatest","toWorld","state","setState","useState","useHostAnchor","anchorRef","canvasRef","offset","useEffect","onMove","canvas","view","viewRef","rect","e","worldX","worldY","clientToWorld","ids","pickEvery","best","pickBest","style","id"],"sources":["../../src/canvas/PickHud.tsx"],"sourcesContent":["/// <reference path=\"../css-modules.d.ts\" />\n/**\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 { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\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  /** Client coords to world. Defaults to the canvas's rect and `viewRef`. A\n   *  canvas whose routing converts some other way (a CSS transform, a 3D host)\n   *  passes that conversion, so the readout agrees with the picks. */\n  toWorld?: (clientX: number, clientY: number) => [number, number];\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, toWorld, pickEvery, pickBest, offset }: PickHudProps) {\n  const toWorldRef = useLatest(toWorld);\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, worldY] = toWorldRef.current?.(e.clientX, e.clientY)\n        ?? clientToWorld(e.clientX, e.clientY, rect, view);\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, toWorldRef]);\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":";;;;;;;AA8CA,SAAgBE,EAAQ,EAAE,cAAW,cAAW,YAAS,YAAS,cAAW,aAAU,aAAwB;CAC7G,IAAMC,IAAaC,EAAUC,CAAO,GAC9B,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,EAFFI,EAAE,WAAWD,EAAK,QAAQC,EAAE,WAAWD,EAAK,SAC5CC,EAAE,WAAWD,EAAK,OAAQC,EAAE,WAAWD,EAAK,SAC/B;IACb,EAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAM,CAACE,GAAQC,KAAUlB,EAAW,UAAUgB,EAAE,SAASA,EAAE,OAAO,KAC7DG,EAAcH,EAAE,SAASA,EAAE,SAASD,GAAMF,CAAI,GAC/CO,IAAyB,CAAC;GAC9B,IAAI;IACF,IAAMC,EAAUJ,GAAQC,CAAM;GAChC,QAAQ;IACN,IAAM,CAAC;GACT;GACA,IAAII,IAAsB;GAC1B,IAAIC,GACF,IAAI;IAAE,IAAOA,EAASN,GAAQC,CAAM;GAAG,QAAQ;IAAE,IAAO;GAAM;GAEhE,EAAS;IAAE;IAAK;IAAM,UAAU;GAAK,CAAC;EACxC;EAIA,OAFA,SAAS,iBAAiB,eAAeP,CAAM,SAElC;GACX,SAAS,oBAAoB,eAAeA,CAAM;EACpD;CACF,GAAG;EAACH;EAAWM;EAASO;EAAWE;EAAUvB;CAAU,CAAC,GAEnDwB,IAGH,kBAAC,OAAD;EAAU;EAAK,WAAW,GAAG3B,EAAE,IAAI,GAAGA,EAAE;EAAgB;EAAxD,UAAA,CACE,kBAAC,OAAD;GAAK,WAAW,GAAGA,EAAE,OAAO,GAAGA,EAAE;GAAjC,UAAA;IAA0C;IAAYM,EAAM,IAAI;IAAO;GAAM;EAC5E,CAAA,GAAAA,EAAM,IAAI,WAAW,IACpB,kBAAC,OAAD;GAAK,WAAWN,EAAE;GAAS,UAAAM,EAAM,WAAW,MAAM;EAAkB,CAAA,IAEpE,kBAAC,MAAD;GAAI,WAAWN,EAAE;GAEd,UAAAM,EAAM,IAAI,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,MAChC,kBAAC,MAAD;IAEE,WAAWsB,MAAOtB,EAAM,OAAO,GAAGN,EAAE,KAAK,GAAGA,EAAE,aAAaA,EAAE;IAE5D,UAAA4B;GACC,GAJGA,CAIH,CACL;EACC,CAAA,CAEH;MApBY;AAsBrB"}
+{"version":3,"file":"PickHud.js","names":["s"],"sources":["../../src/canvas/PickHud.tsx"],"sourcesContent":["/// <reference path=\"../css-modules.d.ts\" />\n/**\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 { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\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  /** Client coords to world. Defaults to the canvas's rect and `viewRef`. A\n   *  canvas whose routing converts some other way (a CSS transform, a 3D host)\n   *  passes that conversion, so the readout agrees with the picks. */\n  toWorld?: (clientX: number, clientY: number) => [number, number];\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, toWorld, pickEvery, pickBest, offset }: PickHudProps) {\n  const toWorldRef = useLatest(toWorld);\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, worldY] = toWorldRef.current?.(e.clientX, e.clientY)\n        ?? clientToWorld(e.clientX, e.clientY, rect, view);\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, toWorldRef]);\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":";;;;;;;;;;;;;;;;;;AA8CA,SAAgB,QAAQ,EAAE,WAAW,WAAW,SAAS,SAAS,WAAW,UAAU,UAAwB;CAC7G,MAAM,aAAa,UAAU,OAAO;CACpC,MAAM,CAAC,OAAO,YAAY,SAAmB;EAC3C,KAAK,CAAC;EAAG,MAAM;EAAM,UAAU;CACjC,CAAC;CACD,MAAM,EAAE,KAAK,UAAU,oBACf,WAAW,WAAW,UAAU,SAAS,iBAAiB,UAAU,SAC1E;EACE,OAAO;GAAE,GAAG;GAAO,GAAG;EAAQ;EAC9B,QAAQ;GAAE,GAAG,QAAQ,SAAS;GAAG,GAAG,QAAQ,OAAO;EAAG;CACxD,CACF;CAEA,gBAAgB;EACd,MAAM,UAAU,MAAoB;GAClC,MAAM,SAAS,UAAU;GACzB,MAAM,OAAO,QAAQ;GACrB,IAAI,CAAC,UAAU,CAAC,MAAM;IACpB,SAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,MAAM,OAAO,OAAO,sBAAsB;GAI1C,IAAI,EAFF,EAAE,WAAW,KAAK,QAAQ,EAAE,WAAW,KAAK,SAC5C,EAAE,WAAW,KAAK,OAAQ,EAAE,WAAW,KAAK,SAC/B;IACb,SAAS;KAAE,KAAK,CAAC;KAAG,MAAM;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,MAAM,CAAC,QAAQ,UAAU,WAAW,UAAU,EAAE,SAAS,EAAE,OAAO,KAC7D,cAAc,EAAE,SAAS,EAAE,SAAS,MAAM,IAAI;GACnD,IAAI,MAAyB,CAAC;GAC9B,IAAI;IACF,MAAM,UAAU,QAAQ,MAAM;GAChC,QAAQ;IACN,MAAM,CAAC;GACT;GACA,IAAI,OAAsB;GAC1B,IAAI,UACF,IAAI;IAAE,OAAO,SAAS,QAAQ,MAAM;GAAG,QAAQ;IAAE,OAAO;GAAM;GAEhE,SAAS;IAAE;IAAK;IAAM,UAAU;GAAK,CAAC;EACxC;EAEA,SAAS,iBAAiB,eAAe,MAAM;EAE/C,aAAa;GACX,SAAS,oBAAoB,eAAe,MAAM;EACpD;CACF,GAAG;EAAC;EAAW;EAAS;EAAW;EAAU;CAAU,CAAC;CAExD,IAAI,CAAC,OAAO,OAAO;CAEnB,OACE,qBAAC,OAAD;EAAU;EAAK,WAAW,GAAGA,mBAAE,IAAI,GAAGA,mBAAE;EAAgB;EAAxD,UAAA,CACE,qBAAC,OAAD;GAAK,WAAW,GAAGA,mBAAE,OAAO,GAAGA,mBAAE;GAAjC,UAAA;IAA0C;IAAY,MAAM,IAAI;IAAO;GAAM;EAC5E,CAAA,GAAA,MAAM,IAAI,WAAW,IACpB,oBAAC,OAAD;GAAK,WAAWA,mBAAE;GAAS,UAAA,MAAM,WAAW,MAAM;EAAkB,CAAA,IAEpE,oBAAC,MAAD;GAAI,WAAWA,mBAAE;GAEd,UAAA,MAAM,IAAI,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,OAChC,oBAAC,MAAD;IAEE,WAAW,OAAO,MAAM,OAAO,GAAGA,mBAAE,KAAK,GAAGA,mBAAE,aAAaA,mBAAE;IAE5D,UAAA;GACC,GAJG,EAIH,CACL;EACC,CAAA,CAEH;;AAET"}

package/dist/canvas/SceneCanvas/ActionsProviderIfRoot.js

@@ -1,10 +1,13 @@
-import { ActionsProvider as e, useActionsRegistry as t } from "@weasel-js/routing/react";
-import { Fragment as n, jsx as r } from "react/jsx-runtime";
+import { ActionsProvider, useActionsRegistry } from "@weasel-js/routing/react";
+import { Fragment, jsx } 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 });
+/** Mount an `<ActionsProvider>` only when none is already in scope. */
+function ActionsProviderIfRoot({ children }) {
+	if (useActionsRegistry()) return /* @__PURE__ */ jsx(Fragment, { children });
+	return /* @__PURE__ */ jsx(ActionsProvider, { children });
 }
-//#endregion
-export { i as ActionsProviderIfRoot };
 
+//#endregion
+export { ActionsProviderIfRoot };
 //# sourceMappingURL=ActionsProviderIfRoot.js.map

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

@@ -1 +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"}
+{"version":3,"file":"ActionsProviderIfRoot.js","names":["_Fragment"],"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,SAAgB,sBAAsB,EAAE,YAAqC;CAE3E,IADe,mBACX,GAAQ,OAAO,oBAAAA,UAAA,EAAG,SAAW,CAAA;CACjC,OAAO,oBAAC,iBAAD,EAAkB,SAA0B,CAAA;AACrD"}

package/dist/canvas/SceneCanvas/CanvasKitProviders.js

@@ -0,0 +1,25 @@
+import { ViewInputsProvider } from "../viewInputs.js";
+import { PointerProviderIfRoot } from "./PointerProviderIfRoot.js";
+import { SnapSourceRegistryContext, createSnapSourceRegistry } from "../../features/snap/registry.js";
+import { IconRegistryProviderIfRoot } from "../../iconRegistry/IconRegistryProvider.js";
+import { useState } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/canvas/SceneCanvas/CanvasKitProviders.tsx
+/** The kit providers a canvas mounts around its surface: view inputs and the
+*  snap source registry, then the icon registry and pointer context where none
+*  is already in scope. */
+function CanvasKitProviders({ viewInputs, children }) {
+	const [snapRegistry] = useState(createSnapSourceRegistry);
+	return /* @__PURE__ */ jsx(ViewInputsProvider, {
+		value: viewInputs,
+		children: /* @__PURE__ */ jsx(SnapSourceRegistryContext.Provider, {
+			value: snapRegistry,
+			children: /* @__PURE__ */ jsx(IconRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children }) })
+		})
+	});
+}
+
+//#endregion
+export { CanvasKitProviders };
+//# sourceMappingURL=CanvasKitProviders.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasKitProviders.js","names":[],"sources":["../../../src/canvas/SceneCanvas/CanvasKitProviders.tsx"],"sourcesContent":["import { useState, type ReactNode } from 'react';\nimport { createSnapSourceRegistry, SnapSourceRegistryContext } from 'features/snap/registry';\nimport { IconRegistryProviderIfRoot } from '../../iconRegistry';\nimport { ViewInputsProvider, type SurfaceViewInputs } from '../viewInputs';\nimport { PointerProviderIfRoot } from './PointerProviderIfRoot';\n\n/** The kit providers a canvas mounts around its surface: view inputs and the\n *  snap source registry, then the icon registry and pointer context where none\n *  is already in scope. */\nexport function CanvasKitProviders({ viewInputs, children }: { viewInputs: SurfaceViewInputs; children: ReactNode }) {\n  const [snapRegistry] = useState(createSnapSourceRegistry);\n  return (\n    <ViewInputsProvider value={viewInputs}>\n      <SnapSourceRegistryContext.Provider value={snapRegistry}>\n        <IconRegistryProviderIfRoot>\n          <PointerProviderIfRoot>{children}</PointerProviderIfRoot>\n        </IconRegistryProviderIfRoot>\n      </SnapSourceRegistryContext.Provider>\n    </ViewInputsProvider>\n  );\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,mBAAmB,EAAE,YAAY,YAAoE;CACnH,MAAM,CAAC,gBAAgB,SAAS,wBAAwB;CACxD,OACE,oBAAC,oBAAD;EAAoB,OAAO;EACzB,UAAA,oBAAC,0BAA0B,UAA3B;GAAoC,OAAO;GACzC,UAAA,oBAAC,4BAAD,EAAA,UACE,oBAAC,uBAAD,EAAwB,SAAgC,CAAA,EAC9B,CAAA;EACM,CAAA;CAClB,CAAA;AAExB"}

package/dist/canvas/SceneCanvas/DepRegistryProviderIfRoot.js

@@ -1,10 +1,14 @@
-import { DepRegistryProvider as e, useOptionalDepRegistry as t } from "@weasel-js/routing/react";
-import { Fragment as n, jsx as r } from "react/jsx-runtime";
+import { DepRegistryProvider, useOptionalDepRegistry } from "@weasel-js/routing/react";
+import { Fragment, jsx } 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 });
+/** Mount a `<DepRegistryProvider>` only when none is already in scope, so a
+*  consumer's dep sources are not shadowed by a nested canvas. */
+function DepRegistryProviderIfRoot({ children }) {
+	if (useOptionalDepRegistry()) return /* @__PURE__ */ jsx(Fragment, { children });
+	return /* @__PURE__ */ jsx(DepRegistryProvider, { children });
 }
-//#endregion
-export { i as DepRegistryProviderIfRoot };
 
+//#endregion
+export { DepRegistryProviderIfRoot };
 //# sourceMappingURL=DepRegistryProviderIfRoot.js.map