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

package/lib/BlockScopedFlowEngine.js

@@ -37,7 +37,6 @@ function createBlockScopedEngine(parent) {
     local.setModelRepository(parent.modelRepository);
   }
   local.context.addDelegate(parent.context);
-  const originalUnlink = local.unlinkFromStack.bind(local);
   local.unlinkFromStack = function() {
     const prev = local._previousEngine;
     const next = local._nextEngine;

package/lib/JSRunner.d.ts

@@ -11,6 +11,12 @@ export interface JSRunnerOptions {
     timeoutMs?: number;
     globals?: Record<string, any>;
     version?: string;
+    /**
+     * Enable RunJS template compatibility preprocessing for `{{ ... }}`.
+     * When enabled via `ctx.runjs(code, vars, { preprocessTemplates: true })` (default),
+     * the code will be rewritten to call `ctx.resolveJsonTemplate(...)` at runtime.
+     */
+    preprocessTemplates?: boolean;
 }
 export declare class JSRunner {
     private globals;

package/lib/JSRunner.js

@@ -62,7 +62,8 @@ const _JSRunner = class _JSRunner {
    * 异步运行代码，带错误处理和超时机制
    */
   async run(code) {
-    if (location == null ? void 0 : location.search.includes("skipRunJs=true")) {
+    const search = typeof location !== "undefined" ? location.search : void 0;
+    if (typeof search === "string" && search.includes("skipRunJs=true")) {
       return { success: true, value: null };
     }
     const wrapped = `(async () => {

package/lib/ViewScopedFlowEngine.js

@@ -31,8 +31,10 @@ __export(ViewScopedFlowEngine_exports, {
 });
 module.exports = __toCommonJS(ViewScopedFlowEngine_exports);
 var import_flowEngine = require("./flowEngine");
+var import_viewEvents = require("./views/viewEvents");
 function createViewScopedEngine(parent) {
   const local = new import_flowEngine.FlowEngine();
+  Object.defineProperty(local, import_viewEvents.ENGINE_SCOPE_KEY, { value: import_viewEvents.VIEW_ENGINE_SCOPE, configurable: true });
   if (parent.modelRepository) {
     local.setModelRepository(parent.modelRepository);
   }
@@ -48,6 +50,7 @@ function createViewScopedEngine(parent) {
     "_applyFlowCache",
     "executor",
     "context",
+    import_viewEvents.ENGINE_SCOPE_KEY,
     "previousEngine",
     "nextEngine",
     // 调度器与事件总线局部化

package/lib/acl/Acl.js

@@ -7,9 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -24,13 +26,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Acl_exports = {};
 __export(Acl_exports, {
   ACL: () => ACL
 });
 module.exports = __toCommonJS(Acl_exports);
-var import_lodash = require("lodash");
+var import_lodash = __toESM(require("lodash"));
 const _ACL = class _ACL {
   constructor(flowEngine) {
     this.flowEngine = flowEngine;
@@ -43,10 +53,10 @@ const _ACL = class _ACL {
   // 记录上一次用于鉴权的 token，用于识别登录态变更
   lastToken = null;
   setData(data) {
-    this.data = data;
+    this.data = import_lodash.default.cloneDeep(data);
   }
   setMeta(data) {
-    this.meta = data;
+    this.meta = import_lodash.default.cloneDeep(data);
   }
   async load() {
     var _a, _b, _c, _d;

package/lib/components/dnd/gridDragPlanner.d.ts

@@ -31,6 +31,7 @@ export interface Point {
 export interface GridLayoutData {
     rows: Record<string, string[][]>;
     sizes: Record<string, number[]>;
+    rowOrder?: string[];
 }
 export interface ColumnSlot {
     type: 'column';

package/lib/components/dnd/gridDragPlanner.js

@@ -59,6 +59,43 @@ const COLUMN_EDGE_MAX_WIDTH = 28;
 const COLUMN_EDGE_WIDTH_RATIO = 0.2;
 const COLUMN_INSERT_THICKNESS_RATIO = 0.5;
 const ROW_GAP_HEIGHT_RATIO = 0.33;
+const deriveRowOrder = /* @__PURE__ */ __name((rows, provided) => {
+  const order = [];
+  const used = /* @__PURE__ */ new Set();
+  (provided || Object.keys(rows)).forEach((rowId) => {
+    if (rows[rowId] && !used.has(rowId)) {
+      order.push(rowId);
+      used.add(rowId);
+    }
+  });
+  Object.keys(rows).forEach((rowId) => {
+    if (!used.has(rowId)) {
+      order.push(rowId);
+      used.add(rowId);
+    }
+  });
+  return order;
+}, "deriveRowOrder");
+const normalizeRowsWithOrder = /* @__PURE__ */ __name((rows, order) => {
+  const next = {};
+  order.forEach((rowId) => {
+    if (rows[rowId]) {
+      next[rowId] = rows[rowId];
+    }
+  });
+  Object.keys(rows).forEach((rowId) => {
+    if (!next[rowId]) {
+      next[rowId] = rows[rowId];
+    }
+  });
+  return next;
+}, "normalizeRowsWithOrder");
+const ensureRowOrder = /* @__PURE__ */ __name((layout) => {
+  const order = deriveRowOrder(layout.rows, layout.rowOrder);
+  layout.rowOrder = order;
+  layout.rows = normalizeRowsWithOrder(layout.rows, order);
+  return order;
+}, "ensureRowOrder");
 const toRect = /* @__PURE__ */ __name((domRect) => ({
   top: domRect.top,
   left: domRect.left,
@@ -330,9 +367,11 @@ const removeItemFromLayout = /* @__PURE__ */ __name((layout, uidValue) => {
   if (columns.length === 0) {
     delete layout.rows[rowId];
     delete layout.sizes[rowId];
+    ensureRowOrder(layout);
     return;
   }
   normalizeRowSizes(rowId, layout);
+  ensureRowOrder(layout);
 }, "removeItemFromLayout");
 const toIntSizes = /* @__PURE__ */ __name((weights, count) => {
   if (count === 0) {
@@ -420,8 +459,10 @@ const simulateLayoutForSlot = /* @__PURE__ */ __name(({
 }) => {
   const cloned = {
     rows: import_lodash.default.cloneDeep(layout.rows),
-    sizes: import_lodash.default.cloneDeep(layout.sizes)
+    sizes: import_lodash.default.cloneDeep(layout.sizes),
+    rowOrder: layout.rowOrder ? [...layout.rowOrder] : void 0
   };
+  ensureRowOrder(cloned);
   removeItemFromLayout(cloned, sourceUid);
   const createRowId = generateRowId ?? import_shared.uid;
   switch (slot.type) {
@@ -464,8 +505,15 @@ const simulateLayoutForSlot = /* @__PURE__ */ __name(({
     case "row-gap": {
       const newRowId = createRowId();
       const rowPosition = slot.position === "above" ? "before" : "after";
+      const currentOrder = deriveRowOrder(cloned.rows, cloned.rowOrder);
       cloned.rows = insertRow(cloned.rows, slot.targetRowId, newRowId, rowPosition, [[sourceUid]]);
       cloned.sizes[newRowId] = [DEFAULT_GRID_COLUMNS];
+      const targetIndex = currentOrder.indexOf(slot.targetRowId);
+      const insertIndex = targetIndex === -1 ? currentOrder.length : rowPosition === "before" ? targetIndex : targetIndex + 1;
+      const nextOrder = [...currentOrder];
+      nextOrder.splice(insertIndex, 0, newRowId);
+      cloned.rowOrder = nextOrder;
+      cloned.rows = normalizeRowsWithOrder(cloned.rows, nextOrder);
       break;
     }
     case "empty-row": {
@@ -475,11 +523,15 @@ const simulateLayoutForSlot = /* @__PURE__ */ __name(({
         [newRowId]: [[sourceUid]]
       };
       cloned.sizes[newRowId] = [DEFAULT_GRID_COLUMNS];
+      const currentOrder = deriveRowOrder(cloned.rows, cloned.rowOrder);
+      cloned.rowOrder = [...currentOrder.filter((id) => id !== newRowId), newRowId];
+      cloned.rows = normalizeRowsWithOrder(cloned.rows, cloned.rowOrder);
       break;
     }
     default:
       break;
   }
+  ensureRowOrder(cloned);
   return cloned;
 }, "simulateLayoutForSlot");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/components/settings/wrappers/component/SwitchWithTitle.js

@@ -73,7 +73,8 @@ const SwitchWithTitle = (0, import_reactive.observer)(
       setChecked(val);
       onChange == null ? void 0 : onChange({ [itemKey]: val });
     }, "handleChange");
-    const handleWrapperClick = /* @__PURE__ */ __name(() => {
+    const handleWrapperClick = /* @__PURE__ */ __name((e) => {
+      e.stopPropagation();
       if (disabled) return;
       handleChange(!checked);
     }, "handleWrapperClick");

package/lib/components/settings/wrappers/contextual/DefaultSettingsIcon.js

@@ -153,6 +153,9 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
   const [visible, setVisible] = (0, import_react.useState)(false);
   const [refreshTick, setRefreshTick] = (0, import_react.useState)(0);
   const [extraMenuItems, setExtraMenuItems] = (0, import_react.useState)([]);
+  const closeDropdown = (0, import_react.useCallback)(() => {
+    setVisible(false);
+  }, []);
   const handleOpenChange = (0, import_react.useCallback)((nextOpen, info) => {
     if (info.source === "trigger" || nextOpen) {
       (0, import_react.startTransition)(() => {
@@ -249,6 +252,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
     [model, copyUidToClipboard]
   );
   const handleDelete = (0, import_react.useCallback)(() => {
+    closeDropdown();
     import_antd.Modal.confirm({
       title: t("Confirm delete"),
       icon: /* @__PURE__ */ import_react.default.createElement(import_icons.ExclamationCircleOutlined, null),
@@ -269,7 +273,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
         }
       }
     });
-  }, [model]);
+  }, [closeDropdown, model, t]);
   const handleStepConfiguration = (0, import_react.useCallback)(
     (key) => {
       const keyParts = key.split(":");
@@ -294,6 +298,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
         [flowKey, stepKey] = keyParts;
       }
       try {
+        closeDropdown();
         targetModel.openFlowSettings({
           flowKey,
           stepKey
@@ -302,23 +307,26 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
         console.log(t("Configuration popup cancelled or error"), ":", error);
       }
     },
-    [model]
+    [closeDropdown, model, t]
   );
   const handleMenuClick = (0, import_react.useCallback)(
     ({ key }) => {
       const originalKey = key;
       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 == null ? void 0 : it.key) === originalKey || (it == null ? void 0 : it.key) === cleanKey);
       if (extra == null ? void 0 : extra.onClick) {
+        closeDropdown();
         extra.onClick();
         return;
       }
       switch (cleanKey) {
         case "copy-uid":
+          closeDropdown();
           handleCopyUid();
           break;
         case "delete":
@@ -329,7 +337,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
           break;
       }
     },
-    [handleCopyUid, handleDelete, handleStepConfiguration, handleCopyPopupUid, extraMenuItems]
+    [closeDropdown, handleCopyUid, handleDelete, handleStepConfiguration, handleCopyPopupUid, extraMenuItems]
   );
   const getModelConfigurableFlowsAndSteps = (0, import_react.useCallback)(
     async (targetModel, modelKey) => {

package/lib/components/variables/VariableInput.js

@@ -230,12 +230,18 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   );
   const handleVariableSelect = (0, import_react.useCallback)(
     (variableValue, metaTreeNode) => {
+      if (!metaTreeNode && variableValue === "") {
+        const cleared = clearValue !== void 0 ? clearValue : null;
+        setInnerValue(cleared);
+        emitChange(cleared);
+        return;
+      }
       setCurrentMetaTreeNode(metaTreeNode);
       const finalValue = (resolveValueFromPath == null ? void 0 : resolveValueFromPath(metaTreeNode)) || variableValue;
       setInnerValue(finalValue);
       emitChange(finalValue, metaTreeNode);
     },
-    [emitChange, resolveValueFromPath]
+    [emitChange, resolveValueFromPath, clearValue]
   );
   const { disabled } = restProps;
   const handleClear = (0, import_react.useCallback)(() => {
@@ -265,7 +271,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   }, [restProps]);
   const inputProps = (0, import_react.useMemo)(() => {
     const baseProps = {
-      value: innerValue ?? "",
+      value: ValueComponent === import_antd.Input ? innerValue ?? "" : innerValue,
       onChange: handleInputChange,
       disabled
     };

package/lib/data-source/index.js

@@ -400,6 +400,9 @@ const _Collection = 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 import_lodash.default.pick(record, this.filterTargetKey);
   }
   get titleableFields() {
@@ -682,6 +685,9 @@ const _CollectionField = class _CollectionField {
         if (typeof v !== "object") {
           return v;
         }
+        if (v.value === null || v.value === void 0) {
+          return v;
+        }
         return {
           ...v,
           value: Number(v.value)

package/lib/executor/FlowExecutor.d.ts

@@ -12,12 +12,13 @@ import type { DispatchEventOptions } from '../types';
 export declare class FlowExecutor {
     private readonly engine;
     constructor(engine: FlowEngine);
+    private emitModelEventIf;
     /** Cache wrapper for applyFlow cache lifecycle */
     private withApplyFlowCache;
     /**
      * Execute a single flow on model.
      */
-    runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string): Promise<any>;
+    runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string, eventName?: string): Promise<any>;
     /**
      * Dispatch an event to flows bound via flow.on and execute them.
      */

package/lib/executor/FlowExecutor.js

@@ -51,6 +51,10 @@ const _FlowExecutor = class _FlowExecutor {
   constructor(engine) {
     this.engine = engine;
   }
+  async emitModelEventIf(eventName, topic, payload) {
+    if (!eventName) return;
+    await this.engine.emitter.emitAsync(`model:event:${eventName}:${topic}`, payload);
+  }
   /** Cache wrapper for applyFlow cache lifecycle */
   async withApplyFlowCache(cacheKey, executor) {
     if (!cacheKey || !this.engine) return await executor();
@@ -81,7 +85,7 @@ const _FlowExecutor = class _FlowExecutor {
   /**
    * Execute a single flow on model.
    */
-  async runFlow(model, flowKey, inputArgs, runId) {
+  async runFlow(model, flowKey, inputArgs, runId, eventName) {
     var _a;
     const flow = model.getFlow(flowKey);
     if (!flow) {
@@ -113,6 +117,14 @@ const _FlowExecutor = class _FlowExecutor {
     const stepDefs = eventStep ? { eventStep, ...flow.steps } : flow.steps;
     (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps;
+    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)) {
       let handler;
       let combinedParams = {};
@@ -163,20 +175,56 @@ const _FlowExecutor = 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;
         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 import_utils.FlowExitException) && !(error instanceof import_exceptions.FlowExitAllException)) {
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:error`, {
+            ...flowEventBasePayload,
+            error,
+            stepKey
+          });
+        }
         if (error instanceof import_utils.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 import_exceptions.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}':`
@@ -184,9 +232,12 @@ const _FlowExecutor = 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.
    */
@@ -198,13 +249,14 @@ const _FlowExecutor = class _FlowExecutor {
     const throwOnError = isBeforeRender;
     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 ((_a = model.onDispatchEventStart) == null ? void 0 : _a.call(model, eventName, options, inputArgs));
     } catch (err) {
       if (isBeforeRender && err instanceof import_utils.FlowExitException) {
@@ -226,9 +278,17 @@ const _FlowExecutor = class _FlowExecutor {
       if (typeof on === "object") return on.eventName === eventName;
       return false;
     });
+    const isRouterReplayClick = eventName === "click" && (inputArgs == null ? void 0 : inputArgs.triggerByRouter) === true;
+    const flowsToRun = isRouterReplayClick ? flows.filter((flow) => {
+      var _a2;
+      const reg = flow["flowRegistry"];
+      const type = (_a2 = reg == null ? void 0 : reg.constructor) == null ? void 0 : _a2._type;
+      return type !== "instance";
+    }) : flows;
+    const scheduledCancels = [];
     const execute = /* @__PURE__ */ __name(async () => {
       if (sequential) {
-        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
         const ordered = flowsWithIndex.slice().sort((a, b) => {
           var _a2, _b2;
           const regA = a.f["flowRegistry"];
@@ -244,12 +304,88 @@ const _FlowExecutor = class _FlowExecutor {
           return a.i - b.i;
         }).map((x) => x.f);
         const results2 = [];
+        const staticFlowsByKey = new Map(
+          ordered.filter((f) => {
+            var _a2;
+            const reg = f["flowRegistry"];
+            const type = (_a2 = reg == null ? void 0 : reg.constructor) == null ? void 0 : _a2._type;
+            return type !== "instance";
+          }).map((f) => [f.key, f])
+        );
+        const scheduled = /* @__PURE__ */ new Set();
+        const scheduleGroups = /* @__PURE__ */ new Map();
+        ordered.forEach((flow, indexInOrdered) => {
+          var _a2;
+          const on = flow.on;
+          const onObj = typeof on === "object" ? on : void 0;
+          if (!onObj) return;
+          const phase = onObj.phase;
+          const flowKey = onObj.flowKey;
+          const stepKey = onObj.stepKey;
+          if (!phase || phase === "beforeAllFlows") return;
+          let whenKey = 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 {
+                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 = !!((_a2 = anchorFlow == null ? void 0 : anchorFlow.hasStep) == null ? void 0 : _a2.call(anchorFlow, String(stepKey)));
+              if (anchorFlow && anchorStepExists) {
+                const anchorPhase = phase === "beforeStep" ? "start" : "end";
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:step:${String(stepKey)}:${anchorPhase}`;
+              } else {
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else {
+            return;
+          }
+          if (!whenKey) return;
+          scheduled.add(flow.key);
+          const list = scheduleGroups.get(whenKey) || [];
+          list.push({ flow, order: indexInOrdered });
+          scheduleGroups.set(whenKey, list);
+        });
+        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);
+                results2.push(res);
+              },
+              { when: whenKey }
+            );
+            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 import_exceptions.FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
               break;
@@ -266,10 +402,10 @@ const _FlowExecutor = class _FlowExecutor {
         return results2;
       }
       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 },
@@ -295,11 +431,8 @@ 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,
+      await this.emitModelEventIf(eventName, "end", {
+        ...eventBasePayload,
         result
       });
       return result;
@@ -312,14 +445,15 @@ 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,
+      await this.emitModelEventIf(eventName, "error", {
+        ...eventBasePayload,
         error
       });
       if (throwOnError) throw error;
+    } finally {
+      for (const cancel of scheduledCancels) {
+        cancel();
+      }
     }
   }
 };

package/lib/flowContext.d.ts

@@ -31,6 +31,7 @@ export interface MetaTreeNode {
     title: string;
     type: string;
     interface?: string;
+    options?: any;
     uiSchema?: ISchema;
     render?: (props: any) => JSX.Element;
     paths: string[];
@@ -44,6 +45,7 @@ export interface PropertyMeta {
     type: string;
     title: string;
     interface?: string;
+    options?: any;
     uiSchema?: ISchema;
     render?: (props: any) => JSX.Element;
     sort?: number;
@@ -147,7 +149,7 @@ declare class BaseFlowEngineContext extends FlowContext {
     dataSourceManager: DataSourceManager;
     requireAsync: (url: string) => Promise<any>;
     importAsync: (url: string) => Promise<any>;
-    createJSRunner: (options?: JSRunnerOptions) => JSRunner;
+    createJSRunner: (options?: JSRunnerOptions) => Promise<JSRunner>;
     pageInfo: {
         version?: 'v1' | 'v2';
     };
@@ -172,6 +174,7 @@ declare class BaseFlowEngineContext extends FlowContext {
     location: Location;
     sql: FlowSQLRepository;
     logger: pino.Logger;
+    constructor();
 }
 declare class BaseFlowModelContext extends BaseFlowEngineContext {
     model: FlowModel;