@weasel-js/core 1.6.1 → 1.7.1

package/dist/core/scene/effectivePose.js

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

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

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

package/dist/core/scene/kitRegistry.js

@@ -0,0 +1,33 @@
+import { unionAABB as e } from "../geometry/unionBounds.js";
+//#region src/core/scene/kitRegistry.ts
+var t = "kit:unionOfChildren";
+function n(t, n) {
+	let i = [];
+	for (let e of n) {
+		if (e === void 0) continue;
+		let t = r(e.pose);
+		if (t === null) return null;
+		i.push(t);
+	}
+	if (i.length === 0) return null;
+	let a = e(i);
+	return a === null ? null : a;
+}
+function r(e) {
+	if (typeof e != "object" || !e) return null;
+	let t = e;
+	return typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number" ? e : null;
+}
+function i(e) {
+	return {
+		...e,
+		derivePose: {
+			[t]: n,
+			...e.derivePose
+		}
+	};
+}
+//#endregion
+export { t as UNION_OF_CHILDREN, r as asRectPose, n as unionOfChildren, i as withKitRegistry };
+
+//# sourceMappingURL=kitRegistry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kitRegistry.js","names":["UNION_OF_CHILDREN","unionOfChildren","poses","d","deps","rect","asRectPose","union","unionAABB","pose","p","withKitRegistry","registry"],"sources":["../../../src/core/scene/kitRegistry.ts"],"sourcesContent":["/**\n * The `SceneRegistry` entries the kit owns.\n *\n * A registry-keyed function has to be resolvable by key in whatever scene\n * loads a snapshot, so a function the *kit* attaches to a node cannot live in\n * the consumer's registry alone — a document saved with a grouped container\n * would come back with a dead key. `createScene` merges these under the\n * consumer's, which stays the winner on a key collision.\n */\nimport { unionAABB } from '../geometry/unionBounds';\nimport type { RectPose, SceneRegistry } from './types';\n\n/** Registry key for {@link unionOfChildren}. */\nexport const UNION_OF_CHILDREN = 'kit:unionOfChildren';\n\n/**\n * A container's pose as the envelope of what it holds — `unionAABB`, so a\n * rotated member contributes the extent of its ink rather than its unrotated\n * box. Paired with `dependsOn: 'children'`, this is what makes a group's\n * bounds track its members instead of freezing at the moment it was made.\n *\n * Its members and its result share one frame: a container deriving its pose\n * from its children defines none of its own (see `definesFrame`), so the same\n * union is right under any composition strategy.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose — the group stays where the last member left it rather than collapsing\n * to a zero box at the origin.\n *\n * Reads members as rect poses, and only as rect poses: a scene whose poses are\n * shaped otherwise gets `null` here and its container keeps its authored pose,\n * because this entry is registered into every scene and the scene layer holds\n * no descriptor to read another shape with. To make such a container track its\n * members, register `unionOfChildrenVia(itsDescriptor)` under\n * {@link UNION_OF_CHILDREN} — the consumer's entry wins the collision.\n */\nexport function unionOfChildren<TPose>(\n  _node: unknown,\n  deps: readonly ({ pose: TPose } | undefined)[],\n): TPose | null {\n  const poses: RectPose[] = [];\n  for (const d of deps) {\n    if (d === undefined) continue;\n    const rect = asRectPose(d.pose);\n    if (rect === null) return null;\n    poses.push(rect);\n  }\n  if (poses.length === 0) return null;\n  const union = unionAABB(poses);\n  // Sound by the check above: every member read as a rect, so the union is one\n  // too, and a scene holding rect poses is a scene whose `TPose` is one.\n  return union === null ? null : (union as unknown as TPose);\n}\n\n/** `pose` as a rect, or `null` when it is some other shape entirely. */\nexport function asRectPose(pose: unknown): RectPose | null {\n  if (pose === null || typeof pose !== 'object') return null;\n  const p = pose as Partial<RectPose>;\n  const rect = typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number';\n  return rect ? (pose as RectPose) : null;\n}\n\n/** Merge the kit's own entries under a consumer registry. */\nexport function withKitRegistry<TPose>(registry: SceneRegistry<TPose>): SceneRegistry<TPose> {\n  return {\n    ...registry,\n    derivePose: {\n      [UNION_OF_CHILDREN]: unionOfChildren as NonNullable<\n        SceneRegistry<TPose>['derivePose']\n      >[string],\n      ...registry.derivePose,\n    },\n  };\n}\n"],"mappings":";;AAaA,IAAaA,IAAoB;AAuBjC,SAAgBC,EACd,GACA,GACc;CACd,IAAMC,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAKC,GAAM;EACpB,IAAID,MAAM,KAAA,GAAW;EACrB,IAAME,IAAOC,EAAWH,EAAE,IAAI;EAC9B,IAAIE,MAAS,MAAM,OAAO;EAC1B,EAAM,KAAKA,CAAI;CACjB;CACA,IAAIH,EAAM,WAAW,GAAG,OAAO;CAC/B,IAAMK,IAAQC,EAAUN,CAAK;CAG7B,OAAOK,MAAU,OAAO,OAAQA;AAClC;AAGA,SAAgBD,EAAW,GAAgC;CACzD,IAAqB,OAAOG,KAAS,aAAjCA,GAA2C,OAAO;CACtD,IAAMC,IAAID;CAGV,OAFa,OAAOC,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAClD,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW,WACzCD,IAAoB;AACrC;AAGA,SAAgBE,EAAuB,GAAsD;CAC3F,OAAO;EACL,GAAGC;EACH,YAAY;IACTZ,IAAoBC;GAGrB,GAAGW,EAAS;EACd;CACF;AACF"}

