@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/scene/poseHold.js

@@ -0,0 +1,39 @@
+//#region src/core/scene/poseHold.ts
+function e(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+	return {
+		set(r) {
+			n.clear();
+			for (let [i, a] of r) {
+				n.add(i);
+				let r = t.get(i);
+				if (r) {
+					r.pose = a;
+					continue;
+				}
+				let o = { pose: a };
+				t.set(i, o), e.set(i, o);
+			}
+			for (let [r, i] of t) n.has(r) || (t.delete(r), e.get(r) === i && e.clear(r));
+			e.commit();
+		},
+		others() {
+			let n = /* @__PURE__ */ new Map();
+			for (let r of e.ids()) {
+				let i = e.get(r);
+				i !== void 0 && i !== t.get(r) && i.pose !== void 0 && n.set(r, i.pose);
+			}
+			return n;
+		},
+		drop() {
+			if (t.size !== 0) {
+				for (let [n, r] of t) e.get(n) === r && e.clear(n);
+				t.clear(), e.commit();
+			}
+		}
+	};
+}
+//#endregion
+export { e as createPoseHold };
+
+//# sourceMappingURL=poseHold.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseHold.js","names":["createPoseHold","held","seen","id","pose","poses","existing","entry","table","out"],"sources":["../../../src/core/scene/poseHold.ts"],"sourcesContent":["import type { NodeId, PoseHold, PoseOverride, PoseOverrides } from './types';\n\n/** The table methods a hold writes through. */\ntype HoldTable<TPose> = Pick<PoseOverrides<TPose>, 'set' | 'get' | 'ids' | 'clear' | 'commit'>;\n\n/** Build the {@link PoseHold} a table hands out from `hold()`. */\nexport function createPoseHold<TPose>(table: HoldTable<TPose>): PoseHold<TPose> {\n  /** The entry published per id, held by reference so a frame mutates it in place. */\n  const held = new Map<NodeId, PoseOverride<TPose>>();\n  const seen = new Set<NodeId>();\n\n  return {\n    set(poses) {\n      seen.clear();\n      for (const [id, pose] of poses) {\n        seen.add(id);\n        const existing = held.get(id);\n        if (existing) {\n          existing.pose = pose;\n          continue;\n        }\n        const entry: PoseOverride<TPose> = { pose };\n        held.set(id, entry);\n        // `table.set` notifies per call, so an id is set once and mutated after.\n        table.set(id, entry);\n      }\n      for (const [id, entry] of held) {\n        if (seen.has(id)) continue;\n        held.delete(id);\n        if (table.get(id) === entry) table.clear(id);\n      }\n      table.commit();\n    },\n    others() {\n      const out = new Map<NodeId, TPose>();\n      for (const id of table.ids()) {\n        const entry = table.get(id);\n        if (entry === undefined || entry === held.get(id) || entry.pose === undefined) continue;\n        out.set(id, entry.pose);\n      }\n      return out;\n    },\n    drop() {\n      if (held.size === 0) return;\n      for (const [id, entry] of held) {\n        if (table.get(id) === entry) table.clear(id);\n      }\n      held.clear();\n      table.commit();\n    },\n  };\n}\n"],"mappings":";AAMA,SAAgBA,EAAsB,GAA0C;CAE9E,IAAMC,oBAAO,IAAI,IAAiC,GAC5CC,oBAAO,IAAI,IAAY;CAE7B,OAAO;EACL,IAAI,GAAO;GACT,EAAK,MAAM;GACX,KAAK,IAAM,CAACC,GAAIC,MAASC,GAAO;IAC9B,EAAK,IAAIF,CAAE;IACX,IAAMG,IAAWL,EAAK,IAAIE,CAAE;IAC5B,IAAIG,GAAU;KACZ,EAAS,OAAOF;KAChB;IACF;IACA,IAAMG,IAA6B,EAAE,QAAK;IAG1C,AAFAN,EAAK,IAAIE,GAAII,CAAK,GAElBC,EAAM,IAAIL,GAAII,CAAK;GACrB;GACA,KAAK,IAAM,CAACJ,GAAII,MAAUN,GACxB,AAAIC,EAAK,IAAIC,CAAE,MACfF,EAAK,OAAOE,CAAE,GACVK,EAAM,IAAIL,CAAE,MAAMI,KAAOC,EAAM,MAAML,CAAE;GAE7C,EAAM,OAAO;EACf;EACA,SAAS;GACP,IAAMM,oBAAM,IAAI,IAAmB;GACnC,KAAK,IAAMN,KAAMK,EAAM,IAAI,GAAG;IAC5B,IAAMD,IAAQC,EAAM,IAAIL,CAAE;IAC1B,AAAII,MAAU,KAAA,KAAaA,MAAUN,EAAK,IAAIE,CAAE,KAAKI,EAAM,SAAS,KAAA,KACpEE,EAAI,IAAIN,GAAII,EAAM,IAAI;GACxB;GACA,OAAOE;EACT;EACA,OAAO;GACL,IAAIR,EAAK,SAAS,GAClB;SAAK,IAAM,CAACE,GAAII,MAAUN,GACxB,AAAIO,EAAM,IAAIL,CAAE,MAAMI,KAAOC,EAAM,MAAML,CAAE;IAG7C,AADAF,EAAK,MAAM,GACXO,EAAM,OAAO;GAHgC;EAI/C;CACF;AACF"}

