@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/ops/createHistory.js

@@ -1,20 +1,29 @@
-import { dlog as e, dwarn as t } from "../../debug/flag.js";
-import { rebuildOp as n } from "./registry.js";
-import { createHistory as r } from "@weasel-js/history";
+import { dlog, dwarn } from "../../debug/flag.js";
+import { rebuildOp } from "./registry.js";
+import { createHistory } from "@weasel-js/history";
+
 //#region src/core/ops/createHistory.ts
-var i = {
-	log: (t) => e("history", t),
-	warn: (e) => t("history", e)
+/** Routes the engine's diagnostics into the kit's `history` debug namespace,
+*  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */
+var kitLogger = {
+	log: (message) => dlog("history", message),
+	warn: (message) => dwarn("history", message)
 };
-function a(e, t = {}) {
-	let a = t.rebuildOp;
-	return r(e, {
-		debug: i,
-		...t,
-		rebuildOp: (e, t) => a?.(e, t) ?? n(e, t)
+/**
+* Build an op-batched undo/redo `History`, defaulting restore-time op
+* hydration to core's global op-factory registry and its diagnostics to the
+* kit's debug namespace. A caller-supplied `rebuildOp` wins; return `null`
+* from it to fall through to the registry.
+*/
+function createHistory$1(adapter, options = {}) {
+	const custom = options.rebuildOp;
+	return createHistory(adapter, {
+		debug: kitLogger,
+		...options,
+		rebuildOp: (name, args) => custom?.(name, args) ?? rebuildOp(name, args)
 	});
 }
-//#endregion
-export { a as createHistory };
 
+//#endregion
+export { createHistory$1 as createHistory };
 //# sourceMappingURL=createHistory.js.map

package/dist/core/ops/createHistory.js.map

@@ -1 +1 @@
-{"version":3,"file":"createHistory.js","names":["createHistory","createHistoryEngine","kitLogger","dlog","message","dwarn","createHistory$1","custom","options","createHistory","adapter","name","args","rebuildOp"],"sources":["../../../src/core/ops/createHistory.ts"],"sourcesContent":["import {\n  createHistory as createHistoryEngine,\n  type History,\n  type CreateHistoryOptions,\n  type HistoryLogger,\n} from '@weasel-js/history';\nimport { rebuildOp } from './registry';\nimport { dlog, dwarn } from '../../debug/flag';\n\n/** Routes the engine's diagnostics into the kit's `history` debug namespace,\n *  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */\nconst kitLogger: HistoryLogger = {\n  log: (message) => dlog('history', message),\n  warn: (message) => dwarn('history', message),\n};\n\n/**\n * Build an op-batched undo/redo `History`, defaulting restore-time op\n * hydration to core's global op-factory registry and its diagnostics to the\n * kit's debug namespace. A caller-supplied `rebuildOp` wins; return `null`\n * from it to fall through to the registry.\n */\nexport function createHistory(adapter: unknown, options: CreateHistoryOptions = {}): History {\n  const custom = options.rebuildOp;\n  return createHistoryEngine(adapter, {\n    debug: kitLogger,\n    ...options,\n    rebuildOp: (name, args) => custom?.(name, args) ?? rebuildOp(name, args),\n  });\n}\n"],"mappings":";;;;AAWA,IAAME,IAA2B;CAC/B,MAAM,MAAYC,EAAK,WAAWC,CAAO;CACzC,OAAO,MAAYC,EAAM,WAAWD,CAAO;AAC7C;AAQA,SAAgBJ,EAAc,GAAkB,IAAgC,CAAC,GAAY;CAC3F,IAAMO,IAASC,EAAQ;CACvB,OAAOP,EAAoBS,GAAS;EAClC,OAAOR;EACP,GAAGM;EACH,YAAY,GAAM,MAASD,IAASI,GAAMC,CAAI,KAAKC,EAAUF,GAAMC,CAAI;CACzE,CAAC;AACH"}
+{"version":3,"file":"createHistory.js","names":["createHistory","createHistoryEngine"],"sources":["../../../src/core/ops/createHistory.ts"],"sourcesContent":["import {\n  createHistory as createHistoryEngine,\n  type History,\n  type CreateHistoryOptions,\n  type HistoryLogger,\n} from '@weasel-js/history';\nimport { rebuildOp } from './registry';\nimport { dlog, dwarn } from '../../debug/flag';\n\n/** Routes the engine's diagnostics into the kit's `history` debug namespace,\n *  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */\nconst kitLogger: HistoryLogger = {\n  log: (message) => dlog('history', message),\n  warn: (message) => dwarn('history', message),\n};\n\n/**\n * Build an op-batched undo/redo `History`, defaulting restore-time op\n * hydration to core's global op-factory registry and its diagnostics to the\n * kit's debug namespace. A caller-supplied `rebuildOp` wins; return `null`\n * from it to fall through to the registry.\n */\nexport function createHistory(adapter: unknown, options: CreateHistoryOptions = {}): History {\n  const custom = options.rebuildOp;\n  return createHistoryEngine(adapter, {\n    debug: kitLogger,\n    ...options,\n    rebuildOp: (name, args) => custom?.(name, args) ?? rebuildOp(name, args),\n  });\n}\n"],"mappings":";;;;;;;AAWA,IAAM,YAA2B;CAC/B,MAAM,YAAY,KAAK,WAAW,OAAO;CACzC,OAAO,YAAY,MAAM,WAAW,OAAO;AAC7C;;;;;;;AAQA,SAAgBA,gBAAc,SAAkB,UAAgC,CAAC,GAAY;CAC3F,MAAM,SAAS,QAAQ;CACvB,OAAOC,cAAoB,SAAS;EAClC,OAAO;EACP,GAAG;EACH,YAAY,MAAM,SAAS,SAAS,MAAM,IAAI,KAAK,UAAU,MAAM,IAAI;CACzE,CAAC;AACH"}

package/dist/core/ops/delete.js

@@ -1,73 +1,100 @@
-import { registerOpFactory as e } from "./registry.js";
-import { captureSlot as t, parentOf as n, slotFromIndex as r } from "./slot.js";
-import { createInsertOp as i } from "./create.js";
+import { registerOpFactory } from "./registry.js";
+import { captureSlot, parentOf, slotFromIndex } from "./slot.js";
+import { createInsertOp } from "./create.js";
+
 //#region src/core/ops/delete.ts
-function a(e, t, n) {
-	return e.getChildren(t).indexOf(n);
+/** `id`'s ordinal among `parentId`'s children, or `-1` when it is not one. */
+function indexIn(a, parentId, id) {
+	return a.getChildren(parentId).indexOf(id);
 }
-function o(e, t) {
-	let r = e.getRemovalClosure?.([t]), i = /* @__PURE__ */ new Map();
-	if (r) for (let t of r) {
-		let n = e.getNode(t);
-		n && i.set(t, n);
+/**
+* Snapshot everything removing `rootId` takes with it, `rootId` included.
+*
+* A cascade unlinks several disjoint subtrees, so the captured set is walked
+* as a forest: a node whose parent is not also going is a detach root, and
+* each one is emitted — ascending sibling index first, so every slot still
+* means what it meant — followed by its captured descendants preorder. The
+* closure's own order will not do: it can reach a dependent before the parent
+* it sits under, and re-inserting a child under a parent that is not back yet
+* puts it in the wrong place.
+*/
+function captureCascade(a, rootId) {
+	const closure = a.getRemovalClosure?.([rootId]);
+	const taken = /* @__PURE__ */ new Map();
+	if (closure) for (const id of closure) {
+		const node = a.getNode(id);
+		if (node) taken.set(id, node);
 	}
 	else {
-		let n = (t) => {
-			let r = e.getNode(t);
-			if (r) {
-				i.set(t, r);
-				for (let r of e.getChildren(t)) n(r);
-			}
+		const walk = (id) => {
+			const node = a.getNode(id);
+			if (!node) return;
+			taken.set(id, node);
+			for (const kid of a.getChildren(id)) walk(kid);
 		};
-		n(t);
+		walk(rootId);
 	}
-	let o = [...i.values()].filter((e) => {
-		let t = n(e);
-		return t === null || !i.has(t);
-	}).map((t) => ({
-		node: t,
-		index: a(e, n(t), t.id)
-	})).sort((e, t) => e.index - t.index), s = [], c = (t) => {
-		s.push(t);
-		let n = e.getChildren(t.node.id);
-		for (let e = 0; e < n.length; e++) {
-			let t = i.get(n[e]);
-			t && c({
-				node: t,
-				index: e
+	const detachRoots = [...taken.values()].filter((n) => {
+		const p = parentOf(n);
+		return p === null || !taken.has(p);
+	}).map((n) => ({
+		node: n,
+		index: indexIn(a, parentOf(n), n.id)
+	})).sort((l, r) => l.index - r.index);
+	const out = [];
+	const emitSubtree = (entry) => {
+		out.push(entry);
+		const kids = a.getChildren(entry.node.id);
+		for (let i = 0; i < kids.length; i++) {
+			const child = taken.get(kids[i]);
+			if (child) emitSubtree({
+				node: child,
+				index: i
 			});
 		}
 	};
-	for (let e of o) c(e);
-	return s;
+	for (const entry of detachRoots) emitSubtree(entry);
+	return out;
 }
-function s(e) {
-	let { node: a, label: s } = e, c = e.slot ?? r(e.index), l = {
-		node: a,
-		label: s,
-		slot: c,
-		cascaded: e.cascaded
-	}, u = e.cascaded ?? [];
+/** Op: remove `node` and everything the adapter cascades with it; inverts to a
+*  re-insert of the whole set at its captured slots. */
+function createDeleteOp(args) {
+	const { node, label } = args;
+	let slot = args.slot ?? slotFromIndex(args.index);
+	const argsForSerial = {
+		node,
+		label,
+		slot,
+		cascaded: args.cascaded
+	};
+	let captured = args.cascaded ?? [];
 	return {
 		name: "delete",
-		args: l,
-		label: s,
-		apply(e) {
-			let r = e, i = t(r, n(a), a.id);
-			i && (c = i, l.slot = i), u = o(r, a.id), l.cascaded = u, r.removeNode(a.id);
+		args: argsForSerial,
+		label,
+		apply(adapter) {
+			const a = adapter;
+			const observed = captureSlot(a, parentOf(node), node.id);
+			if (observed) {
+				slot = observed;
+				argsForSerial.slot = observed;
+			}
+			captured = captureCascade(a, node.id);
+			argsForSerial.cascaded = captured;
+			a.removeNode(node.id);
 		},
 		invert() {
-			return i({
-				node: a,
-				label: s,
-				slot: c,
-				...u.length > 0 ? { cascaded: u } : {}
+			return createInsertOp({
+				node,
+				label,
+				slot,
+				...captured.length > 0 ? { cascaded: captured } : {}
 			});
 		}
 	};
 }
-e("delete", (e) => s(e));
-//#endregion
-export { s as createDeleteOp };
+registerOpFactory("delete", (args) => createDeleteOp(args));
 
+//#endregion
+export { createDeleteOp };
 //# sourceMappingURL=delete.js.map

package/dist/core/ops/delete.js.map

@@ -1 +1 @@
-{"version":3,"file":"delete.js","names":["indexIn","a","parentId","id","captureCascade","closure","rootId","taken","node","walk","kid","detachRoots","p","parentOf","n","l","r","out","emitSubtree","entry","kids","i","child","createDeleteOp","args","slot","slotFromIndex","argsForSerial","captured","adapter","observed","captureSlot","createInsertOp","registerOpFactory"],"sources":["../../../src/core/ops/delete.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** With `getChildren`, the subtree reads that snapshot the cascade before\n   *  it runs. */\n  getNode(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. A store whose removal\n   *  cascades past the subtree — the kit's scene takes a deleted node's\n   *  dependents too — must answer here, or those nodes are absent from the\n   *  snapshot and undo does not bring them back. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\n/** A captured node plus its slot in its own parent's child list. */\nexport interface PlacedNode<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** Arguments to {@link createDeleteOp}: the node to remove, plus what undo needs to put it back. */\nexport interface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter, and that supersedes this. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: SiblingSlot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. Ordered so a node's parent precedes\n   *  it, which is the order they have to be re-inserted in. Captured on apply;\n   *  mirrored into the serialized args so a rebuilt op can invert without\n   *  having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when it is not one. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren(parentId).indexOf(id);\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * A cascade unlinks several disjoint subtrees, so the captured set is walked\n * as a forest: a node whose parent is not also going is a detach root, and\n * each one is emitted — ascending sibling index first, so every slot still\n * means what it meant — followed by its captured descendants preorder. The\n * closure's own order will not do: it can reach a dependent before the parent\n * it sits under, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): PlacedNode<TNode>[] {\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = a.getNode(id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = a.getNode(id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of a.getChildren(id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: PlacedNode<TNode>[] = [];\n  const emitSubtree = (entry: PlacedNode<TNode>): void => {\n    out.push(entry);\n    const kids = a.getChildren(entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: PlacedNode<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      captured = captureCascade(a, node.id);\n      argsForSerial.cascaded = captured;\n      a.removeNode(node.id);\n    },\n    invert() {\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      return createInsertOp<TNode>({\n        node, label, slot,\n        ...(captured.length > 0 ? { cascaded: captured } : {}),\n      });\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":";;;;AA0CA,SAASA,EAAQ,GAAkB,GAAyB,GAAoB;CAC9E,OAAOC,EAAE,YAAYC,CAAQ,CAAC,CAAC,QAAQC,CAAE;AAC3C;AAaA,SAASC,EACP,GACA,GACqB;CACrB,IAAMC,IAAUJ,EAAE,oBAAoB,CAACK,CAAM,CAAC,GACxCC,oBAAQ,IAAI,IAAmB;CACrC,IAAIF,GACF,KAAK,IAAMF,KAAME,GAAS;EACxB,IAAMG,IAAOP,EAAE,QAAQE,CAAE;EACzB,AAAIK,KAAMD,EAAM,IAAIJ,GAAIK,CAAI;CAC9B;MACK;EAEL,IAAMC,KAAQ,MAAqB;GACjC,IAAMD,IAAOP,EAAE,QAAQE,CAAE;GACzB,IAAKK,GACL;MAAM,IAAIL,GAAIK,CAAI;IAClB,KAAK,IAAME,KAAOT,EAAE,YAAYE,CAAE,GAAG,EAAKO,CAAG;GAD3B;EAEpB;EACA,EAAKJ,CAAM;CACb;CAEA,IAAMK,IAAc,CAAC,GAAGJ,EAAM,OAAO,CAAC,CAAC,CACpC,QAAQ,MAAM;EAAE,IAAMK,IAAIC,EAASC,CAAC;EAAG,OAAOF,MAAM,QAAQ,CAACL,EAAM,IAAIK,CAAC;CAAG,CAAC,CAAC,CAC7E,KAAK,OAAO;EAAE,MAAME;EAAG,OAAOd,EAAQC,GAAGY,EAASC,CAAC,GAAGA,EAAE,EAAE;CAAE,EAAE,CAAC,CAC/D,MAAM,GAAG,MAAMC,EAAE,QAAQC,EAAE,KAAK,GAE7BC,IAA2B,CAAC,GAC5BC,KAAe,MAAmC;EACtD,EAAI,KAAKC,CAAK;EACd,IAAMC,IAAOnB,EAAE,YAAYkB,EAAM,KAAK,EAAE;EACxC,KAAK,IAAIE,IAAI,GAAGA,IAAID,EAAK,QAAQ,KAAK;GACpC,IAAME,IAAQf,EAAM,IAAIa,EAAKC,EAAG;GAChC,AAAIC,KAAOJ,EAAY;IAAE,MAAMI;IAAO,OAAOD;GAAE,CAAC;EAClD;CACF;CACA,KAAK,IAAMF,KAASR,GAAa,EAAYQ,CAAK;CAClD,OAAOF;AACT;AAIA,SAAgBM,EAA6C,GAA6B;CACxF,IAAM,EAAE,SAAM,aAAUC,GACpBC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK,GACvDG,IAAmC;EAAE;EAAM;EAAO;EAAM,UAAUH,EAAK;CAAS,GAClFI,IAAgCJ,EAAK,YAAY,CAAC;CACtD,OAAO;EACL,MAAM;EACN,MAAMG;EACN;EACA,MAAM,GAAS;GACb,IAAM1B,IAAI4B,GACJC,IAAWC,EAAY9B,GAAGY,EAASL,CAAI,GAAGA,EAAK,EAAE;GAOvD,AANIsB,MACF,IAAOA,GACP,EAAc,OAAOA,IAEvB,IAAW1B,EAAeH,GAAGO,EAAK,EAAE,GACpC,EAAc,WAAWoB,GACzB3B,EAAE,WAAWO,EAAK,EAAE;EACtB;EACA,SAAS;GAGP,OAAOwB,EAAsB;IAC3B;IAAM;IAAO;IACb,GAAIJ,EAAS,SAAS,IAAI,EAAE,UAAUA,EAAS,IAAI,CAAC;GACtD,CAAC;EACH;CACF;AACF;AAEAK,EAA8C,WAAW,MAASV,EAAeC,CAAI,CAAC"}
+{"version":3,"file":"delete.js","names":[],"sources":["../../../src/core/ops/delete.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** With `getChildren`, the subtree reads that snapshot the cascade before\n   *  it runs. */\n  getNode(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. A store whose removal\n   *  cascades past the subtree — the kit's scene takes a deleted node's\n   *  dependents too — must answer here, or those nodes are absent from the\n   *  snapshot and undo does not bring them back. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\n/** A captured node plus its slot in its own parent's child list. */\nexport interface PlacedNode<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** Arguments to {@link createDeleteOp}: the node to remove, plus what undo needs to put it back. */\nexport interface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter, and that supersedes this. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: SiblingSlot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. Ordered so a node's parent precedes\n   *  it, which is the order they have to be re-inserted in. Captured on apply;\n   *  mirrored into the serialized args so a rebuilt op can invert without\n   *  having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when it is not one. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren(parentId).indexOf(id);\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * A cascade unlinks several disjoint subtrees, so the captured set is walked\n * as a forest: a node whose parent is not also going is a detach root, and\n * each one is emitted — ascending sibling index first, so every slot still\n * means what it meant — followed by its captured descendants preorder. The\n * closure's own order will not do: it can reach a dependent before the parent\n * it sits under, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): PlacedNode<TNode>[] {\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = a.getNode(id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = a.getNode(id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of a.getChildren(id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: PlacedNode<TNode>[] = [];\n  const emitSubtree = (entry: PlacedNode<TNode>): void => {\n    out.push(entry);\n    const kids = a.getChildren(entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: PlacedNode<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      captured = captureCascade(a, node.id);\n      argsForSerial.cascaded = captured;\n      a.removeNode(node.id);\n    },\n    invert() {\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      return createInsertOp<TNode>({\n        node, label, slot,\n        ...(captured.length > 0 ? { cascaded: captured } : {}),\n      });\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":";;;;;;AA0CA,SAAS,QAAQ,GAAkB,UAAyB,IAAoB;CAC9E,OAAO,EAAE,YAAY,QAAQ,CAAC,CAAC,QAAQ,EAAE;AAC3C;;;;;;;;;;;;AAaA,SAAS,eACP,GACA,QACqB;CACrB,MAAM,UAAU,EAAE,oBAAoB,CAAC,MAAM,CAAC;CAC9C,MAAM,wBAAQ,IAAI,IAAmB;CACrC,IAAI,SACF,KAAK,MAAM,MAAM,SAAS;EACxB,MAAM,OAAO,EAAE,QAAQ,EAAE;EACzB,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI;CAC9B;MACK;EAEL,MAAM,QAAQ,OAAqB;GACjC,MAAM,OAAO,EAAE,QAAQ,EAAE;GACzB,IAAI,CAAC,MAAM;GACX,MAAM,IAAI,IAAI,IAAI;GAClB,KAAK,MAAM,OAAO,EAAE,YAAY,EAAE,GAAG,KAAK,GAAG;EAC/C;EACA,KAAK,MAAM;CACb;CAEA,MAAM,cAAc,CAAC,GAAG,MAAM,OAAO,CAAC,CAAC,CACpC,QAAQ,MAAM;EAAE,MAAM,IAAI,SAAS,CAAC;EAAG,OAAO,MAAM,QAAQ,CAAC,MAAM,IAAI,CAAC;CAAG,CAAC,CAAC,CAC7E,KAAK,OAAO;EAAE,MAAM;EAAG,OAAO,QAAQ,GAAG,SAAS,CAAC,GAAG,EAAE,EAAE;CAAE,EAAE,CAAC,CAC/D,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;CAEnC,MAAM,MAA2B,CAAC;CAClC,MAAM,eAAe,UAAmC;EACtD,IAAI,KAAK,KAAK;EACd,MAAM,OAAO,EAAE,YAAY,MAAM,KAAK,EAAE;EACxC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,QAAQ,MAAM,IAAI,KAAK,EAAG;GAChC,IAAI,OAAO,YAAY;IAAE,MAAM;IAAO,OAAO;GAAE,CAAC;EAClD;CACF;CACA,KAAK,MAAM,SAAS,aAAa,YAAY,KAAK;CAClD,OAAO;AACT;;;AAIA,SAAgB,eAA6C,MAA6B;CACxF,MAAM,EAAE,MAAM,UAAU;CACxB,IAAI,OAAoB,KAAK,QAAQ,cAAc,KAAK,KAAK;CAC7D,MAAM,gBAAmC;EAAE;EAAM;EAAO;EAAM,UAAU,KAAK;CAAS;CACtF,IAAI,WAAgC,KAAK,YAAY,CAAC;CACtD,OAAO;EACL,MAAM;EACN,MAAM;EACN;EACA,MAAM,SAAS;GACb,MAAM,IAAI;GACV,MAAM,WAAW,YAAY,GAAG,SAAS,IAAI,GAAG,KAAK,EAAE;GACvD,IAAI,UAAU;IACZ,OAAO;IACP,cAAc,OAAO;GACvB;GACA,WAAW,eAAe,GAAG,KAAK,EAAE;GACpC,cAAc,WAAW;GACzB,EAAE,WAAW,KAAK,EAAE;EACtB;EACA,SAAS;GAGP,OAAO,eAAsB;IAC3B;IAAM;IAAO;IACb,GAAI,SAAS,SAAS,IAAI,EAAE,UAAU,SAAS,IAAI,CAAC;GACtD,CAAC;EACH;CACF;AACF;AAEA,kBAA8C,WAAW,SAAS,eAAe,IAAI,CAAC"}

package/dist/core/ops/nodeFlags.js

@@ -0,0 +1,44 @@
+import { registerOpFactory } from "./registry.js";
+
+//#region src/core/ops/nodeFlags.ts
+function flagOp(name, args) {
+	const { id, from, to, label, coalesceKey } = args;
+	return {
+		name,
+		args: {
+			id,
+			from,
+			to,
+			label,
+			coalesceKey
+		},
+		label,
+		coalesceKey,
+		apply(adapter) {
+			adapter[name](id, to);
+		},
+		invert() {
+			return flagOp(name, {
+				id,
+				from: to,
+				to: from,
+				label,
+				coalesceKey
+			});
+		}
+	};
+}
+/** Op: hide or show a node and its subtree (`SceneNode.hidden`), inverting back to `from`. */
+function createSetHiddenOp(args) {
+	return flagOp("setHidden", args);
+}
+/** Op: lock or unlock a node and its subtree (`SceneNode.locked`), inverting back to `from`. */
+function createSetLockedOp(args) {
+	return flagOp("setLocked", args);
+}
+registerOpFactory("setHidden", (args) => createSetHiddenOp(args));
+registerOpFactory("setLocked", (args) => createSetLockedOp(args));
+
+//#endregion
+export { createSetHiddenOp, createSetLockedOp };
+//# sourceMappingURL=nodeFlags.js.map

package/dist/core/ops/nodeFlags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeFlags.js","names":[],"sources":["../../../src/core/ops/nodeFlags.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface NodeFlagAdapter {\n  setHidden(id: string, hidden: boolean): void;\n  setLocked(id: string, locked: boolean): void;\n}\n\n/** Arguments to {@link createSetHiddenOp} and {@link createSetLockedOp}: set\n *  node `id`'s flag `from` → `to`. */\nexport interface NodeFlagArgs {\n  id: string;\n  from: boolean;\n  to: boolean;\n  label?: string;\n  coalesceKey?: string;\n}\n\nfunction flagOp(name: 'setHidden' | 'setLocked', args: NodeFlagArgs): Op {\n  const { id, from, to, label, coalesceKey } = args;\n  return {\n    name,\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      (adapter as NodeFlagAdapter)[name](id, to);\n    },\n    invert() {\n      return flagOp(name, { id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\n/** Op: hide or show a node and its subtree (`SceneNode.hidden`), inverting back to `from`. */\nexport function createSetHiddenOp(args: NodeFlagArgs): Op {\n  return flagOp('setHidden', args);\n}\n\n/** Op: lock or unlock a node and its subtree (`SceneNode.locked`), inverting back to `from`. */\nexport function createSetLockedOp(args: NodeFlagArgs): Op {\n  return flagOp('setLocked', args);\n}\n\nregisterOpFactory<NodeFlagArgs>('setHidden', (args) => createSetHiddenOp(args));\nregisterOpFactory<NodeFlagArgs>('setLocked', (args) => createSetLockedOp(args));\n"],"mappings":";;;AAkBA,SAAS,OAAO,MAAiC,MAAwB;CACvE,MAAM,EAAE,IAAI,MAAM,IAAI,OAAO,gBAAgB;CAC7C,OAAO;EACL;EACA,MAAM;GAAE;GAAI;GAAM;GAAI;GAAO;EAAY;EACzC;EACA;EACA,MAAM,SAAS;GACb,QAA6B,KAAK,CAAC,IAAI,EAAE;EAC3C;EACA,SAAS;GACP,OAAO,OAAO,MAAM;IAAE;IAAI,MAAM;IAAI,IAAI;IAAM;IAAO;GAAY,CAAC;EACpE;CACF;AACF;;AAGA,SAAgB,kBAAkB,MAAwB;CACxD,OAAO,OAAO,aAAa,IAAI;AACjC;;AAGA,SAAgB,kBAAkB,MAAwB;CACxD,OAAO,OAAO,aAAa,IAAI;AACjC;AAEA,kBAAgC,cAAc,SAAS,kBAAkB,IAAI,CAAC;AAC9E,kBAAgC,cAAc,SAAS,kBAAkB,IAAI,CAAC"}

package/dist/core/ops/registry.js

@@ -1,17 +1,32 @@
-import { createReflectable as e } from "@weasel-js/registry";
+import { createReflectable } from "@weasel-js/registry";
+
 //#region src/core/ops/registry.ts
-var t = e(), n = t.reflection;
-function r(e, n) {
-	t.set(e, n);
+var FACTORIES = createReflectable();
+/** Every registered op factory, keyed by op name, in registration order. */
+var opFactoryRegistry = FACTORIES.reflection;
+/** Register an op-factory builder under a stable name. The builder receives
+*  the serialized `args` and must return an `Op` equivalent to one freshly
+*  constructed at the original call site (`apply` and `invert` behave the
+*  same). Idempotent on the same `(name, build)` pair; a second registration
+*  with a different builder silently overwrites — kit modules import each
+*  factory exactly once at init, so this never races in practice. */
+function registerOpFactory(name, build) {
+	FACTORIES.set(name, build);
 }
-function i(e, n) {
-	let r = t.get(e);
-	return r ? r(n) : null;
+/** Rebuild an op from its serialized `(name, args)`. Returns `null` when
+*  `name` isn't registered — callers handle this (typically by substituting
+*  a no-op placeholder so stack ordering survives across kit version skew). */
+function rebuildOp(name, args) {
+	const f = FACTORIES.get(name);
+	return f ? f(args) : null;
 }
-function a() {
-	return t.entries().map((e) => e.key);
+/** Every op name currently registered, in registration order. The kit's
+*  built-ins self-register at module init, so importing the barrel is enough
+*  to see all of them; consumer factories appear once their module has run. */
+function registeredOpNames() {
+	return FACTORIES.entries().map((e) => e.key);
 }
-//#endregion
-export { n as opFactoryRegistry, i as rebuildOp, r as registerOpFactory, a as registeredOpNames };
 
+//#endregion
+export { opFactoryRegistry, rebuildOp, registerOpFactory, registeredOpNames };
 //# sourceMappingURL=registry.js.map

package/dist/core/ops/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","names":["FACTORIES","createReflectable","opFactoryRegistry","registerOpFactory","name","build","rebuildOp","f","args","registeredOpNames"],"sources":["../../../src/core/ops/registry.ts"],"sourcesContent":["// Op-factory registry — pairs a stable `name` (stamped onto each op by its\n// factory) with a `(args) => Op` rebuilder so a `{ name, args }` snapshot\n// can be reconstituted into a live `Op` whose `apply`/`invert` closures\n// behave identically to the original.\n//\n// The kit calls `registerOpFactory` at module-init time for every built-in\n// factory (see `./create.ts`, `./delete.ts`, `./transform.ts`, etc.).\n// Consumers wanting their custom ops to survive `History.serialize()` /\n// `History.restore()` register their factories at app bootstrap, before\n// `createHistory` is called.\n\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\nimport type { Op } from './types';\n\n/** Rebuilds an op from its serialized `args`. */\nexport type OpFactory = (args: unknown) => Op;\n\nconst FACTORIES = createReflectable<OpFactory>();\n\n/** Every registered op factory, keyed by op name, in registration order. */\nexport const opFactoryRegistry: Reflection<OpFactory> = FACTORIES.reflection;\n\n/** Register an op-factory builder under a stable name. The builder receives\n *  the serialized `args` and must return an `Op` equivalent to one freshly\n *  constructed at the original call site (`apply` and `invert` behave the\n *  same). Idempotent on the same `(name, build)` pair; a second registration\n *  with a different builder silently overwrites — kit modules import each\n *  factory exactly once at init, so this never races in practice. */\nexport function registerOpFactory<A>(name: string, build: (args: A) => Op): void {\n  FACTORIES.set(name, build as OpFactory);\n}\n\n/** Rebuild an op from its serialized `(name, args)`. Returns `null` when\n *  `name` isn't registered — callers handle this (typically by substituting\n *  a no-op placeholder so stack ordering survives across kit version skew). */\nexport function rebuildOp(name: string, args: unknown): Op | null {\n  const f = FACTORIES.get(name);\n  return f ? f(args) : null;\n}\n\n/** Test-only: drop all registrations. Not exported from the kit barrel — the\n *  built-in factories self-register at module init, so production code never\n *  needs to clear the table. Exposed for unit tests that want to assert the\n *  unknown-name fallback path. */\nexport function _clearOpFactoriesForTest(): void {\n  FACTORIES.clear();\n}\n\n/** Every op name currently registered, in registration order. The kit's\n *  built-ins self-register at module init, so importing the barrel is enough\n *  to see all of them; consumer factories appear once their module has run. */\nexport function registeredOpNames(): readonly string[] {\n  return FACTORIES.entries().map((e) => e.key);\n}\n"],"mappings":";;AAiBA,IAAMA,IAAYC,EAA6B,GAGlCC,IAA2CF,EAAU;AAQlE,SAAgBG,EAAqB,GAAc,GAA8B;CAC/E,EAAU,IAAIC,GAAMC,CAAkB;AACxC;AAKA,SAAgBC,EAAU,GAAc,GAA0B;CAChE,IAAMC,IAAIP,EAAU,IAAII,CAAI;CAC5B,OAAOG,IAAIA,EAAEC,CAAI,IAAI;AACvB;AAaA,SAAgBC,IAAuC;CACrD,OAAOT,EAAU,QAAQ,CAAC,CAAC,KAAK,MAAM,EAAE,GAAG;AAC7C"}
+{"version":3,"file":"registry.js","names":[],"sources":["../../../src/core/ops/registry.ts"],"sourcesContent":["// Op-factory registry — pairs a stable `name` (stamped onto each op by its\n// factory) with a `(args) => Op` rebuilder so a `{ name, args }` snapshot\n// can be reconstituted into a live `Op` whose `apply`/`invert` closures\n// behave identically to the original.\n//\n// The kit calls `registerOpFactory` at module-init time for every built-in\n// factory (see `./create.ts`, `./delete.ts`, `./transform.ts`, etc.).\n// Consumers wanting their custom ops to survive `History.serialize()` /\n// `History.restore()` register their factories at app bootstrap, before\n// `createHistory` is called.\n\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\nimport type { Op } from './types';\n\n/** Rebuilds an op from its serialized `args`. */\nexport type OpFactory = (args: unknown) => Op;\n\nconst FACTORIES = createReflectable<OpFactory>();\n\n/** Every registered op factory, keyed by op name, in registration order. */\nexport const opFactoryRegistry: Reflection<OpFactory> = FACTORIES.reflection;\n\n/** Register an op-factory builder under a stable name. The builder receives\n *  the serialized `args` and must return an `Op` equivalent to one freshly\n *  constructed at the original call site (`apply` and `invert` behave the\n *  same). Idempotent on the same `(name, build)` pair; a second registration\n *  with a different builder silently overwrites — kit modules import each\n *  factory exactly once at init, so this never races in practice. */\nexport function registerOpFactory<A>(name: string, build: (args: A) => Op): void {\n  FACTORIES.set(name, build as OpFactory);\n}\n\n/** Rebuild an op from its serialized `(name, args)`. Returns `null` when\n *  `name` isn't registered — callers handle this (typically by substituting\n *  a no-op placeholder so stack ordering survives across kit version skew). */\nexport function rebuildOp(name: string, args: unknown): Op | null {\n  const f = FACTORIES.get(name);\n  return f ? f(args) : null;\n}\n\n/** Test-only: drop all registrations. Not exported from the kit barrel — the\n *  built-in factories self-register at module init, so production code never\n *  needs to clear the table. Exposed for unit tests that want to assert the\n *  unknown-name fallback path. */\nexport function _clearOpFactoriesForTest(): void {\n  FACTORIES.clear();\n}\n\n/** Every op name currently registered, in registration order. The kit's\n *  built-ins self-register at module init, so importing the barrel is enough\n *  to see all of them; consumer factories appear once their module has run. */\nexport function registeredOpNames(): readonly string[] {\n  return FACTORIES.entries().map((e) => e.key);\n}\n"],"mappings":";;;AAiBA,IAAM,YAAY,kBAA6B;;AAG/C,IAAa,oBAA2C,UAAU;;;;;;;AAQlE,SAAgB,kBAAqB,MAAc,OAA8B;CAC/E,UAAU,IAAI,MAAM,KAAkB;AACxC;;;;AAKA,SAAgB,UAAU,MAAc,MAA0B;CAChE,MAAM,IAAI,UAAU,IAAI,IAAI;CAC5B,OAAO,IAAI,EAAE,IAAI,IAAI;AACvB;;;;AAaA,SAAgB,oBAAuC;CACrD,OAAO,UAAU,QAAQ,CAAC,CAAC,KAAK,MAAM,EAAE,GAAG;AAC7C"}

package/dist/core/ops/reorder/algorithms.js

@@ -1,55 +1,79 @@
 //#region src/core/ops/reorder/algorithms.ts
-function e(e, t) {
-	let n = new Set(t), r = [], i = [];
-	for (let t of e) n.has(t) ? i.push(t) : r.push(t);
+/**
+* Pure reorder primitives. All operate on a flat ordered id list (z-order:
+* index 0 = bottom, last = top) and return a new list. Stable: relative
+* order of moved ids is preserved.
+*/
+function partition(list, moving) {
+	const movingSet = new Set(moving);
+	const kept = [];
+	const movedInOrder = [];
+	for (const id of list) if (movingSet.has(id)) movedInOrder.push(id);
+	else kept.push(id);
 	return {
-		kept: r,
-		movedInOrder: i
+		kept,
+		movedInOrder
 	};
 }
-function t(e, t) {
-	let n = new Set(t), r = e.slice();
-	for (let e = r.length - 2; e >= 0; e--) if (n.has(r[e]) && !n.has(r[e + 1])) {
-		let t = r[e];
-		r[e] = r[e + 1], r[e + 1] = t;
+function bringForward(list, ids) {
+	const movingSet = new Set(ids);
+	const out = list.slice();
+	for (let i = out.length - 2; i >= 0; i--) if (movingSet.has(out[i]) && !movingSet.has(out[i + 1])) {
+		const tmp = out[i];
+		out[i] = out[i + 1];
+		out[i + 1] = tmp;
 	}
-	return r;
+	return out;
 }
-function n(e, t) {
-	let n = new Set(t), r = e.slice();
-	for (let e = 1; e < r.length; e++) if (n.has(r[e]) && !n.has(r[e - 1])) {
-		let t = r[e];
-		r[e] = r[e - 1], r[e - 1] = t;
+function sendBackward(list, ids) {
+	const movingSet = new Set(ids);
+	const out = list.slice();
+	for (let i = 1; i < out.length; i++) if (movingSet.has(out[i]) && !movingSet.has(out[i - 1])) {
+		const tmp = out[i];
+		out[i] = out[i - 1];
+		out[i - 1] = tmp;
 	}
-	return r;
+	return out;
 }
-function r(t, n) {
-	let { kept: r, movedInOrder: i } = e(t, n);
-	return [...r, ...i];
+function bringToFront(list, ids) {
+	const { kept, movedInOrder } = partition(list, ids);
+	return [...kept, ...movedInOrder];
 }
-function i(t, n) {
-	let { kept: r, movedInOrder: i } = e(t, n);
-	return [...i, ...r];
+function sendToBack(list, ids) {
+	const { kept, movedInOrder } = partition(list, ids);
+	return [...movedInOrder, ...kept];
 }
-function a(t, n, r) {
-	let { kept: i, movedInOrder: a } = e(t, n), o = Math.max(0, Math.min(i.length, r));
+function moveToIndex(list, ids, index) {
+	const { kept, movedInOrder } = partition(list, ids);
+	const clamped = Math.max(0, Math.min(kept.length, index));
 	return [
-		...i.slice(0, o),
-		...a,
-		...i.slice(o)
+		...kept.slice(0, clamped),
+		...movedInOrder,
+		...kept.slice(clamped)
 	];
 }
-function o(e, t) {
-	let n = new Set(t);
-	for (let t = 0; t < e.length - 1; t++) if (n.has(e[t]) && !n.has(e[t + 1])) return !0;
-	return !1;
+/**
+* True iff `bringForward(list, ids)` would change `list` — i.e. at least one
+* id in `ids` is present in `list` AND has a non-moving (non-`ids`) neighbor
+* above it. Mirrors the swap rule in `bringForward`: a moving id only swaps
+* up when its upper neighbor isn't also moving, so a contiguous block at the
+* top is correctly reported as "can't move forward".
+*
+* Use this to drive button-disabled state in toolbars / menus so the user
+* never fires a no-op reorder onto the undo stack.
+*/
+function canBringForward(list, ids) {
+	const movingSet = new Set(ids);
+	for (let i = 0; i < list.length - 1; i++) if (movingSet.has(list[i]) && !movingSet.has(list[i + 1])) return true;
+	return false;
 }
-function s(e, t) {
-	let n = new Set(t);
-	for (let t = 1; t < e.length; t++) if (n.has(e[t]) && !n.has(e[t - 1])) return !0;
-	return !1;
+/** Symmetric to `canBringForward` — see that docstring. */
+function canSendBackward(list, ids) {
+	const movingSet = new Set(ids);
+	for (let i = 1; i < list.length; i++) if (movingSet.has(list[i]) && !movingSet.has(list[i - 1])) return true;
+	return false;
 }
-//#endregion
-export { t as bringForward, r as bringToFront, o as canBringForward, s as canSendBackward, a as moveToIndex, n as sendBackward, i as sendToBack };
 
+//#endregion
+export { bringForward, bringToFront, canBringForward, canSendBackward, moveToIndex, sendBackward, sendToBack };
 //# sourceMappingURL=algorithms.js.map

package/dist/core/ops/reorder/algorithms.js.map

@@ -1 +1 @@
-{"version":3,"file":"algorithms.js","names":["partition","movingSet","moving","kept","movedInOrder","id","list","bringForward","ids","out","i","tmp","sendBackward","bringToFront","sendToBack","moveToIndex","clamped","index","canBringForward","canSendBackward"],"sources":["../../../../src/core/ops/reorder/algorithms.ts"],"sourcesContent":["/**\n * Pure reorder primitives. All operate on a flat ordered id list (z-order:\n * index 0 = bottom, last = top) and return a new list. Stable: relative\n * order of moved ids is preserved.\n */\n\nfunction partition(list: string[], moving: string[]): { kept: string[]; movedInOrder: string[] } {\n  const movingSet = new Set(moving);\n  const kept: string[] = [];\n  const movedInOrder: string[] = [];\n  for (const id of list) {\n    if (movingSet.has(id)) movedInOrder.push(id);\n    else kept.push(id);\n  }\n  return { kept, movedInOrder };\n}\n\nexport function bringForward(list: string[], ids: string[]): string[] {\n  const movingSet = new Set(ids);\n  const out = list.slice();\n  // Walk from top down; each moving id swaps up by one if its upper neighbor\n  // is not also moving (prevents block from running into itself).\n  for (let i = out.length - 2; i >= 0; i--) {\n    if (movingSet.has(out[i]) && !movingSet.has(out[i + 1])) {\n      const tmp = out[i];\n      out[i] = out[i + 1];\n      out[i + 1] = tmp;\n    }\n  }\n  return out;\n}\n\nexport function sendBackward(list: string[], ids: string[]): string[] {\n  const movingSet = new Set(ids);\n  const out = list.slice();\n  for (let i = 1; i < out.length; i++) {\n    if (movingSet.has(out[i]) && !movingSet.has(out[i - 1])) {\n      const tmp = out[i];\n      out[i] = out[i - 1];\n      out[i - 1] = tmp;\n    }\n  }\n  return out;\n}\n\nexport function bringToFront(list: string[], ids: string[]): string[] {\n  const { kept, movedInOrder } = partition(list, ids);\n  return [...kept, ...movedInOrder];\n}\n\nexport function sendToBack(list: string[], ids: string[]): string[] {\n  const { kept, movedInOrder } = partition(list, ids);\n  return [...movedInOrder, ...kept];\n}\n\nexport function moveToIndex(list: string[], ids: string[], index: number): string[] {\n  const { kept, movedInOrder } = partition(list, ids);\n  const clamped = Math.max(0, Math.min(kept.length, index));\n  return [...kept.slice(0, clamped), ...movedInOrder, ...kept.slice(clamped)];\n}\n\n/**\n * True iff `bringForward(list, ids)` would change `list` — i.e. at least one\n * id in `ids` is present in `list` AND has a non-moving (non-`ids`) neighbor\n * above it. Mirrors the swap rule in `bringForward`: a moving id only swaps\n * up when its upper neighbor isn't also moving, so a contiguous block at the\n * top is correctly reported as \"can't move forward\".\n *\n * Use this to drive button-disabled state in toolbars / menus so the user\n * never fires a no-op reorder onto the undo stack.\n */\nexport function canBringForward(list: string[], ids: string[]): boolean {\n  const movingSet = new Set(ids);\n  for (let i = 0; i < list.length - 1; i++) {\n    if (movingSet.has(list[i]) && !movingSet.has(list[i + 1])) return true;\n  }\n  return false;\n}\n\n/** Symmetric to `canBringForward` — see that docstring. */\nexport function canSendBackward(list: string[], ids: string[]): boolean {\n  const movingSet = new Set(ids);\n  for (let i = 1; i < list.length; i++) {\n    if (movingSet.has(list[i]) && !movingSet.has(list[i - 1])) return true;\n  }\n  return false;\n}\n"],"mappings":";AAMA,SAASA,EAAU,GAAgB,GAA8D;CAC/F,IAAMC,IAAY,IAAI,IAAIC,CAAM,GAC1BC,IAAiB,CAAC,GAClBC,IAAyB,CAAC;CAChC,KAAK,IAAMC,KAAMC,GACf,AAAIL,EAAU,IAAII,CAAE,IAAGD,EAAa,KAAKC,CAAE,IACtCF,EAAK,KAAKE,CAAE;CAEnB,OAAO;EAAE;EAAM;CAAa;AAC9B;AAEA,SAAgBE,EAAa,GAAgB,GAAyB;CACpE,IAAMN,IAAY,IAAI,IAAIO,CAAG,GACvBC,IAAMH,EAAK,MAAM;CAGvB,KAAK,IAAII,IAAID,EAAI,SAAS,GAAGC,KAAK,GAAG,KACnC,IAAIT,EAAU,IAAIQ,EAAIC,EAAE,KAAK,CAACT,EAAU,IAAIQ,EAAIC,IAAI,EAAE,GAAG;EACvD,IAAMC,IAAMF,EAAIC;EAEhB,AADA,EAAIA,KAAKD,EAAIC,IAAI,IACjB,EAAIA,IAAI,KAAKC;CACf;CAEF,OAAOF;AACT;AAEA,SAAgBG,EAAa,GAAgB,GAAyB;CACpE,IAAMX,IAAY,IAAI,IAAIO,CAAG,GACvBC,IAAMH,EAAK,MAAM;CACvB,KAAK,IAAII,IAAI,GAAGA,IAAID,EAAI,QAAQ,KAC9B,IAAIR,EAAU,IAAIQ,EAAIC,EAAE,KAAK,CAACT,EAAU,IAAIQ,EAAIC,IAAI,EAAE,GAAG;EACvD,IAAMC,IAAMF,EAAIC;EAEhB,AADA,EAAIA,KAAKD,EAAIC,IAAI,IACjB,EAAIA,IAAI,KAAKC;CACf;CAEF,OAAOF;AACT;AAEA,SAAgBI,EAAa,GAAgB,GAAyB;CACpE,IAAM,EAAE,SAAM,oBAAiBb,EAAUM,GAAME,CAAG;CAClD,OAAO,CAAC,GAAGL,GAAM,GAAGC,CAAY;AAClC;AAEA,SAAgBU,EAAW,GAAgB,GAAyB;CAClE,IAAM,EAAE,SAAM,oBAAiBd,EAAUM,GAAME,CAAG;CAClD,OAAO,CAAC,GAAGJ,GAAc,GAAGD,CAAI;AAClC;AAEA,SAAgBY,EAAY,GAAgB,GAAe,GAAyB;CAClF,IAAM,EAAE,SAAM,oBAAiBf,EAAUM,GAAME,CAAG,GAC5CQ,IAAU,KAAK,IAAI,GAAG,KAAK,IAAIb,EAAK,QAAQc,CAAK,CAAC;CACxD,OAAO;EAAC,GAAGd,EAAK,MAAM,GAAGa,CAAO;EAAG,GAAGZ;EAAc,GAAGD,EAAK,MAAMa,CAAO;CAAC;AAC5E;AAYA,SAAgBE,EAAgB,GAAgB,GAAwB;CACtE,IAAMjB,IAAY,IAAI,IAAIO,CAAG;CAC7B,KAAK,IAAIE,IAAI,GAAGA,IAAIJ,EAAK,SAAS,GAAG,KACnC,IAAIL,EAAU,IAAIK,EAAKI,EAAE,KAAK,CAACT,EAAU,IAAIK,EAAKI,IAAI,EAAE,GAAG,OAAO;CAEpE,OAAO;AACT;AAGA,SAAgBS,EAAgB,GAAgB,GAAwB;CACtE,IAAMlB,IAAY,IAAI,IAAIO,CAAG;CAC7B,KAAK,IAAIE,IAAI,GAAGA,IAAIJ,EAAK,QAAQ,KAC/B,IAAIL,EAAU,IAAIK,EAAKI,EAAE,KAAK,CAACT,EAAU,IAAIK,EAAKI,IAAI,EAAE,GAAG,OAAO;CAEpE,OAAO;AACT"}
+{"version":3,"file":"algorithms.js","names":[],"sources":["../../../../src/core/ops/reorder/algorithms.ts"],"sourcesContent":["/**\n * Pure reorder primitives. All operate on a flat ordered id list (z-order:\n * index 0 = bottom, last = top) and return a new list. Stable: relative\n * order of moved ids is preserved.\n */\n\nfunction partition(list: string[], moving: string[]): { kept: string[]; movedInOrder: string[] } {\n  const movingSet = new Set(moving);\n  const kept: string[] = [];\n  const movedInOrder: string[] = [];\n  for (const id of list) {\n    if (movingSet.has(id)) movedInOrder.push(id);\n    else kept.push(id);\n  }\n  return { kept, movedInOrder };\n}\n\nexport function bringForward(list: string[], ids: string[]): string[] {\n  const movingSet = new Set(ids);\n  const out = list.slice();\n  // Walk from top down; each moving id swaps up by one if its upper neighbor\n  // is not also moving (prevents block from running into itself).\n  for (let i = out.length - 2; i >= 0; i--) {\n    if (movingSet.has(out[i]) && !movingSet.has(out[i + 1])) {\n      const tmp = out[i];\n      out[i] = out[i + 1];\n      out[i + 1] = tmp;\n    }\n  }\n  return out;\n}\n\nexport function sendBackward(list: string[], ids: string[]): string[] {\n  const movingSet = new Set(ids);\n  const out = list.slice();\n  for (let i = 1; i < out.length; i++) {\n    if (movingSet.has(out[i]) && !movingSet.has(out[i - 1])) {\n      const tmp = out[i];\n      out[i] = out[i - 1];\n      out[i - 1] = tmp;\n    }\n  }\n  return out;\n}\n\nexport function bringToFront(list: string[], ids: string[]): string[] {\n  const { kept, movedInOrder } = partition(list, ids);\n  return [...kept, ...movedInOrder];\n}\n\nexport function sendToBack(list: string[], ids: string[]): string[] {\n  const { kept, movedInOrder } = partition(list, ids);\n  return [...movedInOrder, ...kept];\n}\n\nexport function moveToIndex(list: string[], ids: string[], index: number): string[] {\n  const { kept, movedInOrder } = partition(list, ids);\n  const clamped = Math.max(0, Math.min(kept.length, index));\n  return [...kept.slice(0, clamped), ...movedInOrder, ...kept.slice(clamped)];\n}\n\n/**\n * True iff `bringForward(list, ids)` would change `list` — i.e. at least one\n * id in `ids` is present in `list` AND has a non-moving (non-`ids`) neighbor\n * above it. Mirrors the swap rule in `bringForward`: a moving id only swaps\n * up when its upper neighbor isn't also moving, so a contiguous block at the\n * top is correctly reported as \"can't move forward\".\n *\n * Use this to drive button-disabled state in toolbars / menus so the user\n * never fires a no-op reorder onto the undo stack.\n */\nexport function canBringForward(list: string[], ids: string[]): boolean {\n  const movingSet = new Set(ids);\n  for (let i = 0; i < list.length - 1; i++) {\n    if (movingSet.has(list[i]) && !movingSet.has(list[i + 1])) return true;\n  }\n  return false;\n}\n\n/** Symmetric to `canBringForward` — see that docstring. */\nexport function canSendBackward(list: string[], ids: string[]): boolean {\n  const movingSet = new Set(ids);\n  for (let i = 1; i < list.length; i++) {\n    if (movingSet.has(list[i]) && !movingSet.has(list[i - 1])) return true;\n  }\n  return false;\n}\n"],"mappings":";;;;;;AAMA,SAAS,UAAU,MAAgB,QAA8D;CAC/F,MAAM,YAAY,IAAI,IAAI,MAAM;CAChC,MAAM,OAAiB,CAAC;CACxB,MAAM,eAAyB,CAAC;CAChC,KAAK,MAAM,MAAM,MACf,IAAI,UAAU,IAAI,EAAE,GAAG,aAAa,KAAK,EAAE;MACtC,KAAK,KAAK,EAAE;CAEnB,OAAO;EAAE;EAAM;CAAa;AAC9B;AAEA,SAAgB,aAAa,MAAgB,KAAyB;CACpE,MAAM,YAAY,IAAI,IAAI,GAAG;CAC7B,MAAM,MAAM,KAAK,MAAM;CAGvB,KAAK,IAAI,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KACnC,IAAI,UAAU,IAAI,IAAI,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI,IAAI,EAAE,GAAG;EACvD,MAAM,MAAM,IAAI;EAChB,IAAI,KAAK,IAAI,IAAI;EACjB,IAAI,IAAI,KAAK;CACf;CAEF,OAAO;AACT;AAEA,SAAgB,aAAa,MAAgB,KAAyB;CACpE,MAAM,YAAY,IAAI,IAAI,GAAG;CAC7B,MAAM,MAAM,KAAK,MAAM;CACvB,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAC9B,IAAI,UAAU,IAAI,IAAI,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI,IAAI,EAAE,GAAG;EACvD,MAAM,MAAM,IAAI;EAChB,IAAI,KAAK,IAAI,IAAI;EACjB,IAAI,IAAI,KAAK;CACf;CAEF,OAAO;AACT;AAEA,SAAgB,aAAa,MAAgB,KAAyB;CACpE,MAAM,EAAE,MAAM,iBAAiB,UAAU,MAAM,GAAG;CAClD,OAAO,CAAC,GAAG,MAAM,GAAG,YAAY;AAClC;AAEA,SAAgB,WAAW,MAAgB,KAAyB;CAClE,MAAM,EAAE,MAAM,iBAAiB,UAAU,MAAM,GAAG;CAClD,OAAO,CAAC,GAAG,cAAc,GAAG,IAAI;AAClC;AAEA,SAAgB,YAAY,MAAgB,KAAe,OAAyB;CAClF,MAAM,EAAE,MAAM,iBAAiB,UAAU,MAAM,GAAG;CAClD,MAAM,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,QAAQ,KAAK,CAAC;CACxD,OAAO;EAAC,GAAG,KAAK,MAAM,GAAG,OAAO;EAAG,GAAG;EAAc,GAAG,KAAK,MAAM,OAAO;CAAC;AAC5E;;;;;;;;;;;AAYA,SAAgB,gBAAgB,MAAgB,KAAwB;CACtE,MAAM,YAAY,IAAI,IAAI,GAAG;CAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,SAAS,GAAG,KACnC,IAAI,UAAU,IAAI,KAAK,EAAE,KAAK,CAAC,UAAU,IAAI,KAAK,IAAI,EAAE,GAAG,OAAO;CAEpE,OAAO;AACT;;AAGA,SAAgB,gBAAgB,MAAgB,KAAwB;CACtE,MAAM,YAAY,IAAI,IAAI,GAAG;CAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,IAAI,UAAU,IAAI,KAAK,EAAE,KAAK,CAAC,UAAU,IAAI,KAAK,IAAI,EAAE,GAAG,OAAO;CAEpE,OAAO;AACT"}