@weasel-js/core 1.9.4 → 1.10.1

package/dist/core/scene/arrivalWindow.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"arrivalWindow.js","names":["createArrivalWindow","env","installed","arrivals","departures","changed","reflowDue","reflowListeners","createEmitter","activeHandler","open","always","emitReflow","moves","settle","pending","handler","landed","parent","ids","still","nodes","id","left","gone","touched","poses","SceneArrivalRefused","out","to","node","abandon","withArrivalOps","ops","createArrangeOp","from","list","all","run","owned","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, or `null` while it has none.\n   *  An installed handler takes its place. */\n  declared(): SceneArrivalHandler<TPose> | null;\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  /** 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  runEdit(ops: Op[], run: (ops: Op[]) => void): void;\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 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  function activeHandler(): SceneArrivalHandler<TPose> | null {\n    return installed ?? env.declared();\n  }\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 = new Map<NodeId, NodeId[]>();\n    for (const [parent, ids] of pending) {\n      const still = ids.filter((id) => nodes.get(id)?.parent === parent);\n      if (still.length > 0 && nodes.has(parent)) landed.set(parent, still);\n    }\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 = new Map<NodeId, NodeId[]>();\n    for (const [parent, ids] of departures) {\n      const gone = ids.filter((id) => nodes.get(id)?.parent !== parent);\n      if (gone.length > 0 && nodes.has(parent)) left.set(parent, gone);\n    }\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    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      try {\n        run(all);\n        if (owned) emitReflow();\n      } catch (err) {\n        if (!(err instanceof SceneArrivalRefused)) throw err;\n      } finally {\n        if (owned) abandon();\n      }\n    },\n  };\n}\n"],"mappings":"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"}
+{"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":"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"}

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 * What a container's pose does to its children under a `compose`: nothing,\n * an offset, or a whole frame. `'rigid'` is the frame: a container's rotation\n * and its `transform` both reach its children, and a child's `transform`\n * holds the skew or stretch its box and rotation cannot.\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":";AA+BA,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/core/scene/composePose.js

