@weasel-js/core 1.10.1 → 1.11.1

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

@@ -1 +1 @@
-{"version":3,"file":"depMemo.js","names":["emptyDepRecord","RecordedDep","dep","paths","index","deriveRecorded","derive","deps","into","snapshotPose","sameDeps","record","ids","depOf","samePoseValue","path"],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that changed with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing, a lookup\n * answering nodes no scene edits — is invisible to that key. Recording what\n * the derivation was handed and comparing it on the hit path is what notices\n * it without a trigger.\n *\n * What is recorded is what a derivation may read of a dependency: its node (an\n * identity), its pose (by value), its `data` (a reference, which every edit\n * replaces), its `layer`, and its path where the derivation read it. Anything\n * else on the node — its parent, its children — still needs a push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, Node, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — with a copy of the pose it resolved to, its `data` and `layer`, and\n *  the path it answered, `undefined` where the derivation never asked. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n  data: unknown[];\n  layers: (string | undefined)[];\n  paths: (Path | null | undefined)[];\n}\n\nexport function emptyDepRecord<TPose>(): DepRecord<TPose> {\n  return { nodes: [], poses: [], data: [], layers: [], paths: [] };\n}\n\n/** A dependency as the derivation is handed it, noting a read of its path. A\n *  class for the reason `SceneDep` is one: a prototype accessor is cheap. */\nclass RecordedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly dep: DerivedDep<TPose>,\n    private readonly paths: (Path | null | undefined)[],\n    private readonly index: number,\n  ) {\n    this.node = dep.node;\n    this.pose = dep.pose;\n  }\n\n  get path(): Path | null {\n    return (this.paths[this.index] = this.dep.path);\n  }\n}\n\n/** Run `derive` against `deps`, recording in place what it was run against.\n *  Mutating the record is what updates the memo slot, which holds this object. */\nexport function deriveRecorded<TPose, T>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  derive: (deps: readonly (DerivedDep<TPose> | undefined)[]) => T,\n): T {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  into.data.length = 0;\n  into.layers.length = 0;\n  into.paths.length = 0;\n  const handed = deps.map((dep, i) => {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n    into.data.push(dep?.node.data);\n    into.layers.push(dep?.node.layer);\n    into.paths.push(undefined);\n    return dep === undefined ? undefined : new RecordedDep(dep, into.paths, i);\n  });\n  return derive(handed);\n}\n\n/** Whether the dependencies still resolve to what the record was taken from.\n *  Resolves them one at a time rather than taking an array: this is the hit\n *  path, and it walks every derived node's every dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep === undefined) continue;\n    if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;\n    if (!samePoseValue(record.poses[i], dep.pose)) return false;\n    const path = record.paths[i];\n    if (path !== undefined && path !== dep.path) return false;\n  }\n  return true;\n}\n"],"mappings":";;AA8BA,SAAgBA,IAA0C;CACxD,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO,CAAC;EAAG,MAAM,CAAC;EAAG,QAAQ,CAAC;EAAG,OAAO,CAAC;CAAE;AACjE;AAIA,IAAMC,IAAN,MAAsD;CAKjC;CACA;CACA;CANnB;CACA;CAEA,YACE,GACA,GACA,GACA;EAEA,AALiB,KAAA,MAAAC,GACA,KAAA,QAAAC,GACA,KAAA,QAAAC,GAEjB,KAAK,OAAOF,EAAI,MAChB,KAAK,OAAOA,EAAI;CAClB;CAEA,IAAI,OAAoB;EACtB,OAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI;CAC5C;AACF;AAIA,SAAgBG,EACd,GACA,GACA,GACG;CAcH,OAbA,EAAK,MAAM,SAAS,GACpB,EAAK,MAAM,SAAS,GACpB,EAAK,KAAK,SAAS,GACnB,EAAK,OAAO,SAAS,GACrB,EAAK,MAAM,SAAS,GASbC,EARQC,EAAK,KAAK,GAAK,OAC5BC,EAAK,MAAM,KAAKN,GAAK,IAAI,GACzBM,EAAK,MAAM,KAAKN,MAAQ,KAAA,IAAY,KAAA,IAAYO,EAAaP,EAAI,IAAI,CAAC,GACtEM,EAAK,KAAK,KAAKN,GAAK,KAAK,IAAI,GAC7BM,EAAK,OAAO,KAAKN,GAAK,KAAK,KAAK,GAChCM,EAAK,MAAM,KAAK,KAAA,CAAS,GAClBN,MAAQ,KAAA,IAAY,KAAA,IAAY,IAAID,EAAYC,GAAKM,EAAK,OAAO,CAAC,EAE7D,CAAM;AACtB;AAKA,SAAgBE,EACd,GACA,GACA,GACS;CACT,IAAIC,EAAO,MAAM,WAAWC,EAAI,QAAQ,OAAO;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAIA,EAAI,QAAQ,KAAK;EACnC,IAAMV,IAAMW,EAAMD,EAAI,EAAE;EACxB,IAAID,EAAO,MAAM,QAAQT,MAAQ,KAAA,IAAY,KAAA,IAAYA,EAAI,OAAO,OAAO;EAC3E,IAAIA,MAAQ,KAAA,GAAW;EAEvB,IADIS,EAAO,KAAK,OAAOT,EAAI,KAAK,QAAQS,EAAO,OAAO,OAAOT,EAAI,KAAK,SAClE,CAACY,EAAcH,EAAO,MAAM,IAAIT,EAAI,IAAI,GAAG,OAAO;EACtD,IAAMa,IAAOJ,EAAO,MAAM;EAC1B,IAAII,MAAS,KAAA,KAAaA,MAASb,EAAI,MAAM,OAAO;CACtD;CACA,OAAO;AACT"}
+{"version":3,"file":"depMemo.js","names":[],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that changed with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing, a lookup\n * answering nodes no scene edits — is invisible to that key. Recording what\n * the derivation was handed and comparing it on the hit path is what notices\n * it without a trigger.\n *\n * What is recorded is what a derivation may read of a dependency: its node (an\n * identity), its pose (by value), its `data` (a reference, which every edit\n * replaces), its `layer`, and its path where the derivation read it. Anything\n * else on the node — its parent, its children — still needs a push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, Node, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — with a copy of the pose it resolved to, its `data` and `layer`, and\n *  the path it answered, `undefined` where the derivation never asked. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n  data: unknown[];\n  layers: (string | undefined)[];\n  paths: (Path | null | undefined)[];\n}\n\nexport function emptyDepRecord<TPose>(): DepRecord<TPose> {\n  return { nodes: [], poses: [], data: [], layers: [], paths: [] };\n}\n\n/** A dependency as the derivation is handed it, noting a read of its path. A\n *  class for the reason `SceneDep` is one: a prototype accessor is cheap. */\nclass RecordedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly dep: DerivedDep<TPose>,\n    private readonly paths: (Path | null | undefined)[],\n    private readonly index: number,\n  ) {\n    this.node = dep.node;\n    this.pose = dep.pose;\n  }\n\n  get path(): Path | null {\n    return (this.paths[this.index] = this.dep.path);\n  }\n}\n\n/** Run `derive` against `deps`, recording in place what it was run against.\n *  Mutating the record is what updates the memo slot, which holds this object. */\nexport function deriveRecorded<TPose, T>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  derive: (deps: readonly (DerivedDep<TPose> | undefined)[]) => T,\n): T {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  into.data.length = 0;\n  into.layers.length = 0;\n  into.paths.length = 0;\n  const handed = deps.map((dep, i) => {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n    into.data.push(dep?.node.data);\n    into.layers.push(dep?.node.layer);\n    into.paths.push(undefined);\n    return dep === undefined ? undefined : new RecordedDep(dep, into.paths, i);\n  });\n  return derive(handed);\n}\n\n/** Whether the dependencies still resolve to what the record was taken from.\n *  Resolves them one at a time rather than taking an array: this is the hit\n *  path, and it walks every derived node's every dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep === undefined) continue;\n    if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;\n    if (!samePoseValue(record.poses[i], dep.pose)) return false;\n    const path = record.paths[i];\n    if (path !== undefined && path !== dep.path) return false;\n  }\n  return true;\n}\n"],"mappings":";;;AA8BA,SAAgB,iBAA0C;CACxD,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO,CAAC;EAAG,MAAM,CAAC;EAAG,QAAQ,CAAC;EAAG,OAAO,CAAC;CAAE;AACjE;;;AAIA,IAAM,cAAN,MAAsD;CAKjC;CACA;CACA;CANnB;CACA;CAEA,YACE,KACA,OACA,OACA;EAHiB,KAAA,MAAA;EACA,KAAA,QAAA;EACA,KAAA,QAAA;EAEjB,KAAK,OAAO,IAAI;EAChB,KAAK,OAAO,IAAI;CAClB;CAEA,IAAI,OAAoB;EACtB,OAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI;CAC5C;AACF;;;AAIA,SAAgB,eACd,MACA,MACA,QACG;CACH,KAAK,MAAM,SAAS;CACpB,KAAK,MAAM,SAAS;CACpB,KAAK,KAAK,SAAS;CACnB,KAAK,OAAO,SAAS;CACrB,KAAK,MAAM,SAAS;CASpB,OAAO,OARQ,KAAK,KAAK,KAAK,MAAM;EAClC,KAAK,MAAM,KAAK,KAAK,IAAI;EACzB,KAAK,MAAM,KAAK,QAAQ,SAAY,SAAY,aAAa,IAAI,IAAI,CAAC;EACtE,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI;EAC7B,KAAK,OAAO,KAAK,KAAK,KAAK,KAAK;EAChC,KAAK,MAAM,KAAK,MAAS;EACzB,OAAO,QAAQ,SAAY,SAAY,IAAI,YAAY,KAAK,KAAK,OAAO,CAAC;CAC3E,CACc,CAAM;AACtB;;;;AAKA,SAAgB,SACd,QACA,KACA,OACS;CACT,IAAI,OAAO,MAAM,WAAW,IAAI,QAAQ,OAAO;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,MAAM,MAAM,IAAI,EAAE;EACxB,IAAI,OAAO,MAAM,QAAQ,QAAQ,SAAY,SAAY,IAAI,OAAO,OAAO;EAC3E,IAAI,QAAQ,QAAW;EACvB,IAAI,OAAO,KAAK,OAAO,IAAI,KAAK,QAAQ,OAAO,OAAO,OAAO,IAAI,KAAK,OAAO,OAAO;EACpF,IAAI,CAAC,cAAc,OAAO,MAAM,IAAI,IAAI,IAAI,GAAG,OAAO;EACtD,MAAM,OAAO,OAAO,MAAM;EAC1B,IAAI,SAAS,UAAa,SAAS,IAAI,MAAM,OAAO;CACtD;CACA,OAAO;AACT"}

package/dist/core/scene/dependents.js

@@ -1,66 +1,94 @@
 //#region src/core/scene/dependents.ts
-var e = Object.freeze([]);
-function t(t, n) {
-	let r = t.dependsOn;
-	return r === void 0 ? e : r === "children" ? n(t.id) : r;
+var NONE = Object.freeze([]);
+/**
+* The nodes `node`'s geometry derives from: the ids it named, or its own
+* children when it named `'children'`.
+*
+* The `'children'` form is deliberately absent from the reverse index — a
+* container is not a dependent of the children it hugs, or deleting one child
+* would cascade the whole group away. Its invalidation is the ancestor walk in
+* `scene.ts` instead.
+*/
+function dependencyIdsOf(node, childrenOf) {
+	const deps = node.dependsOn;
+	if (deps === void 0) return NONE;
+	return deps === "children" ? childrenOf(node.id) : deps;
 }
