@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/scene/nodeMemo.js

@@ -1,54 +1,106 @@
 //#region src/core/scene/nodeMemo.ts
-function e() {
+function createNodeMemoScope() {
 	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;
+var MEMO = /* @__PURE__ */ new WeakMap();
+/** Bumped whenever ambient state a derivation reads has changed. Entries
+*  stamped with an older value are dropped rather than served stale. */
+var generation = 0;
+/**
+* Return the value `derive` produces for `node`, recomputing only when the
+* node's `data` reference, the given `pose` reference, or the global
+* generation has changed since the last call for this `slot`.
+*
+* `slot` names the derivation, so a node's several derived values do not
+* overwrite each other.
+*
+* `pose` is a **parameter rather than a read off the node**, because callers
+* legitimately derive against a pose that isn't `node.pose`: a preview or
+* ghost pose mid-drag. Pass `undefined` for derivations that don't depend on
+* the pose at all, leaving `data` as the only key.
+*/
+function nodeMemo(node, slot, pose, derive) {
+	if (typeof slot !== "string") return scopedNodeMemo(node, slot, pose, derive);
+	let record = MEMO.get(node);
+	if (record === void 0) {
+		record = {
+			generation,
+			slots: /* @__PURE__ */ new Map(),
+			drops: 0
+		};
+		MEMO.set(node, record);
+	} else if (record.generation !== generation) {
+		record.generation = generation;
+		record.slots.clear();
+	}
+	const data = node.data;
+	const hit = record.slots.get(slot);
+	if (hit !== void 0 && hit.pose === pose && hit.data === data) return hit.value;
+	const value = derive();
+	if (hit !== void 0) {
+		hit.pose = pose;
+		hit.data = data;
+		hit.value = value;
+	} else record.slots.set(slot, {
+		pose,
+		data,
+		value
+	});
+	return value;
 }
-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: u,
-		generation: n,
-		drops: d
-	}) : (l.pose = i, l.data = s, l.value = u, l.generation = n, l.drops = d), u;
+function scopedNodeMemo(node, scope, pose, derive) {
+	const entries = scope;
+	const data = node.data;
+	const drops = MEMO.get(node)?.drops ?? 0;
+	const hit = entries.get(node);
+	if (hit !== void 0 && hit.generation === generation && hit.pose === pose && hit.data === data && (pose === void 0 || hit.drops === drops)) return hit.value;
+	const value = derive();
+	const dropsNow = MEMO.get(node)?.drops ?? 0;
+	if (hit !== void 0) {
+		hit.pose = pose;
+		hit.data = data;
+		hit.value = value;
+		hit.generation = generation;
+		hit.drops = dropsNow;
+	} else entries.set(node, {
+		pose,
+		data,
+		value,
+		generation,
+		drops: dropsNow
+	});
+	return value;
 }