@@ -0,0 +1,105 @@
+import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, composesFrames as n, frameAtOrAbove as r, rebaseLocalPose as i } from "./composeFrame.js";
+import { applyToPoint as a, multiply as o, poseFrameInverseOf as s, poseFrameOf as c, poseLinearOf as l, rotate as u } from "@weasel-js/geom";
+//#region src/core/scene/composePose.ts
+function d(e, t) {
+	return {
+		...t,
+		x: e.x + t.x,
+		y: e.y + t.y
+	};
+}
+function f(e, t, n) {
+	return {
+		...e,
+		x: e.x + t,
+		y: e.y + n
+	};
+}
+function p(e, t) {
+	return {
+		...t,
+		x: t.x - e.x,
+		y: t.y - e.y
+	};
+}
+function m(e, t, n) {
+	let [r, i, a, s] = o(u(-t), n), c = Math.abs(r - 1) < 1e-12 && Math.abs(i) < 1e-12 && Math.abs(a) < 1e-12 && Math.abs(s - 1) < 1e-12, l = {
+		...e,
+		rotation: t
+	};
+	return c ? delete l.transform : l.transform = [
+		r,
+		i,
+		a,
+		s
+	], l;
+}
+function h(e, t, n) {
+	return {
+		...e,
+		x: t - e.width / 2,
+		y: n - e.height / 2
+	};
+}
+var g = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function _(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 v(e, t) {
+	let n = e.rotation ?? 0, r = l(e) && c(e);
+	if (r) {
+		let [i, s] = a(r, e.x + t.x + t.width / 2, e.y + t.y + t.height / 2), l = o(r, c(t) ?? g);
+		return m(h(t, i, s), (t.rotation ?? 0) + n, l);
+	}
+	let [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);
+	return {
+		...t,
+		x: i - t.width / 2,
+		y: s - t.height / 2,
+		rotation: (t.rotation ?? 0) + n
+	};
+}
+function y(e, t) {
+	let n = e.rotation ?? 0, r = l(e) && s(e);
+	if (r) {
+		let [i, s] = a(r, t.x + t.width / 2, t.y + t.height / 2), l = o(r, c(t) ?? g);
+		return m(h(t, i - e.x, s - e.y), (t.rotation ?? 0) - n, l);
+	}
+	let [i, u] = _(e.x + e.width / 2, e.y + e.height / 2, -n, t.x + t.width / 2, t.y + t.height / 2);
+	return {
+		...t,
+		x: i - e.x - t.width / 2,
+		y: u - e.y - t.height / 2,
+		rotation: (t.rotation ?? 0) - n
+	};
+}
+var b = {
+	compose: d,
+	decompose: p,
+	closure: "translation"
+}, x = {
+	compose: v,
+	decompose: y,
+	closure: "rigid"
+};
+function S(e, n) {
+	return (r) => {
+		try {
+			return t(e, r, n);
+		} catch {
+			return null;
+		}
+	};
+}
+//#endregion
+export { e as IDENTITY_POSE_COMPOSITION, b as RECT_POSE_COMPOSITION, x as RIGID_POSE_COMPOSITION, d as composeRectPose, v as composeRigidPose, t as composeWorldPose, n as composesFrames, p as decomposeRectPose, y as decomposeRigidPose, r as frameAtOrAbove, i as rebaseLocalPose, f as translateRectPose, S 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","withLinear","a","b","c","d","multiply","rotate","rotation","linear","plain","next","centeredAt","cx","cy","NO_FRAME","turn","r","s","x","y","composeRigidPose","pr","frame","poseLinearOf","poseFrameOf","applyToPoint","wcx","wcy","decomposeRigidPose","back","poseFrameInverseOf","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 { applyToPoint, multiply, poseFrameInverseOf, poseFrameOf, poseLinearOf, rotate, type Affine } from '@weasel-js/geom';\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/** `pose` with the linear part `linear` held as `rotation` and whatever is\n *  left over as `transform`, which is dropped when nothing is. */\nfunction withLinear<TPose extends RectPose>(pose: TPose, rotation: number, linear: Affine): TPose {\n  const [a, b, c, d] = multiply(rotate(-rotation), linear);\n  const plain = Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12;\n  const next: RectPose = { ...pose, rotation };\n  if (plain) delete next.transform;\n  else next.transform = [a, b, c, d];\n  return next as TPose;\n}\n\n/** `pose` moved so its box center is at `(cx, cy)`. */\nfunction centeredAt<TPose extends RectPose>(pose: TPose, cx: number, cy: number): TPose {\n  return { ...pose, x: cx - pose.width / 2, y: cy - pose.height / 2 };\n}\n\nconst NO_FRAME: Affine = [1, 0, 0, 1, 0, 0];\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. A parent's\n * `transform` composes too, and what the child's box and rotation cannot hold\n * of the result lands in the child's own `transform`.\n */\nexport function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const frame = poseLinearOf(parent) && poseFrameOf(parent);\n  if (frame) {\n    const [cx, cy] = applyToPoint(frame, parent.x + child.x + child.width / 2, parent.y + child.y + child.height / 2);\n    const linear = multiply(frame, poseFrameOf(child) ?? NO_FRAME);\n    return withLinear(centeredAt(child, cx, cy), (child.rotation ?? 0) + pr, linear);\n  }\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  // A singular transform has no inverse: the container draws nothing, and the turn alone is undone.\n  const back = poseLinearOf(parent) && poseFrameInverseOf(parent);\n  if (back) {\n    const [ux, uy] = applyToPoint(back, world.x + world.width / 2, world.y + world.height / 2);\n    const linear = multiply(back, poseFrameOf(world) ?? NO_FRAME);\n    return withLinear(centeredAt(world, ux - parent.x, uy - parent.y), (world.rotation ?? 0) - pr, linear);\n  }\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":"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"}

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