package/dist/core/scene/layoutPass.js

@@ -0,0 +1,96 @@
+import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, rebaseLocalPose as n } from "./composeFrame.js";
+import { samePoseValue as r } from "./poseSnapshot.js";
+import { definesFrame as i, documentPose as a } from "./effectivePose.js";
+import { asRectPose as o } from "./kitRegistry.js";
+//#region src/core/scene/layoutPass.ts
+function s(t) {
+	return {
+		bounds: t?.bounds ?? ((e) => {
+			let t = o(e);
+			return t === null ? null : {
+				x: t.x,
+				y: t.y,
+				width: t.width,
+				height: t.height
+			};
+		}),
+		remap: t?.remap ?? ((e, t, n) => ({
+			...e,
+			...n
+		})),
+		composition: t?.composition ?? e
+	};
+}
+function c(e, t, n, r) {
+	let i = e.bounds(n, t), a = e.bounds(r, t);
+	return i === null || a === null ? i !== a : i.width !== a.width || i.height !== a.height;
+}
+var l = 16;
+function u(e, o, s, u, d, f = /* @__PURE__ */ new Map()) {
+	let p = /* @__PURE__ */ new Map(), m = (t) => p.get(t) ?? a(e, e.get(t)), h = {
+		getPose: (e) => m(e),
+		getParent: (t) => e.get(t)?.parent ?? null,
+		definesFrame: (t) => {
+			let n = e.get(t);
+			return n === void 0 || i(n);
+		}
+	}, { compose: g, decompose: _ } = d.composition, v = (e) => t(h, e, g), y = [.../* @__PURE__ */ new Set([...s.keys(), ...u])], b = /* @__PURE__ */ new Map(), x = (t, n) => {
+		let i = e.get(t), a = m(t);
+		r(a, n) || (p.set(t, n), t !== S && i.kind === "container" && o(t) !== null && c(d, t, a, n) && y.push(t));
+	}, S = null, C = (t) => {
+		let n = v(t), r = d.bounds(n, t);
+		if (r === null) return null;
+		let i = e.childrenOf(t).map((e) => ({
+			id: e,
+			pose: v(e)
+		}));
+		return {
+			world: n,
+			container: {
+				id: t,
+				bounds: r
+			},
+			children: i
+		};
+	}, w = (t, r, i) => {
+		if (i.bounds) {
+			let a = e.get(t), o = d.remap(r.world, r.container.bounds, i.bounds, t);
+			x(t, n(h, o, a.parent, g, _));
+		}
+		for (let [r, a] of i.poses) {
+			let i = r;
+			e.get(i)?.parent === t && x(i, n(h, a, t, g, _));
+		}
+	};
+	for (; y.length > 0;) {
+		let t = y.shift();
+		S = t;
+		let n = (b.get(t) ?? 0) + 1;
+		if (b.set(t, n), n > l) continue;
+		let r = o(t);
+		if (r === null || e.get(t) === void 0) continue;
+		let i = n === 1 ? s.get(t) : void 0, a = n === 1 ? f.get(t) : void 0, c = !1;
+		if (a !== void 0 && r.depart) {
+			let e = C(t);
+			if (e === null) continue;
+			let n = new Set(i ?? []), o = e.children.filter((e) => !n.has(e.id));
+			w(t, e, r.depart(e.container, o, new Set(a))), c = !0;
+		}
+		if (i !== void 0 && r.arrive) {
+			let e = C(t);
+			if (e === null) continue;
+			let n = r.arrive(e.container, e.children, new Set(i));
+			if (n === null) return null;
+			w(t, e, n);
+		} else if (!c || i !== void 0) {
+			let e = C(t);
+			if (e === null) continue;
+			w(t, e, { poses: r.childPoses(e.container, e.children) });
+		}
+	}
+	return p;
+}
+//#endregion
+export { c as resized, s as resolveLayoutFrame, u as runLayoutPass };
+
+//# sourceMappingURL=layoutPass.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layoutPass.js","names":["resolveLayoutFrame","frame","r","asRectPose","pose","to","IDENTITY_POSE_COMPOSITION","resized","a","from","id","b","MAX_PASSES","runLayoutPass","out","poseOf","documentPose","source","pa","node","definesFrame","world","composeWorldPose","compose","queue","arrivals","changed","passes","write","before","samePoseValue","current","layoutOf","frameOf","containerId","bounds","children","cid","apply","result","sized","at","rebaseLocalPose","decompose","layout","joined","left","departures","arranged","joinedSet","staying","c"],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, or gained or lost children with neither hook — is put back in its\n * resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n  composition: PoseComposition<TPose>;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n    composition: frame?.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = frame.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n    }\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":"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"}

