@weasel-js/core 1.9.2 → 1.9.4

package/dist/core/scene/historyFacade.js

@@ -0,0 +1,84 @@
+//#region src/core/scene/historyFacade.ts
+function e(e) {
+	let { engine: t, replay: n, notify: r, refuseUntracked: i, runArrivalEdit: a } = e, o = /* @__PURE__ */ new WeakMap();
+	function s(t) {
+		let i = {
+			targetId: t.targetId,
+			forkedAtEntryId: t.forkedAtEntryId,
+			applyBatch(n, i) {
+				a(n, (n) => {
+					e.applying(() => t.applyBatch(n, i)), r();
+				});
+			},
+			undo() {
+				n(() => t.undo()), r();
+			},
+			redo() {
+				n(() => t.redo()), r();
+			},
+			canUndo: () => t.canUndo(),
+			canRedo: () => t.canRedo(),
+			entries: () => t.entries(),
+			seal: () => t.seal(),
+			getVersion: () => t.getVersion(),
+			subscribe: (e) => t.subscribe(e),
+			commit(e) {
+				t.commit(e), r();
+			},
+			cancel() {
+				n(() => t.cancel()), r();
+			},
+			suspend: () => t.suspend(),
+			isActive: () => t.isActive()
+		};
+		return o.set(i, t), i;
+	}
+	return {
+		apply(n, o) {
+			i("history.apply"), a([n], (i) => {
+				e.applying(() => i.length === 1 ? t.apply(n, o) : t.applyOps(i, o ?? n.label ?? "")), r();
+			});
+		},
+		applyOps(n, o) {
+			i("history.applyOps"), a(n, (n) => {
+				e.applying(() => t.applyOps(n, o)), r();
+			});
+		},
+		undo: e.undo,
+		redo: e.redo,
+		goto: e.goto,
+		clear() {
+			t.clear(), r();
+		},
+		recordEntry(e, n, i) {
+			t.recordEntry(e, n, i), r();
+		},
+		prune(e) {
+			t.prune(e), r();
+		},
+		switchBranch(e) {
+			t.switchBranch(e), r();
+		},
+		restore: e.restore,
+		canUndo: () => t.canUndo(),
+		canRedo: () => t.canRedo(),
+		undoDepth: () => t.undoDepth(),
+		redoDepth: () => t.redoDepth(),
+		entries: () => t.entries(),
+		timestampAt: (e) => t.timestampAt(e),
+		depthAt: (e) => t.depthAt(e),
+		branches: () => t.branches(),
+		getVersion: () => t.getVersion(),
+		subscribe: (e) => t.subscribe(e),
+		serialize: () => t.serialize(),
+		allForwardOps: () => t.allForwardOps(),
+		seal: () => t.seal(),
+		currentEntryId: () => t.currentEntryId(),
+		beginJournal: (e) => s(t.beginJournal(e)),
+		resumeJournal: (e) => t.resumeJournal(o.get(e) ?? e)
+	};
+}
+//#endregion
+export { e as createSceneHistory };
+
+//# sourceMappingURL=historyFacade.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"historyFacade.js","names":["createSceneHistory","history","env","rawJournals","wrapJournal","wrapped","raw","ops","all","label","notify","replay","listener","refuseUntracked","runArrivalEdit","op","opts","t","id","i","journal"],"sources":["../../../src/core/scene/historyFacade.ts"],"sourcesContent":["/**\n * `scene.history`: the `History` the kit's `undo`/`redo` actions resolve\n * their `history` dep to, and the handle a mode machine opens journals\n * against.\n *\n * Handing out the engine directly would let an action-driven undo replay ops\n * with scene-side recording still armed and without bumping the scene's\n * version, so every member that mutates routes through the scene's own\n * wrappers and one `notify()`; reads forward to the engine.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\n\n/** What the facade needs from the scene it fronts. */\nexport interface SceneHistoryEnv {\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Run a step that applies ops through an engine: all-or-nothing, with\n   *  scene-side recording suppressed. */\n  applying(step: () => void): void;\n  /** Run a step that replays recorded ops: an undo, a redo, a cancel. */\n  replay(step: () => void): void;\n  notify(): void;\n  refuseUntracked(verb: string): void;\n  /** Run an op-driven edit with its arrivals settled into the same batch. */\n  runArrivalEdit(ops: Op[], run: (ops: Op[]) => void): void;\n  undo: History['undo'];\n  redo: History['redo'];\n  goto: History['goto'];\n  restore: History['restore'];\n}\n\nexport function createSceneHistory(env: SceneHistoryEnv): History {\n  const { engine: history, replay, notify, refuseUntracked, runArrivalEdit } = env;\n\n  /** Wrapped journal → the engine's own, for `resumeJournal`: the engine keys\n   *  resumability off journal identity, which a wrapper would not match. */\n  const rawJournals = new WeakMap<Journal, Journal>();\n\n  /** Same treatment as the façade: a journal drives adapter mutation itself,\n   *  so its applies/undos re-enter scene mutation methods. */\n  function wrapJournal(raw: Journal): Journal {\n    const wrapped: Journal = {\n      targetId: raw.targetId,\n      forkedAtEntryId: raw.forkedAtEntryId,\n      applyBatch(ops, label) {\n        runArrivalEdit(ops, (all) => {\n          env.applying(() => raw.applyBatch(all, label));\n          notify();\n        });\n      },\n      undo() {\n        replay(() => raw.undo());\n        notify();\n      },\n      redo() {\n        replay(() => raw.redo());\n        notify();\n      },\n      canUndo: () => raw.canUndo(),\n      canRedo: () => raw.canRedo(),\n      entries: () => raw.entries(),\n      seal: () => raw.seal(),\n      getVersion: () => raw.getVersion(),\n      subscribe: (listener) => raw.subscribe(listener),\n      commit(label) {\n        // Flushes the session's net ops to the parent stack — no apply, but\n        // the parent's undo depth changes and listeners read that.\n        raw.commit(label);\n        notify();\n      },\n      cancel() {\n        replay(() => raw.cancel());\n        notify();\n      },\n      suspend: () => raw.suspend(),\n      isActive: () => raw.isActive(),\n    };\n    rawJournals.set(wrapped, raw);\n    return wrapped;\n  }\n\n  return {\n    // Mutating: applied ops re-enter the scene's own mutation methods.\n    apply(op, label) {\n      refuseUntracked('history.apply');\n      runArrivalEdit([op], (all) => {\n        const run = () => (all.length === 1\n          ? history.apply(op, label)\n          : history.applyOps(all, label ?? op.label ?? ''));\n        env.applying(run);\n        notify();\n      });\n    },\n    applyOps(ops, label) {\n      refuseUntracked('history.applyOps');\n      runArrivalEdit(ops, (all) => {\n        env.applying(() => history.applyOps(all, label));\n        notify();\n      });\n    },\n    undo: env.undo,\n    redo: env.redo,\n    goto: env.goto,\n    // Stack-only: nothing applies, but what `canUndo()` answers changes.\n    clear() {\n      history.clear();\n      notify();\n    },\n    recordEntry(ops, label, opts) {\n      history.recordEntry(ops, label, opts);\n      notify();\n    },\n    prune(t) {\n      history.prune(t);\n      notify();\n    },\n    switchBranch(id) {\n      history.switchBranch(id);\n      notify();\n    },\n    restore: env.restore,\n    // Reads forward to the engine, `version` included: it counts history\n    // operations, where the scene's counts every mutation.\n    canUndo: () => history.canUndo(),\n    canRedo: () => history.canRedo(),\n    undoDepth: () => history.undoDepth(),\n    redoDepth: () => history.redoDepth(),\n    entries: () => history.entries(),\n    timestampAt: (i) => history.timestampAt(i),\n    depthAt: (t) => history.depthAt(t),\n    branches: () => history.branches(),\n    getVersion: () => history.getVersion(),\n    subscribe: (listener) => history.subscribe(listener),\n    serialize: () => history.serialize(),\n    allForwardOps: () => history.allForwardOps(),\n    seal: () => history.seal(),\n    currentEntryId: () => history.currentEntryId(),\n    beginJournal: (opts) => wrapJournal(history.beginJournal(opts)),\n    resumeJournal: (journal) => history.resumeJournal(rawJournals.get(journal) ?? journal),\n  };\n}\n"],"mappings":";AAgCA,SAAgBA,EAAmB,GAA+B;CAChE,IAAM,EAAE,QAAQC,GAAS,WAAQ,WAAQ,oBAAiB,sBAAmBC,GAIvEC,oBAAc,IAAI,QAA0B;CAIlD,SAASC,EAAY,GAAuB;EAC1C,IAAMC,IAAmB;GACvB,UAAUC,EAAI;GACd,iBAAiBA,EAAI;GACrB,WAAW,GAAK,GAAO;IACrB,EAAeC,IAAM,MAAQ;KAE3B,AADAL,EAAI,eAAeI,EAAI,WAAWE,GAAKC,CAAK,CAAC,GAC7CC,EAAO;IACT,CAAC;GACH;GACA,OAAO;IAEL,AADAC,QAAaL,EAAI,KAAK,CAAC,GACvBI,EAAO;GACT;GACA,OAAO;IAEL,AADAC,QAAaL,EAAI,KAAK,CAAC,GACvBI,EAAO;GACT;GACA,eAAeJ,EAAI,QAAQ;GAC3B,eAAeA,EAAI,QAAQ;GAC3B,eAAeA,EAAI,QAAQ;GAC3B,YAAYA,EAAI,KAAK;GACrB,kBAAkBA,EAAI,WAAW;GACjC,YAAY,MAAaA,EAAI,UAAUM,CAAQ;GAC/C,OAAO,GAAO;IAIZ,AADAN,EAAI,OAAOG,CAAK,GAChBC,EAAO;GACT;GACA,SAAS;IAEP,AADAC,QAAaL,EAAI,OAAO,CAAC,GACzBI,EAAO;GACT;GACA,eAAeJ,EAAI,QAAQ;GAC3B,gBAAgBA,EAAI,SAAS;EAC/B;EAEA,OADAH,EAAY,IAAIE,GAASC,CAAG,GACrBD;CACT;CAEA,OAAO;EAEL,MAAM,GAAI,GAAO;GAEf,AADAQ,EAAgB,eAAe,GAC/BC,EAAe,CAACC,CAAE,IAAI,MAAQ;IAK5B,AADAb,EAAI,eAHeM,EAAI,WAAW,IAC9BP,EAAQ,MAAMc,GAAIN,CAAK,IACvBR,EAAQ,SAASO,GAAKC,KAASM,EAAG,SAAS,EAAE,CACjC,GAChBL,EAAO;GACT,CAAC;EACH;EACA,SAAS,GAAK,GAAO;GAEnB,AADAG,EAAgB,kBAAkB,GAClCC,EAAeP,IAAM,MAAQ;IAE3B,AADAL,EAAI,eAAeD,EAAQ,SAASO,GAAKC,CAAK,CAAC,GAC/CC,EAAO;GACT,CAAC;EACH;EACA,MAAMR,EAAI;EACV,MAAMA,EAAI;EACV,MAAMA,EAAI;EAEV,QAAQ;GAEN,AADAD,EAAQ,MAAM,GACdS,EAAO;EACT;EACA,YAAY,GAAK,GAAO,GAAM;GAE5B,AADAT,EAAQ,YAAYM,GAAKE,GAAOO,CAAI,GACpCN,EAAO;EACT;EACA,MAAM,GAAG;GAEP,AADAT,EAAQ,MAAMgB,CAAC,GACfP,EAAO;EACT;EACA,aAAa,GAAI;GAEf,AADAT,EAAQ,aAAaiB,CAAE,GACvBR,EAAO;EACT;EACA,SAASR,EAAI;EAGb,eAAeD,EAAQ,QAAQ;EAC/B,eAAeA,EAAQ,QAAQ;EAC/B,iBAAiBA,EAAQ,UAAU;EACnC,iBAAiBA,EAAQ,UAAU;EACnC,eAAeA,EAAQ,QAAQ;EAC/B,cAAc,MAAMA,EAAQ,YAAYkB,CAAC;EACzC,UAAU,MAAMlB,EAAQ,QAAQgB,CAAC;EACjC,gBAAgBhB,EAAQ,SAAS;EACjC,kBAAkBA,EAAQ,WAAW;EACrC,YAAY,MAAaA,EAAQ,UAAUW,CAAQ;EACnD,iBAAiBX,EAAQ,UAAU;EACnC,qBAAqBA,EAAQ,cAAc;EAC3C,YAAYA,EAAQ,KAAK;EACzB,sBAAsBA,EAAQ,eAAe;EAC7C,eAAe,MAASG,EAAYH,EAAQ,aAAae,CAAI,CAAC;EAC9D,gBAAgB,MAAYf,EAAQ,cAAcE,EAAY,IAAIiB,CAAO,KAAKA,CAAO;CACvF;AACF"}

