@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/scene/arrivalWindow.js

@@ -0,0 +1,102 @@
+import { SceneArrivalRefused as e } from "./arrivals.js";
+import { createArrangeOp as t } from "../ops/arrange.js";
+import { createEmitter as n } from "@weasel-js/registry";
+//#region src/core/scene/arrivalWindow.ts
+function r(e, t, n) {
+	let r = /* @__PURE__ */ new Map();
+	for (let [i, a] of t) {
+		let t = a.filter((t) => e.get(t)?.parent === i === n);
+		t.length > 0 && e.has(i) && r.set(i, t);
+	}
+	return r;
+}
+function i(i) {
+	let { nodes: a } = i, o = null, s = !1, c = null, l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = null, f = n(), p = () => o ?? (s ? i.layoutPass : null);
+	function m(e = !1) {
+		return c !== null || !e && p() === null ? !1 : (c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = null, !0);
+	}
+	function h() {
+		let e = d;
+		d = null, e !== null && e.length !== 0 && f.emit(e);
+	}
+	function g() {
+		let t = c;
+		c = null;
+		let n = p();
+		if (t === null || n === null) return [];
+		let i = r(a, t, !0), o = r(a, l, !1);
+		l = /* @__PURE__ */ new Map();
+		let s = new Set([...u].filter((e) => a.get(e)?.kind === "container"));
+		if (i.size === 0 && s.size === 0) return [];
+		let f = n(i, s, o);
+		if (f === null) throw new e(i);
+		let m = [];
+		for (let [e, t] of f) {
+			let n = a.get(e);
+			n && m.push({
+				id: e,
+				from: n.pose,
+				to: t
+			});
+		}
+		return d = m, m;
+	}
+	function _() {
+		c = null, d = null;
+	}
+	function v(e) {
+		return m(!0) ? {
+			ops: [...e, t({}, g, i.writePose)],
+			owned: !0
+		} : {
+			ops: e,
+			owned: !1
+		};
+	}
+	return {
+		layoutDeclared: () => {
+			s = !0;
+		},
+		setHandler(e) {
+			return o = e, () => {
+				o === e && (o = null);
+			};
+		},
+		onReflow: f.subscribe,
+		noteArrival(e, t, n) {
+			if (c === null || t === null || t === n) return;
+			u.add(t);
+			let r = c.get(t);
+			r === void 0 ? c.set(t, [e]) : r.includes(e) || r.push(e);
+		},
+		noteDeparture(e, t, n) {
+			if (c === null || t === null || t === n || (u.add(t), c.get(t)?.includes(e))) return;
+			let r = l.get(t);
+			r === void 0 ? l.set(t, [e]) : r.includes(e) || r.push(e);
+		},
+		noteChange(e) {
+			c !== null && e !== null && u.add(e);
+		},
+		bareLayoutEdit: () => p() !== null && c === null && i.recordsBareEdits(),
+		open: m,
+		settle: g,
+		emitReflow: h,
+		abandon: _,
+		runEdit(t, n) {
+			let { ops: r, owned: i } = v(t);
+			if (!i) return n(r), !0;
+			try {
+				return n(r), h(), !0;
+			} catch (t) {
+				if (!(t instanceof e)) throw t;
+				return !1;
+			} finally {
+				_();
+			}
+		}
+	};
+}
+//#endregion
+export { i as createArrivalWindow };
+
+//# sourceMappingURL=arrivalWindow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrivalWindow.js","names":["heldMoves","out","parent","ids","noted","held","nodes","id","joined","createArrivalWindow","env","installed","hasLayouts","arrivals","departures","changed","reflowDue","reflowListeners","createEmitter","activeHandler","open","always","emitReflow","moves","settle","pending","handler","landed","left","touched","poses","SceneArrivalRefused","to","node","abandon","withArrivalOps","ops","createArrangeOp","from","list","all","owned","run","err"],"sources":["../../../src/core/scene/arrivalWindow.ts"],"sourcesContent":["/**\n * The scene's arrival window: what a live edit did to containers, collected\n * while it runs and handed to a layout handler before it closes.\n *\n * The window is open while a live edit is collecting the nodes that joined a\n * container, the ones that left one, and every container whose children or\n * size it changed; whoever opened the window settles it before the edit\n * closes. Undo, redo and journal replays never open it: they restore an\n * arrangement that was already decided.\n */\nimport { createEmitter } from '@weasel-js/registry';\nimport type { Op } from 'core/ops/types';\nimport { createArrangeOp, type ArrangedPose } from 'core/ops/arrange';\nimport { SceneArrivalRefused } from './arrivals';\nimport type { LayoutMove, Node, NodeId, SceneArrivalHandler } from './types';\n\n/** What the window needs from the scene it serves. */\nexport interface ArrivalWindowEnv<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  /** The pass over the scene's declared layouts, which settles arrivals once\n   *  a container has declared one. An installed handler takes its place. */\n  layoutPass: SceneArrivalHandler<TPose>;\n  /** Whether a bare scene call would record an edit of its own right now:\n   *  no batch is open and no history engine is driving. */\n  recordsBareEdits(): boolean;\n  /** Write one arranged pose. Bound into the arrange op, since not every\n   *  adapter an edit is applied through can write poses. */\n  writePose(id: string, pose: unknown): void;\n}\n\nexport interface ArrivalWindow<TPose> {\n  /** A container was given a layout: from here on the scene has arrivals to\n   *  settle even with no handler installed. */\n  layoutDeclared(): void;\n  /** Install the handler that settles arrivals. Returns its remover. */\n  setHandler(handler: SceneArrivalHandler<TPose>): () => void;\n  /** Hear the poses each live edit's settle wrote, after the edit lands. */\n  onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;\n  noteArrival(id: NodeId, parent: NodeId | null, from: NodeId | null): void;\n  noteDeparture(id: NodeId, from: NodeId | null, to: NodeId | null): void;\n  /** A container's child set or order changed, or it changed size. */\n  noteChange(id: NodeId | null): void;\n  /** Whether a bare scene call has to run as a batch of its own, so the\n   *  layout pass it triggers lands in its undo step. */\n  bareLayoutEdit(): boolean;\n  /** Open the window when a handler wants one — or `always`, for an edit that\n   *  may give the scene its first layout partway through — and no enclosing\n   *  edit holds it already; true when this caller now owns it. */\n  open(always?: boolean): boolean;\n  /** Close the window and ask the handler what the arrivals get. Throws\n   *  `SceneArrivalRefused` when it refuses, which reverts the edit. */\n  settle(): ArrangedPose[];\n  /** Report what the settled edit wrote, now that it has landed. */\n  emitReflow(): void;\n  /** Close the window with nothing settled or reported: its owner's edit is\n   *  over, however it ended. */\n  abandon(): void;\n  /** Run an op-driven edit that may carry arrivals: a refusal reverts it and\n   *  is swallowed, the way a drop onto a full container is — nothing lands.\n   *  Returns whether the edit landed. */\n  runEdit(ops: Op[], run: (ops: Op[]) => void): boolean;\n}\n\n/** Of the ids noted per container, those the landed edit bears out: still\n *  under it when `joined`, gone from it otherwise. A container that is itself\n *  gone is left out. */\nfunction heldMoves(\n  nodes: ReadonlyMap<NodeId, { parent: NodeId | null }>,\n  noted: ReadonlyMap<NodeId, NodeId[]>,\n  joined: boolean,\n): Map<NodeId, NodeId[]> {\n  const out = new Map<NodeId, NodeId[]>();\n  for (const [parent, ids] of noted) {\n    const held = ids.filter((id) => (nodes.get(id)?.parent === parent) === joined);\n    if (held.length > 0 && nodes.has(parent)) out.set(parent, held);\n  }\n  return out;\n}\n\nexport function createArrivalWindow<TData, TLayer extends string, TPose>(\n  env: ArrivalWindowEnv<TData, TLayer, TPose>,\n): ArrivalWindow<TPose> {\n  const { nodes } = env;\n  let installed: SceneArrivalHandler<TPose> | null = null;\n  let hasLayouts = false;\n  let arrivals: Map<NodeId, NodeId[]> | null = null;\n  let departures = new Map<NodeId, NodeId[]>();\n  let changed = new Set<NodeId>();\n  /** What the last settle wrote, reported to `onReflow` once its edit lands. */\n  let reflowDue: LayoutMove<TPose>[] | null = null;\n  const reflowListeners = createEmitter<[moves: readonly LayoutMove<TPose>[]]>();\n\n  const activeHandler = (): SceneArrivalHandler<TPose> | null => installed ?? (hasLayouts ? env.layoutPass : null);\n\n  function open(always = false): boolean {\n    if (arrivals !== null || (!always && activeHandler() === null)) return false;\n    arrivals = new Map();\n    departures = new Map();\n    changed = new Set();\n    reflowDue = null;\n    return true;\n  }\n\n  function emitReflow(): void {\n    const moves = reflowDue;\n    reflowDue = null;\n    if (moves === null || moves.length === 0) return;\n    reflowListeners.emit(moves);\n  }\n\n  function settle(): ArrangedPose[] {\n    const pending = arrivals;\n    arrivals = null;\n    const handler = activeHandler();\n    if (pending === null || handler === null) return [];\n    // Only what is still there once the edit's other mutations have landed.\n    const landed = heldMoves(nodes, pending, true);\n    // Only what is gone from the container once the edit has landed: a child\n    // that left and came back did not depart.\n    const left = heldMoves(nodes, departures, false);\n    departures = new Map();\n    const touched = new Set([...changed].filter((id) => nodes.get(id)?.kind === 'container'));\n    if (landed.size === 0 && touched.size === 0) return [];\n    const poses = handler(landed, touched, left);\n    if (poses === null) throw new SceneArrivalRefused(landed);\n    const out: ArrangedPose[] = [];\n    for (const [id, to] of poses) {\n      const node = nodes.get(id);\n      if (node) out.push({ id, from: node.pose, to });\n    }\n    reflowDue = out as LayoutMove<TPose>[];\n    return out;\n  }\n\n  function abandon(): void {\n    arrivals = null;\n    reflowDue = null;\n  }\n\n  /** `ops` plus the op that settles their arrivals, when this call owns the\n   *  window; `ops` unchanged otherwise. Opened even on a scene with no layout\n   *  yet: an edit's op list is fixed before it runs, and any op in it may give\n   *  the scene its first. The arrange op that settles nothing elides itself. */\n  function withArrivalOps(ops: Op[]): { ops: Op[]; owned: boolean } {\n    if (!open(true)) return { ops, owned: false };\n    return { ops: [...ops, createArrangeOp({}, settle, env.writePose)], owned: true };\n  }\n\n  return {\n    layoutDeclared: () => { hasLayouts = true; },\n    setHandler(handler) {\n      installed = handler;\n      return () => {\n        if (installed === handler) installed = null;\n      };\n    },\n    onReflow: reflowListeners.subscribe,\n    noteArrival(id, parent, from) {\n      if (arrivals === null || parent === null || parent === from) return;\n      changed.add(parent);\n      const list = arrivals.get(parent);\n      if (list === undefined) arrivals.set(parent, [id]);\n      else if (!list.includes(id)) list.push(id);\n    },\n    noteDeparture(id, from, to) {\n      if (arrivals === null || from === null || from === to) return;\n      changed.add(from);\n      // One that joined earlier in this edit was never there to leave.\n      if (arrivals.get(from)?.includes(id)) return;\n      const list = departures.get(from);\n      if (list === undefined) departures.set(from, [id]);\n      else if (!list.includes(id)) list.push(id);\n    },\n    noteChange(id) {\n      if (arrivals !== null && id !== null) changed.add(id);\n    },\n    bareLayoutEdit: () => activeHandler() !== null && arrivals === null && env.recordsBareEdits(),\n    open,\n    settle,\n    emitReflow,\n    abandon,\n    runEdit(ops, run) {\n      const { ops: all, owned } = withArrivalOps(ops);\n      // An edit inside another's window leaves a refusal to the one that owns\n      // it, which reverts the whole edit and answers for it.\n      if (!owned) return run(all), true;\n      try {\n        run(all);\n        emitReflow();\n        return true;\n      } catch (err) {\n        if (!(err instanceof SceneArrivalRefused)) throw err;\n        return false;\n      } finally {\n        abandon();\n      }\n    },\n  };\n}\n"],"mappings":";;;;AAkEA,SAASA,EACP,GACA,GACA,GACuB;CACvB,IAAMC,oBAAM,IAAI,IAAsB;CACtC,KAAK,IAAM,CAACC,GAAQC,MAAQC,GAAO;EACjC,IAAMC,IAAOF,EAAI,QAAQ,MAAQG,EAAM,IAAIC,CAAE,CAAC,EAAE,WAAWL,MAAYM,CAAM;EAC7E,AAAIH,EAAK,SAAS,KAAKC,EAAM,IAAIJ,CAAM,KAAGD,EAAI,IAAIC,GAAQG,CAAI;CAChE;CACA,OAAOJ;AACT;AAEA,SAAgBQ,EACd,GACsB;CACtB,IAAM,EAAE,aAAUC,GACdC,IAA+C,MAC/CC,IAAa,IACbC,IAAyC,MACzCC,oBAAa,IAAI,IAAsB,GACvCC,oBAAU,IAAI,IAAY,GAE1BC,IAAwC,MACtCC,IAAkBC,EAAqD,GAEvEC,UAAyDR,MAAcC,IAAaF,EAAI,aAAa;CAE3G,SAASU,EAAK,IAAS,IAAgB;EAMrC,OALIP,MAAa,QAAS,CAACQ,KAAUF,EAAc,MAAM,OAAc,MACvE,oBAAW,IAAI,IAAI,GACnB,oBAAa,IAAI,IAAI,GACrB,oBAAU,IAAI,IAAI,GAClB,IAAY,MACL;CACT;CAEA,SAASG,IAAmB;EAC1B,IAAMC,IAAQP;EAEd,AADA,IAAY,MACRO,MAAU,QAAQA,EAAM,WAAW,KACvCN,EAAgB,KAAKM,CAAK;CAC5B;CAEA,SAASC,IAAyB;EAChC,IAAMC,IAAUZ;EAChB,IAAW;EACX,IAAMa,IAAUP,EAAc;EAC9B,IAAIM,MAAY,QAAQC,MAAY,MAAM,OAAO,CAAC;EAElD,IAAMC,IAAS3B,EAAUM,GAAOmB,GAAS,EAAI,GAGvCG,IAAO5B,EAAUM,GAAOQ,GAAY,EAAK;EAC/C,oBAAa,IAAI,IAAI;EACrB,IAAMe,IAAU,IAAI,IAAI,CAAC,GAAGd,CAAO,CAAC,CAAC,QAAQ,MAAOT,EAAM,IAAIC,CAAE,CAAC,EAAE,SAAS,WAAW,CAAC;EACxF,IAAIoB,EAAO,SAAS,KAAKE,EAAQ,SAAS,GAAG,OAAO,CAAC;EACrD,IAAMC,IAAQJ,EAAQC,GAAQE,GAASD,CAAI;EAC3C,IAAIE,MAAU,MAAM,MAAM,IAAIC,EAAoBJ,CAAM;EACxD,IAAM1B,IAAsB,CAAC;EAC7B,KAAK,IAAM,CAACM,GAAIyB,MAAOF,GAAO;GAC5B,IAAMG,IAAO3B,EAAM,IAAIC,CAAE;GACzB,AAAI0B,KAAMhC,EAAI,KAAK;IAAE;IAAI,MAAMgC,EAAK;IAAM;GAAG,CAAC;EAChD;EAEA,OADA,IAAYhC,GACLA;CACT;CAEA,SAASiC,IAAgB;EAEvB,AADA,IAAW,MACX,IAAY;CACd;CAMA,SAASC,EAAe,GAA0C;EAEhE,OADKf,EAAK,EAAI,IACP;GAAE,KAAK,CAAC,GAAGgB,GAAKC,EAAgB,CAAC,GAAGb,GAAQd,EAAI,SAAS,CAAC;GAAG,OAAO;EAAK,IADxD;GAAE;GAAK,OAAO;EAAM;CAE9C;CAEA,OAAO;EACL,sBAAsB;GAAE,IAAa;EAAM;EAC3C,WAAW,GAAS;GAElB,OADA,IAAYgB,SACC;IACX,AAAIf,MAAce,MAAS,IAAY;GACzC;EACF;EACA,UAAUT,EAAgB;EAC1B,YAAY,GAAI,GAAQ,GAAM;GAC5B,IAAIJ,MAAa,QAAQX,MAAW,QAAQA,MAAWoC,GAAM;GAC7D,EAAQ,IAAIpC,CAAM;GAClB,IAAMqC,IAAO1B,EAAS,IAAIX,CAAM;GAChC,AAAIqC,MAAS,KAAA,IAAW1B,EAAS,IAAIX,GAAQ,CAACK,CAAE,CAAC,IACvCgC,EAAK,SAAShC,CAAE,KAAGgC,EAAK,KAAKhC,CAAE;EAC3C;EACA,cAAc,GAAI,GAAM,GAAI;GAI1B,IAHIM,MAAa,QAAQyB,MAAS,QAAQA,MAASN,MACnDjB,EAAQ,IAAIuB,CAAI,GAEZzB,EAAS,IAAIyB,CAAI,CAAC,EAAE,SAAS/B,CAAE,IAAG;GACtC,IAAMgC,IAAOzB,EAAW,IAAIwB,CAAI;GAChC,AAAIC,MAAS,KAAA,IAAWzB,EAAW,IAAIwB,GAAM,CAAC/B,CAAE,CAAC,IACvCgC,EAAK,SAAShC,CAAE,KAAGgC,EAAK,KAAKhC,CAAE;EAC3C;EACA,WAAW,GAAI;GACb,AAAIM,MAAa,QAAQN,MAAO,QAAMQ,EAAQ,IAAIR,CAAE;EACtD;EACA,sBAAsBY,EAAc,MAAM,QAAQN,MAAa,QAAQH,EAAI,iBAAiB;EAC5F;EACA;EACA;EACA;EACA,QAAQ,GAAK,GAAK;GAChB,IAAM,EAAE,KAAK8B,GAAK,aAAUL,EAAeC,CAAG;GAG9C,IAAI,CAACK,GAAO,OAAOC,EAAIF,CAAG,GAAG;GAC7B,IAAI;IAGF,OAFAE,EAAIF,CAAG,GACPlB,EAAW,GACJ;GACT,SAASqB,GAAK;IACZ,IAAI,EAAEA,aAAeZ,IAAsB,MAAMY;IACjD,OAAO;GACT,UAAU;IACR,EAAQ;GACV;EACF;CACF;AACF"}

