@weasel-js/core 1.10.1 → 1.11.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"editPass.js","names":[],"sources":["../../../src/core/scene/editPass.ts"],"sourcesContent":["/**\n * Scene edit passes: functions that hear what a live edit did, once its own\n * mutations and the arrival handler have run, and answer with ops that join\n * the same undo entry.\n *\n * Passes run by ascending order, and each hears the edit's own changes plus\n * every write the passes before it made. A pass still runs once per edit, so\n * none re-triggers itself or another. Undo, redo, and history replays never\n * run passes: they restore an edit whose passes already ran.\n */\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from './types';\n\n/** What one live edit did to the scene's nodes, by id. */\nexport interface SceneEditSummary {\n  added: ReadonlySet<NodeId>;\n  removed: ReadonlySet<NodeId>;\n  posed: ReadonlySet<NodeId>;\n  /** Nodes that changed parent. A reorder among siblings is not here. */\n  reparented: ReadonlySet<NodeId>;\n  dataChanged: ReadonlySet<NodeId>;\n  /** The document-value keys (`scene.doc`) set. */\n  docChanged: ReadonlySet<string>;\n}\n\n/** Where a pass runs among the others. */\nexport interface SceneEditPassOptions {\n  /** Passes run by ascending order, ties in the order they were added.\n   *  Default 0. */\n  order?: number;\n}\n\n/** A scene edit pass: the ops `summary`'s edit also makes, or null for none. */\nexport type SceneEditPass = (summary: SceneEditSummary) => readonly Op[] | null;\n\n/** The scene's edit-pass member. */\nexport interface SceneEditPasses {\n  /** Add a pass that hears each live edit once its own mutations and the\n   *  arrival handler have run, and answers with ops that join the same undo\n   *  entry. A bare scene call runs as an edit of its own while any pass is\n   *  added. A pass hears what the passes ordered before it wrote, never what\n   *  it or a later one writes, and undo, redo, and history replays never run\n   *  it. Returns the pass's remover. */\n  addEditPass(pass: SceneEditPass, opts?: SceneEditPassOptions): () => void;\n}\n\n/** What the passes need from the scene they serve. */\nexport interface EditPassEnv {\n  /** The adapter a pass's ops apply through. */\n  adapter(): unknown;\n  /** Whether an edit made now is untracked, and so not summarized. */\n  untracked(): boolean;\n}\n\nexport interface EditPasses {\n  /** Add a pass after every one of its order or lower. Returns its remover. */\n  add(pass: SceneEditPass, opts?: SceneEditPassOptions): () => void;\n  /** Whether any pass is installed. */\n  any(): boolean;\n  /** Start summarizing an edit when a pass is installed and no enclosing edit\n   *  is summarizing already; true when this caller now owns the summary. */\n  open(): boolean;\n  /** Note what a live kit op is about to write. */\n  note(kind: string, payload: unknown): void;\n  /** Run every pass in order, each over the summary as it stands at its\n   *  turn, applying its ops into that summary; then close it. Answers how\n   *  many ops applied. */\n  run(): number;\n  /** Close the summary with nothing run. */\n  abandon(): void;\n  /** An op that runs the passes when it first applies, for the end of an\n   *  op-driven edit whose summary the caller owns. */\n  op(): Op;\n}\n\ninterface Collecting {\n  added: Set<NodeId>;\n  removed: Set<NodeId>;\n  posed: Set<NodeId>;\n  reparented: Set<NodeId>;\n  dataChanged: Set<NodeId>;\n  docChanged: Set<string>;\n}\n\nconst emptyCollecting = (): Collecting => ({\n  added: new Set(), removed: new Set(), posed: new Set(), reparented: new Set(), dataChanged: new Set(), docChanged: new Set(),\n});\n\nconst snapshot = (c: Collecting): SceneEditSummary => ({\n  added: new Set(c.added),\n  removed: new Set(c.removed),\n  posed: new Set(c.posed),\n  reparented: new Set(c.reparented),\n  dataChanged: new Set(c.dataChanged),\n  docChanged: new Set(c.docChanged),\n});\n\nconst NOOP: Op = { name: 'editPass', args: {}, elideNoop: true, apply: () => 'noop', invert: () => NOOP };\n\n/** Note one kit op's ids into `into`. */\nfunction noteInto(into: Collecting, kind: string, payload: unknown): void {\n  const p = payload as { id?: NodeId; key?: string; nodes?: readonly { id: NodeId }[]; fromParent?: NodeId | null; toParent?: NodeId | null };\n  switch (kind) {\n    case 'kit:add': into.added.add(p.id!); break;\n    case 'kit:remove': for (const n of p.nodes ?? []) into.removed.add(n.id); break;\n    case 'kit:setPose': into.posed.add(p.id!); break;\n    case 'kit:setData': into.dataChanged.add(p.id!); break;\n    case 'kit:setDoc': into.docChanged.add(p.key!); break;\n    case 'kit:move': if (p.fromParent !== p.toParent) into.reparented.add(p.id!); break;\n    default: break;\n  }\n}\n\nexport function createEditPasses(env: EditPassEnv): EditPasses {\n  /** Sorted by order; equal orders keep the order they were added in. */\n  const passes: { pass: SceneEditPass; order: number }[] = [];\n  let collecting: Collecting | null = null;\n\n  function run(): number {\n    const summary = collecting;\n    if (summary === null) return 0;\n    let applied = 0;\n    try {\n      for (const { pass } of [...passes]) {\n        const ops = pass(snapshot(summary));\n        if (ops === null) continue;\n        const adapter = env.adapter();\n        for (const op of ops) {\n          op.apply(adapter);\n          applied++;\n        }\n      }\n    } finally {\n      collecting = null;\n    }\n    return applied;\n  }\n\n  return {\n    add(pass, opts) {\n      const entry = { pass, order: opts?.order ?? 0 };\n      const at = passes.findIndex((p) => p.order > entry.order);\n      passes.splice(at < 0 ? passes.length : at, 0, entry);\n      return () => {\n        const i = passes.indexOf(entry);\n        if (i >= 0) passes.splice(i, 1);\n      };\n    },\n    any: () => passes.length > 0,\n    open() {\n      if (collecting !== null || passes.length === 0) return false;\n      collecting = emptyCollecting();\n      return true;\n    },\n    note(kind, payload) {\n      if (collecting !== null && !env.untracked()) noteInto(collecting, kind, payload);\n    },\n    run,\n    abandon() {\n      collecting = null;\n    },\n    op() {\n      return {\n        name: 'editPass',\n        args: {},\n        label: 'Edit pass',\n        elideNoop: true,\n        apply: () => (run() > 0 ? undefined : 'noop'),\n        invert: () => NOOP,\n      };\n    },\n  };\n}\n"],"mappings":";AAoFA,IAAM,yBAAqC;CACzC,uBAAO,IAAI,IAAI;CAAG,yBAAS,IAAI,IAAI;CAAG,uBAAO,IAAI,IAAI;CAAG,4BAAY,IAAI,IAAI;CAAG,6BAAa,IAAI,IAAI;CAAG,4BAAY,IAAI,IAAI;AAC7H;AAEA,IAAM,YAAY,OAAqC;CACrD,OAAO,IAAI,IAAI,EAAE,KAAK;CACtB,SAAS,IAAI,IAAI,EAAE,OAAO;CAC1B,OAAO,IAAI,IAAI,EAAE,KAAK;CACtB,YAAY,IAAI,IAAI,EAAE,UAAU;CAChC,aAAa,IAAI,IAAI,EAAE,WAAW;CAClC,YAAY,IAAI,IAAI,EAAE,UAAU;AAClC;AAEA,IAAM,OAAW;CAAE,MAAM;CAAY,MAAM,CAAC;CAAG,WAAW;CAAM,aAAa;CAAQ,cAAc;AAAK;;AAGxG,SAAS,SAAS,MAAkB,MAAc,SAAwB;CACxE,MAAM,IAAI;CACV,QAAQ,MAAR;EACE,KAAK;GAAW,KAAK,MAAM,IAAI,EAAE,EAAG;GAAG;EACvC,KAAK;GAAc,KAAK,MAAM,KAAK,EAAE,SAAS,CAAC,GAAG,KAAK,QAAQ,IAAI,EAAE,EAAE;GAAG;EAC1E,KAAK;GAAe,KAAK,MAAM,IAAI,EAAE,EAAG;GAAG;EAC3C,KAAK;GAAe,KAAK,YAAY,IAAI,EAAE,EAAG;GAAG;EACjD,KAAK;GAAc,KAAK,WAAW,IAAI,EAAE,GAAI;GAAG;EAChD,KAAK,YAAY,IAAI,EAAE,eAAe,EAAE,UAAU,KAAK,WAAW,IAAI,EAAE,EAAG;CAE7E;AACF;AAEA,SAAgB,iBAAiB,KAA8B;;CAE7D,MAAM,SAAmD,CAAC;CAC1D,IAAI,aAAgC;CAEpC,SAAS,MAAc;EACrB,MAAM,UAAU;EAChB,IAAI,YAAY,MAAM,OAAO;EAC7B,IAAI,UAAU;EACd,IAAI;GACF,KAAK,MAAM,EAAE,UAAU,CAAC,GAAG,MAAM,GAAG;IAClC,MAAM,MAAM,KAAK,SAAS,OAAO,CAAC;IAClC,IAAI,QAAQ,MAAM;IAClB,MAAM,UAAU,IAAI,QAAQ;IAC5B,KAAK,MAAM,MAAM,KAAK;KACpB,GAAG,MAAM,OAAO;KAChB;IACF;GACF;EACF,UAAU;GACR,aAAa;EACf;EACA,OAAO;CACT;CAEA,OAAO;EACL,IAAI,MAAM,MAAM;GACd,MAAM,QAAQ;IAAE;IAAM,OAAO,MAAM,SAAS;GAAE;GAC9C,MAAM,KAAK,OAAO,WAAW,MAAM,EAAE,QAAQ,MAAM,KAAK;GACxD,OAAO,OAAO,KAAK,IAAI,OAAO,SAAS,IAAI,GAAG,KAAK;GACnD,aAAa;IACX,MAAM,IAAI,OAAO,QAAQ,KAAK;IAC9B,IAAI,KAAK,GAAG,OAAO,OAAO,GAAG,CAAC;GAChC;EACF;EACA,WAAW,OAAO,SAAS;EAC3B,OAAO;GACL,IAAI,eAAe,QAAQ,OAAO,WAAW,GAAG,OAAO;GACvD,aAAa,gBAAgB;GAC7B,OAAO;EACT;EACA,KAAK,MAAM,SAAS;GAClB,IAAI,eAAe,QAAQ,CAAC,IAAI,UAAU,GAAG,SAAS,YAAY,MAAM,OAAO;EACjF;EACA;EACA,UAAU;GACR,aAAa;EACf;EACA,KAAK;GACH,OAAO;IACL,MAAM;IACN,MAAM,CAAC;IACP,OAAO;IACP,WAAW;IACX,aAAc,IAAI,IAAI,IAAI,SAAY;IACtC,cAAc;GAChB;EACF;CACF;AACF"}