package/dist/core/scene/kitOps.js

@@ -0,0 +1,173 @@
+import { dwarn as e } from "../../debug/flag.js";
+import { restoreFn as t } from "./nodeFnFields.js";
+//#region src/core/scene/kitOps.ts
+function n(e, t) {
+	t === void 0 ? delete e.parallax : e.parallax = t;
+}
+function r(r) {
+	let { state: i, requireLayerIndex: a, rebuildLayerIndex: o, invalidateOrder: s, fnFields: c } = r, { dependents: l, childDerived: u, invalidateDependents: d, invalidateChildDerivedFrom: f, trackChildDerived: p, retarget: m, requireNode: h, detach: g, attach: _, addedFns: v, restoreNodeFunctions: y } = r.store;
+	function b(e, t) {
+		r.register(e, t);
+	}
+	b("kit:add", {
+		apply: (n) => {
+			if (i.nodes.has(n.id)) throw Error(`Scene: id collision on "${n.id}"`);
+			let r = n.kind === "container" ? {
+				kind: "container",
+				id: n.id,
+				layer: n.layer,
+				pose: n.pose,
+				data: n.data,
+				parent: n.parent,
+				children: []
+			} : {
+				kind: "leaf",
+				id: n.id,
+				layer: n.layer,
+				pose: n.pose,
+				data: n.data,
+				parent: n.parent
+			};
+			i.nodes.set(n.id, r), _(n.id, n.parent, n.index), n.dependsOn !== void 0 && (r.dependsOn = n.dependsOn), n.pickable !== void 0 && (r.pickable = n.pickable), l.add(n.id, n.dependsOn === "children" ? [] : n.dependsOn ?? []), p(n.id, n.dependsOn);
+			let a = r, o = v.get(n);
+			for (let r of c) {
+				let i = o?.get(r);
+				if (i !== void 0) {
+					r.write(a, i);
+					continue;
+				}
+				let s = n[r.spec.opKey];
+				s !== void 0 && t(r, a, s, "kit:add", e);
+			}
+			d(n.id);
+		},
+		revert: (e) => {
+			g(e.id), i.nodes.delete(e.id), l.remove(e.id), u.delete(e.id), f(e.parent), d(e.id);
+		}
+	}), b("kit:remove", {
+		apply: (e) => {
+			for (let t of e.detached) g(t.id);
+			for (let t of e.nodes) i.nodes.delete(t.id), l.remove(t.id), u.delete(t.id);
+			for (let t of e.detached) f(t.parent);
+		},
+		revert: (e) => {
+			let t = new Map((e.fnKeys ?? []).map((e) => [e.id, e]));
+			for (let n of e.nodes) {
+				let e = n.kind === "container" ? {
+					...n,
+					children: [...n.children]
+				} : { ...n };
+				y(e, t.get(n.id)), i.nodes.set(n.id, e), l.add(n.id, e.dependsOn === "children" ? [] : e.dependsOn ?? []), p(n.id, e.dependsOn);
+			}
+			for (let t of e.detached) _(t.id, t.parent, t.index);
+			for (let t of e.detached) f(t.parent);
+		}
+	}), b("kit:setPose", {
+		apply: (e) => {
+			h(e.id).pose = e.to, d(e.id);
+		},
+		revert: (e) => {
+			h(e.id).pose = e.from, d(e.id);
+		}
+	}), b("kit:setData", {
+		apply: (e) => {
+			h(e.id).data = e.to, d(e.id);
+		},
+		revert: (e) => {
+			h(e.id).data = e.from, d(e.id);
+		}
+	}), b("kit:setLayer", {
+		apply: (e) => {
+			a(e.to), h(e.id).layer = e.to, s(), d(e.id);
+		},
+		revert: (e) => {
+			h(e.id).layer = e.from, s(), d(e.id);
+		}
+	}), b("kit:setDependsOn", {
+		apply: (e) => {
+			m(e.id, e.to);
+		},
+		revert: (e) => {
+			m(e.id, e.from);
+		}
+	});
+	let x = /* @__PURE__ */ new WeakMap();
+	function S(n, r) {
+		let i = h(n.id), a = c.find((e) => e.spec.field === "layout"), o = x.get(n), s = r === "from" ? n.fromKey : n.toKey;
+		if (o === void 0 && s !== void 0) {
+			delete i.layout, t(a, i, s, "kit:setLayout", e);
+			return;
+		}
+		let l = o?.[r] ?? null;
+		l === null ? delete i.layout : a.write(i, l);
+	}
+	b("kit:setLayout", {
+		apply: (e) => {
+			S(e, "to");
+		},
+		revert: (e) => {
+			S(e, "from");
+		}
+	}), b("kit:move", {
+		apply: (e) => {
+			g(e.id), _(e.id, e.toParent, e.toIndex), f(e.fromParent), d(e.id);
+		},
+		revert: (e) => {
+			g(e.id), _(e.id, e.fromParent, e.fromIndex), f(e.toParent), d(e.id);
+		}
+	}), b("kit:setLayerVisible", {
+		apply: (e) => {
+			i.layers[a(e.layer)].visible = e.to;
+		},
+		revert: (e) => {
+			i.layers[a(e.layer)].visible = e.from;
+		}
+	}), b("kit:setLayerLocked", {
+		apply: (e) => {
+			i.layers[a(e.layer)].locked = e.to, e.to && r.narrowSelection();
+		},
+		revert: (e) => {
+			i.layers[a(e.layer)].locked = e.from;
+		}
+	}), b("kit:setLayerParallax", {
+		apply: (e) => {
+			n(i.layers[a(e.layer)], e.to);
+		},
+		revert: (e) => {
+			n(i.layers[a(e.layer)], e.from);
+		}
+	}), b("kit:addLayer", {
+		apply: (e) => {
+			i.layers.splice(e.index, 0, { ...e.record }), o();
+		},
+		revert: (e) => {
+			i.layers.splice(e.index, 1), o();
+		}
+	}), b("kit:removeLayer", {
+		apply: (e) => {
+			i.layers.splice(e.index, 1), o();
+		},
+		revert: (e) => {
+			i.layers.splice(e.index, 0, { ...e.record }), o();
+		}
+	}), b("kit:renameLayer", {
+		apply: (e) => {
+			i.layers[a(e.layer)].name = e.to;
+		},
+		revert: (e) => {
+			i.layers[a(e.layer)].name = e.from;
+		}
+	});
+	function C(e, t) {
+		let [n] = i.layers.splice(a(e), 1);
+		i.layers.splice(t, 0, n), o();
+	}
+	return b("kit:moveLayer", {
+		apply: (e) => C(e.layer, e.to),
+		revert: (e) => C(e.layer, e.from)
+	}), { layoutRefs: x };
+}
+//#endregion
+export { r as registerKitOps };
+
+//# sourceMappingURL=kitOps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kitOps.js","names":["setParallax","to","record","registerKitOps","env","registerKitOp","kind","handler","state","p","node","attach","dependents","trackChildDerived","target","attached","addedFns","field","fnFields","fn","key","restoreFn","dwarn","detach","childDerived","invalidateChildDerivedFrom","invalidateDependents","d","n","keys","k","clone","restoreNodeFunctions","requireLayerIndex","invalidateOrder","layoutRefs","placeLayout","requireNode","f","live","side","layout","rebuildLayerIndex","placeLayer","rec","layer","index"],"sources":["../../../src/core/scene/kitOps.ts"],"sourcesContent":["/**\n * The kit's own op kinds: `kit:add`, `kit:remove`, `kit:setPose`, and the\n * rest. They are registered like any other op; the scene's mutation methods\n * build serializable payloads and route through the same log and replay\n * machinery a consumer's ops do.\n */\nimport type { ParallaxOpts } from 'core/viewport/parallax';\nimport { dwarn } from 'debug/flag';\nimport type { LayoutStrategy } from '../../layout/types';\nimport { restoreFn, type FnBearingNode, type NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type {\n  ContainerNode, LayerRecord, LeafNode, Node, NodeId, RegisteredOp, UserLayerRecord,\n} from './types';\n\n/**\n * Snapshot of every node a removal deletes, so revert restores it exactly.\n *\n * A cascade unlinks several disjoint subtrees, not one, so `detached` names\n * each node the tree has to re-link; everything else in `nodes` has a parent\n * that is also going and rides back in that parent's cloned `children`.\n * Entries are sorted by ascending sibling index — globally rather than\n * per-parent, because only same-parent order constrains re-insertion and\n * entries under different parents never interact.\n */\nexport interface RemoveSnapshot<TData, TLayer extends string, TPose> {\n  nodes: Node<TData, TLayer, TPose>[];\n  detached: { id: NodeId; parent: NodeId | null; index: number }[];\n  /** Registry keys for the function-valued fields on `nodes`. The functions\n   *  themselves do not survive a persisted history, so revert re-resolves\n   *  them the way `kit:add` does. */\n  fnKeys?: ({ id: NodeId } & Record<string, string | undefined>)[];\n}\n\n/** What a `kit:setLayout` op carries: the container, and each side's layout\n *  by registry key when it has one. */\nexport interface SetLayoutPayload { id: NodeId; fromKey?: string; toKey?: string }\n\n/** What the op table needs from the scene it mutates. */\nexport interface KitOpsEnv<TData, TLayer extends string, TPose> {\n  state: {\n    nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n    layers: LayerRecord<TLayer>[];\n  };\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  store: ReturnType<typeof createNodeStore<TData, TLayer, TPose>>;\n  requireLayerIndex(layer: TLayer): number;\n  rebuildLayerIndex(): void;\n  invalidateOrder(): void;\n  fnFields: readonly NodeFnField[];\n  /** Drop from the selection whatever a layer lock just put out of reach. */\n  narrowSelection(): void;\n}\n\nfunction setParallax(record: { parallax?: ParallaxOpts }, to: ParallaxOpts | undefined): void {\n  if (to === undefined) delete record.parallax;\n  else record.parallax = to;\n}\n\n/** Register every kit op kind. Answers with the table a live `kit:setLayout`\n *  payload's strategies are kept in, which `scene.setLayout` fills. */\nexport function registerKitOps<TData, TLayer extends string, TPose>(\n  env: KitOpsEnv<TData, TLayer, TPose>,\n): {\n  layoutRefs: WeakMap<object, { from: LayoutStrategy<TPose> | null; to: LayoutStrategy<TPose> | null }>;\n} {\n  const { state, requireLayerIndex, rebuildLayerIndex, invalidateOrder, fnFields } = env;\n  const {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, detach, attach, addedFns, restoreNodeFunctions,\n  } = env.store;\n\n  function registerKitOp<P>(kind: string, handler: RegisteredOp<P>): void {\n    env.register(kind, handler as RegisteredOp<unknown>);\n  }\n\n  registerKitOp<{\n    id: NodeId; kind: 'leaf' | 'container'; layer: TLayer; pose: TPose; data: TData;\n    parent: NodeId | null; index: number;\n    dependsOn?: readonly NodeId[] | 'children';\n    pickable?: boolean;\n  } & Record<string, unknown>>('kit:add', {\n    apply: (p) => {\n      if (state.nodes.has(p.id)) {\n        throw new Error(`Scene: id collision on \"${p.id}\"`);\n      }\n      const node: Node<TData, TLayer, TPose> = p.kind === 'container'\n        ? ({ kind: 'container', id: p.id, layer: p.layer, pose: p.pose, data: p.data, parent: p.parent, children: [] } as ContainerNode<TData, TLayer, TPose>)\n        : ({ kind: 'leaf', id: p.id, layer: p.layer, pose: p.pose, data: p.data, parent: p.parent } as LeafNode<TData, TLayer, TPose>);\n      state.nodes.set(p.id, node);\n      attach(p.id, p.parent, p.index);\n      if (p.dependsOn !== undefined) node.dependsOn = p.dependsOn;\n      if (p.pickable !== undefined) node.pickable = p.pickable;\n      dependents.add(p.id, p.dependsOn === 'children' ? [] : p.dependsOn ?? []);\n      trackChildDerived(p.id, p.dependsOn);\n      // Two ways a function field comes back. Redo of a live add reads\n      // what `scene.add` attached, since it replays the op without a spec.\n      // A restored history has only the registry key the payload carries.\n      const target = node as unknown as FnBearingNode;\n      const attached = addedFns.get(p);\n      for (const field of fnFields) {\n        const fn = attached?.get(field);\n        if (fn !== undefined) {\n          field.write(target, fn);\n          continue;\n        }\n        const key = p[field.spec.opKey] as string | undefined;\n        if (key !== undefined) restoreFn(field, target, key, 'kit:add', dwarn);\n      }\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      detach(p.id);\n      state.nodes.delete(p.id);\n      dependents.remove(p.id);\n      childDerived.delete(p.id);\n      invalidateChildDerivedFrom(p.parent);\n      invalidateDependents(p.id);\n    },\n  });\n\n  // Neither half invalidates dependents: removal's closure takes every live one.\n  registerKitOp<RemoveSnapshot<TData, TLayer, TPose>>('kit:remove', {\n    apply: (p) => {\n      for (const d of p.detached) detach(d.id);\n      for (const n of p.nodes) {\n        state.nodes.delete(n.id);\n        dependents.remove(n.id);\n        childDerived.delete(n.id);\n      }\n      // A `dependsOn: 'children'` container the removal did not take is now\n      // hugging a smaller set.\n      for (const d of p.detached) invalidateChildDerivedFrom(d.parent);\n    },\n    revert: (p) => {\n      const keys = new Map((p.fnKeys ?? []).map((k) => [k.id, k]));\n      // Order-independent: every clone carries its own parent and children.\n      for (const n of p.nodes) {\n        const clone: Node<TData, TLayer, TPose> = n.kind === 'container'\n          ? { ...n, children: [...n.children] }\n          : { ...n };\n        restoreNodeFunctions(clone, keys.get(n.id));\n        state.nodes.set(n.id, clone);\n        dependents.add(n.id, clone.dependsOn === 'children' ? [] : clone.dependsOn ?? []);\n        trackChildDerived(n.id, clone.dependsOn);\n      }\n      for (const d of p.detached) attach(d.id, d.parent, d.index);\n      for (const d of p.detached) invalidateChildDerivedFrom(d.parent);\n    },\n  });\n\n  registerKitOp<{ id: NodeId; from: TPose; to: TPose }>('kit:setPose', {\n    apply: (p) => {\n      (requireNode(p.id) as { pose: TPose }).pose = p.to;\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      (requireNode(p.id) as { pose: TPose }).pose = p.from;\n      invalidateDependents(p.id);\n    },\n  });\n\n  // A derivation is handed its dependencies' nodes, not only their poses, so a\n  // connector reading `data` or `layer` goes stale on these two exactly as it\n  // does on a move.\n  registerKitOp<{ id: NodeId; from: TData; to: TData }>('kit:setData', {\n    apply: (p) => {\n      (requireNode(p.id) as { data: TData }).data = p.to;\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      (requireNode(p.id) as { data: TData }).data = p.from;\n      invalidateDependents(p.id);\n    },\n  });\n\n  registerKitOp<{ id: NodeId; from: TLayer; to: TLayer }>('kit:setLayer', {\n    apply: (p) => {\n      requireLayerIndex(p.to);\n      (requireNode(p.id) as { layer: TLayer }).layer = p.to;\n      invalidateOrder();\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      (requireNode(p.id) as { layer: TLayer }).layer = p.from;\n      invalidateOrder();\n      invalidateDependents(p.id);\n    },\n  });\n\n  registerKitOp<{\n    id: NodeId;\n    from: Node<TData, TLayer, TPose>['dependsOn'];\n    to: Node<TData, TLayer, TPose>['dependsOn'];\n  }>('kit:setDependsOn', {\n    apply: (p) => { retarget(p.id, p.to); },\n    revert: (p) => { retarget(p.id, p.from); },\n  });\n\n  /** The strategies each live `kit:setLayout` payload swaps between. A payload\n   *  replayed from a persisted history has none, and resolves its keys. */\n  const layoutRefs = new WeakMap<object, { from: LayoutStrategy<TPose> | null; to: LayoutStrategy<TPose> | null }>();\n  function placeLayout(p: SetLayoutPayload, side: 'from' | 'to'): void {\n    const node = requireNode(p.id) as unknown as FnBearingNode;\n    const field = fnFields.find((f) => f.spec.field === 'layout')!;\n    const live = layoutRefs.get(p);\n    const key = side === 'from' ? p.fromKey : p.toKey;\n    if (live === undefined && key !== undefined) {\n      delete node.layout;\n      restoreFn(field, node, key, 'kit:setLayout', dwarn);\n      return;\n    }\n    const layout = live?.[side] ?? null;\n    if (layout === null) delete node.layout;\n    else field.write(node, layout);\n  }\n  registerKitOp<SetLayoutPayload>('kit:setLayout', {\n    apply: (p) => { placeLayout(p, 'to'); },\n    revert: (p) => { placeLayout(p, 'from'); },\n  });\n\n  registerKitOp<{\n    id: NodeId; fromParent: NodeId | null; fromIndex: number;\n    toParent: NodeId | null; toIndex: number;\n  }>('kit:move', {\n    apply: (p) => {\n      detach(p.id);\n      attach(p.id, p.toParent, p.toIndex);\n      // Both ends: the container it left no longer hugs it, and the one it\n      // joined now does.\n      invalidateChildDerivedFrom(p.fromParent);\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      detach(p.id);\n      attach(p.id, p.fromParent, p.fromIndex);\n      invalidateChildDerivedFrom(p.toParent);\n      invalidateDependents(p.id);\n    },\n  });\n\n  registerKitOp<{ layer: TLayer; from: boolean; to: boolean }>('kit:setLayerVisible', {\n    apply: (p) => { state.layers[requireLayerIndex(p.layer)].visible = p.to; },\n    revert: (p) => { state.layers[requireLayerIndex(p.layer)].visible = p.from; },\n  });\n\n  registerKitOp<{ layer: TLayer; from: boolean; to: boolean }>('kit:setLayerLocked', {\n    apply: (p) => {\n      state.layers[requireLayerIndex(p.layer)].locked = p.to;\n      if (p.to) env.narrowSelection();\n    },\n    revert: (p) => { state.layers[requireLayerIndex(p.layer)].locked = p.from; },\n  });\n\n  registerKitOp<{ layer: TLayer; from?: ParallaxOpts; to?: ParallaxOpts }>('kit:setLayerParallax', {\n    apply: (p) => { setParallax(state.layers[requireLayerIndex(p.layer)], p.to); },\n    revert: (p) => { setParallax(state.layers[requireLayerIndex(p.layer)], p.from); },\n  });\n\n  registerKitOp<{ record: UserLayerRecord<TLayer>; index: number }>('kit:addLayer', {\n    apply: (p) => {\n      state.layers.splice(p.index, 0, { ...p.record });\n      rebuildLayerIndex();\n    },\n    revert: (p) => {\n      state.layers.splice(p.index, 1);\n      rebuildLayerIndex();\n    },\n  });\n\n  registerKitOp<{ record: LayerRecord<TLayer>; index: number }>('kit:removeLayer', {\n    apply: (p) => {\n      state.layers.splice(p.index, 1);\n      rebuildLayerIndex();\n    },\n    revert: (p) => {\n      state.layers.splice(p.index, 0, { ...p.record } as LayerRecord<TLayer>);\n      rebuildLayerIndex();\n    },\n  });\n\n  registerKitOp<{ layer: TLayer; from: string; to: string }>('kit:renameLayer', {\n    apply: (p) => {\n      (state.layers[requireLayerIndex(p.layer)] as UserLayerRecord<TLayer>).name = p.to;\n    },\n    revert: (p) => {\n      (state.layers[requireLayerIndex(p.layer)] as UserLayerRecord<TLayer>).name = p.from;\n    },\n  });\n\n  /** Finds the layer by id, not by where the payload last left it: moves of\n   *  one layer coalesce, and the entry then reverts the first payload from\n   *  wherever the last one put the layer. */\n  function placeLayer(layer: TLayer, index: number): void {\n    const [rec] = state.layers.splice(requireLayerIndex(layer), 1);\n    state.layers.splice(index, 0, rec);\n    rebuildLayerIndex();\n  }\n\n  registerKitOp<{ layer: TLayer; from: number; to: number }>('kit:moveLayer', {\n    apply: (p) => placeLayer(p.layer, p.to),\n    revert: (p) => placeLayer(p.layer, p.from),\n  });\n\n  return { layoutRefs };\n}\n"],"mappings":";;;AAsDA,SAASA,EAAY,GAAqC,GAAoC;CAC5F,AAAIC,MAAO,KAAA,IAAW,OAAOC,EAAO,WAC/B,EAAO,WAAWD;AACzB;AAIA,SAAgBE,EACd,GAGA;CACA,IAAM,EAAE,UAAO,sBAAmB,sBAAmB,oBAAiB,gBAAaC,GAC7E,EACJ,eAAY,iBAAc,yBAAsB,+BAA4B,sBAAmB,aAC/F,gBAAa,WAAQ,WAAQ,aAAU,4BACrCA,EAAI;CAER,SAASC,EAAiB,GAAc,GAAgC;EACtE,EAAI,SAASC,GAAMC,CAAgC;CACrD;CAoHA,AAlHAF,EAK6B,WAAW;EACtC,QAAQ,MAAM;GACZ,IAAIG,EAAM,MAAM,IAAIC,EAAE,EAAE,GACtB,MAAU,MAAM,2BAA2BA,EAAE,GAAG,EAAE;GAEpD,IAAMC,IAAmCD,EAAE,SAAS,cAC/C;IAAE,MAAM;IAAa,IAAIA,EAAE;IAAI,OAAOA,EAAE;IAAO,MAAMA,EAAE;IAAM,MAAMA,EAAE;IAAM,QAAQA,EAAE;IAAQ,UAAU,CAAC;GAAE,IAC1G;IAAE,MAAM;IAAQ,IAAIA,EAAE;IAAI,OAAOA,EAAE;IAAO,MAAMA,EAAE;IAAM,MAAMA,EAAE;IAAM,QAAQA,EAAE;GAAO;GAM5F,AALAD,EAAM,MAAM,IAAIC,EAAE,IAAIC,CAAI,GAC1BC,EAAOF,EAAE,IAAIA,EAAE,QAAQA,EAAE,KAAK,GAC1BA,EAAE,cAAc,KAAA,MAAW,EAAK,YAAYA,EAAE,YAC9CA,EAAE,aAAa,KAAA,MAAW,EAAK,WAAWA,EAAE,WAChDG,EAAW,IAAIH,EAAE,IAAIA,EAAE,cAAc,aAAa,CAAC,IAAIA,EAAE,aAAa,CAAC,CAAC,GACxEI,EAAkBJ,EAAE,IAAIA,EAAE,SAAS;GAInC,IAAMK,IAASJ,GACTK,IAAWC,EAAS,IAAIP,CAAC;GAC/B,KAAK,IAAMQ,KAASC,GAAU;IAC5B,IAAMC,IAAKJ,GAAU,IAAIE,CAAK;IAC9B,IAAIE,MAAO,KAAA,GAAW;KACpB,EAAM,MAAML,GAAQK,CAAE;KACtB;IACF;IACA,IAAMC,IAAMX,EAAEQ,EAAM,KAAK;IACzB,AAAIG,MAAQ,KAAA,KAAWC,EAAUJ,GAAOH,GAAQM,GAAK,WAAWE,CAAK;GACvE;GACA,EAAqBb,EAAE,EAAE;EAC3B;EACA,SAAS,MAAM;GAMb,AALAc,EAAOd,EAAE,EAAE,GACXD,EAAM,MAAM,OAAOC,EAAE,EAAE,GACvBG,EAAW,OAAOH,EAAE,EAAE,GACtBe,EAAa,OAAOf,EAAE,EAAE,GACxBgB,EAA2BhB,EAAE,MAAM,GACnCiB,EAAqBjB,EAAE,EAAE;EAC3B;CACF,CAAC,GAGDJ,EAAoD,cAAc;EAChE,QAAQ,MAAM;GACZ,KAAK,IAAMsB,KAAKlB,EAAE,UAAU,EAAOkB,EAAE,EAAE;GACvC,KAAK,IAAMC,KAAKnB,EAAE,OAGhB,AAFAD,EAAM,MAAM,OAAOoB,EAAE,EAAE,GACvBhB,EAAW,OAAOgB,EAAE,EAAE,GACtBJ,EAAa,OAAOI,EAAE,EAAE;GAI1B,KAAK,IAAMD,KAAKlB,EAAE,UAAU,EAA2BkB,EAAE,MAAM;EACjE;EACA,SAAS,MAAM;GACb,IAAME,IAAO,IAAI,KAAKpB,EAAE,UAAU,CAAC,EAAA,CAAG,KAAK,MAAM,CAACqB,EAAE,IAAIA,CAAC,CAAC,CAAC;GAE3D,KAAK,IAAM,KAAKrB,EAAE,OAAO;IACvB,IAAMsB,IAAoC,EAAE,SAAS,cACjD;KAAE,GAAG;KAAG,UAAU,CAAC,GAAG,EAAE,QAAQ;IAAE,IAClC,EAAE,GAAG,EAAE;IAIX,AAHAC,EAAqBD,GAAOF,EAAK,IAAI,EAAE,EAAE,CAAC,GAC1CrB,EAAM,MAAM,IAAI,EAAE,IAAIuB,CAAK,GAC3BnB,EAAW,IAAI,EAAE,IAAImB,EAAM,cAAc,aAAa,CAAC,IAAIA,EAAM,aAAa,CAAC,CAAC,GAChFlB,EAAkB,EAAE,IAAIkB,EAAM,SAAS;GACzC;GACA,KAAK,IAAMJ,KAAKlB,EAAE,UAAU,EAAOkB,EAAE,IAAIA,EAAE,QAAQA,EAAE,KAAK;GAC1D,KAAK,IAAMA,KAAKlB,EAAE,UAAU,EAA2BkB,EAAE,MAAM;EACjE;CACF,CAAC,GAEDtB,EAAsD,eAAe;EACnE,QAAQ,MAAM;GAEZ,AADA,EAAaI,EAAE,EAAE,CAAC,CAAqB,OAAOA,EAAE,IAChDiB,EAAqBjB,EAAE,EAAE;EAC3B;EACA,SAAS,MAAM;GAEb,AADA,EAAaA,EAAE,EAAE,CAAC,CAAqB,OAAOA,EAAE,MAChDiB,EAAqBjB,EAAE,EAAE;EAC3B;CACF,CAAC,GAKDJ,EAAsD,eAAe;EACnE,QAAQ,MAAM;GAEZ,AADA,EAAaI,EAAE,EAAE,CAAC,CAAqB,OAAOA,EAAE,IAChDiB,EAAqBjB,EAAE,EAAE;EAC3B;EACA,SAAS,MAAM;GAEb,AADA,EAAaA,EAAE,EAAE,CAAC,CAAqB,OAAOA,EAAE,MAChDiB,EAAqBjB,EAAE,EAAE;EAC3B;CACF,CAAC,GAEDJ,EAAwD,gBAAgB;EACtE,QAAQ,MAAM;GAIZ,AAHA4B,EAAkBxB,EAAE,EAAE,GACtB,EAAaA,EAAE,EAAE,CAAC,CAAuB,QAAQA,EAAE,IACnDyB,EAAgB,GAChBR,EAAqBjB,EAAE,EAAE;EAC3B;EACA,SAAS,MAAM;GAGb,AAFA,EAAaA,EAAE,EAAE,CAAC,CAAuB,QAAQA,EAAE,MACnDyB,EAAgB,GAChBR,EAAqBjB,EAAE,EAAE;EAC3B;CACF,CAAC,GAEDJ,EAIG,oBAAoB;EACrB,QAAQ,MAAM;GAAE,EAASI,EAAE,IAAIA,EAAE,EAAE;EAAG;EACtC,SAAS,MAAM;GAAE,EAASA,EAAE,IAAIA,EAAE,IAAI;EAAG;CAC3C,CAAC;CAID,IAAM0B,oBAAa,IAAI,QAA0F;CACjH,SAASC,EAAY,GAAqB,GAA2B;EACnE,IAAM1B,IAAO2B,EAAY5B,EAAE,EAAE,GACvBQ,IAAQC,EAAS,MAAM,MAAMoB,EAAE,KAAK,UAAU,QAAQ,GACtDC,IAAOJ,EAAW,IAAI1B,CAAC,GACvBW,IAAMoB,MAAS,SAAS/B,EAAE,UAAUA,EAAE;EAC5C,IAAI8B,MAAS,KAAA,KAAanB,MAAQ,KAAA,GAAW;GAE3C,AADA,OAAOV,EAAK,QACZW,EAAUJ,GAAOP,GAAMU,GAAK,iBAAiBE,CAAK;GAClD;EACF;EACA,IAAMmB,IAASF,IAAOC,MAAS;EAC/B,AAAIC,MAAW,OAAM,OAAO/B,EAAK,SAC5BO,EAAM,MAAMP,GAAM+B,CAAM;CAC/B;CAkEA,AAjEApC,EAAgC,iBAAiB;EAC/C,QAAQ,MAAM;GAAE,EAAYI,GAAG,IAAI;EAAG;EACtC,SAAS,MAAM;GAAE,EAAYA,GAAG,MAAM;EAAG;CAC3C,CAAC,GAEDJ,EAGG,YAAY;EACb,QAAQ,MAAM;GAMZ,AALAkB,EAAOd,EAAE,EAAE,GACXE,EAAOF,EAAE,IAAIA,EAAE,UAAUA,EAAE,OAAO,GAGlCgB,EAA2BhB,EAAE,UAAU,GACvCiB,EAAqBjB,EAAE,EAAE;EAC3B;EACA,SAAS,MAAM;GAIb,AAHAc,EAAOd,EAAE,EAAE,GACXE,EAAOF,EAAE,IAAIA,EAAE,YAAYA,EAAE,SAAS,GACtCgB,EAA2BhB,EAAE,QAAQ,GACrCiB,EAAqBjB,EAAE,EAAE;EAC3B;CACF,CAAC,GAEDJ,EAA6D,uBAAuB;EAClF,QAAQ,MAAM;GAAE,EAAM,OAAO4B,EAAkBxB,EAAE,KAAK,EAAE,CAAC,UAAUA,EAAE;EAAI;EACzE,SAAS,MAAM;GAAE,EAAM,OAAOwB,EAAkBxB,EAAE,KAAK,EAAE,CAAC,UAAUA,EAAE;EAAM;CAC9E,CAAC,GAEDJ,EAA6D,sBAAsB;EACjF,QAAQ,MAAM;GAEZ,AADA,EAAM,OAAO4B,EAAkBxB,EAAE,KAAK,EAAE,CAAC,SAASA,EAAE,IAChDA,EAAE,MAAIL,EAAI,gBAAgB;EAChC;EACA,SAAS,MAAM;GAAE,EAAM,OAAO6B,EAAkBxB,EAAE,KAAK,EAAE,CAAC,SAASA,EAAE;EAAM;CAC7E,CAAC,GAEDJ,EAAyE,wBAAwB;EAC/F,QAAQ,MAAM;GAAE,EAAYG,EAAM,OAAOyB,EAAkBxB,EAAE,KAAK,IAAIA,EAAE,EAAE;EAAG;EAC7E,SAAS,MAAM;GAAE,EAAYD,EAAM,OAAOyB,EAAkBxB,EAAE,KAAK,IAAIA,EAAE,IAAI;EAAG;CAClF,CAAC,GAEDJ,EAAkE,gBAAgB;EAChF,QAAQ,MAAM;GAEZ,AADAG,EAAM,OAAO,OAAOC,EAAE,OAAO,GAAG,EAAE,GAAGA,EAAE,OAAO,CAAC,GAC/CiC,EAAkB;EACpB;EACA,SAAS,MAAM;GAEb,AADAlC,EAAM,OAAO,OAAOC,EAAE,OAAO,CAAC,GAC9BiC,EAAkB;EACpB;CACF,CAAC,GAEDrC,EAA8D,mBAAmB;EAC/E,QAAQ,MAAM;GAEZ,AADAG,EAAM,OAAO,OAAOC,EAAE,OAAO,CAAC,GAC9BiC,EAAkB;EACpB;EACA,SAAS,MAAM;GAEb,AADAlC,EAAM,OAAO,OAAOC,EAAE,OAAO,GAAG,EAAE,GAAGA,EAAE,OAAO,CAAwB,GACtEiC,EAAkB;EACpB;CACF,CAAC,GAEDrC,EAA2D,mBAAmB;EAC5E,QAAQ,MAAM;GACZ,EAAO,OAAO4B,EAAkBxB,EAAE,KAAK,EAAE,CAA6B,OAAOA,EAAE;EACjF;EACA,SAAS,MAAM;GACb,EAAO,OAAOwB,EAAkBxB,EAAE,KAAK,EAAE,CAA6B,OAAOA,EAAE;EACjF;CACF,CAAC;CAKD,SAASkC,EAAW,GAAe,GAAqB;EACtD,IAAM,CAACC,KAAOpC,EAAM,OAAO,OAAOyB,EAAkBY,CAAK,GAAG,CAAC;EAE7D,AADArC,EAAM,OAAO,OAAOsC,GAAO,GAAGF,CAAG,GACjCF,EAAkB;CACpB;CAOA,OALArC,EAA2D,iBAAiB;EAC1E,QAAQ,MAAMsC,EAAWlC,EAAE,OAAOA,EAAE,EAAE;EACtC,SAAS,MAAMkC,EAAWlC,EAAE,OAAOA,EAAE,IAAI;CAC3C,CAAC,GAEM,EAAE,cAAW;AACtB"}

