@weasel-js/core 1.9.4 → 1.10.1

package/dist/core/scene/kitOps.js

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

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

@@ -1 +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":"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"}
+{"version":3,"file":"kitOps.js","names":["setParallax","to","record","setUnits","node","registerKitOps","env","registerKitOp","kind","handler","state","p","attach","dependents","trackChildDerived","target","attached","addedFns","field","fnFields","fn","key","restoreFn","dwarn","detach","childDerived","invalidateChildDerivedFrom","invalidateDependents","n","d","keys","k","clone","restoreNodeFunctions","requireLayerIndex","invalidateOrder","requireNode","layoutRefs","placeLayout","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 { UnitScope } from '@weasel-js/quantity';\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, and\n   *  the ids in `gone`. */\n  narrowSelection(gone?: ReadonlySet<NodeId>): void;\n  /** Drop the pose override of a node that is about to leave the scene: ids\n   *  are reusable, and one left behind would attach itself to whatever is\n   *  added under that id next. */\n  clearOverride(id: NodeId): 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\nfunction setUnits(node: { units?: UnitScope }, to: UnitScope | undefined): void {\n  if (to === undefined) delete node.units;\n  else node.units = 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    units?: UnitScope;\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      if (p.units !== undefined) (node as ContainerNode<TData, TLayer, TPose>).units = p.units;\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      env.clearOverride(p.id);\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 n of p.nodes) env.clearOverride(n.id);\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      env.narrowSelection(new Set(p.nodes.map((n) => n.id)));\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  registerKitOp<{ id: NodeId; from?: UnitScope; to?: UnitScope }>('kit:setUnits', {\n    apply: (p) => { setUnits(requireNode(p.id) as { units?: UnitScope }, p.to); },\n    revert: (p) => { setUnits(requireNode(p.id) as { units?: UnitScope }, 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) => { state.layers[requireLayerIndex(p.layer)].locked = p.to; if (p.to) env.narrowSelection(); },\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) => { state.layers.splice(p.index, 0, { ...p.record }); rebuildLayerIndex(); },\n    revert: (p) => { state.layers.splice(p.index, 1); rebuildLayerIndex(); },\n  });\n\n  registerKitOp<{ record: LayerRecord<TLayer>; index: number }>('kit:removeLayer', {\n    apply: (p) => { state.layers.splice(p.index, 1); rebuildLayerIndex(); },\n    revert: (p) => { state.layers.splice(p.index, 0, { ...p.record } as LayerRecord<TLayer>); rebuildLayerIndex(); },\n  });\n\n  registerKitOp<{ layer: TLayer; from: string; to: string }>('kit:renameLayer', {\n    apply: (p) => { (state.layers[requireLayerIndex(p.layer)] as UserLayerRecord<TLayer>).name = p.to; },\n    revert: (p) => { (state.layers[requireLayerIndex(p.layer)] as UserLayerRecord<TLayer>).name = p.from; },\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":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"kitRegistry.js","names":["UNION_OF_CHILDREN","unionOfChildren","poses","d","deps","rect","asRectPose","union","unionAABB","pose","p","withKitRegistry","registry"],"sources":["../../../src/core/scene/kitRegistry.ts"],"sourcesContent":["/**\n * The `SceneRegistry` entries the kit owns.\n *\n * A registry-keyed function has to be resolvable by key in whatever scene\n * loads a snapshot, so a function the *kit* attaches to a node cannot live in\n * the consumer's registry alone — a document saved with a grouped container\n * would come back with a dead key. `createScene` merges these under the\n * consumer's, which stays the winner on a key collision.\n */\nimport { unionAABB } from '../geometry/unionBounds';\nimport type { RectPose, SceneRegistry } from './types';\n\n/** Registry key for {@link unionOfChildren}. */\nexport const UNION_OF_CHILDREN = 'kit:unionOfChildren';\n\n/**\n * A container's pose as the envelope of what it holds — `unionAABB`, so a\n * rotated member contributes the extent of its ink rather than its unrotated\n * box. Paired with `dependsOn: 'children'`, this is what makes a group's\n * bounds track its members instead of freezing at the moment it was made.\n *\n * Its members and its result share one frame: a container deriving its pose\n * from its children defines none of its own (see `definesFrame`), so the same\n * union is right under any composition strategy.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose — the group stays where the last member left it rather than collapsing\n * to a zero box at the origin.\n *\n * Reads members as rect poses, and only as rect poses: a scene whose poses are\n * shaped otherwise gets `null` here and its container keeps its authored pose,\n * because this entry is registered into every scene and the scene layer holds\n * no descriptor to read another shape with. To make such a container track its\n * members, register `unionOfChildrenVia(itsDescriptor)` under\n * {@link UNION_OF_CHILDREN} — the consumer's entry wins the collision.\n */\nexport function unionOfChildren<TPose>(\n  _node: unknown,\n  deps: readonly ({ pose: TPose } | undefined)[],\n): TPose | null {\n  const poses: RectPose[] = [];\n  for (const d of deps) {\n    if (d === undefined) continue;\n    const rect = asRectPose(d.pose);\n    if (rect === null) return null;\n    poses.push(rect);\n  }\n  if (poses.length === 0) return null;\n  const union = unionAABB(poses);\n  // Sound by the check above: every member read as a rect, so the union is one\n  // too, and a scene holding rect poses is a scene whose `TPose` is one.\n  return union === null ? null : (union as unknown as TPose);\n}\n\n/** `pose` as a rect, or `null` when it is some other shape entirely. */\nexport function asRectPose(pose: unknown): RectPose | null {\n  if (pose === null || typeof pose !== 'object') return null;\n  const p = pose as Partial<RectPose>;\n  const rect = typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number';\n  return rect ? (pose as RectPose) : null;\n}\n\n/** Merge the kit's own entries under a consumer registry. */\nexport function withKitRegistry<TPose, TData = unknown, TLayer extends string = string>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n): SceneRegistry<TPose, TData, TLayer> {\n  return {\n    ...registry,\n    derivePose: {\n      [UNION_OF_CHILDREN]: unionOfChildren as NonNullable<\n        SceneRegistry<TPose, TData, TLayer>['derivePose']\n      >[string],\n      ...registry.derivePose,\n    },\n  };\n}\n"],"mappings":";;AAaA,IAAaA,IAAoB;AAuBjC,SAAgBC,EACd,GACA,GACc;CACd,IAAMC,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAKC,GAAM;EACpB,IAAID,MAAM,KAAA,GAAW;EACrB,IAAME,IAAOC,EAAWH,EAAE,IAAI;EAC9B,IAAIE,MAAS,MAAM,OAAO;EAC1B,EAAM,KAAKA,CAAI;CACjB;CACA,IAAIH,EAAM,WAAW,GAAG,OAAO;CAC/B,IAAMK,IAAQC,EAAUN,CAAK;CAG7B,OAAOK,MAAU,OAAO,OAAQA;AAClC;AAGA,SAAgBD,EAAW,GAAgC;CACzD,IAAqB,OAAOG,KAAS,aAAjCA,GAA2C,OAAO;CACtD,IAAMC,IAAID;CAGV,OAFa,OAAOC,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAClD,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW,WACzCD,IAAoB;AACrC;AAGA,SAAgBE,EACd,GACqC;CACrC,OAAO;EACL,GAAGC;EACH,YAAY;IACTZ,IAAoBC;GAGrB,GAAGW,EAAS;EACd;CACF;AACF"}
+{"version":3,"file":"kitRegistry.js","names":["UNION_OF_CHILDREN","unionOfChildren","poses","d","deps","rect","asRectPose","union","unionAABB","pose","p","withKitRegistry","registry"],"sources":["../../../src/core/scene/kitRegistry.ts"],"sourcesContent":["/**\n * The `SceneRegistry` entries the kit owns.\n *\n * A registry-keyed function has to be resolvable by key in whatever scene\n * loads a snapshot, so a function the *kit* attaches to a node cannot live in\n * the consumer's registry alone — a document saved with a grouped container\n * would come back with a dead key. `createScene` merges these under the\n * consumer's, which stays the winner on a key collision.\n */\nimport { unionAABB } from '../geometry/unionBounds';\nimport type { RectPose, SceneRegistry } from './types';\n\n/** Registry key for {@link unionOfChildren}. */\nexport const UNION_OF_CHILDREN = 'kit:unionOfChildren';\n\n/**\n * A container's pose as the envelope of what it holds — `unionAABB`, so a\n * rotated member contributes the extent of its ink rather than its unrotated\n * box. Paired with `dependsOn: 'children'`, this is what makes a group's\n * bounds track its members.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose.\n *\n * Reads members as rect poses only: a scene whose poses are shaped otherwise\n * gets `null` here and its container keeps its authored pose. To make such a\n * container track its members, register `unionOfChildrenVia(itsDescriptor)`\n * under {@link UNION_OF_CHILDREN} — the consumer's entry wins the collision.\n */\nexport function unionOfChildren<TPose>(\n  _node: unknown,\n  deps: readonly ({ pose: TPose } | undefined)[],\n): TPose | null {\n  const poses: RectPose[] = [];\n  for (const d of deps) {\n    if (d === undefined) continue;\n    const rect = asRectPose(d.pose);\n    if (rect === null) return null;\n    poses.push(rect);\n  }\n  if (poses.length === 0) return null;\n  const union = unionAABB(poses);\n  // Sound by the check above: every member read as a rect, so the union is one\n  // too, and a scene holding rect poses is a scene whose `TPose` is one.\n  return union === null ? null : (union as unknown as TPose);\n}\n\n/** `pose` as a rect, or `null` when it is some other shape entirely. */\nexport function asRectPose(pose: unknown): RectPose | null {\n  if (pose === null || typeof pose !== 'object') return null;\n  const p = pose as Partial<RectPose>;\n  const rect = typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number';\n  return rect ? (pose as RectPose) : null;\n}\n\n/** Merge the kit's own entries under a consumer registry. */\nexport function withKitRegistry<TPose, TData = unknown, TLayer extends string = string>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n): SceneRegistry<TPose, TData, TLayer> {\n  return {\n    ...registry,\n    derivePose: {\n      [UNION_OF_CHILDREN]: unionOfChildren as NonNullable<\n        SceneRegistry<TPose, TData, TLayer>['derivePose']\n      >[string],\n      ...registry.derivePose,\n    },\n  };\n}\n"],"mappings":";;AAaA,IAAaA,IAAoB;AAgBjC,SAAgBC,EACd,GACA,GACc;CACd,IAAMC,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAKC,GAAM;EACpB,IAAID,MAAM,KAAA,GAAW;EACrB,IAAME,IAAOC,EAAWH,EAAE,IAAI;EAC9B,IAAIE,MAAS,MAAM,OAAO;EAC1B,EAAM,KAAKA,CAAI;CACjB;CACA,IAAIH,EAAM,WAAW,GAAG,OAAO;CAC/B,IAAMK,IAAQC,EAAUN,CAAK;CAG7B,OAAOK,MAAU,OAAO,OAAQA;AAClC;AAGA,SAAgBD,EAAW,GAAgC;CACzD,IAAqB,OAAOG,KAAS,aAAjCA,GAA2C,OAAO;CACtD,IAAMC,IAAID;CAGV,OAFa,OAAOC,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAClD,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW,WACzCD,IAAoB;AACrC;AAGA,SAAgBE,EACd,GACqC;CACrC,OAAO;EACL,GAAGC;EACH,YAAY;IACTZ,IAAoBC;GAGrB,GAAGW,EAAS;EACd;CACF;AACF"}

package/dist/core/scene/layerStack.js

@@ -1,15 +1,20 @@
 //#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 e(e) {
+	return {
+		kind: "system",
+		id: e.id,
+		visible: e.visible ?? !0,
+		locked: e.locked ?? !1,
+		...e.parallax ? { parallax: e.parallax } : {}
+	};
+}
+function t(e, t) {
+	function n(n) {
+		e.layers.length = 0, e.layerIndex.clear(), t();
+		for (let t of n) {
+			if (e.layerIndex.has(t.id)) throw Error(`Scene: duplicate ${t.kind} layer id "${t.id}"`);
+			e.layerIndex.set(t.id, e.layers.length), e.layers.push(t);
+		}
 	}
 	function r(t) {
 		let n = e.layerIndex.get(t);
@@ -27,12 +32,100 @@ function e(e, t, n) {
 		}
 	}
 	return {
+		reset: n,
 		requireLayerIndex: r,
 		rebuildLayerIndex: i,
 		assertSubtreeLayer: a
 	};
 }
