@nocobase/client-v2 2.1.0-alpha.31 → 2.1.0-alpha.32

package/src/flow/admin-shell/__tests__/AdminLayoutRouteCoordinator.test.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 { FlowEngine } from '@nocobase/flow-engine';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { getViewDiffAndUpdateHidden } from '../../getViewDiffAndUpdateHidden';
+import { getOpenViewStepParams } from '../../flows/openViewFlow';
+import { resolveViewParamsToViewList } from '../../resolveViewParamsToViewList';
+import { AdminLayoutRouteCoordinator } from '../AdminLayoutRouteCoordinator';
+import { RouteModel } from '../../models/base/RouteModel';
+
+vi.mock('../../resolveViewParamsToViewList', () => ({
+  resolveViewParamsToViewList: vi.fn(),
+  updateViewListHidden: vi.fn(),
+}));
+
+vi.mock('../../getViewDiffAndUpdateHidden', () => ({
+  getViewDiffAndUpdateHidden: vi.fn(),
+  getKey: vi.fn((viewItem) => viewItem.params.viewUid),
+}));
+
+vi.mock('../../flows/openViewFlow', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...(actual as any),
+    getOpenViewStepParams: vi.fn(),
+  };
+});
+
+const mockResolveViewParamsToViewList = vi.mocked(resolveViewParamsToViewList);
+const mockGetViewDiffAndUpdateHidden = vi.mocked(getViewDiffAndUpdateHidden);
+const mockGetOpenViewStepParams = vi.mocked(getOpenViewStepParams);
+
+function setupRouteReplay(viewParams: Record<string, any>) {
+  const engine = new FlowEngine();
+  engine.registerModels({ RouteModel });
+  engine.context.defineProperty('route', {
+    value: {
+      params: { name: 'test-route' },
+      pathname: '/admin/popup/filterbytk/member',
+    },
+  });
+  engine.context.defineProperty('routeRepository', {
+    value: {
+      getRouteBySchemaUid: vi.fn(() => ({})),
+    },
+  });
+
+  const dispatchEvent = vi.fn(() => Promise.resolve());
+  const viewItem = {
+    params: {
+      viewUid: 'popup',
+      filterByTk: 'member',
+      ...viewParams,
+    },
+    modelUid: 'popup',
+    model: { uid: 'popup', dispatchEvent } as any,
+    hidden: { value: false },
+    index: 0,
+  };
+
+  mockResolveViewParamsToViewList.mockReturnValue([viewItem]);
+  mockGetViewDiffAndUpdateHidden.mockReturnValue({
+    viewsToClose: [],
+    viewsToOpen: [viewItem],
+  });
+  mockGetOpenViewStepParams.mockReturnValue({
+    collectionName: 'roles',
+    associationName: 'users.roles',
+    dataSourceKey: 'main',
+  } as any);
+
+  const coordinator = new AdminLayoutRouteCoordinator(engine);
+  coordinator.registerPage('test-route', {
+    active: true,
+    layoutContentElement: document.createElement('div'),
+  });
+
+  return { dispatchEvent };
+}
+
+describe('AdminLayoutRouteCoordinator', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('drops configured associationName during route replay when sourceId is absent', () => {
+    const { dispatchEvent } = setupRouteReplay({});
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      collectionName: 'roles',
+      associationName: null,
+      dataSourceKey: 'main',
+      filterByTk: 'member',
+      triggerByRouter: true,
+    });
+  });
+
+  it('keeps configured associationName during route replay when sourceId is present', () => {
+    const { dispatchEvent } = setupRouteReplay({ sourceId: '1' });
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      collectionName: 'roles',
+      associationName: 'users.roles',
+      dataSourceKey: 'main',
+      filterByTk: 'member',
+      sourceId: '1',
+      triggerByRouter: true,
+    });
+  });
+});

package/src/flow/models/base/PageModel/PageModel.tsx

