@nocobase/client-v2 2.1.0-alpha.23 → 2.1.0-alpha.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-alpha.23",
+  "version": "2.1.0-alpha.25",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -24,9 +24,9 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/flow-engine": "2.1.0-alpha.23",
-    "@nocobase/sdk": "2.1.0-alpha.23",
-    "@nocobase/shared": "2.1.0-alpha.23",
+    "@nocobase/flow-engine": "2.1.0-alpha.25",
+    "@nocobase/sdk": "2.1.0-alpha.25",
+    "@nocobase/shared": "2.1.0-alpha.25",
     "antd": "5.24.2",
     "classnames": "^2.3.1",
     "dayjs": "^1.11.10",
@@ -35,5 +35,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "baa19dafe25e85b680b2fea7451f202831930c1c"
+  "gitHead": "63e4aaa625f3108fe41238e85bb13dee37fe1f48"
 }

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

@@ -8,11 +8,21 @@
  */
 
 import { PlusOutlined } from '@ant-design/icons';
-import { AddSubModelButton, DragOverlayConfig, FlowSettingsButton } from '@nocobase/flow-engine';
+import {
+  AddSubModelButton,
+  DragOverlayConfig,
+  FlowSettingsButton,
+  buildSubModelGroups,
+  buildSubModelItems,
+  type SubModelItem,
+  type SubModelItemsType,
+} from '@nocobase/flow-engine';
 import React from 'react';
 import { FilterManager } from '../blocks/filter-manager/FilterManager';
 import { GridModel } from './GridModel';
 
