@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/layers/retain.js

@@ -0,0 +1,38 @@
+//#region src/core/layers/retain.ts
+/** Measured on 1280x800 at dpr 2: an unchanged layer composites cheaper than
+*  it submits from about 130 to 250 commands, depending on the layer count. */
+var DEFAULT_LAYER_RETAIN = { minCommands: 250 };
+var counts = /* @__PURE__ */ new WeakMap();
+/** Drawing commands in a tree, groups left out. Memoized by array, which a
+*  layer's cache serves unchanged while its deps hold. */
+function countDrawCommands(cmds) {
+	const known = counts.get(cmds);
+	if (known !== void 0) return known;
+	let n = 0;
+	for (const cmd of cmds) n += cmd.kind === "group" ? countDrawCommands(cmd.children) : 1;
+	counts.set(cmds, n);
+	return n;
+}
+function sameView(a, b) {
+	return a !== void 0 && a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;
+}
+/** The layer's id when the renderer should keep its pixels this frame. */
+function retainedId(layer, cache, view, policy) {
+	const entry = cache.get(layer.id);
+	if (!entry || !layer.deps) return void 0;
+	const viewHeld = (layer.space ?? "world") === "screen" || sameView(entry.view, view);
+	entry.view = {
+		x: view.x,
+		y: view.y,
+		scale: {
+			x: view.scale.x,
+			y: view.scale.y
+		}
+	};
+	if (layer.retain === false || !entry.reused || !viewHeld) return void 0;
+	return layer.retain === true || countDrawCommands(entry.cmds) >= policy.minCommands ? layer.id : void 0;
+}
+
+//#endregion
+export { DEFAULT_LAYER_RETAIN, countDrawCommands, retainedId };
+//# sourceMappingURL=retain.js.map