@@ -49,6 +49,17 @@ export class PageModel extends FlowModel<PageModelStructure> {
   private unmounted = false;
   private documentTitleUpdateVersion = 0;
 
+  /**
+   * 根页面标签页开关以路由表为准，避免 flow model 里的旧配置覆盖路由管理设置。
+   */
+  private getEnableTabs(): boolean {
+    const routeEnableTabs = (this.context as any)?.currentRoute?.enableTabs;
+    if (this.props.routeId != null && typeof routeEnableTabs === 'boolean') {
+      return routeEnableTabs;
+    }
+    return !!this.props.enableTabs;
+  }
+
   private getActiveTabKey(): string | undefined {
     const viewParams = this.context.view?.navigation?.viewParams;
     if (viewParams) {
@@ -193,7 +204,7 @@ export class PageModel extends FlowModel<PageModelStructure> {
     };
 
     let nextTitle = '';
-    if (this.props.enableTabs) {
+    if (this.getEnableTabs()) {
       const activeTabKey = preferredActiveTabKey || this.getActiveTabKey();
       const activeTabModel = activeTabKey
         ? (this.flowEngine.getModel(activeTabKey) as BasePageTabModel | undefined)
@@ -356,13 +367,14 @@ export class PageModel extends FlowModel<PageModelStructure> {
       headerStyle.paddingBlock = token.paddingSM;
       headerStyle.paddingInline = token.paddingLG;
     }
-    if (this.props.enableTabs) {
+    const enableTabs = this.getEnableTabs();
+    if (enableTabs) {
       headerStyle.paddingBottom = 0;
     }
     return (
       <>
         {this.props.displayTitle && <PageHeader title={this.props.title} style={headerStyle} />}
-        {this.props.enableTabs ? this.renderTabs() : this.renderFirstTab()}
+        {enableTabs ? this.renderTabs() : this.renderFirstTab()}
       </>
     );
   }

package/src/flow/models/base/PageModel/RootPageModel.tsx

@@ -17,6 +17,31 @@ import { PageModel } from './PageModel';
 export class RootPageModel extends PageModel {
   mounted = false;
 
+  /**
+   * 打开页面设置前，把标签页开关表单值同步为路由表中的当前状态。
+   */
+  private syncPageSettingsEnableTabsFromRoute() {
+    const routeEnableTabs = (this.context as any)?.currentRoute?.enableTabs;
+    if (typeof routeEnableTabs !== 'boolean') {
+      return;
+    }
+    this.setStepParams('pageSettings', 'general', {
+      enableTabs: routeEnableTabs,
+    });
+  }
+
+  /**
+   * 保存页面设置后立即同步当前页面状态，让标签页显隐无需等路由列表刷新或页面重载。
+   */
+  private syncEnableTabsToCurrentPage(enableTabs: boolean) {
+    const currentRoute = (this.context as any)?.currentRoute;
+    const routeId = this.props.routeId;
+    if (currentRoute && (routeId == null || currentRoute.id == null || String(currentRoute.id) === String(routeId))) {
+      currentRoute.enableTabs = enableTabs;
+    }
+    this.setProps('enableTabs', enableTabs);
+  }
+
   /**
    * 新建 tab 在首次保存完成前，前端 route 里可能还没有数据库 id。
    * 拖拽前兜底触发一次保存，确保 move 接口拿到真实主键。
@@ -65,18 +90,28 @@ export class RootPageModel extends PageModel {
     );
   }
 
+  async openFlowSettings(options?: Parameters<PageModel['openFlowSettings']>[0]) {
+    if (options?.flowKey === 'pageSettings' && options?.stepKey === 'general') {
+      this.syncPageSettingsEnableTabsFromRoute();
+    }
+    return super.openFlowSettings(options);
+  }
+
   async saveStepParams() {
     await super.saveStepParams();
 
     if (this.stepParams.pageSettings) {
+      const enableTabs = !!this.stepParams.pageSettings.general.enableTabs;
       // 更新路由
-      this.context.api.request({
+      await this.context.api.request({
         url: `desktopRoutes:update?filter[id]=${this.props.routeId}`,
         method: 'post',
         data: {
-          enableTabs: !!this.stepParams.pageSettings.general.enableTabs,
+          enableTabs,
         },
       });
+      this.syncEnableTabsToCurrentPage(enableTabs);
+      await this.context.refreshDesktopRoutes?.();
     }
   }
 

package/src/flow/models/base/PageModel/__tests__/PageModel.test.ts

@@ -412,6 +412,7 @@ describe('PageModel', () => {
   describe('render header spacing with tabs', () => {
     it('should compact page header bottom spacing when tabs are enabled', () => {
       pageModel.props = {
+        routeId: 'route-1',
         displayTitle: true,
         enableTabs: true,
         title: 'Title',
@@ -430,6 +431,7 @@ describe('PageModel', () => {
 
     it('should keep original header style when tabs are disabled', () => {
       pageModel.props = {
+        routeId: 'route-1',
         displayTitle: true,
         enableTabs: false,
         title: 'Title',
@@ -442,6 +444,57 @@ describe('PageModel', () => {
 
       expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
     });
+
+    it('should use desktop route enableTabs=false before flow model props', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: true,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          enableTabs: false,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).not.toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).toHaveBeenCalled();
+      expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
+    });
+
+    it('should use desktop route enableTabs=true before flow model props', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: false,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          enableTabs: true,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).not.toHaveBeenCalled();
+      expect(header.props.style).toMatchObject({
+        backgroundColor: 'var(--colorBgLayout)',
+        paddingBottom: 0,
+      });
+    });
   });
 
   describe('dirty refresh signal', () => {
@@ -574,6 +627,26 @@ describe('PageModel', () => {
       expect(document.title).toBe('Resolved tab doc title');
     });
 
+    it('should use page documentTitle when desktop route disables tabs even if flow model enables tabs', async () => {
+      pageModel.props = { routeId: 'route-1', enableTabs: true, title: 'Route page title' } as any;
+      (pageModel as any).context.currentRoute = {
+        enableTabs: false,
+      };
+      (pageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            documentTitle: 'Route page doc title',
+          },
+        },
+      };
+      (pageModel as any).context.resolveJsonTemplate = vi.fn(async () => 'Resolved route page doc title');
+
+      await (pageModel as any).updateDocumentTitle();
+
+      expect((pageModel as any).context.resolveJsonTemplate).toHaveBeenCalledWith('Route page doc title');
+      expect(document.title).toBe('Resolved route page doc title');
+    });
+
     it('should fallback to tab title when active tab documentTitle is empty', async () => {
       pageModel.props = { enableTabs: true } as any;
       const activeTab = {

package/src/flow/models/base/PageModel/__tests__/RootPageModel.test.ts

@@ -12,10 +12,32 @@ import { RootPageModel } from '../RootPageModel';
 
 // Mock PageModel
 const mockPageModelSaveStepParams = vi.fn();
+const mockPageModelOpenFlowSettings = vi.fn();
 vi.mock('../PageModel', () => ({
   PageModel: class {
+    props: any = {};
+    stepParams: any = {};
+
     static registerFlow() {}
 
+    setProps(key: string, value: any) {
+      this.props[key] = value;
+    }
+
+    setStepParams(flowKey: string, stepKey: string, params: Record<string, any>) {
+      if (!this.stepParams[flowKey]) {
+        this.stepParams[flowKey] = {};
+      }
+      this.stepParams[flowKey][stepKey] = {
+        ...this.stepParams[flowKey][stepKey],
+        ...params,
+      };
+    }
+
+    async openFlowSettings(options?: any) {
+      return mockPageModelOpenFlowSettings(options);
+    }
+
     async saveStepParams() {
       return mockPageModelSaveStepParams();
     }
@@ -26,6 +48,7 @@ describe('RootPageModel', () => {
   let rootPageModel: RootPageModel;
   let mockContext: any;
   let mockApi: any;
+  let mockRefreshDesktopRoutes: any;
   let mockFlowEngine: any;
 
   beforeEach(() => {
@@ -35,6 +58,7 @@ describe('RootPageModel', () => {
     mockApi = {
       request: vi.fn().mockResolvedValue({ data: { success: true } }),
     };
+    mockRefreshDesktopRoutes = vi.fn().mockResolvedValue(undefined);
 
     // Mock FlowEngine
     mockFlowEngine = {
@@ -45,6 +69,11 @@ describe('RootPageModel', () => {
     // Mock context
     mockContext = {
       api: mockApi,
+      refreshDesktopRoutes: mockRefreshDesktopRoutes,
+      currentRoute: {
+        id: 'route-123',
+        enableTabs: true,
+      },
     };
 
     // Create RootPageModel instance
@@ -63,6 +92,65 @@ describe('RootPageModel', () => {
     };
   });
 
+  describe('openFlowSettings', () => {
+    it('should use desktop route enableTabs as settings dialog initial value', async () => {
+      mockContext.currentRoute.enableTabs = false;
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            displayTitle: true,
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.openFlowSettings({ flowKey: 'pageSettings', stepKey: 'general' } as any);
+
+      expect((rootPageModel as any).stepParams.pageSettings.general).toMatchObject({
+        displayTitle: true,
+        enableTabs: false,
+      });
+      expect(mockPageModelOpenFlowSettings).toHaveBeenCalledWith({
+        flowKey: 'pageSettings',
+        stepKey: 'general',
+      });
+    });
+
+    it('should keep flow model enableTabs when route status is unavailable', async () => {
+      mockContext.currentRoute = {};
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.openFlowSettings({ flowKey: 'pageSettings', stepKey: 'general' } as any);
+
+      expect((rootPageModel as any).stepParams.pageSettings.general.enableTabs).toBe(true);
+    });
+
+    it('should not sync enableTabs when opening other settings steps', async () => {
+      mockContext.currentRoute.enableTabs = false;
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.openFlowSettings({ flowKey: 'otherSettings', stepKey: 'general' } as any);
+
+      expect((rootPageModel as any).stepParams.pageSettings.general.enableTabs).toBe(true);
+      expect(mockPageModelOpenFlowSettings).toHaveBeenCalledWith({
+        flowKey: 'otherSettings',
+        stepKey: 'general',
+      });
+    });
+  });
+
   describe('saveStepParams', () => {
     it('should call parent saveStepParams method', async () => {
       await rootPageModel.saveStepParams();
@@ -89,6 +177,34 @@ describe('RootPageModel', () => {
         },
       });
     });
+
+    it('should refresh desktop routes after route update is persisted', async () => {
+      await rootPageModel.saveStepParams();
+
+      expect(mockApi.request).toHaveBeenCalledTimes(1);
+      expect(mockRefreshDesktopRoutes).toHaveBeenCalledTimes(1);
+      expect(mockApi.request.mock.invocationCallOrder[0]).toBeLessThan(
+        mockRefreshDesktopRoutes.mock.invocationCallOrder[0],
+      );
+    });
+
+    it('should apply enableTabs to current page immediately after route update is persisted', async () => {
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: false,
+          },
+        },
+      };
+
+      await rootPageModel.saveStepParams();
+
+      expect(mockContext.currentRoute.enableTabs).toBe(false);
+      expect((rootPageModel as any).props.enableTabs).toBe(false);
+      expect(mockApi.request.mock.invocationCallOrder[0]).toBeLessThan(
+        mockRefreshDesktopRoutes.mock.invocationCallOrder[0],
+      );
+    });
   });
 
   describe('handleDragEnd', () => {

package/src/flow/models/blocks/form/value-runtime/__tests__/runtime.test.ts

@@ -159,12 +159,141 @@ describe('FormValueRuntime (default rules)', () => {
     await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
     await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Y'));
 
+    // change dependency again -> default keeps following while target is still the last default
+    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Z'));
+
     // user changes target -> default should be disabled permanently
     await runtime.setFormValues(fieldCtx, [{ path: ['a'], value: 'user' }], { source: 'user' });
-    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'W' }], { source: 'user' });
     expect(formStub.getFieldValue(['a'])).toBe('user');
   });
 
+  it('allows direct default patches to keep following until target is explicitly changed', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roleUid: 'role-uid-1', roleName: '' });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-1')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-1',
+      linkageTxId: 'tx-linkage-1',
+    });
+    runtime.recordDefaultValuePatch(['roleName'], 'role-uid-1');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-2' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-2')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-2' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-2',
+      linkageTxId: 'tx-linkage-2',
+    });
+    runtime.recordDefaultValuePatch(['roleName'], 'role-uid-2');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-3' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-3')).toBe(true);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'manual' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-4')).toBe(false);
+  });
+
+  it('keeps direct default patches active when an unchanged default value is carried by a row change', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roles: [{ uid: '1', title: '' }] });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch-row',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '1')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: '1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-row-1',
+      linkageTxId: 'tx-linkage-row-1',
+    });
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '1');
+
+    lodashSet((runtime as any).valuesMirror, ['roles', 0, 'title'], undefined);
+    runtime.handleFormFieldsChange([{ name: ['roles', 0, 'title'], touched: true } as any]);
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+
+    (runtime as any).markExplicit('roles');
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+
+    lodashSet((runtime as any).valuesMirror, ['roles', 0, 'title'], undefined);
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'uid'], '12');
+    runtime.handleFormValuesChange({ roles: formStub.getFieldValue(['roles']) }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: '12' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-row-2',
+      linkageTxId: 'tx-linkage-row-2',
+    });
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '12');
+    expect(formStub.getFieldValue(['roles', 0, 'title'])).toBe('12');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: 'manual' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '13')).toBe(false);
+  });
+
+  it('does not mark omitted sibling fields from partial top-level changedValues as explicit', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ __is_new__: true, __index__: 'row-1', name: '1', title: '1' }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch-partial-row',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '1');
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'name'], '12');
+    runtime.handleFormValuesChange({ roles: [{ name: '12' }] }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+  });
+
   it('handles onFieldsChange name as string and triggers default recompute', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
@@ -3267,4 +3396,41 @@ describe('FormValueRuntime (form assign rules)', () => {
     expect(payload.txId).toBe('tx-current');
     expect(payload.linkageTxId).toBe('tx-root');
   });
+
+  it('does not mark linkage writes explicit so later user edits can keep following default linkage', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roleUid: 'role-uid-1', roleName: '' });
+
+    const blockModel: any = {
+      uid: 'form-linkage-linkage-not-explicit',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-1',
+      linkageTxId: 'tx-linkage-1',
+      linkageScopeDepth: 0,
+    });
+
+    expect(formStub.getFieldValue(['roleName'])).toBe('role-uid-1');
+    expect((runtime as any).findExplicitHit('roleName')).toBeNull();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-2' }], {
+      source: 'user',
+      txId: 'tx-user-1',
+    });
+    expect(formStub.getFieldValue(['roleUid'])).toBe('role-uid-2');
+    expect((runtime as any).findExplicitHit('roleName')).toBeNull();
+  });
 });