-function n() {
-	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
-	function r(e) {
-		let r = n.get(e);
-		if (r !== void 0) {
-			for (let n of r) {
-				let r = t.get(n);
-				r !== void 0 && (r.delete(e), r.size === 0 && t.delete(n));
-			}
-			n.delete(e);
+function createDependentsIndex() {
+	/** dependency -> nodes deriving from it */
+	const forward = /* @__PURE__ */ new Map();
+	/** dependent -> the dependencies it registered against */
+	const reverse = /* @__PURE__ */ new Map();
+	/** Drop `id`'s registrations against its current dependencies. Shared by
+	*  `add` (which re-registers after) and `remove` (which does not). */
+	function detachOwnDeps(id) {
+		const old = reverse.get(id);
+		if (old === void 0) return;
+		for (const dep of old) {
+			const set = forward.get(dep);
+			if (set === void 0) continue;
+			set.delete(id);
+			if (set.size === 0) forward.delete(dep);
 		}
+		reverse.delete(id);
 	}
 	return {
-		add(e, i) {
-			if (r(e), i.length !== 0) {
-				n.set(e, [...i]);
-				for (let n of i) {
-					let r = t.get(n);
-					r === void 0 && (r = /* @__PURE__ */ new Set(), t.set(n, r)), r.add(e);
+		add(id, deps) {
+			detachOwnDeps(id);
+			if (deps.length === 0) return;
+			reverse.set(id, [...deps]);
+			for (const dep of deps) {
+				let set = forward.get(dep);
+				if (set === void 0) {
+					set = /* @__PURE__ */ new Set();
+					forward.set(dep, set);
 				}
+				set.add(id);
 			}
 		},
-		remove(e) {
-			r(e);
+		remove(id) {
+			detachOwnDeps(id);
 		},
 		clear() {
-			t.clear(), n.clear();
+			forward.clear();
+			reverse.clear();
 		},
 		isEmpty() {
-			return t.size === 0;
+			return forward.size === 0;
 		},
-		dependentsOf(n) {
-			let r = t.get(n);
-			return r === void 0 ? e : [...r];
+		dependentsOf(id) {
+			const set = forward.get(id);
+			return set === void 0 ? NONE : [...set];
 		},
-		transitiveDependentsOf(n) {
-			let r = t.get(n);
-			if (r === void 0) return e;
-			let i = /* @__PURE__ */ new Set(), a = [...r];
-			for (; a.length > 0;) {
-				let e = a.pop();
-				if (!i.has(e)) {
-					i.add(e);
-					for (let n of t.get(e) ?? []) a.push(n);
-				}
+		transitiveDependentsOf(id) {
+			const direct = forward.get(id);
+			if (direct === void 0) return NONE;
+			const out = /* @__PURE__ */ new Set();
+			const stack = [...direct];
+			while (stack.length > 0) {
+				const next = stack.pop();
+				if (out.has(next)) continue;
+				out.add(next);
+				for (const d of forward.get(next) ?? []) stack.push(d);
 			}
-			return i;
+			return out;
 		}
 	};
 }
-function r(e, t) {
-	if (e === t) return !0;
-	if (e === void 0 || t === void 0 || e === "children" || t === "children" || e.length !== t.length) return !1;
-	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
-	return !0;
+/**
+* Whether two `dependsOn` values name the same thing, so a retarget to what a
+* node already declares can be elided. Order is part of it: a router reads its
+* ends positionally, and swapping them reverses the edge.
+*/
+function sameDependsOn(a, b) {
+	if (a === b) return true;
+	if (a === void 0 || b === void 0) return false;
+	if (a === "children" || b === "children") return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
 }
-//#endregion
-export { n as createDependentsIndex, t as dependencyIdsOf, r as sameDependsOn };
 
+//#endregion
+export { createDependentsIndex, dependencyIdsOf, sameDependsOn };
 //# sourceMappingURL=dependents.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"dependents.js","names":["NONE","dependencyIdsOf","deps","node","childrenOf","createDependentsIndex","forward","reverse","detachOwnDeps","old","id","dep","set","direct","out","stack","next","d","sameDependsOn","a","b","i"],"sources":["../../../src/core/scene/dependents.ts"],"sourcesContent":["/**\n * Which nodes must recompute when a given node's pose changes — the reverse\n * index, plus {@link dependencyIdsOf}, the forward read it is built from.\n */\nimport type { NodeId } from './types';\n\nconst NONE: readonly NodeId[] = Object.freeze([]);\n\n/**\n * The nodes `node`'s geometry derives from: the ids it named, or its own\n * children when it named `'children'`.\n *\n * The `'children'` form is deliberately absent from the reverse index — a\n * container is not a dependent of the children it hugs, or deleting one child\n * would cascade the whole group away. Its invalidation is the ancestor walk in\n * `scene.ts` instead.\n */\nexport function dependencyIdsOf(\n  node: { id: NodeId; dependsOn?: readonly NodeId[] | 'children' },\n  childrenOf: (id: NodeId) => readonly NodeId[],\n): readonly NodeId[] {\n  const deps = node.dependsOn;\n  if (deps === undefined) return NONE;\n  return deps === 'children' ? childrenOf(node.id) : deps;\n}\n\nexport interface DependentsIndex {\n  add(id: NodeId, deps: readonly NodeId[]): void;\n  /** Forget what `id` declared. Deliberately not symmetric: who depends on\n   *  `id` is those nodes' declaration, not `id`'s, and outlives its removal. */\n  remove(id: NodeId): void;\n  /** Forget every registration. */\n  clear(): void;\n  /** True when nothing derives from anything. */\n  isEmpty(): boolean;\n  dependentsOf(id: NodeId): Iterable<NodeId>;\n  /** Nodes that derive from `id` directly or through a chain. Excludes `id`\n   *  itself unless a cycle leads back to it. */\n  transitiveDependentsOf(id: NodeId): Iterable<NodeId>;\n}\n\nexport function createDependentsIndex(): DependentsIndex {\n  /** dependency -> nodes deriving from it */\n  const forward = new Map<NodeId, Set<NodeId>>();\n  /** dependent -> the dependencies it registered against */\n  const reverse = new Map<NodeId, readonly NodeId[]>();\n\n  /** Drop `id`'s registrations against its current dependencies. Shared by\n   *  `add` (which re-registers after) and `remove` (which does not). */\n  function detachOwnDeps(id: NodeId): void {\n    const old = reverse.get(id);\n    if (old === undefined) return;\n    for (const dep of old) {\n      const set = forward.get(dep);\n      if (set === undefined) continue;\n      set.delete(id);\n      if (set.size === 0) forward.delete(dep);\n    }\n    reverse.delete(id);\n  }\n\n  return {\n    add(id, deps) {\n      detachOwnDeps(id);\n      if (deps.length === 0) return;\n      reverse.set(id, [...deps]);\n      for (const dep of deps) {\n        let set = forward.get(dep);\n        if (set === undefined) { set = new Set(); forward.set(dep, set); }\n        set.add(id);\n      }\n    },\n\n    remove(id) {\n      detachOwnDeps(id);\n    },\n\n    clear() {\n      forward.clear();\n      reverse.clear();\n    },\n\n    isEmpty() {\n      return forward.size === 0;\n    },\n\n    dependentsOf(id) {\n      const set = forward.get(id);\n      return set === undefined ? NONE : [...set];\n    },\n\n    transitiveDependentsOf(id) {\n      // Runs per node per frame; the miss must not allocate.\n      const direct = forward.get(id);\n      if (direct === undefined) return NONE;\n      const out = new Set<NodeId>();\n      const stack: NodeId[] = [...direct];\n      while (stack.length > 0) {\n        const next = stack.pop()!;\n        if (out.has(next)) continue;   // also what stops a cycle\n        out.add(next);\n        for (const d of forward.get(next) ?? []) stack.push(d);\n      }\n      return out;\n    },\n  };\n}\n\n/**\n * Whether two `dependsOn` values name the same thing, so a retarget to what a\n * node already declares can be elided. Order is part of it: a router reads its\n * ends positionally, and swapping them reverses the edge.\n */\nexport function sameDependsOn(\n  a: readonly NodeId[] | 'children' | undefined,\n  b: readonly NodeId[] | 'children' | undefined,\n): boolean {\n  if (a === b) return true;\n  if (a === undefined || b === undefined) return false;\n  if (a === 'children' || b === 'children') return false;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";AAMA,IAAMA,IAA0B,OAAO,OAAO,CAAC,CAAC;AAWhD,SAAgBC,EACd,GACA,GACmB;CACnB,IAAMC,IAAOC,EAAK;CAElB,OADID,MAAS,KAAA,IAAkBF,IACxBE,MAAS,aAAaE,EAAWD,EAAK,EAAE,IAAID;AACrD;AAiBA,SAAgBG,IAAyC;CAEvD,IAAMC,oBAAU,IAAI,IAAyB,GAEvCC,oBAAU,IAAI,IAA+B;CAInD,SAASC,EAAc,GAAkB;EACvC,IAAMC,IAAMF,EAAQ,IAAIG,CAAE;EAC1B,IAAID,MAAQ,KAAA,GACZ;QAAK,IAAME,KAAOF,GAAK;IACrB,IAAMG,IAAMN,EAAQ,IAAIK,CAAG;IAC3B,AAAIC,MAAQ,KAAA,MACZA,EAAI,OAAOF,CAAE,GACTE,EAAI,SAAS,KAAGN,EAAQ,OAAOK,CAAG;GACxC;GACA,EAAQ,OAAOD,CAAE;EADjB;CAEF;CAEA,OAAO;EACL,IAAI,GAAI,GAAM;GAEZ,IADAF,EAAcE,CAAE,GACZR,EAAK,WAAW,GACpB;MAAQ,IAAIQ,GAAI,CAAC,GAAGR,CAAI,CAAC;IACzB,KAAK,IAAMS,KAAOT,GAAM;KACtB,IAAIU,IAAMN,EAAQ,IAAIK,CAAG;KAEzB,AADIC,MAAQ,KAAA,MAAa,oBAAM,IAAI,IAAI,GAAGN,EAAQ,IAAIK,GAAKC,CAAG,IAC9DA,EAAI,IAAIF,CAAE;IACZ;GALyB;EAM3B;EAEA,OAAO,GAAI;GACT,EAAcA,CAAE;EAClB;EAEA,QAAQ;GAEN,AADAJ,EAAQ,MAAM,GACdC,EAAQ,MAAM;EAChB;EAEA,UAAU;GACR,OAAOD,EAAQ,SAAS;EAC1B;EAEA,aAAa,GAAI;GACf,IAAMM,IAAMN,EAAQ,IAAII,CAAE;GAC1B,OAAOE,MAAQ,KAAA,IAAYZ,IAAO,CAAC,GAAGY,CAAG;EAC3C;EAEA,uBAAuB,GAAI;GAEzB,IAAMC,IAASP,EAAQ,IAAII,CAAE;GAC7B,IAAIG,MAAW,KAAA,GAAW,OAAOb;GACjC,IAAMc,oBAAM,IAAI,IAAY,GACtBC,IAAkB,CAAC,GAAGF,CAAM;GAClC,OAAOE,EAAM,SAAS,IAAG;IACvB,IAAMC,IAAOD,EAAM,IAAI;IACvB,IAAI,GAAI,IAAIC,CAAI,GAChB;OAAI,IAAIA,CAAI;KACZ,KAAK,IAAMC,KAAKX,EAAQ,IAAIU,CAAI,KAAK,CAAC,GAAG,EAAM,KAAKC,CAAC;IADzC;GAEd;GACA,OAAOH;EACT;CACF;AACF;AAOA,SAAgBI,EACd,GACA,GACS;CACT,IAAIC,MAAMC,GAAG,OAAO;CAGpB,IAFID,MAAM,KAAA,KAAaC,MAAM,KAAA,KACzBD,MAAM,cAAcC,MAAM,cAC1BD,EAAE,WAAWC,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAIC,IAAI,GAAGA,IAAIF,EAAE,QAAQ,KAAK,IAAIA,EAAEE,OAAOD,EAAEC,IAAI,OAAO;CAC7D,OAAO;AACT"}
+{"version":3,"file":"dependents.js","names":[],"sources":["../../../src/core/scene/dependents.ts"],"sourcesContent":["/**\n * Which nodes must recompute when a given node's pose changes — the reverse\n * index, plus {@link dependencyIdsOf}, the forward read it is built from.\n */\nimport type { NodeId } from './types';\n\nconst NONE: readonly NodeId[] = Object.freeze([]);\n\n/**\n * The nodes `node`'s geometry derives from: the ids it named, or its own\n * children when it named `'children'`.\n *\n * The `'children'` form is deliberately absent from the reverse index — a\n * container is not a dependent of the children it hugs, or deleting one child\n * would cascade the whole group away. Its invalidation is the ancestor walk in\n * `scene.ts` instead.\n */\nexport function dependencyIdsOf(\n  node: { id: NodeId; dependsOn?: readonly NodeId[] | 'children' },\n  childrenOf: (id: NodeId) => readonly NodeId[],\n): readonly NodeId[] {\n  const deps = node.dependsOn;\n  if (deps === undefined) return NONE;\n  return deps === 'children' ? childrenOf(node.id) : deps;\n}\n\nexport interface DependentsIndex {\n  add(id: NodeId, deps: readonly NodeId[]): void;\n  /** Forget what `id` declared. Deliberately not symmetric: who depends on\n   *  `id` is those nodes' declaration, not `id`'s, and outlives its removal. */\n  remove(id: NodeId): void;\n  /** Forget every registration. */\n  clear(): void;\n  /** True when nothing derives from anything. */\n  isEmpty(): boolean;\n  dependentsOf(id: NodeId): Iterable<NodeId>;\n  /** Nodes that derive from `id` directly or through a chain. Excludes `id`\n   *  itself unless a cycle leads back to it. */\n  transitiveDependentsOf(id: NodeId): Iterable<NodeId>;\n}\n\nexport function createDependentsIndex(): DependentsIndex {\n  /** dependency -> nodes deriving from it */\n  const forward = new Map<NodeId, Set<NodeId>>();\n  /** dependent -> the dependencies it registered against */\n  const reverse = new Map<NodeId, readonly NodeId[]>();\n\n  /** Drop `id`'s registrations against its current dependencies. Shared by\n   *  `add` (which re-registers after) and `remove` (which does not). */\n  function detachOwnDeps(id: NodeId): void {\n    const old = reverse.get(id);\n    if (old === undefined) return;\n    for (const dep of old) {\n      const set = forward.get(dep);\n      if (set === undefined) continue;\n      set.delete(id);\n      if (set.size === 0) forward.delete(dep);\n    }\n    reverse.delete(id);\n  }\n\n  return {\n    add(id, deps) {\n      detachOwnDeps(id);\n      if (deps.length === 0) return;\n      reverse.set(id, [...deps]);\n      for (const dep of deps) {\n        let set = forward.get(dep);\n        if (set === undefined) { set = new Set(); forward.set(dep, set); }\n        set.add(id);\n      }\n    },\n\n    remove(id) {\n      detachOwnDeps(id);\n    },\n\n    clear() {\n      forward.clear();\n      reverse.clear();\n    },\n\n    isEmpty() {\n      return forward.size === 0;\n    },\n\n    dependentsOf(id) {\n      const set = forward.get(id);\n      return set === undefined ? NONE : [...set];\n    },\n\n    transitiveDependentsOf(id) {\n      // Runs per node per frame; the miss must not allocate.\n      const direct = forward.get(id);\n      if (direct === undefined) return NONE;\n      const out = new Set<NodeId>();\n      const stack: NodeId[] = [...direct];\n      while (stack.length > 0) {\n        const next = stack.pop()!;\n        if (out.has(next)) continue;   // also what stops a cycle\n        out.add(next);\n        for (const d of forward.get(next) ?? []) stack.push(d);\n      }\n      return out;\n    },\n  };\n}\n\n/**\n * Whether two `dependsOn` values name the same thing, so a retarget to what a\n * node already declares can be elided. Order is part of it: a router reads its\n * ends positionally, and swapping them reverses the edge.\n */\nexport function sameDependsOn(\n  a: readonly NodeId[] | 'children' | undefined,\n  b: readonly NodeId[] | 'children' | undefined,\n): boolean {\n  if (a === b) return true;\n  if (a === undefined || b === undefined) return false;\n  if (a === 'children' || b === 'children') return false;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";AAMA,IAAM,OAA0B,OAAO,OAAO,CAAC,CAAC;;;;;;;;;;AAWhD,SAAgB,gBACd,MACA,YACmB;CACnB,MAAM,OAAO,KAAK;CAClB,IAAI,SAAS,QAAW,OAAO;CAC/B,OAAO,SAAS,aAAa,WAAW,KAAK,EAAE,IAAI;AACrD;AAiBA,SAAgB,wBAAyC;;CAEvD,MAAM,0BAAU,IAAI,IAAyB;;CAE7C,MAAM,0BAAU,IAAI,IAA+B;;;CAInD,SAAS,cAAc,IAAkB;EACvC,MAAM,MAAM,QAAQ,IAAI,EAAE;EAC1B,IAAI,QAAQ,QAAW;EACvB,KAAK,MAAM,OAAO,KAAK;GACrB,MAAM,MAAM,QAAQ,IAAI,GAAG;GAC3B,IAAI,QAAQ,QAAW;GACvB,IAAI,OAAO,EAAE;GACb,IAAI,IAAI,SAAS,GAAG,QAAQ,OAAO,GAAG;EACxC;EACA,QAAQ,OAAO,EAAE;CACnB;CAEA,OAAO;EACL,IAAI,IAAI,MAAM;GACZ,cAAc,EAAE;GAChB,IAAI,KAAK,WAAW,GAAG;GACvB,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC;GACzB,KAAK,MAAM,OAAO,MAAM;IACtB,IAAI,MAAM,QAAQ,IAAI,GAAG;IACzB,IAAI,QAAQ,QAAW;KAAE,sBAAM,IAAI,IAAI;KAAG,QAAQ,IAAI,KAAK,GAAG;IAAG;IACjE,IAAI,IAAI,EAAE;GACZ;EACF;EAEA,OAAO,IAAI;GACT,cAAc,EAAE;EAClB;EAEA,QAAQ;GACN,QAAQ,MAAM;GACd,QAAQ,MAAM;EAChB;EAEA,UAAU;GACR,OAAO,QAAQ,SAAS;EAC1B;EAEA,aAAa,IAAI;GACf,MAAM,MAAM,QAAQ,IAAI,EAAE;GAC1B,OAAO,QAAQ,SAAY,OAAO,CAAC,GAAG,GAAG;EAC3C;EAEA,uBAAuB,IAAI;GAEzB,MAAM,SAAS,QAAQ,IAAI,EAAE;GAC7B,IAAI,WAAW,QAAW,OAAO;GACjC,MAAM,sBAAM,IAAI,IAAY;GAC5B,MAAM,QAAkB,CAAC,GAAG,MAAM;GAClC,OAAO,MAAM,SAAS,GAAG;IACvB,MAAM,OAAO,MAAM,IAAI;IACvB,IAAI,IAAI,IAAI,IAAI,GAAG;IACnB,IAAI,IAAI,IAAI;IACZ,KAAK,MAAM,KAAK,QAAQ,IAAI,IAAI,KAAK,CAAC,GAAG,MAAM,KAAK,CAAC;GACvD;GACA,OAAO;EACT;CACF;AACF;;;;;;AAOA,SAAgB,cACd,GACA,GACS;CACT,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,MAAM,UAAa,MAAM,QAAW,OAAO;CAC/C,IAAI,MAAM,cAAc,MAAM,YAAY,OAAO;CACjD,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;CAC7D,OAAO;AACT"}

package/dist/core/scene/derivedParts.js

@@ -0,0 +1,58 @@
+import { cubicContoursToPath, pathToCubicContours } from "@weasel-js/geom";
+
+//#region src/core/scene/derivedParts.ts
+/**
+* A derived path that paints in several parts, each with its own fill and
+* stroke: the steps of a blend, the copies of a repeat.
+*
+* A derivation returns one `Path`, which is what picking, bounds and every
+* reader of `DerivedDep.path` see. {@link pathFromParts} makes that path out
+* of the parts and remembers the parts against it, so the derived-node
+* painter, handed the path, can paint each part as itself. The parts live as
+* long as the path does — in the derivation's memo.
+*/
+var PARTS = /* @__PURE__ */ new WeakMap();
+/**
+* One path holding every part's outline, with the parts remembered against
+* it for the painter. Return it from a `derivePath`. `null` for no parts.
+*/
+function pathFromParts(parts) {
+	if (parts.length === 0) return null;
+	const whole = parts.length === 1 ? parts[0].path : concatPaths(parts.map((p) => p.path));
+	const key = whole === parts[0].path ? { ...whole } : whole;
+	PARTS.set(key, parts);
+	return key;
+}
+/** The parts `path` was made from by {@link pathFromParts}, or `undefined`
+*  for any other path. */
+function derivedPartsOf(path) {
+	return path == null ? void 0 : PARTS.get(path);
+}
+function concatPaths(paths) {
+	const polys = paths.map((p) => p.kind === "rect" ? cubicContoursToPath(pathToCubicContours(p)) : p);
+	let commands = 0;
+	let coords = 0;
+	for (const p of polys) {
+		commands += p.commands.length;
+		coords += p.coords.length;
+	}
+	const out = {
+		kind: "polygon",
+		commands: new Uint8Array(commands),
+		coords: new Float32Array(coords),
+		fillRule: "nonzero"
+	};
+	let ci = 0;
+	let xi = 0;
+	for (const p of polys) {
+		out.commands.set(p.commands, ci);
+		out.coords.set(p.coords, xi);
+		ci += p.commands.length;
+		xi += p.coords.length;
+	}
+	return out;
+}
+
+//#endregion
+export { derivedPartsOf, pathFromParts };
+//# sourceMappingURL=derivedParts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivedParts.js","names":[],"sources":["../../../src/core/scene/derivedParts.ts"],"sourcesContent":["/**\n * A derived path that paints in several parts, each with its own fill and\n * stroke: the steps of a blend, the copies of a repeat.\n *\n * A derivation returns one `Path`, which is what picking, bounds and every\n * reader of `DerivedDep.path` see. {@link pathFromParts} makes that path out\n * of the parts and remembers the parts against it, so the derived-node\n * painter, handed the path, can paint each part as itself. The parts live as\n * long as the path does — in the derivation's memo.\n */\nimport { pathToCubicContours, cubicContoursToPath, type Path, type PolygonPath } from '@weasel-js/geom';\nimport type { Fill, Stroke } from '@weasel-js/paint';\n\n/** One painted piece of a derived path. */\nexport interface DerivedPart {\n  path: Path;\n  /** The part's fill. Absent, the node's own `data.fill` paints it; `null`\n   *  paints none. */\n  fill?: Fill | null;\n  /** The part's stroke, on the same terms as `fill`. */\n  stroke?: Stroke | null;\n}\n\nconst PARTS = new WeakMap<Path, readonly DerivedPart[]>();\n\n/**\n * One path holding every part's outline, with the parts remembered against\n * it for the painter. Return it from a `derivePath`. `null` for no parts.\n */\nexport function pathFromParts(parts: readonly DerivedPart[]): Path | null {\n  if (parts.length === 0) return null;\n  const whole = parts.length === 1 ? parts[0]!.path : concatPaths(parts.map((p) => p.path));\n  // A one-part path is the part's own, which another reader may hold; the\n  // painter must not mistake that path for a painted one elsewhere.\n  const key = whole === parts[0]!.path ? { ...whole } as Path : whole;\n  PARTS.set(key, parts);\n  return key;\n}\n\n/** The parts `path` was made from by {@link pathFromParts}, or `undefined`\n *  for any other path. */\nexport function derivedPartsOf(path: Path | null | undefined): readonly DerivedPart[] | undefined {\n  return path == null ? undefined : PARTS.get(path);\n}\n\nfunction concatPaths(paths: readonly Path[]): PolygonPath {\n  const polys = paths.map((p) => (p.kind === 'rect' ? cubicContoursToPath(pathToCubicContours(p)) : p));\n  let commands = 0;\n  let coords = 0;\n  for (const p of polys) {\n    commands += p.commands.length;\n    coords += p.coords.length;\n  }\n  const out: PolygonPath = {\n    kind: 'polygon',\n    commands: new Uint8Array(commands),\n    coords: new Float32Array(coords),\n    fillRule: 'nonzero',\n  };\n  let ci = 0;\n  let xi = 0;\n  for (const p of polys) {\n    out.commands.set(p.commands, ci);\n    out.coords.set(p.coords, xi);\n    ci += p.commands.length;\n    xi += p.coords.length;\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,IAAM,wBAAQ,IAAI,QAAsC;;;;;AAMxD,SAAgB,cAAc,OAA4C;CACxE,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,MAAM,QAAQ,MAAM,WAAW,IAAI,MAAM,EAAE,CAAE,OAAO,YAAY,MAAM,KAAK,MAAM,EAAE,IAAI,CAAC;CAGxF,MAAM,MAAM,UAAU,MAAM,EAAE,CAAE,OAAO,EAAE,GAAG,MAAM,IAAY;CAC9D,MAAM,IAAI,KAAK,KAAK;CACpB,OAAO;AACT;;;AAIA,SAAgB,eAAe,MAAmE;CAChG,OAAO,QAAQ,OAAO,SAAY,MAAM,IAAI,IAAI;AAClD;AAEA,SAAS,YAAY,OAAqC;CACxD,MAAM,QAAQ,MAAM,KAAK,MAAO,EAAE,SAAS,SAAS,oBAAoB,oBAAoB,CAAC,CAAC,IAAI,CAAE;CACpG,IAAI,WAAW;CACf,IAAI,SAAS;CACb,KAAK,MAAM,KAAK,OAAO;EACrB,YAAY,EAAE,SAAS;EACvB,UAAU,EAAE,OAAO;CACrB;CACA,MAAM,MAAmB;EACvB,MAAM;EACN,UAAU,IAAI,WAAW,QAAQ;EACjC,QAAQ,IAAI,aAAa,MAAM;EAC/B,UAAU;CACZ;CACA,IAAI,KAAK;CACT,IAAI,KAAK;CACT,KAAK,MAAM,KAAK,OAAO;EACrB,IAAI,SAAS,IAAI,EAAE,UAAU,EAAE;EAC/B,IAAI,OAAO,IAAI,EAAE,QAAQ,EAAE;EAC3B,MAAM,EAAE,SAAS;EACjB,MAAM,EAAE,OAAO;CACjB;CACA,OAAO;AACT"}

package/dist/core/scene/derivedPath.js

@@ -1,30 +1,60 @@
-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 { deriveRecorded, emptyDepRecord, sameDeps } from "./depMemo.js";
+import { dependencyIdsOf } from "./dependents.js";
+import { dropPoseKeyedMemoSlots, nodeMemo } from "./nodeMemo.js";
+
 //#region src/core/scene/derivedPath.ts
-var o = "kit:derivedPath", s = /* @__PURE__ */ new Set(), c = 0;
-function l(e, l, d, f = o) {
-	let p = e.derivePath;
-	if (p === void 0) return null;
-	let m = r(e, d);
-	if (m.length === 0) return null;
-	if (s.has(e.id)) return c++, null;
-	s.add(e.id);
-	let h = c;
+var SLOT = "kit:derivedPath";
+/** Ids whose path is on the stack. `dependsOn` is unvalidated, so a cycle
+*  resolves to `null` at whichever node closes it rather than overflowing
+*  the stack. */
+var resolving = /* @__PURE__ */ new Set();
+/** Bumped each time the guard above fires, so a value computed from a
+*  fallback is not cached — it is an artifact of which node was asked first. */
+var cycleHits = 0;
+/**
+* The path `node` computes from its dependencies, or `null` when it derives
+* from nothing (the normal case) or its `derivePath` has nothing to draw.
+*
+* `depOf` supplies each dependency — its node, the pose it is painted at, and
+* its own path; one it cannot resolve reaches `derivePath` as `undefined`.
+* `childrenOf` answers a node whose `dependsOn` is `'children'`.
+*
+* `memoSlot` separates a `depOf` that answers different poses than the scene's
+* own — the memo key cannot see which lookup filled it.
+*/
+function resolveDerivedPath(node, depOf, childrenOf, memoSlot = SLOT) {
+	const derivePath = node.derivePath;
+	if (derivePath === void 0) return null;
+	const ids = dependencyIdsOf(node, 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 = !1, o = a(e, f, e.pose, () => (r = !0, u(e, p, m.map(l), {
-			...t(),
-			path: null
-		})));
-		return !r && !n(o, m, l) && u(e, p, m.map(l), o), c !== h && i(e), o.path;
+		let computed = false;
+		const record = nodeMemo(node, memoSlot, node.pose, () => {
+			computed = true;
+			return draw(node, derivePath, ids.map(depOf), {
+				...emptyDepRecord(),
+				path: null
+			});
+		});
+		if (!computed && !sameDeps(record, ids, depOf)) draw(node, derivePath, ids.map(depOf), record);
+		if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);
+		return record.path;
 	} finally {
-		s.delete(e.id);
+		resolving.delete(node.id);
 	}
 }
-function u(t, n, r, i) {
-	return i.path = e(i, r, (e) => n(t, e)), i;
+/** Run `derivePath` against `deps` and record what it was run against. */
+function draw(node, derivePath, deps, into) {
+	into.path = deriveRecorded(into, deps, (handed) => derivePath(node, handed));
+	return into;
 }
-//#endregion
-export { l as resolveDerivedPath };
 
+//#endregion
+export { resolveDerivedPath };
 //# sourceMappingURL=derivedPath.js.map

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","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"}
+{"version":3,"file":"derivedPath.js","names":[],"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,IAAM,OAAO;;;;AAqBb,IAAM,4BAAY,IAAI,IAAY;;;AAIlC,IAAI,YAAY;;;;;;;;;;;;AAahB,SAAgB,mBACd,MACA,OACA,YACA,WAAmC,MACtB;CACb,MAAM,aAAa,KAAK;CACxB,IAAI,eAAe,QAAW,OAAO;CACrC,MAAM,MAAM,gBAAgB,MAAM,UAAU;CAC5C,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,IAAI,UAAU,IAAI,KAAK,EAAE,GAAG;EAC1B;EACA,OAAO;CACT;CACA,UAAU,IAAI,KAAK,EAAE;CACrB,MAAM,aAAa;CACnB,IAAI;EACF,IAAI,WAAW;EACf,MAAM,SAAS,SAA0B,MAAM,UAAU,KAAK,YAAY;GACxE,WAAW;GACX,OAAO,KAAK,MAAM,YAAY,IAAI,IAAI,KAAK,GAAG;IAAE,GAAG,eAAsB;IAAG,MAAM;GAAK,CAAC;EAC1F,CAAC;EAGD,IAAI,CAAC,YAAY,CAAC,SAAS,QAAQ,KAAK,KAAK,GAC3C,KAAK,MAAM,YAAY,IAAI,IAAI,KAAK,GAAG,MAAM;EAE/C,IAAI,cAAc,YAAY,uBAAuB,IAAI;EACzD,OAAO,OAAO;CAChB,UAAU;EACR,UAAU,OAAO,KAAK,EAAE;CAC1B;AACF;;AAGA,SAAS,KACP,MACA,YACA,MACA,MACiB;CACjB,KAAK,OAAO,eAAe,MAAM,OAAO,WAAW,WAAW,MAAe,MAAM,CAAC;CACpF,OAAO;AACT"}

package/dist/core/scene/docValues.js

@@ -0,0 +1,57 @@
+import { deepEqual } from "@weasel-js/registry";
+
+//#region src/core/scene/docValues.ts
+/**
+* Document state that is not a node — a document's pages, its theme — held as
+* named JSON values beside the tree, saved in its snapshot and undone with it.
+*/
+var SET_DOC = "kit:setDoc";
+function write(values, key, to) {
+	if (to === void 0) values.delete(key);
+	else values.set(key, to);
+}
+/** The snapshot side of a scene's document values, kept in `values`. */
+function createDocStore(values) {
+	return {
+		/** The values as a snapshot holds them, or `undefined` when there are none. */
+		toJSON() {
+			return values.size === 0 ? void 0 : Object.fromEntries(values);
+		},
+		/** Replace every value, outside history. */
+		reset(next) {
+			values.clear();
+			for (const [key, value] of Object.entries(next ?? {})) write(values, key, value);
+		}
+	};
+}
+/** Register `kit:setDoc` and answer with the `SceneDoc` that records it. */
+function createSceneDoc(env) {
+	const { values } = env;
+	env.register(SET_DOC, {
+		apply: (p) => {
+			const { key, to } = p;
+			write(values, key, to);
+		},
+		revert: (p) => {
+			const { key, from } = p;
+			write(values, key, from);
+		}
+	});
+	return {
+		get: (key) => values.get(key),
+		set(key, to) {
+			const from = values.get(key);
+			if (deepEqual(from, to)) return;
+			env.record(SET_DOC, {
+				key,
+				from,
+				to
+			}, "setDoc");
+		},
+		keys: () => [...values.keys()]
+	};
+}
+
+//#endregion
+export { createDocStore, createSceneDoc };
+//# sourceMappingURL=docValues.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"docValues.js","names":[],"sources":["../../../src/core/scene/docValues.ts"],"sourcesContent":["/**\n * Document state that is not a node — a document's pages, its theme — held as\n * named JSON values beside the tree, saved in its snapshot and undone with it.\n */\nimport { deepEqual } from '@weasel-js/registry';\nimport type { RegisteredOp } from './types';\n\n/**\n * A scene's document values. Keys are namespaced by their owner\n * (`core:pages`, `diagram:theme`); values are JSON, and are not to be mutated\n * once set. A `set` is a scene edit: undoable, part of an enclosing `batch`,\n * skipped when the value is deep-equal to the current one, and heard by\n * `subscribe`. Setting `undefined` removes the key.\n */\nexport interface SceneDoc {\n  get<T = unknown>(key: string): T | undefined;\n  set(key: string, value: unknown): void;\n  keys(): readonly string[];\n}\n\n/** The part of `Scene` that carries its document values. */\nexport interface SceneDocValues {\n  readonly doc: SceneDoc;\n}\n\n/** A snapshot's document values. */\nexport type SerializedDoc = Readonly<Record<string, unknown>>;\n\n/** `undefined` on either side means the key is absent there. */\ninterface SetDocPayload { key: string; from?: unknown; to?: unknown }\n\nconst SET_DOC = 'kit:setDoc';\n\nfunction write(values: Map<string, unknown>, key: string, to: unknown): void {\n  if (to === undefined) values.delete(key);\n  else values.set(key, to);\n}\n\n/** The snapshot side of a scene's document values, kept in `values`. */\nexport function createDocStore(values: Map<string, unknown>) {\n  return {\n    /** The values as a snapshot holds them, or `undefined` when there are none. */\n    toJSON(): SerializedDoc | undefined {\n      return values.size === 0 ? undefined : Object.fromEntries(values);\n    },\n    /** Replace every value, outside history. */\n    reset(next: SerializedDoc | undefined): void {\n      values.clear();\n      for (const [key, value] of Object.entries(next ?? {})) write(values, key, value);\n    },\n  };\n}\n\nexport interface SceneDocEnv {\n  values: Map<string, unknown>;\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  record(kind: string, payload: unknown, label: string): void;\n}\n\n/** Register `kit:setDoc` and answer with the `SceneDoc` that records it. */\nexport function createSceneDoc(env: SceneDocEnv): SceneDoc {\n  const { values } = env;\n  env.register(SET_DOC, {\n    apply: (p) => { const { key, to } = p as SetDocPayload; write(values, key, to); },\n    revert: (p) => { const { key, from } = p as SetDocPayload; write(values, key, from); },\n  });\n  return {\n    get: <T>(key: string) => values.get(key) as T | undefined,\n    set(key, to) {\n      const from = values.get(key);\n      if (deepEqual(from, to)) return;\n      env.record(SET_DOC, { key, from, to } satisfies SetDocPayload, 'setDoc');\n    },\n    keys: () => [...values.keys()],\n  };\n}\n"],"mappings":";;;;;;;AA+BA,IAAM,UAAU;AAEhB,SAAS,MAAM,QAA8B,KAAa,IAAmB;CAC3E,IAAI,OAAO,QAAW,OAAO,OAAO,GAAG;MAClC,OAAO,IAAI,KAAK,EAAE;AACzB;;AAGA,SAAgB,eAAe,QAA8B;CAC3D,OAAO;;EAEL,SAAoC;GAClC,OAAO,OAAO,SAAS,IAAI,SAAY,OAAO,YAAY,MAAM;EAClE;;EAEA,MAAM,MAAuC;GAC3C,OAAO,MAAM;GACb,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAAC,CAAC,GAAG,MAAM,QAAQ,KAAK,KAAK;EACjF;CACF;AACF;;AASA,SAAgB,eAAe,KAA4B;CACzD,MAAM,EAAE,WAAW;CACnB,IAAI,SAAS,SAAS;EACpB,QAAQ,MAAM;GAAE,MAAM,EAAE,KAAK,OAAO;GAAoB,MAAM,QAAQ,KAAK,EAAE;EAAG;EAChF,SAAS,MAAM;GAAE,MAAM,EAAE,KAAK,SAAS;GAAoB,MAAM,QAAQ,KAAK,IAAI;EAAG;CACvF,CAAC;CACD,OAAO;EACL,MAAS,QAAgB,OAAO,IAAI,GAAG;EACvC,IAAI,KAAK,IAAI;GACX,MAAM,OAAO,OAAO,IAAI,GAAG;GAC3B,IAAI,UAAU,MAAM,EAAE,GAAG;GACzB,IAAI,OAAO,SAAS;IAAE;IAAK;IAAM;GAAG,GAA2B,QAAQ;EACzE;EACA,YAAY,CAAC,GAAG,OAAO,KAAK,CAAC;CAC/B;AACF"}

package/dist/core/scene/editMode.js

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

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

@@ -1 +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"}
+{"version":3,"file":"editMode.js","names":[],"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,SAAgB,iBAA2B;CACzC,MAAM,QAAoC;EAAE,OAAO;EAAG,QAAQ;EAAG,WAAW;EAAG,KAAK;CAAE;CAEtF,OAAO;EACL,YAAY,MAAM,QAAQ,MAAM,SAAS,MAAM,YAAY,MAAM,MAAM;EACvE,eAAe,MAAM,SAAS,MAAM,cAAc;EAClD,iBAAiB,MAAM,YAAY;EACnC,OAAO,QAAQ,IAAI;GACjB,MAAM,OAAO;GACb,IAAI;IACF,OAAO,GAAG;GACZ,UAAU;IACR,MAAM,OAAO;GACf;EACF;CACF;AACF"}

package/dist/core/scene/editPass.js

@@ -0,0 +1,111 @@
+//#region src/core/scene/editPass.ts
+var emptyCollecting = () => ({
+	added: /* @__PURE__ */ new Set(),
+	removed: /* @__PURE__ */ new Set(),
+	posed: /* @__PURE__ */ new Set(),
+	reparented: /* @__PURE__ */ new Set(),
+	dataChanged: /* @__PURE__ */ new Set(),
+	docChanged: /* @__PURE__ */ new Set()
+});
+var snapshot = (c) => ({
+	added: new Set(c.added),
+	removed: new Set(c.removed),
+	posed: new Set(c.posed),
+	reparented: new Set(c.reparented),
+	dataChanged: new Set(c.dataChanged),
+	docChanged: new Set(c.docChanged)
+});
+var NOOP = {
+	name: "editPass",
+	args: {},
+	elideNoop: true,
+	apply: () => "noop",
+	invert: () => NOOP
+};
+/** Note one kit op's ids into `into`. */
+function noteInto(into, kind, payload) {
+	const p = payload;
+	switch (kind) {
+		case "kit:add":
+			into.added.add(p.id);
+			break;
+		case "kit:remove":
+			for (const n of p.nodes ?? []) into.removed.add(n.id);
+			break;
+		case "kit:setPose":
+			into.posed.add(p.id);
+			break;
+		case "kit:setData":
+			into.dataChanged.add(p.id);
+			break;
+		case "kit:setDoc":
+			into.docChanged.add(p.key);
+			break;
+		case "kit:move": if (p.fromParent !== p.toParent) into.reparented.add(p.id);
+	}
+}
+function createEditPasses(env) {
+	/** Sorted by order; equal orders keep the order they were added in. */
+	const passes = [];
+	let collecting = null;
+	function run() {
+		const summary = collecting;
+		if (summary === null) return 0;
+		let applied = 0;
+		try {
+			for (const { pass } of [...passes]) {
+				const ops = pass(snapshot(summary));
+				if (ops === null) continue;
+				const adapter = env.adapter();
+				for (const op of ops) {
+					op.apply(adapter);
+					applied++;
+				}
+			}
+		} finally {
+			collecting = null;
+		}
+		return applied;
+	}
+	return {
+		add(pass, opts) {
+			const entry = {
+				pass,
+				order: opts?.order ?? 0
+			};
+			const at = passes.findIndex((p) => p.order > entry.order);
+			passes.splice(at < 0 ? passes.length : at, 0, entry);
+			return () => {
+				const i = passes.indexOf(entry);
+				if (i >= 0) passes.splice(i, 1);
+			};
+		},
+		any: () => passes.length > 0,
+		open() {
+			if (collecting !== null || passes.length === 0) return false;
+			collecting = emptyCollecting();
+			return true;
+		},
+		note(kind, payload) {
+			if (collecting !== null && !env.untracked()) noteInto(collecting, kind, payload);
+		},
+		run,
+		abandon() {
+			collecting = null;
+		},
+		op() {
+			return {
+				name: "editPass",
+				args: {},
+				label: "Edit pass",
+				elideNoop: true,
+				apply: () => run() > 0 ? void 0 : "noop",
+				invert: () => NOOP
+			};
+		}
+	};
+}
+
+//#endregion
+export { createEditPasses };
+//# sourceMappingURL=editPass.js.map