package/dist/core/scene/effectivePose.js

@@ -1,81 +1,203 @@
-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";
+import { deriveRecorded, emptyDepRecord, sameDeps } from "./depMemo.js";
+import { carryDepPath, depFrameRebase, pathAsPainted } from "./depFrame.js";
+import { dependencyIdsOf } from "./dependents.js";
+import { dropPoseKeyedMemoSlots, nodeMemo } from "./nodeMemo.js";
+import { resolveDerivedPath } from "./derivedPath.js";
+
 //#region src/core/scene/effectivePose.ts
-var s = {
+/**
+* `effectivePose` — the pose to draw, pick and measure a node at.
+*
+* Three answers, in order: the ephemeral override a gesture published, the
+* pose the node derives from its dependencies, or the pose the document
+* stores. A reader of `node.pose` disagrees with the render about where a
+* dragged or derived node is.
+*/
+var POSE_SLOT = {
 	effective: "kit:derivedPose",
 	document: "kit:derivedPose:document"
-}, c = {
+};
+var PATH_SLOT = {
 	effective: void 0,
 	document: "kit:derivedPath:document"
-}, l = /* @__PURE__ */ new Set(), u = 0;
-function d(e, t) {
-	return f(e, t, "effective");
+};
+/** Ids whose derivation is on the stack. A dependency graph is meant to be
+*  acyclic and `dependsOn` is unvalidated, so a cycle resolves to the authored
+*  pose at whichever node closes it rather than overflowing the stack. */
+var resolving = /* @__PURE__ */ new Set();
+/** Bumped each time the guard above fires. A derivation that closed a cycle
+*  answered from a fallback rather than from its dependencies, so its value is
+*  an artifact of which node was asked first and must not be cached. */
+var cycleHits = 0;
+/**
+* The pose `node` computes from its dependencies, or `null` when it derives
+* nothing — it has no `derivePose`, nothing to derive from, or its
+* `derivePose` returned `null`.
+*
+* A dependency is read through {@link effectivePose}, so a group of groups
+* resolves bottom-up and a dragged dependency's override reaches the
+* derivation the same frame it is published.
+*/
+function derivedPose(source, node) {
+	return derivedPoseIn(source, node, "effective");
 }
-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;
+function derivedPoseIn(source, node, reading) {
+	const derive = node.derivePose;
+	if (derive === void 0) return null;
+	const ids = dependencyIdsOf(node, source.childrenOf);
+	if (ids.length === 0) return null;
+	if (resolving.has(node.id)) {
+		cycleHits++;
+		return null;
+	}
+	resolving.add(node.id);
+	const hitsBefore = cycleHits;
 	try {
-		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 !l && !n(g, f, r) && p(o, d, f.map(r), g), u !== m && i(o), g.value;
+		const depOf = depsAsRead(source, node, reading);
+		let computed = false;
+		const record = nodeMemo(node, POSE_SLOT[reading], node.pose, () => {
+			computed = true;
+			return run(node, derive, ids.map(depOf), {
+				...emptyDepRecord(),
+				value: null
+			});
+		});
+		if (!computed && !sameDeps(record, ids, depOf)) run(node, derive, ids.map(depOf), record);
+		if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);
+		return record.value;
 	} finally {
-		l.delete(o.id);
+		resolving.delete(node.id);
 	}
 }
