@weasel-js/core 1.9.4 → 1.10.1

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

@@ -1 +1 @@
-{"version":3,"file":"derivedPath.js","names":["SLOT","resolving","cycleHits","resolveDerivedPath","derivePath","node","ids","dependencyIdsOf","childrenOf","hitsBefore","computed","record","nodeMemo","memoSlot","draw","depOf","sameDeps","dropPoseKeyedMemoSlots","deps","recordDeps","into"],"sources":["../../../src/core/scene/derivedPath.ts"],"sourcesContent":["/**\n * `resolveDerivedPath` — the path a node computes from its dependencies.\n *\n * It sits beside `derivedPose` rather than in `canvas/` because a *pose* can\n * now derive from a dependency's path: an edge label is positioned along the\n * route it labels, and `effectivePose` is what resolves it. The render walk's\n * wrapper stays in `canvas/derivedPath.ts`.\n *\n * Invalidation is both pushed and pulled. The scene pushes — dropping the\n * dependent's memo slot on the edits it performs — and on a memo hit this\n * module re-resolves the dependencies and compares their poses *by value*\n * against the ones the cached path was drawn from. The pull is what covers a\n * dependency that moved with no scene edit behind it: a lookup answering poses\n * of its own (`sceneDepLookup(scene, toPose)`), an ancestor's frame moving, a\n * dependency appearing or going away. Value, not reference: a pose override\n * mutates its buffer in place, so the reference never moves.\n *\n * The pull covers poses only. A derivation is handed each dependency's whole\n * node, so one reading `data` or `layer` still rides on the scene's push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { dependencyIdsOf } from './dependents';\nimport { dropPoseKeyedMemoSlots, nodeMemo, type NodeMemoScope } from './nodeMemo';\nimport { recordDeps, sameDeps, type DepRecord } from './depMemo';\nimport type { DerivedDep, DerivePathFn, NodeId } from './types';\n\nconst SLOT = 'kit:derivedPath';\n\n/** The subset of a node this module reads. Structural so a `Node` satisfies it\n *  without importing the full generic shape. */\nexport interface PathDerivingNode<TPose> {\n  id: NodeId;\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  derivePath?: DerivePathFn<TPose>;\n}\n\n/** A cached path, with what it was drawn from. */\ninterface PathMemo<TPose> extends DepRecord<TPose> {\n  path: Path | null;\n}\n\n/** Ids whose path is on the stack. A dependency graph is meant to be acyclic\n *  and `dependsOn` is unvalidated; now that a path can read another path, a\n *  cycle has to resolve to `null` at whichever node closes it rather than\n *  overflowing the stack. */\nconst resolving = new Set<NodeId>();\n\n/** Bumped each time the guard above fires, so a value computed from a\n *  fallback is not cached — it is an artifact of which node was asked first. */\nlet cycleHits = 0;\n\n/**\n * The path `node` computes from its dependencies, or `null` when it derives\n * from nothing (the normal case) or its `derivePath` has nothing to draw.\n *\n * `depOf` supplies each dependency — its node, the pose it is painted at, and\n * its own path; one it cannot resolve reaches `derivePath` as `undefined`.\n * `childrenOf` answers a node whose `dependsOn` is `'children'`.\n *\n * `memoSlot` separates a `depOf` that answers different poses than the scene's\n * own — the memo key cannot see which lookup filled it.\n */\nexport function resolveDerivedPath<TPose>(\n  node: PathDerivingNode<TPose>,\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n  childrenOf: (id: NodeId) => readonly NodeId[],\n  memoSlot: string | NodeMemoScope = SLOT,\n): Path | null {\n  const derivePath = node.derivePath;\n  if (derivePath === undefined) return null;\n  const ids = dependencyIdsOf(node, 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    let computed = false;\n    const record = nodeMemo<PathMemo<TPose>>(node, memoSlot, node.pose, () => {\n      computed = true;\n      return draw(node, derivePath, ids.map(depOf), { nodes: [], poses: [], path: 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      draw(node, derivePath, ids.map(depOf), record);\n    }\n    if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);\n    return record.path;\n  } finally {\n    resolving.delete(node.id);\n  }\n}\n\n/** Run `derivePath` against `deps` and record what it was run against. */\nfunction draw<TPose>(\n  node: PathDerivingNode<TPose>,\n  derivePath: NonNullable<PathDerivingNode<TPose>['derivePath']>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  into: PathMemo<TPose>,\n): PathMemo<TPose> {\n  into.path = derivePath(node as never, deps);\n  recordDeps(into, deps);\n  return into;\n}\n\n"],"mappings":";;;;AA0BA,IAAMA,IAAO,mBAsBPC,oBAAY,IAAI,IAAY,GAI9BC,IAAY;AAahB,SAAgBC,EACd,GACA,GACA,GACA,IAAmCH,GACtB;CACb,IAAMI,IAAaC,EAAK;CACxB,IAAID,MAAe,KAAA,GAAW,OAAO;CACrC,IAAME,IAAMC,EAAgBF,GAAMG,CAAU;CAC5C,IAAIF,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIL,EAAU,IAAII,EAAK,EAAE,GAEvB,OADA,KACO;CAET,EAAU,IAAIA,EAAK,EAAE;CACrB,IAAMI,IAAaP;CACnB,IAAI;EACF,IAAIQ,IAAW,IACTC,IAASC,EAA0BP,GAAMQ,GAAUR,EAAK,aAC5D,IAAW,IACJS,EAAKT,GAAMD,GAAYE,EAAI,IAAIS,CAAK,GAAG;GAAE,OAAO,CAAC;GAAG,OAAO,CAAC;GAAG,MAAM;EAAK,CAAC,EACnF;EAOD,OAJI,CAACL,KAAY,CAACM,EAASL,GAAQL,GAAKS,CAAK,KAC3CD,EAAKT,GAAMD,GAAYE,EAAI,IAAIS,CAAK,GAAGJ,CAAM,GAE3CT,MAAcO,KAAYQ,EAAuBZ,CAAI,GAClDM,EAAO;CAChB,UAAU;EACR,EAAU,OAAON,EAAK,EAAE;CAC1B;AACF;AAGA,SAASS,EACP,GACA,GACA,GACA,GACiB;CAGjB,OAFA,EAAK,OAAOV,EAAWC,GAAea,CAAI,GAC1CC,EAAWC,GAAMF,CAAI,GACdE;AACT"}
+{"version":3,"file":"derivedPath.js","names":["SLOT","resolving","cycleHits","resolveDerivedPath","derivePath","node","ids","dependencyIdsOf","childrenOf","hitsBefore","computed","record","nodeMemo","memoSlot","draw","depOf","emptyDepRecord","sameDeps","dropPoseKeyedMemoSlots","deriveRecorded","into","deps","handed"],"sources":["../../../src/core/scene/derivedPath.ts"],"sourcesContent":["/**\n * `resolveDerivedPath` — the path a node computes from its dependencies.\n *\n * It sits beside `derivedPose` rather than in `canvas/` because a *pose* can\n * derive from a dependency's path.\n *\n * Invalidation is both pushed and pulled. The scene pushes — dropping the\n * dependent's memo slot on the edits it performs — and on a memo hit this\n * module re-resolves the dependencies and compares their poses *by value*\n * against the ones the cached path was drawn from. Value, not reference: a\n * pose override mutates its buffer in place, so the reference never moves.\n * `depMemo.ts` says what else of a dependency the pull covers.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { dependencyIdsOf } from './dependents';\nimport { dropPoseKeyedMemoSlots, nodeMemo, type NodeMemoScope } from './nodeMemo';\nimport { deriveRecorded, emptyDepRecord, sameDeps, type DepRecord } from './depMemo';\nimport type { DerivedDep, DerivePathFn, NodeId } from './types';\n\nconst SLOT = 'kit:derivedPath';\n\n/** The subset of a node this module reads. Structural so a `Node` satisfies it\n *  without importing the full generic shape. */\nexport interface PathDerivingNode<TPose> {\n  id: NodeId;\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  derivePath?: DerivePathFn<TPose>;\n}\n\n/** A cached path, with what it was drawn from. */\ninterface PathMemo<TPose> extends DepRecord<TPose> {\n  path: Path | null;\n}\n\n/** Ids whose path is on the stack. `dependsOn` is unvalidated, so a cycle\n *  resolves to `null` at whichever node closes it rather than overflowing\n *  the stack. */\nconst resolving = new Set<NodeId>();\n\n/** Bumped each time the guard above fires, so a value computed from a\n *  fallback is not cached — it is an artifact of which node was asked first. */\nlet cycleHits = 0;\n\n/**\n * The path `node` computes from its dependencies, or `null` when it derives\n * from nothing (the normal case) or its `derivePath` has nothing to draw.\n *\n * `depOf` supplies each dependency — its node, the pose it is painted at, and\n * its own path; one it cannot resolve reaches `derivePath` as `undefined`.\n * `childrenOf` answers a node whose `dependsOn` is `'children'`.\n *\n * `memoSlot` separates a `depOf` that answers different poses than the scene's\n * own — the memo key cannot see which lookup filled it.\n */\nexport function resolveDerivedPath<TPose>(\n  node: PathDerivingNode<TPose>,\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n  childrenOf: (id: NodeId) => readonly NodeId[],\n  memoSlot: string | NodeMemoScope = SLOT,\n): Path | null {\n  const derivePath = node.derivePath;\n  if (derivePath === undefined) return null;\n  const ids = dependencyIdsOf(node, 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    let computed = false;\n    const record = nodeMemo<PathMemo<TPose>>(node, memoSlot, node.pose, () => {\n      computed = true;\n      return draw(node, derivePath, ids.map(depOf), { ...emptyDepRecord<TPose>(), path: 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      draw(node, derivePath, ids.map(depOf), record);\n    }\n    if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);\n    return record.path;\n  } finally {\n    resolving.delete(node.id);\n  }\n}\n\n/** Run `derivePath` against `deps` and record what it was run against. */\nfunction draw<TPose>(\n  node: PathDerivingNode<TPose>,\n  derivePath: NonNullable<PathDerivingNode<TPose>['derivePath']>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  into: PathMemo<TPose>,\n): PathMemo<TPose> {\n  into.path = deriveRecorded(into, deps, (handed) => derivePath(node as never, handed));\n  return into;\n}\n\n"],"mappings":";;;;AAmBA,IAAMA,IAAO,mBAqBPC,oBAAY,IAAI,IAAY,GAI9BC,IAAY;AAahB,SAAgBC,EACd,GACA,GACA,GACA,IAAmCH,GACtB;CACb,IAAMI,IAAaC,EAAK;CACxB,IAAID,MAAe,KAAA,GAAW,OAAO;CACrC,IAAME,IAAMC,EAAgBF,GAAMG,CAAU;CAC5C,IAAIF,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIL,EAAU,IAAII,EAAK,EAAE,GAEvB,OADA,KACO;CAET,EAAU,IAAIA,EAAK,EAAE;CACrB,IAAMI,IAAaP;CACnB,IAAI;EACF,IAAIQ,IAAW,IACTC,IAASC,EAA0BP,GAAMQ,GAAUR,EAAK,aAC5D,IAAW,IACJS,EAAKT,GAAMD,GAAYE,EAAI,IAAIS,CAAK,GAAG;GAAE,GAAGC,EAAsB;GAAG,MAAM;EAAK,CAAC,EACzF;EAOD,OAJI,CAACN,KAAY,CAACO,EAASN,GAAQL,GAAKS,CAAK,KAC3CD,EAAKT,GAAMD,GAAYE,EAAI,IAAIS,CAAK,GAAGJ,CAAM,GAE3CT,MAAcO,KAAYS,EAAuBb,CAAI,GAClDM,EAAO;CAChB,UAAU;EACR,EAAU,OAAON,EAAK,EAAE;CAC1B;AACF;AAGA,SAASS,EACP,GACA,GACA,GACA,GACiB;CAEjB,OADA,EAAK,OAAOK,EAAeC,GAAMC,IAAO,MAAWjB,EAAWC,GAAeiB,CAAM,CAAC,GAC7EF;AACT"}

