@tmagic/utils 1.8.0-beta.24 → 1.8.0-beta.26

package/types/index.d.ts

@@ -1,12 +1,2236 @@
 import { DataSchema, DataSourceDeps, Id, MComponent, MNode, MNodeInstance } from "@tmagic/schema";
-import { MContainer, MNode as MNode$1, MPage, MPageFragment } from "@tmagic/core";
+import { Component } from "vue";
+import { EventEmitter } from "events";
+import { PascalCasedProperties, Writable } from "type-fest";
+import { CodeBlockContent, CodeBlockDSL, DataSourceSchema, DepData, DepExtendedData, DepTargetType, EventOption, Id as Id$1, MApp, MContainer, MNode as MNode$1, MPage, MPageFragment, Target, TargetOptions } from "@tmagic/core";
+import { ChangeRecord, FormConfig, TableColumnConfig } from "@tmagic/form";
+import StageCore, { CanDropIn, ContainerHighlightType, CustomizeMoveableOptions, GuidesOptions, RenderType, UpdateDragEl } from "@tmagic/stage";
+//#region temp/packages/editor/src/services/BaseService.d.ts
+/**
+ * 对Class进行扩展
+ * 给Class中的每个方法都添加before after两个钩子
+ * 给Class添加一个usePlugin方法，usePlugin方法可以传入一个包含before或者after方法的对象
+ *
+ * 例如：
+ *   Class EditorService extends BaseService {
+ *     constructor() {
+ *       super([ { name: 'add', isAsync: true },]);
+ *     }
+ *     add(value) { return result; }
+ *   };
+ *
+ *   const editorService = new EditorService();
+ *
+ *   editorService.usePlugin({
+ *     beforeAdd(value) { return [value] },
+ *     afterAdd(result, value) { return result },
+ *   });
+ *
+ *   editorService.add(); 最终会变成  () => {
+ *    editorService.beforeAdd();
+ *    editorService.add();
+ *    editorService.afterAdd();
+ *   }
+ *
+ * 调用时的参数会透传到before方法的参数中, 然后before的return 会作为原方法的参数和after的参数，after第一个参数则是原方法的return值;
+ * 如需终止后续方法调用可以return new Error();
+ */
+declare class BaseService extends EventEmitter {
+  private pluginOptionsList;
+  private taskList;
+  private doingTask;
+  constructor(methods?: {
+    name: string;
+    isAsync: boolean;
+  }[], serialMethods?: string[]);
+  usePlugin(options: Record<string, Function>): void;
+  removePlugin(options: Record<string, Function>): void;
+  removeAllPlugins(): void;
+  private doTask;
+}
+//#endregion
+//#region temp/packages/editor/src/services/codeBlock.d.ts
+declare const canUsePluginMethods$8: {
+  async: readonly ["setCodeDslById", "setEditStatus", "setCombineIds", "setUndeleteableList", "deleteCodeDslByIds"];
+  sync: string[];
+};
+type AsyncMethodName$4 = Writable<(typeof canUsePluginMethods$8)['async']>;
+declare class CodeBlock extends BaseService {
+  private state;
+  /**
+   * 最近一次写入历史栈的代码块历史记录 uuid（单条写入场景：新增 / 更新）。
+   * 供 setCodeDslById(Sync)AndGetHistoryId 取回，普通方法不读取它。
+   */
+  private lastPushedHistoryId;
+  /**
+   * deleteCodeDslByIds 一次删除多个代码块时，按写入顺序收集的历史记录 uuid 列表。
+   * 在 deleteCodeDslByIds 入口处重置，供 deleteCodeDslByIdsAndGetHistoryId 取回。
+   */
+  private lastDeletedHistoryIds;
+  constructor();
+  /**
+   * 设置活动的代码块dsl数据源
+   * @param {CodeBlockDSL} codeDsl 代码DSL
+   * @returns {void}
+   */
+  setCodeDsl(codeDsl: CodeBlockDSL): Promise<void>;
+  /**
+   * 获取活动的代码块dsl数据源（默认从dsl中的codeBlocks字段读取）
+   * 方法要支持钩子添加扩展，会被重写为异步方法,因此这里显示写为异步以提醒调用者需以异步形式调用
+   * @param {boolean} forceRefresh 是否强制从活动dsl拉取刷新
+   * @returns {CodeBlockDSL | null}
+   */
+  getCodeDsl(): CodeBlockDSL | null;
+  /**
+   * 根据代码块id获取代码块内容
+   * @param {Id} id 代码块id
+   * @returns {CodeBlockContent | null}
+   */
+  getCodeContentById(id: Id$1): CodeBlockContent | null;
+  /**
+   * 设置代码块ID和代码内容到源dsl
+   * @param {Id} id 代码块id
+   * @param {CodeBlockContent} codeConfig 代码块内容配置信息
+   * @param options 可选配置
+   * @param options.changeRecords form 端 propPath/value 列表，用于历史记录的精细化撤销/重做
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @returns {void}
+   */
+  setCodeDslById(id: Id$1, codeConfig: Partial<CodeBlockContent>, { changeRecords, doNotPushHistory, historyDescription, historySource }?: HistoryOpOptionsWithChangeRecords): Promise<void>;
+  /**
+   * 为了兼容历史原因
+   * 设置代码块ID和代码内容到源dsl
+   * @param {Id} id 代码块id
+   * @param {CodeBlockContent} codeConfig 代码块内容配置信息
+   * @param {boolean} force 是否强制写入，默认true
+   * @param options 可选配置
+   * @param options.changeRecords form 端 propPath/value 列表，用于历史记录的精细化撤销/重做
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @param options.historyDescription 入栈时附带的人类可读描述，用于历史面板展示
+   * @returns {void}
+   */
+  setCodeDslByIdSync(id: Id$1, codeConfig: Partial<CodeBlockContent>, force?: boolean, { changeRecords, doNotPushHistory, historyDescription, historySource }?: HistoryOpOptionsWithChangeRecords): void;
+  /**
+   * 根据代码块id数组获取代码dsl
+   * @param {string[]} ids 代码块id数组
+   * @returns {CodeBlockDSL}
+   */
+  getCodeDslByIds(ids: string[]): CodeBlockDSL;
+  /**
+   * 获取编辑状态
+   * @returns {boolean} 是否可编辑
+   */
+  getEditStatus(): boolean;
+  /**
+   * 设置编辑状态
+   * @param {boolean} status 是否可编辑
+   * @returns {void}
+   */
+  setEditStatus(status: boolean): Promise<void>;
+  /**
+   * 设置当前选中组件已关联绑定的代码块id数组
+   * @param {string[]} ids 代码块id数组
+   * @returns {void}
+   */
+  setCombineIds(ids: string[]): Promise<void>;
+  /**
+   * 获取当前选中组件已关联绑定的代码块id数组
+   * @returns {string[]}
+   */
+  getCombineIds(): string[];
+  /**
+   * 获取不可删除列表
+   * @returns {Id[]}
+   */
+  getUndeletableList(): Id$1[];
+  /**
+   * 设置不可删除列表：为业务逻辑预留的不可删除的代码块列表，由业务逻辑维护（如代码块上线后不可删除）
+   * @param {Id[]} codeIds 代码块id数组
+   * @returns {void}
+   */
+  setUndeleteableList(codeIds: Id$1[]): Promise<void>;
+  /**
+   * 设置代码草稿
+   */
+  setCodeDraft(codeId: Id$1, content: string): void;
+  /**
+   * 获取代码草稿
+   */
+  getCodeDraft(codeId: Id$1): string | null;
+  /**
+   * 删除代码草稿
+   */
+  removeCodeDraft(codeId: Id$1): void;
+  /**
+   * 在dsl数据源中删除指定id的代码块
+   * @param {Id[]} codeIds 需要删除的代码块id数组
+   * @param options 可选配置
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   */
+  deleteCodeDslByIds(codeIds: Id$1[], { doNotPushHistory, historyDescription, historySource }?: HistoryOpOptions): Promise<void>;
+  /**
+   * 下列 *AndGetHistoryId 方法与对应的写入方法行为完全一致，
+   * 返回值在 {@link DslOpWithHistoryIdsResult} 中同时包含原操作结果与本次写入的历史 uuid 列表，
+   * 可用于精确引用 / 定位该条历史记录（埋点、revert、跨端同步等）。
+   *
+   * 当本次操作未写入历史（doNotPushHistory 为 true、或无对应记录）时 historyIds 为 `[]`。
+   */
+  /** 等价于 {@link setCodeDslById}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  setCodeDslByIdAndGetHistoryId(id: Id$1, codeConfig: Partial<CodeBlockContent>, options?: HistoryOpOptionsWithChangeRecords): Promise<DslOpWithHistoryIdsResult<void>>;
+  /** 等价于 {@link setCodeDslByIdSync}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  setCodeDslByIdSyncAndGetHistoryId(id: Id$1, codeConfig: Partial<CodeBlockContent>, force?: boolean, options?: HistoryOpOptionsWithChangeRecords): DslOpWithHistoryIdsResult<void>;
+  /**
+   * 等价于 {@link deleteCodeDslByIds}，并额外返回本次写入的全部历史记录 uuid（按删除顺序）。
+   * 一次删除多个代码块会产生多条历史记录；未写入任何历史时 historyIds 为 `[]`。
+   */
+  deleteCodeDslByIdsAndGetHistoryId(codeIds: Id$1[], options?: HistoryOpOptions): Promise<DslOpWithHistoryIdsResult<void>>;
+  setParamsColConfig(config: TableColumnConfig): void;
+  getParamsColConfig(): TableColumnConfig | undefined;
+  /**
+   * 撤销指定代码块的最近一次变更。
+   *
+   * 内部走 setCodeDslByIdSync / deleteCodeDslByIds，因此会自动触发 codeBlockService 的
+   * `addOrUpdate` / `remove` 事件，由 initService 中的 handler 重新维护 dep target
+   * （DepTargetType.CODE_BLOCK 的 add / remove）。所有写回都带 `doNotPushHistory: true`，
+   * 确保不会在历史栈里产生新的记录。
+   *
+   * @param id 代码块 id
+   * @returns 撤销的 step；栈不存在或已无可撤销时返回 null
+   */
+  undo(id: Id$1): Promise<CodeBlockStepValue | null>;
+  /**
+   * 重做指定代码块的下一次变更。
+   * @param id 代码块 id
+   * @returns 重做的 step；栈不存在或已无可重做时返回 null
+   */
+  redo(id: Id$1): Promise<CodeBlockStepValue | null>;
+  /** 是否可对指定代码块撤销。 */
+  canUndo(id: Id$1): boolean;
+  /** 是否可对指定代码块重做。 */
+  canRedo(id: Id$1): boolean;
+  /**
+   * 跳转指定代码块的历史栈到目标游标。语义同 editor.gotoPageStep。
+   *
+   * @param id          代码块 id
+   * @param targetCursor 目标游标位置（已应用步骤数量）
+   * @returns 实际移动到的最终游标位置
+   */
+  goto(id: Id$1, targetCursor: number): Promise<number>;
+  /**
+   * 「回滚」指定代码块历史步骤（类 git revert 语义）：
+   * - 不动原始栈结构（不移动 cursor、不丢弃任何步骤）；
+   * - 把目标 step 的修改**反向应用**一次，并作为**新步骤**追加到栈顶；
+   * - 仅对已应用的步骤生效。
+   *
+   * @param id    代码块 id
+   * @param index 目标 step 在该栈中的索引（0 为最早），通常由历史面板传入
+   * @returns 反向后产生的新 step；目标不存在 / 未应用时返回 null
+   */
+  revert(id: Id$1, index: number): Promise<CodeBlockStepValue | null>;
+  /**
+   * 通过历史记录 uuid 回滚代码块历史步骤，语义同 {@link revert}，
+   * 仅无需调用方再传 codeBlockId 与 index：内部会按 uuid 在全部代码块栈中定位对应步骤后再回滚。
+   * 按数组顺序依次回滚，返回与入参同序的结果列表（某项失败时为 `null`）。
+   *
+   * @param uuids 目标历史记录的 uuid 列表，通常由 {@link setCodeDslByIdAndGetHistoryId} 等方法返回的 `historyIds`
+   */
+  revertById(uuids: string[]): Promise<(CodeBlockStepValue | null)[]>;
+  /**
+   * 生成代码块唯一id
+   * @returns {Id} 代码块唯一id
+   */
+  getUniqueId(): Promise<string>;
+  /**
+   * 复制时会带上组件关联的代码块
+   * @param config 组件节点配置
+   * @returns
+   */
+  copyWithRelated(config: MNode$1 | MNode$1[], collectorOptions?: TargetOptions): void;
+  /**
+   * 粘贴代码块
+   * @returns
+   */
+  paste(): void;
+  resetState(): void;
+  destroy(): void;
+  usePlugin(options: AsyncHookPlugin<AsyncMethodName$4, CodeBlock>): void;
+  /**
+   * 反向应用一个 step 并以新 step 入栈。逻辑与 applyHistoryStep(reverse=true) 同构，
+   * 差异仅在于通过公开的 setCodeDslByIdSync / deleteCodeDslByIds 触发 push。
+   */
+  private applyRevertStep;
+  /**
+   * 把一条历史 step 应用到当前代码块服务上。
+   *
+   * 复用现有的 setCodeDslByIdSync / deleteCodeDslByIds，目的是借助它们发出的事件
+   * 触发 initService 中的 dep target 维护（CODE_BLOCK 的 add / remove）。
+   * 所有写回都带 `doNotPushHistory: true`，确保不会在历史栈里产生新的记录。
+   *
+   * - oldContent=null, newContent≠null：原始为新增 → undo 删除；redo 再次 setCodeDslByIdSync
+   * - oldContent≠null, newContent=null：原始为删除 → undo 还原写入；redo 再次删除
+   * - 两侧都有：原始为更新 → 按 changeRecords 局部 patch；缺省退化为整内容替换
+   *
+   * @param step 历史 step
+   * @param reverse true=撤销，false=重做
+   */
+  private applyHistoryStep;
+}
+type CodeBlockService = CodeBlock;
+//#endregion
+//#region temp/packages/editor/src/services/componentList.d.ts
+declare class ComponentList extends BaseService {
+  private state;
+  constructor();
+  /**
+   * @param componentGroupList 组件列表配置
+   */
+  setList(componentGroupList: ComponentGroup[]): void;
+  getList(): ComponentGroup[];
+  resetState(): void;
+  destroy(): void;
+}
+type ComponentListService = ComponentList;
+//#endregion
+//#region temp/packages/editor/src/services/dataSource.d.ts
+interface State$1 {
+  datasourceTypeList: DatasourceTypeOption[];
+  dataSources: DataSourceSchema[];
+  editable: boolean;
+  configs: Record<string, FormConfig>;
+  values: Record<string, Partial<DataSourceSchema>>;
+  events: Record<string, EventOption[]>;
+  methods: Record<string, EventOption[]>;
+}
+type StateKey$1 = keyof State$1;
+declare const canUsePluginMethods$7: {
+  async: never[];
+  sync: readonly ["getFormConfig", "setFormConfig", "getFormValue", "setFormValue", "getFormEvent", "setFormEvent", "getFormMethod", "setFormMethod", "add", "update", "remove", "createId"];
+};
+type SyncMethodName$5 = Writable<(typeof canUsePluginMethods$7)['sync']>;
+declare class DataSource extends BaseService {
+  private state;
+  /**
+   * 最近一次写入历史栈的数据源历史记录 uuid。
+   * 供 *AndGetHistoryId 系列方法在调用 add / update / remove 后取回本次产生的历史记录 id；
+   * 普通方法不读取它，调用前由 *AndGetHistoryId 重置为 null。
+   */
+  private lastPushedHistoryId;
+  constructor();
+  set<K extends StateKey$1, T extends State$1[K]>(name: K, value: T): void;
+  get<K extends StateKey$1>(name: K): State$1[K];
+  getFormConfig(type?: string): FormConfig;
+  setFormConfig(type: string, config: FormConfig): void;
+  getFormValue(type?: string): Partial<DataSourceSchema>;
+  setFormValue(type: string, value: Partial<DataSourceSchema>): void;
+  getFormEvent(type?: string): EventOption[];
+  setFormEvent(type: string, value?: EventOption[]): void;
+  getFormMethod(type?: string): EventOption[];
+  setFormMethod(type: string, value?: EventOption[]): void;
+  /**
+   * 新增数据源
+   * @param config 数据源配置
+   * @param options 可选配置
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @param options.historyDescription 入栈时附带的人类可读描述，用于历史面板展示
+   */
+  add(config: DataSourceSchema, { doNotPushHistory, historyDescription, historySource }?: HistoryOpOptions): {
+    id: string;
+    type: string;
+    title?: string;
+    description?: string;
+    fields: import("@tmagic/schema").DataSchema[];
+    methods: import("@tmagic/schema").CodeBlockContent[];
+    mocks?: import("@tmagic/schema").MockSchema[];
+    events: import("@tmagic/schema").EventConfig[];
+    disabledInitInJsEngine?: (import("@tmagic/schema").JsEngine | string)[];
+  };
+  /**
+   * 更新数据源
+   * @param config 数据源配置
+   * @param data 额外数据
+   * @param data.changeRecords form 端变更记录
+   * @param data.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @param data.historyDescription 入栈时附带的人类可读描述，用于历史面板展示
+   */
+  update(config: DataSourceSchema, { changeRecords, doNotPushHistory, historyDescription, historySource }?: HistoryOpOptionsWithChangeRecords): DataSourceSchema;
+  /**
+   * 删除数据源
+   * @param id 数据源 id
+   * @param options 可选配置
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @param options.historyDescription 入栈时附带的人类可读描述，用于历史面板展示
+   */
+  remove(id: string, { doNotPushHistory, historyDescription, historySource }?: HistoryOpOptions): void;
+  /**
+   * 下列 *AndGetHistoryId 方法与对应的 add / update / remove 行为完全一致，
+   * 返回值在 {@link DslOpWithHistoryIdsResult} 中同时包含原操作结果与本次写入历史栈的 uuid 列表（{@link DataSourceStepValue.uuid}），
+   * 可用于精确引用 / 定位该条历史记录（埋点、revert、跨端同步等）。
+   *
+   * 当本次操作未写入历史（doNotPushHistory 为 true、或无对应记录）时 historyIds 为 `[]`。
+   */
+  /** 等价于 {@link add}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  addAndGetHistoryId(config: DataSourceSchema, options?: HistoryOpOptions): DslOpWithHistoryIdsResult<DataSourceSchema>;
+  /** 等价于 {@link update}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  updateAndGetHistoryId(config: DataSourceSchema, options?: HistoryOpOptionsWithChangeRecords): DslOpWithHistoryIdsResult<DataSourceSchema>;
+  /** 等价于 {@link remove}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  removeAndGetHistoryId(id: string, options?: HistoryOpOptions): DslOpWithHistoryIdsResult<void>;
+  /**
+   * 撤销指定数据源的最近一次变更。
+   *
+   * 内部走 add / update / remove，因此会自动触发 dataSourceService 的事件，
+   * 由 initService 中的对应 handler 重新收集 dep（DATA_SOURCE / DATA_SOURCE_COND / DATA_SOURCE_METHOD）。
+   * 所有写回都带 `doNotPushHistory: true`，避免在历史栈里产生新的记录。
+   *
+   * @param id 数据源 id
+   * @returns 撤销的 step；栈不存在或已无可撤销时返回 null
+   */
+  undo(id: Id$1): DataSourceStepValue | null;
+  /**
+   * 重做指定数据源的下一次变更。
+   * @param id 数据源 id
+   * @returns 重做的 step；栈不存在或已无可重做时返回 null
+   */
+  redo(id: Id$1): DataSourceStepValue | null;
+  /** 是否可对指定数据源撤销。 */
+  canUndo(id: Id$1): boolean;
+  /** 是否可对指定数据源重做。 */
+  canRedo(id: Id$1): boolean;
+  /**
+   * 跳转指定数据源的历史栈到目标游标。语义同 editor.gotoPageStep。
+   *
+   * @param id          数据源 id
+   * @param targetCursor 目标游标位置（已应用步骤数量）
+   * @returns 实际移动到的最终游标位置
+   */
+  goto(id: Id$1, targetCursor: number): number;
+  /**
+   * 「回滚」指定数据源历史步骤（类 git revert 语义）：
+   * - 不动原始栈结构（不移动 cursor、不丢弃任何步骤）；
+   * - 把目标 step 的修改**反向应用**一次，并作为**新步骤**追加到栈顶；
+   * - 仅对已应用的步骤生效——未应用步骤本身就不存在于当前 schema 中，反向无意义。
+   *
+   * @param id    数据源 id
+   * @param index 目标 step 在该栈中的索引（0 为最早），通常由历史面板传入
+   * @returns 反向后产生的新 step；目标不存在 / 未应用时返回 null
+   */
+  revert(id: Id$1, index: number): DataSourceStepValue | null;
+  /**
+   * 通过历史记录 uuid 回滚数据源历史步骤，语义同 {@link revert}，
+   * 仅无需调用方再传 dataSourceId 与 index：内部会按 uuid 在全部数据源栈中定位对应步骤后再回滚。
+   * 按数组顺序依次回滚，返回与入参同序的结果列表（某项失败时为 `null`）。
+   *
+   * @param uuids 目标历史记录的 uuid 列表，通常由 {@link addAndGetHistoryId} 等方法返回的 `historyIds`
+   */
+  revertById(uuids: string[]): (DataSourceStepValue | null)[];
+  createId(): string;
+  getDataSourceById(id: string): DataSourceSchema | undefined;
+  resetState(): void;
+  destroy(): void;
+  usePlugin(options: SyncHookPlugin<SyncMethodName$5, DataSource>): void;
+  /**
+   * 复制时会带上组件关联的数据源
+   * @param config 组件节点配置
+   * @returns
+   */
+  copyWithRelated(config: MNode$1 | MNode$1[], collectorOptions?: TargetOptions): void;
+  /**
+   * 粘贴数据源
+   * @returns
+   */
+  paste(): void;
+  /**
+   * 反向应用一个 step 并以新 step 入栈（不带 doNotPushHistory）。逻辑与 applyHistoryStep(reverse=true)
+   * 同构，差异仅在于走对应的公共 add / update / remove 而不是带 doNotPushHistory 的版本。
+   */
+  private applyRevertStep;
+  /**
+   * 把一条历史 step 应用到当前数据源服务上。
+   *
+   * 复用现有的 add / update / remove，目的是借助它们发出的事件触发 initService 中
+   * 的依赖收集逻辑（DATA_SOURCE / DATA_SOURCE_COND / DATA_SOURCE_METHOD）。
+   * 所有写回都带 `doNotPushHistory: true`，确保不会在历史栈里产生新的记录。
+   *
+   * - oldSchema=null, newSchema≠null：原始为新增 → undo 删除；redo 再次 add
+   * - oldSchema≠null, newSchema=null：原始为删除 → undo 还原 add；redo 再次删除
+   * - 两侧都有：原始为更新 → 按 changeRecords 局部 patch；缺省退化为整 schema 替换
+   *
+   * @param step 历史 step
+   * @param reverse true=撤销，false=重做
+   */
+  private applyHistoryStep;
+}
+type DataSourceService = DataSource;
+//#endregion
+//#region temp/packages/editor/src/utils/dep/worker.d.ts
+type DepsData = Record<string, Record<Id$1, DepData>>;
+//#endregion
+//#region temp/packages/editor/src/services/dep.d.ts
+interface DepEvents {
+  'add-target': [target: Target];
+  'remove-target': [id: string | number, type: string | DepTargetType];
+  collected: [nodes: MNode$1[], deep: boolean];
+  'ds-collected': [nodes: MNode$1[], deep: boolean];
+}
+interface State {
+  collecting: boolean;
+  taskLength: number;
+}
+type StateKey = keyof State;
+declare class Dep extends BaseService {
+  private state;
+  private idleTask;
+  private collectWorker;
+  private watcher;
+  private waitingWorker?;
+  private resolveWaitingWorker?;
+  private workerGeneration;
+  private activeBatches;
+  constructor();
+  set<K extends StateKey, T extends State[K]>(name: K, value: T): void;
+  get<K extends StateKey>(name: K): State[K];
+  removeTargets(type?: string): void;
+  getTargets(type?: string): {
+    [targetId: string]: Target;
+    [targetId: number]: Target;
+  };
+  getTarget(id: Id$1, type?: string): Target;
+  addTarget(target: Target): void;
+  removeTarget(id: Id$1, type?: string): void;
+  clearTargets(): void;
+  collect(nodes: MNode$1[], depExtendedData?: DepExtendedData, deep?: boolean, type?: DepTargetType): void;
+  /**
+   * 空闲收集依赖
+   *
+   * 遍历匹配是整个收集过程中最耗时的部分（要深度遍历节点树并对每个属性做 target 匹配），
+   * 节点/数据源多时在主线程执行会长时间卡死页面，因此优先交给 worker 执行，主线程只负责把结果写回 target。
+   * 自定义 target 的 isTarget 是无法跨线程传递的闭包函数（没有 descriptor），仍走主线程空闲队列；
+   * worker 不可用（如 SSR）或执行失败时也会回退到主线程空闲队列。
+   */
+  collectIdle(nodes: MNode$1[], depExtendedData?: DepExtendedData, deep?: boolean, type?: DepTargetType): Promise<boolean>;
+  collectByWorker(dsl: MApp): Promise<DepsData>;
+  collectNode(node: MNode$1, target: Target, depExtendedData?: DepExtendedData, deep?: boolean): void;
+  clear(nodes?: MNode$1[]): void;
+  clearByType(type: DepTargetType, nodes?: MNode$1[]): void;
+  hasTarget(id: Id$1, type?: string): boolean;
+  hasSpecifiedTypeTarget(type?: string): boolean;
+  clearIdleTasks(): void;
+  on<Name extends keyof DepEvents, Param extends DepEvents[Name]>(eventName: Name, listener: (...args: Param) => void | Promise<void>): this;
+  once<Name extends keyof DepEvents, Param extends DepEvents[Name]>(eventName: Name, listener: (...args: Param) => void | Promise<void>): this;
+  reset(): void;
+  destroy(): void;
+  emit<Name extends keyof DepEvents, Param extends DepEvents[Name]>(eventName: Name, ...args: Param): boolean;
+  /**
+   * 删除指定 page 在该 target 下的旧依赖：
+   * 按 pageId 匹配，可清掉页面内已被删除节点的残留依赖
+   */
+  private removePageDep;
+  /**
+   * 把遍历匹配交给 worker，结果回来后按 target 分片写回主线程
+   */
+  private collectByCollectWorker;
+  /**
+   * 用 worker 的收集结果替换 target 上这批节点的依赖
+   */
+  private enqueueApplyTask;
+  private enqueueTasks;
+  private enqueueTask;
+  private beginBatchTask;
+  private onBatchTaskDone;
+  private settleBatchDs;
+  private finishBatch;
+  /**
+   * idleTask 被清空时，在途批次的任务不会再执行，必须主动结算，
+   * 否则对应的 collectIdle Promise 永远不会 resolve（collecting 卡在 true、once 监听器泄漏）。
+   * 收集被中断（通常紧跟一次全量重新收集），因此不再 emit collected/ds-collected，仅结算 Promise。
+   */
+  private abortActiveBatches;
+  private updateCollectingState;
+}
+type DepService = Dep;
+//#endregion
+//#region temp/packages/editor/src/services/editor.d.ts
+declare class Editor extends BaseService {
+  state: StoreState;
+  private selectionBeforeOp;
+  /**
+   * 操作前的节点校验错误快照，与 selectionBeforeOp 同时在 captureSelectionBeforeOp 中捕获，
+   * 供 pushOpHistory 写入 step.extra.invalidNodeIdsBefore，用于撤销时还原到「操作前」的错误状态。
+   */
+  private invalidNodeIdsBeforeOp;
+  /**
+   * 最近一次 pushOpHistory 写入的历史记录 uuid。
+   * 供 *AndGetHistoryId 系列方法在调用普通操作后取回本次产生的历史记录 id；
+   * 普通操作不会读取它，调用前由 *AndGetHistoryId 重置为 null。
+   */
+  private lastPushedHistoryId;
+  /**
+   * 上一次 doAdd 的插入记忆：nodeId 为插入的节点，selectedId 为当时的选中节点。
+   * 仅在选中节点未变化时复用（连续 add / doNotSelect / 批量粘贴），选中变化后自动失效，无需手动清理。
+   */
+  private lastAdded;
+  constructor();
+  /**
+   * 设置当前指点节点配置
+   * @param name 'root' | 'page' | 'parent' | 'node' | 'highlightNode' | 'nodes' | 'stage' | 'modifiedNodeIds' | 'invalidNodeIds' | 'pageLength' | 'pageFragmentLength
+   * @param value MNode
+   * @param options.historySource 设置 root 时，本次变更写入历史记录的「操作来源」（仅 name === 'root' 时生效）
+   */
+  set<K extends StoreStateKey, T extends StoreState[K]>(name: K, value: T, options?: {
+    historySource?: HistoryOpSource;
+  }): void;
+  /**
+   * 获取当前指点节点配置
+   * @param name  'root' | 'page' | 'parent' | 'node' | 'highlightNode' | 'nodes' | 'stage' | 'modifiedNodeIds' | 'invalidNodeIds' | 'pageLength' | 'pageFragmentLength'
+   * @returns MNode
+   */
+  get<K extends StoreStateKey>(name: K): StoreState[K];
+  /**
+   * 根据id获取组件、组件的父组件以及组件所属的页面节点
+   * @param {number | string} id 组件id
+   * @param {boolean} raw 是否使用toRaw
+   * @returns {EditorNodeInfo}
+   */
+  getNodeInfo(id: Id$1, raw?: boolean): EditorNodeInfo;
+  /**
+   * 根据ID获取指点节点配置
+   * @param id 组件ID
+   * @param {boolean} raw 是否使用toRaw
+   * @returns 组件节点配置
+   */
+  getNodeById(id: Id$1, raw?: boolean): MNode$1 | null;
+  /**
+   * 根据ID获取指点节点的父节点配置
+   * @param id 组件ID
+   * @param {boolean} raw 是否使用toRaw
+   * @returns 指点组件的父节点配置
+   */
+  getParentById(id: Id$1, raw?: boolean): MContainer | null;
+  /**
+   * 判断给定节点是否位于非当前页面（即选中该节点将会引起当前页面切换）
+   * @param node 节点
+   * @returns true 表示该节点位于非当前页面
+   */
+  isOnDifferentPage(node: MNode$1): boolean;
+  /**
+   * 只有容器拥有布局
+   */
+  getLayout(parent: MNode$1, node?: MNode$1 | null): Promise<Layout>;
+  /**
+   * 选中指定节点（将指定节点设置成当前选中状态）
+   * @param config 指定节点配置或者ID
+   * @returns 当前选中的节点配置
+   */
+  select(config: MNode$1 | Id$1): Promise<MNode$1> | never;
+  selectNextNode(): Promise<MNode$1 | null> | never;
+  selectNextPage(): Promise<MNode$1> | never;
+  /**
+   * 高亮指定节点
+   * @param config 指定节点配置或者ID
+   * @returns 当前高亮的节点配置
+   */
+  highlight(config: MNode$1 | Id$1): void;
+  /**
+   * 多选
+   * @param ids 指定节点ID
+   * @returns 加入多选的节点配置
+   */
+  multiSelect(ids: Id$1[]): void;
+  selectRoot(): void;
+  doAdd(node: MNode$1, parent: MContainer, _options?: DslOpOptions): Promise<MNode$1>;
+  /**
+   * 向指点容器添加组件节点
+   * @param addConfig 将要添加的组件节点配置
+   * @param parent 要添加到的容器组件节点配置，如果不设置，默认为当前选中的组件的父节点
+   * @param options 可选配置，见 {@link DslOpOptions}
+   * @returns 添加后的节点
+   */
+  add(addNode: AddMNode | MNode$1[], parent?: MContainer | null, options?: DslOpOptions): Promise<MNode$1 | MNode$1[]>;
+  doRemove(node: MNode$1, { doNotSelect, doNotSwitchPage }?: DslOpOptions): Promise<void>;
+  /**
+   * 删除组件
+   * @param {Object} node 要删除的节点或节点集合
+   * @param options 可选配置
+   * @param options.doNotSelect 删除后是否不更新当前选中节点（默认 false，删除后会选中父节点或首个页面）
+   * @param options.doNotSwitchPage 删除后是否不切换当前页面（默认 false；删除页面 / 页面片段时为 true 会跳过自动切换到首个剩余页面）
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   */
+  remove(nodeOrNodeList: MNode$1 | MNode$1[], options?: DslOpOptions): Promise<void>;
+  doUpdate(config: MNode$1, data?: UpdateOptions): Promise<{
+    newNode: MNode$1;
+    oldNode: MNode$1;
+    changeRecords?: ChangeRecord[];
+  }>;
+  /**
+   * 更新节点
+   * update后会触发依赖收集，收集完后会掉stage.update方法
+   * @param config 新的节点配置，配置中需要有id信息
+   * @param data 额外数据，见 {@link UpdateOptions}
+   * @returns 更新后的节点配置
+   */
+  update(config: MNode$1 | MNode$1[], data?: UpdateOptions): Promise<MNode$1 | MNode$1[]>;
+  /**
+   * 将id为id1的组件移动到id为id2的组件位置上，例如：[1,2,3,4] -> sort(1,3) -> [2,1,3,4]
+   * @param id1 组件ID
+   * @param id2 组件ID
+   * @param options 可选配置
+   * @param options.doNotSelect 排序后是否不更新当前选中节点（默认 false）
+   * @param options.doNotSwitchPage 排序后是否不切换当前页面（排序只发生在同一父节点内，方法内为空操作；保留以与其它 DSL 操作 API 一致）
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @returns void
+   */
+  sort(id1: Id$1, id2: Id$1, { doNotSelect, doNotPushHistory, historySource }?: DslOpOptions): Promise<void>;
+  /**
+   * 将组件节点配置存储到localStorage中
+   * @param config 组件节点配置
+   * @returns
+   */
+  copy(config: MNode$1 | MNode$1[]): void;
+  /**
+   * 复制时会带上组件关联的依赖
+   * @param config 组件节点配置
+   * @returns
+   */
+  copyWithRelated(config: MNode$1 | MNode$1[], collectorOptions?: TargetOptions): void;
+  /**
+   * 从localStorage中获取节点，然后添加到当前容器中
+   * @param position 粘贴的坐标
+   * @param collectorOptions 可选的依赖收集器配置
+   * @param options 可选配置
+   * @param options.doNotSelect 粘贴后是否不更新当前选中节点（默认 false）
+   * @param options.doNotSwitchPage 粘贴后是否不切换当前页面（默认 false；跨页粘贴时为 true 会跳过页面切换）
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @returns 添加后的组件节点配置
+   */
+  paste(position?: PastePosition, collectorOptions?: TargetOptions, { doNotSelect, doNotSwitchPage, doNotPushHistory, historyDescription, historySource }?: DslOpOptions): Promise<MNode$1 | MNode$1[] | void>;
+  doPaste(config: MNode$1[], position?: PastePosition): Promise<MNode$1[]>;
+  doAlignCenter(config: MNode$1): Promise<MNode$1>;
+  /**
+   * 将指点节点设置居中
+   * @param config 组件节点配置
+   * @param options 可选配置
+   * @param options.doNotSelect 居中后是否不更新当前选中节点（默认 false）
+   * @param options.doNotSwitchPage 居中后是否不切换当前页面（居中只更新节点 style，方法内为空操作；保留以与其它 DSL 操作 API 一致）
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   * @returns 当前组件节点配置
+   */
+  alignCenter(config: MNode$1 | MNode$1[], { doNotSelect, doNotPushHistory, historyDescription, historySource }?: DslOpOptions): Promise<MNode$1 | MNode$1[]>;
+  /**
+   * 移动当前选中节点位置
+   * @param offset 偏移量
+   * @param options 可选配置
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   */
+  moveLayer(offset: number | LayerOffset, { doNotPushHistory, historyDescription, historySource }?: DslOpOptions): Promise<void>;
+  /**
+   * 移动一个或多个节点到指定容器中。
+   *
+   * 多选场景（config 是数组）只会产生一条历史记录，
+   * `updatedItems` 涵盖所有源父容器 + 目标容器的前后快照。
+   * 这避免了"多选移动到某容器"在历史栈里被切成 N 条记录。
+   *
+   * @param config 需要移动的节点（或节点数组，各项需带 id；style 等字段会与原节点合并）
+   * @param targetId 容器ID
+   * @param options 可选配置
+   * @param options.doNotSelect 移动后是否不更新当前选中节点（默认 false）
+   * @param options.doNotSwitchPage 移动后是否不切换当前页面（默认 false；目标容器位于其它页面时为 true 会跳过自动选中以避免页面切换）
+   * @param options.doNotPushHistory 是否不写入历史记录（默认 false）
+   */
+  moveToContainer(config: MNode$1 | MNode$1[], targetId: Id$1, { doNotSelect, doNotSwitchPage, doNotPushHistory, historyDescription, historySource }?: DslOpOptions): Promise<MNode$1 | MNode$1[]>;
+  dragTo(config: MNode$1 | MNode$1[], targetParent: MContainer, targetIndex: number, { doNotPushHistory, historyDescription, historySource }?: DslOpOptions): Promise<void>;
+  /**
+   * 下列 *AndGetHistoryId 方法与对应的普通操作（add / remove / update ...）行为完全一致，
+   * 返回值在 {@link DslOpWithHistoryIdsResult} 中同时包含原操作结果与本次写入历史栈的 uuid 列表（{@link StepValue.uuid}），
+   * 可用于精确引用 / 定位该条历史记录（埋点、revert、跨端同步等）。
+   *
+   * 当本次操作未写入历史（doNotPushHistory 为 true、或操作无实际变更 / 提前返回）时 historyIds 为 `[]`。
+   */
+  /** 等价于 {@link add}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  addAndGetHistoryId(addNode: AddMNode | MNode$1[], parent?: MContainer | null, options?: DslOpOptions): Promise<DslOpWithHistoryIdsResult<MNode$1 | MNode$1[]>>;
+  /** 等价于 {@link remove}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  removeAndGetHistoryId(nodeOrNodeList: MNode$1 | MNode$1[], options?: DslOpOptions): Promise<DslOpWithHistoryIdsResult<void>>;
+  /** 等价于 {@link update}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  updateAndGetHistoryId(config: MNode$1 | MNode$1[], data?: UpdateOptions): Promise<DslOpWithHistoryIdsResult<MNode$1 | MNode$1[]>>;
+  /** 等价于 {@link moveLayer}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  moveLayerAndGetHistoryId(offset: number | LayerOffset, options?: DslOpOptions): Promise<DslOpWithHistoryIdsResult<void>>;
+  /** 等价于 {@link moveToContainer}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  moveToContainerAndGetHistoryId(config: MNode$1 | MNode$1[], targetId: Id$1, options?: DslOpOptions): Promise<DslOpWithHistoryIdsResult<MNode$1 | MNode$1[]>>;
+  /** 等价于 {@link dragTo}，并额外返回本次写入历史记录的 uuid 列表（未入栈时 historyIds 为 `[]`）。 */
+  dragToAndGetHistoryId(config: MNode$1 | MNode$1[], targetParent: MContainer, targetIndex: number, options?: DslOpOptions): Promise<DslOpWithHistoryIdsResult<void>>;
+  /**
+   * 撤销当前操作
+   * @returns 被撤销的操作
+   */
+  undo(): Promise<StepValue | null>;
+  /**
+   * 恢复到下一步
+   * @returns 被恢复的操作
+   */
+  redo(): Promise<StepValue | null>;
+  /**
+   * 「回滚」指定页面历史步骤（类 git revert 语义）：
+   * - 不动原始历史栈结构（不移动 cursor、不丢弃任何步骤）；
+   * - 取出 `index` 对应的 step，**反向应用**一次（add→remove / remove→add / update→旧值）；
+   * - 把这次反向应用作为一条**新步骤**追加到栈顶，可被普通 undo / redo。
+   *
+   * 与 `gotoPageStep`（类 git reset）的区别在于此操作**不丢弃**目标之后的历史。
+   * 与 `applyHistoryOp(reverse=true)` 的区别在于：本方法**不带** `doNotPushHistory`，
+   * 反向应用会以一条新 step 入栈；并且不实施 step 中保存的选区与 modifiedNodeIds 状态，
+   * 选区由用户当前位置决定，符合"新提交"语义。
+   *
+   * 仅对处于「已应用」状态的步骤生效——未应用的步骤本身就不存在于当前 DSL 中，反向无意义。
+   *
+   * @param index 目标 step 在所属页面栈中的索引（0 为最早），通常由历史面板传入
+   * @returns 反向后产生的新 step；目标不存在 / 未应用 / 反向失败时返回 null
+   */
+  revertPageStep(index: number): Promise<StepValue | null>;
+  /**
+   * 通过历史记录 uuid 回滚当前页面的历史步骤，语义与 {@link revertPageStep} 完全一致，
+   * 仅入参从 index 改为 uuid 列表（{@link StepValue.uuid}）。按数组顺序依次回滚，
+   * 返回与入参同序的结果列表（某项失败时为 `null`）。
+   *
+   * @param uuids 目标历史记录的 uuid 列表，通常由 *AndGetHistoryId 方法返回的 `historyIds`
+   */
+  revertPageStepById(uuids: string[]): Promise<(StepValue | null)[]>;
+  /**
+   * 跳转当前页面历史栈到指定游标位置。
+   *
+   * `targetCursor` 与 `UndoRedo.getCursor()` 同义：表示"已应用步骤数量"，
+   * 取值范围 `[0, length]`。当目标 < 当前游标时循环 undo，否则循环 redo。
+   * 通常由历史面板传入「点击的 step.index + 1」作为目标。
+   *
+   * @returns 实际移动到的最终游标位置
+   */
+  gotoPageStep(targetCursor: number): Promise<number>;
+  move(left: number, top: number, { doNotPushHistory, historyDescription, historySource }?: DslOpOptions): Promise<void>;
+  resetState(): void;
+  destroy(): void;
+  resetModifiedNodeId(): void;
+  /**
+   * 记录（或覆盖）某个节点在指定来源（属性表单 / 样式表单）上的校验错误信息。
+   * @param id 节点 id
+   * @param source 错误来源：'props'（属性表单）| 'style'（样式表单）
+   * @param message 错误文案（可能是包含 <br> 的 HTML）
+   */
+  setInvalidNode(id: Id$1, source: NodeInvalidSource, message: string): void;
+  /**
+   * 删除节点的校验错误记录。
+   * @param id 节点 id
+   * @param source 指定来源则仅删除该来源；不传则删除该节点全部来源的错误
+   */
+  deleteInvalidNode(id: Id$1, source?: NodeInvalidSource): void;
+  /** 获取当前存在校验错误的节点错误 Map（key 为节点 id） */
+  getInvalidNodeIds(): Map<Id$1, NodeInvalidInfo>;
+  /** 获取指定节点的校验错误信息 */
+  getInvalidNodeInfo(id: Id$1): NodeInvalidInfo | undefined;
+  /** 清空全部校验错误记录 */
+  resetInvalidNodeId(): void;
+  usePlugin(options: AsyncHookPlugin<AsyncMethodName, Editor>): void;
+  on<Name extends keyof EditorEvents, Param extends EditorEvents[Name]>(eventName: Name, listener: (...args: Param) => void | Promise<void>): this;
+  once<Name extends keyof EditorEvents, Param extends EditorEvents[Name]>(eventName: Name, listener: (...args: Param) => void | Promise<void>): this;
+  emit<Name extends keyof EditorEvents, Param extends EditorEvents[Name]>(eventName: Name, ...args: Param): boolean;
+  /**
+   * 应用一次属性面板提交携带的校验错误信息（在写入历史记录之前调用，使历史快照与本次变更对齐）。
+   * - invalidInfo 为空（调用方未携带）：认为本次更新对应的节点已无校验错误，清除其全部来源的错误；
+   * - error 非空则记录错误，为空则清除对应来源的错误。
+   */
+  private applyInvalidInfo;
+  /** 删除被移除节点（含其子树）的校验错误记录，避免残留误报 */
+  private removeInvalidNodesBySubtree;
+  /** 清理不在当前 DSL 中的失效节点错误记录（用于整体替换 root 后） */
+  private pruneInvalidNodeIds;
+  private addModifiedNodeId;
+  /**
+   * 获取指定节点所属的页面 / 页面片：
+   * - 普通节点返回其所在的 page；
+   * - 节点本身就是 page / pageFragment 时返回它自己；
+   * - 找不到时返回 null。
+   * 供 `change` 事件携带「变更节点对应的 page」（而非编辑器当前选中页）。
+   */
+  private getPageOfNode;
+  private captureSelectionBeforeOp;
+  /**
+   * 比较「上一次 root」与「新 root」的页面 / 页面片，按页面粒度把整体替换拆成历史记录：
+   * - 新旧都存在且内容变化的页面 → 一条 `update`（整页快照替换，无 changeRecords）；
+   * - 仅新 root 存在的页面 → 一条 `add`；
+   * - 仅旧 root 存在的页面 → 一条 `remove`。
+   *
+   * 每条记录落到对应页面自己的历史栈（与普通节点操作一致），并标记来源 `source`。
+   * 内容未变化的页面不产生记录，避免重复设置相同 DSL 时产生噪声。
+   */
+  private pushRootDiffHistory;
+  /**
+   * 构造一条页面级「set root」历史记录（不携带选区 / modifiedNodeIds 上下文）并落到该页面自己的栈。
+   *
+   * 连续 set root 替换：若该页栈最新一条已是**同来源**的 set root 记录（{@link StepValue.rootStep} 且 `source` 相同），
+   * 则用本次记录**替换**它而非新增，避免源码反复保存 / 外部重设 DSL 时堆积多条 root 记录；
+   * 来源不同则照常新增（initial 基线不是 rootStep，不在此列）。
+   */
+  private pushPageDiffStep;
+  private pushOpHistory;
+  /**
+   * 应用历史操作（撤销 / 重做）
+   *
+   * 删除 / 更新类修改走 `editor.remove / update`，并通过 `doNotPushHistory` 阻止再次入栈、
+   * `doNotSelect / doNotSwitchPage` 让选区由方法末尾的统一逻辑兜底；
+   * 「重新插回节点」（撤销 remove / 重做 add）需按 step 记录的 parentId / index 精确还原，
+   * 不走 this.add，由手工 splice + stage.add 完成后补发等价的 add / change 事件（见 emitHistoryInsertEvents）。
+   *
+   * 注意：这些路径都会发出 add / remove / update / change 事件，业务侧若需要区分"用户操作"与"撤销重做触发"，
+   * 请监听 `history-change` 事件配合判断。
+   *
+   * @param step 操作记录
+   * @param reverse true = 撤销，false = 重做
+   */
+  private applyHistoryOp;
+  private selectedConfigExceptionHandler;
+  /**
+   * 撤销 remove / 重做 add 通过手工 splice 按 step 记录的 parentId / index 精确还原节点（不走 this.add，原因见调用处注释），
+   * 这里补齐与 this.add 等价的 add / change 事件，保证撤销/重做路径的事件行为与正向操作一致。
+   */
+  private emitHistoryInsertEvents;
+}
+type EditorService = Editor;
+//#endregion
+//#region temp/packages/editor/src/services/events.d.ts
+declare const canUsePluginMethods$6: {
+  async: readonly [];
+  sync: readonly ["setEvent", "getEvent", "setMethod", "getMethod"];
+};
+type AsyncMethodName$3 = Writable<(typeof canUsePluginMethods$6)['async']>;
+type SyncMethodName$4 = Writable<(typeof canUsePluginMethods$6)['sync']>;
+declare class Events extends BaseService {
+  constructor();
+  setEvents(events: Record<string, EventOption[]>): void;
+  setEvent(type: string, events: EventOption[]): void;
+  getEvent(type: string, _data?: {
+    node?: MNode$1 | null;
+  }): EventOption[];
+  setMethods(methods: Record<string, EventOption[]>): void;
+  setMethod(type: string, method: EventOption[]): void;
+  getMethod(type: string, _data?: {
+    node?: MNode$1 | null;
+    targetId?: Id$1;
+  }): EventOption[];
+  resetState(): void;
+  destroy(): void;
+  usePlugin(options: AsyncHookPlugin<AsyncMethodName$3, Events> & SyncHookPlugin<SyncMethodName$4, Events>): void;
+}
+type EventsService = Events;
+//#endregion
+//#region temp/packages/editor/src/utils/undo-redo.d.ts
+/**
+ * UndoRedo 栈的可序列化快照，用于持久化（如写入 IndexedDB）后再还原。
+ */
+interface SerializedUndoRedo<T = any> {
+  /** 栈内全部元素（按时间正序，索引 0 为最早一步）。 */
+  elementList: T[];
+  /** 游标位置（已应用步骤数量）。 */
+  listCursor: number;
+  /** 栈容量上限。 */
+  listMaxSize: number;
+}
+declare class UndoRedo<T = any> {
+  /**
+   * 由 {@link UndoRedo.serialize} 产出的快照重建一个 UndoRedo 实例。
+   * 游标会被夹紧到 [0, length] 区间，避免脏数据导致越界。
+   *
+   * @param options.isSavedStep 可选谓词：若提供，则把游标定位到「最近一条满足该谓词的记录」之后
+   *   （即恢复到最近一个已保存点）；找不到匹配记录时退回快照中的原游标。
+   */
+  static fromSerialized<T = any>(data: SerializedUndoRedo<T>, options?: {
+    isSavedStep?: (element: T) => boolean;
+  }): UndoRedo<T>;
+  private elementList;
+  private listCursor;
+  private listMaxSize;
+  constructor(listMaxSize?: number);
+  /**
+   * 导出当前栈的可序列化快照（深克隆，避免外部改动污染内部状态）。
+   * 配合 {@link UndoRedo.fromSerialized} 可在持久化后完整还原撤销/重做栈。
+   */
+  serialize(): SerializedUndoRedo<T>;
+  pushElement(element: T): void;
+  canUndo(): boolean;
+  /** 返回被撤销的操作 */
+  undo(): T | null;
+  canRedo(): boolean;
+  /** 返回被重做的操作 */
+  redo(): T | null;
+  getCurrentElement(): T | null;
+  /**
+   * 用 `element` 替换当前游标所在元素（cursor - 1），并丢弃其后的重做尾部（与 {@link pushElement} 的丢尾一致），
+   * 游标位置保持不变（元素数量不增）。cursor 为 0（无已应用元素）时不做任何操作并返回 false。
+   * 用于「连续同类记录合并」等就地替换最新一条的场景。
+   */
+  replaceCurrentElement(element: T): boolean;
+  /**
+   * 对当前游标所在元素（cursor - 1）做就地更新；cursor 为 0（全部已撤销）时不做任何操作。
+   * 用于给「当前步骤」打标记（如标记为已保存）等元数据写入场景。
+   */
+  updateCurrentElement(updater: (element: T) => void): void;
+  /** 对栈内全部元素做就地更新。用于批量清理元数据（如清空所有元素的已保存标记）。 */
+  updateElements(updater: (element: T, index: number) => void): void;
+  /**
+   * 返回栈内全部元素的浅克隆数组（按时间顺序，索引 0 为最早一步）。
+   * 仅用于历史面板等只读展示场景，不应直接修改返回值。
+   */
+  getElementList(): T[];
+  /**
+   * 当前游标位置：表示已应用的步骤数量。
+   * - cursor === 0 表示全部已撤销
+   * - cursor === length 表示已重做到末尾
+   * 历史面板用于区分"已应用 / 已撤销"两段。
+   */
+  getCursor(): number;
+  /** 栈内总步数。 */
+  getLength(): number;
+}
+//#endregion
+//#region temp/packages/editor/src/services/history.d.ts
+declare const canUsePluginMethods$5: {
+  sync: readonly ["push", "undo", "redo"];
+};
+type SyncMethodName$3 = Writable<(typeof canUsePluginMethods$5)['sync']>;
+declare class History extends BaseService {
+  state: {
+    steps: {
+      [x: string]: Record<Id$1, UndoRedo<any>>;
+      page: Record<Id$1, UndoRedo<StepValue>>;
+      codeBlock: Record<Id$1, UndoRedo<CodeBlockStepValue>>;
+      dataSource: Record<Id$1, UndoRedo<DataSourceStepValue>>;
+    };
+    stepNames: Record<string, string>;
+  };
+  constructor();
+  /**
+   * 注册一个扩展历史类型，使其可与内置 `page` / `codeBlock` / `dataSource` 一样走统一的
+   * {@link push} / {@link undo} / {@link redo}（按 id 分栈、独立 undo/redo）。
+   *
+   * @param stepType 自定义历史类型标识（勿与内置类型重名）
+   * @param options.event push/undo/redo 后派发的事件名，缺省为 `${stepType}-history-change`
+   * @param options.name 历史面板中的展示名称（tab / 分组标题等），缺省回退到 stepType 本身
+   */
+  registerStepType(stepType: string, options?: {
+    event?: string;
+    name?: string;
+  }): void;
+  /**
+   * 读取指定历史类型的展示名称（用于历史面板 tab / 分组标题等）。
+   * 未登记名称时回退到 stepType 本身。
+   */
+  getStepName(stepType: HistoryStepType): string;
+  /**
+   * 设置指定历史类型的展示名称（用于历史面板 tab / 分组标题等）。
+   * 内置 `page` / `codeBlock` / `dataSource` 也可在此覆盖默认中文名。
+   */
+  setStepName(stepType: HistoryStepType, name: string): void;
+  reset(): void;
+  resetState(): void;
+  /**
+   * 为指定历史栈（默认 `page`，也适用于 codeBlock / dataSource / 扩展类型）种入一条「初始基线」记录。
+   *
+   * 该记录是一条 `opType: 'initial'` 的 step，作为对应栈 **index 0 的固定底线**：
+   * - 它是一条真实入栈的 step（随栈一起持久化），但被钉为撤销/回滚的下限——cursor 永不低于它，
+   *   因此不会被 undo / goto / revert 触达（详见 {@link undo} / {@link undoFloor}）；
+   * - 历史面板把它过滤出分组列表（见 {@link getHistoryGroups}），改由底部「初始」行展示。
+   *
+   * 仅当目标栈为空时种入（保证 initial 一定位于 index 0）；已存在 initial 底线时不重复种入。
+   *
+   * @param stepType 历史类型
+   * @param id       目标栈 id（page 为 pageId，其余类型为对应资源 id）
+   * @param options  基线展示信息（名称 / 描述 / 来源）
+   */
+  setMarker(stepType: HistoryStepType, id: Id$1, options?: {
+    name?: string;
+    description?: string;
+    source?: HistoryOpSource;
+    extra?: Record<string, any>;
+  }): StepValue | null;
+  /**
+   * 读取指定历史栈的初始基线 step（栈 index 0 且 `opType: 'initial'`）；
+   * 不存在或 id 缺省时返回 undefined。
+   */
+  getMarker(stepType: HistoryStepType, id?: Id$1): StepValue | undefined;
+  /**
+   * 把一条步骤推入指定历史栈。统一入口，所有类型（page / codeBlock / dataSource / 扩展）行为完全一致：
+   * 按 `stepType` 选择目标栈类型，按 `id`（必填）选择具体栈，按需建栈后入栈，并派发对应的历史变更事件
+   * （`page` 为 `change`，其余见 {@link registerStepType}），回调签名统一为 `(id, step)`。
+   *
+   * 跨页 / 跨资源操作（如 `moveToContainer` 把节点搬到其它页）必须显式传入目标 id，
+   * 否则无法落到正确的栈。step 可由 `createStackStep` 等构造后传入。
+   *
+   * @param stepType 历史类型
+   * @param step     已构造好的历史记录（缺省自动补全 uuid / timestamp）
+   * @param id       目标栈 id（page 为 pageId，其余类型为对应资源 id），必填
+   */
+  push(stepType: 'page', step: StepValue, id: Id$1): StepValue | null;
+  push(stepType: 'codeBlock', step: CodeBlockStepValue, id: Id$1): CodeBlockStepValue | null;
+  push(stepType: 'dataSource', step: DataSourceStepValue, id: Id$1): DataSourceStepValue | null;
+  push<T extends BaseStepValue>(stepType: string, step: T, id: Id$1): T | null;
+  /**
+   * 撤销指定历史栈的最近一次变更。统一入口，所有类型行为一致：
+   * 按 `id`（必填）+ `stepType` 定位栈，不会越过 index 0 的 initial 基线（所有类型同等适用），
+   * 仅在确有可撤销 step 时派发对应的历史变更事件（`page` 为 `change`，回调签名 `(id, step)`）。
+   *
+   * @param stepType 历史类型
+   * @param id       目标栈 id（page 为 pageId，其余类型为对应资源 id），必填
+   */
+  undo(stepType: 'page', id: Id$1): StepValue | null;
+  undo(stepType: 'codeBlock', id: Id$1): CodeBlockStepValue | null;
+  undo(stepType: 'dataSource', id: Id$1): DataSourceStepValue | null;
+  undo<T extends BaseStepValue>(stepType: string, id: Id$1): T | null;
+  /**
+   * 重做指定历史栈的下一次变更。语义与 {@link undo} 对称，详见其说明。
+   *
+   * @param stepType 历史类型
+   * @param id       目标栈 id（page 为 pageId，其余类型为对应资源 id），必填
+   */
+  redo(stepType: 'page', id: Id$1): StepValue | null;
+  redo(stepType: 'codeBlock', id: Id$1): CodeBlockStepValue | null;
+  redo(stepType: 'dataSource', id: Id$1): DataSourceStepValue | null;
+  redo<T extends BaseStepValue>(stepType: string, id: Id$1): T | null;
+  /**
+   * 是否可对指定历史栈撤销（cursor 高于 initial 基线底线）。
+   * @param stepType 历史类型
+   * @param id       目标栈 id；缺省 / 无效时返回 false
+   */
+  canUndo(stepType: HistoryStepType, id?: Id$1): boolean;
+  /**
+   * 是否可对指定历史栈重做。
+   * @param stepType 历史类型
+   * @param id       目标栈 id；缺省 / 无效时返回 false
+   */
+  canRedo(stepType: HistoryStepType, id?: Id$1): boolean;
+  /** 读取指定页面历史栈当前游标所在的 step（cursor - 1）；无则返回 null。 */
+  getCurrentPageStep(pageId: Id$1): StepValue | null;
+  /**
+   * 用 `state` 替换指定页面栈当前游标所在的 step（并丢弃其后的重做尾部），游标不变。
+   * 用于「连续 set root 记录合并」等就地替换最新一条的场景；替换成功后派发 `change`。
+   */
+  replaceCurrentStep(stepType: HistoryStepType, state: StepValue, id: Id$1): StepValue | null;
+  destroy(): void;
+  /**
+   * 清空历史记录栈。统一入口，所有类型（page / codeBlock / dataSource / 扩展）行为一致：
+   * - 传入 `id`：仅清空 `stepType` 下该 id 对应的栈；
+   * - 缺省 `id`：清空 `stepType` 下的全部栈。
+   *
+   * 仅删除撤销/重做记录，不会改动 DSL / 代码块 / 数据源本身。清空时会**保留各栈原有的
+   * initial 基线**（文案 / 来源），无基线时清空成空栈。清空后派发 `clear`（签名 `(id, stepType)`）。
+   *
+   * @param stepType 历史类型
+   * @param id       目标栈 id；缺省表示清空该类型下全部栈
+   */
+  clear(stepType: HistoryStepType, id?: Id$1): void;
+  /**
+   * 标记历史记录为「已保存」（把对应栈当前游标所在的记录标为 `saved`）。统一入口：
+   * - 缺省 `id`：标记**全部类型、全部栈**（整份 DSL 落库场景），派发 `mark-saved` 且 `kind: 'all'`；
+   * - 传入 `id`：仅标记 `stepType` 下该 id 对应的栈，派发 `mark-saved` 且 `kind` 为 `stepType`。
+   *
+   * 同一栈内任意时刻最多只有一条记录为 `saved`；从 IndexedDB 恢复时游标会被定位到最近一条已保存记录之后。
+   *
+   * @param stepType 历史类型
+   * @param id       目标栈 id；缺省表示标记全部类型 / 全部栈
+   */
+  markSaved(stepType: HistoryStepType, id?: Id$1): void;
+  /**
+   * 派发「页面 / 页面片结构变更」事件（`page-structure-change`）。
+   *
+   * 常规 `editorService.add` / `remove` 页面节点不会写入 `page` 历史栈（见 editor.add / remove 中
+   * 对 isPageOrFragment 的分支），因此不会产生任何 historyService 事件。该方法用于在这些
+   * 场景（以及 setRoot 整体替换 DSL 增删页面）下，向外统一通知页面结构的增删变化，供业务方感知。
+   *
+   * 一次操作涉及多个页面时，调用方应把本次增删的页面**合并为一个 change 一次性传入**，
+   * 使一次操作只派发一个事件；`add` / `remove` 分别为本次新增与删除的页面列表（其一可为空数组）。
+   *
+   * @param change 本次结构变更：{ add: 新增的页面列表, remove: 删除的页面列表 }
+   */
+  notifyPageStructureChange(change: {
+    add: (MPage | MPageFragment)[];
+    remove: (MPage | MPageFragment)[];
+  }): void;
+  /**
+   * 把当前内存中的全部历史栈（页面 / 代码块 / 数据源 / 扩展类型）序列化后写入本地 IndexedDB。
+   *
+   * - 每个 UndoRedo 栈连同其游标、容量一并保存，恢复后可继续 undo/redo；
+   * - `key` 用于区分不同活动页 / 项目（同一 store 下可保存多份快照），缺省为 `default`；
+   * - 返回写入成功的快照对象，便于调用方记录 savedAt 等信息；
+   * - 不支持 IndexedDB 的环境（如 SSR）会 reject。
+   */
+  saveToIndexedDB(options?: HistoryPersistOptions): Promise<PersistedHistoryState>;
+  /**
+   * 从本地 IndexedDB 读取此前保存的历史快照并重建全部撤销/重做栈。
+   *
+   * - 读取到的每个栈都会经 {@link UndoRedo.fromSerialized} 还原（含游标），随后可直接 undo/redo；
+   * - 会整体覆盖当前内存中的历史状态（活动页由 editorService 维护，不在此恢复）；
+   * - 找不到对应记录时返回 null，且不改动当前状态；
+   * - 不支持 IndexedDB 的环境（如 SSR）会 reject。
+   */
+  restoreFromIndexedDB(options?: HistoryPersistOptions): Promise<PersistedHistoryState | null>;
+  /**
+   * 取出指定历史类型（页面 / 代码块 / 数据源 / 扩展类型）某个栈的平铺步骤列表（含 applied 标记）。
+   * 统一入口，替代旧的 `getPageStepList` / `getCodeBlockStepList` / `getDataSourceStepList`。
+   *
+   * 列表按时间正序，最早一步在最前面；`applied` 表示该步骤处于栈游标之前（已应用）。
+   * 供 revert / goto 等按 index 索引步骤的场景使用。通常 UI 应使用
+   * {@link getHistoryGroups} 取已合并分组的版本；本方法仅为兼容/调试保留。
+   *
+   * @param stepType 历史类型
+   * @param id       目标栈 id（page 为 pageId，其余类型为对应资源 id）；缺省 / 无效时返回空数组
+   */
+  getStepList(stepType: 'page', id?: Id$1): HistoryStepEntry<StepValue>[];
+  getStepList(stepType: 'codeBlock', id: Id$1): HistoryStepEntry<CodeBlockStepValue>[];
+  getStepList(stepType: 'dataSource', id: Id$1): HistoryStepEntry<DataSourceStepValue>[];
+  getStepList<T extends BaseStepValue>(stepType: HistoryStepType, id?: Id$1): HistoryStepEntry<T>[];
+  /**
+   * 取出指定历史类型的历史分组（页面 / 代码块 / 数据源 / 扩展类型统一入口）。
+   *
+   * 把目标栈的步骤列表按"目标"做相邻合并（连续修改同一目标的 update 合并为一组，组内可展开查看每步；
+   * add / remove / 多实体 update 始终独立成组），并过滤掉 index 0 的 initial 基线（底部「初始」行由
+   * {@link getMarker} 驱动）。各类型行为完全一致，仅 `kind` 与 step 快照类型不同。
+   *
+   * 作用域：
+   * - 传入 `id`：仅取该 id 对应的单个栈（页面历史按活动页查看，传入 pageId）；
+   * - 缺省 `id`：遍历该类型下全部栈并汇总（代码块 / 数据源按全部资源分桶展示）。
+   *
+   * @param stepType 历史类型，缺省 `page`
+   * @param id       目标栈 id；缺省表示遍历该类型下全部栈
+   */
+  getHistoryGroups(stepType: 'page', id?: Id$1): HistoryGroup<StepValue>[];
+  getHistoryGroups(stepType: 'codeBlock', id?: Id$1): HistoryGroup<CodeBlockStepValue>[];
+  getHistoryGroups(stepType: 'dataSource', id?: Id$1): HistoryGroup<DataSourceStepValue>[];
+  getHistoryGroups<T extends BaseStepValue>(stepType: HistoryStepType, id?: Id$1): HistoryGroup<T>[];
+  /**
+   * 读取指定历史栈的当前游标（已应用步骤数量）。统一入口，替代旧的
+   * `getPageCursor` / `getCodeBlockCursor` / `getDataSourceCursor`。
+   * - `id` 缺省或非法、或对应栈不存在时返回 0；
+   * - `stepType` 支持 `page` / `codeBlock` / `dataSource` / 扩展类型。
+   */
+  getCursor(stepType: HistoryStepType, id?: Id$1): number;
+  /**
+   * 按历史记录 uuid 在指定历史类型的栈中查找其所属 id 与索引，统一入口，替代旧的
+   * `getPageStepIndexByUuid` / `findCodeBlockStepLocationByUuid` / `findDataSourceStepLocationByUuid`。
+   *
+   * - 传入 `id`：仅在该 id 对应的单个栈中查找（如页面历史按活动页查看，传入 pageId）；
+   * - 缺省 `id`：遍历该类型下全部栈查找（代码块 / 数据源等按全部资源分桶的场景）。
+   *
+   * 找不到时返回 null。供「按 uuid 回滚」等需要把 uuid 映射回 (id, index) 的场景使用。
+   *
+   * @param stepType 历史类型
+   * @param uuid     目标历史记录的 uuid
+   * @param id       目标栈 id；缺省表示遍历该类型下全部栈
+   */
+  findStepLocationByUuid(stepType: HistoryStepType, uuid: string, id?: Id$1): {
+    id: Id$1;
+    index: number;
+  } | null;
+  usePlugin(options: SyncHookPlugin<SyncMethodName$3, History>): void;
+  emit<Name extends keyof HistoryEvents, Param extends HistoryEvents[Name]>(eventName: Name, ...args: Param): boolean;
+  /**
+   * 取出指定历史类型的栈桶（`Record<id, UndoRedo>`）；不存在时按需创建空桶，
+   * 从而支持通过 {@link registerStepType} 或首次 push 动态扩展历史类型。
+   */
+  private getStepBucket;
+  /**
+   * 清空单个历史栈并按需重建其 initial 基线（保留原基线的文案 / 来源）。
+   */
+  private clearStack;
+  /** 入栈前补全 step 的 uuid / timestamp（调用方未指定时）。 */
+  private fillStepMeta;
+  /** 校验「按 id 分栈」类型（codeBlock / dataSource / 扩展）的 id 是否有效。 */
+  private isValidStackId;
+  /** 清空全部历史栈内容（保留已注册的类型键，使扩展类型在 reset 后仍可用）。 */
+  private clearAllSteps;
+  /**
+   * 把基础 dbName 与当前 DSL（root app）的 id 拼成最终库名，实现不同应用历史隔离。
+   * 取不到 app id（如尚未加载 DSL）时退回基础 dbName。
+   */
+  private resolveDbName;
+}
+type HistoryService = History;
+//#endregion
+//#region temp/packages/editor/src/services/keybinding.d.ts
+declare class Keybinding extends BaseService {
+  ctrlKey: string;
+  private controllers;
+  private bindingList;
+  private commands;
+  registerCommand(command: string, handler: (e: KeyboardEvent) => void | Promise<void>): void;
+  /**
+   * @deprecated
+   */
+  registeCommand(command: string, handler: (e: KeyboardEvent) => void | Promise<void>): void;
+  unregisterCommand(command: string): void;
+  /**
+   * @deprecated
+   */
+  unregisteCommand(command: string): void;
+  registerEl(name: string, el?: HTMLElement): void;
+  /**
+   * @deprecated
+   */
+  registeEl(name: string, el?: HTMLElement): void;
+  unregisterEl(name: string): void;
+  /**
+   * @deprecated
+   */
+  unregisteEl(name: string): void;
+  register(maps: KeyBindingItem[]): void;
+  /**
+   * @deprecated
+   */
+  registe(map: KeyBindingItem[]): void;
+  reset(): void;
+  destroy(): void;
+  private bind;
+  private getKeyconKeys;
+}
+type KeybindingService = Keybinding;
+//#endregion
+//#region temp/packages/editor/src/services/props.d.ts
+declare const canUsePluginMethods$4: {
+  async: readonly ["setPropsConfig", "getPropsConfig", "setPropsValue", "getPropsValue", "fillConfig", "getDefaultPropsValue"];
+  sync: readonly ["createId", "setNewItemId"];
+};
+type AsyncMethodName$2 = Writable<(typeof canUsePluginMethods$4)['async']>;
+type SyncMethodName$2 = Writable<(typeof canUsePluginMethods$4)['sync']>;
+declare class Props extends BaseService {
+  private state;
+  constructor();
+  setDisabledDataSource(disabled: boolean): void;
+  setDisabledCodeBlock(disabled: boolean): void;
+  getDisabledDataSource(): boolean;
+  getDisabledCodeBlock(): boolean;
+  setPropsConfigs(configs: Record<string, FormConfig | PropsFormConfigFunction>): void;
+  getPropsConfigs(): Record<string, FormConfig>;
+  fillConfig(config: FormConfig, labelWidth?: string): Promise<FormConfig>;
+  setPropsConfig(type: string, config: FormConfig | PropsFormConfigFunction): Promise<void>;
+  /**
+   * 获取指点类型的组件属性表单配置
+   * @param type 组件类型
+   * @returns 组件属性表单配置
+   */
+  getPropsConfig(type: string, data?: {
+    node?: MNode$1 | null;
+  }): Promise<FormConfig>;
+  hasPropsConfig(type: string): boolean;
+  setPropsValues(values: Record<string, Partial<MNode$1> | PropsFormValueFunction>): void;
+  getPropsValues(): Record<string, Partial<MNode$1>>;
+  /**
+   * 为指点类型组件设置组件初始值
+   * @param type 组件类型
+   * @param value 组件初始值
+   */
+  setPropsValue(type: string, value: Partial<MNode$1> | PropsFormValueFunction): Promise<void>;
+  /**
+   * 获取指定类型的组件初始值
+   * @param type 组件类型
+   * @returns 组件初始值
+   */
+  getPropsValue(componentType: string, { inputEvent, ...defaultValue }?: Record<string, any>): Promise<any>;
+  hasPropsValue(type: string): boolean;
+  createId(type: string | number): string;
+  /**
+   * 将组件与组件的子元素配置中的id都设置成一个新的ID
+   * 如果没有相同ID并且force为false则保持不变
+   * @param {Object} config 组件配置
+   * @param {Boolean} force 是否强制设置新的ID
+   */
+  setNewItemId(config: MNode$1, force?: boolean): MNode$1;
+  /**
+   * 获取默认属性配置
+   * @param type 组件类型
+   * @returns Object
+   */
+  getDefaultPropsValue(type: string): {
+    type: string;
+    layout: string;
+    style: {};
+    name: string;
+    items: never[];
+  } | {
+    type: string;
+    style: {};
+    name: string;
+    layout?: undefined;
+    items?: undefined;
+  };
+  resetState(): void;
+  /**
+   * 替换关联ID
+   * @param originConfigs 原组件配置
+   * @param targetConfigs 待替换的组件配置
+   */
+  replaceRelateId(originConfigs: MNode$1[], targetConfigs: MNode$1[], collectorOptions: TargetOptions): void;
+  /**
+   * 清除setNewItemId前后映射关系
+   */
+  clearRelateId(): void;
+  destroy(): void;
+  usePlugin(options: AsyncHookPlugin<AsyncMethodName$2, Props> & SyncHookPlugin<SyncMethodName$2, Props>): void;
+  /**
+   * 获取setNewItemId前后映射关系
+   * @param oldId 原组件ID
+   * @returns 新旧ID映射
+   */
+  private getRelateIdMap;
+  /**
+   * 记录setNewItemId前后映射关系
+   * @param oldId 原组件ID
+   * @param newId 分配的新ID
+   */
+  private setRelateId;
+}
+type PropsService = Props;
+//#endregion
+//#region temp/packages/editor/src/services/stageOverlay.d.ts
+declare const canUsePluginMethods$3: {
+  async: never[];
+  sync: readonly ["openOverlay", "closeOverlay", "updateOverlay", "createStage"];
+};
+type SyncMethodName$1 = Writable<(typeof canUsePluginMethods$3)['sync']>;
+declare class StageOverlay extends BaseService {
+  private state;
+  constructor();
+  get<K extends keyof StageOverlayState>(name: K): StageOverlayState[K];
+  set<K extends keyof StageOverlayState, T extends StageOverlayState[K]>(name: K, value: T): void;
+  openOverlay(el: HTMLElement | null): void;
+  closeOverlay(): void;
+  updateOverlay(): void;
+  createStage(stageOptions?: StageOptions): StageCore;
+  usePlugin(options: SyncHookPlugin<SyncMethodName$1, StageOverlay>): void;
+  private createContentEl;
+  private copyDocumentElement;
+  private render;
+  private updateHandler;
+  private addHandler;
+  private removeHandler;
+  private updateSelectStatus;
+}
+type StageOverlayService = StageOverlay;
+//#endregion
+//#region temp/packages/editor/src/services/storage.d.ts
+interface Options {
+  namespace?: string;
+  protocol?: Protocol;
+}
+declare enum Protocol {
+  OBJECT = "object",
+  JSON = "json",
+  STRING = "string",
+  NUMBER = "number",
+  BOOLEAN = "boolean"
+}
+declare const canUsePluginMethods$2: {
+  async: never[];
+  sync: readonly ["getStorage", "getNamespace", "clear", "getItem", "removeItem", "setItem"];
+};
+type SyncMethodName = Writable<(typeof canUsePluginMethods$2)['sync']>;
+/**
+ * 数据存储服务
+ */
+declare class WebStorage extends BaseService {
+  private storage;
+  private namespace;
+  constructor();
+  /**
+   * 获取数据存储对象，可以通过
+   * const storageService = new StorageService();
+   * storageService.usePlugin({
+   *    // 替换存储对象为 sessionStorage
+   *    async afterGetStorage(): Promise<Storage> {
+   *      return window.sessionStorage;
+   *    },
+   * });
+   */
+  getStorage(): Storage;
+  getNamespace(): string;
+  /**
+   * 清理，支持storageService.usePlugin
+   */
+  clear(): void;
+  /**
+   * 获取存储项，支持storageService.usePlugin
+   */
+  getItem(key: string, options?: Options): any;
+  /**
+   * 获取指定索引位置的key
+   */
+  key(index: number): string | null;
+  /**
+   * 移除存储项，支持storageService.usePlugin
+   */
+  removeItem(key: string, options?: Options): void;
+  /**
+   * 设置存储项，支持storageService.usePlugin
+   */
+  setItem(key: string, value: any, options?: Options): void;
+  destroy(): void;
+  usePlugin(options: SyncHookPlugin<SyncMethodName, WebStorage>): void;
+  private getValueAndProtocol;
+}
+type StorageService = WebStorage;
+//#endregion
+//#region temp/packages/editor/src/services/ui.d.ts
+declare const canUsePluginMethods$1: {
+  async: readonly ["zoom", "calcZoom"];
+  sync: readonly [];
+};
+type AsyncMethodName$1 = Writable<(typeof canUsePluginMethods$1)['async']>;
+declare class Ui extends BaseService {
+  constructor();
+  set<K extends keyof UiState, T extends UiState[K]>(name: K, value: T): void;
+  get<K extends keyof UiState>(name: K): import("@vue/reactivity").ShallowReactive<UiState>[K];
+  zoom(zoom: number): Promise<void>;
+  calcZoom(): Promise<number>;
+  resetState(): void;
+  destroy(): void;
+  usePlugin(options: AsyncHookPlugin<AsyncMethodName$1, Ui>): void;
+  private setStageRect;
+}
+type UiService = Ui;
+//#endregion
 //#region temp/packages/editor/src/type.d.ts