-function p(t, n, r, i) {
-	return i.value = e(i, r, (e) => n(t, e)), i;
+/** Run `derivePose` against `deps` and record what it was run against. */
+function run(node, derive, deps, into) {
+	into.value = deriveRecorded(into, deps, (handed) => derive(node, handed));
+	return into;
 }
-function m(e, t) {
-	return h(e, t, "effective");
+/**
+* `id` as a derivation sees it: the node, the pose it is painted at, and the
+* path it derives.
+*
+* The pose is resolved eagerly — every derivation reads it — and the path
+* lazily, because most do not and resolving a route costs a router run. Both
+* resolve *through* this function, so a dependency that is itself derived is
+* resolved before it is read.
+*/
+function derivedDepOf(source, id, reader) {
+	return reader === void 0 ? depIn(source, id, "effective") : depsAsRead(source, reader, "effective")(id);
 }
-function h(e, t, n) {
-	let r = e.get(t);
-	if (r !== void 0) return new g(e, r, n);
+/** `id` as {@link derivedDepOf} answers it, but at the pose and path the
+*  document holds: no override anywhere down its dependencies counts. For a
+*  reader that must not see an in-flight gesture, such as an edit pass. */
+function documentDepOf(source, id) {
+	return depIn(source, id, "document");
+}
+/** `(id) => that dependency as `reader`'s derivation is handed it`: its pose
+*  in `reader`'s frame where the scene composes frames. A `'children'`
+*  dependent shares its children's frame, so it reads them as they are. */
+function depsAsRead(source, reader, reading) {
+	const plain = (id) => depIn(source, id, reading);
+	if (reader.dependsOn === "children") return plain;
+	const rebase = depFrameRebase(source.composition, reader, (id) => source.get(id), (id) => poseIn(source, source.get(id), reading), (id) => {
+		const n = source.get(id);
+		return n === void 0 || definesFrame(n);
+	});
+	if (rebase === null) return plain;
+	return (id) => {
+		const dep = plain(id);
+		if (dep === void 0) return void 0;
+		const pose = rebase(id, dep.pose);
+		return pose === dep.pose ? dep : new RebasedDep(dep, pose);
+	};
+}
+/** A dependency read from another frame: its pose rebased, and its path
+*  carried by the same frame change when asked for. */
+var RebasedDep = class {
+	dep;
+	pose;
+	node;
+	constructor(dep, pose) {
+		this.dep = dep;
+		this.pose = pose;
+		this.node = dep.node;
+	}
+	get path() {
+		const path = this.dep.path;
+		return path === null ? null : carryDepPath(path, this.dep.pose, this.pose);
+	}
+};
+function depIn(source, id, reading) {
+	const node = source.get(id);
+	if (node === void 0) return void 0;
+	return new SceneDep(source, node, reading);
 }
-var g = class {
+/**
+* A class rather than an object literal with a `get path()`: one of these is
+* built per dependency per derived node per frame, and an own accessor costs
+* an order of magnitude more to define than a prototype one does to inherit.
+*/
+var SceneDep = class {
 	source;
 	posed;
 	reading;
 	node;
 	pose;
 	shown;
-	constructor(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;
+	constructor(source, posed, reading) {
+		this.source = source;
+		this.posed = posed;
+		this.reading = reading;
+		this.node = posed;
+		const override = reading === "effective" ? source.overrides.read(posed.id) : void 0;
+		this.shown = override?.path;
+		this.pose = override?.pose ?? derivedPoseIn(source, posed, reading) ?? posed.pose;
 	}
 	get path() {
-		if (this.shown !== void 0) return this.shown;
-		let { source: e, reading: t } = this;
-		return o(this.posed, (n) => h(e, n, t), (t) => e.childrenOf(t), c[t]);
+		if (this.shown !== void 0) return pathAsPainted(this.shown, this.pose, this.pose);
+		const { source, reading } = this;
+		return resolveDerivedPath(this.posed, depsAsRead(source, this.posed, reading), (depId) => source.childrenOf(depId), PATH_SLOT[reading]);
 	}
 };
-function _(e, t, n) {
-	if (n === "effective") {
-		let n = e.overrides.read(t.id)?.pose;
-		if (n !== void 0) return n;
+function poseIn(source, node, reading) {
+	if (reading === "effective") {
+		const override = source.overrides.read(node.id)?.pose;
+		if (override !== void 0) return override;
 	}
-	return f(e, t, n) ?? t.pose;
+	return derivedPoseIn(source, node, reading) ?? node.pose;
 }
-function v(e, t) {
-	return _(e, t, "document");
+/**
+* The pose the *document* says `node` is at: derived when it derives, else
+* authored. `effectivePose` minus the override step, at every link of the
+* dependency chain — a derived node's document pose holds still while
+* something it derives from is being dragged.
+*
+* For a reader that must not see an in-flight gesture, such as an action
+* capturing the `from` of a transform op.
+*/
+function documentPose(source, node) {
+	return poseIn(source, node, "document");
 }
-function y(e, t) {
-	return _(e, t, "effective");
+/**
+* The pose to draw, pick and measure `node` at. Every pose a reader acts on
+* comes from here.
+*/
+function effectivePose(source, node) {
+	return poseIn(source, node, "effective");
 }
-function b(e) {
-	return e.dependsOn !== "children" || e.derivePose === void 0;
+/**
+* Whether `node`'s pose is a frame its children are expressed in, under a
+* composing strategy.
+*
+* A container that derives its pose from its children cannot be one: moving
+* the frame to cover the children would move the children, and a `RectPose`
+* frame's origin is its corner, so no envelope leaves them in place. Such a
+* container is an envelope instead — its children are stored in its own
+* frame — and the composition fold passes over it.
+*/
+function definesFrame(node) {
+	return !(node.dependsOn === "children" && node.derivePose !== void 0);
 }
-//#endregion
-export { b as definesFrame, m as derivedDepOf, d as derivedPose, v as documentPose, y as effectivePose };
 
+//#endregion
+export { definesFrame, derivedDepOf, derivedPose, documentDepOf, documentPose, 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","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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"}
+{"version":3,"file":"effectivePose.js","names":[],"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 type { PoseComposition } from './composeFrame';\nimport { carryDepPath, depFrameRebase, pathAsPainted } from './depFrame';\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  /** Read under a composing strategy, to find the frame its pose is in. */\n  parent?: NodeId | null;\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  /** When it composes frames, a derivation reads each dependency in the\n   *  frame of the node deriving. */\n  readonly composition?: PoseComposition<TPose>;\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 = depsAsRead(source, node, 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  reader?: PosedNode<TPose>,\n): DerivedDep<TPose> | undefined {\n  return reader === undefined ? depIn(source, id, 'effective') : depsAsRead(source, reader, 'effective')(id);\n}\n\n/** `id` as {@link derivedDepOf} answers it, but at the pose and path the\n *  document holds: no override anywhere down its dependencies counts. For a\n *  reader that must not see an in-flight gesture, such as an edit pass. */\nexport function documentDepOf<TPose>(source: PoseSource<TPose>, id: NodeId): DerivedDep<TPose> | undefined {\n  return depIn(source, id, 'document');\n}\n\n/** `(id) => that dependency as `reader`'s derivation is handed it`: its pose\n *  in `reader`'s frame where the scene composes frames. A `'children'`\n *  dependent shares its children's frame, so it reads them as they are. */\nfunction depsAsRead<TPose>(\n  source: PoseSource<TPose>,\n  reader: PosedNode<TPose>,\n  reading: Reading,\n): (id: NodeId) => DerivedDep<TPose> | undefined {\n  const plain = (id: NodeId) => depIn(source, id, reading);\n  if (reader.dependsOn === 'children') return plain;\n  const rebase = depFrameRebase(\n    source.composition,\n    reader,\n    (id) => source.get(id),\n    (id) => poseIn(source, source.get(id)!, reading),\n    (id) => {\n      const n = source.get(id);\n      return n === undefined || definesFrame(n);\n    },\n  );\n  if (rebase === null) return plain;\n  return (id) => {\n    const dep = plain(id);\n    if (dep === undefined) return undefined;\n    const pose = rebase(id, dep.pose);\n    return pose === dep.pose ? dep : new RebasedDep(dep, pose);\n  };\n}\n\n/** A dependency read from another frame: its pose rebased, and its path\n *  carried by the same frame change when asked for. */\nclass RebasedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n\n  constructor(private readonly dep: DerivedDep<TPose>, readonly pose: TPose) {\n    this.node = dep.node;\n  }\n\n  get path(): Path | null {\n    const path = this.dep.path;\n    return path === null ? null : carryDepPath(path, this.dep.pose, this.pose);\n  }\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 pathAsPainted(this.shown, this.pose, this.pose);\n    const { source, reading } = this;\n    return resolveDerivedPath(\n      this.posed,\n      depsAsRead(source, this.posed, 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

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

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

@@ -1 +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":";;;AAkCA,SAAgBA,EACd,GACkC;CAClC,IAAM,EAAE,gBAAa,gBAAa,kBAAeC,GAC3C,EAAE,gBAAa,mBAAgBA,EAAI,OACnC,EAAE,WAAQ,mBAAgBA,EAAI,OAC9B,EAAE,sBAAmB,0BAAuBA,EAAI,QAChD,EAAE,WAAQ,SAAM,aAAUA,EAAI,UAC9B,EAAE,eAAY,sBAAmBA,EAAI;CAE3C,OAAO;EACL,OAAO,GAAI,GAAO;GAChB,IAAMC,IAAOC,EAAYC,CAAE;GAE3B,AADAC,EAAOD,GAAI,QAAQ,GACnBE,EAAO,eAAe;IAAE;IAAI,MAAMJ,EAAK;IAAM,IAAIK,EAAM;GAAK,GAAG,QAAQ;EACzE;EAEA,QAAQ,GAAI,GAAM;GAChB,IAAML,IAAOC,EAAYC,CAAE;GAC3B,EAAOA,GAAI,iBAAiB;GAC5B,IAAMI,IAAUN,EAAK,SAAS,eAAeO,EAAQC,GAAaN,GAAIF,EAAK,MAAMS,CAAI;GACrF,EAAK,WAAWH,SAAe;IAE7B,AADIA,KAASI,EAAWR,CAAE,GAC1BE,EAAO,eAAe;KAAE;KAAI,MAAMJ,EAAK;KAAM,IAAIS;IAAK,GAAG,SAAS;GACpE,CAAC;EACH;EAEA,SAAS,GAAI,GAAO;GAClB,EAAkBE,CAAK;GACvB,IAAMX,IAAOC,EAAYC,CAAE;GAG3B,IAFAC,EAAOD,GAAI,SAAS,GAChBF,EAAK,UAAUW,KAAOC,EAAYD,GAAO,iBAAiB,GAC1DX,EAAK,WAAW,MAAM;IACxB,IAAMa,IAAaZ,EAAYD,EAAK,MAAM;IAC1C,EAAmBE,GAAIS,GAAOX,EAAK,QAAQa,EAAW,OAAO,SAAS;GACxE;GACA,IAAIb,EAAK,UAAUW,GAAO;GAC1B,IAAMG,IAAoB,CAACZ,CAAE;GAC7B,EAAYA,GAAIY,CAAO;GACvB,KAAK,IAAMC,KAAOD,GAAS,EAAOC,GAAK,SAAS;GAChD,AAAID,EAAQ,WAAW,IACrBV,EAAO,gBAAgB;IAAE;IAAI,MAAMJ,EAAK;IAAO,IAAIW;GAAM,GAAG,UAAU,IAEtEK,EAAM,kBAAkB;IACtB,KAAK,IAAMD,KAAOD,GAAS;KACzB,IAAMG,IAAMhB,EAAYc,CAAG;KAC3B,AAAIE,EAAI,UAAUN,KAClBP,EAAO,gBAAgB;MAAE,IAAIW;MAAK,MAAME,EAAI;MAAO,IAAIN;KAAM,GAAG,UAAU;IAC5E;GACF,CAAC;EAEL;EAEA,aAAa,GAAI,GAAW;GAC1B,IAAMX,IAAOC,EAAYC,CAAE;GAE3B,AADAC,EAAOD,GAAI,UAAU,GACjB,GAAcF,EAAK,WAAWkB,CAAS,KAC3Cd,EAAO,oBAAoB;IAAE;IAAI,MAAMJ,EAAK;IAAW,IAAIkB;GAAU,GAAG,cAAc;EACxF;EAEA,UAAU,GAAI,GAAQ;GACpB,IAAMlB,IAAOC,EAAYC,CAAE;GAC3B,IAAIF,EAAK,SAAS,aAAa,MAAU,MAAM,WAAWE,EAAG,qBAAqB;GAClF,EAAOA,GAAI,mBAAmB;GAC9B,IAAIiB;GACJ,IAAI,OAAOC,KAAW,UAEpB;QADA,IAAMC,EAAY,KAAKD,CAAM,KAA2C,MACpED,MAAO,MAAM,MAAU,MAAM,qBAAqBC,EAAO,2BAA2B;GAAA,OAExF,IAAKA;GAEP,IAAME,IAAOtB,EAAK,UAAU;GAC5B,IAAIsB,MAASH,GAAI;GACjB,AAAIA,MAAO,QAAMI,EAAe;GAChC,IAAMC,IAAUF,MAAS,OAAO,KAAA,IAAYD,EAAY,MAAMC,CAAI,GAC5DG,IAAQN,MAAO,OAAO,KAAA,IAAYE,EAAY,MAAMF,CAAE,GACtDO,IAA4B;IAChC;IACA,GAAIF,MAAY,KAAA,IAA0B,CAAC,IAAf,EAAE,WAAQ;IACtC,GAAIC,MAAU,KAAA,IAAwB,CAAC,IAAb,EAAE,SAAM;GACpC;GAEA,AADAE,EAAW,IAAID,GAAS;IAAE;IAAM;GAAG,CAAC,GACpCE,EAAK,aAAa,UAAY;IAE5B,AADAlB,EAAWR,CAAE,GACbE,EAAO,iBAAiBsB,GAAS,WAAW;GAC9C,CAAC;EACH;EAEA,SAAS,GAAI,GAAO;GAClB,IAAM1B,IAAOC,EAAYC,CAAE;GAC3B,IAAIF,EAAK,SAAS,aAAa,MAAU,MAAM,WAAWE,EAAG,qBAAqB;GAElF,AADAC,EAAOD,GAAI,kBAAkB,GAC7BE,EAAO,gBAAgB;IAAE;IAAI,MAAMJ,EAAK;IAAO,IAAI6B,KAAS,KAAA;GAAU,GAAG,UAAU;EACrF;CACF;AACF"}
+{"version":3,"file":"fieldEdits.js","names":[],"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      // A container with a layout owns where its children go, however one is moved.\n      const parent = node.parent === null ? undefined : requireNode(node.parent);\n      const arranger = parent?.kind === 'container' && parent.layout !== undefined ? parent.id : null;\n      edit('setPose', resizes || arranger !== null, () => {\n        if (resizes) noteChange(id);\n        noteChange(arranger);\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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"}