@weasel-js/core 1.12.0 → 1.13.0-rc.0

package/dist/core/scene/poseOverrides.js

@@ -1,11 +1,11 @@
 import { dropPoseKeyedMemoSlots } from "./nodeMemo.js";
+import { shownCopyOf } from "./nodeAsShown.js";
 import { createPoseHold } from "./poseHold.js";
+import { foldPlies } from "./posePlies.js";
+import { createPlyStacks, plyPath } from "./plyStacks.js";
 import { createEmitter } from "@weasel-js/registry";
-import { kit, last, mix, mul, patch } from "@msb235/blits";
 
 //#region src/core/scene/poseOverrides.ts
-/** What the table's voice says about a node it holds no entry for. */
-var NOTHING = Object.freeze({});
 /**
 * Build a {@link PoseOverrides} map.
 *
@@ -13,53 +13,48 @@ var NOTHING = Object.freeze({});
 * `onInvalidate` lets the scene invalidate derived nodes from the same
 * chokepoint.
 *
-* What `read` answers is a blits mix folded per node. The entries a writer
-* `set`s are one voice on it, and a node holding no entry is never probed.
+* What `read` answers is folded from the node's plies by `foldPlies`, its
+* path by `plyPath`; a node holding no entry is never probed.
 */
 function createPoseOverrides(getNode, onInvalidate) {
-	const entries = /* @__PURE__ */ new Map();
+	const stacks = createPlyStacks();
+	const { plies } = stacks;
+	const fold = foldPlies(plies);
 	const listeners = createEmitter();
 	let generation = 0;
-	const folded = mix(kit({
-		pose: last(),
-		alpha: mul(),
-		path: last()
-	}));
-	folded.cue({ patch: patch(0, (_phase, id) => entries.get(id) ?? NOTHING, { writes: [
-		"pose",
-		"alpha",
-		"path"
-	] }) });
-	let clock = 0;
-	folded.sync(clock);
-	/** Per node: the object `read` folds into and returns, and the generation
-	*  it was last folded at. */
+	/** Per node: the object `read` folds into and returns, the generation it
+	*  was last folded at, and the last path it carried. */
 	const reads = /* @__PURE__ */ new Map();
 	function invalidate(id) {
 		const node = getNode(id);
-		if (node) dropPoseKeyedMemoSlots(node);
+		if (node) {
+			dropPoseKeyedMemoSlots(node);
+			const shown = shownCopyOf(node);
+			if (shown) dropPoseKeyedMemoSlots(shown);
+		}
 		onInvalidate?.(id);
 	}
 	function published() {
 		generation++;
-		folded.sync(++clock);
+		fold.publish(stacks.depth());
 		listeners.emit();
 	}
 	function forget(id) {
 		reads.delete(id);
-		folded.drop(id);
+		fold.drop(id);
 	}
 	const table = {
 		set(id, entry) {
-			entries.set(id, entry);
+			stacks.claim(id, entry);
 			invalidate(id);
 			published();
 		},
 		get(id) {
-			return entries.get(id);
+			return plies.get(id)?.at(-1);
 		},
 		read(id) {
-			if (!entries.has(id)) return void 0;
+			const stack = plies.get(id);
+			if (stack === void 0) return void 0;
 			let held = reads.get(id);
 			if (held === void 0) {
 				held = {
@@ -69,41 +64,43 @@ function createPoseOverrides(getNode, onInvalidate) {
 				reads.set(id, held);
 			}
 			if (held.at !== generation) {
-				folded.probe(id, held.out);
+				fold.probe(id, held.out);
+				held.out.path = plyPath(stack, held.out.pose, held);
 				held.at = generation;
 			}
 			return held.out;
 		},
-		has(id) {
-			return entries.has(id);
+		has(id, entry) {
+			const stack = plies.get(id);
+			return stack !== void 0 && (entry === void 0 || stack.includes(entry));
 		},
 		ids() {
-			return [...entries.keys()];
+			return [...plies.keys()];
 		},
-		clear(id) {
-			if (!entries.delete(id)) return;
-			forget(id);
+		clear(id, entry) {
+			if (!(entry === void 0 ? stacks.drop(id) : stacks.release(id, entry))) return;
+			if (!plies.has(id)) forget(id);
 			invalidate(id);
 			published();
 		},
 		clearAll() {
-			if (entries.size === 0) return;
-			for (const id of entries.keys()) {
+			if (plies.size === 0) return;
+			for (const id of plies.keys()) {
 				forget(id);
 				invalidate(id);
 			}
-			entries.clear();
+			stacks.dropAll();
 			published();
 		},
 		commit() {
-			for (const id of entries.keys()) invalidate(id);
+			for (const id of plies.keys()) invalidate(id);
 			published();
 		},
 		subscribe: listeners.subscribe,
 		getGeneration() {
 			return generation;
 		},
-		hold: () => createPoseHold(table)
+		hold: () => createPoseHold(table, (id) => plies.get(id))
 	};
 	return table;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"poseOverrides.js","names":[],"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,IAAM,UAA+B,OAAO,OAAO,CAAC,CAAC;;;;;;;;;;;AAYrD,SAAgB,oBACd,SACA,cACsB;CACtB,MAAM,0BAAU,IAAI,IAAiC;CACrD,MAAM,YAAY,cAAc;CAChC,IAAI,aAAa;CAEjB,MAAM,SAAS,IACb,IAAyB;EAAE,MAAM,KAAyB;EAAG,OAAO,IAAI;EAAG,MAAM,KAAW;CAAE,CAAC,CACjG;CACA,OAAO,IAAI,EACT,OAAO,MACL,IACC,QAAQ,OAAO,QAAQ,IAAI,EAAE,KAAM,SACpC,EAAE,QAAQ;EAAC;EAAQ;EAAS;CAAM,EAAE,CACtC,EACF,CAAC;CAGD,IAAI,QAAQ;CACZ,OAAO,KAAK,KAAK;;;CAIjB,MAAM,wBAAQ,IAAI,IAAsD;CAExE,SAAS,WAAW,IAAkB;EACpC,MAAM,OAAO,QAAQ,EAAE;EACvB,IAAI,MAAM,uBAAuB,IAAI;EACrC,eAAe,EAAE;CACnB;CAEA,SAAS,YAAkB;EACzB;EACA,OAAO,KAAK,EAAE,KAAK;EACnB,UAAU,KAAK;CACjB;CAEA,SAAS,OAAO,IAAkB;EAChC,MAAM,OAAO,EAAE;EACf,OAAO,KAAK,EAAE;CAChB;CAEA,MAAM,QAA8B;EAClC,IAAI,IAAI,OAAO;GACb,QAAQ,IAAI,IAAI,KAAK;GACrB,WAAW,EAAE;GACb,UAAU;EACZ;EACA,IAAI,IAAI;GACN,OAAO,QAAQ,IAAI,EAAE;EACvB;EACA,KAAK,IAAI;GACP,IAAI,CAAC,QAAQ,IAAI,EAAE,GAAG,OAAO;GAC7B,IAAI,OAAO,MAAM,IAAI,EAAE;GACvB,IAAI,SAAS,QAAW;IACtB,OAAO;KAAE,KAAK,CAAC;KAAG,IAAI;IAAG;IACzB,MAAM,IAAI,IAAI,IAAI;GACpB;GACA,IAAI,KAAK,OAAO,YAAY;IAC1B,OAAO,MAAM,IAAI,KAAK,GAAG;IACzB,KAAK,KAAK;GACZ;GACA,OAAO,KAAK;EACd;EACA,IAAI,IAAI;GACN,OAAO,QAAQ,IAAI,EAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAG,QAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,IAAI;GACR,IAAI,CAAC,QAAQ,OAAO,EAAE,GAAG;GACzB,OAAO,EAAE;GACT,WAAW,EAAE;GACb,UAAU;EACZ;EACA,WAAW;GACT,IAAI,QAAQ,SAAS,GAAG;GACxB,KAAK,MAAM,MAAM,QAAQ,KAAK,GAAG;IAC/B,OAAO,EAAE;IACT,WAAW,EAAE;GACf;GACA,QAAQ,MAAM;GACd,UAAU;EACZ;EACA,SAAS;GACP,KAAK,MAAM,MAAM,QAAQ,KAAK,GAAG,WAAW,EAAE;GAC9C,UAAU;EACZ;EACA,WAAW,UAAU;EACrB,gBAAgB;GACd,OAAO;EACT;EACA,YAAY,eAAe,KAAK;CAClC;CACA,OAAO;AACT"}
+{"version":3,"file":"poseOverrides.js","names":[],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { shownCopyOf } from './nodeAsShown';\nimport { createPoseHold } from './poseHold';\nimport { foldPlies } from './posePlies';\nimport { createPlyStacks, plyPath, type CarriedPath } from './plyStacks';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\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 folded from the node's plies by `foldPlies`, its\n * path by `plyPath`; a node holding no entry is never probed.\n */\nexport function createPoseOverrides<TPose, TData = unknown>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose, TData> {\n  type Entry = PoseOverride<TPose, TData>;\n  const stacks = createPlyStacks<Entry>();\n  const { plies } = stacks;\n  const fold = foldPlies(plies);\n  const listeners = createEmitter();\n  let generation = 0;\n\n  /** Per node: the object `read` folds into and returns, the generation it\n   *  was last folded at, and the last path it carried. */\n  const reads = new Map<NodeId, { out: Entry; at: number; carried?: CarriedPath }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) {\n      dropPoseKeyedMemoSlots(node);\n      // A painter handed the node as it shows memoized against that copy.\n      const shown = shownCopyOf(node);\n      if (shown) dropPoseKeyedMemoSlots(shown);\n    }\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    fold.publish(stacks.depth());\n    listeners.emit();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    fold.drop(id);\n  }\n\n  const table: PoseOverrides<TPose, TData> = {\n    set(id, entry) {\n      stacks.claim(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return plies.get(id)?.at(-1);\n    },\n    read(id) {\n      const stack = plies.get(id);\n      if (stack === undefined) 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        fold.probe(id, held.out);\n        held.out.path = plyPath(stack, held.out.pose, held);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id, entry) {\n      const stack = plies.get(id);\n      return stack !== undefined && (entry === undefined || stack.includes(entry));\n    },\n    ids() {\n      return [...plies.keys()];\n    },\n    clear(id, entry) {\n      if (!(entry === undefined ? stacks.drop(id) : stacks.release(id, entry))) return;\n      if (!plies.has(id)) forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (plies.size === 0) return;\n      for (const id of plies.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      stacks.dropAll();\n      published();\n    },\n    commit() {\n      for (const id of plies.keys()) invalidate(id);\n      published();\n    },\n    subscribe: listeners.subscribe,\n    getGeneration() {\n      return generation;\n    },\n    hold: () => createPoseHold(table, (id) => plies.get(id)),\n  };\n  return table;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,oBACd,SACA,cAC6B;CAE7B,MAAM,SAAS,gBAAuB;CACtC,MAAM,EAAE,UAAU;CAClB,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,YAAY,cAAc;CAChC,IAAI,aAAa;;;CAIjB,MAAM,wBAAQ,IAAI,IAA+D;CAEjF,SAAS,WAAW,IAAkB;EACpC,MAAM,OAAO,QAAQ,EAAE;EACvB,IAAI,MAAM;GACR,uBAAuB,IAAI;GAE3B,MAAM,QAAQ,YAAY,IAAI;GAC9B,IAAI,OAAO,uBAAuB,KAAK;EACzC;EACA,eAAe,EAAE;CACnB;CAEA,SAAS,YAAkB;EACzB;EACA,KAAK,QAAQ,OAAO,MAAM,CAAC;EAC3B,UAAU,KAAK;CACjB;CAEA,SAAS,OAAO,IAAkB;EAChC,MAAM,OAAO,EAAE;EACf,KAAK,KAAK,EAAE;CACd;CAEA,MAAM,QAAqC;EACzC,IAAI,IAAI,OAAO;GACb,OAAO,MAAM,IAAI,KAAK;GACtB,WAAW,EAAE;GACb,UAAU;EACZ;EACA,IAAI,IAAI;GACN,OAAO,MAAM,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE;EAC7B;EACA,KAAK,IAAI;GACP,MAAM,QAAQ,MAAM,IAAI,EAAE;GAC1B,IAAI,UAAU,QAAW,OAAO;GAChC,IAAI,OAAO,MAAM,IAAI,EAAE;GACvB,IAAI,SAAS,QAAW;IACtB,OAAO;KAAE,KAAK,CAAC;KAAG,IAAI;IAAG;IACzB,MAAM,IAAI,IAAI,IAAI;GACpB;GACA,IAAI,KAAK,OAAO,YAAY;IAC1B,KAAK,MAAM,IAAI,KAAK,GAAG;IACvB,KAAK,IAAI,OAAO,QAAQ,OAAO,KAAK,IAAI,MAAM,IAAI;IAClD,KAAK,KAAK;GACZ;GACA,OAAO,KAAK;EACd;EACA,IAAI,IAAI,OAAO;GACb,MAAM,QAAQ,MAAM,IAAI,EAAE;GAC1B,OAAO,UAAU,WAAc,UAAU,UAAa,MAAM,SAAS,KAAK;EAC5E;EACA,MAAM;GACJ,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC;EACzB;EACA,MAAM,IAAI,OAAO;GACf,IAAI,EAAE,UAAU,SAAY,OAAO,KAAK,EAAE,IAAI,OAAO,QAAQ,IAAI,KAAK,IAAI;GAC1E,IAAI,CAAC,MAAM,IAAI,EAAE,GAAG,OAAO,EAAE;GAC7B,WAAW,EAAE;GACb,UAAU;EACZ;EACA,WAAW;GACT,IAAI,MAAM,SAAS,GAAG;GACtB,KAAK,MAAM,MAAM,MAAM,KAAK,GAAG;IAC7B,OAAO,EAAE;IACT,WAAW,EAAE;GACf;GACA,OAAO,QAAQ;GACf,UAAU;EACZ;EACA,SAAS;GACP,KAAK,MAAM,MAAM,MAAM,KAAK,GAAG,WAAW,EAAE;GAC5C,UAAU;EACZ;EACA,WAAW,UAAU;EACrB,gBAAgB;GACd,OAAO;EACT;EACA,YAAY,eAAe,QAAQ,OAAO,MAAM,IAAI,EAAE,CAAC;CACzD;CACA,OAAO;AACT"}

package/dist/core/scene/posePlies.js

@@ -0,0 +1,59 @@
+import { kit, last, mix, mul, patch } from "@msb235/blits";
+
+//#region src/core/scene/posePlies.ts
+/** What a ply says about a node with fewer plies than its depth. */
+var NOTHING = Object.freeze({});
+/** Per lower function, per upper one, the two run in turn: kept, so a node
+*  shows one function while neither ply replaces its own. */
+var composed = /* @__PURE__ */ new WeakMap();
+function after(lower, upper) {
+	let byUpper = composed.get(lower);
+	if (byUpper === void 0) composed.set(lower, byUpper = /* @__PURE__ */ new WeakMap());
+	let both = byUpper.get(upper);
+	if (both === void 0) byUpper.set(upper, both = (stored) => upper(lower(stored)));
+	return both;
+}
+/** A later ply's data runs on what the plies under it show. */
+var DATA = {
+	merge: after,
+	lerp: (a, b, u) => u < .5 ? a : b
+};
+/** A fold over `plies`, each node's entries bottom first. */
+function foldPlies(plies) {
+	const folded = mix(kit({
+		pose: last(),
+		alpha: mul(),
+		path: last(),
+		data: DATA
+	}));
+	/** One voice per depth, bottom first; only ever cut from the top, so cue order stays depth order. */
+	const voices = [];
+	let clock = 0;
+	const publish = (depth) => {
+		while (voices.length > depth) voices.pop().fade({ over: 0 });
+		while (voices.length < depth) {
+			const k = voices.length;
+			voices.push(folded.cue({ patch: patch(0, (_phase, id) => plies.get(id)?.[k] ?? NOTHING, { writes: [
+				"pose",
+				"alpha",
+				"path",
+				"data"
+			] }) }));
+		}
+		folded.sync(clock++);
+	};
+	publish(1);
+	return {
+		probe: (id, out) => {
+			folded.probe(id, out);
+		},
+		publish,
+		drop: (id) => {
+			folded.drop(id);
+		}
+	};
+}
+
+//#endregion
+export { foldPlies };
+//# sourceMappingURL=posePlies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"posePlies.js","names":[],"sources":["../../../src/core/scene/posePlies.ts"],"sourcesContent":["/**\n * The fold behind `PoseOverrides.read`: a blits mix over each node's plies of\n * overrides, one voice per depth, cued bottom first, so a later ply folds\n * over an earlier one.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { kit, last, mix, mul, patch, type Channel, type Handle } from '@msb235/blits';\nimport type { NodeId, PoseOverride } from './types';\n\n/** What a ply says about a node with fewer plies than its depth. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\ntype ShowData = (stored: never) => unknown;\n\n/** Per lower function, per upper one, the two run in turn: kept, so a node\n *  shows one function while neither ply replaces its own. */\nconst composed = new WeakMap<ShowData, WeakMap<ShowData, ShowData>>();\n\nfunction after(lower: ShowData, upper: ShowData): ShowData {\n  let byUpper = composed.get(lower);\n  if (byUpper === undefined) composed.set(lower, byUpper = new WeakMap());\n  let both = byUpper.get(upper);\n  if (both === undefined) byUpper.set(upper, both = (stored) => upper(lower(stored) as never));\n  return both;\n}\n\n/** A later ply's data runs on what the plies under it show. */\nconst DATA: Channel<ShowData> = { merge: after, lerp: (a, b, u) => (u < 0.5 ? a : b) };\n\n/** {@link foldPlies}'s handle. */\nexport interface PlyFold<Entry> {\n  /** Fold `id`'s plies into `out`, as of the last `publish`. */\n  probe(id: NodeId, out: Entry): void;\n  /** Make the next probe of every node fold afresh, `depth` plies deep. */\n  publish(depth: number): void;\n  /** Forget what the fold keeps for `id`. */\n  drop(id: NodeId): void;\n}\n\n/** A fold over `plies`, each node's entries bottom first. */\nexport function foldPlies<TPose, TData>(\n  plies: ReadonlyMap<NodeId, readonly PoseOverride<TPose, TData>[]>,\n): PlyFold<PoseOverride<TPose, TData>> {\n  type Entry = PoseOverride<TPose, TData>;\n  const folded = mix<NodeId, Entry>(\n    kit<Entry>({\n      pose: last<NonNullable<TPose>>(),\n      alpha: mul(),\n      path: last<Path>(),\n      data: DATA as unknown as Channel<NonNullable<Entry['data']>>,\n    }),\n  );\n  /** One voice per depth, bottom first; only ever cut from the top, so cue order stays depth order. */\n  const voices: Handle<NodeId>[] = [];\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  const publish = (depth: number): void => {\n    while (voices.length > depth) voices.pop()!.fade({ over: 0 });\n    while (voices.length < depth) {\n      const k = voices.length;\n      voices.push(folded.cue({\n        patch: patch<NodeId, Entry>(\n          0,\n          (_phase, id) => plies.get(id)?.[k] ?? (NOTHING as Entry),\n          { writes: ['pose', 'alpha', 'path', 'data'] },\n        ),\n      }));\n    }\n    folded.sync(clock++);\n  };\n  publish(1);\n  return {\n    probe: (id, out) => { folded.probe(id, out); },\n    publish,\n    drop: (id) => { folded.drop(id); },\n  };\n}\n"],"mappings":";;;;AAUA,IAAM,UAA+B,OAAO,OAAO,CAAC,CAAC;;;AAMrD,IAAM,2BAAW,IAAI,QAA+C;AAEpE,SAAS,MAAM,OAAiB,OAA2B;CACzD,IAAI,UAAU,SAAS,IAAI,KAAK;CAChC,IAAI,YAAY,QAAW,SAAS,IAAI,OAAO,0BAAU,IAAI,QAAQ,CAAC;CACtE,IAAI,OAAO,QAAQ,IAAI,KAAK;CAC5B,IAAI,SAAS,QAAW,QAAQ,IAAI,OAAO,QAAQ,WAAW,MAAM,MAAM,MAAM,CAAU,CAAC;CAC3F,OAAO;AACT;;AAGA,IAAM,OAA0B;CAAE,OAAO;CAAO,OAAO,GAAG,GAAG,MAAO,IAAI,KAAM,IAAI;AAAG;;AAarF,SAAgB,UACd,OACqC;CAErC,MAAM,SAAS,IACb,IAAW;EACT,MAAM,KAAyB;EAC/B,OAAO,IAAI;EACX,MAAM,KAAW;EACjB,MAAM;CACR,CAAC,CACH;;CAEA,MAAM,SAA2B,CAAC;CAGlC,IAAI,QAAQ;CACZ,MAAM,WAAW,UAAwB;EACvC,OAAO,OAAO,SAAS,OAAO,OAAO,IAAI,CAAC,CAAE,KAAK,EAAE,MAAM,EAAE,CAAC;EAC5D,OAAO,OAAO,SAAS,OAAO;GAC5B,MAAM,IAAI,OAAO;GACjB,OAAO,KAAK,OAAO,IAAI,EACrB,OAAO,MACL,IACC,QAAQ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,MAAO,SACvC,EAAE,QAAQ;IAAC;IAAQ;IAAS;IAAQ;GAAM,EAAE,CAC9C,EACF,CAAC,CAAC;EACJ;EACA,OAAO,KAAK,OAAO;CACrB;CACA,QAAQ,CAAC;CACT,OAAO;EACL,QAAQ,IAAI,QAAQ;GAAE,OAAO,MAAM,IAAI,GAAG;EAAG;EAC7C;EACA,OAAO,OAAO;GAAE,OAAO,KAAK,EAAE;EAAG;CACnC;AACF"}

package/dist/core/scene/reconcileSpecs.js

@@ -1,4 +1,4 @@
-import { isPlainObject } from "../isPlainObject.js";
+import { sameValue } from "./sameValue.js";
 
 //#region src/core/scene/reconcileSpecs.ts
 /**
@@ -39,10 +39,11 @@ function reconcileSpecs(scene, prev, next) {
 			const parent = spec.parent ?? null;
 			if (parent !== (before.parent ?? null)) scene.move(id, parent);
 			if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);
-			if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });
-			if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);
-			if (spec.kind === "container" && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);
-			if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);
+			if (!sameValue(spec.data, before.data)) scene.update(id, { data: spec.data });
+			if (!sameValue(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);
+			if (!sameValue(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);
+			if (spec.clip !== before.clip) scene.setClip(id, spec.clip ?? null);
+			if (!sameValue(spec.pose, before.pose)) scene.setPose(id, spec.pose);
 			if (spec.hidden === true !== (before.hidden === true)) scene.setHidden(id, spec.hidden === true);
 			if (spec.locked === true && before.locked !== true) scene.setLocked(id, true);
 		}
@@ -61,16 +62,6 @@ function byId(specs) {
 function needsReplace(a, b) {
 	return a.kind !== b.kind || a.pickable !== b.pickable || a.derivePath !== b.derivePath || a.derivePose !== b.derivePose || a.clipFromPose !== b.clipFromPose || a.copiesFromPose !== b.copiesFromPose || a.layout !== b.layout;
 }
-/** Structural equality over plain objects and arrays; anything else by identity. */
-function same(a, b) {
-	if (Object.is(a, b)) return true;
-	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => same(v, b[i]));
-	if (isPlainObject(a) && isPlainObject(b)) {
-		const ka = Object.keys(a);
-		return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));
-	}
-	return false;
-}
 
 //#endregion
 export { reconcileSpecs };

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

@@ -1 +1 @@
-{"version":3,"file":"reconcileSpecs.js","names":[],"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      // An unlock goes first and a lock last, so the writes between can land.\n      if (before.locked === true && spec.locked !== true) scene.setLocked(id, false);\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      if ((spec.hidden === true) !== (before.hidden === true)) scene.setHidden(id, spec.hidden === true);\n      if (spec.locked === true && before.locked !== true) scene.setLocked(id, true);\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.copiesFromPose !== b.copiesFromPose\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":"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"}
+{"version":3,"file":"reconcileSpecs.js","names":["same"],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { sameValue as same } from './sameValue';\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      // An unlock goes first and a lock last, so the writes between can land.\n      if (before.locked === true && spec.locked !== true) scene.setLocked(id, false);\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.units, before.units)) scene.setUnits(id, spec.units ?? null);\n      if (spec.clip !== before.clip) scene.setClip(id, spec.clip ?? null);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n      if ((spec.hidden === true) !== (before.hidden === true)) scene.setHidden(id, spec.hidden === true);\n      if (spec.locked === true && before.locked !== true) scene.setLocked(id, true);\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.copiesFromPose !== b.copiesFromPose\n    || a.layout !== b.layout;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,eACd,OACA,MACA,MACM;CACN,MAAM,WAAW,KAAK,IAAI;CAC1B,MAAM,WAAW,KAAK,IAAI;CAC1B,MAAM,OAAiB,CAAC;CACxB,KAAK,MAAM,CAAC,IAAI,WAAW,UAAU;EACnC,MAAM,QAAQ,SAAS,IAAI,EAAE;EAC7B,IAAI,UAAU,UAAa,aAAa,QAAQ,KAAK,GAAG,KAAK,KAAK,EAAE;CACtE;CACA,MAAM,WAAW,MAAM,eAAe,KAAK,QAAQ,OAAO,MAAM,IAAI,EAAE,MAAM,MAAS,CAAC;CACtF,MAAM,UAAU,IAAI,IAAI,QAAQ;CAGhC,MAAM,WAAW,MAAM,aAAa;CAEpC,MAAM,gBAAgB;EACpB,MAAM,WAAW,QAAQ;EACzB,KAAK,MAAM,QAAQ,MAAM;GACvB,MAAM,KAAK,KAAK;GAChB,MAAM,SAAS,SAAS,IAAI,EAAE;GAC9B,IAAI,MAAM,IAAI,EAAE,MAAM,UAAa,WAAW,UAAa,QAAQ,IAAI,EAAE,GAAG;IAC1E,MAAM,IAAI,IAAI;IACd;GACF;GAEA,IAAI,OAAO,WAAW,QAAQ,KAAK,WAAW,MAAM,MAAM,UAAU,IAAI,KAAK;GAC7E,MAAM,SAAS,KAAK,UAAU;GAC9B,IAAI,YAAY,OAAO,UAAU,OAAO,MAAM,KAAK,IAAI,MAAM;GAC7D,IAAI,KAAK,UAAU,OAAO,OAAO,MAAM,SAAS,IAAI,KAAK,KAAK;GAC9D,IAAI,CAACA,UAAK,KAAK,MAAM,OAAO,IAAI,GAAG,MAAM,OAAO,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;GACvE,IAAI,CAACA,UAAK,KAAK,WAAW,OAAO,SAAS,GAAG,MAAM,aAAa,IAAI,KAAK,SAAS;GAClF,IAAI,CAACA,UAAK,KAAK,OAAO,OAAO,KAAK,GAAG,MAAM,SAAS,IAAI,KAAK,SAAS,IAAI;GAC1E,IAAI,KAAK,SAAS,OAAO,MAAM,MAAM,QAAQ,IAAI,KAAK,QAAQ,IAAI;GAClE,IAAI,CAACA,UAAK,KAAK,MAAM,OAAO,IAAI,GAAG,MAAM,QAAQ,IAAI,KAAK,IAAI;GAC9D,IAAK,KAAK,WAAW,UAAW,OAAO,WAAW,OAAO,MAAM,UAAU,IAAI,KAAK,WAAW,IAAI;GACjG,IAAI,KAAK,WAAW,QAAQ,OAAO,WAAW,MAAM,MAAM,UAAU,IAAI,IAAI;EAC9E;EACA,IAAI,SAAS,MAAM,OAAO,QAAQ,IAAI,EAAE,CAAC,GACvC,MAAM,aAAa,SAAS,QAAQ,OAAO,MAAM,IAAI,EAAE,MAAM,MAAS,CAAC;CAE3E,CAAC;AACH;AAEA,SAAS,KAAgC,OAAqC;CAC5E,MAAM,sBAAM,IAAI,IAAe;CAC/B,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,KAAK,OAAO,QAAW,MAAM,IAAI,MAAM,wCAAwC;EACnF,IAAI,IAAI,IAAI,KAAK,EAAE,GAAG,MAAM,IAAI,MAAM,uBAAuB,KAAK,GAAG,yBAAyB;EAC9F,IAAI,IAAI,KAAK,IAAI,IAAI;CACvB;CACA,OAAO;AACT;AAEA,SAAS,aACP,GACA,GACS;CACT,OAAO,EAAE,SAAS,EAAE,QACf,EAAE,aAAa,EAAE,YACjB,EAAE,eAAe,EAAE,cACnB,EAAE,eAAe,EAAE,cACnB,EAAE,iBAAiB,EAAE,gBACrB,EAAE,mBAAmB,EAAE,kBACvB,EAAE,WAAW,EAAE;AACtB"}

package/dist/core/scene/renderOrder.js

@@ -1,4 +1,10 @@
+import { hasChildren } from "./treeShape.js";
+
 //#region src/core/scene/renderOrder.ts
+/**
+* A scene's render order: its nodes layer-major, each layer in tree preorder,
+* cached until the structure changes.
+*/
 function createRenderOrder(state) {
 	/**
 	* Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks
@@ -49,7 +55,7 @@ function createRenderOrder(state) {
 			const node = state.nodes.get(id);
 			if (!node) continue;
 			if (node.layer === only) out.push(id);
-			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
+			if (hasChildren(node)) for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
 		return out;
 	}
@@ -62,7 +68,7 @@ function createRenderOrder(state) {
 			const node = state.nodes.get(id);
 			if (!node) continue;
 			if (node.layer === only) out.push(node);
-			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
+			if (hasChildren(node)) for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
 		return out;
 	}
@@ -77,7 +83,7 @@ function createRenderOrder(state) {
 			if (!node) continue;
 			const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];
 			if (bucket) bucket.push(id);
-			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
+			if (hasChildren(node)) for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
 		const out = [];
 		for (const bucket of buckets) for (const id of bucket) out.push(id);
@@ -92,7 +98,7 @@ function createRenderOrder(state) {
 			if (!node) continue;
 			const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];
 			if (bucket) bucket.push(node);
-			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
+			if (hasChildren(node)) for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
 		const out = [];
 		for (const bucket of buckets) for (const node of bucket) out.push(node);

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

@@ -1 +1 @@
-{"version":3,"file":"renderOrder.js","names":[],"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":";AAsBA,SAAgB,kBACd,OACmC;;;;;;;;;;;;;;;CAenC,SAAS,UAAoB;EAC3B,OAAO,MAAM,OAAO,WAAW,IAAI,gBAAgB,IAAI,oBAAoB;CAC7E;CAEA,SAAS,YAA0C;EACjD,OAAO,MAAM,OAAO,WAAW,IAAI,qBAAqB,IAAI,yBAAyB;CACvF;;;;;;;;;;;CAYA,IAAI,sBAAsB;CAC1B,IAAI,aAKA,EAAE,KAAK,EAAE;CAEb,SAAS,aAAmB;EAC1B;CACF;CAEA,MAAM,cAAqD,CAAC;CAE5D,SAAS,oBAAuC;EAC9C,IAAI,WAAW,QAAQ,qBACrB,aAAa,EAAE,KAAK,oBAAoB;EAE1C,OAAO;CACT;CAEA,SAAS,kBAA4B;EACnC,MAAM,OAAO,MAAM,OAAO,EAAE,CAAC;EAC7B,MAAM,MAAgB,CAAC;EACvB,MAAM,QAAkB,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC,QAAQ;EACjD,OAAO,MAAM,SAAS,GAAG;GACvB,MAAM,KAAK,MAAM,IAAI;GACrB,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;GAC/B,IAAI,CAAC,MAAM;GACX,IAAI,KAAK,UAAU,MAAM,IAAI,KAAK,EAAE;GACpC,IAAI,KAAK,SAAS,aAChB,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAC7C,MAAM,KAAK,KAAK,SAAS,EAAE;EAGjC;EACA,OAAO;CACT;CAEA,SAAS,uBAAqD;EAC5D,MAAM,OAAO,MAAM,OAAO,EAAE,CAAC;EAC7B,MAAM,MAAoC,CAAC;EAC3C,MAAM,QAAkB,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC,QAAQ;EACjD,OAAO,MAAM,SAAS,GAAG;GACvB,MAAM,KAAK,MAAM,IAAI;GACrB,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;GAC/B,IAAI,CAAC,MAAM;GACX,IAAI,KAAK,UAAU,MAAM,IAAI,KAAK,IAAI;GACtC,IAAI,KAAK,SAAS,aAChB,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAC7C,MAAM,KAAK,KAAK,SAAS,EAAE;EAGjC;EACA,OAAO;CACT;;;CAIA,SAAS,sBAAgC;EACvC,MAAM,UAAsB,MAAM,OAAO,UAAU,CAAC,CAAC;EACrD,MAAM,QAAkB,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC,QAAQ;EACjD,OAAO,MAAM,SAAS,GAAG;GACvB,MAAM,KAAK,MAAM,IAAI;GACrB,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;GAC/B,IAAI,CAAC,MAAM;GACX,MAAM,SAAS,QAAQ,MAAM,WAAW,IAAI,KAAK,KAAK,KAAK;GAC3D,IAAI,QAAQ,OAAO,KAAK,EAAE;GAC1B,IAAI,KAAK,SAAS,aAChB,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAC7C,MAAM,KAAK,KAAK,SAAS,EAAE;EAGjC;EACA,MAAM,MAAgB,CAAC;EACvB,KAAK,MAAM,UAAU,SACnB,KAAK,MAAM,MAAM,QAAQ,IAAI,KAAK,EAAE;EAEtC,OAAO;CACT;CAEA,SAAS,2BAAyD;EAChE,MAAM,UAA0C,MAAM,OAAO,UAAU,CAAC,CAAC;EACzE,MAAM,QAAkB,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC,QAAQ;EACjD,OAAO,MAAM,SAAS,GAAG;GACvB,MAAM,KAAK,MAAM,IAAI;GACrB,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;GAC/B,IAAI,CAAC,MAAM;GACX,MAAM,SAAS,QAAQ,MAAM,WAAW,IAAI,KAAK,KAAK,KAAK;GAC3D,IAAI,QAAQ,OAAO,KAAK,IAAI;GAC5B,IAAI,KAAK,SAAS,aAChB,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAC7C,MAAM,KAAK,KAAK,SAAS,EAAE;EAGjC;EACA,MAAM,MAAoC,CAAC;EAC3C,KAAK,MAAM,UAAU,SACnB,KAAK,MAAM,QAAQ,QAAQ,IAAI,KAAK,IAAI;EAE1C,OAAO;CACT;CAEA,OAAO;EACL,MAAM;GACJ,MAAM,IAAI,kBAAkB;GAC5B,OAAQ,EAAE,QAAQ,QAAQ;EAC5B;EACA,QAAQ;GACN,MAAM,IAAI,kBAAkB;GAC5B,OAAQ,EAAE,UAAU,UAAU;EAChC;EACA,aAAa,OAAO;GAClB,MAAM,IAAI,kBAAkB;GAC5B,IAAI,UAAU,EAAE;GAChB,IAAI,CAAC,SAAS;IACZ,0BAAU,IAAI,IAAI;IAClB,KAAK,MAAM,QAAS,EAAE,UAAU,UAAU,GAAI;KAC5C,IAAI,SAAS,QAAQ,IAAI,KAAK,KAAK;KACnC,IAAI,CAAC,QAAQ,QAAQ,IAAI,KAAK,OAAQ,SAAS,CAAC,CAAE;KAClD,OAAO,KAAK,IAAI;IAClB;IACA,EAAE,UAAU;GACd;GACA,OAAO,QAAQ,IAAI,KAAK,KAAK;EAC/B;EACA;CACF;AACF"}
+{"version":3,"file":"renderOrder.js","names":[],"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 { hasChildren } from './treeShape';\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 (hasChildren(node)) {\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 (hasChildren(node)) {\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 (hasChildren(node)) {\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 (hasChildren(node)) {\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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"}

package/dist/core/scene/sameValue.js

@@ -0,0 +1,17 @@
+import { isPlainObject } from "../isPlainObject.js";
+
+//#region src/core/scene/sameValue.ts
+/** Structural equality over plain objects and arrays; anything else by identity. */
+function sameValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => sameValue(v, b[i]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ka = Object.keys(a);
+		return ka.length === Object.keys(b).length && ka.every((k) => k in b && sameValue(a[k], b[k]));
+	}
+	return false;
+}
+
+//#endregion
+export { sameValue };
+//# sourceMappingURL=sameValue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sameValue.js","names":[],"sources":["../../../src/core/scene/sameValue.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nexport function sameValue(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) => sameValue(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 && sameValue(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":";;;;AAGA,SAAgB,UAAU,GAAY,GAAqB;CACzD,IAAI,OAAO,GAAG,GAAG,CAAC,GAAG,OAAO;CAC5B,IAAI,MAAM,QAAQ,CAAC,KAAK,MAAM,QAAQ,CAAC,GACrC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,UAAU,GAAG,EAAE,EAAE,CAAC;CAEtE,IAAI,cAAc,CAAC,KAAK,cAAc,CAAC,GAAG;EACxC,MAAM,KAAK,OAAO,KAAK,CAAC;EACxB,OAAO,GAAG,WAAW,OAAO,KAAK,CAAC,CAAC,CAAC,UAAU,GAAG,OAAO,MAAM,KAAK,KAAK,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC;CAC/F;CACA,OAAO;AACT"}

package/dist/core/scene/scene.js

@@ -120,8 +120,8 @@ function buildScene(options, layers, initialNodes, initialDoc) {
 		overrides,
 		getSelection: selection.get,
 		setSelection: (ids) => selection.set([...ids]),
-		loadState(json) {
-			const specs = specsFromSerialized(json, registry);
+		loadState(json, opts) {
+			const specs = specsFromSerialized(json, registry, opts);
 			if (mode.open()) throw new Error("Scene: cannot loadState inside another edit — it replaces the state that edit would revert to");
 			overrides.clearAll();
 			doc.reset(json.systemLayers.map(layerFromSerialized), json.doc);
@@ -145,7 +145,7 @@ function buildScene(options, layers, initialNodes, initialDoc) {
 *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).
 *  The scene starts with empty history. */
 function sceneFromJSON(json, options = {}) {
-	return buildScene(options, json.systemLayers.map(layerFromSerialized), (registry) => specsFromSerialized(json, registry), json.doc);
+	return buildScene(options, json.systemLayers.map(layerFromSerialized), (registry) => specsFromSerialized(json, registry, options), json.doc);
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"scene.js","names":[],"sources":["../../../src/core/scene/scene.ts"],"sourcesContent":["import { withKitRegistry } from './kitRegistry';\nimport { createPoseOverrides } from './poseOverrides';\nimport { createArrivalWindow } from './arrivalWindow';\nimport { documentReads, sceneMutators } from './sceneMutators';\nimport { createNotifier } from './notifier';\nimport type { SerializedDoc } from './docValues';\nimport { sceneChanges } from './sceneChanges';\nimport { createPoseWriteLog } from './poseWrites';\nimport { effectivePose } from './effectivePose';\nimport { createEditMode } from './editMode';\nimport { createSceneEdits } from './sceneEdits';\nimport { createSceneRecording } from './sceneRecording';\nimport { createSceneSelection } from './sceneSelection';\nimport { createSceneState } from './sceneState';\nimport { systemLayerRecord } from './layerStack';\nimport { layerFromSerialized, specsFromSerialized } from './serialization';\nimport { resolveLayoutFrame, runLayoutPass } from './layoutPass';\nimport { IDENTITY_POSE_COMPOSITION, type PoseComposition } from './composeFrame';\nimport {\n  asNodeId,\n  type AddNodeSpec,\n  type LayerRecord,\n  type NodeId,\n  type RegisteredOp,\n  type Scene,\n  type SceneRegistry,\n  type SerializedScene,\n  type UseSceneOptions,\n} from './types';\n\n/** A node still in `scene`, with the pose it is shown at. */\nfunction shownNode<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, id: NodeId) {\n  const node = scene.get(id);\n  return node && { node, pose: effectivePose(scene, node) };\n}\n\nlet defaultIdCounter = 0;\nconst defaultGenerateId = (): NodeId =>\n  asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);\n\n/** Build a scene outside React. `useScene` is the usual entry point; reach for\n *  this in tests, in headless rendering, or wherever a scene must outlive a\n *  component. Throws if no system layers are declared. */\nexport function createScene<TData, TLayer extends string, TPose = import('./composePose').RectPose>(\n  options: UseSceneOptions<TData, TLayer, TPose>,\n): Scene<TData, TLayer, TPose> {\n  return buildScene(options, (options.systemLayers ?? []).map(systemLayerRecord), () => options.initial, options.doc);\n}\n\ntype SceneConfig<TData, TLayer extends string, TPose> =\n  Omit<UseSceneOptions<TData, TLayer, TPose>, 'systemLayers' | 'initial' | 'doc'>;\n\n/** A scene holding `layers`, the document values `initialDoc`, and the nodes\n *  `initialNodes` answers with once it is handed the registry their functions\n *  resolve against. */\nfunction buildScene<TData, TLayer extends string, TPose>(\n  options: SceneConfig<TData, TLayer, TPose>,\n  layers: readonly LayerRecord<TLayer>[],\n  initialNodes: (registry: SceneRegistry<TPose, TData, TLayer>) => readonly AddNodeSpec<TData, TLayer, TPose>[] | undefined,\n  initialDoc: SerializedDoc | undefined,\n): Scene<TData, TLayer, TPose> {\n  if (layers.length === 0) throw new Error('Scene: systemLayers must declare at least one layer');\n\n  // The kit's own registry entries sit under the consumer's, so a snapshot\n  // carrying a kit-attached function (a grouped container's derived pose)\n  // reloads in any scene, not only one whose consumer registered the key.\n  const registry = withKitRegistry(options.registry ?? {});\n\n  const doc = createSceneState<TData, TLayer, TPose>(registry, layers, () => arrivals.layoutDeclared(), initialDoc);\n  const { state, locks, reads } = doc;\n  const notifier = createNotifier();\n  const mode = createEditMode();\n  const poseWrites = createPoseWriteLog({ untracked: mode.untracked, changes: notifier, shown: (id) => shownNode(scene, id) });\n  const writePose = (id: string, pose: unknown): void => poseWrites.layout(() => scene.setPose(asNodeId(id), pose as TPose));\n\n  const layoutFrame = resolveLayoutFrame(options.layoutFrame);\n  const arrivals = createArrivalWindow<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    layoutPass: (arrived, touched, departed) =>\n      runLayoutPass(scene, reads.layoutOf, arrived, touched, layoutFrame, departed),\n    recordsBareEdits: () => !mode.open(),\n    writePose,\n  });\n\n  const generateId = options.generateId ?? defaultGenerateId;\n  const selection = createSceneSelection(locks.reachable);\n  // A selection change is a scene change to every subscriber.\n  selection.subscribe(notifier.notify);\n\n  /** Ephemeral per-node overrides. Deliberately not part of `state`: not\n   *  document content, never reaches `toJSON`, and never touches history. */\n  const overrides = createPoseOverrides<TPose>((id) => state.nodes.get(id), doc.store.invalidateDependents);\n\n  const recording = createSceneRecording({\n    notifier,\n    mode,\n    passAdapter: () => ({ ...sceneMutators(scene), ...documentReads(scene) }),\n    stale: doc.stale,\n    lifted: locks.lifted,\n    selection,\n    arrivals,\n    writePose,\n    poseWrites,\n    config: options,\n  });\n\n  const edits = createSceneEdits<TData, TLayer, TPose>({\n    state,\n    store: doc.store,\n    locks,\n    layers: doc.layers,\n    invalidateOrder: doc.order.invalidate,\n    fnFields: doc.fnFields,\n    ops: { ...recording.ops, register: poseWrites.reporting(recording.ops.register) },\n    recorder: recording.recorder,\n    arrivals,\n    layoutFrame,\n    generateId,\n    narrowSelection: selection.narrow,\n    clearOverride: overrides.clear,\n  });\n  for (const [kind, handler] of Object.entries(options.ops ?? {})) recording.ops.register(kind, handler);\n\n  const scene: Scene<TData, TLayer, TPose> = {\n    get nodes() { return state.nodes; },\n    get roots() { return state.roots; },\n    get layers() { return state.layers; },\n    registry,\n\n    ...reads,\n\n    mintId: generateId,\n    composition: options.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n\n    ...edits.methods,\n    ...recording.methods,\n\n    unlocked: (fn) => locks.lifted(fn),\n\n    setArrivalHandler: arrivals.setHandler,\n    onReflow: arrivals.onReflow,\n    onPoseWrite: poseWrites.subscribe,\n\n    overrides,\n\n    getSelection: selection.get,\n    setSelection: (ids) => selection.set([...ids]),\n\n    loadState(json) {\n      // Validate + map up front (throws before we touch live state on a bad\n      // version or unknown registry key).\n      const specs = specsFromSerialized(json, registry);\n      if (mode.open()) {\n        throw new Error('Scene: cannot loadState inside another edit — it replaces the state that edit would revert to');\n      }\n      // Ephemeral, and every id is a new node after this.\n      overrides.clearAll();\n      doc.reset(json.systemLayers.map(layerFromSerialized), json.doc);\n      recording.clearHistory();\n      poseWrites.quiet(() => edits.construct(specs));\n      selection.replace(locks.reachable(selection.get().filter((id) => state.nodes.has(id))));\n      notifier.notify();\n    },\n\n    ...sceneChanges(notifier, selection),\n  };\n\n  const initial = initialNodes(registry);\n  if (initial) {\n    poseWrites.quiet(() => edits.construct(initial));\n    notifier.notify();\n  }\n\n  return scene;\n}\n\n/** Reconstruct a Scene from a JSON snapshot produced by `scene.toJSON()`.\n *  Function fields (e.g., `clipFromPose`) are resolved by string key via the\n *  registry passed in `options`. Throws on unknown version, unknown registry\n *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).\n *  The scene starts with empty history. */\nexport function sceneFromJSON<TData, TLayer extends string, TPose>(\n  json: SerializedScene<TData, TLayer, TPose>,\n  options: {\n    registry?: SceneRegistry<TPose, TData, TLayer>;\n    historyLimit?: number;\n    coalesceWindowMs?: number;\n    generateId?: () => NodeId;\n    ops?: Readonly<Record<string, RegisteredOp<unknown>>>;\n    composition?: UseSceneOptions<TData, TLayer, TPose>['composition'];\n    layoutFrame?: UseSceneOptions<TData, TLayer, TPose>['layoutFrame'];\n  } = {},\n): Scene<TData, TLayer, TPose> {\n  return buildScene(\n    options,\n    json.systemLayers.map(layerFromSerialized),\n    (registry) => specsFromSerialized(json, registry),\n    json.doc,\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"scene.js","names":[],"sources":["../../../src/core/scene/scene.ts"],"sourcesContent":["import { withKitRegistry } from './kitRegistry';\nimport { createPoseOverrides } from './poseOverrides';\nimport { createArrivalWindow } from './arrivalWindow';\nimport { documentReads, sceneMutators } from './sceneMutators';\nimport { createNotifier } from './notifier';\nimport type { SerializedDoc } from './docValues';\nimport { sceneChanges } from './sceneChanges';\nimport { createPoseWriteLog } from './poseWrites';\nimport { effectivePose } from './effectivePose';\nimport { createEditMode } from './editMode';\nimport { createSceneEdits } from './sceneEdits';\nimport { createSceneRecording } from './sceneRecording';\nimport { createSceneSelection } from './sceneSelection';\nimport { createSceneState } from './sceneState';\nimport { systemLayerRecord } from './layerStack';\nimport { layerFromSerialized, specsFromSerialized, type SpecsFromSerializedOptions } from './serialization';\nimport { resolveLayoutFrame, runLayoutPass } from './layoutPass';\nimport { IDENTITY_POSE_COMPOSITION, type PoseComposition } from './composeFrame';\nimport {\n  asNodeId,\n  type AddNodeSpec,\n  type LayerRecord,\n  type NodeId,\n  type RegisteredOp,\n  type Scene,\n  type SceneRegistry,\n  type SerializedScene,\n  type SerializedSceneV1,\n  type UseSceneOptions,\n} from './types';\n\n/** A node still in `scene`, with the pose it is shown at. */\nfunction shownNode<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, id: NodeId) {\n  const node = scene.get(id);\n  return node && { node, pose: effectivePose(scene, node) };\n}\n\nlet defaultIdCounter = 0;\nconst defaultGenerateId = (): NodeId =>\n  asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);\n\n/** Build a scene outside React. `useScene` is the usual entry point; reach for\n *  this in tests, in headless rendering, or wherever a scene must outlive a\n *  component. Throws if no system layers are declared. */\nexport function createScene<TData, TLayer extends string, TPose = import('./composePose').RectPose>(\n  options: UseSceneOptions<TData, TLayer, TPose>,\n): Scene<TData, TLayer, TPose> {\n  return buildScene(options, (options.systemLayers ?? []).map(systemLayerRecord), () => options.initial, options.doc);\n}\n\ntype SceneConfig<TData, TLayer extends string, TPose> =\n  Omit<UseSceneOptions<TData, TLayer, TPose>, 'systemLayers' | 'initial' | 'doc'>;\n\n/** A scene holding `layers`, the document values `initialDoc`, and the nodes\n *  `initialNodes` answers with once it is handed the registry their functions\n *  resolve against. */\nfunction buildScene<TData, TLayer extends string, TPose>(\n  options: SceneConfig<TData, TLayer, TPose>,\n  layers: readonly LayerRecord<TLayer>[],\n  initialNodes: (registry: SceneRegistry<TPose, TData, TLayer>) => readonly AddNodeSpec<TData, TLayer, TPose>[] | undefined,\n  initialDoc: SerializedDoc | undefined,\n): Scene<TData, TLayer, TPose> {\n  if (layers.length === 0) throw new Error('Scene: systemLayers must declare at least one layer');\n\n  // The kit's own registry entries sit under the consumer's, so a snapshot\n  // carrying a kit-attached function (a grouped container's derived pose)\n  // reloads in any scene, not only one whose consumer registered the key.\n  const registry = withKitRegistry(options.registry ?? {});\n\n  const doc = createSceneState<TData, TLayer, TPose>(registry, layers, () => arrivals.layoutDeclared(), initialDoc);\n  const { state, locks, reads } = doc;\n  const notifier = createNotifier();\n  const mode = createEditMode();\n  const poseWrites = createPoseWriteLog({ untracked: mode.untracked, changes: notifier, shown: (id) => shownNode(scene, id) });\n  const writePose = (id: string, pose: unknown): void => poseWrites.layout(() => scene.setPose(asNodeId(id), pose as TPose));\n\n  const layoutFrame = resolveLayoutFrame(options.layoutFrame);\n  const arrivals = createArrivalWindow<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    layoutPass: (arrived, touched, departed) =>\n      runLayoutPass(scene, reads.layoutOf, arrived, touched, layoutFrame, departed),\n    recordsBareEdits: () => !mode.open(),\n    writePose,\n  });\n\n  const generateId = options.generateId ?? defaultGenerateId;\n  const selection = createSceneSelection(locks.reachable);\n  // A selection change is a scene change to every subscriber.\n  selection.subscribe(notifier.notify);\n\n  /** Ephemeral per-node overrides. Deliberately not part of `state`: not\n   *  document content, never reaches `toJSON`, and never touches history. */\n  const overrides = createPoseOverrides<TPose, TData>((id) => state.nodes.get(id), doc.store.invalidateDependents);\n\n  const recording = createSceneRecording({\n    notifier,\n    mode,\n    passAdapter: () => ({ ...sceneMutators(scene), ...documentReads(scene) }),\n    stale: doc.stale,\n    lifted: locks.lifted,\n    selection,\n    arrivals,\n    writePose,\n    poseWrites,\n    config: options,\n  });\n\n  const edits = createSceneEdits<TData, TLayer, TPose>({\n    state,\n    store: doc.store,\n    locks,\n    layers: doc.layers,\n    invalidateOrder: doc.order.invalidate,\n    fnFields: doc.fnFields,\n    ops: { ...recording.ops, register: poseWrites.reporting(recording.ops.register) },\n    recorder: recording.recorder,\n    arrivals,\n    layoutFrame,\n    generateId,\n    narrowSelection: selection.narrow,\n    clearOverride: overrides.clear,\n  });\n  for (const [kind, handler] of Object.entries(options.ops ?? {})) recording.ops.register(kind, handler);\n\n  const scene: Scene<TData, TLayer, TPose> = {\n    get nodes() { return state.nodes; },\n    get roots() { return state.roots; },\n    get layers() { return state.layers; },\n    registry,\n\n    ...reads,\n\n    mintId: generateId,\n    composition: options.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n\n    ...edits.methods,\n    ...recording.methods,\n\n    unlocked: (fn) => locks.lifted(fn),\n\n    setArrivalHandler: arrivals.setHandler,\n    onReflow: arrivals.onReflow,\n    onPoseWrite: poseWrites.subscribe,\n\n    overrides,\n\n    getSelection: selection.get,\n    setSelection: (ids) => selection.set([...ids]),\n\n    loadState(json, opts) {\n      // Validate + map up front (throws before we touch live state on a bad\n      // version or unknown registry key).\n      const specs = specsFromSerialized(json, registry, opts);\n      if (mode.open()) {\n        throw new Error('Scene: cannot loadState inside another edit — it replaces the state that edit would revert to');\n      }\n      // Ephemeral, and every id is a new node after this.\n      overrides.clearAll();\n      doc.reset(json.systemLayers.map(layerFromSerialized), json.doc);\n      recording.clearHistory();\n      poseWrites.quiet(() => edits.construct(specs));\n      selection.replace(locks.reachable(selection.get().filter((id) => state.nodes.has(id))));\n      notifier.notify();\n    },\n\n    ...sceneChanges(notifier, selection),\n  };\n\n  const initial = initialNodes(registry);\n  if (initial) {\n    poseWrites.quiet(() => edits.construct(initial));\n    notifier.notify();\n  }\n\n  return scene;\n}\n\n/** Reconstruct a Scene from a JSON snapshot produced by `scene.toJSON()`.\n *  Function fields (e.g., `clipFromPose`) are resolved by string key via the\n *  registry passed in `options`. Throws on unknown version, unknown registry\n *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).\n *  The scene starts with empty history. */\nexport function sceneFromJSON<TData, TLayer extends string, TPose>(\n  json: SerializedScene<TData, TLayer, TPose> | SerializedSceneV1<TData, TLayer, TPose>,\n  options: {\n    registry?: SceneRegistry<TPose, TData, TLayer>;\n    historyLimit?: number;\n    coalesceWindowMs?: number;\n    generateId?: () => NodeId;\n    ops?: Readonly<Record<string, RegisteredOp<unknown>>>;\n    composition?: UseSceneOptions<TData, TLayer, TPose>['composition'];\n    layoutFrame?: UseSceneOptions<TData, TLayer, TPose>['layoutFrame'];\n  } & SpecsFromSerializedOptions<TData, TLayer, TPose> = {},\n): Scene<TData, TLayer, TPose> {\n  return buildScene(\n    options,\n    json.systemLayers.map(layerFromSerialized),\n    (registry) => specsFromSerialized(json, registry, options),\n    json.doc,\n  );\n}\n"],"mappings":"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"}

package/dist/core/scene/sceneEdits.js

@@ -1,4 +1,5 @@
 import { createSceneDoc } from "./docValues.js";
+import { createDeclaredFieldSetters } from "./declaredFieldSetters.js";
 import { createFieldEdits } from "./fieldEdits.js";
 import { registerKitOps } from "./kitOps.js";
 import { createNodeFlags } from "./nodeFlags.js";
@@ -56,6 +57,12 @@ function createSceneEdits(env) {
 		record: recorder.record,
 		narrowSelection: () => env.narrowSelection()
 	});
+	const declaredEdits = createDeclaredFieldSetters({
+		register: env.ops.register,
+		requireNode: store.requireNode,
+		refuse: locks.refuse,
+		record: recorder.record
+	});
 	const doc = createSceneDoc({
 		values: state.docValues,
 		register: env.ops.register,
@@ -68,6 +75,7 @@ function createSceneEdits(env) {
 			...fieldEdits,
 			...layerEdits,
 			...flagEdits,
+			...declaredEdits,
 			doc
 		}
 	};

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

@@ -1 +1 @@
-{"version":3,"file":"sceneEdits.js","names":[],"sources":["../../../src/core/scene/sceneEdits.ts"],"sourcesContent":["/**\n * The scene's edits to its document — tree, node fields, layers, and document values — with\n * the kit ops they record.\n */\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { createSceneDoc, type SceneDocValues } from './docValues';\nimport { createFieldEdits, type FieldEdits } from './fieldEdits';\nimport { registerKitOps } from './kitOps';\nimport { createNodeFlags } from './nodeFlags';\nimport { createLayerEdits, type LayerEdits, type createLayerStack } from './layerStack';\nimport type { ResolvedLayoutFrame } from './layoutPass';\nimport type { LockGuard } from './lockGuard';\nimport type { NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type { OpTable } from './opTable';\nimport type { Recorder } from './recorder';\nimport { createTreeEdits, type TreeEdits } from './treeEdits';\nimport type { LayerRecord, Node, NodeId } from './types';\n\nexport interface SceneEditsEnv<TData, TLayer extends string, TPose> {\n  state: {\n    nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n    layers: LayerRecord<TLayer>[];\n    layerIndex: Map<TLayer, number>;\n    /** The scene's document values, which `doc` reads and records. */\n    docValues: Map<string, unknown>;\n  };\n  store: ReturnType<typeof createNodeStore<TData, TLayer, TPose>>;\n  locks: Pick<LockGuard<TLayer>, 'refuse' | 'refuseLayer' | 'lifted'>;\n  layers: Pick<\n    ReturnType<typeof createLayerStack<TLayer>>,\n    'requireLayerIndex' | 'rebuildLayerIndex' | 'assertSubtreeLayer'\n  >;\n  invalidateOrder(): void;\n  fnFields: readonly NodeFnField[];\n  ops: Pick<OpTable, 'register' | 'run'>;\n  recorder: Pick<Recorder, 'record' | 'edit' | 'batch'>;\n  arrivals: Pick<ArrivalWindow<TPose>, 'noteArrival' | 'noteDeparture' | 'noteChange' | 'layoutDeclared'>;\n  layoutFrame: ResolvedLayoutFrame<TPose>;\n  generateId(): NodeId;\n  narrowSelection(gone?: ReadonlySet<NodeId>): void;\n  clearOverride(id: NodeId): void;\n}\n\nexport interface SceneEdits<TData, TLayer extends string, TPose> {\n  construct: TreeEdits<TData, TLayer, TPose>['construct'];\n  methods: Omit<TreeEdits<TData, TLayer, TPose>, 'construct'>\n    & FieldEdits<TData, TLayer, TPose>\n    & LayerEdits<TData, TLayer, TPose>\n    & ReturnType<typeof createNodeFlags<TData, TLayer, TPose>>\n    & SceneDocValues;\n}\n\nexport function createSceneEdits<TData, TLayer extends string, TPose>(\n  env: SceneEditsEnv<TData, TLayer, TPose>,\n): SceneEdits<TData, TLayer, TPose> {\n  const { state, store, locks, layers, fnFields, recorder, arrivals } = env;\n\n  const { layoutRefs } = registerKitOps<TData, TLayer, TPose>({\n    state,\n    register: env.ops.register,\n    store,\n    requireLayerIndex: layers.requireLayerIndex,\n    rebuildLayerIndex: layers.rebuildLayerIndex,\n    invalidateOrder: env.invalidateOrder,\n    fnFields,\n    narrowSelection: env.narrowSelection,\n    clearOverride: env.clearOverride,\n  });\n\n  const { construct, ...treeEdits } = createTreeEdits<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    generateId: env.generateId,\n    store,\n    locks,\n    layers,\n    fnFields,\n    runOp: env.ops.run,\n    recorder,\n    arrivals,\n  });\n\n  const fieldEdits = createFieldEdits<TData, TLayer, TPose>({\n    store,\n    locks,\n    layers,\n    recorder,\n    arrivals,\n    layoutFrame: env.layoutFrame,\n    layoutField: fnFields.find((f) => f.spec.field === 'layout')!,\n    layoutRefs,\n  });\n\n  const layerEdits = createLayerEdits<TData, TLayer, TPose>({\n    layers: state.layers,\n    layerIndex: state.layerIndex,\n    nodes: state.nodes,\n    requireLayerIndex: layers.requireLayerIndex,\n    record: recorder.record,\n    lifted: locks.lifted,\n    batch: recorder.batch,\n    removeMany: treeEdits.removeMany,\n  });\n\n  const flagEdits = createNodeFlags<TData, TLayer, TPose>({\n    register: env.ops.register,\n    requireNode: store.requireNode,\n    record: recorder.record,\n    narrowSelection: () => env.narrowSelection(),\n  });\n\n  const doc = createSceneDoc({ values: state.docValues, register: env.ops.register, record: recorder.record });\n\n  return { construct, methods: { ...treeEdits, ...fieldEdits, ...layerEdits, ...flagEdits, doc } };\n}\n"],"mappings":";;;;;;;;AAqDA,SAAgB,iBACd,KACkC;CAClC,MAAM,EAAE,OAAO,OAAO,OAAO,QAAQ,UAAU,UAAU,aAAa;CAEtE,MAAM,EAAE,eAAe,eAAqC;EAC1D;EACA,UAAU,IAAI,IAAI;EAClB;EACA,mBAAmB,OAAO;EAC1B,mBAAmB,OAAO;EAC1B,iBAAiB,IAAI;EACrB;EACA,iBAAiB,IAAI;EACrB,eAAe,IAAI;CACrB,CAAC;CAED,MAAM,EAAE,WAAW,GAAG,cAAc,gBAAsC;EACxE,OAAO,MAAM;EACb,YAAY,IAAI;EAChB;EACA;EACA;EACA;EACA,OAAO,IAAI,IAAI;EACf;EACA;CACF,CAAC;CAED,MAAM,aAAa,iBAAuC;EACxD;EACA;EACA;EACA;EACA;EACA,aAAa,IAAI;EACjB,aAAa,SAAS,MAAM,MAAM,EAAE,KAAK,UAAU,QAAQ;EAC3D;CACF,CAAC;CAED,MAAM,aAAa,iBAAuC;EACxD,QAAQ,MAAM;EACd,YAAY,MAAM;EAClB,OAAO,MAAM;EACb,mBAAmB,OAAO;EAC1B,QAAQ,SAAS;EACjB,QAAQ,MAAM;EACd,OAAO,SAAS;EAChB,YAAY,UAAU;CACxB,CAAC;CAED,MAAM,YAAY,gBAAsC;EACtD,UAAU,IAAI,IAAI;EAClB,aAAa,MAAM;EACnB,QAAQ,SAAS;EACjB,uBAAuB,IAAI,gBAAgB;CAC7C,CAAC;CAED,MAAM,MAAM,eAAe;EAAE,QAAQ,MAAM;EAAW,UAAU,IAAI,IAAI;EAAU,QAAQ,SAAS;CAAO,CAAC;CAE3G,OAAO;EAAE;EAAW,SAAS;GAAE,GAAG;GAAW,GAAG;GAAY,GAAG;GAAY,GAAG;GAAW;EAAI;CAAE;AACjG"}
+{"version":3,"file":"sceneEdits.js","names":[],"sources":["../../../src/core/scene/sceneEdits.ts"],"sourcesContent":["/**\n * The scene's edits to its document — tree, node fields, layers, and document values — with\n * the kit ops they record.\n */\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { createSceneDoc, type SceneDocValues } from './docValues';\nimport { createDeclaredFieldSetters, type SceneDeclaredFieldSetters } from './declaredFieldSetters';\nimport { createFieldEdits, type FieldEdits } from './fieldEdits';\nimport { registerKitOps } from './kitOps';\nimport { createNodeFlags } from './nodeFlags';\nimport { createLayerEdits, type LayerEdits, type createLayerStack } from './layerStack';\nimport type { ResolvedLayoutFrame } from './layoutPass';\nimport type { LockGuard } from './lockGuard';\nimport type { NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type { OpTable } from './opTable';\nimport type { Recorder } from './recorder';\nimport { createTreeEdits, type TreeEdits } from './treeEdits';\nimport type { LayerRecord, Node, NodeId } from './types';\n\nexport interface SceneEditsEnv<TData, TLayer extends string, TPose> {\n  state: {\n    nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n    layers: LayerRecord<TLayer>[];\n    layerIndex: Map<TLayer, number>;\n    /** The scene's document values, which `doc` reads and records. */\n    docValues: Map<string, unknown>;\n  };\n  store: ReturnType<typeof createNodeStore<TData, TLayer, TPose>>;\n  locks: Pick<LockGuard<TLayer>, 'refuse' | 'refuseLayer' | 'lifted'>;\n  layers: Pick<\n    ReturnType<typeof createLayerStack<TLayer>>,\n    'requireLayerIndex' | 'rebuildLayerIndex' | 'assertSubtreeLayer'\n  >;\n  invalidateOrder(): void;\n  fnFields: readonly NodeFnField[];\n  ops: Pick<OpTable, 'register' | 'run'>;\n  recorder: Pick<Recorder, 'record' | 'edit' | 'batch'>;\n  arrivals: Pick<ArrivalWindow<TPose>, 'noteArrival' | 'noteDeparture' | 'noteChange' | 'layoutDeclared'>;\n  layoutFrame: ResolvedLayoutFrame<TPose>;\n  generateId(): NodeId;\n  narrowSelection(gone?: ReadonlySet<NodeId>): void;\n  clearOverride(id: NodeId): void;\n}\n\nexport interface SceneEdits<TData, TLayer extends string, TPose> {\n  construct: TreeEdits<TData, TLayer, TPose>['construct'];\n  methods: Omit<TreeEdits<TData, TLayer, TPose>, 'construct'>\n    & FieldEdits<TData, TLayer, TPose>\n    & LayerEdits<TData, TLayer, TPose>\n    & ReturnType<typeof createNodeFlags<TData, TLayer, TPose>>\n    & SceneDeclaredFieldSetters\n    & SceneDocValues;\n}\n\nexport function createSceneEdits<TData, TLayer extends string, TPose>(\n  env: SceneEditsEnv<TData, TLayer, TPose>,\n): SceneEdits<TData, TLayer, TPose> {\n  const { state, store, locks, layers, fnFields, recorder, arrivals } = env;\n\n  const { layoutRefs } = registerKitOps<TData, TLayer, TPose>({\n    state,\n    register: env.ops.register,\n    store,\n    requireLayerIndex: layers.requireLayerIndex,\n    rebuildLayerIndex: layers.rebuildLayerIndex,\n    invalidateOrder: env.invalidateOrder,\n    fnFields,\n    narrowSelection: env.narrowSelection,\n    clearOverride: env.clearOverride,\n  });\n\n  const { construct, ...treeEdits } = createTreeEdits<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    generateId: env.generateId,\n    store,\n    locks,\n    layers,\n    fnFields,\n    runOp: env.ops.run,\n    recorder,\n    arrivals,\n  });\n\n  const fieldEdits = createFieldEdits<TData, TLayer, TPose>({\n    store,\n    locks,\n    layers,\n    recorder,\n    arrivals,\n    layoutFrame: env.layoutFrame,\n    layoutField: fnFields.find((f) => f.spec.field === 'layout')!,\n    layoutRefs,\n  });\n\n  const layerEdits = createLayerEdits<TData, TLayer, TPose>({\n    layers: state.layers,\n    layerIndex: state.layerIndex,\n    nodes: state.nodes,\n    requireLayerIndex: layers.requireLayerIndex,\n    record: recorder.record,\n    lifted: locks.lifted,\n    batch: recorder.batch,\n    removeMany: treeEdits.removeMany,\n  });\n\n  const flagEdits = createNodeFlags<TData, TLayer, TPose>({\n    register: env.ops.register,\n    requireNode: store.requireNode,\n    record: recorder.record,\n    narrowSelection: () => env.narrowSelection(),\n  });\n\n  const declaredEdits = createDeclaredFieldSetters<TData, TLayer, TPose>({\n    register: env.ops.register,\n    requireNode: store.requireNode,\n    refuse: locks.refuse,\n    record: recorder.record,\n  });\n\n  const doc = createSceneDoc({ values: state.docValues, register: env.ops.register, record: recorder.record });\n\n  return { construct, methods: { ...treeEdits, ...fieldEdits, ...layerEdits, ...flagEdits, ...declaredEdits, doc } };\n}\n"],"mappings":";;;;;;;;;AAuDA,SAAgB,iBACd,KACkC;CAClC,MAAM,EAAE,OAAO,OAAO,OAAO,QAAQ,UAAU,UAAU,aAAa;CAEtE,MAAM,EAAE,eAAe,eAAqC;EAC1D;EACA,UAAU,IAAI,IAAI;EAClB;EACA,mBAAmB,OAAO;EAC1B,mBAAmB,OAAO;EAC1B,iBAAiB,IAAI;EACrB;EACA,iBAAiB,IAAI;EACrB,eAAe,IAAI;CACrB,CAAC;CAED,MAAM,EAAE,WAAW,GAAG,cAAc,gBAAsC;EACxE,OAAO,MAAM;EACb,YAAY,IAAI;EAChB;EACA;EACA;EACA;EACA,OAAO,IAAI,IAAI;EACf;EACA;CACF,CAAC;CAED,MAAM,aAAa,iBAAuC;EACxD;EACA;EACA;EACA;EACA;EACA,aAAa,IAAI;EACjB,aAAa,SAAS,MAAM,MAAM,EAAE,KAAK,UAAU,QAAQ;EAC3D;CACF,CAAC;CAED,MAAM,aAAa,iBAAuC;EACxD,QAAQ,MAAM;EACd,YAAY,MAAM;EAClB,OAAO,MAAM;EACb,mBAAmB,OAAO;EAC1B,QAAQ,SAAS;EACjB,QAAQ,MAAM;EACd,OAAO,SAAS;EAChB,YAAY,UAAU;CACxB,CAAC;CAED,MAAM,YAAY,gBAAsC;EACtD,UAAU,IAAI,IAAI;EAClB,aAAa,MAAM;EACnB,QAAQ,SAAS;EACjB,uBAAuB,IAAI,gBAAgB;CAC7C,CAAC;CAED,MAAM,gBAAgB,2BAAiD;EACrE,UAAU,IAAI,IAAI;EAClB,aAAa,MAAM;EACnB,QAAQ,MAAM;EACd,QAAQ,SAAS;CACnB,CAAC;CAED,MAAM,MAAM,eAAe;EAAE,QAAQ,MAAM;EAAW,UAAU,IAAI,IAAI;EAAU,QAAQ,SAAS;CAAO,CAAC;CAE3G,OAAO;EAAE;EAAW,SAAS;GAAE,GAAG;GAAW,GAAG;GAAY,GAAG;GAAY,GAAG;GAAW,GAAG;GAAe;EAAI;CAAE;AACnH"}

package/dist/core/scene/sceneState.js

@@ -41,8 +41,7 @@ function createSceneState(registry, initialLayers, layoutDeclared, initialDoc) {
 		isLocked: (id) => locks.isLocked(id),
 		isHidden: (id) => locks.isHidden(id),
 		layoutOf(id) {
-			const node = state.nodes.get(id);
-			return node?.kind === "container" ? node.layout ?? null : null;
+			return state.nodes.get(id)?.layout ?? null;
 		},
 		toJSON: () => serializeScene(state, fnFields, docValues.toJSON())
 	};

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

@@ -1 +1 @@
-{"version":3,"file":"sceneState.js","names":[],"sources":["../../../src/core/scene/sceneState.ts"],"sourcesContent":["/**\n * A scene's document state — its nodes, roots, and layers — with the modules\n * that read and write it directly.\n */\nimport { createDocStore, type SerializedDoc } from './docValues';\nimport { createLayerStack } from './layerStack';\nimport { createLockGuard } from './lockGuard';\nimport { createNodeFnFields } from './nodeFnFields';\nimport { createNodeStore } from './nodeStore';\nimport { createRenderOrder } from './renderOrder';\nimport { serializeScene } from './serialization';\nimport { createStaleReplay } from './staleReplay';\nimport { createTreeReads } from './treeReads';\nimport type { LayerRecord, Node, NodeId, Scene, SceneRegistry } from './types';\n\nexport function createSceneState<TData, TLayer extends string, TPose>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n  initialLayers: readonly LayerRecord<TLayer>[],\n  /** Called when a node is given a layout. */\n  layoutDeclared: () => void,\n  initialDoc?: SerializedDoc,\n) {\n  const state = {\n    nodes: new Map<NodeId, Node<TData, TLayer, TPose>>(),\n    roots: [] as NodeId[],\n    layers: [] as LayerRecord<TLayer>[],\n    layerIndex: new Map<TLayer, number>(),\n    docValues: new Map<string, unknown>(),\n  };\n  const order = createRenderOrder(state);\n  /** The registry-keyed function fields, each with its key maps. A function\n   *  cannot travel through a serializable op payload, so an op carries its key. */\n  const fnFields = createNodeFnFields<TPose>(registry, (field) => {\n    if (field === 'layout') layoutDeclared();\n  });\n  const store = createNodeStore(state, order.invalidate, fnFields);\n  const layers = createLayerStack(state, order.invalidate);\n  layers.reset(initialLayers);\n  const locks = createLockGuard(state);\n  const docValues = createDocStore(state.docValues);\n  docValues.reset(initialDoc);\n\n  const reads: Pick<\n    Scene<TData, TLayer, TPose>,\n    | 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf' | 'renderOrder' | 'renderOrderNodes'\n    | 'nodesOnLayer' | 'isLocked' | 'isHidden' | 'layoutOf' | 'toJSON'\n  > = {\n    ...createTreeReads(state.nodes),\n    renderOrder: order.ids,\n    renderOrderNodes: order.nodes,\n    nodesOnLayer: order.nodesOnLayer,\n    isLocked: (id) => locks.isLocked(id),\n    isHidden: (id) => locks.isHidden(id),\n    layoutOf(id) {\n      const node = state.nodes.get(id);\n      return node?.kind === 'container' ? (node.layout ?? null) : null;\n    },\n    toJSON: () => serializeScene(state, fnFields, docValues.toJSON()),\n  };\n\n  return {\n    state,\n    order,\n    locks,\n    stale: createStaleReplay(state.nodes),\n    fnFields,\n    store,\n    layers,\n    reads,\n    docValues,\n\n    /** Empty the document and give it `records` as its layers and `values` as its document values. */\n    reset(records: readonly LayerRecord<TLayer>[], values?: SerializedDoc): void {\n      docValues.reset(values);\n      store.dependents.clear();\n      store.childDerived.clear();\n      state.nodes.clear();\n      state.roots.length = 0;\n      layers.reset(records);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,SAAgB,iBACd,UACA,eAEA,gBACA,YACA;CACA,MAAM,QAAQ;EACZ,uBAAO,IAAI,IAAwC;EACnD,OAAO,CAAC;EACR,QAAQ,CAAC;EACT,4BAAY,IAAI,IAAoB;EACpC,2BAAW,IAAI,IAAqB;CACtC;CACA,MAAM,QAAQ,kBAAkB,KAAK;;;CAGrC,MAAM,WAAW,mBAA0B,WAAW,UAAU;EAC9D,IAAI,UAAU,UAAU,eAAe;CACzC,CAAC;CACD,MAAM,QAAQ,gBAAgB,OAAO,MAAM,YAAY,QAAQ;CAC/D,MAAM,SAAS,iBAAiB,OAAO,MAAM,UAAU;CACvD,OAAO,MAAM,aAAa;CAC1B,MAAM,QAAQ,gBAAgB,KAAK;CACnC,MAAM,YAAY,eAAe,MAAM,SAAS;CAChD,UAAU,MAAM,UAAU;CAE1B,MAAM,QAIF;EACF,GAAG,gBAAgB,MAAM,KAAK;EAC9B,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,cAAc,MAAM;EACpB,WAAW,OAAO,MAAM,SAAS,EAAE;EACnC,WAAW,OAAO,MAAM,SAAS,EAAE;EACnC,SAAS,IAAI;GACX,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;GAC/B,OAAO,MAAM,SAAS,cAAe,KAAK,UAAU,OAAQ;EAC9D;EACA,cAAc,eAAe,OAAO,UAAU,UAAU,OAAO,CAAC;CAClE;CAEA,OAAO;EACL;EACA;EACA;EACA,OAAO,kBAAkB,MAAM,KAAK;EACpC;EACA;EACA;EACA;EACA;;EAGA,MAAM,SAAyC,QAA8B;GAC3E,UAAU,MAAM,MAAM;GACtB,MAAM,WAAW,MAAM;GACvB,MAAM,aAAa,MAAM;GACzB,MAAM,MAAM,MAAM;GAClB,MAAM,MAAM,SAAS;GACrB,OAAO,MAAM,OAAO;EACtB;CACF;AACF"}
+{"version":3,"file":"sceneState.js","names":[],"sources":["../../../src/core/scene/sceneState.ts"],"sourcesContent":["/**\n * A scene's document state — its nodes, roots, and layers — with the modules\n * that read and write it directly.\n */\nimport { createDocStore, type SerializedDoc } from './docValues';\nimport { createLayerStack } from './layerStack';\nimport { createLockGuard } from './lockGuard';\nimport { createNodeFnFields } from './nodeFnFields';\nimport { createNodeStore } from './nodeStore';\nimport { createRenderOrder } from './renderOrder';\nimport { serializeScene } from './serialization';\nimport { createStaleReplay } from './staleReplay';\nimport { createTreeReads } from './treeReads';\nimport type { LayerRecord, Node, NodeId, Scene, SceneRegistry } from './types';\n\nexport function createSceneState<TData, TLayer extends string, TPose>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n  initialLayers: readonly LayerRecord<TLayer>[],\n  /** Called when a node is given a layout. */\n  layoutDeclared: () => void,\n  initialDoc?: SerializedDoc,\n) {\n  const state = {\n    nodes: new Map<NodeId, Node<TData, TLayer, TPose>>(),\n    roots: [] as NodeId[],\n    layers: [] as LayerRecord<TLayer>[],\n    layerIndex: new Map<TLayer, number>(),\n    docValues: new Map<string, unknown>(),\n  };\n  const order = createRenderOrder(state);\n  /** The registry-keyed function fields, each with its key maps. A function\n   *  cannot travel through a serializable op payload, so an op carries its key. */\n  const fnFields = createNodeFnFields<TPose>(registry, (field) => {\n    if (field === 'layout') layoutDeclared();\n  });\n  const store = createNodeStore(state, order.invalidate, fnFields);\n  const layers = createLayerStack(state, order.invalidate);\n  layers.reset(initialLayers);\n  const locks = createLockGuard(state);\n  const docValues = createDocStore(state.docValues);\n  docValues.reset(initialDoc);\n\n  const reads: Pick<\n    Scene<TData, TLayer, TPose>,\n    | 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf' | 'renderOrder' | 'renderOrderNodes'\n    | 'nodesOnLayer' | 'isLocked' | 'isHidden' | 'layoutOf' | 'toJSON'\n  > = {\n    ...createTreeReads(state.nodes),\n    renderOrder: order.ids,\n    renderOrderNodes: order.nodes,\n    nodesOnLayer: order.nodesOnLayer,\n    isLocked: (id) => locks.isLocked(id),\n    isHidden: (id) => locks.isHidden(id),\n    layoutOf(id) {\n      const node = state.nodes.get(id);\n      return node?.layout ?? null;\n    },\n    toJSON: () => serializeScene(state, fnFields, docValues.toJSON()),\n  };\n\n  return {\n    state,\n    order,\n    locks,\n    stale: createStaleReplay(state.nodes),\n    fnFields,\n    store,\n    layers,\n    reads,\n    docValues,\n\n    /** Empty the document and give it `records` as its layers and `values` as its document values. */\n    reset(records: readonly LayerRecord<TLayer>[], values?: SerializedDoc): void {\n      docValues.reset(values);\n      store.dependents.clear();\n      store.childDerived.clear();\n      state.nodes.clear();\n      state.roots.length = 0;\n      layers.reset(records);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,SAAgB,iBACd,UACA,eAEA,gBACA,YACA;CACA,MAAM,QAAQ;EACZ,uBAAO,IAAI,IAAwC;EACnD,OAAO,CAAC;EACR,QAAQ,CAAC;EACT,4BAAY,IAAI,IAAoB;EACpC,2BAAW,IAAI,IAAqB;CACtC;CACA,MAAM,QAAQ,kBAAkB,KAAK;;;CAGrC,MAAM,WAAW,mBAA0B,WAAW,UAAU;EAC9D,IAAI,UAAU,UAAU,eAAe;CACzC,CAAC;CACD,MAAM,QAAQ,gBAAgB,OAAO,MAAM,YAAY,QAAQ;CAC/D,MAAM,SAAS,iBAAiB,OAAO,MAAM,UAAU;CACvD,OAAO,MAAM,aAAa;CAC1B,MAAM,QAAQ,gBAAgB,KAAK;CACnC,MAAM,YAAY,eAAe,MAAM,SAAS;CAChD,UAAU,MAAM,UAAU;CAE1B,MAAM,QAIF;EACF,GAAG,gBAAgB,MAAM,KAAK;EAC9B,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,cAAc,MAAM;EACpB,WAAW,OAAO,MAAM,SAAS,EAAE;EACnC,WAAW,OAAO,MAAM,SAAS,EAAE;EACnC,SAAS,IAAI;GAEX,OADa,MAAM,MAAM,IAAI,EACtB,CAAA,EAAM,UAAU;EACzB;EACA,cAAc,eAAe,OAAO,UAAU,UAAU,OAAO,CAAC;CAClE;CAEA,OAAO;EACL;EACA;EACA;EACA,OAAO,kBAAkB,MAAM,KAAK;EACpC;EACA;EACA;EACA;EACA;;EAGA,MAAM,SAAyC,QAA8B;GAC3E,UAAU,MAAM,MAAM;GACtB,MAAM,WAAW,MAAM;GACvB,MAAM,aAAa,MAAM;GACzB,MAAM,MAAM,MAAM;GAClB,MAAM,MAAM,SAAS;GACrB,OAAO,MAAM,OAAO;EACtB;CACF;AACF"}