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

package/src/executor/FlowExecutor.ts

@@ -11,14 +11,49 @@ import _ from 'lodash';
 import { FlowRuntimeContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import type { FlowModel } from '../models';
+import type { DispatchEventOptions } from '../types';
 import type { ActionDefinition, ApplyFlowCacheEntry, StepDefinition } from '../types';
 import { FlowExitException, resolveDefaultParams } from '../utils';
 import { FlowExitAllException } from '../utils/exceptions';
 import { setupRuntimeContextSteps } from '../utils/setupRuntimeContextSteps';
+import { createEphemeralContext } from '../utils/createEphemeralContext';
 
 export class FlowExecutor {
   constructor(private readonly engine: FlowEngine) {}
 
+  /** 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();
+
+    const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
+    if (cachedEntry) {
+      if (cachedEntry.status === 'resolved') return cachedEntry.data as T;
+      if (cachedEntry.status === 'rejected') throw cachedEntry.error;
+      if (cachedEntry.status === 'pending') return await cachedEntry.promise;
+    }
+
+    const promise = executor()
+      .then((result) => {
+        this.engine.applyFlowCache.set(cacheKey, {
+          status: 'resolved',
+          data: result,
+          promise: Promise.resolve(result),
+        } as ApplyFlowCacheEntry);
+        return result;
+      })
+      .catch((err) => {
+        this.engine.applyFlowCache.set(cacheKey, {
+          status: 'rejected',
+          error: err,
+          promise: Promise.reject(err),
+        } as ApplyFlowCacheEntry);
+        throw err;
+      });
+
+    this.engine.applyFlowCache.set(cacheKey, { status: 'pending', promise } as ApplyFlowCacheEntry);
+    return await promise;
+  }
+
   /**
    * Execute a single flow on model.
    */
@@ -46,43 +81,55 @@ export class FlowExecutor {
 
     let lastResult: any;
     const stepResults: Record<string, any> = flowContext.stepResults;
+
+    // Build steps with optional eventStep injection (when flow.on is configured)
     let eventStep = model.getEvent(typeof flow.on === 'string' ? flow.on : (flow.on as any)?.eventName);
     if (eventStep) {
-      eventStep = { ...eventStep }; // clone to avoid side effects
-      eventStep.defaultParams = { ..._.get(flow, 'on.defaultParams', {}), ...eventStep.defaultParams };
+      eventStep = { ...eventStep } as any; // clone to avoid side effects
+      (eventStep as any).defaultParams = {
+        ..._.get(flow, 'on.defaultParams', {}),
+        ...(eventStep as any).defaultParams,
+      };
     }
-    // Execute the event step first since it's usually the trigger condition - if the condition is not met, subsequent steps don't need to execute
-    const stepDefs = eventStep ? { eventStep, ...flow.steps } : flow.steps; // Record<string, StepDefinition>
+    const stepDefs: Record<string, StepDefinition> = eventStep
+      ? { eventStep: eventStep as any, ...flow.steps }
+      : flow.steps;
 
     // Setup steps meta and runtime mapping
     setupRuntimeContextSteps(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps as Record<string, { params: any; uiSchema?: any; result?: any }>;
 
-    for (const stepKey in stepDefs) {
-      if (!Object.prototype.hasOwnProperty.call(stepDefs, stepKey)) continue;
-      const step: StepDefinition = stepDefs[stepKey];
-      let handler: ActionDefinition['handler'] | undefined;
+    for (const [stepKey, step] of Object.entries(stepDefs) as [string, StepDefinition][]) {
+      // Resolve handler and params
+      let handler: ActionDefinition<FlowModel, FlowRuntimeContext>['handler'] | undefined;
       let combinedParams: Record<string, any> = {};
-      let actionDefinition: ActionDefinition | undefined;
       let useRawParams: StepDefinition['useRawParams'] = step.useRawParams;
-
+      let runtimeCtx: FlowRuntimeContext;
       if (step.use) {
-        // Step references a registered action
-        actionDefinition = model.getAction(step.use);
+        const actionDefinition = model.getAction(step.use);
         if (!actionDefinition) {
           flowContext.logger.error(
             `BaseModel.applyFlow: Action '${step.use}' not found for step '${stepKey}' in flow '${flowKey}'. Skipping.`,
           );
           continue;
         }
+
+        // 为当前 step 创建“临时上下文”，并直接注入 action 与 step 提供的定义（step 覆盖 action）
+        runtimeCtx = await createEphemeralContext<FlowRuntimeContext>(flowContext, {
+          ...actionDefinition,
+          ...step,
+        });
+
         handler = step.handler || actionDefinition.handler;
         useRawParams = useRawParams ?? actionDefinition.useRawParams;
-        const actionDefaultParams = await resolveDefaultParams(actionDefinition.defaultParams, flowContext);
-        const stepDefaultParams = await resolveDefaultParams(step.defaultParams, flowContext);
+        const actionDefaultParams = await resolveDefaultParams(actionDefinition.defaultParams, runtimeCtx);
+        const stepDefaultParams = await resolveDefaultParams(step.defaultParams, runtimeCtx);
         combinedParams = { ...actionDefaultParams, ...stepDefaultParams };
       } else if (step.handler) {
+        // 对于内联 handler，为该步创建临时上下文并注入 step 定义
+        runtimeCtx = await createEphemeralContext<FlowRuntimeContext>(flowContext, step);
         handler = step.handler;
-        const stepDefaultParams = await resolveDefaultParams(step.defaultParams, flowContext);
+        const stepDefaultParams = await resolveDefaultParams(step.defaultParams, runtimeCtx);
         combinedParams = { ...stepDefaultParams };
       } else {
         flowContext.logger.error(
@@ -97,12 +144,11 @@ export class FlowExecutor {
       }
       if (typeof useRawParams === 'function') {
         // eslint-disable-next-line react-hooks/rules-of-hooks
-        useRawParams = await useRawParams(flowContext);
+        useRawParams = await useRawParams(runtimeCtx);
       }
       if (!useRawParams) {
-        combinedParams = await flowContext.resolveJsonTemplate(combinedParams);
+        combinedParams = await runtimeCtx.resolveJsonTemplate(combinedParams);
       }
-
       try {
         if (!handler) {
           flowContext.logger.error(
@@ -110,13 +156,12 @@ export class FlowExecutor {
           );
           continue;
         }
-        const currentStepResult = handler(flowContext, combinedParams);
+        const currentStepResult = handler(runtimeCtx, combinedParams);
         const isAwait = step.isAwait !== false;
         lastResult = isAwait ? await currentStepResult : currentStepResult;
 
-        // Store step result
+        // Store step result and update context
         stepResults[stepKey] = lastResult;
-        // update the context
         stepsRuntime[stepKey].result = stepResults[stepKey];
       } catch (error) {
         if (error instanceof FlowExitException) {
@@ -125,7 +170,6 @@ export class FlowExecutor {
         }
         if (error instanceof FlowExitAllException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
-          // 传递特殊控制信号，让上层可中止后续流程
           return Promise.resolve(error);
         }
         flowContext.logger.error(
@@ -138,119 +182,169 @@ export class FlowExecutor {
     return Promise.resolve(stepResults);
   }
 
+  // runAutoFlows 已移除：统一通过 dispatchEvent('beforeRender') + useCache 控制
+
   /**
-   * Execute all auto-apply flows for model.
+   * Dispatch an event to flows bound via flow.on and execute them.
    */
-  async runAutoFlows(model: FlowModel, inputArgs?: Record<string, any>, useCache = true): Promise<any[]> {
-    const autoApplyFlows = model.getAutoFlows();
-
-    if (autoApplyFlows.length === 0) {
-      model.context.logger.warn(`FlowModel: No auto-apply flows found for model '${model.uid}'`);
-      return [];
-    }
+  async dispatchEvent(
+    model: FlowModel,
+    eventName: string,
+    inputArgs?: Record<string, any>,
+    options?: DispatchEventOptions,
+  ): Promise<any> {
+    const isBeforeRender = eventName === 'beforeRender';
+    // 由模型层决定缺省值；执行器仅按显式 options 执行
+    const sequential = !!options?.sequential;
+    const useCache = !!options?.useCache;
+    // beforeRender 特殊处理：出错时一律抛出（用于错误边界捕获）
+    const throwOnError = isBeforeRender;
 
-    const cacheKey = useCache
-      ? FlowEngine.generateApplyFlowCacheKey(model.getAutoFlowCacheScope(), 'all', model.uid)
-      : null;
+    const runId = `${model.uid}-${eventName}-${Date.now()}`;
+    const logger = model.context.logger;
 
-    if (cacheKey && this.engine) {
-      const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
-      if (cachedEntry) {
-        if (cachedEntry.status === 'resolved') {
-          model.context.logger.debug(`[FlowEngine.applyAutoFlows] Using cached result for model: ${model.uid}`);
-          return cachedEntry.data;
-        }
-        if (cachedEntry.status === 'rejected') throw cachedEntry.error;
-        if (cachedEntry.status === 'pending') return await cachedEntry.promise;
+    try {
+      await this.engine.emitter.emitAsync(`model:event:${eventName}:start`, {
+        uid: model.uid,
+        model,
+        runId,
+        inputArgs,
+      });
+      await model.onDispatchEventStart?.(eventName, options, inputArgs);
+    } catch (err) {
+      if (isBeforeRender && err instanceof FlowExitException) {
+        logger.debug(`[FlowModel.dispatchEvent] ${err.message}`);
+        return [];
       }
+      // 进入错误钩子并记录
+      try {
+        await model.onDispatchEventError?.(eventName, options, inputArgs, err as Error);
+      } finally {
+        logger.error({ err }, `BaseModel.dispatchEvent: Start hook error for event '${eventName}'`);
+      }
+      if (throwOnError) throw err;
+      return;
     }
 
-    const executeAutoFlows = async (): Promise<any[]> => {
-      const results: any[] = [];
-      const runId = `${model.uid}-autoFlow-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
-      const logger = model.context.logger.child({ module: 'flow-engine', component: 'FlowExecutor', runId });
-      logger.debug(
-        `[FlowExecutor] runAutoFlows: uid=${model.uid}, isFork=${
-          (model as any)?.isFork === true
-        }, useCache=${useCache}, runId=${runId}, flows=${autoApplyFlows.map((f) => f.key).join(',')}`,
-      );
-      try {
-        if (autoApplyFlows.length === 0) {
-          logger.warn(`FlowModel: No auto-apply flows found for model '${model.uid}'`);
-        } else {
-          for (const flow of autoApplyFlows) {
-            try {
-              logger.debug(`[FlowExecutor] runFlow: uid=${model.uid}, flowKey=${flow.key}`);
-              const result = await this.runFlow(model, flow.key, inputArgs, runId);
-              if (result instanceof FlowExitAllException) {
-                logger.debug(`[FlowEngine.applyAutoFlows] ${result.message}`);
-                break; // 终止后续流程执行
-              }
-              results.push(result);
-            } catch (error) {
-              logger.error({ err: error }, `FlowModel.applyAutoFlows: Error executing auto-apply flow '${flow.key}':`);
-              throw error;
+    // 构造待执行的 flows 列表
+    const flows = isBeforeRender
+      ? model.getEventFlows('beforeRender') // beforeRender 事件集合（兼容未声明 on 且非 manual 的定义）
+      : Array.from(model.getFlows().values()).filter((flow) => {
+          const on = flow.on;
+          if (!on) return false;
+          if (typeof on === 'string') return on === eventName;
+          if (typeof on === 'object') return on.eventName === eventName;
+          return false;
+        });
+
+    // 组装执行函数（返回值用于缓存；beforeRender 返回 results:any[]，其它返回 true）
+    const execute = async () => {
+      if (sequential) {
+        // 顺序执行：动态流（实例级）优先，其次静态流；各自组内再按 sort 升序，最后保持原始顺序稳定
+        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const ordered = flowsWithIndex
+          .slice()
+          .sort((a, b) => {
+            const regA = a.f['flowRegistry'] as any;
+            const regB = b.f['flowRegistry'] as any;
+            const typeA = regA?.constructor?._type as 'instance' | 'global' | undefined;
+            const typeB = regB?.constructor?._type as 'instance' | 'global' | undefined;
+            const groupA = typeA === 'instance' ? 0 : 1; // 实例=0，静态=1
+            const groupB = typeB === 'instance' ? 0 : 1;
+            if (groupA !== groupB) return groupA - groupB;
+            const sa = a.f.sort ?? 0;
+            const sb = b.f.sort ?? 0;
+            if (sa !== sb) return sa - sb;
+            return a.i - b.i; // 稳定排序：保持原有相对顺序
+          })
+          .map((x) => x.f);
+        const results: any[] = [];
+        for (const flow of ordered) {
+          try {
+            logger.debug(
+              `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`,
+            );
+            const result = await this.runFlow(model, flow.key, inputArgs, runId);
+            if (result instanceof FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              break; // 终止后续
             }
+            results.push(result);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`,
+            );
+            throw error;
           }
         }
         return results;
-      } catch (error) {
-        if (error instanceof FlowExitException) {
-          logger.debug(`[FlowEngine.applyAutoFlows] ${error.message}`);
-          return results;
-        }
-        throw error;
       }
+
+      // 并行
+      const results = await Promise.all(
+        flows.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);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`,
+            );
+            if (throwOnError) throw error;
+            return undefined;
+          }
+        }),
+      );
+      return results.filter((x) => x !== undefined);
     };
 
-    if (!cacheKey || !this.engine) {
-      return await executeAutoFlows();
-    }
+    // 缓存键：按事件+scope 统一管理（beforeRender 也使用事件名 beforeRender）
+    const argsKey = useCache ? JSON.stringify(inputArgs ?? {}) : '';
+    const cacheKey = useCache
+      ? FlowEngine.generateApplyFlowCacheKey(
+          `event:${model.getFlowCacheScope(eventName)}:${argsKey}`,
+          eventName,
+          model.uid,
+        )
+      : null;
 
-    const promise = executeAutoFlows()
-      .then((result) => {
-        this.engine.applyFlowCache.set(cacheKey, {
-          status: 'resolved',
-          data: result,
-          promise: Promise.resolve(result),
-        } as ApplyFlowCacheEntry);
-        return result;
-      })
-      .catch((err) => {
-        this.engine.applyFlowCache.set(cacheKey, {
-          status: 'rejected',
-          error: err,
-          promise: Promise.reject(err),
-        } as ApplyFlowCacheEntry);
-        throw err;
+    try {
+      const result = await this.withApplyFlowCache(cacheKey, execute);
+      // 事件结束钩子
+      try {
+        await model.onDispatchEventEnd?.(eventName, options, inputArgs, result);
+      } 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,
       });
-
-    this.engine.applyFlowCache.set(cacheKey, { status: 'pending', promise } as ApplyFlowCacheEntry);
-    return await promise;
-  }
-
-  /**
-   * Dispatch an event to flows bound via flow.on and execute them.
-   */
-  async dispatchEvent(model: FlowModel, eventName: string, inputArgs?: Record<string, any>): Promise<void> {
-    const flows = Array.from(model.getFlows().values()).filter((flow) => {
-      const on = flow.on;
-      if (!on) return false;
-      if (typeof on === 'string') return on === eventName;
-      if (typeof on === 'object') return on.eventName === eventName;
-      return false;
-    });
-    const runId = `${model.uid}-${eventName}-${Date.now()}`;
-    const logger = model.context.logger;
-    const promises = flows.map((flow) => {
-      logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
-      return this.runFlow(model, flow.key, inputArgs, runId).catch((error) => {
-        logger.error(
-          { err: error },
-          `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`,
-        );
+      return result;
+    } catch (error) {
+      // 进入错误钩子并记录
+      try {
+        await model.onDispatchEventError?.(eventName, options, inputArgs, error as Error);
+      } catch (_) {
+        // swallow secondary hook error
+      }
+      model.context.logger.error(
+        { 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,
       });
-    });
-    await Promise.all(promises);
+      if (throwOnError) throw error;
+    }
   }
 }

package/src/executor/__tests__/ctx-defs-injection.test.ts

@@ -0,0 +1,197 @@
+/**
+ * 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 { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models';
+import type { FlowDefinitionOptions, FlowModelOptions } from '../../types';
+
+describe('defineProperties/defineMethods injection', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  it('engine.context.runAction applies defs before defaultParams and handler', async () => {
+    const handler = vi.fn((_ctx, params) => params);
+    engine.registerActions({
+      test: {
+        name: 'test',
+        defineProperties: { foo: { value: 5 } },
+        defineMethods: { add: (x: number) => x + 1 },
+        defaultParams: (ctx) => ({ a: (ctx as any).foo, b: (ctx as any).add(2) }),
+        handler,
+      },
+    });
+
+    const result = await (engine.context as any).runAction('test');
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ a: 5, b: 3 });
+  });
+
+  it('model.context.runAction applies defs before defaultParams and handler', async () => {
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const h = vi.fn((_ctx, params) => ({ ...params, y: (_ctx as any).mul(3) }));
+    M.registerAction({
+      name: 'mAction',
+      defineProperties: async () => ({ al: { value: 7 } }),
+      defineMethods: async () => ({ mul: (x: number) => x * 2 }),
+      defaultParams: (ctx) => ({ a: (ctx as any).al }),
+      handler: h,
+    });
+    const m = engine.createModel<M>({ use: 'M' });
+    const res = await (m.context as any).runAction('mAction', { x: 3 });
+    expect(h).toHaveBeenCalledTimes(1);
+    expect(res).toEqual({ a: 7, x: 3, y: 6 });
+  });
+
+  function createModelWithFlows(uid: string, flows: Record<string, Omit<FlowDefinitionOptions, 'key'>>) {
+    const model = new FlowModel({
+      uid,
+      flowEngine: engine,
+      stepParams: {},
+      subModels: {},
+      flowRegistry: flows,
+    } as FlowModelOptions);
+    return model;
+  }
+
+  it('FlowExecutor: action-based step injects defs before defaultParams/handler', async () => {
+    const stepHandler = vi.fn((_ctx, params) => params);
+    engine.registerActions({
+      act: {
+        name: 'act',
+        defineProperties: { base: { value: 10 } },
+        defineMethods: { inc: (x: number) => x + 1 },
+        handler: stepHandler,
+      },
+    });
+
+    const flows = {
+      f: {
+        steps: {
+          s: {
+            use: 'act',
+            defaultParams: (ctx) => ({ p: (ctx as any).base, q: (ctx as any).inc(4) }),
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const m = createModelWithFlows('m1', flows);
+    const res = await engine.executor.runFlow(m, 'f');
+    expect(stepHandler).toHaveBeenCalledTimes(1);
+    const [, received] = stepHandler.mock.calls[0];
+    expect(received).toEqual({ p: 10, q: 5 });
+    expect(res.s).toEqual({ p: 10, q: 5 });
+  });
+
+  it('FlowExecutor: inline step injects defs before defaultParams/handler', async () => {
+    const stepHandler = vi.fn((_ctx, params) => ({ ...params, v: (_ctx as any).twice(5) }));
+    const flows = {
+      f: {
+        steps: {
+          s: {
+            defineProperties: { k: { value: 8 } },
+            defineMethods: { twice: (x: number) => 2 * x },
+            defaultParams: (ctx) => ({ m: (ctx as any).k }),
+            handler: stepHandler,
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const m = createModelWithFlows('m2', flows);
+    const res = await engine.executor.runFlow(m, 'f');
+    expect(stepHandler).toHaveBeenCalledTimes(1);
+    const [, received] = stepHandler.mock.calls[0];
+    // params 仅包含 defaultParams 合并后的值；v 是 handler 计算的返回值
+    expect(received).toEqual({ m: 8 });
+    expect(res.s).toEqual({ m: 8, v: 10 });
+  });
+
+  it('FlowExecutor: step defs are isolated per step', async () => {
+    const flows = {
+      f: {
+        steps: {
+          a: {
+            defineMethods: { only: (x: number) => x + 1 },
+            handler: (_ctx, _params) => ({ ok: true }),
+          },
+          b: {
+            // 这里期望无法访问到上一步注入的方法，从而抛出错误
+            defaultParams: (ctx) => ({ v: (ctx as any).only(1) }),
+            handler: (_ctx, params) => params,
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const m = createModelWithFlows('m-isolation', flows);
+    const res = await engine.executor.runFlow(m, 'f');
+    // a 正常执行，b 无法访问到 a 注入的方法，defaultParams 出错被 resolveDefaultParams 捕获后为空对象
+    expect(res).toEqual({ a: { ok: true }, b: {} });
+  });
+
+  it('FlowExecutor: step defs override action defs when same key', async () => {
+    const stepHandler = vi.fn((_ctx, params) => params);
+    engine.registerActions({
+      act: {
+        name: 'act',
+        defineProperties: { foo: { value: 1 } },
+        defineMethods: { id: (x: number) => x },
+        handler: stepHandler,
+      },
+    });
+    const flows = {
+      f: {
+        steps: {
+          s: {
+            use: 'act',
+            defineProperties: { foo: { value: 2 } },
+            defineMethods: { id: (x: number) => x + 100 },
+            defaultParams: (ctx) => ({ a: (ctx as any).foo, b: (ctx as any).id(1) }),
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const m = createModelWithFlows('m3', flows);
+    await engine.executor.runFlow(m, 'f');
+    const [, received] = stepHandler.mock.calls[0];
+    expect(received).toEqual({ a: 2, b: 101 });
+  });
+
+  it('FlowExecutor: subsequent defineProperty/defineMethod write to parent context (not scoped)', async () => {
+    const flows = {
+      f: {
+        steps: {
+          a: {
+            handler: (ctx) => {
+              (ctx as any).defineProperty('mark', { value: 7 });
+              (ctx as any).defineMethod('inc', (x: number) => x + 1);
+              return { ok: true };
+            },
+          },
+          b: {
+            // 无注入，直接读取上一步通过 defineProperty/defineMethod 挂在到父级的能力
+            defaultParams: (ctx) => ({ v: (ctx as any).mark, w: (ctx as any).inc(2) }),
+            handler: (_ctx, params) => params,
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const m = engine.createModel<FlowModel>({ use: FlowModel.name, flowRegistry: flows });
+    const res = await engine.executor.runFlow(m, 'f');
+    expect(res).toEqual({ a: { ok: true }, b: { v: 7, w: 3 } });
+  });
+});