package/dist/core/scene/nodeFnFields.js

@@ -0,0 +1,83 @@
+//#region src/core/scene/nodeFnFields.ts
+var e = [
+	{
+		field: "clipFromPose",
+		opKey: "clipKey",
+		jsonKey: "clipFromPoseKey",
+		containersOnly: !0,
+		lost: "clip"
+	},
+	{
+		field: "derivePath",
+		opKey: "derivePathKey",
+		jsonKey: "derivePathKey",
+		containersOnly: !1,
+		lost: "derived path"
+	},
+	{
+		field: "derivePose",
+		opKey: "derivePoseKey",
+		jsonKey: "derivePoseKey",
+		containersOnly: !1,
+		lost: "derived pose"
+	},
+	{
+		field: "layout",
+		opKey: "layoutKey",
+		jsonKey: "layoutKey",
+		containersOnly: !0,
+		lost: "layout"
+	}
+];
+function t(t) {
+	return e.map((e) => {
+		let n = t[e.field], r = /* @__PURE__ */ new Map();
+		if (n) for (let [e, t] of Object.entries(n)) r.set(t, e);
+		let i = /* @__PURE__ */ new Map(), a = (t) => !e.containersOnly || t.kind === "container";
+		return {
+			spec: e,
+			keyOf: (e) => r.get(e),
+			fnOf: (e) => n?.[e],
+			read: (t) => a(t) ? t[e.field] : void 0,
+			write: (t, n) => {
+				a(t) && (t[e.field] = n);
+			},
+			pending: i
+		};
+	});
+}
+function n(e, t, n, r, i) {
+	let a = e.fnOf(n);
+	if (a === void 0) {
+		i("scene", `${r}: ${e.spec.opKey} "${n}" not in this scene's registry — node "${t.id}" restored without its ${e.spec.lost}. Register a function with this key in the registry option to restore it.`);
+		return;
+	}
+	e.write(t, a), e.pending.set(t.id, a);
+}
+function r(e, t, n, r) {
+	let i = {};
+	for (let a of e) {
+		let e = a.read(t);
+		if (e === void 0) continue;
+		let o = a.keyOf(e);
+		if (o === void 0) {
+			r?.(a);
+			continue;
+		}
+		i[a.spec[n]] = o;
+	}
+	return i;
+}
+function i(t) {
+	let n = t, r = {};
+	for (let i of e) {
+		if (i.containersOnly && t.kind !== "container") continue;
+		let e = n[i.field];
+		e !== void 0 && (r[i.field] = e);
+	}
+	return r;
+}
+//#endregion
+export { e as NODE_FN_FIELDS, t as createNodeFnFields, i as fnFieldsOfNode, r as fnKeysOf, n as restoreFn };
+
+//# sourceMappingURL=nodeFnFields.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","pending","applies","node","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * `clipFromPose`, `derivePath` and `derivePose` are live functions on a node,\n * and a function travels through neither a serializable op payload nor a JSON\n * snapshot. Each one therefore needs the same six things: a function→key\n * reverse map, a side-channel cache the `kit:add` redo path re-attaches from,\n * a name in the op payload, a name in the snapshot, a registry lookup on\n * restore, and a prune when history evicts the entry that could reach it.\n *\n * The first two fields were written out twice, and `types.ts` said in a\n * comment that a third should be the point it stopped being copied per field.\n * This is that point.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. Each field's real signature lives on `Node`.\n *  A container's `layout` is an object rather than a function, and rides the\n *  same table for the same reason — it travels by reference, not as data. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the three fields on it. The\n *  full `Node` type would make the table generic in `TData`/`TLayer` for no\n *  gain; nothing here looks at either. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n  /** The redo side-channel: `kit:add` replays without the original spec, so\n   *  the function it should re-attach is cached here by node id. */\n  readonly pending: Map<NodeId, NodeFn>;\n}\n\nexport function createNodeFnFields<TPose>(registry: SceneRegistry<TPose>): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const pending = new Map<NodeId, NodeFn>();\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (applies(node)) node[spec.field] = fn;\n      },\n      pending,\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`, seeding the redo cache so later\n * undo/redo cycles behave like the live path. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n  field.pending.set(node.id, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AA8CA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAmBA,SAAgBC,EAA0B,GAAwD;CAChG,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,oBAAU,IAAI,IAAoB,GAClCC,KAAW,MACf,CAACL,EAAK,kBAAkBM,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOL,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUG,EAAQC,CAAI,IAAIA,EAAKN,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAIK,EAAQC,CAAI,MAAG,EAAKN,EAAK,SAASG;GACxC;GACA;EACF;CACF,CAAC;AACH;AAQA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMJ,IAAKK,EAAM,KAAKN,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGM,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIN,EAAI,yCAAyCI,EAAK,GAAG,yBAC5DE,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CAEA,AADAA,EAAM,MAAMF,GAAMH,CAAE,GACpBK,EAAM,QAAQ,IAAIF,EAAK,IAAIH,CAAE;AAC/B;AAIA,SAAgBO,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMT,IAAKK,EAAM,KAAKF,CAAI;EAC1B,IAAIH,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMM,EAAM,MAAML,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBM,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUX;CAC3B;CACA,OAAOS;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMT,GACNK,IAA+B,CAAC;CACtC,KAAK,IAAMX,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBM,EAAK,SAAS,aAAa;EACtD,IAAMH,IAAKY,EAAIf,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOQ;AACT"}

