@weasel-js/core 1.11.1 → 1.13.0-rc.0

package/dist/canvas/pickIndex/nodeBroadBox.js

@@ -0,0 +1,86 @@
+import { framedBounds, poseDescriptorForNode } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR, isPathLike, isRectPose } from "../../core/geometry/autoPoseDescriptor.js";
+import { findShapeInk } from "../NodeShape.js";
+import { regionBoundsOf } from "../../core/geometry/regionHit.js";
+import { applyToPoint, boundsOfPath, poseFrameOf } from "@weasel-js/geom";
+
+//#region src/canvas/pickIndex/nodeBroadBox.ts
+/**
+* One node's box in the pick index: a world box that every query's `hits`
+* accepts only inside of, before that query's own screen-pixel slop.
+*
+* The point query and the region query read a node differently, so the box is
+* the union of both: the region's `regionBoundsOf` through the node's own
+* descriptor, and the frame box the point query's `poseContainsRotated` tests,
+* grown in the pose's own frame by the ink's `outset`. A derived node is read
+* by its path alone, as both queries read it.
+*/
+function grow(out, b, by) {
+	const x1 = b.x + b.width, y1 = b.y + b.height;
+	out[0] = Math.min(out[0], Math.min(b.x, x1) - by);
+	out[1] = Math.min(out[1], Math.min(b.y, y1) - by);
+	out[2] = Math.max(out[2], Math.max(b.x, x1) + by);
+	out[3] = Math.max(out[3], Math.max(b.y, y1) + by);
+}
+/** The local box `poseContainsRotated` tests, grown by `by` and carried through
+*  the pose's frame, as that function reads it. */
+function framedBox(out, pose, d, by) {
+	const local = isPathLike(pose) ? boundsOfPath(pose) : d.getBounds(pose);
+	const framed = d === AUTO_POSE_DESCRIPTOR ? pose : framedBounds(pose, d);
+	const frame = poseFrameOf(framed);
+	if (!frame) {
+		grow(out, local, by);
+		return;
+	}
+	const x0 = local.x - by, y0 = local.y - by;
+	const x1 = local.x + local.width + by, y1 = local.y + local.height + by;
+	for (const [x, y] of [
+		[x0, y0],
+		[x1, y0],
+		[x1, y1],
+		[x0, y1]
+	]) {
+		const [wx, wy] = applyToPoint(frame, x, y);
+		grow(out, {
+			x: wx,
+			y: wy,
+			width: 0,
+			height: 0
+		}, 0);
+	}
+}
+/** Float error in a frame's round trip must not put an accepted point just outside. */
+function pad(b) {
+	const e = 1e-9 * (1 + Math.max(Math.abs(b[0]), Math.abs(b[1]), Math.abs(b[2]), Math.abs(b[3])));
+	b[0] -= e;
+	b[1] -= e;
+	b[2] += e;
+	b[3] += e;
+}
+var UNINHERITED = Object.freeze({ scale: 1 });
+/** Writes the box into `out` and returns the ink's reach measured on screen,
+*  which no world box can hold. */
+function nodeBroadBox(node, pose, derived, inherited, descriptor, out) {
+	const ink = findShapeInk(node, pose, inherited === void 0 ? UNINHERITED : {
+		scale: 1,
+		inherited
+	});
+	const outset = Math.max(0, ink?.outset ?? 0);
+	out[0] = out[1] = Infinity;
+	out[2] = out[3] = -Infinity;
+	if (derived) grow(out, boundsOfPath(derived), outset);
+	else {
+		const own = poseDescriptorForNode(descriptor, node);
+		if (descriptor === AUTO_POSE_DESCRIPTOR && own === descriptor && isRectPose(pose) && poseFrameOf(pose) === null) grow(out, pose, outset);
+		else {
+			grow(out, regionBoundsOf(node, pose, own), outset);
+			framedBox(out, pose, descriptor, outset);
+		}
+	}
+	pad(out);
+	return Math.max(0, ink?.outsetPx ?? 0);
+}
+
+//#endregion
+export { nodeBroadBox };
+//# sourceMappingURL=nodeBroadBox.js.map