package/dist/core/scene/boundOps.js

@@ -0,0 +1,40 @@
+import { dwarn as e } from "../../debug/flag.js";
+//#region src/core/scene/boundOps.ts
+function t(e, n) {
+	return {
+		name: e.name,
+		args: e.args,
+		label: e.label,
+		get coalesceKey() {
+			return e.coalesceKey;
+		},
+		elideNoop: e.elideNoop,
+		apply: () => e.apply(n),
+		invert: () => t(e.invert(), n)
+	};
+}
+function n(t, r) {
+	return {
+		name: t.name,
+		args: t.args,
+		label: t.label,
+		get coalesceKey() {
+			return t.coalesceKey;
+		},
+		elideNoop: t.elideNoop,
+		apply: () => {
+			let n = r();
+			if (!n) return e("scene", `restored op "${t.name ?? "?"}" has no history adapter — skipping (setHistoryAdapter was not wired)`), "noop";
+			try {
+				return t.apply(n());
+			} catch (n) {
+				return e("scene", `restored op "${t.name ?? "?"}" failed against the history adapter — skipping: ${String(n)}`), "noop";
+			}
+		},
+		invert: () => n(t.invert(), r)
+	};
+}
+//#endregion
+export { t as bindOpToAdapter, n as bindOpToHistoryAdapter };
+
+//# sourceMappingURL=boundOps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boundOps.js","names":["bindOpToAdapter","op","adapter","bindOpToHistoryAdapter","get","accessor","dwarn","err"],"sources":["../../../src/core/scene/boundOps.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport { dwarn } from 'debug/flag';\n\n/** Rebind an external op to the adapter supplied at the `applyBatch` call\n *  site — the scene's engine was constructed without an adapter, so ops\n *  it stores and later replays must close over the right one. Forwards\n *  the apply return value (no-op detection) and preserves\n *  `coalesceKey`/`name`/`args`/`label` for coalescing and eviction. See\n *  `bindOpToHistoryAdapter` for RESTORED entries (lazy accessor). */\nexport function bindOpToAdapter(op: Op, adapter: unknown): Op {\n  return {\n    name: op.name,\n    args: op.args,\n    label: op.label,\n    // Read when asked: an arrange op has no key until it has applied.\n    get coalesceKey() { return op.coalesceKey; },\n    elideNoop: op.elideNoop,\n    apply: () => op.apply(adapter),\n    invert: () => bindOpToAdapter(op.invert(), adapter),\n  };\n}\n\n/** Wrap a globally-rebuilt external op so apply resolves the history\n *  adapter lazily — wiring order vs restoreHistory doesn't matter. An\n *  unset accessor makes the op a debug-warned no-op, and an apply that\n *  throws (e.g. the wired adapter lacks a method the op calls) degrades\n *  the same way — never throws mid-undo, matching the placeholder\n *  degradation policy. (The engine pops entries before applying, so an\n *  uncaught throw would corrupt the stacks.) See `bindOpToAdapter` for\n *  the live `applyBatch` path (fixed call-site adapter). */\nexport function bindOpToHistoryAdapter(op: Op, accessor: () => (() => unknown) | null): Op {\n  return {\n    name: op.name,\n    args: op.args,\n    label: op.label,\n    get coalesceKey() { return op.coalesceKey; },\n    elideNoop: op.elideNoop,\n    apply: () => {\n      const get = accessor();\n      if (!get) {\n        dwarn('scene', `restored op \"${op.name ?? '?'}\" has no history adapter — skipping (setHistoryAdapter was not wired)`);\n        return 'noop';\n      }\n      try {\n        return op.apply(get());\n      } catch (err) {\n        dwarn('scene', `restored op \"${op.name ?? '?'}\" failed against the history adapter — skipping: ${String(err)}`);\n        return 'noop';\n      }\n    },\n    invert: () => bindOpToHistoryAdapter(op.invert(), accessor),\n  };\n}\n"],"mappings":";;AASA,SAAgBA,EAAgB,GAAQ,GAAsB;CAC5D,OAAO;EACL,MAAMC,EAAG;EACT,MAAMA,EAAG;EACT,OAAOA,EAAG;EAEV,IAAI,cAAc;GAAE,OAAOA,EAAG;EAAa;EAC3C,WAAWA,EAAG;EACd,aAAaA,EAAG,MAAMC,CAAO;EAC7B,cAAcF,EAAgBC,EAAG,OAAO,GAAGC,CAAO;CACpD;AACF;AAUA,SAAgBC,EAAuB,GAAQ,GAA4C;CACzF,OAAO;EACL,MAAMF,EAAG;EACT,MAAMA,EAAG;EACT,OAAOA,EAAG;EACV,IAAI,cAAc;GAAE,OAAOA,EAAG;EAAa;EAC3C,WAAWA,EAAG;EACd,aAAa;GACX,IAAMG,IAAMC,EAAS;GACrB,IAAI,CAACD,GAEH,OADAE,EAAM,SAAS,gBAAgBL,EAAG,QAAQ,IAAI,sEAAsE,GAC7G;GAET,IAAI;IACF,OAAOA,EAAG,MAAMG,EAAI,CAAC;GACvB,SAASG,GAAK;IAEZ,OADAD,EAAM,SAAS,gBAAgBL,EAAG,QAAQ,IAAI,mDAAmD,OAAOM,CAAG,GAAG,GACvG;GACT;EACF;EACA,cAAcJ,EAAuBF,EAAG,OAAO,GAAGI,CAAQ;CAC5D;AACF"}