package/dist/core/scene/nodeMemo.js

@@ -0,0 +1,28 @@
+//#region src/core/scene/nodeMemo.ts
+var e = /* @__PURE__ */ new WeakMap(), t = 0;
+function n(n, r, i, a) {
+	let o = e.get(n);
+	o === void 0 ? (o = {
+		generation: t,
+		slots: /* @__PURE__ */ new Map()
+	}, e.set(n, o)) : o.generation !== t && (o.generation = t, o.slots.clear());
+	let s = n.data, c = o.slots.get(r);
+	if (c !== void 0 && c.pose === i && c.data === s) return c.value;
+	let l = a();
+	return c === void 0 ? o.slots.set(r, {
+		pose: i,
+		data: s,
+		value: l
+	}) : (c.pose = i, c.data = s, c.value = l), l;
+}
+function r() {
+	t++;
+}
+function i(t) {
+	let n = e.get(t);
+	if (n !== void 0) for (let [e, t] of n.slots) t.pose !== void 0 && n.slots.delete(e);
+}
+//#endregion
+export { r as bumpNodeMemoGeneration, i as dropPoseKeyedMemoSlots, n as nodeMemo };
+
+//# sourceMappingURL=nodeMemo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeMemo.js","names":["MEMO","generation","nodeMemo","record","node","data","hit","slot","pose","value","derive","bumpNodeMemoGeneration","dropPoseKeyedMemoSlots","entry"],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * **Why this key works.** The scene mutates node objects in place but\n * *replaces* `pose` and `data` with new references — see the `kit:setPose` /\n * `kit:setData` ops in `core/scene/scene.ts`, which do `node.pose = p.to` /\n * `node.data = p.to`. So the node object is a stable identity, and those two\n * references are an exact freshness signal for anything derived per node: no\n * deep compare, no dirty flag, no subscription. The whole memo is three\n * reference comparisons.\n *\n * The assumption it rests on is the other side of that contract: nobody\n * mutates `node.data` (or `node.pose`) in place without replacing the\n * reference. A consumer who violates it sees a stale derivation until the next\n * real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Those change what `derive` would\n * return with no change to the node at all, which is the one failure a\n * `(pose, data)` key cannot see. {@link bumpNodeMemoGeneration} is the escape\n * hatch: whoever owns the ambient state bumps, and every slot on every node is\n * dropped. Derivations that read ambient state with *no* such signal (an async\n * image decode landing, say) must not be memoized here at all.\n *\n * Consumers: `canvas/NodeShape.ts` memoizes the painter match and the\n * silhouette path this way.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. Deliberately not `Node<…>` — the memo doesn't read\n *  anything else, and typing it loosely keeps `core/scene` from depending on\n *  the full node shape for a three-comparison cache. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, or the global\n * generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation. A node has more than one derived value — the\n * painter match, the silhouette, draw commands, text layout — and they\n * invalidate on the same signals but must not overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Those miss and recompute, as they should, and must not\n * poison the entry for the node's real pose. Pass `undefined` for derivations\n * that don't depend on the pose at all (the painter match is one) — it\n * compares equal to itself, leaving `data` as the only key.\n *\n * `data` is read off the node rather than passed: no caller has had a reason\n * to derive against data the node doesn't hold.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string,\n  pose: unknown,\n  derive: () => T,\n): T {\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map() };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, value });\n  }\n  return value;\n}\n\n/**\n * Drop every memoized slot on every node.\n *\n * For owners of ambient state that changes what a `derive` would return: the\n * shape-painter registry calls this when a painter is registered or disposed,\n * since a cache keyed only on `(pose, data)` would keep answering with the\n * painter that matched before.\n *\n * Cheap — it bumps a counter; records are re-stamped lazily on next access,\n * and unreachable nodes stay collectable via the `WeakMap`.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't (the painter match passes `undefined`, and re-matching it is a\n * registry scan).\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference: the `(pose, data)` key cannot see that, so the\n * override's `commit()` calls this for each node it holds.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) return;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AA8CA,IAAMA,oBAAO,IAAI,QAAgC,GAI7CC,IAAa;AA2BjB,SAAgBC,EACd,GACA,GACA,GACA,GACG;CACH,IAAIC,IAASH,EAAK,IAAII,CAAI;CAC1B,AAAID,MAAW,KAAA,KACb,IAAS;EAAE;EAAY,uBAAO,IAAI,IAAI;CAAE,GACxCH,EAAK,IAAII,GAAMD,CAAM,KACZA,EAAO,eAAeF,MAC/B,EAAO,aAAaA,GACpBE,EAAO,MAAM,MAAM;CAGrB,IAAME,IAAOD,EAAK,MACZE,IAAMH,EAAO,MAAM,IAAII,CAAI;CACjC,IAAID,MAAQ,KAAA,KAAaA,EAAI,SAASE,KAAQF,EAAI,SAASD,GACzD,OAAOC,EAAI;CAGb,IAAMG,IAAQC,EAAO;CAUrB,OAPIJ,MAAQ,KAAA,IAKVH,EAAO,MAAM,IAAII,GAAM;EAAE;EAAM;EAAM;CAAM,CAAC,KAJ5C,EAAI,OAAOC,GACX,EAAI,OAAOH,GACX,EAAI,QAAQI,IAIPA;AACT;AAaA,SAAgBE,IAA+B;CAC7C;AACF;AAaA,SAAgBC,EAAuB,GAA4B;CACjE,IAAMT,IAASH,EAAK,IAAII,CAAI;CAC5B,IAAID,MAAW,KAAA,GACf,KAAK,IAAM,CAACI,GAAMM,MAAUV,EAAO,OACjC,AAAIU,EAAM,SAAS,KAAA,KAAWV,EAAO,MAAM,OAAOI,CAAI;AAE1D"}