package/dist/core/layers/retain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retain.js","names":[],"sources":["../../../src/core/layers/retain.ts"],"sourcesContent":["import type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport type { LayerCommandCache, RenderLayer } from './render';\n\n/**\n * When `drawLayers` asks the renderer to keep a layer's pixels between frames\n * (`GroupDrawCommand.retain`) rather than submit its commands again.\n *\n * A layer is retained once its `deps` have held for a frame, the view has held\n * since the frame before (for a world-space layer, whose pixels move with\n * it), and it holds at least `minCommands` drawing commands. A layer changing\n * every frame is never retained: drawing it into its surface and compositing\n * that costs more than drawing it.\n */\nexport interface LayerRetainPolicy {\n  minCommands: number;\n}\n\n/** Measured on 1280x800 at dpr 2: an unchanged layer composites cheaper than\n *  it submits from about 130 to 250 commands, depending on the layer count. */\nexport const DEFAULT_LAYER_RETAIN: LayerRetainPolicy = { minCommands: 250 };\n\nconst counts = new WeakMap<readonly DrawCommand[], number>();\n\n/** Drawing commands in a tree, groups left out. Memoized by array, which a\n *  layer's cache serves unchanged while its deps hold. */\nexport function countDrawCommands(cmds: readonly DrawCommand[]): number {\n  const known = counts.get(cmds);\n  if (known !== undefined) return known;\n  let n = 0;\n  for (const cmd of cmds) n += cmd.kind === 'group' ? countDrawCommands(cmd.children) : 1;\n  counts.set(cmds, n);\n  return n;\n}\n\nfunction sameView(a: View | undefined, b: View): boolean {\n  return a !== undefined && a.x === b.x && a.y === b.y\n    && a.scale.x === b.scale.x && a.scale.y === b.scale.y;\n}\n\n/** The layer's id when the renderer should keep its pixels this frame. */\nexport function retainedId<TData>(\n  layer: RenderLayer<TData>,\n  cache: LayerCommandCache,\n  view: View,\n  policy: LayerRetainPolicy,\n): string | undefined {\n  const entry = cache.get(layer.id);\n  if (!entry || !layer.deps) return undefined;\n  const viewHeld = (layer.space ?? 'world') === 'screen' || sameView(entry.view, view);\n  entry.view = { x: view.x, y: view.y, scale: { x: view.scale.x, y: view.scale.y } };\n  if (layer.retain === false || !entry.reused || !viewHeld) return undefined;\n  return layer.retain === true || countDrawCommands(entry.cmds) >= policy.minCommands\n    ? layer.id\n    : undefined;\n}\n"],"mappings":";;;AAoBA,IAAa,uBAA0C,EAAE,aAAa,IAAI;AAE1E,IAAM,yBAAS,IAAI,QAAwC;;;AAI3D,SAAgB,kBAAkB,MAAsC;CACtE,MAAM,QAAQ,OAAO,IAAI,IAAI;CAC7B,IAAI,UAAU,QAAW,OAAO;CAChC,IAAI,IAAI;CACR,KAAK,MAAM,OAAO,MAAM,KAAK,IAAI,SAAS,UAAU,kBAAkB,IAAI,QAAQ,IAAI;CACtF,OAAO,IAAI,MAAM,CAAC;CAClB,OAAO;AACT;AAEA,SAAS,SAAS,GAAqB,GAAkB;CACvD,OAAO,MAAM,UAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAC9C,EAAE,MAAM,MAAM,EAAE,MAAM,KAAK,EAAE,MAAM,MAAM,EAAE,MAAM;AACxD;;AAGA,SAAgB,WACd,OACA,OACA,MACA,QACoB;CACpB,MAAM,QAAQ,MAAM,IAAI,MAAM,EAAE;CAChC,IAAI,CAAC,SAAS,CAAC,MAAM,MAAM,OAAO;CAClC,MAAM,YAAY,MAAM,SAAS,aAAa,YAAY,SAAS,MAAM,MAAM,IAAI;CACnF,MAAM,OAAO;EAAE,GAAG,KAAK;EAAG,GAAG,KAAK;EAAG,OAAO;GAAE,GAAG,KAAK,MAAM;GAAG,GAAG,KAAK,MAAM;EAAE;CAAE;CACjF,IAAI,MAAM,WAAW,SAAS,CAAC,MAAM,UAAU,CAAC,UAAU,OAAO;CACjE,OAAO,MAAM,WAAW,QAAQ,kBAAkB,MAAM,IAAI,KAAK,OAAO,cACpE,MAAM,KACN;AACN"}

package/dist/core/ops/arrange.js

@@ -1,32 +1,43 @@
-import { registerOpFactory as e } from "./registry.js";
+import { registerOpFactory } from "./registry.js";
+
 //#region src/core/ops/arrange.ts
