@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/pathOverlay.js

@@ -0,0 +1,63 @@
+import { createEmitter } from "@weasel-js/registry";
+
+//#region src/canvas/pathOverlay.ts
+/**
+* The kit's roles: `'chrome'` for a path shown for reference, `'picked'` for
+* one a gesture has taken, and `'remove'` for one it would delete.
+*/
+var PATH_OVERLAY_ROLES = {
+	chrome: {
+		fill: { color: "rgba(164, 139, 212, 0.18)" },
+		stroke: { color: "#a48bd4" }
+	},
+	picked: {
+		fill: { color: "rgba(164, 139, 212, 0.45)" },
+		stroke: { color: "#7d5fc0" }
+	},
+	remove: {
+		fill: { color: "rgba(226, 59, 59, 0.35)" },
+		stroke: { color: "#e23b3b" }
+	}
+};
+/** A store of transient paths and the layer that draws it; hand the layer to
+*  a tool's `overlay` or a canvas's `layers`. */
+function createPathOverlay({ id, label = "Transient paths", roles }) {
+	const styles = {
+		...PATH_OVERLAY_ROLES,
+		...roles
+	};
+	const changed = createEmitter();
+	let current = [];
+	const set = (paths) => {
+		if (paths.length === 0 && current.length === 0) return;
+		current = paths;
+		changed.emit();
+	};
+	return {
+		get: () => current,
+		set,
+		clear: () => set([]),
+		layer: {
+			id,
+			label,
+			space: "world",
+			subscribe: changed.subscribe,
+			draw: () => current.map(({ path, role = "chrome" }) => {
+				const style = styles[role] ?? styles["chrome"];
+				return {
+					kind: "path",
+					path,
+					...style.fill ? { fill: { paint: style.fill } } : {},
+					...style.stroke ? { stroke: {
+						paint: style.stroke,
+						width: { px: 1 }
+					} } : {}
+				};
+			})
+		}
+	};
+}
+
+//#endregion
+export { PATH_OVERLAY_ROLES, createPathOverlay };
+//# sourceMappingURL=pathOverlay.js.map