+interface Services {
+  editorService: EditorService;
+  historyService: HistoryService;
+  storageService: StorageService;
+  eventsService: EventsService;
+  propsService: PropsService;
+  componentListService: ComponentListService;
+  uiService: UiService;
+  codeBlockService: CodeBlockService;
+  depService: DepService;
+  dataSourceService: DataSourceService;
+  keybindingService: KeybindingService;
+  stageOverlayService: StageOverlayService;
+}
+declare module '@tmagic/form-schema' {
+  interface FormContext {
+    /** 编辑器服务集合（由 Editor / FormPanel provide） */
+    services?: Services;
+    /** 当前画布 Stage 实例（由 Editor / FormPanel provide） */
+    stage?: any;
+  }
+}
+interface StageOptions {
+  runtimeUrl?: string;
+  autoScrollIntoView?: boolean;
+  containerHighlightClassName?: string;
+  containerHighlightDuration?: number;
+  containerHighlightType?: ContainerHighlightType;
+  /**
+   * 是否仅在新增组件（从组件列表拖入新组件）时才启用识别容器，
+   * 开启后在画布中拖动已有组件不会识别容器，默认 false
+   */
+  containerHighlightAddOnly?: boolean;
+  disabledDragStart?: boolean;
+  render?: (stage: StageCore) => HTMLDivElement | void | Promise<HTMLDivElement | void>;
+  moveableOptions?: CustomizeMoveableOptions;
+  canSelect?: (el: HTMLElement) => boolean | Promise<boolean>;
+  isContainer?: (el: HTMLElement) => boolean | Promise<boolean>;
+  /**
+   * 画布上拖入组件（包括从组件列表拖入新组件、画布上拖动已有组件）时，
+   * 对已通过 isContainer 命中的候选容器进行二次过滤；返回 false 时阻止该容器被高亮命中
+   * - 在画布上拖动已有组件时：sourceIds 为被拖动组件的 id 列表
+   * - 从组件列表拖入新组件时：sourceIds 为空数组（尚无 id，仅可依据 targetId 判断）
+   * 该选项会被透传给 StageCore 的 canDropIn
+   */
+  canDropIn?: CanDropIn;
+  updateDragEl?: UpdateDragEl;
+  renderType?: RenderType;
+  guidesOptions?: Partial<GuidesOptions>;
+  disabledMultiSelect?: boolean;
+  /**
+   * 始终启用多选模式（无需按住 Ctrl/Meta），默认 false。
+   * 当 `disabledMultiSelect` 为 true 时本配置失效。
+   */
+  alwaysMultiSelect?: boolean;
+  disabledRule?: boolean;
+  /**
+   * 禁用「非点击画布选中组件时（如从图层树、面包屑等外部选中），对选中区域做高亮闪烁提示」，
+   * 默认 false（即默认开启闪烁）
+   */
+  disabledFlashTip?: boolean;
+  zoom?: number;
+  /** 画布双击前的钩子函数，返回 false 则阻止默认的双击行为 */
+  beforeDblclick?: (event: MouseEvent) => Promise<boolean | void> | boolean | void;
+}
+/**
+ * 节点校验错误信息，按来源（属性表单 / 样式表单）分别保存错误文案。
+ * 属性表单与样式表单是两个独立的 FormPanel，均指向同一节点，故以来源为键，
+ * 避免某个面板校验通过时误清另一个面板记录的错误。
+ * 节点视为存在错误当且仅当任一来源存在非空文本。
+ */
+interface NodeInvalidInfo {
+  /** 属性表单校验错误文案（可能为包含 <br> 的 HTML） */
+  props?: string;
+  /** 样式表单校验错误文案（可能为包含 <br> 的 HTML） */
+  style?: string;
+}
+/** 节点校验错误来源 */
+type NodeInvalidSource = keyof NodeInvalidInfo;
+interface StoreState {
+  root: MApp | null;
+  page: MPage | MPageFragment | null;
+  parent: MContainer | null;
+  node: MNode$1 | null;
+  highlightNode: MNode$1 | null;
+  nodes: MNode$1[];
+  stage: StageCore | null;
+  stageLoading: boolean;
+  modifiedNodeIds: Map<Id$1, Id$1>;
+  /** 校验失败的节点错误信息，按节点 id 存储，供组件树标记与保存拦截读取 */
+  invalidNodeIds: Map<Id$1, NodeInvalidInfo>;
+  pageLength: number;
+  pageFragmentLength: number;
+  disabledMultiSelect: boolean;
+  /** 是否始终启用多选模式（无需按住 Ctrl/Meta） */
+  alwaysMultiSelect: boolean;
+}
+type StoreStateKey = keyof StoreState;
+interface StageOverlayState {
+  wrapDiv: HTMLDivElement;
+  sourceEl: HTMLElement | null;
+  contentEl: HTMLElement | null;
+  stage: StageCore | null;
+  stageOptions: StageOptions | null;
+  wrapWidth: number;
+  wrapHeight: number;
+  stageOverlayVisible: boolean;
+}
+declare enum ColumnLayout {
+  LEFT = "left",
+  CENTER = "center",
+  RIGHT = "right"
+}
+interface GetColumnWidth {
+  [ColumnLayout.LEFT]: number;
+  [ColumnLayout.CENTER]: number;
+  [ColumnLayout.RIGHT]: number;
+}
+interface StageRect {
+  width: number | string;
+  height: number | string;
+}
+interface UiState {
+  /** 当前点击画布是否触发选中，true: 不触发，false: 触发，默认为false */
+  uiSelectMode: boolean;
+  /** 是否显示整个配置源码， true: 显示， false: 不显示，默认为false */
+  showSrc: boolean;
+  /** 是否将样式配置单独一列显示， true: 显示， false: 不显示，默认为true */
+  showStylePanel: boolean;
+  /** 画布显示放大倍数，默认为 1 */
+  zoom: number;
+  /** 画布容器的宽高 */
+  stageContainerRect: {
+    width: number;
+    height: number;
+  };
+  /** 画布顶层div的宽高，可用于改变画布的大小 */
+  stageRect: StageRect;
+  /** 编辑器列布局每一列的宽度，分为左中右三列 */
+  columnWidth: GetColumnWidth;
+  /** 编辑器列布局左侧列最小宽度 */
+  minLeftColumnWidth: number;
+  /** 编辑器列布局中间列最小宽度 */
+  minCenterColumnWidth: number;
+  /** 编辑器列布局右侧列最小宽度 */
+  minRightColumnWidth: number;
+  /** 是否显示画布参考线，true: 显示，false: 不显示，默认为true */
+  showGuides: boolean;
+  /** 画布上是否存在参考线 */
+  hasGuides: boolean;
+  /** 是否显示标尺，true: 显示，false: 不显示，默认为true */
+  showRule: boolean;
+  /** 用于控制该属性配置表单内组件的尺寸 */
+  propsPanelSize: 'large' | 'default' | 'small';
+  /** 是否显示新增页面按钮 */
+  showAddPageButton: boolean;
+  /** 是否在页面工具栏显示呼起页面列表按钮 */
+  showPageListButton: boolean;
+  /** 是否隐藏侧边栏 */
+  hideSlideBar: boolean;
+  /** 侧边栏面板配置 */
+  sideBarItems: SideComponent[];
+  /** 当前激活的侧边栏面板 */
+  sideBarActiveTabName: string;
+  navMenuRect: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+  };
+  frameworkRect: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+  };
+}
 interface EditorNodeInfo {
   node: MNode$1 | null;
   parent: MContainer | null;
   page: MPage | MPageFragment | null;
   path: MNode$1[];
 }