package/dist/core/scene/composeFrame.js

@@ -4,18 +4,21 @@ var e = {
 	decompose: (e, t) => t,
 	closure: "identity"
 };
-function t(e, t, n) {
+function t(e) {
+	return e.closure !== "identity";
+}
+function n(e, t, n) {
 	let r = [t], i = /* @__PURE__ */ new Set([t]), a = e.getParent(t);
 	for (; a !== null && !i.has(a);) i.add(a), (e.definesFrame?.(a) ?? !0) && r.push(a), a = e.getParent(a);
 	let o = e.getPose(r[r.length - 1]);
 	for (let t = r.length - 2; t >= 0; t--) o = n(o, e.getPose(r[t]));
 	return o;
 }
-function n(e, n, i, a, o) {
-	let s = r(e, i);
-	return s === null ? n : o(t(e, s, a), n);
+function r(e, t, r, a, o) {
+	let s = i(e, r);
+	return s === null ? t : o(n(e, s, a), t);
 }
-function r(e, t) {
+function i(e, t) {
 	let n = /* @__PURE__ */ new Set(), r = t;
 	for (; r !== null && !n.has(r);) {
 		if (e.definesFrame?.(r) ?? !0) return r;
@@ -24,6 +27,6 @@ function r(e, t) {
 	return null;
 }
 //#endregion
-export { e as IDENTITY_POSE_COMPOSITION, t as composeWorldPose, r as frameAtOrAbove, n as rebaseLocalPose };
+export { e as IDENTITY_POSE_COMPOSITION, n as composeWorldPose, t as composesFrames, i as frameAtOrAbove, r as rebaseLocalPose };
 
 //# sourceMappingURL=composeFrame.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"composeFrame.js","names":["IDENTITY_POSE_COMPOSITION","child","world","composeWorldPose","chain","id","seen","cursor","adapter","i","compose","rebaseLocalPose","frame","frameAtOrAbove","newParentId","worldPose","decompose"],"sources":["../../../src/core/scene/composeFrame.ts"],"sourcesContent":["/**\n * Folding a node's pose up its parent chain to world, and back down. Lives\n * under `core/` so the scene can lay out in world without reaching up into\n * `features/`; `features/groups/composePose` re-exports all of it.\n */\n\n/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */\nexport interface PoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  getParent(id: string): string | null;\n  /** Whether `id`'s pose is a frame its children are expressed in. Absent\n   *  means every node is one. A container whose pose derives from its children\n   *  is not: its children share its frame, so the fold passes over it. */\n  definesFrame?(id: string): boolean;\n}\n\n/**\n * The transforms a `compose` represents **exactly**. A parent transform wider\n * than its strategy's closure is rounded to the nearest pose — for `'rigid'`\n * that means an anisotropically scaled parent turns a rotated child into a\n * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the\n * shear is dropped.\n *\n * Measured over 50,000 random parent/child pairs: rotation and translation\n * compose to within 5.7e-13, anisotropic scale to a right-angle error of 0.99.\n * See `docs/superpowers/specs/2026-09-10-group-as-frame-design.md`.\n */\nexport type PoseClosure = 'identity' | 'translation' | 'rigid';\n\n/** Consumer's pose-composition strategy for hierarchical scenes. `compose`\n *  folds a child's pose (in parent's frame) up to the next frame; `decompose`\n *  is its inverse. Default is IDENTITY — an absolute-pose scene where every\n *  node already stores world coords (parent is grouping-only, no transform). */\nexport interface PoseComposition<TPose> {\n  compose: (parent: TPose, child: TPose) => TPose;\n  decompose: (parent: TPose, world: TPose) => TPose;\n  closure: PoseClosure;\n}\n\n/** Default pose-composition strategy: IDENTITY. Both `compose` and\n *  `decompose` return the child/world pose unchanged, modeling an\n *  absolute-pose scene where every node stores world coords and parents are\n *  grouping-only (no transform). With this strategy `composeWorldPose`\n *  returns a node's own raw pose and `rebaseLocalPose` is a no-op. */\nexport const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown> = {\n  compose: (_parent, child) => child,\n  decompose: (_parent, world) => world,\n  closure: 'identity',\n};\n\n/**\n * Walk `id`'s parent chain (root first to id last) and fold local poses into\n * a world pose via `compose`. Returns the world pose for `id`. Cycle-safe:\n * a visited-set guard breaks if the chain ever loops back to itself.\n *\n * `compose(parent, child)` interprets `child` as expressed *in `parent`'s\n * local frame* and returns the equivalent pose in the next frame up. For a\n * standard translation-only rect: `world = { x: p.x + c.x, y: p.y + c.y,\n * width: c.width, height: c.height }`.\n */\nexport function composeWorldPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string,\n  compose: (parent: TPose, child: TPose) => TPose,\n): TPose {\n  const chain: string[] = [id];\n  const seen = new Set<string>([id]);\n  let cursor: string | null = adapter.getParent(id);\n  while (cursor !== null) {\n    if (seen.has(cursor)) break;\n    seen.add(cursor);\n    if (adapter.definesFrame?.(cursor) ?? true) chain.push(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  // chain is [id, parent, grandparent, ..., root]; fold from the root down.\n  let world = adapter.getPose(chain[chain.length - 1]);\n  for (let i = chain.length - 2; i >= 0; i--) {\n    world = compose(world, adapter.getPose(chain[i]));\n  }\n  return world;\n}\n\n/**\n * Convert `worldPose` into a local pose expressed under `newParentId`'s\n * frame. Used when reparenting so the child's visual world position is\n * preserved despite the change of frame. Inverse of one `compose` step.\n *\n * `decompose(parent, world)` returns the local pose `child` such that\n * `compose(parent, child) === world`. For axis-aligned rects:\n * `child = { ...world, x: world.x - parent.x, y: world.y - parent.y }`.\n *\n * Pass `newParentId === null` for the root frame; the function returns\n * `worldPose` unchanged.\n */\nexport function rebaseLocalPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  worldPose: TPose,\n  newParentId: string | null,\n  compose: (parent: TPose, child: TPose) => TPose,\n  decompose: (parent: TPose, world: TPose) => TPose,\n): TPose {\n  const frame = frameAtOrAbove(adapter, newParentId);\n  if (frame === null) return worldPose;\n  return decompose(composeWorldPose(adapter, frame, compose), worldPose);\n}\n\n/** The nearest node at or above `id` whose pose is a frame, or `null` for the\n *  root frame. Cycle-safe, like `composeWorldPose`. */\nexport function frameAtOrAbove<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string | null,\n): string | null {\n  const seen = new Set<string>();\n  let cursor = id;\n  while (cursor !== null && !seen.has(cursor)) {\n    if (adapter.definesFrame?.(cursor) ?? true) return cursor;\n    seen.add(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  return null;\n}\n"],"mappings":";AA4CA,IAAaA,IAAsD;CACjE,UAAU,GAAS,MAAUC;CAC7B,YAAY,GAAS,MAAUC;CAC/B,SAAS;AACX;AAYA,SAAgBC,EACd,GACA,GACA,GACO;CACP,IAAMC,IAAkB,CAACC,CAAE,GACrBC,oBAAO,IAAI,IAAY,CAACD,CAAE,CAAC,GAC7BE,IAAwBC,EAAQ,UAAUH,CAAE;CAChD,OAAOE,MAAW,QACZ,GAAK,IAAIA,CAAM,IAGnB,AAFAD,EAAK,IAAIC,CAAM,IACXC,EAAQ,eAAeD,CAAM,KAAK,OAAMH,EAAM,KAAKG,CAAM,GAC7D,IAASC,EAAQ,UAAUD,CAAM;CAGnC,IAAIL,IAAQM,EAAQ,QAAQJ,EAAMA,EAAM,SAAS,EAAE;CACnD,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAQC,EAAQR,GAAOM,EAAQ,QAAQJ,EAAMK,EAAE,CAAC;CAElD,OAAOP;AACT;AAcA,SAAgBS,EACd,GACA,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAQC,EAAeL,GAASM,CAAW;CAEjD,OADIF,MAAU,OAAaG,IACpBC,EAAUb,EAAiBK,GAASI,GAAOF,CAAO,GAAGK,CAAS;AACvE;AAIA,SAAgBF,EACd,GACA,GACe;CACf,IAAMP,oBAAO,IAAI,IAAY,GACzBC,IAASF;CACb,OAAOE,MAAW,QAAQ,CAACD,EAAK,IAAIC,CAAM,IAAG;EAC3C,IAAIC,EAAQ,eAAeD,CAAM,KAAK,IAAM,OAAOA;EAEnD,AADAD,EAAK,IAAIC,CAAM,GACf,IAASC,EAAQ,UAAUD,CAAM;CACnC;CACA,OAAO;AACT"}
+{"version":3,"file":"composeFrame.js","names":["IDENTITY_POSE_COMPOSITION","child","world","composesFrames","composition","composeWorldPose","chain","id","seen","cursor","adapter","i","compose","rebaseLocalPose","frame","frameAtOrAbove","newParentId","worldPose","decompose"],"sources":["../../../src/core/scene/composeFrame.ts"],"sourcesContent":["/** Folding a node's pose up its parent chain to world, and back down. */\n\n/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */\nexport interface PoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  getParent(id: string): string | null;\n  /** Whether `id`'s pose is a frame its children are expressed in. Absent\n   *  means every node is one. A container whose pose derives from its children\n   *  is not: its children share its frame, so the fold passes over it. */\n  definesFrame?(id: string): boolean;\n}\n\n/**\n * The transforms a `compose` represents **exactly**. A parent transform wider\n * than its strategy's closure is rounded to the nearest pose — for `'rigid'`\n * that means an anisotropically scaled parent turns a rotated child into a\n * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the\n * shear is dropped.\n */\nexport type PoseClosure = 'identity' | 'translation' | 'rigid';\n\n/** Consumer's pose-composition strategy for hierarchical scenes. `compose`\n *  folds a child's pose (in parent's frame) up to the next frame; `decompose`\n *  is its inverse. Default is IDENTITY — an absolute-pose scene where every\n *  node already stores world coords (parent is grouping-only, no transform). */\nexport interface PoseComposition<TPose> {\n  compose(parent: TPose, child: TPose): TPose;\n  decompose(parent: TPose, world: TPose): TPose;\n  closure: PoseClosure;\n}\n\n/** Default pose-composition strategy: IDENTITY, an absolute-pose scene. */\nexport const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown> = {\n  compose: (_parent, child) => child,\n  decompose: (_parent, world) => world,\n  closure: 'identity',\n};\n\n/** Whether `composition` makes a container's pose a frame, so a stored pose\n *  is local to it. False for the absolute-pose model. */\nexport function composesFrames(composition: { closure: PoseClosure }): boolean {\n  return composition.closure !== 'identity';\n}\n\n/**\n * Walk `id`'s parent chain and fold local poses into a world pose via\n * `compose`. Cycle-safe.\n *\n * `compose(parent, child)` interprets `child` as expressed *in `parent`'s\n * local frame* and returns the equivalent pose in the next frame up.\n */\nexport function composeWorldPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string,\n  compose: (parent: TPose, child: TPose) => TPose,\n): TPose {\n  const chain: string[] = [id];\n  const seen = new Set<string>([id]);\n  let cursor: string | null = adapter.getParent(id);\n  while (cursor !== null) {\n    if (seen.has(cursor)) break;\n    seen.add(cursor);\n    if (adapter.definesFrame?.(cursor) ?? true) chain.push(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  // chain is [id, parent, grandparent, ..., root]; fold from the root down.\n  let world = adapter.getPose(chain[chain.length - 1]);\n  for (let i = chain.length - 2; i >= 0; i--) {\n    world = compose(world, adapter.getPose(chain[i]));\n  }\n  return world;\n}\n\n/**\n * Convert `worldPose` into a local pose expressed under `newParentId`'s\n * frame, so a reparented child keeps its visual world position.\n *\n * `decompose(parent, world)` returns the local pose `child` such that\n * `compose(parent, child) === world`. Pass `newParentId === null` for the\n * root frame; the function returns `worldPose` unchanged.\n */\nexport function rebaseLocalPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  worldPose: TPose,\n  newParentId: string | null,\n  compose: (parent: TPose, child: TPose) => TPose,\n  decompose: (parent: TPose, world: TPose) => TPose,\n): TPose {\n  const frame = frameAtOrAbove(adapter, newParentId);\n  if (frame === null) return worldPose;\n  return decompose(composeWorldPose(adapter, frame, compose), worldPose);\n}\n\n/** The nearest node at or above `id` whose pose is a frame, or `null` for the\n *  root frame. Cycle-safe, like `composeWorldPose`. */\nexport function frameAtOrAbove<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string | null,\n): string | null {\n  const seen = new Set<string>();\n  let cursor = id;\n  while (cursor !== null && !seen.has(cursor)) {\n    if (adapter.definesFrame?.(cursor) ?? true) return cursor;\n    seen.add(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  return null;\n}\n"],"mappings":";AAgCA,IAAaA,IAAsD;CACjE,UAAU,GAAS,MAAUC;CAC7B,YAAY,GAAS,MAAUC;CAC/B,SAAS;AACX;AAIA,SAAgBC,EAAe,GAAgD;CAC7E,OAAOC,EAAY,YAAY;AACjC;AASA,SAAgBC,EACd,GACA,GACA,GACO;CACP,IAAMC,IAAkB,CAACC,CAAE,GACrBC,oBAAO,IAAI,IAAY,CAACD,CAAE,CAAC,GAC7BE,IAAwBC,EAAQ,UAAUH,CAAE;CAChD,OAAOE,MAAW,QACZ,GAAK,IAAIA,CAAM,IAGnB,AAFAD,EAAK,IAAIC,CAAM,IACXC,EAAQ,eAAeD,CAAM,KAAK,OAAMH,EAAM,KAAKG,CAAM,GAC7D,IAASC,EAAQ,UAAUD,CAAM;CAGnC,IAAIP,IAAQQ,EAAQ,QAAQJ,EAAMA,EAAM,SAAS,EAAE;CACnD,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAQC,EAAQV,GAAOQ,EAAQ,QAAQJ,EAAMK,EAAE,CAAC;CAElD,OAAOT;AACT;AAUA,SAAgBW,EACd,GACA,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAQC,EAAeL,GAASM,CAAW;CAEjD,OADIF,MAAU,OAAaG,IACpBC,EAAUb,EAAiBK,GAASI,GAAOF,CAAO,GAAGK,CAAS;AACvE;AAIA,SAAgBF,EACd,GACA,GACe;CACf,IAAMP,oBAAO,IAAI,IAAY,GACzBC,IAASF;CACb,OAAOE,MAAW,QAAQ,CAACD,EAAK,IAAIC,CAAM,IAAG;EAC3C,IAAIC,EAAQ,eAAeD,CAAM,KAAK,IAAM,OAAOA;EAEnD,AADAD,EAAK,IAAIC,CAAM,GACf,IAASC,EAAQ,UAAUD,CAAM;CACnC;CACA,OAAO;AACT"}

package/dist/{features/groups → core/scene}/composePose.js

@@ -1,32 +1,32 @@
-import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, frameAtOrAbove as n, rebaseLocalPose as r } from "../../core/scene/composeFrame.js";
-//#region src/features/groups/composePose.ts
-function i(e, t) {
+import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, composesFrames as n, frameAtOrAbove as r, rebaseLocalPose as i } from "./composeFrame.js";
+//#region src/core/scene/composePose.ts
+function a(e, t) {
 	return {
 		...t,
 		x: e.x + t.x,
 		y: e.y + t.y
 	};
 }
-function a(e, t, n) {
+function o(e, t, n) {
 	return {
 		...e,
 		x: e.x + t,
 		y: e.y + n
 	};
 }
-function o(e, t) {
+function s(e, t) {
 	return {
 		...t,
 		x: t.x - e.x,
 		y: t.y - e.y
 	};
 }
-function s(e, t, n, r, i) {
+function c(e, t, n, r, i) {
 	let a = Math.cos(n), o = Math.sin(n);
 	return [e + (r - e) * a - (i - t) * o, t + (r - e) * o + (i - t) * a];
 }
-function c(e, t) {
-	let n = e.rotation ?? 0, [r, i] = s(e.x + e.width / 2, e.y + e.height / 2, n, e.x + t.x + t.width / 2, e.y + t.y + t.height / 2);
+function l(e, t) {
+	let n = e.rotation ?? 0, [r, i] = c(e.x + e.width / 2, e.y + e.height / 2, n, e.x + t.x + t.width / 2, e.y + t.y + t.height / 2);
 	return {
 		...t,
 		x: r - t.width / 2,
@@ -34,8 +34,8 @@ function c(e, t) {
 		rotation: (t.rotation ?? 0) + n
 	};
 }
-function l(e, t) {
-	let n = e.rotation ?? 0, [r, i] = s(e.x + e.width / 2, e.y + e.height / 2, -n, t.x + t.width / 2, t.y + t.height / 2);
+function u(e, t) {
+	let n = e.rotation ?? 0, [r, i] = c(e.x + e.width / 2, e.y + e.height / 2, -n, t.x + t.width / 2, t.y + t.height / 2);
 	return {
 		...t,
 		x: r - e.x - t.width / 2,
@@ -43,16 +43,16 @@ function l(e, t) {
 		rotation: (t.rotation ?? 0) - n
 	};
 }
-var u = {
-	compose: i,
-	decompose: o,
+var d = {
+	compose: a,
+	decompose: s,
 	closure: "translation"
-}, d = {
-	compose: c,
-	decompose: l,
+}, f = {
+	compose: l,
+	decompose: u,
 	closure: "rigid"
 };
-function f(e, n) {
+function p(e, n) {
 	return (r) => {
 		try {
 			return t(e, r, n);
@@ -62,6 +62,6 @@ function f(e, n) {
 	};
 }
 //#endregion
-export { e as IDENTITY_POSE_COMPOSITION, u as RECT_POSE_COMPOSITION, d as RIGID_POSE_COMPOSITION, i as composeRectPose, c as composeRigidPose, t as composeWorldPose, o as decomposeRectPose, l as decomposeRigidPose, n as frameAtOrAbove, r as rebaseLocalPose, a as translateRectPose, f as worldPoseLookup };
+export { e as IDENTITY_POSE_COMPOSITION, d as RECT_POSE_COMPOSITION, f as RIGID_POSE_COMPOSITION, a as composeRectPose, l as composeRigidPose, t as composeWorldPose, n as composesFrames, s as decomposeRectPose, u as decomposeRigidPose, r as frameAtOrAbove, i as rebaseLocalPose, o as translateRectPose, p as worldPoseLookup };
 
 //# sourceMappingURL=composePose.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composePose.js","names":["composeRectPose","child","parent","translateRectPose","pose","dx","dy","decomposeRectPose","world","turn","c","r","s","cx","x","y","cy","composeRigidPose","pr","wcx","wcy","decomposeRigidPose","ux","uy","RECT_POSE_COMPOSITION","RIGID_POSE_COMPOSITION","worldPoseLookup","composeWorldPose","adapter","id","compose","IDENTITY_POSE_COMPOSITION","composesFrames","frameAtOrAbove","rebaseLocalPose"],"sources":["../../../src/core/scene/composePose.ts"],"sourcesContent":["/**\n * Pose composition for hierarchical scene graphs.\n *\n * `getPose(id)` on adapters returns the **local** pose — relative to the\n * object's direct parent. Anything in the kit that needs world coordinates\n * routes through `composeWorldPose`, which folds local poses together via a\n * consumer-supplied `compose`.\n */\n\nimport type { RectPose } from 'core/scene/types';\nexport type { RectPose };\n\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composesFrames,\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseClosure,\n  type PoseComposition,\n} from 'core/scene/composeFrame';\nexport { IDENTITY_POSE_COMPOSITION, composesFrames, composeWorldPose, frameAtOrAbove, rebaseLocalPose };\nexport type { PoseAdapter, PoseClosure, PoseComposition };\n\n/**\n * `compose` for axis-aligned rectangles under a translation-only hierarchy.\n * Adds translation; every other field is taken from the child unchanged.\n */\nexport function composeRectPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  return {\n    ...child,\n    x: parent.x + child.x,\n    y: parent.y + child.y,\n  };\n}\n\n/** Translate a `RectPose`-shaped pose by `(dx, dy)`; other fields are preserved. */\nexport function translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): TPose {\n  return { ...pose, x: pose.x + dx, y: pose.y + dy };\n}\n\n/** Inverse of `composeRectPose` — subtracts parent translation. */\nexport function decomposeRectPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  return {\n    ...world,\n    x: world.x - parent.x,\n    y: world.y - parent.y,\n  };\n}\n\n/** Turn `(x, y)` about `(cx, cy)` by `r` radians. */\nfunction turn(cx: number, cy: number, r: number, x: number, y: number): [number, number] {\n  const c = Math.cos(r);\n  const s = Math.sin(r);\n  return [cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c];\n}\n\n/**\n * `compose` for a container whose pose defines a **frame**: the child's local\n * pose is offset into the parent's unrotated box, then the whole thing is\n * turned about the parent's center. Rotations add; the child keeps its size.\n *\n * Reduces to `composeRectPose` when the parent is upright. Exact for\n * translation and rotation; a parent carrying scale is outside what this can\n * express — see `PoseClosure`.\n */\nexport function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const [wcx, wcy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    pr,\n    parent.x + child.x + child.width / 2,\n    parent.y + child.y + child.height / 2,\n  );\n  return {\n    ...child,\n    x: wcx - child.width / 2,\n    y: wcy - child.height / 2,\n    rotation: (child.rotation ?? 0) + pr,\n  };\n}\n\n/** Inverse of `composeRigidPose` — un-turns about the parent's center, then\n *  subtracts the parent's offset. */\nexport function decomposeRigidPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const [ux, uy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    -pr,\n    world.x + world.width / 2,\n    world.y + world.height / 2,\n  );\n  return {\n    ...world,\n    x: ux - parent.x - world.width / 2,\n    y: uy - parent.y - world.height / 2,\n    rotation: (world.rotation ?? 0) - pr,\n  };\n}\n\n/** Translation-only composition over `RectPose`. What a scene wants when a\n *  container groups its children but never turns them. */\nexport const RECT_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRectPose,\n  decompose: decomposeRectPose,\n  closure: 'translation',\n};\n\n/** Composition over `RectPose` where a container's pose is a frame: rotating\n *  the container rotates its contents. */\nexport const RIGID_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRigidPose,\n  decompose: decomposeRigidPose,\n  closure: 'rigid',\n};\n\n/**\n * Build a `(id) => world pose | null` callback over a `PoseAdapter`, for\n * RenderLayers that take a `getPose` callback.\n *\n * Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the\n * common case is an id removed mid-render between selection state and the\n * next paint. Layers should treat `null` as \"skip this id.\"\n */\nexport function worldPoseLookup<TPose>(\n  adapter: PoseAdapter<TPose>,\n  compose: (parent: TPose, child: TPose) => TPose,\n): (id: string) => TPose | null {\n  return (id: string) => {\n    try {\n      return composeWorldPose(adapter, id, compose);\n    } catch {\n      return null;\n    }\n  };\n}\n"],"mappings":";;AA6BA,SAAgBA,EAAwC,GAAe,GAAqB;CAC1F,OAAO;EACL,GAAGC;EACH,GAAGC,EAAO,IAAID,EAAM;EACpB,GAAGC,EAAO,IAAID,EAAM;CACtB;AACF;AAGA,SAAgBE,EAA0C,GAAa,GAAY,GAAmB;CACpG,OAAO;EAAE,GAAGC;EAAM,GAAGA,EAAK,IAAIC;EAAI,GAAGD,EAAK,IAAIE;CAAG;AACnD;AAGA,SAAgBC,EAA0C,GAAe,GAAqB;CAC5F,OAAO;EACL,GAAGC;EACH,GAAGA,EAAM,IAAIN,EAAO;EACpB,GAAGM,EAAM,IAAIN,EAAO;CACtB;AACF;AAGA,SAASO,EAAK,GAAY,GAAY,GAAW,GAAW,GAA6B;CACvF,IAAMC,IAAI,KAAK,IAAIC,CAAC,GACdC,IAAI,KAAK,IAAID,CAAC;CACpB,OAAO,CAACE,KAAMC,IAAID,KAAMH,KAAKK,IAAIC,KAAMJ,GAAGI,KAAMF,IAAID,KAAMD,KAAKG,IAAIC,KAAMN,CAAC;AAC5E;AAWA,SAAgBO,EAAyC,GAAe,GAAqB;CAC3F,IAAMC,IAAKhB,EAAO,YAAY,GACxB,CAACiB,GAAKC,KAAOX,EACjBP,EAAO,IAAIA,EAAO,QAAQ,GAC1BA,EAAO,IAAIA,EAAO,SAAS,GAC3BgB,GACAhB,EAAO,IAAID,EAAM,IAAIA,EAAM,QAAQ,GACnCC,EAAO,IAAID,EAAM,IAAIA,EAAM,SAAS,CACtC;CACA,OAAO;EACL,GAAGA;EACH,GAAGkB,IAAMlB,EAAM,QAAQ;EACvB,GAAGmB,IAAMnB,EAAM,SAAS;EACxB,WAAWA,EAAM,YAAY,KAAKiB;CACpC;AACF;AAIA,SAAgBG,EAA2C,GAAe,GAAqB;CAC7F,IAAMH,IAAKhB,EAAO,YAAY,GACxB,CAACoB,GAAIC,KAAMd,EACfP,EAAO,IAAIA,EAAO,QAAQ,GAC1BA,EAAO,IAAIA,EAAO,SAAS,GAC3B,CAACgB,GACDV,EAAM,IAAIA,EAAM,QAAQ,GACxBA,EAAM,IAAIA,EAAM,SAAS,CAC3B;CACA,OAAO;EACL,GAAGA;EACH,GAAGc,IAAKpB,EAAO,IAAIM,EAAM,QAAQ;EACjC,GAAGe,IAAKrB,EAAO,IAAIM,EAAM,SAAS;EAClC,WAAWA,EAAM,YAAY,KAAKU;CACpC;AACF;AAIA,IAAaM,IAAmD;CAC9D,SAASxB;CACT,WAAWO;CACX,SAAS;AACX,GAIakB,IAAoD;CAC/D,SAASR;CACT,WAAWI;CACX,SAAS;AACX;AAUA,SAAgBK,EACd,GACA,GAC8B;CAC9B,QAAQ,MAAe;EACrB,IAAI;GACF,OAAOC,EAAiBC,GAASC,GAAIC,CAAO;EAC9C,QAAQ;GACN,OAAO;EACT;CACF;AACF"}

package/dist/core/scene/depMemo.js

@@ -1,18 +1,43 @@
 import { samePoseValue as e, snapshotPose as t } from "./poseSnapshot.js";
 //#region src/core/scene/depMemo.ts
-function n(e, n) {
-	e.nodes.length = 0, e.poses.length = 0;
-	for (let r of n) e.nodes.push(r?.node), e.poses.push(r === void 0 ? void 0 : t(r.pose));
+function n() {
+	return {
+		nodes: [],
+		poses: [],
+		data: [],
+		layers: [],
+		paths: []
+	};
 }
-function r(t, n, r) {
+var r = class {
+	dep;
+	paths;
+	index;
+	node;
+	pose;
+	constructor(e, t, n) {
+		this.dep = e, this.paths = t, this.index = n, this.node = e.node, this.pose = e.pose;
+	}
+	get path() {
+		return this.paths[this.index] = this.dep.path;
+	}
+};
+function i(e, n, i) {
+	return e.nodes.length = 0, e.poses.length = 0, e.data.length = 0, e.layers.length = 0, e.paths.length = 0, i(n.map((n, i) => (e.nodes.push(n?.node), e.poses.push(n === void 0 ? void 0 : t(n.pose)), e.data.push(n?.node.data), e.layers.push(n?.node.layer), e.paths.push(void 0), n === void 0 ? void 0 : new r(n, e.paths, i))));
+}
+function a(t, n, r) {
 	if (t.nodes.length !== n.length) return !1;
 	for (let i = 0; i < n.length; i++) {
 		let a = r(n[i]);
-		if (t.nodes[i] !== (a === void 0 ? void 0 : a.node) || a !== void 0 && !e(t.poses[i], a.pose)) return !1;
+		if (t.nodes[i] !== (a === void 0 ? void 0 : a.node)) return !1;
+		if (a === void 0) continue;
+		if (t.data[i] !== a.node.data || t.layers[i] !== a.node.layer || !e(t.poses[i], a.pose)) return !1;
+		let o = t.paths[i];
+		if (o !== void 0 && o !== a.path) return !1;
 	}
 	return !0;
 }
 //#endregion
-export { n as recordDeps, r as sameDeps };
+export { i as deriveRecorded, n as emptyDepRecord, a as sameDeps };
 
 //# sourceMappingURL=depMemo.js.map

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

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

package/dist/core/scene/derivedPath.js

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

package/dist/core/scene/editMode.js

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

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

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