+function n(e, t, n, r) {
+	let i = /* @__PURE__ */ new Map();
+	for (let e = 0; e < t.length; e++) i.set(t[e].id, e);
+	for (let t of e.values()) {
+		if (t.parent === null) continue;
+		let a = e.get(t.parent);
+		if (a && i.get(t.layer) < i.get(a.layer)) throw Error(`Scene: moveLayer("${n}", ${r}) — a child may not render below its parent's layer`);
+	}
+}
+function r(e) {
+	let { layers: t, nodes: r, requireLayerIndex: i, record: a } = e;
+	function o(e, n) {
+		let r = t[i(e)];
+		if (r.kind !== "user") throw Error(`Scene: cannot ${n} system layer "${e}"`);
+		return r;
+	}
+	return {
+		setLayerVisible(e, n) {
+			let r = t[i(e)];
+			a("kit:setLayerVisible", {
+				layer: e,
+				from: r.visible,
+				to: n
+			}, "setLayerVisible");
+		},
+		setLayerLocked(e, n) {
+			let r = t[i(e)];
+			a("kit:setLayerLocked", {
+				layer: e,
+				from: r.locked,
+				to: n
+			}, "setLayerLocked");
+		},
+		setLayerParallax(e, n) {
+			let r = t[i(e)];
+			a("kit:setLayerParallax", {
+				layer: e,
+				from: r.parallax,
+				to: n
+			}, "setLayerParallax");
+		},
+		addLayer(n) {
+			if (e.layerIndex.has(n.id)) throw Error(`Scene: duplicate layer id "${n.id}"`);
+			let r = Math.max(0, Math.min(n.index ?? t.length, t.length)), i = {
+				kind: "user",
+				id: n.id,
+				name: n.name,
+				visible: n.visible ?? !0,
+				locked: n.locked ?? !1,
+				...n.parallax ? { parallax: n.parallax } : {}
+			};
+			a("kit:addLayer", {
+				record: i,
+				index: r
+			}, "addLayer");
+		},
+		removeLayer(t) {
+			let n = o(t, "remove");
+			e.lifted(() => e.batch("removeLayer", () => {
+				let o = [];
+				for (let [e, n] of r) n.layer === t && o.push(e);
+				e.removeMany(o), a("kit:removeLayer", {
+					record: n,
+					index: i(t)
+				}, "removeLayer");
+			}));
+		},
+		renameLayer(e, t) {
+			let n = o(e, "rename");
+			a("kit:renameLayer", {
+				layer: e,
+				from: n.name,
+				to: t
+			}, "renameLayer");
+		},
+		moveLayer(e, o) {
+			let s = i(e), c = Math.max(0, Math.min(o, t.length - 1));
+			if (s === c) return;
+			let l = [...t], [u] = l.splice(s, 1);
+			l.splice(c, 0, u), n(r, l, e, o), a("kit:moveLayer", {
+				layer: e,
+				from: s,
+				to: c
+			}, "moveLayer");
+		}
+	};
+}
 //#endregion
