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

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

@@ -14,6 +14,7 @@ import dayjs from 'dayjs';
 import { observable } from '@formily/reactive';
 import { get as lodashGet, merge as lodashMerge, set as lodashSet } from 'lodash';
 import { FlowContext, JSRunner } from '@nocobase/flow-engine';
+import { getValuesByPath } from '@nocobase/shared';
 import { FormValueRuntime } from '..';
 import type { FormInstance } from 'antd';
 
@@ -95,6 +96,10 @@ function createFieldContext(runtime: FormValueRuntime) {
         if (match) {
           const pathString = match[1];
           if (!pathString) return this;
+          if (pathString === 'formValues') return this.formValues;
+          if (pathString.startsWith('formValues.')) {
+            return getValuesByPath(runtime.getFormValuesSnapshot(), pathString.slice('formValues.'.length));
+          }
           const segs = pathString.split('.').filter(Boolean);
           return lodashGet(this, segs);
         }
@@ -122,6 +127,93 @@ function createFieldContext(runtime: FormValueRuntime) {
 }
 
 describe('FormValueRuntime (default rules)', () => {
+  it('builds draft snapshots from current user-edited values only', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({});
+    const dispatchEvent = vi.fn();
+
+    const blockModel = {
+      uid: 'form-user-edited-draft-snapshot',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent,
+      getAclActionName: () => 'create',
+    } as ConstructorParameters<typeof FormValueRuntime>[0]['model'];
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as unknown as FormInstance });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    await runtime.setFormValues(blockCtx, [{ path: ['fixed'], value: 'Fixed auto value' }], { source: 'system' });
+    await runtime.setFormValues(blockCtx, [{ path: ['defaultTitle'], value: 'Default auto value' }], {
+      source: 'default',
+    });
+    await runtime.setFormValues(blockCtx, [{ path: ['overrideTitle'], value: 'Override auto value' }], {
+      source: 'override',
+    });
+
+    expect(runtime.getUserEditedValuePatches()).toEqual([]);
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({});
+
+    await runtime.setFormValues(
+      blockCtx,
+      [
+        { path: ['title'], value: 'Manual title' },
+        { path: ['roles', 0, 'roleName'], value: 'Manual role' },
+      ],
+      { source: 'user' },
+    );
+
+    expect(runtime.getUserEditedValuePatches()).toEqual([
+      { path: ['title'], value: 'Manual title' },
+      { path: ['roles', 0, 'roleName'], value: 'Manual role' },
+    ]);
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({
+      title: 'Manual title',
+      roles: [{ roleName: 'Manual role' }],
+    });
+
+    await runtime.setFormValues(blockCtx, [{ path: ['title'], value: 'Fixed title' }], { source: 'system' });
+
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({
+      roles: [{ roleName: 'Manual role' }],
+    });
+  });
+
+  it('omits non-user descendant values from parent user-edited draft patches', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({});
+    const dispatchEvent = vi.fn();
+
+    const blockModel = {
+      uid: 'form-user-edited-parent-draft-patch',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent,
+      getAclActionName: () => 'create',
+    } as ConstructorParameters<typeof FormValueRuntime>[0]['model'];
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as unknown as FormInstance });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    await runtime.setFormValues(
+      blockCtx,
+      [{ path: ['roles'], value: [{ roleName: 'Manual role', fixedRoleName: 'Initial fixed role' }] }],
+      { source: 'user' },
+    );
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'fixedRoleName'], value: 'System fixed role' }], {
+      source: 'system',
+    });
+
+    expect(runtime.getUserEditedValuePatches()).toEqual([{ path: ['roles'], value: [{ roleName: 'Manual role' }] }]);
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({
+      roles: [{ roleName: 'Manual role' }],
+    });
+  });
+
   it('skips object patches when values are unchanged', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
@@ -747,13 +839,13 @@ describe('FormValueRuntime (form assign rules)', () => {
     await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Y'));
   });
 
-  it('mode=default follows explicit semantics and stops after user change', async () => {
+  it('mode=assign follows to-many association title changes without clearing on transient empty arrays', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
-    const formStub = createFormStub({ b: 'X' });
+    const formStub = createFormStub({ roles: [] });
 
     const blockModel: any = {
-      uid: 'form-assign-2',
+      uid: 'form-assign-to-many-source-title',
       flowEngine: { emitter: engineEmitter },
       emitter: blockEmitter,
       dispatchEvent: vi.fn(),
@@ -764,46 +856,66 @@ describe('FormValueRuntime (form assign rules)', () => {
     runtime.mount({ sync: true });
 
     const blockCtx = createFieldContext(runtime);
-    const fieldModel: any = {
-      uid: 'field-a2',
-      context: { fieldPathArray: ['a'] },
+    const usernameField: any = { isAssociationField: () => false, interface: 'input' };
+    const rolesCollection: any = { getField: () => null, filterTargetKey: 'name' };
+    const rolesField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: rolesCollection,
     };
-    blockCtx.defineProperty('engine', {
-      value: {
-        getModel: (id: string) => (id === 'field-a2' ? fieldModel : null),
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'username') return usernameField;
+        if (name === 'roles') return rolesField;
+        return null;
       },
-    });
+    };
+    blockCtx.defineProperty('collection', { value: collection });
     blockModel.context = blockCtx;
 
     runtime.syncAssignRules([
       {
-        key: 'r1',
+        key: 'username-from-role-title',
         enable: true,
-        targetPath: 'a',
-        mode: 'default',
+        targetPath: 'username',
+        mode: 'assign',
         condition: { logic: '$and', items: [] },
-        value: '__B__',
+        value: '{{ ctx.formValues.roles.title }}',
       },
     ]);
 
-    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('X'));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['username'])).toBeUndefined();
 
-    // user writes to target; default mode MUST stop permanently
-    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'user' }], { source: 'user' });
-    expect(formStub.getFieldValue(['a'])).toBe('user');
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ title: '经理' }] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('经理'));
 
