@nocobase/flow-engine 2.0.0-alpha.34 → 2.0.0-alpha.35

package/lib/ViewScopedFlowEngine.js

@@ -37,6 +37,12 @@ function createViewScopedEngine(parent) {
     local.setModelRepository(parent.modelRepository);
   }
   local.context.addDelegate(parent.context);
+  const originalUnlink = local.unlinkFromStack.bind(local);
+  local.unlinkFromStack = function() {
+    var _a;
+    (_a = local.disposeScheduler) == null ? void 0 : _a.call(local);
+    return originalUnlink();
+  };
   const localOnly = /* @__PURE__ */ new Set([
     "_modelInstances",
     "_applyFlowCache",
@@ -44,6 +50,12 @@ function createViewScopedEngine(parent) {
     "context",
     "previousEngine",
     "nextEngine",
+    // 调度器与事件总线局部化
+    "emitter",
+    "_modelOperationScheduler",
+    "getScheduler",
+    "scheduleModelOperation",
+    "disposeScheduler",
     // 栈指针维护方法需要在本地执行，而非代理到父引擎
     "unlinkFromStack",
     "linkAfter",

package/lib/emitter.d.ts

@@ -13,4 +13,10 @@ export declare class Emitter {
     on(event: string, callback: (...args: any[]) => void): void;
     off(event: string, callback: (...args: any[]) => void): void;
     emit(event: string, ...args: any[]): void;
+    /**
+     * 异步触发事件：按监听器注册顺序依次（串行）等待执行完成。
+     * - 若某个监听器抛错/Promise reject，将中断后续执行并将异常向上传递（便于调用方统一处理）。
+     * - 当前不提供并行触发能力；如需并发处理，请在监听器内部自行管理（例如在回调内使用 Promise.all）。
+     */
+    emitAsync(event: string, ...args: any[]): Promise<void>;
 }

package/lib/emitter.js

@@ -49,6 +49,18 @@ const _Emitter = class _Emitter {
     }
     (this.events[event] || []).forEach((fn) => fn(...args));
   }
+  /**
+   * 异步触发事件：按监听器注册顺序依次（串行）等待执行完成。
+   * - 若某个监听器抛错/Promise reject，将中断后续执行并将异常向上传递（便于调用方统一处理）。
+   * - 当前不提供并行触发能力；如需并发处理，请在监听器内部自行管理（例如在回调内使用 Promise.all）。
+   */
+  async emitAsync(event, ...args) {
+    if (this.paused) return;
+    const listeners = (this.events[event] || []).slice();
+    for (const fn of listeners) {
+      await fn(...args);
+    }
+  }
 };
 __name(_Emitter, "Emitter");
 let Emitter = _Emitter;

package/lib/executor/FlowExecutor.js

@@ -199,6 +199,12 @@ const _FlowExecutor = class _FlowExecutor {
     const runId = `${model.uid}-${eventName}-${Date.now()}`;
     const logger = model.context.logger;
     try {
+      await this.engine.emitter.emitAsync(`model:event:${eventName}:start`, {
+        uid: model.uid,
+        model,
+        runId,
+        inputArgs
+      });
       await ((_a = model.onDispatchEventStart) == null ? void 0 : _a.call(model, eventName, options, inputArgs));
     } catch (err) {
       if (isBeforeRender && err instanceof import_utils.FlowExitException) {
@@ -275,6 +281,13 @@ const _FlowExecutor = class _FlowExecutor {
       } catch (hookErr) {
         logger.error({ err: hookErr }, `BaseModel.dispatchEvent: End hook error for event '${eventName}'`);
       }
+      await this.engine.emitter.emitAsync(`model:event:${eventName}:end`, {
+        uid: model.uid,
+        model,
+        runId,
+        inputArgs,
+        result
+      });
       return result;
     } catch (error) {
       try {
@@ -285,6 +298,13 @@ const _FlowExecutor = class _FlowExecutor {
         { err: error },
         `BaseModel.dispatchEvent: Error executing event '${eventName}' for model '${model.uid}':`
       );
+      await this.engine.emitter.emitAsync(`model:event:${eventName}:error`, {
+        uid: model.uid,
+        model,
+        runId,
+        inputArgs,
+        error
+      });
       if (throwOnError) throw error;
     }
   }

package/lib/flowEngine.d.ts

@@ -5,6 +5,9 @@ import { FlowSettings } from './flowSettings';
 import { FlowModel } from './models';
 import { ReactView } from './ReactView';
 import { FlowResource } from './resources';
+import { Emitter } from './emitter';
+import ModelOperationScheduler from './scheduler/ModelOperationScheduler';
+import type { ScheduleOptions, ScheduledCancel } from './scheduler/ModelOperationScheduler';
 import type { ActionDefinition, ApplyFlowCacheEntry, CreateModelOptions, EventDefinition, FlowModelOptions, IFlowModelRepository, ModelConstructor, PersistOptions, ResourceType } from './types';
 /**
  * FlowEngine is the core class of the flow engine, responsible for managing flow models, actions, model repository, and more.
@@ -81,6 +84,13 @@ export declare class FlowEngine {
     private _previousEngine?;
     private _nextEngine?;
     private _resources;
+    /**
+     * 引擎事件总线（目前用于模型生命周期等事件）。
+     * ViewScopedFlowEngine 持有自己的实例，实现作用域隔离。
+     */
+    emitter: Emitter;
+    /** 调度器：仅在 View 作用域引擎本地启用；根/Block 作用域默认不持有 */
+    private _modelOperationScheduler?;
     logger: pino.Logger;
     /**
      * Flow settings, including components and form scopes.
@@ -102,6 +112,12 @@ export declare class FlowEngine {
      * Constructor. Initializes React view, registers default model and form scopes.
      */
     constructor();
+    /** 获取/创建当前引擎的调度器（仅在本地作用域） */
+    getScheduler(): ModelOperationScheduler;
+    /** 释放并清理当前引擎本地调度器（若存在） */
+    disposeScheduler(): void;
+    /** 在目标模型生命周期达成时执行操作（仅在 View 引擎本地存储计划） */
+    scheduleModelOperation(fromModelOrUid: FlowModel | string, toUid: string, fn: (model: FlowModel) => Promise<void> | void, options?: ScheduleOptions): ScheduledCancel;
     /** 上一个引擎（根引擎为 undefined） */
     get previousEngine(): FlowEngine | undefined;
     /** 下一个引擎（若存在） */

package/lib/flowEngine.js

@@ -59,6 +59,8 @@ var import_flowSettings = require("./flowSettings");
 var import_models = require("./models");
 var import_ReactView = require("./ReactView");
 var import_resources = require("./resources");
+var import_emitter = require("./emitter");
+var import_ModelOperationScheduler = __toESM(require("./scheduler/ModelOperationScheduler"));
 var import_utils = require("./utils");
 var _FlowEngine_instances, registerModel_fn;
 const _FlowEngine = class _FlowEngine {
@@ -118,6 +120,13 @@ const _FlowEngine = class _FlowEngine {
     __publicField(this, "_previousEngine");
     __publicField(this, "_nextEngine");
     __publicField(this, "_resources", /* @__PURE__ */ new Map());
+    /**
+     * 引擎事件总线（目前用于模型生命周期等事件）。
+     * ViewScopedFlowEngine 持有自己的实例，实现作用域隔离。
+     */
+    __publicField(this, "emitter", new import_emitter.Emitter());
+    /** 调度器：仅在 View 作用域引擎本地启用；根/Block 作用域默认不持有 */
+    __publicField(this, "_modelOperationScheduler");
     __publicField(this, "logger");
     /**
      * Flow settings, including components and form scopes.
@@ -161,6 +170,27 @@ const _FlowEngine = class _FlowEngine {
     });
     this.executor = new import_FlowExecutor.FlowExecutor(this);
   }
+  /** 获取/创建当前引擎的调度器（仅在本地作用域） */
+  getScheduler() {
+    if (!this._modelOperationScheduler) {
+      this._modelOperationScheduler = new import_ModelOperationScheduler.default(this);
+    }
+    return this._modelOperationScheduler;
+  }
+  /** 释放并清理当前引擎本地调度器（若存在） */
+  disposeScheduler() {
+    if (this._modelOperationScheduler) {
+      try {
+        this._modelOperationScheduler.dispose();
+      } finally {
+        this._modelOperationScheduler = void 0;
+      }
+    }
+  }
+  /** 在目标模型生命周期达成时执行操作（仅在 View 引擎本地存储计划） */
+  scheduleModelOperation(fromModelOrUid, toUid, fn, options) {
+    return this.getScheduler().schedule(fromModelOrUid, toUid, fn, options);
+  }
   /** 上一个引擎（根引擎为 undefined） */
   get previousEngine() {
     return this._previousEngine;
@@ -384,6 +414,10 @@ const _FlowEngine = class _FlowEngine {
     }
     this._modelInstances.set(modelInstance.uid, modelInstance);
     modelInstance.onInit(options);
+    void this.emitter.emitAsync("model:created", {
+      uid: modelInstance.uid,
+      model: modelInstance
+    });
     this._applyFlowDefinitionDefaultParams(modelInstance).catch((err) => {
       console.warn("FlowEngine: apply flow defaultParams failed:", err);
     });
@@ -485,6 +519,10 @@ const _FlowEngine = class _FlowEngine {
       }
     }
     this._modelInstances.delete(uid);
+    void this.emitter.emitAsync("model:destroyed", {
+      uid,
+      model: modelInstance
+    });
     return true;
   }
   /**

package/lib/models/flowModel.d.ts

@@ -20,6 +20,7 @@ import { FlowDefinition } from '../FlowDefinition';
 import { FlowSettingsOpenOptions } from '../flowSettings';
 import type { EventDefinition, DispatchEventOptions } from '../types';
 import { ForkFlowModel } from './forkFlowModel';
+import type { ScheduleOptions } from '../scheduler/ModelOperationScheduler';
 export declare enum ModelRenderMode {
     ReactElement = "reactElement",
     RenderFunction = "renderFunction"
@@ -91,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;

package/lib/models/flowModel.js

@@ -238,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);
   }
@@ -719,13 +723,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);

package/lib/scheduler/ModelOperationScheduler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowEngine } from '../flowEngine';
+import type { FlowModel } from '../models/flowModel';
+type LifecycleType = 'created' | 'mounted' | 'unmounted' | 'destroyed' | `event:${string}:start` | `event:${string}:end` | `event:${string}:error`;
+export type ScheduleWhen = LifecycleType | ((e: LifecycleEvent) => boolean);
+export interface ScheduleOptions {
+    when?: ScheduleWhen;
+}
+export type ScheduledCancel = () => boolean;
+export interface LifecycleEvent {
+    type: LifecycleType;
+    uid: string;
+    model?: FlowModel;
+    runId?: string;
+    error?: any;
+    inputArgs?: Record<string, any>;
+    result?: any;
+}
+export declare class ModelOperationScheduler {
+    private engine;
+    private itemsByTargetUid;
+    private itemIdsByFromUid;
+    private itemsById;
+    private unbindHandlers;
+    private subscribedEventNames;
+    constructor(engine: FlowEngine);
+    /** 外部调用入口 */
+    schedule(fromModelOrUid: FlowModel | string, toUid: string, fn: (model: FlowModel) => Promise<void> | void, options?: ScheduleOptions): ScheduledCancel;
+    cancel(filter: {
+        fromUid?: string;
+        toUid?: string;
+    }): void;
+    /** 引擎关闭时释放 */
+    dispose(): void;
+    private bindEngineLifecycle;
+    private ensureEventSubscriptionIfNeeded;
+    private parseEventWhen;
+    private processLifecycleEvent;
+    private shouldTrigger;
+    private tryExecuteOnce;
+    private internalCancel;
+    private takeItem;
+}
+export default ModelOperationScheduler;

package/lib/scheduler/ModelOperationScheduler.js

@@ -0,0 +1,262 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ModelOperationScheduler_exports = {};
+__export(ModelOperationScheduler_exports, {
+  ModelOperationScheduler: () => ModelOperationScheduler,
+  default: () => ModelOperationScheduler_default
+});
+module.exports = __toCommonJS(ModelOperationScheduler_exports);
+var import_secure = require("uid/secure");
+const _ModelOperationScheduler = class _ModelOperationScheduler {
+  constructor(engine) {
+    this.engine = engine;
+    this.bindEngineLifecycle();
+  }
+  itemsByTargetUid = /* @__PURE__ */ new Map();
+  itemIdsByFromUid = /* @__PURE__ */ new Map();
+  itemsById = /* @__PURE__ */ new Map();
+  unbindHandlers = [];
+  subscribedEventNames = /* @__PURE__ */ new Set();
+  /** 外部调用入口 */
+  schedule(fromModelOrUid, toUid, fn, options) {
+    const fromUid = typeof fromModelOrUid === "string" ? fromModelOrUid : fromModelOrUid == null ? void 0 : fromModelOrUid.uid;
+    if (!fromUid) {
+      throw new Error("scheduleModelOperation: invalid from model or uid");
+    }
+    if (!toUid || typeof toUid !== "string") {
+      throw new Error("scheduleModelOperation: invalid target uid");
+    }
+    const item = {
+      id: (0, import_secure.uid)(),
+      fromUid,
+      toUid,
+      fn,
+      options: {
+        // 默认语义：仅当 when === 'created' 时，对“已存在的目标”进行一次立即执行；
+        // 其它 when 不做立即执行，需等待后续真实生命周期事件。
+        when: (options == null ? void 0 : options.when) ?? "created"
+      }
+    };
+    let targetMap = this.itemsByTargetUid.get(toUid);
+    if (!targetMap) {
+      targetMap = /* @__PURE__ */ new Map();
+      this.itemsByTargetUid.set(toUid, targetMap);
+    }
+    targetMap.set(item.id, item);
+    let fromSet = this.itemIdsByFromUid.get(fromUid);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      this.itemIdsByFromUid.set(fromUid, fromSet);
+    }
+    fromSet.add(item.id);
+    this.itemsById.set(item.id, item);
+    this.ensureEventSubscriptionIfNeeded(item.options.when);
+    const modelNow = this.engine.getModel(toUid);
+    if (modelNow && item.options.when === "created") {
+      void this.tryExecuteOnce(item.id, { type: "created", uid: toUid, model: modelNow });
+    }
+    return () => this.internalCancel(item.id);
+  }
+  cancel(filter) {
+    const { fromUid, toUid } = filter || {};
+    if (toUid && this.itemsByTargetUid.has(toUid)) {
+      const map = this.itemsByTargetUid.get(toUid);
+      if (map)
+        for (const item of map.values()) {
+          if (fromUid && item.fromUid !== fromUid) continue;
+          this.internalCancel(item.id);
+        }
+      return;
+    }
+    if (fromUid && this.itemIdsByFromUid.has(fromUid)) {
+      const set = this.itemIdsByFromUid.get(fromUid);
+      if (set)
+        for (const id of Array.from(set)) {
+          const it = this.itemsById.get(id);
+          if (!it) continue;
+          if (toUid && it.toUid !== toUid) continue;
+          this.internalCancel(id);
+        }
+    }
+  }
+  /** 引擎关闭时释放 */
+  dispose() {
+    try {
+      for (const unbind of this.unbindHandlers) {
+        try {
+          unbind();
+        } catch (err) {
+        }
+      }
+    } finally {
+      this.unbindHandlers = [];
+    }
+    for (const map of this.itemsByTargetUid.values()) {
+      for (const item of map.values()) this.internalCancel(item.id);
+    }
+    this.itemsByTargetUid.clear();
+    this.itemIdsByFromUid.clear();
+  }
+  bindEngineLifecycle() {
+    const emitter = this.engine.emitter;
+    if (!emitter || typeof emitter.on !== "function") return;
+    const onCreated = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "created" });
+    }, "onCreated");
+    emitter.on("model:created", onCreated);
+    this.unbindHandlers.push(() => emitter.off("model:created", onCreated));
+    const onMounted = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "mounted" });
+    }, "onMounted");
+    emitter.on("model:mounted", onMounted);
+    this.unbindHandlers.push(() => emitter.off("model:mounted", onMounted));
+    const onGenericBeforeStart = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:start" });
+    }, "onGenericBeforeStart");
+    emitter.on("model:event:beforeRender:start", onGenericBeforeStart);
+    this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:start", onGenericBeforeStart));
+    const onGenericBeforeEnd = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:end" });
+    }, "onGenericBeforeEnd");
+    emitter.on("model:event:beforeRender:end", onGenericBeforeEnd);
+    this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:end", onGenericBeforeEnd));
+    const onUnmounted = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "unmounted" });
+    }, "onUnmounted");
+    emitter.on("model:unmounted", onUnmounted);
+    this.unbindHandlers.push(() => emitter.off("model:unmounted", onUnmounted));
+    const onDestroyed = /* @__PURE__ */ __name((e) => {
+      const targetBucket = this.itemsByTargetUid.get(e.uid);
+      const event = { ...e, type: "destroyed" };
+      if (targetBucket && targetBucket.size) {
+        const ids = Array.from(targetBucket.keys());
+        for (const id of ids) {
+          const it = this.itemsById.get(id);
+          if (!it) continue;
+          if (this.shouldTrigger(it.options.when, event)) {
+            void this.tryExecuteOnce(id, event);
+          } else {
+            this.internalCancel(id);
+          }
+        }
+      }
+    }, "onDestroyed");
+    emitter.on("model:destroyed", onDestroyed);
+    this.unbindHandlers.push(() => emitter.off("model:destroyed", onDestroyed));
+  }
+  ensureEventSubscriptionIfNeeded(when) {
+    if (!when || typeof when !== "string") return;
+    const parsed = this.parseEventWhen(when);
+    if (!parsed) return;
+    const { name } = parsed;
+    if (this.subscribedEventNames.has(name)) return;
+    this.subscribedEventNames.add(name);
+    const emitter = this.engine.emitter;
+    const onStart = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` });
+    }, "onStart");
+    const onEnd = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` });
+    }, "onEnd");
+    const onError = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` });
+    }, "onError");
+    emitter.on(`model:event:${name}:start`, onStart);
+    emitter.on(`model:event:${name}:end`, onEnd);
+    emitter.on(`model:event:${name}:error`, onError);
+    this.unbindHandlers.push(() => emitter.off(`model:event:${name}:start`, onStart));
+    this.unbindHandlers.push(() => emitter.off(`model:event:${name}:end`, onEnd));
+    this.unbindHandlers.push(() => emitter.off(`model:event:${name}:error`, onError));
+  }
+  parseEventWhen(when) {
+    if (!when || typeof when !== "string") return null;
+    const m = /^event:([^:]+):(start|end|error)$/.exec(when);
+    if (!m) return null;
+    return { name: m[1], phase: m[2] };
+  }
+  processLifecycleEvent(targetUid, event) {
+    const targetBucket = this.itemsByTargetUid.get(targetUid);
+    if (!targetBucket || targetBucket.size === 0) return;
+    const ids = Array.from(targetBucket.keys());
+    for (const id of ids) {
+      const item = this.itemsById.get(id);
+      if (!item) continue;
+      const should = this.shouldTrigger(item.options.when, event);
+      if (!should) continue;
+      void this.tryExecuteOnce(id, event);
+    }
+  }
+  shouldTrigger(when, event) {
+    if (!when) return false;
+    if (typeof when === "function") return !!when(event);
+    return when === event.type;
+  }
+  async tryExecuteOnce(id, event) {
+    var _a, _b;
+    const item = this.takeItem(id);
+    if (!item) return;
+    try {
+      const model = event.model || this.engine.getModel(item.toUid);
+      if (!model) return;
+      await Promise.resolve(item.fn(model));
+    } catch (err) {
+      (_b = (_a = this.engine.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
+        _a,
+        { err, id, fromUid: item.fromUid, toUid: item.toUid, when: item.options.when },
+        "ModelOperationScheduler: operation execution failed"
+      );
+    }
+  }
+  internalCancel(id) {
+    return !!this.takeItem(id);
+  }
+  takeItem(id) {
+    const it = this.itemsById.get(id);
+    if (!it) return void 0;
+    const { toUid, fromUid } = it;
+    const map = this.itemsByTargetUid.get(toUid);
+    if (map) {
+      map.delete(id);
+      if (map.size === 0) this.itemsByTargetUid.delete(toUid);
+    }
+    const set = this.itemIdsByFromUid.get(fromUid);
+    if (set) {
+      set.delete(id);
+      if (set.size === 0) this.itemIdsByFromUid.delete(fromUid);
+    }
+    this.itemsById.delete(id);
+    return it;
+  }
+};
+__name(_ModelOperationScheduler, "ModelOperationScheduler");
+let ModelOperationScheduler = _ModelOperationScheduler;
+var ModelOperationScheduler_default = ModelOperationScheduler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelOperationScheduler
+});

package/lib/views/DrawerComponent.js

@@ -47,7 +47,7 @@ const DrawerComponent = React.forwardRef((props, ref) => {
   const { children, footer: initialFooter, title, extra, hidden, ...drawerProps } = props;
   const [open, setOpen] = React.useState(true);
   const [footer, setFooter] = React.useState(() => initialFooter);
-  const [header, setHeader] = React.useState({ title, extra });
+  const [header, setHeader] = React.useState({ title, extra, ...drawerProps.header });
   React.useImperativeHandle(
     ref,
     () => ({

package/lib/views/useDrawer.js

@@ -179,7 +179,7 @@ function useDrawer() {
             ref: drawerRef,
             ...config,
             footer: currentFooter,
-            header: currentHeader,
+            header: config.header || currentHeader,
             hidden: (_d = (_c = config.inputArgs) == null ? void 0 : _c.hidden) == null ? void 0 : _d.value,
             afterClose: () => {
               var _a3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.34",
+  "version": "2.0.0-alpha.35",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.0.0-alpha.34",
-    "@nocobase/shared": "2.0.0-alpha.34",
+    "@nocobase/sdk": "2.0.0-alpha.35",
+    "@nocobase/shared": "2.0.0-alpha.35",
     "ahooks": "^3.7.2",
     "dompurify": "^3.0.2",
     "lodash": "^4.x",
@@ -35,5 +35,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "d7bda14bac775be7ef207cb25986511740b2ed70"
+  "gitHead": "e60da9bab9fd4c8ba9457e9806d5428054cefa7a"
 }

package/src/ViewScopedFlowEngine.ts

@@ -29,6 +29,14 @@ export function createViewScopedEngine(parent: FlowEngine): FlowEngine {
   }
   local.context.addDelegate(parent.context);
 
+  // 视图引擎关闭时，主动释放本地调度器以避免残留任务与引用
+  const originalUnlink = local.unlinkFromStack.bind(local);
+  local.unlinkFromStack = function () {
+    // 释放本地调度器与其事件监听，避免残留引用
+    local.disposeScheduler?.();
+    return originalUnlink();
+  };
+
   // 默认全部代理到父引擎，只有少数字段（实例/缓存/执行器/上下文/链表指针）使用本地值
   const localOnly = new Set<keyof FlowEngine | string>([
     '_modelInstances',
@@ -37,6 +45,12 @@ export function createViewScopedEngine(parent: FlowEngine): FlowEngine {
     'context',
     'previousEngine',
     'nextEngine',
+    // 调度器与事件总线局部化
+    'emitter',
+    '_modelOperationScheduler',
+    'getScheduler',
+    'scheduleModelOperation',
+    'disposeScheduler',
     // 栈指针维护方法需要在本地执行，而非代理到父引擎
     'unlinkFromStack',
     'linkAfter',