@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.41

package/lib/models/flowModel.d.ts

@@ -18,8 +18,9 @@ import { ModelEventRegistry } from '../event-registry/ModelEventRegistry';
 import { GlobalFlowRegistry } from '../flow-registry/GlobalFlowRegistry';
 import { FlowDefinition } from '../FlowDefinition';
 import { FlowSettingsOpenOptions } from '../flowSettings';
-import type { EventDefinition } from '../types';
+import type { EventDefinition, DispatchEventOptions } from '../types';
 import { ForkFlowModel } from './forkFlowModel';
+import type { ScheduleOptions } from '../scheduler/ModelOperationScheduler';
 export declare enum ModelRenderMode {
     ReactElement = "reactElement",
     RenderFunction = "renderFunction"
@@ -42,6 +43,7 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     private _options;
     protected _title: string;
     isNew: boolean;
+    skeleton: any;
     /**
      * 所有 fork 实例的引用集合。
      * 使用 Set 便于在销毁时主动遍历并调用 dispose，避免悬挂引用。
@@ -53,7 +55,7 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
      */
     private forkCache;
     /**
-     * 上一次 applyAutoFlows 的执行参数
+     * 上一次 beforeRender 的执行参数
      */
     private _lastAutoRunParams;
     protected observerDispose: () => void;
@@ -90,6 +92,7 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     get subType(): "object" | "array";
     get reactView(): import("../ReactView").ReactView;
     get parentId(): string;
+    scheduleModelOperation(toUid: string, fn: (model: FlowModel) => Promise<void> | void, options?: ScheduleOptions): import("../scheduler/ModelOperationScheduler").ScheduledCancel;
     static get meta(): FlowModelMeta;
     static get globalFlowRegistry(): GlobalFlowRegistry;
     protected static get actionRegistry(): ModelActionRegistry;
@@ -117,7 +120,11 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     setTitle(value: string): void;
     setHidden(value: boolean): void;
     _createSubModels(subModels: Record<string, CreateSubModelOptions | CreateSubModelOptions[]>): void;
-    invalidateAutoFlowCache(deep?: boolean): void;
+    /**
+     * 失效指定事件的流程缓存；未指定 eventName 时，失效当前模型全部事件缓存。
+     * - 默认 beforeRender 与其它事件共享同一缓存体系：prefix=`event:${scope}`，flowKey=`eventName`，uid=`model.uid`
+     */
+    invalidateFlowCache(eventName?: string, deep?: boolean): void;
     /**
      * 设置FlowEngine实例
      * @param {FlowEngine} flowEngine FlowEngine实例
@@ -187,45 +194,36 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     private _dispatchEvent;
     private _dispatchEventWithDebounce;
     dispatchEvent(eventName: string, inputArgs?: Record<string, any>, options?: {
-        /**
-         * 是否要开启防抖功能
-         */
-        debounce: boolean;
-    }): Promise<void>;
+        /** 是否要开启防抖功能 */
+        debounce?: boolean;
+    } & DispatchEventOptions): Promise<any[]>;
     /**
-     * 获取所有自动应用流程定义（保持 getFlows 的顺序，即按 sort 排序）
-     * @returns {FlowDefinition[]} 自动应用流程定义数组（已按 sort 排序）
+     * 按事件名获取对应的流程集合（保持 getFlows 的顺序，即按 sort 排序）。
+     * - beforeRender 兼容：除显式 on: 'beforeRender' 外，包含未声明 on 且 manual !== true 的流程。
      */
-    getAutoFlows(): FlowDefinition[];
+    getEventFlows(eventName: string): FlowDefinition[];
     /**
-     * 重新执行上一次的 applyAutoFlows，保持参数一致
+     * 重新执行上一次的 beforeRender，保持参数一致
      * 如果之前没有执行过，则直接跳过
      * 使用 lodash debounce 避免频繁调用
      */
     private _rerunLastAutoRun;
     /**
-     * 自动流程执行前钩子。
-     * 子类可覆盖；可抛出 FlowExitException 提前终止。
+     * 通用事件分发钩子：开始
+     * 子类可覆盖；beforeRender 事件可通过抛出 FlowExitException 提前终止。
      */
