@weasel-js/core 1.6.1 → 1.7.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.js","names":["indexIn","a","parentId","id","captureCascade","getChildren","getNode","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","snapshot","cascaded","restoredSlot","reinsertRoot","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  /** Subtree reads, used to snapshot the cascade before it runs. Optional\n   *  — a flat adapter has neither, and a delete there is a single node. */\n  getNode?(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. Optional: a store whose\n   *  removal cascades along nothing but the subtree needs no such answer, and\n   *  `getChildren` is enough. A store that cascades further — the kit's scene\n   *  takes a deleted node's dependents too — must answer here, or the nodes it\n   *  cascades away are absent from the snapshot and undo brings back the named\n   *  node alone. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\ninterface InsertAdapter<TNode> {\n  insertNode(node: TNode, index?: number): void;\n  getNode?(id: string): TNode | undefined;\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 observation supersedes this. Kept\n   *  because it is the whole story for a flat adapter with no `getChildren`,\n   *  where nothing can be observed. */\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. An inverse that re-inserts `node`\n   *  alone brings a container back empty and leaves every dependent deleted.\n   *  Ordered so a node's parent precedes it, which is the order they have to\n   *  be re-inserted in. Captured on apply; mirrored into the serialized args so\n   *  a rebuilt op can invert without having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when unobservable. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren?.(parentId)?.indexOf(id) ?? -1;\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * Returns `null` when the adapter can't enumerate, which leaves any previously\n * captured snapshot in place rather than clobbering it with an empty one.\n *\n * The order is the whole point. A cascade unlinks several disjoint subtrees, so\n * the captured set is walked as a forest: a node whose parent is not also going\n * is a detach root, and each one is emitted — ascending sibling index first, so\n * every slot still means what it meant — followed by its captured descendants\n * preorder. The closure's own order will not do: it reaches a dependent before\n * the parent it sits under whenever that parent is in the closure as a\n * dependent too, 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>[] | null {\n  const { getChildren, getNode } = a;\n  if (!getChildren || !getNode) return null;\n\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 = getNode.call(a, 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 = getNode.call(a, id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of getChildren.call(a, 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 = getChildren.call(a, 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      const snapshot = captureCascade(a, node.id);\n      if (snapshot) {\n        captured = snapshot;\n        argsForSerial.cascaded = snapshot;\n      }\n      a.removeNode(node.id);\n    },\n    invert() {\n      const cascaded = captured;\n      const restoredSlot = slot;\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      const reinsertRoot = createInsertOp<TNode>({ node, label, slot: restoredSlot });\n      if (cascaded.length === 0) return reinsertRoot;\n      return {\n        label,\n        apply(adapter) {\n          const a = adapter as InsertAdapter<TNode>;\n          for (const entry of cascaded) {\n            // A flat adapter's removeNode doesn't cascade, so its children\n            // were never gone — re-inserting them would duplicate them.\n            if (a.getNode?.(entry.node.id)) continue;\n            if (entry.node.id === node.id) reinsertRoot.apply(adapter);\n            else a.insertNode(entry.node, entry.index);\n          }\n        },\n        invert: () =>\n          createDeleteOp<TNode>({ node, label, slot: restoredSlot, cascaded }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":"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"}

package/dist/core/ops/registry.js

@@ -0,0 +1,17 @@
+import { createReflectable as e } from "@weasel-js/registry";
+//#region src/core/ops/registry.ts
+var t = e(), n = t.reflection;
+function r(e, n) {
+	t.set(e, n);
+}
+function i(e, n) {
+	let r = t.get(e);
+	return r ? r(n) : null;
+}
+function a() {
+	return t.entries().map((e) => e.key);
+}
+//#endregion
+export { n as opFactoryRegistry, i as rebuildOp, r as registerOpFactory, a as registeredOpNames };
+
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,55 @@
+//#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);
+	return {
+		kept: r,
+		movedInOrder: i
+	};
+}
+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;
+	}
+	return r;
+}
+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;
+	}
+	return r;
+}
+function r(t, n) {
+	let { kept: r, movedInOrder: i } = e(t, n);
+	return [...r, ...i];
+}
+function i(t, n) {
+	let { kept: r, movedInOrder: i } = e(t, n);
+	return [...i, ...r];
+}
+function a(t, n, r) {
+	let { kept: i, movedInOrder: a } = e(t, n), o = Math.max(0, Math.min(i.length, r));
+	return [
+		...i.slice(0, o),
+		...a,
+		...i.slice(o)
+	];
+}
+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;
+}
+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;
+}
+//#endregion
+export { t as bringForward, r as bringToFront, o as canBringForward, s as canSendBackward, a as moveToIndex, n as sendBackward, i as sendToBack };
+
+//# sourceMappingURL=algorithms.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,140 @@
+import { registerOpFactory as e } from "../registry.js";
+import { bringForward as t, bringToFront as n, canBringForward as r, canSendBackward as i, moveToIndex as a, sendBackward as o, sendToBack as s } from "./algorithms.js";
+//#region src/core/ops/reorder/index.ts
+function c(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+function l(e) {
+	let { ids: t, direction: n, fn: r, label: i, prevOrders: a } = e, o = {
+		ids: t,
+		direction: n,
+		label: i,
+		prevOrders: a ? a.map((e) => ({
+			...e,
+			before: e.before.slice()
+		})) : void 0
+	}, s = a ? a.map((e) => ({
+		...e,
+		before: e.before.slice()
+	})) : null;
+	return {
+		name: "reorder",
+		args: o,
+		label: i,
+		apply(e) {
+			let n = e;
+			if (!n.getChildren || !n.setChildOrder) return !1;
+			let i = /* @__PURE__ */ new Map();
+			for (let e of t) {
+				let t = n.getParent ? n.getParent(e) : null, r = i.get(t) ?? [];
+				r.push(e), i.set(t, r);
+			}
+			let a = [], l = !1;
+			for (let [e, t] of i) {
+				let i = n.getChildren(e), o = r(i, t);
+				c(i, o) || (a.push({
+					parentId: e,
+					before: i.slice()
+				}), n.setChildOrder(e, o), l = !0);
+			}
+			return s = a, o.prevOrders = a.map((e) => ({
+				...e,
+				before: e.before.slice()
+			})), l;
+		},
+		invert() {
+			let e = s;
+			return {
+				label: i,
+				apply(t) {
+					if (!e) return;
+					let n = t;
+					if (n.setChildOrder) for (let t of e) n.setChildOrder(t.parentId, t.before.slice());
+				},
+				invert() {
+					return {
+						apply() {},
+						invert() {
+							return this;
+						}
+					};
+				}
+			};
+		}
+	};
+}
+var u = {
+	forward: {
+		fn: t,
+		defaultLabel: "Bring forward"
+	},
+	backward: {
+		fn: o,
+		defaultLabel: "Send backward"
+	},
+	front: {
+		fn: n,
+		defaultLabel: "Bring to front"
+	},
+	back: {
+		fn: s,
+		defaultLabel: "Send to back"
+	}
+};
+function d(e) {
+	let { ids: t, direction: n, label: r, prevOrders: i } = e, { fn: a, defaultLabel: o } = u[n];
+	return l({
+		ids: t,
+		direction: n,
+		fn: a,
+		label: r ?? o,
+		prevOrders: i
+	});
+}
+e("reorder", (e) => d(e));
+function f(e) {
+	let { ids: t, parentId: n, index: r, label: i } = e, o = {
+		ids: t,
+		parentId: n,
+		index: r,
+		label: i,
+		prevPositions: e.prevPositions ? e.prevPositions.slice() : void 0
+	}, s = e.prevPositions ? e.prevPositions.slice() : null;
+	return {
+		name: "moveToIndex",
+		args: o,
+		label: i ?? "Move to index",
+		apply(e) {
+			let i = e;
+			if (!i.getChildren || !i.setChildOrder) return;
+			let c = t.filter((e) => (i.getParent ? i.getParent(e) : null) === n), l = i.getChildren(n);
+			s === null && (s = l.slice(), o.prevPositions = s.slice());
+			let u = a(l, c, r);
+			i.setChildOrder(n, u);
+		},
+		invert() {
+			let e = s;
+			return {
+				label: i,
+				apply(t) {
+					e && t.setChildOrder?.(n, e.slice());
+				},
+				invert() {
+					return {
+						apply() {},
+						invert() {
+							return this;
+						}
+					};
+				}
+			};
+		}
+	};
+}
+e("moveToIndex", (e) => f(e));
+//#endregion
+export { r as canBringForward, i as canSendBackward, f as createMoveToIndexOp, d as createReorderOp };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["arraysEqual","a","b","i","createPartitionedReorderOp","args","argsForSerial","prevOrders","restore","adapter","byParent","id","ids","parent","list","snapshots","mutated","parentId","parentIds","before","after","fn","captured","entry","REORDER_DIRECTIONS","bringForward","sendBackward","bringToFront","sendToBack","createReorderOp","direction","label","defaultLabel","registerOpFactory","createMoveToIndexOp","eligible","current","moveToIndex","index","canBringForward","canSendBackward"],"sources":["../../../../src/core/ops/reorder/index.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\nimport {\n  bringForward,\n  sendBackward,\n  bringToFront,\n  sendToBack,\n  moveToIndex,\n} from './algorithms';\n\nexport { canBringForward, canSendBackward } from './algorithms';\n\ninterface ReorderAdapter {\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): string[];\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n}\n\ntype ReorderFn = (list: string[], ids: string[]) => string[];\n\nfunction arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n\n/** One parent's child order before a reorder, kept so undo can restore it. */\nexport interface ReorderRestoreEntry {\n  parentId: string | null;\n  before: string[];\n}\n\n/** Arguments to {@link createReorderOp}: move `ids` in paint order, one step or to the front/back. */\nexport interface ReorderArgs {\n  ids: string[];\n  direction: ReorderDirection;\n  label?: string;\n  /** Pre-mutation child order per touched parent. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ReorderRestoreEntry[];\n}\n\n/**\n * Build an op that, on apply, partitions `ids` by their current parent,\n * runs `fn(currentChildren, idsForParent)` per parent, and writes the\n * result back via setChildOrder. Records before-state per parent so invert\n * is exact.\n *\n * `prevOrders` is that before-state, mirrored into the op's serialized args\n * on first apply. A deserialized op has never run its own `apply`, so its\n * invert has nothing to capture — reading it back from the args is what lets\n * a reorder survive a reload, the same trick `createMoveToIndexOp` uses.\n */\nfunction createPartitionedReorderOp(args: {\n  ids: string[];\n  direction: ReorderDirection;\n  fn: ReorderFn;\n  label?: string;\n  prevOrders?: ReorderRestoreEntry[];\n}): Op {\n  const { ids, direction, fn, label, prevOrders } = args;\n  const argsForSerial: ReorderArgs = {\n    ids,\n    direction,\n    label,\n    prevOrders: prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : undefined,\n  };\n  let restore: ReorderRestoreEntry[] | null =\n    prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : null;\n\n  return {\n    name: 'reorder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      if (!a.getChildren || !a.setChildOrder) return false; // graceful no-op\n      // Partition ids by current parent.\n      const byParent = new Map<string | null, string[]>();\n      for (const id of ids) {\n        const parent = a.getParent ? a.getParent(id) : null;\n        const list = byParent.get(parent) ?? [];\n        list.push(id);\n        byParent.set(parent, list);\n      }\n      const snapshots: ReorderRestoreEntry[] = [];\n      let mutated = false;\n      for (const [parentId, parentIds] of byParent) {\n        const before = a.getChildren(parentId);\n        const after = fn(before, parentIds);\n        if (arraysEqual(before, after)) continue; // already at the desired order\n        snapshots.push({ parentId, before: before.slice() });\n        a.setChildOrder(parentId, after);\n        mutated = true;\n      }\n      restore = snapshots;\n      argsForSerial.prevOrders = snapshots.map((e) => ({ ...e, before: e.before.slice() }));\n      return mutated;\n    },\n    invert() {\n      const captured = restore;\n      return {\n        label,\n        apply(adapter) {\n          if (!captured) return;\n          const a = adapter as ReorderAdapter;\n          if (!a.setChildOrder) return;\n          for (const entry of captured) {\n            a.setChildOrder(entry.parentId, entry.before.slice());\n          }\n        },\n        invert() {\n          // Inverting twice should reapply the original; we don't support\n          // this round-trip beyond two levels — the kit's history layer\n          // doesn't need it. Return a no-op for safety.\n          return { apply() {}, invert() { return this; } };\n        },\n      };\n    },\n  };\n}\n\n/** Direction of a sibling z-order reorder. */\nexport type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';\n\nconst REORDER_DIRECTIONS: Record<ReorderDirection, { fn: ReorderFn; defaultLabel: string }> = {\n  forward:  { fn: bringForward,  defaultLabel: 'Bring forward' },\n  backward: { fn: sendBackward,  defaultLabel: 'Send backward' },\n  front:    { fn: bringToFront,  defaultLabel: 'Bring to front' },\n  back:     { fn: sendToBack,    defaultLabel: 'Send to back' },\n};\n\n/**\n * Op: shift each id within its parent's child order per `direction`:\n *   - `'forward'`  — bump one step toward the top\n *   - `'backward'` — bump one step toward the bottom\n *   - `'front'`    — move to the top, preserving relative order\n *   - `'back'`     — move to the bottom, preserving relative order\n */\nexport function createReorderOp(args: ReorderArgs): Op {\n  const { ids, direction, label, prevOrders } = args;\n  const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];\n  return createPartitionedReorderOp({\n    ids, direction, fn, label: label ?? defaultLabel, prevOrders,\n  });\n}\n\nregisterOpFactory<ReorderArgs>('reorder', (args) => createReorderOp(args));\n\n/** Arguments to {@link createMoveToIndexOp}: move `ids` to `index` under `parentId`. */\nexport interface MoveToIndexArgs {\n  ids: string[];\n  parentId: string | null;\n  index: number;\n  label?: string;\n  /** Optional pre-mutation child order for the parent. When present, the op\n   *  uses it as the invert target instead of capturing at apply time — this\n   *  is how a deserialized op (whose original `apply` already ran in a prior\n   *  session) restores its invert behavior across an IDB round-trip. */\n  prevPositions?: string[];\n}\n\n/** Op: move all `ids` to a contiguous block starting at `index` within `parentId`'s child order. */\nexport function createMoveToIndexOp(args: MoveToIndexArgs): Op {\n  const { ids, parentId, index, label } = args;\n  // Outer args record we'll mutate so the captured `before` lands in the\n  // serialized form. `prevPositions` arrives populated when reconstructed\n  // from a snapshot; otherwise it's filled in on first apply.\n  const argsForSerial: MoveToIndexArgs = {\n    ids,\n    parentId,\n    index,\n    label,\n    prevPositions: args.prevPositions ? args.prevPositions.slice() : undefined,\n  };\n  let before: string[] | null = args.prevPositions ? args.prevPositions.slice() : null;\n\n  return {\n    name: 'moveToIndex',\n    args: argsForSerial,\n    label: label ?? 'Move to index',\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      if (!a.getChildren || !a.setChildOrder) return;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => {\n        const p = a.getParent ? a.getParent(id) : null;\n        return p === parentId;\n      });\n      const current = a.getChildren(parentId);\n      // Only overwrite `before` the first time we apply; redo (a second\n      // apply) must not clobber the originally-captured order, otherwise\n      // invert would replay the post-move state and undo nothing.\n      if (before === null) {\n        before = current.slice();\n        argsForSerial.prevPositions = before.slice();\n      }\n      const after = moveToIndex(current, eligible, index);\n      a.setChildOrder(parentId, after);\n    },\n    invert() {\n      const captured = before;\n      return {\n        label,\n        apply(adapter) {\n          if (!captured) return;\n          const a = adapter as ReorderAdapter;\n          a.setChildOrder?.(parentId, captured.slice());\n        },\n        invert() { return { apply() {}, invert() { return this; } }; },\n      };\n    },\n  };\n}\n\nregisterOpFactory<MoveToIndexArgs>('moveToIndex', (args) => createMoveToIndexOp(args));\n"],"mappings":"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"}