package/dist/core/scene/poseFeed.js

@@ -0,0 +1,87 @@
+import { effectivePose as e } from "./effectivePose.js";
+//#region src/core/scene/poseFeed.ts
+var t = Object.freeze([]);
+function n(n) {
+	let r = null, i = -1, a = -1, o = t, s = /* @__PURE__ */ new Set(), c = () => {
+		for (let e of s) e();
+	}, l = null, u = () => {
+		let t = r, i = [], a = [], o = [], s = /* @__PURE__ */ new Map();
+		for (let [r, o] of n.nodes) {
+			let c = e(n, o);
+			s.set(r, {
+				pose: c,
+				data: o.data,
+				layer: o.layer
+			});
+			let l = t.get(r);
+			l === void 0 ? i.push({
+				node: o,
+				pose: c
+			}) : (l.pose !== c || l.data !== o.data || l.layer !== o.layer) && a.push({
+				node: o,
+				pose: c
+			});
+		}
+		for (let e of t.keys()) s.has(e) || o.push(e);
+		return r = s, {
+			added: i,
+			removed: o,
+			changed: a
+		};
+	}, d = () => (r = /* @__PURE__ */ new Map(), i = n.getVersion(), a = n.overrides.getGeneration(), o = n.overrides.ids(), {
+		...u(),
+		removed: t,
+		changed: t,
+		reset: !0
+	});
+	return {
+		subscribe(e) {
+			if (s.add(e), l === null) {
+				let e = n.subscribe(c), t = n.overrides.subscribe(c);
+				l = () => {
+					e(), t();
+				};
+			}
+			return () => {
+				s.delete(e), s.size === 0 && l !== null && (l(), l = null);
+			};
+		},
+		read() {
+			if (r === null) return d();
+			let s = n.getVersion(), c = n.overrides.getGeneration(), l = s !== i, f = c !== a;
+			if (!l && !f) return {
+				added: t,
+				removed: t,
+				changed: t,
+				reset: !1
+			};
+			let p = l ? u() : {
+				added: [],
+				removed: [],
+				changed: []
+			};
+			if (i = s, f) {
+				let t = n.overrides.ids(), r = new Set(t);
+				for (let e of o) r.add(e);
+				let i = new Set(p.changed.map((e) => e.node.id));
+				for (let t of r) {
+					if (i.has(t)) continue;
+					let r = n.get(t);
+					r !== void 0 && p.changed.push({
+						node: r,
+						pose: e(n, r)
+					});
+				}
+				a = c, o = t;
+			}
+			return {
+				...p,
+				reset: !1
+			};
+		}
+	};
+}
+//#endregion
+export { n as createPoseFeed };
+
+//# sourceMappingURL=poseFeed.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseFeed.js","names":["EMPTY","createPoseFeed","seen","seenVersion","seenGeneration","seenOverridden","listeners","notify","fn","unwire","walk","prev","added","changed","removed","next","id","node","scene","pose","effectivePose","before","resetTo","offScene","offOverrides","version","generation","committedMoved","overridesMoved","base","now","touched","already","n"],"sources":["../../../src/core/scene/poseFeed.ts"],"sourcesContent":["import { effectivePose } from './effectivePose';\nimport type { Node, NodeId, Scene } from './types';\n\n/** A node and the pose a renderer should draw it at. `node.pose` beside it is\n *  still the committed pose, so a host has both without a second channel. */\nexport interface FeedNode<TData, TLayer extends string, TPose> {\n  node: Node<TData, TLayer, TPose>;\n  pose: TPose;\n}\n\n/** What changed since the last `read()`. A node whose effective pose, data or\n *  layer reference moved is `changed`; `reset` means every node is in `added`. */\nexport interface FeedDelta<TData, TLayer extends string, TPose> {\n  added: readonly FeedNode<TData, TLayer, TPose>[];\n  removed: readonly NodeId[];\n  changed: readonly FeedNode<TData, TLayer, TPose>[];\n  /** Discard the object map and rebuild. */\n  reset: boolean;\n}\n\n/** A pull-based change feed over a scene. `subscribe` says something moved;\n *  `read` says what, relative to the previous read. */\nexport interface PoseFeed<TData, TLayer extends string, TPose> {\n  subscribe(fn: () => void): () => void;\n  read(): FeedDelta<TData, TLayer, TPose>;\n}\n\nconst EMPTY = Object.freeze([]) as readonly never[];\n\n/** The three references a node carries that a renderer cares about. The node\n *  object is mutated in place, so it is these — not the node — that move. */\ninterface Snapshot<TData, TLayer extends string, TPose> {\n  pose: TPose;\n  data: TData;\n  layer: TLayer;\n}\n\n/** A {@link PoseFeed} over `scene`, reporting effective poses (committed pose\n *  under any override). The first `read()` is a reset listing every node. */\nexport function createPoseFeed<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n): PoseFeed<TData, TLayer, TPose> {\n  let seen: Map<NodeId, Snapshot<TData, TLayer, TPose>> | null = null;\n  let seenVersion = -1;\n  let seenGeneration = -1;\n  let seenOverridden: readonly NodeId[] = EMPTY;\n\n  const listeners = new Set<() => void>();\n  const notify = () => {\n    for (const fn of listeners) fn();\n  };\n  let unwire: (() => void) | null = null;\n\n  const walk = (): {\n    added: FeedNode<TData, TLayer, TPose>[];\n    removed: NodeId[];\n    changed: FeedNode<TData, TLayer, TPose>[];\n  } => {\n    const prev = seen!;\n    const added: FeedNode<TData, TLayer, TPose>[] = [];\n    const changed: FeedNode<TData, TLayer, TPose>[] = [];\n    const removed: NodeId[] = [];\n    const next = new Map<NodeId, Snapshot<TData, TLayer, TPose>>();\n\n    for (const [id, node] of scene.nodes) {\n      const pose = effectivePose(scene, node);\n      next.set(id, { pose, data: node.data, layer: node.layer });\n      const before = prev.get(id);\n      if (before === undefined) added.push({ node, pose });\n      else if (before.pose !== pose || before.data !== node.data || before.layer !== node.layer) {\n        changed.push({ node, pose });\n      }\n    }\n    for (const id of prev.keys()) if (!next.has(id)) removed.push(id);\n\n    seen = next;\n    return { added, removed, changed };\n  };\n\n  const resetTo = (): FeedDelta<TData, TLayer, TPose> => {\n    // An empty `seen` makes the walk report every node as added, and fills the\n    // snapshot map in the same pass.\n    seen = new Map();\n    seenVersion = scene.getVersion();\n    seenGeneration = scene.overrides.getGeneration();\n    seenOverridden = scene.overrides.ids();\n    return { ...walk(), removed: EMPTY, changed: EMPTY, reset: true };\n  };\n\n  return {\n    subscribe(fn) {\n      listeners.add(fn);\n      if (unwire === null) {\n        const offScene = scene.subscribe(notify);\n        const offOverrides = scene.overrides.subscribe(notify);\n        unwire = () => {\n          offScene();\n          offOverrides();\n        };\n      }\n      return () => {\n        listeners.delete(fn);\n        if (listeners.size === 0 && unwire !== null) {\n          unwire();\n          unwire = null;\n        }\n      };\n    },\n    read() {\n      if (seen === null) return resetTo();\n\n      const version = scene.getVersion();\n      const generation = scene.overrides.getGeneration();\n      const committedMoved = version !== seenVersion;\n      const overridesMoved = generation !== seenGeneration;\n\n      if (!committedMoved && !overridesMoved) {\n        return { added: EMPTY, removed: EMPTY, changed: EMPTY, reset: false };\n      }\n\n      const base = committedMoved\n        ? walk()\n        : {\n            added: [] as FeedNode<TData, TLayer, TPose>[],\n            removed: [] as NodeId[],\n            changed: [] as FeedNode<TData, TLayer, TPose>[],\n          };\n      seenVersion = version;\n\n      if (overridesMoved) {\n        const now = scene.overrides.ids();\n        const touched = new Set<NodeId>(now);\n        for (const id of seenOverridden) touched.add(id); // a cleared override moved too\n        const already = new Set(base.changed.map((n) => n.node.id));\n        for (const id of touched) {\n          if (already.has(id)) continue;\n          const node = scene.get(id);\n          if (node !== undefined) base.changed.push({ node, pose: effectivePose(scene, node) });\n        }\n        seenGeneration = generation;\n        seenOverridden = now;\n      }\n\n      return { ...base, reset: false };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/poseOverrides.js

