@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/scene/scenePoseAdapter.js

@@ -1,16 +1,20 @@
-import { definesFrame as e, documentPose as t } from "./effectivePose.js";
+import { definesFrame, documentPose } from "./effectivePose.js";
+
 //#region src/core/scene/scenePoseAdapter.ts
-function n(n) {
+/** Build a `PoseAdapter` over a `Scene` for `composePose` helpers.
+*  `getParent` returns the live parent at call time so mid-batch
+*  parent updates compose correctly. */
+function scenePoseAdapter(scene) {
 	return {
-		getPose: (e) => t(n, n.get(e)),
-		getParent: (e) => n.get(e)?.parent ?? null,
-		definesFrame: (t) => {
-			let r = n.get(t);
-			return r === void 0 || e(r);
+		getPose: (id) => documentPose(scene, scene.get(id)),
+		getParent: (id) => scene.get(id)?.parent ?? null,
+		definesFrame: (id) => {
+			const node = scene.get(id);
+			return node === void 0 || definesFrame(node);
 		}
 	};
 }
-//#endregion
-export { n as scenePoseAdapter };
 
+//#endregion
+export { scenePoseAdapter };
 //# sourceMappingURL=scenePoseAdapter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"scenePoseAdapter.js","names":["scenePoseAdapter","documentPose","scene","id","node","definesFrame"],"sources":["../../../src/core/scene/scenePoseAdapter.ts"],"sourcesContent":["import { definesFrame, documentPose } from 'core/scene/effectivePose';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseAdapter } from './composePose';\n\n/** Build a `PoseAdapter` over a `Scene` for `composePose` helpers.\n *  `getParent` returns the live parent at call time so mid-batch\n *  parent updates compose correctly. */\nexport function scenePoseAdapter(\n  scene: Scene<unknown, string, unknown>,\n): PoseAdapter<unknown> {\n  return {\n    getPose: (id) => documentPose(scene, scene.get(id as NodeId)!),\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n}\n"],"mappings":";;AAOA,SAAgBA,EACd,GACsB;CACtB,OAAO;EACL,UAAU,MAAOC,EAAaC,GAAOA,EAAM,IAAIC,CAAY,CAAE;EAC7D,YAAY,MAAOD,EAAM,IAAIC,CAAY,CAAC,EAAE,UAAU;EACtD,eAAe,MAAO;GACpB,IAAMC,IAAOF,EAAM,IAAIC,CAAY;GACnC,OAAOC,MAAS,KAAA,KAAaC,EAAaD,CAAI;EAChD;CACF;AACF"}
+{"version":3,"file":"scenePoseAdapter.js","names":[],"sources":["../../../src/core/scene/scenePoseAdapter.ts"],"sourcesContent":["import { definesFrame, documentPose } from 'core/scene/effectivePose';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseAdapter } from './composePose';\n\n/** Build a `PoseAdapter` over a `Scene` for `composePose` helpers.\n *  `getParent` returns the live parent at call time so mid-batch\n *  parent updates compose correctly. */\nexport function scenePoseAdapter(\n  scene: Scene<unknown, string, unknown>,\n): PoseAdapter<unknown> {\n  return {\n    getPose: (id) => documentPose(scene, scene.get(id as NodeId)!),\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n}\n"],"mappings":";;;;;;AAOA,SAAgB,iBACd,OACsB;CACtB,OAAO;EACL,UAAU,OAAO,aAAa,OAAO,MAAM,IAAI,EAAY,CAAE;EAC7D,YAAY,OAAO,MAAM,IAAI,EAAY,CAAC,EAAE,UAAU;EACtD,eAAe,OAAO;GACpB,MAAM,OAAO,MAAM,IAAI,EAAY;GACnC,OAAO,SAAS,UAAa,aAAa,IAAI;EAChD;CACF;AACF"}

package/dist/core/scene/sceneRecording.js

@@ -1,91 +1,124 @@
-import { createHistory as e } from "../ops/createHistory.js";
-import { createAppliedLog as t } from "./appliedLog.js";
-import { createSceneHistory as n } from "./historyFacade.js";
-import { createOpTable as r } from "./opTable.js";
-import { createOuterOps as i } from "./outerOps.js";
-import { createRecorder as a } from "./recorder.js";
+import { createHistory } from "../ops/createHistory.js";
+import { createAppliedLog } from "./appliedLog.js";
+import { createEditPasses } from "./editPass.js";
+import { createSceneHistory } from "./historyFacade.js";
+import { createOpTable } from "./opTable.js";
+import { createOuterOps } from "./outerOps.js";
+import { createRecorder } from "./recorder.js";
+
 //#region src/core/scene/sceneRecording.ts
-function o(o) {
-	let { notifier: s, mode: c, stale: l, lifted: u, selection: d, arrivals: f, config: p } = o, { notify: m } = s, h = r({
-		driven: c.open,
-		replayAlone: (e) => {
-			w(e), m();
+function createSceneRecording(env) {
+	const { notifier, mode, stale, lifted, selection, arrivals, config, poseWrites } = env;
+	const { notify } = notifier;
+	const passes = createEditPasses({
+		adapter: env.passAdapter,
+		untracked: mode.untracked
+	});
+	/** Run an op-driven edit with its arrivals settled and its passes run at
+	*  its end, in the same entry, when this call owns them. */
+	const runEdit = (ops, run) => arrivals.runEdit(ops, (all) => {
+		if (!passes.open()) return run(all);
+		try {
+			run([...all, passes.op()]);
+		} finally {
+			passes.abandon();
+		}
+	});
+	const ops = createOpTable({
+		driven: mode.open,
+		replayAlone: (step) => {
+			replay(step);
+			notify();
 		},
-		skips: l.skips,
-		applied: (e, t, n) => {
-			c.records() || b(e, t, n);
+		skips: stale.skips,
+		applied: (kind, payload, reverted) => {
+			if (!mode.records()) logApplied(kind, payload, reverted);
 		}
-	}), g = i({
-		own: (e, t) => h.handlers.has(e) ? h.op(e, t) : null,
-		recorder: () => x,
-		driving: (e) => s.deferred(() => c.during("engine", () => y(e, () => !0))),
-		getActiveJournal: p.getActiveJournal ?? null
-	}), _ = e(void 0, {
+	});
+	const outer = createOuterOps({
+		own: (name, args) => ops.handlers.has(name) ? ops.op(name, args) : null,
+		recorder: () => recorder,
+		driving: (step) => notifier.deferred(() => mode.during("engine", () => atomically(step, () => true))),
+		getActiveJournal: config.getActiveJournal ?? null
+	});
+	const engine = createHistory(void 0, {
 		selection: {
-			get: d.get,
-			set: (e) => d.set(e)
+			get: selection.get,
+			set: (ids) => selection.set(ids)
 		},
-		...p.coalesceWindowMs === void 0 ? {} : { coalesceWindowMs: p.coalesceWindowMs },
-		...p.historyLimit === void 0 ? {} : { historyLimit: p.historyLimit },
-		rebuildOp: g.rebuild
-	}), v = t({
-		registered: h.handlers,
-		lifted: u,
-		getSelection: d.get,
-		setSelection: d.replace,
-		notify: m
-	}), { atomically: y, logApplied: b } = v, x = a({
-		notifier: s,
-		mode: c,
-		engine: _,
-		runOp: h.run,
-		makeOp: h.op,
-		log: v,
-		arrivals: f,
-		selection: d.get,
-		writePose: o.writePose
-	}), { record: S, engineDriven: C } = x;
-	function w(e) {
-		y(() => u(() => l.during(() => C(e))), () => !0);
+		...config.coalesceWindowMs !== void 0 ? { coalesceWindowMs: config.coalesceWindowMs } : {},
+		...config.historyLimit !== void 0 ? { historyLimit: config.historyLimit } : {},
+		rebuildOp: outer.rebuild
+	});
+	const log = createAppliedLog({
+		registered: ops.handlers,
+		lifted,
+		getSelection: selection.get,
+		setSelection: selection.replace,
+		notify
+	});
+	const { atomically, logApplied } = log;
+	const recorder = createRecorder({
+		notifier,
+		mode,
+		engine,
+		runOp: ops.run,
+		makeOp: ops.op,
+		log,
+		arrivals,
+		passes,
+		selection: selection.get,
+		writePose: env.writePose,
+		labeled: poseWrites.labeled
+	});
+	const { record, engineDriven } = recorder;
+	/** Run an engine step that replays recorded ops — undo, redo, goto, a
+	*  journal stepping. The engine inverts whole ops when one throws; this
+	*  also reverts the scene writes of the op that threw partway. */
+	function replay(step) {
+		poseWrites.replaying(() => atomically(() => lifted(() => stale.during(() => engineDriven(step))), () => true));
 	}
-	function T(e) {
-		if (c.untracked()) throw Error(`Scene: cannot ${e} inside untracked() — it records`);
+	function refuseUntracked(verb) {
+		if (mode.untracked()) throw new Error(`Scene: cannot ${verb} inside untracked() — it records`);
 	}
-	let { history: E, methods: D } = n({
-		engine: _,
-		applying: (e) => y(() => C(e), () => !0),
-		causing: g.causing,
-		replay: w,
-		notify: m,
-		refuseUntracked: T,
-		runArrivalEdit: f.runEdit,
-		activeJournal: g.activeJournal
+	const { history, methods } = createSceneHistory({
+		engine,
+		applying: (step) => atomically(() => engineDriven(step), () => true),
+		causing: outer.causing,
+		replay,
+		notify,
+		refuseUntracked,
+		runArrivalEdit: runEdit,
+		labeled: (label, fn) => poseWrites.labeled(label, "ops", fn),
+		activeJournal: outer.activeJournal
 	});
 	return {
-		ops: h,
-		recorder: x,
-		clearHistory: () => _.clear(),
+		ops,
+		recorder,
+		clearHistory: () => engine.clear(),
 		methods: {
-			registerOp(e, t) {
-				if (e.startsWith("kit:")) throw Error(`Scene: op kind "${e}" is reserved (kit:* prefix)`);
-				h.register(e, t);
+			registerOp(kind, handler) {
+				if (kind.startsWith("kit:")) throw new Error(`Scene: op kind "${kind}" is reserved (kit:* prefix)`);
+				ops.register(kind, handler);
 			},
-			recordOp(e) {
-				S(e.kind, e.payload, e.kind);
+			recordOp(op) {
+				record(op.kind, op.payload, op.kind);
 			},
-			applyBatch(e, t, n) {
-				return T("applyBatch"), f.runEdit(e, (e) => g.apply(_, e, t, n));
+			applyBatch(batch, label, adapter) {
+				refuseUntracked("applyBatch");
+				return poseWrites.labeled(label, "ops", () => runEdit(batch, (all) => outer.apply(engine, all, label, adapter)));
 			},
-			history: E,
-			...D,
-			batch: x.batch,
-			untracked: x.untracked,
-			setActiveJournalAccessor: g.setActiveJournalAccessor,
-			setHistoryAdapter: g.setHistoryAdapter
+			history,
+			...methods,
+			batch: recorder.batch,
+			untracked: recorder.untracked,
+			setActiveJournalAccessor: outer.setActiveJournalAccessor,
+			setHistoryAdapter: outer.setHistoryAdapter,
+			addEditPass: passes.add
 		}
 	};
 }
-//#endregion
-export { o as createSceneRecording };
 
+//#endregion
+export { createSceneRecording };
 //# sourceMappingURL=sceneRecording.js.map

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

@@ -1 +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    activeJournal: outer.activeJournal,\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;EACzB,eAAenB,EAAM;CACvB,CAAC;CAED,OAAO;EACL;EACA;EACA,oBAAoBO,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"}
+{"version":3,"file":"sceneRecording.js","names":[],"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 type { Op } from 'core/ops/types';\nimport { createHistory } from 'core/ops/createHistory';\nimport { createAppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport type { EditMode } from './editMode';\nimport { createEditPasses } from './editPass';\nimport { createSceneHistory, type SceneHistoryMethods } from './historyFacade';\nimport type { Notifier } from './notifier';\nimport type { PoseWriteLog } from './poseWrites';\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  /** The adapter an edit pass's ops apply through. */\n  passAdapter(): unknown;\n  writePose(id: string, pose: unknown): void;\n  poseWrites: Pick<PoseWriteLog<unknown>, 'labeled' | 'replaying'>;\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' | 'addEditPass'\n  >;\n}\n\nexport function createSceneRecording(env: SceneRecordingEnv): SceneRecording {\n  const { notifier, mode, stale, lifted, selection, arrivals, config, poseWrites } = env;\n  const { notify } = notifier;\n  const passes = createEditPasses({ adapter: env.passAdapter, untracked: mode.untracked });\n\n  /** Run an op-driven edit with its arrivals settled and its passes run at\n   *  its end, in the same entry, when this call owns them. */\n  const runEdit = (ops: Op[], run: (ops: Op[]) => void): boolean => arrivals.runEdit(ops, (all) => {\n    if (!passes.open()) return run(all);\n    try {\n      run([...all, passes.op()]);\n    } finally {\n      passes.abandon();\n    }\n  });\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    passes,\n    selection: selection.get,\n    writePose: env.writePose,\n    labeled: poseWrites.labeled,\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    poseWrites.replaying(() => 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: runEdit,\n    labeled: (label, fn) => poseWrites.labeled(label, 'ops', fn),\n    activeJournal: outer.activeJournal,\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 poseWrites.labeled(label, 'ops', () =>\n          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      addEditPass: passes.add,\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/sceneSelection.js

@@ -1,28 +1,38 @@
-import { createEmitter as e } from "@weasel-js/registry";
+import { createEmitter } from "@weasel-js/registry";
+
 //#region src/core/scene/sceneSelection.ts
-function t(t) {
-	let n = [], r = e();
+function createSceneSelection(reachable) {
+	let ids = [];
+	let changes = 0;
+	const changed = createEmitter();
 	return {
-		get: () => n,
-		set(e) {
-			n = t(e), r.emit();
+		get: () => ids,
+		set(next) {
+			ids = reachable(next);
+			changes++;
+			changed.emit();
 		},
-		narrow(e) {
-			n = t(e !== void 0 && n.some((t) => e.has(t)) ? n.filter((t) => !e.has(t)) : n);
+		narrow(gone) {
+			ids = reachable(gone !== void 0 && ids.some((id) => gone.has(id)) ? ids.filter((id) => !gone.has(id)) : ids);
 		},
-		replace(e) {
-			n = e;
+		replace(next) {
+			ids = next;
 		},
-		subscribe: r.subscribe
+		subscribe: changed.subscribe,
+		changes: () => changes
 	};
 }
-function n(e) {
+/** The scene's selection in the shape `createHistory` wants, for a consumer
+*  building a second History over the same scene (a modality machine, a
+*  journal owner) that should restore selection the way the scene's own
+*  history does. */
+function sceneSelectionStore(scene) {
 	return {
-		get: () => e.getSelection(),
-		set: (t) => e.setSelection(t)
+		get: () => scene.getSelection(),
+		set: (ids) => scene.setSelection(ids)
 	};
 }
-//#endregion
-export { t as createSceneSelection, n as sceneSelectionStore };
 
+//#endregion
+export { createSceneSelection, sceneSelectionStore };
 //# sourceMappingURL=sceneSelection.js.map

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

@@ -1 +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"}
+{"version":3,"file":"sceneSelection.js","names":[],"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  /** How many times subscribers have been told the selection changed. */\n  changes(): number;\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  let changes = 0;\n  const changed = createEmitter();\n\n  return {\n    get: () => ids,\n    set(next) {\n      ids = reachable(next);\n      changes++;\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    changes: () => changes,\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":";;;AAuBA,SAAgB,qBAEd,WACgB;CAChB,IAAI,MAAyB,CAAC;CAC9B,IAAI,UAAU;CACd,MAAM,UAAU,cAAc;CAE9B,OAAO;EACL,WAAW;EACX,IAAI,MAAM;GACR,MAAM,UAAU,IAAI;GACpB;GACA,QAAQ,KAAK;EACf;EACA,OAAO,MAAM;GAGX,MAAM,UADO,SAAS,UAAa,IAAI,MAAM,OAAO,KAAK,IAAI,EAAE,CAAC,IAAI,IAAI,QAAQ,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,GACpF;EACtB;EACA,QAAQ,MAAM;GACZ,MAAM;EACR;EACA,WAAW,QAAQ;EACnB,eAAe;CACjB;AACF;;;;;AAMA,SAAgB,oBAAoB,OAGf;CACnB,OAAO;EACL,WAAW,MAAM,aAAa;EAC9B,MAAM,QAAQ,MAAM,aAAa,GAAwB;CAC3D;AACF"}

package/dist/core/scene/sceneState.js

@@ -1,49 +1,73 @@
-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";
+import { createNodeFnFields } from "./nodeFnFields.js";
+import { createDocStore } from "./docValues.js";
+import { createLayerStack } from "./layerStack.js";
+import { createStaleReplay } from "./staleReplay.js";
+import { createLockGuard } from "./lockGuard.js";
+import { createNodeStore } from "./nodeStore.js";
+import { createRenderOrder } from "./renderOrder.js";
+import { serializeScene } from "./serialization.js";
+import { createTreeReads } from "./treeReads.js";
+
 //#region src/core/scene/sceneState.ts
-function c(c, l, u) {
-	let d = {
+/**
+* A scene's document state — its nodes, roots, and layers — with the modules
+* that read and write it directly.
+*/
+function createSceneState(registry, initialLayers, layoutDeclared, initialDoc) {
+	const state = {
 		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;
+		layerIndex: /* @__PURE__ */ new Map(),
+		docValues: /* @__PURE__ */ new Map()
+	};
+	const order = createRenderOrder(state);
+	/** The registry-keyed function fields, each with its key maps. A function
+	*  cannot travel through a serializable op payload, so an op carries its key. */
+	const fnFields = createNodeFnFields(registry, (field) => {
+		if (field === "layout") layoutDeclared();
+	});
+	const store = createNodeStore(state, order.invalidate, fnFields);
+	const layers = createLayerStack(state, order.invalidate);
+	layers.reset(initialLayers);
+	const locks = createLockGuard(state);
+	const docValues = createDocStore(state.docValues);
+	docValues.reset(initialDoc);
+	const reads = {
+		...createTreeReads(state.nodes),
+		renderOrder: order.ids,
+		renderOrderNodes: order.nodes,
+		nodesOnLayer: order.nodesOnLayer,
+		isLocked: (id) => locks.isLocked(id),
+		isHidden: (id) => locks.isHidden(id),
+		layoutOf(id) {
+			const node = state.nodes.get(id);
+			return node?.kind === "container" ? node.layout ?? null : null;
 		},
-		toJSON: () => o(d, p)
+		toJSON: () => serializeScene(state, fnFields, docValues.toJSON())
 	};
 	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);
+		state,
+		order,
+		locks,
+		stale: createStaleReplay(state.nodes),
+		fnFields,
+		store,
+		layers,
+		reads,
+		docValues,
+		/** Empty the document and give it `records` as its layers and `values` as its document values. */
+		reset(records, values) {
+			docValues.reset(values);
+			store.dependents.clear();
+			store.childDerived.clear();
+			state.nodes.clear();
+			state.roots.length = 0;
+			layers.reset(records);
 		}
 	};
 }
-//#endregion
-export { c as createSceneState };
 
+//#endregion
+export { createSceneState };
 //# sourceMappingURL=sceneState.js.map

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

@@ -1 +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"}
+{"version":3,"file":"sceneState.js","names":[],"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 { createDocStore, type SerializedDoc } from './docValues';\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  initialDoc?: SerializedDoc,\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    docValues: new Map<string, unknown>(),\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  const docValues = createDocStore(state.docValues);\n  docValues.reset(initialDoc);\n\n  const reads: Pick<\n    Scene<TData, TLayer, TPose>,\n    | 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf' | 'renderOrder' | 'renderOrderNodes'\n    | 'nodesOnLayer' | 'isLocked' | 'isHidden' | '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    isHidden: (id) => locks.isHidden(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, docValues.toJSON()),\n  };\n\n  return {\n    state,\n    order,\n    locks,\n    stale: createStaleReplay(state.nodes),\n    fnFields,\n    store,\n    layers,\n    reads,\n    docValues,\n\n    /** Empty the document and give it `records` as its layers and `values` as its document values. */\n    reset(records: readonly LayerRecord<TLayer>[], values?: SerializedDoc): void {\n      docValues.reset(values);\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":";;;;;;;;;;;;;;;AAeA,SAAgB,iBACd,UACA,eAEA,gBACA,YACA;CACA,MAAM,QAAQ;EACZ,uBAAO,IAAI,IAAwC;EACnD,OAAO,CAAC;EACR,QAAQ,CAAC;EACT,4BAAY,IAAI,IAAoB;EACpC,2BAAW,IAAI,IAAqB;CACtC;CACA,MAAM,QAAQ,kBAAkB,KAAK;;;CAGrC,MAAM,WAAW,mBAA0B,WAAW,UAAU;EAC9D,IAAI,UAAU,UAAU,eAAe;CACzC,CAAC;CACD,MAAM,QAAQ,gBAAgB,OAAO,MAAM,YAAY,QAAQ;CAC/D,MAAM,SAAS,iBAAiB,OAAO,MAAM,UAAU;CACvD,OAAO,MAAM,aAAa;CAC1B,MAAM,QAAQ,gBAAgB,KAAK;CACnC,MAAM,YAAY,eAAe,MAAM,SAAS;CAChD,UAAU,MAAM,UAAU;CAE1B,MAAM,QAIF;EACF,GAAG,gBAAgB,MAAM,KAAK;EAC9B,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,cAAc,MAAM;EACpB,WAAW,OAAO,MAAM,SAAS,EAAE;EACnC,WAAW,OAAO,MAAM,SAAS,EAAE;EACnC,SAAS,IAAI;GACX,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;GAC/B,OAAO,MAAM,SAAS,cAAe,KAAK,UAAU,OAAQ;EAC9D;EACA,cAAc,eAAe,OAAO,UAAU,UAAU,OAAO,CAAC;CAClE;CAEA,OAAO;EACL;EACA;EACA;EACA,OAAO,kBAAkB,MAAM,KAAK;EACpC;EACA;EACA;EACA;EACA;;EAGA,MAAM,SAAyC,QAA8B;GAC3E,UAAU,MAAM,MAAM;GACtB,MAAM,WAAW,MAAM;GACvB,MAAM,aAAa,MAAM;GACzB,MAAM,MAAM,MAAM;GAClB,MAAM,MAAM,SAAS;GACrB,OAAO,MAAM,OAAO;EACtB;CACF;AACF"}