package/dist/core/scene/layerStack.js

@@ -0,0 +1,38 @@
+//#region src/core/scene/layerStack.ts
+function e(e, t, n) {
+	for (let t = 0; t < n.length; t++) {
+		let r = n[t];
+		if (e.layerIndex.has(r.id)) throw Error(`useScene: duplicate system layer id "${r.id}"`);
+		e.layers.push({
+			kind: "system",
+			id: r.id,
+			visible: r.visible ?? !0,
+			locked: r.locked ?? !1,
+			...r.parallax ? { parallax: r.parallax } : {}
+		}), e.layerIndex.set(r.id, t);
+	}
+	function r(t) {
+		let n = e.layerIndex.get(t);
+		if (n === void 0) throw Error(`Scene: unknown layer "${t}"`);
+		return n;
+	}
+	function i() {
+		t(), e.layerIndex.clear();
+		for (let t = 0; t < e.layers.length; t++) e.layerIndex.set(e.layers[t].id, t);
+	}
+	function a(e, t, n, i, a = "place") {
+		if (r(t) < r(i)) {
+			let r = a === "place" ? `cannot place node '${e ?? "<new>"}' on layer '${t}' under parent '${n}' on layer '${i}'` : `cannot setLayer('${e ?? "<new>"}', '${t}') — node has parent '${n}' on layer '${i}'`;
+			throw Error(`Scene: ${r} — a child may not render below its parent's layer`);
+		}
+	}
+	return {
+		requireLayerIndex: r,
+		rebuildLayerIndex: i,
+		assertSubtreeLayer: a
+	};
+}
+//#endregion
+export { e as createLayerStack };
+
+//# sourceMappingURL=layerStack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layerStack.js","names":["createLayerStack","i","systemLayers","spec","state","requireLayerIndex","layer","rebuildLayerIndex","invalidateOrder","assertSubtreeLayer","nodeLayer","parentLayer","action","verb","nodeId","parentId"],"sources":["../../../src/core/scene/layerStack.ts"],"sourcesContent":["/**\n * The scene's layer stack: the ordered layer records, the index from a\n * layer's id to its place in that order, and the rule tying a node's layer to\n * its parent's.\n */\nimport type { LayerRecord, NodeId, UseSceneOptions } from './types';\n\n/** What the stack keeps of a scene's state. */\nexport interface LayerStackState<TLayer extends string> {\n  layers: LayerRecord<TLayer>[];\n  layerIndex: Map<TLayer, number>;\n}\n\n/** Fill `state` with the declared system layers, and answer with the reads\n *  and the rebuild the rest of the scene uses. Throws on a duplicate id. */\nexport function createLayerStack<TLayer extends string>(\n  state: LayerStackState<TLayer>,\n  /** Called whenever the layer order changes. */\n  invalidateOrder: () => void,\n  systemLayers: UseSceneOptions<unknown, TLayer, unknown>['systemLayers'],\n) {\n  for (let i = 0; i < systemLayers.length; i++) {\n    const spec = systemLayers[i];\n    if (state.layerIndex.has(spec.id)) {\n      throw new Error(`useScene: duplicate system layer id \"${spec.id}\"`);\n    }\n    state.layers.push({\n      kind: 'system',\n      id: spec.id,\n      visible: spec.visible ?? true,\n      locked: spec.locked ?? false,\n      ...(spec.parallax ? { parallax: spec.parallax } : {}),\n    });\n    state.layerIndex.set(spec.id, i);\n  }\n\n  function requireLayerIndex(layer: TLayer): number {\n    const i = state.layerIndex.get(layer);\n    if (i === undefined) throw new Error(`Scene: unknown layer \"${layer}\"`);\n    return i;\n  }\n\n  /** Repopulate `state.layerIndex` from the current `state.layers` order.\n   *  Call after any op that inserts, removes, or reorders a layer record. */\n  function rebuildLayerIndex(): void {\n    invalidateOrder();\n    state.layerIndex.clear();\n    for (let i = 0; i < state.layers.length; i++) {\n      state.layerIndex.set(state.layers[i].id, i);\n    }\n  }\n\n  /**\n   * A child may sit on its parent's layer **or any layer above it** (higher\n   * render index) — never below. `renderOrder()` is layer-major\n   * (each node yielded in its OWN layer's pass) and `buildSceneTree` buckets by\n   * each node's own layer, so a child on a higher layer than its parent renders\n   * correctly on top while staying a tree child for hit-testing / move /\n   * reparent (e.g. plantings tagged into a top `plantings` layer while remaining\n   * children of their container). Rejecting only the *below* case keeps the\n   * sensible invariant that a child never paints under its own parent.\n   */\n  function assertSubtreeLayer(\n    nodeId: string | undefined,\n    nodeLayer: TLayer,\n    parentId: NodeId,\n    parentLayer: TLayer,\n    verb: 'place' | 'relayer' = 'place',\n  ): void {\n    if (requireLayerIndex(nodeLayer) < requireLayerIndex(parentLayer)) {\n      const action = verb === 'place'\n        ? `cannot place node '${nodeId ?? '<new>'}' on layer '${nodeLayer}' under parent '${parentId}' on layer '${parentLayer}'`\n        : `cannot setLayer('${nodeId ?? '<new>'}', '${nodeLayer}') — node has parent '${parentId}' on layer '${parentLayer}'`;\n      throw new Error(`Scene: ${action} — a child may not render below its parent's layer`);\n    }\n  }\n\n  return { requireLayerIndex, rebuildLayerIndex, assertSubtreeLayer };\n}\n"],"mappings":";AAeA,SAAgBA,EACd,GAEA,GACA,GACA;CACA,KAAK,IAAIC,IAAI,GAAGA,IAAIC,EAAa,QAAQ,KAAK;EAC5C,IAAMC,IAAOD,EAAaD;EAC1B,IAAIG,EAAM,WAAW,IAAID,EAAK,EAAE,GAC9B,MAAU,MAAM,wCAAwCA,EAAK,GAAG,EAAE;EASpE,AAPAC,EAAM,OAAO,KAAK;GAChB,MAAM;GACN,IAAID,EAAK;GACT,SAASA,EAAK,WAAW;GACzB,QAAQA,EAAK,UAAU;GACvB,GAAIA,EAAK,WAAW,EAAE,UAAUA,EAAK,SAAS,IAAI,CAAC;EACrD,CAAC,GACDC,EAAM,WAAW,IAAID,EAAK,IAAIF,CAAC;CACjC;CAEA,SAASI,EAAkB,GAAuB;EAChD,IAAMJ,IAAIG,EAAM,WAAW,IAAIE,CAAK;EACpC,IAAIL,MAAM,KAAA,GAAW,MAAU,MAAM,yBAAyBK,EAAM,EAAE;EACtE,OAAOL;CACT;CAIA,SAASM,IAA0B;EAEjC,AADAC,EAAgB,GAChBJ,EAAM,WAAW,MAAM;EACvB,KAAK,IAAIH,IAAI,GAAGA,IAAIG,EAAM,OAAO,QAAQ,KACvC,EAAM,WAAW,IAAIA,EAAM,OAAOH,EAAE,CAAC,IAAIA,CAAC;CAE9C;CAYA,SAASQ,EACP,GACA,GACA,GACA,GACA,IAA4B,SACtB;EACN,IAAIJ,EAAkBK,CAAS,IAAIL,EAAkBM,CAAW,GAAG;GACjE,IAAMC,IAASC,MAAS,UACpB,sBAAsBC,KAAU,QAAQ,cAAcJ,EAAU,kBAAkBK,EAAS,cAAcJ,EAAY,KACrH,oBAAoBG,KAAU,QAAQ,MAAMJ,EAAU,wBAAwBK,EAAS,cAAcJ,EAAY;GACrH,MAAU,MAAM,UAAUC,EAAO,mDAAmD;EACtF;CACF;CAEA,OAAO;EAAE;EAAmB;EAAmB;CAAmB;AACpE"}