-    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    expect(formStub.getFieldValue(['a'])).toBe('user');
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ title: '经理' }, { title: 'Admin' }] }], {
+      source: 'user',
+    });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('经理, Admin'));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ title: null }] }], { source: 'system' });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(formStub.getFieldValue(['username'])).toBe('经理, Admin');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ __index__: 'row-1', __is_new__: true }] }], {
+      source: 'system',
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(formStub.getFieldValue(['username'])).toBe('经理, Admin');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ title: '销售' }] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('销售'));
   });
 
-  it('reapplies mode=default value after form reset starts a new create session', async () => {
+  it('mode=assign clears scalar target when to-many association source is really cleared by user', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
-    const formStub = createFormStub({});
+    const formStub = createFormStub({ roles: [] });
 
     const blockModel: any = {
-      uid: 'form-assign-reset-reapply-default',
+      uid: 'form-assign-to-many-source-user-clear',
       flowEngine: { emitter: engineEmitter },
       emitter: blockEmitter,
       dispatchEvent: vi.fn(),
@@ -814,47 +926,103 @@ describe('FormValueRuntime (form assign rules)', () => {
     runtime.mount({ sync: true });
 
     const blockCtx = createFieldContext(runtime);
-    const fieldModel: any = {
-      uid: 'field-a-reset-reapply-default',
-      context: { fieldPathArray: ['a'] },
+    const usernameField: any = { isAssociationField: () => false, interface: 'input' };
+    const rolesCollection: any = { getField: () => null, filterTargetKey: 'name' };
+    const rolesField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: rolesCollection,
     };
-    blockCtx.defineProperty('engine', {
-      value: {
-        getModel: (id: string) => (id === 'field-a-reset-reapply-default' ? fieldModel : null),
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'username') return usernameField;
+        if (name === 'roles') return rolesField;
+        return null;
       },
-    });
+    };
+    blockCtx.defineProperty('collection', { value: collection });
     blockModel.context = blockCtx;
 
     runtime.syncAssignRules([
       {
-        key: 'r1',
+        key: 'username-from-role-title-user-clear',
         enable: true,
-        targetPath: 'a',
-        mode: 'default',
+        targetPath: 'username',
+        mode: 'assign',
         condition: { logic: '$and', items: [] },
-        value: 'AAA',
+        value: '{{ ctx.formValues.roles.title }}',
       },
     ]);
 
-    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA'));
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ title: '经理' }] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('经理'));
 
-    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'AAA1' }], { source: 'user' });
-    expect(formStub.getFieldValue(['a'])).toBe('AAA1');
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe(''));
+  });
 
-    formStub.__store.a = undefined;
-    delete formStub.__store.a;
-    runtime.resetAfterFormReset();
+  it('mode=assign does not stringify multi-value aggregate for non-text scalar targets', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roles: [] });
 