-function t(e, n, r) {
-	let i = { ...e.placed ? { placed: e.placed } : {} };
+/**
+* Op: write a set of poses decided when the op first applies, not when it is
+* built. The scene appends one to an edit that moves nodes into a container,
+* and `compute` asks the container what to do with them after the rest of
+* the edit has landed. Every later apply — redo, or a rebuild from a
+* serialized history — replays the writes it recorded, so the arrangement is
+* decided once. `write` replaces the adapter's `setPose` for this op and its
+* inverses — the scene passes its own, since not every adapter an edit is
+* applied through can write poses.
+*/
+function createArrangeOp(args, compute, write) {
+	const self = { ...args.placed ? { placed: args.placed } : {} };
 	return {
 		name: "arrange",
-		args: i,
+		args: self,
 		label: "Arrange",
-		elideNoop: !0,
+		elideNoop: true,
 		get coalesceKey() {
-			return i.placed === void 0 ? void 0 : `arrange:${i.placed.map((e) => e.id).sort().join(",")}`;
+			return self.placed === void 0 ? void 0 : `arrange:${self.placed.map((p) => p.id).sort().join(",")}`;
 		},
-		apply(e) {
-			i.placed === void 0 && (i.placed = n?.() ?? []);
-			let t = r ?? ((t, n) => e.setPose(t, n));
-			for (let e of i.placed) t(e.id, e.to);
-			return i.placed.length > 0 ? void 0 : "noop";
+		apply(adapter) {
+			if (self.placed === void 0) self.placed = compute?.() ?? [];
+			const set = write ?? ((id, pose) => adapter.setPose(id, pose));
+			for (const p of self.placed) set(p.id, p.to);
+			return self.placed.length > 0 ? void 0 : "noop";
 		},
 		invert() {
-			return t({ placed: [...i.placed ?? []].reverse().map((e) => ({
-				id: e.id,
-				from: e.to,
-				to: e.from
-			})) }, void 0, r);
+			return createArrangeOp({ placed: [...self.placed ?? []].reverse().map((p) => ({
+				id: p.id,
+				from: p.to,
+				to: p.from
+			})) }, void 0, write);
 		}
 	};
 }
-e("arrange", (e) => t(e));
-//#endregion
-export { t as createArrangeOp };
+registerOpFactory("arrange", (args) => createArrangeOp(args));
 
+//#endregion
+export { createArrangeOp };
 //# sourceMappingURL=arrange.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"arrange.js","names":["createArrangeOp","self","args","p","compute","set","write","adapter","id","pose","registerOpFactory"],"sources":["../../../src/core/ops/arrange.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface ArrangeAdapter {\n  setPose(id: string, pose: unknown): void;\n}\n\n/** One pose write an {@link createArrangeOp} made. */\nexport interface ArrangedPose {\n  id: string;\n  from: unknown;\n  to: unknown;\n}\n\n/** Arguments to {@link createArrangeOp}. */\nexport interface ArrangeArgs {\n  /** The writes to make. Absent until a computed arrangement has run once. */\n  placed?: ArrangedPose[];\n}\n\n/**\n * Op: write a set of poses decided when the op first applies, not when it is\n * built. The scene appends one to an edit that moves nodes into a container,\n * and `compute` asks the container what to do with them after the rest of\n * the edit has landed. Every later apply — redo, or a rebuild from a\n * serialized history — replays the writes it recorded, so the arrangement is\n * decided once. `write` replaces the adapter's `setPose` for this op and its\n * inverses — the scene passes its own, since not every adapter an edit is\n * applied through can write poses.\n */\nexport function createArrangeOp(\n  args: ArrangeArgs,\n  compute?: () => ArrangedPose[],\n  write?: (id: string, pose: unknown) => void,\n): Op {\n  const self: ArrangeArgs = { ...(args.placed ? { placed: args.placed } : {}) };\n  return {\n    name: 'arrange',\n    args: self,\n    label: 'Arrange',\n    elideNoop: true,\n    // Names what it moved, so a coalesced entry never undoes to a pose only\n    // a later push wrote.\n    get coalesceKey() {\n      return self.placed === undefined ? undefined : `arrange:${self.placed.map((p) => p.id).sort().join(',')}`;\n    },\n    apply(adapter) {\n      if (self.placed === undefined) self.placed = compute?.() ?? [];\n      const set = write ?? ((id: string, pose: unknown) => (adapter as ArrangeAdapter).setPose(id, pose));\n      for (const p of self.placed) set(p.id, p.to);\n      return self.placed.length > 0 ? undefined : 'noop';\n    },\n    invert() {\n      const placed = self.placed ?? [];\n      return createArrangeOp({\n        placed: [...placed].reverse().map((p) => ({ id: p.id, from: p.to, to: p.from })),\n      }, undefined, write);\n    },\n  };\n}\n\nregisterOpFactory<ArrangeArgs>('arrange', (args) => createArrangeOp(args));\n"],"mappings":";;AA8BA,SAAgBA,EACd,GACA,GACA,GACI;CACJ,IAAMC,IAAoB,EAAE,GAAIC,EAAK,SAAS,EAAE,QAAQA,EAAK,OAAO,IAAI,CAAC,EAAG;CAC5E,OAAO;EACL,MAAM;EACN,MAAMD;EACN,OAAO;EACP,WAAW;EAGX,IAAI,cAAc;GAChB,OAAOA,EAAK,WAAW,KAAA,IAAY,KAAA,IAAY,WAAWA,EAAK,OAAO,KAAK,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG;EACxG;EACA,MAAM,GAAS;GACb,AAAIF,EAAK,WAAW,KAAA,MAAW,EAAK,SAASG,IAAU,KAAK,CAAC;GAC7D,IAAMC,IAAMC,OAAW,GAAY,MAAmBC,EAA2B,QAAQC,GAAIC,CAAI;GACjG,KAAK,IAAMN,KAAKF,EAAK,QAAQ,EAAIE,EAAE,IAAIA,EAAE,EAAE;GAC3C,OAAOF,EAAK,OAAO,SAAS,IAAI,KAAA,IAAY;EAC9C;EACA,SAAS;GAEP,OAAOD,EAAgB,EACrB,QAAQ,CAAC,GAFIC,EAAK,UAAU,CAAC,CAEX,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,OAAO;IAAE,IAAIE,EAAE;IAAI,MAAMA,EAAE;IAAI,IAAIA,EAAE;GAAK,EAAE,EACjF,GAAG,KAAA,GAAWG,CAAK;EACrB;CACF;AACF;AAEAI,EAA+B,YAAY,MAASV,EAAgBE,CAAI,CAAC"}
+{"version":3,"file":"arrange.js","names":[],"sources":["../../../src/core/ops/arrange.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface ArrangeAdapter {\n  setPose(id: string, pose: unknown): void;\n}\n\n/** One pose write an {@link createArrangeOp} made. */\nexport interface ArrangedPose {\n  id: string;\n  from: unknown;\n  to: unknown;\n}\n\n/** Arguments to {@link createArrangeOp}. */\nexport interface ArrangeArgs {\n  /** The writes to make. Absent until a computed arrangement has run once. */\n  placed?: ArrangedPose[];\n}\n\n/**\n * Op: write a set of poses decided when the op first applies, not when it is\n * built. The scene appends one to an edit that moves nodes into a container,\n * and `compute` asks the container what to do with them after the rest of\n * the edit has landed. Every later apply — redo, or a rebuild from a\n * serialized history — replays the writes it recorded, so the arrangement is\n * decided once. `write` replaces the adapter's `setPose` for this op and its\n * inverses — the scene passes its own, since not every adapter an edit is\n * applied through can write poses.\n */\nexport function createArrangeOp(\n  args: ArrangeArgs,\n  compute?: () => ArrangedPose[],\n  write?: (id: string, pose: unknown) => void,\n): Op {\n  const self: ArrangeArgs = { ...(args.placed ? { placed: args.placed } : {}) };\n  return {\n    name: 'arrange',\n    args: self,\n    label: 'Arrange',\n    elideNoop: true,\n    // Names what it moved, so a coalesced entry never undoes to a pose only\n    // a later push wrote.\n    get coalesceKey() {\n      return self.placed === undefined ? undefined : `arrange:${self.placed.map((p) => p.id).sort().join(',')}`;\n    },\n    apply(adapter) {\n      if (self.placed === undefined) self.placed = compute?.() ?? [];\n      const set = write ?? ((id: string, pose: unknown) => (adapter as ArrangeAdapter).setPose(id, pose));\n      for (const p of self.placed) set(p.id, p.to);\n      return self.placed.length > 0 ? undefined : 'noop';\n    },\n    invert() {\n      const placed = self.placed ?? [];\n      return createArrangeOp({\n        placed: [...placed].reverse().map((p) => ({ id: p.id, from: p.to, to: p.from })),\n      }, undefined, write);\n    },\n  };\n}\n\nregisterOpFactory<ArrangeArgs>('arrange', (args) => createArrangeOp(args));\n"],"mappings":";;;;;;;;;;;;;AA8BA,SAAgB,gBACd,MACA,SACA,OACI;CACJ,MAAM,OAAoB,EAAE,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC,EAAG;CAC5E,OAAO;EACL,MAAM;EACN,MAAM;EACN,OAAO;EACP,WAAW;EAGX,IAAI,cAAc;GAChB,OAAO,KAAK,WAAW,SAAY,SAAY,WAAW,KAAK,OAAO,KAAK,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG;EACxG;EACA,MAAM,SAAS;GACb,IAAI,KAAK,WAAW,QAAW,KAAK,SAAS,UAAU,KAAK,CAAC;GAC7D,MAAM,MAAM,WAAW,IAAY,SAAmB,QAA2B,QAAQ,IAAI,IAAI;GACjG,KAAK,MAAM,KAAK,KAAK,QAAQ,IAAI,EAAE,IAAI,EAAE,EAAE;GAC3C,OAAO,KAAK,OAAO,SAAS,IAAI,SAAY;EAC9C;EACA,SAAS;GAEP,OAAO,gBAAgB,EACrB,QAAQ,CAAC,GAFI,KAAK,UAAU,CAAC,CAEX,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,OAAO;IAAE,IAAI,EAAE;IAAI,MAAM,EAAE;IAAI,IAAI,EAAE;GAAK,EAAE,EACjF,GAAG,QAAW,KAAK;EACrB;CACF;AACF;AAEA,kBAA+B,YAAY,SAAS,gBAAgB,IAAI,CAAC"}

package/dist/core/ops/create.js

@@ -1,37 +1,46 @@
-import { registerOpFactory as e } from "./registry.js";
-import { parentOf as t, resolveSlot as n, slotFromIndex as r } from "./slot.js";
-import { createDeleteOp as i } from "./delete.js";
+import { registerOpFactory } from "./registry.js";
+import { parentOf, resolveSlot, slotFromIndex } from "./slot.js";
+import { createDeleteOp } from "./delete.js";
+
 //#region src/core/ops/create.ts
-function a(e) {
-	let { node: a, label: o, cascaded: s } = e, c = e.slot ?? r(e.index);
+/** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete
+*  of `node`. */
+function createInsertOp(args) {
+	const { node, label, cascaded } = args;
+	const slot = args.slot ?? slotFromIndex(args.index);
 	return {
 		name: "insert",
 		args: {
-			node: a,
-			label: o,
-			slot: c,
-			...s ? { cascaded: s } : {}
+			node,
+			label,
+			slot,
+			...cascaded ? { cascaded } : {}
 		},
-		label: o,
-		apply(e) {
-			let r = e, i = () => {
-				r.insertNode(a, n(r.getChildren?.(t(a)), c));
+		label,
+		apply(adapter) {
+			const a = adapter;
+			const insertRoot = () => {
+				a.insertNode(node, resolveSlot(a.getChildren(parentOf(node)), slot));
 			};
-			if (!s || s.length === 0) return i();
-			for (let e of s) r.getNode?.(e.node.id) || (e.node.id === a.id ? i() : r.insertNode(e.node, e.index));
+			if (!cascaded || cascaded.length === 0) return insertRoot();
+			for (const entry of cascaded) {
+				if (a.getNode(entry.node.id)) continue;
+				if (entry.node.id === node.id) insertRoot();
+				else a.insertNode(entry.node, entry.index);
+			}
 		},
 		invert() {
-			return i({
-				node: a,
-				label: o,
-				slot: c,
-				...s ? { cascaded: s } : {}
+			return createDeleteOp({
+				node,
+				label,
+				slot,
+				...cascaded ? { cascaded } : {}
 			});
 		}
 	};
 }
-e("insert", (e) => a(e));
-//#endregion
-export { a as createInsertOp };
+registerOpFactory("insert", (args) => createInsertOp(args));
 
+//#endregion
+export { createInsertOp };
 //# sourceMappingURL=create.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"create.js","names":["createInsertOp","args","slot","slotFromIndex","cascaded","a","adapter","insertRoot","node","resolveSlot","parentOf","entry","createDeleteOp","registerOpFactory"],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp, type PlacedNode } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  getNode?(id: string): TNode | undefined;\n  /** When `index` is supplied, insert at that position; adapters that ignore\n   *  the second arg (or don't expose it) fall back to their default\n   *  placement (typically append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n  /** Every node to insert, `node` itself included, each at its ordinal among\n   *  its own parent's children and ordered so a parent precedes its children.\n   *  What a delete's `cascaded` captures, and how its inverse brings the whole\n   *  set back; `node` still goes in at `slot`. One already present is skipped. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete\n *  of `node`. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label, cascaded } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot, ...(cascaded ? { cascaded } : {}) },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const insertRoot = (): void => {\n        a.insertNode(node, resolveSlot(a.getChildren?.(parentOf(node)), slot));\n      };\n      if (!cascaded || cascaded.length === 0) return insertRoot();\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) insertRoot();\n        else a.insertNode(entry.node, entry.index);\n      }\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot, ...(cascaded ? { cascaded } : {}) });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;AAoCA,SAAgBA,EAA6C,GAAmC;CAC9F,IAAM,EAAE,SAAM,UAAO,gBAAaC,GAC5BC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;GAAM,GAAIG,IAAW,EAAE,YAAS,IAAI,CAAC;EAAG;EAC7D;EACA,MAAM,GAAS;GACb,IAAMC,IAAIC,GACJC,UAAyB;IAC7B,EAAE,WAAWC,GAAMC,EAAYJ,EAAE,cAAcK,EAASF,CAAI,CAAC,GAAGN,CAAI,CAAC;GACvE;GACA,IAAI,CAACE,KAAYA,EAAS,WAAW,GAAG,OAAOG,EAAW;GAC1D,KAAK,IAAMI,KAASP,GAGlB,AAAIC,EAAE,UAAUM,EAAM,KAAK,EAAE,MACzBA,EAAM,KAAK,OAAOH,EAAK,KAAID,EAAW,IACrCF,EAAE,WAAWM,EAAM,MAAMA,EAAM,KAAK;EAE7C;EACA,SAAS;GACP,OAAOC,EAAe;IAAE;IAAM;IAAO;IAAM,GAAIR,IAAW,EAAE,YAAS,IAAI,CAAC;GAAG,CAAC;EAChF;CACF;AACF;AAEAS,EAA8C,WAAW,MAASb,EAAeC,CAAI,CAAC"}
+{"version":3,"file":"create.js","names":[],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp, type PlacedNode } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  getNode(id: string): TNode | undefined;\n  /** When `index` is supplied, insert at that position; an adapter that\n   *  ignores the second arg falls back to its default placement (typically\n   *  append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n  /** Every node to insert, `node` itself included, each at its ordinal among\n   *  its own parent's children and ordered so a parent precedes its children.\n   *  What a delete's `cascaded` captures, and how its inverse brings the whole\n   *  set back; `node` still goes in at `slot`. One already present is skipped. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete\n *  of `node`. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label, cascaded } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot, ...(cascaded ? { cascaded } : {}) },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const insertRoot = (): void => {\n        a.insertNode(node, resolveSlot(a.getChildren(parentOf(node)), slot));\n      };\n      if (!cascaded || cascaded.length === 0) return insertRoot();\n      for (const entry of cascaded) {\n        // An adapter whose removeNode doesn't cascade never lost the\n        // children — re-inserting them would duplicate them.\n        if (a.getNode(entry.node.id)) continue;\n        if (entry.node.id === node.id) insertRoot();\n        else a.insertNode(entry.node, entry.index);\n      }\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot, ...(cascaded ? { cascaded } : {}) });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;;;;AAoCA,SAAgB,eAA6C,MAAmC;CAC9F,MAAM,EAAE,MAAM,OAAO,aAAa;CAClC,MAAM,OAAoB,KAAK,QAAQ,cAAc,KAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;GAAM,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;EAAG;EAC7D;EACA,MAAM,SAAS;GACb,MAAM,IAAI;GACV,MAAM,mBAAyB;IAC7B,EAAE,WAAW,MAAM,YAAY,EAAE,YAAY,SAAS,IAAI,CAAC,GAAG,IAAI,CAAC;GACrE;GACA,IAAI,CAAC,YAAY,SAAS,WAAW,GAAG,OAAO,WAAW;GAC1D,KAAK,MAAM,SAAS,UAAU;IAG5B,IAAI,EAAE,QAAQ,MAAM,KAAK,EAAE,GAAG;IAC9B,IAAI,MAAM,KAAK,OAAO,KAAK,IAAI,WAAW;SACrC,EAAE,WAAW,MAAM,MAAM,MAAM,KAAK;GAC3C;EACF;EACA,SAAS;GACP,OAAO,eAAe;IAAE;IAAM;IAAO;IAAM,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;GAAG,CAAC;EAChF;CACF;AACF;AAEA,kBAA8C,WAAW,SAAS,eAAe,IAAI,CAAC"}

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,77 +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) ?? -1;
+/** `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 { getChildren: r, getNode: i } = e;
-	if (!r || !i) return null;
-	let o = e.getRemovalClosure?.([t]), s = /* @__PURE__ */ new Map();
-	if (o) for (let t of o) {
-		let n = i.call(e, t);
-		n && s.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 a = i.call(e, t);
-			if (a) {
-				s.set(t, a);
-				for (let i of r.call(e, t)) n(i);
-			}
+		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 c = [...s.values()].filter((e) => {
-		let t = n(e);
-		return t === null || !s.has(t);
-	}).map((t) => ({
-		node: t,
-		index: a(e, n(t), t.id)
-	})).sort((e, t) => e.index - t.index), l = [], u = (t) => {
-		l.push(t);
-		let n = r.call(e, t.node.id);
-		for (let e = 0; e < n.length; e++) {
-			let t = s.get(n[e]);
-			t && u({
-				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 c) u(e);
-	return l;
+	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);
-			let s = o(r, a.id);
-			s && (u = s, l.cascaded = s), 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","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","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. 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, where it can, 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 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 * 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>[] | 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      // 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,cAAcC,CAAQ,CAAC,EAAE,QAAQC,CAAE,KAAK;AACnD;AAgBA,SAASC,EACP,GACA,GAC4B;CAC5B,IAAM,EAAE,gBAAa,eAAYH;CACjC,IAAI,CAACI,KAAe,CAACC,GAAS,OAAO;CAErC,IAAMC,IAAUN,EAAE,oBAAoB,CAACO,CAAM,CAAC,GACxCC,oBAAQ,IAAI,IAAmB;CACrC,IAAIF,GACF,KAAK,IAAMJ,KAAMI,GAAS;EACxB,IAAMG,IAAOJ,EAAQ,KAAKL,GAAGE,CAAE;EAC/B,AAAIO,KAAMD,EAAM,IAAIN,GAAIO,CAAI;CAC9B;MACK;EAEL,IAAMC,KAAQ,MAAqB;GACjC,IAAMD,IAAOJ,EAAQ,KAAKL,GAAGE,CAAE;GAC/B,IAAKO,GACL;MAAM,IAAIP,GAAIO,CAAI;IAClB,KAAK,IAAME,KAAOP,EAAY,KAAKJ,GAAGE,CAAE,GAAG,EAAKS,CAAG;GADjC;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,OAAOhB,EAAQC,GAAGc,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,IAAOjB,EAAY,KAAKJ,GAAGoB,EAAM,KAAK,EAAE;EAC9C,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,IAAM5B,IAAI8B,GACJC,IAAWC,EAAYhC,GAAGc,EAASL,CAAI,GAAGA,EAAK,EAAE;GACvD,AAAIsB,MACF,IAAOA,GACP,EAAc,OAAOA;GAEvB,IAAME,IAAW9B,EAAeH,GAAGS,EAAK,EAAE;GAK1C,AAJIwB,MACF,IAAWA,GACX,EAAc,WAAWA,IAE3BjC,EAAE,WAAWS,EAAK,EAAE;EACtB;EACA,SAAS;GAGP,OAAOyB,EAAsB;IAC3B;IAAM;IAAO;IACb,GAAIL,EAAS,SAAS,IAAI,EAAE,UAAUA,EAAS,IAAI,CAAC;GACtD,CAAC;EACH;CACF;AACF;AAEAM,EAA8C,WAAW,MAASX,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"}