@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/scene/historyFacade.js

@@ -1,130 +1,175 @@
-import { dwarn as e } from "../../debug/flag.js";
-import { SCENE_HISTORY_FORM as t } from "./historyForm.js";
+import { dwarn } from "../../debug/flag.js";
+import { SCENE_HISTORY_FORM } from "./historyForm.js";
+
 //#region src/core/scene/historyFacade.ts
-function n(e, t) {
-	let { replay: n, notify: r } = t;
+/** A journal drives adapter mutation itself, so its applies and undos
+*  re-enter scene mutation methods the way the facade's do. */
+function wrapJournal(raw, env) {
+	const { replay, notify } = env;
 	return {
-		targetId: e.targetId,
-		forkedAtEntryId: e.forkedAtEntryId,
-		applyBatch(n, i) {
-			t.runArrivalEdit(n, (n) => {
-				t.applying(() => e.applyBatch(n.map(t.causing), i)), r();
-			});
+		targetId: raw.targetId,
+		forkedAtEntryId: raw.forkedAtEntryId,
+		applyBatch(ops, label) {
+			env.labeled(label, () => env.runArrivalEdit(ops, (all) => {
+				env.applying(() => raw.applyBatch(all.map(env.causing), label));
+				notify();
+			}));
 		},
 		undo() {
-			n(() => e.undo()), r();
+			replay(() => raw.undo());
+			notify();
 		},
 		redo() {
-			n(() => e.redo()), r();
+			replay(() => raw.redo());
+			notify();
 		},
-		canUndo: () => e.canUndo(),
-		canRedo: () => e.canRedo(),
-		entries: () => e.entries(),
-		seal: () => e.seal(),
-		getVersion: () => e.getVersion(),
-		subscribe: (t) => e.subscribe(t),
-		commit(t) {
-			e.commit(t), r();
+		canUndo: () => raw.canUndo(),
+		canRedo: () => raw.canRedo(),
+		entries: () => raw.entries(),
+		seal: () => raw.seal(),
+		getVersion: () => raw.getVersion(),
+		subscribe: (listener) => raw.subscribe(listener),
+		commit(label) {
+			raw.commit(label);
+			notify();
 		},
 		cancel() {
-			n(() => e.cancel()), r();
+			replay(() => raw.cancel());
+			notify();
 		},
-		suspend: () => e.suspend(),
-		isActive: () => e.isActive()
+		suspend: () => raw.suspend(),
+		isActive: () => raw.isActive()
 	};
 }
-function r(r) {
-	let { engine: i, replay: a, notify: o, refuseUntracked: s, runArrivalEdit: c } = r, l = /* @__PURE__ */ new WeakMap();
-	function u(e, t) {
-		return e() ? (a(t), o(), !0) : !1;
+function createSceneHistory(env) {
+	const { engine, replay, notify, refuseUntracked, runArrivalEdit } = env;
+	/** Wrapped journal → the engine's own, for `resumeJournal`: the engine keys
+	*  resumability off journal identity, which a wrapper would not match. */
+	const rawJournals = /* @__PURE__ */ new WeakMap();
+	function step(can, run) {
+		if (!can()) return false;
+		replay(run);
+		notify();
+		return true;
 	}
-	let d = {
-		undo: () => u(() => i.canUndo(), () => i.undo()),
-		redo: () => u(() => i.canRedo(), () => i.redo()),
-		canUndo: () => i.canUndo(),
-		canRedo: () => i.canRedo(),
+	/** What undo and redo step: the open journal, else the engine. */
+	const stack = () => env.activeJournal() ?? engine;
+	const methods = {
+		undo() {
+			const j = env.activeJournal();
+			if (j) {
+				if (!j.canUndo()) return false;
+				j.undo();
+				return true;
+			}
+			return step(() => engine.canUndo(), () => engine.undo());
+		},
+		redo() {
+			const j = env.activeJournal();
+			if (j) {
+				if (!j.canRedo()) return false;
+				j.redo();
+				return true;
+			}
+			return step(() => engine.canRedo(), () => engine.redo());
+		},
+		canUndo: () => stack().canUndo(),
+		canRedo: () => stack().canRedo(),
 		historyEntries() {
-			let { undo: e, redo: t } = i.entries();
-			return [...e, ...t].map((e) => ({
+			const { undo, redo } = engine.entries();
+			return [...undo, ...redo].map((e) => ({
 				id: String(e.id),
 				label: e.label
 			}));
 		},
-		historyIndex: () => i.undoDepth(),
-		jumpToHistoryIndex(e) {
-			let t = i.undoDepth() + i.redoDepth(), n = Math.max(0, Math.min(t, e));
-			return u(() => n !== i.undoDepth(), () => i.goto(n));
+		historyIndex: () => engine.undoDepth(),
+		jumpToHistoryIndex(index) {
+			const total = engine.undoDepth() + engine.redoDepth();
+			const target = Math.max(0, Math.min(total, index));
+			return step(() => target !== engine.undoDepth(), () => engine.goto(target));
 		},
 		serializeHistory: () => ({
-			...i.serialize(),
-			form: t
+			...engine.serialize(),
+			form: SCENE_HISTORY_FORM
 		}),
-		restoreHistory(n) {
-			if (n.form !== t) {
-				e("scene", "restoreHistory: snapshot is not in the current recorded form — dropped");
+		restoreHistory(snapshot) {
+			if (snapshot.form !== SCENE_HISTORY_FORM) {
+				dwarn("scene", "restoreHistory: snapshot is not in the current recorded form — dropped");
 				return;
 			}
-			i.restore(n), o();
+			engine.restore(snapshot);
+			notify();
 		}
 	};
 	return {
 		history: {
-			apply(e, t) {
-				s("history.apply"), c([e], (n) => {
-					r.applying(() => n.length === 1 ? i.apply(r.causing(e), t) : i.applyOps(n.map(r.causing), t ?? e.label ?? "")), o();
-				});
+			apply(op, label) {
+				refuseUntracked("history.apply");
+				env.labeled(label ?? op.label ?? "", () => runArrivalEdit([op], (all) => {
+					const run = () => all.length === 1 ? engine.apply(env.causing(op), label) : engine.applyOps(all.map(env.causing), label ?? op.label ?? "");
+					env.applying(run);
+					notify();
+				}));
 			},
-			applyOps(e, t) {
-				s("history.applyOps"), c(e, (e) => {
-					r.applying(() => i.applyOps(e.map(r.causing), t)), o();
-				});
+			applyOps(ops, label) {
+				refuseUntracked("history.applyOps");
+				env.labeled(label, () => runArrivalEdit(ops, (all) => {
+					env.applying(() => engine.applyOps(all.map(env.causing), label));
+					notify();
+				}));
 			},
 			undo: () => {
-				d.undo();
+				methods.undo();
 			},
 			redo: () => {
-				d.redo();
+				methods.redo();
 			},
-			goto: (e) => {
-				d.jumpToHistoryIndex(e);
+			goto: (n) => {
+				methods.jumpToHistoryIndex(n);
 			},
 			clear() {
-				i.clear(), o();
+				engine.clear();
+				notify();
 			},
-			recordEntry(e, t, n) {
-				i.recordEntry(e, t, n), o();
+			recordEntry(ops, label, opts) {
+				engine.recordEntry(ops, label, opts);
+				notify();
 			},
-			prune(e) {
-				i.prune(e), o();
+			prune(t) {
+				engine.prune(t);
+				notify();
 			},
-			switchBranch(e) {
-				i.switchBranch(e), o();
+			switchBranch(id) {
+				engine.switchBranch(id);
+				notify();
 			},
-			restore: d.restoreHistory,
-			canUndo: d.canUndo,
-			canRedo: d.canRedo,
-			undoDepth: () => i.undoDepth(),
-			redoDepth: () => i.redoDepth(),
-			entries: () => i.entries(),
-			timestampAt: (e) => i.timestampAt(e),
-			depthAt: (e) => i.depthAt(e),
-			branches: () => i.branches(),
-			getVersion: () => i.getVersion(),
-			subscribe: (e) => i.subscribe(e),
-			serialize: d.serializeHistory,
-			allForwardOps: () => i.allForwardOps(),
-			seal: () => i.seal(),
-			currentEntryId: () => i.currentEntryId(),
-			beginJournal(e) {
-				let t = i.beginJournal(e), a = n(t, r);
-				return l.set(a, t), a;
+			restore: methods.restoreHistory,
+			canUndo: methods.canUndo,
+			canRedo: methods.canRedo,
+			undoDepth: () => engine.undoDepth(),
+			redoDepth: () => engine.redoDepth(),
+			entries: () => engine.entries(),
+			timestampAt: (i) => engine.timestampAt(i),
+			depthAt: (t) => engine.depthAt(t),
+			branches: () => engine.branches(),
+			getVersion: () => engine.getVersion(),
+			subscribe: (listener) => engine.subscribe(listener),
+			serialize: methods.serializeHistory,
+			allForwardOps: () => engine.allForwardOps(),
+			seal: () => engine.seal(),
+			currentEntryId: () => engine.currentEntryId(),
+			beginJournal(opts) {
+				const raw = engine.beginJournal(opts);
+				const wrapped = wrapJournal(raw, env);
+				rawJournals.set(wrapped, raw);
+				return wrapped;
 			},
-			resumeJournal: (e) => i.resumeJournal(l.get(e) ?? e)
+			resumeJournal: (journal) => engine.resumeJournal(rawJournals.get(journal) ?? journal)
 		},
-		methods: d
+		methods
 	};
 }
-//#endregion
-export { r as createSceneHistory };
 
+//#endregion
+export { createSceneHistory };
 //# sourceMappingURL=historyFacade.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"historyFacade.js","names":["wrapJournal","env","raw","ops","all","label","notify","replay","listener","createSceneHistory","rawJournals","step","can","run","methods","engine","undo","redo","total","target","index","SCENE_HISTORY_FORM","snapshot","refuseUntracked","runArrivalEdit","op","n","opts","t","id","i","wrapped","journal"],"sources":["../../../src/core/scene/historyFacade.ts"],"sourcesContent":["/**\n * `scene.history`: the `History` the kit's `undo`/`redo` actions resolve\n * their `history` dep to, and the handle a mode machine opens journals\n * against.\n *\n * Handing out the engine directly would let an action-driven undo replay ops\n * with scene-side recording still armed and without bumping the scene's\n * version, so every member that mutates routes through the scene's own\n * wrappers and one `notify()`; reads forward to the engine.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { dwarn } from 'debug/flag';\nimport { SCENE_HISTORY_FORM, type SerializedSceneHistory } from './historyForm';\nimport type { Scene } from './types';\n\n/** What the facade needs from the scene it fronts. */\nexport interface SceneHistoryEnv {\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Run a step that applies ops through an engine: all-or-nothing, with\n   *  scene-side recording suppressed. */\n  applying(step: () => void): void;\n  /** An op as the engine applies it: its entry records the kit ops it\n   *  caused. */\n  causing(op: Op): Op;\n  /** Run a step that replays recorded ops: an undo, a redo, a cancel. */\n  replay(step: () => void): void;\n  notify(): void;\n  refuseUntracked(verb: string): void;\n  /** Run an op-driven edit with its arrivals settled into the same batch. */\n  runArrivalEdit(ops: Op[], run: (ops: Op[]) => void): void;\n}\n\n/** The scene's own spellings of its history, which answer what a caller\n *  outside the engine's vocabulary asks: whether a step moved anything. */\nexport type SceneHistoryMethods = Pick<\n  Scene<unknown, string, unknown>,\n  | 'undo' | 'redo' | 'canUndo' | 'canRedo' | 'historyEntries' | 'historyIndex'\n  | 'jumpToHistoryIndex' | 'serializeHistory' | 'restoreHistory'\n>;\n\n/** A journal drives adapter mutation itself, so its applies and undos\n *  re-enter scene mutation methods the way the facade's do. */\nfunction wrapJournal(raw: Journal, env: SceneHistoryEnv): Journal {\n  const { replay, notify } = env;\n  return {\n    targetId: raw.targetId,\n    forkedAtEntryId: raw.forkedAtEntryId,\n    applyBatch(ops, label) {\n      env.runArrivalEdit(ops, (all) => {\n        env.applying(() => raw.applyBatch(all.map(env.causing), label));\n        notify();\n      });\n    },\n    undo() {\n      replay(() => raw.undo());\n      notify();\n    },\n    redo() {\n      replay(() => raw.redo());\n      notify();\n    },\n    canUndo: () => raw.canUndo(),\n    canRedo: () => raw.canRedo(),\n    entries: () => raw.entries(),\n    seal: () => raw.seal(),\n    getVersion: () => raw.getVersion(),\n    subscribe: (listener) => raw.subscribe(listener),\n    commit(label) {\n      // Flushes the session's net ops to the parent stack — no apply, but\n      // the parent's undo depth changes and listeners read that.\n      raw.commit(label);\n      notify();\n    },\n    cancel() {\n      replay(() => raw.cancel());\n      notify();\n    },\n    suspend: () => raw.suspend(),\n    isActive: () => raw.isActive(),\n  };\n}\n\nexport function createSceneHistory(env: SceneHistoryEnv): { history: History; methods: SceneHistoryMethods } {\n  const { engine, replay, notify, refuseUntracked, runArrivalEdit } = env;\n\n  /** Wrapped journal → the engine's own, for `resumeJournal`: the engine keys\n   *  resumability off journal identity, which a wrapper would not match. */\n  const rawJournals = new WeakMap<Journal, Journal>();\n\n  function step(can: () => boolean, run: () => void): boolean {\n    if (!can()) return false;\n    replay(run);\n    notify();\n    return true;\n  }\n\n  const methods: SceneHistoryMethods = {\n    undo: () => step(() => engine.canUndo(), () => engine.undo()),\n    redo: () => step(() => engine.canRedo(), () => engine.redo()),\n    canUndo: () => engine.canUndo(),\n    canRedo: () => engine.canRedo(),\n    historyEntries() {\n      const { undo, redo } = engine.entries();\n      // entries().redo is already chronological: the next redo comes first.\n      return [...undo, ...redo].map((e) => ({ id: String(e.id), label: e.label }));\n    },\n    historyIndex: () => engine.undoDepth(),\n    jumpToHistoryIndex(index) {\n      const total = engine.undoDepth() + engine.redoDepth();\n      const target = Math.max(0, Math.min(total, index));\n      return step(() => target !== engine.undoDepth(), () => engine.goto(target));\n    },\n    serializeHistory: () => ({ ...engine.serialize(), form: SCENE_HISTORY_FORM }),\n    restoreHistory(snapshot) {\n      if ((snapshot as Partial<SerializedSceneHistory>).form !== SCENE_HISTORY_FORM) {\n        dwarn('scene', 'restoreHistory: snapshot is not in the current recorded form — dropped');\n        return;\n      }\n      // Only the stacks are rebuilt: no op applies.\n      engine.restore(snapshot);\n      notify();\n    },\n  };\n\n  const history: History = {\n    // Mutating: applied ops re-enter the scene's own mutation methods.\n    apply(op, label) {\n      refuseUntracked('history.apply');\n      runArrivalEdit([op], (all) => {\n        const run = () => (all.length === 1\n          ? engine.apply(env.causing(op), label)\n          : engine.applyOps(all.map(env.causing), label ?? op.label ?? ''));\n        env.applying(run);\n        notify();\n      });\n    },\n    applyOps(ops, label) {\n      refuseUntracked('history.applyOps');\n      runArrivalEdit(ops, (all) => {\n        env.applying(() => engine.applyOps(all.map(env.causing), label));\n        notify();\n      });\n    },\n    undo: () => { methods.undo(); },\n    redo: () => { methods.redo(); },\n    goto: (n) => { methods.jumpToHistoryIndex(n); },\n    // Stack-only: nothing applies, but what `canUndo()` answers changes.\n    clear() {\n      engine.clear();\n      notify();\n    },\n    recordEntry(ops, label, opts) {\n      engine.recordEntry(ops, label, opts);\n      notify();\n    },\n    prune(t) {\n      engine.prune(t);\n      notify();\n    },\n    switchBranch(id) {\n      engine.switchBranch(id);\n      notify();\n    },\n    restore: methods.restoreHistory,\n    // Reads forward to the engine, `version` included: it counts history\n    // operations, where the scene's counts every mutation.\n    canUndo: methods.canUndo,\n    canRedo: methods.canRedo,\n    undoDepth: () => engine.undoDepth(),\n    redoDepth: () => engine.redoDepth(),\n    entries: () => engine.entries(),\n    timestampAt: (i) => engine.timestampAt(i),\n    depthAt: (t) => engine.depthAt(t),\n    branches: () => engine.branches(),\n    getVersion: () => engine.getVersion(),\n    subscribe: (listener) => engine.subscribe(listener),\n    serialize: methods.serializeHistory,\n    allForwardOps: () => engine.allForwardOps(),\n    seal: () => engine.seal(),\n    currentEntryId: () => engine.currentEntryId(),\n    beginJournal(opts) {\n      const raw = engine.beginJournal(opts);\n      const wrapped = wrapJournal(raw, env);\n      rawJournals.set(wrapped, raw);\n      return wrapped;\n    },\n    resumeJournal: (journal) => engine.resumeJournal(rawJournals.get(journal) ?? journal),\n  };\n  return { history, methods };\n}\n"],"mappings":"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"}
+{"version":3,"file":"historyFacade.js","names":[],"sources":["../../../src/core/scene/historyFacade.ts"],"sourcesContent":["/**\n * `scene.history`: the `History` the kit's `undo`/`redo` actions resolve\n * their `history` dep to, and the handle a mode machine opens journals\n * against.\n *\n * Handing out the engine directly would let an action-driven undo replay ops\n * with scene-side recording still armed and without bumping the scene's\n * version, so every member that mutates routes through the scene's own\n * wrappers and one `notify()`; reads forward to the engine.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { dwarn } from 'debug/flag';\nimport { SCENE_HISTORY_FORM, type SerializedSceneHistory } from './historyForm';\nimport type { Scene } from './types';\n\n/** What the facade needs from the scene it fronts. */\nexport interface SceneHistoryEnv {\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Run a step that applies ops through an engine: all-or-nothing, with\n   *  scene-side recording suppressed. */\n  applying(step: () => void): void;\n  /** An op as the engine applies it: its entry records the kit ops it\n   *  caused. */\n  causing(op: Op): Op;\n  /** Run a step that replays recorded ops: an undo, a redo, a cancel. */\n  replay(step: () => void): void;\n  notify(): void;\n  refuseUntracked(verb: string): void;\n  /** Run an op-driven edit with its arrivals settled into the same batch. */\n  runArrivalEdit(ops: Op[], run: (ops: Op[]) => void): void;\n  /** Run an edit applying ops, labeled `label` for the pose writes it reports. */\n  labeled<T>(label: string, fn: () => T): T;\n  /** The journal `applyBatch` writes to now, or null. Undo and redo step it\n   *  instead of the engine, so they take back the edits that went there. */\n  activeJournal(): Journal | null;\n}\n\n/** The scene's own spellings of its history, which answer what a caller\n *  outside the engine's vocabulary asks: whether a step moved anything. */\nexport type SceneHistoryMethods = Pick<\n  Scene<unknown, string, unknown>,\n  | 'undo' | 'redo' | 'canUndo' | 'canRedo' | 'historyEntries' | 'historyIndex'\n  | 'jumpToHistoryIndex' | 'serializeHistory' | 'restoreHistory'\n>;\n\n/** A journal drives adapter mutation itself, so its applies and undos\n *  re-enter scene mutation methods the way the facade's do. */\nfunction wrapJournal(raw: Journal, env: SceneHistoryEnv): Journal {\n  const { replay, notify } = env;\n  return {\n    targetId: raw.targetId,\n    forkedAtEntryId: raw.forkedAtEntryId,\n    applyBatch(ops, label) {\n      env.labeled(label, () => env.runArrivalEdit(ops, (all) => {\n        env.applying(() => raw.applyBatch(all.map(env.causing), label));\n        notify();\n      }));\n    },\n    undo() {\n      replay(() => raw.undo());\n      notify();\n    },\n    redo() {\n      replay(() => raw.redo());\n      notify();\n    },\n    canUndo: () => raw.canUndo(),\n    canRedo: () => raw.canRedo(),\n    entries: () => raw.entries(),\n    seal: () => raw.seal(),\n    getVersion: () => raw.getVersion(),\n    subscribe: (listener) => raw.subscribe(listener),\n    commit(label) {\n      // Flushes the session's net ops to the parent stack — no apply, but\n      // the parent's undo depth changes and listeners read that.\n      raw.commit(label);\n      notify();\n    },\n    cancel() {\n      replay(() => raw.cancel());\n      notify();\n    },\n    suspend: () => raw.suspend(),\n    isActive: () => raw.isActive(),\n  };\n}\n\nexport function createSceneHistory(env: SceneHistoryEnv): { history: History; methods: SceneHistoryMethods } {\n  const { engine, replay, notify, refuseUntracked, runArrivalEdit } = env;\n\n  /** Wrapped journal → the engine's own, for `resumeJournal`: the engine keys\n   *  resumability off journal identity, which a wrapper would not match. */\n  const rawJournals = new WeakMap<Journal, Journal>();\n\n  function step(can: () => boolean, run: () => void): boolean {\n    if (!can()) return false;\n    replay(run);\n    notify();\n    return true;\n  }\n\n  /** What undo and redo step: the open journal, else the engine. */\n  const stack = (): Pick<History, 'canUndo' | 'canRedo' | 'undo' | 'redo'> => env.activeJournal() ?? engine;\n\n  const methods: SceneHistoryMethods = {\n    undo() {\n      const j = env.activeJournal();\n      if (j) { if (!j.canUndo()) return false; j.undo(); return true; }\n      return step(() => engine.canUndo(), () => engine.undo());\n    },\n    redo() {\n      const j = env.activeJournal();\n      if (j) { if (!j.canRedo()) return false; j.redo(); return true; }\n      return step(() => engine.canRedo(), () => engine.redo());\n    },\n    canUndo: () => stack().canUndo(),\n    canRedo: () => stack().canRedo(),\n    historyEntries() {\n      const { undo, redo } = engine.entries();\n      // entries().redo is already chronological: the next redo comes first.\n      return [...undo, ...redo].map((e) => ({ id: String(e.id), label: e.label }));\n    },\n    historyIndex: () => engine.undoDepth(),\n    jumpToHistoryIndex(index) {\n      const total = engine.undoDepth() + engine.redoDepth();\n      const target = Math.max(0, Math.min(total, index));\n      return step(() => target !== engine.undoDepth(), () => engine.goto(target));\n    },\n    serializeHistory: () => ({ ...engine.serialize(), form: SCENE_HISTORY_FORM }),\n    restoreHistory(snapshot) {\n      if ((snapshot as Partial<SerializedSceneHistory>).form !== SCENE_HISTORY_FORM) {\n        dwarn('scene', 'restoreHistory: snapshot is not in the current recorded form — dropped');\n        return;\n      }\n      // Only the stacks are rebuilt: no op applies.\n      engine.restore(snapshot);\n      notify();\n    },\n  };\n\n  const history: History = {\n    // Mutating: applied ops re-enter the scene's own mutation methods.\n    apply(op, label) {\n      refuseUntracked('history.apply');\n      env.labeled(label ?? op.label ?? '', () => runArrivalEdit([op], (all) => {\n        const run = () => (all.length === 1\n          ? engine.apply(env.causing(op), label)\n          : engine.applyOps(all.map(env.causing), label ?? op.label ?? ''));\n        env.applying(run);\n        notify();\n      }));\n    },\n    applyOps(ops, label) {\n      refuseUntracked('history.applyOps');\n      env.labeled(label, () => runArrivalEdit(ops, (all) => {\n        env.applying(() => engine.applyOps(all.map(env.causing), label));\n        notify();\n      }));\n    },\n    undo: () => { methods.undo(); },\n    redo: () => { methods.redo(); },\n    goto: (n) => { methods.jumpToHistoryIndex(n); },\n    // Stack-only: nothing applies, but what `canUndo()` answers changes.\n    clear() {\n      engine.clear();\n      notify();\n    },\n    recordEntry(ops, label, opts) {\n      engine.recordEntry(ops, label, opts);\n      notify();\n    },\n    prune(t) {\n      engine.prune(t);\n      notify();\n    },\n    switchBranch(id) {\n      engine.switchBranch(id);\n      notify();\n    },\n    restore: methods.restoreHistory,\n    // Reads forward to the engine, `version` included: it counts history\n    // operations, where the scene's counts every mutation.\n    canUndo: methods.canUndo,\n    canRedo: methods.canRedo,\n    undoDepth: () => engine.undoDepth(),\n    redoDepth: () => engine.redoDepth(),\n    entries: () => engine.entries(),\n    timestampAt: (i) => engine.timestampAt(i),\n    depthAt: (t) => engine.depthAt(t),\n    branches: () => engine.branches(),\n    getVersion: () => engine.getVersion(),\n    subscribe: (listener) => engine.subscribe(listener),\n    serialize: methods.serializeHistory,\n    allForwardOps: () => engine.allForwardOps(),\n    seal: () => engine.seal(),\n    currentEntryId: () => engine.currentEntryId(),\n    beginJournal(opts) {\n      const raw = engine.beginJournal(opts);\n      const wrapped = wrapJournal(raw, env);\n      rawJournals.set(wrapped, raw);\n      return wrapped;\n    },\n    resumeJournal: (journal) => engine.resumeJournal(rawJournals.get(journal) ?? journal),\n  };\n  return { history, methods };\n}\n"],"mappings":"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"}

package/dist/core/scene/historyForm.js

@@ -1,6 +1,10 @@
 //#region src/core/scene/historyForm.ts
-var e = 2;
-//#endregion
-export { e as SCENE_HISTORY_FORM };
+/** The form a scene's undo entries are recorded in. A serialized history
+*  carries it, and one carrying another is not restored. Form 2 holds the
+*  scene's own ops for every edit; before it, an `applyBatch` entry held the
+*  ops it was given. */
+var SCENE_HISTORY_FORM = 2;
 
+//#endregion
+export { SCENE_HISTORY_FORM };
 //# sourceMappingURL=historyForm.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"historyForm.js","names":["SCENE_HISTORY_FORM"],"sources":["../../../src/core/scene/historyForm.ts"],"sourcesContent":["import type { SerializedHistory } from '@weasel-js/history';\n\n/** The form a scene's undo entries are recorded in. A serialized history\n *  carries it, and one carrying another is not restored. Form 2 holds the\n *  scene's own ops for every edit; before it, an `applyBatch` entry held the\n *  ops it was given. */\nexport const SCENE_HISTORY_FORM = 2;\n\n/** What `Scene.serializeHistory` answers with. */\nexport interface SerializedSceneHistory extends SerializedHistory {\n  form: typeof SCENE_HISTORY_FORM;\n}\n"],"mappings":";AAMA,IAAaA,IAAqB"}
+{"version":3,"file":"historyForm.js","names":[],"sources":["../../../src/core/scene/historyForm.ts"],"sourcesContent":["import type { SerializedHistory } from '@weasel-js/history';\n\n/** The form a scene's undo entries are recorded in. A serialized history\n *  carries it, and one carrying another is not restored. Form 2 holds the\n *  scene's own ops for every edit; before it, an `applyBatch` entry held the\n *  ops it was given. */\nexport const SCENE_HISTORY_FORM = 2;\n\n/** What `Scene.serializeHistory` answers with. */\nexport interface SerializedSceneHistory extends SerializedHistory {\n  form: typeof SCENE_HISTORY_FORM;\n}\n"],"mappings":";;;;;AAMA,IAAa,qBAAqB"}