@@ -0,0 +1,52 @@
+import { dropPoseKeyedMemoSlots as e } from "./nodeMemo.js";
+//#region src/core/scene/poseOverrides.ts
+function t(t, n) {
+	let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set(), a = 0;
+	function o(r) {
+		let i = t(r);
+		i && e(i), n?.(r);
+	}
+	function s() {
+		a++;
+		for (let e of i) e();
+	}
+	return {
+		set(e, t) {
+			r.set(e, t), o(e), s();
+		},
+		get(e) {
+			return r.get(e);
+		},
+		has(e) {
+			return r.has(e);
+		},
+		ids() {
+			return [...r.keys()];
+		},
+		clear(e) {
+			r.delete(e) && (o(e), s());
+		},
+		clearAll() {
+			if (r.size !== 0) {
+				for (let e of r.keys()) o(e);
+				r.clear(), s();
+			}
+		},
+		commit() {
+			for (let e of r.keys()) o(e);
+			s();
+		},
+		subscribe(e) {
+			return i.add(e), () => {
+				i.delete(e);
+			};
+		},
+		getGeneration() {
+			return a;
+		}
+	};
+}
+//#endregion
+export { t as createPoseOverrides };
+
+//# sourceMappingURL=poseOverrides.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseOverrides.js","names":["createPoseOverrides","entries","listeners","generation","invalidate","node","getNode","id","dropPoseKeyedMemoSlots","onInvalidate","published","listener","entry","fn"],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on —\n * the only thing this module needs from the scene, and the reason it doesn't\n * import one. `onInvalidate` lets the scene invalidate derived nodes from the\n * same chokepoint.\n */\nexport function createPoseOverrides<TPose>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose> {\n  const entries = new Map<NodeId, PoseOverride<TPose>>();\n  const listeners = new Set<() => void>();\n  let generation = 0;\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) dropPoseKeyedMemoSlots(node);\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    for (const listener of listeners) listener();\n  }\n\n  return {\n    set(id, entry) {\n      entries.set(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return entries.get(id);\n    },\n    has(id) {\n      return entries.has(id);\n    },\n    ids() {\n      return [...entries.keys()];\n    },\n    clear(id) {\n      if (!entries.delete(id)) return;\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (entries.size === 0) return;\n      for (const id of entries.keys()) invalidate(id);\n      entries.clear();\n      published();\n    },\n    commit() {\n      for (const id of entries.keys()) invalidate(id);\n      published();\n    },\n    subscribe(fn) {\n      listeners.add(fn);\n      return () => { listeners.delete(fn); };\n    },\n    getGeneration() {\n      return generation;\n    },\n  };\n}\n\n"],"mappings":";;AAWA,SAAgBA,EACd,GACA,GACsB;CACtB,IAAMC,oBAAU,IAAI,IAAiC,GAC/CC,oBAAY,IAAI,IAAgB,GAClCC,IAAa;CAEjB,SAASC,EAAW,GAAkB;EACpC,IAAMC,IAAOC,EAAQC,CAAE;EAEvB,AADIF,KAAMG,EAAuBH,CAAI,GACrCI,IAAeF,CAAE;CACnB;CAEA,SAASG,IAAkB;EACzB;EACA,KAAK,IAAMC,KAAYT,GAAW,EAAS;CAC7C;CAEA,OAAO;EACL,IAAI,GAAI,GAAO;GAGb,AAFAD,EAAQ,IAAIM,GAAIK,CAAK,GACrBR,EAAWG,CAAE,GACbG,EAAU;EACZ;EACA,IAAI,GAAI;GACN,OAAOT,EAAQ,IAAIM,CAAE;EACvB;EACA,IAAI,GAAI;GACN,OAAON,EAAQ,IAAIM,CAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAGN,EAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,GAAI;GACR,AAAKA,EAAQ,OAAOM,CAAE,MACtBH,EAAWG,CAAE,GACbG,EAAU;EACZ;EACA,WAAW;GACT,IAAIT,EAAQ,SAAS,GACrB;SAAK,IAAMM,KAAMN,EAAQ,KAAK,GAAG,EAAWM,CAAE;IAE9C,AADAN,EAAQ,MAAM,GACdS,EAAU;GAFoC;EAGhD;EACA,SAAS;GACP,KAAK,IAAMH,KAAMN,EAAQ,KAAK,GAAG,EAAWM,CAAE;GAC9C,EAAU;EACZ;EACA,UAAU,GAAI;GAEZ,OADAL,EAAU,IAAIW,CAAE,SACH;IAAE,EAAU,OAAOA,CAAE;GAAG;EACvC;EACA,gBAAgB;GACd,OAAOV;EACT;CACF;AACF"}

