@tmagic/editor 1.8.0-beta.4 → 1.8.0-beta.5

package/dist/tmagic-editor.umd.cjs

@@ -4917,8 +4917,41 @@
 	};
 	var props_default = new Props();
 	//#endregion
+	//#region packages/editor/src/utils/config.ts
+	var $TMAGIC_EDITOR = {};
+	var setEditorConfig = (option) => {
+		$TMAGIC_EDITOR = option;
+	};
+	var getEditorConfig = (key) => $TMAGIC_EDITOR[key];
+	//#endregion
 	//#region packages/editor/src/utils/undo-redo.ts
-	var UndoRedo = class {
+	var UndoRedo = class UndoRedo {
+		/**
+		* 由 {@link UndoRedo.serialize} 产出的快照重建一个 UndoRedo 实例。
+		* 游标会被夹紧到 [0, length] 区间，避免脏数据导致越界。
+		*
+		* @param options.isSavedStep 可选谓词：若提供，则把游标定位到「最近一条满足该谓词的记录」之后
+		*   （即恢复到最近一个已保存点）；找不到匹配记录时退回快照中的原游标。
+		*/
+		static fromSerialized(data, options = {}) {
+			const undoRedo = new UndoRedo(data.listMaxSize);
+			const list = Array.isArray(data.elementList) ? data.elementList.map((item) => cloneDeep$1(item)) : [];
+			let cursor = Number.isFinite(data.listCursor) ? data.listCursor : list.length;
+			const overflow = list.length - undoRedo.listMaxSize;
+			if (overflow > 0) {
+				list.splice(0, overflow);
+				cursor -= overflow;
+			}
+			if (options.isSavedStep) {
+				for (let i = list.length - 1; i >= 0; i--) if (options.isSavedStep(list[i])) {
+					cursor = i + 1;
+					break;
+				}
+			}
+			undoRedo.elementList = list;
+			undoRedo.listCursor = Math.max(0, Math.min(cursor, list.length));
+			return undoRedo;
+		}
 		elementList;
 		listCursor;
 		listMaxSize;
@@ -4928,6 +4961,17 @@
 			this.listCursor = 0;
 			this.listMaxSize = listMaxSize > minListMaxSize ? listMaxSize : minListMaxSize;
 		}
+		/**
+		* 导出当前栈的可序列化快照（深克隆，避免外部改动污染内部状态）。
+		* 配合 {@link UndoRedo.fromSerialized} 可在持久化后完整还原撤销/重做栈。
+		*/
+		serialize() {
+			return {
+				elementList: this.elementList.map((item) => cloneDeep$1(item)),
+				listCursor: this.listCursor,
+				listMaxSize: this.listMaxSize
+			};
+		}
 		pushElement(element) {
 			this.elementList.splice(this.listCursor, this.elementList.length - this.listCursor, cloneDeep$1(element));
 			this.listCursor += 1;
@@ -4960,6 +5004,28 @@
 			return cloneDeep$1(this.elementList[this.listCursor - 1]);
 		}
 		/**
+		* 用 `element` 替换当前游标所在元素（cursor - 1），并丢弃其后的重做尾部（与 {@link pushElement} 的丢尾一致），
+		* 游标位置保持不变（元素数量不增）。cursor 为 0（无已应用元素）时不做任何操作并返回 false。
+		* 用于「连续同类记录合并」等就地替换最新一条的场景。
+		*/
+		replaceCurrentElement(element) {
+			if (this.listCursor < 1) return false;
+			this.elementList.splice(this.listCursor - 1, this.elementList.length - (this.listCursor - 1), cloneDeep$1(element));
+			return true;
+		}
+		/**
+		* 对当前游标所在元素（cursor - 1）做就地更新；cursor 为 0（全部已撤销）时不做任何操作。
+		* 用于给「当前步骤」打标记（如标记为已保存）等元数据写入场景。
+		*/
+		updateCurrentElement(updater) {
+			if (this.listCursor < 1) return;
+			updater(this.elementList[this.listCursor - 1]);
+		}
+		/** 对栈内全部元素做就地更新。用于批量清理元数据（如清空所有元素的已保存标记）。 */
+		updateElements(updater) {
+			this.elementList.forEach(updater);
+		}
+		/**
 		* 返回栈内全部元素的浅克隆数组（按时间顺序，索引 0 为最早一步）。
 		* 仅用于历史面板等只读展示场景，不应直接修改返回值。
 		*/
@@ -4981,172 +5047,317 @@
 		}
 	};
 	//#endregion