-    onBeforeAutoFlows(inputArgs?: Record<string, any>): Promise<void>;
+    onDispatchEventStart(eventName: string, options?: DispatchEventOptions, inputArgs?: Record<string, any>): Promise<void>;
     /**
-     * 自动流程执行后钩子。
+     * 通用事件分发钩子：结束
      * 子类可覆盖。
      */
-    onAfterAutoFlows(results: any[], inputArgs?: Record<string, any>): Promise<void>;
+    onDispatchEventEnd(eventName: string, options?: DispatchEventOptions, inputArgs?: Record<string, any>, results?: any[]): Promise<void>;
     /**
-     * 自动流程错误钩子。
+     * 通用事件分发钩子：错误
      * 子类可覆盖。
      */
-    onAutoFlowsError(error: Error, inputArgs?: Record<string, any>): Promise<void>;
+    onDispatchEventError(eventName: string, options?: DispatchEventOptions, inputArgs?: Record<string, any>, error?: Error): Promise<void>;
     useHooksBeforeRender(): void;
-    /**
-     * 执行所有自动应用流程
-     * @param {Record<string, any>} [inputArgs] 可选的运行时参数
-     * @param {boolean} [useCache=true] 是否使用缓存机制，默认为 true
-     * @returns {Promise<any[]>} 所有自动应用流程的执行结果数组
-     */
-    applyAutoFlows(inputArgs?: Record<string, any>, useCache?: boolean): Promise<any[]>;
     /**
      * 智能检测是否应该跳过响应式包装
      * 说明：
@@ -261,9 +259,9 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     render(): any;
     rerender(): Promise<void>;
     /**
-     * 自动流程缓存的作用域标识；fork 实例可覆盖以区分缓存。
+     * 事件缓存的作用域标识；可按事件区分（默认与事件无关的 scope 返回 'default'）。
      */
-    getAutoFlowCacheScope(): string;
+    getFlowCacheScope(eventName: string): string;
     setParent(parent: FlowModel): void;
     removeParentDelegate(): void;
     addSubModel<T extends FlowModel>(subKey: string, options: CreateModelOptions | T): T;
@@ -273,7 +271,10 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     hasSubModel<K extends keyof Structure['subModels']>(subKey: K): boolean;
     findSubModel<K extends keyof Structure['subModels'], R>(subKey: K, callback: (model: ArrayElementType<Structure['subModels'][K]>) => R): ArrayElementType<Structure['subModels'][K]> | null;
     createRootModel(options: any): FlowModel<DefaultStructure>;
-    applySubModelsAutoFlows<K extends keyof Structure['subModels']>(subKey: K, inputArgs?: Record<string, any>, shared?: Record<string, any>): Promise<void>;
+    /**
+     * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。
+     */
+    applySubModelsBeforeRenderFlows<K extends keyof Structure['subModels']>(subKey: K, inputArgs?: Record<string, any>, shared?: Record<string, any>): Promise<void>;
     /**
      * 创建一个 fork 实例，实现"一份数据（master）多视图（fork）"的能力。
      * @param {IModelComponentProps} [localProps={}] fork 专属的局部 props，优先级高于 master.props

package/lib/models/flowModel.js

@@ -62,7 +62,6 @@ var import_StepSettingsDialog = require("../components/settings/wrappers/context
 var import_emitter = require("../emitter");
 var import_InstanceFlowRegistry = require("../flow-registry/InstanceFlowRegistry");
 var import_flowContext = require("../flowContext");
-var import_flowEngine = require("../flowEngine");
 var import_utils = require("../utils");
 var import_lib = require("antd/lib");
 var import_ModelActionRegistry = require("../action-registry/ModelActionRegistry");
@@ -94,6 +93,7 @@ const _FlowModel = class _FlowModel {
     __publicField(this, "_title");
     __publicField(this, "isNew", false);
     // 标记是否为新建状态
+    __publicField(this, "skeleton", null);
     /**
      * 所有 fork 实例的引用集合。
      * 使用 Set 便于在销毁时主动遍历并调用 dispose，避免悬挂引用。
@@ -105,7 +105,7 @@ const _FlowModel = class _FlowModel {
      */
     __publicField(this, "forkCache", /* @__PURE__ */ new Map());
     /**
-     * 上一次 applyAutoFlows 的执行参数
+     * 上一次 beforeRender 的执行参数
      */
     __publicField(this, "_lastAutoRunParams", null);
     __publicField(this, "observerDispose");