-export { e as createLayerStack };
+export { r as createLayerEdits, t as createLayerStack, e as systemLayerRecord };
 
 //# sourceMappingURL=layerStack.js.map

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

@@ -1 +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"}
+{"version":3,"file":"layerStack.js","names":["systemLayerRecord","spec","createLayerStack","reset","state","invalidateOrder","record","records","requireLayerIndex","i","layer","rebuildLayerIndex","assertSubtreeLayer","nodeLayer","parentLayer","action","verb","nodeId","parentId","assertOrderKeepsChildrenAbove","place","order","node","nodes","parent","index","createLayerEdits","env","userLayer","rec","layers","visible","locked","parallax","tagged","id","name","from","to","proposed"],"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, the rule tying a node's layer to\n * its parent's, and the edits a caller makes to the stack.\n */\nimport type { LayerRecord, Node, NodeId, Scene, UseSceneOptions, UserLayerRecord } 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/** A declared system layer as the stack holds it. */\nexport function systemLayerRecord<TLayer extends string>(\n  spec: UseSceneOptions<unknown, TLayer, unknown>['systemLayers'][number],\n): LayerRecord<TLayer> {\n  return {\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}\n\n/** The reads over `state`'s layers the rest of the scene uses, and the two\n *  ways the stack is rebuilt. It starts empty; `reset` fills it. */\nexport function createLayerStack<TLayer extends string>(\n  state: LayerStackState<TLayer>,\n  /** Called whenever the layer order changes. */\n  invalidateOrder: () => void,\n) {\n  /** Replace the whole stack with `records`, in order. Throws on a duplicate\n   *  id, leaving the stack holding the records before it. */\n  function reset(records: readonly LayerRecord<TLayer>[]): void {\n    state.layers.length = 0;\n    state.layerIndex.clear();\n    invalidateOrder();\n    for (const record of records) {\n      if (state.layerIndex.has(record.id)) {\n        throw new Error(`Scene: duplicate ${record.kind} layer id \"${record.id}\"`);\n      }\n      state.layerIndex.set(record.id, state.layers.length);\n      state.layers.push(record);\n    }\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 { reset, requireLayerIndex, rebuildLayerIndex, assertSubtreeLayer };\n}\n\n/** What the layer edits read of the scene, and what they record through. */\nexport interface LayerEditsEnv<TData, TLayer extends string, TPose> {\n  layers: readonly LayerRecord<TLayer>[];\n  layerIndex: ReadonlyMap<TLayer, number>;\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  requireLayerIndex(layer: TLayer): number;\n  /** Apply a kit op and record it as an edit. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run with the lock guard lifted. */\n  lifted<T>(fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  removeMany(ids: readonly NodeId[]): void;\n}\n\nexport type LayerEdits<TData, TLayer extends string, TPose> = Pick<\n  Scene<TData, TLayer, TPose>,\n  | 'setLayerVisible' | 'setLayerLocked' | 'setLayerParallax'\n  | 'addLayer' | 'removeLayer' | 'renameLayer' | 'moveLayer'\n>;\n\n/** Throw when moving a layer to give `order` would put a child below its parent. */\nfunction assertOrderKeepsChildrenAbove<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n  order: readonly LayerRecord<TLayer>[],\n  layer: TLayer,\n  index: number,\n): void {\n  const place = new Map<TLayer, number>();\n  for (let i = 0; i < order.length; i++) place.set(order[i].id, i);\n  for (const node of nodes.values()) {\n    if (node.parent === null) continue;\n    const parent = nodes.get(node.parent);\n    if (!parent) continue;\n    if (place.get(node.layer)! < place.get(parent.layer)!) {\n      throw new Error(\n        `Scene: moveLayer(\"${layer}\", ${index}) — a child may not render below its parent's layer`,\n      );\n    }\n  }\n}\n\nexport function createLayerEdits<TData, TLayer extends string, TPose>(\n  env: LayerEditsEnv<TData, TLayer, TPose>,\n): LayerEdits<TData, TLayer, TPose> {\n  const { layers, nodes, requireLayerIndex, record } = env;\n\n  function userLayer(layer: TLayer, verb: string): UserLayerRecord<TLayer> {\n    const rec = layers[requireLayerIndex(layer)];\n    if (rec.kind !== 'user') throw new Error(`Scene: cannot ${verb} system layer \"${layer}\"`);\n    return rec;\n  }\n\n  return {\n    setLayerVisible(layer, visible) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerVisible', { layer, from: rec.visible, to: visible }, 'setLayerVisible');\n    },\n\n    setLayerLocked(layer, locked) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerLocked', { layer, from: rec.locked, to: locked }, 'setLayerLocked');\n    },\n\n    setLayerParallax(layer, parallax) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerParallax', { layer, from: rec.parallax, to: parallax }, 'setLayerParallax');\n    },\n\n    addLayer(spec) {\n      if (env.layerIndex.has(spec.id)) throw new Error(`Scene: duplicate layer id \"${spec.id}\"`);\n      const index = Math.max(0, Math.min(spec.index ?? layers.length, layers.length));\n      const layer: UserLayerRecord<TLayer> = {\n        kind: 'user',\n        id: spec.id,\n        name: spec.name,\n        visible: spec.visible ?? true,\n        locked: spec.locked ?? false,\n        ...(spec.parallax ? { parallax: spec.parallax } : {}),\n      };\n      record('kit:addLayer', { record: layer, index }, 'addLayer');\n    },\n\n    removeLayer(layer) {\n      const rec = userLayer(layer, 'remove');\n      // A layer operation, like the lock toggle: taking a locked layer away\n      // takes its nodes with it.\n      env.lifted(() => env.batch('removeLayer', () => {\n        const tagged: NodeId[] = [];\n        for (const [id, node] of nodes) {\n          if (node.layer === layer) tagged.push(id);\n        }\n        env.removeMany(tagged);\n        record('kit:removeLayer', { record: rec, index: requireLayerIndex(layer) }, 'removeLayer');\n      }));\n    },\n\n    renameLayer(layer, name) {\n      const rec = userLayer(layer, 'rename');\n      record('kit:renameLayer', { layer, from: rec.name, to: name }, 'renameLayer');\n    },\n\n    moveLayer(layer, index) {\n      const from = requireLayerIndex(layer);\n      const to = Math.max(0, Math.min(index, layers.length - 1));\n      if (from === to) return;\n      const proposed = [...layers];\n      const [rec] = proposed.splice(from, 1);\n      proposed.splice(to, 0, rec);\n      assertOrderKeepsChildrenAbove(nodes, proposed, layer, index);\n      record('kit:moveLayer', { layer, from, to }, 'moveLayer');\n    },\n  };\n}\n"],"mappings":"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"}