-	//#region packages/editor/src/services/history.ts
-	var History = class History extends BaseService {
-		/**
-		* 把单个代码块栈拆成若干 group：
-		* - 把"新增/删除"独立成组（语义上属于一次性事件，不应与 update 合并）；
-		* - 连续 'update' 合并到同一组，组内 steps 顺序就是发生顺序。
-		*/
-		static mergeCodeBlockSteps(codeBlockId, list, cursor) {
-			const groups = [];
-			let current = null;
-			const currentIndex = cursor - 1;
-			list.forEach((step, index) => {
-				const opType = History.detectOpType(step.oldContent, step.newContent);
-				const applied = index < cursor;
-				const isCurrent = index === currentIndex;
-				if (opType === "update" && current?.opType === "update") {
-					current.steps.push({
-						step,
-						index,
-						applied,
-						isCurrent
-					});
-					current.applied = applied;
-					if (isCurrent) current.isCurrent = true;
-				} else {
-					current = {
-						kind: "code-block",
-						id: codeBlockId,
-						opType,
-						steps: [{
-							step,
-							index,
-							applied,
-							isCurrent
-						}],
-						applied,
-						isCurrent
-					};
-					groups.push(current);
-				}
-			});
-			return groups;
-		}
-		static mergeDataSourceSteps(dataSourceId, list, cursor) {
-			const groups = [];
-			let current = null;
-			const currentIndex = cursor - 1;
-			list.forEach((step, index) => {
-				const opType = History.detectOpType(step.oldSchema, step.newSchema);
-				const applied = index < cursor;
-				const isCurrent = index === currentIndex;
-				if (opType === "update" && current?.opType === "update") {
-					current.steps.push({
+	//#region packages/editor/src/utils/history.ts
+	/**
+	* 「回滚」生成的新 step 简短描述。代码块 / 数据源共用。
+	* 二者逻辑一致，仅展示名取值字段不同（代码块取 `name`，数据源取 `title`），
+	* 因此通过 `getLabel` 注入取值方式。
+	*
+	* @param id 关联的代码块 / 数据源 id
+	* @param diff 单条变更 diff（缺省视为空）
+	* @param getLabel 从快照取展示名
+	*/
+	var describeRevertStep = (id, { oldSchema, newSchema, changeRecords } = {}, getLabel) => {
+		const labelOf = (schema) => getLabel(schema) || schema.id;
+		if (!oldSchema && newSchema) return `撤回新增 ${labelOf(newSchema) || id}`;
+		if (oldSchema && !newSchema) return `还原已删除的 ${labelOf(oldSchema) || id}`;
+		const label = newSchema && getLabel(newSchema) || oldSchema && getLabel(oldSchema) || `${id}`;
+		const propPath = changeRecords?.[0]?.propPath;
+		return propPath ? `还原 ${label} · ${propPath}` : `还原 ${label}`;
+	};
+	/**
+	* 根据 old/new 是否为 null 推断 opType（与 push 时的约定一致）。
+	*/
+	var detectStackOpType = (oldVal, newVal) => {
+		if (oldVal === null && newVal !== null) return "add";
+		if (oldVal !== null && newVal === null) return "remove";
+		return "update";
+	};
+	/**
+	* 构造一条代码块 / 数据源「按 id 分栈」的历史记录：两者除 payload 字段命名外完全一致。
+	*
+	* - `add`：oldValue = null；`remove`：newValue = null；`update`：两者都有，可带 changeRecords 做局部更新。
+	* - 内容会做 cloneDeep 防止后续被外部引用篡改；opType 依据 old/new 是否为 null 推断。
+	* - 仅负责构造 step 并返回，入栈与事件 emit 由各公共方法（pushCodeBlock / pushDataSource）自行处理。
+	* - 不直接驱动业务 service，调用方负责实际写回。
+	*/
+	var createStackStep = (id, payload) => {
+		if (!id) return null;
+		const oldSchema = payload.oldValue ? cloneDeep$1(payload.oldValue) : null;
+		const newSchema = payload.newValue ? cloneDeep$1(payload.newValue) : null;
+		const changeRecords = payload.changeRecords?.length ? cloneDeep$1(payload.changeRecords) : void 0;
+		const opType = detectStackOpType(payload.oldValue, payload.newValue);
+		return {
+			uuid: (0, _tmagic_utils.guid)(),
+			id,
+			opType,
+			diff: [{
+				...newSchema !== null ? { newSchema } : {},
+				...oldSchema !== null ? { oldSchema } : {},
+				...opType === "update" && changeRecords ? { changeRecords } : {}
+			}],
+			historyDescription: payload.historyDescription,
+			source: payload.source,
+			timestamp: Date.now()
+		};
+	};
+	var markStackSaved = (undoRedo) => {
+		if (!undoRedo) return;
+		undoRedo.updateElements((element) => {
+			element.saved = false;
+		});
+		undoRedo.updateCurrentElement((element) => {
+			element.saved = true;
+		});
+	};
+	/**
+	* 把单个「按 id 分栈」的历史栈（代码块 / 数据源）拆成若干 group：
+	* - 把"新增/删除"独立成组（语义上属于一次性事件，不应与 update 合并）；
+	* - 连续 'update' 合并到同一组，组内 steps 顺序就是发生顺序。
+	*
+	* 代码块与数据源除 `kind` 外结构完全一致，统一由本方法处理；`kind` 决定返回的具体分组类型。
+	*/
+	var mergeStackSteps = (kind, id, list, cursor) => {
+		const groups = [];
+		let current = null;
+		const currentIndex = cursor - 1;
+		list.forEach((step, index) => {
+			const { opType } = step;
+			const applied = index < cursor;
+			const isCurrent = index === currentIndex;
+			if (opType === "update" && current?.opType === "update") {
+				current.steps.push({
+					step,
+					index,
+					applied,
+					isCurrent
+				});
+				current.applied = applied;
+				if (isCurrent) current.isCurrent = true;
+			} else {
+				current = {
+					kind,
+					id,
+					opType,
+					steps: [{
 						step,
 						index,
 						applied,
 						isCurrent
-					});
-					current.applied = applied;
-					if (isCurrent) current.isCurrent = true;
-				} else {
-					current = {
-						kind: "data-source",
-						id: dataSourceId,
-						opType,
-						steps: [{
-							step,
-							index,
-							applied,
-							isCurrent
-						}],
-						applied,
-						isCurrent
-					};
-					groups.push(current);
-				}
-			});
-			return groups;
-		}
-		/**
-		* 根据 old/new 是否为 null 推断 opType（与 push 时的约定一致）。
-		*/
-		static detectOpType(oldVal, newVal) {
-			if (oldVal === null && newVal !== null) return "add";
-			if (oldVal !== null && newVal === null) return "remove";
-			return "update";
-		}
-		/**
-		* 把页面栈拆成若干 group：
-		* - 单节点的 'update' 按 targetId 与相邻同 targetId 的 update 合并到一个 group；
-		* - 'add' / 'remove' 始终独立成组（语义上是结构变更，不应被收纳进单节点修改组）；
-		* - 多节点 'update'（如批量改属性）也独立成组（无明确单一目标，避免误合并）。
-		*/
-		static mergePageSteps(pageId, list, cursor) {
-			const groups = [];
-			let current = null;
-			const currentIndex = cursor - 1;
-			list.forEach((step, index) => {
-				const applied = index < cursor;
-				const isCurrent = index === currentIndex;
-				const targetId = History.detectPageTargetId(step);
-				const targetName = History.detectPageTargetName(step);
-				const entry = {
-					step,
-					index,
+					}],
 					applied,
 					isCurrent
 				};
-				const mergeable = step.opType === "update" && targetId !== void 0;
-				if (mergeable && current?.opType === "update" && current.targetId === targetId) {
-					current.steps.push(entry);
-					current.applied = applied;
-					if (isCurrent) current.isCurrent = true;
-					if (targetName) current.targetName = targetName;
-				} else {
-					current = {
-						kind: "page",
-						pageId,
-						opType: step.opType,
-						targetId: mergeable ? targetId : void 0,
-						targetName,
-						steps: [entry],
-						applied,
-						isCurrent
-					};
-					groups.push(current);
-				}
-			});
-			return groups;
+				groups.push(current);
+			}
+		});
+		return groups;
+	};
+	/**
+	* 把页面栈拆成若干 group：
+	* - 单节点的 'update' 按 targetId 与相邻同 targetId 的 update 合并到一个 group；
+	* - 'add' / 'remove' 始终独立成组（语义上是结构变更，不应被收纳进单节点修改组）；
+	* - 多节点 'update'（如批量改属性）也独立成组（无明确单一目标，避免误合并）。
+	*/
+	var mergePageSteps = (pageId, list, cursor) => {
+		const groups = [];
+		let current = null;
+		const currentIndex = cursor - 1;
+		list.forEach((step, index) => {
+			const applied = index < cursor;
+			const isCurrent = index === currentIndex;
+			const targetId = detectPageTargetId(step);
+			const targetName = detectPageTargetName(step);
+			const entry = {
+				step,
+				index,
+				applied,
+				isCurrent
+			};
+			const mergeable = step.opType === "update" && targetId !== void 0;
+			if (mergeable && current?.opType === "update" && current.targetId === targetId) {
+				current.steps.push(entry);
+				current.applied = applied;
+				if (isCurrent) current.isCurrent = true;
+				if (targetName) current.targetName = targetName;
+			} else {
+				current = {
+					kind: "page",
+					pageId,
+					opType: step.opType,
+					targetId: mergeable ? targetId : void 0,
+					targetName,
+					steps: [entry],
+					applied,
+					isCurrent
+				};
+				groups.push(current);
+			}
+		});
+		return groups;
+	};
+	/**
+	* 解析 StepValue 中的"目标节点 id"用于合并：
+	* - 单节点 update：取唯一一项 updatedItems 的节点 id；
+	* - 其它情形（多节点 update / add / remove）：返回 undefined，表示不参与合并。
+	*/
+	var detectPageTargetId = (step) => {
+		if (step.opType !== "update") return void 0;
+		const items = step.diff;
+		if (items?.length !== 1) return void 0;
+		return items[0].newSchema?.id ?? items[0].oldSchema?.id;
+	};
+	/** 解析 StepValue 中的目标节点可读名（用于 UI 展示）。 */
+	var detectPageTargetName = (step) => {
+		const items = step.diff;
+		if (step.opType === "update") {
+			if (items?.length === 1) {
+				const node = items[0].newSchema || items[0].oldSchema;
+				return node?.name || node?.type || (node?.id !== void 0 ? `${node.id}` : void 0);
+			}
+			return items?.length ? `${items.length} 个节点` : void 0;
 		}
-		/**
-		* 解析 StepValue 中的"目标节点 id"用于合并：
-		* - 单节点 update：取唯一一项 updatedItems 的节点 id；
-		* - 其它情形（多节点 update / add / remove）：返回 undefined，表示不参与合并。
-		*/
-		static detectPageTargetId(step) {
-			if (step.opType !== "update") return void 0;
-			const items = step.updatedItems;
-			if (items?.length !== 1) return void 0;
-			return items[0].newNode?.id ?? items[0].oldNode?.id;
-		}
-		/** 解析 StepValue 中的目标节点可读名（用于 UI 展示）。 */
-		static detectPageTargetName(step) {
-			if (step.opType === "update") {
-				const items = step.updatedItems;
-				if (items?.length === 1) {
-					const node = items[0].newNode || items[0].oldNode;
-					return node?.name || node?.type || (node?.id !== void 0 ? `${node.id}` : void 0);
-				}
-				return items?.length ? `${items.length} 个节点` : void 0;
+		if (step.opType === "add") {
+			if (items?.length === 1) {
+				const n = items[0].newSchema;
+				return n?.name || n?.type || `${n?.id}`;
 			}
-			if (step.opType === "add") {
-				if (step.nodes?.length === 1) {
-					const n = step.nodes[0];
-					return n.name || n.type || `${n.id}`;
-				}
-				return step.nodes?.length ? `${step.nodes.length} 个节点` : void 0;
+			return items?.length ? `${items.length} 个节点` : void 0;
+		}
+		if (step.opType === "remove") {
+			if (items?.length === 1) {
+				const n = items[0].oldSchema;
+				return n?.name || n?.type || `${n?.id}`;
 			}
-			if (step.opType === "remove") {
-				if (step.removedItems?.length === 1) {
-					const n = step.removedItems[0].node;
-					return n.name || n.type || `${n.id}`;
-				}
-				return step.removedItems?.length ? `${step.removedItems.length} 个节点` : void 0;
+			return items?.length ? `${items.length} 个节点` : void 0;
+		}
+	};
+	/** 把 `Record<Id, UndoRedo>` 整体序列化为 `Record<Id, SerializedUndoRedo>`。 */
+	var serializeStacks = (stacks) => {
+		const result = {};
+		Object.entries(stacks).forEach(([id, undoRedo]) => {
+			if (undoRedo) result[id] = undoRedo.serialize();
+		});
+		return result;
+	};
+	/**
+	* 把 `Record<Id, SerializedUndoRedo>` 整体还原为 `Record<Id, UndoRedo>`。
+	* 还原时把每个栈的游标定位到最近一条已保存（`saved === true`）记录之后。
+	*/
+	var deserializeStacks = (stacks = {}) => {
+		const result = {};
+		Object.entries(stacks).forEach(([id, serialized]) => {
+			if (serialized) result[id] = UndoRedo.fromSerialized(serialized, { isSavedStep: (element) => element.saved === true });
+		});
+		return result;
+	};
+	/**
+	* 按 id 从「按 id 分栈」的记录表（代码块 / 数据源）中获取（或创建）对应的 UndoRedo 栈。
+	*/
+	var getOrCreateStack = (stacks, id) => {
+		if (!stacks[id]) stacks[id] = new UndoRedo();
+		return stacks[id];
+	};
+	/**
+	* 撤销下限：当页面栈 index 0 是 `opType: 'initial'` 的基线 step 时为 1（基线不可被撤销），否则为 0。
+	* 用于把 cursor 钉在基线之上，保证 undo / canUndo / goto 都不会越过初始基线。
+	*/
+	var undoFloor = (undoRedo) => {
+		return undoRedo.getElementList()[0]?.opType === "initial" ? 1 : 0;
+	};
+	//#endregion
+	//#region packages/editor/src/utils/indexed-db.ts
+	/**
+	* 一组极简的、基于原生 IndexedDB 的 Promise KV 工具，避免引入额外依赖。
+	* 仅用于浏览器环境；在不支持 IndexedDB 的环境（如 SSR / 部分测试环境）下会 reject。
+	*/
+	/** 是否处于支持 IndexedDB 的环境。 */
+	var isIndexedDBSupported = () => typeof indexedDB !== "undefined" && indexedDB !== null;
+	/**
+	* 打开（必要时升级）数据库，确保目标 objectStore 存在后返回连接。
+	*
+	* 由于 objectStore 只能在 `onupgradeneeded` 内创建，这里先以当前版本打开，
+	* 若发现 store 不存在则关闭连接、以更高版本重开来按需创建，兼容动态 storeName。
+	*/
+	var openIndexedDB = (dbName, storeName) => new Promise((resolve, reject) => {
+		if (!isIndexedDBSupported()) {
+			reject(/* @__PURE__ */ new Error("当前环境不支持 IndexedDB"));
+			return;
+		}
+		const request = indexedDB.open(dbName);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);
+		};
+		request.onerror = () => reject(request.error);
+		request.onsuccess = () => {
+			const db = request.result;
+			if (db.objectStoreNames.contains(storeName)) {
+				resolve(db);
+				return;
 			}
+			const nextVersion = db.version + 1;
+			db.close();
+			const upgradeRequest = indexedDB.open(dbName, nextVersion);
+			upgradeRequest.onupgradeneeded = () => {
+				const upgradeDb = upgradeRequest.result;
+				if (!upgradeDb.objectStoreNames.contains(storeName)) upgradeDb.createObjectStore(storeName);
+			};
+			upgradeRequest.onerror = () => reject(upgradeRequest.error);
+			upgradeRequest.onsuccess = () => resolve(upgradeRequest.result);
+		};
+	});
+	/** 写入（覆盖）一条记录。value 通过结构化克隆存储，支持 Map / Set 等结构。 */
+	var idbSet = async (dbName, storeName, key, value) => {
+		const db = await openIndexedDB(dbName, storeName);
+		try {
+			await new Promise((resolve, reject) => {
+				const tx = db.transaction(storeName, "readwrite");
+				tx.objectStore(storeName).put(value, key);
+				tx.oncomplete = () => resolve();
+				tx.onabort = () => reject(tx.error);
+				tx.onerror = () => reject(tx.error);
+			});
+		} finally {
+			db.close();
+		}
+	};
+	/** 读取一条记录，不存在时返回 undefined。 */
+	var idbGet = async (dbName, storeName, key) => {
+		const db = await openIndexedDB(dbName, storeName);
+		try {
+			return await new Promise((resolve, reject) => {
+				const request = db.transaction(storeName, "readonly").objectStore(storeName).get(key);
+				request.onsuccess = () => resolve(request.result);
+				request.onerror = () => reject(request.error);
+			});
+		} finally {
+			db.close();
+		}
+	};
+	/** 删除一条记录。 */
+	var idbDelete = async (dbName, storeName, key) => {
+		const db = await openIndexedDB(dbName, storeName);
+		try {
+			await new Promise((resolve, reject) => {
+				const tx = db.transaction(storeName, "readwrite");
+				tx.objectStore(storeName).delete(key);
+				tx.oncomplete = () => resolve();
+				tx.onabort = () => reject(tx.error);
+				tx.onerror = () => reject(tx.error);
+			});
+		} finally {
+			db.close();
 		}
+	};
+	//#endregion
+	//#region packages/editor/src/services/history.ts
+	/** 历史记录持久化快照的默认存储位置与结构版本。 */
+	var DEFAULT_DB_NAME = "tmagic-editor";
+	var DEFAULT_STORE_NAME = "history";
+	var DEFAULT_KEY = "default";
+	var PERSIST_VERSION = 1;
+	var History = class extends BaseService {
 		state = (0, vue.reactive)({
 			pageSteps: {},
 			pageId: void 0,
@@ -5186,6 +5397,53 @@
 			this.state.dataSourceState = {};
 		}
 		/**
+		* 为指定页面 / 页面片种入一条「初始基线」记录（如加载 DSL 时的「初始 / 加载」基线）。
+		*
+		* 该记录是一条 `opType: 'initial'` 的 {@link StepValue}，作为页面历史栈 **index 0 的固定底线**：
+		* - 它是一条真实入栈的 step（随栈一起持久化），但被钉为撤销/回滚的下限——cursor 永不低于它，
+		*   因此不会被 undo / goto / revert 触达（详见 {@link undo} / {@link setCanUndoRedo}）；
+		* - 历史面板把它过滤出分组列表（见 {@link getPageHistoryGroups}），改由底部「初始」行展示。
+		*
+		* 仅当目标页面栈为空时种入（保证 initial 一定位于 index 0）；已存在 initial 底线时默认不重复种入，
+		* 传 `force=true` 且栈为空时按新基线种入。
+		*/
+		setPageMarker(pageId, options = {}) {
+			if (pageId === void 0 || pageId === null || `${pageId}` === "") return null;
+			const existing = this.getPageMarker(pageId);
+			if (existing) return existing;
+			const stack = getOrCreateStack(this.state.pageSteps, pageId);
+			if (stack.getLength() > 0) return null;
+			const marker = {
+				uuid: (0, _tmagic_utils.guid)(),
+				opType: "initial",
+				diff: [],
+				data: {
+					name: options.name || "",
+					id: pageId
+				},
+				selectedBefore: [],
+				selectedAfter: [],
+				modifiedNodeIds: /* @__PURE__ */ new Map(),
+				historyDescription: options.description || "未修改的初始状态",
+				timestamp: Date.now(),
+				...options.source ? { source: options.source } : {}
+			};
+			stack.pushElement(marker);
+			if (`${pageId}` === `${this.state.pageId}`) this.setCanUndoRedo();
+			this.emit("page-marker-change", marker);
+			return marker;
+		}
+		/**
+		* 读取指定页面（缺省当前活动页）的初始基线 step（页面栈 index 0 且 `opType: 'initial'`）；
+		* 不存在时返回 undefined。
+		*/
+		getPageMarker(pageId) {
+			const targetPageId = pageId ?? this.state.pageId;
+			if (!targetPageId) return void 0;
+			const first = this.state.pageSteps[targetPageId]?.getElementList()[0];
+			return first?.opType === "initial" ? first : void 0;
+		}
+		/**
 		* 把一条步骤推入指定页面的栈；不指定 pageId 时落到当前活动页。
 		*
 		* 跨页操作（例如 `moveToContainer` 把节点搬到其它页）必须显式传入 `pageId`，
@@ -5194,11 +5452,31 @@
 		push(state, pageId) {
 			const undoRedo = this.getUndoRedo(pageId);
 			if (!undoRedo) return null;
+			if (state.uuid === void 0) state.uuid = (0, _tmagic_utils.guid)();
 			if (state.timestamp === void 0) state.timestamp = Date.now();
 			undoRedo.pushElement(state);
 			if (pageId === void 0 || `${pageId}` === `${this.state.pageId}`) this.emit("change", state);
 			return state;
 		}
+		/** 读取指定页面（缺省当前活动页）历史栈当前游标所在的 step（cursor - 1）；无则返回 null。 */
+		getCurrentPageStep(pageId) {
+			const targetPageId = pageId ?? this.state.pageId;
+			if (!targetPageId) return null;
+			return this.state.pageSteps[targetPageId]?.getCurrentElement() ?? null;
+		}
+		/**
+		* 用 `state` 替换指定页面栈当前游标所在的 step（并丢弃其后的重做尾部），游标不变。
+		* 用于「连续 set root 记录合并」等就地替换最新一条的场景；替换成功后按需刷新 / 通知。
+		*/
+		replaceCurrentPageStep(state, pageId) {
+			const undoRedo = this.getUndoRedo(pageId);
+			if (!undoRedo) return null;
+			if (state.uuid === void 0) state.uuid = (0, _tmagic_utils.guid)();
+			if (state.timestamp === void 0) state.timestamp = Date.now();
+			if (!undoRedo.replaceCurrentElement(state)) return null;
+			this.emit("change", state);
+			return state;
+		}
 		/**
 		* 推入一条代码块变更记录（与页面/节点完全无关），按 `codeBlockId` 维度独立一份 UndoRedo 栈。
 		*
@@ -5209,17 +5487,15 @@
 		* - 不直接驱动 codeBlockService，调用方负责实际写回。
 		*/
 		pushCodeBlock(codeBlockId, payload) {
-			if (!codeBlockId) return null;
-			const step = {
-				id: codeBlockId,
-				oldContent: payload.oldContent ? cloneDeep$1(payload.oldContent) : null,
-				newContent: payload.newContent ? cloneDeep$1(payload.newContent) : null,
-				changeRecords: payload.changeRecords?.length ? cloneDeep$1(payload.changeRecords) : void 0,
+			const step = createStackStep(codeBlockId, {
+				oldValue: payload.oldContent,
+				newValue: payload.newContent,
+				changeRecords: payload.changeRecords,
 				historyDescription: payload.historyDescription,
-				source: payload.source,
-				timestamp: Date.now()
-			};
-			this.getCodeBlockUndoRedo(codeBlockId).pushElement(step);
+				source: payload.source
+			});
+			if (!step) return null;
+			getOrCreateStack(this.state.codeBlockState, codeBlockId).pushElement(step);
 			this.emit("code-block-history-change", codeBlockId, step);
 			return step;
 		}
@@ -5228,17 +5504,15 @@
 		* 行为同 pushCodeBlock（新增 oldSchema=null；删除 newSchema=null）。
 		*/
 		pushDataSource(dataSourceId, payload) {
-			if (!dataSourceId) return null;
-			const step = {
-				id: dataSourceId,
-				oldSchema: payload.oldSchema ? cloneDeep$1(payload.oldSchema) : null,
-				newSchema: payload.newSchema ? cloneDeep$1(payload.newSchema) : null,
-				changeRecords: payload.changeRecords?.length ? cloneDeep$1(payload.changeRecords) : void 0,
+			const step = createStackStep(dataSourceId, {
+				oldValue: payload.oldSchema,
+				newValue: payload.newSchema,
+				changeRecords: payload.changeRecords,
 				historyDescription: payload.historyDescription,
-				source: payload.source,
-				timestamp: Date.now()
-			};
-			this.getDataSourceUndoRedo(dataSourceId).pushElement(step);
+				source: payload.source
+			});
+			if (!step) return null;
+			getOrCreateStack(this.state.dataSourceState, dataSourceId).pushElement(step);
 			this.emit("data-source-history-change", dataSourceId, step);
 			return step;
 		}
@@ -5293,6 +5567,7 @@
 		undo() {
 			const undoRedo = this.getUndoRedo();
 			if (!undoRedo) return null;
+			if (undoRedo.getCursor() <= undoFloor(undoRedo)) return null;
 			const state = undoRedo.undo();
 			this.emit("change", state);
 			return state;
@@ -5310,6 +5585,127 @@
 			this.removeAllPlugins();
 		}
 		/**
+		* 清空指定页面（缺省当前活动页）的历史记录栈。
+		* 仅删除撤销/重做记录，不会改动当前 DSL；清空后该页将无法再撤销/重做之前的操作。
+		*/
+		clearPage(pageId) {
+			const targetPageId = pageId ?? this.state.pageId;
+			if (!targetPageId) return;
+			const marker = this.getPageMarker(targetPageId);
+			this.state.pageSteps[targetPageId] = new UndoRedo();
+			if (marker) this.setPageMarker(targetPageId, {
+				name: marker.data?.name,
+				description: marker.historyDescription,
+				source: marker.source
+			});
+			if (`${targetPageId}` === `${this.state.pageId}`) {
+				this.setCanUndoRedo();
+				this.emit("clear-page", null);
+			}
+		}
+		/**
+		* 清空数据源历史记录栈：传入 `dataSourceId` 仅清空该数据源，缺省清空全部数据源。
+		* 仅删除撤销/重做记录，不会改动数据源本身。
+		*/
+		clearDataSource(dataSourceId) {
+			if (dataSourceId !== void 0) delete this.state.dataSourceState[dataSourceId];
+			else this.state.dataSourceState = {};
+		}
+		/**
+		* 清空代码块历史记录栈：传入 `codeBlockId` 仅清空该代码块，缺省清空全部代码块。
+		* 仅删除撤销/重做记录，不会改动代码块本身。
+		*/
+		clearCodeBlock(codeBlockId) {
+			if (codeBlockId !== void 0) delete this.state.codeBlockState[codeBlockId];
+			else this.state.codeBlockState = {};
+		}
+		/**
+		* 标记「整份 DSL 已保存」：把页面 / 代码块 / 数据源所有栈当前游标所在的记录都标为 `saved`。
+		* 适用于「整体落库」场景；若只保存了其中一类，请改用更细粒度的
+		* {@link markPageSaved} / {@link markCodeBlockSaved} / {@link markDataSourceSaved}。
+		*/
+		markSaved() {
+			Object.values(this.state.pageSteps).forEach(markStackSaved);
+			Object.values(this.state.codeBlockState).forEach(markStackSaved);
+			Object.values(this.state.dataSourceState).forEach(markStackSaved);
+			this.emit("mark-saved", { kind: "all" });
+		}
+		/**
+		* 标记指定页面（缺省为当前活动页）的历史栈当前记录为已保存。
+		* 仅影响该页面自己的栈，不波及代码块 / 数据源 / 其它页面。
+		*/
+		markPageSaved(pageId) {
+			const targetPageId = pageId ?? this.state.pageId;
+			if (!targetPageId) return;
+			markStackSaved(this.state.pageSteps[targetPageId]);
+			this.emit("mark-saved", {
+				kind: "page",
+				id: targetPageId
+			});
+		}
+		/** 标记指定代码块的历史栈当前记录为已保存，仅影响该代码块自己的栈。 */
+		markCodeBlockSaved(codeBlockId) {
+			if (!codeBlockId) return;
+			markStackSaved(this.state.codeBlockState[codeBlockId]);
+			this.emit("mark-saved", {
+				kind: "code-block",
+				id: codeBlockId
+			});
+		}
+		/** 标记指定数据源的历史栈当前记录为已保存，仅影响该数据源自己的栈。 */
+		markDataSourceSaved(dataSourceId) {
+			if (!dataSourceId) return;
+			markStackSaved(this.state.dataSourceState[dataSourceId]);
+			this.emit("mark-saved", {
+				kind: "data-source",
+				id: dataSourceId
+			});
+		}
+		/**
+		* 把当前内存中的全部历史栈（页面 / 代码块 / 数据源）序列化后写入本地 IndexedDB。
+		*
+		* - 每个 UndoRedo 栈连同其游标、容量一并保存，恢复后可继续 undo/redo；
+		* - `key` 用于区分不同活动页 / 项目（同一 store 下可保存多份快照），缺省为 `default`；
+		* - 返回写入成功的快照对象，便于调用方记录 savedAt 等信息；
+		* - 不支持 IndexedDB 的环境（如 SSR）会 reject。
+		*/
+		async saveToIndexedDB(options = {}) {
+			const { dbName = DEFAULT_DB_NAME, storeName = DEFAULT_STORE_NAME, key = DEFAULT_KEY, appId } = options;
+			const snapshot = {
+				version: PERSIST_VERSION,
+				pageId: this.state.pageId,
+				pageSteps: serializeStacks(this.state.pageSteps),
+				codeBlockState: serializeStacks(this.state.codeBlockState),
+				dataSourceState: serializeStacks(this.state.dataSourceState),
+				savedAt: Date.now()
+			};
+			await idbSet(this.resolveDbName(dbName, appId), storeName, key, (0, serialize_javascript.default)(snapshot));
+			this.emit("save-to-indexed-db", snapshot);
+			return snapshot;
+		}
+		/**
+		* 从本地 IndexedDB 读取此前保存的历史快照并重建全部撤销/重做栈。
+		*
+		* - 读取到的每个栈都会经 {@link UndoRedo.fromSerialized} 还原（含游标），随后可直接 undo/redo；
+		* - 会整体覆盖当前内存中的历史状态，并把活动页恢复为快照中的 pageId；
+		* - 找不到对应记录时返回 null，且不改动当前状态；
+		* - 不支持 IndexedDB 的环境（如 SSR）会 reject。
+		*/
+		async restoreFromIndexedDB(options = {}) {
+			const { dbName = DEFAULT_DB_NAME, storeName = DEFAULT_STORE_NAME, key = DEFAULT_KEY, appId } = options;
+			const raw = await idbGet(this.resolveDbName(dbName, appId), storeName, key);
+			if (!raw) return null;
+			const snapshot = typeof raw === "string" ? getEditorConfig("parseDSL")(`(${raw})`) : raw;
+			if (!snapshot) return null;
+			this.state.pageSteps = deserializeStacks(snapshot.pageSteps);
+			this.state.codeBlockState = deserializeStacks(snapshot.codeBlockState);
+			this.state.dataSourceState = deserializeStacks(snapshot.dataSourceState);
+			this.state.pageId = snapshot.pageId;
+			this.setCanUndoRedo();
+			this.emit("restore-from-indexed-db", snapshot);
+			return snapshot;
+		}
+		/**
 		* 取出当前活动页的历史步骤平铺列表（包含已应用 + 已撤销）。
 		* 列表按时间正序，最早一步在最前面。
 		* 通常 UI 应使用 `getPageHistoryGroups` 取已合并分组的版本；本方法仅为兼容/调试保留。
@@ -5340,8 +5736,7 @@
 			if (!undoRedo) return [];
 			const list = undoRedo.getElementList();
 			if (!list.length) return [];
-			const cursor = undoRedo.getCursor();
-			return History.mergePageSteps(targetPageId, list, cursor);
+			return mergePageSteps(targetPageId, list, undoRedo.getCursor()).filter((group) => group.opType !== "initial");
 		}
 		/**
 		* 取出全部代码块的历史栈，按 codeBlockId 分组。
@@ -5357,7 +5752,7 @@
 				const list = undoRedo.getElementList();
 				if (!list.length) return;
 				const cursor = undoRedo.getCursor();
-				groups.push(...History.mergeCodeBlockSteps(id, list, cursor));
+				groups.push(...mergeStackSteps("code-block", id, list, cursor));
 			});
 			return groups;
 		}
@@ -5407,6 +5802,44 @@
 			}));
 		}
 		/**
+		* 按历史记录 uuid 在指定页面（默认当前活动页）的栈中查找其索引。
+		* 找不到时返回 -1。供「按 uuid 回滚」等需要把 uuid 映射回 index 的场景使用。
+		*/
+		getPageStepIndexByUuid(uuid, pageId) {
+			if (!uuid) return -1;
+			return this.getPageStepList(pageId).findIndex((entry) => entry.step.uuid === uuid);
+		}
+		/**
+		* 按历史记录 uuid 在全部代码块栈中查找其所属 codeBlockId 与索引。
+		* 找不到时返回 null。
+		*/
+		findCodeBlockStepLocationByUuid(uuid) {
+			if (!uuid) return null;
+			for (const id of Object.keys(this.state.codeBlockState)) {
+				const index = this.getCodeBlockStepList(id).findIndex((entry) => entry.step.uuid === uuid);
+				if (index >= 0) return {
+					id,
+					index
+				};
+			}
+			return null;
+		}
+		/**
+		* 按历史记录 uuid 在全部数据源栈中查找其所属 dataSourceId 与索引。
+		* 找不到时返回 null。
+		*/
+		findDataSourceStepLocationByUuid(uuid) {
+			if (!uuid) return null;
+			for (const id of Object.keys(this.state.dataSourceState)) {
+				const index = this.getDataSourceStepList(id).findIndex((entry) => entry.step.uuid === uuid);
+				if (index >= 0) return {
+					id,
+					index
+				};
+			}
+			return null;
+		}
+		/**
 		* 取出全部数据源的历史栈，按 dataSourceId 分组。同上。
 		*/
 		getDataSourceHistoryGroups() {
@@ -5416,7 +5849,7 @@
 				const list = undoRedo.getElementList();
 				if (!list.length) return;
 				const cursor = undoRedo.getCursor();
-				groups.push(...History.mergeDataSourceSteps(id, list, cursor));
+				groups.push(...mergeStackSteps("data-source", id, list, cursor));
 			});
 			return groups;
 		}
@@ -5432,35 +5865,22 @@
 			if (!this.state.pageSteps[targetPageId]) this.state.pageSteps[targetPageId] = new UndoRedo();
 			return this.state.pageSteps[targetPageId];
 		}
-		setCanUndoRedo() {
-			const undoRedo = this.getUndoRedo();
-			this.state.canRedo = undoRedo?.canRedo() || false;
-			this.state.canUndo = undoRedo?.canUndo() || false;
-		}
 		/**
-		* 按 id 获取（或创建）指定代码块的 UndoRedo 栈。
+		* 把基础 dbName 与当前 DSL（root app）的 id 拼成最终库名，实现不同应用历史隔离。
+		* 取不到 app id（如尚未加载 DSL）时退回基础 dbName。
 		*/
-		getCodeBlockUndoRedo(codeBlockId) {
-			if (!this.state.codeBlockState[codeBlockId]) this.state.codeBlockState[codeBlockId] = new UndoRedo();
-			return this.state.codeBlockState[codeBlockId];
+		resolveDbName(dbName, appId) {
+			const resolvedAppId = appId ?? editor_default.get("root")?.id;
+			return resolvedAppId ? `${dbName}-${resolvedAppId}` : dbName;
 		}
-		/**
-		* 按 id 获取（或创建）指定数据源的 UndoRedo 栈。
-		*/
-		getDataSourceUndoRedo(dataSourceId) {
-			if (!this.state.dataSourceState[dataSourceId]) this.state.dataSourceState[dataSourceId] = new UndoRedo();
-			return this.state.dataSourceState[dataSourceId];
+		setCanUndoRedo() {
+			const undoRedo = this.getUndoRedo();
+			this.state.canRedo = undoRedo?.canRedo() || false;
+			this.state.canUndo = undoRedo ? undoRedo.getCursor() > undoFloor(undoRedo) : false;
 		}
 	};
 	var history_default = new History();
 	//#endregion
-	//#region packages/editor/src/utils/config.ts
-	var $TMAGIC_EDITOR = {};
-	var setEditorConfig = (option) => {
-		$TMAGIC_EDITOR = option;
-	};
-	var getEditorConfig = (key) => $TMAGIC_EDITOR[key];
-	//#endregion
 	//#region packages/editor/src/services/storage.ts
 	var Protocol = /* @__PURE__ */ function(Protocol) {
 		Protocol["OBJECT"] = "object";
@@ -6010,6 +6430,40 @@
 			aborted: false
 		};
 	};
+	/**
+	* 给「回滚」生成的新 step 用的简短描述生成器。
+	* 与 UI 层 `describePageStep` 同义，但避免 service 反向依赖 layouts/，故放在此工具函数中。
+	*/
+	var describeStepForRevert = (step) => {
+		const items = step.diff ?? [];
+		const withId = (node, label) => {
+			const id = node?.id;
+			if (id === void 0 || id === null || `${id}` === "") return label;
+			return label ? `${label}（id: ${id}）` : `id: ${id}`;
+		};
+		switch (step.opType) {
+			case "add": {
+				const count = items.length;
+				const node = items[0]?.newSchema;
+				const label = node?.name || node?.type || "";
+				return `撤回新增 ${count} 个节点${count === 1 ? `（${withId(node, label)}）` : ""}`;
+			}
+			case "remove": {
+				const count = items.length;
+				const node = items[0]?.oldSchema;
+				const label = node?.name || node?.type || "";
+				return `还原已删除的 ${count} 个节点${count === 1 ? `（${withId(node, label)}）` : ""}`;
+			}
+			default:
+				if (items.length === 1) {
+					const { newSchema, oldSchema, changeRecords } = items[0];
+					const target = withId(newSchema || oldSchema, newSchema?.name || newSchema?.type || oldSchema?.name || oldSchema?.type || "");
+					const propPath = changeRecords?.[0]?.propPath;
+					return propPath ? `还原 ${target} · ${propPath}` : `还原 ${target}`;
+				}
+				return `还原 ${items.length} 个节点的修改`;
+		}
+	};
 	//#endregion
 	//#region packages/editor/src/utils/operator.ts
 	/**
@@ -6078,35 +6532,15 @@
 	//#endregion
 	//#region packages/editor/src/services/editor.ts
 	/**
-	* 给「回滚」生成的新 step 用的简短描述生成器。
-	* 与 UI 层 `describePageStep` 同义，但避免 service 反向依赖 layouts/，故在此本地实现。
+	* 把「变更前后节点快照」列表归一成 update 类型的 {@link StepDiffItem} 列表，供 {@link StepValue.diff} 使用。
+	* `changeRecords` 来自 form 端的 propPath/value 列表，撤销/重做时只对这些 propPath 做局部更新；
+	* 缺省（未传 / 空数组）才退化为整节点替换。
 	*/
-	var describeStepForRevert = (step) => {
-		switch (step.opType) {
-			case "add": {
-				const count = step.nodes?.length ?? 0;
-				const node = step.nodes?.[0];
-				const label = node?.name || node?.type || (node?.id !== void 0 ? `${node.id}` : "");
-				return `撤回新增 ${count} 个节点${count === 1 && label ? `（${label}）` : ""}`;
-			}
-			case "remove": {
-				const count = step.removedItems?.length ?? 0;
-				const node = step.removedItems?.[0]?.node;
-				const label = node?.name || node?.type || (node?.id !== void 0 ? `${node.id}` : "");
-				return `还原已删除的 ${count} 个节点${count === 1 && label ? `（${label}）` : ""}`;
-			}
-			default: {
-				const items = step.updatedItems ?? [];
-				if (items.length === 1) {
-					const { newNode, oldNode, changeRecords } = items[0];
-					const target = newNode?.name || newNode?.type || oldNode?.name || oldNode?.type || `${newNode?.id ?? ""}`;
-					const propPath = changeRecords?.[0]?.propPath;
-					return propPath ? `还原 ${target} · ${propPath}` : `还原 ${target}`;
-				}
-				return `还原 ${items.length} 个节点的修改`;
-			}
-		}
-	};
+	var buildUpdateDiff = (items) => items.map(({ oldNode, newNode, changeRecords }) => ({
+		oldSchema: oldNode,
+		newSchema: newNode,
+		...changeRecords?.length ? { changeRecords } : {}
+	}));
 	var Editor = class extends BaseService {
 		state = (0, vue.reactive)({
 			root: null,
@@ -6124,6 +6558,12 @@
 			alwaysMultiSelect: false
 		});
 		selectionBeforeOp = null;
+		/**
+		* 最近一次 pushOpHistory 写入的历史记录 uuid。
+		* 供 *AndGetHistoryId 系列方法在调用普通操作后取回本次产生的历史记录 id；
+		* 普通操作不会读取它，调用前由 *AndGetHistoryId 重置为 null。
+		*/
+		lastPushedHistoryId = null;
 		constructor() {
 			super(canUsePluginMethods.async.map((methodName) => ({
 				name: methodName,
@@ -6138,8 +6578,9 @@
 		* 设置当前指点节点配置
 		* @param name 'root' | 'page' | 'parent' | 'node' | 'highlightNode' | 'nodes' | 'stage' | 'modifiedNodeIds' | 'pageLength' | 'pageFragmentLength
 		* @param value MNode
+		* @param options.historySource 设置 root 时，本次变更写入历史记录的「操作来源」（仅 name === 'root' 时生效）
 		*/
-		set(name, value) {
+		set(name, value, options = {}) {
 			const preValue = this.state[name];
 			this.state[name] = value;
 			if (name === "nodes" && Array.isArray(value)) this.set("node", value[0]);
@@ -6150,6 +6591,13 @@
 					this.state.pageLength = getPageList(app).length || 0;
 					this.state.pageFragmentLength = getPageFragmentList(app).length || 0;
 					this.state.stageLoading = this.state.pageLength !== 0;
+					if (preValue && !isEmpty(preValue)) this.pushRootDiffHistory(preValue, app, options.historySource);
+					else app.items?.forEach((pageNode) => {
+						if (pageNode?.id !== void 0 && !history_default.getPageMarker(pageNode.id)) history_default.setPageMarker(pageNode.id, {
+							name: pageNode.name,
+							source: options.historySource
+						});
+					});
 				} else {
 					this.state.pageLength = 0;
 					this.state.pageFragmentLength = 0;
@@ -6175,7 +6623,23 @@
 		getNodeInfo(id, raw = true) {
 			let root = this.get("root");
 			if (raw) root = (0, vue.toRaw)(root);
-			return (0, _tmagic_utils.getNodeInfo)(id, root);
+			if (!root) return {
+				node: null,
+				parent: null,
+				page: null
+			};
+			if (id === root.id) return {
+				node: root,
+				parent: null,
+				page: null
+			};
+			const pageIdStr = `${this.get("page")?.id || ""}`;
+			const currentPageNode = root.items?.find((item) => `${item.id}` === pageIdStr);
+			if (currentPageNode && `${id}` !== pageIdStr) {
+				const info = (0, _tmagic_utils.getNodeInfo)(id, currentPageNode);
+				if (info.node) return info;
+			}
+			return (0, _tmagic_utils.getNodeInfo)(id, root, currentPageNode);
 		}
 		/**
 		* 根据ID获取指点节点配置
@@ -6368,23 +6832,26 @@
 			}
 			if (!((0, _tmagic_utils.isPage)(newNodes[0]) || (0, _tmagic_utils.isPageFragment)(newNodes[0]))) {
 				const pageForOp = this.getNodeInfo(newNodes[0].id, false).page;
-				if (!doNotPushHistory) this.pushOpHistory("add", {
-					extra: {
-						nodes: newNodes.map((n) => cloneDeep$1((0, vue.toRaw)(n))),
-						parentId: (this.getParentById(newNodes[0].id, false) ?? this.get("root")).id,
-						indexMap: Object.fromEntries(newNodes.map((n) => {
+				if (!doNotPushHistory) {
+					const parentId = (this.getParentById(newNodes[0].id, false) ?? this.get("root")).id;
+					this.pushOpHistory("add", {
+						diff: newNodes.map((n) => {
 							const p = this.getParentById(n.id, false);
-							return [n.id, p ? getNodeIndex(n.id, p) : -1];
-						}))
-					},
-					pageData: {
-						name: pageForOp?.name || "",
-						id: pageForOp.id
-					},
-					historyDescription,
-					source: historySource
-				});
-				else this.selectionBeforeOp = null;
+							const idx = p ? getNodeIndex(n.id, p) : -1;
+							return {
+								newSchema: cloneDeep$1((0, vue.toRaw)(n)),
+								parentId,
+								index: typeof idx === "number" ? idx : -1
+							};
+						}),
+						pageData: {
+							name: pageForOp?.name || "",
+							id: pageForOp.id
+						},
+						historyDescription,
+						source: historySource
+					});
+				} else this.selectionBeforeOp = null;
 			}
 			this.emit("add", newNodes);
 			return Array.isArray(addNode) ? newNodes : newNodes[0];
@@ -6464,7 +6931,7 @@
 					};
 					const idx = getNodeIndex(curNode.id, parent);
 					removedItems.push({
-						node: cloneDeep$1((0, vue.toRaw)(curNode)),
+						oldSchema: cloneDeep$1((0, vue.toRaw)(curNode)),
 						parentId: parent.id,
 						index: typeof idx === "number" ? idx : -1
 					});
@@ -6475,7 +6942,7 @@
 				doNotSwitchPage
 			})));
 			if (removedItems.length > 0 && pageForOp) if (!doNotPushHistory) this.pushOpHistory("remove", {
-				extra: { removedItems },
+				diff: removedItems,
 				pageData: pageForOp,
 				historyDescription,
 				source: historySource
@@ -6483,7 +6950,7 @@
 			else this.selectionBeforeOp = null;
 			this.emit("remove", nodes);
 		}
-		async doUpdate(config, { changeRecords = [] } = {}) {
+		async doUpdate(config, { changeRecords = [], historySource } = {}) {
 			const root = this.get("root");
 			if (!root) throw new Error("root为空");
 			if (!config?.id) throw new Error("没有配置或者配置缺少id值");
@@ -6494,7 +6961,7 @@
 			newConfig = mergeWith(cloneDeep$1(node), newConfig, editorNodeMergeCustomizer);
 			if (!newConfig.type) throw new Error("配置缺少type值");
 			if (newConfig.type === _tmagic_core.NodeType.ROOT) {
-				this.set("root", newConfig);
+				this.set("root", newConfig, { historySource });
 				return {
 					oldNode: node,
 					newNode: newConfig,
@@ -6544,17 +7011,20 @@
 			const nodes = Array.isArray(config) ? config : [config];
 			const updateData = await Promise.all(nodes.map((node, index) => {
 				const recordsForNode = changeRecordList ? changeRecordList[index] ?? [] : changeRecords ?? [];
-				return this.doUpdate(node, { changeRecords: recordsForNode });
+				return this.doUpdate(node, {
+					changeRecords: recordsForNode,
+					historySource
+				});
 			}));
 			if (updateData[0].oldNode?.type !== _tmagic_core.NodeType.ROOT) {
 				if (this.get("nodes").length) if (!doNotPushHistory) {
 					const pageForOp = this.getNodeInfo(nodes[0].id, false).page;
 					this.pushOpHistory("update", {
-						extra: { updatedItems: updateData.map((d) => ({
+						diff: buildUpdateDiff(updateData.map((d) => ({
 							oldNode: cloneDeep$1(d.oldNode),
-							newNode: cloneDeep$1((0, vue.toRaw)(d.newNode)),
+							newNode: cloneDeep$1(d.newNode),
 							changeRecords: d.changeRecords?.length ? cloneDeep$1(d.changeRecords) : void 0
-						})) },
+						}))),
 						pageData: {
 							name: pageForOp?.name || "",
 							id: pageForOp.id
@@ -6717,10 +7187,10 @@
 			if (!doNotPushHistory) {
 				const pageForOp = this.getNodeInfo(node.id, false).page;
 				this.pushOpHistory("update", {
-					extra: { updatedItems: [{
+					diff: buildUpdateDiff([{
 						oldNode: oldParent,
 						newNode: cloneDeep$1((0, vue.toRaw)(parent))
-					}] },
+					}]),
 					pageData: {
 						name: pageForOp?.name || "",
 						id: pageForOp.id
@@ -6794,7 +7264,7 @@
 					id: target.id
 				};
 				this.pushOpHistory("update", {
-					extra: { updatedItems },
+					diff: buildUpdateDiff(updatedItems),
 					pageData: historyPage,
 					historyDescription,
 					source: historySource
@@ -6845,7 +7315,7 @@
 			if (!doNotPushHistory) {
 				const pageForOp = this.getNodeInfo(configs[0].id, false).page;
 				this.pushOpHistory("update", {
-					extra: { updatedItems },
+					diff: buildUpdateDiff(updatedItems),
 					pageData: {
 						name: pageForOp?.name || "",
 						id: pageForOp.id
@@ -6861,6 +7331,49 @@
 			});
 		}
 		/**
+		* 下列 *AndGetHistoryId 方法与对应的普通操作（add / remove / update ...）行为完全一致，
+		* 唯一区别是返回值为本次写入历史栈的历史记录 uuid（{@link StepValue.uuid}），
+		* 而非节点 / 节点数组。可用于精确引用 / 定位该条历史记录（埋点、revert、跨端同步等）。
+		*
+		* 当本次操作未写入历史（doNotPushHistory 为 true、或操作无实际变更 / 提前返回）时返回 null。
+		*/
+		/** 等价于 {@link add}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async addAndGetHistoryId(addNode, parent, options = {}) {
+			this.lastPushedHistoryId = null;
+			await this.add(addNode, parent, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link remove}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async removeAndGetHistoryId(nodeOrNodeList, options = {}) {
+			this.lastPushedHistoryId = null;
+			await this.remove(nodeOrNodeList, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link update}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async updateAndGetHistoryId(config, data = {}) {
+			this.lastPushedHistoryId = null;
+			await this.update(config, data);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link moveLayer}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async moveLayerAndGetHistoryId(offset, options = {}) {
+			this.lastPushedHistoryId = null;
+			await this.moveLayer(offset, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link moveToContainer}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async moveToContainerAndGetHistoryId(config, targetId, options = {}) {
+			this.lastPushedHistoryId = null;
+			await this.moveToContainer(config, targetId, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link dragTo}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async dragToAndGetHistoryId(config, targetParent, targetIndex, options = {}) {
+			this.lastPushedHistoryId = null;
+			await this.dragTo(config, targetParent, targetIndex, options);
+			return this.lastPushedHistoryId;
+		}
+		/**
 		* 撤销当前操作
 		* @returns 被撤销的操作
 		*/
@@ -6898,9 +7411,10 @@
 			const entry = history_default.getPageStepList()[index];
 			if (!entry?.applied) return null;
 			const { step } = entry;
+			if (step.opType === "initial") return null;
 			if (!this.get("root")) return null;
 			if (step.opType === "update") {
-				const items = step.updatedItems ?? [];
+				const items = step.diff ?? [];
 				if (!items.length || !items.every((item) => item.changeRecords?.length)) return null;
 			}
 			let revertedStep = null;
@@ -6917,24 +7431,26 @@
 			};
 			try {
 				switch (step.opType) {
-					case "add": {
-						const nodes = step.nodes ?? [];
-						for (const n of nodes) {
-							const existing = this.getNodeById(n.id, false);
+					case "add":
+						for (const { newSchema } of step.diff ?? []) {
+							if (!newSchema) continue;
+							const existing = this.getNodeById(newSchema.id, false);
 							if (existing) await this.remove(existing, opts);
 						}
 						break;
-					}
 					case "remove": {
-						const sorted = [...step.removedItems ?? []].sort((a, b) => a.index - b.index);
-						for (const { node, parentId } of sorted) {
+						const sorted = [...step.diff ?? []].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+						for (const { oldSchema, parentId } of sorted) {
+							if (!oldSchema || parentId === void 0) continue;
 							const parent = this.getNodeById(parentId, false);
-							if (parent) await this.add([cloneDeep$1(node)], parent, opts);
+							if (parent) await this.add([cloneDeep$1(oldSchema)], parent, opts);
 						}
 						break;
 					}
 					case "update": {
-						const configs = (step.updatedItems ?? []).map(({ oldNode, newNode, changeRecords }) => {
+						const configs = (step.diff ?? []).filter((item) => item.oldSchema && item.newSchema).map(({ oldSchema, newSchema, changeRecords }) => {
+							const oldNode = oldSchema;
+							const newNode = newSchema;
 							if (changeRecords?.length) {
 								const patch = {
 									id: newNode.id,
@@ -6964,6 +7480,19 @@
 			return revertedStep;
 		}
 		/**
+		* 通过历史记录 uuid 回滚当前页面的某条历史步骤，语义与 {@link revertPageStep} 完全一致，
+		* 仅入参从 index 改为 uuid（{@link StepValue.uuid}）。uuid 不随栈内步骤增删而变化，
+		* 更适合业务侧持有引用后再回滚（埋点、跨端同步等场景）。
+		*
+		* @param uuid 目标历史记录的 uuid，通常由 *AndGetHistoryId 方法返回
+		* @returns 反向后产生的新 step；找不到对应 uuid / 未应用 / 反向失败时返回 null
+		*/
+		async revertPageStepById(uuid) {
+			const index = history_default.getPageStepIndexByUuid(uuid);
+			if (index < 0) return null;
+			return this.revertPageStep(index);
+		}
+		/**
 		* 跳转当前页面历史栈到指定游标位置。
 		*
 		* `targetCursor` 与 `UndoRedo.getCursor()` 同义：表示"已应用步骤数量"，
@@ -7039,19 +7568,83 @@
 			if (this.selectionBeforeOp) return;
 			this.selectionBeforeOp = this.get("nodes").map((n) => n.id);
 		}
-		pushOpHistory(opType, { extra, pageData, historyDescription, source }) {
+		/**
+		* 比较「上一次 root」与「新 root」的页面 / 页面片，按页面粒度把整体替换拆成历史记录：
+		* - 新旧都存在且内容变化的页面 → 一条 `update`（整页快照替换，无 changeRecords）；
+		* - 仅新 root 存在的页面 → 一条 `add`；
+		* - 仅旧 root 存在的页面 → 一条 `remove`。
+		*
+		* 每条记录落到对应页面自己的历史栈（与普通节点操作一致），并标记来源 `source`。
+		* 内容未变化的页面不产生记录，避免重复设置相同 DSL 时产生噪声。
+		*/
+		pushRootDiffHistory(preRoot, nextRoot, source) {
+			const prevPages = preRoot?.items || [];
+			const nextPages = nextRoot?.items || [];
+			const prevMap = new Map(prevPages.map((p) => [`${p.id}`, p]));
+			const nextMap = new Map(nextPages.map((p) => [`${p.id}`, p]));
+			const indexInItems = (root, id) => (root.items ?? []).findIndex((item) => `${item.id}` === `${id}`);
+			nextPages.forEach((nextPage) => {
+				const prevPage = prevMap.get(`${nextPage.id}`);
+				if (!prevPage) this.pushPageDiffStep("add", nextPage, {
+					newSchema: cloneDeep$1((0, vue.toRaw)(nextPage)),
+					parentId: nextRoot.id,
+					index: indexInItems(nextRoot, nextPage.id)
+				}, source);
+				else if (!isEqual((0, vue.toRaw)(prevPage), (0, vue.toRaw)(nextPage))) this.pushPageDiffStep("update", nextPage, {
+					oldSchema: cloneDeep$1((0, vue.toRaw)(prevPage)),
+					newSchema: cloneDeep$1((0, vue.toRaw)(nextPage))
+				}, source);
+			});
+			prevPages.forEach((prevPage) => {
+				if (!nextMap.has(`${prevPage.id}`)) this.pushPageDiffStep("remove", prevPage, {
+					oldSchema: cloneDeep$1((0, vue.toRaw)(prevPage)),
+					parentId: preRoot.id,
+					index: indexInItems(preRoot, prevPage.id)
+				}, source);
+			});
+		}
+		/**
+		* 构造一条页面级「set root」历史记录（不携带选区 / modifiedNodeIds 上下文）并落到该页面自己的栈。
+		*
+		* 连续 set root 替换：若该页栈最新一条已是**同来源**的 set root 记录（{@link StepValue.rootStep} 且 `source` 相同），
+		* 则用本次记录**替换**它而非新增，避免源码反复保存 / 外部重设 DSL 时堆积多条 root 记录；
+		* 来源不同则照常新增（initial 基线不是 rootStep，不在此列）。
+		*/
+		pushPageDiffStep(opType, page, diffItem, source) {
+			const step = {
+				uuid: (0, _tmagic_utils.guid)(),
+				data: {
+					name: page.name || "",
+					id: page.id
+				},
+				opType,
+				selectedBefore: [],
+				selectedAfter: [],
+				modifiedNodeIds: /* @__PURE__ */ new Map(),
+				diff: [diffItem],
+				rootStep: true
+			};
+			if (source) step.source = source;
+			const top = history_default.getCurrentPageStep(page.id);
+			if (top?.rootStep && top.source === source) history_default.replaceCurrentPageStep(step, page.id);
+			else history_default.push(step, page.id);
+		}
+		pushOpHistory(opType, { diff, pageData, historyDescription, source }) {
 			const step = {
+				uuid: (0, _tmagic_utils.guid)(),
 				data: pageData,
 				opType,
 				selectedBefore: this.selectionBeforeOp ?? [],
 				selectedAfter: this.get("nodes").map((n) => n.id),
 				modifiedNodeIds: new Map(this.get("modifiedNodeIds")),
-				...extra
+				diff
 			};
 			if (historyDescription) step.historyDescription = historyDescription;
 			if (source) step.source = source;
-			history_default.push(step, pageData.id);
+			const historyId = history_default.push(step, pageData.id) ? step.uuid : null;
+			this.lastPushedHistoryId = historyId;
 			this.selectionBeforeOp = null;
+			return historyId;
 		}
 		/**
 		* 应用历史操作（撤销 / 重做）
@@ -7066,6 +7659,7 @@
 		* @param reverse true = 撤销，false = 重做
 		*/
 		async applyHistoryOp(step, reverse) {
+			if (step.opType === "initial") return;
 			const root = this.get("root");
 			const stage = this.get("stage");
 			if (!root) return;
@@ -7076,56 +7670,59 @@
 			};
 			switch (step.opType) {
 				case "add": {
-					const nodes = step.nodes ?? [];
-					if (reverse) for (const n of nodes) {
-						const existing = this.getNodeById(n.id, false);
+					const items = step.diff ?? [];
+					if (reverse) for (const { newSchema } of items) {
+						if (!newSchema) continue;
+						const existing = this.getNodeById(newSchema.id, false);
 						if (existing) await this.remove(existing, commonOpts);
 					}
 					else {
-						const parent = this.getNodeById(step.parentId, false);
-						if (parent) {
-							const sorted = [...nodes].sort((a, b) => (step.indexMap?.[a.id] ?? 0) - (step.indexMap?.[b.id] ?? 0));
-							for (const n of sorted) {
-								const idx = step.indexMap?.[n.id];
-								if (parent.items) {
-									if (typeof idx === "number" && idx >= 0 && idx < parent.items.length) parent.items.splice(idx, 0, cloneDeep$1(n));
-									else parent.items.push(cloneDeep$1(n));
-									await stage?.add({
-										config: cloneDeep$1(n),
-										parent: cloneDeep$1(parent),
-										parentId: parent.id,
-										root: cloneDeep$1(root)
-									});
-								}
+						const sorted = [...items].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+						for (const { newSchema, parentId, index } of sorted) {
+							if (!newSchema || parentId === void 0) continue;
+							const parent = this.getNodeById(parentId, false);
+							if (parent?.items) {
+								if (typeof index === "number" && index >= 0 && index < parent.items.length) parent.items.splice(index, 0, cloneDeep$1(newSchema));
+								else parent.items.push(cloneDeep$1(newSchema));
+								await stage?.add({
+									config: cloneDeep$1(newSchema),
+									parent: cloneDeep$1(parent),
+									parentId: parent.id,
+									root: cloneDeep$1(root)
+								});
 							}
 						}
 					}
 					break;
 				}
 				case "remove": {
-					const items = step.removedItems ?? [];
+					const items = step.diff ?? [];
 					if (reverse) {
-						const sorted = [...items].sort((a, b) => a.index - b.index);
-						for (const { node, parentId, index } of sorted) {
+						const sorted = [...items].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+						for (const { oldSchema, parentId, index } of sorted) {
+							if (!oldSchema || parentId === void 0) continue;
 							const parent = this.getNodeById(parentId, false);
 							if (parent?.items) {
-								parent.items.splice(index, 0, cloneDeep$1(node));
+								parent.items.splice(index ?? parent.items.length, 0, cloneDeep$1(oldSchema));
 								await stage?.add({
-									config: cloneDeep$1(node),
+									config: cloneDeep$1(oldSchema),
 									parent: cloneDeep$1(parent),
 									parentId,
 									root: cloneDeep$1(root)
 								});
 							}
 						}
-					} else for (const { node } of items) {
-						const existing = this.getNodeById(node.id, false);
+					} else for (const { oldSchema } of items) {
+						if (!oldSchema) continue;
+						const existing = this.getNodeById(oldSchema.id, false);
 						if (existing) await this.remove(existing, commonOpts);
 					}
 					break;
 				}
 				case "update": {
-					const configs = (step.updatedItems ?? []).map(({ oldNode, newNode, changeRecords }) => {
+					const configs = (step.diff ?? []).filter((item) => item.oldSchema && item.newSchema).map(({ oldSchema, newSchema, changeRecords }) => {
+						const oldNode = oldSchema;
+						const newNode = newSchema;
 						if (changeRecords?.length) {
 							const sourceForValues = reverse ? oldNode : newNode;
 							const patch = {
@@ -7206,6 +7803,7 @@
 		showPageListButton: true,
 		hideSlideBar: false,
 		sideBarItems: [],
+		sideBarActiveTabName: "",
 		navMenuRect: {
 			left: 0,
 			top: 0,
@@ -7238,7 +7836,9 @@
 			}
 			if (name === "showGuides") mask?.showGuides(value);
 			if (name === "showRule") mask?.showRule(value);
+			const preValue = state[name];
 			state[name] = value;
+			if (preValue !== value) this.emit("state-change", name, value, preValue);
 		}
 		get(name) {
 			return state[name];
@@ -8461,7 +9061,7 @@
 		key: 1,
 		class: "menu-item-text"
 	};
-	var _hoisted_2$28 = { class: "el-dropdown-link menubar-menu-button" };
+	var _hoisted_2$30 = { class: "el-dropdown-link menubar-menu-button" };
 	var ToolButton_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorToolButton",
 		__name: "ToolButton",
@@ -8526,11 +9126,11 @@
 					placement: "bottom-start",
 					content: __props.data.tooltip
 				}, {
-					default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+					default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), (0, vue.mergeProps)({
 						size: "small",
 						link: "",
 						disabled: disabled.value
-					}, (0, vue.createSlots)({ _: 2 }, [__props.data.icon ? {
+					}, __props.data.buttonProps || {}), (0, vue.createSlots)({ _: 2 }, [__props.data.icon ? {
 						name: "icon",
 						fn: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: __props.data.icon }, null, 8, ["icon"])]),
 						key: "0"
@@ -8538,15 +9138,15 @@
 						name: "default",
 						fn: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(__props.data.text), 1)]),
 						key: "1"
-					} : void 0]), 1032, ["disabled"])]),
+					} : void 0]), 1040, ["disabled"])]),
 					_: 1
-				}, 8, ["content"])) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicButton), {
+				}, 8, ["content"])) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicButton), (0, vue.mergeProps)({
 					key: 1,
 					size: "small",
 					link: "",
 					disabled: disabled.value,
 					title: __props.data.text
-				}, (0, vue.createSlots)({ _: 2 }, [__props.data.icon ? {
+				}, __props.data.buttonProps || {}), (0, vue.createSlots)({ _: 2 }, [__props.data.icon ? {
 					name: "icon",
 					fn: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: __props.data.icon }, null, 8, ["icon"])]),
 					key: "0"
@@ -8554,7 +9154,7 @@
 					name: "default",
 					fn: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(__props.data.text), 1)]),
 					key: "1"
-				} : void 0]), 1032, ["disabled", "title"]))], 64)) : __props.data.type === "dropdown" ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicDropdown), {
+				} : void 0]), 1040, ["disabled", "title"]))], 64)) : __props.data.type === "dropdown" ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicDropdown), {
 					key: 3,
 					trigger: "click",
 					disabled: disabled.value,
@@ -8575,7 +9175,7 @@
 						}), 128))]),
 						_: 1
 					})) : (0, vue.createCommentVNode)("v-if", true)]),
