@weasel-js/core 1.9.2 → 1.9.4

package/dist/core/scene/nodeStore.js

@@ -0,0 +1,126 @@
+import { dropPoseKeyedMemoSlots as e } from "./nodeMemo.js";
+import { createDependentsIndex as t } from "./dependents.js";
+import { dwarn as n } from "../../debug/flag.js";
+import { restoreFn as r } from "./nodeFnFields.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 u(t) {
+		if (c.size === 0) return;
+		let n = t;
+		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);
+				}
+			}
+			n = t.parent;
+		}
+	}
+	function d(e, t) {
+		t === "children" ? c.add(e) : c.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) {
+		let t = i.nodes.get(e);
+		if (!t) throw Error(`Scene: unknown node id "${e}"`);
+		return t;
+	}
+	function m(e) {
+		if (e === null) return i.roots;
+		let t = p(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);
+		if (r < 0) throw Error(`Scene: node "${e}" not found in its parent's children`);
+		return n.splice(r, 1), a(), {
+			parent: t.parent,
+			index: r
+		};
+	}
+	function g(e, t, n) {
+		let r = m(t), i = Math.max(0, Math.min(n, r.length));
+		r.splice(i, 0, e);
+		let o = p(e);
+		o.parent = t, a();
+	}
+	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) {
+		let t = [], n = /* @__PURE__ */ new Set();
+		function r(e) {
+			if (n.has(e)) return;
+			n.add(e), t.push(e);
+			let r = [];
+			_(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);
+		return {
+			ids: t,
+			removing: n
+		};
+	}
+	let y = /* @__PURE__ */ new WeakMap();
+	function b(e, t, n) {
+		let r = i.nodes.get(t);
+		if (r === void 0) return;
+		let a = /* @__PURE__ */ new Map();
+		for (let t of o) {
+			let n = e[t.spec.field];
+			n !== void 0 && (t.spec.containersOnly && e.kind !== "container" || (t.write(r, n), a.set(t, n)));
+		}
+		n && a.size > 0 && y.set(n, a);
+	}
+	function x(e, t) {
+		if (!t) return;
+		let i = e;
+		for (let e of o) {
+			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
+	};
+}
+//#endregion
+export { i as createNodeStore };
+
+//# sourceMappingURL=nodeStore.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeStore.js","names":["createNodeStore","dependents","createDependentsIndex","childDerived","invalidateDependents","invalidateChildDerivedFrom","state","id","subtree","src","dep","node","dropPoseKeyedMemoSlots","cursor","start","d","trackChildDerived","dependsOn","retarget","requireNode","n","siblingsOf","parent","p","detach","sibs","idx","invalidateOrder","attach","index","descendants","c","out","removalClosure","ids","removing","take","sub","s","root","rootIds","i","addedFns","patchNodeFunctions","attached","field","fnFields","fn","spec","payload","restoreNodeFunctions","keys","target","key","restoreFn","dwarn"],"sources":["../../../src/core/scene/nodeStore.ts"],"sourcesContent":["/**\n * The scene's node store: the tree links, the reverse index of who derives\n * from whom, and the function fields a node carries beside its data.\n *\n * Everything here reads and writes `state.nodes` and `state.roots` directly;\n * none of it records. The kit ops call it from both of their directions.\n */\nimport { dwarn } from 'debug/flag';\nimport { createDependentsIndex } from './dependents';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { restoreFn, type FnBearingNode, type NodeFn, type NodeFnField } from './nodeFnFields';\nimport type { AddNodeSpec, Node, NodeId } from './types';\n\n/** What the store keeps of a scene's state. */\nexport interface NodeStoreState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n}\n\nexport function createNodeStore<TData, TLayer extends string, TPose>(\n  state: NodeStoreState<TData, TLayer, TPose>,\n  /** Called on every edit to the tree's links. */\n  invalidateOrder: () => void,\n  fnFields: readonly NodeFnField[],\n) {\n  /** Maintained from `kit:add` / `kit:remove` — the only two places a node is\n   *  created or destroyed, and unlike `add`/`remove` they replay on undo/redo.\n   *  Only explicit `dependsOn` id lists are registered here; `'children'` is\n   *  the ancestor walk in `invalidateDependents` instead. */\n  const dependents = createDependentsIndex();\n\n  /** Nodes carrying `dependsOn: 'children'`. Empty in every scene that has no\n   *  container hugging its contents, which is what keeps the ancestor walk off\n   *  the hot path. */\n  const childDerived = new Set<NodeId>();\n\n  /** Walks `id`'s whole subtree: under a composing pose strategy a container's\n   *  move carries every descendant, and whatever derives from one. */\n  function invalidateDependents(id: NodeId): void {\n    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);\n    if (dependents.isEmpty()) return;\n    const subtree: NodeId[] = [id];\n    descendants(id, subtree);\n    for (const src of subtree) {\n      for (const dep of dependents.transitiveDependentsOf(src)) {\n        const node = state.nodes.get(dep);\n        if (node !== undefined) dropPoseKeyedMemoSlots(node);\n      }\n    }\n  }\n\n  /** A `dependsOn: 'children'` container derives from nodes the reverse index\n   *  never sees, so its invalidation runs the other way: up the parent chain\n   *  from `start` inclusive, and on to each such ancestor's own dependents.\n   *\n   *  Callers that removed or reparented a node pass the parent explicitly —\n   *  a gone node cannot say who its parent was. */\n  function invalidateChildDerivedFrom(start: NodeId | null): void {\n    if (childDerived.size === 0) return;\n    let cursor = start;\n    while (cursor !== null) {\n      const node = state.nodes.get(cursor);\n      if (node === undefined) return;\n      if (childDerived.has(cursor)) {\n        dropPoseKeyedMemoSlots(node);\n        for (const dep of dependents.transitiveDependentsOf(cursor)) {\n          const d = state.nodes.get(dep);\n          if (d !== undefined) dropPoseKeyedMemoSlots(d);\n        }\n      }\n      cursor = node.parent;\n    }\n  }\n\n  /** Track (or forget) a node whose `dependsOn` is `'children'`. Paired with\n   *  `dependents.add` / `.remove` at every site a node is created or destroyed. */\n  function trackChildDerived(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    if (dependsOn === 'children') childDerived.add(id);\n    else childDerived.delete(id);\n  }\n\n  /** Point `id` at a different set of dependencies, keeping both indices and\n   *  every memo that reads them in step. Shared by `kit:setDependsOn`'s two\n   *  directions, which differ only in which value they install.\n   *\n   *  `id`'s own memo is dropped as well as its dependents': its derivation now\n   *  reads different sources, and nothing else would clear it. */\n  function retarget(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    const node = requireNode(id) as { dependsOn?: readonly NodeId[] | 'children' };\n    if (dependsOn === undefined) delete node.dependsOn;\n    else node.dependsOn = dependsOn;\n    dependents.add(id, dependsOn === undefined || dependsOn === 'children' ? [] : dependsOn);\n    trackChildDerived(id, dependsOn);\n    dropPoseKeyedMemoSlots(requireNode(id));\n    invalidateDependents(id);\n  }\n\n  function requireNode(id: NodeId): Node<TData, TLayer, TPose> {\n    const n = state.nodes.get(id);\n    if (!n) throw new Error(`Scene: unknown node id \"${id}\"`);\n    return n;\n  }\n\n  function siblingsOf(parent: NodeId | null): NodeId[] {\n    if (parent === null) return state.roots;\n    const p = requireNode(parent);\n    if (p.kind !== 'container') {\n      throw new Error(`Scene: parent \"${parent}\" is not a container`);\n    }\n    return p.children;\n  }\n\n  function detach(id: NodeId): { parent: NodeId | null; index: number } {\n    const node = requireNode(id);\n    const sibs = siblingsOf(node.parent);\n    const idx = sibs.indexOf(id);\n    if (idx < 0) throw new Error(`Scene: node \"${id}\" not found in its parent's children`);\n    sibs.splice(idx, 1);\n    invalidateOrder();\n    return { parent: node.parent, index: idx };\n  }\n\n  function attach(id: NodeId, parent: NodeId | null, index: number): void {\n    const sibs = siblingsOf(parent);\n    const i = Math.max(0, Math.min(index, sibs.length));\n    sibs.splice(i, 0, id);\n    const node = requireNode(id);\n    (node as { parent: NodeId | null }).parent = parent;\n    invalidateOrder();\n  }\n\n  function descendants(id: NodeId, out: NodeId[]): void {\n    const n = state.nodes.get(id);\n    if (!n || n.kind !== 'container') return;\n    for (const c of n.children) {\n      out.push(c);\n      descendants(c, out);\n    }\n  }\n\n  /** Everything removing `rootIds` takes with it: each root's subtree, then\n   *  every node deriving from any of those, then those nodes' subtrees in turn.\n   *  A dependent is not a descendant, so the second pass is a separate\n   *  reachability walk; `ids` grows as it runs, which is what carries the\n   *  cascade transitively and upward through a dependent's own ancestors.\n   *\n   *  Published as {@link Scene.removalClosure}, which is what the delete op and\n   *  `buildDeleteOps` ask instead of rebuilding the walk from `dependsOn` and\n   *  `children` — a third cascade relation is then added here alone. */\n  function removalClosure(rootIds: readonly NodeId[]): {\n    ids: NodeId[];\n    removing: Set<NodeId>;\n  } {\n    const ids: NodeId[] = [];\n    const removing = new Set<NodeId>();\n    function take(id: NodeId): void {\n      if (removing.has(id)) return;\n      removing.add(id);\n      ids.push(id);\n      const sub: NodeId[] = [];\n      descendants(id, sub);\n      for (const s of sub) {\n        if (removing.has(s)) continue;\n        removing.add(s);\n        ids.push(s);\n      }\n    }\n    for (const root of rootIds) take(root);\n    for (let i = 0; i < ids.length; i++) {\n      for (const dep of dependents.transitiveDependentsOf(ids[i])) take(dep);\n    }\n    return { ids, removing };\n  }\n\n  /** The functions a live `scene.add` attached, by the `kit:add` payload it\n   *  recorded: redo replays that payload without the spec. Keyed on the\n   *  payload rather than the node id because an id is reusable, and each\n   *  add of it owns its own functions. */\n  const addedFns = new WeakMap<object, Map<NodeFnField, NodeFn>>();\n\n  /** Post-patch the registry-keyed function fields onto a node after its\n   *  `kit:add` op runs. A function cannot travel through the serializable op\n   *  payload, so it is attached to the live node here, and kept against\n   *  `payload` for redo when there is one. `dependsOn` is plain data and\n   *  rides the payload instead. */\n  function patchNodeFunctions(\n    spec: AddNodeSpec<TData, TLayer, TPose>,\n    id: NodeId,\n    payload: object | null,\n  ): void {\n    const node = state.nodes.get(id) as FnBearingNode | undefined;\n    if (node === undefined) return;\n    const attached = new Map<NodeFnField, NodeFn>();\n    for (const field of fnFields) {\n      const fn = (spec as unknown as Record<string, unknown>)[field.spec.field] as NodeFn | undefined;\n      if (fn === undefined) continue;\n      if (field.spec.containersOnly && spec.kind !== 'container') continue;\n      field.write(node, fn);\n      attached.set(field, fn);\n    }\n    if (payload && attached.size > 0) addedFns.set(payload, attached);\n  }\n\n  /** Re-attach those fields to a node restored from a `kit:remove` snapshot.\n   *  In-session the clone already carries them; a persisted history does not,\n   *  so the registry keys are what is left. */\n  function restoreNodeFunctions(\n    node: Node<TData, TLayer, TPose>,\n    keys: Record<string, string | undefined> | undefined,\n  ): void {\n    if (!keys) return;\n    const target = node as unknown as FnBearingNode;\n    for (const field of fnFields) {\n      if (field.read(target) !== undefined) continue;\n      const key = keys[field.spec.opKey];\n      if (key === undefined) continue;\n      restoreFn(field, target, key, 'kit:remove', dwarn);\n    }\n  }\n\n  return {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, siblingsOf, detach, attach, descendants, removalClosure, addedFns, patchNodeFunctions,\n    restoreNodeFunctions,\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/pickability.js

@@ -0,0 +1,6 @@
+//#region src/core/scene/pickability.ts
+var e = (e) => e.pickable === void 0 ? {} : { pickable: e.pickable };
+//#endregion
+export { e as pickability };
+
+//# sourceMappingURL=pickability.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pickability.js","names":["pickability","n"],"sources":["../../../src/core/scene/pickability.ts"],"sourcesContent":["/** The `pickable` field of a node as a spread for `scene.add`: present only\n *  when the node states it, so an unstated one keeps the scene's default. */\nexport const pickability = (n: { pickable?: boolean }): { pickable?: boolean } =>\n  n.pickable !== undefined ? { pickable: n.pickable } : {};\n"],"mappings":";AAEA,IAAaA,KAAe,MAC1BC,EAAE,aAAa,KAAA,IAAuC,CAAC,IAA5B,EAAE,UAAUA,EAAE,SAAS"}

package/dist/core/scene/poseFeed.js

@@ -1,20 +1,19 @@
 import { effectivePose as e } from "./effectivePose.js";
+import { createEmitter as t } from "@weasel-js/registry";
 //#region src/core/scene/poseFeed.ts
-var t = Object.freeze([]);
-function n(n) {
-	let r = null, i = -1, a = -1, o = t, s = /* @__PURE__ */ new Set(), c = () => {
-		for (let e of s) e();
-	}, l = null, u = () => {
-		let t = r, i = [], a = [], o = [], s = /* @__PURE__ */ new Map();
-		for (let [r, o] of n.nodes) {
-			let c = e(n, o);
-			s.set(r, {
+var n = Object.freeze([]);
+function r(r) {
+	let i = null, a = -1, o = -1, s = n, c = t(), l = c.emit, u = null, d = () => {
+		let t = i, n = [], a = [], o = [], s = /* @__PURE__ */ new Map();
+		for (let [i, o] of r.nodes) {
+			let c = e(r, o);
+			s.set(i, {
 				pose: c,
 				data: o.data,
 				layer: o.layer
 			});
-			let l = t.get(r);
-			l === void 0 ? i.push({
+			let l = t.get(i);
+			l === void 0 ? n.push({
 				node: o,
 				pose: c
 			}) : (l.pose !== c || l.data !== o.data || l.layer !== o.layer) && a.push({
@@ -23,56 +22,57 @@ function n(n) {
 			});
 		}
 		for (let e of t.keys()) s.has(e) || o.push(e);
-		return r = s, {
-			added: i,
+		return i = s, {
+			added: n,
 			removed: o,
 			changed: a
 		};
-	}, d = () => (r = /* @__PURE__ */ new Map(), i = n.getVersion(), a = n.overrides.getGeneration(), o = n.overrides.ids(), {
-		...u(),
-		removed: t,
-		changed: t,
+	}, f = () => (i = /* @__PURE__ */ new Map(), a = r.getVersion(), o = r.overrides.getGeneration(), s = r.overrides.ids(), {
+		...d(),
+		removed: n,
+		changed: n,
 		reset: !0
 	});
 	return {
 		subscribe(e) {
-			if (s.add(e), l === null) {
-				let e = n.subscribe(c), t = n.overrides.subscribe(c);
-				l = () => {
+			let t = c.subscribe(e);
+			if (u === null) {
+				let e = r.subscribe(l), t = r.overrides.subscribe(l);
+				u = () => {
 					e(), t();
 				};
 			}
 			return () => {
-				s.delete(e), s.size === 0 && l !== null && (l(), l = null);
+				t(), c.size === 0 && u !== null && (u(), u = null);
 			};
 		},
 		read() {
-			if (r === null) return d();
-			let s = n.getVersion(), c = n.overrides.getGeneration(), l = s !== i, f = c !== a;
-			if (!l && !f) return {
-				added: t,
-				removed: t,
-				changed: t,
+			if (i === null) return f();
+			let t = r.getVersion(), c = r.overrides.getGeneration(), l = t !== a, u = c !== o;
+			if (!l && !u) return {
+				added: n,
+				removed: n,
+				changed: n,
 				reset: !1
 			};
-			let p = l ? u() : {
+			let p = l ? d() : {
 				added: [],
 				removed: [],
 				changed: []
 			};
-			if (i = s, f) {
-				let t = n.overrides.ids(), r = new Set(t);
-				for (let e of o) r.add(e);
+			if (a = t, u) {
+				let t = r.overrides.ids(), n = new Set(t);
+				for (let e of s) n.add(e);
 				let i = new Set(p.changed.map((e) => e.node.id));
-				for (let t of r) {
+				for (let t of n) {
 					if (i.has(t)) continue;
-					let r = n.get(t);
-					r !== void 0 && p.changed.push({
-						node: r,
-						pose: e(n, r)
+					let n = r.get(t);
+					n !== void 0 && p.changed.push({
+						node: n,
+						pose: e(r, n)
 					});
 				}
-				a = c, o = t;
+				o = c, s = t;
 			}
 			return {
 				...p,
@@ -82,6 +82,6 @@ function n(n) {
 	};
 }
 //#endregion
-export { n as createPoseFeed };
+export { r as createPoseFeed };
 
 //# sourceMappingURL=poseFeed.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poseFeed.js","names":["EMPTY","createPoseFeed","seen","seenVersion","seenGeneration","seenOverridden","listeners","notify","fn","unwire","walk","prev","added","changed","removed","next","id","node","scene","pose","effectivePose","before","resetTo","offScene","offOverrides","version","generation","committedMoved","overridesMoved","base","now","touched","already","n"],"sources":["../../../src/core/scene/poseFeed.ts"],"sourcesContent":["import { effectivePose } from './effectivePose';\nimport type { Node, NodeId, Scene } from './types';\n\n/** A node and the pose a renderer should draw it at. `node.pose` beside it is\n *  still the committed pose, so a host has both without a second channel. */\nexport interface FeedNode<TData, TLayer extends string, TPose> {\n  node: Node<TData, TLayer, TPose>;\n  pose: TPose;\n}\n\n/** What changed since the last `read()`. A node whose effective pose, data or\n *  layer reference moved is `changed`; `reset` means every node is in `added`. */\nexport interface FeedDelta<TData, TLayer extends string, TPose> {\n  added: readonly FeedNode<TData, TLayer, TPose>[];\n  removed: readonly NodeId[];\n  changed: readonly FeedNode<TData, TLayer, TPose>[];\n  /** Discard the object map and rebuild. */\n  reset: boolean;\n}\n\n/** A pull-based change feed over a scene. `subscribe` says something moved;\n *  `read` says what, relative to the previous read. */\nexport interface PoseFeed<TData, TLayer extends string, TPose> {\n  subscribe(fn: () => void): () => void;\n  read(): FeedDelta<TData, TLayer, TPose>;\n}\n\nconst EMPTY = Object.freeze([]) as readonly never[];\n\n/** The three references a node carries that a renderer cares about. The node\n *  object is mutated in place, so it is these — not the node — that move. */\ninterface Snapshot<TData, TLayer extends string, TPose> {\n  pose: TPose;\n  data: TData;\n  layer: TLayer;\n}\n\n/** A {@link PoseFeed} over `scene`, reporting effective poses (committed pose\n *  under any override). The first `read()` is a reset listing every node. */\nexport function createPoseFeed<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n): PoseFeed<TData, TLayer, TPose> {\n  let seen: Map<NodeId, Snapshot<TData, TLayer, TPose>> | null = null;\n  let seenVersion = -1;\n  let seenGeneration = -1;\n  let seenOverridden: readonly NodeId[] = EMPTY;\n\n  const listeners = new Set<() => void>();\n  const notify = () => {\n    for (const fn of listeners) fn();\n  };\n  let unwire: (() => void) | null = null;\n\n  const walk = (): {\n    added: FeedNode<TData, TLayer, TPose>[];\n    removed: NodeId[];\n    changed: FeedNode<TData, TLayer, TPose>[];\n  } => {\n    const prev = seen!;\n    const added: FeedNode<TData, TLayer, TPose>[] = [];\n    const changed: FeedNode<TData, TLayer, TPose>[] = [];\n    const removed: NodeId[] = [];\n    const next = new Map<NodeId, Snapshot<TData, TLayer, TPose>>();\n\n    for (const [id, node] of scene.nodes) {\n      const pose = effectivePose(scene, node);\n      next.set(id, { pose, data: node.data, layer: node.layer });\n      const before = prev.get(id);\n      if (before === undefined) added.push({ node, pose });\n      else if (before.pose !== pose || before.data !== node.data || before.layer !== node.layer) {\n        changed.push({ node, pose });\n      }\n    }\n    for (const id of prev.keys()) if (!next.has(id)) removed.push(id);\n\n    seen = next;\n    return { added, removed, changed };\n  };\n\n  const resetTo = (): FeedDelta<TData, TLayer, TPose> => {\n    // An empty `seen` makes the walk report every node as added, and fills the\n    // snapshot map in the same pass.\n    seen = new Map();\n    seenVersion = scene.getVersion();\n    seenGeneration = scene.overrides.getGeneration();\n    seenOverridden = scene.overrides.ids();\n    return { ...walk(), removed: EMPTY, changed: EMPTY, reset: true };\n  };\n\n  return {\n    subscribe(fn) {\n      listeners.add(fn);\n      if (unwire === null) {\n        const offScene = scene.subscribe(notify);\n        const offOverrides = scene.overrides.subscribe(notify);\n        unwire = () => {\n          offScene();\n          offOverrides();\n        };\n      }\n      return () => {\n        listeners.delete(fn);\n        if (listeners.size === 0 && unwire !== null) {\n          unwire();\n          unwire = null;\n        }\n      };\n    },\n    read() {\n      if (seen === null) return resetTo();\n\n      const version = scene.getVersion();\n      const generation = scene.overrides.getGeneration();\n      const committedMoved = version !== seenVersion;\n      const overridesMoved = generation !== seenGeneration;\n\n      if (!committedMoved && !overridesMoved) {\n        return { added: EMPTY, removed: EMPTY, changed: EMPTY, reset: false };\n      }\n\n      const base = committedMoved\n        ? walk()\n        : {\n            added: [] as FeedNode<TData, TLayer, TPose>[],\n            removed: [] as NodeId[],\n            changed: [] as FeedNode<TData, TLayer, TPose>[],\n          };\n      seenVersion = version;\n\n      if (overridesMoved) {\n        const now = scene.overrides.ids();\n        const touched = new Set<NodeId>(now);\n        for (const id of seenOverridden) touched.add(id); // a cleared override moved too\n        const already = new Set(base.changed.map((n) => n.node.id));\n        for (const id of touched) {\n          if (already.has(id)) continue;\n          const node = scene.get(id);\n          if (node !== undefined) base.changed.push({ node, pose: effectivePose(scene, node) });\n        }\n        seenGeneration = generation;\n        seenOverridden = now;\n      }\n\n      return { ...base, reset: false };\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"poseFeed.js","names":["EMPTY","createPoseFeed","seen","seenVersion","seenGeneration","seenOverridden","listeners","createEmitter","notify","unwire","walk","prev","added","changed","removed","next","id","node","scene","pose","effectivePose","before","resetTo","off","fn","offScene","offOverrides","version","generation","committedMoved","overridesMoved","base","now","touched","already","n"],"sources":["../../../src/core/scene/poseFeed.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport { effectivePose } from './effectivePose';\nimport type { Node, NodeId, Scene } from './types';\n\n/** A node and the pose a renderer should draw it at. `node.pose` beside it is\n *  still the committed pose, so a host has both without a second channel. */\nexport interface FeedNode<TData, TLayer extends string, TPose> {\n  node: Node<TData, TLayer, TPose>;\n  pose: TPose;\n}\n\n/** What changed since the last `read()`. A node whose effective pose, data or\n *  layer reference moved is `changed`; `reset` means every node is in `added`. */\nexport interface FeedDelta<TData, TLayer extends string, TPose> {\n  added: readonly FeedNode<TData, TLayer, TPose>[];\n  removed: readonly NodeId[];\n  changed: readonly FeedNode<TData, TLayer, TPose>[];\n  /** Discard the object map and rebuild. */\n  reset: boolean;\n}\n\n/** A pull-based change feed over a scene. `subscribe` says something moved;\n *  `read` says what, relative to the previous read. */\nexport interface PoseFeed<TData, TLayer extends string, TPose> {\n  subscribe(fn: () => void): () => void;\n  read(): FeedDelta<TData, TLayer, TPose>;\n}\n\nconst EMPTY = Object.freeze([]) as readonly never[];\n\n/** The three references a node carries that a renderer cares about. The node\n *  object is mutated in place, so it is these — not the node — that move. */\ninterface Snapshot<TData, TLayer extends string, TPose> {\n  pose: TPose;\n  data: TData;\n  layer: TLayer;\n}\n\n/** A {@link PoseFeed} over `scene`, reporting effective poses (committed pose\n *  under any override). The first `read()` is a reset listing every node. */\nexport function createPoseFeed<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n): PoseFeed<TData, TLayer, TPose> {\n  let seen: Map<NodeId, Snapshot<TData, TLayer, TPose>> | null = null;\n  let seenVersion = -1;\n  let seenGeneration = -1;\n  let seenOverridden: readonly NodeId[] = EMPTY;\n\n  const listeners = createEmitter();\n  const notify = listeners.emit;\n  let unwire: (() => void) | null = null;\n\n  const walk = (): {\n    added: FeedNode<TData, TLayer, TPose>[];\n    removed: NodeId[];\n    changed: FeedNode<TData, TLayer, TPose>[];\n  } => {\n    const prev = seen!;\n    const added: FeedNode<TData, TLayer, TPose>[] = [];\n    const changed: FeedNode<TData, TLayer, TPose>[] = [];\n    const removed: NodeId[] = [];\n    const next = new Map<NodeId, Snapshot<TData, TLayer, TPose>>();\n\n    for (const [id, node] of scene.nodes) {\n      const pose = effectivePose(scene, node);\n      next.set(id, { pose, data: node.data, layer: node.layer });\n      const before = prev.get(id);\n      if (before === undefined) added.push({ node, pose });\n      else if (before.pose !== pose || before.data !== node.data || before.layer !== node.layer) {\n        changed.push({ node, pose });\n      }\n    }\n    for (const id of prev.keys()) if (!next.has(id)) removed.push(id);\n\n    seen = next;\n    return { added, removed, changed };\n  };\n\n  const resetTo = (): FeedDelta<TData, TLayer, TPose> => {\n    // An empty `seen` makes the walk report every node as added, and fills the\n    // snapshot map in the same pass.\n    seen = new Map();\n    seenVersion = scene.getVersion();\n    seenGeneration = scene.overrides.getGeneration();\n    seenOverridden = scene.overrides.ids();\n    return { ...walk(), removed: EMPTY, changed: EMPTY, reset: true };\n  };\n\n  return {\n    subscribe(fn) {\n      const off = listeners.subscribe(fn);\n      if (unwire === null) {\n        const offScene = scene.subscribe(notify);\n        const offOverrides = scene.overrides.subscribe(notify);\n        unwire = () => {\n          offScene();\n          offOverrides();\n        };\n      }\n      return () => {\n        off();\n        if (listeners.size === 0 && unwire !== null) {\n          unwire();\n          unwire = null;\n        }\n      };\n    },\n    read() {\n      if (seen === null) return resetTo();\n\n      const version = scene.getVersion();\n      const generation = scene.overrides.getGeneration();\n      const committedMoved = version !== seenVersion;\n      const overridesMoved = generation !== seenGeneration;\n\n      if (!committedMoved && !overridesMoved) {\n        return { added: EMPTY, removed: EMPTY, changed: EMPTY, reset: false };\n      }\n\n      const base = committedMoved\n        ? walk()\n        : {\n            added: [] as FeedNode<TData, TLayer, TPose>[],\n            removed: [] as NodeId[],\n            changed: [] as FeedNode<TData, TLayer, TPose>[],\n          };\n      seenVersion = version;\n\n      if (overridesMoved) {\n        const now = scene.overrides.ids();\n        const touched = new Set<NodeId>(now);\n        for (const id of seenOverridden) touched.add(id); // a cleared override moved too\n        const already = new Set(base.changed.map((n) => n.node.id));\n        for (const id of touched) {\n          if (already.has(id)) continue;\n          const node = scene.get(id);\n          if (node !== undefined) base.changed.push({ node, pose: effectivePose(scene, node) });\n        }\n        seenGeneration = generation;\n        seenOverridden = now;\n      }\n\n      return { ...base, reset: false };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/poseOverrides.js

@@ -1,72 +1,68 @@
 import { dropPoseKeyedMemoSlots as e } from "./nodeMemo.js";
-import { kit as t, last as n, mix as r, mul as i, patch as a } from "@msb235/blits";
+import { createEmitter as t } from "@weasel-js/registry";
+import { kit as n, last as r, mix as i, mul as a, patch as o } from "@msb235/blits";
 //#region src/core/scene/poseOverrides.ts
-var o = Object.freeze({});
-function s(s, c) {
-	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = 0, f = r(t({
-		pose: n(),
-		alpha: i()
+var s = Object.freeze({});
+function c(c, l) {
+	let u = /* @__PURE__ */ new Map(), d = t(), f = 0, p = i(n({
+		pose: r(),
+		alpha: a()
 	}));
-	f.cue({ patch: a(0, (e, t) => l.get(t) ?? o, { writes: ["pose", "alpha"] }) });
-	let p = 0;
-	f.sync(p);
-	let m = /* @__PURE__ */ new Map();
-	function h(t) {
-		let n = s(t);
-		n && e(n), c?.(t);
+	p.cue({ patch: o(0, (e, t) => u.get(t) ?? s, { writes: ["pose", "alpha"] }) });
+	let m = 0;
+	p.sync(m);
+	let h = /* @__PURE__ */ new Map();
+	function g(t) {
+		let n = c(t);
+		n && e(n), l?.(t);
 	}
-	function g() {
-		d++, f.sync(++p);
-		for (let e of u) e();
+	function _() {
+		f++, p.sync(++m), d.emit();
 	}
-	function _(e) {
-		m.delete(e), f.drop(e);
+	function v(e) {
+		h.delete(e), p.drop(e);
 	}
 	return {
 		set(e, t) {
-			l.set(e, t), h(e), g();
+			u.set(e, t), g(e), _();
 		},
 		get(e) {
-			return l.get(e);
+			return u.get(e);
 		},
 		read(e) {
-			if (!l.has(e)) return;
-			let t = m.get(e);
+			if (!u.has(e)) return;
+			let t = h.get(e);
 			return t === void 0 && (t = {
 				out: {},
 				at: -1
-			}, m.set(e, t)), t.at !== d && (f.probe(e, t.out), t.at = d), t.out;
+			}, h.set(e, t)), t.at !== f && (p.probe(e, t.out), t.at = f), t.out;
 		},
 		has(e) {
-			return l.has(e);
+			return u.has(e);
 		},
 		ids() {
-			return [...l.keys()];
+			return [...u.keys()];
 		},
 		clear(e) {
-			l.delete(e) && (_(e), h(e), g());
+			u.delete(e) && (v(e), g(e), _());
 		},
 		clearAll() {
-			if (l.size !== 0) {
-				for (let e of l.keys()) _(e), h(e);
-				l.clear(), g();
+			if (u.size !== 0) {
+				for (let e of u.keys()) v(e), g(e);
+				u.clear(), _();
 			}
 		},
 		commit() {
-			for (let e of l.keys()) h(e);
-			g();
-		},
-		subscribe(e) {
-			return u.add(e), () => {
-				u.delete(e);
-			};
+			for (let e of u.keys()) g(e);
+			_();
 		},
+		subscribe: d.subscribe,
 		getGeneration() {
-			return d;
+			return f;
 		}
 	};
 }
 //#endregion
-export { s as createPoseOverrides };
+export { c as createPoseOverrides };
 
 //# sourceMappingURL=poseOverrides.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poseOverrides.js","names":["NOTHING","createPoseOverrides","entries","listeners","generation","folded","mix","kit","last","mul","patch","id","clock","reads","invalidate","node","getNode","dropPoseKeyedMemoSlots","onInvalidate","published","listener","forget","entry","held","fn"],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import { kit, last, mix, mul, patch } from '@msb235/blits';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/** What the table's voice says about a node it holds no entry for. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on —\n * the only thing this module needs from the scene, and the reason it doesn't\n * import one. `onInvalidate` lets the scene invalidate derived nodes from the\n * same chokepoint.\n *\n * What `read` answers is a blits mix folded per node. The entries a writer\n * `set`s are one voice on it, and the nodes holding an entry are the mix's\n * reach: a node outside it is never probed.\n */\nexport function createPoseOverrides<TPose>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose> {\n  const entries = new Map<NodeId, PoseOverride<TPose>>();\n  const listeners = new Set<() => void>();\n  let generation = 0;\n\n  const folded = mix<NodeId, PoseOverride<TPose>>(\n    kit<PoseOverride<TPose>>({ pose: last<NonNullable<TPose>>(), alpha: mul() }),\n  );\n  folded.cue({\n    patch: patch<NodeId, PoseOverride<TPose>>(\n      0,\n      (_phase, id) => entries.get(id) ?? (NOTHING as PoseOverride<TPose>),\n      { writes: ['pose', 'alpha'] },\n    ),\n  });\n  // Mix time only has to move between publishes, so a probe after one never\n  // hands back the delta a probe before it cached.\n  let clock = 0;\n  folded.sync(clock);\n\n  /** Per node: the object `read` folds into and returns, and the generation\n   *  it was last folded at. */\n  const reads = new Map<NodeId, { out: PoseOverride<TPose>; at: number }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) dropPoseKeyedMemoSlots(node);\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    folded.sync(++clock);\n    for (const listener of listeners) listener();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    folded.drop(id);\n  }\n\n  return {\n    set(id, entry) {\n      entries.set(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return entries.get(id);\n    },\n    read(id) {\n      if (!entries.has(id)) return undefined;\n      let held = reads.get(id);\n      if (held === undefined) {\n        held = { out: {}, at: -1 };\n        reads.set(id, held);\n      }\n      if (held.at !== generation) {\n        folded.probe(id, held.out);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id) {\n      return entries.has(id);\n    },\n    ids() {\n      return [...entries.keys()];\n    },\n    clear(id) {\n      if (!entries.delete(id)) return;\n      forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (entries.size === 0) return;\n      for (const id of entries.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      entries.clear();\n      published();\n    },\n    commit() {\n      for (const id of entries.keys()) invalidate(id);\n      published();\n    },\n    subscribe(fn) {\n      listeners.add(fn);\n      return () => { listeners.delete(fn); };\n    },\n    getGeneration() {\n      return generation;\n    },\n  };\n}\n"],"mappings":";;;AAKA,IAAMA,IAA+B,OAAO,OAAO,CAAC,CAAC;AAcrD,SAAgBC,EACd,GACA,GACsB;CACtB,IAAMC,oBAAU,IAAI,IAAiC,GAC/CC,oBAAY,IAAI,IAAgB,GAClCC,IAAa,GAEXC,IAASC,EACbC,EAAyB;EAAE,MAAMC,EAAyB;EAAG,OAAOC,EAAI;CAAE,CAAC,CAC7E;CACA,EAAO,IAAI,EACT,OAAOC,EACL,IACC,GAAQ,MAAOR,EAAQ,IAAIS,CAAE,KAAMX,GACpC,EAAE,QAAQ,CAAC,QAAQ,OAAO,EAAE,CAC9B,EACF,CAAC;CAGD,IAAIY,IAAQ;CACZ,EAAO,KAAKA,CAAK;CAIjB,IAAMC,oBAAQ,IAAI,IAAsD;CAExE,SAASC,EAAW,GAAkB;EACpC,IAAMC,IAAOC,EAAQL,CAAE;EAEvB,AADII,KAAME,EAAuBF,CAAI,GACrCG,IAAeP,CAAE;CACnB;CAEA,SAASQ,IAAkB;EAEzB,AADA,KACAd,EAAO,KAAK,EAAEO,CAAK;EACnB,KAAK,IAAMQ,KAAYjB,GAAW,EAAS;CAC7C;CAEA,SAASkB,EAAO,GAAkB;EAEhC,AADAR,EAAM,OAAOF,CAAE,GACfN,EAAO,KAAKM,CAAE;CAChB;CAEA,OAAO;EACL,IAAI,GAAI,GAAO;GAGb,AAFAT,EAAQ,IAAIS,GAAIW,CAAK,GACrBR,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,IAAI,GAAI;GACN,OAAOjB,EAAQ,IAAIS,CAAE;EACvB;EACA,KAAK,GAAI;GACP,IAAI,CAACT,EAAQ,IAAIS,CAAE,GAAG;GACtB,IAAIY,IAAOV,EAAM,IAAIF,CAAE;GASvB,OARIY,MAAS,KAAA,MACX,IAAO;IAAE,KAAK,CAAC;IAAG,IAAI;GAAG,GACzBV,EAAM,IAAIF,GAAIY,CAAI,IAEhBA,EAAK,OAAOnB,MACdC,EAAO,MAAMM,GAAIY,EAAK,GAAG,GACzB,EAAK,KAAKnB,IAELmB,EAAK;EACd;EACA,IAAI,GAAI;GACN,OAAOrB,EAAQ,IAAIS,CAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAGT,EAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,GAAI;GACR,AAAKA,EAAQ,OAAOS,CAAE,MACtBU,EAAOV,CAAE,GACTG,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,WAAW;GACT,IAAIjB,EAAQ,SAAS,GACrB;SAAK,IAAMS,KAAMT,EAAQ,KAAK,GAE5B,AADAmB,EAAOV,CAAE,GACTG,EAAWH,CAAE;IAGf,AADAT,EAAQ,MAAM,GACdiB,EAAU;GAFV;EAGF;EACA,SAAS;GACP,KAAK,IAAMR,KAAMT,EAAQ,KAAK,GAAG,EAAWS,CAAE;GAC9C,EAAU;EACZ;EACA,UAAU,GAAI;GAEZ,OADAR,EAAU,IAAIqB,CAAE,SACH;IAAE,EAAU,OAAOA,CAAE;GAAG;EACvC;EACA,gBAAgB;GACd,OAAOpB;EACT;CACF;AACF"}
+{"version":3,"file":"poseOverrides.js","names":["NOTHING","createPoseOverrides","entries","listeners","createEmitter","generation","folded","mix","kit","last","mul","patch","id","clock","reads","invalidate","node","getNode","dropPoseKeyedMemoSlots","onInvalidate","published","forget","entry","held"],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport { kit, last, mix, mul, patch } from '@msb235/blits';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/** What the table's voice says about a node it holds no entry for. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on —\n * the only thing this module needs from the scene, and the reason it doesn't\n * import one. `onInvalidate` lets the scene invalidate derived nodes from the\n * same chokepoint.\n *\n * What `read` answers is a blits mix folded per node. The entries a writer\n * `set`s are one voice on it, and the nodes holding an entry are the mix's\n * reach: a node outside it is never probed.\n */\nexport function createPoseOverrides<TPose>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose> {\n  const entries = new Map<NodeId, PoseOverride<TPose>>();\n  const listeners = createEmitter();\n  let generation = 0;\n\n  const folded = mix<NodeId, PoseOverride<TPose>>(\n    kit<PoseOverride<TPose>>({ pose: last<NonNullable<TPose>>(), alpha: mul() }),\n  );\n  folded.cue({\n    patch: patch<NodeId, PoseOverride<TPose>>(\n      0,\n      (_phase, id) => entries.get(id) ?? (NOTHING as PoseOverride<TPose>),\n      { writes: ['pose', 'alpha'] },\n    ),\n  });\n  // Mix time only has to move between publishes, so a probe after one never\n  // hands back the delta a probe before it cached.\n  let clock = 0;\n  folded.sync(clock);\n\n  /** Per node: the object `read` folds into and returns, and the generation\n   *  it was last folded at. */\n  const reads = new Map<NodeId, { out: PoseOverride<TPose>; at: number }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) dropPoseKeyedMemoSlots(node);\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    folded.sync(++clock);\n    listeners.emit();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    folded.drop(id);\n  }\n\n  return {\n    set(id, entry) {\n      entries.set(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return entries.get(id);\n    },\n    read(id) {\n      if (!entries.has(id)) return undefined;\n      let held = reads.get(id);\n      if (held === undefined) {\n        held = { out: {}, at: -1 };\n        reads.set(id, held);\n      }\n      if (held.at !== generation) {\n        folded.probe(id, held.out);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id) {\n      return entries.has(id);\n    },\n    ids() {\n      return [...entries.keys()];\n    },\n    clear(id) {\n      if (!entries.delete(id)) return;\n      forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (entries.size === 0) return;\n      for (const id of entries.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      entries.clear();\n      published();\n    },\n    commit() {\n      for (const id of entries.keys()) invalidate(id);\n      published();\n    },\n    subscribe: listeners.subscribe,\n    getGeneration() {\n      return generation;\n    },\n  };\n}\n"],"mappings":";;;;AAMA,IAAMA,IAA+B,OAAO,OAAO,CAAC,CAAC;AAcrD,SAAgBC,EACd,GACA,GACsB;CACtB,IAAMC,oBAAU,IAAI,IAAiC,GAC/CC,IAAYC,EAAc,GAC5BC,IAAa,GAEXC,IAASC,EACbC,EAAyB;EAAE,MAAMC,EAAyB;EAAG,OAAOC,EAAI;CAAE,CAAC,CAC7E;CACA,EAAO,IAAI,EACT,OAAOC,EACL,IACC,GAAQ,MAAOT,EAAQ,IAAIU,CAAE,KAAMZ,GACpC,EAAE,QAAQ,CAAC,QAAQ,OAAO,EAAE,CAC9B,EACF,CAAC;CAGD,IAAIa,IAAQ;CACZ,EAAO,KAAKA,CAAK;CAIjB,IAAMC,oBAAQ,IAAI,IAAsD;CAExE,SAASC,EAAW,GAAkB;EACpC,IAAMC,IAAOC,EAAQL,CAAE;EAEvB,AADII,KAAME,EAAuBF,CAAI,GACrCG,IAAeP,CAAE;CACnB;CAEA,SAASQ,IAAkB;EAGzB,AAFA,KACAd,EAAO,KAAK,EAAEO,CAAK,GACnBV,EAAU,KAAK;CACjB;CAEA,SAASkB,EAAO,GAAkB;EAEhC,AADAP,EAAM,OAAOF,CAAE,GACfN,EAAO,KAAKM,CAAE;CAChB;CAEA,OAAO;EACL,IAAI,GAAI,GAAO;GAGb,AAFAV,EAAQ,IAAIU,GAAIU,CAAK,GACrBP,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,IAAI,GAAI;GACN,OAAOlB,EAAQ,IAAIU,CAAE;EACvB;EACA,KAAK,GAAI;GACP,IAAI,CAACV,EAAQ,IAAIU,CAAE,GAAG;GACtB,IAAIW,IAAOT,EAAM,IAAIF,CAAE;GASvB,OARIW,MAAS,KAAA,MACX,IAAO;IAAE,KAAK,CAAC;IAAG,IAAI;GAAG,GACzBT,EAAM,IAAIF,GAAIW,CAAI,IAEhBA,EAAK,OAAOlB,MACdC,EAAO,MAAMM,GAAIW,EAAK,GAAG,GACzB,EAAK,KAAKlB,IAELkB,EAAK;EACd;EACA,IAAI,GAAI;GACN,OAAOrB,EAAQ,IAAIU,CAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAGV,EAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,GAAI;GACR,AAAKA,EAAQ,OAAOU,CAAE,MACtBS,EAAOT,CAAE,GACTG,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,WAAW;GACT,IAAIlB,EAAQ,SAAS,GACrB;SAAK,IAAMU,KAAMV,EAAQ,KAAK,GAE5B,AADAmB,EAAOT,CAAE,GACTG,EAAWH,CAAE;IAGf,AADAV,EAAQ,MAAM,GACdkB,EAAU;GAFV;EAGF;EACA,SAAS;GACP,KAAK,IAAMR,KAAMV,EAAQ,KAAK,GAAG,EAAWU,CAAE;GAC9C,EAAU;EACZ;EACA,WAAWT,EAAU;EACrB,gBAAgB;GACd,OAAOE;EACT;CACF;AACF"}

package/dist/core/scene/renderOrder.js

@@ -0,0 +1,84 @@
+//#region src/core/scene/renderOrder.ts
+function e(e) {
+	function t() {
+		return e.layers.length === 1 ? c() : u();
+	}
+	function n() {
+		return e.layers.length === 1 ? l() : d();
+	}
+	let r = 0, i = { gen: 0 };
+	function a() {
+		r++;
+	}
+	let o = [];
+	function s() {
+		return i.gen !== r && (i = { gen: r }), i;
+	}
+	function c() {
+		let t = e.layers[0].id, n = [], r = [...e.roots].reverse();
+		for (; r.length > 0;) {
+			let i = r.pop(), a = e.nodes.get(i);
+			if (a && (a.layer === t && n.push(i), a.kind === "container")) for (let e = a.children.length - 1; e >= 0; e--) r.push(a.children[e]);
+		}
+		return n;
+	}
+	function l() {
+		let t = e.layers[0].id, n = [], r = [...e.roots].reverse();
+		for (; r.length > 0;) {
+			let i = r.pop(), a = e.nodes.get(i);
+			if (a && (a.layer === t && n.push(a), a.kind === "container")) for (let e = a.children.length - 1; e >= 0; e--) r.push(a.children[e]);
+		}
+		return n;
+	}
+	function u() {
+		let t = e.layers.map(() => []), n = [...e.roots].reverse();
+		for (; n.length > 0;) {
+			let r = n.pop(), i = e.nodes.get(r);
+			if (!i) continue;
+			let a = t[e.layerIndex.get(i.layer) ?? -1];
+			if (a && a.push(r), i.kind === "container") for (let e = i.children.length - 1; e >= 0; e--) n.push(i.children[e]);
+		}
+		let r = [];
+		for (let e of t) for (let t of e) r.push(t);
+		return r;
+	}
+	function d() {
+		let t = e.layers.map(() => []), n = [...e.roots].reverse();
+		for (; n.length > 0;) {
+			let r = n.pop(), i = e.nodes.get(r);
+			if (!i) continue;
+			let a = t[e.layerIndex.get(i.layer) ?? -1];
+			if (a && a.push(i), i.kind === "container") for (let e = i.children.length - 1; e >= 0; e--) n.push(i.children[e]);
+		}
+		let r = [];
+		for (let e of t) for (let t of e) r.push(t);
+		return r;
+	}
+	return {
+		ids() {
+			let e = s();
+			return e.ids ??= t();
+		},
+		nodes() {
+			let e = s();
+			return e.nodes ??= n();
+		},
+		nodesOnLayer(e) {
+			let t = s(), r = t.byLayer;
+			if (!r) {
+				r = /* @__PURE__ */ new Map();
+				for (let e of t.nodes ??= n()) {
+					let t = r.get(e.layer);
+					t || r.set(e.layer, t = []), t.push(e);
+				}
+				t.byLayer = r;
+			}
+			return r.get(e) ?? o;
+		},
+		invalidate: a
+	};
+}
+//#endregion
+export { e as createRenderOrder };
+
+//# sourceMappingURL=renderOrder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderOrder.js","names":["createRenderOrder","walkIds","state","renderOrderFlat","renderOrderBucketed","walkNodes","renderOrderNodesFlat","renderOrderNodesBucketed","structureGeneration","orderCache","invalidate","EMPTY_NODES","currentOrderCache","only","out","stack","id","node","i","buckets","bucket","c","byLayer","layer"],"sources":["../../../src/core/scene/renderOrder.ts"],"sourcesContent":["/**\n * A scene's render order: its nodes layer-major, each layer in tree preorder,\n * cached until the structure changes.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the walks read of a scene's state. */\nexport interface RenderOrderState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: { id: TLayer }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface RenderOrder<TData, TLayer extends string, TPose> {\n  ids(): NodeId[];\n  nodes(): Node<TData, TLayer, TPose>[];\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n  /** Call on every structural edit; see the cache note below. */\n  invalidate(): void;\n}\n\nexport function createRenderOrder<TData, TLayer extends string, TPose>(\n  state: RenderOrderState<TData, TLayer, TPose>,\n): RenderOrder<TData, TLayer, TPose> {\n  /**\n   * Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks\n   * for two sequences, which wants explaining, because collapsing them is the\n   * obvious cleanup and each collapse was measured to cost something:\n   *\n   * - ids vs nodes: projecting one from the other is a whole extra pass, worth\n   *   20% of `renderOrder()` on a multi-layer scene.\n   * - flat vs bucketed: a single layer needs no buckets and can compare the\n   *   layer id instead of indexing it, which is 1.4x. Behind a branch in one\n   *   function it also slows the bucketed path by 20% — the two shapes share\n   *   one optimized body, and whichever ran first wins it.\n   *\n   * All four emit the same order and `renderOrder.test.ts` holds them to it.\n   */\n  function walkIds(): NodeId[] {\n    return state.layers.length === 1 ? renderOrderFlat() : renderOrderBucketed();\n  }\n\n  function walkNodes(): Node<TData, TLayer, TPose>[] {\n    return state.layers.length === 1 ? renderOrderNodesFlat() : renderOrderNodesBucketed();\n  }\n\n  /**\n   * Render order survives everything except a structural edit, so both walks\n   * are cached against a counter the structural writers bump: `attach` and\n   * `detach` (add / remove / reparent / reorder), `kit:setLayer` (which bucket\n   * a node lands in), `rebuildLayerIndex` (the layer list itself), and\n   * `loadState`. Pose and data edits leave order alone and must NOT invalidate\n   * — they fire per frame during a drag, which is exactly when the cache pays.\n   *\n   * A missed bump is a silent wrong answer: nodes painted in the wrong z-order,\n   * or unpickable. `renderOrder.test.ts` walks each structural op and asserts\n   * the order moved.\n   */\n  let structureGeneration = 0;\n  let orderCache: {\n    gen: number;\n    ids?: NodeId[];\n    nodes?: Node<TData, TLayer, TPose>[];\n    byLayer?: Map<TLayer, Node<TData, TLayer, TPose>[]>;\n  } = { gen: 0 };\n\n  function invalidate(): void {\n    structureGeneration++;\n  }\n\n  const EMPTY_NODES: readonly Node<TData, TLayer, TPose>[] = [];\n\n  function currentOrderCache(): typeof orderCache {\n    if (orderCache.gen !== structureGeneration) {\n      orderCache = { gen: structureGeneration };\n    }\n    return orderCache;\n  }\n\n  function renderOrderFlat(): NodeId[] {\n    const only = state.layers[0].id;\n    const out: NodeId[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  function renderOrderNodesFlat(): Node<TData, TLayer, TPose>[] {\n    const only = state.layers[0].id;\n    const out: Node<TData, TLayer, TPose>[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  /** One DFS of the tree, bucketed by layer: appending in preorder keeps each\n   *  bucket in preorder, so concatenating them is the layer-major sequence. */\n  function renderOrderBucketed(): NodeId[] {\n    const buckets: NodeId[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: NodeId[] = [];\n    for (const bucket of buckets) {\n      for (const id of bucket) out.push(id);\n    }\n    return out;\n  }\n\n  function renderOrderNodesBucketed(): Node<TData, TLayer, TPose>[] {\n    const buckets: Node<TData, TLayer, TPose>[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: Node<TData, TLayer, TPose>[] = [];\n    for (const bucket of buckets) {\n      for (const node of bucket) out.push(node);\n    }\n    return out;\n  }\n\n  return {\n    ids() {\n      const c = currentOrderCache();\n      return (c.ids ??= walkIds());\n    },\n    nodes() {\n      const c = currentOrderCache();\n      return (c.nodes ??= walkNodes());\n    },\n    nodesOnLayer(layer) {\n      const c = currentOrderCache();\n      let byLayer = c.byLayer;\n      if (!byLayer) {\n        byLayer = new Map();\n        for (const node of (c.nodes ??= walkNodes())) {\n          let bucket = byLayer.get(node.layer);\n          if (!bucket) byLayer.set(node.layer, (bucket = []));\n          bucket.push(node);\n        }\n        c.byLayer = byLayer;\n      }\n      return byLayer.get(layer) ?? EMPTY_NODES;\n    },\n    invalidate,\n  };\n}\n"],"mappings":"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"}