@nocobase/client-v2 2.2.0-beta.8 → 2.2.0

package/src/flow/actions/__tests__/linkageRules.tab.test.ts

@@ -0,0 +1,171 @@
+/**
+ * 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 { ActionScene } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as registeredActions from '../index';
+import * as linkageActions from '../linkageRules';
+
+const tabLinkageRules = (linkageActions as Record<string, unknown>).tabLinkageRules as
+  | typeof linkageActions.menuLinkageRules
+  | undefined;
+const linkageSetTabProps = (linkageActions as Record<string, unknown>).linkageSetTabProps as
+  | typeof linkageActions.linkageSetMenuItemProps
+  | undefined;
+
+function createRuntime() {
+  let matched = true;
+  const setProps = vi.fn(function (this: { props: Record<string, unknown> }, props: Record<string, unknown>) {
+    this.props = {
+      ...this.props,
+      ...props,
+    };
+  });
+  const setHidden = vi.fn(function (this: { hidden: boolean }, value: boolean) {
+    this.hidden = value;
+  });
+  const model = {
+    uid: 'tab-1',
+    props: {} as Record<string, unknown>,
+    hidden: false,
+    __allModels: [],
+    setProps,
+    setHidden,
+  };
+  const ctx = {
+    app: { jsonLogic: { apply: () => matched } },
+    model,
+    t: (text: string) => text,
+    getAction: (name: string) => (name === 'linkageSetTabProps' ? linkageSetTabProps : undefined),
+    resolveJsonTemplate: vi.fn(async (value: unknown) => value),
+  };
+
+  return {
+    ctx,
+    model,
+    setMatched(value: boolean) {
+      matched = value;
+    },
+  };
+}
+
+const hideRule = {
+  value: [
+    {
+      key: 'rule-1',
+      title: 'Hide tab',
+      enable: true,
+      condition: {
+        logic: '$and',
+        items: [{ path: 'status', operator: '$eq', value: 'visible' }],
+      },
+      actions: [
+        {
+          key: 'action-1',
+          name: 'linkageSetTabProps',
+          params: { value: 'hidden' },
+        },
+      ],
+    },
+  ],
+};
+
+describe('tab linkage rules', () => {
+  it('should append the tab linkage scene without changing existing scene values', () => {
+    const scenes = ActionScene as unknown as Record<string, number>;
+
+    expect(scenes.MENU_LINKAGE_RULES).toBe(7);
+    expect(scenes.TAB_LINKAGE_RULES).toBe(8);
+    expect(scenes.TAB_LINKAGE_RULES).toBe(Math.max(...Object.values(scenes).filter(Number.isInteger)));
+  });
+
+  it('should register tab linkage actions from the actions entry', () => {
+    expect((registeredActions as Record<string, unknown>).tabLinkageRules).toBe(tabLinkageRules);
+    expect((registeredActions as Record<string, unknown>).linkageSetTabProps).toBe(linkageSetTabProps);
+    expect(tabLinkageRules).toBeDefined();
+    expect(linkageSetTabProps).toBeDefined();
+  });
+
+  it('should expose tab state and runjs actions in ui schema', () => {
+    expect(tabLinkageRules).toBeDefined();
+    expect(linkageSetTabProps).toBeDefined();
+
+    const schema = tabLinkageRules?.uiSchema?.({
+      getActions: () =>
+        new Map([
+          ['linkageSetTabProps', linkageSetTabProps],
+          ['linkageRunjs', linkageActions.linkageRunjs],
+          ['linkageSetMenuItemProps', linkageActions.linkageSetMenuItemProps],
+        ]),
+    } as never) as Record<string, Record<string, Record<string, unknown>>> | undefined;
+
+    expect(schema?.value?.['x-component-props']?.supportedActions).toEqual(['linkageSetTabProps', 'linkageRunjs']);
+    expect(linkageSetTabProps?.scene).toBe((ActionScene as unknown as Record<string, number>).TAB_LINKAGE_RULES);
+    expect(linkageActions.linkageRunjs.scene).toContain(
+      (ActionScene as unknown as Record<string, number>).TAB_LINKAGE_RULES,
+    );
+  });
+
+  it('should hide the tab when the condition matches and restore it when the condition misses', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    runtime.setMatched(false);
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(false);
+  });
+
+  it('should restore the tab when linkage rules are cleared', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    await tabLinkageRules?.handler(runtime.ctx as never, { value: [] });
+    expect(runtime.model.hidden).toBe(false);
+  });
+
+  it('should not restore stale tab props while applying or clearing visibility rules', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+    runtime.model.props = {
+      title: 'Original title',
+      icon: 'original-icon',
+      route: { options: { badge: 'original' } },
+    };
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    const updatedProps = {
+      title: 'Updated title',
+      icon: 'updated-icon',
+      route: { options: { badge: 'updated' } },
+    };
+    runtime.model.props = updatedProps;
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(true);
+
+    runtime.setMatched(false);
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(false);
+
+    await tabLinkageRules?.handler(runtime.ctx as never, { value: [] });
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(false);
+  });
+});

package/src/flow/actions/__tests__/linkageRulesRefresh.test.ts

@@ -135,11 +135,15 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-mounted'] });
   });
 
-  it('runs linkage action on master model when forks exist in design mode', async () => {
+  it('skips master model when forks can handle flow in design mode', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
-      forks: new Set([{}]),
+      forks: new Set([
+        {
+          getFlow: vi.fn(() => ({})),
+        },
+      ]),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn(() => ({ value: ['master'] })),
       context: {
@@ -157,7 +161,7 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
-    expect(handler).toHaveBeenCalledWith(ctx, { value: ['master'] });
+    expect(handler).not.toHaveBeenCalled();
   });
 
   it('runs linkage action on fork model and resolves params', async () => {

package/src/flow/actions/__tests__/openView.defineProps.route.test.tsx

@@ -12,6 +12,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { RUNJS_OPEN_VIEW_ROUTE_STATE } from '@nocobase/flow-engine';
 import { openView } from '../openView';
 import { FlowPage } from '../../FlowPage';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../../routeTransientInputArgs';
 
 describe('openView action - route mode defineProperties/defineMethods', () => {
   const createRouteManagedCtx = () => {
@@ -172,6 +173,56 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
     expect(defineMethodCalls).toContain('pong');
   });
 
+  it('passes formData through route navigation state', async () => {
+    const navigateTo = vi.fn();
+    const ctx: any = {
+      inputArgs: {
+        formData: {
+          start: '2026-06-24 08:00:00',
+          end: '2026-06-24 09:00:00',
+        },
+      },
+      engine: {
+        context: {},
+      },
+      model: {
+        uid: 'popup-uid',
+        context: {
+          defineProperty: vi.fn(),
+        },
+      },
+      view: {
+        navigation: {
+          navigateTo,
+        },
+      },
+      isNavigationEnabled: true,
+    };
+
+    await openView.handler(ctx, { navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      {
+        state: {
+          [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+            'popup-uid': {
+              formData: {
+                start: '2026-06-24 08:00:00',
+                end: '2026-06-24 09:00:00',
+              },
+            },
+          },
+        },
+      },
+    );
+  });
+
   it('adds route state to first-stage navigation only for RunJS ctx.openView calls', async () => {
     const { ctx, navigateTo } = createFirstStageCtx({
       mode: 'dialog',
@@ -181,13 +232,16 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-      openViewRouteState: { mode: 'dialog', size: 'large' },
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'dialog', size: 'large' },
+      },
+      undefined,
+    );
   });
 
   it('normalizes first-stage RunJS route state mode on mobile layout', async () => {
@@ -200,13 +254,16 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-      openViewRouteState: { mode: 'embed', size: 'large' },
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'embed', size: 'large' },
+      },
+      undefined,
+    );
   });
 
   it('uses route replay mode and size before persisted openView defaults', async () => {
@@ -246,11 +303,14 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      undefined,
+    );
   });
 });

package/src/flow/actions/dataScopeFilter.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
+import { extractPropertyPath, isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
 import { transformFilter } from '@nocobase/utils/client';
 import _ from 'lodash';
 
@@ -45,6 +45,14 @@ function restorePreservedNull(value: any): any {
   return value;
 }
 
+function isUrlSearchParamsExpression(value: any) {
+  if (!isVariableExpression(value)) {
+    return false;
+  }
+
+  return extractPropertyPath(value)?.[0] === 'urlSearchParams';
+}
+
 function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
   if (!rawNode || !resolvedNode || typeof rawNode !== 'object' || typeof resolvedNode !== 'object') {
     return;
@@ -57,6 +65,7 @@ function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
     }
     if (
       isVariableExpression(rawNode.value) &&
+      !isUrlSearchParamsExpression(rawNode.value) &&
       (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')
     ) {
       resolvedNode.value = PRESERVE_NULL;

package/src/flow/actions/dateTimeFormat.tsx

@@ -28,11 +28,11 @@ const isTableColumnFieldSubModel = (model) => {
 
 const syncTableColumnDateTimeFormatProps = (ctx, props) => {
   const model = ctx.model;
-  if (!isTableColumnFieldSubModel(model) || !model?.parent?.collectionField?.isAssociationField?.()) {
+  if (!isTableColumnFieldSubModel(model)) {
     return;
   }
 
-  model.parent.setProps(props);
+  model.parent?.setProps?.(props);
 };
 
 export const dateTimeFormat = defineAction({

package/src/flow/actions/index.ts

@@ -43,10 +43,12 @@ export {
   linkageSetDetailsFieldProps,
   actionLinkageRules,
   menuLinkageRules,
+  tabLinkageRules,
   blockLinkageRules,
   linkageSetBlockProps,
   linkageSetActionProps,
   linkageSetMenuItemProps,
+  linkageSetTabProps,
   linkageSetFieldProps,
   subFormLinkageSetFieldProps,
   linkageAssignField,

package/src/flow/actions/linkageRules.tsx

@@ -68,6 +68,12 @@ interface LinkageRule {
   }[];
 }
 
+export function updateLinkageRules<T>(rules: T[], updater: (nextRules: T[]) => void): T[] {
+  const nextRules = _.cloneDeep(rules);
+  updater(nextRules);
+  return nextRules;
+}
+
 const previewValueForLog = (value: any) => {
   if (value == null) return value;
   const t = typeof value;
@@ -114,11 +120,16 @@ const isActionFlowModel = (model: any): boolean => {
   return false;
 };
 
+const isFormFieldModel = (model: unknown): model is FlowModel => {
+  if (!model || typeof model !== 'object') return false;
+  return !!(model as FlowModel).subModels?.field;
+};
+
 // 获取表单中所有字段的 model 实例的通用函数
 const getFormFields = (ctx: any) => {
   try {
     const fieldModels = ctx.model?.subModels?.grid?.subModels?.items || [];
-    return fieldModels.map((model: any) => ({
+    return fieldModels.filter(isFormFieldModel).map((model) => ({
       label: model.props.label || model.props.name,
       value: model.uid,
       model,
@@ -340,8 +351,8 @@ const FieldStateEditor = ({
 const getFormFieldsByForkModel = (ctx: any) => {
   try {
     const fieldModels = ctx.model?.subModels?.grid?.subModels?.items || [];
-    return fieldModels.map((model: any) => {
-      const forkModel = Array.from(model.forks)[0] as any;
+    return fieldModels.filter(isFormFieldModel).map((model) => {
+      const forkModel = Array.from(model.forks)[0] as FlowModel | undefined;
 
       if (forkModel) {
         return {
@@ -654,6 +665,30 @@ export const linkageSetBlockProps = defineAction({
   },
 });
 
+const ACTION_LINKAGE_STATE_OPTIONS = [
+  { label: 'Visible', value: 'visible' },
+  { label: 'Hidden', value: 'hidden' },
+  { label: 'Hidden text', value: 'hiddenText' },
+  { label: 'Enabled', value: 'enabled' },
+  { label: 'Disabled', value: 'disabled' },
+] as const;
+
+type ActionLinkageState = (typeof ACTION_LINKAGE_STATE_OPTIONS)[number]['value'];
+
+export function getActionLinkageStateOptions(
+  model: { supportedActionLinkageStates?: readonly ActionLinkageState[] },
+  t: (key: string) => string,
+) {
+  const supportedStates = model.supportedActionLinkageStates ? new Set(model.supportedActionLinkageStates) : undefined;
+
+  return ACTION_LINKAGE_STATE_OPTIONS.filter((option) => !supportedStates || supportedStates.has(option.value)).map(
+    (option) => ({
+      label: t(option.label),
+      value: option.value,
+    }),
+  );
+}
+
 export const linkageSetActionProps = defineAction({
   name: 'linkageSetActionProps',
   title: tExpr('Set button state'),
@@ -674,13 +709,7 @@ export const linkageSetActionProps = defineAction({
             onChange={onChange}
             placeholder={t('Please select state')}
             style={{ width: '100%' }}
-            options={[
-              { label: t('Visible'), value: 'visible' },
-              { label: t('Hidden'), value: 'hidden' },
-              { label: t('Hidden text'), value: 'hiddenText' },
-              { label: t('Enabled'), value: 'enabled' },
-              { label: t('Disabled'), value: 'disabled' },
-            ]}
+            options={getActionLinkageStateOptions(ctx.model, t)}
             allowClear
           />
         );
@@ -731,6 +760,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'),
@@ -1339,6 +1403,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,
   ],
@@ -1464,13 +1529,26 @@ async function resolveLinkageRulesParamsPreservingRunJsScripts(ctx: FlowContext,
 }
 
 const LinkageRulesUI = observer(
-  (props: { readonly value: LinkageRule[]; supportedActions: string[]; title?: string }) => {
-    const { value: rules, supportedActions } = props;
+  (props: {
+    readonly value: LinkageRule[];
+    onChange?: (value: LinkageRule[]) => void;
+    supportedActions: string[];
+    title?: string;
+  }) => {
+    const { value: rules = [], onChange, supportedActions } = props;
     const ctx = useFlowContext();
     const flowEngine = useFlowEngine();
     const t = ctx.model.translate.bind(ctx.model);
     const assignPriorityTip = t('Assignment takes precedence over form field assignment');
 
+    const replaceRules = (updater: (nextRules: LinkageRule[]) => void) => {
+      if (onChange) {
+        onChange(updateLinkageRules(rules, updater));
+      } else {
+        updater(rules);
+      }
+    };
+
     // 创建新规则的默认值
     const createNewRule = (): LinkageRule => ({
       key: uid(),
@@ -1487,7 +1565,7 @@ const LinkageRulesUI = observer(
 
     // 删除规则
     const handleDeleteRule = (index: number) => {
-      rules.splice(index, 1);
+      replaceRules((nextRules) => nextRules.splice(index, 1));
     };
 
     // 上移规则
@@ -1526,7 +1604,9 @@ const LinkageRulesUI = observer(
 
     // 切换规则启用状态
     const handleToggleEnable = (index: number, enable: boolean) => {
-      rules[index].enable = enable;
+      replaceRules((nextRules) => {
+        nextRules[index].enable = enable;
+      });
     };
 
     // 获取可用的动作类型
@@ -2169,17 +2249,30 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
               }
             : props;
 
-        // 存储原始值，用于恢复
-        if (!model.__originalProps) {
-          model.__originalProps = {
-            hiddenModel: model.hidden,
-            hiddenText: undefined,
-            disabled: undefined,
-            required: undefined,
-            hidden: undefined,
-            ...model.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, {
@@ -2237,7 +2330,6 @@ 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', LINKAGE_ASSIGN_MODE_PROP]));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
@@ -2463,6 +2555,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'),

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;
     }