@weasel-js/core 1.10.1 → 1.11.0

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/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"}