package/dist/core/ops/reparent.js

@@ -0,0 +1,52 @@
+import { registerOpFactory as e } from "./registry.js";
+import { captureSlot as t, resolveSlot as n, slotFromIndex as r } from "./slot.js";
+//#region src/core/ops/reparent.ts
+function i(e, t, r, i) {
+	if (!e.getChildren || !e.setChildOrder) return;
+	let a = e.getChildren(t), o = a.indexOf(r);
+	if (o < 0) return;
+	let s = a.slice();
+	s.splice(o, 1);
+	let c = n(s, i), l = c === void 0 ? s.length : Math.max(0, Math.min(c, s.length));
+	o !== l && (s.splice(l, 0, r), e.setChildOrder(t, s));
+}
+function a(e, t) {
+	return e || (t === void 0 ? void 0 : r(t));
+}
+function o(e) {
+	let { id: n, fromParentId: r, toParentId: s, label: c = "Reparent", coalesceKey: l = `reparent:${n}` } = e, u = a(e.fromSlot, e.fromIndex), d = a(e.toSlot, e.toIndex), f = {
+		id: n,
+		fromParentId: r,
+		toParentId: s,
+		fromSlot: u,
+		toSlot: d,
+		label: c,
+		coalesceKey: l
+	};
+	return {
+		name: "reparent",
+		args: f,
+		label: c,
+		coalesceKey: l,
+		apply(e) {
+			let a = e, o = t(a, r, n);
+			o && (u = o, f.fromSlot = o), a.setParent(n, s), d && i(a, s, n, d);
+		},
+		invert() {
+			return o({
+				id: n,
+				fromParentId: s,
+				toParentId: r,
+				fromSlot: d,
+				toSlot: u,
+				label: c,
+				coalesceKey: l
+			});
+		}
+	};
+}
+e("reparent", (e) => o(e));
+//#endregion
+export { o as createReparentOp };
+
+//# sourceMappingURL=reparent.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reparent.js","names":["placeAt","a","current","parentId","from","id","next","resolved","resolveSlot","slot","to","optionalSlot","index","slotFromIndex","createReparentOp","args","fromSlot","toSlot","argsForSerial","adapter","observed","captureSlot","fromParentId","toParentId","registerOpFactory"],"sources":["../../../src/core/ops/reparent.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface ReparentAdapter extends OrderedReader {\n  setParent(id: string, parentId: string | null): void;\n  /** Sibling-order write, paired with `getChildren`. Optional: an adapter\n   *  without both silently ignores slots and appends. */\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n}\n\n/** Arguments to {@link createReparentOp}: move node `id` from one parent to another. */\nexport interface ReparentArgs {\n  id: string;\n  fromParentId: string | null;\n  toParentId: string | null;\n  /** Sibling ordinal under the old parent. Sugar for `fromSlot: { index }`,\n   *  and only a seed: `apply` re-observes the node's full slot through the\n   *  adapter and that observation supersedes this. */\n  fromIndex?: number;\n  /** Sibling ordinal under the new parent. Sugar for `toSlot: { index }`.\n   *  Omit to append. */\n  toIndex?: number;\n  /** Slot under the old parent, anchor included. `invert()` forwards it as\n   *  the destination slot; without it undo re-parents with no position and\n   *  the node lands last, quietly changing paint order. */\n  fromSlot?: SiblingSlot;\n  /** Slot under the new parent, anchor included. Omit to append. */\n  toSlot?: SiblingSlot;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Move `id` to `slot` among `parentId`'s children. No-op when the adapter\n *  has no ordering seam, when `id` isn't there, or when it's already in\n *  place. */\nfunction placeAt(\n  a: ReparentAdapter,\n  parentId: string | null,\n  id: string,\n  slot: SiblingSlot,\n): void {\n  if (!a.getChildren || !a.setChildOrder) return;\n  const current = a.getChildren(parentId);\n  const from = current.indexOf(id);\n  if (from < 0) return;\n  const next = current.slice();\n  next.splice(from, 1);\n  const resolved = resolveSlot(next, slot);\n  const to = resolved === undefined ? next.length : Math.max(0, Math.min(resolved, next.length));\n  if (from === to) return;\n  next.splice(to, 0, id);\n  a.setChildOrder(parentId, next);\n}\n\n/** Present when the caller named a destination at all; `undefined` leaves\n *  placement to the adapter. */\nfunction optionalSlot(slot: SiblingSlot | undefined, index: number | undefined): SiblingSlot | undefined {\n  if (slot) return slot;\n  return index === undefined ? undefined : slotFromIndex(index);\n}\n\n/**\n * Op: change `id`'s parent and sibling slot, inverting back to the prior\n * parent and slot.\n *\n * `coalesceKey` defaults to `reparent:${id}` so successive reparents of the\n * same id batch-merge cleanly.\n */\nexport function createReparentOp(args: ReparentArgs): Op {\n  const {\n    id, fromParentId, toParentId,\n    label = 'Reparent', coalesceKey = `reparent:${id}`,\n  } = args;\n  let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);\n  const toSlot = optionalSlot(args.toSlot, args.toIndex);\n  const argsForSerial: ReparentArgs = {\n    id, fromParentId, toParentId, fromSlot, toSlot, label, coalesceKey,\n  };\n  return {\n    name: 'reparent',\n    args: argsForSerial,\n    label,\n    coalesceKey,\n    apply(adapter) {\n      const a = adapter as ReparentAdapter;\n      const observed = captureSlot(a, fromParentId, id);\n      if (observed) {\n        fromSlot = observed;\n        argsForSerial.fromSlot = observed;\n      }\n      a.setParent(id, toParentId);\n      if (toSlot) placeAt(a, toParentId, id, toSlot);\n    },\n    invert() {\n      return createReparentOp({\n        id,\n        fromParentId: toParentId,\n        toParentId: fromParentId,\n        fromSlot: toSlot,\n        toSlot: fromSlot,\n        label,\n        coalesceKey,\n      });\n    },\n  };\n}\n\nregisterOpFactory<ReparentArgs>('reparent', (args) => createReparentOp(args));\n"],"mappings":";;;AAoCA,SAASA,EACP,GACA,GACA,GACA,GACM;CACN,IAAI,CAACC,EAAE,eAAe,CAACA,EAAE,eAAe;CACxC,IAAMC,IAAUD,EAAE,YAAYE,CAAQ,GAChCC,IAAOF,EAAQ,QAAQG,CAAE;CAC/B,IAAID,IAAO,GAAG;CACd,IAAME,IAAOJ,EAAQ,MAAM;CAC3B,EAAK,OAAOE,GAAM,CAAC;CACnB,IAAMG,IAAWC,EAAYF,GAAMG,CAAI,GACjCC,IAAKH,MAAa,KAAA,IAAYD,EAAK,SAAS,KAAK,IAAI,GAAG,KAAK,IAAIC,GAAUD,EAAK,MAAM,CAAC;CAC7F,AAAIF,MAASM,MACbJ,EAAK,OAAOI,GAAI,GAAGL,CAAE,GACrBJ,EAAE,cAAcE,GAAUG,CAAI;AAChC;AAIA,SAASK,EAAa,GAA+B,GAAoD;CAEvG,OADIF,MACGG,MAAU,KAAA,IAAY,KAAA,IAAYC,EAAcD,CAAK;AAC9D;AASA,SAAgBE,EAAiB,GAAwB;CACvD,IAAM,EACJ,OAAI,iBAAc,eAClB,WAAQ,YAAY,iBAAc,YAAYT,QAC5CU,GACAC,IAAWL,EAAaI,EAAK,UAAUA,EAAK,SAAS,GACnDE,IAASN,EAAaI,EAAK,QAAQA,EAAK,OAAO,GAC/CG,IAA8B;EAClC;EAAI;EAAc;EAAY;EAAU;EAAQ;EAAO;CACzD;CACA,OAAO;EACL,MAAM;EACN,MAAMA;EACN;EACA;EACA,MAAM,GAAS;GACb,IAAM,IAAIC,GACJC,IAAWC,EAAY,GAAGC,GAAcjB,CAAE;GAMhD,AALIe,MACF,IAAWA,GACX,EAAc,WAAWA,IAE3B,EAAE,UAAUf,GAAIkB,CAAU,GACtBN,KAAQjB,EAAQ,GAAGuB,GAAYlB,GAAIY,CAAM;EAC/C;EACA,SAAS;GACP,OAAOH,EAAiB;IACtB;IACA,cAAcS;IACd,YAAYD;IACZ,UAAUL;IACV,QAAQD;IACR;IACA;GACF,CAAC;EACH;CACF;AACF;AAEAQ,EAAgC,aAAa,MAASV,EAAiBC,CAAI,CAAC"}