package/dist/core/scene/lockGuard.js

@@ -0,0 +1,37 @@
+//#region src/core/scene/lockGuard.ts
+function e(e) {
+	let t = 0;
+	function n(t) {
+		if (!e.layers.some((e) => e.locked)) return !1;
+		let n = e.nodes.get(t);
+		for (; n !== void 0;) {
+			if (e.layers[e.layerIndex.get(n.layer) ?? -1]?.locked) return !0;
+			n = n.parent === null ? void 0 : e.nodes.get(n.parent);
+		}
+		return !1;
+	}
+	return {
+		isLocked: n,
+		refuse(e, r) {
+			if (!(t > 0 || !n(e))) throw Error(`Scene: cannot ${r} "${e}" — it is on a locked layer`);
+		},
+		refuseLayer(n, r) {
+			if (!(t > 0 || !e.layers[e.layerIndex.get(n) ?? -1]?.locked)) throw Error(`Scene: cannot ${r} layer "${n}" — it is locked`);
+		},
+		reachable(t) {
+			return e.layers.some((e) => e.locked) ? t.filter((e) => !n(e)) : t;
+		},
+		lifted(e) {
+			t++;
+			try {
+				return e();
+			} finally {
+				t--;
+			}
+		}
+	};
+}
+//#endregion
+export { e as createLockGuard };
+
+//# sourceMappingURL=lockGuard.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lockGuard.js","names":["createLockGuard","bypass","isLocked","state","l","cur","id","verb","layer","ids","fn"],"sources":["../../../src/core/scene/lockGuard.ts"],"sourcesContent":["/**\n * The scene's lock guard: what a locked layer refuses, and how a caller that\n * is restoring an already-legal state gets past it.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the guard reads of a scene's state. */\nexport interface LockGuardState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  layers: { locked: boolean }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface LockGuard<TLayer extends string> {\n  /** Whether `id` sits on a locked layer, or inside a node that does. */\n  isLocked(id: NodeId): boolean;\n  /** Throw when `id` is locked and the guard is not lifted. */\n  refuse(id: NodeId, verb: string): void;\n  /** Throw when `layer` is locked and the guard is not lifted. */\n  refuseLayer(layer: TLayer, verb: string): void;\n  /** `ids` less the locked ones: the scene's selection never holds a locked\n   *  node, whoever writes it. */\n  reachable(ids: readonly NodeId[]): readonly NodeId[];\n  /** Run `fn` with the guard lifted: `unlocked()`, `removeLayer`, and every\n   *  replay — undo, redo, a journal stepping, a rollback — which restores a\n   *  state that was legal when it was recorded. */\n  lifted<T>(fn: () => T): T;\n}\n\nexport function createLockGuard<TData, TLayer extends string, TPose>(\n  state: LockGuardState<TData, TLayer, TPose>,\n): LockGuard<TLayer> {\n  let bypass = 0;\n\n  function isLocked(id: NodeId): boolean {\n    if (!state.layers.some((l) => l.locked)) return false;\n    let cur = state.nodes.get(id);\n    while (cur !== undefined) {\n      if (state.layers[state.layerIndex.get(cur.layer) ?? -1]?.locked) return true;\n      cur = cur.parent === null ? undefined : state.nodes.get(cur.parent);\n    }\n    return false;\n  }\n\n  return {\n    isLocked,\n    refuse(id, verb) {\n      if (bypass > 0 || !isLocked(id)) return;\n      throw new Error(`Scene: cannot ${verb} \"${id}\" — it is on a locked layer`);\n    },\n    refuseLayer(layer, verb) {\n      if (bypass > 0 || !state.layers[state.layerIndex.get(layer) ?? -1]?.locked) return;\n      throw new Error(`Scene: cannot ${verb} layer \"${layer}\" — it is locked`);\n    },\n    reachable(ids) {\n      if (!state.layers.some((l) => l.locked)) return ids;\n      return ids.filter((id) => !isLocked(id));\n    },\n    lifted(fn) {\n      bypass++;\n      try {\n        return fn();\n      } finally {\n        bypass--;\n      }\n    },\n  };\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACmB;CACnB,IAAIC,IAAS;CAEb,SAASC,EAAS,GAAqB;EACrC,IAAI,CAACC,EAAM,OAAO,MAAM,MAAMC,EAAE,MAAM,GAAG,OAAO;EAChD,IAAIC,IAAMF,EAAM,MAAM,IAAIG,CAAE;EAC5B,OAAOD,MAAQ,KAAA,IAAW;GACxB,IAAIF,EAAM,OAAOA,EAAM,WAAW,IAAIE,EAAI,KAAK,KAAK,GAAG,EAAE,QAAQ,OAAO;GACxE,IAAMA,EAAI,WAAW,OAAO,KAAA,IAAYF,EAAM,MAAM,IAAIE,EAAI,MAAM;EACpE;EACA,OAAO;CACT;CAEA,OAAO;EACL;EACA,OAAO,GAAI,GAAM;GACf,IAAI,MAAS,KAAK,CAACH,EAASI,CAAE,IAC9B,MAAU,MAAM,iBAAiBC,EAAK,IAAID,EAAG,4BAA4B;EAC3E;EACA,YAAY,GAAO,GAAM;GACvB,IAAI,MAAS,KAAK,CAACH,EAAM,OAAOA,EAAM,WAAW,IAAIK,CAAK,KAAK,GAAG,EAAE,SACpE,MAAU,MAAM,iBAAiBD,EAAK,UAAUC,EAAM,iBAAiB;EACzE;EACA,UAAU,GAAK;GAEb,OADKL,EAAM,OAAO,MAAM,MAAMC,EAAE,MAAM,IAC/BK,EAAI,QAAQ,MAAO,CAACP,EAASI,CAAE,CAAC,IADSG;EAElD;EACA,OAAO,GAAI;GACT;GACA,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IACR;GACF;EACF;CACF;AACF"}