-    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA'));
+    const blockModel: any = {
+      uid: 'form-assign-to-many-number-target',
+      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);
+    const scoreField: any = { isAssociationField: () => false, interface: 'number' };
+    const rolesCollection: any = { getField: () => null, filterTargetKey: 'name' };
+    const rolesField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: rolesCollection,
+    };
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'score') return scoreField;
+        if (name === 'roles') return rolesField;
+        return null;
+      },
+    };
+    blockCtx.defineProperty('collection', { value: collection });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'score-from-role-level',
+        enable: true,
+        targetPath: 'score',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+        value: '{{ ctx.formValues.roles.level }}',
+      },
+    ]);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ level: 3 }] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['score'])).toBe(3));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ level: 1 }, { level: 2 }] }], {
+      source: 'user',
+    });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(formStub.getFieldValue(['score'])).toBe(3);
   });
 
-  it('resets valuesMirror before rescheduling default rules after form reset', async () => {
+  it('tracks dynamic ctx.resolveJsonTemplate formValues dependencies from RunJS values', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
     const formStub = createFormStub({ selector: 'x', x: 'AAA', y: 'BBB' });
 
     const blockModel: any = {
-      uid: 'form-assign-reset-values-mirror',
+      uid: 'form-assign-runjs-dynamic-template-deps',
       flowEngine: { emitter: engineEmitter },
       emitter: blockEmitter,
       dispatchEvent: vi.fn(),
@@ -866,56 +1034,104 @@ describe('FormValueRuntime (form assign rules)', () => {
 
     const blockCtx = createFieldContext(runtime);
     const fieldModel: any = {
-      uid: 'field-a-reset-values-mirror',
+      uid: 'field-a-runjs-dynamic-template-deps',
       context: { fieldPathArray: ['a'] },
     };
     blockCtx.defineProperty('engine', {
       value: {
-        getModel: (id: string) => (id === 'field-a-reset-values-mirror' ? fieldModel : null),
+        getModel: (id: string) => (id === 'field-a-runjs-dynamic-template-deps' ? fieldModel : null),
       },
     });
     blockModel.context = blockCtx;
 
     runtime.syncAssignRules([
       {
-        key: 'r1',
+        key: 'runjs-dynamic-template-deps',
         enable: true,
         targetPath: 'a',
-        mode: 'default',
+        mode: 'assign',
         condition: { logic: '$and', items: [] },
-        value: '__DYNAMIC__',
+        value: {
+          code: "const key = ctx.formValues.selector; return await ctx.resolveJsonTemplate('{{ ctx.formValues.' + key + ' }}');",
+          version: 'v1',
+        },
       },
     ]);
 
     await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA'));
 
-    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'AAA1' }], { source: 'user' });
-    expect(formStub.getFieldValue(['a'])).toBe('AAA1');
+    await runtime.setFormValues(blockCtx, [{ path: ['x'], value: 'AAA2' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA2'));
 
-    for (const key of Object.keys(formStub.__store)) {
-      delete formStub.__store[key];
-    }
-    runtime.resetAfterFormReset();
+    await runtime.setFormValues(blockCtx, [{ path: ['selector'], value: 'y' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('BBB'));
+  });
 
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    expect(formStub.getFieldValue(['a'])).toBeUndefined();
+  it('mode=assign keeps local formValues replacement text literal', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roles: [] });
 
-    await runtime.setFormValues(blockCtx, [{ path: ['selector'], value: 'y' }], { source: 'user' });
-    await runtime.setFormValues(blockCtx, [{ path: ['y'], value: 'BBB2' }], { source: 'user' });
-    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('BBB2'));
+    const blockModel: any = {
+      uid: 'form-assign-local-template-literal',
+      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);
+    blockCtx.defineProperty('locale', { value: 'zh-CN' });
+
+    const usernameField: any = { isAssociationField: () => false, interface: 'input' };
+    const rolesCollection: any = { getField: () => null, filterTargetKey: 'name' };
+    const rolesField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: rolesCollection,
+    };
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'username') return usernameField;
+        if (name === 'roles') return rolesField;
+        return null;
+      },
+    };
+    blockCtx.defineProperty('collection', { value: collection });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'username-from-role-template-literal',
+        enable: true,
+        targetPath: 'username',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+        value: '{{ ctx.formValues.roles.title }}',
+      },
+    ]);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ title: '{{ ctx.locale }}' }] }], {
+      source: 'user',
+    });
+
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('{{ ctx.locale }}'));
   });
 