-function a() {
-	n++;
+/**
+* Drop every memoized slot on every node. For owners of ambient state that
+* changes what a `derive` would return. Cheap — it bumps a counter.
+*/
+function bumpNodeMemoGeneration() {
+	generation++;
 }
-function o(e) {
-	let r = t.get(e);
-	if (r === void 0) {
-		t.set(e, {
-			generation: n,
+/**
+* Drop the slots of `node` that were keyed on a pose, keeping the ones that
+* weren't.
+*
+* For per-frame pose overrides, which mutate one buffer in place rather than
+* replacing the reference, which the `(pose, data)` key cannot see.
+* {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every
+* static node's slots too, every frame.
+*/
+function dropPoseKeyedMemoSlots(node) {
+	const record = MEMO.get(node);
+	if (record === void 0) {
+		MEMO.set(node, {
+			generation,
 			slots: /* @__PURE__ */ new Map(),
 			drops: 1
 		});
 		return;
 	}
-	r.drops++;
-	for (let [e, t] of r.slots) t.pose !== void 0 && r.slots.delete(e);
+	record.drops++;
+	for (const [slot, entry] of record.slots) if (entry.pose !== void 0) record.slots.delete(slot);
 }
-//#endregion
-export { a as bumpNodeMemoGeneration, e as createNodeMemoScope, o as dropPoseKeyedMemoSlots, r as nodeMemo };
 
+//#endregion
+export { bumpNodeMemoGeneration, createNodeMemoScope, dropPoseKeyedMemoSlots, nodeMemo };
 //# sourceMappingURL=nodeMemo.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodeMemo.js","names":["createNodeMemoScope","MEMO","generation","nodeMemo","slot","scopedNodeMemo","node","pose","derive","record","data","hit","value","entries","scope","drops","dropsNow","bumpNodeMemoGeneration","dropPoseKeyedMemoSlots","entry"],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * 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"}
+{"version":3,"file":"nodeMemo.js","names":[],"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,SAAgB,sBAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAM,uBAAO,IAAI,QAAgC;;;AAIjD,IAAI,aAAa;;;;;;;;;;;;;;AAmBjB,SAAgB,SACd,MACA,MACA,MACA,QACG;CACH,IAAI,OAAO,SAAS,UAAU,OAAO,eAAe,MAAM,MAAM,MAAM,MAAM;CAC5E,IAAI,SAAS,KAAK,IAAI,IAAI;CAC1B,IAAI,WAAW,QAAW;EACxB,SAAS;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE;EAClD,KAAK,IAAI,MAAM,MAAM;CACvB,OAAO,IAAI,OAAO,eAAe,YAAY;EAC3C,OAAO,aAAa;EACpB,OAAO,MAAM,MAAM;CACrB;CAEA,MAAM,OAAO,KAAK;CAClB,MAAM,MAAM,OAAO,MAAM,IAAI,IAAI;CACjC,IAAI,QAAQ,UAAa,IAAI,SAAS,QAAQ,IAAI,SAAS,MACzD,OAAO,IAAI;CAGb,MAAM,QAAQ,OAAO;CAGrB,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;CACd,OACE,OAAO,MAAM,IAAI,MAAM;EAAE;EAAM;EAAM;CAAM,CAAC;CAE9C,OAAO;AACT;AAEA,SAAS,eACP,MACA,OACA,MACA,QACG;CACH,MAAM,UAAU;CAChB,MAAM,OAAO,KAAK;CAClB,MAAM,QAAQ,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;CACvC,MAAM,MAAM,QAAQ,IAAI,IAAI;CAC5B,IACE,QAAQ,UAAa,IAAI,eAAe,cAAc,IAAI,SAAS,QAAQ,IAAI,SAAS,SACpF,SAAS,UAAa,IAAI,UAAU,QAExC,OAAO,IAAI;CAEb,MAAM,QAAQ,OAAO;CAErB,MAAM,WAAW,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;CAC1C,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;EACZ,IAAI,aAAa;EACjB,IAAI,QAAQ;CACd,OACE,QAAQ,IAAI,MAAM;EAAE;EAAM;EAAM;EAAO;EAAY,OAAO;CAAS,CAAC;CAEtE,OAAO;AACT;;;;;AAYA,SAAgB,yBAA+B;CAC7C;AACF;;;;;;;;;;AAWA,SAAgB,uBAAuB,MAA4B;CACjE,MAAM,SAAS,KAAK,IAAI,IAAI;CAC5B,IAAI,WAAW,QAAW;EACxB,KAAK,IAAI,MAAM;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE,CAAC;EACzD;CACF;CACA,OAAO;CACP,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,OACjC,IAAI,MAAM,SAAS,QAAW,OAAO,MAAM,OAAO,IAAI;AAE1D"}

package/dist/core/scene/nodeStore.js

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

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

@@ -1 +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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"}
+{"version":3,"file":"nodeStore.js","names":[],"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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"}