package/dist/core/scene/poseSnapshot.js

@@ -0,0 +1,54 @@
+import { isPlainObject as e, isPlainPrototype as t } from "../isPlainObject.js";
+//#region src/core/scene/poseSnapshot.ts
+var n = 4;
+function r(e) {
+	return ArrayBuffer.isView(e) && !(e instanceof DataView);
+}
+function i(t, a = n) {
+	if (a <= 0) return t;
+	if (Array.isArray(t)) return t.map((e) => i(e, a - 1));
+	if (r(t)) return t.slice();
+	if (e(t)) {
+		let e = { ...t };
+		for (let t in e) {
+			let n = e[t];
+			typeof n == "object" && n && (e[t] = i(n, a - 1));
+		}
+		return e;
+	}
+	return t;
+}
+function a(e, i, o = n) {
+	if (e === i) return !0;
+	if (typeof e != "object" || !e || typeof i != "object" || !i) return Object.is(e, i);
+	if (o <= 0) return !1;
+	let s = Object.getPrototypeOf(e);
+	if (t(s)) {
+		if (!t(Object.getPrototypeOf(i))) return !1;
+		let n = e, r = i, s = 0;
+		for (let e in n) {
+			s++;
+			let t = n[e], i = r[e];
+			if (t === i) {
+				if (i === void 0 && !(e in r)) return !1;
+				continue;
+			}
+			if (!a(t, i, o - 1)) return !1;
+		}
+		for (let e in r) if (--s < 0) return !1;
+		return !0;
+	}
+	if (Array.isArray(e) || r(e)) {
+		let t = e;
+		if (!(Array.isArray(i) || r(i))) return !1;
+		let n = i;
+		if (t.length !== n.length) return !1;
+		for (let e = 0; e < t.length; e++) if (!a(t[e], n[e], o - 1)) return !1;
+		return !0;
+	}
+	return !1;
+}
+//#endregion
+export { a as samePoseValue, i as snapshotPose };
+
+//# sourceMappingURL=poseSnapshot.js.map