@nocobase/flow-engine 2.0.0-beta.2 → 2.0.0-beta.20

package/src/components/settings/wrappers/component/__tests__/InlineControls.test.tsx

@@ -0,0 +1,74 @@
+/**
+ * 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 React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@nocobase/test/client';
+import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+
+import { SwitchWithTitle } from '../SwitchWithTitle';
+import { SelectWithTitle } from '../SelectWithTitle';
+
+vi.mock('antd', async (importOriginal) => {
+  const actual = (await importOriginal()) as any;
+  return {
+    ...actual,
+    Select: ({
+      popupMatchSelectWidth,
+      bordered,
+      popupClassName,
+      fieldNames,
+      labelRender,
+      optionRender,
+      dropdownRender,
+      options,
+      ...props
+    }: any) => React.createElement('select', props),
+    Switch: ({ checkedChildren, unCheckedChildren, size, ...props }: any) =>
+      React.createElement('input', { ...props, type: 'checkbox', readOnly: true }),
+  };
+});
+
+describe('Inline controls - stopPropagation', () => {
+  it('SwitchWithTitle click does not bubble to parent', async () => {
+    const engine = new FlowEngine();
+    const parentClick = vi.fn();
+    const onChange = vi.fn();
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <div onClick={parentClick}>
+          <SwitchWithTitle title="Enabled" itemKey="enabled" onChange={onChange} />
+        </div>
+      </FlowEngineProvider>,
+    );
+
+    fireEvent.click(screen.getByText('Enabled'));
+
+    expect(parentClick).not.toHaveBeenCalled();
+    expect(onChange).toHaveBeenCalledWith({ enabled: true });
+  });
+
+  it('SelectWithTitle click does not bubble to parent', async () => {
+    const engine = new FlowEngine();
+    const parentClick = vi.fn();
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <div onClick={parentClick}>
+          <SelectWithTitle title="Mode" itemKey="mode" options={[{ label: 'A', value: 'a' }]} />
+        </div>
+      </FlowEngineProvider>,
+    );
+
+    fireEvent.click(screen.getByText('Mode'));
+
+    expect(parentClick).not.toHaveBeenCalled();
+  });
+});

package/src/components/settings/wrappers/contextual/DefaultSettingsIcon.tsx

@@ -184,6 +184,9 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
   // 当模型发生子模型替换/增删等变化时，强制刷新菜单数据
   const [refreshTick, setRefreshTick] = useState(0);
   const [extraMenuItems, setExtraMenuItems] = useState<FlowModelExtraMenuItem[]>([]);
+  const closeDropdown = useCallback(() => {
+    setVisible(false);
+  }, []);
   const handleOpenChange: DropdownProps['onOpenChange'] = useCallback((nextOpen: boolean, info) => {
     if (info.source === 'trigger' || nextOpen) {
       // 当鼠标快速滑过时，终止菜单的渲染，防止卡顿
@@ -292,6 +295,7 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
   );
 
   const handleDelete = useCallback(() => {
+    closeDropdown();
     Modal.confirm({
       title: t('Confirm delete'),
       icon: <ExclamationCircleOutlined />,
@@ -312,7 +316,7 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
         }
       },
     });
-  }, [model]);
+  }, [closeDropdown, model, t]);
 
   const handleStepConfiguration = useCallback(
     (key: string) => {
@@ -345,6 +349,7 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
       }
 
       try {
+        closeDropdown();
         targetModel.openFlowSettings({
           flowKey,
           stepKey,
@@ -353,7 +358,7 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
         console.log(t('Configuration popup cancelled or error'), ':', error);
       }
     },
-    [model],
+    [closeDropdown, model, t],
   );
 
   const handleMenuClick = useCallback(
@@ -363,18 +368,21 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
       const cleanKey = key.includes('-') && /^(.+)-\d+$/.test(key) ? key.replace(/-\d+$/, '') : key;
 
       if (cleanKey.startsWith('copy-pop-uid:')) {
+        closeDropdown();
         handleCopyPopupUid(cleanKey);
         return;
       }
 
       const extra = extraMenuItems.find((it) => it?.key === originalKey || it?.key === cleanKey);
       if (extra?.onClick) {
+        closeDropdown();
         extra.onClick();
         return;
       }
 
       switch (cleanKey) {
         case 'copy-uid':
+          closeDropdown();
           handleCopyUid();
           break;
         case 'delete':
@@ -385,7 +393,7 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
           break;
       }
     },
-    [handleCopyUid, handleDelete, handleStepConfiguration, handleCopyPopupUid, extraMenuItems],
+    [closeDropdown, handleCopyUid, handleDelete, handleStepConfiguration, handleCopyPopupUid, extraMenuItems],
   );
 
   // 获取单个模型的可配置flows和steps

package/src/components/settings/wrappers/contextual/__tests__/DefaultSettingsIcon.test.tsx

@@ -35,6 +35,7 @@ vi.mock('antd', async (importOriginal) => {
   const Dropdown = (props: any) => {
     (globalThis as any).__lastDropdownMenu = props.menu;
     (globalThis as any).__lastDropdownOnOpenChange = props.onOpenChange;
+    (globalThis as any).__lastDropdownOpen = props.open;
     dropdownMenus.push(props.menu);
     return React.createElement('span', { 'data-testid': 'dropdown' }, props.children);
   };
@@ -98,6 +99,7 @@ describe('DefaultSettingsIcon - only static flows are shown', () => {
     dropdownMenus.length = 0;
     (globalThis as any).__lastDropdownMenu = undefined;
     (globalThis as any).__lastDropdownOnOpenChange = undefined;
+    (globalThis as any).__lastDropdownOpen = undefined;
   });
 
   afterEach(() => {
@@ -265,10 +267,60 @@ describe('DefaultSettingsIcon - only static flows are shown', () => {
       expect((globalThis as any).__lastDropdownMenu).toBeTruthy();
     });
     const menu = (globalThis as any).__lastDropdownMenu;
-    menu.onClick?.({ key: 'flowC:general' });
+    await act(async () => {
+      menu.onClick?.({ key: 'flowC:general' });
+    });
     expect(openSpy).toHaveBeenCalledWith({ flowKey: 'flowC', stepKey: 'general' });
   });
 
+  it('closes dropdown when opening flow settings modal', async () => {
+    class TestFlowModel extends FlowModel {}
+    const engine = new FlowEngine();
+    const model = new TestFlowModel({ uid: 'm-close', flowEngine: engine });
+    vi.spyOn(model, 'openFlowSettings').mockResolvedValue(undefined as any);
+
+    TestFlowModel.registerFlow({
+      key: 'flowClose',
+      title: 'Flow Close',
+      steps: {
+        general: { title: 'General', uiSchema: { f: { type: 'string', 'x-component': 'Input' } } },
+      },
+    });
+
+    render(
+      React.createElement(
+        ConfigProvider as any,
+        null,
+        React.createElement(App as any, null, React.createElement(DefaultSettingsIcon as any, { model })),
+      ),
+    );
+
+    await waitFor(() => {
+      expect((globalThis as any).__lastDropdownMenu).toBeTruthy();
+      expect((globalThis as any).__lastDropdownOnOpenChange).toBeTruthy();
+    });
+
+    // open dropdown
+    await act(async () => {
+      (globalThis as any).__lastDropdownOnOpenChange?.(true, { source: 'trigger' });
+    });
+
+    await waitFor(() => {
+      expect((globalThis as any).__lastDropdownOpen).toBe(true);
+    });
+
+    const menu = (globalThis as any).__lastDropdownMenu;
+
+    // click config item to open modal
+    await act(async () => {
+      menu.onClick?.({ key: 'flowClose:general' });
+    });
+
+    await waitFor(() => {
+      expect((globalThis as any).__lastDropdownOpen).toBe(false);
+    });
+  });
+
   it('copy UID action writes model uid to clipboard', async () => {
     class TestFlowModel extends FlowModel {}
     const engine = new FlowEngine();
@@ -298,7 +350,9 @@ describe('DefaultSettingsIcon - only static flows are shown', () => {
       expect((globalThis as any).__lastDropdownMenu).toBeTruthy();
     });
     const menu = (globalThis as any).__lastDropdownMenu;
-    menu.onClick?.({ key: 'copy-uid' });
+    await act(async () => {
+      menu.onClick?.({ key: 'copy-uid' });
+    });
     expect((navigator as any).clipboard.writeText).toHaveBeenCalledWith('m-copy');
   });
 
@@ -326,7 +380,9 @@ describe('DefaultSettingsIcon - only static flows are shown', () => {
       expect((globalThis as any).__lastDropdownMenu).toBeTruthy();
     });
     const menu = (globalThis as any).__lastDropdownMenu;
-    menu.onClick?.({ key: 'delete' });
+    await act(async () => {
+      menu.onClick?.({ key: 'delete' });
+    });
     expect(destroySpy).toHaveBeenCalled();
   });
 
@@ -556,8 +612,11 @@ describe('DefaultSettingsIcon - extra menu items', () => {
       });
 
       const menu = (globalThis as any).__lastDropdownMenu;
-      menu.onClick?.({ key: 'extra-action' });
+      await act(async () => {
+        menu.onClick?.({ key: 'extra-action' });
+      });
       expect(onClick).toHaveBeenCalled();
+      expect((globalThis as any).__lastDropdownOpen).toBe(false);
     } finally {
       dispose?.();
     }

package/src/components/variables/VariableInput.tsx

@@ -241,12 +241,18 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   const handleVariableSelect = useCallback(
     (variableValue: string, metaTreeNode?: MetaTreeNode) => {
+      if (!metaTreeNode && variableValue === '') {
+        const cleared = clearValue !== undefined ? clearValue : null;
+        setInnerValue(cleared);
+        emitChange(cleared as any);
+        return;
+      }
       setCurrentMetaTreeNode(metaTreeNode);
       const finalValue = resolveValueFromPath?.(metaTreeNode) || variableValue;
       setInnerValue(finalValue);
       emitChange(finalValue, metaTreeNode);
     },
-    [emitChange, resolveValueFromPath],
+    [emitChange, resolveValueFromPath, clearValue],
   );
 
   const { disabled } = restProps;
@@ -286,7 +292,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   const inputProps = useMemo(() => {
     const baseProps = {
-      value: innerValue ?? '',
+      value: ValueComponent === Input ? innerValue ?? '' : innerValue,
       onChange: handleInputChange,
       disabled,
     };

package/src/data-source/index.ts

@@ -486,6 +486,9 @@ export class Collection {
     if (typeof this.filterTargetKey === 'string') {
       return record[this.filterTargetKey];
     }
+    if (Array.isArray(this.filterTargetKey) && this.filterTargetKey.length === 1) {
+      return record[this.filterTargetKey[0]];
+    }
     return _.pick(record, this.filterTargetKey);
   }
 
@@ -815,6 +818,9 @@ export class CollectionField {
         if (typeof v !== 'object') {
           return v;
         }
+        if (v.value === null || v.value === undefined) {
+          return v;
+        }
         return {
           ...v,
           value: Number(v.value),

package/src/executor/FlowExecutor.ts

@@ -17,10 +17,20 @@ import { FlowExitException, resolveDefaultParams } from '../utils';
 import { FlowExitAllException } from '../utils/exceptions';
 import { setupRuntimeContextSteps } from '../utils/setupRuntimeContextSteps';
 import { createEphemeralContext } from '../utils/createEphemeralContext';
+import type { ScheduledCancel } from '../scheduler/ModelOperationScheduler';
 
 export class FlowExecutor {
   constructor(private readonly engine: FlowEngine) {}
 
+  private async emitModelEventIf(
+    eventName: string | undefined,
+    topic: string,
+    payload: Record<string, any>,
+  ): Promise<void> {
+    if (!eventName) return;
+    await this.engine.emitter.emitAsync(`model:event:${eventName}:${topic}`, payload);
+  }
+
   /** Cache wrapper for applyFlow cache lifecycle */
   private async withApplyFlowCache<T>(cacheKey: string | null, executor: () => Promise<T>): Promise<T> {
     if (!cacheKey || !this.engine) return await executor();
@@ -57,7 +67,13 @@ export class FlowExecutor {
   /**
    * Execute a single flow on model.
    */
-  async runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string): Promise<any> {
+  async runFlow(
+    model: FlowModel,
+    flowKey: string,
+    inputArgs?: Record<string, any>,
+    runId?: string,
+    eventName?: string,
+  ): Promise<any> {
     const flow = model.getFlow(flowKey);
 
     if (!flow) {
@@ -99,6 +115,16 @@ export class FlowExecutor {
     setupRuntimeContextSteps(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps as Record<string, { params: any; uiSchema?: any; result?: any }>;
 
+    const flowEventBasePayload = {
+      uid: model.uid,
+      model,
+      runId: flowContext.runId,
+      inputArgs,
+      flowKey,
+    };
+
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:start`, flowEventBasePayload);
+
     for (const [stepKey, step] of Object.entries(stepDefs) as [string, StepDefinition][]) {
       // Resolve handler and params
       let handler: ActionDefinition<FlowModel, FlowRuntimeContext>['handler'] | undefined;
@@ -156,6 +182,11 @@ export class FlowExecutor {
           );
           continue;
         }
+
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:start`, {
+          ...flowEventBasePayload,
+          stepKey,
+        });
         const currentStepResult = handler(runtimeCtx, combinedParams);
         const isAwait = step.isAwait !== false;
         lastResult = isAwait ? await currentStepResult : currentStepResult;
@@ -163,15 +194,47 @@ export class FlowExecutor {
         // Store step result and update context
         stepResults[stepKey] = lastResult;
         stepsRuntime[stepKey].result = stepResults[stepKey];
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+          ...flowEventBasePayload,
+          result: lastResult,
+          stepKey,
+        });
       } catch (error) {
+        if (!(error instanceof FlowExitException) && !(error instanceof FlowExitAllException)) {
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:error`, {
+            ...flowEventBasePayload,
+            error,
+            stepKey,
+          });
+        }
         if (error instanceof FlowExitException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey,
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: stepResults,
+          });
           return Promise.resolve(stepResults);
         }
         if (error instanceof FlowExitAllException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey,
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: error,
+          });
           return Promise.resolve(error);
         }
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:error`, {
+          ...flowEventBasePayload,
+          error,
+        });
         flowContext.logger.error(
           { err: error },
           `BaseModel.applyFlow: Error executing step '${stepKey}' in flow '${flowKey}':`,
@@ -179,11 +242,13 @@ export class FlowExecutor {
         return Promise.reject(error);
       }
     }
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+      ...flowEventBasePayload,
+      result: stepResults,
+    });
     return Promise.resolve(stepResults);
   }
 
-  // runAutoFlows 已移除：统一通过 dispatchEvent('beforeRender') + useCache 控制
-
   /**
    * Dispatch an event to flows bound via flow.on and execute them.
    */
@@ -202,14 +267,15 @@ export class FlowExecutor {
 
     const runId = `${model.uid}-${eventName}-${Date.now()}`;
     const logger = model.context.logger;
+    const eventBasePayload = {
+      uid: model.uid,
+      model,
+      runId,
+      inputArgs,
+    };
 
     try {
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:start`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs,
-      });
+      await this.emitModelEventIf(eventName, 'start', eventBasePayload);
       await model.onDispatchEventStart?.(eventName, options, inputArgs);
     } catch (err) {
       if (isBeforeRender && err instanceof FlowExitException) {
@@ -237,11 +303,25 @@ export class FlowExecutor {
           return false;
         });
 
+    // 路由系统的“重放打开视图”会再次 dispatchEvent('click')，但这不应重复触发用户配置的动态事件流。
+    // 约定：由路由重放触发时，会在 inputArgs 中携带 triggerByRouter: true
+    const isRouterReplayClick = eventName === 'click' && inputArgs?.triggerByRouter === true;
+    const flowsToRun = isRouterReplayClick
+      ? flows.filter((flow) => {
+          const reg = flow['flowRegistry'] as any;
+          const type = reg?.constructor?._type as 'instance' | 'global' | undefined;
+          return type !== 'instance';
+        })
+      : flows;
+
+    // 记录本次 dispatchEvent 内注册的调度任务，用于在结束/错误后兜底清理未触发的任务
+    const scheduledCancels: ScheduledCancel[] = [];
+
     // 组装执行函数（返回值用于缓存；beforeRender 返回 results:any[]，其它返回 true）
     const execute = async () => {
       if (sequential) {
         // 顺序执行：动态流（实例级）优先，其次静态流；各自组内再按 sort 升序，最后保持原始顺序稳定
-        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
         const ordered = flowsWithIndex
           .slice()
           .sort((a, b) => {
@@ -259,12 +339,103 @@ export class FlowExecutor {
           })
           .map((x) => x.f);
         const results: any[] = [];
+
+        // 预处理：当事件流配置了 on.phase 时，将其执行移动到指定节点，并从“立即执行列表”中移除
+        const staticFlowsByKey = new Map(
+          ordered
+            .filter((f) => {
+              const reg = f['flowRegistry'] as any;
+              const type = reg?.constructor?._type as 'instance' | 'global' | undefined;
+              return type !== 'instance';
+            })
+            .map((f) => [f.key, f] as const),
+        );
+        const scheduled = new Set<string>();
+        const scheduleGroups = new Map<string, Array<{ flow: any; order: number }>>();
+        ordered.forEach((flow, indexInOrdered) => {
+          const on = flow.on;
+          const onObj = typeof on === 'object' ? (on as any) : undefined;
+          if (!onObj) return;
+
+          const phase: any = onObj.phase;
+          const flowKey: any = onObj.flowKey;
+          const stepKey: any = onObj.stepKey;
+
+          // 默认：beforeAllFlows（保持现有行为）
+          if (!phase || phase === 'beforeAllFlows') return;
+
+          let whenKey: string | null = null;
+          if (phase === 'afterAllFlows') {
+            whenKey = `event:${eventName}:end`;
+          } else if (phase === 'beforeFlow' || phase === 'afterFlow') {
+            if (!flowKey) {
+              // 配置不完整：降级到“全部静态流之后”
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              if (anchorFlow) {
+                const anchorPhase = phase === 'beforeFlow' ? 'start' : 'end';
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:${anchorPhase}`;
+              } else {
+                // 锚点不存在（flow 被删除或覆盖等）：降级到“全部静态流之后”
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else if (phase === 'beforeStep' || phase === 'afterStep') {
+            if (!flowKey || !stepKey) {
+              // 配置不完整：降级到“全部静态流之后”
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              const anchorStepExists = !!anchorFlow?.hasStep?.(String(stepKey));
+              if (anchorFlow && anchorStepExists) {
+                const anchorPhase = phase === 'beforeStep' ? 'start' : 'end';
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:step:${String(stepKey)}:${anchorPhase}`;
+              } else {
+                // 锚点不存在（flow/step 被删除或覆盖等）：降级到“全部静态流之后”
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else {
+            // 未知 phase：忽略
+            return;
+          }
+
+          if (!whenKey) return;
+          scheduled.add(flow.key);
+          const list = scheduleGroups.get(whenKey) || [];
+          list.push({ flow, order: indexInOrdered });
+          scheduleGroups.set(whenKey, list);
+        });
+
+        // 注册调度（同锚点按 flow.sort 升序；sort 相同保持稳定顺序）
+        for (const [whenKey, list] of scheduleGroups.entries()) {
+          const sorted = list.slice().sort((a, b) => {
+            const sa = a.flow.sort ?? 0;
+            const sb = b.flow.sort ?? 0;
+            if (sa !== sb) return sa - sb;
+            return a.order - b.order;
+          });
+          for (const it of sorted) {
+            const cancel = model.scheduleModelOperation(
+              model.uid,
+              async (m) => {
+                const res = await this.runFlow(m, it.flow.key, inputArgs, runId, eventName);
+                results.push(res);
+              },
+              { when: whenKey as any },
+            );
+            scheduledCancels.push(cancel);
+          }
+        }
+
         for (const flow of ordered) {
+          if (scheduled.has(flow.key)) continue;
           try {
             logger.debug(
               `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`,
             );
-            const result = await this.runFlow(model, flow.key, inputArgs, runId);
+            const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
               break; // 终止后续
@@ -283,10 +454,10 @@ export class FlowExecutor {
 
       // 并行
       const results = await Promise.all(
-        flows.map(async (flow) => {
+        flowsToRun.map(async (flow) => {
           logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
           try {
-            return await this.runFlow(model, flow.key, inputArgs, runId);
+            return await this.runFlow(model, flow.key, inputArgs, runId, eventName);
           } catch (error) {
             logger.error(
               { err: error },
@@ -318,11 +489,8 @@ export 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,
+      await this.emitModelEventIf(eventName, 'end', {
+        ...eventBasePayload,
         result,
       });
       return result;
@@ -337,14 +505,16 @@ export 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,
+      await this.emitModelEventIf(eventName, 'error', {
+        ...eventBasePayload,
         error,
       });
       if (throwOnError) throw error;
+    } finally {
+      // 清理未触发的调度任务，避免跨事件/跨 runId 残留导致意外执行
+      for (const cancel of scheduledCancels) {
+        cancel();
+      }
     }
   }
 }