-					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("span", _hoisted_2$28, [(0, vue.createTextVNode)((0, vue.toDisplayString)(__props.data.text), 1), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicIcon), { class: "el-icon--right" }, {
+					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("span", _hoisted_2$30, [(0, vue.createTextVNode)((0, vue.toDisplayString)(__props.data.text), 1), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicIcon), { class: "el-icon--right" }, {
 						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_element_plus_icons_vue.ArrowDown))]),
 						_: 1
 					})])]),
@@ -8594,7 +9194,7 @@
 		id: "m-editor-page-bar-add-icon",
 		class: "m-editor-page-bar-item m-editor-page-bar-item-icon"
 	};
-	var _hoisted_2$27 = {
+	var _hoisted_2$29 = {
 		key: 1,
 		style: { "width": "21px" }
 	};
@@ -8631,7 +9231,7 @@
 						}
 					} }, null, 8, ["data"])]),
 					_: 1
-				})])) : ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_2$27));
+				})])) : ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_2$29));
 			};
 		}
 	});
@@ -8644,7 +9244,7 @@
 		class: "m-editor-page-bar",
 		ref: "pageBar"
 	};
-	var _hoisted_2$26 = {
+	var _hoisted_2$28 = {
 		key: 0,
 		class: "m-editor-page-bar-items",
 		ref: "itemsContainer"
@@ -8736,7 +9336,7 @@
 			return (_ctx, _cache) => {
 				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$68, [
 					(0, vue.renderSlot)(_ctx.$slots, "prepend"),
-					__props.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_2$26, [(0, vue.renderSlot)(_ctx.$slots, "default")], 512)) : (0, vue.createCommentVNode)("v-if", true),
+					__props.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_2$28, [(0, vue.renderSlot)(_ctx.$slots, "default")], 512)) : (0, vue.createCommentVNode)("v-if", true),
 					canScroll.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
 						key: 1,
 						class: "m-editor-page-bar-item m-editor-page-bar-item-icon m-editor-page-bar-item-left-icon",
@@ -8761,8 +9361,8 @@
 		id: "m-editor-page-bar-list-icon",
 		class: "m-editor-page-bar-item m-editor-page-bar-item-icon"
 	};
