@weasel-js/core 1.7.0 → 1.7.2

package/dist/core/scene/scene.js

@@ -0,0 +1,1271 @@
+import { dropPoseKeyedMemoSlots as e } from "./nodeMemo.js";
+import { createDependentsIndex as t, sameDependsOn as n } from "./dependents.js";
+import { asNodeId as r } from "./types.js";
+import { SceneArrivalRefused as i } from "./arrivals.js";
+import { rebuildOp as a } from "../ops/registry.js";
+import { NODE_FN_FIELDS as o, createNodeFnFields as s, fnKeysOf as c, restoreFn as ee } from "./nodeFnFields.js";
+import { withKitRegistry as te } from "./kitRegistry.js";
+import { dwarn as l } from "../../debug/flag.js";
+import { createArrangeOp as ne } from "../ops/arrange.js";
+import { createPoseOverrides as re } from "./poseOverrides.js";
+import { resized as ie, resolveLayoutFrame as ae, runLayoutPass as oe } from "./layoutPass.js";
+import { createHistory as se } from "@weasel-js/history";
+//#region src/core/scene/scene.ts
+var u = 0, ce = () => r(`n${(u++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+function le(e, t) {
+	t === void 0 ? delete e.parallax : e.parallax = t;
+}
+function ue(e) {
+	let t = {
+		id: e.id,
+		visible: e.visible ?? !0,
+		locked: e.locked ?? !1,
+		...e.parallax ? { parallax: e.parallax } : {}
+	};
+	return e.kind === "user" ? {
+		...t,
+		kind: "user",
+		name: e.name ?? e.id
+	} : {
+		...t,
+		kind: "system"
+	};
+}
+function d(o) {
+	if (!o.systemLayers || o.systemLayers.length === 0) throw Error("useScene: systemLayers must declare at least one layer");
+	let u = {
+		nodes: /* @__PURE__ */ new Map(),
+		roots: [],
+		layers: [],
+		layerIndex: /* @__PURE__ */ new Map()
+	}, d = te(o.registry ?? {}), f = s(d), p = (e) => f.find((t) => t.spec.field === e), fe = ae(o.layoutFrame), pe = !1;
+	{
+		let e = p("layout"), t = e.write;
+		e.write = (e, n) => {
+			e.kind === "container" && (pe = !0), t(e, n);
+		};
+	}
+	function me(e) {
+		let t = u.nodes.get(e);
+		return t?.kind === "container" ? t.layout ?? null : null;
+	}
+	let m = t(), h = /* @__PURE__ */ new Set();
+	function g(t) {
+		if (_(u.nodes.get(t)?.parent ?? null), m.isEmpty()) return;
+		let n = [t];
+		q(t, n);
+		for (let t of n) for (let n of m.transitiveDependentsOf(t)) {
+			let t = u.nodes.get(n);
+			t !== void 0 && e(t);
+		}
+	}
+	function _(t) {
+		if (h.size === 0) return;
+		let n = t;
+		for (; n !== null;) {
+			let t = u.nodes.get(n);
+			if (t === void 0) return;
+			if (h.has(n)) {
+				e(t);
+				for (let t of m.transitiveDependentsOf(n)) {
+					let n = u.nodes.get(t);
+					n !== void 0 && e(n);
+				}
+			}
+			n = t.parent;
+		}
+	}
+	function he(e, t) {
+		t === "children" ? h.add(e) : h.delete(e);
+	}
+	function ge(t, n) {
+		let r = B(t);
+		n === void 0 ? delete r.dependsOn : r.dependsOn = n, m.add(t, n === void 0 || n === "children" ? [] : n), he(t, n), e(B(t)), g(t);
+	}
+	for (let e = 0; e < o.systemLayers.length; e++) {
+		let t = o.systemLayers[e];
+		if (u.layerIndex.has(t.id)) throw Error(`useScene: duplicate system layer id "${t.id}"`);
+		u.layers.push({
+			kind: "system",
+			id: t.id,
+			visible: t.visible ?? !0,
+			locked: t.locked ?? !1,
+			...t.parallax ? { parallax: t.parallax } : {}
+		}), u.layerIndex.set(t.id, e);
+	}
+	let _e = o.generateId ?? ce, v = /* @__PURE__ */ new Set(), y = /* @__PURE__ */ new Map(), ve = null;
+	function ye(e) {
+		return {
+			name: e.name,
+			args: e.args,
+			label: e.label,
+			coalesceKey: e.coalesceKey,
+			apply: () => {
+				let t = ve;
+				if (!t) return l("scene", `restored op "${e.name ?? "?"}" has no history adapter — skipping (setHistoryAdapter was not wired)`), "noop";
+				try {
+					return e.apply(t());
+				} catch (t) {
+					return l("scene", `restored op "${e.name ?? "?"}" failed against the history adapter — skipping: ${String(t)}`), "noop";
+				}
+			},
+			invert: () => ye(e.invert())
+		};
+	}
+	let b = [], be = re((e) => u.nodes.get(e), g), x = se(void 0, {
+		selection: {
+			get: () => b,
+			set: (e) => {
+				b = Be(e), z();
+			}
+		},
+		...o.coalesceWindowMs === void 0 ? {} : { coalesceWindowMs: o.coalesceWindowMs },
+		...o.historyLimit === void 0 ? {} : { historyLimit: o.historyLimit },
+		onEvict: (e) => {
+			Ve(e.forwardOps), Ve(e.baseOps);
+		},
+		rebuildOp: (e, t) => {
+			if (y.has(e)) return Y(e, t);
+			if (e === "arrange") return ne(t, void 0, Pe);
+			let n = a(e, t);
+			return n === null ? null : ye(n);
+		}
+	}), S = 0, xe = /* @__PURE__ */ new WeakMap(), Se = 1, C = 0, w = null, T = !1, Ce = 0, E = 0, D = null, O = !1, we = o.getActiveJournal ?? null, Te = null, k = null, A = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Set(), M = null, Ee = /* @__PURE__ */ new Set(), De = (e, t, n) => oe($, me, e, t, fe, n);
+	function Oe() {
+		return Te ?? (pe ? De : null);
+	}
+	function ke(e, t, n) {
+		if (k === null || t === null || t === n) return;
+		j.add(t);
+		let r = k.get(t);
+		r === void 0 ? k.set(t, [e]) : r.includes(e) || r.push(e);
+	}
+	function Ae(e, t, n) {
+		if (k === null || t === null || t === n || (j.add(t), k.get(t)?.includes(e))) return;
+		let r = A.get(t);
+		r === void 0 ? A.set(t, [e]) : r.includes(e) || r.push(e);
+	}
+	function N(e) {
+		k !== null && e !== null && j.add(e);
+	}
+	function P() {
+		return Oe() !== null && k === null && C === 0 && !T;
+	}
+	function je(e = !1) {
+		return k !== null || !e && Oe() === null ? !1 : (k = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Set(), M = null, !0);
+	}
+	function Me() {
+		let e = M;
+		if (M = null, e !== null && e.length !== 0) for (let t of [...Ee]) t(e);
+	}
+	function Ne() {
+		let e = k;
+		k = null;
+		let t = Oe();
+		if (e === null || t === null) return [];
+		let n = /* @__PURE__ */ new Map();
+		for (let [t, r] of e) {
+			let e = r.filter((e) => u.nodes.get(e)?.parent === t);
+			e.length > 0 && u.nodes.has(t) && n.set(t, e);
+		}
+		let r = /* @__PURE__ */ new Map();
+		for (let [e, t] of A) {
+			let n = t.filter((t) => u.nodes.get(t)?.parent !== e);
+			n.length > 0 && u.nodes.has(e) && r.set(e, n);
+		}
+		A = /* @__PURE__ */ new Map();
+		let a = new Set([...j].filter((e) => u.nodes.get(e)?.kind === "container"));
+		if (n.size === 0 && a.size === 0) return [];
+		let o = t(n, a, r);
+		if (o === null) throw new i(n);
+		let s = [];
+		for (let [e, t] of o) {
+			let n = u.nodes.get(e);
+			n && s.push({
+				id: e,
+				from: n.pose,
+				to: t
+			});
+		}
+		return M = s, s;
+	}
+	function Pe(e, t) {
+		$.setPose(r(e), t);
+	}
+	function Fe(e) {
+		return e.name === "setLayout" && e.args?.to != null;
+	}
+	function Ie(e) {
+		return je(e.some(Fe)) ? {
+			ops: [...e, ne({}, Ne, Pe)],
+			owned: !0
+		} : {
+			ops: e,
+			owned: !1
+		};
+	}
+	function F(e, t) {
+		let { ops: n, owned: r } = Ie(e);
+		try {
+			t(n), r && Me();
+		} catch (e) {
+			if (!(e instanceof i)) throw e;
+		} finally {
+			r && (k = null, M = null);
+		}
+	}
+	function Le(e) {
+		if (!u.layers.some((e) => e.locked)) return !1;
+		let t = u.nodes.get(e);
+		for (; t !== void 0;) {
+			if (u.layers[u.layerIndex.get(t.layer) ?? -1]?.locked) return !0;
+			t = t.parent === null ? void 0 : u.nodes.get(t.parent);
+		}
+		return !1;
+	}
+	function Re(e) {
+		if (Ce > 0) throw Error(`Scene: cannot ${e} inside untracked() — it records`);
+	}
+	function I(e, t) {
+		if (!(E > 0 || !Le(e))) throw Error(`Scene: cannot ${t} "${e}" — it is on a locked layer`);
+	}
+	function ze(e, t) {
+		if (!(E > 0 || !u.layers[u.layerIndex.get(e) ?? -1]?.locked)) throw Error(`Scene: cannot ${t} layer "${e}" — it is locked`);
+	}
+	function Be(e) {
+		return u.layers.some((e) => e.locked) ? e.filter((e) => !Le(e)) : e;
+	}
+	function L(e) {
+		E++;
+		try {
+			return e();
+		} finally {
+			E--;
+		}
+	}
+	function R(e, t) {
+		let n = D, r = [], i = b;
+		D = r;
+		try {
+			let i = e();
+			return n && !t() && n.push(...r), i;
+		} catch (e) {
+			throw D = null, L(() => {
+				for (let e = r.length - 1; e >= 0; e--) {
+					let { kind: t, payload: n } = r[e];
+					y.get(t).revert(n);
+				}
+			}), b = i, r.length > 0 && z(), e;
+		} finally {
+			D = n;
+		}
+	}
+	function z() {
+		if (S++, C > 0) {
+			O = !0;
+			return;
+		}
+		for (let e of v) e();
+	}
+	function Ve(e) {
+		if (!f.every((e) => e.pending.size === 0)) for (let t of e) {
+			if (t.name !== "kit:add") continue;
+			let e = t.args?.id;
+			if (e && !u.nodes.has(e)) for (let t of f) t.pending.delete(e);
+		}
+	}
+	function B(e) {
+		let t = u.nodes.get(e);
+		if (!t) throw Error(`Scene: unknown node id "${e}"`);
+		return t;
+	}
+	function V(e) {
+		let t = u.layerIndex.get(e);
+		if (t === void 0) throw Error(`Scene: unknown layer "${e}"`);
+		return t;
+	}
+	function H() {
+		Q(), u.layerIndex.clear();
+		for (let e = 0; e < u.layers.length; e++) u.layerIndex.set(u.layers[e].id, e);
+	}
+	function U(e, t, n, r, i = "place") {
+		if (V(t) < V(r)) {
+			let a = i === "place" ? `cannot place node '${e ?? "<new>"}' on layer '${t}' under parent '${n}' on layer '${r}'` : `cannot setLayer('${e ?? "<new>"}', '${t}') — node has parent '${n}' on layer '${r}'`;
+			throw Error(`Scene: ${a} — a child may not render below its parent's layer`);
+		}
+	}
+	function W(e) {
+		if (e === null) return u.roots;
+		let t = B(e);
+		if (t.kind !== "container") throw Error(`Scene: parent "${e}" is not a container`);
+		return t.children;
+	}
+	function G(e) {
+		let t = B(e), n = W(t.parent), r = n.indexOf(e);
+		if (r < 0) throw Error(`Scene: node "${e}" not found in its parent's children`);
+		return n.splice(r, 1), Q(), {
+			parent: t.parent,
+			index: r
+		};
+	}
+	function K(e, t, n) {
+		let r = W(t), i = Math.max(0, Math.min(n, r.length));
+		r.splice(i, 0, e);
+		let a = B(e);
+		a.parent = t, Q();
+	}
+	function q(e, t) {
+		let n = u.nodes.get(e);
+		if (n && n.kind === "container") for (let e of n.children) t.push(e), q(e, t);
+	}
+	function He(e) {
+		let t = [], n = /* @__PURE__ */ new Set();
+		function r(e) {
+			if (n.has(e)) return;
+			n.add(e), t.push(e);
+			let r = [];
+			q(e, r);
+			for (let e of r) n.has(e) || (n.add(e), t.push(e));
+		}
+		for (let t of e) r(t);
+		for (let e = 0; e < t.length; e++) for (let n of m.transitiveDependentsOf(t[e])) r(n);
+		return {
+			ids: t,
+			removing: n
+		};
+	}
+	function Ue(e, t, { cacheForRedo: n }) {
+		let r = u.nodes.get(t);
+		if (r !== void 0) for (let i of f) {
+			let a = e[i.spec.field];
+			a !== void 0 && (i.spec.containersOnly && e.kind !== "container" || (i.write(r, a), n && i.pending.set(t, a)));
+		}
+	}
+	function We(e, t) {
+		if (!t) return;
+		let n = e;
+		for (let e of f) {
+			if (e.read(n) !== void 0) continue;
+			let r = t[e.spec.opKey];
+			r !== void 0 && ee(e, n, r, "kit:remove", l);
+		}
+	}
+	function J(e, t) {
+		y.set(e, t);
+	}
+	J("kit:add", {
+		apply: (e) => {
+			if (u.nodes.has(e.id)) throw Error(`Scene: id collision on "${e.id}"`);
+			let t = e.kind === "container" ? {
+				kind: "container",
+				id: e.id,
+				layer: e.layer,
+				pose: e.pose,
+				data: e.data,
+				parent: e.parent,
+				children: []
+			} : {
+				kind: "leaf",
+				id: e.id,
+				layer: e.layer,
+				pose: e.pose,
+				data: e.data,
+				parent: e.parent
+			};
+			u.nodes.set(e.id, t), K(e.id, e.parent, e.index), e.dependsOn !== void 0 && (t.dependsOn = e.dependsOn), e.pickable !== void 0 && (t.pickable = e.pickable), m.add(e.id, e.dependsOn === "children" ? [] : e.dependsOn ?? []), he(e.id, e.dependsOn);
+			let n = t;
+			for (let t of f) {
+				let r = t.pending.get(e.id);
+				if (r !== void 0) {
+					t.write(n, r);
+					continue;
+				}
+				let i = e[t.spec.opKey];
+				i !== void 0 && ee(t, n, i, "kit:add", l);
+			}
+			g(e.id);
+		},
+		revert: (e) => {
+			G(e.id), u.nodes.delete(e.id), m.remove(e.id), h.delete(e.id), _(e.parent), g(e.id);
+		}
+	}), J("kit:remove", {
+		apply: (e) => {
+			for (let t of e.detached) G(t.id);
+			for (let t of e.nodes) u.nodes.delete(t.id), m.remove(t.id), h.delete(t.id);
+			for (let t of e.detached) _(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 };
+				We(e, t.get(n.id)), u.nodes.set(n.id, e), m.add(n.id, e.dependsOn === "children" ? [] : e.dependsOn ?? []), he(n.id, e.dependsOn);
+			}
+			for (let t of e.detached) K(t.id, t.parent, t.index);
+			for (let t of e.detached) _(t.parent);
+		}
+	}), J("kit:setPose", {
+		apply: (e) => {
+			B(e.id).pose = e.to, g(e.id);
+		},
+		revert: (e) => {
+			B(e.id).pose = e.from, g(e.id);
+		}
+	}), J("kit:setData", {
+		apply: (e) => {
+			B(e.id).data = e.to, g(e.id);
+		},
+		revert: (e) => {
+			B(e.id).data = e.from, g(e.id);
+		}
+	}), J("kit:setLayer", {
+		apply: (e) => {
+			V(e.to), B(e.id).layer = e.to, Q(), g(e.id);
+		},
+		revert: (e) => {
+			B(e.id).layer = e.from, Q(), g(e.id);
+		}
+	}), J("kit:setDependsOn", {
+		apply: (e) => {
+			ge(e.id, e.to);
+		},
+		revert: (e) => {
+			ge(e.id, e.from);
+		}
+	});
+	let Ge = /* @__PURE__ */ new WeakMap();
+	function Ke(e, t) {
+		let n = B(e.id), r = p("layout"), i = Ge.get(e), a = t === "from" ? e.fromKey : e.toKey;
+		if (i === void 0 && a !== void 0) {
+			delete n.layout, ee(r, n, a, "kit:setLayout", l);
+			return;
+		}
+		let o = i?.[t] ?? null;
+		o === null ? delete n.layout : r.write(n, o);
+	}
+	J("kit:setLayout", {
+		apply: (e) => {
+			Ke(e, "to");
+		},
+		revert: (e) => {
+			Ke(e, "from");
+		}
+	}), J("kit:move", {
+		apply: (e) => {
+			G(e.id), K(e.id, e.toParent, e.toIndex), _(e.fromParent), g(e.id);
+		},
+		revert: (e) => {
+			G(e.id), K(e.id, e.fromParent, e.fromIndex), _(e.toParent), g(e.id);
+		}
+	}), J("kit:setLayerVisible", {
+		apply: (e) => {
+			u.layers[V(e.layer)].visible = e.to;
+		},
+		revert: (e) => {
+			u.layers[V(e.layer)].visible = e.from;
+		}
+	}), J("kit:setLayerLocked", {
+		apply: (e) => {
+			u.layers[V(e.layer)].locked = e.to, e.to && (b = Be(b));
+		},
+		revert: (e) => {
+			u.layers[V(e.layer)].locked = e.from;
+		}
+	}), J("kit:setLayerParallax", {
+		apply: (e) => {
+			le(u.layers[V(e.layer)], e.to);
+		},
+		revert: (e) => {
+			le(u.layers[V(e.layer)], e.from);
+		}
+	}), J("kit:addLayer", {
+		apply: (e) => {
+			u.layers.splice(e.index, 0, { ...e.record }), H();
+		},
+		revert: (e) => {
+			u.layers.splice(e.index, 1), H();
+		}
+	}), J("kit:removeLayer", {
+		apply: (e) => {
+			u.layers.splice(e.index, 1), H();
+		},
+		revert: (e) => {
+			u.layers.splice(e.index, 0, { ...e.record }), H();
+		}
+	}), J("kit:renameLayer", {
+		apply: (e) => {
+			u.layers[V(e.layer)].name = e.to;
+		},
+		revert: (e) => {
+			u.layers[V(e.layer)].name = e.from;
+		}
+	}), J("kit:moveLayer", {
+		apply: (e) => {
+			let [t] = u.layers.splice(e.from, 1);
+			u.layers.splice(e.to, 0, t), H();
+		},
+		revert: (e) => {
+			let [t] = u.layers.splice(e.to, 1);
+			u.layers.splice(e.from, 0, t), H();
+		}
+	});
+	function qe(e, t) {
+		let n = y.get(e);
+		if (!n) throw Error(`Scene: no registered op for kind "${e}"`);
+		n.apply(t);
+	}
+	function Y(e, t, n = "fwd") {
+		if (!y.has(e)) throw Error(`Scene: no registered op for kind "${e}"`);
+		return {
+			name: e,
+			args: t,
+			coalesceKey: Ye(e, t),
+			apply: () => {
+				let r = y.get(e);
+				if (!r) throw Error(`Scene: no registered op for kind "${e}"`);
+				(n === "fwd" ? r.apply : r.revert)(t);
+			},
+			invert: () => Y(e, t, n === "fwd" ? "rev" : "fwd")
+		};
+	}
+	function Je(e, t) {
+		return {
+			name: e.name,
+			args: e.args,
+			label: e.label,
+			coalesceKey: e.coalesceKey,
+			apply: () => e.apply(t),
+			invert: () => Je(e.invert(), t)
+		};
+	}
+	function Ye(e, t) {
+		if (typeof t != "object" || !t) return;
+		let n = t, r = typeof n.id == "string" ? n.id : typeof n.layer == "string" ? n.layer : void 0;
+		return r === void 0 ? void 0 : `${e}:${r}`;
+	}
+	function X(e) {
+		let t = T;
+		T = !0, C++;
+		let n = O;
+		try {
+			return e();
+		} finally {
+			C--, T = t, O = n;
+		}
+	}
+	function Z(e, t, n) {
+		if (T) {
+			qe(e, t), D?.push({
+				kind: e,
+				payload: t
+			}), z();
+			return;
+		}
+		if (w) {
+			qe(e, t), D?.push({
+				kind: e,
+				payload: t
+			}), w.ops.push(Y(e, t)), z();
+			return;
+		}
+		x.applyOps([Y(e, t)], n), z();
+	}
+	if (o.ops) for (let [e, t] of Object.entries(o.ops)) y.set(e, t);
+	function Xe() {
+		return u.layers.length === 1 ? nt() : it();
+	}
+	function Ze() {
+		return u.layers.length === 1 ? rt() : at();
+	}
+	let Qe = 0, $e = { gen: 0 };
+	function Q() {
+		Qe++;
+	}
+	let et = [];
+	function tt() {
+		return $e.gen !== Qe && ($e = { gen: Qe }), $e;
+	}
+	function nt() {
+		let e = u.layers[0].id, t = [], n = [...u.roots].reverse();
+		for (; n.length > 0;) {
+			let r = n.pop(), i = u.nodes.get(r);
+			if (i && (i.layer === e && t.push(r), i.kind === "container")) for (let e = i.children.length - 1; e >= 0; e--) n.push(i.children[e]);
+		}
+		return t;
+	}
+	function rt() {
+		let e = u.layers[0].id, t = [], n = [...u.roots].reverse();
+		for (; n.length > 0;) {
+			let r = n.pop(), i = u.nodes.get(r);
+			if (i && (i.layer === e && t.push(i), i.kind === "container")) for (let e = i.children.length - 1; e >= 0; e--) n.push(i.children[e]);
+		}
+		return t;
+	}
+	function it() {
+		let e = u.layers.map(() => []), t = [...u.roots].reverse();
+		for (; t.length > 0;) {
+			let n = t.pop(), r = u.nodes.get(n);
+			if (!r) continue;
+			let i = e[u.layerIndex.get(r.layer) ?? -1];
+			if (i && i.push(n), r.kind === "container") for (let e = r.children.length - 1; e >= 0; e--) t.push(r.children[e]);
+		}
+		let n = [];
+		for (let t of e) for (let e of t) n.push(e);
+		return n;
+	}
+	function at() {
+		let e = u.layers.map(() => []), t = [...u.roots].reverse();
+		for (; t.length > 0;) {
+			let n = t.pop(), r = u.nodes.get(n);
+			if (!r) continue;
+			let i = e[u.layerIndex.get(r.layer) ?? -1];
+			if (i && i.push(r), r.kind === "container") for (let e = r.children.length - 1; e >= 0; e--) t.push(r.children[e]);
+		}
+		let n = [];
+		for (let t of e) for (let e of t) n.push(e);
+		return n;
+	}
+	let ot = /* @__PURE__ */ new WeakMap();
+	function st(e) {
+		let t = {
+			targetId: e.targetId,
+			forkedAtEntryId: e.forkedAtEntryId,
+			applyBatch(t, n) {
+				F(t, (t) => {
+					R(() => X(() => e.applyBatch(t, n)), () => !0), z();
+				});
+			},
+			undo() {
+				L(() => X(() => e.undo())), z();
+			},
+			redo() {
+				L(() => X(() => e.redo())), z();
+			},
+			canUndo: () => e.canUndo(),
+			canRedo: () => e.canRedo(),
+			entries: () => e.entries(),
+			seal: () => e.seal(),
+			getVersion: () => e.getVersion(),
+			subscribe: (t) => e.subscribe(t),
+			commit(t) {
+				e.commit(t), z();
+			},
+			cancel() {
+				L(() => X(() => e.cancel())), z();
+			},
+			suspend: () => e.suspend(),
+			isActive: () => e.isActive()
+		};
+		return ot.set(t, e), t;
+	}
+	let ct = {
+		apply(e, t) {
+			Re("history.apply"), F([e], (n) => {
+				let r = () => n.length === 1 ? x.apply(e, t) : x.applyOps(n, t ?? e.label ?? "");
+				R(() => X(r), () => !0), z();
+			});
+		},
+		applyOps(e, t) {
+			Re("history.applyOps"), F(e, (e) => {
+				R(() => X(() => x.applyOps(e, t)), () => !0), z();
+			});
+		},
+		undo: () => {
+			$.undo();
+		},
+		redo: () => {
+			$.redo();
+		},
+		goto: (e) => {
+			$.jumpToHistoryIndex(e);
+		},
+		clear() {
+			x.clear(), z();
+		},
+		recordEntry(e, t, n) {
+			x.recordEntry(e, t, n), z();
+		},
+		restore: (e) => {
+			$.restoreHistory(e);
+		},
+		canUndo: () => x.canUndo(),
+		canRedo: () => x.canRedo(),
+		undoDepth: () => x.undoDepth(),
+		redoDepth: () => x.redoDepth(),
+		entries: () => x.entries(),
+		getVersion: () => x.getVersion(),
+		subscribe: (e) => x.subscribe(e),
+		serialize: () => x.serialize(),
+		allForwardOps: () => x.allForwardOps(),
+		seal: () => x.seal(),
+		currentEntryId: () => x.currentEntryId(),
+		beginJournal: (e) => st(x.beginJournal(e)),
+		resumeJournal: (e) => x.resumeJournal(ot.get(e) ?? e)
+	};
+	function lt(e, t, n) {
+		let r = (we ?? (() => null))(), i = T, a = O;
+		T = !0, C++, O = !1;
+		try {
+			R(() => {
+				r ? r.applyBatch(e, t) : x.applyOps(e.map((e) => Je(e, n)), t);
+			}, () => !0);
+		} finally {
+			if (C--, T = i, O ||= a, C === 0 && O) {
+				O = !1;
+				for (let e of v) e();
+			}
+		}
+	}
+	let $ = {
+		get nodes() {
+			return u.nodes;
+		},
+		get roots() {
+			return u.roots;
+		},
+		get layers() {
+			return u.layers;
+		},
+		registry: d,
+		get(e) {
+			return u.nodes.get(e);
+		},
+		incarnation(e) {
+			let t = u.nodes.get(e);
+			if (!t) return;
+			let n = xe.get(t);
+			return n === void 0 && (n = Se++, xe.set(t, n)), n;
+		},
+		childrenOf(e) {
+			let t = u.nodes.get(e);
+			return t && t.kind === "container" ? t.children : [];
+		},
+		ancestorsOf(e) {
+			let t = [], n = u.nodes.get(e)?.parent ?? null;
+			for (; n !== null;) t.push(n), n = u.nodes.get(n)?.parent ?? null;
+			return t;
+		},
+		renderOrder() {
+			let e = tt();
+			return e.ids ??= Xe();
+		},
+		renderOrderNodes() {
+			let e = tt();
+			return e.nodes ??= Ze();
+		},
+		nodesOnLayer(e) {
+			let t = tt(), n = t.byLayer;
+			if (!n) {
+				n = /* @__PURE__ */ new Map();
+				for (let e of t.nodes ??= Ze()) {
+					let t = n.get(e.layer);
+					t || n.set(e.layer, t = []), t.push(e);
+				}
+				t.byLayer = n;
+			}
+			return n.get(e) ?? et;
+		},
+		add(e) {
+			let t = e.id ?? _e();
+			if (u.nodes.has(t)) throw Error(`Scene: id collision on "${t}"`);
+			V(e.layer), ze(e.layer, "add to");
+			let n = e.parent ?? null;
+			if (n !== null) {
+				let t = B(n);
+				if (t.kind !== "container") throw Error(`Scene: parent "${n}" is not a container`);
+				U(e.id, e.layer, n, t.layer), I(n, "add under");
+			}
+			if (n !== null && P()) return $.batch(`add ${e.kind}`, () => $.add(e));
+			let r = W(n), i = e.index ?? r.length;
+			return ke(t, n, null), Z("kit:add", {
+				id: t,
+				kind: e.kind,
+				layer: e.layer,
+				pose: e.pose,
+				data: e.data,
+				parent: n,
+				index: i,
+				...e.dependsOn === void 0 ? {} : { dependsOn: e.dependsOn },
+				...e.pickable === void 0 ? {} : { pickable: e.pickable },
+				...c(f, {
+					...e,
+					id: t,
+					kind: e.kind
+				}, "opKey")
+			}, `add ${e.kind}`), Ue(e, t, { cacheForRedo: !0 }), t;
+		},
+		remove(e) {
+			$.removeMany([e]);
+		},
+		removalClosure(e) {
+			return He(e).ids;
+		},
+		removeMany(e) {
+			if (e.length === 0) return;
+			let { ids: t, removing: n } = He(e);
+			for (let e of t) I(e, "remove");
+			let r = t.map((e) => {
+				let t = B(e);
+				return t.kind === "container" ? {
+					...t,
+					children: [...t.children]
+				} : { ...t };
+			}), i = r.filter((e) => e.parent === null || !n.has(e.parent)).map((e) => ({
+				id: e.id,
+				parent: e.parent,
+				index: W(e.parent).indexOf(e.id)
+			})).sort((e, t) => e.index - t.index);
+			for (let e of t) be.clear(e);
+			let a = r.flatMap((e) => {
+				let t = c(f, e, "opKey");
+				return Object.keys(t).length === 0 ? [] : [{
+					id: e.id,
+					...t
+				}];
+			}), o = {
+				nodes: r,
+				detached: i,
+				...a.length > 0 ? { fnKeys: a } : {}
+			};
+			if (i.some((e) => e.parent !== null) && P()) {
+				$.batch("remove", () => $.removeMany(e));
+				return;
+			}
+			for (let e of i) Ae(e.id, e.parent, null);
+			Z("kit:remove", o, "remove");
+		},
+		update(e, t) {
+			let n = B(e);
+			I(e, "update"), Z("kit:setData", {
+				id: e,
+				from: n.data,
+				to: t.data
+			}, "update");
+		},
+		setPose(e, t) {
+			let n = B(e);
+			if (I(e, "set the pose of"), n.kind === "container" && ie(fe, e, n.pose, t)) {
+				if (P()) {
+					$.batch("setPose", () => $.setPose(e, t));
+					return;
+				}
+				N(e);
+			}
+			Z("kit:setPose", {
+				id: e,
+				from: n.pose,
+				to: t
+			}, "setPose");
+		},
+		setLayer(e, t) {
+			V(t);
+			let n = B(e);
+			if (I(e, "relayer"), n.layer !== t && ze(t, "move nodes onto"), n.parent !== null) {
+				let r = B(n.parent);
+				U(e, t, n.parent, r.layer, "relayer");
+			}
+			if (n.layer === t) return;
+			let r = [], i = [e];
+			for (; i.length > 0;) {
+				let e = i.pop(), t = u.nodes.get(e);
+				if (t && (r.push(e), I(e, "relayer"), t.kind === "container")) for (let e = t.children.length - 1; e >= 0; e--) i.push(t.children[e]);
+			}
+			r.length === 1 ? Z("kit:setLayer", {
+				id: e,
+				from: n.layer,
+				to: t
+			}, "setLayer") : $.batch("setLayer", () => {
+				for (let e of r) {
+					let n = B(e);
+					n.layer !== t && Z("kit:setLayer", {
+						id: e,
+						from: n.layer,
+						to: t
+					}, "setLayer");
+				}
+			});
+		},
+		setDependsOn(e, t) {
+			let r = B(e);
+			I(e, "retarget"), !n(r.dependsOn, t) && Z("kit:setDependsOn", {
+				id: e,
+				from: r.dependsOn,
+				to: t
+			}, "setDependsOn");
+		},
+		setLayout(e, t) {
+			let n = B(e);
+			if (n.kind !== "container") throw Error(`Scene: "${e}" is not a container`);
+			I(e, "set the layout of");
+			let r = p("layout"), i;
+			if (typeof t == "string") {
+				if (i = r.fnOf(t) ?? null, i === null) throw Error(`Scene: no layout "${t}" in this scene's registry`);
+			} else i = t;
+			let a = n.layout ?? null;
+			if (a === i) return;
+			if (i !== null && (pe = !0), P()) {
+				$.batch("setLayout", () => $.setLayout(e, i));
+				return;
+			}
+			N(e);
+			let o = a === null ? void 0 : r.keyOf(a), s = i === null ? void 0 : r.keyOf(i), c = {
+				id: e,
+				...o === void 0 ? {} : { fromKey: o },
+				...s === void 0 ? {} : { toKey: s }
+			};
+			Ge.set(c, {
+				from: a,
+				to: i
+			}), Z("kit:setLayout", c, "setLayout");
+		},
+		move(e, t, n) {
+			let r = B(e);
+			if (I(e, "move"), t !== null) {
+				I(t, "move nodes into");
+				let n = B(t);
+				if (n.kind !== "container") throw Error(`Scene: parent "${t}" is not a container`);
+				if (U(e, r.layer, t, n.layer), t === e) throw Error("Scene: cannot parent a node to itself");
+				let i = [];
+				if (q(e, i), i.includes(t)) throw Error("Scene: cannot parent a node to its own descendant");
+			}
+			if ((t !== null || r.parent !== null) && P()) {
+				$.batch("move", () => $.move(e, t, n));
+				return;
+			}
+			let i = W(r.parent), a = i.indexOf(e), o = t === r.parent ? i : W(t), s = n ?? o.length;
+			ke(e, t, r.parent), Ae(e, r.parent, t), N(r.parent), Z("kit:move", {
+				id: e,
+				fromParent: r.parent,
+				fromIndex: a,
+				toParent: t,
+				toIndex: s
+			}, "move");
+		},
+		reorder(e, t) {
+			let n = B(e);
+			if (I(e, "reorder"), n.parent !== null && P()) {
+				$.batch("reorder", () => $.reorder(e, t));
+				return;
+			}
+			N(n.parent);
+			let r = W(n.parent).indexOf(e);
+			Z("kit:move", {
+				id: e,
+				fromParent: n.parent,
+				fromIndex: r,
+				toParent: n.parent,
+				toIndex: t
+			}, "reorder");
+		},
+		setLayerVisible(e, t) {
+			let n = V(e);
+			Z("kit:setLayerVisible", {
+				layer: e,
+				from: u.layers[n].visible,
+				to: t
+			}, "setLayerVisible");
+		},
+		setLayerLocked(e, t) {
+			let n = V(e);
+			Z("kit:setLayerLocked", {
+				layer: e,
+				from: u.layers[n].locked,
+				to: t
+			}, "setLayerLocked");
+		},
+		setLayerParallax(e, t) {
+			let n = V(e);
+			Z("kit:setLayerParallax", {
+				layer: e,
+				from: u.layers[n].parallax,
+				to: t
+			}, "setLayerParallax");
+		},
+		isLocked: (e) => Le(e),
+		unlocked: (e) => L(e),
+		addLayer(e) {
+			if (u.layerIndex.has(e.id)) throw Error(`Scene: duplicate layer id "${e.id}"`);
+			let t = e.index ?? u.layers.length, n = Math.max(0, Math.min(t, u.layers.length));
+			Z("kit:addLayer", {
+				record: {
+					kind: "user",
+					id: e.id,
+					name: e.name,
+					visible: e.visible ?? !0,
+					locked: e.locked ?? !1,
+					...e.parallax ? { parallax: e.parallax } : {}
+				},
+				index: n
+			}, "addLayer");
+		},
+		removeLayer(e) {
+			let t = V(e), n = u.layers[t];
+			if (n.kind !== "user") throw Error(`Scene: cannot remove system layer "${e}"`);
+			L(() => $.batch("removeLayer", () => {
+				let t = [];
+				for (let [n, r] of u.nodes) r.layer === e && t.push(n);
+				$.removeMany(t);
+				let r = V(e);
+				Z("kit:removeLayer", {
+					record: n,
+					index: r
+				}, "removeLayer");
+			}));
+		},
+		renameLayer(e, t) {
+			let n = u.layers[V(e)];
+			if (n.kind !== "user") throw Error(`Scene: cannot rename system layer "${e}"`);
+			Z("kit:renameLayer", {
+				layer: e,
+				from: n.name,
+				to: t
+			}, "renameLayer");
+		},
+		moveLayer(e, t) {
+			let n = V(e), r = Math.max(0, Math.min(t, u.layers.length - 1));
+			if (n === r) return;
+			let i = [...u.layers], [a] = i.splice(n, 1);
+			i.splice(r, 0, a);
+			let o = /* @__PURE__ */ new Map();
+			for (let e = 0; e < i.length; e++) o.set(i[e].id, e);
+			for (let n of u.nodes.values()) {
+				if (n.parent === null) continue;
+				let r = u.nodes.get(n.parent);
+				if (r && o.get(n.layer) < o.get(r.layer)) throw Error(`Scene: moveLayer("${e}", ${t}) — a child may not render below its parent's layer`);
+			}
+			Z("kit:moveLayer", {
+				layer: e,
+				from: n,
+				to: r
+			}, "moveLayer");
+		},
+		registerOp(e, t) {
+			if (e.startsWith("kit:")) throw Error(`Scene: op kind "${e}" is reserved (kit:* prefix)`);
+			y.set(e, t);
+		},
+		recordOp(e) {
+			Z(e.kind, e.payload, e.kind);
+		},
+		setActiveJournalAccessor(e) {
+			we = e;
+		},
+		applyBatch(e, t, n) {
+			Re("applyBatch"), F(e, (e) => lt(e, t, n));
+		},
+		setArrivalHandler(e) {
+			return Te = e, () => {
+				Te === e && (Te = null);
+			};
+		},
+		layoutOf(e) {
+			return me(e);
+		},
+		onReflow(e) {
+			return Ee.add(e), () => {
+				Ee.delete(e);
+			};
+		},
+		overrides: be,
+		getSelection: () => b,
+		setSelection(e) {
+			b = Be([...e]), z();
+		},
+		history: ct,
+		undo() {
+			return x.canUndo() ? (L(() => X(() => x.undo())), z(), !0) : !1;
+		},
+		redo() {
+			return x.canRedo() ? (L(() => X(() => x.redo())), z(), !0) : !1;
+		},
+		canUndo: () => x.canUndo(),
+		canRedo: () => x.canRedo(),
+		historyEntries() {
+			let { undo: e, redo: t } = x.entries(), n = [];
+			for (let t of e) n.push({
+				id: String(t.id),
+				label: t.label
+			});
+			for (let e of t) n.push({
+				id: String(e.id),
+				label: e.label
+			});
+			return n;
+		},
+		historyIndex: () => x.undoDepth(),
+		jumpToHistoryIndex(e) {
+			let t = x.undoDepth() + x.redoDepth(), n = Math.max(0, Math.min(t, e));
+			return n !== x.undoDepth() && (L(() => X(() => x.goto(n))), z(), !0);
+		},
+		serializeHistory: () => x.serialize(),
+		restoreHistory(e) {
+			x.restore(e), z();
+		},
+		setHistoryAdapter(e) {
+			ve = e;
+		},
+		batch(e, t) {
+			let n = C === 0;
+			n && (w = {
+				label: e,
+				ops: [],
+				selectionBefore: b
+			});
+			let i = n && je(!0);
+			C++;
+			try {
+				if (!n) return t();
+				try {
+					let e = R(() => {
+						let e = t();
+						if (i) for (let e of Ne()) $.setPose(r(e.id), e.to);
+						return e;
+					}, () => (w?.ops.length ?? 0) > 0);
+					return i && Me(), e;
+				} catch (e) {
+					throw w = null, e;
+				}
+			} finally {
+				if (C--, i && (k = null, M = null), C === 0) {
+					if (w) {
+						let e = w;
+						w = null, e.ops.length > 0 && x.recordEntry(e.ops, e.label, { selectionBefore: e.selectionBefore });
+					}
+					if (O) {
+						O = !1;
+						for (let e of v) e();
+					}
+				}
+			}
+		},
+		untracked(e) {
+			let t = T, n = S;
+			T = !0, Ce++;
+			let i = je(!0);
+			C++;
+			try {
+				let t = R(() => {
+					let t = e();
+					if (i) for (let e of Ne()) $.setPose(r(e.id), e.to);
+					return t;
+				}, () => !1);
+				return i && Me(), t;
+			} finally {
+				if (C--, i && (k = null, M = null), Ce--, T = t, S !== n && x.seal(), C === 0 && O) {
+					O = !1;
+					for (let e of v) e();
+				}
+			}
+		},
+		toJSON() {
+			let e = [];
+			for (let t of Ze()) {
+				let n = t.id, r = {
+					id: n,
+					kind: t.kind,
+					layer: t.layer,
+					pose: t.pose,
+					data: t.data
+				};
+				t.parent != null && (r.parent = t.parent), t.dependsOn === "children" ? r.dependsOn = "children" : t.dependsOn && t.dependsOn.length > 0 && (r.dependsOn = t.dependsOn), t.pickable === !1 && (r.pickable = !1), Object.assign(r, c(f, t, "jsonKey", (e) => {
+					throw Error(`Scene.toJSON: node '${n}' has ${e.spec.field} but no matching registry key. The function must be registered via createScene's registry option to round-trip.`);
+				})), e.push(r);
+			}
+			return {
+				version: 1,
+				systemLayers: u.layers.map((e) => {
+					let t = { id: e.id };
+					return e.visible === !1 && (t.visible = !1), e.locked === !0 && (t.locked = !0), e.parallax && (t.parallax = e.parallax), e.kind === "user" && (t.kind = "user", t.name = e.name), t;
+				}),
+				nodes: e
+			};
+		},
+		loadState(e) {
+			let t = de(e, d);
+			m.clear(), u.nodes.clear(), u.roots.length = 0, u.layers.length = 0, u.layerIndex.clear(), Q();
+			for (let t = 0; t < e.systemLayers.length; t++) {
+				let n = e.systemLayers[t];
+				if (u.layerIndex.has(n.id)) throw Error(`Scene.loadState: duplicate system layer id "${n.id}"`);
+				u.layers.push(ue(n)), u.layerIndex.set(n.id, t);
+			}
+			x.clear();
+			for (let e of f) e.pending.clear();
+			w = null, C = 0, O = !1, ut(t), z();
+		},
+		subscribe(e) {
+			return v.add(e), () => v.delete(e);
+		},
+		getVersion: () => S
+	};
+	function ut(e) {
+		for (let t of e) {
+			let e = t.id ?? _e();
+			if (u.nodes.has(e)) throw Error(`Scene: id collision on "${e}"`);
+			V(t.layer);
+			let n = t.parent ?? null;
+			if (n !== null) {
+				let e = B(n);
+				if (e.kind !== "container") throw Error(`Scene: parent "${n}" is not a container`);
+				U(t.id, t.layer, n, e.layer);
+			}
+			let r = W(n), i = t.index ?? r.length;
+			qe("kit:add", {
+				id: e,
+				kind: t.kind,
+				layer: t.layer,
+				pose: t.pose,
+				data: t.data,
+				parent: n,
+				index: i,
+				...t.dependsOn === void 0 ? {} : { dependsOn: t.dependsOn },
+				...t.pickable === void 0 ? {} : { pickable: t.pickable }
+			}), Ue(t, e, { cacheForRedo: !1 });
+		}
+	}
+	return o.initial && (ut(o.initial), z()), $.__clipCacheSize = () => p("clipFromPose").pending.size, $.__derivePathCacheSize = () => p("derivePath").pending.size, $.__derivePoseCacheSize = () => p("derivePose").pending.size, $;
+}
+function de(e, t) {
+	if (e.version !== 1) throw Error(`Scene: unsupported version ${e.version}; only v1 supported`);
+	return e.nodes.map((e) => {
+		let n = {
+			id: e.id,
+			kind: e.kind,
+			layer: e.layer,
+			pose: e.pose,
+			data: e.data
+		};
+		e.parent !== void 0 && (n.parent = e.parent), e.pickable !== void 0 && (n.pickable = e.pickable), e.dependsOn !== void 0 && (n.dependsOn = e.dependsOn === "children" ? "children" : e.dependsOn);
+		let r = e;
+		for (let e of o) {
+			let i = r[e.jsonKey];
+			if (i === void 0) continue;
+			let a = t[e.field]?.[i];
+			if (!a) throw Error(`Scene: unknown ${e.field} key '${i}'. Register a function with this key in the registry option.`);
+			n[e.field] = a;
+		}
+		return n;
+	});
+}
+function f(e) {
+	return {
+		get: () => e.getSelection(),
+		set: (t) => e.setSelection(t)
+	};
+}
+function p(e, t = {}) {
+	let n = t.registry ?? {}, r = d({
+		systemLayers: e.systemLayers.map((e) => ({ id: e.id })),
+		registry: n,
+		...t.historyLimit === void 0 ? {} : { historyLimit: t.historyLimit },
+		...t.coalesceWindowMs === void 0 ? {} : { coalesceWindowMs: t.coalesceWindowMs },
+		...t.generateId === void 0 ? {} : { generateId: t.generateId },
+		...t.ops === void 0 ? {} : { ops: t.ops },
+		...t.layoutFrame === void 0 ? {} : { layoutFrame: t.layoutFrame }
+	});
+	return r.loadState(e), r;
+}
+//#endregion
+export { d as createScene, p as sceneFromJSON, f as sceneSelectionStore };
+
+//# sourceMappingURL=scene.js.map