@nocobase/flow-engine 2.0.0-beta.9 → 2.0.1

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,18 +304,101 @@ 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);
+                if (res instanceof import_exceptions.FlowExitAllException) {
+                  throw res;
+                }
+                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;
             }
             results2.push(result);
           } catch (error) {
+            if (error instanceof import_exceptions.FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              break;
+            }
             logger.error(
               { err: error },
               `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`
@@ -266,10 +409,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 +438,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 +452,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

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { ISchema } from '@formily/json-schema';
-import { APIClient } from '@nocobase/sdk';
+import { APIClient, RequestOptions } from '@nocobase/sdk';
 import type { Router } from '@remix-run/router';
 import { MessageInstance } from 'antd/es/message/interface';
 import type { HookAPI } from 'antd/es/modal/useModal';
@@ -25,12 +25,51 @@ import type { ActionDefinition, EventDefinition, ResourceType } from './types';
 import { JSONValue } from './utils/params-resolvers';
 import type { RecordRef } from './utils/serverContextParams';
 import { FlowView, FlowViewer } from './views/FlowView';
+import { type RunJSVersion } from './runjs-context/registry';
 type Getter<T = any> = (ctx: FlowContext) => T | Promise<T>;
+export type FlowContextDocRef = string | {
+    url: string;
+    title?: string;
+};
+export type FlowDeprecationDoc = boolean | {
+    /**
+     * 废弃说明（面向人/大模型）。
+     */
+    message?: string;
+    /**
+     * 推荐替代 API（例如 'ctx.resolveJsonTemplate'）。
+     */
+    replacedBy?: string | string[];
+    /**
+     * 开始废弃的版本号（可选）。
+     */
+    since?: string;
+    /**
+     * 预计移除的版本号（可选）。
+     */
+    removedIn?: string;
+    /**
+     * 参考链接（可选）。
+     */
+    ref?: FlowContextDocRef;
+};
+export type FlowContextDocParam = {
+    name: string;
+    description?: string;
+    type?: string;
+    optional?: boolean;
+    default?: JSONValue;
+};
+export type FlowContextDocReturn = {
+    description?: string;
+    type?: string;
+};
 export interface MetaTreeNode {
     name: string;
     title: string;
     type: string;
     interface?: string;
+    options?: any;
     uiSchema?: ISchema;
     render?: (props: any) => JSX.Element;
     paths: string[];
@@ -44,13 +83,14 @@ export interface PropertyMeta {
     type: string;
     title: string;
     interface?: string;
+    options?: any;
     uiSchema?: ISchema;
     render?: (props: any) => JSX.Element;
     sort?: number;
     properties?: Record<string, PropertyMeta> | (() => Promise<Record<string, PropertyMeta>>);
-    disabled?: boolean | (() => boolean);
-    disabledReason?: string | (() => string | undefined);
-    hidden?: boolean | (() => boolean);
+    disabled?: boolean | (() => boolean | Promise<boolean>);
+    disabledReason?: string | (() => string | undefined | Promise<string | undefined>);
+    hidden?: boolean | (() => boolean | Promise<boolean>);
     buildVariablesParams?: (ctx: FlowContext) => RecordRef | Record<string, any> | Promise<RecordRef | Record<string, any> | undefined> | undefined;
 }
 export type PropertyMetaFactory = {
@@ -73,9 +113,130 @@ export interface PropertyOptions {
     cache?: boolean;
     observable?: boolean;
     meta?: PropertyMetaOrFactory;
+    /**
+     * 面向工具/大模型的静态文档信息（不影响变量选择器 UI）。
+     * - `getApiInfos()` 仅使用 RunJS doc + 这里的 `info`（不会读取/展开 `meta`）
+     * - 变量结构信息请使用 `getVarInfos()`（来源于 `meta`）
+     */
+    info?: FlowContextPropertyInfoOrFactory;
     resolveOnServer?: boolean | ((subPath: string) => boolean);
     serverOnlyWhenContextParams?: boolean;
 }
+export type FlowContextMethodInfoInput = {
+    description?: string;
+    detail?: string;
+    examples?: string[];
+    completion?: RunJSDocCompletionDoc;
+    ref?: FlowContextDocRef;
+    deprecated?: FlowDeprecationDoc;
+    params?: FlowContextDocParam[];
+    returns?: FlowContextDocReturn;
+    hidden?: boolean | ((ctx: any) => boolean | Promise<boolean>);
+    disabled?: boolean | ((ctx: any) => boolean | Promise<boolean>);
+    disabledReason?: string | ((ctx: any) => string | undefined | Promise<string | undefined>);
+};
+export type FlowContextMethodInfo = {
+    description?: string;
+    detail?: string;
+    examples?: string[];
+    completion?: RunJSDocCompletionDoc;
+    ref?: FlowContextDocRef;
+    deprecated?: FlowDeprecationDoc;
+    params?: FlowContextDocParam[];
+    returns?: FlowContextDocReturn;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+export type FlowContextPropertyInfoObjectInput = Omit<FlowContextPropertyInfo, 'disabled' | 'disabledReason' | 'properties'> & {
+    properties?: Record<string, FlowContextPropertyInfoInput> | (() => Promise<Record<string, FlowContextPropertyInfoInput>>);
+    hidden?: RunJSDocHiddenOrPathsDoc;
+    disabled?: boolean | ((ctx: any) => boolean | Promise<boolean>);
+    disabledReason?: string | ((ctx: any) => string | undefined | Promise<string | undefined>);
+};
+export type FlowContextPropertyInfoInput = string | FlowContextPropertyInfoObjectInput;
+export type FlowContextPropertyInfoFactory = {
+    (): FlowContextPropertyInfoInput | Promise<FlowContextPropertyInfoInput | null> | null;
+};
+export type FlowContextPropertyInfoOrFactory = FlowContextPropertyInfoInput | FlowContextPropertyInfoFactory;
+export type FlowContextPropertyInfo = {
+    title?: string;
+    type?: string;
+    interface?: string;
+    description?: string;
+    detail?: string;
+    examples?: string[];
+    completion?: RunJSDocCompletionDoc;
+    ref?: FlowContextDocRef;
+    deprecated?: FlowDeprecationDoc;
+    params?: FlowContextDocParam[];
+    returns?: FlowContextDocReturn;
+    disabled?: boolean;
+    disabledReason?: string;
+    properties?: Record<string, FlowContextPropertyInfo>;
+};
+export type FlowContextApiInfo = {
+    title?: string;
+    type?: string;
+    interface?: string;
+    description?: string;
+    examples?: string[];
+    completion?: RunJSDocCompletionDoc;
+    ref?: FlowContextDocRef;
+    deprecated?: FlowDeprecationDoc;
+    params?: FlowContextDocParam[];
+    returns?: FlowContextDocReturn;
+    disabled?: boolean;
+    disabledReason?: string;
+    properties?: Record<string, FlowContextApiInfo>;
+};
+export type FlowContextInfosEnvNode = {
+    /**
+     * 说明（面向人/大模型）。建议为一句话。
+     */
+    description?: string;
+    /**
+     * 可用于 `await ctx.getVar(getVar)` 的表达式字符串，推荐以 `ctx.` 开头。
+     * 例如：'ctx.popup'、'ctx.resource.collectionName'
+     */
+    getVar?: string;
+    /**
+     * 已解析/可序列化的静态值（用于 prompt 直接使用）。
+     * 注意：应保持小体积，避免放入 record 等大对象。
+     */
+    value?: JSONValue;
+    /**
+     * 子节点（用于表达 popup.resource.xxx 等层级结构）。
+     */
+    properties?: Record<string, FlowContextInfosEnvNode>;
+};
+export type FlowContextInfosEnvs = {
+    popup?: FlowContextInfosEnvNode;
+    block?: FlowContextInfosEnvNode;
+    currentViewBlocks?: FlowContextInfosEnvNode;
+    flowModel?: FlowContextInfosEnvNode;
+    resource?: FlowContextInfosEnvNode;
+    record?: FlowContextInfosEnvNode;
+};
+export type FlowContextGetApiInfosOptions = {
+    /**
+     * RunJS 文档版本（默认 v1）。
+     */
+    version?: RunJSVersion;
+};
+export type FlowContextGetVarInfosOptions = {
+    /**
+     * 最大展开层级（默认 3）。
+     * - 当不传 path 时，top-level property depth=1。
+     * - 当传 path 时，path 对应节点 depth=1。
+     */
+    maxDepth?: number;
+    /**
+     * 剪裁：仅收集指定 path 下的变量结构信息。
+     * - string 形式支持：'record'、'record.id'、'ctx.record'、'{{ ctx.record }}'
+     * - string[] 表示多个剪裁路径合并
+     */
+    path?: string | string[];
+};
 type RouteOptions = {
     name?: string;
     path?: string;
@@ -86,6 +247,7 @@ export declare class FlowContext {
     #private;
     _props: Record<string, PropertyOptions>;
     _methods: Record<string, (...args: any[]) => any>;
+    _methodInfos: Record<string, FlowContextMethodInfoInput>;
     protected _cache: Record<string, any>;
     protected _observableCache: Record<string, any>;
     protected _delegates: FlowContext[];
@@ -95,7 +257,7 @@ export declare class FlowContext {
     createProxy(): FlowContext;
     constructor();
     defineProperty(key: string, options: PropertyOptions): void;
-    defineMethod(name: string, fn: (...args: any[]) => any, des?: string): void;
+    defineMethod(name: string, fn: (...args: any[]) => any, info?: string | FlowContextMethodInfoInput): void;
     removeCache(key: string): boolean;
     delegate(ctx: FlowContext): void;
     addDelegate(ctx: FlowContext): void;
@@ -125,6 +287,26 @@ export declare class FlowContext {
     getPropertyMetaTree(value?: string, options?: {
         flatten?: boolean;
     }): MetaTreeNode[];
+    /**
+     * 获取静态 API 文档信息（仅顶层一层）。
+     *
+     * - 输出仅来自 RunJS doc 与 defineProperty/defineMethod 的 info
+     * - 不读取/展开 PropertyMeta（变量结构）
+     * - 不自动展开深层 properties
+     * - 不返回自动补全字段（例如 completion）
+     */
+    getApiInfos(options?: FlowContextGetApiInfosOptions): Promise<Record<string, FlowContextApiInfo>>;
+    /**
+     * 获取运行时环境快照信息（小体积、可序列化）。
+     */
+    getEnvInfos(): Promise<FlowContextInfosEnvs>;
+    /**
+     * 获取变量结构信息（来源于 PropertyMeta）。
+     *
+     * - 返回静态 plain object（不包含函数）
+     * - 支持 maxDepth（默认 3）与 path 剪裁
+     */
+    getVarInfos(options?: FlowContextGetVarInfosOptions): Promise<Record<string, FlowContextApiInfo>>;
     _getPropertiesMeta(): Record<string, PropertyMetaOrFactory>;
     protected _getOwnProperty(key: string, currentContext: any): any;
     protected _getOwnMethod(key: string, flowContext?: FlowContext): any;
@@ -147,7 +329,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';
     };
@@ -156,6 +338,8 @@ declare class BaseFlowEngineContext extends FlowContext {
      */
     renderJson: (template: JSONValue) => Promise<any>;
     resolveJsonTemplate: (template: JSONValue) => Promise<any>;
+    getVar: (path: string) => Promise<any>;
+    request: (options: RequestOptions) => Promise<any>;
     runjs: (code: string, variables?: Record<string, any>, options?: JSRunnerOptions) => Promise<any>;
     getAction: <TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext>(name: string) => ActionDefinition<TModel, TCtx> | undefined;
     getActions: <TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext>() => Map<string, ActionDefinition<TModel, TCtx>>;
@@ -172,6 +356,7 @@ declare class BaseFlowEngineContext extends FlowContext {
     location: Location;
     sql: FlowSQLRepository;
     logger: pino.Logger;
+    constructor();
 }
 declare class BaseFlowModelContext extends BaseFlowEngineContext {
     model: FlowModel;
@@ -180,7 +365,16 @@ declare class BaseFlowModelContext extends BaseFlowEngineContext {
     getActions: <TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext>() => Map<string, ActionDefinition<TModel, TCtx>>;
     getEvents: <TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext>() => Map<string, EventDefinition<TModel, TCtx>>;
     runAction: (actionName: string, params?: Record<string, any>) => Promise<any> | any;
+    /**
+     * @deprecated use `makeResource` instead
+     */
     createResource: <T extends FlowResource = FlowResource>(resourceType: ResourceType<T>) => T;
+    /**
+     * Create a new resource instance without adding it to the context.
+     * @param resourceType - The resource type.
+     * @returns The resource instance.
+     */
+    makeResource: <T extends FlowResource = FlowResource>(resourceType: ResourceType<T>) => T;
 }
 export declare class FlowEngineContext extends BaseFlowEngineContext {
     engine: FlowEngine;
@@ -204,7 +398,15 @@ export declare class FlowRuntimeContext<TModel extends FlowModel = FlowModel, TM
         result?: any;
     }>;
     stepResults: Record<string, any>;
-    useResource: (className: 'APIResource' | 'SingleRecordResource' | 'MultiRecordResource') => void;
+    /**
+     * @deprecated use `initResource` instead
+     */
+    useResource: (className: 'APIResource' | 'SingleRecordResource' | 'MultiRecordResource' | 'SQLResource') => void;
+    /**
+     * Initialize a resource instance without adding it to the context.
+     * @param className - The resource class name.
+     */
+    initResource: (className: 'APIResource' | 'SingleRecordResource' | 'MultiRecordResource' | 'SQLResource') => void;
     getStepParams: (stepKey: string) => Record<string, any>;
     setStepParams: (stepKey: string, params?: any) => void;
     getStepResults: (stepKey: string) => any;
@@ -219,19 +421,35 @@ export type FlowSettingsContext<TModel extends FlowModel = FlowModel> = FlowRunt
 export type RunJSDocCompletionDoc = {
     insertText?: string;
 };
+export type RunJSDocHiddenDoc = boolean | ((ctx: any) => boolean | Promise<boolean>);
+export type RunJSDocHiddenOrPathsDoc = boolean | string[] | ((ctx: any) => boolean | string[] | Promise<boolean | string[]>);
 export type RunJSDocPropertyDoc = string | {
     description?: string;
     detail?: string;
     type?: string;
     examples?: string[];
     completion?: RunJSDocCompletionDoc;
+    ref?: FlowContextDocRef;
+    deprecated?: FlowDeprecationDoc;
+    params?: FlowContextDocParam[];
+    returns?: FlowContextDocReturn;
     properties?: Record<string, RunJSDocPropertyDoc>;
+    hidden?: RunJSDocHiddenOrPathsDoc;
+    disabled?: boolean | ((ctx: any) => boolean | Promise<boolean>);
+    disabledReason?: string | ((ctx: any) => string | undefined | Promise<string | undefined>);
 };
 export type RunJSDocMethodDoc = string | {
     description?: string;
     detail?: string;
     examples?: string[];
     completion?: RunJSDocCompletionDoc;
+    ref?: FlowContextDocRef;
+    deprecated?: FlowDeprecationDoc;
+    params?: FlowContextDocParam[];
+    returns?: FlowContextDocReturn;
+    hidden?: RunJSDocHiddenDoc;
+    disabled?: boolean | ((ctx: any) => boolean | Promise<boolean>);
+    disabledReason?: string | ((ctx: any) => string | undefined | Promise<string | undefined>);
 };
 export type RunJSDocMeta = {
     label?: string;
@@ -239,8 +457,13 @@ export type RunJSDocMeta = {
     methods?: Record<string, RunJSDocMethodDoc>;
     snippets?: Record<string, any>;
 };
+export declare function createRunJSDeprecationProxy(ctx: any, options?: {
+    doc?: RunJSDocMeta;
+}): any;
 export declare class FlowRunJSContext extends FlowContext {
     constructor(delegate: FlowContext);
+    exit(): void;
+    exitAll(): void;
     static define(meta: RunJSDocMeta, options?: {
         locale?: string;
     }): void;