-  it('skips mode=default form assignment in update form', async () => {
+  it('mode=default follows explicit semantics and stops after user change', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
     const formStub = createFormStub({ b: 'X' });
 
     const blockModel: any = {
-      uid: 'form-assign-update-skip-default',
+      uid: 'form-assign-2',
       flowEngine: { emitter: engineEmitter },
       emitter: blockEmitter,
       dispatchEvent: vi.fn(),
-      getAclActionName: () => 'update',
+      getAclActionName: () => 'create',
     };
 
     const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
@@ -923,12 +1139,12 @@ describe('FormValueRuntime (form assign rules)', () => {
 
     const blockCtx = createFieldContext(runtime);
     const fieldModel: any = {
-      uid: 'field-a-update-skip-default',
+      uid: 'field-a2',
       context: { fieldPathArray: ['a'] },
     };
     blockCtx.defineProperty('engine', {
       value: {
-        getModel: (id: string) => (id === 'field-a-update-skip-default' ? fieldModel : null),
+        getModel: (id: string) => (id === 'field-a2' ? fieldModel : null),
       },
     });
     blockModel.context = blockCtx;
@@ -944,21 +1160,24 @@ describe('FormValueRuntime (form assign rules)', () => {
       },
     ]);
 
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    expect(formStub.getFieldValue(['a'])).toBeUndefined();
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('X'));
+
+    // user writes to target; default mode MUST stop permanently
+    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'user' }], { source: 'user' });
+    expect(formStub.getFieldValue(['a'])).toBe('user');
 
     await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
     await new Promise((resolve) => setTimeout(resolve, 20));
-    expect(formStub.getFieldValue(['a'])).toBeUndefined();
+    expect(formStub.getFieldValue(['a'])).toBe('user');
   });
 
