@weasel-js/core 1.9.3 → 1.10.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneRecording.js","names":["createSceneRecording","env","notifier","ops","createOpTable","mode","replay","step","notify","stale","logApplied","kind","payload","reverted","outer","createOuterOps","name","args","recorder","atomically","config","engine","createHistory","selection","ids","log","createAppliedLog","createRecorder","lifted","engineDriven","refuseUntracked","verb","createSceneHistory","arrivals","handler","op","batch","all","label","adapter","methods"],"sources":["../../../src/core/scene/sceneRecording.ts"],"sourcesContent":["/**\n * How a scene's edits reach its undo stack: the op table, the log that takes\n * back an edit refused partway, the engine, and the recorder between them.\n */\nimport type { Journal } from '@weasel-js/history';\nimport { createHistory } from 'core/ops/createHistory';\nimport { createAppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport type { EditMode } from './editMode';\nimport { createSceneHistory, type SceneHistoryMethods } from './historyFacade';\nimport type { Notifier } from './notifier';\nimport { createOpTable, type OpTable } from './opTable';\nimport { createOuterOps } from './outerOps';\nimport { createRecorder, type Recorder, type RecorderEnv } from './recorder';\nimport type { SceneSelection } from './sceneSelection';\nimport type { StaleReplay } from './staleReplay';\nimport type { NodeId, RegisteredOp, Scene } from './types';\n\nexport interface SceneRecordingEnv {\n  notifier: Notifier;\n  mode: EditMode;\n  stale: StaleReplay;\n  /** Run with the lock guard lifted. */\n  lifted<T>(fn: () => T): T;\n  selection: Pick<SceneSelection, 'get' | 'set' | 'replace'>;\n  arrivals: RecorderEnv['arrivals'] & Pick<ArrivalWindow<unknown>, 'runEdit'>;\n  writePose(id: string, pose: unknown): void;\n  config: {\n    getActiveJournal?: (() => Journal | null) | undefined;\n    coalesceWindowMs?: number | undefined;\n    historyLimit?: number | undefined;\n  };\n}\n\nexport interface SceneRecording {\n  ops: Pick<OpTable, 'register' | 'run'>;\n  recorder: Recorder;\n  clearHistory(): void;\n  methods: SceneHistoryMethods & Pick<\n    Scene<unknown, string, unknown>,\n    | 'registerOp' | 'recordOp' | 'applyBatch' | 'history' | 'batch' | 'untracked'\n    | 'setActiveJournalAccessor' | 'setHistoryAdapter'\n  >;\n}\n\nexport function createSceneRecording(env: SceneRecordingEnv): SceneRecording {\n  const { notifier, mode, stale, lifted, selection, arrivals, config } = env;\n  const { notify } = notifier;\n\n  const ops = createOpTable({\n    driven: mode.open,\n    replayAlone: (step) => { replay(step); notify(); },\n    skips: stale.skips,\n    // Only a replay is logged: a first apply is recorded by the entry it\n    // creates, and reverting it would leave that entry describing nothing.\n    applied: (kind, payload, reverted) => { if (!mode.records()) logApplied(kind, payload, reverted); },\n  });\n\n  const outer = createOuterOps({\n    own: (name, args) => (ops.handlers.has(name) ? ops.op(name, args) : null),\n    recorder: () => recorder,\n    // Deferred rather than muted, so a throwing op cannot strand subscribers\n    // after earlier ops in the batch already mutated state.\n    driving: (step) => notifier.deferred(() => mode.during('engine', () => atomically(step, () => true))),\n    getActiveJournal: config.getActiveJournal ?? null,\n  });\n\n  // The scene's undo/redo engine. Its recorded ops close over their payloads,\n  // so the engine's adapter argument is unused.\n  const engine = createHistory(undefined, {\n    selection: { get: selection.get, set: (ids) => selection.set(ids as readonly NodeId[]) },\n    ...(config.coalesceWindowMs !== undefined ? { coalesceWindowMs: config.coalesceWindowMs } : {}),\n    ...(config.historyLimit !== undefined ? { historyLimit: config.historyLimit } : {}),\n    rebuildOp: outer.rebuild,\n  });\n\n  const log = createAppliedLog({\n    registered: ops.handlers,\n    lifted,\n    getSelection: selection.get,\n    setSelection: selection.replace,\n    notify,\n  });\n  const { atomically, logApplied } = log;\n\n  const recorder = createRecorder({\n    notifier,\n    mode,\n    engine,\n    runOp: ops.run,\n    makeOp: ops.op,\n    log,\n    arrivals,\n    selection: selection.get,\n    writePose: env.writePose,\n  });\n  const { record, engineDriven } = recorder;\n\n  /** Run an engine step that replays recorded ops — undo, redo, goto, a\n   *  journal stepping. The engine inverts whole ops when one throws; this\n   *  also reverts the scene writes of the op that threw partway. */\n  function replay(step: () => void): void {\n    atomically(() => lifted(() => stale.during(() => engineDriven(step))), () => true);\n  }\n\n  function refuseUntracked(verb: string): void {\n    if (mode.untracked()) throw new Error(`Scene: cannot ${verb} inside untracked() — it records`);\n  }\n\n  const { history, methods } = createSceneHistory({\n    engine,\n    applying: (step) => atomically(() => engineDriven(step), () => true),\n    causing: outer.causing,\n    replay,\n    notify,\n    refuseUntracked,\n    runArrivalEdit: arrivals.runEdit,\n  });\n\n  return {\n    ops,\n    recorder,\n    clearHistory: () => engine.clear(),\n    methods: {\n      registerOp(kind, handler) {\n        if (kind.startsWith('kit:')) {\n          throw new Error(`Scene: op kind \"${kind}\" is reserved (kit:* prefix)`);\n        }\n        ops.register(kind, handler as RegisteredOp<unknown>);\n      },\n      recordOp(op) {\n        record(op.kind, op.payload, op.kind);\n      },\n      applyBatch(batch, label, adapter) {\n        refuseUntracked('applyBatch');\n        return arrivals.runEdit(batch, (all) => outer.apply(engine, all, label, adapter));\n      },\n      history,\n      ...methods,\n      batch: recorder.batch,\n      untracked: recorder.untracked,\n      setActiveJournalAccessor: outer.setActiveJournalAccessor,\n      setHistoryAdapter: outer.setHistoryAdapter,\n    },\n  };\n}\n"],"mappings":";;;;;;;AA6CA,SAAgBA,EAAqB,GAAwC;CAC3E,IAAM,EAAE,aAAU,SAAM,UAAO,WAAQ,cAAW,aAAU,cAAWC,GACjE,EAAE,cAAWC,GAEbC,IAAMC,EAAc;EACxB,QAAQC,EAAK;EACb,cAAc,MAAS;GAAgB,AAAdC,EAAOC,CAAI,GAAGC,EAAO;EAAG;EACjD,OAAOC,EAAM;EAGb,UAAU,GAAM,GAAS,MAAa;GAAE,AAAKJ,EAAK,QAAQ,KAAGK,EAAWC,GAAMC,GAASC,CAAQ;EAAG;CACpG,CAAC,GAEKC,IAAQC,EAAe;EAC3B,MAAM,GAAM,MAAUZ,EAAI,SAAS,IAAIa,CAAI,IAAIb,EAAI,GAAGa,GAAMC,CAAI,IAAI;EACpE,gBAAgBC;EAGhB,UAAU,MAAShB,EAAS,eAAeG,EAAK,OAAO,gBAAgBc,EAAWZ,SAAY,EAAI,CAAC,CAAC;EACpG,kBAAkBa,EAAO,oBAAoB;CAC/C,CAAC,GAIKC,IAASC,EAAc,KAAA,GAAW;EACtC,WAAW;GAAE,KAAKC,EAAU;GAAK,MAAM,MAAQA,EAAU,IAAIC,CAAwB;EAAE;EACvF,GAAIJ,EAAO,qBAAqB,KAAA,IAA4D,CAAC,IAAjD,EAAE,kBAAkBA,EAAO,iBAAiB;EACxF,GAAIA,EAAO,iBAAiB,KAAA,IAAoD,CAAC,IAAzC,EAAE,cAAcA,EAAO,aAAa;EAC5E,WAAWN,EAAM;CACnB,CAAC,GAEKW,IAAMC,EAAiB;EAC3B,YAAYvB,EAAI;EAChB;EACA,cAAcoB,EAAU;EACxB,cAAcA,EAAU;EACxB;CACF,CAAC,GACK,EAAE,eAAY,kBAAeE,GAE7BP,IAAWS,EAAe;EAC9B;EACA;EACA;EACA,OAAOxB,EAAI;EACX,QAAQA,EAAI;EACZ;EACA;EACA,WAAWoB,EAAU;EACrB,WAAWtB,EAAI;CACjB,CAAC,GACK,EAAE,WAAQ,oBAAiBiB;CAKjC,SAASZ,EAAO,GAAwB;EACtC,QAAiBsB,QAAanB,EAAM,aAAaoB,EAAatB,CAAI,CAAC,CAAC,SAAS,EAAI;CACnF;CAEA,SAASuB,EAAgB,GAAoB;EAC3C,IAAIzB,EAAK,UAAU,GAAG,MAAU,MAAM,iBAAiB0B,EAAK,iCAAiC;CAC/F;CAEA,IAAM,EAAE,YAAS,eAAYC,EAAmB;EAC9C;EACA,WAAW,MAASb,QAAiBU,EAAatB,CAAI,SAAS,EAAI;EACnE,SAASO,EAAM;EACf;EACA;EACA;EACA,gBAAgBmB,EAAS;CAC3B,CAAC;CAED,OAAO;EACL;EACA;EACA,oBAAoBZ,EAAO,MAAM;EACjC,SAAS;GACP,WAAW,GAAM,GAAS;IACxB,IAAIV,EAAK,WAAW,MAAM,GACxB,MAAU,MAAM,mBAAmBA,EAAK,6BAA6B;IAEvE,EAAI,SAASA,GAAMuB,CAAgC;GACrD;GACA,SAAS,GAAI;IACX,EAAOC,EAAG,MAAMA,EAAG,SAASA,EAAG,IAAI;GACrC;GACA,WAAW,GAAO,GAAO,GAAS;IAEhC,OADAL,EAAgB,YAAY,GACrBG,EAAS,QAAQG,IAAQ,MAAQtB,EAAM,MAAMO,GAAQgB,GAAKC,GAAOC,CAAO,CAAC;GAClF;GACA;GACA,GAAGC;GACH,OAAOtB,EAAS;GAChB,WAAWA,EAAS;GACpB,0BAA0BJ,EAAM;GAChC,mBAAmBA,EAAM;EAC3B;CACF;AACF"}

package/dist/core/scene/sceneSelection.js

@@ -0,0 +1,28 @@
+import { createEmitter as e } from "@weasel-js/registry";
+//#region src/core/scene/sceneSelection.ts
+function t(t) {
+	let n = [], r = e();
+	return {
+		get: () => n,
+		set(e) {
+			n = t(e), r.emit();
+		},
+		narrow(e) {
+			n = t(e !== void 0 && n.some((t) => e.has(t)) ? n.filter((t) => !e.has(t)) : n);
+		},
+		replace(e) {
+			n = e;
+		},
+		subscribe: r.subscribe
+	};
+}
+function n(e) {
+	return {
+		get: () => e.getSelection(),
+		set: (t) => e.setSelection(t)
+	};
+}
+//#endregion
+export { t as createSceneSelection, n as sceneSelectionStore };
+
+//# sourceMappingURL=sceneSelection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneSelection.js","names":["createSceneSelection","ids","changed","createEmitter","reachable","next","gone","id","sceneSelectionStore","scene"],"sources":["../../../src/core/scene/sceneSelection.ts"],"sourcesContent":["/**\n * The scene's selection: the transient set of active ids. Not document\n * content, so it never reaches `toJSON`; it does ride on history entries.\n */\nimport type { HistorySelection } from '@weasel-js/history';\nimport { createEmitter } from '@weasel-js/registry';\nimport type { NodeId } from './types';\n\nexport interface SceneSelection {\n  get(): readonly NodeId[];\n  /** Select the ids of `ids` that are in reach, and tell subscribers. */\n  set(ids: readonly NodeId[]): void;\n  /** Drop the ids in `gone`, and any a lock has put out of reach. Tells no\n   *  one: the edit that took them is what subscribers hear about. */\n  narrow(gone?: ReadonlySet<NodeId>): void;\n  /** Put a selection in place exactly as given, telling no one: for a caller\n   *  returning what it read earlier, or one that has already filtered. */\n  replace(ids: readonly NodeId[]): void;\n  subscribe(listener: () => void): () => void;\n}\n\nexport function createSceneSelection(\n  /** `ids` less those out of reach; the same array when none is. */\n  reachable: (ids: readonly NodeId[]) => readonly NodeId[],\n): SceneSelection {\n  let ids: readonly NodeId[] = [];\n  const changed = createEmitter();\n\n  return {\n    get: () => ids,\n    set(next) {\n      ids = reachable(next);\n      changed.emit();\n    },\n    narrow(gone) {\n      // A new array only when one is dropped: readers compare the selection by identity.\n      const kept = gone !== undefined && ids.some((id) => gone.has(id)) ? ids.filter((id) => !gone.has(id)) : ids;\n      ids = reachable(kept);\n    },\n    replace(next) {\n      ids = next;\n    },\n    subscribe: changed.subscribe,\n  };\n}\n\n/** The scene's selection in the shape `createHistory` wants, for a consumer\n *  building a second History over the same scene (a modality machine, a\n *  journal owner) that should restore selection the way the scene's own\n *  history does. */\nexport function sceneSelectionStore(scene: {\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n}): HistorySelection {\n  return {\n    get: () => scene.getSelection(),\n    set: (ids) => scene.setSelection(ids as readonly NodeId[]),\n  };\n}\n"],"mappings":";;AAqBA,SAAgBA,EAEd,GACgB;CAChB,IAAIC,IAAyB,CAAC,GACxBC,IAAUC,EAAc;CAE9B,OAAO;EACL,WAAWF;EACX,IAAI,GAAM;GAER,AADA,IAAMG,EAAUC,CAAI,GACpBH,EAAQ,KAAK;EACf;EACA,OAAO,GAAM;GAGX,IAAME,EADOE,MAAS,KAAA,KAAaL,EAAI,MAAM,MAAOK,EAAK,IAAIC,CAAE,CAAC,IAAIN,EAAI,QAAQ,MAAO,CAACK,EAAK,IAAIC,CAAE,CAAC,IAAIN,CACpF;EACtB;EACA,QAAQ,GAAM;GACZ,IAAMI;EACR;EACA,WAAWH,EAAQ;CACrB;AACF;AAMA,SAAgBM,EAAoB,GAGf;CACnB,OAAO;EACL,WAAWC,EAAM,aAAa;EAC9B,MAAM,MAAQA,EAAM,aAAaR,CAAwB;CAC3D;AACF"}

package/dist/core/scene/sceneState.js

@@ -0,0 +1,49 @@
+import { createNodeFnFields as e } from "./nodeFnFields.js";
+import { createLayerStack as t } from "./layerStack.js";
+import { createStaleReplay as n } from "./staleReplay.js";
+import { createLockGuard as r } from "./lockGuard.js";
+import { createNodeStore as i } from "./nodeStore.js";
+import { createRenderOrder as a } from "./renderOrder.js";
+import { serializeScene as o } from "./serialization.js";
+import { createTreeReads as s } from "./treeReads.js";
+//#region src/core/scene/sceneState.ts
+function c(c, l, u) {
+	let d = {
+		nodes: /* @__PURE__ */ new Map(),
+		roots: [],
+		layers: [],
+		layerIndex: /* @__PURE__ */ new Map()
+	}, f = a(d), p = e(c, (e) => {
+		e === "layout" && u();
+	}), m = i(d, f.invalidate, p), h = t(d, f.invalidate);
+	h.reset(l);
+	let g = r(d), _ = {
+		...s(d.nodes),
+		renderOrder: f.ids,
+		renderOrderNodes: f.nodes,
+		nodesOnLayer: f.nodesOnLayer,
+		isLocked: (e) => g.isLocked(e),
+		layoutOf(e) {
+			let t = d.nodes.get(e);
+			return t?.kind === "container" ? t.layout ?? null : null;
+		},
+		toJSON: () => o(d, p)
+	};
+	return {
+		state: d,
+		order: f,
+		locks: g,
+		stale: n(d.nodes),
+		fnFields: p,
+		store: m,
+		layers: h,
+		reads: _,
+		reset(e) {
+			m.dependents.clear(), m.childDerived.clear(), d.nodes.clear(), d.roots.length = 0, h.reset(e);
+		}
+	};
+}
+//#endregion
+export { c as createSceneState };
+
+//# sourceMappingURL=sceneState.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneState.js","names":["createSceneState","state","order","createRenderOrder","fnFields","createNodeFnFields","registry","field","layoutDeclared","store","createNodeStore","layers","createLayerStack","initialLayers","locks","createLockGuard","reads","createTreeReads","id","node","serializeScene","createStaleReplay","records"],"sources":["../../../src/core/scene/sceneState.ts"],"sourcesContent":["/**\n * A scene's document state — its nodes, roots, and layers — with the modules\n * that read and write it directly.\n */\nimport { createLayerStack } from './layerStack';\nimport { createLockGuard } from './lockGuard';\nimport { createNodeFnFields } from './nodeFnFields';\nimport { createNodeStore } from './nodeStore';\nimport { createRenderOrder } from './renderOrder';\nimport { serializeScene } from './serialization';\nimport { createStaleReplay } from './staleReplay';\nimport { createTreeReads } from './treeReads';\nimport type { LayerRecord, Node, NodeId, Scene, SceneRegistry } from './types';\n\nexport function createSceneState<TData, TLayer extends string, TPose>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n  initialLayers: readonly LayerRecord<TLayer>[],\n  /** Called when a node is given a layout. */\n  layoutDeclared: () => void,\n) {\n  const state = {\n    nodes: new Map<NodeId, Node<TData, TLayer, TPose>>(),\n    roots: [] as NodeId[],\n    layers: [] as LayerRecord<TLayer>[],\n    layerIndex: new Map<TLayer, number>(),\n  };\n  const order = createRenderOrder(state);\n  /** The registry-keyed function fields, each with its key maps. A function\n   *  cannot travel through a serializable op payload, so an op carries its key. */\n  const fnFields = createNodeFnFields<TPose>(registry, (field) => {\n    if (field === 'layout') layoutDeclared();\n  });\n  const store = createNodeStore(state, order.invalidate, fnFields);\n  const layers = createLayerStack(state, order.invalidate);\n  layers.reset(initialLayers);\n  const locks = createLockGuard(state);\n\n  const reads: Pick<\n    Scene<TData, TLayer, TPose>,\n    | 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf' | 'renderOrder' | 'renderOrderNodes'\n    | 'nodesOnLayer' | 'isLocked' | 'layoutOf' | 'toJSON'\n  > = {\n    ...createTreeReads(state.nodes),\n    renderOrder: order.ids,\n    renderOrderNodes: order.nodes,\n    nodesOnLayer: order.nodesOnLayer,\n    isLocked: (id) => locks.isLocked(id),\n    layoutOf(id) {\n      const node = state.nodes.get(id);\n      return node?.kind === 'container' ? (node.layout ?? null) : null;\n    },\n    toJSON: () => serializeScene(state, fnFields),\n  };\n\n  return {\n    state,\n    order,\n    locks,\n    stale: createStaleReplay(state.nodes),\n    fnFields,\n    store,\n    layers,\n    reads,\n\n    /** Empty the document and give it `records` as its layers. */\n    reset(records: readonly LayerRecord<TLayer>[]): void {\n      store.dependents.clear();\n      store.childDerived.clear();\n      state.nodes.clear();\n      state.roots.length = 0;\n      layers.reset(records);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;AAcA,SAAgBA,EACd,GACA,GAEA,GACA;CACA,IAAMC,IAAQ;EACZ,uBAAO,IAAI,IAAwC;EACnD,OAAO,CAAC;EACR,QAAQ,CAAC;EACT,4BAAY,IAAI,IAAoB;CACtC,GACMC,IAAQC,EAAkBF,CAAK,GAG/BG,IAAWC,EAA0BC,IAAW,MAAU;EAC9D,AAAIC,MAAU,YAAUC,EAAe;CACzC,CAAC,GACKC,IAAQC,EAAgBT,GAAOC,EAAM,YAAYE,CAAQ,GACzDO,IAASC,EAAiBX,GAAOC,EAAM,UAAU;CACvD,EAAO,MAAMW,CAAa;CAC1B,IAAMC,IAAQC,EAAgBd,CAAK,GAE7Be,IAIF;EACF,GAAGC,EAAgBhB,EAAM,KAAK;EAC9B,aAAaC,EAAM;EACnB,kBAAkBA,EAAM;EACxB,cAAcA,EAAM;EACpB,WAAW,MAAOY,EAAM,SAASI,CAAE;EACnC,SAAS,GAAI;GACX,IAAMC,IAAOlB,EAAM,MAAM,IAAIiB,CAAE;GAC/B,OAAOC,GAAM,SAAS,cAAeA,EAAK,UAAU,OAAQ;EAC9D;EACA,cAAcC,EAAenB,GAAOG,CAAQ;CAC9C;CAEA,OAAO;EACL;EACA;EACA;EACA,OAAOiB,EAAkBpB,EAAM,KAAK;EACpC;EACA;EACA;EACA;EAGA,MAAM,GAA+C;GAKnD,AAJAQ,EAAM,WAAW,MAAM,GACvBA,EAAM,aAAa,MAAM,GACzBR,EAAM,MAAM,MAAM,GAClB,EAAM,MAAM,SAAS,GACrBU,EAAO,MAAMW,CAAO;EACtB;CACF;AACF"}

package/dist/core/scene/serialization.js

@@ -0,0 +1,71 @@
+import { NODE_FN_FIELDS as e, fnKeysOf as t } from "./nodeFnFields.js";
+import { treePreorder as n } from "./treeOrder.js";
+//#region src/core/scene/serialization.ts
+function r(e) {
+	return typeof e == "object" && !!e && e.version === 1 && Array.isArray(e.nodes);
+}
+function i(e) {
+	let t = {
+		id: e.id,
+		visible: e.visible ?? !0,
+		locked: e.locked ?? !1,
+		...e.parallax ? { parallax: e.parallax } : {}
+	};
+	return e.kind === "user" ? {
+		...t,
+		kind: "user",
+		name: e.name ?? e.id
+	} : {
+		...t,
+		kind: "system"
+	};
+}
+function a(e, r) {
+	let i = [];
+	for (let a of n(e.roots, e.nodes)) {
+		let e = a.id, n = {
+			id: e,
+			kind: a.kind,
+			layer: a.layer,
+			pose: a.pose,
+			data: a.data
+		};
+		a.parent != null && (n.parent = a.parent), a.dependsOn === "children" ? n.dependsOn = "children" : a.dependsOn && a.dependsOn.length > 0 && (n.dependsOn = a.dependsOn), a.pickable === !1 && (n.pickable = !1), a.kind === "container" && a.units !== void 0 && (n.units = a.units), Object.assign(n, t(r, a, "jsonKey", (t) => {
+			throw Error(`Scene.toJSON: node '${e}' has ${t.spec.field} but no matching registry key. The function must be registered via createScene's registry option to round-trip.`);
+		})), i.push(n);
+	}
+	return {
+		version: 1,
+		systemLayers: e.layers.map((e) => {
+			let t = { id: e.id };
+			return e.visible === !1 && (t.visible = !1), e.locked === !0 && (t.locked = !0), e.parallax && (t.parallax = e.parallax), e.kind === "user" && (t.kind = "user", t.name = e.name), t;
+		}),
+		nodes: i
+	};
+}
+function o(t, n) {
+	if (t.version !== 1) throw Error(`Scene: unsupported version ${t.version}; only v1 supported`);
+	return t.nodes.map((t) => {
+		let r = {
+			id: t.id,
+			kind: t.kind,
+			layer: t.layer,
+			pose: t.pose,
+			data: t.data
+		};
+		t.parent !== void 0 && (r.parent = t.parent), t.pickable !== void 0 && (r.pickable = t.pickable), t.units !== void 0 && (r.units = t.units), t.dependsOn !== void 0 && (r.dependsOn = t.dependsOn === "children" ? "children" : t.dependsOn);
+		let i = t;
+		for (let t of e) {
+			let e = i[t.jsonKey];
+			if (e === void 0) continue;
+			let a = n[t.field]?.[e];
+			if (!a) throw Error(`Scene: unknown ${t.field} key '${e}'. Register a function with this key in the registry option.`);
+			r[t.field] = a;
+		}
+		return r;
+	});
+}
+//#endregion
+export { r as isSerializedScene, i as layerFromSerialized, a as serializeScene, o as specsFromSerialized };
+
+//# sourceMappingURL=serialization.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.js","names":["isSerializedScene","value","layerFromSerialized","base","spec","serializeScene","nodes","n","treePreorder","state","id","out","fnKeysOf","fnFields","field","layer","l","specsFromSerialized","json","serialized","NODE_FN_FIELDS","key","fn","registry"],"sources":["../../../src/core/scene/serialization.ts"],"sourcesContent":["/**\n * A scene to and from its JSON snapshot: the walk that writes one, and the\n * two readers that turn one back into layer records and node specs.\n */\nimport {\n  NODE_FN_FIELDS, fnKeysOf, type FnBearingNode, type NodeFnField,\n} from './nodeFnFields';\nimport { treePreorder } from './treeOrder';\nimport type {\n  AddNodeSpec, LayerRecord, Node, NodeId, SceneRegistry, SerializedLayer, SerializedNode, SerializedScene,\n} from './types';\n\n/** Whether `value` is a snapshot `specsFromSerialized` reads, as against a live scene. */\nexport function isSerializedScene<TData, TLayer extends string, TPose>(\n  value: unknown,\n): value is SerializedScene<TData, TLayer, TPose> {\n  return typeof value === 'object' && value != null\n    && (value as { version?: unknown }).version === 1\n    && Array.isArray((value as { nodes?: unknown }).nodes);\n}\n\n/** What a snapshot is written from. */\nexport interface SerializableState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: LayerRecord<TLayer>[];\n}\n\n/** One layer record from its snapshot form. A snapshot with no `kind` predates\n *  user layers, so everything in it was a system layer. */\nexport function layerFromSerialized<TLayer extends string>(\n  spec: SerializedLayer<TLayer>,\n): LayerRecord<TLayer> {\n  const base = {\n    id: spec.id,\n    visible: spec.visible ?? true,\n    locked: spec.locked ?? false,\n    ...(spec.parallax ? { parallax: spec.parallax } : {}),\n  };\n  return spec.kind === 'user'\n    ? { ...base, kind: 'user', name: spec.name ?? spec.id }\n    : { ...base, kind: 'system' };\n}\n\n/** The snapshot of `state`: layers in order, nodes in tree preorder. Throws\n *  when a node carries a function the registry has no key for. */\nexport function serializeScene<TData, TLayer extends string, TPose>(\n  state: SerializableState<TData, TLayer, TPose>,\n  fnFields: readonly NodeFnField[],\n): SerializedScene<TData, TLayer, TPose> {\n  const nodes: SerializedNode<TData, TLayer, TPose>[] = [];\n  for (const n of treePreorder(state.roots, state.nodes)) {\n    const id = n.id;\n    const out: SerializedNode<TData, TLayer, TPose> = {\n      id,\n      kind: n.kind,\n      layer: n.layer,\n      pose: n.pose,\n      data: n.data,\n    };\n    if (n.parent != null) out.parent = n.parent;\n    if (n.dependsOn === 'children') out.dependsOn = 'children';\n    else if (n.dependsOn && n.dependsOn.length > 0) out.dependsOn = n.dependsOn;\n    if (n.pickable === false) out.pickable = false;\n    if (n.kind === 'container' && n.units !== undefined) out.units = n.units;\n    Object.assign(\n      out,\n      fnKeysOf(fnFields, n as unknown as FnBearingNode, 'jsonKey', (field) => {\n        throw new Error(\n          `Scene.toJSON: node '${id}' has ${field.spec.field} but no matching registry key. ` +\n          `The function must be registered via createScene's registry option to round-trip.`\n        );\n      }),\n    );\n    nodes.push(out);\n  }\n  const systemLayers = state.layers.map((l) => {\n    const layer: SerializedLayer<TLayer> = { id: l.id };\n    if (l.visible === false) layer.visible = false;\n    if (l.locked === true) layer.locked = true;\n    if (l.parallax) layer.parallax = l.parallax;\n    if (l.kind === 'user') {\n      layer.kind = 'user';\n      layer.name = l.name;\n    }\n    return layer;\n  });\n  return { version: 1, systemLayers, nodes };\n}\n\n/** Map a `SerializedScene` to construction specs. Shared by `sceneFromJSON`\n *  (new instance) and `Scene.loadState` (in-place). Validates version and\n *  resolves every `NODE_FN_FIELDS` key → function via the registry;\n *  throws on an unsupported version or an unknown registry key. */\nexport function specsFromSerialized<TData, TLayer extends string, TPose>(\n  json: SerializedScene<TData, TLayer, TPose>,\n  registry: SceneRegistry<TPose, TData, TLayer>,\n): AddNodeSpec<TData, TLayer, TPose>[] {\n  if (json.version !== 1) {\n    throw new Error(`Scene: unsupported version ${json.version}; only v1 supported`);\n  }\n  return json.nodes.map((n) => {\n    const spec: AddNodeSpec<TData, TLayer, TPose> = {\n      id: n.id as NodeId,\n      kind: n.kind,\n      layer: n.layer,\n      pose: n.pose,\n      data: n.data,\n    };\n    if (n.parent !== undefined) spec.parent = n.parent as NodeId;\n    if (n.pickable !== undefined) spec.pickable = n.pickable;\n    if (n.units !== undefined) spec.units = n.units;\n    if (n.dependsOn !== undefined) {\n      spec.dependsOn = n.dependsOn === 'children'\n        ? 'children'\n        : (n.dependsOn as readonly NodeId[]);\n    }\n    const serialized = n as unknown as Record<string, string | undefined>;\n    for (const field of NODE_FN_FIELDS) {\n      const key = serialized[field.jsonKey];\n      if (key === undefined) continue;\n      const fn = (registry[field.field] as Record<string, unknown> | undefined)?.[key];\n      if (!fn) {\n        throw new Error(\n          `Scene: unknown ${field.field} key '${key}'. ` +\n          `Register a function with this key in the registry option.`,\n        );\n      }\n      (spec as unknown as Record<string, unknown>)[field.field] = fn;\n    }\n    return spec;\n  });\n}\n"],"mappings":";;;AAaA,SAAgBA,EACd,GACgD;CAChD,OAAO,OAAOC,KAAU,cAAYA,KAC9BA,EAAgC,YAAY,KAC7C,MAAM,QAASA,EAA8B,KAAK;AACzD;AAWA,SAAgBC,EACd,GACqB;CACrB,IAAMC,IAAO;EACX,IAAIC,EAAK;EACT,SAASA,EAAK,WAAW;EACzB,QAAQA,EAAK,UAAU;EACvB,GAAIA,EAAK,WAAW,EAAE,UAAUA,EAAK,SAAS,IAAI,CAAC;CACrD;CACA,OAAOA,EAAK,SAAS,SACjB;EAAE,GAAGD;EAAM,MAAM;EAAQ,MAAMC,EAAK,QAAQA,EAAK;CAAG,IACpD;EAAE,GAAGD;EAAM,MAAM;CAAS;AAChC;AAIA,SAAgBE,EACd,GACA,GACuC;CACvC,IAAMC,IAAgD,CAAC;CACvD,KAAK,IAAMC,KAAKC,EAAaC,EAAM,OAAOA,EAAM,KAAK,GAAG;EACtD,IAAMC,IAAKH,EAAE,IACPI,IAA4C;GAChD;GACA,MAAMJ,EAAE;GACR,OAAOA,EAAE;GACT,MAAMA,EAAE;GACR,MAAMA,EAAE;EACV;EAeA,AAdIA,EAAE,UAAU,SAAM,EAAI,SAASA,EAAE,SACjCA,EAAE,cAAc,aAAY,EAAI,YAAY,aACvCA,EAAE,aAAaA,EAAE,UAAU,SAAS,MAAG,EAAI,YAAYA,EAAE,YAC9DA,EAAE,aAAa,OAAO,EAAI,WAAW,KACrCA,EAAE,SAAS,eAAeA,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACnE,OAAO,OACLI,GACAC,EAASC,GAAUN,GAA+B,YAAY,MAAU;GACtE,MAAU,MACR,uBAAuBG,EAAG,QAAQI,EAAM,KAAK,MAAM,gHAErD;EACF,CAAC,CACH,GACAR,EAAM,KAAKK,CAAG;CAChB;CAYA,OAAO;EAAE,SAAS;EAAG,cAXAF,EAAM,OAAO,KAAK,MAAM;GAC3C,IAAMM,IAAiC,EAAE,IAAIC,EAAE,GAAG;GAQlD,OAPIA,EAAE,YAAY,OAAO,EAAM,UAAU,KACrCA,EAAE,WAAW,OAAM,EAAM,SAAS,KAClCA,EAAE,aAAU,EAAM,WAAWA,EAAE,WAC/BA,EAAE,SAAS,WACb,EAAM,OAAO,QACb,EAAM,OAAOA,EAAE,OAEVD;EACT,CACqB;EAAc;CAAM;AAC3C;AAMA,SAAgBE,EACd,GACA,GACqC;CACrC,IAAIC,EAAK,YAAY,GACnB,MAAU,MAAM,8BAA8BA,EAAK,QAAQ,oBAAoB;CAEjF,OAAOA,EAAK,MAAM,KAAK,MAAM;EAC3B,IAAMd,IAA0C;GAC9C,IAAIG,EAAE;GACN,MAAMA,EAAE;GACR,OAAOA,EAAE;GACT,MAAMA,EAAE;GACR,MAAMA,EAAE;EACV;EAIA,AAHIA,EAAE,WAAW,KAAA,MAAW,EAAK,SAASA,EAAE,SACxCA,EAAE,aAAa,KAAA,MAAW,EAAK,WAAWA,EAAE,WAC5CA,EAAE,UAAU,KAAA,MAAW,EAAK,QAAQA,EAAE,QACtCA,EAAE,cAAc,KAAA,MAClB,EAAK,YAAYA,EAAE,cAAc,aAC7B,aACCA,EAAE;EAET,IAAMY,IAAaZ;EACnB,KAAK,IAAMO,KAASM,GAAgB;GAClC,IAAMC,IAAMF,EAAWL,EAAM;GAC7B,IAAIO,MAAQ,KAAA,GAAW;GACvB,IAAMC,IAAMC,EAAST,EAAM,MAAM,GAA2CO;GAC5E,IAAI,CAACC,GACH,MAAU,MACR,kBAAkBR,EAAM,MAAM,QAAQO,EAAI,6DAE5C;GAEF,EAA6CP,EAAM,SAASQ;EAC9D;EACA,OAAOlB;CACT,CAAC;AACH"}

package/dist/core/scene/staleReplay.js

@@ -0,0 +1,51 @@
+//#region src/core/scene/staleReplay.ts
+var e = class extends Error {};
+function t(e) {
+	let t = 0, n = /* @__PURE__ */ new WeakMap(), r = (t) => t === null || e.has(t), i = (t, n) => {
+		let r = e.get(t);
+		return r?.kind !== "container" || r.children.every((e) => n?.has(e) === !0);
+	};
+	function a(t, n, a) {
+		switch (t) {
+			case "kit:add": {
+				let t = n;
+				return a ? e.has(t.id) || !r(t.parent) : !e.has(t.id) || !i(t.id);
+			}
+			case "kit:remove": {
+				let t = n;
+				if (!a) return t.nodes.some((t) => e.has(t.id)) || !t.detached.every((e) => r(e.parent));
+				let o = new Set(t.nodes.map((e) => e.id));
+				return !t.nodes.every((t) => e.has(t.id) && i(t.id, o));
+			}
+			case "kit:move": {
+				let t = n;
+				return !e.has(t.id) || !r(a ? t.toParent : t.fromParent);
+			}
+			case "kit:setPose":
+			case "kit:setData":
+			case "kit:setLayer":
+			case "kit:setDependsOn":
+			case "kit:setLayout":
+			case "kit:setUnits": return !e.has(n.id);
+			default: return !1;
+		}
+	}
+	function o(e, r, i) {
+		return t === 0 || typeof r != "object" || !r ? !1 : n.get(r) === !i ? n.delete(r) : a(e, r, i) ? (n.set(r, i), !0) : !1;
+	}
+	return {
+		during(e) {
+			t++;
+			try {
+				return e();
+			} finally {
+				t--;
+			}
+		},
+		skips: o
+	};
+}
+//#endregion
+export { e as SceneMembershipError, t as createStaleReplay };
+
+//# sourceMappingURL=staleReplay.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staleReplay.js","names":["SceneMembershipError","createStaleReplay","replaying","skipped","holds","id","nodes","childless","node","within","c","stale","kind","p","payload","forward","n","d","taken","skips","step"],"sources":["../../../src/core/scene/staleReplay.ts"],"sourcesContent":["/**\n * What a replay does with an op whose node is not where its entry left it.\n *\n * An untracked edit changes the tree without the history stack hearing of it,\n * so an entry can name a node that edit removed, or add one it already put\n * back. Replaying such an op is skipped rather than refused: a refusal leaves\n * the entry on top of its stack, and every entry beneath it out of reach. The\n * inverse of a skipped op is skipped too, so undo then redo changes nothing.\n */\nimport type { RemoveSnapshot } from './kitOps';\nimport type { Node, NodeId } from './types';\n\n/** A scene edit named a node the scene does not hold, or one it already does. */\nexport class SceneMembershipError extends Error {}\n\nexport interface StaleReplay {\n  /** Run a step that replays recorded ops. */\n  during<T>(step: () => T): T;\n  /** Whether replaying this kit op would address a node that is gone, or\n   *  restore one that is already there. Always false outside `during`. */\n  skips(kind: string, payload: unknown, forward: boolean): boolean;\n}\n\nexport function createStaleReplay<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n): StaleReplay {\n  let replaying = 0;\n  /** Kit payloads whose last replay was skipped, by the direction it ran in. */\n  const skipped = new WeakMap<object, boolean>();\n  const holds = (id: NodeId | null): boolean => id === null || nodes.has(id);\n  const childless = (id: NodeId, within?: ReadonlySet<NodeId>): boolean => {\n    const node = nodes.get(id);\n    return node?.kind !== 'container' || node.children.every((c) => within?.has(c) === true);\n  };\n\n  function stale(kind: string, payload: unknown, forward: boolean): boolean {\n    switch (kind) {\n      case 'kit:add': {\n        const p = payload as { id: NodeId; parent: NodeId | null };\n        return forward ? nodes.has(p.id) || !holds(p.parent) : !nodes.has(p.id) || !childless(p.id);\n      }\n      case 'kit:remove': {\n        const p = payload as RemoveSnapshot<TData, TLayer, TPose>;\n        if (!forward) return p.nodes.some((n) => nodes.has(n.id)) || !p.detached.every((d) => holds(d.parent));\n        const taken = new Set(p.nodes.map((n) => n.id));\n        return !p.nodes.every((n) => nodes.has(n.id) && childless(n.id, taken));\n      }\n      case 'kit:move': {\n        const p = payload as { id: NodeId; fromParent: NodeId | null; toParent: NodeId | null };\n        return !nodes.has(p.id) || !holds(forward ? p.toParent : p.fromParent);\n      }\n      case 'kit:setPose':\n      case 'kit:setData':\n      case 'kit:setLayer':\n      case 'kit:setDependsOn':\n      case 'kit:setLayout':\n      case 'kit:setUnits':\n        return !nodes.has((payload as { id: NodeId }).id);\n      default:\n        return false;\n    }\n  }\n\n  function skips(kind: string, payload: unknown, forward: boolean): boolean {\n    if (replaying === 0 || typeof payload !== 'object' || payload === null) return false;\n    if (skipped.get(payload) === !forward) return skipped.delete(payload);\n    if (!stale(kind, payload, forward)) return false;\n    skipped.set(payload, forward);\n    return true;\n  }\n\n  return {\n    during(step) {\n      replaying++;\n      try {\n        return step();\n      } finally {\n        replaying--;\n      }\n    },\n    skips,\n  };\n}\n"],"mappings":";AAaA,IAAaA,IAAb,cAA0C,MAAM,CAAC;AAUjD,SAAgBC,EACd,GACa;CACb,IAAIC,IAAY,GAEVC,oBAAU,IAAI,QAAyB,GACvCC,KAAS,MAA+BC,MAAO,QAAQC,EAAM,IAAID,CAAE,GACnEE,KAAa,GAAY,MAA0C;EACvE,IAAMC,IAAOF,EAAM,IAAID,CAAE;EACzB,OAAOG,GAAM,SAAS,eAAeA,EAAK,SAAS,OAAO,MAAMC,GAAQ,IAAIC,CAAC,MAAM,EAAI;CACzF;CAEA,SAASC,EAAM,GAAc,GAAkB,GAA2B;EACxE,QAAQC,GAAR;GACE,KAAK,WAAW;IACd,IAAMC,IAAIC;IACV,OAAOC,IAAUT,EAAM,IAAIO,EAAE,EAAE,KAAK,CAACT,EAAMS,EAAE,MAAM,IAAI,CAACP,EAAM,IAAIO,EAAE,EAAE,KAAK,CAACN,EAAUM,EAAE,EAAE;GAC5F;GACA,KAAK,cAAc;IACjB,IAAMA,IAAIC;IACV,IAAI,CAACC,GAAS,OAAOF,EAAE,MAAM,MAAM,MAAMP,EAAM,IAAIU,EAAE,EAAE,CAAC,KAAK,CAACH,EAAE,SAAS,OAAO,MAAMT,EAAMa,EAAE,MAAM,CAAC;IACrG,IAAMC,IAAQ,IAAI,IAAIL,EAAE,MAAM,KAAK,MAAMG,EAAE,EAAE,CAAC;IAC9C,OAAO,CAACH,EAAE,MAAM,OAAO,MAAMP,EAAM,IAAIU,EAAE,EAAE,KAAKT,EAAUS,EAAE,IAAIE,CAAK,CAAC;GACxE;GACA,KAAK,YAAY;IACf,IAAML,IAAIC;IACV,OAAO,CAACR,EAAM,IAAIO,EAAE,EAAE,KAAK,CAACT,EAAMW,IAAUF,EAAE,WAAWA,EAAE,UAAU;GACvE;GACA,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK,gBACH,OAAO,CAACP,EAAM,IAAKQ,EAA2B,EAAE;GAClD,SACE,OAAO;EACX;CACF;CAEA,SAASK,EAAM,GAAc,GAAkB,GAA2B;EAKxE,OAJIjB,MAAc,KAAK,OAAOY,KAAY,aAAYA,IAAyB,KAC3EX,EAAQ,IAAIW,CAAO,MAAM,CAACC,IAAgBZ,EAAQ,OAAOW,CAAO,IAC/DH,EAAMC,GAAME,GAASC,CAAO,KACjCZ,EAAQ,IAAIW,GAASC,CAAO,GACrB,MAFoC;CAG7C;CAEA,OAAO;EACL,OAAO,GAAM;GACX;GACA,IAAI;IACF,OAAOK,EAAK;GACd,UAAU;IACR;GACF;EACF;EACA;CACF;AACF"}

package/dist/core/scene/statedFields.js

@@ -0,0 +1,9 @@
+//#region src/core/scene/statedFields.ts
+var e = (e) => ({
+	...e.pickable === void 0 ? {} : { pickable: e.pickable },
+	...e.kind === "container" && e.units !== void 0 ? { units: e.units } : {}
+});
+//#endregion
+export { e as statedFields };
+
+//# sourceMappingURL=statedFields.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statedFields.js","names":["statedFields","n"],"sources":["../../../src/core/scene/statedFields.ts"],"sourcesContent":["import type { UnitScope } from '@weasel-js/quantity';\n\ninterface Stated { kind?: 'leaf' | 'container'; pickable?: boolean; units?: UnitScope }\n\n/** The plain optional fields of a node or spec as a spread for `scene.add`:\n *  each present only when stated, so an unstated one keeps the scene's\n *  default. A leaf states no `units`. */\nexport const statedFields = (n: Stated): { pickable?: boolean; units?: UnitScope } => ({\n  ...(n.pickable !== undefined ? { pickable: n.pickable } : {}),\n  ...(n.kind === 'container' && n.units !== undefined ? { units: n.units } : {}),\n});\n"],"mappings":";AAOA,IAAaA,KAAgB,OAA0D;CACrF,GAAIC,EAAE,aAAa,KAAA,IAAuC,CAAC,IAA5B,EAAE,UAAUA,EAAE,SAAS;CACtD,GAAIA,EAAE,SAAS,eAAeA,EAAE,UAAU,KAAA,IAAY,EAAE,OAAOA,EAAE,MAAM,IAAI,CAAC;AAC9E"}

package/dist/core/scene/treeEdits.js

@@ -0,0 +1,127 @@
+import { fnKeysOf as e } from "./nodeFnFields.js";
+import { statedFields as t } from "./statedFields.js";
+import { SceneMembershipError as n } from "./staleReplay.js";
+//#region src/core/scene/treeEdits.ts
+function r(t, n, r, i) {
+	let a = t.map((e) => {
+		let t = r.requireNode(e);
+		return t.kind === "container" ? {
+			...t,
+			children: [...t.children]
+		} : { ...t };
+	}), o = a.filter((e) => e.parent === null || !n.has(e.parent)).map((e) => ({
+		id: e.id,
+		parent: e.parent,
+		index: r.siblingsOf(e.parent).indexOf(e.id)
+	})).sort((e, t) => e.index - t.index), s = a.flatMap((t) => {
+		let n = e(i, t, "opKey");
+		return Object.keys(n).length === 0 ? [] : [{
+			id: t.id,
+			...n
+		}];
+	});
+	return {
+		nodes: a,
+		detached: o,
+		...s.length > 0 ? { fnKeys: s } : {}
+	};
+}
+function i(i) {
+	let { nodes: a, fnFields: o } = i, { requireNode: s, siblingsOf: c, descendants: l, removalClosure: u, patchNodeFunctions: d } = i.store, { refuse: f, refuseLayer: p } = i.locks, { requireLayerIndex: m, assertSubtreeLayer: h } = i.layers, { record: g, edit: _ } = i.recorder, { noteArrival: v, noteDeparture: y, noteChange: b } = i.arrivals;
+	function x(r) {
+		let l = r.id ?? i.generateId();
+		if (a.has(l)) throw new n(`Scene: id collision on "${l}"`);
+		m(r.layer), p(r.layer, "add to");
+		let u = r.parent ?? null;
+		if (u !== null) {
+			let e = s(u);
+			if (e.kind !== "container") throw Error(`Scene: parent "${u}" is not a container`);
+			h(r.id, r.layer, u, e.layer), f(u, "add under");
+		}
+		return {
+			id: l,
+			kind: r.kind,
+			layer: r.layer,
+			pose: r.pose,
+			data: r.data,
+			parent: u,
+			index: r.index ?? c(u).length,
+			...r.dependsOn === void 0 ? {} : { dependsOn: r.dependsOn },
+			...t(r),
+			...e(o, {
+				...r,
+				id: l,
+				kind: r.kind
+			}, "opKey")
+		};
+	}
+	function S(e) {
+		if (e.length === 0) return;
+		let { ids: t, removing: n } = u(e);
+		for (let e of t) f(e, "remove");
+		let a = r(t, n, i.store, o), { detached: s } = a;
+		_("remove", s.some((e) => e.parent !== null), () => {
+			for (let e of s) y(e.id, e.parent, null);
+			g("kit:remove", a, "remove");
+		});
+	}
+	return {
+		construct(e) {
+			i.locks.lifted(() => {
+				for (let t of e) {
+					let e = x(t);
+					i.runOp("kit:add", e), d(t, e.id, null);
+				}
+			});
+		},
+		add(e) {
+			let t = x(e), n = `add ${e.kind}`;
+			return _(n, t.parent !== null, () => (v(t.id, t.parent, null), g("kit:add", t, n), d(e, t.id, t), t.id));
+		},
+		remove: (e) => S([e]),
+		removalClosure: (e) => u(e).ids,
+		removeMany: S,
+		move(e, t, n) {
+			let r = s(e);
+			if (f(e, "move"), t !== null) {
+				f(t, "move nodes into");
+				let n = s(t);
+				if (n.kind !== "container") throw Error(`Scene: parent "${t}" is not a container`);
+				if (h(e, r.layer, t, n.layer), t === e) throw Error("Scene: cannot parent a node to itself");
+				let i = [];
+				if (l(e, i), i.includes(t)) throw Error("Scene: cannot parent a node to its own descendant");
+			}
+			let i = r.parent;
+			_("move", t !== null || i !== null, () => {
+				let r = c(i).indexOf(e), a = n ?? c(t).length;
+				v(e, t, i), y(e, i, t), b(i), g("kit:move", {
+					id: e,
+					fromParent: i,
+					fromIndex: r,
+					toParent: t,
+					toIndex: a
+				}, "move");
+			});
+		},
+		reorder(e, t) {
+			let n = s(e);
+			f(e, "reorder");
+			let r = n.parent;
+			_("reorder", r !== null, () => {
+				b(r);
+				let n = c(r).indexOf(e);
+				g("kit:move", {
+					id: e,
+					fromParent: r,
+					fromIndex: n,
+					toParent: r,
+					toIndex: t
+				}, "reorder");
+			});
+		}
+	};
+}
+//#endregion
+export { i as createTreeEdits };
+
+//# sourceMappingURL=treeEdits.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeEdits.js","names":["removeSnapshot","nodes","ids","n","store","nid","detached","removing","l","r","fnKeys","keys","fnKeysOf","fnFields","createTreeEdits","env","addPayload","id","spec","SceneMembershipError","requireLayerIndex","refuseLayer","parent","p","requireNode","assertSubtreeLayer","refuse","siblingsOf","statedFields","removeMany","rootIds","removalClosure","payload","d","specs","patchNodeFunctions","label","edit","noteArrival","record","node","desc","descendants","fromParent","fromIndex","toIndex","index","noteDeparture","noteChange"],"sources":["../../../src/core/scene/treeEdits.ts"],"sourcesContent":["/**\n * The scene's edits to its tree: adding and removing nodes, reparenting, and\n * reordering siblings. Each checks its arguments, then records one kit op.\n */\nimport type { ArrivalWindow } from './arrivalWindow';\nimport type { RemoveSnapshot } from './kitOps';\nimport type { createLayerStack } from './layerStack';\nimport type { LockGuard } from './lockGuard';\nimport { fnKeysOf, type FnBearingNode, type NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type { Recorder } from './recorder';\nimport { SceneMembershipError } from './staleReplay';\nimport { statedFields } from './statedFields';\nimport type { AddNodeSpec, Node, NodeId, Scene } from './types';\n\nexport interface TreeEditsEnv<TData, TLayer extends string, TPose> {\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  generateId(): NodeId;\n  store: Pick<\n    ReturnType<typeof createNodeStore<TData, TLayer, TPose>>,\n    'requireNode' | 'siblingsOf' | 'descendants' | 'removalClosure' | 'patchNodeFunctions'\n  >;\n  locks: Pick<LockGuard<TLayer>, 'refuse' | 'refuseLayer' | 'lifted'>;\n  layers: Pick<ReturnType<typeof createLayerStack<TLayer>>, 'requireLayerIndex' | 'assertSubtreeLayer'>;\n  fnFields: readonly NodeFnField[];\n  /** Run a registered op without recording it. */\n  runOp(kind: string, payload: unknown): void;\n  recorder: Pick<Recorder, 'record' | 'edit'>;\n  arrivals: Pick<ArrivalWindow<TPose>, 'noteArrival' | 'noteDeparture' | 'noteChange'>;\n}\n\nexport interface TreeEdits<TData, TLayer extends string, TPose>\n  extends Pick<Scene<TData, TLayer, TPose>, 'add' | 'remove' | 'removalClosure' | 'removeMany' | 'move' | 'reorder'> {\n  /** Place nodes as the document a scene starts from, or is loaded with:\n   *  nothing is recorded, and no lock refuses. Specs list parents before\n   *  children, the order `toJSON()` emits. */\n  construct(specs: readonly AddNodeSpec<TData, TLayer, TPose>[]): void;\n}\n\n/** What `kit:remove` carries for the nodes `ids`, read before any of them\n *  goes. Throws on an id that is not in the scene. */\nfunction removeSnapshot<TData, TLayer extends string, TPose>(\n  ids: readonly NodeId[],\n  removing: ReadonlySet<NodeId>,\n  store: Pick<TreeEditsEnv<TData, TLayer, TPose>['store'], 'requireNode' | 'siblingsOf'>,\n  fnFields: readonly NodeFnField[],\n): RemoveSnapshot<TData, TLayer, TPose> {\n  const nodes: Node<TData, TLayer, TPose>[] = ids.map((nid) => {\n    const n = store.requireNode(nid);\n    return n.kind === 'container' ? { ...n, children: [...n.children] } : { ...n };\n  });\n  // The rest is reachable through a snapshotted parent's cloned `children`.\n  const detached = nodes\n    .filter((n) => n.parent === null || !removing.has(n.parent))\n    .map((n) => ({ id: n.id, parent: n.parent, index: store.siblingsOf(n.parent).indexOf(n.id) }))\n    .sort((l, r) => l.index - r.index);\n  const fnKeys = nodes.flatMap((n) => {\n    const keys = fnKeysOf(fnFields, n as unknown as FnBearingNode, 'opKey');\n    return Object.keys(keys).length === 0 ? [] : [{ id: n.id, ...keys }];\n  });\n  return { nodes, detached, ...(fnKeys.length > 0 ? { fnKeys } : {}) };\n}\n\nexport function createTreeEdits<TData, TLayer extends string, TPose>(\n  env: TreeEditsEnv<TData, TLayer, TPose>,\n): TreeEdits<TData, TLayer, TPose> {\n  const { nodes, fnFields } = env;\n  const { requireNode, siblingsOf, descendants, removalClosure, patchNodeFunctions } = env.store;\n  const { refuse, refuseLayer } = env.locks;\n  const { requireLayerIndex, assertSubtreeLayer } = env.layers;\n  const { record, edit } = env.recorder;\n  const { noteArrival, noteDeparture, noteChange } = env.arrivals;\n\n  /** Check that `spec` can be placed, and answer with the `kit:add` payload\n   *  that places it. Throws on an id collision, an unknown or locked layer,\n   *  a parent that is not a container or is locked, and a layer below the\n   *  parent's. */\n  function addPayload(spec: AddNodeSpec<TData, TLayer, TPose>) {\n    const id = spec.id ?? env.generateId();\n    if (nodes.has(id)) throw new SceneMembershipError(`Scene: id collision on \"${id}\"`);\n    requireLayerIndex(spec.layer);\n    refuseLayer(spec.layer, 'add to');\n    const parent = spec.parent ?? null;\n    if (parent !== null) {\n      const p = requireNode(parent);\n      if (p.kind !== 'container') {\n        throw new Error(`Scene: parent \"${parent}\" is not a container`);\n      }\n      assertSubtreeLayer(spec.id, spec.layer, parent, p.layer);\n      refuse(parent, 'add under');\n    }\n    return {\n      id, kind: spec.kind, layer: spec.layer, pose: spec.pose, data: spec.data,\n      parent, index: spec.index ?? siblingsOf(parent).length,\n      ...(spec.dependsOn !== undefined ? { dependsOn: spec.dependsOn } : {}),\n      ...statedFields(spec),\n      ...fnKeysOf(fnFields, { ...spec, id, kind: spec.kind } as unknown as FnBearingNode, 'opKey'),\n    };\n  }\n\n  function removeMany(rootIds: readonly NodeId[]): void {\n    if (rootIds.length === 0) return;\n    // Every id resolves against the pre-removal tree, so an id another one\n    // cascades away is absorbed rather than being a second, failing removal.\n    const { ids, removing } = removalClosure(rootIds);\n    for (const nid of ids) refuse(nid, 'remove');\n    const payload = removeSnapshot(ids, removing, env.store, fnFields);\n    const { detached } = payload;\n    edit('remove', detached.some((d) => d.parent !== null), () => {\n      for (const d of detached) noteDeparture(d.id, d.parent, null);\n      record('kit:remove', payload, 'remove');\n    });\n  }\n\n  return {\n    construct(specs) {\n      env.locks.lifted(() => {\n        for (const spec of specs) {\n          const payload = addPayload(spec);\n          env.runOp('kit:add', payload);\n          patchNodeFunctions(spec, payload.id, null);\n        }\n      });\n    },\n\n    add(spec) {\n      const payload = addPayload(spec);\n      const label = `add ${spec.kind}`;\n      return edit(label, payload.parent !== null, () => {\n        noteArrival(payload.id, payload.parent, null);\n        record('kit:add', payload, label);\n        patchNodeFunctions(spec, payload.id, payload);\n        return payload.id;\n      });\n    },\n\n    remove: (id) => removeMany([id]),\n\n    removalClosure: (rootIds) => removalClosure(rootIds).ids,\n\n    removeMany,\n\n    move(id, parent, index) {\n      const node = requireNode(id);\n      refuse(id, 'move');\n      if (parent !== null) {\n        refuse(parent, 'move nodes into');\n        const p = requireNode(parent);\n        if (p.kind !== 'container') {\n          throw new Error(`Scene: parent \"${parent}\" is not a container`);\n        }\n        assertSubtreeLayer(id, node.layer, parent, p.layer);\n        if (parent === id) throw new Error('Scene: cannot parent a node to itself');\n        const desc: NodeId[] = [];\n        descendants(id, desc);\n        if (desc.includes(parent)) {\n          throw new Error('Scene: cannot parent a node to its own descendant');\n        }\n      }\n      const fromParent = node.parent;\n      edit('move', parent !== null || fromParent !== null, () => {\n        const fromIndex = siblingsOf(fromParent).indexOf(id);\n        const toIndex = index ?? siblingsOf(parent).length;\n        noteArrival(id, parent, fromParent);\n        noteDeparture(id, fromParent, parent);\n        noteChange(fromParent);\n        record('kit:move', { id, fromParent, fromIndex, toParent: parent, toIndex }, 'move');\n      });\n    },\n\n    reorder(id, index) {\n      const node = requireNode(id);\n      refuse(id, 'reorder');\n      const parent = node.parent;\n      edit('reorder', parent !== null, () => {\n        noteChange(parent);\n        const fromIndex = siblingsOf(parent).indexOf(id);\n        record('kit:move', { id, fromParent: parent, fromIndex, toParent: parent, toIndex: index }, 'reorder');\n      });\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/treeOrder.js

@@ -0,0 +1,13 @@
+//#region src/core/scene/treeOrder.ts
+function e(e, t) {
+	let n = [], r = [...e].reverse();
+	for (; r.length > 0;) {
+		let e = t.get(r.pop());
+		if (e && (n.push(e), e.kind === "container")) for (let t = e.children.length - 1; t >= 0; t--) r.push(e.children[t]);
+	}
+	return n;
+}
+//#endregion
+export { e as treePreorder };
+
+//# sourceMappingURL=treeOrder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeOrder.js","names":["treePreorder","out","stack","roots","node","nodes","i"],"sources":["../../../src/core/scene/treeOrder.ts"],"sourcesContent":["import type { Node, NodeId } from './types';\n\n/** Every node reachable from `roots`, in tree preorder: a parent before its\n *  children, siblings in sibling order, whatever layer each sits on. */\nexport function treePreorder<TData, TLayer extends string, TPose>(\n  roots: readonly NodeId[],\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n): Node<TData, TLayer, TPose>[] {\n  const out: Node<TData, TLayer, TPose>[] = [];\n  const stack: NodeId[] = [...roots].reverse();\n  while (stack.length > 0) {\n    const node = nodes.get(stack.pop()!);\n    if (!node) continue;\n    out.push(node);\n    if (node.kind === 'container') {\n      for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);\n    }\n  }\n  return out;\n}\n"],"mappings":";AAIA,SAAgBA,EACd,GACA,GAC8B;CAC9B,IAAMC,IAAoC,CAAC,GACrCC,IAAkB,CAAC,GAAGC,CAAK,CAAC,CAAC,QAAQ;CAC3C,OAAOD,EAAM,SAAS,IAAG;EACvB,IAAME,IAAOC,EAAM,IAAIH,EAAM,IAAI,CAAE;EACnC,IAAKE,MACLH,EAAI,KAAKG,CAAI,GACTA,EAAK,SAAS,cAChB,KAAK,IAAIE,IAAIF,EAAK,SAAS,SAAS,GAAGE,KAAK,GAAG,KAAK,EAAM,KAAKF,EAAK,SAASE,EAAE;CAEnF;CACA,OAAOL;AACT"}

package/dist/core/scene/treeReads.js

@@ -0,0 +1,26 @@
+//#region src/core/scene/treeReads.ts
+function e(e) {
+	let t = /* @__PURE__ */ new WeakMap(), n = 1;
+	return {
+		get: (t) => e.get(t),
+		incarnation(r) {
+			let i = e.get(r);
+			if (!i) return;
+			let a = t.get(i);
+			return a === void 0 && (a = n++, t.set(i, a)), a;
+		},
+		childrenOf(t) {
+			let n = e.get(t);
+			return n && n.kind === "container" ? n.children : [];
+		},
+		ancestorsOf(t) {
+			let n = [], r = e.get(t)?.parent ?? null;
+			for (; r !== null;) n.push(r), r = e.get(r)?.parent ?? null;
+			return n;
+		}
+	};
+}
+//#endregion
+export { e as createTreeReads };
+
+//# sourceMappingURL=treeReads.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeReads.js","names":["createTreeReads","incarnations","nextIncarnation","nodes","id","node","token","out","cur"],"sources":["../../../src/core/scene/treeReads.ts"],"sourcesContent":["/** The scene's reads of one node and its place in the tree. */\nimport type { Node, NodeId, Scene } from './types';\n\nexport function createTreeReads<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n): Pick<Scene<TData, TLayer, TPose>, 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf'> {\n  // Keyed by node object: every entry into `nodes` is a fresh object and\n  // every edit mutates it in place, which is exactly an incarnation's lifetime.\n  const incarnations = new WeakMap<object, number>();\n  let nextIncarnation = 1;\n\n  return {\n    get: (id) => nodes.get(id),\n\n    incarnation(id) {\n      const node = nodes.get(id);\n      if (!node) return undefined;\n      let token = incarnations.get(node);\n      if (token === undefined) {\n        token = nextIncarnation++;\n        incarnations.set(node, token);\n      }\n      return token;\n    },\n\n    childrenOf(id) {\n      const n = nodes.get(id);\n      return n && n.kind === 'container' ? n.children : [];\n    },\n\n    ancestorsOf(id) {\n      const out: NodeId[] = [];\n      let cur = nodes.get(id)?.parent ?? null;\n      while (cur !== null) {\n        out.push(cur);\n        cur = nodes.get(cur)?.parent ?? null;\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AAGA,SAAgBA,EACd,GACyF;CAGzF,IAAMC,oBAAe,IAAI,QAAwB,GAC7CC,IAAkB;CAEtB,OAAO;EACL,MAAM,MAAOC,EAAM,IAAIC,CAAE;EAEzB,YAAY,GAAI;GACd,IAAMC,IAAOF,EAAM,IAAIC,CAAE;GACzB,IAAI,CAACC,GAAM;GACX,IAAIC,IAAQL,EAAa,IAAII,CAAI;GAKjC,OAJIC,MAAU,KAAA,MACZ,IAAQ,KACRL,EAAa,IAAII,GAAMC,CAAK,IAEvBA;EACT;EAEA,WAAW,GAAI;GACb,IAAM,IAAIH,EAAM,IAAIC,CAAE;GACtB,OAAO,KAAK,EAAE,SAAS,cAAc,EAAE,WAAW,CAAC;EACrD;EAEA,YAAY,GAAI;GACd,IAAMG,IAAgB,CAAC,GACnBC,IAAML,EAAM,IAAIC,CAAE,CAAC,EAAE,UAAU;GACnC,OAAOI,MAAQ,OAEb,AADAD,EAAI,KAAKC,CAAG,GACZ,IAAML,EAAM,IAAIK,CAAG,CAAC,EAAE,UAAU;GAElC,OAAOD;EACT;CACF;AACF"}