-	var _hoisted_2$25 = { class: "page-bar-popover-wrapper" };
-	var _hoisted_3$10 = { class: "page-bar-popover-inner" };
+	var _hoisted_2$27 = { class: "page-bar-popover-wrapper" };
+	var _hoisted_3$13 = { class: "page-bar-popover-inner" };
 	var PageList_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorPageList",
 		__name: "PageList",
@@ -8786,7 +9386,7 @@
 						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_element_plus_icons_vue.Files))]),
 						_: 1
 					})]),
-					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", _hoisted_2$25, [(0, vue.createElementVNode)("div", _hoisted_3$10, [(0, vue.renderSlot)(_ctx.$slots, "page-list-popover", { list: __props.list }, () => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.list, (item, index) => {
+					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", _hoisted_2$27, [(0, vue.createElementVNode)("div", _hoisted_3$13, [(0, vue.renderSlot)(_ctx.$slots, "page-list-popover", { list: __props.list }, () => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.list, (item, index) => {
 						return (0, vue.openBlock)(), (0, vue.createBlock)(ToolButton_default, {
 							data: {
 								type: "button",
@@ -8865,9 +9465,9 @@
 	//#endregion
 	//#region packages/editor/src/layouts/page-bar/PageBar.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$65 = { class: "m-editor-page-bar-tabs" };
-	var _hoisted_2$24 = ["data-page-id", "onClick"];
-	var _hoisted_3$9 = { class: "m-editor-page-bar-title" };
-	var _hoisted_4$8 = ["title"];
+	var _hoisted_2$26 = ["data-page-id", "onClick"];
+	var _hoisted_3$12 = { class: "m-editor-page-bar-title" };
+	var _hoisted_4$9 = ["title"];
 	var PageBar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorPageBar",
 		__name: "PageBar",
@@ -8909,7 +9509,8 @@
 					top: 0
 				});
 			};
-			const remove = (node) => {
+			const remove = async (node) => {
+				await _tmagic_design.tMagicMessageBox.confirm("确定删除该页面吗？");
 				editorService.remove(node);
 			};
 			const pageBarScrollContainerRef = (0, vue.useTemplateRef)("pageBarScrollContainer");
@@ -8956,7 +9557,7 @@
 							key: item.id,
 							"data-page-id": item.id,
 							onClick: ($event) => switchPage(item.id)
-						}, [(0, vue.createElementVNode)("div", _hoisted_3$9, [(0, vue.renderSlot)(_ctx.$slots, "page-bar-title", { page: item }, () => [(0, vue.createElementVNode)("span", { title: item.name }, (0, vue.toDisplayString)(item.name || item.id), 9, _hoisted_4$8)])]), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicPopover), {
+						}, [(0, vue.createElementVNode)("div", _hoisted_3$12, [(0, vue.renderSlot)(_ctx.$slots, "page-bar-title", { page: item }, () => [(0, vue.createElementVNode)("span", { title: item.name }, (0, vue.toDisplayString)(item.name || item.id), 9, _hoisted_4$9)])]), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicPopover), {
 							"popper-class": "page-bar-popover",
 							placement: "top",
 							trigger: "hover",
@@ -8976,10 +9577,11 @@
 								type: "button",
 								text: "删除",
 								icon: (0, vue.unref)(_element_plus_icons_vue.Delete),
+								buttonProps: { type: "danger" },
 								handler: () => remove(item)
 							} }, null, 8, ["data"])])])]),
 							_: 2
-						}, 1024)], 10, _hoisted_2$24);
+						}, 1024)], 10, _hoisted_2$26);
 					}), 128))]),
 					_: 3
 				}, 8, ["page-bar-sort-options", "length"])]);
@@ -8992,7 +9594,7 @@
 	//#endregion
 	//#region packages/editor/src/layouts/AddPageBox.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$64 = { class: "m-editor-empty-panel" };
-	var _hoisted_2$23 = { class: "m-editor-empty-content" };
+	var _hoisted_2$25 = { class: "m-editor-empty-content" };
 	var AddPageBox_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorAddPageBox",
 		__name: "AddPageBox",
@@ -9009,7 +9611,7 @@
 				});
 			};
 			return (_ctx, _cache) => {
-				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$64, [(0, vue.createElementVNode)("div", _hoisted_2$23, [(0, vue.createElementVNode)("div", {
+				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$64, [(0, vue.createElementVNode)("div", _hoisted_2$25, [(0, vue.createElementVNode)("div", {
 					class: "m-editor-empty-button",
 					onClick: _cache[0] || (_cache[0] = ($event) => clickHandler((0, vue.unref)(_tmagic_core.NodeType).PAGE))
 				}, [(0, vue.createElementVNode)("div", null, [(0, vue.createVNode)(Icon_default, { icon: (0, vue.unref)(_element_plus_icons_vue.Plus) }, null, 8, ["icon"])]), _cache[2] || (_cache[2] = (0, vue.createElementVNode)("p", null, "新增页面", -1))]), !__props.disabledPageFragment ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
@@ -9026,7 +9628,7 @@
 	//#endregion
 	//#region packages/editor/src/layouts/CodeEditor.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$63 = { class: "magic-code-editor" };
-	var _hoisted_2$22 = {
+	var _hoisted_2$24 = {
 		ref: "codeEditor",
 		class: "magic-code-editor-content"
 	};
@@ -9281,7 +9883,7 @@
 				}, {
 					default: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: (0, vue.unref)(_element_plus_icons_vue.FullScreen) }, null, 8, ["icon"])]),
 					_: 1
-				})) : (0, vue.createCommentVNode)("v-if", true), (0, vue.createElementVNode)("div", _hoisted_2$22, null, 512)], 6)], 8, ["disabled"]))]);
+				})) : (0, vue.createCommentVNode)("v-if", true), (0, vue.createElementVNode)("div", _hoisted_2$24, null, 512)], 6)], 8, ["disabled"]))]);
 			};
 		}
 	});
@@ -9348,7 +9950,7 @@
 			const saveCode = (value) => {
 				try {
 					const parseDSL = getEditorConfig("parseDSL");
-					editorService.set("root", parseDSL(value));
+					editorService.set("root", parseDSL(value), { historySource: "root-code" });
 				} catch (e) {
 					console.error(e);
 				}
@@ -9422,6 +10024,8 @@
 	var Framework_default = Framework_vue_vue_type_script_setup_true_lang_default;
 	//#endregion
 	//#region packages/editor/src/layouts/history-list/composables.ts
+	/** 合并组默认展开；仅当 expanded[key] === false 时为收起。 */
+	var isHistoryGroupExpanded = (expanded, key) => expanded[key] !== false;
 	/**
 	* 历史记录面板共享逻辑：
 	* - 暴露三类历史的聚合数据（页面 / 数据源 / 代码块）；
@@ -9435,10 +10039,11 @@
 		/**
 		* 折叠状态：key 形如 `pg-${组内首步 index}` / `ds-${id}-${组内首步 index}` / `cb-${id}-${组内首步 index}`。
 		* 用组内首步的稳定 index（而非展示位置）作为 key，确保历史数据更新后已展开的分组状态保持不变。
+		* 合并组默认展开；仅当值为 `false` 时表示收起。
 		*/
 		const expanded = (0, vue.reactive)({});
 		const toggleGroup = (key) => {
-			expanded[key] = !expanded[key];
+			expanded[key] = expanded[key] === false;
 		};
 		const pageGroups = (0, vue.computed)(() => historyService.getPageHistoryGroups());
 		const dataSourceGroups = (0, vue.computed)(() => historyService.getDataSourceHistoryGroups());
@@ -9500,6 +10105,7 @@
 		"component-panel": "组件面板",
 		props: "配置面板",
 		code: "源码",
+		"root-code": "DSL源码",
 		"stage-contextmenu": "画布菜单",
 		"tree-contextmenu": "树菜单",
 		toolbar: "工具栏",
@@ -9507,6 +10113,8 @@
 		rollback: "回滚",
 		api: "接口",
 		ai: "AI",
+		initial: "初始值",
+		sync: "同步",
 		unknown: "未知"
 	};
 	/** 操作途径文案：用于历史面板展示「画布 / 树面板 / 配置面板…」标签。 */
@@ -9515,6 +10123,37 @@
 	};
 	/** 取一组历史步骤里最后一步（最近一次）的操作途径，用于组头部展示。 */
 	var groupSource = (group) => group.steps[group.steps.length - 1]?.step.source;
+	/**
+	* 把一个历史分组（页面 / bucket）派生为 GroupRow 直接消费的视图模型 {@link HistoryRowGroup}。
+	* 统一了原先 PageTab / Bucket 各自内联的 sub-steps 映射逻辑：描述、可差异、可回滚、时间、途径
+	* 全部在此一次性算好，组件层只负责渲染。
+	*/
+	var toRowGroup = (group, key, descriptor) => {
+		const { describeGroup, describeStep, isStepDiffable, isStepRevertable } = descriptor;
+		const timestamp = groupTimestamp(group);
+		return {
+			key,
+			applied: group.applied,
+			isCurrent: Boolean(group.isCurrent),
+			opType: group.opType,
+			desc: describeGroup(group),
+			source: groupSource(group),
+			time: formatHistoryTime(timestamp),
+			timeTitle: formatHistoryFullTime(timestamp),
+			subSteps: group.steps.map((s) => ({
+				index: s.index,
+				applied: s.applied,
+				isCurrent: s.isCurrent,
+				saved: s.step.saved,
+				desc: describeStep(s.step),
+				diffable: isStepDiffable ? isStepDiffable(s.step) : false,
+				revertable: s.applied && (isStepRevertable ? isStepRevertable(s.step) : true),
+				source: s.step.source,
+				time: formatHistoryTime(s.step.timestamp),
+				timeTitle: formatHistoryFullTime(s.step.timestamp)
+			}))
+		};
+	};
 	var nameOf = (node) => node?.name || node?.type || `${node?.id ?? ""}`;
 	/**
 	* 默认描述里展示「名称 (id: xxx)」，便于区分同名实体。
@@ -9533,24 +10172,24 @@
 	var describePageStep = (step) => {
 		if (step.historyDescription) return step.historyDescription;
 		const { opType } = step;
+		const items = step.diff ?? [];
 		if (opType === "add") {
-			const count = step.nodes?.length ?? 0;
-			const node = step.nodes?.[0];
+			const count = items.length;
+			const node = items[0]?.newSchema;
 			return `新增 ${count} 个节点${count === 1 && node ? `（${labelWithId(nameOf(node), node.id)}）` : ""}`;
 		}
 		if (opType === "remove") {
-			const count = step.removedItems?.length ?? 0;
-			const node = step.removedItems?.[0]?.node;
+			const count = items.length;
+			const node = items[0]?.oldSchema;
 			return `删除 ${count} 个节点${count === 1 && node ? `（${labelWithId(nameOf(node), node.id)}）` : ""}`;
 		}
-		const updated = step.updatedItems ?? [];
-		if (!updated.length) return "修改节点";
-		if (updated.length === 1) {
-			const { newNode, changeRecords } = updated[0];
+		if (!items.length) return "修改节点";
+		if (items.length === 1) {
+			const { newSchema, changeRecords } = items[0];
 			const propPath = changeRecords?.[0]?.propPath;
-			return `修改 ${labelWithId(nameOf(newNode), newNode?.id)}${propPath ? ` · ${propPath}` : ""}`;
+			return `修改 ${labelWithId(nameOf(newSchema), newSchema?.id)}${propPath ? ` · ${propPath}` : ""}`;
 		}
-		return `修改 ${updated.length} 个节点`;
+		return `修改 ${items.length} 个节点`;
 	};
 	/**
 	* 合并组的展示文案：
@@ -9564,7 +10203,7 @@
 		if (group.steps.length === 1) return describePageStep(group.steps[0].step);
 		const paths = /* @__PURE__ */ new Set();
 		group.steps.forEach((s) => {
-			s.step.updatedItems?.[0]?.changeRecords?.forEach((r) => r.propPath && paths.add(r.propPath));
+			s.step.diff?.[0]?.changeRecords?.forEach((r) => r.propPath && paths.add(r.propPath));
 		});
 		const pathList = Array.from(paths).slice(0, 3).join(", ");
 		const target = labelWithId(group.targetName ?? (group.targetId !== void 0 ? `${group.targetId}` : "节点"), group.targetId);
@@ -9572,10 +10211,11 @@
 	};
 	var describeDataSourceStep = (step) => {
 		if (step.historyDescription) return step.historyDescription;
-		if (step.oldSchema === null && step.newSchema) return `创建 ${labelWithId(step.newSchema.title, step.newSchema.id ?? step.id)}`;
-		if (step.newSchema === null && step.oldSchema) return `删除 ${labelWithId(step.oldSchema.title, step.oldSchema.id ?? step.id)}`;
-		const propPath = step.changeRecords?.[0]?.propPath;
-		const title = labelWithId(step.newSchema?.title || step.oldSchema?.title, step.id);
+		const { oldSchema, newSchema, changeRecords } = step.diff?.[0] ?? {};
+		if (!oldSchema && newSchema) return `创建 ${labelWithId(newSchema.title, newSchema.id ?? step.id)}`;
+		if (!newSchema && oldSchema) return `删除 ${labelWithId(oldSchema.title, oldSchema.id ?? step.id)}`;
+		const propPath = changeRecords?.[0]?.propPath;
+		const title = labelWithId(newSchema?.title || oldSchema?.title, step.id);
 		return propPath ? `修改 ${title} · ${propPath}` : `修改 ${title}`;
 	};
 	var describeDataSourceGroup = (group) => {
@@ -9584,18 +10224,19 @@
 		if (group.steps.length === 1) return describeDataSourceStep(group.steps[0].step);
 		const paths = /* @__PURE__ */ new Set();
 		group.steps.forEach((s) => {
-			s.step.changeRecords?.forEach((r) => r.propPath && paths.add(r.propPath));
+			s.step.diff?.[0]?.changeRecords?.forEach((r) => r.propPath && paths.add(r.propPath));
 		});
 		const pathList = Array.from(paths).slice(0, 3).join(", ");
-		const target = labelWithId(group.steps[group.steps.length - 1].step.newSchema?.title || group.steps[0].step.oldSchema?.title, group.id);
+		const target = labelWithId(group.steps[group.steps.length - 1].step.diff?.[0]?.newSchema?.title || group.steps[0].step.diff?.[0]?.oldSchema?.title, group.id);
 		return pathList ? `修改 ${target} · ${pathList}${paths.size > 3 ? "…" : ""}` : `修改 ${target}`;
 	};
 	var describeCodeBlockStep = (step) => {
 		if (step.historyDescription) return step.historyDescription;
-		if (step.oldContent === null && step.newContent) return `创建 ${labelWithId(step.newContent.name, step.newContent.id ?? step.id)}`;
-		if (step.newContent === null && step.oldContent) return `删除 ${labelWithId(step.oldContent.name, step.oldContent.id ?? step.id)}`;
-		const propPath = step.changeRecords?.[0]?.propPath;
-		const title = labelWithId(step.newContent?.name || step.oldContent?.name, step.id);
+		const { oldSchema: oldContent, newSchema: newContent, changeRecords } = step.diff?.[0] ?? {};
+		if (!oldContent && newContent) return `创建 ${labelWithId(newContent.name, newContent.id ?? step.id)}`;
+		if (!newContent && oldContent) return `删除 ${labelWithId(oldContent.name, oldContent.id ?? step.id)}`;
+		const propPath = changeRecords?.[0]?.propPath;
+		const title = labelWithId(newContent?.name || oldContent?.name, step.id);
 		return propPath ? `修改 ${title} · ${propPath}` : `修改 ${title}`;
 	};
 	var describeCodeBlockGroup = (group) => {
@@ -9604,10 +10245,10 @@
 		if (group.steps.length === 1) return describeCodeBlockStep(group.steps[0].step);
 		const paths = /* @__PURE__ */ new Set();
 		group.steps.forEach((s) => {
-			s.step.changeRecords?.forEach((r) => r.propPath && paths.add(r.propPath));
+			s.step.diff?.[0]?.changeRecords?.forEach((r) => r.propPath && paths.add(r.propPath));
 		});
 		const pathList = Array.from(paths).slice(0, 3).join(", ");
-		const target = labelWithId(group.steps[group.steps.length - 1].step.newContent?.name || group.steps[0].step.oldContent?.name, group.id);
+		const target = labelWithId(group.steps[group.steps.length - 1].step.diff?.[0]?.newSchema?.name || group.steps[0].step.diff?.[0]?.oldSchema?.name, group.id);
 		return pathList ? `修改 ${target} · ${pathList}${paths.size > 3 ? "…" : ""}` : `修改 ${target}`;
 	};
 	/**
@@ -9618,136 +10259,176 @@
 	*/
 	var isPageStepRevertable = (step) => {
 		if (step.opType !== "update") return true;
-		const items = step.updatedItems ?? [];
+		const items = step.diff ?? [];
 		if (!items.length) return false;
 		return items.every((item) => Boolean(item.changeRecords?.length));
 	};
 	/**
 	* 数据源 step 是否支持「回滚」：
-	* - 新增（oldSchema=null）/ 删除（newSchema=null）：不依赖 changeRecords，始终可回滚；
+	* - 新增（无 oldSchema）/ 删除（无 newSchema）：不依赖 changeRecords，始终可回滚；
 	* - 更新（前后 schema 都存在）：必须有 changeRecords 才支持局部反向 patch，否则不支持回滚。
 	*/
 	var isDataSourceStepRevertable = (step) => {
-		if (step.oldSchema === null || step.newSchema === null) return true;
-		return Boolean(step.changeRecords?.length);
+		const item = step.diff?.[0];
+		if (!item?.oldSchema || !item?.newSchema) return true;
+		return Boolean(item.changeRecords?.length);
 	};
 	/**
 	* 代码块 step 是否支持「回滚」：
-	* - 新增（oldContent=null）/ 删除（newContent=null）：不依赖 changeRecords，始终可回滚；
+	* - 新增（无 oldSchema）/ 删除（无 newSchema）：不依赖 changeRecords，始终可回滚；
 	* - 更新（前后 content 都存在）：必须有 changeRecords 才支持局部反向 patch，否则不支持回滚。
 	*/
 	var isCodeBlockStepRevertable = (step) => {
-		if (step.oldContent === null || step.newContent === null) return true;
-		return Boolean(step.changeRecords?.length);
+		const item = step.diff?.[0];
+		if (!item?.oldSchema || !item?.newSchema) return true;
+		return Boolean(item.changeRecords?.length);
 	};
 	//#endregion
 	//#region packages/editor/src/layouts/history-list/GroupRow.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$61 = ["title"];
