@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.10

package/src/flow/actions/linkageRules.tsx

@@ -16,13 +16,9 @@ import {
   FlowRuntimeContext,
   useFlowContext,
   useFlowEngine,
-  createSafeWindow,
-  createSafeDocument,
-  createSafeNavigator,
   observer,
   isRunJSValue,
   normalizeRunJSValue,
-  runjsWithSafeGlobals,
 } from '@nocobase/flow-engine';
 import { evaluateConditions, FilterGroupType, removeInvalidFilterItems } from '@nocobase/utils/client';
 import React from 'react';
@@ -40,7 +36,7 @@ import { FilterGroup } from '../components/filter/FilterGroup';
 import { LinkageFilterItem } from '../components/filter';
 import { CodeEditor } from '../components/code-editor';
 import { FieldAssignRulesEditor } from '../components/FieldAssignRulesEditor';
-import type { FieldAssignRuleItem } from '../components/FieldAssignRulesEditor';
+import type { AssignMode, FieldAssignRuleItem } from '../components/FieldAssignRulesEditor';
 import { collectFieldAssignCascaderOptions } from '../components/fieldAssignOptions';
 import { useAssociationTitleFieldSync } from '../components/useAssociationTitleFieldSync';
 import _ from 'lodash';
@@ -492,7 +488,7 @@ async function resolveLinkageAssignRuntimeValue(ctx: FlowContext, rawValue: any)
 
   try {
     const { code, version } = normalizeRunJSValue(rawValue);
-    const ret = await runjsWithSafeGlobals(ctx, code, { version });
+    const ret = await ctx.runjs(code, undefined, { version });
     if (!ret?.success) {
       return SKIP_RUNJS_ASSIGN_VALUE;
     }
@@ -735,6 +731,41 @@ export const linkageSetMenuItemProps = defineAction({
   },
 });
 