package/dist/core/scene/nodeFnFields.js

@@ -33,16 +33,15 @@ function t(t) {
 	return e.map((e) => {
 		let n = t[e.field], r = /* @__PURE__ */ new Map();
 		if (n) for (let [e, t] of Object.entries(n)) r.set(t, e);
-		let i = /* @__PURE__ */ new Map(), a = (t) => !e.containersOnly || t.kind === "container";
+		let i = (t) => !e.containersOnly || t.kind === "container";
 		return {
 			spec: e,
 			keyOf: (e) => r.get(e),
 			fnOf: (e) => n?.[e],
-			read: (t) => a(t) ? t[e.field] : void 0,
+			read: (t) => i(t) ? t[e.field] : void 0,
 			write: (t, n) => {
-				a(t) && (t[e.field] = n);
-			},
-			pending: i
+				i(t) && (t[e.field] = n);
+			}
 		};
 	});
 }
@@ -52,7 +51,7 @@ function n(e, t, n, r, i) {
 		i("scene", `${r}: ${e.spec.opKey} "${n}" not in this scene's registry — node "${t.id}" restored without its ${e.spec.lost}. Register a function with this key in the registry option to restore it.`);
 		return;
 	}
-	e.write(t, a), e.pending.set(t.id, a);
+	e.write(t, a);
 }
 function r(e, t, n, r) {
 	let i = {};

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

@@ -1 +1 @@
-{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","pending","applies","node","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * `clipFromPose`, `derivePath` and `derivePose` are live functions on a node,\n * and a function travels through neither a serializable op payload nor a JSON\n * snapshot. Each one therefore needs the same six things: a function→key\n * reverse map, a side-channel cache the `kit:add` redo path re-attaches from,\n * a name in the op payload, a name in the snapshot, a registry lookup on\n * restore, and a prune when history evicts the entry that could reach it.\n *\n * The first two fields were written out twice, and `types.ts` said in a\n * comment that a third should be the point it stopped being copied per field.\n * This is that point.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. Each field's real signature lives on `Node`.\n *  A container's `layout` is an object rather than a function, and rides the\n *  same table for the same reason — it travels by reference, not as data. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the three fields on it. The\n *  full `Node` type would make the table generic in `TData`/`TLayer` for no\n *  gain; nothing here looks at either. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n  /** The redo side-channel: `kit:add` replays without the original spec, so\n   *  the function it should re-attach is cached here by node id. */\n  readonly pending: Map<NodeId, NodeFn>;\n}\n\nexport function createNodeFnFields<TPose>(registry: SceneRegistry<TPose>): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const pending = new Map<NodeId, NodeFn>();\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (applies(node)) node[spec.field] = fn;\n      },\n      pending,\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`, seeding the redo cache so later\n * undo/redo cycles behave like the live path. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n  field.pending.set(node.id, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AA8CA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAmBA,SAAgBC,EAA0B,GAAwD;CAChG,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,oBAAU,IAAI,IAAoB,GAClCC,KAAW,MACf,CAACL,EAAK,kBAAkBM,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOL,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUG,EAAQC,CAAI,IAAIA,EAAKN,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAIK,EAAQC,CAAI,MAAG,EAAKN,EAAK,SAASG;GACxC;GACA;EACF;CACF,CAAC;AACH;AAQA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMJ,IAAKK,EAAM,KAAKN,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGM,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIN,EAAI,yCAAyCI,EAAK,GAAG,yBAC5DE,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CAEA,AADAA,EAAM,MAAMF,GAAMH,CAAE,GACpBK,EAAM,QAAQ,IAAIF,EAAK,IAAIH,CAAE;AAC/B;AAIA,SAAgBO,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMT,IAAKK,EAAM,KAAKF,CAAI;EAC1B,IAAIH,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMM,EAAM,MAAML,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBM,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUX;CAC3B;CACA,OAAOS;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMT,GACNK,IAA+B,CAAC;CACtC,KAAK,IAAMX,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBM,EAAK,SAAS,aAAa;EACtD,IAAMH,IAAKY,EAAIf,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOQ;AACT"}
+{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","applies","node","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * `clipFromPose`, `derivePath` and `derivePose` are live functions on a node,\n * and a function travels through neither a serializable op payload nor a JSON\n * snapshot. Each one therefore needs the same five things: a function→key\n * reverse map, a side channel the `kit:add` redo path re-attaches from, a\n * name in the op payload, a name in the snapshot, and a registry lookup on\n * restore.\n *\n * The first two fields were written out twice, and `types.ts` said in a\n * comment that a third should be the point it stopped being copied per field.\n * This is that point.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. Each field's real signature lives on `Node`.\n *  A container's `layout` is an object rather than a function, and rides the\n *  same table for the same reason — it travels by reference, not as data. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the three fields on it. The\n *  full `Node` type would make the table generic in `TData`/`TLayer` for no\n *  gain; nothing here looks at either. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(registry: SceneRegistry<TPose>): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (applies(node)) node[spec.field] = fn;\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AA8CA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgBC,EAA0B,GAAwD;CAChG,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,KAAW,MACf,CAACJ,EAAK,kBAAkBK,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOJ,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUE,EAAQC,CAAI,IAAIA,EAAKL,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAII,EAAQC,CAAI,MAAG,EAAKL,EAAK,SAASG;GACxC;EACF;CACF,CAAC;AACH;AAOA,SAAgBG,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMH,IAAKI,EAAM,KAAKL,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGK,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIL,EAAI,yCAAyCG,EAAK,GAAG,yBAC5DE,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,EAAM,MAAMF,GAAMF,CAAE;AACtB;AAIA,SAAgBM,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMR,IAAKI,EAAM,KAAKF,CAAI;EAC1B,IAAIF,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMK,EAAM,MAAMJ,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBK,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUV;CAC3B;CACA,OAAOQ;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMT,GACNK,IAA+B,CAAC;CACtC,KAAK,IAAMV,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBK,EAAK,SAAS,aAAa;EACtD,IAAMF,IAAKW,EAAId,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOO;AACT"}

package/dist/core/scene/nodeMemo.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"nodeMemo.js","names":["MEMO","generation","nodeMemo","record","node","data","hit","slot","pose","value","derive","bumpNodeMemoGeneration","dropPoseKeyedMemoSlots","entry"],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * **Why this key works.** The scene mutates node objects in place but\n * *replaces* `pose` and `data` with new references — see the `kit:setPose` /\n * `kit:setData` ops in `core/scene/scene.ts`, which do `node.pose = p.to` /\n * `node.data = p.to`. So the node object is a stable identity, and those two\n * references are an exact freshness signal for anything derived per node: no\n * deep compare, no dirty flag, no subscription. The whole memo is three\n * reference comparisons.\n *\n * The assumption it rests on is the other side of that contract: nobody\n * mutates `node.data` (or `node.pose`) in place without replacing the\n * reference. A consumer who violates it sees a stale derivation until the next\n * real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Those change what `derive` would\n * return with no change to the node at all, which is the one failure a\n * `(pose, data)` key cannot see. {@link bumpNodeMemoGeneration} is the escape\n * hatch: whoever owns the ambient state bumps, and every slot on every node is\n * dropped. Derivations that read ambient state with *no* such signal (an async\n * image decode landing, say) must not be memoized here at all.\n *\n * Consumers: `canvas/NodeShape.ts` memoizes the painter match and the\n * silhouette path this way.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. Deliberately not `Node<…>` — the memo doesn't read\n *  anything else, and typing it loosely keeps `core/scene` from depending on\n *  the full node shape for a three-comparison cache. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, or the global\n * generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation. A node has more than one derived value — the\n * painter match, the silhouette, draw commands, text layout — and they\n * invalidate on the same signals but must not overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Those miss and recompute, as they should, and must not\n * poison the entry for the node's real pose. Pass `undefined` for derivations\n * that don't depend on the pose at all (the painter match is one) — it\n * compares equal to itself, leaving `data` as the only key.\n *\n * `data` is read off the node rather than passed: no caller has had a reason\n * to derive against data the node doesn't hold.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string,\n  pose: unknown,\n  derive: () => T,\n): T {\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map() };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, value });\n  }\n  return value;\n}\n\n/**\n * Drop every memoized slot on every node.\n *\n * For owners of ambient state that changes what a `derive` would return: the\n * shape-painter registry calls this when a painter is registered or disposed,\n * since a cache keyed only on `(pose, data)` would keep answering with the\n * painter that matched before.\n *\n * Cheap — it bumps a counter; records are re-stamped lazily on next access,\n * and unreachable nodes stay collectable via the `WeakMap`.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't (the painter match passes `undefined`, and re-matching it is a\n * registry scan).\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference: the `(pose, data)` key cannot see that, so the\n * override's `commit()` calls this for each node it holds.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) return;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AA8CA,IAAMA,oBAAO,IAAI,QAAgC,GAI7CC,IAAa;AA2BjB,SAAgBC,EACd,GACA,GACA,GACA,GACG;CACH,IAAIC,IAASH,EAAK,IAAII,CAAI;CAC1B,AAAID,MAAW,KAAA,KACb,IAAS;EAAE;EAAY,uBAAO,IAAI,IAAI;CAAE,GACxCH,EAAK,IAAII,GAAMD,CAAM,KACZA,EAAO,eAAeF,MAC/B,EAAO,aAAaA,GACpBE,EAAO,MAAM,MAAM;CAGrB,IAAME,IAAOD,EAAK,MACZE,IAAMH,EAAO,MAAM,IAAII,CAAI;CACjC,IAAID,MAAQ,KAAA,KAAaA,EAAI,SAASE,KAAQF,EAAI,SAASD,GACzD,OAAOC,EAAI;CAGb,IAAMG,IAAQC,EAAO;CAUrB,OAPIJ,MAAQ,KAAA,IAKVH,EAAO,MAAM,IAAII,GAAM;EAAE;EAAM;EAAM;CAAM,CAAC,KAJ5C,EAAI,OAAOC,GACX,EAAI,OAAOH,GACX,EAAI,QAAQI,IAIPA;AACT;AAaA,SAAgBE,IAA+B;CAC7C;AACF;AAaA,SAAgBC,EAAuB,GAA4B;CACjE,IAAMT,IAASH,EAAK,IAAII,CAAI;CAC5B,IAAID,MAAW,KAAA,GACf,KAAK,IAAM,CAACI,GAAMM,MAAUV,EAAO,OACjC,AAAIU,EAAM,SAAS,KAAA,KAAWV,EAAO,MAAM,OAAOI,CAAI;AAE1D"}
+{"version":3,"file":"nodeMemo.js","names":["createNodeMemoScope","MEMO","generation","nodeMemo","slot","scopedNodeMemo","node","pose","derive","record","data","hit","value","entries","scope","drops","dropsNow","bumpNodeMemoGeneration","dropPoseKeyedMemoSlots","entry"],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * **Why this key works.** The scene mutates node objects in place but\n * *replaces* `pose` and `data` with new references — see the `kit:setPose` /\n * `kit:setData` ops in `core/scene/scene.ts`, which do `node.pose = p.to` /\n * `node.data = p.to`. So the node object is a stable identity, and those two\n * references are an exact freshness signal for anything derived per node: no\n * deep compare, no dirty flag, no subscription. The whole memo is three\n * reference comparisons.\n *\n * The assumption it rests on is the other side of that contract: nobody\n * mutates `node.data` (or `node.pose`) in place without replacing the\n * reference. A consumer who violates it sees a stale derivation until the next\n * real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Those change what `derive` would\n * return with no change to the node at all, which is the one failure a\n * `(pose, data)` key cannot see. {@link bumpNodeMemoGeneration} is the escape\n * hatch: whoever owns the ambient state bumps, and every slot on every node is\n * dropped. Derivations that read ambient state with *no* such signal (an async\n * image decode landing, say) must not be memoized here at all.\n *\n * Consumers: `canvas/NodeShape.ts` memoizes the painter match and the\n * silhouette path this way.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n  /** How many times {@link dropPoseKeyedMemoSlots} has run for this node,\n   *  which is how a drop reaches the scopes it cannot enumerate. */\n  drops: number;\n}\n\n/** A scoped entry also carries what a named slot's record holds for it. */\ninterface ScopedSlot extends MemoSlot {\n  generation: number;\n  drops: number;\n}\n\ndeclare const scopeBrand: unique symbol;\n\n/**\n * A private place to memoize one derivation, in place of a slot name.\n *\n * A named slot lives on the node, so it lasts as long as the node does. That\n * is wrong for a derivation that belongs to some shorter-lived reader — one\n * `toPose` function among many over the life of a scene. A scope is held by\n * that reader, and its entries go when the reader does.\n */\nexport type NodeMemoScope = { readonly [scopeBrand]: true };\n\nexport function createNodeMemoScope(): NodeMemoScope {\n  return new WeakMap<object, ScopedSlot>() as unknown as NodeMemoScope;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. Deliberately not `Node<…>` — the memo doesn't read\n *  anything else, and typing it loosely keeps `core/scene` from depending on\n *  the full node shape for a three-comparison cache. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, or the global\n * generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation. A node has more than one derived value — the\n * painter match, the silhouette, draw commands, text layout — and they\n * invalidate on the same signals but must not overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Those miss and recompute, as they should, and must not\n * poison the entry for the node's real pose. Pass `undefined` for derivations\n * that don't depend on the pose at all (the painter match is one) — it\n * compares equal to itself, leaving `data` as the only key.\n *\n * `data` is read off the node rather than passed: no caller has had a reason\n * to derive against data the node doesn't hold.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string | NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  if (typeof slot !== 'string') return scopedNodeMemo(node, slot, pose, derive);\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map(), drops: 0 };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, value });\n  }\n  return value;\n}\n\nfunction scopedNodeMemo<T>(\n  node: MemoizableNode,\n  scope: NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  const entries = scope as unknown as WeakMap<object, ScopedSlot>;\n  const data = node.data;\n  const drops = MEMO.get(node)?.drops ?? 0;\n  const hit = entries.get(node);\n  if (\n    hit !== undefined && hit.generation === generation && hit.pose === pose && hit.data === data\n    && (pose === undefined || hit.drops === drops)\n  ) {\n    return hit.value as T;\n  }\n  const value = derive();\n  // Read again: a derivation that hit a cycle drops this node's slots itself.\n  const dropsNow = MEMO.get(node)?.drops ?? 0;\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n    hit.generation = generation;\n    hit.drops = dropsNow;\n  } else {\n    entries.set(node, { pose, data, value, generation, drops: dropsNow });\n  }\n  return value;\n}\n\n/** How many named slots `node` holds. For tests of what is kept on a node. */\nexport function nodeMemoSlotCount(node: MemoizableNode): number {\n  const record = MEMO.get(node);\n  return record === undefined || record.generation !== generation ? 0 : record.slots.size;\n}\n\n/**\n * Drop every memoized slot on every node.\n *\n * For owners of ambient state that changes what a `derive` would return: the\n * shape-painter registry calls this when a painter is registered or disposed,\n * since a cache keyed only on `(pose, data)` would keep answering with the\n * painter that matched before.\n *\n * Cheap — it bumps a counter; records are re-stamped lazily on next access,\n * and unreachable nodes stay collectable via the `WeakMap`.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't (the painter match passes `undefined`, and re-matching it is a\n * registry scan).\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference: the `(pose, data)` key cannot see that, so the\n * override's `commit()` calls this for each node it holds.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) {\n    MEMO.set(node, { generation, slots: new Map(), drops: 1 });\n    return;\n  }\n  record.drops++;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AAmEA,SAAgBA,IAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAMC,oBAAO,IAAI,QAAgC,GAI7CC,IAAa;AA2BjB,SAAgBC,EACd,GACA,GACA,GACA,GACG;CACH,IAAI,OAAOC,KAAS,UAAU,OAAOC,EAAeC,GAAMF,GAAMG,GAAMC,CAAM;CAC5E,IAAIC,IAASR,EAAK,IAAIK,CAAI;CAC1B,AAAIG,MAAW,KAAA,KACb,IAAS;EAAE;EAAY,uBAAO,IAAI,IAAI;EAAG,OAAO;CAAE,GAClDR,EAAK,IAAIK,GAAMG,CAAM,KACZA,EAAO,eAAeP,MAC/B,EAAO,aAAaA,GACpBO,EAAO,MAAM,MAAM;CAGrB,IAAMC,IAAOJ,EAAK,MACZK,IAAMF,EAAO,MAAM,IAAIL,CAAI;CACjC,IAAIO,MAAQ,KAAA,KAAaA,EAAI,SAASJ,KAAQI,EAAI,SAASD,GACzD,OAAOC,EAAI;CAGb,IAAMC,IAAQJ,EAAO;CAUrB,OAPIG,MAAQ,KAAA,IAKVF,EAAO,MAAM,IAAIL,GAAM;EAAE;EAAM;EAAM;CAAM,CAAC,KAJ5C,EAAI,OAAOG,GACX,EAAI,OAAOG,GACX,EAAI,QAAQE,IAIPA;AACT;AAEA,SAASP,EACP,GACA,GACA,GACA,GACG;CACH,IAAMQ,IAAUC,GACVJ,IAAOJ,EAAK,MACZS,IAAQd,EAAK,IAAIK,CAAI,CAAC,EAAE,SAAS,GACjCK,IAAME,EAAQ,IAAIP,CAAI;CAC5B,IACEK,MAAQ,KAAA,KAAaA,EAAI,eAAeT,KAAcS,EAAI,SAASJ,KAAQI,EAAI,SAASD,MACpFH,MAAS,KAAA,KAAaI,EAAI,UAAUI,IAExC,OAAOJ,EAAI;CAEb,IAAMC,IAAQJ,EAAO,GAEfQ,IAAWf,EAAK,IAAIK,CAAI,CAAC,EAAE,SAAS;CAU1C,OATIK,MAAQ,KAAA,IAOVE,EAAQ,IAAIP,GAAM;EAAE;EAAM;EAAM;EAAO;EAAY,OAAOU;CAAS,CAAC,KANpE,EAAI,OAAOT,GACX,EAAI,OAAOG,GACX,EAAI,QAAQE,GACZ,EAAI,aAAaV,GACjB,EAAI,QAAQc,IAIPJ;AACT;AAmBA,SAAgBK,IAA+B;CAC7C;AACF;AAaA,SAAgBC,EAAuB,GAA4B;CACjE,IAAMT,IAASR,EAAK,IAAIK,CAAI;CAC5B,IAAIG,MAAW,KAAA,GAAW;EACxB,EAAK,IAAIH,GAAM;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE,CAAC;EACzD;CACF;CACA,EAAO;CACP,KAAK,IAAM,CAACF,GAAMe,MAAUV,EAAO,OACjC,AAAIU,EAAM,SAAS,KAAA,KAAWV,EAAO,MAAM,OAAOL,CAAI;AAE1D"}