+interface AddMNode {
+  type: string;
+  name?: string;
+  inputEvent?: DragEvent;
+  [key: string]: any;
+}
+interface PastePosition {
+  left?: number;
+  top?: number;
+  /**
+   * 粘贴位置X方向偏移量
+   */
+  offsetX?: number;
+  /**
+   * 粘贴位置Y方向偏移量
+   */
+  offsetY?: number;
+}
+interface MenuComponent {
+  type: 'component';
+  /** Vue3组件 */
+  component: any;
+  /** 传入组件的props对象 */
+  props?: Record<string, any>;
+  /** 组件监听的事件对象，如：{ click: () => { console.log('click'); } } */
+  listeners?: Record<string, Function>;
+  slots?: Record<string, any>;
+  /** 是否显示，默认为true */
+  className?: string;
+  display?: boolean | ((data: Services) => Promise<boolean> | boolean);
+  [key: string]: any;
+}
+interface SideComponent extends MenuComponent {
+  /** 显示文案 */
+  text: string;
+  /** tab样式 */
+  tabStyle?: string | Record<string, any>;
+  /** vue组件或url */
+  icon?: any;
+  /** slide 唯一标识 key */
+  $key: string;
+  /** 是否可以将面板拖出，默认为true */
+  draggable?: boolean;
+  /** 点击切换tab前调用，返回false阻止切换 */
+  beforeClick?: (config: SideComponent) => boolean | Promise<boolean>;
+  /** 组件扩展参数 */
+  boxComponentConfig?: {
+    /** Vue3组件 */
+    component?: any;
+    /** 传入组件的props对象 */
+    props?: Record<string, any>;
+  };
+}
+interface ComponentItem {
+  /** 显示文案 */
+  text: string;
+  /** 详情，用于tooltip */
+  desc?: string;
+  /** 组件类型 */
+  type: string;
+  /** Vue组件或url */
+  icon?: string | Component<{}, {}, any>;
+  /** 新增组件时需要透传到组价节点上的数据 */
+  data?: {
+    [key: string]: any;
+  };
+}
+interface ComponentGroup {
+  /** 显示文案 */
+  title: string;
+  /** 组内列表 */
+  items: ComponentItem[];
+}
+declare enum LayerOffset {
+  TOP = "top",
+  BOTTOM = "bottom"
+}
+/** 容器布局 */
+declare enum Layout {
+  FLEX = "flex",
+  FIXED = "fixed",
+  RELATIVE = "relative",
+  ABSOLUTE = "absolute"
+}
+/**
+ * 历史记录操作类型：
+ * - `add` / `remove` / `update`：普通可撤销/重做的节点变更；
+ * - `initial`：页面「未修改的初始状态」基线（设置 root 时生成），作为页面栈 index 0 的固定底线 step。
+ *   该 step 不可被撤销/回滚（cursor 不会低于它），仅用于历史面板底部的初始行展示。
+ */
+type HistoryOpType = 'add' | 'remove' | 'update' | 'initial';
+/**
+ * 历史记录的「操作途径」——标记本次变更由哪条交互入口触发，仅用于历史面板展示 / 业务埋点，
+ * 不影响 undo/redo 行为。缺省（未传）时 UI 视为「未知」。
+ *
+ * - `stage`：画布（拖拽 / 缩放 / 排序等舞台直接操作）
+ * - `tree`：树形面板（图层 / 数据源 / 代码块等树形结构里的拖拽 / 菜单操作）
+ * - `component-panel`：组件面板（左侧组件列表点击 / 拖拽新增组件）
+ * - `props`：配置面板表单（属性表单字段编辑）
+ * - `code`：源码编辑器（配置面板「源码」面板里直接编辑 JSON/代码后保存）
+ * - `stage-contextmenu`：画布右键菜单（舞台上节点的右键上下文菜单）
+ * - `tree-contextmenu`：树面板右键菜单（图层 / 数据源 / 代码块等树形列表上的右键上下文菜单）
+ * - `toolbar`：工具栏菜单（顶部导航工具栏按钮）
+ * - `shortcut`：键盘快捷键
+ * - `rollback`：历史回滚（历史面板里对某条历史「回滚」，反向应用为一条新记录，类 git revert）
+ * - `api`：代码 / 接口调用（程序化触发）
+ * - `ai`：AI 生成 / 智能助手触发的变更
+ * - `unknown`：未知来源
+ *
+ * 通过 `(string & {})` 允许业务侧扩展自定义途径字符串，同时保留内置值的自动补全。
+ */
+type HistoryOpSource = 'initial' | 'stage' | 'tree' | 'component-panel' | 'props' | 'code' | 'root-code' | 'stage-contextmenu' | 'tree-contextmenu' | 'toolbar' | 'shortcut' | 'rollback' | 'api' | 'ai' | 'sync' | 'unknown' | (string & {});
+/** *AndGetHistoryId 系列方法返回值：原操作结果 + 本次写入历史记录的 uuid 列表（未入栈时为 `[]`）。 */
+type DslOpWithHistoryIdsResult<T> = {
+  result: T;
+  historyIds: string[];
+};
+/**
+ * 单条变更的 diff 描述，统一表达「页面节点 / 代码块 / 数据源」的变化内容，
+ * 被 {@link StepValue} / {@link CodeBlockStepValue} / {@link DataSourceStepValue} 的 `diff` 复用。
+ *
+ * 按 `opType` 区分携带的字段：
+ * - `add`：仅 `newSchema`（页面节点还带 `parentId` / `index`）；
+ * - `remove`：仅 `oldSchema`（页面节点还带 `parentId` / `index`）；
+ * - `update`：`oldSchema` + `newSchema`，并可带 `changeRecords` 做局部更新。
+ *
+ * 泛型 `T` 为变化内容的快照类型：页面节点为 `MNode`，代码块为 `CodeBlockContent`，数据源为 `DataSourceSchema`。
+ */
+interface StepDiffItem<T = unknown> {
+  /** 变更后的内容快照。`opType` 为 `add` / `update` 时有，`remove` 时无。 */
+  newSchema?: T;
+  /** 变更前的内容快照。`opType` 为 `remove` / `update` 时有，`add` 时无。 */
+  oldSchema?: T;
+  /** 父节点 id。仅页面节点有（数据源 / 代码块没有父节点）。 */
+  parentId?: Id$1;
+  /** 在父节点 items 数组中的索引。仅页面节点有（数据源 / 代码块无需排序）。 */
+  index?: number;
+  /**
+   * form 端 propPath/value 变更列表，仅 `opType` 为 `update` 时有；
+   * 撤销/重做时若有则按 propPath 局部更新，缺省才退化为整内容替换。
+   */
+  changeRecords?: ChangeRecord[];
+}
+/**
+ * 历史记录条目公共字段，被 {@link StepValue} / {@link CodeBlockStepValue} / {@link DataSourceStepValue} 复用。
+ *
+ * 泛型 `T` 为 `diff` 中变化内容的快照类型（页面节点 `MNode` / 代码块 `CodeBlockContent` / 数据源 `DataSourceSchema`）。
+ */
+interface BaseStepValue<T = unknown, U extends Record<string, any> = {}> {
+  /**
+   * 历史记录唯一标识（uuid）。入栈时自动写入（若调用方未指定），
+   * 用于精确定位 / 引用某一条历史记录（如 revert、埋点、跨端同步等）。
+   * 注意与 `data.id`（关联的页面 / 代码块 / 数据源 id）区分。
+   */
+  uuid: string;
+  /**
+   * 关联目标信息：`id` 为关联的页面 / 代码块 / 数据源等资源 id（也是历史栈的分组 key），
+   * `name` 为展示名。所有历史类型统一携带。
+   */
+  data: {
+    name: string;
+    id: Id$1;
+  };
+  /** 操作类型：新增 / 删除 / 更新（三类历史记录统一携带）。 */
+  opType: HistoryOpType;
+  /**
+   * 本次变更的内容（统一 diff 表达），每项见 {@link StepDiffItem}。
+   * 页面节点（add/remove 多节点、update 多节点）会有多项，代码块 / 数据源通常只有一项。
+   */
+  diff: StepDiffItem<T>[];
+  /**
+   * 调用方可选传入的人类可读描述（如「调整按钮颜色」），用于历史面板展示。
+   * 不影响 undo/redo 行为；缺省时面板会根据节点 / propPath 自动生成描述。
+   */
+  historyDescription?: string;
+  /**
+   * 操作途径：标记本次变更由哪条交互入口触发，取值见 {@link HistoryOpSource}
+   * （画布 / 树面板 / 组件面板 / 配置面板 / 源码编辑器 / 右键菜单 / 工具栏 / 快捷键 / 回滚 / 接口 等）。
+   * 仅用于历史面板展示与业务埋点，不影响 undo/redo 行为；缺省时面板视为「未知」。
+   */
+  source?: HistoryOpSource;
+  /**
+   * 入栈时间戳（毫秒）。入栈时自动写入（若调用方未指定），仅用于历史面板展示。
+   */
+  timestamp?: number;
+  /**
+   * 是否为「已保存」记录：DSL 落库（如保存到后端 / 本地）时由 historyService.markSaved 标记。
+   * 同一栈内任意时刻最多只有一条记录为 true；从 IndexedDB 恢复时游标会被定位到最近一条已保存记录之后。
+   */
+  saved?: boolean;
+  /**
+   * 是否为「整体设置 root」（set root）产生的记录（由 {@link Editor.pushRootDiffHistory} 写入）。
+   * 用于「连续 set root 合并」：当某页栈最新一条已是 root 记录时，下一条 set root 会替换它而非新增，
+   * 避免源码反复保存 / 外部重设 DSL 时堆积多条 root 记录。
+   */
+  rootStep?: boolean;
+  /** 操作人 */
+  operator?: string;
+  /** 扩展信息 */
+  extra?: U;
+}
+/**
+ * 历史记录的扩展上下文（{@link BaseStepValue.extra}）。
+ * 内置字段供 `page` 类型在撤销 / 重做时恢复选区与受影响节点；扩展类型可自由附加其它键。
+ */
+interface StepExtra {
+  /** 操作前选中的节点 ID，用于撤销后恢复选择状态（page 类型） */
+  selectedBefore?: Id$1[];
+  /** 操作后选中的节点 ID，用于重做后恢复选择状态（page 类型） */
+  selectedAfter?: Id$1[];
+  /** 本次操作涉及的节点 id 集合（page 类型） */
+  modifiedNodeIds?: Map<Id$1, Id$1>;
+  /** 操作前的节点校验错误快照，撤销后还原（使撤销一个「校验失败」的改动后错误消失） */
+  invalidNodeIdsBefore?: Map<Id$1, NodeInvalidInfo>;
+  /** 操作后的节点校验错误快照，重做后还原（使重做后错误恢复） */
+  invalidNodeIdsAfter?: Map<Id$1, NodeInvalidInfo>;
+  [key: string]: any;
+}
+/**
+ * 页面节点历史记录条目（`diff` 内容为 {@link MNode}）。结构已与代码块 / 数据源统一收敛到
+ * {@link BaseStepValue}：关联 id 见 `data.id`，选区等上下文见 `extra`。
+ */
+type StepValue = BaseStepValue<MNode$1, StepExtra>;
+/**
+ * 代码块历史记录条目（`diff` 内容为 {@link CodeBlockContent}），按 `data.id`（codeBlock.id）
+ * 分组保存到 historyState.steps.codeBlock。结构与 {@link StepValue} / {@link DataSourceStepValue}
+ * 一致，仅 `diff` 快照类型不同。
+ */
+type CodeBlockStepValue = BaseStepValue<CodeBlockContent>;
+/**
+ * 数据源历史记录条目（`diff` 内容为 {@link DataSourceSchema}），按 `data.id`（dataSource.id）
+ * 分组保存到 historyState.steps.dataSource。结构与 {@link StepValue} / {@link CodeBlockStepValue}
+ * 一致，仅 `diff` 快照类型不同。
+ */
+type DataSourceStepValue = BaseStepValue<DataSourceSchema>;
+/**
+ * 历史记录类型标识：内置 `page` / `codeBlock` / `dataSource`，并允许业务扩展自定义类型。
+ * `(string & {})` 保留对内置字面量的智能提示，同时不限制扩展取值。
+ */
+type HistoryStepType = 'page' | 'codeBlock' | 'dataSource' | (string & {});
+/**
+ * 历史记录的可持久化快照。由 historyService.saveToIndexedDB 写入 IndexedDB，
+ * 再由 historyService.restoreFromIndexedDB 读出并重建各 UndoRedo 栈。
+ */
+interface PersistedHistoryState {
+  /** 快照结构版本号，便于后续兼容升级。 */
+  version: number;
+  /**
+   * 全部历史栈的序列化快照，按「类型 -> id」两级分组，与 {@link HistorySteps} 对应。
+   * 内置 `page` / `codeBlock` / `dataSource`，并包含业务注册的扩展类型。
+   */
+  steps: {
+    page: Record<Id$1, SerializedUndoRedo<StepValue>>;
+    codeBlock: Record<Id$1, SerializedUndoRedo<CodeBlockStepValue>>;
+    dataSource: Record<Id$1, SerializedUndoRedo<DataSourceStepValue>>;
+    [stepType: string]: Record<Id$1, SerializedUndoRedo<any>>;
+  };
+  /** 保存时间戳（毫秒）。 */
+  savedAt: number;
+}
+/** historyService 持久化相关 API 的可选配置。 */
+interface HistoryPersistOptions {
+  /** IndexedDB 数据库名，默认 `tmagic-editor`（最终库名会拼上当前 DSL app id）。 */
+  dbName?: string;
+  /** objectStore 名，默认 `history`。 */
+  storeName?: string;
+  /** 记录 key，用于区分不同活动页 / 项目，默认 `default`。 */
+  key?: IDBValidKey;
+  /**
+   * 显式指定用于库名隔离的 DSL app id。
+   * 缺省时回退到当前 editorService 的 `root.id`；在「先恢复历史再 set root」场景下 root 尚未设置，
+   * 需由调用方（如从待加载 DSL 取 id）显式传入，否则会读 / 写到未按 app 隔离的默认库。
+   */
+  appId?: Id$1;
+}
+/**
+ * 历史面板用：当前页面的一条历史步骤（包含位置和是否已应用）。
+ */
+interface HistoryStepEntry<T> {
+  /** 步骤内容 */
+  step: T;
+  /** 在所属栈中的索引（0 为最早） */
+  index: number;
+  /** 是否处于"已应用"段（即位于栈游标之前）。撤销后变为 false。 */
+  applied: boolean;
+  /** 是否为当前所在的步骤（栈中最近一次已应用的那一步，即 index === cursor - 1）。 */
+  isCurrent?: boolean;
+}
+/**
+ * 历史面板分组（页面 / 数据源 / 代码块 / 扩展类型统一结构）。
+ *
+ * 把指定历史栈的步骤列表按"目标"做相邻合并：
+ * - 连续修改同一目标（单实体 update，targetId 一致）的多步合并成一组，组内可展开查看每步；
+ * - add / remove / 多实体 update 始终独立成组（无法明确归属单一目标）；
+ * - targetId 为 undefined 表示"无明确目标"，不参与合并。
+ *
+ * 各类型仅 `kind` 与 step 快照类型不同，统一由泛型描述：
+ * - 页面：`HistoryGroup<StepValue>`，`kind: 'page'`，`id` 为 pageId，`targetId` 为被改节点 id；
+ * - 数据源：`HistoryGroup<DataSourceStepValue>`，`kind: 'data-source'`，`id` 为 dataSource.id；
+ * - 代码块：`HistoryGroup<CodeBlockStepValue>`，`kind: 'code-block'`，`id` 为 codeBlock.id。
+ */
+interface HistoryGroup<T extends BaseStepValue = BaseStepValue> {
+  /** 历史类型标识：page / code-block / data-source（扩展类型同理）。 */
+  kind: string;
+  /** 所属栈 id（page 为 pageId，代码块 / 数据源为对应资源 id）。 */
+  id: Id$1;
+  /** 该分组的操作类型。 */
+  opType: HistoryOpType;
+  /**
+   * 合并的目标 id：仅"单实体 update"有值，并按此与相邻同 id 的 update 合并。
+   * undefined 表示该分组不可被合并（add / remove / 多实体 update）。
+   */
+  targetId?: Id$1;
+  /** 目标可读名（取最后一步快照的 name/type/id）。 */
+  targetName?: string;
+  /** 组内所有步骤，按时间正序。 */
+  steps: {
+    step: T;
+    index: number;
+    applied: boolean;
+    isCurrent?: boolean;
+  }[];
+  /** 组内最后一步是否已应用。 */
+  applied: boolean;
+  /** 是否为当前所在的分组（包含栈中最近一次已应用步骤的那一组）。 */
+  isCurrent?: boolean;
+}
+declare enum KeyBindingCommand {
+  /** 复制 */
+  COPY_NODE = "tmagic-system-copy-node",
+  /** 粘贴 */
+  PASTE_NODE = "tmagic-system-paste-node",
+  /** 删除 */
+  DELETE_NODE = "tmagic-system-delete-node",
+  /** 剪切 */
+  CUT_NODE = "tmagic-system-cut-node",
+  /** 撤销 */
+  UNDO = "tmagic-system-undo",
+  /** 重做 */
+  REDO = "tmagic-system-redo",
+  /** 放大 */
+  ZOOM_IN = "tmagic-system-zoom-in",
+  /** 缩小 */
+  ZOOM_OUT = "tmagic-system-zoom-out",
+  /** 缩放到实际大小 */
+  ZOOM_RESET = "tmagic-system-zoom-reset",
+  /** 缩放以适应 */
+  ZOOM_FIT = "tmagic-system-zoom-fit",
+  /** 向上移动1px */
+  MOVE_UP_1 = "tmagic-system-move-up-1",
+  /** 向下移动1px */
+  MOVE_DOWN_1 = "tmagic-system-move-down-1",
+  /** 向左移动1px */
+  MOVE_LEFT_1 = "tmagic-system-move-left-1",
+  /** 向右移动1px */
+  MOVE_RIGHT_1 = "tmagic-system-move-right-1",
+  /** 向上移动10px */
+  MOVE_UP_10 = "tmagic-system-move-up-10",
+  /** 向下移动10px */
+  MOVE_DOWN_10 = "tmagic-system-move-down-10",
+  /** 向左移动10px */
+  MOVE_LEFT_10 = "tmagic-system-move-left-10",
+  /** 向右移动10px */
+  MOVE_RIGHT_10 = "tmagic-system-move-right-10",
+  /** 切换组件 */
+  SWITCH_NODE = "tmagic-system-switch-node"
+}
+interface KeyBindingItem {
+  command: KeyBindingCommand | string;
+  keybinding?: string | string[];
+  when: [string, 'keyup' | 'keydown'][];
+}
+/** 可新增的数据源类型选项 */
+interface DatasourceTypeOption {
+  /** 数据源类型 */
+  type: string;
+  /** 数据源名称 */
+  text: string;
+}
+type AsyncBeforeHook<Value extends Array<string>, C extends Record<Value[number], (...args: any) => any>> = { [K in Value[number]]?: (...args: Parameters<C[K]>) => Promise<Parameters<C[K]>> | Parameters<C[K]>; };
+type AsyncAfterHook<Value extends Array<string>, C extends Record<Value[number], (...args: any) => any>> = { [K in Value[number]]?: (result: Awaited<ReturnType<C[K]>>, ...args: Parameters<C[K]>) => ReturnType<C[K]> | Awaited<ReturnType<C[K]>>; };
+type SyncBeforeHook<Value extends Array<string>, C extends Record<Value[number], (...args: any) => any>> = { [K in Value[number]]?: (...args: Parameters<C[K]>) => Parameters<C[K]>; };
+type SyncAfterHook<Value extends Array<string>, C extends Record<Value[number], (...args: any) => any>> = { [K in Value[number]]?: (result: ReturnType<C[K]>, ...args: Parameters<C[K]>) => ReturnType<C[K]>; };
+type AddPrefixToObject<T, P extends string> = { [K in keyof T as K extends string ? `${P}${K}` : never]: T[K]; };
+type AsyncHookPlugin<T extends Array<string>, C extends Record<T[number], (...args: any) => any>> = AddPrefixToObject<PascalCasedProperties<AsyncBeforeHook<T, C>>, 'before'> & AddPrefixToObject<PascalCasedProperties<AsyncAfterHook<T, C>>, 'after'>;
+type SyncHookPlugin<T extends Array<string>, C extends Record<T[number], (...args: any) => any>> = AddPrefixToObject<PascalCasedProperties<SyncBeforeHook<T, C>>, 'before'> & AddPrefixToObject<PascalCasedProperties<SyncAfterHook<T, C>>, 'after'>;
+type PropsFormConfigFunction = (data: {
+  editorService: EditorService;
+}) => FormConfig;
+type PropsFormValueFunction = (data: {
+  editorService: EditorService;
+}) => Partial<MNode$1>;
+interface EditorEvents {
+  'root-change': [value: StoreState['root'], preValue?: StoreState['root'], options?: {
+    historySource?: HistoryOpSource;
+  }];
+  select: [node: MNode$1 | null];
+  add: [nodes: MNode$1[]];
+  remove: [nodes: MNode$1[]];
+  update: [nodes: {
+    newNode: MNode$1;
+    oldNode: MNode$1;
+    changeRecords?: ChangeRecord[];
+  }[]];
+  'move-layer': [offset: number | LayerOffset];
+  'drag-to': [data: {
+    targetIndex: number;
+    configs: MNode$1 | MNode$1[];
+    targetParent: MContainer;
+  }];
+  'history-change': [data: MPage | MPageFragment];
+  /**
+   * DSL 发生变更后统一触发，免去分别监听 add / remove / update / move-layer / drag-to。
+   * 回调参数为 {@link EditorChangeEvent}，按 `type` 区分操作类型并携带各自的操作内容（payload）
+   * 以及变更所在的当前 page（可能为 null）。撤销 / 重做内部同样会经由
+   * add / remove / update 触发本事件；如需区分「用户操作」与「撤销重做」请配合 `history-change`。
+   */
+  change: [event: EditorChangeEvent];
+  /** 节点校验错误状态发生变化时触发，携带当前完整的错误 Map（供非响应式消费方订阅） */
+  'invalid-node-change': [invalidNodeIds: Map<Id$1, NodeInvalidInfo>];
+}
+/** `change` 事件中单个变更项：变更的 node 及其所属的 page（可能为 null）。 */
+interface EditorChangeItem {
+  node: MNode$1;
+  page: StoreState['page'];
+}
+/** `update` 类型变更项：node 为前后快照及 form 端变更记录，page 为其所属页面。 */
+interface EditorUpdateChangeItem {
+  node: {
+    newNode: MNode$1;
+    oldNode: MNode$1;
+    changeRecords?: ChangeRecord[];
+  };
+  page: StoreState['page'];
+}
+/** {@link EditorEvents.change} 各操作类型共有的历史相关字段。 */
+interface EditorChangeEventHistoryMeta {
+  /**
+   * 本次变更的「历史来源」（调用 DSL 操作时传入的 {@link HistoryOpOptions.historySource}，
+   * 撤销 / 重做时则为被应用 step 上记录的 `source`），未携带时为 undefined。
+   */
+  historySource?: HistoryOpSource;
+  /**
+   * 本次操作是否未写入历史记录（即调用时传入的 {@link HistoryOpOptions.doNotPushHistory}，缺省为 false）；
+   * 撤销 / 重做路径补发的事件恒为 true（撤销/重做本身不再入栈）。
+   */
+  doNotPushHistory?: boolean;
+}
+/**
+ * {@link EditorEvents.change} 的回调参数：以 `type` 区分操作类型，并携带对应的操作内容。
+ * `data` 为本次变更的节点列表，每项包含 node 及其所属的 page（可能为 null）；
+ * `move-layer` 额外带层级偏移 `offset`，`drag-to` 额外带目标位置 `targetIndex` / `targetParent`；
+ * 历史相关字段（historySource / doNotPushHistory）见 {@link EditorChangeEventHistoryMeta}。
+ */
+type EditorChangeEvent = ({
+  type: 'add';
+  data: EditorChangeItem[];
+} & EditorChangeEventHistoryMeta) | ({
+  type: 'remove';
+  data: EditorChangeItem[];
+} & EditorChangeEventHistoryMeta) | ({
+  type: 'update';
+  data: EditorUpdateChangeItem[];
+} & EditorChangeEventHistoryMeta) | ({
+  type: 'move-layer';
+  data: EditorChangeItem[];
+  offset: number | LayerOffset;
+} & EditorChangeEventHistoryMeta) | ({
+  type: 'drag-to';
+  data: EditorChangeItem[];
+  targetIndex: number;
+  targetParent: MContainer;
+} & EditorChangeEventHistoryMeta);
+interface HistoryEvents {
+  change: [state: BaseStepValue | StepValue | CodeBlockStepValue | DataSourceStepValue, stepType: HistoryStepType, id: Id$1];
+  'code-block-history-change': [id: Id$1, state: CodeBlockStepValue];
+  'data-source-history-change': [id: Id$1, state: DataSourceStepValue];
+  'restore-from-indexed-db': [snapshot: PersistedHistoryState | null];
+  'save-to-indexed-db': [snapshot: PersistedHistoryState];
+  'mark-saved': [{
+    kind: HistoryStepType;
+    id?: Id$1;
+  }];
+  clear: [{
+    id: Id$1;
+    stepType: HistoryStepType;
+  }];
+  'marker-change': [{
+    id: Id$1;
+    marker: StepValue;
+    stepType: HistoryStepType;
+  }];
+  /**
+   * 页面 / 页面片结构变更（新增 / 删除）时派发，见 {@link HistoryService.notifyPageStructureChange}。
+   * 一次操作（add / remove / setRoot 整体替换）涉及多个页面时合并为**一个**事件；
+   * `add` / `remove` 分别为本次新增与删除的页面列表（其一可为空数组）。
+   */
+  'page-structure-change': [change: {
+    add: (MPage | MPageFragment)[];
+    remove: (MPage | MPageFragment)[];
+  }];
+}
+declare const canUsePluginMethods: {
+  async: readonly ["getLayout", "highlight", "select", "multiSelect", "doAdd", "add", "doRemove", "remove", "doUpdate", "update", "sort", "copy", "paste", "doPaste", "doAlignCenter", "alignCenter", "moveLayer", "moveToContainer", "dragTo", "undo", "redo", "move"];
+  sync: never[];
+};
+type AsyncMethodName = Writable<(typeof canUsePluginMethods)['async']>;
+/**
+ * 历史记录写入相关的通用配置（codeBlock / dataSource / editor 共用）
+ * - doNotPushHistory: 操作完成后是否不要将本次操作压入历史栈（撤销/重做记录），默认 false
+ * - historyDescription: 入栈时附带的人类可读描述，用于历史面板展示；不影响 undo/redo 行为，缺省时面板会自动生成描述
+ * - historySource: 操作途径，取值见 {@link HistoryOpSource}（画布 / 树面板 / 组件面板 / 配置面板 / 源码编辑器 / 右键菜单 / 工具栏 / 快捷键 / 回滚 / 接口 等），用于历史面板展示与埋点；不影响 undo/redo 行为
+ */
+interface HistoryOpOptions {
+  doNotPushHistory?: boolean;
+  historyDescription?: string;
+  historySource?: HistoryOpSource;
+}
+/**
+ * 在 HistoryOpOptions 基础上携带 form 端 propPath/value 变更记录，
+ * 用于历史记录的精细化撤销/重做（按 propPath 局部 patch）。
+ */
+interface HistoryOpOptionsWithChangeRecords extends HistoryOpOptions {
+  changeRecords?: ChangeRecord[];
+}
+/**
+ * DSL 修改类操作的通用配置
+ * - doNotSelect: 操作后是否不要自动触发选中（不调用 this.select / this.multiSelect / stage.select / stage.multiSelect）
+ * - doNotSwitchPage: 操作若会引发当前页面切换（如新增 / 删除 / 跨页移动），是否跳过这次切换
+ */
+interface DslOpOptions extends HistoryOpOptions {
+  doNotSelect?: boolean;
+  doNotSwitchPage?: boolean;
+}
+/**
+ * {@link EditorService.update} / {@link EditorService.doUpdate} 的额外数据
+ * - changeRecords: 单节点 form 端变更记录（多节点场景下被忽略，使用 changeRecordList）
+ * - changeRecordList: 多节点 form 端变更记录列表，按 config 数组同序对应每个节点；优先级高于 changeRecords
+ * - replace: 为 true 时跳过 mergeWith / toggleFixedPosition / setChildrenLayout，直接用传入配置整节点替换
+ * - invalidInfo: 属性面板提交时携带的校验错误信息，在写入历史记录之前落库
+ */
+interface UpdateOptions extends HistoryOpOptionsWithChangeRecords {
+  changeRecordList?: ChangeRecord[][];
+  /**
+   * 为 true 时不做深合并等变换，直接用传入配置整节点替换现有节点。
+   * 适用于源码编辑、历史整节点快照回放等「完整 DSL」场景；默认 false（局部属性更新走 merge）。
+   */
+  replace?: boolean;
+  /**
+   * 属性面板提交时携带的校验错误信息，在写入历史记录之前落库，
+   * 使历史快照与本次变更对齐，从而 undo/redo 能正确还原错误标记。
+   */
+  invalidInfo?: {
+    id: Id$1;
+    source: NodeInvalidSource;
+    error?: string;
+  };
+}
 //#endregion
 //#region temp/packages/utils/src/dom.d.ts
 declare const asyncLoadJs: (url: string, crossOrigin?: string, document?: Document) => any;