@dazhicheng/ui 1.5.215 → 1.5.217

package/dist/components/tt-form/src/group-form/groupFormApi.js

@@ -1,10 +1,10 @@
-var M = Object.defineProperty;
-var A = (u, c, e) => c in u ? M(u, c, { enumerable: !0, configurable: !0, writable: !0, value: e }) : u[c] = e;
-var n = (u, c, e) => A(u, typeof c != "symbol" ? c + "" : c, e);
+var C = Object.defineProperty;
+var V = (h, f, e) => f in h ? C(h, f, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[f] = e;
+var l = (h, f, e) => V(h, typeof f != "symbol" ? f + "" : f, e);
 import "axios";
 import "element-plus";
-import { isFunction as S, isString as b, isBoolean as G } from "../../../../packages/utils/src/is.js";
-import { ref as N, reactive as p, nextTick as C } from "vue";
+import { isString as F, isFunction as v, isBoolean as E } from "../../../../packages/utils/src/is.js";
+import { ref as b, reactive as A, computed as T, nextTick as R } from "vue";
 import "xe-utils";
 import "dayjs";
 import "dayjs/plugin/utc";
@@ -14,13 +14,24 @@ import "../../../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/ae
 import "../../../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-utf8.js";
 import "../../../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ecb.js";
 import "../../../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-pkcs7.js";
-import { isPlainObject as f, get as v, cloneDeep as V } from "lodash-es";
-import { FormApi as P } from "../formApi.js";
-import { resolveValueByFieldName as E } from "../form-render/dependencies.js";
-import { resolveSchemaFieldInitialValue as k } from "../useFormContext.js";
-import { normalizeArrayFieldPath as y, childArrayPath as H } from "../utils/array-path.js";
-import { extractFlatSchemas as m, collectDefaultCollapseStates as w, getGroupValues as K, cloneSchemaTree as _, insertFieldsByPosition as O, removeFieldsFromGroup as j, removeGroupsFromGroup as T, isGroupSchema as R, isRowSchema as x } from "./utils.js";
-class ae extends P {
+import { isPlainObject as S, get as N, cloneDeep as K, isEqual as H } from "lodash-es";
+import { validate as k } from "vee-validate";
+import { toTypedSchema as O } from "@vee-validate/zod";
+import { FormApi as x } from "../formApi.js";
+import { resolveRequiredRuleName as j, resolveValueByFieldName as P } from "../form-render/dependencies.js";
+import { resolveArraySchemasForRuntime as W, resolveSchemaFieldInitialValue as $ } from "../useFormContext.js";
+import { normalizeArrayFieldPath as _, childArrayPath as I } from "../utils/array-path.js";
+import { extractFlatSchemas as g, collectDefaultCollapseStates as M, getGroupValues as q, cloneSchemaTree as y, insertFieldsByPosition as D, removeFieldsFromGroup as B, removeGroupsFromGroup as L, isGroupSchema as z, isRowSchema as X } from "./utils.js";
+function Y(h) {
+  if (h) {
+    if (F(h))
+      return h;
+    if (v(h.safeParse))
+      return O(h);
+  }
+}
+const J = 20;
+class Se extends x {
   /**
    * @param {TtFormProps} formProps - 底层表单配置（已展平的 schema、layout 等）
    * @param {GroupFormApiOptions} groupOptions - 分组场景专属配置
@@ -28,75 +39,105 @@ class ae extends P {
   constructor(e, t) {
     super(e);
     /** 是否启用虚拟化（IntersectionObserver 懒渲染） */
-    n(this, "virtual");
+    l(this, "virtual");
+    /** 是否启用渐进式挂载（分批后台挂载全部字段，挂载后常驻 DOM，用于操作全量 DOM 场景） */
+    l(this, "progressive");
     /** 构造时的导航锚点默认配置，作为 store 未设置时的 fallback */
-    n(this, "_defaultNavAnchorProps");
+    l(this, "_defaultNavAnchorProps");
     /** 校验失败时是否自动滚动到第一个有错误的分组，默认 true */
-    n(this, "_scrollToFirstError");
+    l(this, "_scrollToFirstError");
     /** 滚动容器高度 */
-    n(this, "_containerHeight");
+    l(this, "_containerHeight");
     /** IntersectionObserver rootMargin */
-    n(this, "_rootMargin");
+    l(this, "_rootMargin");
     /** 预估每个表单项高度（px） */
-    n(this, "_estimateFieldHeight");
+    l(this, "_estimateFieldHeight");
     /** 滚动到分组时的顶部偏移量（px），补偿固定元素遮挡 */
-    n(this, "_scrollOffset");
+    l(this, "_scrollOffset");
     /** 各分组折叠状态（key → 是否折叠） */
-    n(this, "collapseStates");
+    l(this, "collapseStates");
     /** 当前被 ifShow 隐藏的分组 key 集合 */
-    n(this, "hiddenGroupKeys");
+    l(this, "hiddenGroupKeys");
     /** 当前被 ifShow 隐藏的字段名集合 */
-    n(this, "hiddenFieldNames");
-    /** 导航各分组的错误数量，validate 后自动更新 */
-    n(this, "navErrorCounts");
-    /** 共享错误缓存，validate 写入 → LazyFormField 挂载时读取恢复 */
-    n(this, "errorCacheMap", /* @__PURE__ */ new Map());
-    /** 重置信号，递增时通知所有 LazyFormField 清空 cachedError */
-    n(this, "resetSignal", N(0));
+    l(this, "hiddenFieldNames");
+    /**
+     * 导航各分组的错误数量（派生自 vee-validate 的 form.errors，已内置合并挂载 pathState 与未挂载 extraErrorsBag）。
+     * 通过 computed 惰性求值：读取时依赖收集 form.errors，任何 setFieldError / validate 之后
+     * 只要 form.errors 变化，导航栏渲染时自动重算，无需手动同步。
+     */
+    l(this, "navErrorCounts");
+    /** navErrorCounts 的响应式来源，reactive Proxy 在读取时依赖注入到此 computed */
+    l(this, "_navErrorCountsRef");
     /** 初始传入的分组 schema（用于 fallback） */
-    n(this, "_initialGroupSchema");
+    l(this, "_initialGroupSchema");
     /** 初始展平后的 flatSchema（用于 fallback） */
-    n(this, "_initialFlatSchema");
+    l(this, "_initialFlatSchema");
     /** 各分组 key → 其直属字段名（不含子分组的字段） */
-    n(this, "_groupFieldMap", {});
+    l(this, "_groupFieldMap", {});
     /** 各分组 key → 其直属子分组 key 列表 */
-    n(this, "_groupChildrenMap", {});
+    l(this, "_groupChildrenMap", {});
     /** 字段名 → 所属分组 key 的反向映射，用于快速判断字段是否属于隐藏分组 */
-    n(this, "_fieldToGroupKey", {});
+    l(this, "_fieldToGroupKey", {});
     /** 子分组 key → 父分组 key 的映射，用于递归向上查找祖先分组是否被隐藏 */
-    n(this, "_groupParentMap", {});
+    l(this, "_groupParentMap", {});
     /** 字段名 → 字段 schema 的映射，用于隐藏清空时读取默认值 */
-    n(this, "_fieldSchemaMap", {});
+    l(this, "_fieldSchemaMap", {});
     /** 分组 key 构建时的去重集合，用于检测重复 key */
-    n(this, "_groupKeySet", /* @__PURE__ */ new Set());
+    l(this, "_groupKeySet", /* @__PURE__ */ new Set());
     /** 是否已执行过 validate，用于控制导航栏错误同步是否需要重新校验未挂载字段 */
-    n(this, "_hasValidated", !1);
+    l(this, "_hasValidated", !1);
+    /** 导航错误同步在单个宏任务窗口内的累计趟数，用于防御非确定性动态规则导致的 errors↔navCount 回环 */
+    l(this, "_navSyncPassCount", 0);
+    /** 是否已安排本窗口的计数重置（宏任务后清零） */
+    l(this, "_navSyncResetScheduled", !1);
+    /** 本轮回环告警是否已输出，避免刷屏 */
+    l(this, "_navSyncLoopWarned", !1);
     /** VirtualGroupForm 组件实例引用，由 useGroupForm 的 h() 渲染时赋值 */
-    n(this, "groupFormRef", N(null));
+    l(this, "groupFormRef", b(null));
     /**
      * @description 响应式读取 store 状态，由 useGroupForm 在运行时注入实现
      * @param {Function} [selector] - 可选的状态选择器
      * @returns {Readonly<Ref<T>>} 响应式状态引用
      */
-    n(this, "useStore");
+    l(this, "useStore");
     const {
-      groupSchema: r,
-      virtual: s = !0,
+      groupSchema: s,
+      virtual: r = !0,
+      progressive: i = !1,
       navAnchorProps: o,
-      scrollToFirstError: i = !0,
-      containerHeight: a = "100%",
-      rootMargin: l = "400px 0px",
-      estimateFieldHeight: h = 52,
-      scrollOffset: d = 0
+      scrollToFirstError: a = !0,
+      containerHeight: n = "100%",
+      rootMargin: u = "400px 0px",
+      estimateFieldHeight: c = 52,
+      scrollOffset: p = 0
     } = t;
-    this.virtual = s, this._defaultNavAnchorProps = { show: !0, ...o }, this._scrollToFirstError = i, this._containerHeight = a, this._rootMargin = l, this._estimateFieldHeight = h, this._scrollOffset = d, this._initialGroupSchema = r, this._initialFlatSchema = m(r), this.collapseStates = p({}), w(r, this.collapseStates), this.hiddenGroupKeys = p(/* @__PURE__ */ new Set()), this.hiddenFieldNames = p(/* @__PURE__ */ new Set()), this.navErrorCounts = p({}), this._buildGroupFieldMap(r), this.setState({
-      groupSchema: r,
+    this.progressive = i, this.virtual = i ? !1 : r, this._defaultNavAnchorProps = { show: !0, ...o }, this._scrollToFirstError = a, this._containerHeight = n, this._rootMargin = u, this._estimateFieldHeight = c, this._scrollOffset = p, this._initialGroupSchema = s, this._initialFlatSchema = g(s), this.collapseStates = A({}), M(s, this.collapseStates), this.hiddenGroupKeys = A(/* @__PURE__ */ new Set()), this.hiddenFieldNames = A(/* @__PURE__ */ new Set()), this._navErrorCountsRef = T(() => this._computeNavErrorCounts()), this.navErrorCounts = new Proxy({}, {
+      get: (m, d) => {
+        if (F(d))
+          return this._navErrorCountsRef.value[d] ?? 0;
+      },
+      has: (m, d) => F(d) ? d in this._navErrorCountsRef.value : !1,
+      ownKeys: () => Reflect.ownKeys(this._navErrorCountsRef.value),
+      getOwnPropertyDescriptor: (m, d) => {
+        if (!F(d)) return;
+        const w = this._navErrorCountsRef.value;
+        if (d in w)
+          return {
+            configurable: !0,
+            enumerable: !0,
+            writable: !1,
+            value: w[d]
+          };
+      }
+    }), this._buildGroupFieldMap(s), this.setState({
+      groupSchema: s,
       navAnchorProps: this._defaultNavAnchorProps,
-      virtual: s,
-      containerHeight: a,
-      rootMargin: l,
-      estimateFieldHeight: h,
-      scrollOffset: d
+      virtual: this.virtual,
+      progressive: i,
+      containerHeight: n,
+      rootMargin: u,
+      estimateFieldHeight: c,
+      scrollOffset: p
     });
   }
   /**
@@ -111,11 +152,11 @@ class ae extends P {
    * @param {Partial<GroupFormState> | ((prev: GroupFormState) => Partial<GroupFormState>)} stateOrFn - 新状态或更新函数
    */
   setState(e) {
-    const t = this.store.state, r = S(e) ? e(t) : e;
-    if (super.setState(e), r.groupSchema === void 0)
+    const t = this.store.state, s = v(e) ? e(t) : e;
+    if (super.setState(e), s.groupSchema === void 0)
       return;
-    const s = this.store.state.groupSchema;
-    !s || s === t.groupSchema || (this._buildGroupFieldMap(s), super.setState({ schema: m(s) }));
+    const r = this.store.state.groupSchema;
+    !r || r === t.groupSchema || (this._buildGroupFieldMap(r), super.setState({ schema: g(r) }));
   }
   /**
    * @description 分组表单以 `groupSchema` 展平结果为字段全集。仅依赖 store 中的 `schema` 时，若与 `groupSchema` 不同步（例如外部只 `setState` 了 `groupSchema`、或合并顺序导致 `schema` 滞后），`setValues` 默认过滤会误删合法字段；此处优先按 `groupSchema` 展平生成白名单。
@@ -123,17 +164,17 @@ class ae extends P {
    */
   getFieldNamesForSetValuesFilter() {
     const e = this.store.state.groupSchema;
-    return e != null && e.length ? m(e).map((t) => t.fieldName).filter((t) => typeof t == "string" && t.length > 0) : super.getFieldNamesForSetValuesFilter();
+    return e != null && e.length ? g(e).map((t) => t.fieldName).filter((t) => F(t) && t.length > 0) : super.getFieldNamesForSetValuesFilter();
   }
   /**
-   * @description schema 中移除字段后清空 vee 值/错误，并同步清理虚拟列表 errorCacheMap
+   * @description schema 中移除字段后清空 vee 值/错误，并注销对应数组字段句柄
    * @param {string[]} removedFieldNames 已移除的 fieldName 列表
    */
   onRemovedSchemaFields(e) {
     if (e.length) {
       super.onRemovedSchemaFields(e);
       for (const t of e)
-        this.errorCacheMap.delete(t), this.unregisterArrayField(t);
+        this.unregisterArrayField(t);
     }
   }
   /**
@@ -149,8 +190,77 @@ class ae extends P {
    * await formApi.validate(undefined, false);
    */
   async validate(e, t) {
-    let r = await super.validate(e);
-    return this.hiddenFieldNames.size > 0 && (r = this._stripHiddenFieldErrors(r)), this.virtual && (this.errorCacheMap.clear(), this._hasValidated = !0, r = await this._validateUnmountedFields(r)), this.navAnchorProps.show && await this.syncNavErrorCountsFromForm(), (t ?? this._scrollToFirstError) && !r.valid && this._scrollToFirstErrorGroup(r.errors), r;
+    var u;
+    const s = ((u = this.form) == null ? void 0 : u.values) ?? {}, r = await this._collectValidationFields(s), i = await this._runFieldValidations(r, s);
+    this._applyFieldErrors(r, i), this._hasValidated = !0;
+    const o = {};
+    for (const c of r) {
+      const p = i[c.name];
+      o[c.name] = { valid: !p, errors: p ? [p] : [] };
+    }
+    const a = {
+      valid: Object.keys(i).length === 0,
+      errors: i,
+      results: o
+    };
+    return (t ?? this._scrollToFirstError) && !a.valid && this._scrollToFirstErrorField(r, i), a;
+  }
+  /**
+   * @description 对收集到的可见字段逐个用 vee-validate 底层 `validate()` 校验，独立字段并发执行。
+   *   规则引擎与挂载态字段完全一致（含 defineRule 自定义规则、zod typed schema、跨字段 target 解析）。
+   * @param {ResolvedValidationField[]} fields - 待校验字段清单
+   * @param {Record<string, any>} values - 整表值，透传给 vee-validate 做跨字段规则解析
+   * @returns {Promise<Record<string, string>>} 字段名 → 首条错误信息（仅含校验失败字段）
+   */
+  async _runFieldValidations(e, t) {
+    const s = await Promise.all(
+      e.map(async (i) => {
+        const o = Y(i.rules);
+        if (!o)
+          return { name: i.name, error: void 0 };
+        const { valid: a, errors: n } = await k(i.value, o, {
+          name: i.name,
+          label: i.label,
+          values: t
+        });
+        return { name: i.name, error: a ? void 0 : n[0] };
+      })
+    ), r = {};
+    for (const i of s)
+      i.error && (r[i.name] = i.error);
+    return r;
+  }
+  /**
+   * @description 把校验结果写回 vee-validate 的错误状态（唯一错误 sink）。
+   *   带 diff 保护：只有当目标错误与当前 form.errors 不一致时才写，避免触发 useGroupForm 里
+   *   `watch(form.errors)` → syncNavErrorCountsFromForm 的无谓回环，并保证回环在有限趟内收敛。
+   * @param {ResolvedValidationField[]} fields - 本轮参与校验的字段（决定要清空/设置哪些字段）
+   * @param {Record<string, string>} errorMap - 字段名 → 错误信息
+   */
+  _applyFieldErrors(e, t) {
+    var r, i, o, a;
+    const s = ((i = (r = this.form) == null ? void 0 : r.errors) == null ? void 0 : i.value) ?? {};
+    for (const n of e) {
+      const u = t[n.name];
+      s[n.name] !== u && ((a = (o = this.form) == null ? void 0 : o.setFieldError) == null || a.call(o, n.name, u));
+    }
+  }
+  /**
+   * @description 清空全部字段错误（含 vee-validate extraErrorsBag 里从未挂载过的残留）。
+   *   vee-validate 的 resetForm 只遍历已挂载的 pathState，不会清 extraErrorsBag 里未挂载路径的错误，
+   *   因此这里显式遍历「展平 schema 顶层字段 + 当前 form.errors 的全部 key（含未挂载/数组行路径）」
+   *   逐个 setFieldError(undefined)，保证重置后未挂载字段的残留错误也被清掉。
+   */
+  _clearAllFieldErrors() {
+    var r, i, o, a;
+    const e = /* @__PURE__ */ new Set(), t = this.store.state.schema ?? this._initialFlatSchema;
+    for (const n of t)
+      n.fieldName && e.add(_(n.fieldName));
+    const s = ((i = (r = this.form) == null ? void 0 : r.errors) == null ? void 0 : i.value) ?? {};
+    for (const n of Object.keys(s))
+      e.add(n);
+    for (const n of e)
+      (a = (o = this.form) == null ? void 0 : o.setFieldError) == null || a.call(o, n, void 0);
   }
   /**
    * @description 校验并提交表单
@@ -166,13 +276,13 @@ class ae extends P {
    * @param {Partial<ResetFormOpts>} [opts] - 重置选项
    */
   async resetForm(e, t) {
-    return this.virtual && (this._clearAllCachedErrors(), this._hasValidated = !1), this.navAnchorProps.show && this._clearNavErrorCounts(), await super.resetForm(e, t);
+    return this._clearAllFieldErrors(), this._hasValidated = !1, await super.resetForm(e, t);
   }
   /**
-   * @description 重置校验状态（含清空虚拟字段错误缓存和导航错误计数）
+   * @description 重置校验状态（同时清空虚拟字段错误缓存；navErrorCounts 由 form.errors 派生，自动更新）
    */
   async resetValidate() {
-    return this.virtual && (this._clearAllCachedErrors(), this._hasValidated = !1), this.navAnchorProps.show && this._clearNavErrorCounts(), await super.resetValidate();
+    return this._clearAllFieldErrors(), this._hasValidated = !1, await super.resetValidate();
   }
   /**
    * @description 获取表单值
@@ -182,8 +292,8 @@ class ae extends P {
   async getValues(e = !1) {
     const t = await super.getValues();
     if (e) {
-      const r = this.store.state.groupSchema ?? this._initialGroupSchema;
-      return K(r, t);
+      const s = this.store.state.groupSchema ?? this._initialGroupSchema;
+      return q(s, t);
     }
     return t;
   }
@@ -192,9 +302,29 @@ class ae extends P {
    * @param {string} key - 分组 key
    */
   scrollToGroup(e) {
-    var r;
+    var s;
     const t = this.groupFormRef.value;
-    (r = t == null ? void 0 : t.scrollToGroup) == null || r.call(t, e);
+    (s = t == null ? void 0 : t.scrollToGroup) == null || s.call(t, e);
+  }
+  /**
+   * @description 滚动到指定字段（借助 LazyFormField 容器的 data-field-anchor 锚点，未挂载也可定位）。
+   *   主要用于「无分组、且虚拟懒渲染尚未挂载」的字段——它们没有分组锚点，基类按 [name] 也找不到 DOM。
+   * @param {string} fieldName - 字段名（完整路径）
+   */
+  scrollToField(e) {
+    var s;
+    const t = this.groupFormRef.value;
+    (s = t == null ? void 0 : t.scrollToField) == null || s.call(t, e);
+  }
+  /**
+   * @description 等待渐进式挂载完成（所有字段已渲染进 DOM）。用于需要操作全量 DOM 的场景
+   *   （截图、导出、爬虫等）前调用。非 progressive 模式下立即 resolve。
+   * @returns {Promise<void>}
+   */
+  whenAllRendered() {
+    var t;
+    const e = this.groupFormRef.value;
+    return ((t = e == null ? void 0 : e.whenAllRendered) == null ? void 0 : t.call(e)) ?? Promise.resolve();
   }
   /**
    * @description 切换分组折叠状态
@@ -216,18 +346,18 @@ class ae extends P {
    *   group 隐藏时额外维护 {@link hiddenGroupKeys} 供导航和渲染判断；
    *   group / row 隐藏时都会清空其下字段校验，并把字段加入 {@link hiddenFieldNames}，使隐藏字段不参与校验。
    *   可见性变化后在下一帧调用 {@link syncNavErrorCountsFromForm}，使「先 validate 再隐藏再显示」时
-   *   导航徽标、{@link errorCacheMap} 与表单项错误展示保持一致。
+   *   导航徽标与表单项错误展示保持一致。
    * @param {string} key - 分组 key
    * @param {boolean} visible - 是否可见
    * @param {string[]} [fieldNames] - 兼容旧内部调用的字段名列表，传入时按字段集合显隐处理
    */
-  setGroupVisible(e, t, r) {
-    if (r) {
-      this.setFieldsVisible(r, t);
+  setGroupVisible(e, t, s) {
+    if (s) {
+      this.setFieldsVisible(s, t);
       return;
     }
-    const s = this.getGroupFieldNames(e);
-    t ? (this.hiddenGroupKeys.delete(e), this._setFieldsHidden(s, !1)) : (this._setFieldsHidden(s, !0), this._clearHiddenFieldValues(s), this.hiddenGroupKeys.add(e)), C(() => {
+    const r = this.getGroupFieldNames(e);
+    t ? (this.hiddenGroupKeys.delete(e), this._setFieldsHidden(r, !1)) : (this._setFieldsHidden(r, !0), this._clearHiddenFieldValues(r), this.hiddenGroupKeys.add(e)), R(() => {
       this.syncNavErrorCountsFromForm();
     });
   }
@@ -237,7 +367,7 @@ class ae extends P {
    * @param {boolean} visible - 是否可见
    */
   setFieldsVisible(e, t) {
-    t ? this._setFieldsHidden(e, !1) : (this._setFieldsHidden(e, !0), this._clearHiddenFieldValues(e)), C(() => {
+    t ? this._setFieldsHidden(e, !1) : (this._setFieldsHidden(e, !0), this._clearHiddenFieldValues(e)), R(() => {
       this.syncNavErrorCountsFromForm();
     });
   }
@@ -259,8 +389,8 @@ class ae extends P {
    * @returns {boolean}
    */
   _matchFieldOrNested(e, t) {
-    const r = y(e), s = y(t);
-    return r === s || r.startsWith(`${s}.`) || r.startsWith(`${s}[`);
+    const s = _(e), r = _(t);
+    return s === r || s.startsWith(`${r}.`) || s.startsWith(`${r}[`);
   }
   /**
    * @description 按当前 store 中的 groupSchema（若无则用初始 schema）重置折叠状态：
@@ -271,7 +401,7 @@ class ae extends P {
     const e = this.store.state.groupSchema ?? this._initialGroupSchema;
     for (const t of Object.keys(this.collapseStates))
       delete this.collapseStates[t];
-    w(e, this.collapseStates);
+    M(e, this.collapseStates);
   }
   /**
    * @description 全量应用分组 schema 树到 store（扁平 schema、groupSchema、分组字段映射、折叠默认值）。
@@ -293,8 +423,8 @@ class ae extends P {
    * formApi.appendFields([newGroup]);
    */
   appendFields(e, t) {
-    const r = this.store.state.groupSchema ?? [], s = _(r);
-    t && (t.before || t.after) ? O(s, e, t) || s.push(...e) : s.push(...e), this._applyGroupSchema(s), this.seedDefaultsForAppendedFields(m(e));
+    const s = this.store.state.groupSchema ?? [], r = y(s);
+    t && (t.before || t.after) ? D(r, e, t) || r.push(...e) : r.push(...e), this._applyGroupSchema(r), this.seedDefaultsForAppendedFields(g(e));
   }
   /**
    * @description 按标识从 groupSchema 树中移除节点，无需全量重建 schema。
@@ -305,22 +435,20 @@ class ae extends P {
    */
   removeFields(e) {
     if (!e.length) return;
-    const t = this.store.state.groupSchema ?? [], r = j(_(t), new Set(e));
-    this._applyGroupSchema(r);
+    const t = this.store.state.groupSchema ?? [], s = B(y(t), new Set(e));
+    this._applyGroupSchema(s);
   }
   /**
    * @description 清理已移除分组的运行时状态（隐藏集、折叠、导航徽标等）
    * @param keysToRemove - 待移除的分组 key（含子分组）
    */
   _purgeRemovedGroupState(e) {
-    for (const r of e)
-      this._setFieldsHidden(this.getGroupFieldNames(r), !1), this.hiddenGroupKeys.delete(r), Reflect.deleteProperty(this.navErrorCounts, r), Reflect.deleteProperty(this.collapseStates, r);
+    for (const s of e)
+      this._setFieldsHidden(this.getGroupFieldNames(s), !1), this.hiddenGroupKeys.delete(s), Reflect.deleteProperty(this.collapseStates, s);
     const t = this.navAnchorProps.extraBadgeCounts;
     if (t)
-      for (const r of e)
-        Reflect.deleteProperty(t, r);
-    for (const r of Object.keys(this.navErrorCounts))
-      r in this._groupFieldMap || Reflect.deleteProperty(this.navErrorCounts, r);
+      for (const s of e)
+        Reflect.deleteProperty(t, s);
   }
   /**
    * @description 按分组 key 移除分组及其子分组（从 groupSchema 树删除），并清空其下字段值与相关状态
@@ -330,123 +458,118 @@ class ae extends P {
    * formApi.removeGroups('group1');
    */
   removeGroups(e) {
-    const t = Array.isArray(e) ? e : [e], r = this._collectGroupKeysWithDescendants(t);
-    if (!r.length)
+    const t = Array.isArray(e) ? e : [e], s = this._collectGroupKeysWithDescendants(t);
+    if (!s.length)
       return;
-    const s = [...new Set(r.flatMap((a) => this.getGroupFieldNames(a, !0)))], o = this.store.state.groupSchema ?? [], i = T(_(o), new Set(r));
-    this._applyGroupSchema(i), s.length && this.onRemovedSchemaFields(s), this._purgeRemovedGroupState(r), this.navAnchorProps.show && this.syncNavErrorCountsFromForm();
+    const r = [...new Set(s.flatMap((a) => this.getGroupFieldNames(a, !0)))], i = this.store.state.groupSchema ?? [], o = L(y(i), new Set(s));
+    this._applyGroupSchema(o), r.length && this.onRemovedSchemaFields(r), this._purgeRemovedGroupState(s), this.navAnchorProps.show && this.syncNavErrorCountsFromForm();
   }
   /**
-   * @description 合并 vee-validate 实时 errors 与虚拟列表未挂载字段的 errorCacheMap，用于导航徽标与输入联动
-   * @returns {Record<string, string>} 合并后的错误映射
+   * @description 读取 vee-validate 的实时 errors（已内置合并挂载字段 pathState 与未挂载字段 extraErrorsBag），
+   *   剔除隐藏字段后作为导航徽标计数来源。不再需要外挂 errorCacheMap——未挂载字段的错误由 setFieldError
+   *   直接写入 vee-validate 的 extraErrorsBag，天然进入 form.errors。
+   * @returns {Record<string, string>} 过滤隐藏字段后的错误映射
    */
   _mergeErrorsForNav() {
-    var r, s;
-    const e = (s = (r = this.form) == null ? void 0 : r.errors) == null ? void 0 : s.value, t = {};
+    var s, r;
+    const e = (r = (s = this.form) == null ? void 0 : s.errors) == null ? void 0 : r.value, t = {};
     if (e && typeof e == "object")
-      for (const o of Object.keys(e)) {
-        if (this._isFieldHidden(o)) continue;
-        const i = e[o];
-        i && (t[o] = i);
+      for (const i of Object.keys(e)) {
+        if (this._isFieldHidden(i)) continue;
+        const o = e[i];
+        o && (t[i] = o);
       }
-    return this.virtual && this.errorCacheMap.forEach((o, i) => {
-      this._isFieldHidden(i) || o && t[i] === void 0 && (t[i] = o);
-    }), t;
+    return t;
   }
   /**
-   * @description 同步导航错误计数。
-   *   当开启虚拟列表且已执行过 validate 时，会重新对未挂载字段做可见性检查和校验，
-   *   确保 dependencies 条件变化后错误计数实时更新。
+   * @description 刷新未挂载字段的校验错误，使 dependencies 条件变化后导航徽标即时反映。
+   *   注：`navErrorCounts` 是依赖 form.errors 的 computed 派生量，会自动重算，此方法只负责在
+   *   「已 validate 过」的虚拟列表场景下，重算可见字段错误并写回 form.errors（未挂载字段落 extraErrorsBag）。
+   *   非虚拟化 / 未 validate 过时直接返回，computed 会自然反映 form.errors 现状。
    */
   async syncNavErrorCountsFromForm() {
-    var a, l;
-    if (!this.virtual || !this._hasValidated) {
-      this._updateNavErrorCounts(this._mergeErrorsForNav());
+    if (!this.virtual && !this.progressive || !this._hasValidated)
       return;
-    }
     const e = this.form;
-    if (!(e != null && e.values)) {
-      this._updateNavErrorCounts(this._mergeErrorsForNav());
+    if (!(e != null && e.values))
+      return;
+    if (this._navSyncPassCount >= J) {
+      this._navSyncLoopWarned || (this._navSyncLoopWarned = !0);
       return;
     }
-    const t = e.values, r = (l = (a = this.form) == null ? void 0 : a.errors) == null ? void 0 : l.value, s = /* @__PURE__ */ new Set();
-    if (r)
-      for (const h of Object.keys(r))
-        s.add(h);
-    const o = {};
-    if (r && typeof r == "object")
-      for (const h of Object.keys(r)) {
-        if (this._isFieldHidden(h)) continue;
-        const d = r[h];
-        d && (o[h] = d);
-      }
-    const i = this.store.state.schema ?? this._initialFlatSchema;
-    for (const h of i) {
-      const d = h.fieldName;
-      if (!d || s.has(d)) continue;
-      if (!await this._isFieldVisible(h, t)) {
-        this.errorCacheMap.delete(d);
-        continue;
-      }
-      const F = E(t, d), g = await this._validateFieldValue(F, h.rules, d);
-      g ? (this.errorCacheMap.set(d, g), o[d] = g) : this.errorCacheMap.delete(d);
+    this._navSyncPassCount++, this._navSyncResetScheduled || (this._navSyncResetScheduled = !0, setTimeout(() => {
+      this._navSyncPassCount = 0, this._navSyncResetScheduled = !1, this._navSyncLoopWarned = !1;
+    }, 0));
+    const t = e.values, s = await this._collectValidationFields(t), r = await this._runFieldValidations(s, t);
+    this._applyFieldErrors(s, r);
+  }
+  // _clearNavErrorCounts 已移除：navErrorCounts 是派生量，resetForm/resetValidate
+  // 会让 vee-validate 清空 form.errors，computed 自动重算为全 0，无需主动清。
+  /**
+   * @description 校验失败后滚动到第一个错误字段所属的分组。
+   *   按 fields 的文档顺序取第一个出错字段（不是遍历分组"是否含任意错误"，避免总是命中最外层祖先分组），
+   *   定位到该字段直接所属的最内层分组，并展开其整条折叠的祖先链，保证目标在 DOM 中且可见。
+   * @param {ResolvedValidationField[]} fields - 本轮参与校验的字段（已按文档顺序）
+   * @param {Record<string, string>} errorMap - 字段名 → 错误信息
+   */
+  _scrollToFirstErrorField(e, t) {
+    var a;
+    const s = e.find((n) => t[n.name]);
+    if (!s) return;
+    const r = this._getFieldGroupKey(s.name);
+    if (!r) {
+      this.virtual && ((a = this.groupFormRef.value) != null && a.scrollToField) ? this.scrollToField(s.name) : this.scrollToFirstError(s.name);
+      return;
     }
-    this._updateNavErrorCounts(o);
-  }
-  /**
-   * @description 清空导航各分组的错误计数
+    let i = r;
+    const o = [];
+    for (; i; )
+      o.push(i), i = this._groupParentMap[i];
+    for (const n of o.reverse())
+      this.collapseStates[n] && this.toggleCollapse(n);
+    this.scrollToGroup(r);
+  }
+  /**
+   * @description 解析字段在未挂载状态下应使用的有效校验规则：优先取 dependencies.rules 的动态结果，
+   *   为空时回退到静态 schema.rules；两者都为空时，若 dependencies.required 为真则视为 "required"。
+   *   与 FormField.vue 中 currentRules / fieldRules 的计算逻辑保持一致，避免虚拟列表下未挂载字段
+   *   因为只写了 dependencies.required（未写静态 rules）而被漏判为合法。
+   * @param {FormSchema} schema - 字段 schema
+   * @param {Record<string, any>} values - 当前表单值
+   * @returns {Promise<FormSchemaRuleType | undefined>} 有效校验规则
    */
-  _clearNavErrorCounts() {
-    for (const e of Object.keys(this.navErrorCounts))
-      this.navErrorCounts[e] = 0;
-  }
   /**
-   * @description 校验失败后展开包含错误的分组，并滚动到该分组标题
-   * @param {Record<string, string>} errors - 合并后的所有错误
+   * @description 安全执行用户提供的 dependencies 异步回调：捕获异常并降级，避免单个字段的回调抛错
+   *   （或 reject）拖垮整表校验 / 导航同步。故障隔离到字段级，出错时用给定回退值并告警。
+   * @param {() => T | Promise<T>} fn - 用户回调
+   * @param {T} fallback - 出错时的回退值
+   * @param {string} context - 日志上下文（字段名 + 回调类型）
+   * @returns {Promise<T>}
    */
-  _scrollToFirstErrorGroup(e) {
-    const t = this._findFirstErrorGroupKey(e);
-    t && (this.collapseStates[t] && this.toggleCollapse(t), this.scrollToGroup(t));
-  }
-  /**
-   * @description 从校验结果中剔除属于隐藏字段集合的错误，并重新判定 valid 状态
-   * @param {object} result - 校验结果
-   * @returns {object} 过滤后的校验结果
-   */
-  _stripHiddenFieldErrors(e) {
-    const t = {};
-    let r = !1;
-    for (const [s, o] of Object.entries(e.errors))
-      this._isFieldHidden(s) || (t[s] = o, o && (r = !0));
-    return { ...e, errors: t, valid: !r };
-  }
-  /**
-   * @description 对单个字段值执行 rules 校验（纯数据，不挂载组件）。
-   *   支持字符串规则（"required" / "selectRequired"）和 Zod schema。
-   * @param {unknown} value - 字段值
-   * @param {FormSchemaRuleType | undefined} rules - 校验规则
-   * @param {string} fieldName - 字段名
-   * @returns {Promise<string | undefined>} 错误信息，无错误返回 undefined
-   */
-  async _validateFieldValue(e, t, r) {
-    var s;
-    if (t) {
-      if (b(t)) {
-        if (t === "required") {
-          if (e == null || e === "")
-            return "请输入";
-        } else if (t === "selectRequired" && (e == null || Array.isArray(e) && e.length === 0 || e === ""))
-          return "请选择";
-        return;
-      }
-      try {
-        const i = t.safeParse(e);
-        if (!i.success)
-          return ((s = i.error.issues[0]) == null ? void 0 : s.message) || `${r} 校验失败`;
-      } catch {
-      }
+  async _safeInvoke(e, t, s) {
+    try {
+      return await e();
+    } catch {
+      return t;
     }
   }
+  async _resolveEffectiveRules(e, t) {
+    var a;
+    const s = e.dependencies;
+    let r;
+    s && v(s.rules) && (r = await this._safeInvoke(
+      () => s.rules(t, this.form),
+      void 0,
+      `${e.fieldName}.dependencies.rules`
+    ));
+    const i = r || e.rules;
+    let o = !1;
+    return s && v(s.required) && (o = !!await this._safeInvoke(
+      () => s.required(t, this.form),
+      !1,
+      `${e.fieldName}.dependencies.required`
+    )), i ? F(i) ? i : o ? ((a = i == null ? void 0 : i.unwrap) == null ? void 0 : a.call(i)) ?? i : i : o ? j(e.component) : void 0;
+  }
   /**
    * @description 检查字段的 dependencies 条件，判断字段在当前值下是否应该被校验。
    *   与 FormField.vue 保持一致：visible = !hide && isIf && isShow
@@ -454,59 +577,104 @@ class ae extends P {
    * @param {Record<string, any>} values - 当前表单值
    * @returns {Promise<boolean>} 字段是否可见
    */
-  async _isFieldVisible(e, t) {
-    if (e.fieldName && this._isFieldHidden(e.fieldName) || e.hide) return !1;
-    const r = e.dependencies;
-    if (!r) return !0;
-    const s = r.if;
-    if (s != null && (G(s) && !s || S(s) && !await s(t, this.form)))
+  async _isFieldVisible(e, t, s) {
+    const r = s ?? e.fieldName;
+    if (r && this._isFieldHidden(r) || e.hide) return !1;
+    const i = e.dependencies;
+    if (!i) return !0;
+    const o = i.if;
+    if (o != null && (E(o) && !o || v(o) && !await this._safeInvoke(() => o(t, this.form), !0, `${r}.dependencies.if`)))
       return !1;
-    const o = r.show;
-    return !(o != null && (G(o) && !o || S(o) && !await o(t, this.form)));
-  }
-  /**
-   * @description 对所有未挂载的字段做纯值校验，补充到 validate 结果中，
-   *   并将错误写入 errorCacheMap 以便 LazyFormField 挂载时恢复。
-   *   会跳过因 dependencies.if 条件不满足而不应渲染的字段，与原始表单校验行为一致。
-   * @param {object} validateResult - 父类 validate 返回的校验结果
-   * @returns {Promise<object>} 补充未挂载字段错误后的校验结果
-   */
-  async _validateUnmountedFields(e) {
-    const t = this.form;
-    if (!(t != null && t.values)) return e;
-    const r = t.values, s = new Set(Object.keys(e.results || {})), o = {}, i = this.store.state.schema ?? this._initialFlatSchema;
-    for (const a of i) {
-      const l = a.fieldName;
-      if (!l || s.has(l) || !await this._isFieldVisible(a, r)) continue;
-      const h = E(r, l), d = await this._validateFieldValue(h, a.rules, l);
-      d && (o[l] = d, this.errorCacheMap.set(l, d));
-    }
-    return Object.keys(o).length > 0 ? {
-      valid: !1,
-      errors: { ...e.errors, ...o },
-      results: e.results
-    } : e;
+    const a = i.show;
+    return !(a != null && (E(a) && !a || v(a) && !await this._safeInvoke(() => a(t, this.form), !0, `${r}.dependencies.show`)));
   }
   /**
-   * @description 清空所有缓存的错误并递增重置信号
+   * @description 收集当前需要校验的全部可见字段（顶层字段 + 数组行递归展开的行内字段）。
+   *   统一 validate / syncNavErrorCountsFromForm 的字段来源，避免两份平行遍历逻辑走偏。
+   *   - 顶层字段：遍历展平 schema，逐个走 {@link _isFieldVisible} 过滤（hide / dependencies.if / dependencies.show / 隐藏分组）。
+   *   - 数组字段（useArraySchema）：字段自身规则按普通字段收集（与未挂载路径旧行为一致，也顺带覆盖挂载态），
+   *     再从 form.values 取当前数组值，按行调用 {@link resolveArraySchemasForRuntime}（safeMutations 只读，无副作用）
+   *     展开行内字段，递归处理嵌套数组。行内字段路径与 FormArrayRegister 渲染时的注册键完全一致。
+   * @param {Record<string, any>} values - 当前表单值
+   * @returns {Promise<ResolvedValidationField[]>} 扁平化的待校验字段清单
    */
-  _clearAllCachedErrors() {
-    this.errorCacheMap.clear(), this.resetSignal.value++;
+  async _collectValidationFields(e) {
+    const t = this.store.state.schema ?? this._initialFlatSchema;
+    return (await Promise.all(
+      t.map((r) => this._collectFieldRecursive(r, r.fieldName, e))
+    )).flat();
+  }
+  /**
+   * @description 递归收集单个 schema 节点的可校验字段。普通字段直接产出；
+   *   数组字段先产出自身规则，再按当前值逐行展开行内字段（含嵌套数组）。
+   * @param {FormSchema} schema - 字段 schema（顶层或行内）
+   * @param {string} fieldName - 该字段的完整路径（行内字段已拼好数组下标路径）
+   * @param {Record<string, any>} values - 当前表单值
+   * @returns {Promise<ResolvedValidationField[]>} 该节点（含数组行内字段）产出的字段清单，按文档顺序排列
+   */
+  async _collectFieldRecursive(e, t, s) {
+    if (!t) return [];
+    if (!await this._isFieldVisible(e, s, t)) return [];
+    const r = [], i = await this._resolveEffectiveRules(e, s);
+    if (i && r.push({
+      name: t,
+      label: F(e.label) ? e.label : void 0,
+      rules: i,
+      value: P(s, t)
+    }), !e.useArraySchema) return r;
+    const o = _(t), a = P(s, o);
+    if (!Array.isArray(a) || a.length === 0) return r;
+    const n = t.includes(".") ? t.slice(0, t.lastIndexOf(".")) : void 0, u = await Promise.all(
+      a.map(async (c, p) => {
+        const m = _(`${o}[${p}]`);
+        let d;
+        try {
+          d = W({
+            item: e,
+            arrayPath: o,
+            itemPath: m,
+            index: p,
+            row: c ?? {},
+            arrayLength: a.length,
+            parentItemPath: n,
+            form: s,
+            // 传入 arrayAction：safeMutations 会把它包成只读（push/remove 等变为 no-op），
+            // 既让 arraySchema 里读 ctx.arrayHandle/arrayAction 不至于 NPE，又保证校验阶段无副作用。
+            arrayAction: this.arrayAction,
+            safeMutations: !0
+          });
+        } catch {
+          return [];
+        }
+        return (await Promise.all(
+          d.map(
+            (G) => this._collectFieldRecursive(
+              G,
+              _(`${m}.${G.fieldName}`),
+              s
+            )
+          )
+        )).flat();
+      })
+    );
+    for (const c of u)
+      r.push(...c);
+    return r;
   }
   /**
    * @description 收集分组 key 及其所有子分组 key（去重）
    * @param keys - 起始分组 key 列表
    */
   _collectGroupKeysWithDescendants(e) {
-    const t = /* @__PURE__ */ new Set(), r = (s) => {
-      if (!(!s || t.has(s))) {
-        t.add(s);
-        for (const o of this._groupChildrenMap[s] ?? [])
-          r(o);
+    const t = /* @__PURE__ */ new Set(), s = (r) => {
+      if (!(!r || t.has(r))) {
+        t.add(r);
+        for (const i of this._groupChildrenMap[r] ?? [])
+          s(i);
       }
     };
-    for (const s of e)
-      r(s);
+    for (const r of e)
+      s(r);
     return [...t];
   }
   /**
@@ -515,42 +683,35 @@ class ae extends P {
    * @param {string} [parentKey] - 父分组 key
    */
   _buildGroupFieldMap(e, t) {
-    var r;
+    var s;
     t || (this._groupFieldMap = {}, this._groupChildrenMap = {}, this._fieldToGroupKey = {}, this._groupParentMap = {}, this._fieldSchemaMap = {}, this._groupKeySet.clear());
-    for (const s of e)
-      if (R(s)) {
-        if (this._groupKeySet.has(s.key))
+    for (const r of e)
+      if (z(r)) {
+        if (this._groupKeySet.has(r.key))
           throw new Error(
-            `[GroupFormApi] duplicate group key detected: "${s.key}". Group key must be unique in groupSchema tree.`
+            `[GroupFormApi] duplicate group key detected: "${r.key}". Group key must be unique in groupSchema tree.`
           );
-        this._groupKeySet.add(s.key), this._groupFieldMap[s.key] = [], this._groupChildrenMap[s.key] = [], t && (this._groupParentMap[s.key] = t, (r = this._groupChildrenMap)[t] ?? (r[t] = []), this._groupChildrenMap[t].push(s.key)), this._buildGroupFieldMap(s.children, s.key);
-      } else x(s) ? this._buildGroupFieldMap(s.children, t) : t && "fieldName" in s && s.fieldName ? (this._groupFieldMap[t].push(s.fieldName), this._fieldToGroupKey[s.fieldName] = t, this._fieldSchemaMap[s.fieldName] = s) : "fieldName" in s && s.fieldName && (this._fieldSchemaMap[s.fieldName] = s);
+        this._groupKeySet.add(r.key), this._groupFieldMap[r.key] = [], this._groupChildrenMap[r.key] = [], t && (this._groupParentMap[r.key] = t, (s = this._groupChildrenMap)[t] ?? (s[t] = []), this._groupChildrenMap[t].push(r.key)), this._buildGroupFieldMap(r.children, r.key);
+      } else X(r) ? this._buildGroupFieldMap(r.children, t) : t && "fieldName" in r && r.fieldName ? (this._groupFieldMap[t].push(r.fieldName), this._fieldToGroupKey[r.fieldName] = t, this._fieldSchemaMap[r.fieldName] = r) : "fieldName" in r && r.fieldName && (this._fieldSchemaMap[r.fieldName] = r);
   }
   /**
    * @description 根据错误映射更新导航各分组的错误计数
    * @param {Record<string, string>} errors - 字段错误映射
    */
-  _updateNavErrorCounts(e) {
-    const t = Object.keys(e).filter((r) => !!e[r]);
+  /**
+   * @description 计算导航各分组的错误数量（纯函数：读入 form.errors，返回 { groupKey: count }）。
+   *   仅在 {@link _navErrorCountsRef} 的 computed getter 中调用；不再对外暴露 push 式更新入口。
+   * @returns {Record<string, number>} 各分组的错误数量
+   */
+  _computeNavErrorCounts() {
+    const e = this._mergeErrorsForNav(), t = Object.keys(e).filter((r) => !!e[r]), s = {};
     for (const r of Object.keys(this._groupFieldMap)) {
-      const o = this.getGroupFieldNames(r).filter(
-        (i) => t.some((a) => this._matchFieldOrNested(a, i))
+      const i = this.getGroupFieldNames(r), o = t.filter(
+        (a) => i.some((n) => this._matchFieldOrNested(a, n))
       ).length;
-      this.navErrorCounts[r] = o;
+      s[r] = o;
     }
-  }
-  /**
-   * @description 根据错误字段找到第一个包含错误的分组 key（按 schema 定义顺序）
-   * @param {Record<string, string>} errors - 错误字段映射
-   * @returns {string | undefined} 第一个有错误的分组 key
-   */
-  _findFirstErrorGroupKey(e) {
-    const t = Object.keys(e).filter((r) => e[r]);
-    if (t.length !== 0)
-      for (const r of Object.keys(this._groupFieldMap)) {
-        const s = this.getGroupFieldNames(r);
-        if (s != null && s.some((o) => t.some((i) => this._matchFieldOrNested(i, o)))) return r;
-      }
+    return s;
   }
   /**
    * @description 获取指定分组下的字段名列表，默认会获取该分组下的所有字段
@@ -564,17 +725,17 @@ class ae extends P {
   /**
    * @description 获取指定分组字段名（带防环保护），避免异常 schema 导致递归栈溢出
    */
-  _getGroupFieldNamesWithVisited(e, t, r) {
-    if (r.has(e))
+  _getGroupFieldNamesWithVisited(e, t, s) {
+    if (s.has(e))
       return [];
-    r.add(e);
-    const s = this._groupFieldMap[e] ?? [];
+    s.add(e);
+    const r = this._groupFieldMap[e] ?? [];
     if (!t)
-      return [...s];
-    const o = [...s], i = this._groupChildrenMap[e] ?? [];
-    for (const a of i)
-      o.push(...this._getGroupFieldNamesWithVisited(a, !0, r));
-    return r.delete(e), Array.from(new Set(o));
+      return [...r];
+    const i = [...r], o = this._groupChildrenMap[e] ?? [];
+    for (const a of o)
+      i.push(...this._getGroupFieldNamesWithVisited(a, !0, s));
+    return s.delete(e), Array.from(new Set(i));
   }
   /**
    * @description 获取字段所属分组 key，支持数组/对象嵌套路径回溯到 schema 字段。
@@ -584,9 +745,9 @@ class ae extends P {
   _getFieldGroupKey(e) {
     const t = this._fieldToGroupKey[e];
     if (t) return t;
-    for (const r of Object.keys(this._fieldToGroupKey))
-      if (this._matchFieldOrNested(e, r))
-        return this._fieldToGroupKey[r];
+    for (const s of Object.keys(this._fieldToGroupKey))
+      if (this._matchFieldOrNested(e, s))
+        return this._fieldToGroupKey[s];
   }
   /**
    * @description 判断字段所属分组或祖先分组是否仍处于隐藏状态，用于避免字段显示时绕过仍隐藏的父级分组。
@@ -607,8 +768,8 @@ class ae extends P {
    * @param {boolean} hidden 是否隐藏
    */
   _setFieldsHidden(e, t) {
-    for (const r of e)
-      t ? this.hiddenFieldNames.add(r) : this._hasHiddenGroup(r) || this.hiddenFieldNames.delete(r);
+    for (const s of e)
+      t ? this.hiddenFieldNames.add(s) : this._hasHiddenGroup(s) || this.hiddenFieldNames.delete(s);
   }
   /**
    * @description 生成清空后的值：数组和对象保留结构，叶子值按默认值回填，否则置为 undefined
@@ -618,77 +779,67 @@ class ae extends P {
    */
   _clearValueKeepStructure(e, t) {
     if (Array.isArray(e)) {
-      const r = Array.isArray(t) ? t : [];
-      return e.map((s, o) => this._clearValueKeepStructure(s, r[o] ?? r[0]));
+      const s = Array.isArray(t) ? t : [];
+      return e.map((r, i) => this._clearValueKeepStructure(r, s[i] ?? s[0]));
     }
-    if (f(e)) {
-      const r = f(t) ? t : {};
+    if (S(e)) {
+      const s = S(t) ? t : {};
       return Object.fromEntries(
-        Object.keys(e).map((s) => [
-          s,
-          this._clearValueKeepStructure(v(e, s), v(r, s))
+        Object.keys(e).map((r) => [
+          r,
+          this._clearValueKeepStructure(N(e, r), N(s, r))
         ])
       );
     }
-    if (e === void 0 && (Array.isArray(t) || f(t)))
+    if (e === void 0 && (Array.isArray(t) || S(t)))
       return this._clearValueKeepStructure(t, t);
-    if (t !== void 0 && !Array.isArray(t) && !f(t))
-      return V(t);
+    if (t !== void 0 && !Array.isArray(t) && !S(t))
+      return K(t);
   }
   /**
    * @description 清空隐藏字段的值、校验状态和虚拟错误缓存，数组和对象保留结构
    * @param {string[]} fieldNames 字段名列表
    */
   _clearHiddenFieldValues(e) {
-    var t, r, s, o, i, a, l;
+    var t, s, r, i, o, a, n;
     if (e.length)
-      for (const h of e) {
-        const d = v((t = this.form) == null ? void 0 : t.values, h), F = this._fieldSchemaMap[h] ? k(this._fieldSchemaMap[h]) : void 0;
-        (s = (r = this.form) == null ? void 0 : r.setFieldValue) == null || s.call(r, h, this._clearValueKeepStructure(d, F), !1), (i = (o = this.form) == null ? void 0 : o.setFieldError) == null || i.call(o, h, void 0), (l = (a = this.form) == null ? void 0 : a.setFieldTouched) == null || l.call(a, h, !1), this.errorCacheMap.delete(h);
+      for (const u of e) {
+        const c = N((t = this.form) == null ? void 0 : t.values, u), p = this._fieldSchemaMap[u] ? $(this._fieldSchemaMap[u]) : void 0, m = this._clearValueKeepStructure(c, p);
+        H(c, m) || (r = (s = this.form) == null ? void 0 : s.setFieldValue) == null || r.call(s, u, m, !1), (o = (i = this.form) == null ? void 0 : i.setFieldError) == null || o.call(i, u, void 0), (n = (a = this.form) == null ? void 0 : a.setFieldTouched) == null || n.call(a, u, !1);
       }
   }
   /**
    * @description 卸载分组表单时恢复初始schema
    */
   get arrayAction() {
-    var o;
-    const e = super.arrayAction;
-    let t = ((o = this.resetSignal) == null ? void 0 : o.value) ?? 0;
-    const r = () => {
-      var a;
-      if (!this.navAnchorProps.show) return;
-      const i = ((a = this.resetSignal) == null ? void 0 : a.value) ?? 0;
-      if (i !== t) {
-        t = i, this.syncNavErrorCountsFromForm();
-        return;
-      }
-      this._hasValidated && this.syncNavErrorCountsFromForm();
-    }, s = (i) => y(i);
+    const e = super.arrayAction, t = () => {
+      this.navAnchorProps.show && this._hasValidated && this.syncNavErrorCountsFromForm();
+    }, s = (r) => _(r);
     return {
-      get: (i) => e.get(s(i)),
-      push: (i, a) => {
-        e.push(s(i), a), r();
+      get: (r) => e.get(s(r)),
+      push: (r, i) => {
+        e.push(s(r), i), t();
       },
-      remove: (i, a) => {
-        e.remove(s(i), a), r();
+      remove: (r, i) => {
+        e.remove(s(r), i), t();
       },
-      replace: (i, a) => {
-        e.replace(s(i), a), r();
+      replace: (r, i) => {
+        e.replace(s(r), i), t();
       },
-      update: (i, a, l) => {
-        e.update(s(i), a, l), r();
+      update: (r, i, o) => {
+        e.update(s(r), i, o), t();
       },
-      insert: (i, a, l) => {
-        e.insert(s(i), a, l), r();
+      insert: (r, i, o) => {
+        e.insert(s(r), i, o), t();
       },
-      prepend: (i, a) => {
-        e.prepend(s(i), a), r();
+      prepend: (r, i) => {
+        e.prepend(s(r), i), t();
       },
-      move: (i, a, l) => {
-        e.move(s(i), a, l), r();
+      move: (r, i, o) => {
+        e.move(s(r), i, o), t();
       },
-      swap: (i, a, l) => {
-        e.swap(s(i), a, l), r();
+      swap: (r, i, o) => {
+        e.swap(s(r), i, o), t();
       },
       /**
        * @description 获取嵌套数组路径下的操作器
@@ -696,16 +847,16 @@ class ae extends P {
        * @param index 父数组索引
        * @param childField 子数组字段名
        */
-      at: (i, a, l) => {
-        const h = e.at(H(s(i), a, l));
-        return this._wrapNestedArrayHandle(h, r);
+      at: (r, i, o) => {
+        const a = e.at(I(s(r), i, o));
+        return this._wrapNestedArrayHandle(a, t);
       }
     };
   }
   unmount() {
-    this._applyGroupSchema(_(this._initialGroupSchema)), this.hiddenGroupKeys.clear(), this.hiddenFieldNames.clear(), this.virtual && (this._clearAllCachedErrors(), this._hasValidated = !1), this._clearNavErrorCounts(), super.unmount();
+    this._applyGroupSchema(y(this._initialGroupSchema)), this.hiddenGroupKeys.clear(), this.hiddenFieldNames.clear(), this._clearAllFieldErrors(), this._hasValidated = !1, super.unmount();
   }
 }
 export {
-  ae as GroupFormApi
+  Se as GroupFormApi
 };