@nocobase/flow-engine 2.0.0-beta.21 → 2.0.0-beta.23

package/src/components/variables/VariableTag.tsx

@@ -30,65 +30,74 @@ const VariableTagComponent: React.FC<VariableTagProps> = ({
 
   const { data: displayedValue } = useRequest(
     async () => {
-      // 1) 优先使用已解析到的节点（包含完整父标题链）
-      if (metaTreeNode) {
-        return metaTreeNode.parentTitles
-          ? [...metaTreeNode.parentTitles, metaTreeNode.title].map(ctx.t).join('/')
-          : ctx.t(metaTreeNode.title) || '';
-      }
+      const resolveLabelFromPath = async (rawPath?: (string | number)[]): Promise<string | null> => {
+        if (!rawPath) return null;
+        if (!Array.isArray(rawPath)) return null;
+        if (!Array.isArray(resolvedMetaTree)) return null;
 
-      // 2) 无 metaTreeNode 时，尝试从值还原路径，并在 metaTree 中寻找“最深前缀节点”，
-      //    即便最后一段无效，也能显示前缀的翻译标题。
-      if (!value) return String(value);
-      const rawPath = parseValueToPath(value);
-      if (!rawPath || !Array.isArray(resolvedMetaTree)) {
-        return Array.isArray(rawPath) ? rawPath.join('/') : String(value);
-      }
+        // 兼容 metaTree 为子树：顶层不含首段时，裁剪首段
+        const topNames = new Set((resolvedMetaTree || []).map((n: any) => String(n?.name)));
+        const path = !topNames.has(String(rawPath[0])) ? rawPath.slice(1) : rawPath;
+        if (!path.length) return '';
+
+        let nodes: MetaTreeNode[] | undefined = resolvedMetaTree as MetaTreeNode[];
+        const titleChain: string[] = [];
+        let matchedCount = 0;
+
+        for (let i = 0; i < path.length; i++) {
+          if (!nodes) break;
+          const seg = String(path[i]);
+          const node = nodes.find((n) => String(n?.name) === seg) as MetaTreeNode | undefined;
+          if (!node) break; // 停在第一个无效段之前
+
+          titleChain.push(String(node.title ?? node.name ?? seg));
+          matchedCount = i + 1;
 
-      // 兼容 metaTree 为子树：顶层不含首段时，裁剪首段
-      const topNames = new Set((resolvedMetaTree || []).map((n: any) => String(n?.name)));
-      const path = !topNames.has(String(rawPath[0])) ? rawPath.slice(1) : rawPath;
-      if (!path.length) return '';
-
-      let nodes: MetaTreeNode[] | undefined = resolvedMetaTree as MetaTreeNode[];
-      let deepest: MetaTreeNode | null = null;
-      let matchedCount = 0;
-      for (let i = 0; i < path.length; i++) {
-        if (!nodes) break;
-        const seg = String(path[i]);
-        const node = nodes.find((n) => String(n?.name) === seg) as MetaTreeNode | undefined;
-        if (!node) break; // 停在第一个无效段之前
-        deepest = node;
-        matchedCount = i + 1;
-        if (i < path.length - 1) {
-          if (Array.isArray(node.children)) {
-            nodes = node.children as any;
-          } else if (typeof node.children === 'function') {
-            try {
-              const childNodes = await (node.children as any)();
-              (node as any).children = childNodes;
-              nodes = childNodes as any;
-            } catch {
+          if (i < path.length - 1) {
+            if (Array.isArray(node.children)) {
+              nodes = node.children as any;
+            } else if (typeof node.children === 'function') {
+              try {
+                const childNodes = await (node.children as any)();
+                (node as any).children = childNodes;
+                nodes = childNodes as any;
+              } catch {
+                nodes = undefined;
+              }
+            } else {
               nodes = undefined;
             }
-          } else {
-            nodes = undefined;
           }
         }
-      }
 
-      if (deepest) {
-        const titles = deepest.parentTitles ? [...deepest.parentTitles, deepest.title] : [deepest.title];
-        let label = titles.map(ctx.t).join('/');
+        if (matchedCount === 0) return null;
+
+        let label = titleChain.map(ctx.t).join('/');
         if (matchedCount < path.length) {
           const tail = path.slice(matchedCount).join('/');
           label = tail ? `${label}/${tail}` : label;
         }
         return label;
+      };
+
+      // 1) 优先使用已解析到的节点（包含完整父标题链）
+      if (metaTreeNode?.parentTitles) {
+        return [...metaTreeNode.parentTitles, metaTreeNode.title].map(ctx.t).join('/');
       }
 
-      // 3) 完全找不到任何前缀时，退回原始路径字符串
-      return path.join('/');
+      // 2) metaTreeNode 存在但缺少 parentTitles：尝试根据 value/metaTreeNode.paths 从 metaTree 还原完整路径
+      if (metaTreeNode) {
+        const rawPath = parseValueToPath(value) || metaTreeNode.paths;
+        const label = await resolveLabelFromPath(rawPath as any);
+        return label ?? ctx.t(metaTreeNode.title) ?? '';
+      }
+
+      // 3) 无 metaTreeNode：从 value 还原路径并拼接标题链；若找不到任何前缀则回退原始路径字符串
+      if (!value) return String(value);
+      const rawPath = parseValueToPath(value);
+      const label = await resolveLabelFromPath(rawPath as any);
+      if (label != null) return label;
+      return Array.isArray(rawPath) ? rawPath.join('/') : String(value);
     },
     { refreshDeps: [resolvedMetaTree, value, metaTreeNode] },
   );

package/src/components/variables/__tests__/VariableTag.test.tsx

@@ -272,6 +272,56 @@ describe('VariableTag', () => {
     );
   });
 
+  it('should display full path when metaTreeNode has no parentTitles but metaTree is provided', async () => {
+    const metaTree = [
+      {
+        name: 'item',
+        title: 'Current item',
+        type: 'object',
+        paths: ['item'],
+        children: [
+          {
+            name: 'value',
+            title: 'Attributes',
+            type: 'object',
+            paths: ['item', 'value'],
+            children: [
+              {
+                name: 'nickname',
+                title: 'Nickname',
+                type: 'string',
+                paths: ['item', 'value', 'nickname'],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const mockMetaTreeNode = {
+      name: 'nickname',
+      title: 'Nickname',
+      type: 'string',
+      paths: ['item', 'value', 'nickname'],
+      // 没有 parentTitles 属性
+    };
+
+    renderWithCtx(
+      <VariableTag
+        value="{{ ctx.item.value.nickname }}"
+        metaTreeNode={mockMetaTreeNode as any}
+        metaTree={metaTree as any}
+      />,
+    );
+
+    await waitFor(
+      () => {
+        expect(screen.getByText('Current item/Attributes/Nickname')).toBeInTheDocument();
+      },
+      { timeout: 3000 },
+    );
+  });
+
   it('should handle function type metaTree gracefully', async () => {
     const mockMetaTreeFunction = () => [
       {

package/src/data-source/index.ts

@@ -99,7 +99,7 @@ export class DataSource {
   }
 
   get displayName() {
-    return this.options.displayName ? this.flowEngine.translate(this.options.displayName) : this.key;
+    return this.flowEngine.translate(this.options.displayName, { ns: 'lm-collections' }) || this.key;
   }
 
   get key() {
@@ -496,7 +496,7 @@ export class Collection {
     return this.options.storage || 'local';
   }
   get title() {
-    return this.options.title ? this.flowEngine.translate(this.options.title) : this.name;
+    return this.flowEngine.translate(this.options.title, { ns: 'lm-collections' }) || this.name;
   }
 
   get titleCollectionField() {
@@ -769,8 +769,8 @@ export class CollectionField {
   }
 
   get title() {
-    const titleValue = this.options?.uiSchema?.title || this.options?.title || this.options.name;
-    return this.flowEngine.translate(titleValue);
+    const titleValue = this.options?.uiSchema?.title || this.options?.title;
+    return this.flowEngine.translate(titleValue, { ns: 'lm-collections' }) || this.options.name;
   }
 
   set title(value: string) {
@@ -789,11 +789,17 @@ export class CollectionField {
         }
         return {
           ...v,
+          label: v.label ? this.flowEngine.translate(v.label, { ns: 'lm-collections' }) : v.label,
           value: Number(v.value),
         };
       });
     }
-    return options;
+    return options.map((v) => {
+      return {
+        ...v,
+        label: this.flowEngine.translate(v.label, { ns: 'lm-collections' }),
+      };
+    });
   }
 
   get defaultValue() {

package/src/flowContext.ts

@@ -205,7 +205,7 @@ export interface PropertyOptions {
   // - function: 根据子路径决定是否交给服务端（子路径示例：'record.roles[0].name'、'id'、''）
   resolveOnServer?: boolean | ((subPath: string) => boolean);
   // 优化：当需要服务端解析但本属性在 buildVariablesParams 返回空时，是否跳过调用服务端。
-  // - 典型场景：formValues / currentObject 仅在“已选关联值”存在时才需要服务端；否则没有必要请求。
+  // - 典型场景：formValues / item 仅在“已选关联值”存在时才需要服务端；否则没有必要请求。
   // - 默认 false：保持兼容，其他变量即使没有 contextParams 也可选择调用服务端。
   serverOnlyWhenContextParams?: boolean;
 }
@@ -1144,7 +1144,8 @@ export class FlowEngineContext extends BaseFlowEngineContext {
       value: this.engine,
     });
     this.defineProperty('sql', {
-      get: () => new FlowSQLRepository(this),
+      get: (ctx) => new FlowSQLRepository(ctx),
+      cache: false,
     });
     this.defineProperty('dataSourceManager', {
       value: dataSourceManager,
@@ -1471,6 +1472,9 @@ export class FlowEngineContext extends BaseFlowEngineContext {
       const modelClass = getModelClassName(this);
       const Ctor: new (delegate: any) => any = RunJSContextRegistry.resolve(version, modelClass) || FlowRunJSContext;
       const runCtx = new Ctor(this);
+      runCtx.defineMethod('t', (key: string, options?: any) => {
+        return this.t(key, { ns: 'runjs', ...options });
+      });
       const globals: Record<string, any> = { ctx: runCtx, ...(options?.globals || {}) };
       const { timeoutMs } = options || {};
       return new JSRunner({ globals, timeoutMs });

package/src/flowI18n.ts

@@ -33,15 +33,17 @@ export class FlowI18n {
       return keyOrTemplate;
     }
 
-    // 先尝试一次翻译
-    let result = this.translateKey(keyOrTemplate, options);
+    if (options?.compareWith && keyOrTemplate === options.compareWith) {
+      return keyOrTemplate;
+    }
 
     // 检查翻译结果是否包含模板语法，如果有则进行模板编译
-    if (this.isTemplate(result)) {
-      result = this.compileTemplate(result);
+    if (this.isTemplate(keyOrTemplate)) {
+      return this.compileTemplate(keyOrTemplate);
     }
 
-    return result;
+    // 先尝试一次翻译
+    return this.translateKey(keyOrTemplate, options);
   }
 
   /**

package/src/locale/en-US.json

@@ -62,6 +62,7 @@
   "This is likely a NocoBase internals bug. Please open an issue at": "This is likely a NocoBase internals bug. Please open an issue at",
   "This step has no configurable parameters": "This step has no configurable parameters",
   "This variable is not available": "This variable is not available",
+  "Use return to output value": "Use return to output value",
   "Try again": "Try again",
   "Template created": "Template created",
   "Template description": "Template description",
@@ -70,4 +71,4 @@
   "UID copied to clipboard": "UID copied to clipboard",
   "createModelOptions must specify use property": "createModelOptions must specify \"use\" property",
   "here": "here"
-}
+}

package/src/locale/zh-CN.json

@@ -66,6 +66,7 @@
   "This is likely a NocoBase internals bug. Please open an issue at": "这可能是 NocoBase 内部错误。请在以下地址提交问题",
   "This step has no configurable parameters": "此步骤没有可配置的参数",
   "This variable is not available": "此变量不可用",
+  "Use return to output value": "使用 return 返回最终值",
   "Try again": "重试",
   "UID copied to clipboard": "UID 已复制到剪贴板",
   "createModelOptions must specify use property": "createModelOptions 必须指定 \"use\" 属性",

package/src/resources/sqlResource.ts

@@ -27,10 +27,10 @@ type SQLSaveOptions = {
 };
 
 export class FlowSQLRepository {
-  protected ctx: FlowEngineContext;
+  protected ctx: FlowContext;
 
-  constructor(ctx: FlowEngineContext) {
-    this.ctx = new FlowContext() as FlowEngineContext;
+  constructor(ctx: FlowContext) {
+    this.ctx = new FlowContext();
     this.ctx.addDelegate(ctx);
     this.ctx.defineProperty('offset', {
       get: () => 0,

package/src/types.ts

@@ -172,6 +172,18 @@ export interface ActionDefinition<TModel extends FlowModel = FlowModel, TCtx ext
    * - StepDefinition.hideInSettings can override the ActionDefinition value.
    */
   hideInSettings?: boolean | ((ctx: TCtx) => boolean | Promise<boolean>);
+  /**
+   * Whether to disable this step/action in settings menus.
+   * - Supports static boolean and dynamic decision based on runtime context.
+   * - StepDefinition.disabledInSettings can override the ActionDefinition value.
+   */
+  disabledInSettings?: boolean | ((ctx: TCtx) => boolean | Promise<boolean>);
+  /**
+   * Optional reason shown when this step/action is disabled in settings menus.
+   * - Supports static string and dynamic resolver based on runtime context.
+   * - StepDefinition.disabledReasonInSettings can override the ActionDefinition value.
+   */
+  disabledReasonInSettings?: string | ((ctx: TCtx) => string | Promise<string>);
   /**
    * 在执行 Action 前为 ctx 定义临时属性。
    * - 仅支持 PropertyOptions 形态（例如：{ foo: { value: 5 } }）；

package/src/utils/__tests__/runjsValue.test.ts

@@ -0,0 +1,44 @@
+/**
+ * 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, expect, it } from 'vitest';
+import { extractUsedVariablePathsFromRunJS, isRunJSValue, normalizeRunJSValue } from '../runjsValue';
+
+describe('runjsValue utils', () => {
+  it('isRunJSValue: strict shape detection', () => {
+    expect(isRunJSValue({ code: 'return 1' })).toBe(true);
+    expect(isRunJSValue({ code: 'return 1', version: 'v1' })).toBe(true);
+
+    expect(isRunJSValue(null)).toBe(false);
+    expect(isRunJSValue('return 1')).toBe(false);
+    expect(isRunJSValue({})).toBe(false);
+    expect(isRunJSValue({ version: 'v1' })).toBe(false);
+    expect(isRunJSValue({ code: 1 })).toBe(false);
+    expect(isRunJSValue({ code: 'return 1', foo: 1 })).toBe(false);
+    expect(isRunJSValue([])).toBe(false);
+  });
+
+  it('normalizeRunJSValue: defaults version to v1', () => {
+    expect(normalizeRunJSValue({ code: 'return 1' })).toEqual({ code: 'return 1', version: 'v1' });
+    expect(normalizeRunJSValue({ code: 'return 1', version: 'v2' })).toEqual({ code: 'return 1', version: 'v2' });
+  });
+
+  it('extractUsedVariablePathsFromRunJS: extracts ctx usage (dot + bracket root)', () => {
+    const code = `
+      // comment: ctx.ignore.me
+      const x = "ctx.ignore.too";
+      return ctx.formValues.a + ctx.record.id + ctx.someVar + ctx['user'].name;
+    `;
+    const out = extractUsedVariablePathsFromRunJS(code);
+    expect(out.formValues).toContain('a');
+    expect(out.record).toContain('id');
+    expect(out.someVar).toContain('');
+    expect(out.user).toContain('name');
+  });
+});

package/src/utils/__tests__/safeGlobals.test.ts

@@ -28,6 +28,14 @@ describe('safeGlobals', () => {
     expect(win.console).toBeDefined();
     expect(win.foo).toBe(123);
     expect(new win.FormData()).toBeInstanceOf(window.FormData);
+    if (typeof window.Blob !== 'undefined') {
+      expect(typeof win.Blob).toBe('function');
+      expect(new win.Blob(['x'])).toBeInstanceOf(window.Blob);
+    }
+    if (typeof window.URL !== 'undefined') {
+      expect(win.URL).toBe(window.URL);
+      expect(typeof win.URL.createObjectURL).toBe('function');
+    }
     // access to location proxy is allowed, but sensitive props throw
     expect(() => win.location.href).toThrow(/not allowed/);
   });

package/src/utils/__tests__/utils.test.ts

@@ -13,6 +13,7 @@ import {
   isInheritedFrom,
   resolveDefaultParams,
   resolveStepUiSchema,
+  resolveStepDisabledInSettings,
   shouldHideStepInSettings,
   FlowExitException,
   defineAction,
@@ -1117,4 +1118,98 @@ describe('Utils', () => {
       consoleSpy.mockRestore();
     });
   });
+
+  // ==================== resolveStepDisabledInSettings() FUNCTION ====================
+  describe('resolveStepDisabledInSettings()', () => {
+    let mockFlow: any;
+    let mockStep: StepDefinition;
+
+    beforeEach(() => {
+      mockFlow = {
+        key: 'testFlow',
+        title: 'Test Flow',
+        steps: {},
+      };
+
+      mockStep = {
+        key: 'testStep',
+        handler: vi.fn(),
+      };
+    });
+
+    test('returns disabled=false when step is falsy', async () => {
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, null as any);
+      expect(result).toEqual({ disabled: false });
+    });
+
+    test('respects static step.disabledInSettings and disabledReasonInSettings', async () => {
+      mockStep.disabledInSettings = true;
+      mockStep.disabledReasonInSettings = 'legacy reason';
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+      expect(result).toEqual({ disabled: true, reason: 'legacy reason' });
+    });
+
+    test('falls back to action disabled settings when step value is undefined', async () => {
+      const action: ActionDefinition = {
+        name: 'testAction',
+        handler: vi.fn(),
+        disabledInSettings: true,
+        disabledReasonInSettings: 'from action',
+      } as any;
+
+      mockStep.use = 'testAction';
+      mockModel.flowEngine.getAction = vi.fn().mockReturnValue(action);
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+      expect(result).toEqual({ disabled: true, reason: 'from action' });
+    });
+
+    test('prefers step disabled settings over action values', async () => {
+      const action: ActionDefinition = {
+        name: 'testAction',
+        handler: vi.fn(),
+        disabledInSettings: false,
+        disabledReasonInSettings: 'from action',
+      } as any;
+
+      mockStep.use = 'testAction';
+      mockStep.disabledInSettings = true;
+      mockStep.disabledReasonInSettings = 'from step';
+      mockModel.flowEngine.getAction = vi.fn().mockReturnValue(action);
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+      expect(result).toEqual({ disabled: true, reason: 'from step' });
+    });
+
+    test('evaluates function disabled settings with FlowRuntimeContext', async () => {
+      const disabledFn = vi.fn().mockResolvedValue(true);
+      const reasonFn = vi.fn().mockResolvedValue('computed reason');
+      mockStep.disabledInSettings = disabledFn as any;
+      mockStep.disabledReasonInSettings = reasonFn as any;
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+
+      expect(disabledFn).toHaveBeenCalledTimes(1);
+      expect(reasonFn).toHaveBeenCalledTimes(1);
+      const disabledCtx = disabledFn.mock.calls[0][0] as FlowRuntimeContext;
+      const reasonCtx = reasonFn.mock.calls[0][0] as FlowRuntimeContext;
+      expect(disabledCtx).toBeInstanceOf(FlowRuntimeContext);
+      expect(reasonCtx).toBeInstanceOf(FlowRuntimeContext);
+      expect((disabledCtx as any).currentStep).toBeInstanceOf(ContextPathProxy);
+      expect(String((disabledCtx as any).currentStep)).toBe('{{ctx.currentStep}}');
+      expect(result).toEqual({ disabled: true, reason: 'computed reason' });
+    });
+
+    test('returns disabled=false when function disabledInSettings throws', async () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      mockStep.disabledInSettings = vi.fn().mockRejectedValue(new Error('boom')) as any;
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(result).toEqual({ disabled: false });
+      consoleSpy.mockRestore();
+    });
+  });
 });

package/src/utils/associationObjectVariable.ts

@@ -71,7 +71,7 @@ function toFilterByTk(value: unknown, primaryKey: string | string[]) {
 }
 
 /**
- * 创建一个用于“对象类变量”（如 formValues / currentObject）的 `resolveOnServer` 判定函数。
+ * 创建一个用于“对象类变量”（如 formValues / item）的 `resolveOnServer` 判定函数。
  * 仅当访问路径以“关联字段名”开头（且继续访问其子属性）时，返回 true 交由服务端解析；
  * 否则在前端解析即可。
  *
@@ -114,7 +114,7 @@ export function createAssociationSubpathResolver(
  *
  * @param collectionAccessor 获取集合对象，用于字段/元信息来源
  * @param title 变量组标题（用于 UI 展示）
- * @param valueAccessor 获取当前对象值（如 ctx.form.getFieldsValue() / ctx.currentObject）
+ * @param valueAccessor 获取当前对象值（如 ctx.form.getFieldsValue() / ctx.item）
  * @returns PropertyMetaFactory
  */
 export function createAssociationAwareObjectMetaFactory(

package/src/utils/index.ts

@@ -34,7 +34,13 @@ export { isInheritedFrom } from './inheritance';
 export { resolveCreateModelOptions, resolveDefaultParams, resolveExpressions } from './params-resolvers';
 
 // Schema 工具
-export { compileUiSchema, resolveStepUiSchema, resolveUiMode, shouldHideStepInSettings } from './schema-utils';
+export {
+  compileUiSchema,
+  resolveStepUiSchema,
+  resolveStepDisabledInSettings,
+  resolveUiMode,
+  shouldHideStepInSettings,
+} from './schema-utils';
 
 // Runtime Context Steps 设置
 export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
@@ -61,7 +67,19 @@ export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowEr
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
 
 // 安全全局对象（window/document）
-export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
+export {
+  createSafeDocument,
+  createSafeWindow,
+  createSafeNavigator,
+  createSafeRunJSGlobals,
+  runjsWithSafeGlobals,
+} from './safeGlobals';
+
+// RunJS value helpers
+export { isRunJSValue, normalizeRunJSValue, extractUsedVariablePathsFromRunJS, type RunJSValue } from './runjsValue';
+
+// RunJS helpers
+export { resolveRunJSObjectValues } from './resolveRunJSObjectValues';
 
 // RunJS 代码兼容预处理（{{ }}）与 JSX 编译
 export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompat';

package/src/utils/resolveRunJSObjectValues.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { isRunJSValue, normalizeRunJSValue } from './runjsValue';
+import { runjsWithSafeGlobals } from './safeGlobals';
+
+/**
+ * Resolve an object's values, executing any RunJSValue entries via ctx.runjs.
+ *
+ * - Skips `undefined` values
+ * - Skips empty RunJS code (treated as not configured)
+ * - Throws when a RunJS execution fails
+ */
+export async function resolveRunJSObjectValues(ctx: unknown, raw: unknown): Promise<Record<string, any>> {
+  const out: Record<string, any> = {};
+
+  if (!raw || typeof raw !== 'object') return out;
+  if (Array.isArray(raw)) return out;
+
+  for (const [key, value] of Object.entries(raw as Record<string, any>)) {
+    if (typeof value === 'undefined') continue;
+
+    if (isRunJSValue(value)) {
+      const { code, version } = normalizeRunJSValue(value);
+      if (!code.trim()) continue;
+      const ret = await runjsWithSafeGlobals(ctx, code, { version });
+      if (!ret?.success) {
+        throw new Error(`RunJS execution failed for "${key}"`);
+      }
+      if (typeof ret.value !== 'undefined') {
+        out[key] = ret.value;
+      }
+      continue;
+    }
+
+    out[key] = value;
+  }
+
+  return out;
+}