package/dist/canvas/pathOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathOverlay.js","names":[],"sources":["../../src/canvas/pathOverlay.ts"],"sourcesContent":["/**\n * Paths that are no node, drawn over the scene: a region a tool would take,\n * the result an operation would make before it is applied.\n */\nimport type { Path } from '@weasel-js/geom';\nimport type { CommandPaint } from '@weasel-js/paint';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { OverlayRole } from '@weasel-js/routing';\nimport { createEmitter } from '@weasel-js/registry';\nimport type { RenderLayer } from 'core/layers/render';\n\n/** One path to draw, in world coordinates, and what it is. */\nexport interface TransientPath {\n  path: Path;\n  /** Omitted reads as `'chrome'`. */\n  role?: OverlayRole;\n}\n\n/** How one role reads. The stroke is one screen pixel wide at any zoom. */\nexport interface PathOverlayStyle {\n  fill?: CommandPaint;\n  stroke?: CommandPaint;\n}\n\n/**\n * The kit's roles: `'chrome'` for a path shown for reference, `'picked'` for\n * one a gesture has taken, and `'remove'` for one it would delete.\n */\nexport const PATH_OVERLAY_ROLES: Readonly<Record<string, PathOverlayStyle>> = {\n  chrome: { fill: { color: 'rgba(164, 139, 212, 0.18)' }, stroke: { color: '#a48bd4' } },\n  picked: { fill: { color: 'rgba(164, 139, 212, 0.45)' }, stroke: { color: '#7d5fc0' } },\n  remove: { fill: { color: 'rgba(226, 59, 59, 0.35)' }, stroke: { color: '#e23b3b' } },\n};\n\n/** The paths an overlay holds, and the layer that draws them. */\nexport interface PathOverlay {\n  get(): readonly TransientPath[];\n  /** Replace every path. */\n  set(paths: readonly TransientPath[]): void;\n  clear(): void;\n  /** A world-space layer drawing the paths in order, repainting on each change. */\n  layer: RenderLayer<unknown>;\n}\n\n/** Options for {@link createPathOverlay}. */\nexport interface PathOverlayOptions {\n  /** The layer's id; see `RenderLayer.id`. */\n  id: string;\n  label?: string;\n  /** Styles per role, merged over {@link PATH_OVERLAY_ROLES}. A role with\n   *  none paints as `'chrome'`. */\n  roles?: Readonly<Record<string, PathOverlayStyle>>;\n}\n\n/** A store of transient paths and the layer that draws it; hand the layer to\n *  a tool's `overlay` or a canvas's `layers`. */\nexport function createPathOverlay({ id, label = 'Transient paths', roles }: PathOverlayOptions): PathOverlay {\n  const styles = { ...PATH_OVERLAY_ROLES, ...roles };\n  const changed = createEmitter();\n  let current: readonly TransientPath[] = [];\n  const set = (paths: readonly TransientPath[]): void => {\n    if (paths.length === 0 && current.length === 0) return;\n    current = paths;\n    changed.emit();\n  };\n  return {\n    get: () => current,\n    set,\n    clear: () => set([]),\n    layer: {\n      id,\n      label,\n      space: 'world',\n      subscribe: changed.subscribe,\n      draw: () =>\n        current.map(({ path, role = 'chrome' }): DrawCommand => {\n          const style = styles[role] ?? styles['chrome']!;\n          return {\n            kind: 'path',\n            path,\n            ...(style.fill ? { fill: { paint: style.fill } } : {}),\n            ...(style.stroke ? { stroke: { paint: style.stroke, width: { px: 1 } } } : {}),\n          };\n        }),\n    },\n  };\n}\n"],"mappings":";;;;;;;AA4BA,IAAa,qBAAiE;CAC5E,QAAQ;EAAE,MAAM,EAAE,OAAO,4BAA4B;EAAG,QAAQ,EAAE,OAAO,UAAU;CAAE;CACrF,QAAQ;EAAE,MAAM,EAAE,OAAO,4BAA4B;EAAG,QAAQ,EAAE,OAAO,UAAU;CAAE;CACrF,QAAQ;EAAE,MAAM,EAAE,OAAO,0BAA0B;EAAG,QAAQ,EAAE,OAAO,UAAU;CAAE;AACrF;;;AAwBA,SAAgB,kBAAkB,EAAE,IAAI,QAAQ,mBAAmB,SAA0C;CAC3G,MAAM,SAAS;EAAE,GAAG;EAAoB,GAAG;CAAM;CACjD,MAAM,UAAU,cAAc;CAC9B,IAAI,UAAoC,CAAC;CACzC,MAAM,OAAO,UAA0C;EACrD,IAAI,MAAM,WAAW,KAAK,QAAQ,WAAW,GAAG;EAChD,UAAU;EACV,QAAQ,KAAK;CACf;CACA,OAAO;EACL,WAAW;EACX;EACA,aAAa,IAAI,CAAC,CAAC;EACnB,OAAO;GACL;GACA;GACA,OAAO;GACP,WAAW,QAAQ;GACnB,YACE,QAAQ,KAAK,EAAE,MAAM,OAAO,eAA4B;IACtD,MAAM,QAAQ,OAAO,SAAS,OAAO;IACrC,OAAO;KACL,MAAM;KACN;KACA,GAAI,MAAM,OAAO,EAAE,MAAM,EAAE,OAAO,MAAM,KAAK,EAAE,IAAI,CAAC;KACpD,GAAI,MAAM,SAAS,EAAE,QAAQ;MAAE,OAAO,MAAM;MAAQ,OAAO,EAAE,IAAI,EAAE;KAAE,EAAE,IAAI,CAAC;IAC9E;GACF,CAAC;EACL;CACF;AACF"}