-	var _hoisted_2$21 = ["title"];
-	var _hoisted_3$8 = { class: "m-editor-history-list-item-desc" };
-	var _hoisted_4$7 = ["title"];
-	var _hoisted_5$3 = ["title"];
-	var _hoisted_6$3 = {
-		key: 2,
+	var _hoisted_2$23 = ["title"];
+	var _hoisted_3$11 = { class: "m-editor-history-list-item-desc" };
+	var _hoisted_4$8 = {
+		key: 0,
+		class: "m-editor-history-list-item-saved",
+		title: "该记录为最近一次保存的状态"
+	};
+	var _hoisted_5$3 = {
+		key: 1,
+		class: "m-editor-history-list-item-actions"
+	};
+	var _hoisted_6$3 = ["title"];
+	var _hoisted_7$1 = ["title"];
+	var _hoisted_8 = {
+		key: 4,
 		class: "m-editor-history-list-item-merge"
 	};
-	var _hoisted_7$1 = {
+	var _hoisted_9 = {
 		key: 0,
 		class: "m-editor-history-list-substeps"
 	};
-	var _hoisted_8 = ["title"];
-	var _hoisted_9 = { class: "m-editor-history-list-item-index" };
-	var _hoisted_10 = { class: "m-editor-history-list-substep-desc" };
-	var _hoisted_11 = ["title"];
-	var _hoisted_12 = ["title"];
-	var _hoisted_13 = ["onClick"];
-	var _hoisted_14 = ["onClick"];
+	var _hoisted_10 = ["title", "onClick"];
+	var _hoisted_11 = { class: "m-editor-history-list-item-index" };
+	var _hoisted_12 = { class: "m-editor-history-list-substep-desc" };
+	var _hoisted_13 = {
+		key: 0,
+		class: "m-editor-history-list-item-saved",
+		title: "该记录为最近一次保存的状态"
+	};
+	var _hoisted_14 = {
+		key: 1,
+		class: "m-editor-history-list-item-actions"
+	};
 	var _hoisted_15 = ["onClick"];
+	var _hoisted_16 = ["onClick"];
+	var _hoisted_17 = ["onClick"];
+	var _hoisted_18 = ["title"];
+	var _hoisted_19 = ["title"];
 	var GroupRow_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorHistoryListGroupRow",
 		__name: "GroupRow",
 		props: {
-			groupKey: {},
-			applied: { type: Boolean },
-			merged: { type: Boolean },
-			opType: {},
-			desc: {},
-			source: {},
-			time: {},
-			timeTitle: {},
-			stepCount: {},
-			subSteps: {},
+			group: {},
 			expanded: { type: Boolean },
-			isCurrent: {
-				type: Boolean,
-				default: false
-			},
 			gotoEnabled: {
 				type: Boolean,
 				default: true
+			},
+			selectEnabled: {
+				type: Boolean,
+				default: false
 			}
 		},
 		emits: [
 			"toggle",
 			"goto",
 			"diff-step",
-			"revert-step"
+			"revert-step",
+			"select"
 		],
 		setup(__props, { emit: __emit }) {
 			const props = __props;
 			const emit = __emit;
+			/** 子步数大于 1 即为合并组：决定是否展示合并标记与可展开的子步列表。 */
+			const merged = (0, vue.computed)(() => props.group.subSteps.length > 1);
+			/** 组内 step 总数，仅在合并组时显示为 "合并 N 步"。 */
+			const stepCount = (0, vue.computed)(() => props.group.subSteps.length);
 			/**
-			* 仅合并组头部可点击（切换展开 / 收起）；
-			* 单步组的跳转改由头部的「回退」按钮触发，整行不再可点击。
+			* 头部可点击的场景：
+			* - 合并组：点击切换展开 / 收起；
+			* - 开启 `selectEnabled`（页面 tab）：点击选中对应节点。
+			* 单步组的跳转仍由头部的「回到」按钮触发。
 			*/
-			const isHeadClickable = (0, vue.computed)(() => props.merged);
+			const isHeadClickable = (0, vue.computed)(() => merged.value || props.selectEnabled);
 			const headTitle = (0, vue.computed)(() => {
-				if (props.merged) return props.expanded ? "点击收起子步" : "点击展开子步";
-				if (props.isCurrent) return "当前所在记录";
+				if (merged.value) {
+					const expandHint = props.expanded ? "点击收起子步" : "点击展开子步";
+					return props.selectEnabled ? `${expandHint}（并选中该节点）` : expandHint;
+				}
+				if (props.selectEnabled) return "点击选中该节点";
+				if (props.group.isCurrent) return "当前所在记录";
 				return "";
 			});
 			/**
-			* 头部点击行为：仅合并组切换展开 / 收起；单步组不再响应整行点击。
+			* 头部点击行为：
+			* - 开启 selectEnabled 时，发出 select（携带组内首步 index，上层据此选中节点）；
+			* - 合并组同时切换展开 / 收起。
 			*/
 			const onHeadClick = () => {
-				if (props.merged) emit("toggle", props.groupKey);
+				if (props.selectEnabled && props.group.subSteps.length) emit("select", props.group.subSteps[0].index);
+				if (merged.value) emit("toggle", props.group.key);
 			};
 			const onGotoClick = (index) => {
 				if (!props.gotoEnabled) return;
 				emit("goto", index);
 			};
+			/** 点击子步行：开启 selectEnabled 时选中该子步对应的节点。 */
+			const onSubStepClick = (index) => {
+				if (!props.selectEnabled) return;
+				emit("select", index);
+			};
 			const subStepTitle = (s) => {
+				if (props.selectEnabled) return "点击选中该节点";
 				if (s.isCurrent) return "当前所在记录";
 				return "";
 			};
+			/**
+			* 头部是否展示「已保存」标记：
+			* - 单步组：取该唯一子步的 saved；
+			* - 合并组：组内任一子步为已保存即在头部提示（具体落在哪一步可展开查看）。
+			*/
+			const headSaved = (0, vue.computed)(() => merged.value ? props.group.subSteps.some((s) => s.saved) : Boolean(props.group.subSteps[0]?.saved));
 			/** 单步组头部是否展示"查看差异"入口：要求该唯一子步本身可对比。 */
-			const headDiffable = (0, vue.computed)(() => !props.merged && Boolean(props.subSteps[0]?.diffable));
+			const headDiffable = (0, vue.computed)(() => !merged.value && Boolean(props.group.subSteps[0]?.diffable));
 			/** 单步组头部是否展示"回滚"入口：要求该唯一子步本身可回滚（已应用）。 */
-			const headRevertable = (0, vue.computed)(() => !props.merged && Boolean(props.subSteps[0]?.revertable));
+			const headRevertable = (0, vue.computed)(() => !merged.value && Boolean(props.group.subSteps[0]?.revertable));
+			/** 单步组头部是否展示"回到"入口：可跳转、非当前、且存在唯一子步。 */
+			const canHeadGoto = (0, vue.computed)(() => !merged.value && props.gotoEnabled && !props.group.isCurrent && props.group.subSteps.length > 0);
 			/**
 			* 合并组展开后的子步渲染顺序：与外层分组列表保持一致——倒序展示（最新的子步在最上方）。
 			* 外层 page tab / bucket 都已对 groups 做了 reverse，子步沿用同样的视觉规则更直观。
 			* 注意：仅用于渲染，原 `subSteps` 保持时间正序，`headIndexLabel` 等基于首尾索引的展示语义不变。
 			*/
-			const subStepsDisplay = (0, vue.computed)(() => props.subSteps.slice().reverse());
+			const subStepsDisplay = (0, vue.computed)(() => props.group.subSteps.slice().reverse());
 			/**
 			* 头部索引展示：
-			* - 单步组（merged=false）：显示该唯一 step 的编号，如 `#5`；
+			* - 单步组（非合并）：显示该唯一 step 的编号，如 `#5`；
 			* - 合并组：显示组内 step 的编号范围，如 `#3-#7`（首尾相同则退化为 `#5`）。
 			*
 			* 这里展示的是 step.index + 1（与子步列表 `#{{ s.index + 1 }}` 保持一致），从 1 起编号更符合直觉。
 			*/
 			const headIndexLabel = (0, vue.computed)(() => {
-				const list = props.subSteps;
+				const list = props.group.subSteps;
 				if (!list.length) return "";
 				const first = list[0].index + 1;
 				const last = list[list.length - 1].index + 1;
-				if (!props.merged || first === last) return `#${first}`;
+				if (!merged.value || first === last) return `#${first}`;
 				return `#${first}-#${last}`;
 			});
 			const headIndexTitle = (0, vue.computed)(() => {
-				if (!props.merged) return `历史步骤编号 #${props.subSteps[0]?.index + 1}`;
-				return `合并了第 ${props.subSteps[0]?.index + 1} 至第 ${props.subSteps[props.subSteps.length - 1]?.index + 1} 共 ${props.subSteps.length} 条历史步骤`;
+				const list = props.group.subSteps;
+				if (!merged.value) return `历史步骤编号 #${list[0]?.index + 1}`;
+				return `合并了第 ${list[0]?.index + 1} 至第 ${list[list.length - 1]?.index + 1} 共 ${list.length} 条历史步骤`;
 			});
 			const onDiffClick = (index) => {
 				emit("diff-step", index);
@@ -9757,9 +10438,9 @@
 			};
 			return (_ctx, _cache) => {
 				return (0, vue.openBlock)(), (0, vue.createElementBlock)("li", { class: (0, vue.normalizeClass)(["m-editor-history-list-item m-editor-history-list-group", {
-					"is-undone": !__props.applied,
-					"is-merged": __props.merged,
-					"is-current": __props.isCurrent
+					"is-undone": !__props.group.applied,
+					"is-merged": merged.value,
+					"is-current": __props.group.isCurrent
 				}]) }, [(0, vue.createElementVNode)("div", {
 					class: (0, vue.normalizeClass)(["m-editor-history-list-group-head", { "is-clickable": isHeadClickable.value }]),
 					title: headTitle.value,
@@ -9768,82 +10449,90 @@
 					(0, vue.createElementVNode)("span", {
 						class: "m-editor-history-list-item-index",
 						title: headIndexTitle.value
-					}, (0, vue.toDisplayString)(headIndexLabel.value), 9, _hoisted_2$21),
-					(0, vue.createElementVNode)("span", { class: (0, vue.normalizeClass)(["m-editor-history-list-item-op", `op-${__props.opType}`]) }, (0, vue.toDisplayString)((0, vue.unref)(opLabel)(__props.opType)), 3),
-					(0, vue.createElementVNode)("span", _hoisted_3$8, (0, vue.toDisplayString)(__props.desc), 1),
-					!__props.merged && (0, vue.unref)(sourceLabel)(__props.source) ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-						key: 0,
+					}, (0, vue.toDisplayString)(headIndexLabel.value), 9, _hoisted_2$23),
+					(0, vue.createElementVNode)("span", { class: (0, vue.normalizeClass)(["m-editor-history-list-item-op", `op-${__props.group.opType}`]) }, (0, vue.toDisplayString)((0, vue.unref)(opLabel)(__props.group.opType)), 3),
+					(0, vue.createElementVNode)("span", _hoisted_3$11, (0, vue.toDisplayString)(__props.group.desc), 1),
+					headSaved.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_4$8, "已保存")) : (0, vue.createCommentVNode)("v-if", true),
+					!merged.value && (headRevertable.value || headDiffable.value || canHeadGoto.value) ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_5$3, [
+						headRevertable.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+							key: 0,
+							class: "m-editor-history-list-item-revert",
+							title: "将该步骤的修改作为一次新操作反向应用（不影响后续历史）",
+							onClick: _cache[0] || (_cache[0] = (0, vue.withModifiers)(($event) => onRevertClick(__props.group.subSteps[0].index), ["stop"]))
+						}, "回滚")) : (0, vue.createCommentVNode)("v-if", true),
+						canHeadGoto.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+							key: 1,
+							class: "m-editor-history-list-item-goto",
+							title: "回到该记录",
+							onClick: _cache[1] || (_cache[1] = (0, vue.withModifiers)(($event) => onGotoClick(__props.group.subSteps[0].index), ["stop"]))
+						}, "回到")) : (0, vue.createCommentVNode)("v-if", true),
+						headDiffable.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+							key: 2,
+							class: "m-editor-history-list-item-diff",
+							title: "查看修改差异",
+							onClick: _cache[2] || (_cache[2] = (0, vue.withModifiers)(($event) => onDiffClick(__props.group.subSteps[0].index), ["stop"]))
+						}, "查看差异")) : (0, vue.createCommentVNode)("v-if", true)
+					])) : (0, vue.createCommentVNode)("v-if", true),
+					!merged.value && (0, vue.unref)(sourceLabel)(__props.group.source) ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+						key: 2,
 						class: "m-editor-history-list-item-source",
-						title: `操作途径：${(0, vue.unref)(sourceLabel)(__props.source)}`
-					}, (0, vue.toDisplayString)((0, vue.unref)(sourceLabel)(__props.source)), 9, _hoisted_4$7)) : (0, vue.createCommentVNode)("v-if", true),
-					!__props.merged && __props.time ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-						key: 1,
-						class: "m-editor-history-list-item-time",
-						title: __props.timeTitle || __props.time
-					}, (0, vue.toDisplayString)(__props.time), 9, _hoisted_5$3)) : (0, vue.createCommentVNode)("v-if", true),
-					__props.merged ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_6$3, "合并 " + (0, vue.toDisplayString)(__props.stepCount) + " 步", 1)) : (0, vue.createCommentVNode)("v-if", true),
-					!__props.merged && headRevertable.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+						title: `操作途径：${(0, vue.unref)(sourceLabel)(__props.group.source)}`
+					}, (0, vue.toDisplayString)((0, vue.unref)(sourceLabel)(__props.group.source)), 9, _hoisted_6$3)) : (0, vue.createCommentVNode)("v-if", true),
+					!merged.value && __props.group.time ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
 						key: 3,
-						class: "m-editor-history-list-item-revert",
-						title: "将该步骤的修改作为一次新操作反向应用（不影响后续历史）",
-						onClick: _cache[0] || (_cache[0] = (0, vue.withModifiers)(($event) => onRevertClick(__props.subSteps[0].index), ["stop"]))
-					}, "回滚")) : (0, vue.createCommentVNode)("v-if", true),
-					!__props.merged && __props.gotoEnabled && !__props.isCurrent && __props.subSteps.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-						key: 4,
-						class: "m-editor-history-list-item-goto",
-						title: "回到该记录",
-						onClick: _cache[1] || (_cache[1] = (0, vue.withModifiers)(($event) => onGotoClick(__props.subSteps[0].index), ["stop"]))
-					}, "回到")) : (0, vue.createCommentVNode)("v-if", true),
-					!__props.merged && headDiffable.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+						class: "m-editor-history-list-item-time",
+						title: __props.group.timeTitle || __props.group.time
+					}, (0, vue.toDisplayString)(__props.group.time), 9, _hoisted_7$1)) : (0, vue.createCommentVNode)("v-if", true),
+					merged.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_8, "合并 " + (0, vue.toDisplayString)(stepCount.value) + " 步", 1)) : (0, vue.createCommentVNode)("v-if", true),
+					merged.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
 						key: 5,
-						class: "m-editor-history-list-item-diff",
-						title: "查看修改差异",
-						onClick: _cache[2] || (_cache[2] = (0, vue.withModifiers)(($event) => onDiffClick(__props.subSteps[0].index), ["stop"]))
-					}, "查看差异")) : (0, vue.createCommentVNode)("v-if", true),
-					__props.merged ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-						key: 6,
 						class: (0, vue.normalizeClass)(["m-editor-history-list-group-toggle", { "is-expanded": __props.expanded }])
 					}, "▾", 2)) : (0, vue.createCommentVNode)("v-if", true)
-				], 10, _hoisted_1$61), __props.merged && __props.expanded ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("ul", _hoisted_7$1, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(subStepsDisplay.value, (s) => {
+				], 10, _hoisted_1$61), merged.value && __props.expanded ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("ul", _hoisted_9, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(subStepsDisplay.value, (s) => {
 					return (0, vue.openBlock)(), (0, vue.createElementBlock)("li", {
 						key: s.index,
 						class: (0, vue.normalizeClass)({
 							"is-undone": !s.applied,
-							"is-current": s.isCurrent
+							"is-current": s.isCurrent,
+							"is-clickable": __props.selectEnabled
 						}),
-						title: subStepTitle(s)
+						title: subStepTitle(s),
+						onClick: ($event) => onSubStepClick(s.index)
 					}, [
-						(0, vue.createElementVNode)("span", _hoisted_9, "#" + (0, vue.toDisplayString)(s.index + 1), 1),
-						(0, vue.createElementVNode)("span", _hoisted_10, (0, vue.toDisplayString)(s.desc), 1),
+						(0, vue.createElementVNode)("span", _hoisted_11, "#" + (0, vue.toDisplayString)(s.index + 1), 1),
+						(0, vue.createElementVNode)("span", _hoisted_12, (0, vue.toDisplayString)(s.desc), 1),
+						s.saved ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_13, "已保存")) : (0, vue.createCommentVNode)("v-if", true),
+						s.revertable || s.diffable || __props.gotoEnabled && !s.isCurrent ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_14, [
+							s.revertable ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+								key: 0,
+								class: "m-editor-history-list-item-revert",
+								title: "将该步骤的修改作为一次新操作反向应用（不影响后续历史）",
+								onClick: (0, vue.withModifiers)(($event) => onRevertClick(s.index), ["stop"])
+							}, "回滚", 8, _hoisted_15)) : (0, vue.createCommentVNode)("v-if", true),
+							__props.gotoEnabled && !s.isCurrent ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+								key: 1,
+								class: "m-editor-history-list-item-goto",
+								title: "回到该记录",
+								onClick: (0, vue.withModifiers)(($event) => onGotoClick(s.index), ["stop"])
+							}, "回到", 8, _hoisted_16)) : (0, vue.createCommentVNode)("v-if", true),
+							s.diffable ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+								key: 2,
+								class: "m-editor-history-list-item-diff",
+								title: "查看修改差异",
+								onClick: (0, vue.withModifiers)(($event) => onDiffClick(s.index), ["stop"])
+							}, "查看差异", 8, _hoisted_17)) : (0, vue.createCommentVNode)("v-if", true)
+						])) : (0, vue.createCommentVNode)("v-if", true),
 						(0, vue.unref)(sourceLabel)(s.source) ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-							key: 0,
+							key: 2,
 							class: "m-editor-history-list-item-source",
 							title: `操作途径：${(0, vue.unref)(sourceLabel)(s.source)}`
-						}, (0, vue.toDisplayString)((0, vue.unref)(sourceLabel)(s.source)), 9, _hoisted_11)) : (0, vue.createCommentVNode)("v-if", true),
+						}, (0, vue.toDisplayString)((0, vue.unref)(sourceLabel)(s.source)), 9, _hoisted_18)) : (0, vue.createCommentVNode)("v-if", true),
 						s.time ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-							key: 1,
+							key: 3,
 							class: "m-editor-history-list-item-time",
 							title: s.timeTitle || s.time
-						}, (0, vue.toDisplayString)(s.time), 9, _hoisted_12)) : (0, vue.createCommentVNode)("v-if", true),
-						s.revertable ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-							key: 2,
-							class: "m-editor-history-list-item-revert",
-							title: "将该步骤的修改作为一次新操作反向应用（不影响后续历史）",
-							onClick: (0, vue.withModifiers)(($event) => onRevertClick(s.index), ["stop"])
-						}, "回滚", 8, _hoisted_13)) : (0, vue.createCommentVNode)("v-if", true),
-						__props.gotoEnabled && !s.isCurrent ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-							key: 3,
-							class: "m-editor-history-list-item-goto",
-							title: "回到该记录",
-							onClick: (0, vue.withModifiers)(($event) => onGotoClick(s.index), ["stop"])
-						}, "回到", 8, _hoisted_14)) : (0, vue.createCommentVNode)("v-if", true),
-						s.diffable ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-							key: 4,
-							class: "m-editor-history-list-item-diff",
-							title: "查看修改差异",
-							onClick: (0, vue.withModifiers)(($event) => onDiffClick(s.index), ["stop"])
-						}, "查看差异", 8, _hoisted_15)) : (0, vue.createCommentVNode)("v-if", true)
-					], 10, _hoisted_8);
+						}, (0, vue.toDisplayString)(s.time), 9, _hoisted_19)) : (0, vue.createCommentVNode)("v-if", true)
+					], 10, _hoisted_10);
 				}), 128))])) : (0, vue.createCommentVNode)("v-if", true)], 2);
 			};
 		}
@@ -9854,6 +10543,12 @@
 	//#endregion
 	//#region packages/editor/src/layouts/history-list/InitialRow.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$60 = ["title"];
+	var _hoisted_2$22 = { class: "m-editor-history-list-item-desc" };
+	var _hoisted_3$10 = {
+		key: 0,
+		class: "m-editor-history-list-item-actions"
+	};
+	var _hoisted_4$7 = ["title"];
 	var InitialRow_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorHistoryListInitialRow",
 		__name: "InitialRow",
@@ -9862,7 +10557,8 @@
 			gotoEnabled: {
 				type: Boolean,
 				default: true
-			}
+			},
+			marker: { default: void 0 }
 		},
 		emits: ["goto-initial"],
 		setup(__props, { emit: __emit }) {
@@ -9870,10 +10566,19 @@
 			* 「初始状态」记录行：渲染于历史列表底部，作为整个栈的"零点"。
 			* - 点击该行会把对应栈撤销到 cursor === 0（即没有任何已应用步骤），等同于回到所有修改之前。
 			* - 当对应栈本身已处于 cursor === 0 时（isCurrent=true），用户已在初始状态，点击不再触发动作。
+			* - 当上层传入 `marker`（设置 root 时为该页生成的「未修改的初始状态」标记）时，
+			*   用标记的文案与时间渲染本行；标记不进入撤销/重做栈，仅作为该页基线展示。
 			*
 			* 该行不是真实 step，仅作为 UI 入口；上层负责把"点击"翻译为 `service.goto*(0)`。
 			*/
 			const props = __props;
+			const desc = (0, vue.computed)(() => props.marker?.historyDescription || "未修改的初始状态");
+			const time = (0, vue.computed)(() => formatHistoryTime(props.marker?.timestamp));
+			const timeTitle = (0, vue.computed)(() => formatHistoryFullTime(props.marker?.timestamp));
+			const rowTitle = (0, vue.computed)(() => {
+				const base = props.marker?.historyDescription || "未修改的初始状态";
+				return props.isCurrent ? `当前已回到${base}` : `点击回到${base}`;
+			});
 			const emit = __emit;
 			const onClick = () => {
 				if (props.isCurrent) return;
@@ -9885,20 +10590,24 @@
 						"is-current": __props.isCurrent,
 						"is-clickable": !__props.isCurrent
 					}]),
-					title: __props.isCurrent ? "当前已回到未修改的初始状态" : "点击回到未修改的初始状态"
+					title: rowTitle.value
 				}, [
 					_cache[0] || (_cache[0] = (0, vue.createElementVNode)("span", {
 						class: "m-editor-history-list-item-index",
 						title: "历史步骤编号 #0（未修改的初始状态）"
 					}, "#0", -1)),
 					_cache[1] || (_cache[1] = (0, vue.createElementVNode)("span", { class: "m-editor-history-list-item-op op-initial" }, "初始", -1)),
-					_cache[2] || (_cache[2] = (0, vue.createElementVNode)("span", { class: "m-editor-history-list-item-desc" }, "未修改的初始状态", -1)),
-					__props.gotoEnabled && !__props.isCurrent ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-						key: 0,
+					(0, vue.createElementVNode)("span", _hoisted_2$22, (0, vue.toDisplayString)(desc.value), 1),
+					__props.gotoEnabled && !__props.isCurrent ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_3$10, [(0, vue.createElementVNode)("span", {
 						class: "m-editor-history-list-item-goto",
 						title: "回到该记录",
 						onClick: (0, vue.withModifiers)(onClick, ["stop"])
-					}, "回到")) : (0, vue.createCommentVNode)("v-if", true)
+					}, "回到")])) : (0, vue.createCommentVNode)("v-if", true),
+					time.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+						key: 1,
+						class: "m-editor-history-list-item-time",
+						title: timeTitle.value
+					}, (0, vue.toDisplayString)(time.value), 9, _hoisted_4$7)) : (0, vue.createCommentVNode)("v-if", true)
 				], 10, _hoisted_1$60);
 			};
 		}
@@ -9909,30 +10618,17 @@
 	//#endregion
 	//#region packages/editor/src/layouts/history-list/Bucket.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$59 = { class: "m-editor-history-list-bucket" };