package/dist/core/scene/poseOverrides.js

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"poseSnapshot.js","names":["DEPTH","isTypedArray","v","snapshotPose","depth","value","isPlainObject","out","key","field","samePoseValue","snapshot","proto","isPlainPrototype","a","b","count","left","right","_key","i"],"sources":["../../../src/core/scene/poseSnapshot.ts"],"sourcesContent":["import { isPlainObject, isPlainPrototype } from '../isPlainObject';\n/**\n * Comparing a pose against what it was, by value.\n *\n * For readers that cannot be told when a pose moved. A pose override mutates\n * its buffer in place, so holding the pose object and comparing references\n * sees nothing; holding a *copy* of its values and comparing those sees the\n * move without anyone pushing an invalidation.\n *\n * `TPose` is opaque to the kit — a consumer's pose is whatever it declared —\n * so both sides walk plain objects, arrays and typed arrays, and fall back to\n * reference identity for anything else (a class instance, a `Map`). A pose of\n * that shape mutated in place still needs the scene's pushed invalidation,\n * which is unchanged either way.\n */\n\n/** How deep the walk goes before it stops copying and keeps the reference.\n *  A pose is a handful of numbers; nothing legitimate is nested this far. */\nconst DEPTH = 4;\n\nfunction isTypedArray(v: unknown): v is ArrayLike<number> & { slice(): unknown } {\n  return ArrayBuffer.isView(v) && !(v instanceof DataView);\n}\n\n/** A copy of `value` that later mutation of `value` cannot reach. */\nexport function snapshotPose<T>(value: T, depth = DEPTH): T {\n  if (depth <= 0) return value;\n  if (Array.isArray(value)) {\n    return value.map((v) => snapshotPose(v, depth - 1)) as unknown as T;\n  }\n  if (isTypedArray(value)) return value.slice() as unknown as T;\n  if (isPlainObject(value)) {\n    // Spread first, then replace only the fields that need a copy of their\n    // own: a built-up object lands in a different hidden class than the pose\n    // it mirrors, which costs the per-frame compare several times over.\n    const out: Record<string, unknown> = { ...value };\n    for (const key in out) {\n      const field = out[key];\n      if (typeof field === 'object' && field !== null) out[key] = snapshotPose(field, depth - 1);\n    }\n    return out as unknown as T;\n  }\n  return value;\n}\n\n/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates\n *  nothing, and takes the plain-object branch first: this runs per dependency\n *  per frame, and a pose is an object of numbers nearly every time. */\nexport function samePoseValue(snapshot: unknown, value: unknown, depth = DEPTH): boolean {\n  if (snapshot === value) return true;\n  if (typeof snapshot !== 'object' || snapshot === null\n    || typeof value !== 'object' || value === null) return Object.is(snapshot, value);\n  if (depth <= 0) return false;\n\n  const proto = Object.getPrototypeOf(snapshot) as object | null;\n  if (isPlainPrototype(proto)) {\n    if (!isPlainPrototype(Object.getPrototypeOf(value) as object | null)) return false;\n    const a = snapshot as Record<string, unknown>;\n    const b = value as Record<string, unknown>;\n    let count = 0;\n    for (const key in a) {\n      count++;\n      const left = a[key];\n      const right = b[key];\n      if (left === right) {\n        if (right === undefined && !(key in b)) return false;\n        continue;\n      }\n      if (!samePoseValue(left, right, depth - 1)) return false;\n    }\n    // A field `value` gained is a change too, and the key counts are what say so.\n    for (const _key in b) if (--count < 0) return false;\n    return true;\n  }\n\n  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {\n    const a = snapshot as ArrayLike<unknown>;\n    if (!(Array.isArray(value) || isTypedArray(value))) return false;\n    const b = value as ArrayLike<unknown>;\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!samePoseValue(a[i], b[i], depth - 1)) return false;\n    }\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;AAkBA,IAAMA,IAAQ;AAEd,SAASC,EAAa,GAA2D;CAC/E,OAAO,YAAY,OAAOC,CAAC,KAAK,EAAEA,aAAa;AACjD;AAGA,SAAgBC,EAAgB,GAAU,IAAQH,GAAU;CAC1D,IAAII,KAAS,GAAG,OAAOC;CACvB,IAAI,MAAM,QAAQA,CAAK,GACrB,OAAOA,EAAM,KAAK,MAAMF,EAAaD,GAAGE,IAAQ,CAAC,CAAC;CAEpD,IAAIH,EAAaI,CAAK,GAAG,OAAOA,EAAM,MAAM;CAC5C,IAAIC,EAAcD,CAAK,GAAG;EAIxB,IAAME,IAA+B,EAAE,GAAGF,EAAM;EAChD,KAAK,IAAMG,KAAOD,GAAK;GACrB,IAAME,IAAQF,EAAIC;GAClB,AAAI,OAAOC,KAAU,YAAYA,MAAgB,EAAID,KAAOL,EAAaM,GAAOL,IAAQ,CAAC;EAC3F;EACA,OAAOG;CACT;CACA,OAAOF;AACT;AAKA,SAAgBK,EAAc,GAAmB,GAAgB,IAAQV,GAAgB;CACvF,IAAIW,MAAaN,GAAO,OAAO;CAC/B,IAAI,OAAOM,KAAa,aAAYA,KAC/B,OAAON,KAAU,aAAYA,GAAgB,OAAO,OAAO,GAAGM,GAAUN,CAAK;CAClF,IAAID,KAAS,GAAG,OAAO;CAEvB,IAAMQ,IAAQ,OAAO,eAAeD,CAAQ;CAC5C,IAAIE,EAAiBD,CAAK,GAAG;EAC3B,IAAI,CAACC,EAAiB,OAAO,eAAeR,CAAK,CAAkB,GAAG,OAAO;EAC7E,IAAMS,IAAIH,GACJI,IAAIV,GACNW,IAAQ;EACZ,KAAK,IAAMR,KAAOM,GAAG;GACnB;GACA,IAAMG,IAAOH,EAAEN,IACTU,IAAQH,EAAEP;GAChB,IAAIS,MAASC,GAAO;IAClB,IAAIA,MAAU,KAAA,KAAa,EAAEV,KAAOO,IAAI,OAAO;IAC/C;GACF;GACA,IAAI,CAACL,EAAcO,GAAMC,GAAOd,IAAQ,CAAC,GAAG,OAAO;EACrD;EAEA,KAAK,IAAMe,KAAQJ,GAAG,IAAI,EAAEC,IAAQ,GAAG,OAAO;EAC9C,OAAO;CACT;CAEA,IAAI,MAAM,QAAQL,CAAQ,KAAKV,EAAaU,CAAQ,GAAG;EACrD,IAAMG,IAAIH;EACV,IAAI,EAAE,MAAM,QAAQN,CAAK,KAAKJ,EAAaI,CAAK,IAAI,OAAO;EAC3D,IAAMU,IAAIV;EACV,IAAIS,EAAE,WAAWC,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAIK,IAAI,GAAGA,IAAIN,EAAE,QAAQ,KAC5B,IAAI,CAACJ,EAAcI,EAAEM,IAAIL,EAAEK,IAAIhB,IAAQ,CAAC,GAAG,OAAO;EAEpD,OAAO;CACT;CACA,OAAO;AACT"}
+{"version":3,"file":"poseSnapshot.js","names":["DEPTH","isTypedArray","v","snapshotPose","depth","value","isPlainObject","out","key","field","samePoseValue","snapshot","proto","isPlainPrototype","a","b","count","left","right","_key","i"],"sources":["../../../src/core/scene/poseSnapshot.ts"],"sourcesContent":["import { isPlainObject, isPlainPrototype } from '../isPlainObject';\n/**\n * Comparing a pose against what it was, by value.\n *\n * For readers that cannot be told when a pose moved: a pose override mutates\n * its buffer in place, so comparing references sees nothing.\n *\n * `TPose` is opaque to the kit, so both sides walk plain objects, arrays, and\n * typed arrays, and fall back to reference identity for anything else (a\n * class instance, a `Map`). A pose of that shape mutated in place still needs\n * the scene's pushed invalidation.\n */\n\n/** How deep the walk goes before it stops copying and keeps the reference.\n *  A pose is a handful of numbers; nothing legitimate is nested this far. */\nconst DEPTH = 4;\n\nfunction isTypedArray(v: unknown): v is ArrayLike<number> & { slice(): unknown } {\n  return ArrayBuffer.isView(v) && !(v instanceof DataView);\n}\n\n/** A copy of `value` that later mutation of `value` cannot reach. */\nexport function snapshotPose<T>(value: T, depth = DEPTH): T {\n  if (depth <= 0) return value;\n  if (Array.isArray(value)) {\n    return value.map((v) => snapshotPose(v, depth - 1)) as unknown as T;\n  }\n  if (isTypedArray(value)) return value.slice() as unknown as T;\n  if (isPlainObject(value)) {\n    // Spread first, then replace only the fields that need a copy of their\n    // own: a built-up object lands in a different hidden class than the pose\n    // it mirrors, which costs the per-frame compare several times over.\n    const out: Record<string, unknown> = { ...value };\n    for (const key in out) {\n      const field = out[key];\n      if (typeof field === 'object' && field !== null) out[key] = snapshotPose(field, depth - 1);\n    }\n    return out as unknown as T;\n  }\n  return value;\n}\n\n/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates\n *  nothing, and takes the plain-object branch first: this runs per dependency\n *  per frame, and a pose is an object of numbers nearly every time. */\nexport function samePoseValue(snapshot: unknown, value: unknown, depth = DEPTH): boolean {\n  if (snapshot === value) return true;\n  if (typeof snapshot !== 'object' || snapshot === null\n    || typeof value !== 'object' || value === null) return Object.is(snapshot, value);\n  if (depth <= 0) return false;\n\n  const proto = Object.getPrototypeOf(snapshot) as object | null;\n  if (isPlainPrototype(proto)) {\n    if (!isPlainPrototype(Object.getPrototypeOf(value) as object | null)) return false;\n    const a = snapshot as Record<string, unknown>;\n    const b = value as Record<string, unknown>;\n    let count = 0;\n    for (const key in a) {\n      count++;\n      const left = a[key];\n      const right = b[key];\n      if (left === right) {\n        if (right === undefined && !(key in b)) return false;\n        continue;\n      }\n      if (!samePoseValue(left, right, depth - 1)) return false;\n    }\n    // A field `value` gained is a change too, and the key counts are what say so.\n    for (const _key in b) if (--count < 0) return false;\n    return true;\n  }\n\n  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {\n    const a = snapshot as ArrayLike<unknown>;\n    if (!(Array.isArray(value) || isTypedArray(value))) return false;\n    const b = value as ArrayLike<unknown>;\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!samePoseValue(a[i], b[i], depth - 1)) return false;\n    }\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;AAeA,IAAMA,IAAQ;AAEd,SAASC,EAAa,GAA2D;CAC/E,OAAO,YAAY,OAAOC,CAAC,KAAK,EAAEA,aAAa;AACjD;AAGA,SAAgBC,EAAgB,GAAU,IAAQH,GAAU;CAC1D,IAAII,KAAS,GAAG,OAAOC;CACvB,IAAI,MAAM,QAAQA,CAAK,GACrB,OAAOA,EAAM,KAAK,MAAMF,EAAaD,GAAGE,IAAQ,CAAC,CAAC;CAEpD,IAAIH,EAAaI,CAAK,GAAG,OAAOA,EAAM,MAAM;CAC5C,IAAIC,EAAcD,CAAK,GAAG;EAIxB,IAAME,IAA+B,EAAE,GAAGF,EAAM;EAChD,KAAK,IAAMG,KAAOD,GAAK;GACrB,IAAME,IAAQF,EAAIC;GAClB,AAAI,OAAOC,KAAU,YAAYA,MAAgB,EAAID,KAAOL,EAAaM,GAAOL,IAAQ,CAAC;EAC3F;EACA,OAAOG;CACT;CACA,OAAOF;AACT;AAKA,SAAgBK,EAAc,GAAmB,GAAgB,IAAQV,GAAgB;CACvF,IAAIW,MAAaN,GAAO,OAAO;CAC/B,IAAI,OAAOM,KAAa,aAAYA,KAC/B,OAAON,KAAU,aAAYA,GAAgB,OAAO,OAAO,GAAGM,GAAUN,CAAK;CAClF,IAAID,KAAS,GAAG,OAAO;CAEvB,IAAMQ,IAAQ,OAAO,eAAeD,CAAQ;CAC5C,IAAIE,EAAiBD,CAAK,GAAG;EAC3B,IAAI,CAACC,EAAiB,OAAO,eAAeR,CAAK,CAAkB,GAAG,OAAO;EAC7E,IAAMS,IAAIH,GACJI,IAAIV,GACNW,IAAQ;EACZ,KAAK,IAAMR,KAAOM,GAAG;GACnB;GACA,IAAMG,IAAOH,EAAEN,IACTU,IAAQH,EAAEP;GAChB,IAAIS,MAASC,GAAO;IAClB,IAAIA,MAAU,KAAA,KAAa,EAAEV,KAAOO,IAAI,OAAO;IAC/C;GACF;GACA,IAAI,CAACL,EAAcO,GAAMC,GAAOd,IAAQ,CAAC,GAAG,OAAO;EACrD;EAEA,KAAK,IAAMe,KAAQJ,GAAG,IAAI,EAAEC,IAAQ,GAAG,OAAO;EAC9C,OAAO;CACT;CAEA,IAAI,MAAM,QAAQL,CAAQ,KAAKV,EAAaU,CAAQ,GAAG;EACrD,IAAMG,IAAIH;EACV,IAAI,EAAE,MAAM,QAAQN,CAAK,KAAKJ,EAAaI,CAAK,IAAI,OAAO;EAC3D,IAAMU,IAAIV;EACV,IAAIS,EAAE,WAAWC,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAIK,IAAI,GAAGA,IAAIN,EAAE,QAAQ,KAC5B,IAAI,CAACJ,EAAcI,EAAEM,IAAIL,EAAEK,IAAIhB,IAAQ,CAAC,GAAG,OAAO;EAEpD,OAAO;CACT;CACA,OAAO;AACT"}

package/dist/core/scene/reconcileSpecs.js

@@ -6,7 +6,7 @@ function t(e, t, a) {
 		let n = s.get(e);
 		(n === void 0 || r(t, n)) && c.push(e);
 	}
-	let l = e.removalClosure(c.filter((t) => e.get(t) !== void 0)), u = new Set(l);
+	let l = e.removalClosure(c.filter((t) => e.get(t) !== void 0)), u = new Set(l), d = e.getSelection();
 	e.untracked(() => {
 		e.removeMany(l);
 		for (let t of a) {
@@ -16,8 +16,9 @@ function t(e, t, a) {
 				continue;
 			}
 			let a = t.parent ?? null;
-			a !== (r.parent ?? null) && e.move(n, a), t.layer !== r.layer && e.setLayer(n, t.layer), i(t.data, r.data) || e.update(n, { data: t.data }), i(t.dependsOn, r.dependsOn) || e.setDependsOn(n, t.dependsOn), i(t.pose, r.pose) || e.setPose(n, t.pose);
+			a !== (r.parent ?? null) && e.move(n, a), t.layer !== r.layer && e.setLayer(n, t.layer), i(t.data, r.data) || e.update(n, { data: t.data }), i(t.dependsOn, r.dependsOn) || e.setDependsOn(n, t.dependsOn), t.kind === "container" && !i(t.units, r.units) && e.setUnits(n, t.units ?? null), i(t.pose, r.pose) || e.setPose(n, t.pose);
 		}
+		d.some((e) => u.has(e)) && e.setSelection(d.filter((t) => e.get(t) !== void 0));
 	});
 }
 function n(e) {

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

@@ -1 +1 @@
-{"version":3,"file":"reconcileSpecs.js","names":["reconcileSpecs","prevById","byId","prev","nextById","next","gone","id","before","after","needsReplace","removing","scene","removed","spec","parent","same","out","specs","a","b","v","i","isPlainObject","ka","k"],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\nimport type { AddNodeSpec, NodeId, Scene } from './types';\n\n/**\n * Bring `scene` from `prev` to `next`: add what `next` gained, remove what it\n * lost, and write only the fields that changed between the two.\n *\n * The diff is spec against spec, not spec against scene, so whatever the scene\n * did since `prev` — a node dragged, an edge authored by a gesture — survives\n * unless `next` changes that same field. The writes are untracked: syncing to\n * outside data is not an undo step.\n *\n * Every spec needs an `id`, and `next` must be in an order `createScene` would\n * accept — parents and dependencies before what names them. A node whose\n * `kind` or derive functions change is removed and added again, along with\n * everything its removal takes with it.\n */\nexport function reconcileSpecs<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  prev: readonly AddNodeSpec<TData, TLayer, TPose>[],\n  next: readonly AddNodeSpec<TData, TLayer, TPose>[],\n): void {\n  const prevById = byId(prev);\n  const nextById = byId(next);\n  const gone: NodeId[] = [];\n  for (const [id, before] of prevById) {\n    const after = nextById.get(id);\n    if (after === undefined || needsReplace(before, after)) gone.push(id);\n  }\n  const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== undefined));\n  const removed = new Set(removing);\n\n  scene.untracked(() => {\n    scene.removeMany(removing);\n    for (const spec of next) {\n      const id = spec.id!;\n      const before = prevById.get(id);\n      if (scene.get(id) === undefined || before === undefined || removed.has(id)) {\n        scene.add(spec);\n        continue;\n      }\n      const parent = spec.parent ?? null;\n      if (parent !== (before.parent ?? null)) scene.move(id, parent);\n      if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);\n      if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });\n      if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n    }\n  });\n}\n\nfunction byId<T extends { id?: NodeId }>(specs: readonly T[]): Map<NodeId, T> {\n  const out = new Map<NodeId, T>();\n  for (const spec of specs) {\n    if (spec.id === undefined) throw new Error('reconcileSpecs: every spec needs an id');\n    if (out.has(spec.id)) throw new Error(`reconcileSpecs: id \"${spec.id}\" appears more than once`);\n    out.set(spec.id, spec);\n  }\n  return out;\n}\n\nfunction needsReplace<TData, TLayer extends string, TPose>(\n  a: AddNodeSpec<TData, TLayer, TPose>,\n  b: AddNodeSpec<TData, TLayer, TPose>,\n): boolean {\n  return a.kind !== b.kind\n    || a.pickable !== b.pickable\n    || a.derivePath !== b.derivePath\n    || a.derivePose !== b.derivePose\n    || a.clipFromPose !== b.clipFromPose\n    || a.layout !== b.layout;\n}\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nfunction same(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((v, i) => same(v, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const ka = Object.keys(a);\n    return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":";;AAiBA,SAAgBA,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAWC,EAAKC,CAAI,GACpBC,IAAWF,EAAKG,CAAI,GACpBC,IAAiB,CAAC;CACxB,KAAK,IAAM,CAACC,GAAIC,MAAWP,GAAU;EACnC,IAAMQ,IAAQL,EAAS,IAAIG,CAAE;EAC7B,CAAIE,MAAU,KAAA,KAAaC,EAAaF,GAAQC,CAAK,MAAGH,EAAK,KAAKC,CAAE;CACtE;CACA,IAAMI,IAAWC,EAAM,eAAeN,EAAK,QAAQ,MAAOM,EAAM,IAAIL,CAAE,MAAM,KAAA,CAAS,CAAC,GAChFM,IAAU,IAAI,IAAIF,CAAQ;CAEhC,EAAM,gBAAgB;EACpB,EAAM,WAAWA,CAAQ;EACzB,KAAK,IAAMG,KAAQT,GAAM;GACvB,IAAME,IAAKO,EAAK,IACVN,IAASP,EAAS,IAAIM,CAAE;GAC9B,IAAIK,EAAM,IAAIL,CAAE,MAAM,KAAA,KAAaC,MAAW,KAAA,KAAaK,EAAQ,IAAIN,CAAE,GAAG;IAC1E,EAAM,IAAIO,CAAI;IACd;GACF;GACA,IAAMC,IAASD,EAAK,UAAU;GAK9B,AAJIC,OAAYP,EAAO,UAAU,SAAOI,EAAM,KAAKL,GAAIQ,CAAM,GACzDD,EAAK,UAAUN,EAAO,SAAOI,EAAM,SAASL,GAAIO,EAAK,KAAK,GACzDE,EAAKF,EAAK,MAAMN,EAAO,IAAI,KAAGI,EAAM,OAAOL,GAAI,EAAE,MAAMO,EAAK,KAAK,CAAC,GAClEE,EAAKF,EAAK,WAAWN,EAAO,SAAS,KAAGI,EAAM,aAAaL,GAAIO,EAAK,SAAS,GAC7EE,EAAKF,EAAK,MAAMN,EAAO,IAAI,KAAGI,EAAM,QAAQL,GAAIO,EAAK,IAAI;EAChE;CACF,CAAC;AACH;AAEA,SAASZ,EAAgC,GAAqC;CAC5E,IAAMe,oBAAM,IAAI,IAAe;CAC/B,KAAK,IAAMH,KAAQI,GAAO;EACxB,IAAIJ,EAAK,OAAO,KAAA,GAAW,MAAU,MAAM,wCAAwC;EACnF,IAAIG,EAAI,IAAIH,EAAK,EAAE,GAAG,MAAU,MAAM,uBAAuBA,EAAK,GAAG,yBAAyB;EAC9F,EAAI,IAAIA,EAAK,IAAIA,CAAI;CACvB;CACA,OAAOG;AACT;AAEA,SAASP,EACP,GACA,GACS;CACT,OAAOS,EAAE,SAASC,EAAE,QACfD,EAAE,aAAaC,EAAE,YACjBD,EAAE,eAAeC,EAAE,cACnBD,EAAE,eAAeC,EAAE,cACnBD,EAAE,iBAAiBC,EAAE,gBACrBD,EAAE,WAAWC,EAAE;AACtB;AAGA,SAASJ,EAAK,GAAY,GAAqB;CAC7C,IAAI,OAAO,GAAGG,GAAGC,CAAC,GAAG,OAAO;CAC5B,IAAI,MAAM,QAAQD,CAAC,KAAK,MAAM,QAAQC,CAAC,GACrC,OAAOD,EAAE,WAAWC,EAAE,UAAUD,EAAE,OAAO,GAAG,MAAMH,EAAKK,GAAGD,EAAEE,EAAE,CAAC;CAEjE,IAAIC,EAAcJ,CAAC,KAAKI,EAAcH,CAAC,GAAG;EACxC,IAAMI,IAAK,OAAO,KAAKL,CAAC;EACxB,OAAOK,EAAG,WAAW,OAAO,KAAKJ,CAAC,CAAC,CAAC,UAAUI,EAAG,OAAO,MAAMC,KAAKL,KAAKJ,EAAKG,EAAEM,IAAIL,EAAEK,EAAE,CAAC;CAC1F;CACA,OAAO;AACT"}
+{"version":3,"file":"reconcileSpecs.js","names":["reconcileSpecs","prevById","byId","prev","nextById","next","gone","id","before","after","needsReplace","removing","scene","removed","selected","spec","parent","same","out","specs","a","b","v","i","isPlainObject","ka","k"],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\nimport type { AddNodeSpec, NodeId, Scene } from './types';\n\n/**\n * Bring `scene` from `prev` to `next`: add what `next` gained, remove what it\n * lost, and write only the fields that changed between the two.\n *\n * The diff is spec against spec, not spec against scene, so whatever the scene\n * did since `prev` — a node dragged, an edge authored by a gesture — survives\n * unless `next` changes that same field. The writes are untracked: syncing to\n * outside data is not an undo step.\n *\n * Every spec needs an `id`, and `next` must be in an order `createScene` would\n * accept — parents and dependencies before what names them. A node whose\n * `kind` or derive functions change is removed and added again, along with\n * everything its removal takes with it, and stays selected if it was.\n */\nexport function reconcileSpecs<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  prev: readonly AddNodeSpec<TData, TLayer, TPose>[],\n  next: readonly AddNodeSpec<TData, TLayer, TPose>[],\n): void {\n  const prevById = byId(prev);\n  const nextById = byId(next);\n  const gone: NodeId[] = [];\n  for (const [id, before] of prevById) {\n    const after = nextById.get(id);\n    if (after === undefined || needsReplace(before, after)) gone.push(id);\n  }\n  const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== undefined));\n  const removed = new Set(removing);\n\n  // A replaced node is the same node to whoever selected it.\n  const selected = scene.getSelection();\n\n  scene.untracked(() => {\n    scene.removeMany(removing);\n    for (const spec of next) {\n      const id = spec.id!;\n      const before = prevById.get(id);\n      if (scene.get(id) === undefined || before === undefined || removed.has(id)) {\n        scene.add(spec);\n        continue;\n      }\n      const parent = spec.parent ?? null;\n      if (parent !== (before.parent ?? null)) scene.move(id, parent);\n      if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);\n      if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });\n      if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);\n      if (spec.kind === 'container' && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n    }\n    if (selected.some((id) => removed.has(id))) {\n      scene.setSelection(selected.filter((id) => scene.get(id) !== undefined));\n    }\n  });\n}\n\nfunction byId<T extends { id?: NodeId }>(specs: readonly T[]): Map<NodeId, T> {\n  const out = new Map<NodeId, T>();\n  for (const spec of specs) {\n    if (spec.id === undefined) throw new Error('reconcileSpecs: every spec needs an id');\n    if (out.has(spec.id)) throw new Error(`reconcileSpecs: id \"${spec.id}\" appears more than once`);\n    out.set(spec.id, spec);\n  }\n  return out;\n}\n\nfunction needsReplace<TData, TLayer extends string, TPose>(\n  a: AddNodeSpec<TData, TLayer, TPose>,\n  b: AddNodeSpec<TData, TLayer, TPose>,\n): boolean {\n  return a.kind !== b.kind\n    || a.pickable !== b.pickable\n    || a.derivePath !== b.derivePath\n    || a.derivePose !== b.derivePose\n    || a.clipFromPose !== b.clipFromPose\n    || a.layout !== b.layout;\n}\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nfunction same(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((v, i) => same(v, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const ka = Object.keys(a);\n    return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":";;AAiBA,SAAgBA,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAWC,EAAKC,CAAI,GACpBC,IAAWF,EAAKG,CAAI,GACpBC,IAAiB,CAAC;CACxB,KAAK,IAAM,CAACC,GAAIC,MAAWP,GAAU;EACnC,IAAMQ,IAAQL,EAAS,IAAIG,CAAE;EAC7B,CAAIE,MAAU,KAAA,KAAaC,EAAaF,GAAQC,CAAK,MAAGH,EAAK,KAAKC,CAAE;CACtE;CACA,IAAMI,IAAWC,EAAM,eAAeN,EAAK,QAAQ,MAAOM,EAAM,IAAIL,CAAE,MAAM,KAAA,CAAS,CAAC,GAChFM,IAAU,IAAI,IAAIF,CAAQ,GAG1BG,IAAWF,EAAM,aAAa;CAEpC,EAAM,gBAAgB;EACpB,EAAM,WAAWD,CAAQ;EACzB,KAAK,IAAMI,KAAQV,GAAM;GACvB,IAAME,IAAKQ,EAAK,IACVP,IAASP,EAAS,IAAIM,CAAE;GAC9B,IAAIK,EAAM,IAAIL,CAAE,MAAM,KAAA,KAAaC,MAAW,KAAA,KAAaK,EAAQ,IAAIN,CAAE,GAAG;IAC1E,EAAM,IAAIQ,CAAI;IACd;GACF;GACA,IAAMC,IAASD,EAAK,UAAU;GAM9B,AALIC,OAAYR,EAAO,UAAU,SAAOI,EAAM,KAAKL,GAAIS,CAAM,GACzDD,EAAK,UAAUP,EAAO,SAAOI,EAAM,SAASL,GAAIQ,EAAK,KAAK,GACzDE,EAAKF,EAAK,MAAMP,EAAO,IAAI,KAAGI,EAAM,OAAOL,GAAI,EAAE,MAAMQ,EAAK,KAAK,CAAC,GAClEE,EAAKF,EAAK,WAAWP,EAAO,SAAS,KAAGI,EAAM,aAAaL,GAAIQ,EAAK,SAAS,GAC9EA,EAAK,SAAS,eAAe,CAACE,EAAKF,EAAK,OAAOP,EAAO,KAAK,KAAGI,EAAM,SAASL,GAAIQ,EAAK,SAAS,IAAI,GAClGE,EAAKF,EAAK,MAAMP,EAAO,IAAI,KAAGI,EAAM,QAAQL,GAAIQ,EAAK,IAAI;EAChE;EACA,AAAID,EAAS,MAAM,MAAOD,EAAQ,IAAIN,CAAE,CAAC,KACvCK,EAAM,aAAaE,EAAS,QAAQ,MAAOF,EAAM,IAAIL,CAAE,MAAM,KAAA,CAAS,CAAC;CAE3E,CAAC;AACH;AAEA,SAASL,EAAgC,GAAqC;CAC5E,IAAMgB,oBAAM,IAAI,IAAe;CAC/B,KAAK,IAAMH,KAAQI,GAAO;EACxB,IAAIJ,EAAK,OAAO,KAAA,GAAW,MAAU,MAAM,wCAAwC;EACnF,IAAIG,EAAI,IAAIH,EAAK,EAAE,GAAG,MAAU,MAAM,uBAAuBA,EAAK,GAAG,yBAAyB;EAC9F,EAAI,IAAIA,EAAK,IAAIA,CAAI;CACvB;CACA,OAAOG;AACT;AAEA,SAASR,EACP,GACA,GACS;CACT,OAAOU,EAAE,SAASC,EAAE,QACfD,EAAE,aAAaC,EAAE,YACjBD,EAAE,eAAeC,EAAE,cACnBD,EAAE,eAAeC,EAAE,cACnBD,EAAE,iBAAiBC,EAAE,gBACrBD,EAAE,WAAWC,EAAE;AACtB;AAGA,SAASJ,EAAK,GAAY,GAAqB;CAC7C,IAAI,OAAO,GAAGG,GAAGC,CAAC,GAAG,OAAO;CAC5B,IAAI,MAAM,QAAQD,CAAC,KAAK,MAAM,QAAQC,CAAC,GACrC,OAAOD,EAAE,WAAWC,EAAE,UAAUD,EAAE,OAAO,GAAG,MAAMH,EAAKK,GAAGD,EAAEE,EAAE,CAAC;CAEjE,IAAIC,EAAcJ,CAAC,KAAKI,EAAcH,CAAC,GAAG;EACxC,IAAMI,IAAK,OAAO,KAAKL,CAAC;EACxB,OAAOK,EAAG,WAAW,OAAO,KAAKJ,CAAC,CAAC,CAAC,UAAUI,EAAG,OAAO,MAAMC,KAAKL,KAAKJ,EAAKG,EAAEM,IAAIL,EAAEK,EAAE,CAAC;CAC1F;CACA,OAAO;AACT"}

package/dist/core/scene/recorder.js

@@ -0,0 +1,86 @@
+import { bindOpToAdapter as e } from "./boundOps.js";
+//#region src/core/scene/recorder.ts
+function t(e) {
+	for (let t = e.length - 1; t >= 0; t--) try {
+		e[t].invert().apply(void 0);
+	} catch {}
+}
+function n(n) {
+	let { notifier: r, mode: i, engine: a, log: o, arrivals: s } = n, c = null, l = null;
+	function u(e, t) {
+		let r = e();
+		if (t) for (let e of s.settle()) n.writePose(e.id, e.to);
+		return r;
+	}
+	function d(e, l) {
+		let d = !i.open();
+		d && (c = {
+			label: e,
+			ops: [],
+			outer: [],
+			selectionBefore: n.selection()
+		});
+		let f = d && s.open(!0);
+		return r.deferred(() => i.during("batch", () => {
+			if (!d) return l();
+			try {
+				let e = o.atomically(() => u(l, f), () => (c?.ops.length ?? 0) > 0);
+				return f && s.emitReflow(), e;
+			} catch (e) {
+				throw t(c?.outer ?? []), c = null, e;
+			}
+		}), () => {
+			if (f && s.abandon(), !d || !c) return;
+			let e = c;
+			c = null, e.ops.length > 0 && a.recordEntry(e.ops, e.label, { selectionBefore: e.selectionBefore });
+		});
+	}
+	return {
+		record(e, t, s) {
+			i.records() && !c ? i.during("own", () => a.applyOps([n.makeOp(e, t)], s)) : (n.runOp(e, t), o.logApplied(e, t), i.records() ? c.ops.push(n.makeOp(e, t)) : i.untracked() || l?.push(n.makeOp(e, t))), r.notify();
+		},
+		edit: (e, t, n) => t && s.bareLayoutEdit() ? d(e, n) : n(),
+		batch: d,
+		untracked(e) {
+			let t = r.version(), n = s.open(!0);
+			return r.deferred(() => i.during("untracked", () => {
+				let t = o.atomically(() => u(e, n), () => !1);
+				return n && s.emitReflow(), t;
+			}), () => {
+				n && s.abandon(), r.version() !== t && a.seal();
+			});
+		},
+		joins: () => i.records() && c !== null,
+		join(n, r) {
+			let i = c, a = i.ops.length, s = [];
+			try {
+				o.atomically(() => {
+					for (let t of n) {
+						let n = i.ops.length, a = t.apply(r);
+						i.ops.length > n || a === !1 || a === "noop" || (s.push(e(t, r)), i.ops.push(s[s.length - 1]));
+					}
+				}, () => !1);
+			} catch (e) {
+				throw t(s), i.ops.length = a, e;
+			}
+			i.outer.push(...s);
+		},
+		capturing(e) {
+			let t = l, n = [];
+			l = n;
+			try {
+				return {
+					result: e(),
+					ops: n
+				};
+			} finally {
+				l = t;
+			}
+		},
+		engineDriven: (e) => i.during("engine", () => r.muted(e))
+	};
+}
+//#endregion
+export { n as createRecorder };
+
+//# sourceMappingURL=recorder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.js","names":["unwind","i","outer","createRecorder","env","collecting","captured","withArrivalsSettled","result","fn","owns","p","arrivals","batch","outermost","mode","ownsArrivals","notifier","log","err","finished","engine","kind","payload","label","touchesLayout","versionBefore","into","mark","op","ops","before","adapter","bindOpToAdapter","enclosing","step"],"sources":["../../../src/core/scene/recorder.ts"],"sourcesContent":["/**\n * How a scene mutation becomes an undo entry: recorded on its own, collected\n * into the batch it runs in, or left to the engine or the untracked run that\n * is driving it.\n */\nimport type { History } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport type { AppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { bindOpToAdapter } from './boundOps';\nimport type { EditMode } from './editMode';\nimport type { Notifier } from './notifier';\nimport type { NodeId } from './types';\n\n/** What the recorder needs from the scene it records for. */\nexport interface RecorderEnv {\n  notifier: Notifier;\n  mode: EditMode;\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Apply a registered op's forward half. */\n  runOp(kind: string, payload: unknown): void;\n  /** A registered op as the engine holds it. */\n  makeOp(kind: string, payload: unknown): Op;\n  log: AppliedLog;\n  arrivals: Pick<ArrivalWindow<unknown>, 'bareLayoutEdit' | 'open' | 'settle' | 'emitReflow' | 'abandon'>;\n  selection(): readonly NodeId[];\n  /** Write one pose an arrival settle decided. */\n  writePose(id: string, pose: unknown): void;\n}\n\nexport interface Recorder {\n  /** Apply a registered op as part of whatever edit is running. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run the recording half of a mutation. One that touches a laid-out\n   *  container, called bare, runs as a batch of its own: that is what puts\n   *  the arrangement it triggers in the same undo step. */\n  edit<T>(label: string, touchesLayout: boolean, fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  untracked<T>(fn: () => T): T;\n  /** Whether an edit made now would join an open `batch`'s entry. */\n  joins(): boolean;\n  /** Apply ops built outside the scene as part of the open `batch`, all or\n   *  none. Its entry holds the kit ops they cause, and beside them, bound to\n   *  `adapter`, any op that wrote no scene state. */\n  join(ops: Op[], adapter: unknown): void;\n  /** Run `step`, and answer with the kit ops applied during it. */\n  capturing<T>(step: () => T): { result: T; ops: Op[] };\n  /** Run `fn` as a history engine's step: the ops it applies may re-enter\n   *  scene mutation methods, which apply but do not record. The caller\n   *  notifies once after. */\n  engineDriven<T>(fn: () => T): T;\n}\n\n/** Take back ops that wrote outside the scene, newest first. The scene's own\n *  writes are reverted by the applied log. */\nfunction unwind(outer: readonly Op[]): void {\n  for (let i = outer.length - 1; i >= 0; i--) {\n    try {\n      outer[i].invert().apply(undefined);\n    } catch {\n      // The throw being unwound is the one the caller sees.\n    }\n  }\n}\n\nexport function createRecorder(env: RecorderEnv): Recorder {\n  const { notifier, mode, engine, log, arrivals } = env;\n  /** The outermost open batch, while it is recording. */\n  let collecting: { label: string; ops: Op[]; outer: Op[]; selectionBefore: readonly NodeId[] } | null = null;\n  /** The kit ops applied since the innermost `capturing` opened. */\n  let captured: Op[] | null = null;\n\n  /** `fn`, then the poses its arrivals settle to when this edit owns them. */\n  function withArrivalsSettled<T>(fn: () => T, owns: boolean): T {\n    const result = fn();\n    if (owns) for (const p of arrivals.settle()) env.writePose(p.id, p.to);\n    return result;\n  }\n\n  function batch<T>(label: string, fn: () => T): T {\n    const outermost = !mode.open();\n    // Captured at open, not at recordEntry: by the time the batch closes\n    // the selection has already moved to wherever the batch put it.\n    if (outermost) collecting = { label, ops: [], outer: [], selectionBefore: env.selection() };\n    const ownsArrivals = outermost && arrivals.open(true);\n    return notifier.deferred(() => mode.during('batch', () => {\n      if (!outermost) return fn();\n      try {\n        const result = log.atomically(\n          () => withArrivalsSettled(fn, ownsArrivals),\n          () => (collecting?.ops.length ?? 0) > 0,\n        );\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      } catch (err) {\n        // Reverted already; the half-built entry must not reach history.\n        unwind(collecting?.outer ?? []);\n        collecting = null;\n        throw err;\n      }\n    }), () => {\n      if (ownsArrivals) arrivals.abandon();\n      if (!outermost || !collecting) return;\n      const finished = collecting;\n      collecting = null;\n      // The ops were applied as they were issued, so the entry is pushed\n      // without re-applying.\n      if (finished.ops.length > 0) {\n        engine.recordEntry(finished.ops, finished.label, { selectionBefore: finished.selectionBefore });\n      }\n    });\n  }\n\n  return {\n    record(kind, payload, label) {\n      if (mode.records() && !collecting) {\n        // The engine applies the op itself, which is what lets it coalesce.\n        mode.during('own', () => engine.applyOps([env.makeOp(kind, payload)], label));\n      } else {\n        env.runOp(kind, payload);\n        log.logApplied(kind, payload);\n        if (mode.records()) collecting!.ops.push(env.makeOp(kind, payload));\n        else if (!mode.untracked()) captured?.push(env.makeOp(kind, payload));\n      }\n      notifier.notify();\n    },\n    edit: (label, touchesLayout, fn) => (touchesLayout && arrivals.bareLayoutEdit() ? batch(label, fn) : fn()),\n    batch,\n    untracked(fn) {\n      const versionBefore = notifier.version();\n      const ownsArrivals = arrivals.open(true);\n      return notifier.deferred(() => mode.during('untracked', () => {\n        const result = log.atomically(() => withArrivalsSettled(fn, ownsArrivals), () => false);\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      }), () => {\n        if (ownsArrivals) arrivals.abandon();\n        if (notifier.version() !== versionBefore) engine.seal();\n      });\n    },\n    joins: () => mode.records() && collecting !== null,\n    join(ops, adapter) {\n      const into = collecting!;\n      const mark = into.ops.length;\n      const outer: Op[] = [];\n      try {\n        log.atomically(() => {\n          for (const op of ops) {\n            const before = into.ops.length;\n            const result = op.apply(adapter);\n            if (into.ops.length > before || result === false || result === 'noop') continue;\n            outer.push(bindOpToAdapter(op, adapter));\n            into.ops.push(outer[outer.length - 1]);\n          }\n        }, () => false);\n      } catch (err) {\n        unwind(outer);\n        into.ops.length = mark;\n        throw err;\n      }\n      into.outer.push(...outer);\n    },\n    capturing(step) {\n      const enclosing = captured;\n      const ops: Op[] = [];\n      captured = ops;\n      try {\n        return { result: step(), ops };\n      } finally {\n        captured = enclosing;\n      }\n    },\n    engineDriven: (fn) => mode.during('engine', () => notifier.muted(fn)),\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/renderOrder.js

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

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

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