@weasel-js/core 1.9.4 → 1.10.0

package/dist/core/scene/layoutPass.js

@@ -1,12 +1,12 @@
-import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, rebaseLocalPose as n } from "./composeFrame.js";
-import { samePoseValue as r } from "./poseSnapshot.js";
-import { definesFrame as i, documentPose as a } from "./effectivePose.js";
-import { asRectPose as o } from "./kitRegistry.js";
+import { composeWorldPose as e, rebaseLocalPose as t } from "./composeFrame.js";
+import { samePoseValue as n } from "./poseSnapshot.js";
+import { definesFrame as r, documentPose as i } from "./effectivePose.js";
+import { asRectPose as a } from "./kitRegistry.js";
 //#region src/core/scene/layoutPass.ts
-function s(t) {
+function o(e) {
 	return {
-		bounds: t?.bounds ?? ((e) => {
-			let t = o(e);
+		bounds: e?.bounds ?? ((e) => {
+			let t = a(e);
 			return t === null ? null : {
 				x: t.x,
 				y: t.y,
@@ -14,83 +14,82 @@ function s(t) {
 				height: t.height
 			};
 		}),
-		remap: t?.remap ?? ((e, t, n) => ({
+		remap: e?.remap ?? ((e, t, n) => ({
 			...e,
 			...n
-		})),
-		composition: t?.composition ?? e
+		}))
 	};
 }
-function c(e, t, n, r) {
+function s(e, t, n, r) {
 	let i = e.bounds(n, t), a = e.bounds(r, t);
 	return i === null || a === null ? i !== a : i.width !== a.width || i.height !== a.height;
 }
-var l = 16;
-function u(e, o, s, u, d, f = /* @__PURE__ */ new Map()) {
-	let p = /* @__PURE__ */ new Map(), m = (t) => p.get(t) ?? a(e, e.get(t)), h = {
+var c = 16;
+function l(a, o, l, u, d, f = /* @__PURE__ */ new Map()) {
+	let p = /* @__PURE__ */ new Map(), m = (e) => p.get(e) ?? i(a, a.get(e)), h = {
 		getPose: (e) => m(e),
-		getParent: (t) => e.get(t)?.parent ?? null,
-		definesFrame: (t) => {
-			let n = e.get(t);
-			return n === void 0 || i(n);
+		getParent: (e) => a.get(e)?.parent ?? null,
+		definesFrame: (e) => {
+			let t = a.get(e);
+			return t === void 0 || r(t);
 		}
-	}, { compose: g, decompose: _ } = d.composition, v = (e) => t(h, e, g), y = [.../* @__PURE__ */ new Set([...s.keys(), ...u])], b = /* @__PURE__ */ new Map(), x = (t, n) => {
-		let i = e.get(t), a = m(t);
-		r(a, n) || (p.set(t, n), t !== S && i.kind === "container" && o(t) !== null && c(d, t, a, n) && y.push(t));
-	}, S = null, C = (t) => {
-		let n = v(t), r = d.bounds(n, t);
-		if (r === null) return null;
-		let i = e.childrenOf(t).map((e) => ({
+	}, { compose: g, decompose: _ } = a.composition, v = (t) => e(h, t, g), y = [.../* @__PURE__ */ new Set([...l.keys(), ...u])], b = /* @__PURE__ */ new Map(), x = (e, t) => {
+		let r = a.get(e), i = m(e);
+		n(i, t) || (p.set(e, t), e !== S && r.kind === "container" && o(e) !== null && s(d, e, i, t) && y.push(e));
+	}, S = null, C = (e) => {
+		let t = v(e), n = d.bounds(t, e);
+		if (n === null) return null;
+		let r = a.childrenOf(e).map((e) => ({
 			id: e,
 			pose: v(e)
 		}));
 		return {
-			world: n,
+			world: t,
 			container: {
-				id: t,
-				bounds: r
+				id: e,
+				bounds: n
 			},
-			children: i
+			children: r
 		};
-	}, w = (t, r, i) => {
-		if (i.bounds) {
-			let a = e.get(t), o = d.remap(r.world, r.container.bounds, i.bounds, t);
-			x(t, n(h, o, a.parent, g, _));
+	}, w = (e, n, r) => {
+		if (r.bounds) {
+			let i = a.get(e), o = d.remap(n.world, n.container.bounds, r.bounds, e);
+			x(e, t(h, o, i.parent, g, _));
 		}
-		for (let [r, a] of i.poses) {
-			let i = r;
-			e.get(i)?.parent === t && x(i, n(h, a, t, g, _));
+		for (let [n, i] of r.poses) {
+			let r = n;
+			a.get(r)?.parent === e && x(r, t(h, i, e, g, _));
 		}
 	};
 	for (; y.length > 0;) {
-		let t = y.shift();
-		S = t;
-		let n = (b.get(t) ?? 0) + 1;
-		if (b.set(t, n), n > l) continue;
-		let r = o(t);
-		if (r === null || e.get(t) === void 0) continue;
-		let i = n === 1 ? s.get(t) : void 0, a = n === 1 ? f.get(t) : void 0, c = !1;
-		if (a !== void 0 && r.depart) {
-			let e = C(t);
-			if (e === null) continue;
-			let n = new Set(i ?? []), o = e.children.filter((e) => !n.has(e.id));
-			w(t, e, r.depart(e.container, o, new Set(a))), c = !0;
+		let e = y.shift();
+		S = e;
+		let t = (b.get(e) ?? 0) + 1;
+		if (b.set(e, t), t > c) continue;
+		let n = o(e);
+		if (n === null || a.get(e) === void 0) continue;
+		let r = t === 1 ? l.get(e) : void 0, i = t === 1 ? f.get(e) : void 0, s = !1;
+		if (i !== void 0 && n.depart) {
+			let t = C(e);
+			if (t === null) continue;
+			let a = new Set(r ?? []), o = t.children.filter((e) => !a.has(e.id));
+			w(e, t, n.depart(t.container, o, new Set(i))), s = !0;
 		}
-		if (i !== void 0 && r.arrive) {
-			let e = C(t);
-			if (e === null) continue;
-			let n = r.arrive(e.container, e.children, new Set(i));
-			if (n === null) return null;
-			w(t, e, n);
-		} else if (!c || i !== void 0) {
-			let e = C(t);
-			if (e === null) continue;
-			w(t, e, { poses: r.childPoses(e.container, e.children) });
+		if (r !== void 0 && n.arrive) {
+			let t = C(e);
+			if (t === null) continue;
+			let i = n.arrive(t.container, t.children, new Set(r));
+			if (i === null) return null;
+			w(e, t, i);
+		} else if (!s || r !== void 0) {
+			let t = C(e);
+			if (t === null) continue;
+			w(e, t, { poses: n.childPoses(t.container, t.children) });
 		}
 	}
 	return p;
 }
 //#endregion
-export { c as resized, s as resolveLayoutFrame, u as runLayoutPass };
+export { s as resized, o as resolveLayoutFrame, l as runLayoutPass };
 
 //# sourceMappingURL=layoutPass.js.map

package/dist/core/scene/layoutPass.js.map

@@ -1 +1 @@
-{"version":3,"file":"layoutPass.js","names":["resolveLayoutFrame","frame","r","asRectPose","pose","to","IDENTITY_POSE_COMPOSITION","resized","a","from","id","b","MAX_PASSES","runLayoutPass","out","poseOf","documentPose","source","pa","node","definesFrame","world","composeWorldPose","compose","queue","arrivals","changed","passes","write","before","samePoseValue","current","layoutOf","frameOf","containerId","bounds","children","cid","apply","result","sized","at","rebaseLocalPose","decompose","layout","joined","left","departures","arranged","joinedSet","staying","c"],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, or gained or lost children with neither hook — is put back in its\n * resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n  composition: PoseComposition<TPose>;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n    composition: frame?.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = frame.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n    }\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":"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"}
+{"version":3,"file":"layoutPass.js","names":["resolveLayoutFrame","frame","r","asRectPose","pose","to","resized","a","from","id","b","MAX_PASSES","runLayoutPass","out","poseOf","documentPose","source","pa","node","definesFrame","world","composeWorldPose","compose","queue","arrivals","changed","passes","write","before","samePoseValue","current","layoutOf","frameOf","containerId","bounds","children","cid","apply","result","sized","at","rebaseLocalPose","decompose","n","layout","joined","left","departures","arranged","joinedSet","staying","c"],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, or gained or lost children with neither hook — is put back in its\n * resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n  readonly composition: PoseComposition<TPose>;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = source.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n    }\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":"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"}

package/dist/{features/groups → core/scene}/nestedHit.js

@@ -1,7 +1,7 @@
 import { worldPoseLookup as e } from "./composePose.js";
-import { poseDescriptorForNode as t } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-//#region src/features/groups/nestedHit.ts
+import { poseDescriptorForNode as t } from "../geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as n } from "../geometry/autoPoseDescriptor.js";
+//#region src/core/scene/nestedHit.ts
 function r(r, i) {
 	let a = i.poseDescriptor ?? n, o = i.isGroup ?? (() => !1), s = e(r, i.composePose), c = (e) => {
 		let t = [], n = e;

package/dist/core/scene/nestedHit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestedHit.js","names":["nestedHitTester","d","opts","AUTO_POSE_DESCRIPTOR","isGroup","worldOf","worldPoseLookup","adapter","ancestorChain","chain","cur","id","hitLeaf","objs","i","o","w","b","poseDescriptorForNode","wx","wy","leaf","alt","selection"],"sources":["../../../src/core/scene/nestedHit.ts"],"sourcesContent":["import { worldPoseLookup } from 'core/scene/composePose';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\n\n/** @internal */\ninterface HitAdapter<TNode extends { id: string }, TPose> {\n  getNode: (id: string) => TNode | undefined;\n  getNodes: () => TNode[];\n  getPose: (id: string) => TPose;\n  getParent: (id: string) => string | null;\n}\n\n/** Options for `nestedHitTester`. */\nexport interface NestedHitOpts<TNode extends { id: string }, TPose> {\n  /** Compose a child's local pose into world coords given its parent's world\n   *  pose. Same shape as `composeRectPose` (the default expectation). */\n  composePose: (parent: TPose, child: TPose) => TPose;\n  /** How to read world poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Predicate for \"this object is a nesting parent body\". The leaf scan\n   *  skips objects for which this returns true so a click on a parent's\n   *  painted body resolves to a child leaf, not the parent itself. Default:\n   *  never (treat every object as hittable). */\n  isGroup?: (id: string, obj: TNode | undefined) => boolean;\n}\n\n/** Hit-test entry points for a nested scene: one that always picks the\n *  outermost ancestor, and one that steps deeper on alt-click. */\nexport interface NestedHitTester {\n  /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a\n   *  casual click selects the whole top-level ancestor. Returns `null` on\n   *  empty space. */\n  pickOutermost: (worldX: number, worldY: number) => string | null;\n  /** Alt-aware selection-update pick. Without `alt`, returns the outermost\n   *  ancestor (same as `pickOutermost`). With `alt`, returns one level\n   *  deeper than the deepest currently-selected ancestor in the leaf's\n   *  chain — repeated alt-clicks step ancestor → descendant → leaf. With\n   *  `alt` and nothing in the chain selected, jumps straight to the leaf.\n   *  Plug into `useSelectTool({ pickBest })`. */\n  pickBest: (\n    worldX: number,\n    worldY: number,\n    alt: boolean,\n    selection: readonly string[],\n  ) => string | null;\n}\n\n/** Build hit-testers that respect containers: a plain click selects the\n *  top-level ancestor, and alt-clicking descends one level at a time toward\n *  the leaf actually under the pointer. */\nexport function nestedHitTester<TNode extends { id: string }, TPose>(\n  adapter: HitAdapter<TNode, TPose>,\n  opts: NestedHitOpts<TNode, TPose>,\n): NestedHitTester {\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const isGroup = opts.isGroup ?? (() => false);\n  const worldOf = worldPoseLookup(adapter, opts.composePose);\n\n  const ancestorChain = (id: string): string[] => {\n    const chain: string[] = [];\n    let cur: string | null = id;\n    while (cur !== null) {\n      chain.unshift(cur);\n      cur = adapter.getParent(cur);\n    }\n    return chain;\n  };\n\n  const hitLeaf = (wx: number, wy: number): string | null => {\n    const objs = adapter.getNodes();\n    for (let i = objs.length - 1; i >= 0; i--) {\n      const o = objs[i];\n      if (isGroup(o.id, o)) continue;\n      const w = worldOf(o.id);\n      if (!w) continue;\n      const b = poseDescriptorForNode(d, o).getBounds(w);\n      if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) {\n        return o.id;\n      }\n    }\n    return null;\n  };\n\n  const pickOutermost = (wx: number, wy: number): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    return leaf === null ? null : ancestorChain(leaf)[0];\n  };\n\n  const pickBest = (\n    wx: number,\n    wy: number,\n    alt: boolean,\n    selection: readonly string[],\n  ): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    if (leaf === null) return null;\n    const chain = ancestorChain(leaf);\n    if (!alt) return chain[0];\n    for (let i = chain.length - 1; i >= 0; i--) {\n      if (selection.includes(chain[i])) {\n        return chain[Math.min(i + 1, chain.length - 1)];\n      }\n    }\n    return chain[chain.length - 1];\n  };\n\n  return { pickOutermost, pickBest };\n}\n"],"mappings":";;;;AAkDA,SAAgBA,EACd,GACA,GACiB;CACjB,IAAMC,IAAKC,EAAK,kBAAkBC,GAC5BC,IAAUF,EAAK,kBAAkB,KACjCG,IAAUC,EAAgBC,GAASL,EAAK,WAAW,GAEnDM,KAAiB,MAAyB;EAC9C,IAAMC,IAAkB,CAAC,GACrBC,IAAqBC;EACzB,OAAOD,MAAQ,OAEb,AADAD,EAAM,QAAQC,CAAG,GACjB,IAAMH,EAAQ,UAAUG,CAAG;EAE7B,OAAOD;CACT,GAEMG,KAAW,GAAY,MAA8B;EACzD,IAAMC,IAAON,EAAQ,SAAS;EAC9B,KAAK,IAAIO,IAAID,EAAK,SAAS,GAAGC,KAAK,GAAG,KAAK;GACzC,IAAMC,IAAIF,EAAKC;GACf,IAAIV,EAAQW,EAAE,IAAIA,CAAC,GAAG;GACtB,IAAMC,IAAIX,EAAQU,EAAE,EAAE;GACtB,IAAI,CAACC,GAAG;GACR,IAAMC,IAAIC,EAAsBjB,GAAGc,CAAC,CAAC,CAAC,UAAUC,CAAC;GACjD,IAAIG,KAAMF,EAAE,KAAKE,KAAMF,EAAE,IAAIA,EAAE,SAASG,KAAMH,EAAE,KAAKG,KAAMH,EAAE,IAAIA,EAAE,QACjE,OAAOF,EAAE;EAEb;EACA,OAAO;CACT;CAyBA,OAAO;EAAE,gBAvBc,GAAY,MAA8B;GAC/D,IAAMM,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,OAAOC,MAAS,OAAO,OAAOb,EAAca,CAAI,CAAC,CAAC;EACpD;EAoBwB,WAjBtB,GACA,GACA,GACA,MACkB;GAClB,IAAMA,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,IAAIC,MAAS,MAAM,OAAO;GAC1B,IAAMZ,IAAQD,EAAca,CAAI;GAChC,IAAI,CAACC,GAAK,OAAOb,EAAM;GACvB,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAIS,EAAU,SAASd,EAAMK,EAAE,GAC7B,OAAOL,EAAM,KAAK,IAAIK,IAAI,GAAGL,EAAM,SAAS,CAAC;GAGjD,OAAOA,EAAMA,EAAM,SAAS;EAC9B;CAEiC;AACnC"}

package/dist/core/scene/nodeFnFields.js

@@ -29,18 +29,18 @@ var e = [
 		lost: "layout"
 	}
 ];
-function t(t) {
+function t(t, n) {
 	return e.map((e) => {
-		let n = t[e.field], r = /* @__PURE__ */ new Map();
-		if (n) for (let [e, t] of Object.entries(n)) r.set(t, e);
-		let i = (t) => !e.containersOnly || t.kind === "container";
+		let r = t[e.field], i = /* @__PURE__ */ new Map();
+		if (r) for (let [e, t] of Object.entries(r)) i.set(t, e);
+		let a = (t) => !e.containersOnly || t.kind === "container";
 		return {
 			spec: e,
-			keyOf: (e) => r.get(e),
-			fnOf: (e) => n?.[e],
-			read: (t) => i(t) ? t[e.field] : void 0,
-			write: (t, n) => {
-				i(t) && (t[e.field] = n);
+			keyOf: (e) => i.get(e),
+			fnOf: (e) => r?.[e],
+			read: (t) => a(t) ? t[e.field] : void 0,
+			write: (t, r) => {
+				a(t) && (t[e.field] = r, n?.(e.field, t));
 			}
 		};
 	});

package/dist/core/scene/nodeFnFields.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","applies","node","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * `clipFromPose`, `derivePath` and `derivePose` are live functions on a node,\n * and a function travels through neither a serializable op payload nor a JSON\n * snapshot. Each one therefore needs the same five things: a function→key\n * reverse map, a side channel the `kit:add` redo path re-attaches from, a\n * name in the op payload, a name in the snapshot, and a registry lookup on\n * restore.\n *\n * The first two fields were written out twice, and `types.ts` said in a\n * comment that a third should be the point it stopped being copied per field.\n * This is that point.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. Each field's real signature lives on `Node`.\n *  A container's `layout` is an object rather than a function, and rides the\n *  same table for the same reason — it travels by reference, not as data. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the three fields on it. The\n *  full `Node` type would make the table generic in `TData`/`TLayer` for no\n *  gain; nothing here looks at either. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(registry: SceneRegistry<TPose>): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (applies(node)) node[spec.field] = fn;\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AA8CA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgBC,EAA0B,GAAwD;CAChG,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,KAAW,MACf,CAACJ,EAAK,kBAAkBK,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOJ,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUE,EAAQC,CAAI,IAAIA,EAAKL,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAII,EAAQC,CAAI,MAAG,EAAKL,EAAK,SAASG;GACxC;EACF;CACF,CAAC;AACH;AAOA,SAAgBG,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMH,IAAKI,EAAM,KAAKL,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGK,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIL,EAAI,yCAAyCG,EAAK,GAAG,yBAC5DE,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,EAAM,MAAMF,GAAMF,CAAE;AACtB;AAIA,SAAgBM,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMR,IAAKI,EAAM,KAAKF,CAAI;EAC1B,IAAIF,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMK,EAAM,MAAMJ,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBK,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUV;CAC3B;CACA,OAAOQ;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMT,GACNK,IAA+B,CAAC;CACtC,KAAK,IAAMV,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBK,EAAK,SAAS,aAAa;EACtD,IAAMF,IAAKW,EAAId,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOO;AACT"}
+{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","applies","node","onWrite","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * These fields are live functions on a node, and a function travels through\n * neither a serializable op payload nor a JSON snapshot. Each one therefore\n * needs the same things: a function→key reverse map, a name in the op\n * payload, a name in the snapshot, and a registry lookup on restore.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. A container's `layout` is an object rather\n *  than a function, and rides the same table for the same reason. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the function fields on it. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(\n  registry: SceneRegistry<TPose>,\n  /** Called after a field is written onto a node it applies to. */\n  onWrite?: (field: NodeFnFieldName, node: FnBearingNode) => void,\n): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (!applies(node)) return;\n        node[spec.field] = fn;\n        onWrite?.(spec.field, node);\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AAqCA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgBC,EACd,GAEA,GACwB;CACxB,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,KAAW,MACf,CAACJ,EAAK,kBAAkBK,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOJ,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUE,EAAQC,CAAI,IAAIA,EAAKL,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAKI,EAAQC,CAAI,MACjB,EAAKL,EAAK,SAASG,GACnBG,IAAUN,EAAK,OAAOK,CAAI;GAC5B;EACF;CACF,CAAC;AACH;AAOA,SAAgBE,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMJ,IAAKK,EAAM,KAAKN,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGM,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIN,EAAI,yCAAyCG,EAAK,GAAG,yBAC5DG,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,EAAM,MAAMH,GAAMF,CAAE;AACtB;AAIA,SAAgBO,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMT,IAAKK,EAAM,KAAKH,CAAI;EAC1B,IAAIF,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMM,EAAM,MAAML,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBM,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUX;CAC3B;CACA,OAAOS;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMV,GACNM,IAA+B,CAAC;CACtC,KAAK,IAAMX,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBK,EAAK,SAAS,aAAa;EACtD,IAAMF,IAAKY,EAAIf,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOQ;AACT"}

package/dist/core/scene/nodeMemo.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodeMemo.js","names":["createNodeMemoScope","MEMO","generation","nodeMemo","slot","scopedNodeMemo","node","pose","derive","record","data","hit","value","entries","scope","drops","dropsNow","bumpNodeMemoGeneration","dropPoseKeyedMemoSlots","entry"],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * **Why this key works.** The scene mutates node objects in place but\n * *replaces* `pose` and `data` with new references — see the `kit:setPose` /\n * `kit:setData` ops in `core/scene/scene.ts`, which do `node.pose = p.to` /\n * `node.data = p.to`. So the node object is a stable identity, and those two\n * references are an exact freshness signal for anything derived per node: no\n * deep compare, no dirty flag, no subscription. The whole memo is three\n * reference comparisons.\n *\n * The assumption it rests on is the other side of that contract: nobody\n * mutates `node.data` (or `node.pose`) in place without replacing the\n * reference. A consumer who violates it sees a stale derivation until the next\n * real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Those change what `derive` would\n * return with no change to the node at all, which is the one failure a\n * `(pose, data)` key cannot see. {@link bumpNodeMemoGeneration} is the escape\n * hatch: whoever owns the ambient state bumps, and every slot on every node is\n * dropped. Derivations that read ambient state with *no* such signal (an async\n * image decode landing, say) must not be memoized here at all.\n *\n * Consumers: `canvas/NodeShape.ts` memoizes the painter match and the\n * silhouette path this way.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n  /** How many times {@link dropPoseKeyedMemoSlots} has run for this node,\n   *  which is how a drop reaches the scopes it cannot enumerate. */\n  drops: number;\n}\n\n/** A scoped entry also carries what a named slot's record holds for it. */\ninterface ScopedSlot extends MemoSlot {\n  generation: number;\n  drops: number;\n}\n\ndeclare const scopeBrand: unique symbol;\n\n/**\n * A private place to memoize one derivation, in place of a slot name.\n *\n * A named slot lives on the node, so it lasts as long as the node does. That\n * is wrong for a derivation that belongs to some shorter-lived reader — one\n * `toPose` function among many over the life of a scene. A scope is held by\n * that reader, and its entries go when the reader does.\n */\nexport type NodeMemoScope = { readonly [scopeBrand]: true };\n\nexport function createNodeMemoScope(): NodeMemoScope {\n  return new WeakMap<object, ScopedSlot>() as unknown as NodeMemoScope;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. Deliberately not `Node<…>` — the memo doesn't read\n *  anything else, and typing it loosely keeps `core/scene` from depending on\n *  the full node shape for a three-comparison cache. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, or the global\n * generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation. A node has more than one derived value — the\n * painter match, the silhouette, draw commands, text layout — and they\n * invalidate on the same signals but must not overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Those miss and recompute, as they should, and must not\n * poison the entry for the node's real pose. Pass `undefined` for derivations\n * that don't depend on the pose at all (the painter match is one) — it\n * compares equal to itself, leaving `data` as the only key.\n *\n * `data` is read off the node rather than passed: no caller has had a reason\n * to derive against data the node doesn't hold.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string | NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  if (typeof slot !== 'string') return scopedNodeMemo(node, slot, pose, derive);\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map(), drops: 0 };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, value });\n  }\n  return value;\n}\n\nfunction scopedNodeMemo<T>(\n  node: MemoizableNode,\n  scope: NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  const entries = scope as unknown as WeakMap<object, ScopedSlot>;\n  const data = node.data;\n  const drops = MEMO.get(node)?.drops ?? 0;\n  const hit = entries.get(node);\n  if (\n    hit !== undefined && hit.generation === generation && hit.pose === pose && hit.data === data\n    && (pose === undefined || hit.drops === drops)\n  ) {\n    return hit.value as T;\n  }\n  const value = derive();\n  // Read again: a derivation that hit a cycle drops this node's slots itself.\n  const dropsNow = MEMO.get(node)?.drops ?? 0;\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n    hit.generation = generation;\n    hit.drops = dropsNow;\n  } else {\n    entries.set(node, { pose, data, value, generation, drops: dropsNow });\n  }\n  return value;\n}\n\n/** How many named slots `node` holds. For tests of what is kept on a node. */\nexport function nodeMemoSlotCount(node: MemoizableNode): number {\n  const record = MEMO.get(node);\n  return record === undefined || record.generation !== generation ? 0 : record.slots.size;\n}\n\n/**\n * Drop every memoized slot on every node.\n *\n * For owners of ambient state that changes what a `derive` would return: the\n * shape-painter registry calls this when a painter is registered or disposed,\n * since a cache keyed only on `(pose, data)` would keep answering with the\n * painter that matched before.\n *\n * Cheap — it bumps a counter; records are re-stamped lazily on next access,\n * and unreachable nodes stay collectable via the `WeakMap`.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't (the painter match passes `undefined`, and re-matching it is a\n * registry scan).\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference: the `(pose, data)` key cannot see that, so the\n * override's `commit()` calls this for each node it holds.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) {\n    MEMO.set(node, { generation, slots: new Map(), drops: 1 });\n    return;\n  }\n  record.drops++;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AAmEA,SAAgBA,IAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAMC,oBAAO,IAAI,QAAgC,GAI7CC,IAAa;AA2BjB,SAAgBC,EACd,GACA,GACA,GACA,GACG;CACH,IAAI,OAAOC,KAAS,UAAU,OAAOC,EAAeC,GAAMF,GAAMG,GAAMC,CAAM;CAC5E,IAAIC,IAASR,EAAK,IAAIK,CAAI;CAC1B,AAAIG,MAAW,KAAA,KACb,IAAS;EAAE;EAAY,uBAAO,IAAI,IAAI;EAAG,OAAO;CAAE,GAClDR,EAAK,IAAIK,GAAMG,CAAM,KACZA,EAAO,eAAeP,MAC/B,EAAO,aAAaA,GACpBO,EAAO,MAAM,MAAM;CAGrB,IAAMC,IAAOJ,EAAK,MACZK,IAAMF,EAAO,MAAM,IAAIL,CAAI;CACjC,IAAIO,MAAQ,KAAA,KAAaA,EAAI,SAASJ,KAAQI,EAAI,SAASD,GACzD,OAAOC,EAAI;CAGb,IAAMC,IAAQJ,EAAO;CAUrB,OAPIG,MAAQ,KAAA,IAKVF,EAAO,MAAM,IAAIL,GAAM;EAAE;EAAM;EAAM;CAAM,CAAC,KAJ5C,EAAI,OAAOG,GACX,EAAI,OAAOG,GACX,EAAI,QAAQE,IAIPA;AACT;AAEA,SAASP,EACP,GACA,GACA,GACA,GACG;CACH,IAAMQ,IAAUC,GACVJ,IAAOJ,EAAK,MACZS,IAAQd,EAAK,IAAIK,CAAI,CAAC,EAAE,SAAS,GACjCK,IAAME,EAAQ,IAAIP,CAAI;CAC5B,IACEK,MAAQ,KAAA,KAAaA,EAAI,eAAeT,KAAcS,EAAI,SAASJ,KAAQI,EAAI,SAASD,MACpFH,MAAS,KAAA,KAAaI,EAAI,UAAUI,IAExC,OAAOJ,EAAI;CAEb,IAAMC,IAAQJ,EAAO,GAEfQ,IAAWf,EAAK,IAAIK,CAAI,CAAC,EAAE,SAAS;CAU1C,OATIK,MAAQ,KAAA,IAOVE,EAAQ,IAAIP,GAAM;EAAE;EAAM;EAAM;EAAO;EAAY,OAAOU;CAAS,CAAC,KANpE,EAAI,OAAOT,GACX,EAAI,OAAOG,GACX,EAAI,QAAQE,GACZ,EAAI,aAAaV,GACjB,EAAI,QAAQc,IAIPJ;AACT;AAmBA,SAAgBK,IAA+B;CAC7C;AACF;AAaA,SAAgBC,EAAuB,GAA4B;CACjE,IAAMT,IAASR,EAAK,IAAIK,CAAI;CAC5B,IAAIG,MAAW,KAAA,GAAW;EACxB,EAAK,IAAIH,GAAM;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE,CAAC;EACzD;CACF;CACA,EAAO;CACP,KAAK,IAAM,CAACF,GAAMe,MAAUV,EAAO,OACjC,AAAIU,EAAM,SAAS,KAAA,KAAWV,EAAO,MAAM,OAAOL,CAAI;AAE1D"}
+{"version":3,"file":"nodeMemo.js","names":["createNodeMemoScope","MEMO","generation","nodeMemo","slot","scopedNodeMemo","node","pose","derive","record","data","hit","value","entries","scope","drops","dropsNow","bumpNodeMemoGeneration","dropPoseKeyedMemoSlots","entry"],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * The scene mutates node objects in place but *replaces* `pose` and `data`\n * with new references, so those two references are an exact freshness signal.\n * The assumption it rests on: nobody mutates `node.data` (or `node.pose`) in\n * place without replacing the reference. A consumer who violates it sees a\n * stale derivation until the next real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Whoever owns the ambient state calls\n * {@link bumpNodeMemoGeneration}. Derivations that read ambient state with\n * *no* such signal (an async image decode landing, say) must not be memoized\n * here at all.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n  /** How many times {@link dropPoseKeyedMemoSlots} has run for this node,\n   *  which is how a drop reaches the scopes it cannot enumerate. */\n  drops: number;\n}\n\n/** A scoped entry also carries what a named slot's record holds for it. */\ninterface ScopedSlot extends MemoSlot {\n  generation: number;\n  drops: number;\n}\n\ndeclare const scopeBrand: unique symbol;\n\n/**\n * A private place to memoize one derivation, in place of a slot name.\n *\n * A named slot lives on the node, so it lasts as long as the node does. That\n * is wrong for a derivation that belongs to some shorter-lived reader — one\n * `toPose` function among many over the life of a scene. A scope is held by\n * that reader, and its entries go when the reader does.\n */\nexport type NodeMemoScope = { readonly [scopeBrand]: true };\n\nexport function createNodeMemoScope(): NodeMemoScope {\n  return new WeakMap<object, ScopedSlot>() as unknown as NodeMemoScope;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, or the global\n * generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation, so a node's several derived values do not\n * overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Pass `undefined` for derivations that don't depend on\n * the pose at all, leaving `data` as the only key.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string | NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  if (typeof slot !== 'string') return scopedNodeMemo(node, slot, pose, derive);\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map(), drops: 0 };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, value });\n  }\n  return value;\n}\n\nfunction scopedNodeMemo<T>(\n  node: MemoizableNode,\n  scope: NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  const entries = scope as unknown as WeakMap<object, ScopedSlot>;\n  const data = node.data;\n  const drops = MEMO.get(node)?.drops ?? 0;\n  const hit = entries.get(node);\n  if (\n    hit !== undefined && hit.generation === generation && hit.pose === pose && hit.data === data\n    && (pose === undefined || hit.drops === drops)\n  ) {\n    return hit.value as T;\n  }\n  const value = derive();\n  // Read again: a derivation that hit a cycle drops this node's slots itself.\n  const dropsNow = MEMO.get(node)?.drops ?? 0;\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n    hit.generation = generation;\n    hit.drops = dropsNow;\n  } else {\n    entries.set(node, { pose, data, value, generation, drops: dropsNow });\n  }\n  return value;\n}\n\n/** How many named slots `node` holds. For tests of what is kept on a node. */\nexport function nodeMemoSlotCount(node: MemoizableNode): number {\n  const record = MEMO.get(node);\n  return record === undefined || record.generation !== generation ? 0 : record.slots.size;\n}\n\n/**\n * Drop every memoized slot on every node. For owners of ambient state that\n * changes what a `derive` would return. Cheap — it bumps a counter.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't.\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference, which the `(pose, data)` key cannot see.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) {\n    MEMO.set(node, { generation, slots: new Map(), drops: 1 });\n    return;\n  }\n  record.drops++;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AAuDA,SAAgBA,IAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAMC,oBAAO,IAAI,QAAgC,GAI7CC,IAAa;AAmBjB,SAAgBC,EACd,GACA,GACA,GACA,GACG;CACH,IAAI,OAAOC,KAAS,UAAU,OAAOC,EAAeC,GAAMF,GAAMG,GAAMC,CAAM;CAC5E,IAAIC,IAASR,EAAK,IAAIK,CAAI;CAC1B,AAAIG,MAAW,KAAA,KACb,IAAS;EAAE;EAAY,uBAAO,IAAI,IAAI;EAAG,OAAO;CAAE,GAClDR,EAAK,IAAIK,GAAMG,CAAM,KACZA,EAAO,eAAeP,MAC/B,EAAO,aAAaA,GACpBO,EAAO,MAAM,MAAM;CAGrB,IAAMC,IAAOJ,EAAK,MACZK,IAAMF,EAAO,MAAM,IAAIL,CAAI;CACjC,IAAIO,MAAQ,KAAA,KAAaA,EAAI,SAASJ,KAAQI,EAAI,SAASD,GACzD,OAAOC,EAAI;CAGb,IAAMC,IAAQJ,EAAO;CAUrB,OAPIG,MAAQ,KAAA,IAKVF,EAAO,MAAM,IAAIL,GAAM;EAAE;EAAM;EAAM;CAAM,CAAC,KAJ5C,EAAI,OAAOG,GACX,EAAI,OAAOG,GACX,EAAI,QAAQE,IAIPA;AACT;AAEA,SAASP,EACP,GACA,GACA,GACA,GACG;CACH,IAAMQ,IAAUC,GACVJ,IAAOJ,EAAK,MACZS,IAAQd,EAAK,IAAIK,CAAI,CAAC,EAAE,SAAS,GACjCK,IAAME,EAAQ,IAAIP,CAAI;CAC5B,IACEK,MAAQ,KAAA,KAAaA,EAAI,eAAeT,KAAcS,EAAI,SAASJ,KAAQI,EAAI,SAASD,MACpFH,MAAS,KAAA,KAAaI,EAAI,UAAUI,IAExC,OAAOJ,EAAI;CAEb,IAAMC,IAAQJ,EAAO,GAEfQ,IAAWf,EAAK,IAAIK,CAAI,CAAC,EAAE,SAAS;CAU1C,OATIK,MAAQ,KAAA,IAOVE,EAAQ,IAAIP,GAAM;EAAE;EAAM;EAAM;EAAO;EAAY,OAAOU;CAAS,CAAC,KANpE,EAAI,OAAOT,GACX,EAAI,OAAOG,GACX,EAAI,QAAQE,GACZ,EAAI,aAAaV,GACjB,EAAI,QAAQc,IAIPJ;AACT;AAYA,SAAgBK,IAA+B;CAC7C;AACF;AAWA,SAAgBC,EAAuB,GAA4B;CACjE,IAAMT,IAASR,EAAK,IAAIK,CAAI;CAC5B,IAAIG,MAAW,KAAA,GAAW;EACxB,EAAK,IAAIH,GAAM;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE,CAAC;EACzD;CACF;CACA,EAAO;CACP,KAAK,IAAM,CAACF,GAAMe,MAAUV,EAAO,OACjC,AAAIU,EAAM,SAAS,KAAA,KAAWV,EAAO,MAAM,OAAOL,CAAI;AAE1D"}

package/dist/core/scene/nodeStore.js

@@ -1,126 +1,127 @@
-import { dropPoseKeyedMemoSlots as e } from "./nodeMemo.js";
-import { createDependentsIndex as t } from "./dependents.js";
+import { createDependentsIndex as e } from "./dependents.js";
+import { dropPoseKeyedMemoSlots as t } from "./nodeMemo.js";
 import { dwarn as n } from "../../debug/flag.js";
 import { restoreFn as r } from "./nodeFnFields.js";
+import { SceneMembershipError as i } from "./staleReplay.js";
 //#region src/core/scene/nodeStore.ts
-function i(i, a, o) {
-	let s = t(), c = /* @__PURE__ */ new Set();
-	function l(t) {
-		if (u(i.nodes.get(t)?.parent ?? null), s.isEmpty()) return;
-		let n = [t];
-		_(t, n);
-		for (let t of n) for (let n of s.transitiveDependentsOf(t)) {
-			let t = i.nodes.get(n);
-			t !== void 0 && e(t);
+function a(a, o, s) {
+	let c = e(), l = /* @__PURE__ */ new Set();
+	function u(e) {
+		if (d(a.nodes.get(e)?.parent ?? null), c.isEmpty()) return;
+		let n = [e];
+		v(e, n);
+		for (let e of n) for (let n of c.transitiveDependentsOf(e)) {
+			let e = a.nodes.get(n);
+			e !== void 0 && t(e);
 		}
 	}
-	function u(t) {
-		if (c.size === 0) return;
-		let n = t;
+	function d(e) {
+		if (l.size === 0) return;
+		let n = e;
 		for (; n !== null;) {
-			let t = i.nodes.get(n);
-			if (t === void 0) return;
-			if (c.has(n)) {
-				e(t);
-				for (let t of s.transitiveDependentsOf(n)) {
-					let n = i.nodes.get(t);
-					n !== void 0 && e(n);
+			let e = a.nodes.get(n);
+			if (e === void 0) return;
+			if (l.has(n)) {
+				t(e);
+				for (let e of c.transitiveDependentsOf(n)) {
+					let n = a.nodes.get(e);
+					n !== void 0 && t(n);
 				}
 			}
-			n = t.parent;
+			n = e.parent;
 		}
 	}
-	function d(e, t) {
-		t === "children" ? c.add(e) : c.delete(e);
+	function f(e, t) {
+		t === "children" ? l.add(e) : l.delete(e);
 	}
-	function f(t, n) {
-		let r = p(t);
-		n === void 0 ? delete r.dependsOn : r.dependsOn = n, s.add(t, n === void 0 || n === "children" ? [] : n), d(t, n), e(p(t)), l(t);
+	function p(e, n) {
+		let r = m(e);
+		n === void 0 ? delete r.dependsOn : r.dependsOn = n, c.add(e, n === void 0 || n === "children" ? [] : n), f(e, n), t(m(e)), u(e);
 	}
-	function p(e) {
-		let t = i.nodes.get(e);
-		if (!t) throw Error(`Scene: unknown node id "${e}"`);
+	function m(e) {
+		let t = a.nodes.get(e);
+		if (!t) throw new i(`Scene: unknown node id "${e}"`);
 		return t;
 	}
-	function m(e) {
-		if (e === null) return i.roots;
-		let t = p(e);
+	function h(e) {
+		if (e === null) return a.roots;
+		let t = m(e);
 		if (t.kind !== "container") throw Error(`Scene: parent "${e}" is not a container`);
 		return t.children;
 	}
-	function h(e) {
-		let t = p(e), n = m(t.parent), r = n.indexOf(e);
+	function g(e) {
+		let t = m(e), n = h(t.parent), r = n.indexOf(e);
 		if (r < 0) throw Error(`Scene: node "${e}" not found in its parent's children`);
-		return n.splice(r, 1), a(), {
+		return n.splice(r, 1), o(), {
 			parent: t.parent,
 			index: r
 		};
 	}
-	function g(e, t, n) {
-		let r = m(t), i = Math.max(0, Math.min(n, r.length));
+	function _(e, t, n) {
+		let r = h(t), i = Math.max(0, Math.min(n, r.length));
 		r.splice(i, 0, e);
-		let o = p(e);
-		o.parent = t, a();
+		let a = m(e);
+		a.parent = t, o();
 	}
-	function _(e, t) {
-		let n = i.nodes.get(e);
-		if (n && n.kind === "container") for (let e of n.children) t.push(e), _(e, t);
+	function v(e, t) {
+		let n = a.nodes.get(e);
+		if (n && n.kind === "container") for (let e of n.children) t.push(e), v(e, t);
 	}
-	function v(e) {
+	function y(e) {
 		let t = [], n = /* @__PURE__ */ new Set();
 		function r(e) {
 			if (n.has(e)) return;
 			n.add(e), t.push(e);
 			let r = [];
-			_(e, r);
+			v(e, r);
 			for (let e of r) n.has(e) || (n.add(e), t.push(e));
 		}
 		for (let t of e) r(t);
-		for (let e = 0; e < t.length; e++) for (let n of s.transitiveDependentsOf(t[e])) r(n);
+		for (let e = 0; e < t.length; e++) for (let n of c.transitiveDependentsOf(t[e])) r(n);
 		return {
 			ids: t,
 			removing: n
 		};
 	}
-	let y = /* @__PURE__ */ new WeakMap();
-	function b(e, t, n) {
-		let r = i.nodes.get(t);
+	let b = /* @__PURE__ */ new WeakMap();
+	function x(e, t, n) {
+		let r = a.nodes.get(t);
 		if (r === void 0) return;
-		let a = /* @__PURE__ */ new Map();
-		for (let t of o) {
+		let i = /* @__PURE__ */ new Map();
+		for (let t of s) {
 			let n = e[t.spec.field];
-			n !== void 0 && (t.spec.containersOnly && e.kind !== "container" || (t.write(r, n), a.set(t, n)));
+			n !== void 0 && (t.spec.containersOnly && e.kind !== "container" || (t.write(r, n), i.set(t, n)));
 		}
-		n && a.size > 0 && y.set(n, a);
+		n && i.size > 0 && b.set(n, i);
 	}
-	function x(e, t) {
+	function S(e, t) {
 		if (!t) return;
 		let i = e;
-		for (let e of o) {
+		for (let e of s) {
 			if (e.read(i) !== void 0) continue;
 			let a = t[e.spec.opKey];
 			a !== void 0 && r(e, i, a, "kit:remove", n);
 		}
 	}
 	return {
-		dependents: s,
-		childDerived: c,
-		invalidateDependents: l,
-		invalidateChildDerivedFrom: u,
-		trackChildDerived: d,
-		retarget: f,
-		requireNode: p,
-		siblingsOf: m,
-		detach: h,
-		attach: g,
-		descendants: _,
-		removalClosure: v,
-		addedFns: y,
-		patchNodeFunctions: b,
-		restoreNodeFunctions: x
+		dependents: c,
+		childDerived: l,
+		invalidateDependents: u,
+		invalidateChildDerivedFrom: d,
+		trackChildDerived: f,
+		retarget: p,
+		requireNode: m,
+		siblingsOf: h,
+		detach: g,
+		attach: _,
+		descendants: v,
+		removalClosure: y,
+		addedFns: b,
+		patchNodeFunctions: x,
+		restoreNodeFunctions: S
 	};
 }
 //#endregion
-export { i as createNodeStore };
+export { a as createNodeStore };
 
 //# sourceMappingURL=nodeStore.js.map