package/dist/core/scene/editMode.js

@@ -0,0 +1,26 @@
+//#region src/core/scene/editMode.ts
+function e() {
+	let e = {
+		batch: 0,
+		engine: 0,
+		untracked: 0,
+		own: 0
+	};
+	return {
+		open: () => e.batch + e.engine + e.untracked + e.own > 0,
+		records: () => e.engine + e.untracked === 0,
+		untracked: () => e.untracked > 0,
+		during(t, n) {
+			e[t]++;
+			try {
+				return n();
+			} finally {
+				e[t]--;
+			}
+		}
+	};
+}
+//#endregion
+export { e as createEditMode };
+
+//# sourceMappingURL=editMode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editMode.js","names":["createEditMode","depth","driver","fn"],"sources":["../../../src/core/scene/editMode.ts"],"sourcesContent":["/**\n * Who is driving the scene's mutations right now.\n *\n * A bare call records itself. Inside a `batch` the batch records it; while a\n * history engine applies or replays ops the engine's entry already holds it;\n * inside `untracked` nothing does; and `own` is the scene handing a bare call's\n * op to its engine, which records it.\n */\nexport type EditDriver = 'batch' | 'engine' | 'untracked' | 'own';\n\nexport interface EditMode {\n  /** Whether any driver is running, so a scene call is part of its edit\n   *  rather than an edit of its own. */\n  open(): boolean;\n  /** Whether a scene call is recorded by the scene: false under an engine\n   *  or an untracked run, however deep. */\n  records(): boolean;\n  untracked(): boolean;\n  /** Run `fn` under `driver`. */\n  during<T>(driver: EditDriver, fn: () => T): T;\n}\n\nexport function createEditMode(): EditMode {\n  const depth: Record<EditDriver, number> = { batch: 0, engine: 0, untracked: 0, own: 0 };\n\n  return {\n    open: () => depth.batch + depth.engine + depth.untracked + depth.own > 0,\n    records: () => depth.engine + depth.untracked === 0,\n    untracked: () => depth.untracked > 0,\n    during(driver, fn) {\n      depth[driver]++;\n      try {\n        return fn();\n      } finally {\n        depth[driver]--;\n      }\n    },\n  };\n}\n"],"mappings":";AAsBA,SAAgBA,IAA2B;CACzC,IAAMC,IAAoC;EAAE,OAAO;EAAG,QAAQ;EAAG,WAAW;EAAG,KAAK;CAAE;CAEtF,OAAO;EACL,YAAYA,EAAM,QAAQA,EAAM,SAASA,EAAM,YAAYA,EAAM,MAAM;EACvE,eAAeA,EAAM,SAASA,EAAM,cAAc;EAClD,iBAAiBA,EAAM,YAAY;EACnC,OAAO,GAAQ,GAAI;GACjB,EAAMC,EAAO;GACb,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IACR,EAAMD,EAAO;GACf;EACF;CACF;AACF"}

package/dist/core/scene/effectivePose.js

@@ -1,78 +1,81 @@
-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;
+	shown;
 	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;
+		let r = n === "effective" ? e.overrides.read(t.id) : void 0;
+		this.shown = r?.path, this.pose = r?.pose ?? f(e, t, n) ?? t.pose;
 	}
 	get path() {
+		if (this.shown !== void 0) return this.shown;
 		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","override","resolveDerivedPath","depId","poseIn","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  private readonly shown: Path | undefined;\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    const override = reading === 'effective' ? source.overrides.read(posed.id) : undefined;\n    this.shown = override?.path;\n    this.pose = override?.pose ?? derivedPoseIn(source, posed, reading) ?? posed.pose;\n  }\n\n  get path(): Path | null {\n    if (this.shown !== undefined) return this.shown;\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":"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"}

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

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

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

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