package/dist/canvas/pickReach.js

@@ -1,23 +1,40 @@
 //#region src/canvas/pickReach.ts
-function e(e, t, n, r, i, a, o) {
-	let s = (r, i) => {
-		let a = o.clipOf(i);
-		return a === null || r.clipAdmits(o.carry(a, i.layer, e.layer), e, t, n);
-	}, c = a && r.inCopy !== void 0 ? i() : null;
-	if (c === null || !c.some((e) => o.copiesOf(e).length > 0)) return r.hits(e, t, n) ? (c ?? i()).every((e) => s(r, e)) : !1;
-	let l = [...c].reverse(), u = (r, i) => {
-		if (r === l.length) return i.hits(e, t, n);
-		let a = l[r];
-		if (s(i, a) && u(r + 1, i)) return !0;
-		for (let e of o.copiesOf(a)) {
-			let t = i.inCopy?.(e);
-			if (t !== void 0 && s(t, a) && u(r + 1, t)) return !0;
+/**
+* Whether `q` lands on `node` anywhere it is painted: as authored, or in any
+* copy an ancestor draws of it. `parents` is innermost first.
+*
+* A copy is the clipped content transformed, so the query is carried into the
+* copy's source frame before the copying container's own clip is asked, and
+* every clip below it is asked in that frame too.
+*
+* `parents` is called only when the answer needs it — always when
+* `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) {
+	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;
+		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);
+		const ancestor = outermostFirst[i];
+		if (admits(query, ancestor) && from(i + 1, query)) return true;
+		for (const m of look.copiesOf(ancestor)) {
+			const inCopy = query.inCopy?.(m);
+			if (inCopy !== void 0 && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;
 		}
-		return !1;
+		return false;
 	};
-	return u(0, r);
+	return from(0, q);
 }
-//#endregion
-export { e as reaches };
 
+//#endregion
+export { reaches };
 //# sourceMappingURL=pickReach.js.map

package/dist/canvas/pickReach.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickReach.js","names":["reaches","admits","clip","look","ancestor","query","node","pose","derived","parents","copying","q","parentsOf","a","outermostFirst","from","i","m","inCopy"],"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,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAMC,KAAU,GAAyB,MAA4C;EACnF,IAAMC,IAAOC,EAAK,OAAOC,CAAQ;EACjC,OAAOF,MAAS,QACXG,EAAM,WAAWF,EAAK,MAAMD,GAAME,EAAS,OAAOE,EAAK,KAAK,GAAGA,GAAMC,GAAMC,CAAO;CACzF,GAEMC,IAAUC,KAAWC,EAAE,WAAW,KAAA,IAAYC,EAAU,IAAI;CAClE,IAAIH,MAAY,QAAQ,CAACA,EAAQ,MAAM,MAAMN,EAAK,SAASU,CAAC,CAAC,CAAC,SAAS,CAAC,GAEtE,OADKF,EAAE,KAAKL,GAAMC,GAAMC,CAAO,KACvBC,KAAWG,EAAU,EAAA,CAAG,OAAO,MAAMX,EAAOU,GAAGE,CAAC,CAAC,IADhB;CAI3C,IAAMC,IAAiB,CAAC,GAAGL,CAAO,CAAC,CAAC,QAAQ,GACtCM,KAAQ,GAAW,MAAqC;EAC5D,IAAIC,MAAMF,EAAe,QAAQ,OAAOT,EAAM,KAAKC,GAAMC,GAAMC,CAAO;EACtE,IAAMJ,IAAWU,EAAeE;EAChC,IAAIf,EAAOI,GAAOD,CAAQ,KAAKW,EAAKC,IAAI,GAAGX,CAAK,GAAG,OAAO;EAC1D,KAAK,IAAMY,KAAKd,EAAK,SAASC,CAAQ,GAAG;GACvC,IAAMc,IAASb,EAAM,SAASY,CAAC;GAC/B,IAAIC,MAAW,KAAA,KAAajB,EAAOiB,GAAQd,CAAQ,KAAKW,EAAKC,IAAI,GAAGE,CAAM,GAAG,OAAO;EACtF;EACA,OAAO;CACT;CACA,OAAOH,EAAK,GAAGJ,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';\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"}

package/dist/canvas/pickWalk.js

@@ -1,120 +1,169 @@
-import { planeMap as e } from "../core/viewport/parallax.js";
-import { resolveDerivedPath as t } from "../core/scene/derivedPath.js";
-import { clipCarrier as n } from "./planeClips.js";
-import { findShapeSilhouette as r } from "./NodeShape.js";
-import { asNodeId as i } from "../core/scene/types.js";
-import { sceneDerivedPathOf as a, scenePaintedPoseOf as o, showsComputedPath as s } from "./derivedPath.js";
-import { reaches as c } from "./pickReach.js";
-import { adapterPickSource as l } from "./adapterPickSource.js";
-import { invert as u } from "@weasel-js/geom";
+import { planeMap } from "../core/viewport/parallax.js";
+import { resolveDerivedPath } from "../core/scene/derivedPath.js";
+import { findShapeSilhouette } from "./NodeShape.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 { reaches } from "./pickReach.js";
+import { adapterPickSource } from "./adapterPickSource.js";
+import { invert } from "@weasel-js/geom";
+
 //#region src/canvas/pickWalk.ts
-var d = [];
-function f(e, t, n) {
-	return e.kind === "container" ? typeof e.clipFromPose == "function" ? e.clipFromPose(t) : r(e, t, { derivedPath: n }) : null;
+/**
+* The one hit-test walk. Everything that decides whether a node *can* be hit lives here; a
+* 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
+*   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
+*   4. the node is not locked, unless the query asks for locked nodes
+*   5. the query's own shape test
+*   6. every ancestor clip admits the query region
+*
+* 2, 3 and 6 are all "the renderer did not put this on screen". A pick path
+* 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 });
 }
-function p(e, t) {
-	let r = t.includeContainers ?? !0, i = t.includeLocked === !0 ? void 0 : e.isLocked, a = [], o = /* @__PURE__ */ new Map(), s = n(e.planeOf ?? null), l = (t) => {
-		let n = o.get(t.id);
-		if (n !== void 0) return n;
-		let r = f(t, e.poseOf(t), e.derivedPathOf?.(t));
-		return o.set(t.id, r), r;
-	}, d = /* @__PURE__ */ new Map(), p = (t) => {
-		let n = d.get(t.id);
-		if (n === void 0) {
-			let r = t.kind === "container" ? t.copiesFromPose : void 0;
-			n = (r ? r(e.poseOf(t), t) ?? [] : []).map(u).filter((e) => e !== null), d.set(t.id, n);
-		}
-		return n;
-	}, m = /* @__PURE__ */ new Map(), h = (n) => {
-		if (n === void 0 || e.planeOf === void 0) return t;
-		let r = m.get(n);
-		if (r === void 0) {
-			let i = e.planeOf(n);
-			r = i === null ? t : t.inPlane?.(i) ?? null, m.set(n, r);
+/**
+* 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 isLocked = q.includeLocked === true ? void 0 : src.isLocked;
+	const out = [];
+	const clipPath = /* @__PURE__ */ new Map();
+	const carry = clipCarrier(src.planeOf ?? null);
+	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));
+		clipPath.set(ancestor.id, resolved);
+		return resolved;
+	};
+	const copyMaps = /* @__PURE__ */ new Map();
+	const copiesOf = (ancestor) => {
+		let found = copyMaps.get(ancestor.id);
+		if (found === void 0) {
+			const fn = ancestor.kind === "container" ? ancestor.copiesFromPose : void 0;
+			found = (fn ? fn(src.poseOf(ancestor), ancestor) ?? [] : []).map(invert).filter((m) => m !== null);
+			copyMaps.set(ancestor.id, found);
 		}
-		return r;
-	}, g = e.order(), _ = g.some((e) => e.kind === "container" && typeof e.copiesFromPose == "function");
-	for (let t of g) {
-		if (!r && t.kind === "container" || t.pickable === !1 || t.layer !== void 0 && e.layerIsPainted?.(t.layer) === !1 || e.alphaOf !== void 0 && e.alphaOf(t.id) <= 0 || i !== void 0 && i(t)) continue;
-		let n = h(t.layer);
-		if (n === null) continue;
-		let o = e.poseOf(t), u = e.derivedPathOf?.(t);
-		c(t, o, u, n, () => e.parentsOf(t), _, {
-			clipOf: l,
-			copiesOf: p,
-			carry: s
-		}) && a.push(t.id);
-	}
-	return a;
-}
-function m(e) {
-	let t = null;
-	for (let n of e.layers ?? []) n.locked === !0 && (t ??= /* @__PURE__ */ new Set()).add(n.id);
-	if (t === null) return null;
-	let n = t;
-	return (t) => {
-		let r = e.get(i(t)), a = /* @__PURE__ */ new Set();
-		for (; r !== void 0 && !a.has(r.id);) {
-			if (n.has(r.layer)) return !0;
-			a.add(r.id), r = r.parent === null ? void 0 : e.get(r.parent);
+		return found;
+	};
+	const planeQueries = /* @__PURE__ */ new Map();
+	const queryFor = (layer) => {
+		if (layer === void 0 || src.planeOf === void 0) return q;
+		let found = planeQueries.get(layer);
+		if (found === void 0) {
+			const map = src.planeOf(layer);
+			found = map === null ? q : q.inPlane?.(map) ?? null;
+			planeQueries.set(layer, found);
 		}
-		return !1;
+		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;
+		if (node.pickable === false) continue;
+		if (src.isHidden?.(node) === true) continue;
+		if (node.layer !== void 0 && src.layerIsPainted?.(node.layer) === false) continue;
+		if (src.alphaOf !== void 0 && src.alphaOf(node.id) <= 0) continue;
+		if (isLocked !== void 0 && isLocked(node)) continue;
+		const query = queryFor(node.layer);
+		if (query === null) continue;
+		const pose = src.poseOf(node);
+		const derived = src.derivedPathOf?.(node);
+		if (!reaches(node, pose, derived, query, () => src.parentsOf(node), copying, {
+			clipOf,
+			copiesOf,
+			carry
+		})) continue;
+		out.push(node.id);
+	}
+	return out;
 }
-function h(e) {
-	let t = /* @__PURE__ */ new Set();
-	for (let n of e ?? []) n.visible === !1 && t.add(n.id);
-	return t;
-}
-function g(e, n = {}) {
-	let r = h(e.layers), c = m(e), { getPose: l, alphaOf: u, layerIsPainted: f } = n, p = null, g = typeof e.overrides?.ids == "function";
-	if (!u && g) for (let t of e.overrides.ids()) {
-		let n = e.overrides.read(t)?.alpha;
-		n !== void 0 && n <= 0 && (p ??= /* @__PURE__ */ new Set()).add(t);
+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);
 	}
-	let v = u ?? (g ? p ? (e) => +!p.has(e) : void 0 : (t) => e.overrides.read(i(t))?.alpha ?? 1), y = o(e), b = l ? (e) => l(e.id) : (e) => y(e), x = (t) => e.childrenOf(t), S = (n) => {
-		let r = e.get(n);
-		if (r !== void 0) return {
-			node: r,
-			pose: b(r),
+	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 t(r, S, x);
+				return resolveDerivedPath(dep, depOf, childrenOf);
 			}
 		};
-	}, C = l ? null : a(e), w = (n) => {
-		let r = n;
-		return C ? s(e, r) ? C(r) : null : r.dependsOn === void 0 ? null : t(r, S, x);
-	}, T = n.camera ? _(e.layers, n.camera) : null;
+	};
+	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 {
-		...T ? { planeOf: T } : {},
-		order: () => e.renderOrderNodes(),
-		derivedPathOf: w,
-		poseOf: b,
-		parentsOf(t) {
-			let n = t.parent ?? null;
-			if (n === null) return d;
-			let r = [], a = /* @__PURE__ */ new Set();
-			for (; n !== null && !a.has(n);) {
-				a.add(n);
-				let t = e.get(i(n));
-				if (!t) break;
-				r.push(t), n = t.parent ?? null;
+		...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 r;
+			return chain;
 		},
-		...v ? { alphaOf: v } : {},
-		...c ? { isLocked: (e) => c(e.id) } : {},
-		...r.size > 0 || f ? { layerIsPainted: (e) => !r.has(e) && (f === void 0 || f(e)) } : {}
+		...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)) } : {}
 	};
 }
