@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/scene/appliedLog.js

@@ -1,37 +1,45 @@
 //#region src/core/scene/appliedLog.ts
-function e(e) {
-	let t = null;
+function createAppliedLog(env) {
+	let applied = null;
 	return {
-		atomically(n, r) {
-			let i = t, a = [], o = e.getSelection();
-			t = a;
+		atomically(fn, ownsEntry) {
+			const outer = applied;
+			const log = [];
+			const selectionBefore = env.getSelection();
+			applied = log;
 			try {
-				let e = n();
-				return i && !r() && i.push(...a), e;
-			} catch (n) {
-				throw t = null, e.lifted(() => {
-					for (let t = a.length - 1; t >= 0; t--) {
-						let { kind: n, payload: r, reverted: i } = a[t], o = e.registered.get(n);
-						(i ? o.apply : o.revert)(r);
+				const result = fn();
+				if (outer && !ownsEntry()) outer.push(...log);
+				return result;
+			} catch (err) {
+				applied = null;
+				env.lifted(() => {
+					for (let i = log.length - 1; i >= 0; i--) {
+						const { kind, payload, reverted } = log[i];
+						const handler = env.registered.get(kind);
+						(reverted ? handler.apply : handler.revert)(payload);
 					}
-				}), e.setSelection(o), a.length > 0 && e.notify(), n;
+				});
+				env.setSelection(selectionBefore);
+				if (log.length > 0) env.notify();
+				throw err;
 			} finally {
-				t = i;
+				applied = outer;
 			}
 		},
-		logApplied(e, n, r) {
-			t?.push(r === void 0 ? {
-				kind: e,
-				payload: n
+		logApplied(kind, payload, reverted) {
+			applied?.push(reverted === void 0 ? {
+				kind,
+				payload
 			} : {
-				kind: e,
-				payload: n,
-				reverted: r
+				kind,
+				payload,
+				reverted
 			});
 		}
 	};
 }
-//#endregion
-export { e as createAppliedLog };
 
+//#endregion
+export { createAppliedLog };
 //# sourceMappingURL=appliedLog.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"appliedLog.js","names":["createAppliedLog","applied","outer","log","selectionBefore","env","result","fn","ownsEntry","err","i","handler","kind","reverted","payload"],"sources":["../../../src/core/scene/appliedLog.ts"],"sourcesContent":["/**\n * The scene's atomic-revert log: every kit op applied since the innermost\n * `atomically` opened, so an edit that is refused partway can take back what\n * it already did.\n */\nimport type { NodeId, RegisteredOp } from './types';\n\n/** What the log needs from the scene it reverts. */\nexport interface AppliedLogEnv {\n  /** The op table a logged kind is reverted through. */\n  registered: ReadonlyMap<string, RegisteredOp<unknown>>;\n  /** Run with the lock guard lifted: a revert restores a state that was legal. */\n  lifted<T>(fn: () => T): T;\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n  notify(): void;\n}\n\nexport interface AppliedLog {\n  /**\n   * Run `fn` as all-or-nothing: if it throws, every kit op it applied is\n   * reverted, newest first, and the selection goes back to where it was.\n   * The log is at kit-op grain rather than per external op, because one\n   * external op can issue several scene mutations (a container move cascading\n   * to its children) and fail halfway through its own.\n   *\n   * On success the ops join an enclosing log only when `ownsEntry` says no\n   * history entry holds them: reverting ops an entry still claims would leave\n   * undo replaying a change that is no longer there.\n   */\n  atomically<T>(fn: () => T, ownsEntry: () => boolean): T;\n  /** Note a kit op that was just applied, or with `reverted`, just reverted.\n   *  Does nothing outside `atomically`. */\n  logApplied(kind: string, payload: unknown, reverted?: boolean): void;\n}\n\nexport function createAppliedLog(env: AppliedLogEnv): AppliedLog {\n  let applied: { kind: string; payload: unknown; reverted?: boolean }[] | null = null;\n\n  return {\n    atomically(fn, ownsEntry) {\n      const outer = applied;\n      const log: NonNullable<typeof applied> = [];\n      const selectionBefore = env.getSelection();\n      applied = log;\n      try {\n        const result = fn();\n        if (outer && !ownsEntry()) outer.push(...log);\n        return result;\n      } catch (err) {\n        applied = null;\n        env.lifted(() => {\n          for (let i = log.length - 1; i >= 0; i--) {\n            const { kind, payload, reverted } = log[i];\n            const handler = env.registered.get(kind)!;\n            (reverted ? handler.apply : handler.revert)(payload);\n          }\n        });\n        env.setSelection(selectionBefore);\n        if (log.length > 0) env.notify();\n        throw err;\n      } finally {\n        applied = outer;\n      }\n    },\n    logApplied(kind, payload, reverted) {\n      applied?.push(reverted === undefined ? { kind, payload } : { kind, payload, reverted });\n    },\n  };\n}\n"],"mappings":";AAoCA,SAAgBA,EAAiB,GAAgC;CAC/D,IAAIC,IAA2E;CAE/E,OAAO;EACL,WAAW,GAAI,GAAW;GACxB,IAAMC,IAAQD,GACRE,IAAmC,CAAC,GACpCC,IAAkBC,EAAI,aAAa;GACzC,IAAUF;GACV,IAAI;IACF,IAAMG,IAASC,EAAG;IAElB,OADIL,KAAS,CAACM,EAAU,KAAGN,EAAM,KAAK,GAAGC,CAAG,GACrCG;GACT,SAASG,GAAK;IAWZ,MAVA,IAAU,MACVJ,EAAI,aAAa;KACf,KAAK,IAAIK,IAAIP,EAAI,SAAS,GAAGO,KAAK,GAAG,KAAK;MACxC,IAAM,EAAE,SAAM,YAAS,gBAAaP,EAAIO,IAClCC,IAAUN,EAAI,WAAW,IAAIO,CAAI;MACvC,CAACC,IAAWF,EAAQ,QAAQA,EAAQ,OAAA,CAAQG,CAAO;KACrD;IACF,CAAC,GACDT,EAAI,aAAaD,CAAe,GAC5BD,EAAI,SAAS,KAAGE,EAAI,OAAO,GACzBI;GACR,UAAU;IACR,IAAUP;GACZ;EACF;EACA,WAAW,GAAM,GAAS,GAAU;GAClC,GAAS,KAAKW,MAAa,KAAA,IAAY;IAAE;IAAM;GAAQ,IAAI;IAAE;IAAM;IAAS;GAAS,CAAC;EACxF;CACF;AACF"}
+{"version":3,"file":"appliedLog.js","names":[],"sources":["../../../src/core/scene/appliedLog.ts"],"sourcesContent":["/**\n * The scene's atomic-revert log: every kit op applied since the innermost\n * `atomically` opened, so an edit that is refused partway can take back what\n * it already did.\n */\nimport type { NodeId, RegisteredOp } from './types';\n\n/** What the log needs from the scene it reverts. */\nexport interface AppliedLogEnv {\n  /** The op table a logged kind is reverted through. */\n  registered: ReadonlyMap<string, RegisteredOp<unknown>>;\n  /** Run with the lock guard lifted: a revert restores a state that was legal. */\n  lifted<T>(fn: () => T): T;\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n  notify(): void;\n}\n\nexport interface AppliedLog {\n  /**\n   * Run `fn` as all-or-nothing: if it throws, every kit op it applied is\n   * reverted, newest first, and the selection goes back to where it was.\n   * The log is at kit-op grain rather than per external op, because one\n   * external op can issue several scene mutations (a container move cascading\n   * to its children) and fail halfway through its own.\n   *\n   * On success the ops join an enclosing log only when `ownsEntry` says no\n   * history entry holds them: reverting ops an entry still claims would leave\n   * undo replaying a change that is no longer there.\n   */\n  atomically<T>(fn: () => T, ownsEntry: () => boolean): T;\n  /** Note a kit op that was just applied, or with `reverted`, just reverted.\n   *  Does nothing outside `atomically`. */\n  logApplied(kind: string, payload: unknown, reverted?: boolean): void;\n}\n\nexport function createAppliedLog(env: AppliedLogEnv): AppliedLog {\n  let applied: { kind: string; payload: unknown; reverted?: boolean }[] | null = null;\n\n  return {\n    atomically(fn, ownsEntry) {\n      const outer = applied;\n      const log: NonNullable<typeof applied> = [];\n      const selectionBefore = env.getSelection();\n      applied = log;\n      try {\n        const result = fn();\n        if (outer && !ownsEntry()) outer.push(...log);\n        return result;\n      } catch (err) {\n        applied = null;\n        env.lifted(() => {\n          for (let i = log.length - 1; i >= 0; i--) {\n            const { kind, payload, reverted } = log[i];\n            const handler = env.registered.get(kind)!;\n            (reverted ? handler.apply : handler.revert)(payload);\n          }\n        });\n        env.setSelection(selectionBefore);\n        if (log.length > 0) env.notify();\n        throw err;\n      } finally {\n        applied = outer;\n      }\n    },\n    logApplied(kind, payload, reverted) {\n      applied?.push(reverted === undefined ? { kind, payload } : { kind, payload, reverted });\n    },\n  };\n}\n"],"mappings":";AAoCA,SAAgB,iBAAiB,KAAgC;CAC/D,IAAI,UAA2E;CAE/E,OAAO;EACL,WAAW,IAAI,WAAW;GACxB,MAAM,QAAQ;GACd,MAAM,MAAmC,CAAC;GAC1C,MAAM,kBAAkB,IAAI,aAAa;GACzC,UAAU;GACV,IAAI;IACF,MAAM,SAAS,GAAG;IAClB,IAAI,SAAS,CAAC,UAAU,GAAG,MAAM,KAAK,GAAG,GAAG;IAC5C,OAAO;GACT,SAAS,KAAK;IACZ,UAAU;IACV,IAAI,aAAa;KACf,KAAK,IAAI,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;MACxC,MAAM,EAAE,MAAM,SAAS,aAAa,IAAI;MACxC,MAAM,UAAU,IAAI,WAAW,IAAI,IAAI;MACvC,CAAC,WAAW,QAAQ,QAAQ,QAAQ,OAAA,CAAQ,OAAO;KACrD;IACF,CAAC;IACD,IAAI,aAAa,eAAe;IAChC,IAAI,IAAI,SAAS,GAAG,IAAI,OAAO;IAC/B,MAAM;GACR,UAAU;IACR,UAAU;GACZ;EACF;EACA,WAAW,MAAM,SAAS,UAAU;GAClC,SAAS,KAAK,aAAa,SAAY;IAAE;IAAM;GAAQ,IAAI;IAAE;IAAM;IAAS;GAAS,CAAC;EACxF;CACF;AACF"}

package/dist/core/scene/arrivalWindow.js

@@ -1,102 +1,147 @@
-import { SceneArrivalRefused as e } from "./arrivals.js";
-import { createArrangeOp as t } from "../ops/arrange.js";
-import { createEmitter as n } from "@weasel-js/registry";
+import { SceneArrivalRefused } from "./arrivals.js";
+import { createArrangeOp } from "../ops/arrange.js";
+import { createEmitter } 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);
+/**
+* The scene's arrival window: what a live edit did to containers, collected
+* while it runs and handed to a layout handler before it closes.
+*
+* The window is open while a live edit is collecting the nodes that joined a
+* container, the ones that left one, and every container whose children or
+* size it changed; whoever opened the window settles it before the edit
+* closes. Undo, redo and journal replays never open it: they restore an
+* arrangement that was already decided.
+*/
+/** Of the ids noted per container, those the landed edit bears out: still
+*  under it when `joined`, gone from it otherwise. A container that is itself
+*  gone is left out. */
+function heldMoves(nodes, noted, joined) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [parent, ids] of noted) {
+		const held = ids.filter((id) => nodes.get(id)?.parent === parent === joined);
+		if (held.length > 0 && nodes.has(parent)) out.set(parent, held);
 	}
-	return r;
+	return out;
 }
-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 createArrivalWindow(env) {
+	const { nodes } = env;
+	let installed = null;
+	let hasLayouts = false;
+	let arrivals = null;
+	let departures = /* @__PURE__ */ new Map();
+	let changed = /* @__PURE__ */ new Set();
+	/** What the last settle wrote, reported to `onReflow` once its edit lands. */
+	let reflowDue = null;
+	const reflowListeners = createEmitter();
+	const activeHandler = () => installed ?? (hasLayouts ? env.layoutPass : null);
+	function open(always = false) {
+		if (arrivals !== null || !always && activeHandler() === null) return false;
+		arrivals = /* @__PURE__ */ new Map();
+		departures = /* @__PURE__ */ new Map();
+		changed = /* @__PURE__ */ new Set();
+		reflowDue = null;
+		return true;
 	}
-	function h() {
-		let e = d;
-		d = null, e !== null && e.length !== 0 && f.emit(e);
+	function emitReflow() {
+		const moves = reflowDue;
+		reflowDue = null;
+		if (moves === null || moves.length === 0) return;
+		reflowListeners.emit(moves);
 	}
-	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
+	function settle() {
+		const pending = arrivals;
+		arrivals = null;
+		const handler = activeHandler();
+		if (pending === null || handler === null) return [];
+		const landed = heldMoves(nodes, pending, true);
+		const left = heldMoves(nodes, departures, false);
+		departures = /* @__PURE__ */ new Map();
+		const touched = new Set([...changed].filter((id) => nodes.get(id)?.kind === "container"));
+		if (landed.size === 0 && touched.size === 0) return [];
+		const poses = handler(landed, touched, left);
+		if (poses === null) throw new SceneArrivalRefused(landed);
+		const out = [];
+		for (const [id, to] of poses) {
+			const node = nodes.get(id);
+			if (node) out.push({
+				id,
+				from: node.pose,
+				to
 			});
 		}
-		return d = m, m;
+		reflowDue = out;
+		return out;
 	}
-	function _() {
-		c = null, d = null;
+	function abandon() {
+		arrivals = null;
+		reflowDue = null;
 	}
-	function v(e) {
-		return m(!0) ? {
-			ops: [...e, t({}, g, i.writePose)],
-			owned: !0
-		} : {
-			ops: e,
-			owned: !1
+	/** `ops` plus the op that settles their arrivals, when this call owns the
+	*  window; `ops` unchanged otherwise. Opened even on a scene with no layout
+	*  yet: an edit's op list is fixed before it runs, and any op in it may give
+	*  the scene its first. The arrange op that settles nothing elides itself. */
+	function withArrivalOps(ops) {
+		if (!open(true)) return {
+			ops,
+			owned: false
+		};
+		return {
+			ops: [...ops, createArrangeOp({}, settle, env.writePose)],
+			owned: true
 		};
 	}
 	return {
 		layoutDeclared: () => {
-			s = !0;
+			hasLayouts = true;
 		},
-		setHandler(e) {
-			return o = e, () => {
-				o === e && (o = null);
+		setHandler(handler) {
+			installed = handler;
+			return () => {
+				if (installed === handler) installed = 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);
+		onReflow: reflowListeners.subscribe,
+		noteArrival(id, parent, from) {
+			if (arrivals === null || parent === null || parent === from) return;
+			changed.add(parent);
+			const list = arrivals.get(parent);
+			if (list === void 0) arrivals.set(parent, [id]);
+			else if (!list.includes(id)) list.push(id);
 		},
-		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);
+		noteDeparture(id, from, to) {
+			if (arrivals === null || from === null || from === to) return;
+			changed.add(from);
+			if (arrivals.get(from)?.includes(id)) return;
+			const list = departures.get(from);
+			if (list === void 0) departures.set(from, [id]);
+			else if (!list.includes(id)) list.push(id);
 		},
-		noteChange(e) {
-			c !== null && e !== null && u.add(e);
+		noteChange(id) {
+			if (arrivals !== null && id !== null) changed.add(id);
 		},
-		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;
+		bareLayoutEdit: () => activeHandler() !== null && arrivals === null && env.recordsBareEdits(),
+		open,
+		settle,
+		emitReflow,
+		abandon,
+		runEdit(ops, run) {
+			const { ops: all, owned } = withArrivalOps(ops);
+			if (!owned) return run(all), true;
 			try {
-				return n(r), h(), !0;
-			} catch (t) {
-				if (!(t instanceof e)) throw t;
-				return !1;
+				run(all);
+				emitReflow();
+				return true;
+			} catch (err) {
+				if (!(err instanceof SceneArrivalRefused)) throw err;
+				return false;
 			} finally {
-				_();
+				abandon();
 			}
 		}
 	};
 }
-//#endregion
-export { i as createArrivalWindow };
 
+//#endregion
+export { createArrivalWindow };
 //# sourceMappingURL=arrivalWindow.js.map

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

@@ -1 +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":"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"}
+{"version":3,"file":"arrivalWindow.js","names":[],"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, it changed size, or a child was posed. */\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/arrivals.js

@@ -1,12 +1,23 @@
 //#region src/core/scene/arrivals.ts
-var e = class extends Error {
+/**
+* Thrown by a scene edit — `batch`, `untracked`, or a bare `add` / `move` —
+* whose arrivals the scene's arrival handler refused. The edit has already
+* been reverted when this reaches the caller. An op-driven edit
+* (`applyBatch`, `history.applyOps`, a journal's `applyBatch`) is reverted
+* the same way but does not throw: nothing lands, as with a drop onto a
+* container that takes none.
+*/
+var SceneArrivalRefused = class extends Error {
+	/** The nodes refused, by the container they were joining. */
 	arrivals;
-	constructor(e) {
-		let t = [...e.keys()].map((e) => `"${e}"`).join(", ");
-		super(`Scene: ${t} refused the nodes joining it`), this.name = "SceneArrivalRefused", this.arrivals = e;
+	constructor(arrivals) {
+		const where = [...arrivals.keys()].map((id) => `"${id}"`).join(", ");
+		super(`Scene: ${where} refused the nodes joining it`);
+		this.name = "SceneArrivalRefused";
+		this.arrivals = arrivals;
 	}
 };
-//#endregion
-export { e as SceneArrivalRefused };
 
+//#endregion
+export { SceneArrivalRefused };
 //# sourceMappingURL=arrivals.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"arrivals.js","names":["SceneArrivalRefused","where","arrivals","id"],"sources":["../../../src/core/scene/arrivals.ts"],"sourcesContent":["import type { NodeId } from './types';\n\n/**\n * Thrown by a scene edit — `batch`, `untracked`, or a bare `add` / `move` —\n * whose arrivals the scene's arrival handler refused. The edit has already\n * been reverted when this reaches the caller. An op-driven edit\n * (`applyBatch`, `history.applyOps`, a journal's `applyBatch`) is reverted\n * the same way but does not throw: nothing lands, as with a drop onto a\n * container that takes none.\n */\nexport class SceneArrivalRefused extends Error {\n  /** The nodes refused, by the container they were joining. */\n  readonly arrivals: ReadonlyMap<NodeId, readonly NodeId[]>;\n\n  constructor(arrivals: ReadonlyMap<NodeId, readonly NodeId[]>) {\n    const where = [...arrivals.keys()].map((id) => `\"${id}\"`).join(', ');\n    super(`Scene: ${where} refused the nodes joining it`);\n    this.name = 'SceneArrivalRefused';\n    this.arrivals = arrivals;\n  }\n}\n"],"mappings":";AAUA,IAAaA,IAAb,cAAyC,MAAM;CAE7C;CAEA,YAAY,GAAkD;EAC5D,IAAMC,IAAQ,CAAC,GAAGC,EAAS,KAAK,CAAC,CAAC,CAAC,KAAK,MAAO,IAAIC,EAAG,EAAE,CAAC,CAAC,KAAK,IAAI;EAGnE,AAFA,MAAM,UAAUF,EAAM,8BAA8B,GACpD,KAAK,OAAO,uBACZ,KAAK,WAAWC;CAClB;AACF"}
+{"version":3,"file":"arrivals.js","names":[],"sources":["../../../src/core/scene/arrivals.ts"],"sourcesContent":["import type { NodeId } from './types';\n\n/**\n * Thrown by a scene edit — `batch`, `untracked`, or a bare `add` / `move` —\n * whose arrivals the scene's arrival handler refused. The edit has already\n * been reverted when this reaches the caller. An op-driven edit\n * (`applyBatch`, `history.applyOps`, a journal's `applyBatch`) is reverted\n * the same way but does not throw: nothing lands, as with a drop onto a\n * container that takes none.\n */\nexport class SceneArrivalRefused extends Error {\n  /** The nodes refused, by the container they were joining. */\n  readonly arrivals: ReadonlyMap<NodeId, readonly NodeId[]>;\n\n  constructor(arrivals: ReadonlyMap<NodeId, readonly NodeId[]>) {\n    const where = [...arrivals.keys()].map((id) => `\"${id}\"`).join(', ');\n    super(`Scene: ${where} refused the nodes joining it`);\n    this.name = 'SceneArrivalRefused';\n    this.arrivals = arrivals;\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,IAAa,sBAAb,cAAyC,MAAM;;CAE7C;CAEA,YAAY,UAAkD;EAC5D,MAAM,QAAQ,CAAC,GAAG,SAAS,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC,KAAK,IAAI;EACnE,MAAM,UAAU,MAAM,8BAA8B;EACpD,KAAK,OAAO;EACZ,KAAK,WAAW;CAClB;AACF"}

package/dist/core/scene/boundOps.js

@@ -1,40 +1,59 @@
-import { dwarn as e } from "../../debug/flag.js";
+import { dwarn } from "../../debug/flag.js";
+
 //#region src/core/scene/boundOps.ts
-function t(e, n) {
+/** Rebind an external op to the adapter supplied at the `applyBatch` call
+*  site — the scene's engine was constructed without an adapter, so ops
+*  it stores and later replays must close over the right one. Forwards
+*  the apply return value (no-op detection) and preserves
+*  `coalesceKey`/`name`/`args`/`label` for coalescing and eviction. See
+*  `bindOpToHistoryAdapter` for RESTORED entries (lazy accessor). */
+function bindOpToAdapter(op, adapter) {
 	return {
-		name: e.name,
-		args: e.args,
-		label: e.label,
+		name: op.name,
+		args: op.args,
+		label: op.label,
 		get coalesceKey() {
-			return e.coalesceKey;
+			return op.coalesceKey;
 		},
-		elideNoop: e.elideNoop,
-		apply: () => e.apply(n),
-		invert: () => t(e.invert(), n)
+		elideNoop: op.elideNoop,
+		apply: () => op.apply(adapter),
+		invert: () => bindOpToAdapter(op.invert(), adapter)
 	};
 }
-function n(t, r) {
+/** Wrap a globally-rebuilt external op so apply resolves the history
+*  adapter lazily — wiring order vs restoreHistory doesn't matter. An
+*  unset accessor makes the op a debug-warned no-op, and an apply that
+*  throws (e.g. the wired adapter lacks a method the op calls) degrades
+*  the same way — never throws mid-undo, matching the placeholder
+*  degradation policy. (The engine pops entries before applying, so an
+*  uncaught throw would corrupt the stacks.) See `bindOpToAdapter` for
+*  the live `applyBatch` path (fixed call-site adapter). */
+function bindOpToHistoryAdapter(op, accessor) {
 	return {
-		name: t.name,
-		args: t.args,
-		label: t.label,
+		name: op.name,
+		args: op.args,
+		label: op.label,
 		get coalesceKey() {
-			return t.coalesceKey;
+			return op.coalesceKey;
 		},
-		elideNoop: t.elideNoop,
+		elideNoop: op.elideNoop,
 		apply: () => {
-			let n = r();
-			if (!n) return e("scene", `restored op "${t.name ?? "?"}" has no history adapter — skipping (setHistoryAdapter was not wired)`), "noop";
+			const get = accessor();
+			if (!get) {
+				dwarn("scene", `restored op "${op.name ?? "?"}" has no history adapter — skipping (setHistoryAdapter was not wired)`);
+				return "noop";
+			}
 			try {
-				return t.apply(n());
-			} catch (n) {
-				return e("scene", `restored op "${t.name ?? "?"}" failed against the history adapter — skipping: ${String(n)}`), "noop";
+				return op.apply(get());
+			} catch (err) {
+				dwarn("scene", `restored op "${op.name ?? "?"}" failed against the history adapter — skipping: ${String(err)}`);
+				return "noop";
 			}
 		},
-		invert: () => n(t.invert(), r)
+		invert: () => bindOpToHistoryAdapter(op.invert(), accessor)
 	};
 }
-//#endregion
-export { t as bindOpToAdapter, n as bindOpToHistoryAdapter };
 
+//#endregion
+export { bindOpToAdapter, bindOpToHistoryAdapter };
 //# sourceMappingURL=boundOps.js.map

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

@@ -1 +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"}
+{"version":3,"file":"boundOps.js","names":[],"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,SAAgB,gBAAgB,IAAQ,SAAsB;CAC5D,OAAO;EACL,MAAM,GAAG;EACT,MAAM,GAAG;EACT,OAAO,GAAG;EAEV,IAAI,cAAc;GAAE,OAAO,GAAG;EAAa;EAC3C,WAAW,GAAG;EACd,aAAa,GAAG,MAAM,OAAO;EAC7B,cAAc,gBAAgB,GAAG,OAAO,GAAG,OAAO;CACpD;AACF;;;;;;;;;AAUA,SAAgB,uBAAuB,IAAQ,UAA4C;CACzF,OAAO;EACL,MAAM,GAAG;EACT,MAAM,GAAG;EACT,OAAO,GAAG;EACV,IAAI,cAAc;GAAE,OAAO,GAAG;EAAa;EAC3C,WAAW,GAAG;EACd,aAAa;GACX,MAAM,MAAM,SAAS;GACrB,IAAI,CAAC,KAAK;IACR,MAAM,SAAS,gBAAgB,GAAG,QAAQ,IAAI,sEAAsE;IACpH,OAAO;GACT;GACA,IAAI;IACF,OAAO,GAAG,MAAM,IAAI,CAAC;GACvB,SAAS,KAAK;IACZ,MAAM,SAAS,gBAAgB,GAAG,QAAQ,IAAI,mDAAmD,OAAO,GAAG,GAAG;IAC9G,OAAO;GACT;EACF;EACA,cAAc,uBAAuB,GAAG,OAAO,GAAG,QAAQ;CAC5D;AACF"}

package/dist/core/scene/carryDescendants.js

@@ -0,0 +1,51 @@
+import { composeWorldPose, composesFrames, frameAtOrAbove, rebaseLocalPose } from "./composeFrame.js";
+import { scenePoseAdapter } from "./scenePoseAdapter.js";
+
+//#region src/core/scene/carryDescendants.ts
+/**
+* Bringing a node's descendants along when something writes the node's pose
+* and nothing writes theirs: a layout restacking a container, a drop landing
+* one, a page move. Under absolute poses a descendant stores its own world
+* pose, so it stays behind unless it is written too.
+*/
+/** A {@link CarrySource} over a scene's document poses. */
+function sceneCarrySource(scene) {
+	return {
+		childrenOf: (id) => scene.childrenOf(id),
+		poses: scenePoseAdapter(scene),
+		composition: scene.composition
+	};
+}
+/**
+* The stored poses that bring `root`'s descendants along with it: each one's
+* world pose put through `translate`, rebased into the frame it is stored in.
+* A descendant stored in the frame of `root` or of a node under it is left
+* out, since that frame carries it, and so is one `translate` answers null
+* for. A descendant `moving` names is moving on its own: it and everything
+* under it are left to whoever moves it.
+*/
+function carriedDescendants(source, root, translate, moving = () => false) {
+	const { poses, composition } = source;
+	const framed = composesFrames(composition);
+	const under = /* @__PURE__ */ new Set([root]);
+	const out = /* @__PURE__ */ new Map();
+	const walk = (at) => {
+		for (const id of source.childrenOf(at)) {
+			if (moving(id)) continue;
+			under.add(id);
+			const parent = poses.getParent(id);
+			const frame = framed ? frameAtOrAbove(poses, parent) : null;
+			if (frame === null || !under.has(frame)) {
+				const world = translate(composeWorldPose(poses, id, composition.compose), id);
+				if (world !== null) out.set(id, rebaseLocalPose(poses, world, parent, composition.compose, composition.decompose));
+			}
+			walk(id);
+		}
+	};
+	walk(root);
+	return out;
+}
+
+//#endregion
+export { carriedDescendants, sceneCarrySource };
+//# sourceMappingURL=carryDescendants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"carryDescendants.js","names":[],"sources":["../../../src/core/scene/carryDescendants.ts"],"sourcesContent":["/**\n * Bringing a node's descendants along when something writes the node's pose\n * and nothing writes theirs: a layout restacking a container, a drop landing\n * one, a page move. Under absolute poses a descendant stores its own world\n * pose, so it stays behind unless it is written too.\n */\nimport { composeWorldPose, composesFrames, frameAtOrAbove, rebaseLocalPose, type PoseAdapter, type PoseComposition } from './composeFrame';\nimport { scenePoseAdapter } from './scenePoseAdapter';\nimport type { NodeId, Scene } from './types';\n\n/** What carrying reads: the tree, every stored pose, and how poses compose. */\nexport interface CarrySource<TPose> {\n  childrenOf(id: NodeId): readonly NodeId[];\n  poses: PoseAdapter<TPose>;\n  composition: PoseComposition<TPose>;\n}\n\n/** A {@link CarrySource} over a scene's document poses. */\nexport function sceneCarrySource(scene: Scene<unknown, string, unknown>): CarrySource<unknown> {\n  return {\n    childrenOf: (id) => scene.childrenOf(id),\n    poses: scenePoseAdapter(scene),\n    composition: scene.composition,\n  };\n}\n\n/**\n * The stored poses that bring `root`'s descendants along with it: each one's\n * world pose put through `translate`, rebased into the frame it is stored in.\n * A descendant stored in the frame of `root` or of a node under it is left\n * out, since that frame carries it, and so is one `translate` answers null\n * for. A descendant `moving` names is moving on its own: it and everything\n * under it are left to whoever moves it.\n */\nexport function carriedDescendants<TPose>(\n  source: CarrySource<TPose>,\n  root: NodeId,\n  translate: (world: TPose, id: NodeId) => TPose | null,\n  moving: (id: NodeId) => boolean = () => false,\n): Map<NodeId, TPose> {\n  const { poses, composition } = source;\n  const framed = composesFrames(composition);\n  const under = new Set<NodeId>([root]);\n  const out = new Map<NodeId, TPose>();\n  const walk = (at: NodeId): void => {\n    for (const id of source.childrenOf(at)) {\n      if (moving(id)) continue;\n      under.add(id);\n      const parent = poses.getParent(id);\n      const frame = framed ? frameAtOrAbove(poses, parent) : null;\n      if (frame === null || !under.has(frame as NodeId)) {\n        const world = translate(composeWorldPose(poses, id, composition.compose), id);\n        if (world !== null) out.set(id, rebaseLocalPose(poses, world, parent, composition.compose, composition.decompose));\n      }\n      walk(id);\n    }\n  };\n  walk(root);\n  return out;\n}\n"],"mappings":";;;;;;;;;;;AAkBA,SAAgB,iBAAiB,OAA8D;CAC7F,OAAO;EACL,aAAa,OAAO,MAAM,WAAW,EAAE;EACvC,OAAO,iBAAiB,KAAK;EAC7B,aAAa,MAAM;CACrB;AACF;;;;;;;;;AAUA,SAAgB,mBACd,QACA,MACA,WACA,eAAwC,OACpB;CACpB,MAAM,EAAE,OAAO,gBAAgB;CAC/B,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,wBAAQ,IAAI,IAAY,CAAC,IAAI,CAAC;CACpC,MAAM,sBAAM,IAAI,IAAmB;CACnC,MAAM,QAAQ,OAAqB;EACjC,KAAK,MAAM,MAAM,OAAO,WAAW,EAAE,GAAG;GACtC,IAAI,OAAO,EAAE,GAAG;GAChB,MAAM,IAAI,EAAE;GACZ,MAAM,SAAS,MAAM,UAAU,EAAE;GACjC,MAAM,QAAQ,SAAS,eAAe,OAAO,MAAM,IAAI;GACvD,IAAI,UAAU,QAAQ,CAAC,MAAM,IAAI,KAAe,GAAG;IACjD,MAAM,QAAQ,UAAU,iBAAiB,OAAO,IAAI,YAAY,OAAO,GAAG,EAAE;IAC5E,IAAI,UAAU,MAAM,IAAI,IAAI,IAAI,gBAAgB,OAAO,OAAO,QAAQ,YAAY,SAAS,YAAY,SAAS,CAAC;GACnH;GACA,KAAK,EAAE;EACT;CACF;CACA,KAAK,IAAI;CACT,OAAO;AACT"}