@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/scene/effectivePose.js

@@ -1,78 +1,77 @@
-import { dropPoseKeyedMemoSlots as e, nodeMemo as t } from "./nodeMemo.js";
-import { recordDeps as n, sameDeps as r } from "./depMemo.js";
-import { dependencyIdsOf as i } from "./dependents.js";
-import { resolveDerivedPath as a } from "./derivedPath.js";
+import { deriveRecorded as e, emptyDepRecord as t, sameDeps as n } from "./depMemo.js";
+import { dependencyIdsOf as r } from "./dependents.js";
+import { dropPoseKeyedMemoSlots as i, nodeMemo as a } from "./nodeMemo.js";
+import { resolveDerivedPath as o } from "./derivedPath.js";
 //#region src/core/scene/effectivePose.ts
-var o = {
+var s = {
 	effective: "kit:derivedPose",
 	document: "kit:derivedPose:document"
-}, s = {
+}, c = {
 	effective: void 0,
 	document: "kit:derivedPath:document"
-}, c = /* @__PURE__ */ new Set(), l = 0;
-function u(e, t) {
-	return d(e, t, "effective");
+}, l = /* @__PURE__ */ new Set(), u = 0;
+function d(e, t) {
+	return f(e, t, "effective");
 }
-function d(n, a, s) {
-	let u = a.derivePose;
-	if (u === void 0) return null;
-	let d = i(a, n.childrenOf);
-	if (d.length === 0) return null;
-	if (c.has(a.id)) return l++, null;
-	c.add(a.id);
-	let p = l;
+function f(e, o, c) {
+	let d = o.derivePose;
+	if (d === void 0) return null;
+	let f = r(o, e.childrenOf);
+	if (f.length === 0) return null;
+	if (l.has(o.id)) return u++, null;
+	l.add(o.id);
+	let m = u;
 	try {
-		let i = (e) => m(n, e, s), c = !1, h = t(a, o[s], a.pose, () => (c = !0, f(a, u, d.map(i), {
-			nodes: [],
-			poses: [],
+		let r = (t) => h(e, t, c), l = !1, g = a(o, s[c], o.pose, () => (l = !0, p(o, d, f.map(r), {
+			...t(),
 			value: null
 		})));
-		return !c && !r(h, d, i) && f(a, u, d.map(i), h), l !== p && e(a), h.value;
+		return !l && !n(g, f, r) && p(o, d, f.map(r), g), u !== m && i(o), g.value;
 	} finally {
-		c.delete(a.id);
+		l.delete(o.id);
 	}
 }
-function f(e, t, r, i) {
-	return i.value = t(e, r), n(i, r), i;
+function p(t, n, r, i) {
+	return i.value = e(i, r, (e) => n(t, e)), i;
 }
-function p(e, t) {
-	return m(e, t, "effective");
+function m(e, t) {
+	return h(e, t, "effective");
 }
-function m(e, t, n) {
+function h(e, t, n) {
 	let r = e.get(t);
-	if (r !== void 0) return new h(e, r, n);
+	if (r !== void 0) return new g(e, r, n);
 }
-var h = class {
+var g = class {
 	source;
 	posed;
 	reading;
 	node;
 	pose;
 	constructor(e, t, n) {
-		this.source = e, this.posed = t, this.reading = n, this.node = t, this.pose = g(e, t, n);
+		this.source = e, this.posed = t, this.reading = n, this.node = t, this.pose = _(e, t, n);
 	}
 	get path() {
 		let { source: e, reading: t } = this;
-		return a(this.posed, (n) => m(e, n, t), (t) => e.childrenOf(t), s[t]);
+		return o(this.posed, (n) => h(e, n, t), (t) => e.childrenOf(t), c[t]);
 	}
 };
-function g(e, t, n) {
+function _(e, t, n) {
 	if (n === "effective") {
 		let n = e.overrides.read(t.id)?.pose;
 		if (n !== void 0) return n;
 	}
-	return d(e, t, n) ?? t.pose;
-}
-function _(e, t) {
-	return g(e, t, "document");
+	return f(e, t, n) ?? t.pose;
 }
 function v(e, t) {
-	return g(e, t, "effective");
+	return _(e, t, "document");
+}
+function y(e, t) {
+	return _(e, t, "effective");
 }
-function y(e) {
+function b(e) {
 	return e.dependsOn !== "children" || e.derivePose === void 0;
 }
 //#endregion
-export { y as definesFrame, p as derivedDepOf, u as derivedPose, _ as documentPose, v as effectivePose };
+export { b as definesFrame, m as derivedDepOf, d as derivedPose, v as documentPose, y as effectivePose };
 
 //# sourceMappingURL=effectivePose.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"effectivePose.js","names":["POSE_SLOT","PATH_SLOT","resolving","cycleHits","derivedPose","derivedPoseIn","source","node","derive","ids","dependencyIdsOf","hitsBefore","depOf","depIn","id","reading","computed","record","nodeMemo","run","sameDeps","dropPoseKeyedMemoSlots","deps","recordDeps","into","derivedDepOf","SceneDep","posed","poseIn","resolveDerivedPath","depId","override","documentPose","effectivePose","definesFrame"],"sources":["../../../src/core/scene/effectivePose.ts"],"sourcesContent":["/**\n * `effectivePose` — the pose to draw, pick and measure a node at.\n *\n * Three answers, in order: the ephemeral override a gesture published, the\n * pose the node derives from its dependencies, or the pose the document\n * stores. Reading `node.pose` directly is how the render and hit-test paths\n * came to disagree about where a node is, and a derived pose widens that gap\n * from \"mid-drag\" to \"always\".\n */\nimport { recordDeps, sameDeps, type DepRecord } from './depMemo';\nimport { dependencyIdsOf } from './dependents';\nimport { resolveDerivedPath } from './derivedPath';\nimport { dropPoseKeyedMemoSlots, nodeMemo } from './nodeMemo';\nimport type { Path } from '@weasel-js/geom';\nimport type { DerivedDep, DerivePathFn, DerivePoseFn, Node, NodeId, PoseOverrides } from './types';\n\n/**\n * Which pose a resolution answers: `effective` honors overrides all the way\n * down the dependency chain, `document` ignores them all the way down. Each\n * reading memoizes in its own slots — the memo key is the node and its\n * authored pose, which is the same for both.\n */\ntype Reading = 'effective' | 'document';\n\nconst POSE_SLOT: Record<Reading, string> = {\n  effective: 'kit:derivedPose',\n  document: 'kit:derivedPose:document',\n};\nconst PATH_SLOT: Record<Reading, string | undefined> = {\n  effective: undefined,\n  document: 'kit:derivedPath:document',\n};\n\n/** The subset of a node this module reads. Structural so a `Node` satisfies\n *  it without importing the full generic shape. */\nexport interface PosedNode<TPose> {\n  id: NodeId;\n  kind?: 'leaf' | 'container';\n  pose: TPose;\n  /** Read only by the memo, which keys on its reference alongside the pose. */\n  data?: unknown;\n  dependsOn?: readonly NodeId[] | 'children';\n  derivePose?: DerivePoseFn<TPose>;\n  /** Read only when something asks a dependency for its `path`. */\n  derivePath?: DerivePathFn<TPose>;\n}\n\n/** What resolving a pose needs: the overrides, and enough of the scene to\n *  reach a node's dependencies. A `Scene` satisfies it. */\nexport interface PoseSource<TPose> {\n  readonly overrides: Pick<PoseOverrides<TPose>, 'read'>;\n  get(id: NodeId): PosedNode<TPose> | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n}\n\n/** A cached derived pose, with what it was derived from. */\ninterface PoseMemo<TPose> extends DepRecord<TPose> {\n  value: TPose | null;\n}\n\n/** Ids whose derivation is on the stack. A dependency graph is meant to be\n *  acyclic and `dependsOn` is unvalidated, so a cycle resolves to the authored\n *  pose at whichever node closes it rather than overflowing the stack. */\nconst resolving = new Set<NodeId>();\n\n/** Bumped each time the guard above fires. A derivation that closed a cycle\n *  answered from a fallback rather than from its dependencies, so its value is\n *  an artifact of which node was asked first and must not be cached. */\nlet cycleHits = 0;\n\n/**\n * The pose `node` computes from its dependencies, or `null` when it derives\n * nothing — it has no `derivePose`, nothing to derive from, or its\n * `derivePose` returned `null`.\n *\n * A dependency is read through {@link effectivePose}, so a group of groups\n * resolves bottom-up and a dragged dependency's override reaches the\n * derivation the same frame it is published.\n */\nexport function derivedPose<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n): TPose | null {\n  return derivedPoseIn(source, node, 'effective');\n}\n\nfunction derivedPoseIn<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n  reading: Reading,\n): TPose | null {\n  const derive = node.derivePose;\n  if (derive === undefined) return null;\n  const ids = dependencyIdsOf(node, source.childrenOf);\n  if (ids.length === 0) return null;\n  if (resolving.has(node.id)) {\n    cycleHits++;\n    return null;\n  }\n  resolving.add(node.id);\n  const hitsBefore = cycleHits;\n  try {\n    const depOf = (id: NodeId) => depIn(source, id, reading);\n    // Keyed on the authored pose, which is what `dropPoseKeyedMemoSlots`\n    // clears. That key only sees a change someone pushed, so the record also\n    // carries what the derivation read and re-checks it by value on a hit —\n    // see `depMemo.ts`.\n    let computed = false;\n    const record = nodeMemo<PoseMemo<TPose>>(node, POSE_SLOT[reading], node.pose, () => {\n      computed = true;\n      return run(node, derive, ids.map(depOf), { nodes: [], poses: [], value: null });\n    });\n    // Mutating the record in place is what updates the memo slot, which holds\n    // this object.\n    if (!computed && !sameDeps(record, ids, depOf)) {\n      run(node, derive, ids.map(depOf), record);\n    }\n    if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);\n    return record.value;\n  } finally {\n    resolving.delete(node.id);\n  }\n}\n\n/** Run `derivePose` against `deps` and record what it was run against. */\nfunction run<TPose>(\n  node: PosedNode<TPose>,\n  derive: NonNullable<PosedNode<TPose>['derivePose']>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  into: PoseMemo<TPose>,\n): PoseMemo<TPose> {\n  into.value = derive(node as never, deps);\n  recordDeps(into, deps);\n  return into;\n}\n\n/**\n * `id` as a derivation sees it: the node, the pose it is painted at, and the\n * path it derives.\n *\n * The pose is resolved eagerly — every derivation reads it — and the path\n * lazily, because most do not and resolving a route costs a router run. Both\n * resolve *through* this function, so a dependency that is itself derived is\n * resolved before it is read.\n */\nexport function derivedDepOf<TPose>(\n  source: PoseSource<TPose>,\n  id: NodeId,\n): DerivedDep<TPose> | undefined {\n  return depIn(source, id, 'effective');\n}\n\nfunction depIn<TPose>(\n  source: PoseSource<TPose>,\n  id: NodeId,\n  reading: Reading,\n): DerivedDep<TPose> | undefined {\n  const node = source.get(id);\n  if (node === undefined) return undefined;\n  return new SceneDep(source, node, reading);\n}\n\n/**\n * A class rather than an object literal with a `get path()`: one of these is\n * built per dependency per derived node per frame, and an own accessor costs\n * an order of magnitude more to define than a prototype one does to inherit.\n */\nclass SceneDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly source: PoseSource<TPose>,\n    private readonly posed: PosedNode<TPose>,\n    private readonly reading: Reading,\n  ) {\n    this.node = posed as unknown as Node<unknown, string, TPose>;\n    this.pose = poseIn(source, posed, reading);\n  }\n\n  get path(): Path | null {\n    const { source, reading } = this;\n    return resolveDerivedPath(\n      this.posed,\n      (depId) => depIn(source, depId, reading),\n      (depId) => source.childrenOf(depId),\n      PATH_SLOT[reading],\n    );\n  }\n}\n\nfunction poseIn<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n  reading: Reading,\n): TPose {\n  if (reading === 'effective') {\n    const override = source.overrides.read(node.id)?.pose;\n    if (override !== undefined) return override;\n  }\n  return derivedPoseIn(source, node, reading) ?? node.pose;\n}\n\n/**\n * The pose the *document* says `node` is at: derived when it derives, else\n * authored. `effectivePose` minus the override step, at every link of the\n * dependency chain — a derived node's document pose holds still while\n * something it derives from is being dragged.\n *\n * For a reader that must not see an in-flight gesture — an action capturing\n * the `from` of a transform op, a placement computed against a sibling, the\n * minimap's framing. A derived pose belongs here and an override does not:\n * derivation is what the document means, an override is what one gesture is\n * currently showing.\n */\nexport function documentPose<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n): TPose {\n  return poseIn(source, node, 'document');\n}\n\n/**\n * The pose to draw, pick and measure `node` at.\n *\n * The one rule. Every pose a reader acts on comes from here: the three render\n * walks, the pick walk, the adapters tools and actions commit through.\n */\nexport function effectivePose<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n): TPose {\n  return poseIn(source, node, 'effective');\n}\n\n/**\n * Whether `node`'s pose is a frame its children are expressed in, under a\n * composing strategy.\n *\n * A container that derives its pose from its children cannot be one: moving\n * the frame to cover the children would move the children, and a `RectPose`\n * frame's origin is its corner, so no envelope leaves them in place. Such a\n * container is an envelope instead — its children are stored in its own\n * frame — and the composition fold passes over it.\n */\nexport function definesFrame(node: { dependsOn?: unknown; derivePose?: unknown }): boolean {\n  return !(node.dependsOn === 'children' && node.derivePose !== undefined);\n}\n"],"mappings":";;;;;AAwBA,IAAMA,IAAqC;CACzC,WAAW;CACX,UAAU;AACZ,GACMC,IAAiD;CACrD,WAAW,KAAA;CACX,UAAU;AACZ,GAgCMC,oBAAY,IAAI,IAAY,GAK9BC,IAAY;AAWhB,SAAgBC,EACd,GACA,GACc;CACd,OAAOC,EAAcC,GAAQC,GAAM,WAAW;AAChD;AAEA,SAASF,EACP,GACA,GACA,GACc;CACd,IAAMG,IAASD,EAAK;CACpB,IAAIC,MAAW,KAAA,GAAW,OAAO;CACjC,IAAMC,IAAMC,EAAgBH,GAAMD,EAAO,UAAU;CACnD,IAAIG,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIP,EAAU,IAAIK,EAAK,EAAE,GAEvB,OADA,KACO;CAET,EAAU,IAAIA,EAAK,EAAE;CACrB,IAAMI,IAAaR;CACnB,IAAI;EACF,IAAMS,KAAS,MAAeC,EAAMP,GAAQQ,GAAIC,CAAO,GAKnDC,IAAW,IACTC,IAASC,EAA0BX,GAAMP,EAAUe,IAAUR,EAAK,aACtE,IAAW,IACJY,EAAIZ,GAAMC,GAAQC,EAAI,IAAIG,CAAK,GAAG;GAAE,OAAO,CAAC;GAAG,OAAO,CAAC;GAAG,OAAO;EAAK,CAAC,EAC/E;EAOD,OAJI,CAACI,KAAY,CAACI,EAASH,GAAQR,GAAKG,CAAK,KAC3CO,EAAIZ,GAAMC,GAAQC,EAAI,IAAIG,CAAK,GAAGK,CAAM,GAEtCd,MAAcQ,KAAYU,EAAuBd,CAAI,GAClDU,EAAO;CAChB,UAAU;EACR,EAAU,OAAOV,EAAK,EAAE;CAC1B;AACF;AAGA,SAASY,EACP,GACA,GACA,GACA,GACiB;CAGjB,OAFA,EAAK,QAAQX,EAAOD,GAAee,CAAI,GACvCC,EAAWC,GAAMF,CAAI,GACdE;AACT;AAWA,SAAgBC,EACd,GACA,GAC+B;CAC/B,OAAOZ,EAAMP,GAAQQ,GAAI,WAAW;AACtC;AAEA,SAASD,EACP,GACA,GACA,GAC+B;CAC/B,IAAMN,IAAOD,EAAO,IAAIQ,CAAE;CAC1B,IAAIP,MAAS,KAAA,GACb,OAAO,IAAImB,EAASpB,GAAQC,GAAMQ,CAAO;AAC3C;AAOA,IAAMW,IAAN,MAAmD;CAK9B;CACA;CACA;CANnB;CACA;CAEA,YACE,GACA,GACA,GACA;EAEA,AALiB,KAAA,SAAApB,GACA,KAAA,QAAAqB,GACA,KAAA,UAAAZ,GAEjB,KAAK,OAAOY,GACZ,KAAK,OAAOC,EAAOtB,GAAQqB,GAAOZ,CAAO;CAC3C;CAEA,IAAI,OAAoB;EACtB,IAAM,EAAE,WAAQ,eAAY;EAC5B,OAAOc,EACL,KAAK,QACJ,MAAUhB,EAAMP,GAAQwB,GAAOf,CAAO,IACtC,MAAUT,EAAO,WAAWwB,CAAK,GAClC7B,EAAUc,EACZ;CACF;AACF;AAEA,SAASa,EACP,GACA,GACA,GACO;CACP,IAAIb,MAAY,aAAa;EAC3B,IAAMgB,IAAWzB,EAAO,UAAU,KAAKC,EAAK,EAAE,CAAC,EAAE;EACjD,IAAIwB,MAAa,KAAA,GAAW,OAAOA;CACrC;CACA,OAAO1B,EAAcC,GAAQC,GAAMQ,CAAO,KAAKR,EAAK;AACtD;AAcA,SAAgByB,EACd,GACA,GACO;CACP,OAAOJ,EAAOtB,GAAQC,GAAM,UAAU;AACxC;AAQA,SAAgB0B,EACd,GACA,GACO;CACP,OAAOL,EAAOtB,GAAQC,GAAM,WAAW;AACzC;AAYA,SAAgB2B,EAAa,GAA8D;CACzF,OAAS3B,EAAK,cAAc,cAAcA,EAAK,eAAe,KAAA;AAChE"}
+{"version":3,"file":"effectivePose.js","names":["POSE_SLOT","PATH_SLOT","resolving","cycleHits","derivedPose","derivedPoseIn","source","node","derive","ids","dependencyIdsOf","hitsBefore","depOf","depIn","id","reading","computed","record","nodeMemo","run","emptyDepRecord","sameDeps","dropPoseKeyedMemoSlots","deriveRecorded","into","deps","handed","derivedDepOf","SceneDep","posed","poseIn","resolveDerivedPath","depId","override","documentPose","effectivePose","definesFrame"],"sources":["../../../src/core/scene/effectivePose.ts"],"sourcesContent":["/**\n * `effectivePose` — the pose to draw, pick and measure a node at.\n *\n * Three answers, in order: the ephemeral override a gesture published, the\n * pose the node derives from its dependencies, or the pose the document\n * stores. A reader of `node.pose` disagrees with the render about where a\n * dragged or derived node is.\n */\nimport { deriveRecorded, emptyDepRecord, sameDeps, type DepRecord } from './depMemo';\nimport { dependencyIdsOf } from './dependents';\nimport { resolveDerivedPath } from './derivedPath';\nimport { dropPoseKeyedMemoSlots, nodeMemo } from './nodeMemo';\nimport type { Path } from '@weasel-js/geom';\nimport type { DerivedDep, DerivePathFn, DerivePoseFn, Node, NodeId, PoseOverrides } from './types';\n\n/**\n * Which pose a resolution answers: `effective` honors overrides all the way\n * down the dependency chain, `document` ignores them all the way down. Each\n * reading memoizes in its own slots — the memo key is the node and its\n * authored pose, which is the same for both.\n */\ntype Reading = 'effective' | 'document';\n\nconst POSE_SLOT: Record<Reading, string> = {\n  effective: 'kit:derivedPose',\n  document: 'kit:derivedPose:document',\n};\nconst PATH_SLOT: Record<Reading, string | undefined> = {\n  effective: undefined,\n  document: 'kit:derivedPath:document',\n};\n\n/** The subset of a node this module reads. Structural so a `Node` satisfies\n *  it without importing the full generic shape. */\nexport interface PosedNode<TPose> {\n  id: NodeId;\n  kind?: 'leaf' | 'container';\n  pose: TPose;\n  /** Read only by the memo, which keys on its reference alongside the pose. */\n  data?: unknown;\n  dependsOn?: readonly NodeId[] | 'children';\n  derivePose?: DerivePoseFn<TPose>;\n  /** Read only when something asks a dependency for its `path`. */\n  derivePath?: DerivePathFn<TPose>;\n}\n\n/** What resolving a pose needs: the overrides, and enough of the scene to\n *  reach a node's dependencies. A `Scene` satisfies it. */\nexport interface PoseSource<TPose> {\n  readonly overrides: Pick<PoseOverrides<TPose>, 'read'>;\n  get(id: NodeId): PosedNode<TPose> | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n}\n\n/** A cached derived pose, with what it was derived from. */\ninterface PoseMemo<TPose> extends DepRecord<TPose> {\n  value: TPose | null;\n}\n\n/** Ids whose derivation is on the stack. A dependency graph is meant to be\n *  acyclic and `dependsOn` is unvalidated, so a cycle resolves to the authored\n *  pose at whichever node closes it rather than overflowing the stack. */\nconst resolving = new Set<NodeId>();\n\n/** Bumped each time the guard above fires. A derivation that closed a cycle\n *  answered from a fallback rather than from its dependencies, so its value is\n *  an artifact of which node was asked first and must not be cached. */\nlet cycleHits = 0;\n\n/**\n * The pose `node` computes from its dependencies, or `null` when it derives\n * nothing — it has no `derivePose`, nothing to derive from, or its\n * `derivePose` returned `null`.\n *\n * A dependency is read through {@link effectivePose}, so a group of groups\n * resolves bottom-up and a dragged dependency's override reaches the\n * derivation the same frame it is published.\n */\nexport function derivedPose<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n): TPose | null {\n  return derivedPoseIn(source, node, 'effective');\n}\n\nfunction derivedPoseIn<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n  reading: Reading,\n): TPose | null {\n  const derive = node.derivePose;\n  if (derive === undefined) return null;\n  const ids = dependencyIdsOf(node, source.childrenOf);\n  if (ids.length === 0) return null;\n  if (resolving.has(node.id)) {\n    cycleHits++;\n    return null;\n  }\n  resolving.add(node.id);\n  const hitsBefore = cycleHits;\n  try {\n    const depOf = (id: NodeId) => depIn(source, id, reading);\n    // Keyed on the authored pose, which only sees a change someone pushed, so\n    // the record also carries what the derivation read and re-checks it by\n    // value on a hit — see `depMemo.ts`.\n    let computed = false;\n    const record = nodeMemo<PoseMemo<TPose>>(node, POSE_SLOT[reading], node.pose, () => {\n      computed = true;\n      return run(node, derive, ids.map(depOf), { ...emptyDepRecord<TPose>(), value: null });\n    });\n    // Mutating the record in place is what updates the memo slot, which holds\n    // this object.\n    if (!computed && !sameDeps(record, ids, depOf)) {\n      run(node, derive, ids.map(depOf), record);\n    }\n    if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);\n    return record.value;\n  } finally {\n    resolving.delete(node.id);\n  }\n}\n\n/** Run `derivePose` against `deps` and record what it was run against. */\nfunction run<TPose>(\n  node: PosedNode<TPose>,\n  derive: NonNullable<PosedNode<TPose>['derivePose']>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  into: PoseMemo<TPose>,\n): PoseMemo<TPose> {\n  into.value = deriveRecorded(into, deps, (handed) => derive(node as never, handed));\n  return into;\n}\n\n/**\n * `id` as a derivation sees it: the node, the pose it is painted at, and the\n * path it derives.\n *\n * The pose is resolved eagerly — every derivation reads it — and the path\n * lazily, because most do not and resolving a route costs a router run. Both\n * resolve *through* this function, so a dependency that is itself derived is\n * resolved before it is read.\n */\nexport function derivedDepOf<TPose>(\n  source: PoseSource<TPose>,\n  id: NodeId,\n): DerivedDep<TPose> | undefined {\n  return depIn(source, id, 'effective');\n}\n\nfunction depIn<TPose>(\n  source: PoseSource<TPose>,\n  id: NodeId,\n  reading: Reading,\n): DerivedDep<TPose> | undefined {\n  const node = source.get(id);\n  if (node === undefined) return undefined;\n  return new SceneDep(source, node, reading);\n}\n\n/**\n * A class rather than an object literal with a `get path()`: one of these is\n * built per dependency per derived node per frame, and an own accessor costs\n * an order of magnitude more to define than a prototype one does to inherit.\n */\nclass SceneDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly source: PoseSource<TPose>,\n    private readonly posed: PosedNode<TPose>,\n    private readonly reading: Reading,\n  ) {\n    this.node = posed as unknown as Node<unknown, string, TPose>;\n    this.pose = poseIn(source, posed, reading);\n  }\n\n  get path(): Path | null {\n    const { source, reading } = this;\n    return resolveDerivedPath(\n      this.posed,\n      (depId) => depIn(source, depId, reading),\n      (depId) => source.childrenOf(depId),\n      PATH_SLOT[reading],\n    );\n  }\n}\n\nfunction poseIn<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n  reading: Reading,\n): TPose {\n  if (reading === 'effective') {\n    const override = source.overrides.read(node.id)?.pose;\n    if (override !== undefined) return override;\n  }\n  return derivedPoseIn(source, node, reading) ?? node.pose;\n}\n\n/**\n * The pose the *document* says `node` is at: derived when it derives, else\n * authored. `effectivePose` minus the override step, at every link of the\n * dependency chain — a derived node's document pose holds still while\n * something it derives from is being dragged.\n *\n * For a reader that must not see an in-flight gesture, such as an action\n * capturing the `from` of a transform op.\n */\nexport function documentPose<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n): TPose {\n  return poseIn(source, node, 'document');\n}\n\n/**\n * The pose to draw, pick and measure `node` at. Every pose a reader acts on\n * comes from here.\n */\nexport function effectivePose<TPose>(\n  source: PoseSource<TPose>,\n  node: PosedNode<TPose>,\n): TPose {\n  return poseIn(source, node, 'effective');\n}\n\n/**\n * Whether `node`'s pose is a frame its children are expressed in, under a\n * composing strategy.\n *\n * A container that derives its pose from its children cannot be one: moving\n * the frame to cover the children would move the children, and a `RectPose`\n * frame's origin is its corner, so no envelope leaves them in place. Such a\n * container is an envelope instead — its children are stored in its own\n * frame — and the composition fold passes over it.\n */\nexport function definesFrame(node: { dependsOn?: unknown; derivePose?: unknown }): boolean {\n  return !(node.dependsOn === 'children' && node.derivePose !== undefined);\n}\n"],"mappings":";;;;;AAuBA,IAAMA,IAAqC;CACzC,WAAW;CACX,UAAU;AACZ,GACMC,IAAiD;CACrD,WAAW,KAAA;CACX,UAAU;AACZ,GAgCMC,oBAAY,IAAI,IAAY,GAK9BC,IAAY;AAWhB,SAAgBC,EACd,GACA,GACc;CACd,OAAOC,EAAcC,GAAQC,GAAM,WAAW;AAChD;AAEA,SAASF,EACP,GACA,GACA,GACc;CACd,IAAMG,IAASD,EAAK;CACpB,IAAIC,MAAW,KAAA,GAAW,OAAO;CACjC,IAAMC,IAAMC,EAAgBH,GAAMD,EAAO,UAAU;CACnD,IAAIG,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIP,EAAU,IAAIK,EAAK,EAAE,GAEvB,OADA,KACO;CAET,EAAU,IAAIA,EAAK,EAAE;CACrB,IAAMI,IAAaR;CACnB,IAAI;EACF,IAAMS,KAAS,MAAeC,EAAMP,GAAQQ,GAAIC,CAAO,GAInDC,IAAW,IACTC,IAASC,EAA0BX,GAAMP,EAAUe,IAAUR,EAAK,aACtE,IAAW,IACJY,EAAIZ,GAAMC,GAAQC,EAAI,IAAIG,CAAK,GAAG;GAAE,GAAGQ,EAAsB;GAAG,OAAO;EAAK,CAAC,EACrF;EAOD,OAJI,CAACJ,KAAY,CAACK,EAASJ,GAAQR,GAAKG,CAAK,KAC3CO,EAAIZ,GAAMC,GAAQC,EAAI,IAAIG,CAAK,GAAGK,CAAM,GAEtCd,MAAcQ,KAAYW,EAAuBf,CAAI,GAClDU,EAAO;CAChB,UAAU;EACR,EAAU,OAAOV,EAAK,EAAE;CAC1B;AACF;AAGA,SAASY,EACP,GACA,GACA,GACA,GACiB;CAEjB,OADA,EAAK,QAAQI,EAAeC,GAAMC,IAAO,MAAWjB,EAAOD,GAAemB,CAAM,CAAC,GAC1EF;AACT;AAWA,SAAgBG,EACd,GACA,GAC+B;CAC/B,OAAOd,EAAMP,GAAQQ,GAAI,WAAW;AACtC;AAEA,SAASD,EACP,GACA,GACA,GAC+B;CAC/B,IAAMN,IAAOD,EAAO,IAAIQ,CAAE;CAC1B,IAAIP,MAAS,KAAA,GACb,OAAO,IAAIqB,EAAStB,GAAQC,GAAMQ,CAAO;AAC3C;AAOA,IAAMa,IAAN,MAAmD;CAK9B;CACA;CACA;CANnB;CACA;CAEA,YACE,GACA,GACA,GACA;EAEA,AALiB,KAAA,SAAAtB,GACA,KAAA,QAAAuB,GACA,KAAA,UAAAd,GAEjB,KAAK,OAAOc,GACZ,KAAK,OAAOC,EAAOxB,GAAQuB,GAAOd,CAAO;CAC3C;CAEA,IAAI,OAAoB;EACtB,IAAM,EAAE,WAAQ,eAAY;EAC5B,OAAOgB,EACL,KAAK,QACJ,MAAUlB,EAAMP,GAAQ0B,GAAOjB,CAAO,IACtC,MAAUT,EAAO,WAAW0B,CAAK,GAClC/B,EAAUc,EACZ;CACF;AACF;AAEA,SAASe,EACP,GACA,GACA,GACO;CACP,IAAIf,MAAY,aAAa;EAC3B,IAAMkB,IAAW3B,EAAO,UAAU,KAAKC,EAAK,EAAE,CAAC,EAAE;EACjD,IAAI0B,MAAa,KAAA,GAAW,OAAOA;CACrC;CACA,OAAO5B,EAAcC,GAAQC,GAAMQ,CAAO,KAAKR,EAAK;AACtD;AAWA,SAAgB2B,EACd,GACA,GACO;CACP,OAAOJ,EAAOxB,GAAQC,GAAM,UAAU;AACxC;AAMA,SAAgB4B,EACd,GACA,GACO;CACP,OAAOL,EAAOxB,GAAQC,GAAM,WAAW;AACzC;AAYA,SAAgB6B,EAAa,GAA8D;CACzF,OAAS7B,EAAK,cAAc,cAAcA,EAAK,eAAe,KAAA;AAChE"}

package/dist/core/scene/fieldEdits.js

@@ -0,0 +1,98 @@
+import { sameDependsOn as e } from "./dependents.js";
+import { resized as t } from "./layoutPass.js";
+//#region src/core/scene/fieldEdits.ts
+function n(n) {
+	let { layoutFrame: r, layoutField: i, layoutRefs: a } = n, { requireNode: o, descendants: s } = n.store, { refuse: c, refuseLayer: l } = n.locks, { requireLayerIndex: u, assertSubtreeLayer: d } = n.layers, { record: f, edit: p, batch: m } = n.recorder, { noteChange: h, layoutDeclared: g } = n.arrivals;
+	return {
+		update(e, t) {
+			let n = o(e);
+			c(e, "update"), f("kit:setData", {
+				id: e,
+				from: n.data,
+				to: t.data
+			}, "update");
+		},
+		setPose(e, n) {
+			let i = o(e);
+			c(e, "set the pose of");
+			let a = i.kind === "container" && t(r, e, i.pose, n);
+			p("setPose", a, () => {
+				a && h(e), f("kit:setPose", {
+					id: e,
+					from: i.pose,
+					to: n
+				}, "setPose");
+			});
+		},
+		setLayer(e, t) {
+			u(t);
+			let n = o(e);
+			if (c(e, "relayer"), n.layer !== t && l(t, "move nodes onto"), n.parent !== null) {
+				let r = o(n.parent);
+				d(e, t, n.parent, r.layer, "relayer");
+			}
+			if (n.layer === t) return;
+			let r = [e];
+			s(e, r);
+			for (let e of r) c(e, "relayer");
+			r.length === 1 ? f("kit:setLayer", {
+				id: e,
+				from: n.layer,
+				to: t
+			}, "setLayer") : m("setLayer", () => {
+				for (let e of r) {
+					let n = o(e);
+					n.layer !== t && f("kit:setLayer", {
+						id: e,
+						from: n.layer,
+						to: t
+					}, "setLayer");
+				}
+			});
+		},
+		setDependsOn(t, n) {
+			let r = o(t);
+			c(t, "retarget"), !e(r.dependsOn, n) && f("kit:setDependsOn", {
+				id: t,
+				from: r.dependsOn,
+				to: n
+			}, "setDependsOn");
+		},
+		setLayout(e, t) {
+			let n = o(e);
+			if (n.kind !== "container") throw Error(`Scene: "${e}" is not a container`);
+			c(e, "set the layout of");
+			let r;
+			if (typeof t == "string") {
+				if (r = i.fnOf(t) ?? null, r === null) throw Error(`Scene: no layout "${t}" in this scene's registry`);
+			} else r = t;
+			let s = n.layout ?? null;
+			if (s === r) return;
+			r !== null && g();
+			let l = s === null ? void 0 : i.keyOf(s), u = r === null ? void 0 : i.keyOf(r), d = {
+				id: e,
+				...l === void 0 ? {} : { fromKey: l },
+				...u === void 0 ? {} : { toKey: u }
+			};
+			a.set(d, {
+				from: s,
+				to: r
+			}), p("setLayout", !0, () => {
+				h(e), f("kit:setLayout", d, "setLayout");
+			});
+		},
+		setUnits(e, t) {
+			let n = o(e);
+			if (n.kind !== "container") throw Error(`Scene: "${e}" is not a container`);
+			c(e, "set the units of"), f("kit:setUnits", {
+				id: e,
+				from: n.units,
+				to: t ?? void 0
+			}, "setUnits");
+		}
+	};
+}
+//#endregion
+export { n as createFieldEdits };
+
+//# sourceMappingURL=fieldEdits.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fieldEdits.js","names":["createFieldEdits","env","node","requireNode","id","refuse","record","patch","resizes","resized","layoutFrame","pose","noteChange","layer","refuseLayer","parentNode","subtree","sid","batch","cur","dependsOn","to","layout","layoutField","from","layoutDeclared","fromKey","toKey","payload","layoutRefs","edit","units"],"sources":["../../../src/core/scene/fieldEdits.ts"],"sourcesContent":["/**\n * The scene's edits to one node's fields: its data, pose, layer, dependency\n * list, layout, and unit scope. Each checks its arguments, then records.\n */\nimport type { LayoutStrategy } from '../../layout/types';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { sameDependsOn } from './dependents';\nimport type { SetLayoutPayload } from './kitOps';\nimport type { createLayerStack } from './layerStack';\nimport { resized, type ResolvedLayoutFrame } from './layoutPass';\nimport type { LockGuard } from './lockGuard';\nimport type { NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type { Recorder } from './recorder';\nimport type { NodeId, Scene } from './types';\n\nexport interface FieldEditsEnv<TData, TLayer extends string, TPose> {\n  store: Pick<ReturnType<typeof createNodeStore<TData, TLayer, TPose>>, 'requireNode' | 'descendants'>;\n  locks: Pick<LockGuard<TLayer>, 'refuse' | 'refuseLayer'>;\n  layers: Pick<ReturnType<typeof createLayerStack<TLayer>>, 'requireLayerIndex' | 'assertSubtreeLayer'>;\n  recorder: Pick<Recorder, 'record' | 'edit' | 'batch'>;\n  arrivals: Pick<ArrivalWindow<TPose>, 'noteChange' | 'layoutDeclared'>;\n  layoutFrame: ResolvedLayoutFrame<TPose>;\n  /** The registry's layouts, by key and back. */\n  layoutField: NodeFnField;\n  /** Where a live `kit:setLayout` payload's strategies are kept. */\n  layoutRefs: WeakMap<object, { from: LayoutStrategy<TPose> | null; to: LayoutStrategy<TPose> | null }>;\n}\n\nexport type FieldEdits<TData, TLayer extends string, TPose> = Pick<\n  Scene<TData, TLayer, TPose>,\n  'update' | 'setPose' | 'setLayer' | 'setDependsOn' | 'setLayout' | 'setUnits'\n>;\n\nexport function createFieldEdits<TData, TLayer extends string, TPose>(\n  env: FieldEditsEnv<TData, TLayer, TPose>,\n): FieldEdits<TData, TLayer, TPose> {\n  const { layoutFrame, layoutField, layoutRefs } = env;\n  const { requireNode, descendants } = env.store;\n  const { refuse, refuseLayer } = env.locks;\n  const { requireLayerIndex, assertSubtreeLayer } = env.layers;\n  const { record, edit, batch } = env.recorder;\n  const { noteChange, layoutDeclared } = env.arrivals;\n\n  return {\n    update(id, patch) {\n      const node = requireNode(id);\n      refuse(id, 'update');\n      record('kit:setData', { id, from: node.data, to: patch.data }, 'update');\n    },\n\n    setPose(id, pose) {\n      const node = requireNode(id);\n      refuse(id, 'set the pose of');\n      const resizes = node.kind === 'container' && resized(layoutFrame, id, node.pose, pose);\n      edit('setPose', resizes, () => {\n        if (resizes) noteChange(id);\n        record('kit:setPose', { id, from: node.pose, to: pose }, 'setPose');\n      });\n    },\n\n    setLayer(id, layer) {\n      requireLayerIndex(layer);\n      const node = requireNode(id);\n      refuse(id, 'relayer');\n      if (node.layer !== layer) refuseLayer(layer, 'move nodes onto');\n      if (node.parent !== null) {\n        const parentNode = requireNode(node.parent);\n        assertSubtreeLayer(id, layer, node.parent, parentNode.layer, 'relayer');\n      }\n      if (node.layer === layer) return;\n      const subtree: NodeId[] = [id];\n      descendants(id, subtree);\n      for (const sid of subtree) refuse(sid, 'relayer');\n      if (subtree.length === 1) {\n        record('kit:setLayer', { id, from: node.layer, to: layer }, 'setLayer');\n      } else {\n        batch('setLayer', () => {\n          for (const sid of subtree) {\n            const cur = requireNode(sid);\n            if (cur.layer === layer) continue;\n            record('kit:setLayer', { id: sid, from: cur.layer, to: layer }, 'setLayer');\n          }\n        });\n      }\n    },\n\n    setDependsOn(id, dependsOn) {\n      const node = requireNode(id);\n      refuse(id, 'retarget');\n      if (sameDependsOn(node.dependsOn, dependsOn)) return;\n      record('kit:setDependsOn', { id, from: node.dependsOn, to: dependsOn }, 'setDependsOn');\n    },\n\n    setLayout(id, layout) {\n      const node = requireNode(id);\n      if (node.kind !== 'container') throw new Error(`Scene: \"${id}\" is not a container`);\n      refuse(id, 'set the layout of');\n      let to: LayoutStrategy<TPose> | null;\n      if (typeof layout === 'string') {\n        to = (layoutField.fnOf(layout) as LayoutStrategy<TPose> | undefined) ?? null;\n        if (to === null) throw new Error(`Scene: no layout \"${layout}\" in this scene's registry`);\n      } else {\n        to = layout;\n      }\n      const from = node.layout ?? null;\n      if (from === to) return;\n      if (to !== null) layoutDeclared();\n      const fromKey = from === null ? undefined : layoutField.keyOf(from);\n      const toKey = to === null ? undefined : layoutField.keyOf(to);\n      const payload: SetLayoutPayload = {\n        id,\n        ...(fromKey !== undefined ? { fromKey } : {}),\n        ...(toKey !== undefined ? { toKey } : {}),\n      };\n      layoutRefs.set(payload, { from, to });\n      edit('setLayout', true, () => {\n        noteChange(id);\n        record('kit:setLayout', payload, 'setLayout');\n      });\n    },\n\n    setUnits(id, units) {\n      const node = requireNode(id);\n      if (node.kind !== 'container') throw new Error(`Scene: \"${id}\" is not a container`);\n      refuse(id, 'set the units of');\n      record('kit:setUnits', { id, from: node.units, to: units ?? undefined }, 'setUnits');\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/historyFacade.js

@@ -0,0 +1,130 @@
+import { dwarn as e } from "../../debug/flag.js";
+import { SCENE_HISTORY_FORM as t } from "./historyForm.js";
+//#region src/core/scene/historyFacade.ts
+function n(e, t) {
+	let { replay: n, notify: r } = t;
+	return {
+		targetId: e.targetId,
+		forkedAtEntryId: e.forkedAtEntryId,
+		applyBatch(n, i) {
+			t.runArrivalEdit(n, (n) => {
+				t.applying(() => e.applyBatch(n.map(t.causing), i)), r();
+			});
+		},
+		undo() {
+			n(() => e.undo()), r();
+		},
+		redo() {
+			n(() => e.redo()), r();
+		},
+		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), r();
+		},
+		cancel() {
+			n(() => e.cancel()), r();
+		},
+		suspend: () => e.suspend(),
+		isActive: () => e.isActive()
+	};
+}
+function r(r) {
+	let { engine: i, replay: a, notify: o, refuseUntracked: s, runArrivalEdit: c } = r, l = /* @__PURE__ */ new WeakMap();
+	function u(e, t) {
+		return e() ? (a(t), o(), !0) : !1;
+	}
+	let d = {
+		undo: () => u(() => i.canUndo(), () => i.undo()),
+		redo: () => u(() => i.canRedo(), () => i.redo()),
+		canUndo: () => i.canUndo(),
+		canRedo: () => i.canRedo(),
+		historyEntries() {
+			let { undo: e, redo: t } = i.entries();
+			return [...e, ...t].map((e) => ({
+				id: String(e.id),
+				label: e.label
+			}));
+		},
+		historyIndex: () => i.undoDepth(),
+		jumpToHistoryIndex(e) {
+			let t = i.undoDepth() + i.redoDepth(), n = Math.max(0, Math.min(t, e));
+			return u(() => n !== i.undoDepth(), () => i.goto(n));
+		},
+		serializeHistory: () => ({
+			...i.serialize(),
+			form: t
+		}),
+		restoreHistory(n) {
+			if (n.form !== t) {
+				e("scene", "restoreHistory: snapshot is not in the current recorded form — dropped");
+				return;
+			}
+			i.restore(n), o();
+		}
+	};
+	return {
+		history: {
+			apply(e, t) {
+				s("history.apply"), c([e], (n) => {
+					r.applying(() => n.length === 1 ? i.apply(r.causing(e), t) : i.applyOps(n.map(r.causing), t ?? e.label ?? "")), o();
+				});
+			},
+			applyOps(e, t) {
+				s("history.applyOps"), c(e, (e) => {
+					r.applying(() => i.applyOps(e.map(r.causing), t)), o();
+				});
+			},
+			undo: () => {
+				d.undo();
+			},
+			redo: () => {
+				d.redo();
+			},
+			goto: (e) => {
+				d.jumpToHistoryIndex(e);
+			},
+			clear() {
+				i.clear(), o();
+			},
+			recordEntry(e, t, n) {
+				i.recordEntry(e, t, n), o();
+			},
+			prune(e) {
+				i.prune(e), o();
+			},
+			switchBranch(e) {
+				i.switchBranch(e), o();
+			},
+			restore: d.restoreHistory,
+			canUndo: d.canUndo,
+			canRedo: d.canRedo,
+			undoDepth: () => i.undoDepth(),
+			redoDepth: () => i.redoDepth(),
+			entries: () => i.entries(),
+			timestampAt: (e) => i.timestampAt(e),
+			depthAt: (e) => i.depthAt(e),
+			branches: () => i.branches(),
+			getVersion: () => i.getVersion(),
+			subscribe: (e) => i.subscribe(e),
+			serialize: d.serializeHistory,
+			allForwardOps: () => i.allForwardOps(),
+			seal: () => i.seal(),
+			currentEntryId: () => i.currentEntryId(),
+			beginJournal(e) {
+				let t = i.beginJournal(e), a = n(t, r);
+				return l.set(a, t), a;
+			},
+			resumeJournal: (e) => i.resumeJournal(l.get(e) ?? e)
+		},
+		methods: d
+	};
+}
+//#endregion
+export { r as createSceneHistory };
+
+//# sourceMappingURL=historyFacade.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"historyFacade.js","names":["wrapJournal","env","raw","ops","all","label","notify","replay","listener","createSceneHistory","rawJournals","step","can","run","methods","engine","undo","redo","total","target","index","SCENE_HISTORY_FORM","snapshot","refuseUntracked","runArrivalEdit","op","n","opts","t","id","i","wrapped","journal"],"sources":["../../../src/core/scene/historyFacade.ts"],"sourcesContent":["/**\n * `scene.history`: the `History` the kit's `undo`/`redo` actions resolve\n * their `history` dep to, and the handle a mode machine opens journals\n * against.\n *\n * Handing out the engine directly would let an action-driven undo replay ops\n * with scene-side recording still armed and without bumping the scene's\n * version, so every member that mutates routes through the scene's own\n * wrappers and one `notify()`; reads forward to the engine.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { dwarn } from 'debug/flag';\nimport { SCENE_HISTORY_FORM, type SerializedSceneHistory } from './historyForm';\nimport type { Scene } from './types';\n\n/** What the facade needs from the scene it fronts. */\nexport interface SceneHistoryEnv {\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Run a step that applies ops through an engine: all-or-nothing, with\n   *  scene-side recording suppressed. */\n  applying(step: () => void): void;\n  /** An op as the engine applies it: its entry records the kit ops it\n   *  caused. */\n  causing(op: Op): Op;\n  /** Run a step that replays recorded ops: an undo, a redo, a cancel. */\n  replay(step: () => void): void;\n  notify(): void;\n  refuseUntracked(verb: string): void;\n  /** Run an op-driven edit with its arrivals settled into the same batch. */\n  runArrivalEdit(ops: Op[], run: (ops: Op[]) => void): void;\n}\n\n/** The scene's own spellings of its history, which answer what a caller\n *  outside the engine's vocabulary asks: whether a step moved anything. */\nexport type SceneHistoryMethods = Pick<\n  Scene<unknown, string, unknown>,\n  | 'undo' | 'redo' | 'canUndo' | 'canRedo' | 'historyEntries' | 'historyIndex'\n  | 'jumpToHistoryIndex' | 'serializeHistory' | 'restoreHistory'\n>;\n\n/** A journal drives adapter mutation itself, so its applies and undos\n *  re-enter scene mutation methods the way the facade's do. */\nfunction wrapJournal(raw: Journal, env: SceneHistoryEnv): Journal {\n  const { replay, notify } = env;\n  return {\n    targetId: raw.targetId,\n    forkedAtEntryId: raw.forkedAtEntryId,\n    applyBatch(ops, label) {\n      env.runArrivalEdit(ops, (all) => {\n        env.applying(() => raw.applyBatch(all.map(env.causing), label));\n        notify();\n      });\n    },\n    undo() {\n      replay(() => raw.undo());\n      notify();\n    },\n    redo() {\n      replay(() => raw.redo());\n      notify();\n    },\n    canUndo: () => raw.canUndo(),\n    canRedo: () => raw.canRedo(),\n    entries: () => raw.entries(),\n    seal: () => raw.seal(),\n    getVersion: () => raw.getVersion(),\n    subscribe: (listener) => raw.subscribe(listener),\n    commit(label) {\n      // Flushes the session's net ops to the parent stack — no apply, but\n      // the parent's undo depth changes and listeners read that.\n      raw.commit(label);\n      notify();\n    },\n    cancel() {\n      replay(() => raw.cancel());\n      notify();\n    },\n    suspend: () => raw.suspend(),\n    isActive: () => raw.isActive(),\n  };\n}\n\nexport function createSceneHistory(env: SceneHistoryEnv): { history: History; methods: SceneHistoryMethods } {\n  const { engine, replay, notify, refuseUntracked, runArrivalEdit } = env;\n\n  /** Wrapped journal → the engine's own, for `resumeJournal`: the engine keys\n   *  resumability off journal identity, which a wrapper would not match. */\n  const rawJournals = new WeakMap<Journal, Journal>();\n\n  function step(can: () => boolean, run: () => void): boolean {\n    if (!can()) return false;\n    replay(run);\n    notify();\n    return true;\n  }\n\n  const methods: SceneHistoryMethods = {\n    undo: () => step(() => engine.canUndo(), () => engine.undo()),\n    redo: () => step(() => engine.canRedo(), () => engine.redo()),\n    canUndo: () => engine.canUndo(),\n    canRedo: () => engine.canRedo(),\n    historyEntries() {\n      const { undo, redo } = engine.entries();\n      // entries().redo is already chronological: the next redo comes first.\n      return [...undo, ...redo].map((e) => ({ id: String(e.id), label: e.label }));\n    },\n    historyIndex: () => engine.undoDepth(),\n    jumpToHistoryIndex(index) {\n      const total = engine.undoDepth() + engine.redoDepth();\n      const target = Math.max(0, Math.min(total, index));\n      return step(() => target !== engine.undoDepth(), () => engine.goto(target));\n    },\n    serializeHistory: () => ({ ...engine.serialize(), form: SCENE_HISTORY_FORM }),\n    restoreHistory(snapshot) {\n      if ((snapshot as Partial<SerializedSceneHistory>).form !== SCENE_HISTORY_FORM) {\n        dwarn('scene', 'restoreHistory: snapshot is not in the current recorded form — dropped');\n        return;\n      }\n      // Only the stacks are rebuilt: no op applies.\n      engine.restore(snapshot);\n      notify();\n    },\n  };\n\n  const history: History = {\n    // Mutating: applied ops re-enter the scene's own mutation methods.\n    apply(op, label) {\n      refuseUntracked('history.apply');\n      runArrivalEdit([op], (all) => {\n        const run = () => (all.length === 1\n          ? engine.apply(env.causing(op), label)\n          : engine.applyOps(all.map(env.causing), label ?? op.label ?? ''));\n        env.applying(run);\n        notify();\n      });\n    },\n    applyOps(ops, label) {\n      refuseUntracked('history.applyOps');\n      runArrivalEdit(ops, (all) => {\n        env.applying(() => engine.applyOps(all.map(env.causing), label));\n        notify();\n      });\n    },\n    undo: () => { methods.undo(); },\n    redo: () => { methods.redo(); },\n    goto: (n) => { methods.jumpToHistoryIndex(n); },\n    // Stack-only: nothing applies, but what `canUndo()` answers changes.\n    clear() {\n      engine.clear();\n      notify();\n    },\n    recordEntry(ops, label, opts) {\n      engine.recordEntry(ops, label, opts);\n      notify();\n    },\n    prune(t) {\n      engine.prune(t);\n      notify();\n    },\n    switchBranch(id) {\n      engine.switchBranch(id);\n      notify();\n    },\n    restore: methods.restoreHistory,\n    // Reads forward to the engine, `version` included: it counts history\n    // operations, where the scene's counts every mutation.\n    canUndo: methods.canUndo,\n    canRedo: methods.canRedo,\n    undoDepth: () => engine.undoDepth(),\n    redoDepth: () => engine.redoDepth(),\n    entries: () => engine.entries(),\n    timestampAt: (i) => engine.timestampAt(i),\n    depthAt: (t) => engine.depthAt(t),\n    branches: () => engine.branches(),\n    getVersion: () => engine.getVersion(),\n    subscribe: (listener) => engine.subscribe(listener),\n    serialize: methods.serializeHistory,\n    allForwardOps: () => engine.allForwardOps(),\n    seal: () => engine.seal(),\n    currentEntryId: () => engine.currentEntryId(),\n    beginJournal(opts) {\n      const raw = engine.beginJournal(opts);\n      const wrapped = wrapJournal(raw, env);\n      rawJournals.set(wrapped, raw);\n      return wrapped;\n    },\n    resumeJournal: (journal) => engine.resumeJournal(rawJournals.get(journal) ?? journal),\n  };\n  return { history, methods };\n}\n"],"mappings":"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"}

package/dist/core/scene/historyForm.js

@@ -0,0 +1,6 @@
+//#region src/core/scene/historyForm.ts
+var e = 2;
+//#endregion
+export { e as SCENE_HISTORY_FORM };
+
+//# sourceMappingURL=historyForm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"historyForm.js","names":["SCENE_HISTORY_FORM"],"sources":["../../../src/core/scene/historyForm.ts"],"sourcesContent":["import type { SerializedHistory } from '@weasel-js/history';\n\n/** The form a scene's undo entries are recorded in. A serialized history\n *  carries it, and one carrying another is not restored. Form 2 holds the\n *  scene's own ops for every edit; before it, an `applyBatch` entry held the\n *  ops it was given. */\nexport const SCENE_HISTORY_FORM = 2;\n\n/** What `Scene.serializeHistory` answers with. */\nexport interface SerializedSceneHistory extends SerializedHistory {\n  form: typeof SCENE_HISTORY_FORM;\n}\n"],"mappings":";AAMA,IAAaA,IAAqB"}

package/dist/core/scene/kitOps.js

@@ -0,0 +1,185 @@
+import { dwarn as e } from "../../debug/flag.js";
+import { restoreFn as t } from "./nodeFnFields.js";
+//#region src/core/scene/kitOps.ts
+function n(e, t) {
+	t === void 0 ? delete e.parallax : e.parallax = t;
+}
+function r(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);
+	}
+	x("kit:add", {
+		apply: (n) => {
+			if (a.nodes.has(n.id)) throw Error(`Scene: id collision on "${n.id}"`);
+			let r = n.kind === "container" ? {
+				kind: "container",
+				id: n.id,
+				layer: n.layer,
+				pose: n.pose,
+				data: n.data,
+				parent: n.parent,
+				children: []
+			} : {
+				kind: "leaf",
+				id: n.id,
+				layer: n.layer,
+				pose: n.pose,
+				data: n.data,
+				parent: n.parent
+			};
+			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, i, s, "kit:add", e);
+			}
+			f(n.id);
+		},
+		revert: (e) => {
+			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);
+		}
+	}), x("kit:remove", {
+		apply: (e) => {
+			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]));
+			for (let n of e.nodes) {
+				let e = n.kind === "container" ? {
+					...n,
+					children: [...n.children]
+				} : { ...n };
+				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) 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);
+		}
+	}), x("kit:setData", {
+		apply: (e) => {
+			g(e.id).data = e.to, f(e.id);
+		},
+		revert: (e) => {
+			g(e.id).data = e.from, f(e.id);
+		}
+	}), x("kit:setLayer", {
+		apply: (e) => {
+			o(e.to), g(e.id).layer = e.to, c(), f(e.id);
+		},
+		revert: (e) => {
+			g(e.id).layer = e.from, c(), f(e.id);
+		}
+	}), x("kit:setDependsOn", {
+		apply: (e) => {
+			h(e.id, e.to);
+		},
+		revert: (e) => {
+			h(e.id, e.from);
+		}
+	}), x("kit:setUnits", {
+		apply: (e) => {
+			r(g(e.id), e.to);
+		},
+		revert: (e) => {
+			r(g(e.id), e.from);
+		}
+	});
+	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 c = o?.[r] ?? null;
+		c === null ? delete i.layout : a.write(i, c);
+	}
+	x("kit:setLayout", {
+		apply: (e) => {
+			C(e, "to");
+		},
+		revert: (e) => {
+			C(e, "from");
+		}
+	}), x("kit:move", {
+		apply: (e) => {
+			_(e.id), v(e.id, e.toParent, e.toIndex), p(e.fromParent), f(e.id);
+		},
+		revert: (e) => {
+			_(e.id), v(e.id, e.fromParent, e.fromIndex), p(e.toParent), f(e.id);
+		}
+	}), x("kit:setLayerVisible", {
+		apply: (e) => {
+			a.layers[o(e.layer)].visible = e.to;
+		},
+		revert: (e) => {
+			a.layers[o(e.layer)].visible = e.from;
+		}
+	}), x("kit:setLayerLocked", {
+		apply: (e) => {
+			a.layers[o(e.layer)].locked = e.to, e.to && i.narrowSelection();
+		},
+		revert: (e) => {
+			a.layers[o(e.layer)].locked = e.from;
+		}
+	}), x("kit:setLayerParallax", {
+		apply: (e) => {
+			n(a.layers[o(e.layer)], e.to);
+		},
+		revert: (e) => {
+			n(a.layers[o(e.layer)], e.from);
+		}
+	}), x("kit:addLayer", {
+		apply: (e) => {
+			a.layers.splice(e.index, 0, { ...e.record }), s();
+		},
+		revert: (e) => {
+			a.layers.splice(e.index, 1), s();
+		}
+	}), x("kit:removeLayer", {
+		apply: (e) => {
+			a.layers.splice(e.index, 1), s();
+		},
+		revert: (e) => {
+			a.layers.splice(e.index, 0, { ...e.record }), s();
+		}
+	}), x("kit:renameLayer", {
+		apply: (e) => {
+			a.layers[o(e.layer)].name = e.to;
+		},
+		revert: (e) => {
+			a.layers[o(e.layer)].name = e.from;
+		}
+	});
+	function w(e, t) {
+		let [n] = a.layers.splice(o(e), 1);
+		a.layers.splice(t, 0, n), s();
+	}
+	return x("kit:moveLayer", {
+		apply: (e) => w(e.layer, e.to),
+		revert: (e) => w(e.layer, e.from)
+	}), { layoutRefs: S };
+}
+//#endregion
+export { i as registerKitOps };
+
+//# sourceMappingURL=kitOps.js.map