-function _(t, n) {
-	let r = null;
-	for (let i of t ?? []) i.parallax && (r ??= /* @__PURE__ */ new Map()).set(i.id, e(n, i.parallax));
-	if (r === null) return null;
-	let i = r;
-	return (e) => i.get(e) ?? null;
+/** 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 { l as adapterPickSource, h as hiddenLayerIds, f as ownClipOf, p as pickWalk, g as scenePickSource, _ as scenePlaneOf };
 
+//#endregion
+export { adapterPickSource, ownClipOf, pickWalk, scenePickSource, scenePlaneOf };
 //# sourceMappingURL=pickWalk.js.map

package/dist/canvas/pickWalk.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickWalk.js","names":["EMPTY_PARENTS","ownClipOf","node","pose","findShapeSilhouette","derived","pickWalk","includeContainers","q","isLocked","src","out","clipPath","carry","clipCarrier","clipOf","cached","ancestor","resolved","copyMaps","copiesOf","found","fn","invert","m","planeQueries","queryFor","layer","map","order","copying","n","query","reaches","lockedNodeTest","locked","scene","lockedLayers","cur","asNodeId","id","seen","hiddenLayerIds","layers","scenePickSource","hidden","opts","faded","enumerable","alphaOf","a","readAlpha","paintedPoseOf","scenePaintedPoseOf","poseOf","getPose","childrenOf","depOf","dep","resolveDerivedPath","sceneDerivedPath","sceneDerivedPathOf","derivedPathOf","showsComputedPath","planeOf","scenePlaneOf","parentId","chain","parent","layerIsPainted","maps","l","planeMap","camera","adapterPickSource"],"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 layer is painted at all — scene visibility, and the asking view's\n *      `layerVisibility` / `layerOrder`\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 { 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  /** 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 (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/** Answers `Scene.isLocked` from the layer records and parent links alone,\n *  so a partial scene stand-in works too. Null when nothing is locked, which\n *  is what keeps the gate off the walk in the common case. */\nfunction lockedNodeTest(\n  scene: Pick<Scene<unknown, string, unknown>, 'layers' | 'get'>,\n): ((id: string) => boolean) | null {\n  let locked: Set<string> | null = null;\n  for (const layer of scene.layers ?? []) {\n    if (layer.locked === true) (locked ??= new Set()).add(layer.id);\n  }\n  if (locked === null) return null;\n  const lockedLayers = locked;\n  return (id) => {\n    let cur = scene.get(asNodeId(id));\n    const seen = new Set<string>();\n    while (cur !== undefined && !seen.has(cur.id)) {\n      if (lockedLayers.has(cur.layer)) return true;\n      seen.add(cur.id);\n      cur = cur.parent === null ? undefined : scene.get(cur.parent);\n    }\n    return false;\n  };\n}\n\n/** Layer ids the scene reports as hidden. Only an explicit `false` hides a\n *  layer: a partial scene stand-in that omits the flag stays pickable. */\nexport function hiddenLayerIds(\n  layers: readonly { id: string; visible?: boolean }[] | undefined,\n): Set<string> {\n  const out = new Set<string>();\n  for (const layer of layers ?? []) {\n    if (layer.visible === false) out.add(layer.id);\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  const hidden = hiddenLayerIds(scene.layers);\n  const locked = lockedNodeTest(scene as never);\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    ...(locked ? { isLocked: (node: PickCandidate<TPose>) => locked(node.id) } : {}),\n    ...(hidden.size > 0 || layerIsPainted\n      ? {\n        layerIsPainted: (layer: string) =>\n          !hidden.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. 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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"}

package/dist/canvas/planeClips.js

@@ -1,29 +1,46 @@
-import { planeMatrix as e, planeToPlane as t } from "../core/viewport/parallax.js";
-import { mat3 as n, transformPath as r } from "@weasel-js/geom";
+import { planeMatrix, planeToPlane } from "../core/viewport/parallax.js";
+import { mat3, transformPath } from "@weasel-js/geom";
+
 //#region src/canvas/planeClips.ts
-function i(n) {
-	if (n === null) return (e) => e;
-	let i = (e) => e === void 0 ? null : n(e), a = /* @__PURE__ */ new WeakMap();
-	return (n, o, s) => {
-		let c = i(s), l = t(i(o), c);
-		if (l === null) return n;
-		let u = a.get(n);
-		u === void 0 && a.set(n, u = /* @__PURE__ */ new Map());
-		let d = u.get(c);
-		return d === void 0 && u.set(c, d = r(n, e(l))), d;
+/**
+* Carries a container's clip into the world a descendant is drawn or picked
+* in. A clip is built from the container's pose, so it is in the container's
+* plane; a child on another plane reads it in its own. Null `planeOf` means no
+* layer is a plane, and every clip passes through untouched.
+*
+* Memoized per clip path and target plane, so a container with many children
+* on one other plane maps its clip once.
+*/
+function clipCarrier(planeOf) {
+	if (planeOf === null) return (clip) => clip;
+	const mapOf = (layer) => layer === void 0 ? null : planeOf(layer);
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (clip, fromLayer, toLayer) => {
+		const to = mapOf(toLayer);
+		const m = planeToPlane(mapOf(fromLayer), to);
+		if (m === null) return clip;
+		let byTarget = cache.get(clip);
+		if (byTarget === void 0) cache.set(clip, byTarget = /* @__PURE__ */ new Map());
+		let out = byTarget.get(to);
+		if (out === void 0) byTarget.set(to, out = transformPath(clip, planeMatrix(m)));
+		return out;
 	};
 }
-function a(r, i) {
-	let a = t(r, i);
-	return a === null ? void 0 : n.fromAffine(e(a));
+/** The group transform that draws `from`'s world inside `to`'s, where `null`
+*  is the camera's. Undefined when they are the same world. */
+function planeTransform(from, to) {
+	const m = planeToPlane(from, to);
+	return m === null ? void 0 : mat3.fromAffine(planeMatrix(m));
 }
-function o(n, i) {
-	let a = n;
-	if (i === null || !a || a.kind !== "polygon" && a.kind !== "rect") return n;
-	let o = t(i, null);
-	return o === null ? n : r(n, e(o));
+/** A path in a plane's world, in the camera's. Anything that is not a path
+*  passes through. */
+function pathFromPlane(path, m) {
+	const p = path;
+	if (m === null || !p || p.kind !== "polygon" && p.kind !== "rect") return path;
+	const back = planeToPlane(m, null);
+	return back === null ? path : transformPath(path, planeMatrix(back));
 }
-//#endregion
-export { i as clipCarrier, o as pathFromPlane, a as planeTransform };
 
+//#endregion
+export { clipCarrier, pathFromPlane, planeTransform };
 //# sourceMappingURL=planeClips.js.map