@@ -120,18 +120,22 @@ const _FlowModel = class _FlowModel {
     __publicField(this, "_reactiveWrapperCache");
     __publicField(this, "flowRegistry");
     __publicField(this, "_cleanRun");
-    __publicField(this, "_dispatchEventWithDebounce", import_lodash.default.debounce(async (eventName, inputArgs) => {
-      return this._dispatchEvent(eventName, inputArgs);
-    }, 100));
+    __publicField(this, "_dispatchEventWithDebounce", import_lodash.default.debounce(
+      async (eventName, inputArgs, options) => {
+        return this._dispatchEvent(eventName, inputArgs, options);
+      },
+      100
+    ));
     /**
-     * 重新执行上一次的 applyAutoFlows，保持参数一致
+     * 重新执行上一次的 beforeRender，保持参数一致
      * 如果之前没有执行过，则直接跳过
      * 使用 lodash debounce 避免频繁调用
      */
     __publicField(this, "_rerunLastAutoRun", import_lodash.default.debounce(async () => {
       if (this._lastAutoRunParams) {
         try {
-          await this.applyAutoFlows(...this._lastAutoRunParams);
+          const [inputArgs] = this._lastAutoRunParams;
+          await this.dispatchEvent("beforeRender", inputArgs);
         } catch (error) {
           console.error("FlowModel._rerunLastAutoRun: Error during rerun:", error);
         }
@@ -172,7 +176,7 @@ const _FlowModel = class _FlowModel {
         return;
       }
       if (this.flowEngine) {
-        this.invalidateAutoFlowCache();
+        this.invalidateFlowCache("beforeRender");
       }
       this._rerunLastAutoRun();
       this.forks.forEach((fork) => {
@@ -234,6 +238,10 @@ const _FlowModel = class _FlowModel {
   get parentId() {
     return this._options.parentId;
   }
+  scheduleModelOperation(toUid, fn, options) {
+    var _a;
+    return (_a = this.flowEngine) == null ? void 0 : _a.scheduleModelOperation(this, toUid, fn, options);
+  }
   static get meta() {
     return modelMetas.get(this);
   }
@@ -342,13 +350,57 @@ const _FlowModel = class _FlowModel {
       }
     });
   }
-  invalidateAutoFlowCache(deep = false) {
+  /**
+   * 失效指定事件的流程缓存；未指定 eventName 时，失效当前模型全部事件缓存。
+   * - 默认 beforeRender 与其它事件共享同一缓存体系：prefix=`event:${scope}`，flowKey=`eventName`，uid=`model.uid`
+   */
+  invalidateFlowCache(eventName, deep = false) {
     if (this.flowEngine) {
-      const cacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey("autoFlow", "all", this.uid);
-      this.flowEngine.applyFlowCache.delete(cacheKey);
+      const scope = `event:${this.getFlowCacheScope(eventName || "beforeRender")}`;
+      const cache = this.flowEngine.applyFlowCache;
+      if (eventName) {
+        const altScope = scope.replace(/:/g, "-");
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        const eventSegments = [`:${eventName}:`, `-${eventName}-`];
+        for (const key of cache.keys()) {
+          const startMatches = key.startsWith(scope) || key.startsWith(altScope);
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          const eventMatches = eventSegments.some((seg) => key.includes(seg));
+          if (startMatches && endMatches && eventMatches) {
+            cache.delete(key);
+          }
+        }
+      } else {
+        const altScope = `${scope}:`.replace(/:/g, "-");
+        const prefixes = [`${scope}:`, altScope];
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        for (const key of cache.keys()) {
+          const startMatches = prefixes.some((p) => key.startsWith(p));
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          if (startMatches && endMatches) cache.delete(key);
+        }
+      }
       this.forks.forEach((fork) => {
-        const forkCacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey(`${fork["forkId"]}`, "all", this.uid);
-        this.flowEngine.applyFlowCache.delete(forkCacheKey);
+        var _a;
+        const forkScope = `event:${((_a = fork.getFlowCacheScope) == null ? void 0 : _a.call(fork, eventName || "beforeRender")) ?? String(fork["forkId"])}`;
+        const altForkScope = forkScope.replace(/:/g, "-");
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        if (eventName) {
+          const eventSegments = [`:${eventName}:`, `-${eventName}-`];
+          for (const key of this.flowEngine.applyFlowCache.keys()) {
+            const startMatches = key.startsWith(forkScope) || key.startsWith(altForkScope);
+            const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+            const eventMatches = eventSegments.some((seg) => key.includes(seg));
+            if (startMatches && endMatches && eventMatches) this.flowEngine.applyFlowCache.delete(key);
+          }
+        } else {
+          const prefixes = [`${forkScope}:`, `${altForkScope}-`];
+          for (const key of this.flowEngine.applyFlowCache.keys()) {
+            const startMatches = prefixes.some((p) => key.startsWith(p));
+            const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+            if (startMatches && endMatches) this.flowEngine.applyFlowCache.delete(key);
+          }
+        }
       });
     }
     if (deep) {
@@ -357,10 +409,10 @@ const _FlowModel = class _FlowModel {
         const subModelValue = this.subModels[subModelKey];
         if (Array.isArray(subModelValue)) {
           for (const subModel of subModelValue) {
-            subModel.invalidateAutoFlowCache(deep);
+            subModel.invalidateFlowCache(eventName, deep);
           }
         } else if (subModelValue instanceof _FlowModel) {
-          subModelValue.invalidateAutoFlowCache(deep);
+          subModelValue.invalidateFlowCache(eventName, deep);
         }
       }
     }
@@ -480,14 +532,15 @@ const _FlowModel = class _FlowModel {
     const instanceKeys = new Set(instanceFlows.keys());
     const staticEntries = Array.from(staticFlows.entries()).filter(([key]) => !instanceKeys.has(key));
     const instanceEntries = Array.from(instanceFlows.entries());
-    const allEntries = [...staticEntries, ...instanceEntries];
-    allEntries.sort(([, a], [, b]) => {
-      const sa = a.sort ?? 0;
-      const sb = b.sort ?? 0;
+    const instanceEntriesWithIndex = instanceEntries.map((e, i) => ({ e, i }));
+    instanceEntriesWithIndex.sort((a, b) => {
+      const sa = a.e[1].sort ?? 0;
+      const sb = b.e[1].sort ?? 0;
       if (sa !== sb) return sa - sb;
-      return 0;
+      return a.i - b.i;
     });
-    return new Map(allEntries);
+    const merged = [...instanceEntriesWithIndex.map(({ e }) => e), ...staticEntries];
+    return new Map(merged);
   }
   setProps(props, value) {
     if (typeof props === "string") {
@@ -544,7 +597,7 @@ const _FlowModel = class _FlowModel {
     );
     return currentFlowEngine.executor.runFlow(target, flowKey, inputArgs, runId);
   }
-  async _dispatchEvent(eventName, inputArgs) {
+  async _dispatchEvent(eventName, inputArgs, options) {
     const currentFlowEngine = this.flowEngine;
     if (!currentFlowEngine) {
       console.warn("FlowEngine not available on this model for dispatchEvent. Please set flowEngine on the model.");
@@ -555,93 +608,67 @@ const _FlowModel = class _FlowModel {
     console.log(
       `[FlowModel] dispatchEvent: uid=${this.uid}, event=${eventName}, isFork=${isFork}, cleanRun=${this.cleanRun}, targetIsFork=${(target == null ? void 0 : target.isFork) === true}`
     );
-    await currentFlowEngine.executor.dispatchEvent(target, eventName, inputArgs);
+    return await currentFlowEngine.executor.dispatchEvent(target, eventName, inputArgs, options);
   }
   async dispatchEvent(eventName, inputArgs, options) {
+    const isBeforeRender = eventName === "beforeRender";
+    const defaults = isBeforeRender ? { sequential: true, useCache: true } : { sequential: true };
+    const execOptions = {
+      sequential: (options == null ? void 0 : options.sequential) ?? defaults.sequential,
+      useCache: (options == null ? void 0 : options.useCache) ?? defaults.useCache
+    };
+    if (isBeforeRender) {
+      this._lastAutoRunParams = [inputArgs, execOptions.useCache];
+    }
+    let finalInputArgs = inputArgs;
+    if (this.context.record) {
+      finalInputArgs = { record: this.context.record, ...inputArgs };
+    }
     if (options == null ? void 0 : options.debounce) {
-      return this._dispatchEventWithDebounce(eventName, inputArgs);
+      return this._dispatchEventWithDebounce(eventName, finalInputArgs, execOptions);
     }
-    return this._dispatchEvent(eventName, inputArgs);
+    return this._dispatchEvent(eventName, finalInputArgs, execOptions);
   }
   /**
-   * 获取所有自动应用流程定义（保持 getFlows 的顺序，即按 sort 排序）
-   * @returns {FlowDefinition[]} 自动应用流程定义数组（已按 sort 排序）
+   * 按事件名获取对应的流程集合（保持 getFlows 的顺序，即按 sort 排序）。
+   * - beforeRender 兼容：除显式 on: 'beforeRender' 外，包含未声明 on 且 manual !== true 的流程。
    */
-  getAutoFlows() {
+  getEventFlows(eventName) {
     const allFlows = this.getFlows();
-    const autoFlows = Array.from(allFlows.values()).filter((flow) => {
-      if (flow.on) {
-        return false;
+    const beforeRender = eventName === "beforeRender";
+    const isMatch = /* @__PURE__ */ __name((flow) => {
+      var _a;
+      if (beforeRender) {
+        if (flow.manual === true) return false;
+        if (!flow.on) return true;
+        return typeof flow.on === "string" ? flow.on === "beforeRender" : ((_a = flow.on) == null ? void 0 : _a.eventName) === "beforeRender";
       }
-      if (flow.manual === true) {
-        return false;
-      }
-      return true;
-    });
-    return autoFlows;
+      const on = flow.on;
+      if (!on) return false;
+      return typeof on === "string" ? on === eventName : (on == null ? void 0 : on.eventName) === eventName;
+    }, "isMatch");
+    return Array.from(allFlows.values()).filter(isMatch);
   }
   /**
-   * 自动流程执行前钩子。
-   * 子类可覆盖；可抛出 FlowExitException 提前终止。
+   * 通用事件分发钩子：开始
+   * 子类可覆盖；beforeRender 事件可通过抛出 FlowExitException 提前终止。
    */
-  async onBeforeAutoFlows(inputArgs) {
+  async onDispatchEventStart(eventName, options, inputArgs) {
   }
   /**
-   * 自动流程执行后钩子。
+   * 通用事件分发钩子：结束
    * 子类可覆盖。
    */
-  async onAfterAutoFlows(results, inputArgs) {
+  async onDispatchEventEnd(eventName, options, inputArgs, results) {
   }
   /**
-   * 自动流程错误钩子。
+   * 通用事件分发钩子：错误
    * 子类可覆盖。
    */
-  async onAutoFlowsError(error, inputArgs) {
+  async onDispatchEventError(eventName, options, inputArgs, error) {
   }
   useHooksBeforeRender() {
   }
-  async applyAutoFlows(...args) {
-    var _a, _b;
-    const [inputArgs, useCache = true] = args;
-    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(this["forkId"] ?? "autoFlow", "all", this.uid) : null;
-    if (!import_lodash.default.isEqual(inputArgs, (_a = this._lastAutoRunParams) == null ? void 0 : _a[0]) && cacheKey) {
-      this.flowEngine.applyFlowCache.delete(cacheKey);
-    }
-    this._lastAutoRunParams = args;
-    try {
-      await this.onBeforeAutoFlows(inputArgs);
-    } catch (error) {
-      if (error instanceof import_utils.FlowExitException) {
-        (_b = this.context.logger) == null ? void 0 : _b.debug(`[FlowModel.applyAutoFlows] ${error.message}`);
-        return [];
-      }
-      try {
-        await this.onAutoFlowsError(error, inputArgs);
-      } catch (_2) {
-      }
-      throw error;
-    }
-    let results = [];
-    try {
-      results = await this.flowEngine.executor.runAutoFlows(this, inputArgs, useCache);
-    } catch (error) {
-      try {
-        await this.onAutoFlowsError(error, inputArgs);
-      } catch (_2) {
-      }
-      throw error;
-    }
-    try {
-      await this.onAfterAutoFlows(results, inputArgs);
-    } catch (error) {
-      try {
-        await this.onAutoFlowsError(error, inputArgs);
-      } catch (_2) {
-      }
-      throw error;
-    }
-    return results;
-  }
   /**
    * 智能检测是否应该跳过响应式包装
    * 说明：
@@ -701,13 +728,23 @@ const _FlowModel = class _FlowModel {
             modelInstance.props;
           }
           import_react.default.useEffect(() => {
+            var _a2, _b2;
             if (typeof renderTarget.onMount === "function") {
               renderTarget.onMount();
             }
+            void ((_b2 = (_a2 = renderTarget.flowEngine) == null ? void 0 : _a2.emitter) == null ? void 0 : _b2.emitAsync("model:mounted", {
+              uid: renderTarget.uid,
+              model: renderTarget
+            }));
             return () => {
+              var _a3, _b3;
               if (typeof renderTarget.onUnmount === "function") {
                 renderTarget.onUnmount();
               }
+              void ((_b3 = (_a3 = renderTarget.flowEngine) == null ? void 0 : _a3.emitter) == null ? void 0 : _b3.emitAsync("model:unmounted", {
+                uid: renderTarget.uid,
+                model: renderTarget
+              }));
             };
           }, [renderTarget]);
           const isConfigMode = !!((_b = (_a = modelInstance == null ? void 0 : modelInstance.flowEngine) == null ? void 0 : _a.flowSettings) == null ? void 0 : _b.enabled);
@@ -717,6 +754,7 @@ const _FlowModel = class _FlowModel {
             }
             return (_c = modelInstance.renderHiddenInConfig) == null ? void 0 : _c.call(modelInstance);
           }
+          modelInstance.stepParams;
           return originalRender.call(renderTarget);
         });
         ReactiveWrapper.displayName = `ReactiveWrapper(${modelInstance.constructor.name})`;
@@ -768,13 +806,13 @@ const _FlowModel = class _FlowModel {
   }
   async rerender() {
     var _a;
-    await this.applyAutoFlows((_a = this._lastAutoRunParams) == null ? void 0 : _a[0], false);
+    await this.dispatchEvent("beforeRender", (_a = this._lastAutoRunParams) == null ? void 0 : _a[0], { useCache: false });
   }
   /**
-   * 自动流程缓存的作用域标识；fork 实例可覆盖以区分缓存。
+   * 事件缓存的作用域标识；可按事件区分（默认与事件无关的 scope 返回 'default'）。
    */
-  getAutoFlowCacheScope() {
-    return "autoFlow";
+  getFlowCacheScope(eventName) {
+    return String(eventName);
   }
   setParent(parent) {
     const isValidParent = parent && (parent.constructor === _FlowModel || (0, import_utils.isInheritedFrom)(parent.constructor, _FlowModel));
@@ -794,7 +832,7 @@ const _FlowModel = class _FlowModel {
     this.context.removeDelegate(this.parent.context);
   }
   addSubModel(subKey, options) {
-    var _a;
+    var _a, _b, _c;
     const actualParent = this["master"] || this;
     let model;
     if (options instanceof _FlowModel) {
@@ -821,10 +859,16 @@ const _FlowModel = class _FlowModel {
     model.sortIndex = maxSortIndex + 1;
     subModels[subKey].push(model);
     actualParent.emitter.emit("onSubModelAdded", model);
+    (_c = (_b = actualParent.flowEngine) == null ? void 0 : _b.emitter) == null ? void 0 : _c.emit("model:subModel:added", {
+      parentUid: actualParent.uid,
+      parent: actualParent,
+      subKey,
+      model
+    });
     return model;
   }
   setSubModel(subKey, options) {
-    var _a;
+    var _a, _b, _c;
     const actualParent = this["master"] || this;
     let model;
     if (options instanceof _FlowModel) {
@@ -845,6 +889,12 @@ const _FlowModel = class _FlowModel {
     model.setParent(actualParent);
     actualParent.subModels[subKey] = model;
     actualParent.emitter.emit("onSubModelAdded", model);
+    (_c = (_b = actualParent.flowEngine) == null ? void 0 : _b.emitter) == null ? void 0 : _c.emit("model:subModel:added", {
+      parentUid: actualParent.uid,
+      parent: actualParent,
+      subKey,
+      model
+    });
     return model;
   }
   filterSubModels(subKey, callback) {
@@ -892,10 +942,13 @@ const _FlowModel = class _FlowModel {
   createRootModel(options) {
     return this.flowEngine.createModel(options);
   }
-  async applySubModelsAutoFlows(subKey, inputArgs, shared) {
+  /**
+   * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。
+   */
+  async applySubModelsBeforeRenderFlows(subKey, inputArgs, shared) {
     await Promise.all(
       this.mapSubModels(subKey, async (sub) => {
-        await sub.applyAutoFlows(inputArgs);
+        await sub.dispatchEvent("beforeRender", inputArgs);
       })
     );
   }
@@ -913,7 +966,7 @@ const _FlowModel = class _FlowModel {
         return cachedFork;
       }
     }
-    const forkId = this.forks.size;
+    const forkId = (0, import_secure.uid)();
     const fork = new import_forkFlowModel.ForkFlowModel(this, localProps, forkId);
     if ((options == null ? void 0 : options.register) !== false) {
       this.forks.add(fork);
@@ -952,7 +1005,7 @@ const _FlowModel = class _FlowModel {
       throw new Error("FlowEngine is not set on this model. Please set flowEngine before saving.");
     }
     this.observerDispose();
-    this.invalidateAutoFlowCache(true);
+    this.invalidateFlowCache("beforeRender", true);
     return this.flowEngine.removeModel(this.uid);
   }
   async save() {
@@ -969,7 +1022,7 @@ const _FlowModel = class _FlowModel {
       throw new Error("FlowEngine is not set on this model. Please set flowEngine before deleting.");
     }
     this.observerDispose();
-    this.invalidateAutoFlowCache(true);
+    this.invalidateFlowCache("beforeRender", true);
     return this.flowEngine.destroyModel(this.uid);
   }
   /**
@@ -1032,7 +1085,8 @@ const _FlowModel = class _FlowModel {
       uid: this.uid,
       ...import_lodash.default.omit(this._options, ["flowEngine"]),
       stepParams: this.stepParams,
-      sortIndex: this.sortIndex
+      sortIndex: this.sortIndex,
+      flowRegistry: {}
     };
     const subModels = this.subModels;
     for (const subModelKey in subModels) {
@@ -1047,8 +1101,7 @@ const _FlowModel = class _FlowModel {
       }
     }
     for (const [key, flow] of this.flowRegistry.getFlows()) {
-      data["flowRegistry"] = data["flowRegistry"] || {};
-      data["flowRegistry"][key] = flow.toData();
+      data.flowRegistry[key] = flow.toData();
     }
     return data;
   }

package/lib/models/forkFlowModel.d.ts

@@ -31,7 +31,7 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
     /** 是否已被释放 */
     private disposed;
     /** fork 在 master.forks 中的索引 */
-    readonly forkId: number;
+    readonly forkId: string;
     /** 需要与 master 共享的属性列表 */
     private static readonly SHARED_PROPERTIES;
     /**
@@ -48,7 +48,7 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      * 注意：此属性通过 Proxy 在 get/set 陷阱中被动态访问，IDE 可能无法检测到使用, 切勿删除！
      */
     private localProperties;
-    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: number);
+    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: string);
     get context(): FlowModelContext;
     /**
      * 获取对象及其原型链上的属性描述符
@@ -58,14 +58,18 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      * 修改局部 props，仅影响当前 fork
      */
     setProps(key: string | IModelComponentProps, value?: any): void;
+    /**
+     * 清理局部 props，仅影响当前 fork
+     */
+    clearProps(): {};
     /**
      * render 依旧使用 master 的方法，但合并后的 props 需要透传
      */
     render(): any;
     /**
-     * 自动流程缓存的作用域标识（fork 专用）。
+     * 事件缓存的作用域标识（fork 专用）。
      */
-    getAutoFlowCacheScope(): string;
+    getFlowCacheScope(eventName: string): string;
     /**
      * 释放 fork：从 master.forks 中移除自身并断开引用
      */