-  it('syncs UI props for mode=default form assignment on configured fields', async () => {
+  it('mode=default follows to-many association subpath changes without clearing on transient empty arrays', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
-    const formStub = createFormStub();
+    const formStub = createFormStub({ roles: [] });
 
     const blockModel: any = {
-      uid: 'form-assign-default-ui-sync',
+      uid: 'form-assign-default-to-many-source',
       flowEngine: { emitter: engineEmitter },
       emitter: blockEmitter,
       dispatchEvent: vi.fn(),
@@ -969,10 +1188,542 @@ describe('FormValueRuntime (form assign rules)', () => {
     runtime.mount({ sync: true });
 
     const blockCtx = createFieldContext(runtime);
-    blockModel.context = blockCtx;
-
-    const fieldCtx = createFieldContext(runtime);
-    fieldCtx.defineProperty('blockModel', { value: blockModel });
+    const usernameField: any = { isAssociationField: () => false, interface: 'input' };
+    const rolesCollection: any = { getField: () => null, filterTargetKey: 'name' };
+    const rolesField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: rolesCollection,
+    };
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'username') return usernameField;
+        if (name === 'roles') return rolesField;
+        return null;
+      },
+    };
+    blockCtx.defineProperty('collection', { value: collection });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'username-from-role-name',
+        enable: true,
+        targetPath: 'username',
+        mode: 'default',
+        condition: { logic: '$and', items: [] },
+        value: '{{ ctx.formValues.roles.name }}',
+      },
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['username'])).toBeUndefined();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ name: 'manager' }] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('manager'));
+
+    // Association selects can briefly carry an incomplete display record while option data is refreshing.
+    // For scalar targets, default mode should not treat that empty aggregate as a real default value.
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ name: null }] }], { source: 'system' });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(formStub.getFieldValue(['username'])).toBe('manager');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ name: 'member' }] }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['username'])).toBe('member'));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['username'], value: 'manual' }], { source: 'user' });
+    await runtime.setFormValues(blockCtx, [{ path: ['roles'], value: [{ name: 'admin' }] }], { source: 'user' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['username'])).toBe('manual');
+  });
+
+  it('mode=override overwrites existing update values until the user changes the target', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ a: 'Existing', b: 'X' });
+
+    const blockModel: any = {
+      uid: 'form-assign-override-update',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    const fieldModel: any = {
+      uid: 'field-a-override-update',
+      context: { fieldPathArray: ['a'] },
+    };
+    blockCtx.defineProperty('engine', {
+      value: {
+        getModel: (id: string) => (id === 'field-a-override-update' ? fieldModel : null),
+      },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'a',
+        mode: 'override',
+        condition: { logic: '$and', items: [] },
+        value: '__B__',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('X'));
+    expect(runtime.canApplyOverrideValuePatch(['a'])).toBe(true);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Y'));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'Manual' }], { source: 'user' });
+    expect(formStub.getFieldValue(['a'])).toBe('Manual');
+    expect(runtime.canApplyOverrideValuePatch(['a'])).toBe(false);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['a'])).toBe('Manual');
+  });
+
+  it('stops mode=override for an association root when the user edits descendant fields', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      b: { id: 2, name: 'Auto' },
+      user: { id: 1, name: 'Existing' },
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-override-association-root',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'user',
+        mode: 'override',
+        condition: { logic: '$and', items: [] },
+        value: '__B__',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['user'])).toEqual({ id: 2, name: 'Auto' }));
+    expect(runtime.canApplyOverrideValuePatch(['user'])).toBe(true);
+
+    lodashSet((formStub as any).__store, ['user'], { id: 3, name: 'Manual' });
+    runtime.handleFormValuesChange({ user: formStub.getFieldValue(['user']) }, formStub.getFieldsValue());
+    expect(runtime.canApplyOverrideValuePatch(['user'])).toBe(false);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: { id: 4, name: 'Next' } }], { source: 'user' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(formStub.getFieldValue(['user'])).toEqual({ id: 3, name: 'Manual' });
+  });
+
+  it('stops mode=override for a subtable relation array after a user edits a row cell', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [
+        { id: 1, name: 'Existing A' },
+        { id: 2, name: 'Existing B' },
+      ],
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-override-subtable-array',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'roles',
+        mode: 'override',
+        condition: { logic: '$and', items: [] },
+        value: [
+          { id: 1, name: 'Auto A' },
+          { id: 2, name: 'Auto B' },
+        ],
+      },
+    ]);
+
+    await waitFor(() =>
+      expect(formStub.getFieldValue(['roles'])).toEqual([
+        { id: 1, name: 'Auto A' },
+        { id: 2, name: 'Auto B' },
+      ]),
+    );
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'name'], 'Manual A');
+    runtime.handleFormFieldsChange([{ name: ['roles', 0, 'name'], touched: true } as any]);
+    runtime.handleFormValuesChange({ roles: formStub.getFieldValue(['roles']) }, formStub.getFieldsValue());
+    expect(runtime.canApplyOverrideValuePatch(['roles'])).toBe(false);
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'roles',
+        mode: 'override',
+        condition: { logic: '$and', items: [] },
+        value: [
+          { id: 1, name: 'Next A' },
+          { id: 2, name: 'Next B' },
+          { id: 3, name: 'Unexpected extra row' },
+        ],
+      },
+    ]);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(formStub.getFieldValue(['roles'])).toEqual([
+      { id: 1, name: 'Manual A' },
+      { id: 2, name: 'Auto B' },
+    ]);
+  });
+
+  it('stops mode=override after a user clears a multiple value array', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ b: 'ready', tags: ['Existing'] });
+
+    const blockModel: any = {
+      uid: 'form-assign-override-multiple-clear',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'tags',
+        mode: 'override',
+        condition: { logic: '$and', items: [{ path: '{{ ctx.formValues.b }}', operator: '$notEmpty', value: '' }] },
+        value: ['A', 'B'],
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['tags'])).toEqual(['A', 'B']));
+    expect(runtime.canApplyOverrideValuePatch(['tags'])).toBe(true);
+
+    lodashSet((formStub as any).__store, ['tags'], []);
+    runtime.handleFormValuesChange({ tags: [] }, formStub.getFieldsValue());
+    expect(runtime.canApplyOverrideValuePatch(['tags'])).toBe(false);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'changed' }], { source: 'user' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(formStub.getFieldValue(['tags'])).toEqual([]);
+  });
+
+  it('stops mode=override after a user removes an item from a multiple value array', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ b: 'ready', tags: ['Existing'] });
+
+    const blockModel: any = {
+      uid: 'form-assign-override-multiple-remove-item',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'tags',
+        mode: 'override',
+        condition: { logic: '$and', items: [{ path: '{{ ctx.formValues.b }}', operator: '$notEmpty', value: '' }] },
+        value: ['A', 'B'],
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['tags'])).toEqual(['A', 'B']));
+    expect(runtime.canApplyOverrideValuePatch(['tags'])).toBe(true);
+
+    lodashSet((formStub as any).__store, ['tags'], ['A']);
+    runtime.handleFormValuesChange({ tags: ['A'] }, formStub.getFieldsValue());
+    expect(runtime.canApplyOverrideValuePatch(['tags'])).toBe(false);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'changed' }], { source: 'user' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(formStub.getFieldValue(['tags'])).toEqual(['A']);
+  });
+
+  it('reapplies mode=override after user edited state is reset', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ a: 'Existing', b: 'X' });
+
+    const blockModel: any = {
+      uid: 'form-assign-override-reset-user-edited',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    const fieldModel: any = {
+      uid: 'field-a-override-reset-user-edited',
+      context: { fieldPathArray: ['a'] },
+    };
+    blockCtx.defineProperty('engine', {
+      value: {
+        getModel: (id: string) => (id === 'field-a-override-reset-user-edited' ? fieldModel : null),
+      },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'a',
+        mode: 'override',
+        condition: { logic: '$and', items: [] },
+        value: '__B__',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('X'));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'Manual' }], { source: 'user' });
+    expect(formStub.getFieldValue(['a'])).toBe('Manual');
+
+    formStub.__store.a = 'Next record';
+    formStub.__store.b = 'Y';
+    runtime.handleFormValuesChange({ a: 'Next record', b: 'Y' }, formStub.getFieldsValue());
+    runtime.resetUserEditedState();
+    expect(runtime.canApplyOverrideValuePatch(['a'])).toBe(true);
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Y'));
+  });
+
+  it('reapplies mode=default value after form reset starts a new create session', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({});
+
+    const blockModel: any = {
+      uid: 'form-assign-reset-reapply-default',
+      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);
+    const fieldModel: any = {
+      uid: 'field-a-reset-reapply-default',
+      context: { fieldPathArray: ['a'] },
+    };
+    blockCtx.defineProperty('engine', {
+      value: {
+        getModel: (id: string) => (id === 'field-a-reset-reapply-default' ? fieldModel : null),
+      },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'a',
+        mode: 'default',
+        condition: { logic: '$and', items: [] },
+        value: 'AAA',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA'));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'AAA1' }], { source: 'user' });
+    expect(formStub.getFieldValue(['a'])).toBe('AAA1');
+
+    formStub.__store.a = undefined;
+    delete formStub.__store.a;
+    runtime.resetAfterFormReset();
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA'));
+  });
+
+  it('resets valuesMirror before rescheduling default rules after form reset', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ selector: 'x', x: 'AAA', y: 'BBB' });
+
+    const blockModel: any = {
+      uid: 'form-assign-reset-values-mirror',
+      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);
+    const fieldModel: any = {
+      uid: 'field-a-reset-values-mirror',
+      context: { fieldPathArray: ['a'] },
+    };
+    blockCtx.defineProperty('engine', {
+      value: {
+        getModel: (id: string) => (id === 'field-a-reset-values-mirror' ? fieldModel : null),
+      },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'a',
+        mode: 'default',
+        condition: { logic: '$and', items: [] },
+        value: '__DYNAMIC__',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('AAA'));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['a'], value: 'AAA1' }], { source: 'user' });
+    expect(formStub.getFieldValue(['a'])).toBe('AAA1');
+
+    for (const key of Object.keys(formStub.__store)) {
+      delete formStub.__store[key];
+    }
+    runtime.resetAfterFormReset();
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['a'])).toBeUndefined();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['selector'], value: 'y' }], { source: 'user' });
+    await runtime.setFormValues(blockCtx, [{ path: ['y'], value: 'BBB2' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('BBB2'));
+  });
+
+  it('skips mode=default form assignment in update form', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ b: 'X' });
+
+    const blockModel: any = {
+      uid: 'form-assign-update-skip-default',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'update',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    const fieldModel: any = {
+      uid: 'field-a-update-skip-default',
+      context: { fieldPathArray: ['a'] },
+    };
+    blockCtx.defineProperty('engine', {
+      value: {
+        getModel: (id: string) => (id === 'field-a-update-skip-default' ? fieldModel : null),
+      },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'a',
+        mode: 'default',
+        condition: { logic: '$and', items: [] },
+        value: '__B__',
+      },
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['a'])).toBeUndefined();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['a'])).toBeUndefined();
+  });
+
+  it('syncs UI props for mode=default form assignment on configured fields', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub();
+
+    const blockModel: any = {
+      uid: 'form-assign-default-ui-sync',
+      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;
+
+    const fieldCtx = createFieldContext(runtime);
+    fieldCtx.defineProperty('blockModel', { value: blockModel });
     fieldCtx.defineProperty('fieldPathArray', { value: ['color'] });
 
     const colorFieldModel: any = {
@@ -1014,6 +1765,116 @@ describe('FormValueRuntime (form assign rules)', () => {
     expect(colorFieldModel.setProps).toHaveBeenCalledWith({ value: '#1677FF' });
   });
 
+  it('syncs mounted field UI props after programmatic form writes', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub();
+
+    const blockModel: any = {
+      uid: 'form-runtime-mounted-field-ui-sync',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    const fieldCtx = createFieldContext(runtime);
+    fieldCtx.defineProperty('blockModel', { value: blockModel });
+    fieldCtx.defineProperty('fieldPathArray', { value: ['username'] });
+
+    const inputFieldModel: any = {
+      setProps: vi.fn(),
+    };
+    const formItemModel: any = {
+      uid: 'form-item-username-runtime-ui-sync',
+      context: fieldCtx,
+      subModels: { field: inputFieldModel },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'username' };
+        }
+        return undefined;
+      },
+      setProps: vi.fn(),
+    };
+
+    blockCtx.defineProperty('engine', {
+      value: {
+        forEachModel: (visit: (model: any) => void) => visit(formItemModel),
+      },
+    });
+
+    runtime.mount({ sync: true });
+
+    await runtime.setFormValues(blockCtx, [{ path: ['username'], value: 'Admin' }], { source: 'system' });
+
+    expect(formStub.getFieldValue(['username'])).toBe('Admin');
+    expect(formItemModel.setProps).toHaveBeenCalledWith({ value: 'Admin' });
+    expect(inputFieldModel.setProps).toHaveBeenCalledWith({ value: 'Admin' });
+  });
+
+  it('syncs mounted field UI props from model index without scanning all models on every write', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub();
+
+    const blockModel: any = {
+      uid: 'form-runtime-mounted-field-ui-index-sync',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    const fieldCtx = createFieldContext(runtime);
+    fieldCtx.defineProperty('blockModel', { value: blockModel });
+    fieldCtx.defineProperty('fieldPathArray', { value: ['username'] });
+
+    const inputFieldModel: any = {
+      setProps: vi.fn(),
+    };
+    const formItemModel: any = {
+      uid: 'form-item-username-runtime-ui-index-sync',
+      context: fieldCtx,
+      subModels: { field: inputFieldModel },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'username' };
+        }
+        return undefined;
+      },
+      setProps: vi.fn(),
+    };
+
+    const forEachModel = vi.fn((visit: (model: any) => void) => visit(formItemModel));
+    blockCtx.defineProperty('engine', {
+      value: {
+        forEachModel,
+      },
+    });
+
+    runtime.mount({ sync: true });
+    engineEmitter.emit('model:mounted', { model: formItemModel });
+    forEachModel.mockClear();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['username'], value: 'Admin' }], { source: 'system' });
+    await runtime.setFormValues(blockCtx, [{ path: ['username'], value: 'Owner' }], { source: 'system' });
+
+    expect(forEachModel).not.toHaveBeenCalled();
+    expect(formItemModel.setProps).toHaveBeenLastCalledWith({ value: 'Owner' });
+    expect(inputFieldModel.setProps).toHaveBeenLastCalledWith({ value: 'Owner' });
+  });
+
   it('linkage assignment takes precedence over mode=assign form assignment', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
@@ -2396,6 +3257,10 @@ describe('FormValueRuntime (form assign rules)', () => {
 
     lodashSet((formStub as any).__store, ['users'], [{ __is_new__: true, name: '' }]);
     runtime.handleFormValuesChange({ users: formStub.getFieldValue(['users']) }, formStub.getFieldsValue());
+    expect((runtime as any).findExplicitHit('users')).toBe('users');
+    expect((runtime as any).findExplicitHit('users[0].name')).toBeNull();
+    expect((runtime as any).findUserEditedHit('users')).toBe('users');
+    expect((runtime as any).findUserEditedHit('users[0].name')).toBeNull();
 
     const row0: any = {
       uid: 'users.name',