package/dist/core/ops/select.js

@@ -0,0 +1,34 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/select.ts
+function t(e) {
+	let { from: r, to: i, label: a } = e;
+	return {
+		name: "setSelection",
+		args: {
+			from: r,
+			to: i,
+			label: a
+		},
+		label: a,
+		apply(e) {
+			if (e.setSelection([...i]), n(r, i)) return !1;
+		},
+		invert() {
+			return t({
+				from: i,
+				to: r,
+				label: a
+			});
+		}
+	};
+}
+e("setSelection", (e) => t(e));
+function n(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+//#endregion
+export { t as createSetSelectionOp };
+
+//# sourceMappingURL=select.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"select.js","names":["createSetSelectionOp","args","adapter","to","sequenceEqual","from","registerOpFactory","a","b","i"],"sources":["../../../src/core/ops/select.ts"],"sourcesContent":["import type { NodeId } from '../scene/types';\nimport type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface SelectionAdapter {\n  setSelection(ids: NodeId[]): void;\n}\n\n/** Arguments to {@link createSetSelectionOp}: replace the selection `from` → `to`. */\nexport interface SetSelectionArgs {\n  from: readonly NodeId[];\n  to: readonly NodeId[];\n  label?: string;\n}\n\n/** Op: replace the current selection with `to`; inverts back to `from`. */\nexport function createSetSelectionOp(args: SetSelectionArgs): Op {\n  const { from, to, label } = args;\n  return {\n    name: 'setSelection',\n    args: { from, to, label },\n    label,\n    apply(adapter) {\n      // Always call setSelection so consumers that inspect op behavior\n      // (tests, overlays) see a consistent \"this op writes `to`\" signal.\n      // When from and to are sequence-equal, additionally report a no-op\n      // to history so the entry can be skipped from the undo stack.\n      // setSelection with the same value is idempotent.\n      (adapter as SelectionAdapter).setSelection([...to]);\n      if (sequenceEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createSetSelectionOp({ from: to, to: from, label });\n    },\n  };\n}\n\nregisterOpFactory<SetSelectionArgs>('setSelection', (args) => createSetSelectionOp(args));\n\nfunction sequenceEqual(a: readonly NodeId[], b: readonly NodeId[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";;AAgBA,SAAgBA,EAAqB,GAA4B;CAC/D,IAAM,EAAE,SAAM,OAAI,aAAUC;CAC5B,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAI;EAAM;EACxB;EACA,MAAM,GAAS;GAOb,IADAC,EAA8B,aAAa,CAAC,GAAGC,CAAE,CAAC,GAC9CC,EAAcC,GAAMF,CAAE,GAAG,OAAO;EAEtC;EACA,SAAS;GACP,OAAOH,EAAqB;IAAE,MAAMG;IAAI,IAAIE;IAAM;GAAM,CAAC;EAC3D;CACF;AACF;AAEAC,EAAoC,iBAAiB,MAASN,EAAqBC,CAAI,CAAC;AAExF,SAASG,EAAc,GAAsB,GAA+B;CAC1E,IAAIG,EAAE,WAAWC,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAIC,IAAI,GAAGA,IAAIF,EAAE,QAAQ,KAAK,IAAIA,EAAEE,OAAOD,EAAEC,IAAI,OAAO;CAC7D,OAAO;AACT"}

package/dist/core/ops/setData.js

@@ -0,0 +1,34 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/setData.ts
+function t(e) {
+	let { id: n, from: r, to: i, label: a, coalesceKey: o } = e;
+	return {
+		name: "setData",
+		args: {
+			id: n,
+			from: r,
+			to: i,
+			label: a,
+			coalesceKey: o
+		},
+		label: a,
+		coalesceKey: o,
+		apply(e) {
+			e.setData(n, i);
+		},
+		invert() {
+			return t({
+				id: n,
+				from: i,
+				to: r,
+				label: a,
+				coalesceKey: o
+			});
+		}
+	};
+}
+e("setData", (e) => t(e));
+//#endregion
+export { t as createSetDataOp };
+
+//# sourceMappingURL=setData.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setData.js","names":["createSetDataOp","args","id","to","from","registerOpFactory"],"sources":["../../../src/core/ops/setData.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface SetDataAdapter<TData> {\n  setData(id: string, data: TData): void;\n}\n\n/** Arguments to {@link createSetDataOp}: replace node `id`'s data `from` → `to`. */\nexport interface SetDataArgs<TData> {\n  id: string;\n  from: TData;\n  to: TData;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Op: set a node's app-defined `data` payload, inverting back to `from`. */\nexport function createSetDataOp<TData>(args: SetDataArgs<TData>): Op {\n  const { id, from, to, label, coalesceKey } = args;\n  return {\n    name: 'setData',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      (adapter as SetDataAdapter<TData>).setData(id, to);\n    },\n    invert() {\n      return createSetDataOp<TData>({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<SetDataArgs<unknown>>('setData', (args) => createSetDataOp(args));\n"],"mappings":";;AAiBA,SAAgBA,EAAuB,GAA8B;CACnE,IAAM,EAAE,OAAI,SAAM,OAAI,UAAO,mBAAgBC;CAC7C,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAI;GAAM;GAAI;GAAO;EAAY;EACzC;EACA;EACA,MAAM,GAAS;GACb,EAAmC,QAAQC,GAAIC,CAAE;EACnD;EACA,SAAS;GACP,OAAOH,EAAuB;IAAE;IAAI,MAAMG;IAAI,IAAIC;IAAM;IAAO;GAAY,CAAC;EAC9E;CACF;AACF;AAEAC,EAAwC,YAAY,MAASL,EAAgBC,CAAI,CAAC"}

package/dist/core/ops/setLayer.js

@@ -0,0 +1,34 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/setLayer.ts
+function t(e) {
+	let { id: n, from: r, to: i, label: a, coalesceKey: o = `setLayer:${n}` } = e;
+	return {
+		name: "setLayer",
+		args: {
+			id: n,
+			from: r,
+			to: i,
+			label: a,
+			coalesceKey: o
+		},
+		label: a,
+		coalesceKey: o,
+		apply(e) {
+			e.setLayer(n, i);
+		},
+		invert() {
+			return t({
+				id: n,
+				from: i,
+				to: r,
+				label: a,
+				coalesceKey: o
+			});
+		}
+	};
+}
+e("setLayer", (e) => t(e));
+//#endregion
+export { t as createSetLayerOp };
+
+//# sourceMappingURL=setLayer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setLayer.js","names":["createSetLayerOp","id","args","to","from","registerOpFactory"],"sources":["../../../src/core/ops/setLayer.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface SetLayerAdapter {\n  setLayer(id: string, layer: string): void;\n}\n\n/** Arguments to {@link createSetLayerOp}: move node `id` from layer `from` to layer `to`. */\nexport interface SetLayerArgs {\n  id: string;\n  from: string;\n  to: string;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Op: set a node's `layer` tag, inverting back to `from`. `coalesceKey`\n *  defaults to `setLayer:${id}` so successive layer changes to the same node\n *  merge into one undo entry within the history's coalesce window. Pass an\n *  explicit key to opt out. */\nexport function createSetLayerOp(args: SetLayerArgs): Op {\n  const { id, from, to, label, coalesceKey = `setLayer:${id}` } = args;\n  return {\n    name: 'setLayer',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      (adapter as SetLayerAdapter).setLayer(id, to);\n    },\n    invert() {\n      return createSetLayerOp({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<SetLayerArgs>('setLayer', (args) => createSetLayerOp(args));\n"],"mappings":";;AAoBA,SAAgBA,EAAiB,GAAwB;CACvD,IAAM,EAAE,OAAI,SAAM,OAAI,UAAO,iBAAc,YAAYC,QAASC;CAChE,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAI;GAAM;GAAI;GAAO;EAAY;EACzC;EACA;EACA,MAAM,GAAS;GACb,EAA6B,SAASD,GAAIE,CAAE;EAC9C;EACA,SAAS;GACP,OAAOH,EAAiB;IAAE;IAAI,MAAMG;IAAI,IAAIC;IAAM;IAAO;GAAY,CAAC;EACxE;CACF;AACF;AAEAC,EAAgC,aAAa,MAASL,EAAiBE,CAAI,CAAC"}

package/dist/core/ops/setLayout.js

@@ -0,0 +1,31 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/setLayout.ts
+function t(e) {
+	let { id: n, from: r, to: i, label: a } = e;
+	return {
+		name: "setLayout",
+		args: {
+			id: n,
+			from: r,
+			to: i,
+			label: a
+		},
+		label: a ?? "Set layout",
+		apply(e) {
+			e.setLayout(n, i);
+		},
+		invert() {
+			return t({
+				id: n,
+				from: i,
+				to: r,
+				label: a
+			});
+		}
+	};
+}
+e("setLayout", (e) => t(e));
+//#endregion
+export { t as createSetLayoutOp };
+
+//# sourceMappingURL=setLayout.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setLayout.js","names":["createSetLayoutOp","args","label","id","to","from","registerOpFactory"],"sources":["../../../src/core/ops/setLayout.ts"],"sourcesContent":["import type { Op } from './types';\nimport type { LayoutStrategy } from '../../layout/types';\nimport { registerOpFactory } from './registry';\n\n/** A container's layout as an op names it: the strategy itself, its key in\n *  the scene's `SceneRegistry.layout`, or `null` for none. */\nexport type LayoutRef<TPose = unknown> = LayoutStrategy<TPose> | string | null;\n\ninterface SetLayoutAdapter<TPose> {\n  setLayout(id: string, layout: LayoutRef<TPose>): void;\n}\n\n/** Arguments to {@link createSetLayoutOp}: swap container `id`'s layout\n *  `from` → `to`. */\nexport interface SetLayoutArgs<TPose = unknown> {\n  id: string;\n  from: LayoutRef<TPose>;\n  to: LayoutRef<TPose>;\n  label?: string;\n}\n\n/**\n * Op: give a container a different layout, inverting back to `from`. Applied\n * through a scene adapter (`adapter.setLayout`), the scene re-arranges the\n * container under the new layout in the same undo step.\n *\n * A strategy object cannot be serialized, so an op that has to survive a\n * persisted history names its layouts by registry key.\n */\nexport function createSetLayoutOp<TPose = unknown>(args: SetLayoutArgs<TPose>): Op {\n  const { id, from, to, label } = args;\n  return {\n    name: 'setLayout',\n    args: { id, from, to, label },\n    label: label ?? 'Set layout',\n    apply(adapter) {\n      (adapter as SetLayoutAdapter<TPose>).setLayout(id, to);\n    },\n    invert() {\n      return createSetLayoutOp<TPose>({ id, from: to, to: from, label });\n    },\n  };\n}\n\nregisterOpFactory<SetLayoutArgs>('setLayout', (args) => createSetLayoutOp(args));\n"],"mappings":";;AA6BA,SAAgBA,EAAmC,GAAgC;CACjF,IAAM,EAAE,OAAI,SAAM,OAAI,aAAUC;CAChC,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAI;GAAM;GAAI;EAAM;EAC5B,OAAOC,KAAS;EAChB,MAAM,GAAS;GACb,EAAqC,UAAUC,GAAIC,CAAE;EACvD;EACA,SAAS;GACP,OAAOJ,EAAyB;IAAE;IAAI,MAAMI;IAAI,IAAIC;IAAM;GAAM,CAAC;EACnE;CACF;AACF;AAEAC,EAAiC,cAAc,MAASN,EAAkBC,CAAI,CAAC"}

package/dist/core/ops/setPath.js

@@ -0,0 +1,57 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/setPath.ts
+function t(e) {
+	let { id: r, from: i, to: a, label: o, coalesceKey: s = `setPath:${r}` } = e;
+	return {
+		name: "setPath",
+		args: {
+			id: r,
+			from: i,
+			to: a,
+			label: o,
+			coalesceKey: s
+		},
+		label: o,
+		coalesceKey: s,
+		apply(e) {
+			if (e.setPath(r, a), n(i, a)) return !1;
+		},
+		invert() {
+			return t({
+				id: r,
+				from: a,
+				to: i,
+				label: o,
+				coalesceKey: s
+			});
+		}
+	};
+}
+e("setPath", (e) => t(e));
+function n(e, t) {
+	return e === t ? !0 : e.closed !== t.closed || !i(e.params, t.params) ? !1 : r(e.path, t.path);
+}
+function r(e, t) {
+	if (e === t) return !0;
+	if (typeof e != "object" || typeof t != "object" || e === null || t === null) return !1;
+	let n = e, r = t;
+	if (n.kind !== r.kind) return !1;
+	if (n.kind === "rect") return i(e, t);
+	let a = e, o = t;
+	if (a.commands.length !== o.commands.length || a.coords.length !== o.coords.length) return !1;
+	for (let e = 0; e < a.commands.length; e++) if (a.commands[e] !== o.commands[e]) return !1;
+	for (let e = 0; e < a.coords.length; e++) if (a.coords[e] !== o.coords[e]) return !1;
+	return !0;
+}
+function i(e, t) {
+	if (e === t) return !0;
+	if (e == null || t == null || typeof e != "object" || typeof t != "object") return !1;
+	let n = Object.keys(e), r = Object.keys(t);
+	if (n.length !== r.length) return !1;
+	for (let r of n) if (e[r] !== t[r]) return !1;
+	return !0;
+}
+//#endregion
+export { t as createSetPathOp };
+
+//# sourceMappingURL=setPath.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setPath.js","names":["createSetPathOp","id","args","adapter","to","fieldsEqual","from","registerOpFactory","a","b","shallowEqual","pathEqual","ao","bo","aa","bb","i","ka","kb","k"],"sources":["../../../src/core/ops/setPath.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\n/** The geometry fields a `setPath` op replaces together — the path itself,\n *  whether it is closed, and the parameters it was generated from. They move\n *  as one so a parametric shape and its baked path never disagree. */\nexport interface SetPathFields {\n  path: unknown;     // Path | RectPath; left unknown so kit doesn't depend on features/paths/types here\n  closed: boolean;\n  params: unknown;\n}\n\ninterface SetPathAdapter {\n  setPath(id: string, fields: SetPathFields): void;\n}\n\n/** Arguments to {@link createSetPathOp}: replace a path node's geometry fields `from` → `to`. */\nexport interface SetPathArgs {\n  id: string;\n  from: SetPathFields;\n  to: SetPathFields;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/**\n * Op: atomically replace a PathObj's geometric fields (path + closed + params).\n * Used for pen-edit anchor mutations and parametric-shape trapdoor conversions.\n * Reports no-op when `from` and `to` are structurally equal (same path bytes,\n * closed, params), letting history skip the entry.\n *\n * `coalesceKey` defaults to `setPath:${id}` so successive geometry writes to\n * the same node (dragging a bezier anchor) merge into one undo entry within the\n * history's coalesce window. Pass an explicit key to opt out.\n */\nexport function createSetPathOp(args: SetPathArgs): Op {\n  const { id, from, to, label, coalesceKey = `setPath:${id}` } = args;\n  return {\n    name: 'setPath',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      // Always call setPath so consumers that inspect op behavior see a\n      // consistent \"this op writes (id, to)\" signal. When from and to\n      // are field-equal, additionally report a no-op to history so the\n      // entry can be skipped from the undo stack. setPath with the same\n      // value is idempotent.\n      (adapter as SetPathAdapter).setPath(id, to);\n      if (fieldsEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createSetPathOp({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<SetPathArgs>('setPath', (args) => createSetPathOp(args));\n\nfunction fieldsEqual(a: SetPathFields, b: SetPathFields): boolean {\n  if (a === b) return true;\n  if (a.closed !== b.closed) return false;\n  if (!shallowEqual(a.params, b.params)) return false;\n  return pathEqual(a.path, b.path);\n}\n\nfunction pathEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;\n  const ao = a as { kind?: string };\n  const bo = b as { kind?: string };\n  if (ao.kind !== bo.kind) return false;\n  if (ao.kind === 'rect') return shallowEqual(a, b);\n  // polygon: compare commands + coords arrays\n  const aa = a as { commands: ArrayLike<number>; coords: ArrayLike<number> };\n  const bb = b as { commands: ArrayLike<number>; coords: ArrayLike<number> };\n  if (aa.commands.length !== bb.commands.length) return false;\n  if (aa.coords.length !== bb.coords.length) return false;\n  for (let i = 0; i < aa.commands.length; i++) if (aa.commands[i] !== bb.commands[i]) return false;\n  for (let i = 0; i < aa.coords.length; i++) if (aa.coords[i] !== bb.coords[i]) return false;\n  return true;\n}\n\nfunction shallowEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (a == null || b == null || typeof a !== 'object' || typeof b !== 'object') return false;\n  const ka = Object.keys(a as object);\n  const kb = Object.keys(b as object);\n  if (ka.length !== kb.length) return false;\n  for (const k of ka) {\n    if ((a as Record<string, unknown>)[k] !== (b as Record<string, unknown>)[k]) return false;\n  }\n  return true;\n}\n"],"mappings":";;AAmCA,SAAgBA,EAAgB,GAAuB;CACrD,IAAM,EAAE,OAAI,SAAM,OAAI,UAAO,iBAAc,WAAWC,QAASC;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAI;GAAM;GAAI;GAAO;EAAY;EACzC;EACA;EACA,MAAM,GAAS;GAOb,IADAC,EAA4B,QAAQF,GAAIG,CAAE,GACtCC,EAAYC,GAAMF,CAAE,GAAG,OAAO;EAEpC;EACA,SAAS;GACP,OAAOJ,EAAgB;IAAE;IAAI,MAAMI;IAAI,IAAIE;IAAM;IAAO;GAAY,CAAC;EACvE;CACF;AACF;AAEAC,EAA+B,YAAY,MAASP,EAAgBE,CAAI,CAAC;AAEzE,SAASG,EAAY,GAAkB,GAA2B;CAIhE,OAHIG,MAAMC,IAAU,KAChBD,EAAE,WAAWC,EAAE,UACf,CAACC,EAAaF,EAAE,QAAQC,EAAE,MAAM,IAAU,KACvCE,EAAUH,EAAE,MAAMC,EAAE,IAAI;AACjC;AAEA,SAASE,EAAU,GAAY,GAAqB;CAClD,IAAIH,MAAMC,GAAG,OAAO;CACpB,IAAI,OAAOD,KAAM,YAAY,OAAOC,KAAM,YAAYD,MAAM,QAAQC,MAAM,MAAM,OAAO;CACvF,IAAMG,IAAKJ,GACLK,IAAKJ;CACX,IAAIG,EAAG,SAASC,EAAG,MAAM,OAAO;CAChC,IAAID,EAAG,SAAS,QAAQ,OAAOF,EAAaF,GAAGC,CAAC;CAEhD,IAAMK,IAAKN,GACLO,IAAKN;CAEX,IADIK,EAAG,SAAS,WAAWC,EAAG,SAAS,UACnCD,EAAG,OAAO,WAAWC,EAAG,OAAO,QAAQ,OAAO;CAClD,KAAK,IAAIC,IAAI,GAAGA,IAAIF,EAAG,SAAS,QAAQ,KAAK,IAAIA,EAAG,SAASE,OAAOD,EAAG,SAASC,IAAI,OAAO;CAC3F,KAAK,IAAIA,IAAI,GAAGA,IAAIF,EAAG,OAAO,QAAQ,KAAK,IAAIA,EAAG,OAAOE,OAAOD,EAAG,OAAOC,IAAI,OAAO;CACrF,OAAO;AACT;AAEA,SAASN,EAAa,GAAY,GAAqB;CACrD,IAAIF,MAAMC,GAAG,OAAO;CACpB,IAAID,KAAK,QAAQC,KAAK,QAAQ,OAAOD,KAAM,YAAY,OAAOC,KAAM,UAAU,OAAO;CACrF,IAAMQ,IAAK,OAAO,KAAKT,CAAW,GAC5BU,IAAK,OAAO,KAAKT,CAAW;CAClC,IAAIQ,EAAG,WAAWC,EAAG,QAAQ,OAAO;CACpC,KAAK,IAAMC,KAAKF,GACd,IAAKT,EAA8BW,OAAQV,EAA8BU,IAAI,OAAO;CAEtF,OAAO;AACT"}

package/dist/core/ops/setText.js

@@ -0,0 +1,34 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/setText.ts
+function t(e) {
+	let { id: n, from: r, to: i, label: a, coalesceKey: o = `setText:${n}` } = e;
+	return {
+		name: "setText",
+		args: {
+			id: n,
+			from: r,
+			to: i,
+			label: a,
+			coalesceKey: o
+		},
+		label: a,
+		coalesceKey: o,
+		apply(e) {
+			e.setText(n, i);
+		},
+		invert() {
+			return t({
+				id: n,
+				from: i,
+				to: r,
+				label: a,
+				coalesceKey: o
+			});
+		}
+	};
+}
+e("setText", (e) => t(e));
+//#endregion
+export { t as createSetTextOp };
+
+//# sourceMappingURL=setText.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setText.js","names":["createSetTextOp","id","args","to","from","registerOpFactory"],"sources":["../../../src/core/ops/setText.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface SetTextAdapter {\n  setText(id: string, text: string): void;\n}\n\n/** Arguments to {@link createSetTextOp}: replace node `id`'s text `from` → `to`. */\nexport interface SetTextArgs {\n  id: string;\n  from: string;\n  to: string;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Op: set a text node's text content, inverting back to `from`. `coalesceKey`\n *  defaults to `setText:${id}` so successive edits to the same node (typing)\n *  merge into one undo entry within the history's coalesce window. Pass an\n *  explicit key to opt out. */\nexport function createSetTextOp(args: SetTextArgs): Op {\n  const { id, from, to, label, coalesceKey = `setText:${id}` } = args;\n  return {\n    name: 'setText',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      (adapter as SetTextAdapter).setText(id, to);\n    },\n    invert() {\n      return createSetTextOp({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<SetTextArgs>('setText', (args) => createSetTextOp(args));\n"],"mappings":";;AAoBA,SAAgBA,EAAgB,GAAuB;CACrD,IAAM,EAAE,OAAI,SAAM,OAAI,UAAO,iBAAc,WAAWC,QAASC;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAI;GAAM;GAAI;GAAO;EAAY;EACzC;EACA;EACA,MAAM,GAAS;GACb,EAA4B,QAAQD,GAAIE,CAAE;EAC5C;EACA,SAAS;GACP,OAAOH,EAAgB;IAAE;IAAI,MAAMG;IAAI,IAAIC;IAAM;IAAO;GAAY,CAAC;EACvE;CACF;AACF;AAEAC,EAA+B,YAAY,MAASL,EAAgBE,CAAI,CAAC"}