-	var _hoisted_2$20 = { class: "m-editor-history-list-bucket-title" };
-	var _hoisted_3$7 = { class: "m-editor-history-list-bucket-count" };
+	var _hoisted_2$21 = { class: "m-editor-history-list-bucket-title" };
+	var _hoisted_3$9 = { class: "m-editor-history-list-bucket-count" };
 	var _hoisted_4$6 = { class: "m-editor-history-list-ul" };
 	var Bucket_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorHistoryListBucket",
 		__name: "Bucket",
 		props: {
-			title: {},
+			config: {},
 			bucketId: {},
-			prefix: {},
-			showInitial: {
-				type: Boolean,
-				default: true
-			},
 			groups: {},
-			describeGroup: {},
-			describeStep: {},
-			isStepDiffable: {},
-			isStepRevertable: {},
-			expanded: {},
-			gotoEnabled: {
-				type: Boolean,
-				default: true
-			}
+			expanded: {}
 		},
 		emits: [
 			"toggle",
@@ -9943,65 +10639,42 @@
 		],
 		setup(__props) {
 			const props = __props;
+			/**
+			* 子项 / 折叠状态 key：`${prefix}-${bucketId}-${组内首步 index}`。
+			* 以稳定的 step 索引（而非展示位置）标识分组，历史数据更新后已展开的分组状态仍能正确保持。
+			*/
+			const rowKey = (group) => `${props.config.prefix}-${props.bucketId}-${group.steps[0]?.index}`;
+			/** 把原始分组派生为 GroupRow 直接消费的视图模型。 */
+			const toRow = (group) => toRowGroup(group, rowKey(group), props.config);
 			/** 该 bucket 是否处于初始状态（栈 cursor=0），等价于全部 group 都未 applied。 */
 			const isInitial = (0, vue.computed)(() => props.groups.length > 0 && props.groups.every((g) => !g.applied));
 			return (_ctx, _cache) => {
-				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$59, [(0, vue.createElementVNode)("div", _hoisted_2$20, [
-					(0, vue.createElementVNode)("span", null, (0, vue.toDisplayString)(__props.title), 1),
+				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$59, [(0, vue.createElementVNode)("div", _hoisted_2$21, [
+					(0, vue.createElementVNode)("span", null, (0, vue.toDisplayString)(__props.config.title), 1),
 					(0, vue.createElementVNode)("code", null, (0, vue.toDisplayString)(String(__props.bucketId)), 1),
-					(0, vue.createElementVNode)("span", _hoisted_3$7, (0, vue.toDisplayString)(__props.groups.length) + " 组", 1)
+					(0, vue.createElementVNode)("span", _hoisted_3$9, (0, vue.toDisplayString)(__props.groups.length) + " 组", 1)
 				]), (0, vue.createElementVNode)("ul", _hoisted_4$6, [
 					((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.groups, (group) => {
 						return (0, vue.openBlock)(), (0, vue.createBlock)(GroupRow_default, {
-							key: `${__props.prefix}-${__props.bucketId}-${group.steps[0]?.index}`,
-							"group-key": `${__props.prefix}-${__props.bucketId}-${group.steps[0]?.index}`,
-							applied: group.applied,
-							merged: group.steps.length > 1,
-							"op-type": group.opType,
-							desc: __props.describeGroup(group),
-							source: (0, vue.unref)(groupSource)(group),
-							time: (0, vue.unref)(formatHistoryTime)((0, vue.unref)(groupTimestamp)(group)),
-							"time-title": (0, vue.unref)(formatHistoryFullTime)((0, vue.unref)(groupTimestamp)(group)),
-							"step-count": group.steps.length,
-							"sub-steps": group.steps.map((s) => ({
-								index: s.index,
-								applied: s.applied,
-								isCurrent: s.isCurrent,
-								desc: __props.describeStep(s.step),
-								diffable: __props.isStepDiffable ? __props.isStepDiffable(s.step) : false,
-								revertable: s.applied && (__props.isStepRevertable ? __props.isStepRevertable(s.step) : true),
-								source: s.step.source,
-								time: (0, vue.unref)(formatHistoryTime)(s.step.timestamp),
-								timeTitle: (0, vue.unref)(formatHistoryFullTime)(s.step.timestamp)
-							})),
-							"is-current": group.isCurrent,
-							expanded: !!__props.expanded[`${__props.prefix}-${__props.bucketId}-${group.steps[0]?.index}`],
-							"goto-enabled": __props.gotoEnabled,
+							key: rowKey(group),
+							group: toRow(group),
+							expanded: (0, vue.unref)(isHistoryGroupExpanded)(__props.expanded, rowKey(group)),
+							"goto-enabled": __props.config.gotoEnabled,
 							onToggle: _cache[0] || (_cache[0] = (key) => _ctx.$emit("toggle", key)),
 							onGoto: _cache[1] || (_cache[1] = (index) => _ctx.$emit("goto", __props.bucketId, index)),
 							onDiffStep: _cache[2] || (_cache[2] = (index) => _ctx.$emit("diff-step", __props.bucketId, index)),
 							onRevertStep: _cache[3] || (_cache[3] = (index) => _ctx.$emit("revert-step", __props.bucketId, index))
 						}, null, 8, [
-							"group-key",
-							"applied",
-							"merged",
-							"op-type",
-							"desc",
-							"source",
-							"time",
-							"time-title",
-							"step-count",
-							"sub-steps",
-							"is-current",
+							"group",
 							"expanded",
 							"goto-enabled"
 						]);
 					}), 128)),
-					(0, vue.createCommentVNode)("\n        初始状态项：永远位于该 bucket 列表底部（同样按倒序展示，最底部 = 最早状态）。\n        当 bucket 内所有 group 都未 applied 时即为当前位置。\n        showInitial=false 时不展示（用于没有\"撤销到初始状态\"语义的自定义历史，如业务模块历史）。\n      "),
-					__props.showInitial !== false ? ((0, vue.openBlock)(), (0, vue.createBlock)(InitialRow_default, {
+					(0, vue.createCommentVNode)("\n        初始状态项：永远位于该 bucket 列表底部（同样按倒序展示，最底部 = 最早状态）。\n        当 bucket 内所有 group 都未 applied 时即为当前位置。\n        config.showInitial=false 时不展示（用于没有\"撤销到初始状态\"语义的自定义历史，如业务模块历史）。\n      "),
+					__props.config.showInitial !== false ? ((0, vue.openBlock)(), (0, vue.createBlock)(InitialRow_default, {
 						key: 0,
 						"is-current": isInitial.value,
-						"goto-enabled": __props.gotoEnabled,
+						"goto-enabled": __props.config.gotoEnabled,
 						onGotoInitial: _cache[4] || (_cache[4] = ($event) => _ctx.$emit("goto-initial", __props.bucketId))
 					}, null, 8, ["is-current", "goto-enabled"])) : (0, vue.createCommentVNode)("v-if", true)
 				])]);
@@ -10017,69 +10690,52 @@
 		key: 0,
 		class: "m-editor-history-list-empty"
 	};
+	var _hoisted_2$20 = { class: "m-editor-history-list-toolbar" };
+	var _hoisted_3$8 = ["title"];
 	var BucketTab_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorHistoryListBucketTab",
 		__name: "BucketTab",
 		props: {
-			title: {},
-			prefix: {},
+			config: {},
 			buckets: {},
-			describeGroup: {},
-			describeStep: {},
-			isStepDiffable: {},
-			isStepRevertable: {},
-			expanded: {},
-			gotoEnabled: {
-				type: Boolean,
-				default: true
-			}
+			expanded: {}
 		},
 		emits: [
 			"toggle",
 			"goto",
 			"goto-initial",
 			"diff-step",
-			"revert-step"
+			"revert-step",
+			"clear"
 		],
 		setup(__props) {
 			return (_ctx, _cache) => {
-				return !__props.buckets.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$58, "暂无操作记录")) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicScrollbar), {
-					key: 1,
-					"max-height": "360px"
-				}, {
+				return !__props.buckets.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$58, "暂无操作记录")) : ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [(0, vue.createElementVNode)("div", _hoisted_2$20, [(0, vue.createElementVNode)("span", {
+					class: "m-editor-history-list-clear",
+					title: `清空${__props.config.title}的历史记录`,
+					onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("clear"))
+				}, "清空", 8, _hoisted_3$8)]), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicScrollbar), { "max-height": "360px" }, {
 					default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.buckets, (bucket) => {
 						return (0, vue.openBlock)(), (0, vue.createBlock)(Bucket_default, {
-							key: `${__props.prefix}-${bucket.id}`,
-							title: __props.title,
+							key: `${__props.config.prefix}-${bucket.id}`,
+							config: __props.config,
 							"bucket-id": bucket.id,
-							prefix: __props.prefix,
 							groups: bucket.groups,
-							"describe-group": __props.describeGroup,
-							"describe-step": __props.describeStep,
-							"is-step-diffable": __props.isStepDiffable,
-							"is-step-revertable": __props.isStepRevertable,
 							expanded: __props.expanded,
-							"goto-enabled": __props.gotoEnabled,
-							onToggle: _cache[0] || (_cache[0] = (key) => _ctx.$emit("toggle", key)),
-							onGoto: _cache[1] || (_cache[1] = (id, index) => _ctx.$emit("goto", id, index)),
-							onGotoInitial: _cache[2] || (_cache[2] = (id) => _ctx.$emit("goto-initial", id)),
-							onDiffStep: _cache[3] || (_cache[3] = (id, index) => _ctx.$emit("diff-step", id, index)),
-							onRevertStep: _cache[4] || (_cache[4] = (id, index) => _ctx.$emit("revert-step", id, index))
+							onToggle: _cache[1] || (_cache[1] = (key) => _ctx.$emit("toggle", key)),
+							onGoto: _cache[2] || (_cache[2] = (id, index) => _ctx.$emit("goto", id, index)),
+							onGotoInitial: _cache[3] || (_cache[3] = (id) => _ctx.$emit("goto-initial", id)),
+							onDiffStep: _cache[4] || (_cache[4] = (id, index) => _ctx.$emit("diff-step", id, index)),
+							onRevertStep: _cache[5] || (_cache[5] = (id, index) => _ctx.$emit("revert-step", id, index))
 						}, null, 8, [
-							"title",
+							"config",
 							"bucket-id",
-							"prefix",
 							"groups",
-							"describe-group",
-							"describe-step",
-							"is-step-diffable",
-							"is-step-revertable",
-							"expanded",
-							"goto-enabled"
+							"expanded"
 						]);
 					}), 128))]),
 					_: 1
-				}));
+				})], 64));
 			};
 		}
 	});
@@ -10184,7 +10840,7 @@
 				switch (props.category) {
 					case "node":
 						if (!props.type) return [];
-						return removeStyleDisplayConfig(await propsService.getPropsConfig(props.type));
+						return removeStyleDisplayConfig(await propsService.getPropsConfig(props.type, { node: props.value }));
 					case "data-source": return dataSourceService.getFormConfig(props.type || "base");
 					case "code-block": return getCodeBlockFormConfig({
 						paramColConfig: codeBlockService.getParamsColConfig(),
@@ -10277,7 +10933,7 @@
 		key: 0,
 		class: "m-editor-history-diff-dialog-notice"
 	};
-	var _hoisted_3$6 = { class: "m-editor-history-diff-dialog-header" };
+	var _hoisted_3$7 = { class: "m-editor-history-diff-dialog-header" };
 	var _hoisted_4$5 = { class: "m-editor-history-diff-dialog-target" };
 	var _hoisted_5$2 = { class: "m-editor-history-diff-dialog-controls" };
 	var _hoisted_6$2 = { class: "m-editor-history-diff-dialog-legend" };
@@ -10292,6 +10948,7 @@
 			extendState: {},
 			loadConfig: {},
 			width: { default: "900px" },
+			isConfirm: { type: Boolean },
 			onConfirm: {},
 			selfDiffFieldTypes: {}
 		},
@@ -10346,9 +11003,12 @@
 				if (mode.value !== "current" || !payload.value) return false;
 				return isEqual(payload.value.value, payload.value.currentValue);
 			});
+			/** confirm() 的 resolve，仅在「等待用户确认回滚」期间存在 */
+			let confirmResolve = null;
 			const onConfirmClick = () => {
-				const cb = props.onConfirm;
-				cb?.();
+				props.onConfirm?.();
+				confirmResolve?.(true);
+				confirmResolve = null;
 				visible.value = false;
 			};
 			const targetText = (0, vue.computed)(() => {
@@ -10370,21 +11030,41 @@
 				viewMode.value = "form";
 				visible.value = true;
 			};
+			/**
+			* 以 Promise 形式打开确认回滚弹窗：
+			* - 用户点击「确定回滚」时 resolve(true)；
+			* - 取消 / 关闭 / 按 Esc 等其他方式关闭弹窗时 resolve(false)。
+			*
+			* 同一时刻只允许一个待确认流程，重复调用会先 resolve(false) 掉上一个。
+			*/
+			const confirm = (p) => {
+				confirmResolve?.(false);
+				confirmResolve = null;
+				return new Promise((resolve) => {
+					confirmResolve = resolve;
+					open(p);
+				});
+			};
 			const close = () => {
 				visible.value = false;
 			};
 			(0, vue.watch)(visible, (v) => {
-				if (!v) payload.value = null;
+				if (!v) {
+					payload.value = null;
+					confirmResolve?.(false);
+					confirmResolve = null;
+				}
 			});
 			const onClose = () => {
 				emit("close");
 			};
 			__expose({
 				open,
+				confirm,
 				close
 			});
 			return (_ctx, _cache) => {
-				return (0, vue.openBlock)(), (0, vue.createBlock)(vue.Teleport, { to: "body" }, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicDialog), {
+				return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicDialog), {
 					modelValue: visible.value,
 					"onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => visible.value = $event),
 					class: "m-editor-history-diff-dialog",
@@ -10395,7 +11075,7 @@
 					width: __props.width,
 					onClose
 				}, {
-					footer: (0, vue.withCtx)(() => [__props.onConfirm ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+					footer: (0, vue.withCtx)(() => [__props.isConfirm ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
 						size: "small",
 						onClick: _cache[2] || (_cache[2] = ($event) => visible.value = false)
 					}, {
@@ -10416,9 +11096,9 @@
 						default: (0, vue.withCtx)(() => [..._cache[12] || (_cache[12] = [(0, vue.createTextVNode)("关闭", -1)])]),
 						_: 1
 					}))]),
-					default: (0, vue.withCtx)(() => [payload.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$57, [
+					default: (0, vue.withCtx)(() => [payload.value && visible.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$57, [
 						__props.onConfirm ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_2$19, "仅回滚有差异的字段")) : (0, vue.createCommentVNode)("v-if", true),
-						(0, vue.createElementVNode)("div", _hoisted_3$6, [(0, vue.createElementVNode)("span", _hoisted_4$5, (0, vue.toDisplayString)(targetText.value), 1), (0, vue.createElementVNode)("div", _hoisted_5$2, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicRadioGroup), {
+						(0, vue.createElementVNode)("div", _hoisted_3$7, [(0, vue.createElementVNode)("span", _hoisted_4$5, (0, vue.toDisplayString)(targetText.value), 1), (0, vue.createElementVNode)("div", _hoisted_5$2, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicRadioGroup), {
 							modelValue: viewMode.value,
 							"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => viewMode.value = $event),
 							size: "small",
@@ -10504,7 +11184,7 @@
 					"modelValue",
 					"title",
 					"width"
-				])]);
+				]);
 			};
 		}
 	});
@@ -10517,99 +11197,86 @@
 		key: 0,
 		class: "m-editor-history-list-empty"
 	};
-	var _hoisted_2$18 = { class: "m-editor-history-list-ul" };
+	var _hoisted_2$18 = {
+		key: 0,
+		class: "m-editor-history-list-toolbar"
+	};
+	var _hoisted_3$6 = { class: "m-editor-history-list-ul" };
 	var PageTab_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorHistoryListPageTab",
 		__name: "PageTab",
 		props: {
 			list: {},
-			expanded: {}
+			expanded: {},
+			marker: {}
 		},
 		emits: [
 			"toggle",
 			"goto",
 			"goto-initial",
 			"diff-step",
-			"revert-step"
+			"revert-step",
+			"select",
+			"clear"
 		],
 		setup(__props) {
 			const props = __props;
 			/**
 			* 当前 step 是否可查看差异：
 			* - 仅 update 操作；
-			* - 单节点更新（updatedItems.length === 1），且 oldNode / newNode 都存在。
+			* - 单节点更新（diff.length === 1），且 oldSchema / newSchema 都存在。
 			* 多节点更新难以选定单一对比目标，统一不展示差异入口。
 			*/
 			const isPageStepDiffable = (step) => {
 				if (step.opType !== "update") return false;
-				const items = step.updatedItems ?? [];
+				const items = step.diff ?? [];
 				if (items.length !== 1) return false;
-				return Boolean(items[0]?.oldNode && items[0]?.newNode);
+				return Boolean(items[0]?.oldSchema && items[0]?.newSchema);
 			};
+			/** 页面历史的描述 / 可操作性判定集合，注入给统一的 `toRowGroup`。 */
+			const descriptor = {
+				describeGroup: describePageGroup,
+				describeStep: describePageStep,
+				isStepDiffable: isPageStepDiffable,
+				isStepRevertable: isPageStepRevertable
+			};
+			const rowKey = (group) => `pg-${group.steps[0]?.index}`;
+			const toRow = (group) => toRowGroup(group, rowKey(group), descriptor);
 			/**
 			* 是否处于"初始状态"——即对应页面历史栈 cursor===0：
-			* 当 list 中所有 group 的 applied 都为 false 时即为该状态。
-			* 没有任何 group 的情况由外层"暂无操作记录"分支兜底，本计算可以不考虑。
+			* 当 list 中所有 group 的 applied 都为 false 时即为该状态（空列表 `every` 返回 true，
+			* 即仅有 marker、无任何操作记录时也视为处于初始状态）。
 			*/
-			const isInitial = (0, vue.computed)(() => props.list.length > 0 && props.list.every((g) => !g.applied));
+			const isInitial = (0, vue.computed)(() => props.list.every((g) => !g.applied));
 			return (_ctx, _cache) => {
-				return !__props.list.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$56, "暂无操作记录")) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicScrollbar), {
-					key: 1,
-					"max-height": "360px"
-				}, {
-					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("ul", _hoisted_2$18, [
+				return !__props.list.length && !__props.marker ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$56, "暂无操作记录")) : ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [__props.list.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_2$18, [(0, vue.createElementVNode)("span", {
+					class: "m-editor-history-list-clear",
+					title: "清空当前页面的历史记录",
+					onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("clear"))
+				}, "清空")])) : (0, vue.createCommentVNode)("v-if", true), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicScrollbar), { "max-height": "360px" }, {
+					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("ul", _hoisted_3$6, [
 						((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.list, (group) => {
 							return (0, vue.openBlock)(), (0, vue.createBlock)(GroupRow_default, {
-								key: `pg-${group.steps[0]?.index}`,
-								"group-key": `pg-${group.steps[0]?.index}`,
-								applied: group.applied,
-								merged: group.steps.length > 1,
-								"op-type": group.opType,
-								desc: (0, vue.unref)(describePageGroup)(group),
-								source: (0, vue.unref)(groupSource)(group),
-								time: (0, vue.unref)(formatHistoryTime)((0, vue.unref)(groupTimestamp)(group)),
-								"time-title": (0, vue.unref)(formatHistoryFullTime)((0, vue.unref)(groupTimestamp)(group)),
-								"step-count": group.steps.length,
-								"sub-steps": group.steps.map((s) => ({
-									index: s.index,
-									applied: s.applied,
-									isCurrent: s.isCurrent,
-									desc: (0, vue.unref)(describePageStep)(s.step),
-									diffable: isPageStepDiffable(s.step),
-									revertable: s.applied && (0, vue.unref)(isPageStepRevertable)(s.step),
-									source: s.step.source,
-									time: (0, vue.unref)(formatHistoryTime)(s.step.timestamp),
-									timeTitle: (0, vue.unref)(formatHistoryFullTime)(s.step.timestamp)
-								})),
-								"is-current": group.isCurrent,
-								expanded: !!__props.expanded[`pg-${group.steps[0]?.index}`],
-								onToggle: _cache[0] || (_cache[0] = (key) => _ctx.$emit("toggle", key)),
-								onGoto: _cache[1] || (_cache[1] = (index) => _ctx.$emit("goto", index)),
-								onDiffStep: _cache[2] || (_cache[2] = (index) => _ctx.$emit("diff-step", index)),
-								onRevertStep: _cache[3] || (_cache[3] = (index) => _ctx.$emit("revert-step", index))
-							}, null, 8, [
-								"group-key",
-								"applied",
-								"merged",
-								"op-type",
-								"desc",
-								"source",
-								"time",
-								"time-title",
-								"step-count",
-								"sub-steps",
-								"is-current",
-								"expanded"
-							]);
+								key: rowKey(group),
+								group: toRow(group),
+								expanded: (0, vue.unref)(isHistoryGroupExpanded)(__props.expanded, rowKey(group)),
+								"select-enabled": true,
+								onToggle: _cache[1] || (_cache[1] = (key) => _ctx.$emit("toggle", key)),
+								onGoto: _cache[2] || (_cache[2] = (index) => _ctx.$emit("goto", index)),
+								onDiffStep: _cache[3] || (_cache[3] = (index) => _ctx.$emit("diff-step", index)),
+								onRevertStep: _cache[4] || (_cache[4] = (index) => _ctx.$emit("revert-step", index)),
+								onSelect: _cache[5] || (_cache[5] = (index) => _ctx.$emit("select", index))
+							}, null, 8, ["group", "expanded"]);
 						}), 128)),
-						(0, vue.createCommentVNode)("\n        初始状态项：永远位于列表底部（页面 tab 倒序展示，最底部=最早），\n        作为\"未修改\"零点。当所有 group 都未 applied 时它即为当前位置。\n      "),
+						(0, vue.createCommentVNode)("\n        初始状态项：永远位于列表底部（页面 tab 倒序展示，最底部=最早），\n        作为\"未修改\"零点。当所有 group 都未 applied 时它即为当前位置。\n        设置 root 时生成的「未修改的初始状态」标记（marker）会作为该行的文案与时间来源。\n      "),
 						(0, vue.createVNode)(InitialRow_default, {
 							"is-current": isInitial.value,
-							onGotoInitial: _cache[4] || (_cache[4] = ($event) => _ctx.$emit("goto-initial"))
-						}, null, 8, ["is-current"])
+							marker: __props.marker,
+							onGotoInitial: _cache[6] || (_cache[6] = ($event) => _ctx.$emit("goto-initial"))
+						}, null, 8, ["is-current", "marker"])
 					])]),
 					_: 1
-				}));
+				})], 64));
 			};
 		}
 	});
@@ -10619,6 +11286,12 @@
 	//#endregion
 	//#region packages/editor/src/layouts/history-list/HistoryListPanel.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$55 = { class: "m-editor-history-list" };
+	/**
+	* 构造差异弹窗入参：仅 update（前后值都存在）可对比。
+	* - 页面（无 id）：在全部分组中按 index 定位 step，目标 id 取自快照；
+	* - 数据源 / 代码块（带 id）：先匹配分组 id 再按 index 定位。
+	* 无可对比内容（多节点 / add / remove）或定位不到时返回 null。
+	*/
 	var HistoryListPanel_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MEditorHistoryListPanel",
 		__name: "HistoryListPanel",
@@ -10647,7 +11320,10 @@
 			const ClockIcon = (0, vue.markRaw)(_element_plus_icons_vue.Clock);
 			const CloseIcon = (0, vue.markRaw)(_element_plus_icons_vue.Close);
 			const activeTab = (0, vue.ref)("page");
-			/** 面板显隐受控：reference 图标点击切换，右上角关闭按钮置为 false。 */
+			/**
+			* 面板显隐受控：reference 图标点击切换，右上角关闭按钮置为 false。
+			* 点击面板以外区域的自动收起由 TMagicPopover 通过 v-model:visible 回写完成。
+			*/
 			const visible = (0, vue.ref)(false);
 			const tabPaneComponent = (0, _tmagic_design.getDesignConfig)("components")?.tabPane;
 			/**
@@ -10657,7 +11333,7 @@
 			const extraTabs = (0, vue.inject)("historyListExtraTabs", []);
 			/** label 支持字符串或函数，函数形式便于展示动态数量等内容。 */
 			const resolveTabLabel = (tab) => typeof tab.label === "function" ? tab.label() : tab.label;
-			const { editorService, dataSourceService, codeBlockService, historyService, propsService } = useServices();
+			const { editorService, dataSourceService, codeBlockService, historyService, propsService, stageOverlayService } = useServices();
 			/**
 			* 数据源 / 代码块功能可被业务方通过 `disabledDataSource` / `disabledCodeBlock` 禁用，
 			* 禁用后对应的历史记录 tab 不再展示。若当前激活的 tab 恰好被禁用，则回退到「页面」tab。
@@ -10674,15 +11350,60 @@
 			*/
 			const extendFormState = (0, vue.inject)("extendFormState", void 0);
 			const { expanded, toggleGroup, pageGroups, dataSourceGroups, codeBlockGroups, pageGroupsDisplay, dataSourceGroupsByTarget, codeBlockGroupsByTarget } = useHistoryList();
+			/**
+			* 当前活动页的「加载/初始」标记记录（设置 root 时生成），透传给 PageTab 的底部初始行展示。
+			* 基于 historyService 的 reactive state 派生，活动页切换或标记写入后自动刷新。
+			*/
+			const pageMarker = (0, vue.computed)(() => historyService.getPageMarker());
 			/** 数据源 step 仅 update（前后 schema 都存在）时可查看差异。 */
-			const isDataSourceStepDiffable = (step) => Boolean(step.oldSchema && step.newSchema);
+			const isDataSourceStepDiffable = (step) => Boolean(step.diff?.[0]?.oldSchema && step.diff?.[0]?.newSchema);
 			/** 代码块 step 仅 update（前后 content 都存在）时可查看差异。 */
-			const isCodeBlockStepDiffable = (step) => Boolean(step.oldContent && step.newContent);
+			const isCodeBlockStepDiffable = (step) => Boolean(step.diff?.[0]?.oldSchema && step.diff?.[0]?.newSchema);
+			/**
+			* 数据源 / 代码块两类 bucket 历史的整体渲染配置：把 title / prefix 与各自的描述、
+			* 可差异、可回滚判定收敛为单一对象整体注入 BucketTab，组件内部按需读取。
+			*/
+			const dataSourceConfig = {
+				title: "数据源",
+				prefix: "ds",
+				describeGroup: describeDataSourceGroup,
+				describeStep: describeDataSourceStep,
+				isStepDiffable: isDataSourceStepDiffable,
+				isStepRevertable: isDataSourceStepRevertable
+			};
+			const codeBlockConfig = {
+				title: "代码块",
+				prefix: "cb",
+				describeGroup: describeCodeBlockGroup,
+				describeStep: describeCodeBlockStep,
+				isStepDiffable: isCodeBlockStepDiffable,
+				isStepRevertable: isCodeBlockStepRevertable
+			};
 			/** 把"目标 step 索引"翻译成"目标 cursor"（已应用步骤数量）。 */
 			const indexToCursor = (index) => index + 1;
 			const onPageGoto = (index) => {
 				editorService.gotoPageStep(indexToCursor(index));
 			};
+			/**
+			* 点击页面历史记录行：选中该记录对应的画布节点。
+			* - 从目标 step 的 diff 中取节点 id（优先 newSchema，回退 oldSchema），按出现顺序找到第一个当前仍存在的节点；
+			* - 与图层树点击选中一致：editorService.select + 画布 / overlay 画布 select 三者联动；
+			* - 该 step 涉及的节点都已不存在（如删除记录、被撤销的新增）时给出提示，不做选中。
+			*/
+			const onPageSelect = async (index) => {
+				const step = historyService.getPageStepList()[index]?.step;
+				if (!step) return;
+				const targetId = (step.diff ?? []).map((item) => item.newSchema?.id ?? item.oldSchema?.id).find((id) => id !== void 0 && id !== null && editorService.getNodeById(id, false));
+				if (targetId === void 0 || targetId === null) {
+					_tmagic_design.tMagicMessage.warning("该记录对应的节点已不存在，无法选中");
+					return;
+				}
+				const node = editorService.getNodeById(targetId, false);
+				if (!node) return;
+				await editorService.select(node);
+				editorService.get("stage")?.select(targetId);
+				stageOverlayService.get("stage")?.select(targetId);
+			};
 			const onDataSourceGoto = (id, index) => {
 				dataSourceService.goto(id, indexToCursor(index));
 			};