package/dist/canvas/pickIndex/nodeBroadBox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeBroadBox.js","names":[],"sources":["../../../src/canvas/pickIndex/nodeBroadBox.ts"],"sourcesContent":["/**\n * One node's box in the pick index: a world box that every query's `hits`\n * accepts only inside of, before that query's own screen-pixel slop.\n *\n * The point query and the region query read a node differently, so the box is\n * the union of both: the region's `regionBoundsOf` through the node's own\n * descriptor, and the frame box the point query's `poseContainsRotated` tests,\n * grown in the pose's own frame by the ink's `outset`. A derived node is read\n * by its path alone, as both queries read it.\n */\nimport { applyToPoint, boundsOfPath, poseFrameOf, type Path } from '@weasel-js/geom';\nimport { findShapeInk } from 'canvas/NodeShape';\nimport { AUTO_POSE_DESCRIPTOR, isPathLike, isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { regionBoundsOf } from 'core/geometry/regionHit';\nimport type { InheritedPaint } from 'core/scene/inheritedPaint';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'interactions/actions/resize/geometry';\n\n/** `[minX, minY, maxX, maxY]`, the layout `createBvh(2)` takes. */\nexport type Box2 = [number, number, number, number];\n\ntype Rect = { x: number; y: number; width: number; height: number };\n\nfunction grow(out: Box2, b: Rect, by: number): void {\n  const x1 = b.x + b.width, y1 = b.y + b.height;\n  out[0] = Math.min(out[0], Math.min(b.x, x1) - by);\n  out[1] = Math.min(out[1], Math.min(b.y, y1) - by);\n  out[2] = Math.max(out[2], Math.max(b.x, x1) + by);\n  out[3] = Math.max(out[3], Math.max(b.y, y1) + by);\n}\n\n/** The local box `poseContainsRotated` tests, grown by `by` and carried through\n *  the pose's frame, as that function reads it. */\nfunction framedBox(out: Box2, pose: unknown, d: PoseDescriptor<unknown>, by: number): void {\n  const local: Rect = isPathLike(pose) ? boundsOfPath(pose) : d.getBounds(pose);\n  const framed = d === AUTO_POSE_DESCRIPTOR ? pose : framedBounds(pose, d);\n  const frame = poseFrameOf(framed);\n  if (!frame) {\n    grow(out, local, by);\n    return;\n  }\n  const x0 = local.x - by, y0 = local.y - by;\n  const x1 = local.x + local.width + by, y1 = local.y + local.height + by;\n  for (const [x, y] of [[x0, y0], [x1, y0], [x1, y1], [x0, y1]] as const) {\n    const [wx, wy] = applyToPoint(frame, x, y);\n    grow(out, { x: wx, y: wy, width: 0, height: 0 }, 0);\n  }\n}\n\n/** Float error in a frame's round trip must not put an accepted point just outside. */\nfunction pad(b: Box2): void {\n  const e = 1e-9 * (1 + Math.max(Math.abs(b[0]), Math.abs(b[1]), Math.abs(b[2]), Math.abs(b[3])));\n  b[0] -= e; b[1] -= e; b[2] += e; b[3] += e;\n}\n\nconst UNINHERITED = Object.freeze({ scale: 1 });\n\n/** Writes the box into `out` and returns the ink's reach measured on screen,\n *  which no world box can hold. */\nexport function nodeBroadBox(\n  node: object,\n  pose: unknown,\n  derived: Path | null | undefined,\n  inherited: InheritedPaint | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  out: Box2,\n): number {\n  const ink = findShapeInk(node as never, pose, inherited === undefined ? UNINHERITED : { scale: 1, inherited });\n  const outset = Math.max(0, ink?.outset ?? 0);\n  out[0] = out[1] = Infinity;\n  out[2] = out[3] = -Infinity;\n  if (derived) {\n    grow(out, boundsOfPath(derived), outset);\n  } else {\n    const own = poseDescriptorForNode(descriptor, node);\n    if (descriptor === AUTO_POSE_DESCRIPTOR && own === descriptor && isRectPose(pose) && poseFrameOf(pose) === null) {\n      // Both reads come to the pose rect itself.\n      grow(out, pose, outset);\n    } else {\n      grow(out, regionBoundsOf(node, pose, own), outset);\n      framedBox(out, pose, descriptor, outset);\n    }\n  }\n  pad(out);\n  return Math.max(0, ink?.outsetPx ?? 0);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAuBA,SAAS,KAAK,KAAW,GAAS,IAAkB;CAClD,MAAM,KAAK,EAAE,IAAI,EAAE,OAAO,KAAK,EAAE,IAAI,EAAE;CACvC,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE;CAChD,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE;CAChD,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE;CAChD,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE;AAClD;;;AAIA,SAAS,UAAU,KAAW,MAAe,GAA4B,IAAkB;CACzF,MAAM,QAAc,WAAW,IAAI,IAAI,aAAa,IAAI,IAAI,EAAE,UAAU,IAAI;CAC5E,MAAM,SAAS,MAAM,uBAAuB,OAAO,aAAa,MAAM,CAAC;CACvE,MAAM,QAAQ,YAAY,MAAM;CAChC,IAAI,CAAC,OAAO;EACV,KAAK,KAAK,OAAO,EAAE;EACnB;CACF;CACA,MAAM,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,IAAI;CACxC,MAAM,KAAK,MAAM,IAAI,MAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,MAAM,SAAS;CACrE,KAAK,MAAM,CAAC,GAAG,MAAM;EAAC,CAAC,IAAI,EAAE;EAAG,CAAC,IAAI,EAAE;EAAG,CAAC,IAAI,EAAE;EAAG,CAAC,IAAI,EAAE;CAAC,GAAY;EACtE,MAAM,CAAC,IAAI,MAAM,aAAa,OAAO,GAAG,CAAC;EACzC,KAAK,KAAK;GAAE,GAAG;GAAI,GAAG;GAAI,OAAO;GAAG,QAAQ;EAAE,GAAG,CAAC;CACpD;AACF;;AAGA,SAAS,IAAI,GAAe;CAC1B,MAAM,IAAI,QAAQ,IAAI,KAAK,IAAI,KAAK,IAAI,EAAE,EAAE,GAAG,KAAK,IAAI,EAAE,EAAE,GAAG,KAAK,IAAI,EAAE,EAAE,GAAG,KAAK,IAAI,EAAE,EAAE,CAAC;CAC7F,EAAE,MAAM;CAAG,EAAE,MAAM;CAAG,EAAE,MAAM;CAAG,EAAE,MAAM;AAC3C;AAEA,IAAM,cAAc,OAAO,OAAO,EAAE,OAAO,EAAE,CAAC;;;AAI9C,SAAgB,aACd,MACA,MACA,SACA,WACA,YACA,KACQ;CACR,MAAM,MAAM,aAAa,MAAe,MAAM,cAAc,SAAY,cAAc;EAAE,OAAO;EAAG;CAAU,CAAC;CAC7G,MAAM,SAAS,KAAK,IAAI,GAAG,KAAK,UAAU,CAAC;CAC3C,IAAI,KAAK,IAAI,KAAK;CAClB,IAAI,KAAK,IAAI,KAAK;CAClB,IAAI,SACF,KAAK,KAAK,aAAa,OAAO,GAAG,MAAM;MAClC;EACL,MAAM,MAAM,sBAAsB,YAAY,IAAI;EAClD,IAAI,eAAe,wBAAwB,QAAQ,cAAc,WAAW,IAAI,KAAK,YAAY,IAAI,MAAM,MAEzG,KAAK,KAAK,MAAM,MAAM;OACjB;GACL,KAAK,KAAK,eAAe,MAAM,MAAM,GAAG,GAAG,MAAM;GACjD,UAAU,KAAK,MAAM,YAAY,MAAM;EACzC;CACF;CACA,IAAI,GAAG;CACP,OAAO,KAAK,IAAI,GAAG,KAAK,YAAY,CAAC;AACvC"}

package/dist/canvas/pickIndex/scenePickIndex.js

@@ -0,0 +1,208 @@
+import { nodeMemoGeneration } from "../../core/scene/nodeMemo.js";
+import { inheritedPaintOf, inheritsPaint } from "../../core/scene/inheritedPaint.js";
+import { nodesAsShown } from "../../core/scene/nodeAsShown.js";
+import { getNodeShapes } from "../NodeShape.js";
+import { scenePaintedPoseOf } from "../derivedPath.js";
+import { sceneParentsOf, sceneShownPathOf } from "../scenePickReads.js";
+import { nodeBroadBox } from "./nodeBroadBox.js";
+import { markerGeneration } from "@weasel-js/stroke";
+import { createBvh } from "@weasel-js/geom/nd";
+
+//#region src/canvas/pickIndex/scenePickIndex.ts
+/**
+* The per-scene pick index: one BVH per scene layer over every node's broad
+* box (`nodeBroadBox`), keyed by the node's place in the render order it was
+* built from. A pick after anything it read can have changed walks the scene
+* and only records that state; the next pick to find the scene unchanged
+* builds, so a scene edited before every pick never pays for a build. Nodes it
+* cannot box conservatively are on `always` and are tested by every walk.
+*/
+var builds = 0;
+var CACHE = /* @__PURE__ */ new WeakMap();
+/** Past this share of the scene the index costs more than the walk it narrows. */
+var MAX_SHARE = .5;
+var BuiltIndex = class {
+	built;
+	trees;
+	always;
+	maxOutsetPx;
+	layers;
+	/** The render order the candidates are read out of. */
+	order;
+	/** Build position to position in `order`, or null while they are the same array. */
+	remap = null;
+	marks;
+	found;
+	constructor(built, trees, always, maxOutsetPx) {
+		this.built = built;
+		this.trees = trees;
+		this.always = always;
+		this.maxOutsetPx = maxOutsetPx;
+		this.layers = [...trees.keys()];
+		this.order = built;
+		this.marks = new Uint8Array(built.length);
+		this.found = new Int32Array(Math.max(16, always.length));
+	}
+	/** Follow a new render order array the scene hands back for the same state. */
+	rankBy(order) {
+		if (order === this.order) return;
+		this.order = order;
+		if (order === this.built) {
+			this.remap = null;
+			return;
+		}
+		const rank = /* @__PURE__ */ new Map();
+		for (let i = 0; i < order.length; i++) rank.set(order[i].id, i);
+		const remap = new Int32Array(this.built.length);
+		for (let i = 0; i < remap.length; i++) remap[i] = rank.get(this.built[i].id) ?? -1;
+		this.remap = remap;
+	}
+	/** The nodes the boxes reach, in render order, or null when that is most of the scene. */
+	candidates(broads) {
+		const limit = Math.floor(this.order.length * MAX_SHARE);
+		let count = 0;
+		const add = (built) => {
+			const at = this.remap === null ? built : this.remap[built];
+			if (at < 0) return true;
+			if (count === this.found.length) {
+				const next = new Int32Array(count * 2);
+				next.set(this.found);
+				this.found = next;
+			}
+			this.found[count++] = at;
+			return count <= limit;
+		};
+		for (const i of this.always) if (!add(i)) return null;
+		for (let l = 0; l < this.layers.length; l++) {
+			const broad = broads[l];
+			const tree = this.trees.get(this.layers[l]);
+			if (broad === null || tree === void 0) continue;
+			const { x, y, width, height } = broad.box;
+			const k = broad.pxPerWorld;
+			const by = this.maxOutsetPx > 0 && k !== void 0 ? k > 0 ? this.maxOutsetPx / k : Infinity : 0;
+			let over = false;
+			tree.queryBox([
+				x - by,
+				y - by,
+				x + width + by,
+				y + height + by
+			], (i) => {
+				if (add(i)) return true;
+				over = true;
+				return false;
+			});
+			if (over) return null;
+		}
+		return this.readOut(count);
+	}
+	readOut(count) {
+		const { order, found } = this;
+		const out = new Array(count);
+		if (count * 32 < order.length) {
+			const ranks = found.subarray(0, count).sort();
+			for (let i = 0; i < count; i++) out[i] = order[ranks[i]];
+			return out;
+		}
+		const marks = this.marks.length >= order.length ? this.marks : new Uint8Array(order.length);
+		for (let i = 0; i < count; i++) marks[found[i]] = 1;
+		let n = 0;
+		for (let i = 0; n < count && i < order.length; i++) {
+			if (marks[i] === 0) continue;
+			marks[i] = 0;
+			out[n++] = order[i];
+		}
+		return out;
+	}
+};
+function hasCopyingAncestor(parents) {
+	return parents.some((p) => typeof p.copiesFromPose === "function");
+}
+function build(scene, descriptor, order) {
+	builds++;
+	const poseOf = scenePaintedPoseOf(scene);
+	const pathOf = sceneShownPathOf(scene);
+	const parentsOf = sceneParentsOf(scene);
+	const entries = /* @__PURE__ */ new Map();
+	const always = [];
+	let maxOutsetPx = 0;
+	for (let i = 0; i < order.length; i++) {
+		const node = order[i];
+		const parents = parentsOf(node);
+		if (hasCopyingAncestor(parents)) {
+			always.push(i);
+			continue;
+		}
+		const box = [
+			0,
+			0,
+			0,
+			0
+		];
+		let outsetPx;
+		try {
+			const inherited = inheritsPaint(node) ? inheritedPaintOf(node, parents) : void 0;
+			outsetPx = nodeBroadBox(node, poseOf(node), pathOf(node), inherited, descriptor, box);
+		} catch {
+			always.push(i);
+			continue;
+		}
+		if (!Number.isFinite(outsetPx) || !box.every(Number.isFinite)) {
+			always.push(i);
+			continue;
+		}
+		if (outsetPx > maxOutsetPx) maxOutsetPx = outsetPx;
+		let list = entries.get(node.layer);
+		if (list === void 0) entries.set(node.layer, list = []);
+		list.push([i, box]);
+	}
+	const trees = /* @__PURE__ */ new Map();
+	for (const [layer, list] of entries) {
+		const tree = createBvh(2, list);
+		if (tree.size !== list.length) {
+			for (const [i, box] of list) if (!(box[0] <= box[2] && box[1] <= box[3])) always.push(i);
+		}
+		trees.set(layer, tree);
+	}
+	return new BuiltIndex(order, trees, Int32Array.from(always), maxOutsetPx);
+}
+function current(scene, descriptor) {
+	getNodeShapes();
+	const version = scene.getVersion();
+	const overrides = scene.overrides.getGeneration();
+	const memo = nodeMemoGeneration();
+	const markers = markerGeneration();
+	let perScene = CACHE.get(scene);
+	if (perScene === void 0) CACHE.set(scene, perScene = /* @__PURE__ */ new WeakMap());
+	const hit = perScene.get(descriptor);
+	const order = nodesAsShown(scene.overrides, scene.renderOrderNodes());
+	if (hit && hit.version === version && hit.overrides === overrides && hit.memo === memo && hit.markers === markers) {
+		if (hit.index === null) hit.index = build(scene, descriptor, order);
+		else hit.index.rankBy(order);
+		return hit.index;
+	}
+	perScene.set(descriptor, {
+		version,
+		overrides,
+		memo,
+		markers,
+		index: null
+	});
+	return null;
+}
+/** What `PickSource.candidates` answers for a scene source with an index. */
+function indexedCandidates(scene, descriptor, broadFor) {
+	const index = current(scene, descriptor);
+	if (index === null) return null;
+	const broads = [];
+	for (const layer of index.layers) {
+		const broad = broadFor(layer);
+		if (broad === void 0) return null;
+		if (broad !== null && Number.isNaN(broad.box.x + broad.box.y + broad.box.width + broad.box.height)) return null;
+		broads.push(broad);
+	}
+	return index.candidates(broads);
+}
+
+//#endregion
+export { indexedCandidates };
+//# sourceMappingURL=scenePickIndex.js.map

package/dist/canvas/pickIndex/scenePickIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenePickIndex.js","names":[],"sources":["../../../src/canvas/pickIndex/scenePickIndex.ts"],"sourcesContent":["/**\n * The per-scene pick index: one BVH per scene layer over every node's broad\n * box (`nodeBroadBox`), keyed by the node's place in the render order it was\n * built from. A pick after anything it read can have changed walks the scene\n * and only records that state; the next pick to find the scene unchanged\n * builds, so a scene edited before every pick never pays for a build. Nodes it\n * cannot box conservatively are on `always` and are tested by every walk.\n */\nimport { createBvh, type Bvh } from '@weasel-js/geom/nd';\nimport { markerGeneration } from '@weasel-js/stroke';\nimport { getNodeShapes } from 'canvas/NodeShape';\nimport { inheritedPaintOf, inheritsPaint } from 'core/scene/inheritedPaint';\nimport { nodesAsShown } from 'core/scene/nodeAsShown';\nimport { nodeMemoGeneration } from 'core/scene/nodeMemo';\nimport type { Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { scenePaintedPoseOf } from '../derivedPath';\nimport type { PickBroad, PickCandidate } from '../pickWalk';\nimport { sceneParentsOf, sceneShownPathOf } from '../scenePickReads';\nimport { nodeBroadBox, type Box2 } from './nodeBroadBox';\n\ntype AnyScene = Scene<unknown, string, unknown>;\ntype Order = readonly PickCandidate<unknown>[];\n\nexport interface ScenePickIndex {\n  /** The layers holding indexed nodes; `undefined` for nodes with none. */\n  readonly layers: readonly (string | undefined)[];\n  readonly maxOutsetPx: number;\n}\n\nlet builds = 0;\n\n/** How many indexes have been built, for tests that pin when one rebuilds. */\nexport function pickIndexBuildCount(): number {\n  return builds;\n}\n\ninterface Cached {\n  version: number;\n  overrides: number;\n  memo: number;\n  markers: number;\n  /** Null until a second pick finds the same state. */\n  index: BuiltIndex | null;\n}\n\nconst CACHE = new WeakMap<object, WeakMap<PoseDescriptor<unknown>, Cached>>();\n\n/** Past this share of the scene the index costs more than the walk it narrows. */\nconst MAX_SHARE = 0.5;\n\nclass BuiltIndex implements ScenePickIndex {\n  readonly layers: readonly (string | undefined)[];\n  /** The render order the candidates are read out of. */\n  private order: Order;\n  /** Build position to position in `order`, or null while they are the same array. */\n  private remap: Int32Array | null = null;\n  private readonly marks: Uint8Array;\n  private found: Int32Array;\n\n  constructor(\n    private readonly built: Order,\n    private readonly trees: Map<string | undefined, Bvh<number>>,\n    private readonly always: Int32Array,\n    readonly maxOutsetPx: number,\n  ) {\n    this.layers = [...trees.keys()];\n    this.order = built;\n    this.marks = new Uint8Array(built.length);\n    this.found = new Int32Array(Math.max(16, always.length));\n  }\n\n  /** Follow a new render order array the scene hands back for the same state. */\n  rankBy(order: Order): void {\n    if (order === this.order) return;\n    this.order = order;\n    if (order === this.built) {\n      this.remap = null;\n      return;\n    }\n    const rank = new Map<string, number>();\n    for (let i = 0; i < order.length; i++) rank.set(order[i].id, i);\n    const remap = new Int32Array(this.built.length);\n    for (let i = 0; i < remap.length; i++) remap[i] = rank.get(this.built[i].id) ?? -1;\n    this.remap = remap;\n  }\n\n  /** The nodes the boxes reach, in render order, or null when that is most of the scene. */\n  candidates(broads: readonly (PickBroad | null)[]): Order | null {\n    const limit = Math.floor(this.order.length * MAX_SHARE);\n    let count = 0;\n    const add = (built: number): boolean => {\n      const at = this.remap === null ? built : this.remap[built];\n      if (at < 0) return true;\n      if (count === this.found.length) {\n        const next = new Int32Array(count * 2);\n        next.set(this.found);\n        this.found = next;\n      }\n      this.found[count++] = at;\n      return count <= limit;\n    };\n    for (const i of this.always) if (!add(i)) return null;\n    for (let l = 0; l < this.layers.length; l++) {\n      const broad = broads[l];\n      const tree = this.trees.get(this.layers[l]);\n      if (broad === null || tree === undefined) continue;\n      const { x, y, width, height } = broad.box;\n      const k = broad.pxPerWorld;\n      const by = this.maxOutsetPx > 0 && k !== undefined ? (k > 0 ? this.maxOutsetPx / k : Infinity) : 0;\n      let over = false;\n      tree.queryBox([x - by, y - by, x + width + by, y + height + by], (i) => {\n        if (add(i)) return true;\n        over = true;\n        return false;\n      });\n      if (over) return null;\n    }\n    return this.readOut(count);\n  }\n\n  private readOut(count: number): Order {\n    const { order, found } = this;\n    const out: PickCandidate<unknown>[] = new Array(count);\n    // A handful sorts faster than a pass over every mark.\n    if (count * 32 < order.length) {\n      const ranks = found.subarray(0, count).sort();\n      for (let i = 0; i < count; i++) out[i] = order[ranks[i]];\n      return out;\n    }\n    const marks = this.marks.length >= order.length ? this.marks : new Uint8Array(order.length);\n    for (let i = 0; i < count; i++) marks[found[i]] = 1;\n    let n = 0;\n    for (let i = 0; n < count && i < order.length; i++) {\n      if (marks[i] === 0) continue;\n      marks[i] = 0;\n      out[n++] = order[i];\n    }\n    return out;\n  }\n}\n\nfunction hasCopyingAncestor(parents: Order): boolean {\n  return parents.some((p) => typeof p.copiesFromPose === 'function');\n}\n\nfunction build(scene: AnyScene, descriptor: PoseDescriptor<unknown>, order: Order): BuiltIndex {\n  builds++;\n  const poseOf = scenePaintedPoseOf(scene);\n  const pathOf = sceneShownPathOf(scene);\n  const parentsOf = sceneParentsOf(scene);\n  const entries = new Map<string | undefined, [number, Box2][]>();\n  const always: number[] = [];\n  let maxOutsetPx = 0;\n  for (let i = 0; i < order.length; i++) {\n    const node = order[i];\n    const parents = parentsOf(node);\n    // Also hit wherever an ancestor paints a copy of it, which its own box does not cover.\n    if (hasCopyingAncestor(parents)) {\n      always.push(i);\n      continue;\n    }\n    const box: Box2 = [0, 0, 0, 0];\n    let outsetPx: number;\n    try {\n      const inherited = inheritsPaint(node) ? inheritedPaintOf(node, parents) : undefined;\n      outsetPx = nodeBroadBox(node, poseOf(node as never), pathOf(node), inherited, descriptor, box);\n    } catch {\n      always.push(i);\n      continue;\n    }\n    if (!Number.isFinite(outsetPx) || !box.every(Number.isFinite)) {\n      always.push(i);\n      continue;\n    }\n    if (outsetPx > maxOutsetPx) maxOutsetPx = outsetPx;\n    let list = entries.get(node.layer);\n    if (list === undefined) entries.set(node.layer, (list = []));\n    list.push([i, box]);\n  }\n  const trees = new Map<string | undefined, Bvh<number>>();\n  for (const [layer, list] of entries) {\n    const tree = createBvh<number>(2, list);\n    // The tree drops an inverted box: test that node the old way.\n    if (tree.size !== list.length) {\n      for (const [i, box] of list) if (!(box[0] <= box[2] && box[1] <= box[3])) always.push(i);\n    }\n    trees.set(layer, tree);\n  }\n  return new BuiltIndex(order, trees, Int32Array.from(always), maxOutsetPx);\n}\n\n/** The index for `scene` read through `descriptor`, or null when this pick walks instead. */\nexport function scenePickIndex(scene: AnyScene, descriptor: PoseDescriptor<unknown>): ScenePickIndex | null {\n  return current(scene, descriptor);\n}\n\nfunction current(scene: AnyScene, descriptor: PoseDescriptor<unknown>): BuiltIndex | null {\n  // Registers the built-in painters first, which bumps the memo generation.\n  getNodeShapes();\n  const version = scene.getVersion();\n  const overrides = scene.overrides.getGeneration();\n  const memo = nodeMemoGeneration();\n  const markers = markerGeneration();\n  let perScene = CACHE.get(scene);\n  if (perScene === undefined) CACHE.set(scene, (perScene = new WeakMap()));\n  const hit = perScene.get(descriptor);\n  // Boxed as shown, so a data override that grows a node's ink is met where it is painted.\n  const order = nodesAsShown(scene.overrides, scene.renderOrderNodes()) as unknown as Order;\n  if (hit && hit.version === version && hit.overrides === overrides && hit.memo === memo && hit.markers === markers) {\n    if (hit.index === null) hit.index = build(scene, descriptor, order);\n    else hit.index.rankBy(order);\n    return hit.index;\n  }\n  perScene.set(descriptor, { version, overrides, memo, markers, index: null });\n  return null;\n}\n\n/** What `PickSource.candidates` answers for a scene source with an index. */\nexport function indexedCandidates(\n  scene: AnyScene,\n  descriptor: PoseDescriptor<unknown>,\n  broadFor: (layer: string | undefined) => PickBroad | null | undefined,\n): Order | null {\n  const index = current(scene, descriptor);\n  if (index === null) return null;\n  const broads: (PickBroad | null)[] = [];\n  for (const layer of index.layers) {\n    const broad = broadFor(layer);\n    if (broad === undefined) return null;\n    if (broad !== null && Number.isNaN(broad.box.x + broad.box.y + broad.box.width + broad.box.height)) return null;\n    broads.push(broad);\n  }\n  return index.candidates(broads);\n}\n"],"mappings":"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"}

package/dist/canvas/pickReach.js

@@ -11,19 +11,19 @@
 * `copying` says some container in the walk draws copies, otherwise only
 * after the node hits as authored.
 */
-function reaches(node, pose, derived, q, parentsOf, copying, look) {
+function reaches(node, pose, derived, inherited, q, parentsOf, copying, look) {
 	const admits = (query, ancestor) => {
 		const clip = look.clipOf(ancestor);
 		return clip === null || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);
 	};
 	const parents = copying && q.inCopy !== void 0 ? parentsOf() : null;
 	if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {
-		if (!q.hits(node, pose, derived)) return false;
+		if (!q.hits(node, pose, derived, inherited)) return false;
 		return (parents ?? parentsOf()).every((a) => admits(q, a));
 	}
 	const outermostFirst = [...parents].reverse();
 	const from = (i, query) => {
-		if (i === outermostFirst.length) return query.hits(node, pose, derived);
+		if (i === outermostFirst.length) return query.hits(node, pose, derived, inherited);
 		const ancestor = outermostFirst[i];
 		if (admits(query, ancestor) && from(i + 1, query)) return true;
 		for (const m of look.copiesOf(ancestor)) {

package/dist/canvas/pickReach.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickReach.js","names":[],"sources":["../../src/canvas/pickReach.ts"],"sourcesContent":["import type { Affine, Path } from '@weasel-js/geom';\nimport type { PickCandidate, PickQuery } from './pickWalk';\n\n/** What {@link reaches} needs from the walk, each memoized per walk there. */\nexport interface ReachLookups<TPose> {\n  /** An ancestor's own clip, or null. */\n  clipOf(ancestor: PickCandidate<TPose>): Path | null;\n  /** The maps from world into the source frame of each copy `ancestor` draws:\n   *  the inverses of its `copiesFromPose`. Empty when it draws none. */\n  copiesOf(ancestor: PickCandidate<TPose>): readonly Affine[];\n  /** A clip carried from its container's plane into the node's. */\n  carry(clip: Path, fromLayer: string | undefined, toLayer: string | undefined): Path;\n}\n\n/**\n * Whether `q` lands on `node` anywhere it is painted: as authored, or in any\n * copy an ancestor draws of it. `parents` is innermost first.\n *\n * A copy is the clipped content transformed, so the query is carried into the\n * copy's source frame before the copying container's own clip is asked, and\n * every clip below it is asked in that frame too.\n *\n * `parents` is called only when the answer needs it — always when\n * `copying` says some container in the walk draws copies, otherwise only\n * after the node hits as authored.\n */\nexport function reaches<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived: Path | null | undefined,\n  q: PickQuery<TPose>,\n  parentsOf: () => readonly PickCandidate<TPose>[],\n  copying: boolean,\n  look: ReachLookups<TPose>,\n): boolean {\n  const admits = (query: PickQuery<TPose>, ancestor: PickCandidate<TPose>): boolean => {\n    const clip = look.clipOf(ancestor);\n    return clip === null\n      || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);\n  };\n\n  const parents = copying && q.inCopy !== undefined ? parentsOf() : null;\n  if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {\n    if (!q.hits(node, pose, derived)) return false;\n    return (parents ?? parentsOf()).every((a) => admits(q, a));\n  }\n\n  const outermostFirst = [...parents].reverse();\n  const from = (i: number, query: PickQuery<TPose>): boolean => {\n    if (i === outermostFirst.length) return query.hits(node, pose, derived);\n    const ancestor = outermostFirst[i];\n    if (admits(query, ancestor) && from(i + 1, query)) return true;\n    for (const m of look.copiesOf(ancestor)) {\n      const inCopy = query.inCopy?.(m);\n      if (inCopy !== undefined && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;\n    }\n    return false;\n  };\n  return from(0, q);\n}\n"],"mappings":";;;;;;;;;;;;;AA0BA,SAAgB,QACd,MACA,MACA,SACA,GACA,WACA,SACA,MACS;CACT,MAAM,UAAU,OAAyB,aAA4C;EACnF,MAAM,OAAO,KAAK,OAAO,QAAQ;EACjC,OAAO,SAAS,QACX,MAAM,WAAW,KAAK,MAAM,MAAM,SAAS,OAAO,KAAK,KAAK,GAAG,MAAM,MAAM,OAAO;CACzF;CAEA,MAAM,UAAU,WAAW,EAAE,WAAW,SAAY,UAAU,IAAI;CAClE,IAAI,YAAY,QAAQ,CAAC,QAAQ,MAAM,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG;EACzE,IAAI,CAAC,EAAE,KAAK,MAAM,MAAM,OAAO,GAAG,OAAO;EACzC,QAAQ,WAAW,UAAU,EAAA,CAAG,OAAO,MAAM,OAAO,GAAG,CAAC,CAAC;CAC3D;CAEA,MAAM,iBAAiB,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ;CAC5C,MAAM,QAAQ,GAAW,UAAqC;EAC5D,IAAI,MAAM,eAAe,QAAQ,OAAO,MAAM,KAAK,MAAM,MAAM,OAAO;EACtE,MAAM,WAAW,eAAe;EAChC,IAAI,OAAO,OAAO,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,GAAG,OAAO;EAC1D,KAAK,MAAM,KAAK,KAAK,SAAS,QAAQ,GAAG;GACvC,MAAM,SAAS,MAAM,SAAS,CAAC;GAC/B,IAAI,WAAW,UAAa,OAAO,QAAQ,QAAQ,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,OAAO;EACtF;EACA,OAAO;CACT;CACA,OAAO,KAAK,GAAG,CAAC;AAClB"}
+{"version":3,"file":"pickReach.js","names":[],"sources":["../../src/canvas/pickReach.ts"],"sourcesContent":["import type { Affine, Path } from '@weasel-js/geom';\nimport type { PickCandidate, PickQuery } from './pickWalk';\nimport type { InheritedPaint } from 'core/scene/inheritedPaint';\n\n/** What {@link reaches} needs from the walk, each memoized per walk there. */\nexport interface ReachLookups<TPose> {\n  /** An ancestor's own clip, or null. */\n  clipOf(ancestor: PickCandidate<TPose>): Path | null;\n  /** The maps from world into the source frame of each copy `ancestor` draws:\n   *  the inverses of its `copiesFromPose`. Empty when it draws none. */\n  copiesOf(ancestor: PickCandidate<TPose>): readonly Affine[];\n  /** A clip carried from its container's plane into the node's. */\n  carry(clip: Path, fromLayer: string | undefined, toLayer: string | undefined): Path;\n}\n\n/**\n * Whether `q` lands on `node` anywhere it is painted: as authored, or in any\n * copy an ancestor draws of it. `parents` is innermost first.\n *\n * A copy is the clipped content transformed, so the query is carried into the\n * copy's source frame before the copying container's own clip is asked, and\n * every clip below it is asked in that frame too.\n *\n * `parents` is called only when the answer needs it — always when\n * `copying` says some container in the walk draws copies, otherwise only\n * after the node hits as authored.\n */\nexport function reaches<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived: Path | null | undefined,\n  inherited: InheritedPaint | undefined,\n  q: PickQuery<TPose>,\n  parentsOf: () => readonly PickCandidate<TPose>[],\n  copying: boolean,\n  look: ReachLookups<TPose>,\n): boolean {\n  const admits = (query: PickQuery<TPose>, ancestor: PickCandidate<TPose>): boolean => {\n    const clip = look.clipOf(ancestor);\n    return clip === null\n      || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);\n  };\n\n  const parents = copying && q.inCopy !== undefined ? parentsOf() : null;\n  if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {\n    if (!q.hits(node, pose, derived, inherited)) return false;\n    return (parents ?? parentsOf()).every((a) => admits(q, a));\n  }\n\n  const outermostFirst = [...parents].reverse();\n  const from = (i: number, query: PickQuery<TPose>): boolean => {\n    if (i === outermostFirst.length) return query.hits(node, pose, derived, inherited);\n    const ancestor = outermostFirst[i];\n    if (admits(query, ancestor) && from(i + 1, query)) return true;\n    for (const m of look.copiesOf(ancestor)) {\n      const inCopy = query.inCopy?.(m);\n      if (inCopy !== undefined && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;\n    }\n    return false;\n  };\n  return from(0, q);\n}\n"],"mappings":";;;;;;;;;;;;;AA2BA,SAAgB,QACd,MACA,MACA,SACA,WACA,GACA,WACA,SACA,MACS;CACT,MAAM,UAAU,OAAyB,aAA4C;EACnF,MAAM,OAAO,KAAK,OAAO,QAAQ;EACjC,OAAO,SAAS,QACX,MAAM,WAAW,KAAK,MAAM,MAAM,SAAS,OAAO,KAAK,KAAK,GAAG,MAAM,MAAM,OAAO;CACzF;CAEA,MAAM,UAAU,WAAW,EAAE,WAAW,SAAY,UAAU,IAAI;CAClE,IAAI,YAAY,QAAQ,CAAC,QAAQ,MAAM,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG;EACzE,IAAI,CAAC,EAAE,KAAK,MAAM,MAAM,SAAS,SAAS,GAAG,OAAO;EACpD,QAAQ,WAAW,UAAU,EAAA,CAAG,OAAO,MAAM,OAAO,GAAG,CAAC,CAAC;CAC3D;CAEA,MAAM,iBAAiB,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ;CAC5C,MAAM,QAAQ,GAAW,UAAqC;EAC5D,IAAI,MAAM,eAAe,QAAQ,OAAO,MAAM,KAAK,MAAM,MAAM,SAAS,SAAS;EACjF,MAAM,WAAW,eAAe;EAChC,IAAI,OAAO,OAAO,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,GAAG,OAAO;EAC1D,KAAK,MAAM,KAAK,KAAK,SAAS,QAAQ,GAAG;GACvC,MAAM,SAAS,MAAM,SAAS,CAAC;GAC/B,IAAI,WAAW,UAAa,OAAO,QAAQ,QAAQ,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,OAAO;EACtF;EACA,OAAO;CACT;CACA,OAAO,KAAK,GAAG,CAAC;AAClB"}

package/dist/canvas/pickWalk.js

@@ -1,12 +1,8 @@
-import { planeMap } from "../core/viewport/parallax.js";
-import { resolveDerivedPath } from "../core/scene/derivedPath.js";
-import { findShapeSilhouette } from "./NodeShape.js";
+import { inheritedPaintOf, inheritsPaint } from "../core/scene/inheritedPaint.js";
 import { clipCarrier } from "./planeClips.js";
-import { asNodeId } from "../core/scene/types.js";
-import { annotationLayerIds } from "../core/scene/annotation.js";
-import { nodeGates } from "../core/scene/nodeGates.js";
-import { sceneDerivedPathOf, scenePaintedPoseOf, showsComputedPath } from "./derivedPath.js";
+import { ownClipOf } from "./ownClip.js";
 import { reaches } from "./pickReach.js";
+import { scenePickSource, scenePlaneOf } from "./scenePickSource.js";
 import { adapterPickSource } from "./adapterPickSource.js";
 import { invert } from "@weasel-js/geom";
 
@@ -16,7 +12,7 @@ import { invert } from "@weasel-js/geom";
 * query supplies only the shape test and the clip predicate for its own region.
 *
 * The gates, in the order the walk applies them:
-*   1. containers, when the query does not want them
+*   1. groups, when the query does not want them
 *   2. the node is painted at all — not hidden in the scene (`nodeGates`),
 *      and on a layer the asking view's `layerVisibility` / `layerOrder` paints
 *   3. painted alpha is above zero
@@ -28,20 +24,12 @@ import { invert } from "@weasel-js/geom";
 * that skips one answers for a node the user cannot see. 4 is the other axis:
 * a locked node is on screen and still out of reach.
 */
-/** Shared, never mutated: most scenes are flat and every node returns it. */
-var EMPTY_PARENTS = [];
-/** The clip a container imposes on its subtree, or null when it imposes none. */
-function ownClipOf(node, pose, derived) {
-	if (node.kind !== "container") return null;
-	if (typeof node.clipFromPose === "function") return node.clipFromPose(pose);
-	return findShapeSilhouette(node, pose, { derivedPath: derived });
-}
 /**
 * Collect every candidate the query hits, back-to-front — the last element is
 * the topmost, which is the order `pickTopMostHit` expects.
 */
 function pickWalk(src, q) {
-	const includeContainers = q.includeContainers ?? true;
+	const includeGroups = q.includeGroups ?? true;
 	const isLocked = q.includeLocked === true ? void 0 : src.isLocked;
 	const out = [];
 	const clipPath = /* @__PURE__ */ new Map();
@@ -49,7 +37,7 @@ function pickWalk(src, q) {
 	const clipOf = (ancestor) => {
 		const cached = clipPath.get(ancestor.id);
 		if (cached !== void 0) return cached;
-		const resolved = ownClipOf(ancestor, src.poseOf(ancestor), src.derivedPathOf?.(ancestor));
+		const resolved = ownClipOf(ancestor, src.poseOf(ancestor), () => src.derivedPathOf?.(ancestor));
 		clipPath.set(ancestor.id, resolved);
 		return resolved;
 	};
@@ -57,7 +45,7 @@ function pickWalk(src, q) {
 	const copiesOf = (ancestor) => {
 		let found = copyMaps.get(ancestor.id);
 		if (found === void 0) {
-			const fn = ancestor.kind === "container" ? ancestor.copiesFromPose : void 0;
+			const fn = ancestor.copiesFromPose;
 			found = (fn ? fn(src.poseOf(ancestor), ancestor) ?? [] : []).map(invert).filter((m) => m !== null);
 			copyMaps.set(ancestor.id, found);
 		}
@@ -75,9 +63,13 @@ function pickWalk(src, q) {
 		return found;
 	};
 	const order = src.order();
-	const copying = order.some((n) => n.kind === "container" && typeof n.copiesFromPose === "function");
-	for (const node of order) {
-		if (!includeContainers && node.kind === "container") continue;
+	const copying = order.some((n) => typeof n.copiesFromPose === "function");
+	const visit = (q.broad !== void 0 ? src.candidates?.((layer) => {
+		const query = queryFor(layer);
+		return query === null ? null : query.broad;
+	}) : null) ?? order;
+	for (const node of visit) {
+		if (!includeGroups && node.kind === "group") continue;
 		if (node.pickable === false) continue;
 		if (src.isHidden?.(node) === true) continue;
 		if (node.layer !== void 0 && src.layerIsPainted?.(node.layer) === false) continue;
@@ -87,7 +79,8 @@ function pickWalk(src, q) {
 		if (query === null) continue;
 		const pose = src.poseOf(node);
 		const derived = src.derivedPathOf?.(node);
-		if (!reaches(node, pose, derived, query, () => src.parentsOf(node), copying, {
+		const inherited = inheritsPaint(node) ? inheritedPaintOf(node, src.parentsOf(node)) : void 0;
+		if (!reaches(node, pose, derived, inherited, query, () => src.parentsOf(node), copying, {
 			clipOf,
 			copiesOf,
 			carry
@@ -96,74 +89,7 @@ function pickWalk(src, q) {
 	}
 	return out;
 }
-function scenePickSource(scene, opts = {}) {
-	const gates = nodeGates(scene);
-	const annotations = annotationLayerIds(scene.layers);
-	const { getPose, alphaOf, layerIsPainted } = opts;
-	let faded = null;
-	const enumerable = typeof scene.overrides?.ids === "function";
-	if (!alphaOf && enumerable) for (const id of scene.overrides.ids()) {
-		const a = scene.overrides.read(id)?.alpha;
-		if (a !== void 0 && a <= 0) (faded ??= /* @__PURE__ */ new Set()).add(id);
-	}
-	const readAlpha = alphaOf ?? (enumerable ? faded ? (id) => faded.has(id) ? 0 : 1 : void 0 : (id) => scene.overrides.read(asNodeId(id))?.alpha ?? 1);
-	const paintedPoseOf = scenePaintedPoseOf(scene);
-	const poseOf = getPose ? (node) => getPose(node.id) : (node) => paintedPoseOf(node);
-	const childrenOf = (id) => scene.childrenOf(id);
-	const depOf = (id) => {
-		const dep = scene.get(id);
-		if (dep === void 0) return void 0;
-		return {
-			node: dep,
-			pose: poseOf(dep),
-			get path() {
-				return resolveDerivedPath(dep, depOf, childrenOf);
-			}
-		};
-	};
-	const sceneDerivedPath = getPose ? null : sceneDerivedPathOf(scene);
-	const derivedPathOf = (node) => {
-		const n = node;
-		if (!sceneDerivedPath) return n.dependsOn === void 0 ? null : resolveDerivedPath(n, depOf, childrenOf);
-		return showsComputedPath(scene, n) ? sceneDerivedPath(n) : null;
-	};
-	const planeOf = opts.camera ? scenePlaneOf(scene.layers, opts.camera) : null;
-	return {
-		...planeOf ? { planeOf } : {},
-		order: () => scene.renderOrderNodes(),
-		derivedPathOf,
-		poseOf,
-		parentsOf(node) {
-			let parentId = node.parent ?? null;
-			if (parentId === null) return EMPTY_PARENTS;
-			const chain = [];
-			const seen = /* @__PURE__ */ new Set();
-			while (parentId !== null) {
-				if (seen.has(parentId)) break;
-				seen.add(parentId);
-				const parent = scene.get(asNodeId(parentId));
-				if (!parent) break;
-				chain.push(parent);
-				parentId = parent.parent ?? null;
-			}
-			return chain;
-		},
-		...readAlpha ? { alphaOf: readAlpha } : {},
-		isLocked: (node) => gates.locked(node.id),
-		isHidden: (node) => gates.hidden(node.id),
-		...annotations.size > 0 || layerIsPainted ? { layerIsPainted: (layer) => !annotations.has(layer) && (layerIsPainted === void 0 || layerIsPainted(layer)) } : {}
-	};
-}
-/** Each parallax layer's plane map under `camera`, or null when no layer is a
-*  plane — which keeps the per-layer lookup off the walk entirely. */
-function scenePlaneOf(layers, camera) {
-	let maps = null;
-	for (const l of layers ?? []) if (l.parallax) (maps ??= /* @__PURE__ */ new Map()).set(l.id, planeMap(camera, l.parallax));
-	if (maps === null) return null;
-	const found = maps;
-	return (layer) => found.get(layer) ?? null;
-}
 
 //#endregion
-export { adapterPickSource, ownClipOf, pickWalk, scenePickSource, scenePlaneOf };
+export { adapterPickSource, pickWalk, scenePickSource, scenePlaneOf };
 //# sourceMappingURL=pickWalk.js.map

package/dist/canvas/pickWalk.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickWalk.js","names":[],"sources":["../../src/canvas/pickWalk.ts"],"sourcesContent":["/**\n * The one hit-test walk. Everything that decides whether a node *can* be hit lives here; a\n * query supplies only the shape test and the clip predicate for its own region.\n *\n * The gates, in the order the walk applies them:\n *   1. containers, when the query does not want them\n *   2. the node is painted at all — not hidden in the scene (`nodeGates`),\n *      and on a layer the asking view's `layerVisibility` / `layerOrder` paints\n *   3. painted alpha is above zero\n *   4. the node is not locked, unless the query asks for locked nodes\n *   5. the query's own shape test\n *   6. every ancestor clip admits the query region\n *\n * 2, 3 and 6 are all \"the renderer did not put this on screen\". A pick path\n * that skips one answers for a node the user cannot see. 4 is the other axis:\n * a locked node is on screen and still out of reach.\n */\n\nimport { invert, type Affine, type Path } from '@weasel-js/geom';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\nimport type { ClipFromPoseFn, CopiesFromPoseFn, DerivedDep, Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { annotationLayerIds } from 'core/scene/annotation';\nimport { nodeGates } from 'core/scene/nodeGates';\nimport { resolveDerivedPath, sceneDerivedPathOf, scenePaintedPoseOf, showsComputedPath } from './derivedPath';\nimport { planeMap, type ParallaxOpts, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { clipCarrier } from './planeClips';\nimport { reaches } from './pickReach';\n\n/** Shared, never mutated: most scenes are flat and every node returns it. */\nconst EMPTY_PARENTS: readonly never[] = [];\n\n/** The subset of a node the walk itself reads. Deliberately structural: a\n *  bare adapter's node satisfies it as readily as a `SceneNode`. */\nexport interface PickCandidate<TPose> {\n  id: string;\n  kind?: string;\n  layer?: string;\n  pose: TPose;\n  /** `false` makes the node transparent to the walk — see `SceneNode.pickable`. */\n  pickable?: boolean;\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  copiesFromPose?: CopiesFromPoseFn<TPose>;\n}\n\n/**\n * Everything the walk reads that a **view** owns.\n *\n * A layer must not hold state a view owns, so none of these are closed over\n * at construction — each is asked per walk, of the view being dispatched to.\n */\nexport interface PickSource<TPose> {\n  /** Candidates in paint order, back-to-front. Containers included; the\n   *  query decides whether they can be hit. */\n  order(): readonly PickCandidate<TPose>[];\n  /** The pose the renderer draws — override-aware. Not `node.pose`, which is\n   *  how the render and pick paths came to disagree about where a node is. */\n  poseOf(node: PickCandidate<TPose>): TPose;\n  /** Ancestors, innermost first. Only walked for candidates that already\n   *  passed their own shape test. */\n  parentsOf(node: PickCandidate<TPose>): readonly PickCandidate<TPose>[];\n  /** Painted alpha for the asking view: the view's `alphaFor` times any\n   *  per-node override alpha. Omit when the source has no alpha concept. */\n  alphaOf?(id: string): number;\n  /** Whether this layer reaches the screen in the asking view. Omit for a\n   *  source with no layers. */\n  layerIsPainted?(layer: string): boolean;\n  /** Whether the node is locked — painted, but not something a pointer can\n   *  take. Omit for a source with no lock concept. */\n  isLocked?(node: PickCandidate<TPose>): boolean;\n  /** Whether the source hides the node, so nothing of it is on screen. Omit\n   *  for a source that hides nothing. */\n  isHidden?(node: PickCandidate<TPose>): boolean;\n  /** The path a node computes from its dependencies, or null for none. */\n  derivedPathOf?(node: PickCandidate<TPose>): Path | null;\n  /** How the asking view's world maps into a parallax layer's, or null for a\n   *  layer that moves with the camera. Omit for a source with no planes. */\n  planeOf?(layer: string): PlaneMap | null;\n}\n\n/** One hit-test question: what region, and what counts as covering it. */\nexport interface PickQuery<TPose> {\n  /** Default `true`. The area walks exclude containers so a marquee does not\n   *  return a container and its children both. */\n  includeContainers?: boolean;\n  /** Default `false`. Every selecting or editing query passes over locked\n   *  nodes; one that only samples what is painted can take them back. */\n  includeLocked?: boolean;\n  /** Does this node, drawn at this pose, cover the query region? `derived`\n   *  is the node's resolved path when it has one — a derived node's pose is a\n   *  placeholder, so a region test that reads only the pose answers for the\n   *  wrong box. */\n  hits(node: PickCandidate<TPose>, pose: TPose, derived?: Path | null): boolean;\n  /**\n   * Does an ancestor's clip leave anything of `node` for this query to hit?\n   *\n   * A point query asks point-in-clip and ignores the node. An area query has\n   * to ask about the node as well: the clip and the area can overlap where\n   * the node is not, and the node and the clip can overlap where the area is\n   * not, and only the two terms together reject both.\n   */\n  clipAdmits(\n    clip: Path,\n    node: PickCandidate<TPose>,\n    pose: TPose,\n    derived?: Path | null,\n  ): boolean;\n  /** The same question asked in a parallax plane's world: the region carried\n   *  through `map`, and any screen-pixel slop re-derived at the plane's scale.\n   *  A query without it cannot reach nodes on a plane — it would test them\n   *  where their poses sit rather than where they are painted. */\n  inPlane?(map: PlaneMap): PickQuery<TPose>;\n  /** The same question carried by `m`, an affine from world into the source\n   *  frame of a copy a container draws. A query without it cannot reach\n   *  copies — see `ContainerNode.copiesFromPose`. */\n  inCopy?(m: Affine): PickQuery<TPose>;\n}\n\n/** The clip a container imposes on its subtree, or null when it imposes none. */\nexport function ownClipOf<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived?: Path | null,\n): Path | null {\n  if (node.kind !== 'container') return null;\n  if (typeof node.clipFromPose === 'function') return node.clipFromPose(pose);\n  return findShapeSilhouette(\n    node as unknown as Node<unknown, string, TPose>,\n    pose,\n    { derivedPath: derived },\n  );\n}\n\n/**\n * Collect every candidate the query hits, back-to-front — the last element is\n * the topmost, which is the order `pickTopMostHit` expects.\n */\nexport function pickWalk<TPose>(\n  src: PickSource<TPose>,\n  q: PickQuery<TPose>,\n): string[] {\n  const includeContainers = q.includeContainers ?? true;\n  const isLocked = q.includeLocked === true ? undefined : src.isLocked;\n  const out: string[] = [];\n\n  // Resolving a container's clip is the expensive half, so the *path* is memoized per\n  // container for the walk. The predicate re-runs per candidate: caching its answer per\n  // container would answer the wrong question for an area query.\n  const clipPath = new Map<string, Path | null>();\n  // A clip is in its container's plane; the query is in the candidate's.\n  const carry = clipCarrier(src.planeOf ?? null);\n\n  const clipOf = (ancestor: PickCandidate<TPose>): Path | null => {\n    const cached = clipPath.get(ancestor.id);\n    if (cached !== undefined) return cached;\n    const resolved = ownClipOf(\n      ancestor, src.poseOf(ancestor), src.derivedPathOf?.(ancestor),\n    );\n    clipPath.set(ancestor.id, resolved);\n    return resolved;\n  };\n\n  const copyMaps = new Map<string, readonly Affine[]>();\n  const copiesOf = (ancestor: PickCandidate<TPose>): readonly Affine[] => {\n    let found = copyMaps.get(ancestor.id);\n    if (found === undefined) {\n      const fn = ancestor.kind === 'container' ? ancestor.copiesFromPose : undefined;\n      const copies = fn ? fn(src.poseOf(ancestor), ancestor as never) ?? [] : [];\n      found = copies.map(invert).filter((m): m is Affine => m !== null);\n      copyMaps.set(ancestor.id, found);\n    }\n    return found;\n  };\n\n  // One reprojected query per plane per walk; `null` marks a plane this\n  // query cannot reach.\n  const planeQueries = new Map<string, PickQuery<TPose> | null>();\n  const queryFor = (layer: string | undefined): PickQuery<TPose> | null => {\n    if (layer === undefined || src.planeOf === undefined) return q;\n    let found = planeQueries.get(layer);\n    if (found === undefined) {\n      const map = src.planeOf(layer);\n      found = map === null ? q : (q.inPlane?.(map) ?? null);\n      planeQueries.set(layer, found);\n    }\n    return found;\n  };\n\n  const order = src.order();\n  const copying = order.some((n) => n.kind === 'container' && typeof n.copiesFromPose === 'function');\n  for (const node of order) {\n    if (!includeContainers && node.kind === 'container') continue;\n    // Transparent to picking: the click belongs to whatever is behind it,\n    // which for a label inside a box is the box.\n    if (node.pickable === false) continue;\n    if (src.isHidden?.(node) === true) continue;\n    if (node.layer !== undefined && src.layerIsPainted?.(node.layer) === false) continue;\n    if (src.alphaOf !== undefined && src.alphaOf(node.id) <= 0) continue;\n    if (isLocked !== undefined && isLocked(node)) continue;\n\n    const query = queryFor(node.layer);\n    if (query === null) continue;\n    const pose = src.poseOf(node);\n    const derived = src.derivedPathOf?.(node);\n    if (!reaches(node, pose, derived, query, () => src.parentsOf(node), copying, { clipOf, copiesOf, carry })) continue;\n    out.push(node.id);\n  }\n\n  return out;\n}\n\n/**\n * The two answers a pick needs from the view it is asked for rather than from\n * the data behind it: how that view paints a node, and whether it paints a\n * layer at all. A scene and a bare adapter take the same pair.\n */\nexport interface ViewPickGates {\n  /** Painted alpha: the view's `alphaFor` times any per-node override alpha.\n   *  A node painted at alpha 0 cannot be hit. */\n  alphaOf?: (id: string) => number;\n  /** Whether a node's `layer` reaches the screen in the asking view. */\n  layerIsPainted?: (layer: string) => boolean;\n}\n\n/** The gates a bare adapter takes from its view, plus how that view's camera\n *  maps into each parallax layer — see `scenePlaneOf`. */\nexport interface AdapterPickGates extends ViewPickGates {\n  planeOf?: (layer: string) => PlaneMap | null;\n}\n\nexport interface ScenePickSourceOptions<TPose> extends ViewPickGates {\n  /** Pose lookup, when the caller holds an adapter that already resolves\n   *  overrides. Defaults to `effectivePose` against the scene's own. */\n  getPose?: (id: string) => TPose;\n  /** The asking view's composed alpha — `alphaFor(id)` times override alpha.\n   *  Defaults to the override alpha alone, which is all a bare scene knows. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\",\n   *  which is `layerVisibility` and `layerOrder` on top of the scene's own\n   *  `visible` flag. Consulted after the scene's flag, never instead of it. */\n  layerIsPainted?: (layer: string) => boolean;\n  /** The asking view's camera. With it, a layer carrying `parallax` is picked\n   *  through its plane; without it, every layer is taken to move with the\n   *  camera. */\n  camera?: View;\n}\n\nexport function scenePickSource<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: ScenePickSourceOptions<TPose> = {},\n): PickSource<TPose> {\n  // Partial scene stand-ins carry only `layers` and `get`, which is all the gates read.\n  const gates = nodeGates(scene as never);\n  const annotations = annotationLayerIds(scene.layers);\n  const { getPose, alphaOf, layerIsPainted } = opts;\n\n  // Resolved once per walk rather than once per candidate. Needs enumeration — a\n  // partial scene stand-in carrying only `read` falls back to reading per node.\n  let faded: Set<string> | null = null;\n  const enumerable = typeof scene.overrides?.ids === 'function';\n  if (!alphaOf && enumerable) {\n    for (const id of scene.overrides.ids()) {\n      const a = scene.overrides.read(id)?.alpha;\n      if (a !== undefined && a <= 0) (faded ??= new Set()).add(id);\n    }\n  }\n  const readAlpha = alphaOf\n    ?? (enumerable\n      ? (faded ? (id: string) => (faded.has(id) ? 0 : 1) : undefined)\n      : (id: string) => scene.overrides.read(asNodeId(id))?.alpha ?? 1);\n\n  // A composing strategy makes a node's own pose local, so picking folds the\n  // parent chain the same way the render walk does: one definition of both.\n  const paintedPoseOf = scenePaintedPoseOf(scene);\n  const poseOf = getPose\n    ? (node: PickCandidate<TPose>) => getPose(node.id)\n    : (node: PickCandidate<TPose>) => paintedPoseOf(node as never);\n\n  // Through `poseOf`, not the document pose: a derived node has to be tested\n  // where the renderer draws its dependencies, which is what an override says.\n  const childrenOf = (id: NodeId): readonly NodeId[] => scene.childrenOf(id);\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const dep = scene.get(id);\n    if (dep === undefined) return undefined;\n    return {\n      node: dep as Node<unknown, string, TPose>,\n      pose: poseOf(dep as never),\n      get path(): Path | null {\n        return resolveDerivedPath(dep as never, depOf, childrenOf);\n      },\n    };\n  };\n\n  const sceneDerivedPath = getPose ? null : sceneDerivedPathOf(scene);\n  const derivedPathOf = (node: PickCandidate<TPose>): Path | null => {\n    const n = node as unknown as Node<TData, TLayer, TPose>;\n    if (!sceneDerivedPath) return n.dependsOn === undefined ? null : resolveDerivedPath(n, depOf, childrenOf);\n    return showsComputedPath(scene, n) ? sceneDerivedPath(n) : null;\n  };\n\n  const planeOf = opts.camera ? scenePlaneOf(scene.layers, opts.camera) : null;\n\n  return {\n    ...(planeOf ? { planeOf } : {}),\n    order: () => scene.renderOrderNodes() as unknown as readonly PickCandidate<TPose>[],\n    derivedPathOf,\n    poseOf,\n    parentsOf(node) {\n      let parentId = (node as { parent?: string | null }).parent ?? null;\n      if (parentId === null) return EMPTY_PARENTS;\n      const chain: PickCandidate<TPose>[] = [];\n      const seen = new Set<string>();\n      while (parentId !== null) {\n        if (seen.has(parentId)) break;\n        seen.add(parentId);\n        const parent = scene.get(asNodeId(parentId));\n        if (!parent) break;\n        chain.push(parent as unknown as PickCandidate<TPose>);\n        parentId = parent.parent ?? null;\n      }\n      return chain;\n    },\n    // Absent entirely when nothing is faded, so the walk skips the gate.\n    ...(readAlpha ? { alphaOf: readAlpha } : {}),\n    isLocked: (node: PickCandidate<TPose>) => gates.locked(node.id),\n    isHidden: (node: PickCandidate<TPose>) => gates.hidden(node.id),\n    ...(annotations.size > 0 || layerIsPainted\n      ? {\n        layerIsPainted: (layer: string) =>\n          !annotations.has(layer) && (layerIsPainted === undefined || layerIsPainted(layer)),\n      }\n      : {}),\n  };\n}\n\n/** Each parallax layer's plane map under `camera`, or null when no layer is a\n *  plane — which keeps the per-layer lookup off the walk entirely. */\nexport function scenePlaneOf(\n  layers: readonly { id: string; parallax?: ParallaxOpts }[] | undefined,\n  camera: View,\n): ((layer: string) => PlaneMap | null) | null {\n  let maps: Map<string, PlaneMap> | null = null;\n  for (const l of layers ?? []) {\n    if (l.parallax) (maps ??= new Map()).set(l.id, planeMap(camera, l.parallax));\n  }\n  if (maps === null) return null;\n  const found = maps;\n  return (layer) => found.get(layer) ?? null;\n}\n\nexport { adapterPickSource } from './adapterPickSource';\n"],"mappings":"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"}
+{"version":3,"file":"pickWalk.js","names":[],"sources":["../../src/canvas/pickWalk.ts"],"sourcesContent":["/**\n * The one hit-test walk. Everything that decides whether a node *can* be hit lives here; a\n * query supplies only the shape test and the clip predicate for its own region.\n *\n * The gates, in the order the walk applies them:\n *   1. groups, when the query does not want them\n *   2. the node is painted at all — not hidden in the scene (`nodeGates`),\n *      and on a layer the asking view's `layerVisibility` / `layerOrder` paints\n *   3. painted alpha is above zero\n *   4. the node is not locked, unless the query asks for locked nodes\n *   5. the query's own shape test\n *   6. every ancestor clip admits the query region\n *\n * 2, 3 and 6 are all \"the renderer did not put this on screen\". A pick path\n * that skips one answers for a node the user cannot see. 4 is the other axis:\n * a locked node is on screen and still out of reach.\n */\n\nimport { invert, type Affine, type Path } from '@weasel-js/geom';\nimport type { CopiesFromPoseFn } from 'core/scene/types';\nimport { ownClipOf, type ClipBearing } from './ownClip';\nimport { inheritedPaintOf, inheritsPaint, type InheritedPaint } from 'core/scene/inheritedPaint';\nimport { rectToPlane, type PlaneMap } from 'core/viewport/parallax';\nimport { clipCarrier } from './planeClips';\nimport { reaches } from './pickReach';\n\n/** The subset of a node the walk itself reads. Deliberately structural: a\n *  bare adapter's node satisfies it as readily as a `SceneNode`. */\nexport interface PickCandidate<TPose> extends ClipBearing<TPose> {\n  id: string;\n  kind?: string;\n  layer?: string;\n  pose: TPose;\n  /** `false` makes the node transparent to the walk — see `SceneNode.pickable`. */\n  pickable?: boolean;\n  /** Read for an `'inherit'` fill or stroke, which takes its containers'. */\n  data?: unknown;\n  copiesFromPose?: CopiesFromPoseFn<TPose>;\n}\n\n/**\n * Everything the walk reads that a **view** owns.\n *\n * A layer must not hold state a view owns, so none of these are closed over\n * at construction — each is asked per walk, of the view being dispatched to.\n */\nexport interface PickSource<TPose> {\n  /** Candidates in paint order, back-to-front. Containers included; the\n   *  query decides whether they can be hit. */\n  order(): readonly PickCandidate<TPose>[];\n  /** The pose the renderer draws — override-aware. Not `node.pose`, which is\n   *  how the render and pick paths came to disagree about where a node is. */\n  poseOf(node: PickCandidate<TPose>): TPose;\n  /** Ancestors, innermost first. Only walked for candidates that already\n   *  passed their own shape test. */\n  parentsOf(node: PickCandidate<TPose>): readonly PickCandidate<TPose>[];\n  /** Painted alpha for the asking view: the view's `alphaFor` times any\n   *  per-node override alpha. Omit when the source has no alpha concept. */\n  alphaOf?(id: string): number;\n  /** Whether this layer reaches the screen in the asking view. Omit for a\n   *  source with no layers. */\n  layerIsPainted?(layer: string): boolean;\n  /** Whether the node is locked — painted, but not something a pointer can\n   *  take. Omit for a source with no lock concept. */\n  isLocked?(node: PickCandidate<TPose>): boolean;\n  /** Whether the source hides the node, so nothing of it is on screen. Omit\n   *  for a source that hides nothing. */\n  isHidden?(node: PickCandidate<TPose>): boolean;\n  /** The path a node computes from its dependencies, or null for none. */\n  derivedPathOf?(node: PickCandidate<TPose>): Path | null;\n  /** How the asking view's world maps into a parallax layer's, or null for a\n   *  layer that moves with the camera. Omit for a source with no planes. */\n  planeOf?(layer: string): PlaneMap | null;\n  /**\n   * The candidates a query with these broad boxes can hit, back-to-front: a\n   * subset of `order()` that drops only nodes no query inside the box could\n   * hit. `broadFor(layer)` is the box for that layer's query: `null` for a\n   * layer it cannot reach, `undefined` for one with no box, which makes this\n   * answer `null` and the walk visit `order()`. Omit for a source with no index.\n   */\n  candidates?(\n    broadFor: (layer: string | undefined) => PickBroad | null | undefined,\n  ): readonly PickCandidate<TPose>[] | null;\n}\n\n/** The box a query cannot hit outside of, for a source's index to look up. */\nexport interface PickBroad {\n  /** World box, already grown by the query's own slop. */\n  box: { x: number; y: number; width: number; height: number };\n  /** Screen px per world unit at the asking view (least axis); grows the box\n   *  by the largest `outsetPx` the index holds. Omit for a query whose test\n   *  reads no `outsetPx`. */\n  pxPerWorld?: number;\n}\n\n/** `broad` carried into a plane's world, as `inPlane` carries the query. */\nexport function broadInPlane(broad: PickBroad, m: PlaneMap): PickBroad {\n  const box = rectToPlane(m, broad.box);\n  if (broad.pxPerWorld === undefined) return { box };\n  // A plane's pixel is the same on screen, so its world unit holds fewer of them.\n  const k = Math.max(Math.abs(m.scale.x), Math.abs(m.scale.y));\n  return { box, pxPerWorld: broad.pxPerWorld / k };\n}\n\n/** One hit-test question: what region, and what counts as covering it. */\nexport interface PickQuery<TPose> {\n  /** Default `true`. The area walks exclude groups so a marquee does not\n   *  return a group and its members both. */\n  includeGroups?: boolean;\n  /** Default `false`. Every selecting or editing query passes over locked\n   *  nodes; one that only samples what is painted can take them back. */\n  includeLocked?: boolean;\n  /** Where the query can hit at all, for a source with an index. `inPlane`\n   *  carries it with the query; without it the walk visits every node. */\n  broad?: PickBroad;\n  /** Does this node, drawn at this pose, cover the query region? `derived`\n   *  is the node's resolved path when it has one — a derived node's pose is a\n   *  placeholder, so a region test that reads only the pose answers for the\n   *  wrong box. `inherited` is what its `'inherit'` fields take from its\n   *  containers, for the ink it is tested against; absent when it inherits\n   *  nothing. */\n  hits(node: PickCandidate<TPose>, pose: TPose, derived?: Path | null, inherited?: InheritedPaint): boolean;\n  /**\n   * Does an ancestor's clip leave anything of `node` for this query to hit?\n   *\n   * A point query asks point-in-clip and ignores the node. An area query has\n   * to ask about the node as well: the clip and the area can overlap where\n   * the node is not, and the node and the clip can overlap where the area is\n   * not, and only the two terms together reject both.\n   */\n  clipAdmits(\n    clip: Path,\n    node: PickCandidate<TPose>,\n    pose: TPose,\n    derived?: Path | null,\n  ): boolean;\n  /** The same question asked in a parallax plane's world: the region carried\n   *  through `map`, and any screen-pixel slop re-derived at the plane's scale.\n   *  A query without it cannot reach nodes on a plane — it would test them\n   *  where their poses sit rather than where they are painted. */\n  inPlane?(map: PlaneMap): PickQuery<TPose>;\n  /** The same question carried by `m`, an affine from world into the source\n   *  frame of a copy a container draws. A query without it cannot reach\n   *  copies — see `GroupNode.copiesFromPose`. */\n  inCopy?(m: Affine): PickQuery<TPose>;\n}\n\n/**\n * Collect every candidate the query hits, back-to-front — the last element is\n * the topmost, which is the order `pickTopMostHit` expects.\n */\nexport function pickWalk<TPose>(\n  src: PickSource<TPose>,\n  q: PickQuery<TPose>,\n): string[] {\n  const includeGroups = q.includeGroups ?? true;\n  const isLocked = q.includeLocked === true ? undefined : src.isLocked;\n  const out: string[] = [];\n\n  // Resolving a container's clip is the expensive half, so the *path* is memoized per\n  // container for the walk. The predicate re-runs per candidate: caching its answer per\n  // container would answer the wrong question for an area query.\n  const clipPath = new Map<string, Path | null>();\n  // A clip is in its container's plane; the query is in the candidate's.\n  const carry = clipCarrier(src.planeOf ?? null);\n\n  const clipOf = (ancestor: PickCandidate<TPose>): Path | null => {\n    const cached = clipPath.get(ancestor.id);\n    if (cached !== undefined) return cached;\n    const resolved = ownClipOf(\n      ancestor, src.poseOf(ancestor), () => src.derivedPathOf?.(ancestor),\n    );\n    clipPath.set(ancestor.id, resolved);\n    return resolved;\n  };\n\n  const copyMaps = new Map<string, readonly Affine[]>();\n  const copiesOf = (ancestor: PickCandidate<TPose>): readonly Affine[] => {\n    let found = copyMaps.get(ancestor.id);\n    if (found === undefined) {\n      const fn = ancestor.copiesFromPose;\n      const copies = fn ? fn(src.poseOf(ancestor), ancestor as never) ?? [] : [];\n      found = copies.map(invert).filter((m): m is Affine => m !== null);\n      copyMaps.set(ancestor.id, found);\n    }\n    return found;\n  };\n\n  // One reprojected query per plane per walk; `null` marks a plane this\n  // query cannot reach.\n  const planeQueries = new Map<string, PickQuery<TPose> | null>();\n  const queryFor = (layer: string | undefined): PickQuery<TPose> | null => {\n    if (layer === undefined || src.planeOf === undefined) return q;\n    let found = planeQueries.get(layer);\n    if (found === undefined) {\n      const map = src.planeOf(layer);\n      found = map === null ? q : (q.inPlane?.(map) ?? null);\n      planeQueries.set(layer, found);\n    }\n    return found;\n  };\n\n  const order = src.order();\n  const copying = order.some((n) => typeof n.copiesFromPose === 'function');\n  const visit = (q.broad !== undefined ? src.candidates?.((layer) => {\n    const query = queryFor(layer);\n    return query === null ? null : query.broad;\n  }) : null) ?? order;\n  for (const node of visit) {\n    if (!includeGroups && node.kind === 'group') continue;\n    // Transparent to picking: the click belongs to whatever is behind it,\n    // which for a label inside a box is the box.\n    if (node.pickable === false) continue;\n    if (src.isHidden?.(node) === true) continue;\n    if (node.layer !== undefined && src.layerIsPainted?.(node.layer) === false) continue;\n    if (src.alphaOf !== undefined && src.alphaOf(node.id) <= 0) continue;\n    if (isLocked !== undefined && isLocked(node)) continue;\n\n    const query = queryFor(node.layer);\n    if (query === null) continue;\n    const pose = src.poseOf(node);\n    const derived = src.derivedPathOf?.(node);\n    const inherited = inheritsPaint(node) ? inheritedPaintOf(node, src.parentsOf(node)) : undefined;\n    if (!reaches(node, pose, derived, inherited, query, () => src.parentsOf(node), copying, { clipOf, copiesOf, carry })) continue;\n    out.push(node.id);\n  }\n\n  return out;\n}\n\n/**\n * The two answers a pick needs from the view it is asked for rather than from\n * the data behind it: how that view paints a node, and whether it paints a\n * layer at all. A scene and a bare adapter take the same pair.\n */\nexport interface ViewPickGates {\n  /** Painted alpha: the view's `alphaFor` times any per-node override alpha.\n   *  A node painted at alpha 0 cannot be hit. */\n  alphaOf?: (id: string) => number;\n  /** Whether a node's `layer` reaches the screen in the asking view. */\n  layerIsPainted?: (layer: string) => boolean;\n}\n\n/** The gates a bare adapter takes from its view, plus how that view's camera\n *  maps into each parallax layer — see `scenePlaneOf`. */\nexport interface AdapterPickGates extends ViewPickGates {\n  planeOf?: (layer: string) => PlaneMap | null;\n}\n\nexport { scenePickSource, scenePlaneOf, type ScenePickSourceOptions } from './scenePickSource';\nexport { adapterPickSource } from './adapterPickSource';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,SAAgB,SACd,KACA,GACU;CACV,MAAM,gBAAgB,EAAE,iBAAiB;CACzC,MAAM,WAAW,EAAE,kBAAkB,OAAO,SAAY,IAAI;CAC5D,MAAM,MAAgB,CAAC;CAKvB,MAAM,2BAAW,IAAI,IAAyB;CAE9C,MAAM,QAAQ,YAAY,IAAI,WAAW,IAAI;CAE7C,MAAM,UAAU,aAAgD;EAC9D,MAAM,SAAS,SAAS,IAAI,SAAS,EAAE;EACvC,IAAI,WAAW,QAAW,OAAO;EACjC,MAAM,WAAW,UACf,UAAU,IAAI,OAAO,QAAQ,SAAS,IAAI,gBAAgB,QAAQ,CACpE;EACA,SAAS,IAAI,SAAS,IAAI,QAAQ;EAClC,OAAO;CACT;CAEA,MAAM,2BAAW,IAAI,IAA+B;CACpD,MAAM,YAAY,aAAsD;EACtE,IAAI,QAAQ,SAAS,IAAI,SAAS,EAAE;EACpC,IAAI,UAAU,QAAW;GACvB,MAAM,KAAK,SAAS;GAEpB,SADe,KAAK,GAAG,IAAI,OAAO,QAAQ,GAAG,QAAiB,KAAK,CAAC,IAAI,CAAC,EACjE,CAAO,IAAI,MAAM,CAAC,CAAC,QAAQ,MAAmB,MAAM,IAAI;GAChE,SAAS,IAAI,SAAS,IAAI,KAAK;EACjC;EACA,OAAO;CACT;CAIA,MAAM,+BAAe,IAAI,IAAqC;CAC9D,MAAM,YAAY,UAAuD;EACvE,IAAI,UAAU,UAAa,IAAI,YAAY,QAAW,OAAO;EAC7D,IAAI,QAAQ,aAAa,IAAI,KAAK;EAClC,IAAI,UAAU,QAAW;GACvB,MAAM,MAAM,IAAI,QAAQ,KAAK;GAC7B,QAAQ,QAAQ,OAAO,IAAK,EAAE,UAAU,GAAG,KAAK;GAChD,aAAa,IAAI,OAAO,KAAK;EAC/B;EACA,OAAO;CACT;CAEA,MAAM,QAAQ,IAAI,MAAM;CACxB,MAAM,UAAU,MAAM,MAAM,MAAM,OAAO,EAAE,mBAAmB,UAAU;CACxE,MAAM,SAAS,EAAE,UAAU,SAAY,IAAI,cAAc,UAAU;EACjE,MAAM,QAAQ,SAAS,KAAK;EAC5B,OAAO,UAAU,OAAO,OAAO,MAAM;CACvC,CAAC,IAAI,SAAS;CACd,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,CAAC,iBAAiB,KAAK,SAAS,SAAS;EAG7C,IAAI,KAAK,aAAa,OAAO;EAC7B,IAAI,IAAI,WAAW,IAAI,MAAM,MAAM;EACnC,IAAI,KAAK,UAAU,UAAa,IAAI,iBAAiB,KAAK,KAAK,MAAM,OAAO;EAC5E,IAAI,IAAI,YAAY,UAAa,IAAI,QAAQ,KAAK,EAAE,KAAK,GAAG;EAC5D,IAAI,aAAa,UAAa,SAAS,IAAI,GAAG;EAE9C,MAAM,QAAQ,SAAS,KAAK,KAAK;EACjC,IAAI,UAAU,MAAM;EACpB,MAAM,OAAO,IAAI,OAAO,IAAI;EAC5B,MAAM,UAAU,IAAI,gBAAgB,IAAI;EACxC,MAAM,YAAY,cAAc,IAAI,IAAI,iBAAiB,MAAM,IAAI,UAAU,IAAI,CAAC,IAAI;EACtF,IAAI,CAAC,QAAQ,MAAM,MAAM,SAAS,WAAW,aAAa,IAAI,UAAU,IAAI,GAAG,SAAS;GAAE;GAAQ;GAAU;EAAM,CAAC,GAAG;EACtH,IAAI,KAAK,KAAK,EAAE;CAClB;CAEA,OAAO;AACT"}

package/dist/canvas/poseCascade.js

@@ -42,7 +42,7 @@ function containerCascade(scene, id, d, write) {
 function cascadingSetPose(scene, d) {
 	return (id, pose) => {
 		const node = scene.get(id);
-		if (!node || node.kind !== "container") return scene.setPose(id, pose);
+		if (!node || node.kind !== "group") return scene.setPose(id, pose);
 		const g = poseDescriptorForNode(d, node);
 		const from = g.getBounds(node.pose);
 		const to = g.getBounds(pose);