+const SELECT_SCENE_ALLOWED_OTHER_BLOCK_MODELS = ['JSBlockModel', 'IframeBlockModel', 'MarkdownBlockModel'] as const;
+
 export class BlockGridModel extends GridModel {
   dragOverlayConfig: DragOverlayConfig = {
     // 列内插入
@@ -53,6 +63,36 @@ export class BlockGridModel extends GridModel {
     return this.context.filterManager;
   }
 
+  get addBlockItems(): SubModelItemsType | undefined {
+    if (this.context.view?.inputArgs?.scene !== 'select') {
+      return undefined;
+    }
+
+    return async (ctx) => {
+      const items = await buildSubModelGroups(['DataBlockModel', 'FilterBlockModel'])(ctx);
+      const allowedOtherBlockModels = SELECT_SCENE_ALLOWED_OTHER_BLOCK_MODELS.filter((modelName) =>
+        Boolean(ctx.engine.getModelClass(modelName)),
+      );
+      const otherBlockItems = (
+        await Promise.all(allowedOtherBlockModels.map((modelName) => buildSubModelItems(modelName)(ctx)))
+      )
+        .flat()
+        .sort((a, b) => (a.sort ?? 1000) - (b.sort ?? 1000));
+
+      if (otherBlockItems.length > 0) {
+        items.push({
+          key: 'select-scene-other-blocks',
+          type: 'group',
+          label: ctx.t('Other blocks'),
+          sort: 1000,
+          children: otherBlockItems,
+        } satisfies SubModelItem);
+      }
+
+      return items;
+    };
+  }
+
   serialize() {
     const data = super.serialize();
     data['filterManager'] = this.filterManager.getFilterConfigs();
@@ -60,8 +100,14 @@ export class BlockGridModel extends GridModel {
   }
 
   renderAddSubModelButton() {
+    const items = this.addBlockItems;
     return (
-      <AddSubModelButton model={this} subModelKey="items" subModelBaseClasses={this.subModelBaseClasses}>
+      <AddSubModelButton
+        model={this}
+        subModelKey="items"
+        items={items}
+        subModelBaseClasses={items ? undefined : this.subModelBaseClasses}
+      >
         <FlowSettingsButton icon={<PlusOutlined />} data-flow-add-block>
           {this.context.t('Add block')}
         </FlowSettingsButton>

package/src/flow/models/base/__tests__/BlockGridModel.selectSceneAddBlock.test.ts

@@ -0,0 +1,83 @@
+/**
+ * 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, FlowModel } from '@nocobase/flow-engine';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BlockGridModel } from '../BlockGridModel';
+
+class BlockModel extends FlowModel {}
+BlockModel.define({ label: 'Other blocks' });
+
+class DataBlockModel extends BlockModel {}
+DataBlockModel.define({ label: 'Data blocks' });
+
+class FilterBlockModel extends BlockModel {}
+FilterBlockModel.define({ label: 'Filter blocks' });
+
+class SelectTableBlockModel extends DataBlockModel {}
+SelectTableBlockModel.define({ label: 'Table', children: false });
+
+class SelectFilterBlockModel extends FilterBlockModel {}
+SelectFilterBlockModel.define({ label: 'Filter', children: false });
+
+class JSBlockModel extends BlockModel {}
+JSBlockModel.define({ label: 'JS block' });
+
+class IframeBlockModel extends BlockModel {}
+IframeBlockModel.define({ label: 'Iframe' });
+
+class MarkdownBlockModel extends BlockModel {}
+MarkdownBlockModel.define({ label: 'Markdown' });
+
+class ActionPanelBlockModel extends BlockModel {}
+ActionPanelBlockModel.define({ label: 'Action panel' });
+
+class ReferenceBlockModel extends BlockModel {}
+ReferenceBlockModel.define({ label: 'Block template' });
+
+describe('BlockGridModel - select scene add block menu', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    engine.registerModels({
+      BlockModel,
+      DataBlockModel,
+      FilterBlockModel,
+      BlockGridModel,
+      SelectTableBlockModel,
+      SelectFilterBlockModel,
+      JSBlockModel,
+      IframeBlockModel,
+      MarkdownBlockModel,
+      ActionPanelBlockModel,
+      ReferenceBlockModel,
+    });
+  });
+
+  it('keeps only JS, iframe and markdown under other blocks in select scene', async () => {
+    engine.context.defineProperty('view', { value: { inputArgs: { scene: 'select' } } });
+    const model = engine.createModel<BlockGridModel>({ use: 'BlockGridModel' });
+
+    const itemsSource = model.addBlockItems;
+    expect(typeof itemsSource).toBe('function');
+
+    const items = await itemsSource!(model.context);
+    const otherBlocks = items.find((item) => item.key === 'select-scene-other-blocks');
+
+    expect(otherBlocks).toBeTruthy();
+    expect(otherBlocks?.type).toBe('group');
+    expect(Array.isArray(otherBlocks?.children)).toBe(true);
+
+    const childKeys = (otherBlocks?.children as any[]).map((item) => item.key);
+    expect(childKeys).toEqual(['JSBlockModel', 'IframeBlockModel', 'MarkdownBlockModel']);
+    expect(childKeys).not.toContain('ActionPanelBlockModel');
+    expect(childKeys).not.toContain('ReferenceBlockModel');
+  });
+});

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

@@ -1706,6 +1706,299 @@ describe('FormValueRuntime (form assign rules)', () => {
     expect(formStub.getFieldValue(['users', 0, 'name'])).toBe('');
   });
 
+  it('clears explicit state for deleted to-many rows even when allValues is stale', () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ title: 'Z', __is_new__: true }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-default-create-readd-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 });
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'title'], 'custom');
+    runtime.handleFormFieldsChange([{ name: ['roles', 0, 'title'], touched: true } as any]);
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBe('roles[0].title');
+
+    const staleAllValues = { roles: [{ title: 'custom', __is_new__: true }] };
+    lodashSet((formStub as any).__store, ['roles'], []);
+    runtime.handleFormValuesChange({ roles: [] }, staleAllValues);
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+  });
+
+  it('moves explicit state with filterTargetKey identified to-many rows after deleting a preceding row', () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [
+        { code: 'admin', title: 'same-title' },
+        { code: 'editor', title: 'custom' },
+      ],
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-default-create-shift-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);
+    const roleRowCollection: any = { getField: () => null, filterTargetKey: 'code' };
+    const rolesField: any = { type: 'hasMany', isAssociationField: () => true, targetCollection: roleRowCollection };
+    const rootCollection: any = { getField: (name: string) => (name === 'roles' ? rolesField : null) };
+    blockCtx.defineProperty('collection', { value: rootCollection });
+    blockModel.context = blockCtx;
+
+    lodashSet((formStub as any).__store, ['roles', 1, 'title'], 'same-title');
+    runtime.handleFormFieldsChange([{ name: ['roles', 1, 'title'], touched: true } as any]);
+    expect((runtime as any).findExplicitHit('roles[1].title')).toBe('roles[1].title');
+
+    const shiftedRow = formStub.getFieldValue(['roles', 1]);
+    lodashSet((formStub as any).__store, ['roles'], [shiftedRow]);
+    runtime.handleFormValuesChange({ roles: [shiftedRow] }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[1].title')).toBeNull();
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBe('roles[0].title');
+  });
+
+  it('moves observable binding writes with filterTargetKey identified rows after deleting a preceding row', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ code: 'admin' }, { code: 'editor' }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-default-observable-shift-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);
+    const roleRowCollection: any = { getField: () => null, filterTargetKey: 'code' };
+    const rolesField: any = { type: 'hasMany', isAssociationField: () => true, targetCollection: roleRowCollection };
+    const rootCollection: any = { getField: (name: string) => (name === 'roles' ? rolesField : null) };
+    blockCtx.defineProperty('collection', { value: rootCollection });
+    blockCtx.defineProperty('fieldIndex', { value: ['roles:1'] });
+    blockModel.context = blockCtx;
+
+    const defaultMeta = observable({ label: 'Editor' });
+    await runtime.setFormValues(blockCtx, [{ path: 'roles.meta', value: defaultMeta }], {
+      source: 'linkage',
+      markExplicit: false,
+    });
+
+    expect(formStub.getFieldValue(['roles', 1, 'meta'])).toEqual({ label: 'Editor' });
+
+    const shiftedRow = formStub.getFieldValue(['roles', 1]);
+    lodashSet((formStub as any).__store, ['roles'], [shiftedRow]);
+    runtime.handleFormValuesChange({ roles: [shiftedRow] }, formStub.getFieldsValue());
+
+    defaultMeta.label = 'Updated';
+
+    await waitFor(() => expect(formStub.getFieldValue(['roles', 0, 'meta'])).toEqual({ label: 'Updated' }));
+    expect(formStub.getFieldValue(['roles', 1])).toBeUndefined();
+  });
+
+  it('skips stale to-many row rules after the row index is out of bounds', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ title: 'Z', __is_new__: true, __index__: 'row-1' }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-default-stale-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);
+    const roleRowCollection: any = { getField: () => null };
+    const rolesField: any = { type: 'hasMany', isAssociationField: () => true, targetCollection: roleRowCollection };
+    const rootCollection: any = { getField: (name: string) => (name === 'roles' ? rolesField : null) };
+    blockCtx.defineProperty('collection', { value: rootCollection });
+    blockModel.context = blockCtx;
+
+    const masterModel: any = {
+      uid: 'roles.title',
+      subModels: { field: {} },
+      getStepParams(flowKey: string, stepKey: string) {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'roles.title' };
+        }
+        return undefined;
+      },
+    };
+    const masterCtx = createFieldContext(runtime);
+    masterCtx.defineProperty('blockModel', { value: blockModel });
+    masterCtx.defineProperty('model', { value: masterModel });
+    masterModel.context = masterCtx;
+
+    const staleRow: any = {
+      uid: 'roles.title',
+      isFork: true,
+      forkId: 'roles:stale',
+      subModels: { field: {} },
+      getStepParams(flowKey: string, stepKey: string) {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'roles.title' };
+        }
+        return undefined;
+      },
+    };
+    const staleCtx = createFieldContext(runtime);
+    staleCtx.defineProperty('blockModel', { value: blockModel });
+    staleCtx.defineProperty('fieldIndex', { value: ['roles:1'] });
+    staleCtx.defineProperty('item', {
+      value: {
+        index: 1,
+        length: 1,
+        __is_new__: true,
+        value: { title: 'Z', __is_new__: true, __index__: 'row-1' },
+      },
+    });
+    staleCtx.defineProperty('model', { value: staleRow });
+    staleRow.context = staleCtx;
+    masterModel.forks = new Set([staleRow]);
+
+    blockCtx.defineProperty('engine', {
+      value: {
+        forEachModel: (cb: any) => {
+          cb(masterModel);
+        },
+      },
+    });
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'roles.title',
+        mode: 'default',
+        condition: { logic: '$and', items: [] },
+        value: 'Z',
+      },
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['roles'])).toHaveLength(1);
+    expect(formStub.getFieldValue(['roles', 1])).toBeUndefined();
+  });
+
+  it('skips to-many row rules when filterTargetKey identity does not match the current row at that index', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ code: 'admin', title: '' }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-assign-default-mismatched-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);
+    const roleRowCollection: any = { getField: () => null, filterTargetKey: 'code' };
+    const rolesField: any = { type: 'hasMany', isAssociationField: () => true, targetCollection: roleRowCollection };
+    const rootCollection: any = { getField: (name: string) => (name === 'roles' ? rolesField : null) };
+    blockCtx.defineProperty('collection', { value: rootCollection });
+    blockModel.context = blockCtx;
+
+    const masterModel: any = {
+      uid: 'roles.title',
+      subModels: { field: {} },
+      getStepParams(flowKey: string, stepKey: string) {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'roles.title' };
+        }
+        return undefined;
+      },
+    };
+    const masterCtx = createFieldContext(runtime);
+    masterCtx.defineProperty('blockModel', { value: blockModel });
+    masterCtx.defineProperty('model', { value: masterModel });
+    masterModel.context = masterCtx;
+
+    const mismatchedRow: any = {
+      uid: 'roles.title',
+      isFork: true,
+      forkId: 'roles:mismatched',
+      subModels: { field: {} },
+      getStepParams(flowKey: string, stepKey: string) {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'roles.title' };
+        }
+        return undefined;
+      },
+    };
+    const rowCtx = createFieldContext(runtime);
+    rowCtx.defineProperty('blockModel', { value: blockModel });
+    rowCtx.defineProperty('fieldIndex', { value: ['roles:0'] });
+    rowCtx.defineProperty('item', {
+      value: {
+        index: 0,
+        length: 1,
+        value: { code: 'editor', title: 'custom' },
+      },
+    });
+    rowCtx.defineProperty('model', { value: mismatchedRow });
+    mismatchedRow.context = rowCtx;
+    masterModel.forks = new Set([mismatchedRow]);
+
+    blockCtx.defineProperty('engine', {
+      value: {
+        forEachModel: (cb: any) => {
+          cb(masterModel);
+        },
+      },
+    });
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'roles.title',
+        mode: 'default',
+        condition: { logic: '$and', items: [] },
+        value: 'Z',
+      },
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(formStub.getFieldValue(['roles', 0, 'title'])).toBe('');
+  });
+
   it('keeps default-disabled for edited to-many leaf when onValuesChange only provides top-level path', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();

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

@@ -82,8 +82,9 @@ describe('SubTableColumnModel (nested subform)', () => {
       parentFieldIndex: ['users:0'],
     });
 
-    const rowFork = column.getFork('row:users:0:1');
-    expect(rowFork?.context?.fieldIndex).toEqual(['users:0', 'roles:1']);
+    const [rowFork] = Array.from(column.forks ?? []);
+    expect(rowFork).toBeDefined();
+    expect((rowFork as any)?.context?.fieldIndex).toEqual(['users:0', 'roles:1']);
 
     runtime.syncAssignRules([
       {

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

@@ -17,6 +17,7 @@ import { namePathToPathKey, parsePathString, pathKeyToNamePath } from './path';
 import type { FormAssignRuleItem, FormValueWriteMeta, NamePath, Patch, SetOptions, ValueSource } from './types';
 import { createTxId, isEmptyValue } from './utils';
 import { isToManyAssociationField } from '../../../../internal/utils/modelUtils';
+import { getSubTableRowIdentity } from '../../../fields/AssociationFieldModel/SubTableFieldModel/rowIdentity';
 
 /** Symbol to indicate rule value resolution should be skipped */
 const SKIP_RULE_VALUE = Symbol('SKIP_RULE_VALUE');
@@ -51,6 +52,7 @@ type RuntimeRule = {
 
 type ObservableBinding = {
   source: ValueSource;
+  pathKey: string;
   dispose: () => void;
 };
 
@@ -1172,7 +1174,6 @@ export class RuleEngine {
 
     const ruleContext = this.prepareRuleContext(rule);
     const { baseCtx, targetNamePath, targetKey, clearDeps, disposeBinding } = ruleContext;
-
     if (!this.shouldRunRule(rule, targetNamePath, targetKey, baseCtx)) {
       clearDeps(state);
       disposeBinding();
@@ -1487,18 +1488,59 @@ export class RuleEngine {
     // 编辑态默认值规则：
     // - 顶层编辑表单：不应用默认值
     // - 子表单：仅对“新增行/新增对象”（__is_new__ = true）应用默认值
-    let item: any;
+    return this.getItemContext(baseCtx)?.__is_new__ === true;
+  }
+
+  private isStaleToManyItemContext(baseCtx: any): boolean {
+    const item = this.getItemContext(baseCtx);
+    if (!Number.isFinite(item?.index) || !Number.isFinite(item?.length)) return false;
+    return item.index < 0 || item.index >= item.length;
+  }
+
+  private getItemContext(baseCtx: any) {
     try {
-      item = baseCtx?.item;
+      return baseCtx?.item;
     } catch {
-      item = undefined;
+      return undefined;
     }
+  }
 
-    if (!item || typeof item !== 'object') {
-      return false;
+  private getRowTargetKey(baseCtx: any, rowPath: NamePath): string | string[] {
+    let collection = this.getRootCollection() || this.getCollectionFromContext(baseCtx);
+    let field: any;
+    for (const seg of rowPath) {
+      if (typeof seg === 'number') continue;
+      if (typeof seg !== 'string' || !seg || !collection?.getField) break;
+
+      field = collection?.getField?.(seg);
+      if (!field?.isAssociationField?.()) break;
+      collection = field?.targetCollection;
     }
 
-    return item.__is_new__ === true;
+    const raw = field?.targetCollection?.filterTargetKey ?? field?.targetCollection?.filterByTk ?? field?.targetKey;
+    if (Array.isArray(raw)) {
+      const keys = raw.filter((key): key is string => typeof key === 'string' && !!key);
+      return keys.length ? keys : 'id';
+    }
+    return typeof raw === 'string' && raw ? raw : 'id';
+  }
+
+  private isMismatchedToManyItemContext(baseCtx: any, targetNamePath: NamePath): boolean {
+    const item = this.getItemContext(baseCtx);
+    if (!item) return false;
+
+    for (let i = targetNamePath.length - 1; i >= 0; i--) {
+      if (typeof targetNamePath[i] !== 'number') continue;
+
+      const rowPath = targetNamePath.slice(0, i + 1);
+      const targetKey = this.getRowTargetKey(baseCtx, rowPath);
+      const currentRow = this.options.getFormValueAtPath(rowPath);
+      const currentIdentity = getSubTableRowIdentity(currentRow, targetKey);
+      const itemIdentity = getSubTableRowIdentity(item.value, targetKey);
+      return !!currentIdentity && !!itemIdentity && currentIdentity !== itemIdentity;
+    }
+
+    return false;
   }
 
   private shouldRunRule(
@@ -1509,6 +1551,8 @@ export class RuleEngine {
   ): boolean {
     if (!rule.getEnabled()) return false;
     if (!targetNamePath || !targetKey) return false;
+    if (this.isStaleToManyItemContext(baseCtx)) return false;
+    if (this.isMismatchedToManyItemContext(baseCtx, targetNamePath)) return false;
     if (rule.source === 'default') {
       if (!this.shouldApplyDefaultRuleInCurrentState(baseCtx)) return false;
       if (this.options.findExplicitHit(targetKey)) return false;
@@ -1808,6 +1852,19 @@ export class RuleEngine {
       }
     })();
 
+    // Row/grid rules resolve target paths through fieldIndex (for example `roles.title`
+    // -> `roles[1].title`). When a row is deleted or reordered, the rule must reschedule
+    // even if its value/condition does not reference ctx.item directly.
+    const fieldIndex = baseCtx?.model?.context?.fieldIndex ?? baseCtx?.fieldIndex;
+    const shouldWatchFieldIndex = Array.isArray(fieldIndex) && fieldIndex.some((it) => typeof it === 'string');
+    if (shouldWatchFieldIndex) {
+      const fieldIndexDisposer = reaction(
+        () => this.getFieldIndexSignature(baseCtx),
+        () => this.scheduleRule(rule.id),
+      );
+      state.depDisposers.push(fieldIndexDisposer);
+    }
+
     for (const depKey of deps) {
       if (depKey === 'fv:*') {
         continue;
@@ -1841,14 +1898,9 @@ export class RuleEngine {
       const subPath = sep >= 0 ? rest.slice(sep + 1) : '';
       const depPath = subPath ? (parsePathString(subPath).filter((seg) => typeof seg !== 'object') as NamePath) : [];
 
-      // 特殊变量：item 为 RuleEngine 注入的计算属性（不直接存在于 baseCtx 上），其 parentItem/index 链依赖 fieldIndex。
+      // 特殊变量：item 为 RuleEngine 注入的计算属性（不直接存在于 baseCtx 上）。
+      // fieldIndex 的变化已统一在上面监听，这里只补 item 自身取值的依赖。
       if (varName === 'item') {
-        const fieldIndexDisposer = reaction(
-          () => this.getFieldIndexSignature(baseCtx),
-          () => this.scheduleRule(rule.id),
-        );
-        state.depDisposers.push(fieldIndexDisposer);
-
         if (depPath.length) {
           const trackingFormValues = this.options.createTrackingFormValues({ deps: new Set(), wildcard: false });
           const itemValueDisposer = reaction(