@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/scene/nodeMemo.js

@@ -1,28 +1,54 @@
 //#region src/core/scene/nodeMemo.ts
-var e = /* @__PURE__ */ new WeakMap(), t = 0;
-function n(n, r, i, a) {
-	let o = e.get(n);
-	o === void 0 ? (o = {
-		generation: t,
-		slots: /* @__PURE__ */ new Map()
-	}, e.set(n, o)) : o.generation !== t && (o.generation = t, o.slots.clear());
-	let s = n.data, c = o.slots.get(r);
-	if (c !== void 0 && c.pose === i && c.data === s) return c.value;
-	let l = a();
-	return c === void 0 ? o.slots.set(r, {
+function e() {
+	return /* @__PURE__ */ new WeakMap();
+}
+var t = /* @__PURE__ */ new WeakMap(), n = 0;
+function r(e, r, a, o) {
+	if (typeof r != "string") return i(e, r, a, o);
+	let s = t.get(e);
+	s === void 0 ? (s = {
+		generation: n,
+		slots: /* @__PURE__ */ new Map(),
+		drops: 0
+	}, t.set(e, s)) : s.generation !== n && (s.generation = n, s.slots.clear());
+	let c = e.data, l = s.slots.get(r);
+	if (l !== void 0 && l.pose === a && l.data === c) return l.value;
+	let u = o();
+	return l === void 0 ? s.slots.set(r, {
+		pose: a,
+		data: c,
+		value: u
+	}) : (l.pose = a, l.data = c, l.value = u), u;
+}
+function i(e, r, i, a) {
+	let o = r, s = e.data, c = t.get(e)?.drops ?? 0, l = o.get(e);
+	if (l !== void 0 && l.generation === n && l.pose === i && l.data === s && (i === void 0 || l.drops === c)) return l.value;
+	let u = a(), d = t.get(e)?.drops ?? 0;
+	return l === void 0 ? o.set(e, {
 		pose: i,
 		data: s,
-		value: l
-	}) : (c.pose = i, c.data = s, c.value = l), l;
+		value: u,
+		generation: n,
+		drops: d
+	}) : (l.pose = i, l.data = s, l.value = u, l.generation = n, l.drops = d), u;
 }
-function r() {
-	t++;
+function a() {
+	n++;
 }
-function i(t) {
-	let n = e.get(t);
-	if (n !== void 0) for (let [e, t] of n.slots) t.pose !== void 0 && n.slots.delete(e);
+function o(e) {
+	let r = t.get(e);
+	if (r === void 0) {
+		t.set(e, {
+			generation: n,
+			slots: /* @__PURE__ */ new Map(),
+			drops: 1
+		});
+		return;
+	}
+	r.drops++;
+	for (let [e, t] of r.slots) t.pose !== void 0 && r.slots.delete(e);
 }
 //#endregion
-export { r as bumpNodeMemoGeneration, i as dropPoseKeyedMemoSlots, n as nodeMemo };
+export { a as bumpNodeMemoGeneration, e as createNodeMemoScope, o as dropPoseKeyedMemoSlots, r as nodeMemo };
 
 //# sourceMappingURL=nodeMemo.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodeMemo.js","names":["MEMO","generation","nodeMemo","record","node","data","hit","slot","pose","value","derive","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}\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,\n  pose: unknown,\n  derive: () => T,\n): T {\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map() };\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\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) return;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AA8CA,IAAMA,oBAAO,IAAI,QAAgC,GAI7CC,IAAa;AA2BjB,SAAgBC,EACd,GACA,GACA,GACA,GACG;CACH,IAAIC,IAASH,EAAK,IAAII,CAAI;CAC1B,AAAID,MAAW,KAAA,KACb,IAAS;EAAE;EAAY,uBAAO,IAAI,IAAI;CAAE,GACxCH,EAAK,IAAII,GAAMD,CAAM,KACZA,EAAO,eAAeF,MAC/B,EAAO,aAAaA,GACpBE,EAAO,MAAM,MAAM;CAGrB,IAAME,IAAOD,EAAK,MACZE,IAAMH,EAAO,MAAM,IAAII,CAAI;CACjC,IAAID,MAAQ,KAAA,KAAaA,EAAI,SAASE,KAAQF,EAAI,SAASD,GACzD,OAAOC,EAAI;CAGb,IAAMG,IAAQC,EAAO;CAUrB,OAPIJ,MAAQ,KAAA,IAKVH,EAAO,MAAM,IAAII,GAAM;EAAE;EAAM;EAAM;CAAM,CAAC,KAJ5C,EAAI,OAAOC,GACX,EAAI,OAAOH,GACX,EAAI,QAAQI,IAIPA;AACT;AAaA,SAAgBE,IAA+B;CAC7C;AACF;AAaA,SAAgBC,EAAuB,GAA4B;CACjE,IAAMT,IAASH,EAAK,IAAII,CAAI;CAC5B,IAAID,MAAW,KAAA,GACf,KAAK,IAAM,CAACI,GAAMM,MAAUV,EAAO,OACjC,AAAIU,EAAM,SAAS,KAAA,KAAWV,EAAO,MAAM,OAAOI,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

@@ -0,0 +1,127 @@
+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 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 d(e) {
+		if (l.size === 0) return;
+		let n = e;
+		for (; n !== null;) {
+			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 = e.parent;
+		}
+	}
+	function f(e, t) {
+		t === "children" ? l.add(e) : l.delete(e);
+	}
+	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 m(e) {
+		let t = a.nodes.get(e);
+		if (!t) throw new i(`Scene: unknown node id "${e}"`);
+		return t;
+	}
+	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 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), o(), {
+			parent: t.parent,
+			index: r
+		};
+	}
+	function _(e, t, n) {
+		let r = h(t), i = Math.max(0, Math.min(n, r.length));
+		r.splice(i, 0, e);
+		let a = m(e);
+		a.parent = t, o();
+	}
+	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 y(e) {
+		let t = [], n = /* @__PURE__ */ new Set();
+		function r(e) {
+			if (n.has(e)) return;
+			n.add(e), t.push(e);
+			let 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 c.transitiveDependentsOf(t[e])) r(n);
+		return {
+			ids: t,
+			removing: n
+		};
+	}
+	let b = /* @__PURE__ */ new WeakMap();
+	function x(e, t, n) {
+		let r = a.nodes.get(t);
+		if (r === void 0) return;
+		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), i.set(t, n)));
+		}
+		n && i.size > 0 && b.set(n, i);
+	}
+	function S(e, t) {
+		if (!t) return;
+		let i = e;
+		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: 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 { a 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","SceneMembershipError","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 { SceneMembershipError } from './staleReplay';\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 SceneMembershipError(`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/notifier.js

@@ -0,0 +1,37 @@
+import { createEmitter as e } from "@weasel-js/registry";
+//#region src/core/scene/notifier.ts
+function t() {
+	let t = e(), n = 0, r = 0, i = !1;
+	return {
+		notify() {
+			if (n++, r > 0) {
+				i = !0;
+				return;
+			}
+			t.emit();
+		},
+		version: () => n,
+		subscribe: t.subscribe,
+		deferred(e, n) {
+			r++;
+			try {
+				return e();
+			} finally {
+				r--, n?.(), r === 0 && i && (i = !1, t.emit());
+			}
+		},
+		muted(e) {
+			let t = i;
+			r++;
+			try {
+				return e();
+			} finally {
+				r--, i = t;
+			}
+		}
+	};
+}
+//#endregion
+export { t as createNotifier };
+
+//# sourceMappingURL=notifier.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.js","names":["createNotifier","changed","createEmitter","version","held","pending","fn","settle","was"],"sources":["../../../src/core/scene/notifier.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\n\n/**\n * The scene's change notice: its version, its subscribers, and when a change\n * reaches them.\n */\nexport interface Notifier {\n  /** Count a change, and call the subscribers unless the call is held. */\n  notify(): void;\n  version(): number;\n  subscribe(listener: () => void): () => void;\n  /** Run `fn` with the calls it causes held, then make one for all of them\n   *  once the outermost holder is done. `settle` runs between the two: after\n   *  this holder has let go, before any subscriber is called. */\n  deferred<T>(fn: () => T, settle?: () => void): T;\n  /** Run `fn` with the calls it causes held and then dropped: its caller\n   *  notifies once itself. The version still counts each one. */\n  muted<T>(fn: () => T): T;\n}\n\nexport function createNotifier(): Notifier {\n  const changed = createEmitter();\n  let version = 0;\n  let held = 0;\n  let pending = false;\n\n  return {\n    notify() {\n      version++;\n      if (held > 0) {\n        pending = true;\n        return;\n      }\n      changed.emit();\n    },\n    version: () => version,\n    subscribe: changed.subscribe,\n    deferred(fn, settle) {\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        settle?.();\n        if (held === 0 && pending) {\n          pending = false;\n          changed.emit();\n        }\n      }\n    },\n    muted(fn) {\n      const was = pending;\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        pending = was;\n      }\n    },\n  };\n}\n"],"mappings":";;AAoBA,SAAgBA,IAA2B;CACzC,IAAMC,IAAUC,EAAc,GAC1BC,IAAU,GACVC,IAAO,GACPC,IAAU;CAEd,OAAO;EACL,SAAS;GAEP,IADA,KACID,IAAO,GAAG;IACZ,IAAU;IACV;GACF;GACA,EAAQ,KAAK;EACf;EACA,eAAeD;EACf,WAAWF,EAAQ;EACnB,SAAS,GAAI,GAAQ;GACnB;GACA,IAAI;IACF,OAAOK,EAAG;GACZ,UAAU;IAGR,AAFA,KACAC,IAAS,GACLH,MAAS,KAAKC,MAChB,IAAU,IACVJ,EAAQ,KAAK;GAEjB;EACF;EACA,MAAM,GAAI;GACR,IAAMO,IAAMH;GACZ;GACA,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IAER,AADA,KACA,IAAUE;GACZ;EACF;CACF;AACF"}

package/dist/core/scene/opTable.js

@@ -0,0 +1,50 @@
+//#region src/core/scene/opTable.ts
+function e(e) {
+	let t = /* @__PURE__ */ new Map();
+	function n(e) {
+		let n = t.get(e);
+		if (!n) throw Error(`Scene: no registered op for kind "${e}"`);
+		return n;
+	}
+	function r(e, n) {
+		let r;
+		if (e.startsWith("kit:")) {
+			if (typeof n != "object" || !n) return;
+			let e = n;
+			r = typeof e.id == "string" ? e.id : typeof e.layer == "string" ? e.layer : void 0;
+		} else r = t.get(e)?.coalesceKey?.(n);
+		return r === void 0 ? void 0 : `${e}:${r}`;
+	}
+	function i(t, a, o = !0) {
+		return n(t), {
+			name: t,
+			args: a,
+			coalesceKey: r(t, a),
+			apply: () => {
+				let r = () => {
+					let r = n(t);
+					if (e.skips(t, a, o)) return "noop";
+					(o ? r.apply : r.revert)(a), e.applied(t, a, !o);
+				};
+				if (e.driven()) return r();
+				let i;
+				return e.replayAlone(() => {
+					i = r();
+				}), i;
+			},
+			invert: () => i(t, a, !o)
+		};
+	}
+	return {
+		handlers: t,
+		register: (e, n) => {
+			t.set(e, n);
+		},
+		run: (e, t) => n(e).apply(t),
+		op: (e, t) => i(e, t)
+	};
+}
+//#endregion
+export { e as createOpTable };
+
+//# sourceMappingURL=opTable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opTable.js","names":["createOpTable","handlers","handlerFor","handler","kind","coalesceKeyFor","token","payload","p","op","run","env","forward","result"],"sources":["../../../src/core/scene/opTable.ts"],"sourcesContent":["/**\n * The scene's registered ops: the kit's own kinds and a consumer's, each a\n * pair of functions over a serializable payload, and the engine `Op` built\n * from one.\n */\nimport type { Op } from 'core/ops/types';\nimport type { RegisteredOp } from './types';\n\n/** What the table asks of the scene when one of its ops runs. */\nexport interface OpTableEnv {\n  /** Whether replaying this op would address a node that is no longer where\n   *  its entry left it; such an op reports a no-op. */\n  skips(kind: string, payload: unknown, forward: boolean): boolean;\n  /** Called after an op built by {@link OpTable.op} has applied, with the\n   *  direction it ran in. */\n  applied(kind: string, payload: unknown, reverted: boolean): void;\n  /** Whether an edit of the scene's is running. An op applied outside one\n   *  is a replay by a history the scene does not own: a mode journal's undo,\n   *  redo or cancel. */\n  driven(): boolean;\n  /** Run `step` as a replay step of its own, and notify. */\n  replayAlone(step: () => void): void;\n}\n\nexport interface OpTable {\n  handlers: ReadonlyMap<string, RegisteredOp<unknown>>;\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  /** Apply a kind's forward half. Throws when nothing is registered for it. */\n  run(kind: string, payload: unknown): void;\n  /** A registered op as an engine `Op`. `invert()` flips the direction with\n   *  the same payload, so undo replays `revert` and redo replays `apply`.\n   *  The handler is looked up at apply time, so a re-registered kind takes\n   *  effect on replay; that one exists is checked here, to fail at the call\n   *  site. */\n  op(kind: string, payload: unknown): Op;\n}\n\nexport function createOpTable(env: OpTableEnv): OpTable {\n  const handlers = new Map<string, RegisteredOp<unknown>>();\n\n  function handlerFor(kind: string): RegisteredOp<unknown> {\n    const handler = handlers.get(kind);\n    if (!handler) throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n    return handler;\n  }\n\n  /** Coalesce-grouping key. Kit ops are keyed by the node or layer they\n   *  address; a consumer kind only by the `coalesceKey` it declares. Keys\n   *  take effect only under `UseSceneOptions.coalesceWindowMs`. */\n  function coalesceKeyFor(kind: string, payload: unknown): string | undefined {\n    let token: string | undefined;\n    if (kind.startsWith('kit:')) {\n      if (payload === null || typeof payload !== 'object') return undefined;\n      const p = payload as { id?: unknown; layer?: unknown };\n      token =\n        typeof p.id === 'string' ? p.id\n        : typeof p.layer === 'string' ? p.layer\n        : undefined;\n    } else {\n      token = handlers.get(kind)?.coalesceKey?.(payload);\n    }\n    return token === undefined ? undefined : `${kind}:${token}`;\n  }\n\n  function op(kind: string, payload: unknown, forward = true): Op {\n    handlerFor(kind);\n    return {\n      name: kind,\n      args: payload,\n      coalesceKey: coalesceKeyFor(kind, payload),\n      apply: () => {\n        const run = (): 'noop' | undefined => {\n          const handler = handlerFor(kind);\n          if (env.skips(kind, payload, forward)) return 'noop';\n          (forward ? handler.apply : handler.revert)(payload);\n          env.applied(kind, payload, !forward);\n          return undefined;\n        };\n        if (env.driven()) return run();\n        let result: 'noop' | undefined;\n        env.replayAlone(() => { result = run(); });\n        return result;\n      },\n      invert: () => op(kind, payload, !forward),\n    };\n  }\n\n  return {\n    handlers,\n    register: (kind, handler) => { handlers.set(kind, handler); },\n    run: (kind, payload) => handlerFor(kind).apply(payload),\n    op: (kind, payload) => op(kind, payload),\n  };\n}\n"],"mappings":";AAqCA,SAAgBA,EAAc,GAA0B;CACtD,IAAMC,oBAAW,IAAI,IAAmC;CAExD,SAASC,EAAW,GAAqC;EACvD,IAAMC,IAAUF,EAAS,IAAIG,CAAI;EACjC,IAAI,CAACD,GAAS,MAAU,MAAM,qCAAqCC,EAAK,EAAE;EAC1E,OAAOD;CACT;CAKA,SAASE,EAAe,GAAc,GAAsC;EAC1E,IAAIC;EACJ,IAAIF,EAAK,WAAW,MAAM,GAAG;GAC3B,IAAwB,OAAOG,KAAY,aAAvCA,GAAiD;GACrD,IAAMC,IAAID;GACV,IACE,OAAOC,EAAE,MAAO,WAAWA,EAAE,KAC3B,OAAOA,EAAE,SAAU,WAAWA,EAAE,QAChC,KAAA;EACN,OACE,IAAQP,EAAS,IAAIG,CAAI,CAAC,EAAE,cAAcG,CAAO;EAEnD,OAAOD,MAAU,KAAA,IAAY,KAAA,IAAY,GAAGF,EAAK,GAAGE;CACtD;CAEA,SAASG,EAAG,GAAc,GAAkB,IAAU,IAAU;EAE9D,OADAP,EAAWE,CAAI,GACR;GACL,MAAMA;GACN,MAAMG;GACN,aAAaF,EAAeD,GAAMG,CAAO;GACzC,aAAa;IACX,IAAMG,UAAgC;KACpC,IAAMP,IAAUD,EAAWE,CAAI;KAC/B,IAAIO,EAAI,MAAMP,GAAMG,GAASK,CAAO,GAAG,OAAO;KAE9C,CADCA,IAAUT,EAAQ,QAAQA,EAAQ,OAAA,CAAQI,CAAO,GAClDI,EAAI,QAAQP,GAAMG,GAAS,CAACK,CAAO;IAErC;IACA,IAAID,EAAI,OAAO,GAAG,OAAOD,EAAI;IAC7B,IAAIG;IAEJ,OADAF,EAAI,kBAAkB;KAAE,IAASD,EAAI;IAAG,CAAC,GAClCG;GACT;GACA,cAAcJ,EAAGL,GAAMG,GAAS,CAACK,CAAO;EAC1C;CACF;CAEA,OAAO;EACL;EACA,WAAW,GAAM,MAAY;GAAE,EAAS,IAAIR,GAAMD,CAAO;EAAG;EAC5D,MAAM,GAAM,MAAYD,EAAWE,CAAI,CAAC,CAAC,MAAMG,CAAO;EACtD,KAAK,GAAM,MAAYE,EAAGL,GAAMG,CAAO;CACzC;AACF"}

package/dist/core/scene/outerOps.js

@@ -0,0 +1,66 @@
+import { rebuildOp as e } from "../ops/registry.js";
+import { bindOpToAdapter as t, bindOpToHistoryAdapter as n } from "./boundOps.js";
+//#region src/core/scene/outerOps.ts
+function r(e, t) {
+	let n = t === void 0 || e.coalesceKey === void 0 ? void 0 : `${t}>${e.coalesceKey}`;
+	return {
+		name: e.name,
+		args: e.args,
+		coalesceKey: n,
+		apply: e.apply,
+		invert: e.invert
+	};
+}
+function i(i) {
+	let a = null, o = i.getActiveJournal;
+	function s(e, t = e) {
+		if (e.caused) return e;
+		let n = [t];
+		return {
+			get name() {
+				return e.name;
+			},
+			get args() {
+				return e.args;
+			},
+			label: e.label,
+			get coalesceKey() {
+				return e.coalesceKey;
+			},
+			elideNoop: e.elideNoop,
+			apply(a) {
+				let { result: o, ops: s } = i.recorder().capturing(() => t.apply(a));
+				return s.length > 0 && (n = s.map((t) => r(t, e.coalesceKey))), o;
+			},
+			caused: () => n,
+			invert: () => t.invert()
+		};
+	}
+	return {
+		rebuild(t, r) {
+			let o = i.own(t, r);
+			if (o !== null) return o;
+			let s = e(t, r);
+			return s === null ? null : n(s, () => a);
+		},
+		causing: (e) => s(e),
+		apply(e, n, r, a) {
+			if (i.recorder().joins()) return i.recorder().join(n, a);
+			let c = o?.() ?? null;
+			i.driving(() => {
+				let i = n.map((e) => s(e, t(e, a)));
+				c ? c.applyBatch(i, r) : e.applyOps(i, r);
+			});
+		},
+		setHistoryAdapter(e) {
+			a = e;
+		},
+		setActiveJournalAccessor(e) {
+			o = e;
+		}
+	};
+}
+//#endregion
+export { i as createOuterOps };
+
+//# sourceMappingURL=outerOps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outerOps.js","names":["rebuildGlobalOp","keyed","key","outerKey","kit","createOuterOps","historyAdapter","activeJournal","env","causing","op","caused","given","adapter","ops","result","own","name","args","rebuilt","rebuildOp","bindOpToHistoryAdapter","journal","bound","bindOpToAdapter","label","engine","fn"],"sources":["../../../src/core/scene/outerOps.ts"],"sourcesContent":["/**\n * Ops built outside the scene and handed to `applyBatch` or `scene.history`.\n *\n * An undo entry holds the scene's own ops, so an outer op is recorded as the\n * kit ops it caused. One that wrote no scene state is recorded as itself, and\n * needs an adapter to replay through: the one it was applied with, or after a\n * reload the one `setHistoryAdapter` supplies.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { rebuildOp as rebuildGlobalOp } from 'core/ops/registry';\nimport { bindOpToAdapter, bindOpToHistoryAdapter } from './boundOps';\nimport type { Recorder } from './recorder';\n\n/** What the outer ops need from the scene they are applied to. */\nexport interface OuterOpsEnv {\n  /** The scene's own op for a kind it has registered, or `null`. */\n  own(name: string, args: unknown): Op | null;\n  /** The scene's recorder, built after this is. */\n  recorder(): Pick<Recorder, 'capturing' | 'joins' | 'join'>;\n  /** Run a step that applies ops through a history engine: all-or-nothing,\n   *  unrecorded by the scene, with subscribers called once after. */\n  driving(step: () => void): void;\n  /** Where `applyBatch` looks for an open journal until an accessor is set. */\n  getActiveJournal: (() => Journal | null) | null;\n}\n\nexport interface OuterOps {\n  /** The op a restored history names: the scene's own, or an outer op bound\n   *  to the adapter `setHistoryAdapter` supplies. `null` when nothing knows\n   *  the name, and the engine places its no-op placeholder. */\n  rebuild(name: string, args: unknown): Op | null;\n  /** `op` as an engine applies it: its entry records the kit ops it caused,\n   *  or the op itself when it caused none. */\n  causing(op: Op): Op;\n  /** Apply `ops` against `adapter` as one entry: part of the open `batch`\n   *  when there is one, else on the active journal, else on `engine`. */\n  apply(engine: History, ops: Op[], label: string, adapter: unknown): void;\n  setHistoryAdapter(fn: (() => unknown) | null): void;\n  setActiveJournalAccessor(fn: (() => Journal | null) | null): void;\n}\n\n/** A kit op under the key of the outer op that caused it, so two edits merge\n *  when their outer ops would have. */\nfunction keyed(kit: Op, outerKey: string | undefined): Op {\n  const key = outerKey === undefined || kit.coalesceKey === undefined ? undefined : `${outerKey}>${kit.coalesceKey}`;\n  return { name: kit.name, args: kit.args, coalesceKey: key, apply: kit.apply, invert: kit.invert };\n}\n\nexport function createOuterOps(env: OuterOpsEnv): OuterOps {\n  let historyAdapter: (() => unknown) | null = null;\n  let activeJournal = env.getActiveJournal;\n\n  function causing(op: Op, given: Op = op): Op {\n    if (op.caused) return op;\n    let caused: Op[] = [given];\n    return {\n      get name() { return op.name; },\n      get args() { return op.args; },\n      label: op.label,\n      // Read when asked: an arrange op has no key until it has applied.\n      get coalesceKey() { return op.coalesceKey; },\n      elideNoop: op.elideNoop,\n      apply(adapter) {\n        const { result, ops } = env.recorder().capturing(() => given.apply(adapter));\n        if (ops.length > 0) caused = ops.map((kit) => keyed(kit, op.coalesceKey));\n        return result;\n      },\n      caused: () => caused,\n      invert: () => given.invert(),\n    };\n  }\n\n  return {\n    rebuild(name, args) {\n      const own = env.own(name, args);\n      if (own !== null) return own;\n      const rebuilt = rebuildGlobalOp(name, args);\n      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt, () => historyAdapter);\n    },\n    causing: (op) => causing(op),\n    apply(engine, ops, label, adapter) {\n      if (env.recorder().joins()) return env.recorder().join(ops, adapter);\n      const journal = activeJournal?.() ?? null;\n      env.driving(() => {\n        // Neither engine was built with an adapter, so an op is bound to\n        // this call's before either applies or stores it.\n        const bound = ops.map((op) => causing(op, bindOpToAdapter(op, adapter)));\n        if (journal) journal.applyBatch(bound, label);\n        else engine.applyOps(bound, label);\n      });\n    },\n    setHistoryAdapter(fn) {\n      historyAdapter = fn;\n    },\n    setActiveJournalAccessor(fn) {\n      activeJournal = fn;\n    },\n  };\n}\n"],"mappings":";;;AA4CA,SAASC,EAAM,GAAS,GAAkC;CACxD,IAAMC,IAAMC,MAAa,KAAA,KAAaC,EAAI,gBAAgB,KAAA,IAAY,KAAA,IAAY,GAAGD,EAAS,GAAGC,EAAI;CACrG,OAAO;EAAE,MAAMA,EAAI;EAAM,MAAMA,EAAI;EAAM,aAAaF;EAAK,OAAOE,EAAI;EAAO,QAAQA,EAAI;CAAO;AAClG;AAEA,SAAgBC,EAAe,GAA4B;CACzD,IAAIC,IAAyC,MACzCC,IAAgBC,EAAI;CAExB,SAASC,EAAQ,GAAQ,IAAYC,GAAQ;EAC3C,IAAIA,EAAG,QAAQ,OAAOA;EACtB,IAAIC,IAAe,CAACC,CAAK;EACzB,OAAO;GACL,IAAI,OAAO;IAAE,OAAOF,EAAG;GAAM;GAC7B,IAAI,OAAO;IAAE,OAAOA,EAAG;GAAM;GAC7B,OAAOA,EAAG;GAEV,IAAI,cAAc;IAAE,OAAOA,EAAG;GAAa;GAC3C,WAAWA,EAAG;GACd,MAAM,GAAS;IACb,IAAM,EAAE,WAAQ,WAAQF,EAAI,SAAS,CAAC,CAAC,gBAAgBI,EAAM,MAAMC,CAAO,CAAC;IAE3E,OADIC,EAAI,SAAS,MAAG,IAASA,EAAI,KAAK,MAAQb,EAAMG,GAAKM,EAAG,WAAW,CAAC,IACjEK;GACT;GACA,cAAcJ;GACd,cAAcC,EAAM,OAAO;EAC7B;CACF;CAEA,OAAO;EACL,QAAQ,GAAM,GAAM;GAClB,IAAMI,IAAMR,EAAI,IAAIS,GAAMC,CAAI;GAC9B,IAAIF,MAAQ,MAAM,OAAOA;GACzB,IAAMG,IAAUnB,EAAgBiB,GAAMC,CAAI;GAC1C,OAAOC,MAAY,OAAO,OAAOE,EAAuBF,SAAeb,CAAc;EACvF;EACA,UAAU,MAAOG,EAAQC,CAAE;EAC3B,MAAM,GAAQ,GAAK,GAAO,GAAS;GACjC,IAAIF,EAAI,SAAS,CAAC,CAAC,MAAM,GAAG,OAAOA,EAAI,SAAS,CAAC,CAAC,KAAKM,GAAKD,CAAO;GACnE,IAAMS,IAAUf,IAAgB,KAAK;GACrC,EAAI,cAAc;IAGhB,IAAMgB,IAAQT,EAAI,KAAK,MAAOL,EAAQC,GAAIc,EAAgBd,GAAIG,CAAO,CAAC,CAAC;IACvE,AAAIS,IAASA,EAAQ,WAAWC,GAAOE,CAAK,IACvCC,EAAO,SAASH,GAAOE,CAAK;GACnC,CAAC;EACH;EACA,kBAAkB,GAAI;GACpB,IAAiBE;EACnB;EACA,yBAAyB,GAAI;GAC3B,IAAgBA;EAClB;CACF;AACF"}

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":";;;AA4BA,IAAMA,IAAQ,OAAO,OAAO,CAAC,CAAC;AAY9B,SAAgBC,EACd,GACgC;CAChC,IAAIC,IAA2D,MAC3DC,IAAc,IACdC,IAAiB,IACjBC,IAAoCL,GAElCM,IAAYC,EAAc,GAC1BC,IAASF,EAAU,MACrBG,IAA8B,MAE5BC,UAID;EACH,IAAMC,IAAOT,GACPU,IAA0C,CAAC,GAC3CC,IAA4C,CAAC,GAC7CC,IAAoB,CAAC,GACrBC,oBAAO,IAAI,IAA4C;EAE7D,KAAK,IAAM,CAACC,GAAIC,MAASC,EAAM,OAAO;GACpC,IAAMC,IAAOC,EAAcF,GAAOD,CAAI;GACtC,EAAK,IAAID,GAAI;IAAE;IAAM,MAAMC,EAAK;IAAM,OAAOA,EAAK;GAAM,CAAC;GACzD,IAAMI,IAASV,EAAK,IAAIK,CAAE;GAC1B,AAAIK,MAAW,KAAA,IAAWT,EAAM,KAAK;IAAE;IAAM;GAAK,CAAC,KAC1CS,EAAO,SAASF,KAAQE,EAAO,SAASJ,EAAK,QAAQI,EAAO,UAAUJ,EAAK,UAClFJ,EAAQ,KAAK;IAAE;IAAM;GAAK,CAAC;EAE/B;EACA,KAAK,IAAMG,KAAML,EAAK,KAAK,GAAG,AAAKI,EAAK,IAAIC,CAAE,KAAGF,EAAQ,KAAKE,CAAE;EAGhE,OADA,IAAOD,GACA;GAAE;GAAO;GAAS;EAAQ;CACnC,GAEMO,WAGJ,oBAAO,IAAI,IAAI,GACf,IAAcJ,EAAM,WAAW,GAC/B,IAAiBA,EAAM,UAAU,cAAc,GAC/C,IAAiBA,EAAM,UAAU,IAAI,GAC9B;EAAE,GAAGR,EAAK;EAAG,SAASV;EAAO,SAASA;EAAO,OAAO;CAAK;CAGlE,OAAO;EACL,UAAU,GAAI;GACZ,IAAMuB,IAAMjB,EAAU,UAAUkB,CAAE;GAClC,IAAIf,MAAW,MAAM;IACnB,IAAMgB,IAAWP,EAAM,UAAUV,CAAM,GACjCkB,IAAeR,EAAM,UAAU,UAAUV,CAAM;IACrD,UAAe;KAEb,AADAiB,EAAS,GACTC,EAAa;IACf;GACF;GACA,aAAa;IAEX,AADAH,EAAI,GACAjB,EAAU,SAAS,KAAKG,MAAW,SACrCA,EAAO,GACP,IAAS;GAEb;EACF;EACA,OAAO;GACL,IAAIP,MAAS,MAAM,OAAOoB,EAAQ;GAElC,IAAMK,IAAUT,EAAM,WAAW,GAC3BU,IAAaV,EAAM,UAAU,cAAc,GAC3CW,IAAiBF,MAAYxB,GAC7B2B,IAAiBF,MAAexB;GAEtC,IAAI,CAACyB,KAAkB,CAACC,GACtB,OAAO;IAAE,OAAO9B;IAAO,SAASA;IAAO,SAASA;IAAO,OAAO;GAAM;GAGtE,IAAM+B,IAAOF,IACTnB,EAAK,IACL;IACE,OAAO,CAAC;IACR,SAAS,CAAC;IACV,SAAS,CAAC;GACZ;GAGJ,IAFA,IAAciB,GAEVG,GAAgB;IAClB,IAAME,IAAMd,EAAM,UAAU,IAAI,GAC1Be,IAAU,IAAI,IAAYD,CAAG;IACnC,KAAK,IAAMhB,KAAMX,GAAgB,EAAQ,IAAIW,CAAE;IAC/C,IAAMkB,IAAU,IAAI,IAAIH,EAAK,QAAQ,KAAK,MAAMI,EAAE,KAAK,EAAE,CAAC;IAC1D,KAAK,IAAMnB,KAAMiB,GAAS;KACxB,IAAIC,EAAQ,IAAIlB,CAAE,GAAG;KACrB,IAAMC,IAAOC,EAAM,IAAIF,CAAE;KACzB,AAAIC,MAAS,KAAA,KAAWc,EAAK,QAAQ,KAAK;MAAE;MAAM,MAAMX,EAAcF,GAAOD,CAAI;KAAE,CAAC;IACtF;IAEA,AADA,IAAiBW,GACjB,IAAiBI;GACnB;GAEA,OAAO;IAAE,GAAGD;IAAM,OAAO;GAAM;EACjC;CACF;AACF"}