@@ -10703,71 +11424,53 @@
 				codeBlockService.goto(id, 0);
 			};
 			const diffDialogRef = (0, vue.useTemplateRef)("diffDialog");
+			const confirmDialogRef = (0, vue.useTemplateRef)("confirmDialog");
 			/**
-			* 构造页面 step 的差异弹窗入参：仅 update 单节点修改可对比，传入旧/新节点。
-			* 节点类型 `type` 优先取 newNode.type，再回退 oldNode.type。
-			* `currentValue` 取自 editorService 中该节点当前实际值，用于支持「与当前对比」。
-			* 无可对比内容（如多节点 / add / remove）时返回 null。
+			* 三类历史（页面 / 数据源 / 代码块）差异弹窗入参的构造差异，收敛为一份配置：
+			* 仅「分组来源、当前值读取、类型 / 展示名提取」不同，定位 step、校验前后值、组装 payload 的流程共用。
 			*/
-			const buildPageDiffPayload = (index) => {
-				const groups = historyService.getPageHistoryGroups();
-				for (const group of groups) {
-					const entry = group.steps.find((s) => s.index === index);
-					if (!entry) continue;
-					const item = entry.step.updatedItems?.[0];
-					if (!item?.oldNode || !item?.newNode) return null;
-					const type = item.newNode.type || item.oldNode.type || "";
-					const nodeId = item.newNode.id ?? item.oldNode.id;
-					const currentNode = nodeId !== void 0 ? editorService.getNodeById(nodeId) : null;
+			const buildDiffPayload = (source, index, id) => {
+				for (const group of source.groups()) {
+					if (id !== void 0 && group.id !== id) continue;
+					const step = group.steps.find((s) => s.index === index)?.step;
+					if (!step) continue;
+					const oldSchema = step.diff?.[0]?.oldSchema;
+					const newSchema = step.diff?.[0]?.newSchema;
+					if (!oldSchema || !newSchema) return null;
+					const targetId = id ?? newSchema.id ?? oldSchema.id;
+					const type = source.resolveType?.(newSchema, oldSchema);
 					return {
-						category: "node",
-						type,
-						lastValue: item.oldNode,
-						value: item.newNode,
-						currentValue: currentNode || null,
-						targetLabel: item.newNode.name || item.oldNode.name || type,
-						id: nodeId
+						category: source.category,
+						...type !== void 0 ? { type } : {},
+						lastValue: oldSchema,
+						value: newSchema,
+						currentValue: (targetId !== void 0 ? source.getCurrent(targetId) : null) || null,
+						targetLabel: source.resolveLabel(newSchema, oldSchema, targetId),
+						id: targetId
 					};
 				}
 				return null;
 			};
-			/**
-			* 在指定分组列表中按 id / index 查找命中的 step，命中后交由 build 构造差异弹窗入参。
-			* 用于统一数据源、代码块两类历史的查找逻辑。
-			*/
-			const findGroupStep = (groups, id, index, build) => {
-				for (const group of groups) {
-					if (group.id !== id) continue;
-					const entry = group.steps.find((s) => s.index === index);
-					if (!entry) continue;
-					return build(entry.step);
-				}
-				return null;
-			};
-			const buildDataSourceDiffPayload = (id, index) => findGroupStep(historyService.getDataSourceHistoryGroups(), id, index, ({ oldSchema, newSchema }) => {
-				if (!oldSchema || !newSchema) return null;
-				const currentSchema = dataSourceService.getDataSourceById(`${id}`);
-				return {
-					category: "data-source",
-					type: newSchema.type || oldSchema.type || "base",
-					lastValue: oldSchema,
-					value: newSchema,
-					currentValue: currentSchema || null,
-					targetLabel: newSchema.title || oldSchema.title || `${id}`,
-					id
-				};
-			});
-			const buildCodeBlockDiffPayload = (id, index) => findGroupStep(historyService.getCodeBlockHistoryGroups(), id, index, ({ oldContent, newContent }) => {
-				if (!oldContent || !newContent) return null;
-				return {
-					category: "code-block",
-					lastValue: oldContent,
-					value: newContent,
-					currentValue: codeBlockService.getCodeContentById(id) || null,
-					targetLabel: newContent.name || oldContent.name || `${id}`,
-					id
-				};
-			});
+			const buildPageDiffPayload = (index) => buildDiffPayload({
+				category: "node",
+				groups: () => historyService.getPageHistoryGroups(),
+				getCurrent: (id) => editorService.getNodeById(id),
+				resolveType: (n, o) => n.type || o.type || "",
+				resolveLabel: (n, o) => n.name || o.name || n.type || o.type || ""
+			}, index);
+			const buildDataSourceDiffPayload = (id, index) => buildDiffPayload({
+				category: "data-source",
+				groups: () => historyService.getDataSourceHistoryGroups(),
+				getCurrent: (id) => dataSourceService.getDataSourceById(`${id}`),
+				resolveType: (n, o) => n.type || o.type || "base",
+				resolveLabel: (n, o, id) => n.title || o.title || `${id}`
+			}, index, id);
+			const buildCodeBlockDiffPayload = (id, index) => buildDiffPayload({
+				category: "code-block",
+				groups: () => historyService.getCodeBlockHistoryGroups(),
+				getCurrent: (id) => codeBlockService.getCodeContentById(id),
+				resolveLabel: (n, o, id) => n.name || o.name || `${id}`
+			}, index, id);
 			const onPageDiff = (index) => {
 				const payload = buildPageDiffPayload(index);
 				if (payload) diffDialogRef.value?.open(payload);
@@ -10780,173 +11483,259 @@
 				const payload = buildCodeBlockDiffPayload(id, index);
 				if (payload) diffDialogRef.value?.open(payload);
 			};
-			const onConfirmRevert = (0, vue.shallowRef)();
 			/**
-			* 「回滚」入口：把目标历史步骤的修改作为一次新操作反向应用（类 git revert），
+			* 「回滚」统一入口：把目标历史步骤的修改作为一次新操作反向应用（类 git revert），
 			* 不破坏原有栈结构。各 service 内部完成反向 + 入栈，并自带描述用于面板展示。
 			*
-			* 交互：先弹出该步骤的差异弹窗供用户确认，点击「确定回滚」后再真正执行回滚；
-			* 对没有可对比内容的步骤（如 add / remove / 多节点更新）则直接回滚。
+			* 交互：
+			* - 可差异对比的步骤（单节点 / 单实体 update）：弹出差异弹窗供用户确认，点「确定回滚」再执行；
+			* - 无法对比的步骤（add / remove / 多节点更新，payload 为 null）：弹出普通二次确认框，确认后执行。
+			*
+			* 页面 / 数据源 / 代码块三类回滚仅「差异入参构造」与「实际 revert 调用」不同，
+			* 由调用方分别传入 payload 与 revert，公共的弹窗 / 确认流程在此收敛。
+			*/
+			const runRevert = (payload) => {
+				if (payload && confirmDialogRef.value) return confirmDialogRef.value.confirm(payload);
+				return confirmRevert();
+			};
+			/**
+			* 回滚前置校验：若该历史步骤回滚所依赖的目标数据已被删除，则无法回滚。
+			* - update（把旧值写回）：被修改的目标必须仍存在；
+			* - 页面 remove（还原被删节点）：被删节点的原父容器必须仍存在，否则无处插回；
+			* add（回滚即删除）即使目标已不在，也已达成「删除」目的，不视为失败。
+			*
+			* 命中时弹出「回滚失败」提示并返回 true，调用方据此中止本次回滚。
 			*/
+			const isPageRevertTargetMissing = (index) => {
+				const step = historyService.getPageStepList()[index]?.step;
+				if (!step) return false;
+				if (step.opType === "update") return (step.diff ?? []).some((item) => {
+					const id = item.newSchema?.id ?? item.oldSchema?.id;
+					return id !== void 0 && !editorService.getNodeById(id, false);
+				});
+				if (step.opType === "remove") return (step.diff ?? []).some((item) => item.parentId !== void 0 && !editorService.getNodeById(item.parentId, false));
+				return false;
+			};
+			/** 数据源 update 步骤回滚时，对应数据源必须仍存在（已删除则无处写回旧值）。 */
+			const isDataSourceRevertTargetMissing = (id, index) => {
+				const step = historyService.getDataSourceStepList(id)[index]?.step;
+				return Boolean(step && step.opType === "update" && !dataSourceService.getDataSourceById(`${id}`));
+			};
+			/** 代码块 update 步骤回滚时，对应代码块必须仍存在（已删除则无处写回旧值）。 */
+			const isCodeBlockRevertTargetMissing = (id, index) => {
+				const step = historyService.getCodeBlockStepList(id)[index]?.step;
+				return Boolean(step && step.opType === "update" && !codeBlockService.getCodeContentById(id));
+			};
+			/** 目标数据已被删除、无法回滚时的统一提示。 */
+			const showRevertTargetMissing = () => {
+				_tmagic_design.tMagicMessage.error("回滚失败：该记录对应的数据已被删除");
+			};
 			const onPageRevert = (index) => {
-				const payload = buildPageDiffPayload(index);
-				onConfirmRevert.value = () => editorService.revertPageStep(index);
-				if (payload) diffDialogRef.value?.open({ ...payload });
-				else onConfirmRevert.value();
+				if (isPageRevertTargetMissing(index)) {
+					showRevertTargetMissing();
+					return Promise.resolve(null);
+				}
+				return runRevert(buildPageDiffPayload(index)).then((result) => result ? editorService.revertPageStep(index) : null);
 			};
 			const onDataSourceRevert = (id, index) => {
-				const payload = buildDataSourceDiffPayload(id, index);
-				onConfirmRevert.value = () => dataSourceService.revert(id, index);
-				if (payload) diffDialogRef.value?.open({ ...payload });
-				else onConfirmRevert.value();
+				if (isDataSourceRevertTargetMissing(id, index)) {
+					showRevertTargetMissing();
+					return Promise.resolve(null);
+				}
+				return runRevert(buildDataSourceDiffPayload(id, index)).then((result) => result ? dataSourceService.revert(id, index) : null);
 			};
 			const onCodeBlockRevert = (id, index) => {
-				const payload = buildCodeBlockDiffPayload(id, index);
-				onConfirmRevert.value = () => codeBlockService.revert(id, index);
-				if (payload) diffDialogRef.value?.open({ ...payload });
-				else onConfirmRevert.value();
+				if (isCodeBlockRevertTargetMissing(id, index)) {
+					showRevertTargetMissing();
+					return Promise.resolve(null);
+				}
+				return runRevert(buildCodeBlockDiffPayload(id, index)).then((result) => result ? codeBlockService.revert(id, index) : null);
+			};
+			/**
+			* 「回滚」二次确认：新增 / 删除 / 多节点更新等无法做差异对比的步骤，
+			* 不弹差异弹窗，改用一个普通确认框替代「确定回滚」按钮，避免点击后无任何提示直接执行。
+			* 用户取消时返回 false，调用方据此中止回滚。
+			*/
+			const confirmRevert = () => confirmDialog("确定回滚该步骤吗？回滚会将该操作作为一条新记录反向应用（新增将被删除、删除将被还原），不影响后续历史记录。");
+			/**
+			* 通用二次确认弹窗：清空历史 / 无法差异对比的回滚等会改变状态的操作，先弹出确认框，
+			* 用户点击「确定」返回 true，取消（confirm reject）时返回 false 并静默忽略。
+			*/
+			const confirmDialog = async (message) => {
+				try {
+					await _tmagic_design.tMagicMessageBox.confirm(message, "提示", {
+						confirmButtonText: "确定",
+						cancelButtonText: "取消",
+						type: "warning"
+					});
+					return true;
+				} catch (e) {
+					return false;
+				}
+			};
+			/**
+			* 把内存中（已清空对应类别后的）历史状态重新写回 IndexedDB，
+			* 使本地持久化的那份与内存保持一致——即「连同本地保存的一并删除」。
+			* 不支持 IndexedDB 或写入失败时静默忽略（内存清空已生效）。
+			*/
+			const syncIndexedDB = async () => {
+				try {
+					await historyService.saveToIndexedDB();
+				} catch (e) {}
+			};
+			const onPageClear = async () => {
+				if (await confirmDialog("确定清空当前页面的历史记录吗？清空后将无法撤销/重做之前的操作，本地保存的记录也会一并删除。")) {
+					historyService.clearPage();
+					await syncIndexedDB();
+				}
 			};
-			const onDiffDialogClose = () => {
-				onConfirmRevert.value = void 0;
+			const onDataSourceClear = async () => {
+				if (await confirmDialog("确定清空数据源的历史记录吗？清空后将无法撤销/重做之前的操作，本地保存的记录也会一并删除。")) {
+					historyService.clearDataSource();
+					await syncIndexedDB();
+				}
+			};
+			const onCodeBlockClear = async () => {
+				if (await confirmDialog("确定清空代码块的历史记录吗？清空后将无法撤销/重做之前的操作，本地保存的记录也会一并删除。")) {
+					historyService.clearCodeBlock();
+					await syncIndexedDB();
+				}
 			};
 			return (_ctx, _cache) => {
-				return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicPopover), {
-					"popper-class": "m-editor-history-list-popover",
-					placement: "bottom",
-					trigger: "click",
-					visible: visible.value,
-					width: 660
-				}, {
-					reference: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
-						effect: "dark",
+				return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [
+					(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicPopover), {
+						"popper-class": "m-editor-history-list-popover",
 						placement: "bottom",
-						content: "历史记录"
+						trigger: "click",
+						visible: visible.value,
+						"onUpdate:visible": _cache[3] || (_cache[3] = ($event) => visible.value = $event),
+						width: 660
 					}, {
-						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
-							size: "small",
-							link: "",
-							onClick: _cache[2] || (_cache[2] = ($event) => visible.value = !visible.value)
+						reference: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+							effect: "dark",
+							placement: "bottom",
+							content: "历史记录"
 						}, {
-							icon: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: (0, vue.unref)(ClockIcon) }, null, 8, ["icon"])]),
+							default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+								size: "small",
+								link: "",
+								onClick: _cache[2] || (_cache[2] = ($event) => visible.value = !visible.value)
+							}, {
+								icon: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: (0, vue.unref)(ClockIcon) }, null, 8, ["icon"])]),
+								_: 1
+							})]),
 							_: 1
 						})]),
-						_: 1
-					})]),
-					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", _hoisted_1$55, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
-						effect: "dark",
-						placement: "top",
-						content: "关闭"
-					}, {
-						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
-							class: "m-editor-history-list-close",
-							size: "small",
-							link: "",
-							onClick: _cache[0] || (_cache[0] = ($event) => visible.value = false)
+						default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", _hoisted_1$55, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+							effect: "dark",
+							placement: "top",
+							content: "关闭"
 						}, {
-							icon: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: (0, vue.unref)(CloseIcon) }, null, 8, ["icon"])]),
-							_: 1
-						})]),
-						_: 1
-					}), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTabs), {
-						modelValue: activeTab.value,
-						"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => activeTab.value = $event),
-						class: "m-editor-history-list-tabs"
-					}, {
-						default: (0, vue.withCtx)(() => [
-							((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.normalizeProps)((0, vue.guardReactiveProps)((0, vue.unref)(tabPaneComponent)?.props({
-								name: "page",
-								label: `页面 (${(0, vue.unref)(pageGroups).length})`
-							}) || {})), {
-								default: (0, vue.withCtx)(() => [(0, vue.createVNode)(PageTab_default, {
-									list: (0, vue.unref)(pageGroupsDisplay),
-									expanded: (0, vue.unref)(expanded),
-									onToggle: (0, vue.unref)(toggleGroup),
-									onGoto: onPageGoto,
-									onGotoInitial: onPageGotoInitial,
-									onDiffStep: onPageDiff,
-									onRevertStep: onPageRevert
-								}, null, 8, [
-									"list",
-									"expanded",
-									"onToggle"
-								])]),
-								_: 1
-							}, 16)),
-							!disabledDataSource.value ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.normalizeProps)((0, vue.mergeProps)({ key: 0 }, (0, vue.unref)(tabPaneComponent)?.props({
-								name: "data-source",
-								label: `数据源 (${(0, vue.unref)(dataSourceGroups).length})`
-							}) || {})), {
-								default: (0, vue.withCtx)(() => [(0, vue.createVNode)(BucketTab_default, {
-									title: "数据源",
-									prefix: "ds",
-									buckets: (0, vue.unref)(dataSourceGroupsByTarget),
-									expanded: (0, vue.unref)(expanded),
-									"describe-group": (0, vue.unref)(describeDataSourceGroup),
-									"describe-step": (0, vue.unref)(describeDataSourceStep),
-									"is-step-diffable": isDataSourceStepDiffable,
-									"is-step-revertable": (0, vue.unref)(isDataSourceStepRevertable),
-									onToggle: (0, vue.unref)(toggleGroup),
-									onGoto: onDataSourceGoto,
-									onGotoInitial: onDataSourceGotoInitial,
-									onDiffStep: onDataSourceDiff,
-									onRevertStep: onDataSourceRevert
-								}, null, 8, [
-									"buckets",
-									"expanded",
-									"describe-group",
-									"describe-step",
-									"is-step-revertable",
-									"onToggle"
-								])]),
-								_: 1
-							}, 16)) : (0, vue.createCommentVNode)("v-if", true),
-							!disabledCodeBlock.value ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.normalizeProps)((0, vue.mergeProps)({ key: 1 }, (0, vue.unref)(tabPaneComponent)?.props({
-								name: "code-block",
-								label: `代码块 (${(0, vue.unref)(codeBlockGroups).length})`
-							}) || {})), {
-								default: (0, vue.withCtx)(() => [(0, vue.createVNode)(BucketTab_default, {
-									title: "代码块",
-									prefix: "cb",
-									buckets: (0, vue.unref)(codeBlockGroupsByTarget),
-									expanded: (0, vue.unref)(expanded),
-									"describe-group": (0, vue.unref)(describeCodeBlockGroup),
-									"describe-step": (0, vue.unref)(describeCodeBlockStep),
-									"is-step-diffable": isCodeBlockStepDiffable,
-									"is-step-revertable": (0, vue.unref)(isCodeBlockStepRevertable),
-									onToggle: (0, vue.unref)(toggleGroup),
-									onGoto: onCodeBlockGoto,
-									onGotoInitial: onCodeBlockGotoInitial,
-									onDiffStep: onCodeBlockDiff,
-									onRevertStep: onCodeBlockRevert
-								}, null, 8, [
-									"buckets",
-									"expanded",
-									"describe-group",
-									"describe-step",
-									"is-step-revertable",
-									"onToggle"
-								])]),
+							default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+								class: "m-editor-history-list-close",
+								size: "small",
+								link: "",
+								onClick: _cache[0] || (_cache[0] = ($event) => visible.value = false)
+							}, {
+								icon: (0, vue.withCtx)(() => [(0, vue.createVNode)(Icon_default, { icon: (0, vue.unref)(CloseIcon) }, null, 8, ["icon"])]),
 								_: 1
-							}, 16)) : (0, vue.createCommentVNode)("v-if", true),
-							((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)((0, vue.unref)(extraTabs), (tab) => {
-								return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.mergeProps)({ key: tab.name }, { ref_for: true }, (0, vue.unref)(tabPaneComponent)?.props({
-									name: tab.name,
-									label: resolveTabLabel(tab)
-								}) || {}), {
-									default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(tab.component), (0, vue.mergeProps)({ ref_for: true }, tab.props || {}, (0, vue.toHandlers)(tab.listeners || {})), null, 16))]),
-									_: 2
-								}, 1040);
-							}), 128))
-						]),
+							})]),
+							_: 1
+						}), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTabs), {
+							modelValue: activeTab.value,
+							"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => activeTab.value = $event),
+							class: "m-editor-history-list-tabs"
+						}, {
+							default: (0, vue.withCtx)(() => [
+								((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.normalizeProps)((0, vue.guardReactiveProps)((0, vue.unref)(tabPaneComponent)?.props({
+									name: "page",
+									label: `页面 (${(0, vue.unref)(pageGroups).length})`
+								}) || {})), {
+									default: (0, vue.withCtx)(() => [(0, vue.createVNode)(PageTab_default, {
+										list: (0, vue.unref)(pageGroupsDisplay),
+										expanded: (0, vue.unref)(expanded),
+										marker: pageMarker.value,
+										onToggle: (0, vue.unref)(toggleGroup),
+										onGoto: onPageGoto,
+										onGotoInitial: onPageGotoInitial,
+										onDiffStep: onPageDiff,
+										onRevertStep: onPageRevert,
+										onSelect: onPageSelect,
+										onClear: onPageClear
+									}, null, 8, [
+										"list",
+										"expanded",
+										"marker",
+										"onToggle"
+									])]),
+									_: 1
+								}, 16)),
+								!disabledDataSource.value ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.normalizeProps)((0, vue.mergeProps)({ key: 0 }, (0, vue.unref)(tabPaneComponent)?.props({
+									name: "data-source",
+									label: `数据源 (${(0, vue.unref)(dataSourceGroups).length})`
+								}) || {})), {
+									default: (0, vue.withCtx)(() => [(0, vue.createVNode)(BucketTab_default, {
+										config: dataSourceConfig,
+										buckets: (0, vue.unref)(dataSourceGroupsByTarget),
+										expanded: (0, vue.unref)(expanded),
+										onToggle: (0, vue.unref)(toggleGroup),
+										onGoto: onDataSourceGoto,
+										onGotoInitial: onDataSourceGotoInitial,
+										onDiffStep: onDataSourceDiff,
+										onRevertStep: onDataSourceRevert,
+										onClear: onDataSourceClear
+									}, null, 8, [
+										"buckets",
+										"expanded",
+										"onToggle"
+									])]),
+									_: 1
+								}, 16)) : (0, vue.createCommentVNode)("v-if", true),
+								!disabledCodeBlock.value ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.normalizeProps)((0, vue.mergeProps)({ key: 1 }, (0, vue.unref)(tabPaneComponent)?.props({
+									name: "code-block",
+									label: `代码块 (${(0, vue.unref)(codeBlockGroups).length})`
+								}) || {})), {
+									default: (0, vue.withCtx)(() => [(0, vue.createVNode)(BucketTab_default, {
+										config: codeBlockConfig,
+										buckets: (0, vue.unref)(codeBlockGroupsByTarget),
+										expanded: (0, vue.unref)(expanded),
+										onToggle: (0, vue.unref)(toggleGroup),
+										onGoto: onCodeBlockGoto,
+										onGotoInitial: onCodeBlockGotoInitial,
+										onDiffStep: onCodeBlockDiff,
+										onRevertStep: onCodeBlockRevert,
+										onClear: onCodeBlockClear
+									}, null, 8, [
+										"buckets",
+										"expanded",
+										"onToggle"
+									])]),
+									_: 1
+								}, 16)) : (0, vue.createCommentVNode)("v-if", true),
+								((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)((0, vue.unref)(extraTabs), (tab) => {
+									return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(tabPaneComponent)?.component || "el-tab-pane"), (0, vue.mergeProps)({ key: tab.name }, { ref_for: true }, (0, vue.unref)(tabPaneComponent)?.props({
+										name: tab.name,
+										label: resolveTabLabel(tab)
+									}) || {}), {
+										default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(tab.component), (0, vue.mergeProps)({ ref_for: true }, tab.props || {}, (0, vue.toHandlers)(tab.listeners || {})), null, 16))]),
+										_: 2
+									}, 1040);
+								}), 128))
+							]),
+							_: 1
+						}, 8, ["modelValue"])])]),
 						_: 1