+export const linkageSetTabProps = defineAction({
+  name: 'linkageSetTabProps',
+  title: tExpr('Set tab state'),
+  scene: ActionScene.TAB_LINKAGE_RULES,
+  sort: 100,
+  uiSchema: {
+    value: {
+      type: 'string',
+      'x-component': (props) => {
+        const { value, onChange } = props;
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const ctx = useFlowContext();
+        const t = ctx.model.translate.bind(ctx.model);
+
+        return (
+          <Select
+            value={value}
+            onChange={onChange}
+            placeholder={t('Please select state')}
+            style={{ width: '100%' }}
+            options={[
+              { label: t('Visible'), value: 'visible' },
+              { label: t('Hidden'), value: 'hidden' },
+            ]}
+            allowClear
+          />
+        );
+      },
+    },
+  },
+  handler(ctx, { value, setProps }) {
+    setProps(ctx.model, { hiddenModel: value === 'hidden' });
+  },
+});
+
 export const linkageSetFieldProps = defineAction({
   name: 'linkageSetFieldProps',
   title: tExpr('Set field state'),
@@ -888,6 +919,20 @@ type ArrayFieldComponentProps = {
 
 const LEGACY_ASSIGN_RULE = { mode: 'assign', valueKey: 'assignValue' } as const;
 const LEGACY_DEFAULT_RULE = { mode: 'default', valueKey: 'initialValue' } as const;
+const LINKAGE_ASSIGN_MODE_PROP = '__linkageAssignMode';
+
+function normalizeLinkageAssignMode(mode: unknown): AssignMode {
+  if (mode === 'default') return 'default';
+  if (mode === 'override') return 'override';
+  return 'assign';
+}
+
+type LinkageValuePatch = {
+  path: Array<string | number>;
+  value: unknown;
+  whenEmpty?: boolean;
+  mode?: AssignMode;
+};
 
 const FieldAssignRulesActionComponent: React.FC<
   ArrayFieldComponentProps & {
@@ -1002,16 +1047,24 @@ export const linkageAssignField = defineAction({
           continue;
         }
 
-        const mode = it?.mode === 'default' ? 'default' : 'assign';
+        const mode = normalizeLinkageAssignMode(it?.mode);
         if (fieldModel) {
           if (mode === 'default') {
             setProps(fieldModel as FlowModel, { initialValue: finalValue });
           } else {
-            setProps(fieldModel as FlowModel, { value: finalValue });
+            setProps(fieldModel as FlowModel, {
+              value: finalValue,
+              ...(mode === 'override' ? { [LINKAGE_ASSIGN_MODE_PROP]: mode } : {}),
+            });
           }
         } else if (typeof addFormValuePatch === 'function') {
           // 对关联字段子属性（如 user.name）等没有独立 FormItemModel 的目标，直接写入表单值
-          addFormValuePatch({ path: targetPath, value: finalValue, whenEmpty: mode === 'default' });
+          addFormValuePatch({
+            path: targetPath,
+            value: finalValue,
+            whenEmpty: mode === 'default',
+            ...(mode === 'override' ? { mode } : {}),
+          });
         }
       }
     } catch (error) {
@@ -1177,7 +1230,7 @@ export const subFormLinkageAssignField = defineAction({
           continue;
         }
 
-        const mode = it?.mode === 'default' ? 'default' : 'assign';
+        const mode = normalizeLinkageAssignMode(it?.mode);
         const actionName = (ctx.model as any)?.getAclActionName?.() ?? (ctx.model as any)?.context?.actionName;
         const isEditForm = actionName === 'update';
         const isNewItem = (ctx as any)?.item?.__is_new__ === true;
@@ -1207,12 +1260,21 @@ export const subFormLinkageAssignField = defineAction({
           continue;
         }
 
+        if (mode === 'override' && hasExplicitPathHit(targetPath)) {
+          continue;
+        }
+
         if (!fieldUid) {
           if (mode === 'default' && hasExplicitPathHit(targetPath)) {
             continue;
           }
           if (typeof addFormValuePatch === 'function') {
-            addFormValuePatch({ path: targetPath, value: finalValue, whenEmpty: mode === 'default' });
+            addFormValuePatch({
+              path: targetPath,
+              value: finalValue,
+              whenEmpty: mode === 'default',
+              ...(mode === 'override' ? { mode } : {}),
+            });
           }
           continue;
         }
@@ -1223,7 +1285,10 @@ export const subFormLinkageAssignField = defineAction({
         if (mode === 'default') {
           setProps(model, { initialValue: finalValue });
         } else {
-          setProps(model, { value: finalValue });
+          setProps(model, {
+            value: finalValue,
+            ...(mode === 'override' ? { [LINKAGE_ASSIGN_MODE_PROP]: mode } : {}),
+          });
         }
       }
     } catch (error) {
@@ -1309,6 +1374,7 @@ export const linkageRunjs = defineAction({
     ActionScene.FIELD_LINKAGE_RULES,
     ActionScene.ACTION_LINKAGE_RULES,
     ActionScene.MENU_LINKAGE_RULES,
+    ActionScene.TAB_LINKAGE_RULES,
     ActionScene.DETAILS_FIELD_LINKAGE_RULES,
     ActionScene.SUB_FORM_FIELD_LINKAGE_RULES,
   ],
@@ -1363,8 +1429,7 @@ export const linkageRunjs = defineAction({
     }
 
     try {
-      const navigator = createSafeNavigator();
-      await ctx.runjs(script, { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator });
+      await ctx.runjs(script);
     } catch (error) {
       console.error('Script execution error:', error);
       // 可以选择显示错误信息给用户
@@ -1781,7 +1846,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const modelsToApply = new Set<FlowModel>(allModels);
   const patchPropsByModel = new Map<FlowModel, any>();
   const clearValueOnHiddenModelUids = new Set<string>();
-  const directValuePatches: Array<{ path: Array<string | number>; value: any; whenEmpty?: boolean }> = [];
+  const directValuePatches: LinkageValuePatch[] = [];
   const rootCollection = getCollectionFromModel((ctx.model as any)?.context?.blockModel ?? ctx.model);
   const isSafeToWriteAssociationSubpath = (namePath: any): boolean => {
     if (!Array.isArray(namePath) || !namePath.length) return true;
@@ -1836,13 +1901,18 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     }
 
     for (const patch of lastPatchByPathKey.values()) {
-      if (!patch.whenEmpty) continue;
+      if (!patch.whenEmpty && patch.mode !== 'default') continue;
       runtime.recordDefaultValuePatch(patch.path, patch.value);
     }
   };
-  const addFormValuePatch = (patch: { path: any; value: any; whenEmpty?: boolean }) => {
+  const getPatchMode = (patch: { mode?: unknown; whenEmpty?: boolean }): AssignMode => {
+    if (patch?.mode === 'default') return 'default';
+    if (patch?.mode === 'override') return 'override';
+    return patch?.whenEmpty ? 'default' : 'assign';
+  };
+  const addFormValuePatch = (patch: { path: unknown; value: unknown; whenEmpty?: boolean; mode?: AssignMode }) => {
     if (!patch) return;
-    const path = (patch as any)?.path;
+    const path = patch.path;
     if (!path) return;
     const resolvedPath = resolveNamePathForPatch(path);
     if (!resolvedPath) {
@@ -1862,8 +1932,9 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       });
       return;
     }
-    const whenEmpty = !!(patch as any)?.whenEmpty;
-    const value = (patch as any)?.value;
+    const mode = getPatchMode(patch);
+    const whenEmpty = mode === 'default';
+    const value = patch.value;
     try {
       const form = ctx.model?.context?.form;
       const current = form?.getFieldValue?.(resolvedPath);
@@ -1878,6 +1949,15 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           return;
         }
       }
+      if (mode === 'override') {
+        const runtime = getDefaultPatchRuntime();
+        if (
+          typeof runtime?.canApplyOverrideValuePatch === 'function' &&
+          !runtime.canApplyOverrideValuePatch(resolvedPath)
+        ) {
+          return;
+        }
+      }
       if (_.isEqual(current, value)) {
         return;
       }
@@ -1889,6 +1969,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       path: resolvedPath,
       value,
       ...(whenEmpty ? { whenEmpty: true } : {}),
+      ...(mode === 'override' ? { mode } : {}),
     });
   };
   const removePendingFormValuePatches = (path: any) => {
@@ -1948,6 +2029,21 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     >;
     return normalized.length ? normalized : null;
   };
+  const pathKeysEqual = (
+    a: Array<string | number> | null | undefined,
+    b: Array<string | number> | null | undefined,
+  ) => {
+    if (!a || !b) return false;
+    return namePathToPathKey(a) === namePathToPathKey(b);
+  };
+  const namePathEndsWith = (
+    namePath: Array<string | number> | null | undefined,
+    suffix: Array<string | number> | null | undefined,
+  ) => {
+    if (!namePath || !suffix || suffix.length > namePath.length) return false;
+    const offset = namePath.length - suffix.length;
+    return suffix.every((seg, index) => namePath[offset + index] === seg);
+  };
   const getFieldIndexEntries = (fieldIndex: any): Array<{ name: string; index: number }> => {
     if (!Array.isArray(fieldIndex)) return [];
     return fieldIndex
@@ -1996,17 +2092,35 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     return out;
   };
+  const getTrustedFieldPathArray = (
+    fieldPathArray: Array<string | number> | null,
+    targetPath: string | null,
+    fieldIndex: unknown,
+  ): Array<string | number> | null => {
+    if (!fieldPathArray || !targetPath) return null;
+
+    const targetNamePath = normalizeNamePathForKey(
+      parsePathString(targetPath).filter((seg) => typeof seg === 'string' || typeof seg === 'number'),
+    );
+    const resolvedTargetPath = normalizeNamePathForKey(resolveDynamicNamePath(targetPath, fieldIndex));
+    const indexedRelativePath = resolveIndexedRelativePath(targetPath, fieldIndex);
+
+    if (
+      pathKeysEqual(fieldPathArray, resolvedTargetPath) ||
+      pathKeysEqual(fieldPathArray, indexedRelativePath) ||
+      namePathEndsWith(fieldPathArray, targetNamePath)
+    ) {
+      return fieldPathArray;
+    }
+
+    return null;
+  };
   const getModelTargetPathForHiddenClear = (model: any): string | Array<string | number> | null => {
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
     const targetPath = getModelTargetPathForPatch(model);
-    if (fieldPathArray) {
-      const targetPathLastString = targetPath
-        ? ([...parsePathString(targetPath)].reverse().find((seg) => typeof seg === 'string') as string | undefined)
-        : undefined;
-      const fieldPathArrayLastString = [...fieldPathArray].reverse().find((seg) => typeof seg === 'string');
-      if (!targetPathLastString || targetPathLastString === fieldPathArrayLastString) {
-        return fieldPathArray;
-      }
+    const trustedFieldPathArray = getTrustedFieldPathArray(fieldPathArray, targetPath, model?.context?.fieldIndex);
+    if (trustedFieldPathArray) {
+      return trustedFieldPathArray;
     }
 
     if (!targetPath) return null;
@@ -2016,12 +2130,13 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const getModelTargetPathKeys = (model: any): Set<string> => {
     const keys = new Set<string>();
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
-    if (fieldPathArray) {
-      keys.add(namePathToPathKey(fieldPathArray));
+    const targetPath = getModelTargetPathForPatch(model);
+    const trustedFieldPathArray = getTrustedFieldPathArray(fieldPathArray, targetPath, model?.context?.fieldIndex);
+    if (trustedFieldPathArray) {
+      keys.add(namePathToPathKey(trustedFieldPathArray));
       return keys;
     }
 
-    const targetPath = getModelTargetPathForPatch(model);
     if (targetPath) {
       const fieldIndexEntries = getFieldIndexEntries(model?.context?.fieldIndex);
       if (!fieldIndexEntries.length) {
@@ -2082,22 +2197,43 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     for (const action of actions) {
       const setProps = (model: FlowModel & { __originalProps?: any; __shouldReset?: boolean }, props: any) => {
-        // 存储原始值，用于恢复
-        if (!model.__originalProps) {
-          model.__originalProps = {
-            hiddenModel: model.hidden,
-            hiddenText: undefined,
-            disabled: undefined,
-            required: undefined,
-            hidden: undefined,
-            ...model.props,
-          };
-        }
+        const normalizedProps =
+          props && typeof props === 'object' && Object.prototype.hasOwnProperty.call(props, 'value')
+            ? {
+                ...props,
+                [LINKAGE_ASSIGN_MODE_PROP]: normalizeLinkageAssignMode(props?.[LINKAGE_ASSIGN_MODE_PROP]),
+              }
+            : props;
+
+        // 只记录联动实际控制的属性，避免之后恢复状态时把标题、路由等无关的新配置回滚到旧快照。
+        const originalProps = model.__originalProps || (model.__originalProps = {});
+        const rememberOriginalProp = (key: string, value: unknown) => {
+          if (!Object.prototype.hasOwnProperty.call(originalProps, key)) {
+            originalProps[key] = value;
+          }
+        };
+        Object.keys(normalizedProps || {}).forEach((key) => {
+          if (key === 'hiddenModel') {
+            rememberOriginalProp(
+              key,
+              Object.prototype.hasOwnProperty.call(model.props || {}, key) ? model.props?.[key] : model.hidden,
+            );
+            return;
+          }
+
+          rememberOriginalProp(key, model.props?.[key]);
+          if (key === 'hiddenText' && normalizedProps[key]) {
+            rememberOriginalProp('title', model.props?.title);
+          }
+          if (key === 'required') {
+            rememberOriginalProp('rules', model.props?.rules);
+          }
+        });
 
         // 临时存起来，遍历完所有规则后，再统一处理
         patchPropsByModel.set(model, {
           ...(patchPropsByModel.get(model) || {}),
-          ...props,
+          ...normalizedProps,
         });
 
         if (
@@ -2150,8 +2286,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     const newProps = { ...model.__originalProps, ...patchProps };
     const prevHidden = !!model.hidden;
     const nextHidden = !!newProps.hiddenModel;
-
-    model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
+    model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText', LINKAGE_ASSIGN_MODE_PROP]));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(nextHidden);
@@ -2190,7 +2325,8 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           targetUid: model?.uid,
         });
       } else {
-        addFormValuePatch({ path: targetPath, value: newProps.value });
+        const mode = normalizeLinkageAssignMode(patchProps?.[LINKAGE_ASSIGN_MODE_PROP]);
+        addFormValuePatch({ path: targetPath, value: newProps.value, ...(mode === 'override' ? { mode } : {}) });
       }
     }
 
@@ -2375,6 +2511,32 @@ export const menuLinkageRules = defineAction({
   },
 });
 
+export const tabLinkageRules = defineAction({
+  name: 'tabLinkageRules',
+  title: tExpr('Tab linkage rules'),
+  uiMode: 'embed',
+  uiSchema(ctx) {
+    return {
+      value: {
+        type: 'array',
+        'x-component': LinkageRulesUI,
+        'x-component-props': {
+          supportedActions: getSupportedActions(ctx, ActionScene.TAB_LINKAGE_RULES),
+          title: tExpr('Tab linkage rules'),
+        },
+      },
+    };
+  },
+  defaultParams: {
+    value: [],
+  },
+  useRawParams: true,
+  handler: async (ctx, params) => {
+    const resolved = await resolveLinkageRulesParamsPreservingRunJsScripts(ctx, params);
+    return commonLinkageRulesHandler(ctx, resolved);
+  },
+});
+
 export const fieldLinkageRules = defineAction({
   name: 'fieldLinkageRules',
   title: tExpr('Field linkage rules'),
@@ -2842,7 +3004,7 @@ export const subFormFieldLinkageRules = defineAction({
       }
     } else {
       await Promise.all(
-        (grid.forks || []).map(async (forkModel: FlowModel) => {
+        Array.from(grid.forks || []).map(async (forkModel: FlowModel) => {
           if (forkModel.hidden) {
             return;
           }

package/src/flow/actions/linkageRulesFormValueRefresh.ts

@@ -15,17 +15,29 @@ import {
   isRunJSValue,
 } from '@nocobase/flow-engine';
 import _ from 'lodash';
-import { namePathToPathKey, parsePathString, pathKeyToNamePath } from '../models/blocks/form/value-runtime/path';
+import { namePathToPathKey } from '../models/blocks/form/value-runtime/path';
 import {
   collectStaticDepsFromRunJSValue,
   collectStaticDepsFromTemplateValue,
   recordDep,
   type DepCollector,
 } from '../models/blocks/form/value-runtime/deps';
+import {
+  buildItemListRootPath,
+  buildItemRowPath,
+  dedupeNamePaths,
+  findFormValueChangeSource,
+  getChangedPathsFromPayload,
+  getFieldIndexEntriesFromContext,
+  isNamePathPrefix,
+  isSameNamePath,
+  minimizeNamePaths,
+  parseDependencyPath,
+  parsePathKey,
+  type NamePath,
+} from '../utils/formValueDeps';
 import { linkageRulesRefresh } from './linkageRulesRefresh';
 
-type NamePath = Array<string | number>;
-
 type LinkageRefreshDeps = {
   wildcard: boolean;
   valuePaths: NamePath[];
@@ -40,75 +52,11 @@ type LinkageRefreshBinding = {
   dispose: () => void;
 };
 
-type FieldIndexEntry = {
-  name: string;
-  index: number;
-};
-
 const FORM_VALUES_CHANGE_EVENT = 'formValuesChange';
 const LINKAGE_REFRESH_BINDINGS_KEY = '__formValueDrivenLinkageRefreshBindings';
 
-function isSameNamePath(a: NamePath, b: NamePath) {
-  return a.length === b.length && a.every((seg, index) => seg === b[index]);
-}
-
-function isNamePathPrefix(prefix: NamePath, path: NamePath) {
-  if (prefix.length > path.length) return false;
-  return prefix.every((seg, index) => seg === path[index]);
-}
-
-function dedupeNamePaths(paths: NamePath[]) {
-  const byKey = new Map<string, NamePath>();
-  for (const path of paths) {
-    if (!path?.length) continue;
-    byKey.set(namePathToPathKey(path), path);
-  }
-  return Array.from(byKey.values());
-}
-
-function minimizeValueNamePaths(paths: NamePath[]) {
-  const deduped = dedupeNamePaths(paths);
-  return deduped.filter((path, index) => {
-    return !deduped.some((other, otherIndex) => otherIndex !== index && isNamePathPrefix(path, other));
-  });
-}
-
-function parseFieldIndexEntries(fieldIndex: unknown): FieldIndexEntry[] {
-  const arr = Array.isArray(fieldIndex) ? fieldIndex : [];
-  const entries: FieldIndexEntry[] = [];
-  for (const it of arr) {
-    if (typeof it !== 'string') continue;
-    const [name, indexStr] = it.split(':');
-    const index = Number(indexStr);
-    if (!name || Number.isNaN(index)) continue;
-    entries.push({ name, index });
-  }
-  return entries;
-}
-
-function getFieldIndexEntriesFromContext(ctx: any): FieldIndexEntry[] {
-  return parseFieldIndexEntries(ctx?.model?.context?.fieldIndex ?? ctx?.fieldIndex);
-}
-
-function buildItemRowPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
-  const targetIndex = entries.length - 1 - parentDepth;
-  if (targetIndex < 0) return null;
-
-  const out: NamePath = [];
-  for (let i = 0; i <= targetIndex; i++) {
-    out.push(entries[i].name, entries[i].index);
-  }
-  return out;
-}
-
-function buildItemListRootPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
-  const rowPath = buildItemRowPath(entries, parentDepth);
-  if (!rowPath?.length) return null;
-  return rowPath.slice(0, -1);
-}
-
 function resolveItemDependencyPath(ctx: FlowContext, depPath: NamePath): LinkageRefreshDeps {
-  const entries = getFieldIndexEntriesFromContext(ctx as any);
+  const entries = getFieldIndexEntriesFromContext(ctx);
   if (!entries.length) {
     return { wildcard: true, valuePaths: [], structuralPaths: [] };
   }
@@ -171,8 +119,7 @@ function addRunjsUsageToCollector(script: string, collector: DepCollector) {
           collector.wildcard = true;
           continue;
         }
-        const segs = parsePathString(String(subPath)).filter((seg) => typeof seg !== 'object') as NamePath;
-        recordDep(segs, collector);
+        recordDep(parseDependencyPath(String(subPath)), collector);
         continue;
       }
       if (varName === 'item') {
@@ -233,13 +180,13 @@ function collectLinkageRefreshDeps(ctx: FlowContext, params: any): LinkageRefres
         wildcard = true;
         continue;
       }
-      valuePaths.push(pathKeyToNamePath(inner));
+      valuePaths.push(parsePathKey(inner));
       continue;
     }
 
     if (depKey === 'ctx:item' || depKey.startsWith('ctx:item:')) {
       const subPath = depKey === 'ctx:item' ? '' : depKey.slice('ctx:item:'.length);
-      const depPath = subPath ? (parsePathString(subPath).filter((seg) => typeof seg !== 'object') as NamePath) : [];
+      const depPath = subPath ? parseDependencyPath(subPath) : [];
       const resolved = resolveItemDependencyPath(ctx, depPath);
       wildcard ||= resolved.wildcard;
       valuePaths.push(...resolved.valuePaths);
@@ -249,7 +196,7 @@ function collectLinkageRefreshDeps(ctx: FlowContext, params: any): LinkageRefres
 
   return {
     wildcard,
-    valuePaths: minimizeValueNamePaths(valuePaths),
+    valuePaths: minimizeNamePaths(valuePaths),
     structuralPaths: dedupeNamePaths(structuralPaths),
   };
 }
@@ -258,44 +205,9 @@ function hasLinkageRefreshDeps(deps: LinkageRefreshDeps) {
   return deps.wildcard || deps.valuePaths.length > 0 || deps.structuralPaths.length > 0;
 }
 
-function getChangedPathsFromPayload(payload: any): NamePath[] {
-  const rawChangedPaths = Array.isArray(payload?.changedPaths) ? payload.changedPaths : [];
-  const out: NamePath[] = [];
-
-  for (const path of rawChangedPaths) {
-    if (Array.isArray(path)) {
-      if (path.length === 1 && typeof path[0] === 'string') {
-        const namePath = pathKeyToNamePath(path[0]);
-        if (namePath.length) out.push(namePath);
-        continue;
-      }
-      const segs = path.filter((seg) => typeof seg === 'string' || typeof seg === 'number') as NamePath;
-      if (segs.length) out.push(segs);
-      continue;
-    }
-    if (typeof path === 'string' && path) {
-      out.push(pathKeyToNamePath(path));
-    }
-  }
-
-  if (out.length) {
-    return out;
-  }
-
-  const changedValues = payload?.changedValues;
-  if (changedValues && typeof changedValues === 'object') {
-    for (const key of Object.keys(changedValues)) {
-      const namePath = pathKeyToNamePath(key);
-      if (namePath.length) out.push(namePath);
-    }
-  }
-
-  return out;
-}
-
 function linkageRefreshDepsMatchPayload(deps: LinkageRefreshDeps, payload: any) {
   if (!hasLinkageRefreshDeps(deps)) return false;
-  const changedPaths = getChangedPathsFromPayload(payload);
+  const changedPaths = getChangedPathsFromPayload(payload, { includeArrayChangedValues: true });
   if (deps.wildcard) return true;
   if (!changedPaths.length) return true;
 
@@ -330,28 +242,8 @@ function getLinkageRefreshBindings(model: any): Map<string, LinkageRefreshBindin
   return (model[LINKAGE_REFRESH_BINDINGS_KEY] ||= new Map<string, LinkageRefreshBinding>());
 }
 
-function isFormBlockForLinkageRefresh(model: any) {
-  if (!model || typeof model !== 'object') return false;
-  if (!model.emitter || typeof model.emitter.on !== 'function' || typeof model.emitter.off !== 'function') return false;
-  return !!model.formValueRuntime || !!model.context?.form || typeof model.context?.setFormValues === 'function';
-}
-
 function findFormBlockForLinkageRefresh(ctx: FlowContext): any | null {
-  const candidates: any[] = [];
-  const push = (model: any) => {
-    if (model && !candidates.includes(model)) candidates.push(model);
-  };
-
-  push((ctx.model as any)?.context?.blockModel);
-  push(ctx.model);
-
-  let cursor: any = (ctx.model as any)?.parent;
-  while (cursor) {
-    push(cursor);
-    cursor = cursor?.parent;
-  }
-
-  return candidates.find(isFormBlockForLinkageRefresh) || null;
+  return findFormValueChangeSource(ctx) as any;
 }
 
 function disposeLinkageRefreshBinding(model: any, key: string) {

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -35,12 +35,8 @@ export const linkageRulesRefresh = defineAction({
     // Prefer running on the current model; fallback to blockModel when the current model doesn't own the flow.
     if (!hasFlow) return;
 
-    // In runtime, only skip master when there are mounted forks that can handle the same flow.
+    // Skip master when unmounted forks can handle the same flow.
     // Otherwise master is likely the rendered model and still needs refresh.
-    // In design mode, always refresh master so the currently edited model state stays in sync.
-    const flowSettingsEnabled = Boolean(
-      (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
-    );
     const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
@@ -49,7 +45,7 @@ export const linkageRulesRefresh = defineAction({
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted) {
       return;
     }