-					}, 8, ["modelValue"])])]),
-					_: 1
-				}, 8, ["visible"]), (0, vue.createVNode)(HistoryDiffDialog_default, {
-					ref: "diffDialog",
-					"extend-state": (0, vue.unref)(extendFormState),
-					"on-confirm": onConfirmRevert.value,
-					onClose: onDiffDialogClose
-				}, null, 8, ["extend-state", "on-confirm"])], 64);
+					}, 8, ["visible"]),
+					(0, vue.createVNode)(HistoryDiffDialog_default, {
+						ref: "diffDialog",
+						"extend-state": (0, vue.unref)(extendFormState)
+					}, null, 8, ["extend-state"]),
+					(0, vue.createVNode)(HistoryDiffDialog_default, {
+						ref: "confirmDialog",
+						"is-confirm": true,
+						"extend-state": (0, vue.unref)(extendFormState)
+					}, null, 8, ["extend-state"])
+				], 64);
 			};
 		}
 	});
@@ -14242,7 +15031,11 @@
 					});
 				}
 			}, { immediate: true });
-			const activeTabName = (0, vue.ref)(props.data?.status);
+			const activeTabName = (0, vue.computed)({
+				get: () => uiService.get("sideBarActiveTabName"),
+				set: (value) => uiService.set("sideBarActiveTabName", value)
+			});
+			uiService.set("sideBarActiveTabName", props.data?.status || "");
 			const getItemConfig = (data) => {
 				const map = {
 					[SideItemKey.COMPONENT_LIST]: {
@@ -15436,17 +16229,6 @@
 		],
 		sync: ["setCodeDslByIdSync"]
 	};
-	/**
-	* 「回滚」生成的新 step 简短描述。仅 service 层使用。
-	*/
-	var describeRevertCodeBlockStep = (step) => {
-		const { oldContent, newContent, changeRecords, id } = step;
-		if (oldContent === null && newContent) return `撤回新增 ${newContent.name || newContent.id || id}`;
-		if (oldContent && newContent === null) return `还原已删除的 ${oldContent.name || oldContent.id || id}`;
-		const name = newContent?.name || oldContent?.name || `${id}`;
-		const propPath = changeRecords?.[0]?.propPath;
-		return propPath ? `还原 ${name} · ${propPath}` : `还原 ${name}`;
-	};
 	var CodeBlock = class extends BaseService {
 		state = (0, vue.reactive)({
 			codeDsl: null,
@@ -15455,6 +16237,16 @@
 			undeletableList: [],
 			paramsColConfig: void 0
 		});
+		/**
+		* 最近一次写入历史栈的代码块历史记录 uuid（单条写入场景：新增 / 更新）。
+		* 供 setCodeDslById(Sync)AndGetHistoryId 取回，普通方法不读取它。
+		*/
+		lastPushedHistoryId = null;
+		/**
+		* deleteCodeDslByIds 一次删除多个代码块时，按写入顺序收集的历史记录 uuid 列表。
+		* 在 deleteCodeDslByIds 入口处重置，供 deleteCodeDslByIdsAndGetHistoryId 取回。
+		*/
+		lastDeletedHistoryIds = [];
 		constructor() {
 			super([...canUsePluginMethods$4.async.map((methodName) => ({
 				name: methodName,
@@ -15537,13 +16329,13 @@
 				...codeConfigProcessed
 			};
 			const newContent = cloneDeep$1(codeDsl[id]);
-			if (!doNotPushHistory) history_default.pushCodeBlock(id, {
+			if (!doNotPushHistory) this.lastPushedHistoryId = history_default.pushCodeBlock(id, {
 				oldContent,
 				newContent,
 				changeRecords,
 				historyDescription,
 				source: historySource
-			});
+			})?.uuid ?? null;
 			this.emit("addOrUpdate", id, codeDsl[id]);
 		}
 		/**
@@ -15626,18 +16418,50 @@
 		async deleteCodeDslByIds(codeIds, { doNotPushHistory = false, historyDescription, historySource } = {}) {
 			const currentDsl = await this.getCodeDsl();
 			if (!currentDsl) return;
+			this.lastDeletedHistoryIds = [];
 			codeIds.forEach((id) => {
 				const oldContent = currentDsl[id] ? cloneDeep$1(currentDsl[id]) : null;
 				delete currentDsl[id];
-				if (oldContent && !doNotPushHistory) history_default.pushCodeBlock(id, {
-					oldContent,
-					newContent: null,
-					historyDescription,
-					source: historySource
-				});
+				if (oldContent && !doNotPushHistory) {
+					const uuid = history_default.pushCodeBlock(id, {
+						oldContent,
+						newContent: null,
+						historyDescription,
+						source: historySource
+					})?.uuid;
+					if (uuid) this.lastDeletedHistoryIds.push(uuid);
+				}
 				this.emit("remove", id);
 			});
 		}
+		/**
+		* 下列 *AndGetHistoryId 方法与对应的写入方法行为完全一致，
+		* 唯一区别是返回值为本次写入历史栈的历史记录 uuid（{@link CodeBlockStepValue.uuid}），
+		* 可用于精确引用 / 定位该条历史记录（埋点、revert、跨端同步等）。
+		*
+		* 当本次操作未写入历史（doNotPushHistory 为 true、或无对应记录）时：单条写入返回 null，批量删除返回空数组。
+		*/
+		/** 等价于 {@link setCodeDslById}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		async setCodeDslByIdAndGetHistoryId(id, codeConfig, options = {}) {
+			this.lastPushedHistoryId = null;
+			await this.setCodeDslById(id, codeConfig, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link setCodeDslByIdSync}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		setCodeDslByIdSyncAndGetHistoryId(id, codeConfig, force = true, options = {}) {
+			this.lastPushedHistoryId = null;
+			this.setCodeDslByIdSync(id, codeConfig, force, options);
+			return this.lastPushedHistoryId;
+		}
+		/**
+		* 等价于 {@link deleteCodeDslByIds}，但返回本次写入的全部历史记录 uuid（按删除顺序）。
+		* 一次删除多个代码块会产生多条历史记录，因此返回数组；未写入任何历史时返回空数组。
+		*/
+		async deleteCodeDslByIdsAndGetHistoryId(codeIds, options = {}) {
+			this.lastDeletedHistoryIds = [];
+			await this.deleteCodeDslByIds(codeIds, options);
+			return [...this.lastDeletedHistoryIds];
+		}
 		setParamsColConfig(config) {
 			this.state.paramsColConfig = config;
 		}
@@ -15713,11 +16537,25 @@
 		async revert(id, index) {
 			const entry = history_default.getCodeBlockStepList(id)[index];
 			if (!entry?.applied) return null;
-			if (entry.step.oldContent && entry.step.newContent && !entry.step.changeRecords?.length) return null;
-			const description = `回滚 #${index + 1}: ${describeRevertCodeBlockStep(entry.step)}`;
+			const { oldSchema, newSchema, changeRecords } = entry.step.diff?.[0] ?? {};
+			if (oldSchema && newSchema && !changeRecords?.length) return null;
+			const description = `回滚 #${index + 1}: ${describeRevertStep(entry.step.id, entry.step.diff?.[0], (s) => s.name)}`;
 			return await this.applyRevertStep(entry.step, description);
 		}
 		/**
+		* 通过历史记录 uuid 回滚某条代码块历史步骤，语义同 {@link revert}，
+		* 仅无需调用方再传 codeBlockId 与 index：内部会按 uuid（{@link CodeBlockStepValue.uuid}）
+		* 在全部代码块栈中定位对应步骤后再回滚。
+		*
+		* @param uuid 目标历史记录的 uuid，通常由 {@link setCodeDslByIdAndGetHistoryId} 等方法返回
+		* @returns 反向后产生的新 step；找不到对应 uuid / 未应用时返回 null
+		*/
+		async revertById(uuid) {
+			const location = history_default.findCodeBlockStepLocationByUuid(uuid);
+			if (!location) return null;
+			return await this.revert(location.id, location.index);
+		}
+		/**
 		* 生成代码块唯一id
 		* @returns {Id} 代码块唯一id
 		*/
@@ -15782,22 +16620,23 @@
 		* 差异仅在于通过公开的 setCodeDslByIdSync / deleteCodeDslByIds 触发 push。
 		*/
 		async applyRevertStep(step, historyDescription) {
-			const { id, oldContent, newContent, changeRecords } = step;
-			if (oldContent === null && newContent) {
+			const { id } = step;
+			const { oldSchema, newSchema, changeRecords } = step.diff?.[0] ?? {};
+			if (!oldSchema && newSchema) {
 				await this.deleteCodeDslByIds([id], {
 					historyDescription,
 					historySource: "rollback"
 				});
 				return history_default.getCodeBlockStepList(id).slice(-1)[0]?.step ?? null;
 			}
-			if (oldContent && newContent === null) {
-				this.setCodeDslByIdSync(id, cloneDeep$1(oldContent), true, {
+			if (oldSchema && !newSchema) {
+				this.setCodeDslByIdSync(id, cloneDeep$1(oldSchema), true, {
 					historyDescription,
 					historySource: "rollback"
 				});
 				return history_default.getCodeBlockStepList(id).slice(-1)[0]?.step ?? null;
 			}
-			if (!oldContent || !newContent) return null;
+			if (!oldSchema || !newSchema) return null;
 			if (changeRecords?.length) {
 				const current = this.getCodeContentById(id);
 				if (!current) return null;
@@ -15808,17 +16647,17 @@
 						fallbackToFullReplace = true;
 						break;
 					}
-					const value = cloneDeep$1((0, _tmagic_utils.getValueByKeyPath)(record.propPath, oldContent));
+					const value = cloneDeep$1((0, _tmagic_utils.getValueByKeyPath)(record.propPath, oldSchema));
 					(0, _tmagic_utils.setValueByKeyPath)(record.propPath, value, patched);
 				}
-				this.setCodeDslByIdSync(id, fallbackToFullReplace ? cloneDeep$1(oldContent) : patched, true, {
+				this.setCodeDslByIdSync(id, fallbackToFullReplace ? cloneDeep$1(oldSchema) : patched, true, {
 					changeRecords,
 					historyDescription,
 					historySource: "rollback"
 				});
 				return history_default.getCodeBlockStepList(id).slice(-1)[0]?.step ?? null;
 			}
-			this.setCodeDslByIdSync(id, cloneDeep$1(oldContent), true, {
+			this.setCodeDslByIdSync(id, cloneDeep$1(oldSchema), true, {
 				historyDescription,
 				historySource: "rollback"
 			});
@@ -15839,19 +16678,20 @@
 		* @param reverse true=撤销，false=重做
 		*/
 		async applyHistoryStep(step, reverse) {
-			const { id, oldContent, newContent, changeRecords } = step;
-			if (oldContent === null && newContent) {
+			const { id } = step;
+			const { oldSchema, newSchema, changeRecords } = step.diff?.[0] ?? {};
+			if (!oldSchema && newSchema) {
 				if (reverse) await this.deleteCodeDslByIds([id], { doNotPushHistory: true });
-				else this.setCodeDslByIdSync(id, cloneDeep$1(newContent), true, { doNotPushHistory: true });
+				else this.setCodeDslByIdSync(id, cloneDeep$1(newSchema), true, { doNotPushHistory: true });
 				return;
 			}
-			if (oldContent && newContent === null) {
-				if (reverse) this.setCodeDslByIdSync(id, cloneDeep$1(oldContent), true, { doNotPushHistory: true });
+			if (oldSchema && !newSchema) {
+				if (reverse) this.setCodeDslByIdSync(id, cloneDeep$1(oldSchema), true, { doNotPushHistory: true });
 				else await this.deleteCodeDslByIds([id], { doNotPushHistory: true });
 				return;
 			}
-			if (!oldContent || !newContent) return;
-			const sourceForValues = reverse ? oldContent : newContent;
+			if (!oldSchema || !newSchema) return;
+			const sourceForValues = reverse ? oldSchema : newSchema;
 			if (changeRecords?.length) {
 				const current = this.getCodeContentById(id);
 				if (!current) return;
@@ -15920,18 +16760,6 @@
 			"createId"
 		]
 	};
-	/**
-	* 「回滚」生成的新 step 简短描述。
-	* 仅在 service 层使用，避免依赖 UI 层 composables。
-	*/
-	var describeRevertDataSourceStep = (step) => {
-		const { oldSchema, newSchema, changeRecords, id } = step;
-		if (oldSchema === null && newSchema) return `撤回新增 ${newSchema.title || newSchema.id || id}`;
-		if (oldSchema && newSchema === null) return `还原已删除的 ${oldSchema.title || oldSchema.id || id}`;
-		const title = newSchema?.title || oldSchema?.title || `${id}`;
-		const propPath = changeRecords?.[0]?.propPath;
-		return propPath ? `还原 ${title} · ${propPath}` : `还原 ${title}`;
-	};
 	var DataSource = class extends BaseService {
 		state = (0, vue.reactive)({
 			datasourceTypeList: [],
@@ -15942,6 +16770,12 @@
 			events: {},
 			methods: {}
 		});
+		/**
+		* 最近一次写入历史栈的数据源历史记录 uuid。
+		* 供 *AndGetHistoryId 系列方法在调用 add / update / remove 后取回本次产生的历史记录 id；
+		* 普通方法不读取它，调用前由 *AndGetHistoryId 重置为 null。
+		*/
+		lastPushedHistoryId = null;
 		constructor() {
 			super(canUsePluginMethods$3.sync.map((methodName) => ({
 				name: methodName,
@@ -15991,12 +16825,12 @@
 				id: config.id && !this.getDataSourceById(config.id) ? config.id : this.createId()
 			};
 			this.get("dataSources").push(newConfig);
-			if (!doNotPushHistory) history_default.pushDataSource(newConfig.id, {
+			if (!doNotPushHistory) this.lastPushedHistoryId = history_default.pushDataSource(newConfig.id, {
 				oldSchema: null,
 				newSchema: newConfig,
 				historyDescription,
 				source: historySource
-			});
+			})?.uuid ?? null;
 			this.emit("add", newConfig);
 			return newConfig;
 		}
@@ -16014,13 +16848,13 @@
 			const oldConfig = dataSources[index];
 			const newConfig = cloneDeep$1(config);
 			dataSources[index] = newConfig;
-			if (!doNotPushHistory) history_default.pushDataSource(newConfig.id, {
+			if (!doNotPushHistory) this.lastPushedHistoryId = history_default.pushDataSource(newConfig.id, {
 				oldSchema: oldConfig ? cloneDeep$1(oldConfig) : null,
 				newSchema: newConfig,
 				changeRecords,
 				historyDescription,
 				source: historySource
-			});
+			})?.uuid ?? null;
 			this.emit("update", newConfig, {
 				oldConfig,
 				changeRecords
@@ -16039,15 +16873,40 @@
 			const index = dataSources.findIndex((ds) => ds.id === id);
 			const oldConfig = index !== -1 ? dataSources[index] : null;
 			dataSources.splice(index, 1);
-			if (oldConfig && !doNotPushHistory) history_default.pushDataSource(id, {
+			if (oldConfig && !doNotPushHistory) this.lastPushedHistoryId = history_default.pushDataSource(id, {
 				oldSchema: cloneDeep$1(oldConfig),
 				newSchema: null,
 				historyDescription,
 				source: historySource
-			});
+			})?.uuid ?? null;
 			this.emit("remove", id);
 		}
 		/**
+		* 下列 *AndGetHistoryId 方法与对应的 add / update / remove 行为完全一致，
+		* 唯一区别是返回值为本次写入历史栈的历史记录 uuid（{@link DataSourceStepValue.uuid}），
+		* 而非数据源配置。可用于精确引用 / 定位该条历史记录（埋点、revert、跨端同步等）。
+		*
+		* 当本次操作未写入历史（doNotPushHistory 为 true、或无对应记录）时返回 null。
+		*/
+		/** 等价于 {@link add}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		addAndGetHistoryId(config, options = {}) {
+			this.lastPushedHistoryId = null;
+			this.add(config, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link update}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		updateAndGetHistoryId(config, options = {}) {
+			this.lastPushedHistoryId = null;
+			this.update(config, options);
+			return this.lastPushedHistoryId;
+		}
+		/** 等价于 {@link remove}，但返回本次写入历史记录的 uuid（未入栈时返回 null）。 */
+		removeAndGetHistoryId(id, options = {}) {
+			this.lastPushedHistoryId = null;
+			this.remove(id, options);
+			return this.lastPushedHistoryId;
+		}
+		/**
 		* 撤销指定数据源的最近一次变更。
 		*
 		* 内部走 add / update / remove，因此会自动触发 dataSourceService 的事件，
@@ -16115,10 +16974,24 @@
 		revert(id, index) {
 			const entry = history_default.getDataSourceStepList(id)[index];
 			if (!entry?.applied) return null;
-			if (entry.step.oldSchema && entry.step.newSchema && !entry.step.changeRecords?.length) return null;
-			const description = `回滚 #${index + 1}: ${describeRevertDataSourceStep(entry.step)}`;
+			const { oldSchema, newSchema, changeRecords } = entry.step.diff?.[0] ?? {};
+			if (oldSchema && newSchema && !changeRecords?.length) return null;
+			const description = `回滚 #${index + 1}: ${describeRevertStep(entry.step.id, entry.step.diff?.[0], (s) => s.title)}`;
 			return this.applyRevertStep(entry.step, description);
 		}
+		/**
+		* 通过历史记录 uuid 回滚某条数据源历史步骤，语义同 {@link revert}，
+		* 仅无需调用方再传 dataSourceId 与 index：内部会按 uuid（{@link DataSourceStepValue.uuid}）
+		* 在全部数据源栈中定位对应步骤后再回滚。
+		*
+		* @param uuid 目标历史记录的 uuid，通常由 {@link addAndGetHistoryId} 等方法返回
+		* @returns 反向后产生的新 step；找不到对应 uuid / 未应用时返回 null
+		*/
+		revertById(uuid) {
+			const location = history_default.findDataSourceStepLocationByUuid(uuid);
+			if (!location) return null;
+			return this.revert(location.id, location.index);
+		}
 		createId() {
 			return `ds_${(0, _tmagic_utils.guid)()}`;
 		}
@@ -16177,15 +17050,16 @@
 		* 同构，差异仅在于走对应的公共 add / update / remove 而不是带 doNotPushHistory 的版本。
 		*/
 		applyRevertStep(step, historyDescription) {
-			const { id, oldSchema, newSchema, changeRecords } = step;
-			if (oldSchema === null && newSchema) {
+			const { id } = step;
+			const { oldSchema, newSchema, changeRecords } = step.diff?.[0] ?? {};
+			if (!oldSchema && newSchema) {
 				this.remove(`${id}`, {
 					historyDescription,
 					historySource: "rollback"
 				});
 				return history_default.getDataSourceStepList(id).slice(-1)[0]?.step ?? null;
 			}
-			if (oldSchema && newSchema === null) {
+			if (oldSchema && !newSchema) {
 				this.add(cloneDeep$1(oldSchema), {
 					historyDescription,
 					historySource: "rollback"
@@ -16234,13 +17108,14 @@
 		* @param reverse true=撤销，false=重做
 		*/
 		applyHistoryStep(step, reverse) {
-			const { id, oldSchema, newSchema, changeRecords } = step;
-			if (oldSchema === null && newSchema) {
+			const { id } = step;
+			const { oldSchema, newSchema, changeRecords } = step.diff?.[0] ?? {};
+			if (!oldSchema && newSchema) {
 				if (reverse) this.remove(`${id}`, { doNotPushHistory: true });
 				else this.add(cloneDeep$1(newSchema), { doNotPushHistory: true });
 				return;
 			}
-			if (oldSchema && newSchema === null) {
+			if (oldSchema && !newSchema) {
 				if (reverse) this.add(cloneDeep$1(oldSchema), { doNotPushHistory: true });
 				else this.remove(`${id}`, { doNotPushHistory: true });
 				return;
@@ -16891,7 +17766,7 @@
 	//#region packages/editor/src/initService.ts
 	var initServiceState = (props, { editorService, historyService, componentListService, propsService, eventsService, uiService, codeBlockService, keybindingService, dataSourceService, depService }) => {
 		(0, vue.watch)(() => props.modelValue, (modelValue) => {
-			editorService.set("root", modelValue || null);
+			editorService.set("root", modelValue || null, { historySource: "initial" });
 		}, { immediate: true });
 		(0, vue.watch)(() => props.disabledMultiSelect, (disabledMultiSelect) => {
 			editorService.set("disabledMultiSelect", disabledMultiSelect || false);
@@ -22166,6 +23041,7 @@
 	exports.H_GUIDE_LINE_STORAGE_KEY = H_GUIDE_LINE_STORAGE_KEY;
 	exports.HistoryDiffDialog = HistoryDiffDialog_default;
 	exports.HistoryListBucket = Bucket_default;
+	exports.HistoryListBucketTab = BucketTab_default;
 	exports.Icon = Icon_default;
 	exports.IdleTask = IdleTask;
 	exports.KeyBindingCommand = KeyBindingCommand;
@@ -22215,17 +23091,24 @@
 	exports.classifyDragSources = classifyDragSources;
 	exports.codeBlockService = codeBlock_default;
 	exports.collectRelatedNodes = collectRelatedNodes;
+	exports.createStackStep = createStackStep;
 	exports.dataSourceService = dataSource_default;
 	exports.debug = debug;
 	exports.default = plugin_default;
 	exports.defaultIsExpandable = defaultIsExpandable;
 	exports.depService = dep_default;
+	exports.describeRevertStep = describeRevertStep;
+	exports.describeStepForRevert = describeStepForRevert;
+	exports.deserializeStacks = deserializeStacks;
 	Object.defineProperty(exports, "designPlugin", {
 		enumerable: true,
 		get: function() {
 			return _tmagic_design.default;
 		}
 	});
+	exports.detectPageTargetId = detectPageTargetId;
+	exports.detectPageTargetName = detectPageTargetName;
+	exports.detectStackOpType = detectStackOpType;
 	exports.displayTabConfig = displayTabConfig;
 	exports.editorNodeMergeCustomizer = editorNodeMergeCustomizer;
 	exports.editorService = editor_default;
@@ -22256,21 +23139,31 @@
 	exports.getGuideLineFromCache = getGuideLineFromCache;
 	exports.getInitPositionStyle = getInitPositionStyle;
 	exports.getNodeIndex = getNodeIndex;
+	exports.getOrCreateStack = getOrCreateStack;
 	exports.getPageFragmentList = getPageFragmentList;
 	exports.getPageList = getPageList;
 	exports.getPageNameList = getPageNameList;
 	exports.getPositionInContainer = getPositionInContainer;
 	exports.getRelativeStyle = getRelativeStyle;
 	exports.historyService = history_default;
+	exports.idbDelete = idbDelete;
+	exports.idbGet = idbGet;
+	exports.idbSet = idbSet;
 	exports.info = info;
 	exports.isIncludeDataSource = isIncludeDataSource;
+	exports.isIndexedDBSupported = isIndexedDBSupported;
 	exports.loadMonaco = monaco_editor_default;
 	exports.log = log;
+	exports.markStackSaved = markStackSaved;
+	exports.mergePageSteps = mergePageSteps;
+	exports.mergeStackSteps = mergeStackSteps;
 	exports.moveItemsInContainer = moveItemsInContainer;
 	exports.numberOptions = numberOptions;
+	exports.openIndexedDB = openIndexedDB;
 	exports.propsService = props_default;
 	exports.resolveSelectedNode = resolveSelectedNode;
 	exports.serializeConfig = serializeConfig;
+	exports.serializeStacks = serializeStacks;
 	exports.setChildrenLayout = setChildrenLayout;
 	exports.setEditorConfig = setEditorConfig;
 	exports.setLayout = setLayout;
@@ -22285,6 +23178,7 @@
 	});
 	exports.toggleFixedPosition = toggleFixedPosition;
 	exports.uiService = ui_default;
+	exports.undoFloor = undoFloor;
 	exports.updateStatus = updateStatus;
 	exports.useCodeBlockEdit = useCodeBlockEdit;
 	exports.useEditorContentHeight = useEditorContentHeight;