@tmagic/form 1.8.0-beta.25 → 1.8.0-beta.27

package/dist/tmagic-form.umd.cjs

@@ -1,16 +1,18 @@
 (function(global, factory) {
-	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("vue"), require("dayjs"), require("dayjs/plugin/utc"), require("@tmagic/design"), require("@tmagic/utils"), require("dayjs/plugin/customParseFormat"), require("@element-plus/icons-vue"), require("@popperjs/core")) : typeof define === "function" && define.amd ? define([
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("vue"), require("async-validator"), require("@tmagic/utils"), require("dayjs"), require("dayjs/plugin/utc.js"), require("@tmagic/design/headless"), require("dayjs/plugin/customParseFormat.js"), require("@tmagic/design"), require("@element-plus/icons-vue"), require("@popperjs/core")) : typeof define === "function" && define.amd ? define([
 		"exports",
 		"vue",
+		"async-validator",
+		"@tmagic/utils",
 		"dayjs",
-		"dayjs/plugin/utc",
+		"dayjs/plugin/utc.js",
+		"@tmagic/design/headless",
+		"dayjs/plugin/customParseFormat.js",
 		"@tmagic/design",
-		"@tmagic/utils",
-		"dayjs/plugin/customParseFormat",
 		"@element-plus/icons-vue",
 		"@popperjs/core"
-	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.TMagicForm = {}, global.Vue, global.dayjs, global.dayjs_plugin_utc, global._tmagic_design, global._tmagic_utils, global.dayjs_plugin_customParseFormat, global._element_plus_icons_vue, global._popperjs_core));
-})(this, function(exports, vue, dayjs, dayjs_plugin_utc, _tmagic_design, _tmagic_utils, dayjs_plugin_customParseFormat, _element_plus_icons_vue, _popperjs_core) {
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.TMagicForm = {}, global.Vue, global.async_validator, global._tmagic_utils, global.dayjs, global.dayjs_plugin_utc_js, global._tmagic_design_headless, global.dayjs_plugin_customParseFormat_js, global._tmagic_design, global._element_plus_icons_vue, global._popperjs_core));
+})(this, function(exports, vue, async_validator, _tmagic_utils, dayjs, dayjs_plugin_utc_js, _tmagic_design_headless, dayjs_plugin_customParseFormat_js, _tmagic_design, _element_plus_icons_vue, _popperjs_core) {
 	Object.defineProperties(exports, {
 		__esModule: { value: true },
 		[Symbol.toStringTag]: { value: "Module" }
@@ -37,23 +39,22 @@
 		enumerable: true
 	}) : target, mod));
 	//#endregion
+	async_validator = __toESM(async_validator, 1);
 	dayjs = __toESM(dayjs, 1);
-	dayjs_plugin_utc = __toESM(dayjs_plugin_utc, 1);
-	dayjs_plugin_customParseFormat = __toESM(dayjs_plugin_customParseFormat, 1);
+	dayjs_plugin_utc_js = __toESM(dayjs_plugin_utc_js, 1);
+	dayjs_plugin_customParseFormat_js = __toESM(dayjs_plugin_customParseFormat_js, 1);
 	//#region packages/form/src/schema.ts
 	var FORM_DIFF_CONFIG_KEY = Symbol("mFormDiffConfig");
 	var FORM_TYPE_MATCH_VALID_KEY = Symbol("mFormTypeMatchValid");
 	/**
-	* 静默模式标记，由 `submitForm` / `validateForm` 以隐藏方式挂载临时表单时 provide（debug 弹层模式不提供）。
+	* 宿主业务上下文，由 `MForm`（或更外层的 Editor）通过 `provide` 下发。
 	*
-	* Container 会基于该标记，并对照 `getSilentLeafFieldTypes()`（默认 `LEAF_FIELD_TYPES`）
-	* 跳过叶子字段的渲染，只保留 FormItem：字段校验由 FormItem 基于 model 值完成，与叶子 UI 组件实例无关。
-	* 重型字段组件（如 vs-code）也可 inject 该标记跳过自身渲染，省去无谓的实例化开销。
+	* 嵌套表单（Link 子表单、FormBox、临时校验表单等）会自动继承最近祖先的 context，
+	* 无需层层透传。
 	*
-	* 注意：仅「挂载无值副作用」（不在 onMounted/watch immediate 中 emit change、不依赖 DOM 计算值）的
-	* 字段组件可以安全跳过，接入前需逐一审计；业务扩展请使用 `registerSilentLeafFieldTypes`。
+	* 配置回调统一通过 `mForm.xxx` 读取，由 formState 的读穿 Proxy 落到这里。
 	*/
-	var FORM_SILENT_MODE_KEY = Symbol("mFormSilentMode");
+	var FORM_CONTEXT_KEY = Symbol("mFormContext");
 	//#endregion
 	//#region node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_freeGlobal.js
 	/** Detect free variable `global` from Node.js. */
@@ -2731,27 +2732,191 @@
 		return baseIsEqual(value, other);
 	}
 	//#endregion
+	//#region node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isEqualWith.js
+	/**
+	* This method is like `_.isEqual` except that it accepts `customizer` which
+	* is invoked to compare values. If `customizer` returns `undefined`, comparisons
+	* are handled by the method instead. The `customizer` is invoked with up to
+	* six arguments: (objValue, othValue [, index|key, object, other, stack]).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to compare.
+	* @param {*} other The other value to compare.
+	* @param {Function} [customizer] The function to customize comparisons.
+	* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	* @example
+	*
+	* function isGreeting(value) {
+	*   return /^h(?:i|ello)$/.test(value);
+	* }
+	*
+	* function customizer(objValue, othValue) {
+	*   if (isGreeting(objValue) && isGreeting(othValue)) {
+	*     return true;
+	*   }
+	* }
+	*
+	* var array = ['hello', 'goodbye'];
+	* var other = ['hi', 'goodbye'];
+	*
+	* _.isEqualWith(array, other, customizer);
+	* // => true
+	*/
+	function isEqualWith(value, other, customizer) {
+		customizer = typeof customizer == "function" ? customizer : void 0;
+		var result = customizer ? customizer(value, other) : void 0;
+		return result === void 0 ? baseIsEqual(value, other, void 0, customizer) : !!result;
+	}
+	//#endregion
+	//#region packages/form/src/utils/fieldInnerConfig.ts
+	/** 内置内部配置（由 `registerBuiltInFields` 写入；`clearFields` 不会清掉） */
+	var builtInInnerConfigs = /* @__PURE__ */ new Map();
+	/** 业务侧登记的内部配置 */
+	var extraInnerConfigs = /* @__PURE__ */ new Map();
+	/**
+	* 登记复合字段的内部配置：无渲染校验遇到该 type 时，用返回值继续遍历内部字段。
+	*
+	* `type` 会按 Container 的规则归一化为中划线形式（`codeSelect` 与 `code-select` 等价）。
+	* 重复登记以最后一次为准，便于业务侧覆盖内置实现。
+	* `builtIn` 登记不受 `deleteFieldInnerConfig` / `clearFieldInnerConfigs` 影响。
+	*
+	* @param type - 字段 type
+	* @param resolve - innerConfig 回调
+	* @param [builtIn=false] - 是否写入内置表
+	*/
+	var registerFieldInnerConfig = (type, resolve, builtIn = false) => {
+		if (typeof type !== "string" || !type || typeof resolve !== "function") return;
+		(builtIn ? builtInInnerConfigs : extraInnerConfigs).set((0, _tmagic_utils.toLine)(type), resolve);
+	};
+	/**
+	* 获取指定 type 的 innerConfig 回调（业务侧优先于内置）。
+	*
+	* @param type - 字段 type
+	* @returns innerConfig 回调；未登记则为 `undefined`
+	*/
+	var getFieldInnerConfig = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		return extraInnerConfigs.get(key) ?? builtInInnerConfigs.get(key);
+	};
+	/**
+	* 删除业务侧登记的 innerConfig（不影响内置）。
+	*
+	* @param type - 字段 type
+	* @returns 是否删除成功
+	*/
+	var deleteFieldInnerConfig = (type) => extraInnerConfigs.delete((0, _tmagic_utils.toLine)(type));
+	/** 清空业务侧登记的 innerConfig（不影响内置；主要用于单测）。 */
+	var clearFieldInnerConfigs = () => extraInnerConfigs.clear();
+	//#endregion
+	//#region packages/form/src/utils/fieldValueEffects.ts
+	/**
+	* @fileoverview 叶子字段登记表：哪些 type 是叶子，以及该字段对表单值的初始化写入。
+	*
+	* 无渲染校验据此判定该 type 没有属于父表单的嵌套字段。
+	* 业务自定义字段通过 `registerField` / `registerFields` 登记。
+	* 内置叶子字段由 `MagicForm.install` 的 `registerBuiltInFields` 写入。
+	* 未登记且没有 innerConfig 的 type：有 `items` 会下钻子项，自身有 `rules` 会校验自身。
+	*
+	* 这里只是登记表。各字段的 effect 写在对应组件同目录的 `fields/<Field>/effect.ts`，
+	* 执行收口在 `collectFields` 的 `applyMountValueEffects`：渲染（`Form.vue`）
+	* 与无渲染（`validateValues`）都在表单值初始化完成后调用它一次，
+	* 字段组件自身不再在 setup 里改写 model。
+	*
+	* @module fieldValueEffects
+	*/
+	/** 内置叶子字段（由 `MagicForm.install` 写入；clearFields 不会清掉） */
+	var builtInLeafFieldTypes = /* @__PURE__ */ new Set();
+	var builtInMountValueEffects = /* @__PURE__ */ new Map();
+	/** 业务侧登记的叶子字段与其挂载副作用 */
+	var extraLeafFieldTypes = /* @__PURE__ */ new Set();
+	var extraMountValueEffects = /* @__PURE__ */ new Map();
+	/**
+	* 登记一个叶子字段 type。由 `registerField` 调用，业务侧请走 `registerField`。
+	*
+	* 传了 `effect` 会覆盖该 type 已有的 extra effect（含覆盖内置）；不传则清掉 extra effect，
+	* 内置 effect 仍生效。
+	*
+	* @param type - 字段 type
+	* @param [effect] - 挂载时改写 model 的副作用
+	* @param [builtIn=false] - 是否写入内置表
+	*/
+	var registerLeafFieldType = (type, effect, builtIn = false) => {
+		if (typeof type !== "string" || !type) return;
+		const key = (0, _tmagic_utils.toLine)(type);
+		const types = builtIn ? builtInLeafFieldTypes : extraLeafFieldTypes;
+		const effects = builtIn ? builtInMountValueEffects : extraMountValueEffects;
+		types.add(key);
+		if (typeof effect === "function") effects.set(key, effect);
+		else if (!builtIn) effects.delete(key);
+	};
+	/**
+	* 是否为叶子字段 type（内置 ∪ 已登记）。
+	*
+	* @param type - 字段 type
+	* @returns 是否为叶子
+	*/
+	var isLeafFieldType = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		return extraLeafFieldTypes.has(key) || builtInLeafFieldTypes.has(key);
+	};
+	/**
+	* 获取指定 type 挂载时改写 model 的副作用（已登记的优先于内置）。
+	*
+	* @param type - 字段 type
+	* @returns 副作用函数；未登记则为 `undefined`
+	*/
+	var getFieldMountValueEffect = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		return extraMountValueEffects.get(key) ?? builtInMountValueEffects.get(key);
+	};
+	/**
+	* 删除业务侧登记的叶子字段（不影响内置；主要用于单测）。
+	*
+	* @param type - 字段 type
+	* @returns 是否删除成功
+	*/
+	var deleteLeafFieldType = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		extraMountValueEffects.delete(key);
+		return extraLeafFieldTypes.delete(key);
+	};
+	/** 清空业务侧登记的叶子字段（不影响内置；主要用于单测）。 */
+	var clearLeafFieldTypes = () => {
+		extraLeafFieldTypes.clear();
+		extraMountValueEffects.clear();
+	};
+	//#endregion
+	//#region packages/form/src/utils/config.ts
+	var $MAGIC_FORM = {};
+	var isGlobalFlat = (0, vue.ref)(false);
+	var setConfig = (option) => {
+		$MAGIC_FORM = option;
+		isGlobalFlat.value = option.flat ?? false;
+	};
+	var getConfig = (key) => $MAGIC_FORM[key];
+	//#endregion
 	//#region packages/form/src/utils/typeMatch.ts
-	dayjs.default.extend(dayjs_plugin_customParseFormat.default);
-	var typeMatchRuleRegistry = /* @__PURE__ */ new Map();
+	dayjs.default.extend(dayjs_plugin_customParseFormat_js.default);
+	var extraTypeMatchRules = /* @__PURE__ */ new Map();
+	var builtInTypeMatchRules = /* @__PURE__ */ new Map();
 	var isPromise = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
-	/** 注册或覆盖某个字段 type 的 typeMatch 校验规则 */
-	var registerTypeMatchRule = (type, validator) => {
-		typeMatchRuleRegistry.set((0, _tmagic_utils.toLine)(type), validator);
-	};
-	/** 批量注册 typeMatch 校验规则 */
-	var registerTypeMatchRules = (rules) => {
-		Object.entries(rules).forEach(([type, validator]) => {
-			registerTypeMatchRule(type, validator);
-		});
+	/** 注册或覆盖某个字段 type 的 typeMatch 校验规则。`builtIn` 登记不受 `clearTypeMatchRules` / `deleteTypeMatchRule` 影响。 */
+	var registerTypeMatchRule = (type, validator, builtIn = false) => {
+		(builtIn ? builtInTypeMatchRules : extraTypeMatchRules).set((0, _tmagic_utils.toLine)(type), validator);
+	};
+	/** 获取某个字段 type 的 typeMatch 校验规则（业务侧优先于内置） */
+	var getTypeMatchRule = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		return extraTypeMatchRules.get(key) ?? builtInTypeMatchRules.get(key);
 	};
-	/** 获取某个字段 type 的自定义 typeMatch 校验规则 */
-	var getTypeMatchRule = (type) => typeMatchRuleRegistry.get((0, _tmagic_utils.toLine)(type));
-	/** 删除某个字段 type 的自定义 typeMatch 校验规则 */
-	var deleteTypeMatchRule = (type) => typeMatchRuleRegistry.delete((0, _tmagic_utils.toLine)(type));
-	/** 清空所有自定义 typeMatch 校验规则 */
+	/** 删除业务侧 typeMatch 校验规则（不影响内置） */
+	var deleteTypeMatchRule = (type) => extraTypeMatchRules.delete((0, _tmagic_utils.toLine)(type));
+	/** 清空业务侧 typeMatch 校验规则（不影响内置） */
 	var clearTypeMatchRules = () => {
-		typeMatchRuleRegistry.clear();
+		extraTypeMatchRules.clear();
 	};
 	/** 本地解析配置函数，避免与 form.ts 循环依赖 */
 	var resolveConfig = (mForm, config, props) => {
@@ -2884,7 +3049,7 @@
 	*/
 	var defaultMessage = (message, fallback, suggestion) => {
 		if (message) return message;
-		return (0, _tmagic_design.appendValidateSuggestion)(fallback, suggestion);
+		return (0, _tmagic_design_headless.appendValidateSuggestion)(fallback, suggestion);
 	};
 	var isEmptyValue = (value) => value === void 0 || value === null || value === "";
 	var isEmptyArray = (value) => Array.isArray(value) && value.length === 0;
@@ -3215,8 +3380,117 @@
 		};
 	};
 	//#endregion
+	//#region packages/form/src/utils/formStateProxy.ts
+	/** 无上下文时共用的空对象，避免每次读取都分配新对象 */
+	var EMPTY_CONTEXT = Object.freeze({});
+	/**
+	* 按优先级分层合并上下文，**靠后的层优先**。
+	*
+	* 用读穿 Proxy 而非 `{ ...a, ...b }`：展开会立即执行 accessor，
+	* 而宿主允许用 `{ get stage() { ... } }` 这类读时求值的描述符。
+	*/
+	var mergeFormContexts = (...layers) => {
+		const stack = layers.filter((layer) => Boolean(layer));
+		if (stack.length === 0) return EMPTY_CONTEXT;
+		if (stack.length === 1) return stack[0];
+		const ordered = stack.slice().reverse();
+		const owner = (k) => ordered.find((layer) => Reflect.has(layer, k));
+		return new Proxy({}, {
+			get: (_t, k) => owner(k)?.[k],
+			has: (_t, k) => Boolean(owner(k)),
+			ownKeys: () => [...new Set(ordered.flatMap((layer) => Reflect.ownKeys(layer)))],
+			getOwnPropertyDescriptor: (_t, k) => {
+				for (const layer of ordered) {
+					const descriptor = Object.getOwnPropertyDescriptor(layer, k);
+					if (descriptor) return {
+						...descriptor,
+						configurable: true
+					};
+				}
+			}
+		});
+	};
+	/**
+	* 存量下发配置沿用 Vue2 时代的写法，把回调第一个参数当组件实例用，靠 `vm.mForm.xxx`
+	* 取表单状态。这类配置除了读，还会往上面挂方法做跨字段通信，例如：
+	*
+	* ```js
+	* vm.mForm.checkPropertyLimit = async (...) => { ... }   // 一个字段的 validator 里挂
+	* await vm.mForm.checkPropertyLimit(...)                 // 另一处再取出来调用
+	* ```
+	*
+	* 所以 `mForm` 必须能指回某个 formState：读能落到 core / context，写能经 `set` trap
+	* 落到 coreState 并持久化。
+	*
+	* 优先级是 core > context > 合成自引用，三者都是刻意的：
+	*
+	* - **core**：`formState.mForm = formState` 这类直写（如 FormPreview 用自建 services 时）
+	*   必须最优先。
+	* - **context**：唯一的生产者是把父 formState 整体当 context 传下来的嵌套表单
+	*   （ComponentForm）。此时 `mForm` 命中 context 指向**父表单**，与 `extendState` 时代
+	*   把父 formState 并入子状态的结果一致，跨字段通信仍落在同一份对象上。父 formState
+	*   本身也是 Proxy，写入照样持久化，所以这里让 context 赢是对的，别「修正」成指向子表单。
+	* - **合成自引用**：前两者都没有时才兜底，让 `vm.mForm.xxx = fn` 落到自己的 coreState。
+	*
+	* 由此推出一条约束：**不要往 context 里塞普通对象充当 `mForm`**。context 通常是 computed
+	* 产物，依赖一变就重建，挂上去的方法会静默丢失。要么直写 core，要么什么都不放交给兜底。
+	*
+	* 枚举语义上合成的自引用表现得像原型链上的属性：`'mForm' in state` 为真，但不出现在
+	* `Object.keys(state)` 里，`getOwnPropertyDescriptor` 也返回 undefined。这是故意的——
+	* 按扩展字段打包 formState 的调用方（如发给 AI 的逻辑）会因循环引用炸掉。
+	*/
+	var SELF_REF_KEY = "mForm";
+	/**
+	* 将 coreState 与宿主业务上下文关联：读取时优先 core，miss 再读穿到 context。
+	*
+	* - `get` 用属性访问而非 `Reflect.get(t, k, receiver)`，避免破坏 Vue reactive 的 `__v_raw`；
+	* - symbol 键一律只走 core，四个 trap 保持一致。context 是业务数据袋，不承载 symbol 键，
+	*   把 Vue / 工具链的内部 symbol 隔离在 core 上才能让 `toRaw` / `isReactive` 判定正确；
+	* - `ownKeys` + `getOwnPropertyDescriptor` 保证 `Object.entries(formState)` 能枚举到扩展字段
+	*   （admin-web-next 的 `pickPanelFormStateExtendFields` 依赖此语义）；
+	* - `set` 写入 coreState，第三方 `formState.xxx = v` 仍生效且优先于 context。
+	*
+	* 独立成文件，避免与 `form.ts` ↔ `typeMatch.ts` 形成循环依赖。
+	*/
+	var createFormStateProxy = (coreState, getContext) => {
+		const resolve = () => {
+			const ctx = (typeof getContext === "function" ? getContext() : (0, vue.unref)(getContext)) || EMPTY_CONTEXT;
+			return ctx === proxy ? EMPTY_CONTEXT : ctx;
+		};
+		const proxy = new Proxy(coreState, {
+			get(t, k) {
+				if (typeof k === "symbol") return Reflect.get(t, k);
+				const v = t[k];
+				if (v !== void 0 || Reflect.has(t, k)) return v;
+				const ctx = resolve();
+				if (k in ctx) return ctx[k];
+				return k === SELF_REF_KEY ? proxy : void 0;
+			},
+			set(t, k, value) {
+				t[k] = value;
+				return true;
+			},
+			has: (t, k) => Reflect.has(t, k) || typeof k !== "symbol" && (k in resolve() || k === SELF_REF_KEY),
+			ownKeys: (t) => [.../* @__PURE__ */ new Set([...Reflect.ownKeys(t), ...Reflect.ownKeys(resolve()).filter((k) => typeof k !== "symbol")])],
+			getOwnPropertyDescriptor: (t, k) => {
+				const own = Reflect.getOwnPropertyDescriptor(t, k);
+				if (own) return own;
+				if (typeof k === "symbol") return void 0;
+				const ctx = resolve();
+				if (!(k in ctx)) return void 0;
+				return {
+					configurable: true,
+					enumerable: true,
+					writable: true,
+					value: ctx[k]
+				};
+			}
+		});
+		return proxy;
+	};
+	//#endregion
 	//#region packages/form/src/utils/form.ts
-	var isTDesignAdapter = () => (0, _tmagic_design.getDesignConfig)("adapterType") === "tdesign-vue-next";
+	var isTDesignAdapter = () => (0, _tmagic_design_headless.getDesignConfig)("adapterType") === "tdesign-vue-next";
 	/**
 	* 将 async-validator（Element Plus）风格的 validator 适配到当前 UI 库。
 	* TDesign 调用签名为 `(val) => boolean | CustomValidateObj | Promise`，无 callback。
@@ -3326,6 +3600,79 @@
 		if (type === "daterange" && !names) return [];
 		return "";
 	};
+	/**
+	* formState 中与表单 props 无关的公共部分：字段注册表、消息组件、post 请求。
+	*
+	* 由渲染式表单（`Form.vue`）与无渲染校验（`createHeadlessFormState`）共用，
+	* 保证两者提供给字段配置（`onChange` / `validator` / 异步 options 等）的能力一致。
+	*/
+	var fallbackMessage = {
+		error: (msg) => console.error(msg),
+		success: (msg) => console.log(msg),
+		warning: (msg) => console.warn(msg),
+		info: (msg) => console.info(msg),
+		closeAll: () => void 0
+	};
+	var fallbackMessageBox = {
+		alert: (msg) => console.log(msg),
+		confirm: (msg) => console.log(msg),
+		close: (msg) => console.log(msg)
+	};
+	var createFormStateBase = (ui) => {
+		const fields = /* @__PURE__ */ new Map();
+		const requestFuc = getConfig("request");
+		return {
+			fields,
+			setField: (prop, field) => fields.set(prop, field),
+			getField: (prop) => fields.get(prop),
+			deleteField: (prop) => fields.delete(prop),
+			$messageBox: ui?.$messageBox ?? fallbackMessageBox,
+			$message: ui?.$message ?? fallbackMessage,
+			post: (options) => {
+				if (requestFuc) return requestFuc({
+					method: "POST",
+					...options
+				});
+			}
+		};
+	};
+	/**
+	* 配置项的 `name` 是否可用于从 model 中下钻取值。
+	*
+	* 供 `Container.vue` 与无渲染校验（`collectValidatableFields`）共用，两者对「该不该下钻」
+	* 的判断必须一致。
+	*/
+	var isValidName = (name) => {
+		const valueType = typeof name;
+		if (valueType !== "string" && valueType !== "symbol" && valueType !== "number") return false;
+		if (name === "") return false;
+		if (valueType === "number") return name >= 0;
+		return true;
+	};
+	/**
+	* 在 `prop` 后追加一段路径。
+	*
+	* 用于容器把 `prop` 透传给子级时再拼上索引 / key（如 group-list 的行、table 的行）。
+	*/
+	var appendProp = (prop = "", key) => `${prop}${prop ? "." : ""}${key}`;
+	/**
+	* 由父级 `prop` 与配置项 `name` 拼出该配置项的完整 `prop`（即 FormItem 的 prop）。
+	*
+	* 调用方传入的 name 已按 `config.name || ''` 归一化，空 name 表示该配置项不占据值路径上的一层，
+	* 此时沿用父级 `prop`。
+	*/
+	var getItemProp = (prop = "", name = "") => name === "" ? prop ?? "" : appendProp(prop, name);
+	/**
+	* 归一化配置项的 `type`：求值动态 type、剥离容器语义的 type、驼峰转中划线、补默认值。
+	*
+	* 供 `Container.vue` 与无渲染校验共用，保证两者分派到的 type 完全一致。
+	*/
+	var resolveItemType = (mForm, config, props) => {
+		let type = "type" in (config || {}) ? config.type : "";
+		type = type && filterFunction(mForm, type, props);
+		if (type === "form" || type === "container") return "";
+		return type?.replace(/([A-Z])/g, "-$1").toLowerCase() || (config?.items ? "" : "text");
+	};
 	var filterFunction = (mForm, config, props) => {
 		if (typeof config === "function") return config(mForm, {
 			values: (0, vue.readonly)(mForm?.initValues || {}),
@@ -3345,18 +3692,18 @@
 		if (config === false) return false;
 		return true;
 	};
-	var getRules = function(mForm, r = [], props, typeMatchValid) {
+	var buildRules = function(mForm, r = [], props, typeMatchValid, adapt = (validator) => validator) {
 		let rules = cloneDeep(r);
 		if (typeof rules === "object" && !Array.isArray(rules)) rules = [rules];
-		if (typeMatchValid?.value && !rules.some((r) => typeof r.typeMatch !== "undefined")) rules.push({ typeMatch: true });
+		if ((0, vue.unref)(typeMatchValid) && !rules.some((r) => typeof r.typeMatch !== "undefined")) rules.push({ typeMatch: true });
 		return rules.map((item) => {
 			if (item.typeMatch) {
-				item.validator = adaptFormValidator(createTypeMatchValidator(mForm, props, item));
+				item.validator = adapt(createTypeMatchValidator(mForm, props, item));
 				return item;
 			}
 			if (typeof item.validator === "function") {
 				const fnc = item.validator;
-				item.validator = adaptFormValidator((rule, value, callback, source, options) => fnc({
+				item.validator = adapt((rule, value, callback, source, options) => fnc({
 					rule,
 					value: props.config.names ? props.model : value,
 					callback,
@@ -3377,6 +3724,18 @@
 			return true;
 		});
 	};
+	var getRules = function(mForm, r = [], props, typeMatchValid) {
+		return buildRules(mForm, r, props, typeMatchValid, adaptFormValidator);
+	};
+	/**
+	* 与 `getRules` 相同，但 validator 保持 async-validator（Element Plus）原生签名，不做 UI 库适配。
+	*
+	* 供无渲染校验（`validateValues`）使用：它直接把规则交给 async-validator 执行，
+	* 不经过 TDesign 的 `validator(val)` 调用约定，因此不能套 `adaptFormValidator`。
+	*/
+	var getNativeRules = function(mForm, r = [], props, typeMatchValid) {
+		return buildRules(mForm, r, props, typeMatchValid);
+	};
 	var initValue = async (mForm, { initValues, config }) => {
 		if (!Array.isArray(config)) throw new Error("config应该为数组");
 		const initValuesCopy = cloneDeep(initValues);
@@ -3393,7 +3752,7 @@
 			let time;
 			if (["x", "timestamp"].includes(format)) time = (0, dayjs.default)(Number.isNaN(Number(v)) ? v : Number(v)).valueOf();
 			else if (typeof v === "string" && v.includes("Z") || v instanceof Date) {
-				dayjs.default.extend(dayjs_plugin_utc.default);
+				dayjs.default.extend(dayjs_plugin_utc_js.default);
 				time = (0, dayjs.default)(v).utcOffset(8).format(format);
 			} else time = (0, dayjs.default)(v).format(format);
 			if (time !== "Invalid Date") return time;
@@ -3417,47 +3776,712 @@
 		if (order === "ascending") data.sort((a, b) => a[prop] - b[prop]);
 		else if (order === "descending") data.sort((a, b) => b[prop] - a[prop]);
 	};
+	var createObjectProp = (prop, key, name) => {
+		if (prop === "") return key;
+		const itemPath = `${prop}`.split(".");
+		if (name) {
+			if (`${itemPath[itemPath.length - 1]}` === `${name}`) return `${[...itemPath.slice(0, -1), key].join(".")}`;
+		}
+		return `${[...itemPath, key].join(".")}`;
+	};
+	//#endregion
+	//#region packages/form/src/utils/tableGroupList.ts
 	/**
-	* 将 extendState 返回的扩展字段合并进 formState。
+	* table / group-list 是同一份配置的两种展示形态，可以互相切换（`TableGroupList.vue`）。
 	*
-	* - data 描述符（普通字段）通过 `formState[key] = value` 写入，走 reactive proxy 的 set，
-	*   触发依赖通知；
-	* - accessor 描述符（`{ get stage() { return ... } }`）按原样 defineProperty，调用方
-	*   可控制读时求值；强制 `configurable: true` 以便下一次合并可再 define。
+	* 本模块收口两种形态之间的配置派生，以及各形态下「子项配置怎么算出来」的规则，
+	* 供渲染（`TableGroupList.vue` / `GroupListItem.vue` / `useTableColumns.ts`）与无渲染校验
+	* （`collectValidatableFields`）共用，避免两条链路各写一份而产生偏差。
+	*/
+	/** group-list 形态的 type（兼容驼峰与中划线两种写法） */
+	var isGroupListType = (type) => type === "groupList" || type === "group-list";
+	/** 按 label 文案长度估算 label 宽度（中文按 20px、其他按 8px，最小 80px） */
+	var calcLabelWidth = (label) => {
+		if (!label) return "0px";
+		const zhLength = label.match(/[^\x00-\xff]/g)?.length || 0;
+		const chLength = label.length - zhLength;
+		return `${Math.max(chLength * 8 + zhLength * 20, 80)}px`;
+	};
+	/** 由 group-list 形态的配置派生出 table 形态所需的配置；本身已是 table 形态则原样返回 */
+	var toTableConfig = (config) => {
+		if (!isGroupListType(config.type)) return config;
+		const source = config;
+		return {
+			...config,
+			type: "table",
+			groupItems: source.items,
+			items: source.tableItems || source.items.map((item) => ({
+				...item,
+				label: item.label || item.text,
+				text: null
+			}))
+		};
+	};
+	/** 由 table 形态的配置派生出 group-list 形态所需的配置；本身已是 group-list 形态则原样返回 */
+	var toGroupListConfig = (config) => {
+		if (isGroupListType(config.type)) return config;
+		const source = config;
+		return {
+			...config,
+			type: "groupList",
+			tableItems: source.items,
+			items: source.groupItems || source.items.map((item) => {
+				const text = item.text || item.label;
+				return {
+					...item,
+					text,
+					labelWidth: calcLabelWidth(text),
+					span: item.span || 12
+				};
+			})
+		};
+	};
+	/**
+	* group-list 每一行渲染的 row 容器配置（`GroupListItem.vue` 渲染的 `Container` 的 config）。
+	*
+	* `keyProp` 由调用方从 `mForm.keyProp` 取，默认 `__key`。
+	*/
+	var getGroupListRowConfig = (config, index, keyProp) => {
+		const key = keyProp || "__key";
+		return {
+			type: "row",
+			span: config.span || 24,
+			items: config.items,
+			labelWidth: config.labelWidth,
+			labelPosition: config.labelPosition,
+			[key]: `${config[key]}${String(index)}`
+		};
+	};
+	/**
+	* 列是否会被渲染成一列（`hidden` 列不渲染，`display` 为假的列也不渲染）。
 	*
-	* 注意：extendState 只能向 formState「新增」字段，不允许覆盖其已有 key。
-	* 调用方可通过 `reservedKeys` 传入合并前已存在的内置 key 快照（keyProp / popperClass /
-	* config / initValues / isCompare / lastValues / parentValues / values / $emit / fields /
-	* post 等），命中这些 key 时统一跳过并告警。
+	* `display` 的求值上下文是表格自身的 props，由调用方通过 `evalDisplay` 注入。
+	*/
+	var isTableColumnRendered = (column, evalDisplay) => column.type !== "hidden" && Boolean(evalDisplay(column.display));
+	/**
+	* 单元格内 `Container` 实际收到的列配置：按行求值 `itemsFunction`，并去掉已在列层面消费过的 `display`。
+	*/
+	var makeTableColumnConfig = (column, row) => {
+		const newConfig = cloneDeep(column);
+		if (typeof column.itemsFunction === "function") newConfig.items = column.itemsFunction(row);
+		delete newConfig.display;
+		return newConfig;
+	};
+	//#endregion
+	//#region packages/form/src/utils/collectFields.ts
+	/** 已登记的 innerConfig 回调自身抛错时抛出（机制故障，不是漏登记） */
+	var FieldInnerConfigError = class extends Error {
+		code = "FIELD_INNER_CONFIG";
+		type;
+		prop;
+		constructor(type, prop, cause) {
+			const reason = cause instanceof Error ? cause.message : String(cause);
+			super(`[MForm] innerConfig for "${type}" at "${prop}" failed: ${reason}`);
+			this.name = "FieldInnerConfigError";
+			this.type = type;
+			this.prop = prop;
+			if (cause instanceof Error) this.cause = cause;
+		}
+	};
+	var isFieldInnerConfigError = (error) => error instanceof FieldInnerConfigError || typeof error === "object" && error !== null && error.code === "FIELD_INNER_CONFIG";
+	/** `effects` 模式下遍历全部配置，不受 display / 折叠状态影响 */
+	var ignoresDisplay = (ctx) => ctx.mode === "effects";
+	var extraContainerWalkers = /* @__PURE__ */ new Map();
+	var builtInContainerWalkers = /* @__PURE__ */ new Map();
+	var registerContainerWalker = (type, walker, builtIn = false) => {
+		if (typeof type !== "string" || !type || typeof walker !== "function") return;
+		const key = (0, _tmagic_utils.toLine)(type);
+		if (builtIn) {
+			builtInContainerWalkers.set(key, walker);
+			return;
+		}
+		extraContainerWalkers.set(key, walker);
+	};
+	var getContainerWalker = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		return extraContainerWalkers.get(key) ?? builtInContainerWalkers.get(key);
+	};
+	var deleteContainerWalker = (type) => extraContainerWalkers.delete((0, _tmagic_utils.toLine)(type));
+	var clearContainerWalkers = () => extraContainerWalkers.clear();
+	var getItems = (config) => config?.items;
+	/**
+	* `resolveItemType` 的静态版本：不求值函数型 `type`，由调用方按「未知」处理。
 	*
-	* 兜底：未传 `reservedKeys` 时，仍会拦截 props 派生的只读 getter 字段（无 setter），
-	* 否则以普通字段形式赋值会让 proxy 的 set trap 抛出
-	* `TypeError: 'set' on proxy: trap returned falsish`。
+	* 两者必须保持一致，否则预扫描判定的 type 与实际遍历的不同，会漏执行 effect。
 	*/
-	var applyExtendState = (formState, state, reservedKeys) => {
-		if (!state) return;
-		for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(state))) {
-			if (reservedKeys?.has(key)) continue;
-			if (!("value" in descriptor)) {
-				descriptor.configurable = true;
-				Object.defineProperty(formState, key, descriptor);
-				continue;
+	var staticItemType = (config) => {
+		const type = "type" in config ? config.type : "";
+		if (type === "form" || type === "container") return "";
+		return `${type || ""}`.replace(/([A-Z])/g, "-$1").toLowerCase() || (config.items ? "" : "text");
+	};
+	/**
+	* 静态预判一份配置子树是否可能触发值初始化写入。
+	*
+	* 只有「确定不会」时才返回 false。函数型 `type`、`itemsFunction`、业务登记的容器遍历器、
+	* 登记了 innerConfig 的复合字段，其运行期结构静态看不出来，一律按可能触发处理。
+	*
+	* 只用在同一份 `items` 会被逐行 / 逐标签页重复展开的地方（table、group-list、dynamic tab）：
+	* 预判成本是 O(子项数)，跳过省下的是 O(行数 × 子项数)，无 effect 的多行表格能省一个量级。
+	* 其余位置不做预判——扫描与遍历的单节点成本相当，扫完再遍历只会更慢。
+	*
+	* 只看 `items`：table / group-list 只遍历当前形态的子项，另一形态的
+	* `tableItems` / `groupItems` 不参与遍历，判定范围与遍历保持一致。
+	*/
+	var mayRunEffects = (config) => {
+		if (!config) return false;
+		if (typeof config.type === "function" || typeof config.itemsFunction === "function") return true;
+		const type = staticItemType(config);
+		if (type === "hidden") return false;
+		if (type) {
+			const key = (0, _tmagic_utils.toLine)(type);
+			if (extraContainerWalkers.has(key)) return true;
+			if (!builtInContainerWalkers.has(key)) {
+				if (getFieldInnerConfig(type) || getFieldMountValueEffect(type)) return true;
+				if (isLeafFieldType(type)) return false;
 			}
-			const targetDescriptor = Object.getOwnPropertyDescriptor(formState, key);
-			if (targetDescriptor && !("value" in targetDescriptor) && typeof targetDescriptor.set !== "function") {
-				console.warn(`[MForm] extendState: "${key}" is a read-only field derived from props and cannot be assigned a plain value. Return it as a getter accessor if you really need to override it.`);
-				continue;
+		}
+		return itemsMayRunEffects(config.items);
+	};
+	var itemsMayRunEffects = (items) => Array.isArray(items) && items.some((item) => mayRunEffects(item));
+	/**
+	* 复刻 `Container.vue` 的 `display`。
+	*
+	* 与渲染的唯一差异：`display: 'expand'`（「展开更多配置」按钮背后的字段）在此视为可见。
+	* 「是否已展开」纯粹是交互状态，不改变字段是否属于这份配置，无渲染校验按配置声明的范围校验。
+	*/
+	var resolveDisplay = (ctx, config, nodeProps) => {
+		if (ignoresDisplay(ctx)) return true;
+		const value = display(ctx.mForm, config?.display, nodeProps);
+		if (value === "expand") return true;
+		return Boolean(value);
+	};
+	var addField = (ctx, node, itemProp, nodeProps) => {
+		if (ctx.mode !== "collect") return;
+		const rules = getNativeRules(ctx.mForm, node.config.rules, nodeProps, ctx.typeMatchValid);
+		if (!rules.length) return;
+		ctx.fields.push({
+			prop: itemProp,
+			rules,
+			config: node.config,
+			model: node.model
+		});
+	};
+	var walkChildren = (ctx, items, model, prop) => {
+		if (!Array.isArray(items)) return;
+		for (const item of items) {
+			if (!item) continue;
+			walkNode(ctx, {
+				config: item,
+				model,
+				prop
+			});
+		}
+	};
+	var getContainerScope = (node) => {
+		const { config, model } = node;
+		const name = config.name || "";
+		return {
+			config,
+			model,
+			name,
+			items: getItems(config),
+			childModel: name ? model?.[name] : model
+		};
+	};
+	/** containers/Tabs.vue */
+	var expandTab = (ctx, node, itemProp) => {
+		const { config, model, name, items, childModel } = getContainerScope(node);
+		const tabsProps = {
+			model,
+			config,
+			prop: itemProp
+		};
+		if (config.dynamic) {
+			if (!name) return;
+			const tabs = model?.[name] || [];
+			if (!tabs.length) return;
+			if (ctx.mode === "effects" && !itemsMayRunEffects(items)) return;
+			tabs.forEach((_tab, tabIndex) => {
+				walkChildren(ctx, items, childModel?.[tabIndex], appendProp(itemProp, tabIndex));
+			});
+			return;
+		}
+		const tabs = ignoresDisplay(ctx) ? items || [] : (items || []).filter((item) => display(ctx.mForm, item?.display, tabsProps));
+		for (const tab of tabs) {
+			const tabName = tab.name;
+			walkChildren(ctx, getItems(tab), tabName ? childModel?.[tabName] : childModel, tabName ? appendProp(itemProp, tabName) : itemProp);
+		}
+	};
+	/** containers/Row.vue → Col.vue：col 用 v-show 控制显隐，始终渲染 */
+	var expandRow = (ctx, node, itemProp) => {
+		const { items, childModel } = getContainerScope(node);
+		walkChildren(ctx, items, childModel, itemProp);
+	};
+	/** containers/Fieldset.vue */
+	var expandFieldset = (ctx, node, itemProp) => {
+		const { config, items, childModel } = getContainerScope(node);
+		if (!childModel) return;
+		const { checkbox } = config;
+		const checkboxName = typeof checkbox === "object" && typeof checkbox.name === "string" ? checkbox.name : "value";
+		const checkboxTrueValue = typeof checkbox === "object" && typeof checkbox.trueValue !== "undefined" ? checkbox.trueValue : 1;
+		if (!ignoresDisplay(ctx) && config.expand && childModel?.[checkboxName] !== checkboxTrueValue) return;
+		walkChildren(ctx, items, childModel, itemProp);
+	};
+	/** containers/Panel.vue：折叠仅 display:none，子项照常渲染 */
+	var expandPanel = (ctx, node, itemProp) => {
+		const { items, childModel } = getContainerScope(node);
+		if (!items?.length) return;
+		walkChildren(ctx, items, childModel, itemProp);
+	};
+	/** containers/Step.vue：非当前步仅 v-show 隐藏，子项照常渲染；prop 基准被重置为 step.name */
+	var expandStep = (ctx, node, _itemProp) => {
+		const { model, items } = getContainerScope(node);
+		for (const step of items || []) {
+			const stepName = step?.name;
+			walkChildren(ctx, getItems(step), stepName ? model?.[stepName] : model, `${stepName}`);
+		}
+	};
+	/**
+	* 遍历 table / group-list。
+	*
+	* `TableGroupList.vue` 按原始 `config.type` 决定初始展示形态（table 或 groupList），
+	* 两种形态的子项结构不同，这里分别复刻（形态间的配置派生复用 `utils/tableGroupList`，
+	* 与渲染式实现同源）：
+	* - table：逐列（跳过 hidden 列与 display 为假的列）× 逐行渲染 Container，行 prop 为 `${prop}.${index}`；
+	* - groupList：逐行渲染一个 row 容器，包含 `items` 全部字段。
+	*
+	* 与渲染的差异：不做分页截断（table）、不跳过折叠行（groupList）。二者都是列表的视图状态，
+	* 与「这些行的值是否合法」无关，无渲染校验覆盖全部行。
+	*/
+	var expandTableGroupList = (ctx, node, itemProp) => {
+		const { config, model } = node;
+		const name = config.name || "";
+		const rows = model?.[name];
+		if (!Array.isArray(rows) || !rows.length) return;
+		if (isGroupListType(config.type)) {
+			const groupListConfig = toGroupListConfig(config);
+			if (ctx.mode === "effects" && !itemsMayRunEffects(groupListConfig.items)) return;
+			rows.forEach((row, index) => {
+				walkNode(ctx, {
+					config: getGroupListRowConfig(groupListConfig, index, ctx.mForm?.keyProp),
+					model: row,
+					prop: appendProp(itemProp, index)
+				});
+			});
+			return;
+		}
+		const tableItems = toTableConfig(config).items;
+		if (!Array.isArray(tableItems)) return;
+		if (ctx.mode === "effects" && !itemsMayRunEffects(tableItems)) return;
+		const tableProps = {
+			model,
+			config,
+			prop: itemProp
+		};
+		const evalDisplay = (display$4) => display(ctx.mForm, display$4, tableProps);
+		const isRendered = (column) => ignoresDisplay(ctx) || isTableColumnRendered(column, evalDisplay);
+		rows.forEach((row, index) => {
+			for (const column of tableItems) {
+				if (!column || !isRendered(column)) continue;
+				walkNode(ctx, {
+					config: makeTableColumnConfig(column, row),
+					model: row,
+					prop: appendProp(itemProp, index)
+				});
 			}
-			formState[key] = state[key];
+		});
+	};
+	/**
+	* 执行某个叶子字段登记的值初始化写入。
+	*
+	* 跑在表单初始化路径上，单个字段的 effect 抛错不应该让整张表单渲染不出来，因此只记录并继续。
+	*/
+	var runMountValueEffect = (ctx, type, node, itemProp) => {
+		const effect = getFieldMountValueEffect(type);
+		if (!effect) return;
+		try {
+			effect({
+				config: node.config,
+				model: node.model,
+				prop: itemProp,
+				mForm: ctx.mForm,
+				values: ctx.values
+			});
+		} catch (e) {
+			console.error(`[MForm] mount value effect for "${type}" at "${itemProp}" failed:`, e);
 		}
 	};
-	var createObjectProp = (prop, key, name) => {
-		if (prop === "") return key;
-		const itemPath = `${prop}`.split(".");
-		if (name) {
-			if (`${itemPath[itemPath.length - 1]}` === `${name}`) return `${[...itemPath.slice(0, -1), key].join(".")}`;
+	/**
+	* 遍历已登记 innerConfig 的复合字段。
+	*
+	* `collect` 模式下回调抛错视为机制故障，包装成 `FieldInnerConfigError` 抛出，由校验流程暴露。
+	* `effects` 模式跑在表单初始化路径上，抛出会让整张表单渲染不出来，因此只记录并跳过该子树。
+	*/
+	var walkInnerConfig = (ctx, type, node, itemProp) => {
+		const resolve = getFieldInnerConfig(type);
+		if (!resolve) return false;
+		let result;
+		try {
+			result = resolve({
+				config: node.config,
+				model: node.model,
+				prop: itemProp,
+				parentProp: node.prop,
+				mForm: ctx.mForm
+			});
+		} catch (e) {
+			if (ctx.mode === "collect") throw new FieldInnerConfigError(type, itemProp, e);
+			console.error(new FieldInnerConfigError(type, itemProp, e));
+			return true;
+		}
+		if (!result) return true;
+		const innerModel = result.model ?? node.model;
+		const innerProp = result.prop ?? itemProp;
+		walkChildren(ctx, Array.isArray(result.config) ? result.config : [result.config], innerModel, innerProp);
+		return true;
+	};
+	/**
+	* 遍历一个 Container 节点，分支顺序与 `Container.vue` 的模板保持一致。
+	*
+	* 对比模式（`isCompare`）在此被忽略：它只改变同一个 prop 渲染几份 FormItem，
+	* 规则与取值完全相同，对校验结果没有影响。
+	*/
+	var walkNode = (ctx, node) => {
+		const { config, prop } = node;
+		const model = node.model ?? {};
+		const nodeProps = {
+			model,
+			config,
+			prop
+		};
+		const name = config.name || "";
+		const items = getItems(config);
+		const type = resolveItemType(ctx.mForm, config, nodeProps);
+		const itemProp = getItemProp(prop, name);
+		const text = filterFunction(ctx.mForm, config.text, nodeProps);
+		if (type === "hidden") {
+			addField(ctx, {
+				...node,
+				model
+			}, itemProp, nodeProps);
+			return;
+		}
+		const display = resolveDisplay(ctx, config, nodeProps);
+		if (items && !text && type && display) {
+			dispatchByType(ctx, type, {
+				...node,
+				model
+			}, itemProp);
+			return;
+		}
+		if (type && display) {
+			addField(ctx, {
+				...node,
+				model
+			}, itemProp, nodeProps);
+			dispatchByType(ctx, type, {
+				...node,
+				model
+			}, itemProp);
+			return;
+		}
+		if (items && display) {
+			const childModel = isValidName(name) ? model[name] : model;
+			if (!childModel) return;
+			walkChildren(ctx, items, childModel, itemProp);
+		}
+	};
+	/**
+	* 按 type 分派：已登记 walk 的容器 → 按容器模板遍历；
+	* `effects` 模式下先执行本字段的 effect（可与 innerConfig 并存，如 `code-select` 先归一化再下钻）；
+	* 登记了 innerConfig 的复合字段 → 遍历其内部配置；叶子字段无子树。
+	*
+	* 未登记的 type：配置里若有 `items` 则按普通容器下钻；否则视为没有嵌套表单项。
+	* 自身 rules 已在 FormItem 分支收集，有 rules 就会校验。
+	*/
+	var dispatchByType = (ctx, type, node, itemProp) => {
+		const walkContainer = getContainerWalker(type);
+		if (walkContainer) {
+			walkContainer(ctx, node, itemProp);
+			return;
+		}
+		if (ctx.mode === "effects") runMountValueEffect(ctx, type, node, itemProp);
+		if (walkInnerConfig(ctx, type, node, itemProp)) return;
+		if (isLeafFieldType(type)) return;
+		const items = getItems(node.config);
+		if (items?.length) {
+			const { childModel } = getContainerScope(node);
+			walkChildren(ctx, items, childModel, itemProp);
+		}
+	};
+	/**
+	* 纯逻辑收集「一份 config + 一份 values」中所有参与校验的字段。
+	*
+	* 遍历规则与 `Container.vue` 及各容器组件的模板一一对应，因此产出的 prop / rules
+	* 与渲染式校验（挂载 MForm 后调用 `validate()`）等价，无需任何 DOM 或组件实例。
+	*
+	* 本函数只读不写。字段的值初始化副作用由 `applyMountValueEffects` 负责，
+	* 调用方需在初始化表单值之后、收集字段之前执行一次（`validateValues` 已经这么做）。
+	*
+	* @param mForm - 表单状态；无渲染时由 `createHeadlessFormState` 构造
+	* @param config - 表单配置
+	* @param values - 表单值
+	* @param [typeMatchValid] - 是否自动注入 typeMatch 规则；为 true 时，未显式声明
+	*   `typeMatch` 的字段会补上 `{ typeMatch: true }`，按字段 type 校验值形态
+	* @returns 带规则的字段列表
+	*/
+	var collectValidatableFields = (mForm, config, values, typeMatchValid) => {
+		const ctx = {
+			mForm,
+			typeMatchValid,
+			fields: [],
+			values,
+			mode: "collect"
+		};
+		if (Array.isArray(config)) walkChildren(ctx, config, values, "");
+		return ctx.fields;
+	};
+	/**
+	* 执行「一份 config + 一份 values」中所有叶子字段登记的值初始化写入，就地改写 `values`。
+	*
+	* 渲染与无渲染两条链路共用的唯一执行点：字段组件自身不再在 setup 里改写 model，
+	* 由持有完整表单值的一方（`Form.vue` / `validateValues`）在表单值初始化完成、
+	* 且已挂到 `mForm.values` 之后调用一次。这样 effect 与动态 `type` 回调读到的
+	* `formValue` 就是最新值，而不是上一轮的旧值。
+	*
+	* 与 `collectValidatableFields` 的差异：不看 `display`（`display: false` 的字段也会规整）。
+	* `type: 'hidden'` 会在该节点停止遍历，内部字段不执行 effect。
+	*
+	* `prop` 与 `values` 都以传入的 `values` 为根，因此也可以用于 tab / table 新增行这类
+	* 「先构造一份子树的值，再挂到表单上」的场景：传入子树配置与该行的值即可。
+	*
+	* @param mForm - 表单状态；无渲染时由 `createHeadlessFormState` 构造
+	* @param config - 表单配置
+	* @param values - 表单值（会被就地修改）
+	*/
+	var applyMountValueEffects = (mForm, config, values) => {
+		if (!Array.isArray(config)) return;
+		walkChildren({
+			mForm,
+			fields: [],
+			values,
+			mode: "effects"
+		}, config, values, "");
+	};
+	//#endregion
+	//#region packages/form/src/utils/validateError.ts
+	/**
+	* 通过 name 从 config 中查找对应的 text
+	*
+	* @param name - 字段名，支持点分隔的路径格式，如 'a.b.c'
+	* @param config - 表单配置数组
+	* @returns 找到的 text 值，如果未找到则返回 undefined
+	*/
+	var getTextByName = (name, config = []) => {
+		if (!name || !Array.isArray(config)) return void 0;
+		const nameParts = name.split(".");
+		const findInConfig = (configs, parts) => {
+			if (parts.length === 0) return void 0;
+			const [currentPart, ...remainingParts] = parts;
+			for (const item of configs) {
+				if (item.name === currentPart) {
+					if (remainingParts.length === 0) return typeof item.text === "string" ? item.text : void 0;
+					if ("items" in item && Array.isArray(item.items)) {
+						const result = findInConfig(item.items, remainingParts);
+						if (result !== void 0) return result;
+					}
+				}
+				if ("items" in item && Array.isArray(item.items)) {
+					const result = findInConfig(item.items, parts);
+					if (result !== void 0) return result;
+				}
+			}
+		};
+		return findInConfig(config, nameParts);
+	};
+	/**
+	* 将校验返回的 invalidFields 汇总为可读的错误文案（多条以 `<br>` 拼接）。
+	*
+	* `useFieldTextInError` 为 `true`（默认）时用字段的 text 文案作为错误前缀，找不到则回退为字段 name。
+	*
+	* 由渲染式校验（Form.vue 的 `submitForm` / `validate`）与无渲染校验（`validateValues`）共用，
+	* 保证两条校验链路产出的错误文案格式完全一致。
+	*
+	* @param invalidFields - async-validator 产出的字段错误表
+	* @param [options] - 文案选项
+	* @param [options.config] - 用于查找 text 的表单配置
+	* @param [options.useFieldTextInError=true] - 错误前缀是否使用字段 text
+	* @returns 拼接后的错误文案；无错误时为空串
+	*/
+	var formatValidateError = (invalidFields, { config = [], useFieldTextInError = true } = {}) => {
+		const error = [];
+		Object.entries(invalidFields).forEach(([prop, validateError]) => {
+			validateError.forEach(({ field, message }) => {
+				const name = field || prop;
+				const text = (useFieldTextInError ? getTextByName(name, config) : void 0) || name;
+				error.push(`${text} -> ${message}`);
+			});
+		});
+		return error.join("<br>");
+	};
+	//#endregion
+	//#region packages/form/src/utils/validateValues.ts
+	/**
+	* 构造一个不依赖组件实例的 `formState`。
+	*
+	* 字段结构与 `Form.vue` 中 provide 给子树的 `mForm` 保持一致，使配置里的
+	* `display` / `rules.validator` / `filter` 等回调拿到的上下文与渲染式校验相同。
+	*
+	* 差异：没有真实的表单实例，因此 `$emit` 为空实现、`fields` 注册表始终为空
+	* （该注册表在整个仓库中只写不读，不参与校验）。
+	*/
+	var createHeadlessFormState = (options) => {
+		const context = options.context ?? {};
+		const state = {
+			keyProp: options.keyProp ?? "__key",
+			popperClass: options.popperClass ?? "",
+			config: options.config,
+			initValues: options.initValues ?? {},
+			isCompare: false,
+			lastValues: {},
+			parentValues: options.parentValues ?? {},
+			values: {},
+			lastValuesProcessed: {},
+			$emit: () => void 0,
+			...createFormStateBase()
+		};
+		return createFormStateProxy((0, vue.reactive)(state), () => context);
+	};
+	/**
+	* 按 prop 路径从表单值中取字段值，路径中断时返回 `undefined`。
+	*
+	* 不复用 `@tmagic/utils` 的 `getValueByKeyPath`：后者在路径中断时抛错，
+	* 而 Element Plus 的 FormItem 取值是宽松的（拿不到就是 `undefined`），此处与之对齐。
+	*/
+	var getFieldValue = (prop, values) => {
+		if (!prop) return void 0;
+		return prop.split(".").reduce((acc, key) => {
+			if (acc === null || typeof acc !== "object") return void 0;
+			return acc[key];
+		}, values);
+	};
+	/**
+	* 校验单个字段，返回 async-validator 的 `fields` 错误映射（通过则返回 `null`）。
+	*
+	* 与 Element Plus 的 FormItem 逐字段校验保持一致：
+	* 每个字段独立构造一个 `Schema({ [prop]: rules })`，以字段自身的值为 source，
+	* 并开启 `firstFields` 只取每个字段的首条错误；`trigger` 是 FormItem 用来筛选规则的
+	* 元信息，交给 async-validator 前必须剔除，否则会改变规则的匹配方式。
+	*/
+	var validateField = async (field, values) => {
+		const rules = field.rules.map(({ trigger, ...rule }) => rule);
+		if (!rules.length) return null;
+		const value = getFieldValue(field.prop, values);
+		try {
+			await new async_validator.default({ [field.prop]: rules }).validate({ [field.prop]: value }, { firstFields: true });
+			return null;
+		} catch (err) {
+			if (err?.fields) return err.fields;
+			return { [field.prop]: [{
+				field: field.prop,
+				message: err?.message ?? `${err}`
+			}] };
 		}
-		return `${[...itemPath, key].join(".")}`;
+	};
+	/**
+	* 不挂载任何组件，纯逻辑地对「一份 config + 一份值」执行一次完整校验。
+	*
+	* 流程与渲染式校验一一对应，但不需要 DOM，也不会实例化任何字段组件：
+	*
+	* 1. 构造 headless `formState` 并挂上 `context` 读穿；
+	* 2. `initValue` 初始化表单值（默认值、嵌套结构、`onInitValue` 等）；
+	* 3. `applyMountValueEffects` 执行字段登记的值初始化写入（与渲染式共用同一份登记表）；
+	* 4. 遍历 config 树收集所有带规则的字段（等价于渲染出的 FormItem 集合）；
+	* 5. 逐字段交给 async-validator 执行，汇总错误文案。
+	*
+	* @example
+	* ```ts
+	* const { error, values } = await validateValues({
+	*   config: [...],
+	*   initValues: { name: '' },
+	*   typeMatchValid: true,
+	* });
+	* ```
+	*/
+	var validateValues = async (options) => {
+		const { config, initValues = {}, typeMatchValid, useFieldTextInError = true } = options;
+		const formState = createHeadlessFormState(options);
+		const values = await initValue(formState, {
+			initValues,
+			config
+		});
+		formState.values = values;
+		applyMountValueEffects(formState, config, values);
+		const fields = collectValidatableFields(formState, config, values, Boolean(typeMatchValid));
+		const invalidFields = {};
+		for (const field of fields) {
+			const fieldErrors = await validateField(field, values);
+			if (fieldErrors) Object.assign(invalidFields, fieldErrors);
+		}
+		return {
+			values,
+			invalidFields,
+			error: formatValidateError(invalidFields, {
+				config,
+				useFieldTextInError
+			})
+		};
+	};
+	//#endregion
+	//#region packages/form/src/utils/submitHeadless.ts
+	var throwIfAborted = (signal, fnName) => {
+		if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error(`${fnName} aborted`);
+	};
+	var throwIfDialog = (dialog, fnName) => {
+		if (dialog) throw new Error(`[MForm] ${fnName}({ dialog: true }) is not available from @tmagic/form/headless. Import from @tmagic/form instead.`);
+	};
+	/**
+	* `submitForm` 与 `validateForm` 共用的无渲染校验流程：中断检查 → `validateValues`。
+	*/
+	var validateWithoutRender = async (fnName, options) => {
+		const { signal, config, initValues, parentValues, keyProp, typeMatchValid, useFieldTextInError, context } = options;
+		throwIfAborted(signal, fnName);
+		const result = await validateValues({
+			config,
+			initValues,
+			parentValues,
+			keyProp,
+			popperClass: options.popperClass,
+			typeMatchValid,
+			useFieldTextInError,
+			context
+		});
+		throwIfAborted(signal, fnName);
+		return result;
+	};
+	/**
+	* 以命令式方式对一份「表单配置 + 值」做一次校验并取回表单值（无渲染）。
+	*
+	* `@tmagic/form/headless` 不支持 `dialog: true`。
+	*/
+	var submitForm$1 = async (options) => {
+		throwIfDialog(options.dialog, "submitForm");
+		const validated = await validateWithoutRender("submitForm", options);
+		if (validated.error) throw new Error(validated.error);
+		const values = options.native ? validated.values : cloneDeep(validated.values);
+		return options.returnChangeRecords ? {
+			values,
+			changeRecords: []
+		} : values;
+	};
+	/**
+	* 以命令式方式对一份「表单配置 + 值」做一次静默校验（无渲染）。
+	*
+	* `@tmagic/form/headless` 不支持 `dialog: true`。
+	*/
+	var validateForm$1 = async (options) => {
+		throwIfDialog(options.dialog, "validateForm");
+		return (await validateWithoutRender("validateForm", options)).error;
 	};
 	//#endregion
 	//#region packages/form/src/utils/useAddField.ts
@@ -3492,67 +4516,156 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/utils/config.ts
-	var $MAGIC_FORM = {};
-	var isGlobalFlat = (0, vue.ref)(false);
-	var setConfig = (option) => {
-		$MAGIC_FORM = option;
-		isGlobalFlat.value = option.flat ?? false;
-	};
-	var getConfig = (key) => $MAGIC_FORM[key];
-	var fieldRegistry = /* @__PURE__ */ new Map();
-	var registerField = (tagName, component) => {
-		if (fieldRegistry.has(tagName)) return;
-		fieldRegistry.set(tagName, component);
+	//#region packages/form/src/utils/registerField.ts
+	var extraComponents = /* @__PURE__ */ new Map();
+	var builtInComponents = /* @__PURE__ */ new Map();
+	var applyVueComponent = (type, component, app, builtIn, kind) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		if (builtIn) builtInComponents.set(key, component);
+		else extraComponents.set(key, component);
+		app?.component(`m-${kind}-${key}`, component);
 	};
-	var getField = (tagName) => fieldRegistry.get(tagName);
-	var deleteField = (tagName) => fieldRegistry.delete(tagName);
-	//#endregion
-	//#region packages/form/src/utils/silentLeafFieldTypes.ts
 	/**
-	* 可在静默校验模式下跳过渲染的内置叶子字段（默认集合）。
+	* 把多份字段登记表按 type 浅合并。后一份只覆盖自己带了的 key，未出现的 key 保留前一份。
 	*
-	* 这些字段只渲染一个输入控件，内部没有嵌套 FormItem，且不会依赖组件挂载修改 model；
-	* 字段值由初始化逻辑处理（包括 defaultValue），因此跳过不影响校验结果。
+	* 安装插件时用：Node 侧只登记 `headless`，浏览器再补 `component` / `container`。
 	*
-	* 业务侧可通过 `registerSilentLeafFieldTypes` 追加已审计的安全自定义字段。
+	* @param tables - 待合并的登记表，`undefined` 会被跳过
+	* @returns 合并后的登记表
 	*/
-	var LEAF_FIELD_TYPES = /* @__PURE__ */ new Set([
-		"text",
-		"textarea",
-		"number",
-		"time",
-		"daterange",
-		"timerange",
-		"checkbox",
-		"radio-group",
-		"switch",
-		"select",
-		"cascader",
-		"color-picker",
-		"link"
-	]);
-	/** 业务侧追加的静默叶子字段（不含内置默认集合） */
-	var extraSilentLeafFieldTypes = /* @__PURE__ */ new Set();
+	var mergeFieldOptions = (...tables) => {
+		const result = {};
+		for (const table of tables) {
+			if (!table) continue;
+			for (const [type, options] of Object.entries(table)) result[type] = {
+				...result[type],
+				...pickDefinedFieldOptions(options)
+			};
+		}
+		return result;
+	};
+	var FIELD_OPTION_KEYS = [
+		"component",
+		"container",
+		"effect",
+		"walk",
+		"innerConfig",
+		"typeMatch"
+	];
+	var pickDefinedFieldOptions = (options) => {
+		if (!options) return {};
+		const next = {};
+		for (const key of FIELD_OPTION_KEYS) if (options[key] !== void 0) next[key] = options[key];
+		return next;
+	};
+	var extraFieldOptions = /* @__PURE__ */ new Map();
+	var builtInFieldOptions = /* @__PURE__ */ new Map();
+	var removeFormComponent = (type) => {
+		extraComponents.delete((0, _tmagic_utils.toLine)(type));
+	};
+	var clearFormComponents = () => {
+		extraComponents.clear();
+	};
 	/**
-	* 注册可在静默校验中跳过渲染的叶子字段 type（追加到默认 `LEAF_FIELD_TYPES` 之上）。
+	* 按字段 type 取已登记的渲染组件（`codeSelect` 与 `code-select` 等价）。
 	*
-	* 仅应纳入「无嵌套 FormItem、无挂载值副作用」的字段；复合 / 动态子表单不可加入。
+	* @param type - 字段 type
+	* @returns 已登记的 Vue 组件；未登记则为 `undefined`
 	*/
-	var registerSilentLeafFieldTypes = (types) => {
-		for (const type of types) {
-			if (typeof type !== "string" || !type) continue;
-			extraSilentLeafFieldTypes.add((0, _tmagic_utils.toLine)(type));
+	var getField = (type) => {
+		const key = (0, _tmagic_utils.toLine)(type);
+		return extraComponents.get(key) ?? builtInComponents.get(key);
+	};
+	var registerFieldImpl = (type, options, app, builtIn) => {
+		if (typeof type !== "string" || !type) return;
+		const key = (0, _tmagic_utils.toLine)(type);
+		const store = builtIn ? builtInFieldOptions : extraFieldOptions;
+		const incoming = pickDefinedFieldOptions(options);
+		const merged = {
+			...store.get(key),
+			...incoming
+		};
+		store.set(key, merged);
+		if (incoming.walk && (incoming.innerConfig || typeof incoming.effect === "function")) console.warn(`[MForm] registerField("${key}"): walk is set together with innerConfig/effect; headless validation will use walk and innerConfig/effect will be ignored.`);
+		if (incoming.component && incoming.container) console.warn(`[MForm] registerField("${key}"): component and container are both set; getField will use container, and both m-fields-* / m-form-* will be registered.`);
+		if (merged.component) applyVueComponent(type, merged.component, app, builtIn, "fields");
+		if (merged.container) applyVueComponent(type, merged.container, app, builtIn, "form");
+		if (merged.typeMatch) registerTypeMatchRule(type, merged.typeMatch, builtIn);
+		if (merged.walk) {
+			registerContainerWalker(type, merged.walk, builtIn);
+			if (!builtIn) {
+				deleteLeafFieldType(type);
+				deleteFieldInnerConfig(type);
+			}
+			return;
 		}
+		if (!builtIn) deleteContainerWalker(type);
+		if (merged.innerConfig) {
+			registerFieldInnerConfig(type, merged.innerConfig, builtIn);
+			if (typeof merged.effect === "function") registerLeafFieldType(type, merged.effect, builtIn);
+			else if (!builtIn) deleteLeafFieldType(type);
+			return;
+		}
+		if (merged.container && !merged.component && typeof merged.effect !== "function") {
+			if (!builtIn) deleteLeafFieldType(type);
+			return;
+		}
+		if (!builtIn) deleteFieldInnerConfig(type);
+		registerLeafFieldType(type, merged.effect, builtIn);
 	};
-	/** 当前生效的静默叶子字段集合：内置默认 ∪ 已注册扩展 */
-	var getSilentLeafFieldTypes = () => {
-		if (extraSilentLeafFieldTypes.size === 0) return LEAF_FIELD_TYPES;
-		return /* @__PURE__ */ new Set([...LEAF_FIELD_TYPES, ...extraSilentLeafFieldTypes]);
+	/**
+	* 登记一个字段 type 在无渲染校验里的行为，以及可选的渲染组件。
+	*
+	* `type` 会按 Container 的规则归一化为中划线形式（`codeSelect` 与 `code-select` 等价）。
+	* 对同一 type 重复登记按字段浅合并：后一次只覆盖自己传入的 key，未传入的 key 保留。
+	* 传入 `app` 且带了 `component` / `container` 时，会同步 `app.component('m-fields-*'` / `'m-form-*')`。
+	*
+	* @param type - 字段 type
+	* @param [options] - 登记项；省略或空对象视为叶子
+	* @param [app] - Vue 应用；省略则不调用 `app.component`
+	*/
+	var registerField = (type, options, app) => {
+		registerFieldImpl(type, options, app, false);
 	};
-	/** 清空业务侧追加的静默叶子字段（不影响内置默认集合；主要用于单测） */
-	var clearSilentLeafFieldTypes = () => {
-		extraSilentLeafFieldTypes.clear();
+	/**
+	* 批量登记字段。
+	*
+	* @param fields - type 到登记项的映射
+	* @param [app] - Vue 应用；省略则不调用 `app.component`
+	*/
+	var registerFields = (fields, app) => {
+		for (const [type, options] of Object.entries(fields)) registerFieldImpl(type, options, app, false);
+	};
+	/**
+	* 登记内置字段（`clearFields` / `unregisterField` 不会清掉）。
+	*
+	* @param fields - type 到登记项的映射
+	* @param [app] - Vue 应用；省略则不调用 `app.component`
+	*/
+	var registerBuiltInFields = (fields, app) => {
+		for (const [type, options] of Object.entries(fields)) registerFieldImpl(type, options, app, true);
+	};
+	/**
+	* 删除业务侧对指定 type 的登记（不影响内置；主要用于单测）。
+	*
+	* @param type - 字段 type
+	*/
+	var unregisterField = (type) => {
+		extraFieldOptions.delete((0, _tmagic_utils.toLine)(type));
+		deleteLeafFieldType(type);
+		deleteFieldInnerConfig(type);
+		deleteTypeMatchRule(type);
+		deleteContainerWalker(type);
+		removeFormComponent(type);
+	};
+	/** 清空业务侧登记（不影响内置；主要用于单测）。 */
+	var clearFields = () => {
+		extraFieldOptions.clear();
+		clearLeafFieldTypes();
+		clearFieldInnerConfigs();
+		clearTypeMatchRules();
+		clearContainerWalkers();
+		clearFormComponents();
 	};
 	//#endregion
 	//#region packages/form/src/containers/FormLabel.vue?vue&type=script&setup=true&lang.ts
@@ -3612,7 +4725,7 @@
 	};
 	var _hoisted_3$7 = ["innerHTML"];
 	var _hoisted_4$6 = ["innerHTML"];
-	var _hoisted_5$4 = ["innerHTML"];
+	var _hoisted_5$5 = ["innerHTML"];
 	var _hoisted_6$3 = ["innerHTML"];
 	var _hoisted_7$2 = ["innerHTML"];
 	var _hoisted_8$2 = ["innerHTML"];
@@ -3633,6 +4746,7 @@
 			prop: { default: "" },
 			disabled: { type: Boolean },
 			labelWidth: {},
+			labelPosition: {},
 			expandMore: {
 				type: Boolean,
 				default: false
@@ -3668,20 +4782,8 @@
 				return !isEqual(curValue, lastValue);
 			});
 			const items = (0, vue.computed)(() => props.config.items);
-			const itemProp = (0, vue.computed)(() => {
-				let n = "";
-				if (name.value) n = name.value;
-				else return props.prop;
-				if (typeof props.prop !== "undefined" && props.prop !== "") return `${props.prop}.${n}`;
-				return `${n}`;
-			});
-			const type = (0, vue.computed)(() => {
-				let type = "type" in props.config ? props.config.type : "";
-				type = type && filterFunction(mForm, type, props);
-				if (type === "form") return "";
-				if (type === "container") return "";
-				return type?.replace(/([A-Z])/g, "-$1").toLowerCase() || (items.value ? "" : "text");
-			});
+			const itemProp = (0, vue.computed)(() => getItemProp(props.prop, name.value));
+			const type = (0, vue.computed)(() => resolveItemType(mForm, props.config, props));
 			const tagName = (0, vue.computed)(() => {
 				if (type.value === "component" && props.config.component) return props.config.component;
 				return getField(type.value || "container") || `m-${items.value ? "form" : "fields"}-${type.value}`;
@@ -3715,8 +4817,6 @@
 				return new Set(DEFAULT_SELF_DIFF_FIELD_TYPES);
 			});
 			const isSelfDiffField = (0, vue.computed)(() => effectiveSelfDiffFieldTypes.value.has(type.value));
-			const silentMode = (0, vue.inject)(FORM_SILENT_MODE_KEY, false);
-			const shouldRenderLeafField = (0, vue.computed)(() => !silentMode || !getSilentLeafFieldTypes().has(type.value));
 			const disabled = (0, vue.computed)(() => props.disabled || filterFunction(mForm, props.config.disabled, props));
 			const text = (0, vue.computed)(() => filterFunction(mForm, props.config.text, props));
 			const tooltip = (0, vue.computed)(() => {
@@ -3748,12 +4848,13 @@
 			const formItemProps = (0, vue.computed)(() => ({
 				prop: itemProp.value,
 				labelWidth: itemLabelWidth.value,
-				labelPosition: props.config.labelPosition,
+				labelPosition: itemLabelPosition.value,
 				rules: rule.value,
 				extra: filterFunction(mForm, props.config.extra, props),
 				extraTips: props.config.extraTips
 			}));
 			const itemLabelWidth = (0, vue.computed)(() => props.config.labelWidth ?? props.labelWidth);
+			const itemLabelPosition = (0, vue.computed)(() => props.config.labelPosition ?? props.labelPosition);
 			(0, vue.watchEffect)(() => {
 				expand.value = props.expandMore;
 			});
@@ -3782,13 +4883,7 @@
 			};
 			const onAddDiffCount = () => emit("addDiffCount");
 			const hasModifyKey = (eventDataItem) => typeof eventDataItem?.modifyKey !== "undefined" && eventDataItem.modifyKey !== "";
-			const isValidName = () => {
-				const valueType = typeof name.value;
-				if (valueType !== "string" && valueType !== "symbol" && valueType !== "number") return false;
-				if (name.value === "") return false;
-				if (typeof name.value === "number") return name.value >= 0;
-				return true;
-			};
+			const isValidName$1 = () => isValidName(name.value);
 			const createModelProxy = (target, setModelFn, pathPrefix = "") => {
 				return new Proxy(target, {
 					get: (obj, key) => {
@@ -3880,6 +4975,7 @@
 					"step-active": __props.stepActive,
 					"expand-more": expand.value,
 					"label-width": itemLabelWidth.value,
+					"label-position": itemLabelPosition.value,
 					style: __props.config.fieldStyle,
 					onChange: onChangeHandler,
 					onAddDiffCount
@@ -3890,9 +4986,10 @@
 					"step-active",
 					"expand-more",
 					"label-width",
+					"label-position",
 					"style"
 				])) : type.value && display$3.value && !showDiff.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 2 }, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicFormItem), (0, vue.mergeProps)(formItemProps.value, { class: { "tmagic-form-hidden": `${itemLabelWidth.value}` === "0" || !text.value } }), {
-					label: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? (0, vue.renderSlot)(_ctx.$slots, "label", {
+					label: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "label", {
 						config: __props.config,
 						type: type.value,
 						text: text.value,
@@ -3910,8 +5007,8 @@
 						"use-label",
 						"label-title",
 						"text"
-					]), __props.config.titleExtra && __props.config.labelPosition === "top" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_2$8, (0, vue.toDisplayString)(__props.config.titleExtra), 1)) : (0, vue.createCommentVNode)("v-if", true)], void 0, 0) : (0, vue.createCommentVNode)("v-if", true)]),
-					default: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+					]), __props.config.titleExtra && itemLabelPosition.value === "top" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_2$8, (0, vue.toDisplayString)(__props.config.titleExtra), 1)) : (0, vue.createCommentVNode)("v-if", true)])]),
+					default: (0, vue.withCtx)(() => [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 						key: 0,
 						placement: tooltip.value.placement
 					}, {
@@ -3938,9 +5035,9 @@
 						"model",
 						"last-values",
 						"is-compare"
-					]))], 64)) : (0, vue.createCommentVNode)("v-if", true)]),
+					]))]),
 					_: 3
-				}, 16, ["class"]), shouldRenderLeafField.value && __props.config.tip && type.value === "checkbox" && !__props.config.useLabel ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+				}, 16, ["class"]), __props.config.tip && type.value === "checkbox" && !__props.config.useLabel ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 					key: 0,
 					placement: "top"
 				}, {
@@ -3960,7 +5057,7 @@
 						"tmagic-form-hidden": `${itemLabelWidth.value}` === "0" || !text.value,
 						"self-diff": true
 					} }), {
-						label: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? (0, vue.renderSlot)(_ctx.$slots, "label", {
+						label: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "label", {
 							config: __props.config,
 							type: type.value,
 							text: text.value,
@@ -3978,12 +5075,12 @@
 							"use-label",
 							"label-title",
 							"text"
-						])], void 0, 0) : (0, vue.createCommentVNode)("v-if", true)]),
-						default: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+						])])]),
+						default: (0, vue.withCtx)(() => [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 							key: 0,
 							placement: tooltip.value.placement
 						}, {
-							content: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", { innerHTML: tooltip.value.text }, null, 8, _hoisted_5$4)]),
+							content: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", { innerHTML: tooltip.value.text }, null, 8, _hoisted_5$5)]),
 							default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(tagName.value), (0, vue.mergeProps)(fieldsProps.value, {
 								model: __props.model,
 								"last-values": __props.lastValues,
@@ -4004,7 +5101,7 @@
 							"model",
 							"last-values",
 							"is-compare"
-						]))], 64)) : (0, vue.createCommentVNode)("v-if", true)]),
+						]))]),
 						_: 3
 					}, 16, ["class"])) : ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [
 						(0, vue.createCommentVNode)(" 普通字段：渲染前后两份独立的组件用于对比 "),
@@ -4013,7 +5110,7 @@
 							"tmagic-form-hidden": `${itemLabelWidth.value}` === "0" || !text.value,
 							"show-before-diff": true
 						} }), {
-							label: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? (0, vue.renderSlot)(_ctx.$slots, "label", {
+							label: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "label", {
 								config: __props.config,
 								type: type.value,
 								text: text.value,
@@ -4031,8 +5128,8 @@
 								"use-label",
 								"label-title",
 								"text"
-							])], void 0, 0) : (0, vue.createCommentVNode)("v-if", true)]),
-							default: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+							])])]),
+							default: (0, vue.withCtx)(() => [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 								key: 0,
 								placement: tooltip.value.placement
 							}, {
@@ -4045,10 +5142,10 @@
 							}, 8, ["placement"])) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(tagName.value), (0, vue.mergeProps)({ key: 1 }, fieldsProps.value, {
 								model: __props.lastValues,
 								onChange: onChangeHandler
-							}), null, 16, ["model"]))], 64)) : (0, vue.createCommentVNode)("v-if", true)]),
+							}), null, 16, ["model"]))]),
 							_: 3
 						}, 16, ["class"]),
-						shouldRenderLeafField.value && __props.config.tip && type.value === "checkbox" && !__props.config.useLabel ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+						__props.config.tip && type.value === "checkbox" && !__props.config.useLabel ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 							key: 0,
 							placement: "top"
 						}, {
@@ -4070,7 +5167,7 @@
 								"show-after-diff": true
 							}
 						}), {
-							label: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? (0, vue.renderSlot)(_ctx.$slots, "label", {
+							label: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "label", {
 								config: __props.config,
 								type: type.value,
 								text: text.value,
@@ -4088,8 +5185,8 @@
 								"use-label",
 								"label-title",
 								"text"
-							])], void 0, 0) : (0, vue.createCommentVNode)("v-if", true)]),
-							default: (0, vue.withCtx)(() => [shouldRenderLeafField.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+							])])]),
+							default: (0, vue.withCtx)(() => [tooltip.value.text ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 								key: 0,
 								placement: tooltip.value.placement
 							}, {
@@ -4102,10 +5199,10 @@
 							}, 8, ["placement"])) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(tagName.value), (0, vue.mergeProps)({ key: 1 }, fieldsProps.value, {
 								model: __props.model,
 								onChange: onChangeHandler
-							}), null, 16, ["model"]))], 64)) : (0, vue.createCommentVNode)("v-if", true)]),
+							}), null, 16, ["model"]))]),
 							_: 3
 						}, 16, ["style", "class"]),
-						shouldRenderLeafField.value && __props.config.tip && type.value === "checkbox" && !__props.config.useLabel ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+						__props.config.tip && type.value === "checkbox" && !__props.config.useLabel ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
 							key: 1,
 							placement: "top"
 						}, {
@@ -4120,11 +5217,11 @@
 							_: 1
 						})) : (0, vue.createCommentVNode)("v-if", true)
 					], 64))
-				], 64)) : items.value && display$3.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 4 }, [(isValidName() ? __props.model[name.value] : __props.model) ? ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, (0, vue.renderList)(items.value, (item) => {
+				], 64)) : items.value && display$3.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 4 }, [(isValidName$1() ? __props.model[name.value] : __props.model) ? ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, (0, vue.renderList)(items.value, (item) => {
 					return (0, vue.openBlock)(), (0, vue.createBlock)(_component_Container, {
 						key: key(item),
-						model: isValidName() ? __props.model[name.value] : __props.model,
-						"last-values": isValidName() ? __props.lastValues[name.value] || {} : __props.lastValues,
+						model: isValidName$1() ? __props.model[name.value] : __props.model,
+						"last-values": isValidName$1() ? __props.lastValues[name.value] || {} : __props.lastValues,
 						"is-compare": __props.isCompare,
 						config: item,
 						size: __props.size,
@@ -4132,6 +5229,7 @@
 						"step-active": __props.stepActive,
 						"expand-more": expand.value,
 						"label-width": itemLabelWidth.value,
+						"label-position": itemLabelPosition.value,
 						prop: itemProp.value,
 						onChange: onChangeHandler,
 						onAddDiffCount
@@ -4149,6 +5247,7 @@
 						"step-active",
 						"expand-more",
 						"label-width",
+						"label-position",
 						"prop"
 					]);
 				}), 128)) : (0, vue.createCommentVNode)("v-if", true)], 64)) : (0, vue.createCommentVNode)("v-if", true), __props.config.expand && type.value !== "fieldset" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_10, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
@@ -4204,7 +5303,7 @@
 				type: Boolean,
 				default: true
 			},
-			extendState: {},
+			context: {},
 			showDiff: {},
 			selfDiffFieldTypes: {},
 			theme: {}
@@ -4224,8 +5323,6 @@
 			const initialized = (0, vue.ref)(false);
 			const values = (0, vue.ref)({});
 			const lastValuesProcessed = (0, vue.ref)({});
-			const fields = /* @__PURE__ */ new Map();
-			const requestFuc = getConfig("request");
 			/**
 			* 当前表单生效的主题名称：
 			* - 优先用本组件自己的 `props.theme`；
@@ -4255,18 +5352,14 @@
 			* 2. `values` / `lastValuesProcessed` 是 ref，Vue 的 `reactive` 会自动解包，因此每次
 			*    访问 `formState.values` / `formState.lastValuesProcessed` 也都是当前 ref 值。
 			*
-			* 3. `extendState` 注入的字段在下方的 `watchEffect` 中合并到 `formState`：
-			*    - data 描述符（普通字段）通过 `formState[key] = value` 写入，走 reactive proxy 的
-			*      set，触发依赖通知；`extendState` 同步段读到的响应式数据变化时会自动重跑，
-			*      把最新值刷进 formState。
-			*    - accessor 描述符（`{ get stage() { return ... } }`）按原样写入，调用方可以控制
-			*      读时求值，每次读取都会重新执行 getter。
+			* 3. 宿主业务上下文不再 merge 进 coreState，而是单独放在 `contextRef` 上，由读穿
+			*    Proxy 在 miss 时落到 context。核心字段结构性优先，`mForm.xxx` 永久兼容旧读法。
 			*
 			* 4. `popperClass` 会自动拼接 `themeClass`：调用方传入的 `popperClass` + 当前主题
 			*    修饰类（含祖先 `<MEditor>` provide 的主题）。这样所有透传到 Element Plus 弹层
 			*    `popper-class` 的字段（Select / DateTime / Cascader 等）能自带主题作用域。
 			*/
-			const formState = (0, vue.reactive)({
+			const coreState = (0, vue.reactive)({
 				get keyProp() {
 					return props.keyProp;
 				},
@@ -4295,68 +5388,20 @@
 				values,
 				lastValuesProcessed,
 				$emit: emit,
-				fields,
-				setField: (prop, field) => fields.set(prop, field),
-				getField: (prop) => fields.get(prop),
-				deleteField: (prop) => fields.delete(prop),
-				$messageBox: _tmagic_design.tMagicMessageBox,
-				$message: _tmagic_design.tMagicMessage,
-				post: (options) => {
-					if (requestFuc) return requestFuc({
-						method: "POST",
-						...options
-					});
-				}
+				...createFormStateBase({
+					$message: _tmagic_design.tMagicMessage,
+					$messageBox: _tmagic_design.tMagicMessageBox
+				})
 			});
+			const ancestorContext = (0, vue.inject)(FORM_CONTEXT_KEY, void 0);
 			/**
-			* formState 的内置 key 快照（keyProp / values / $emit / fields / post 等）。
-			*
-			* 在 `extendState` 首次合并前捕获，`applyExtendState` 会据此禁止 `extendState`
-			* 覆盖这些已有字段（只能新增字段），避免表单核心状态被外部意外改写。
-			*
-			* 之所以在此处（effect 之外）捕获而不是在 `applyExtendState` 内动态取：
-			* `watchEffect` 会在依赖变化时重跑，若动态取，`extendState` 自己新增的字段在第二次
-			* 合并时也会被当成「已有 key」而拒绝刷新；这里只锁定内置字段即可规避该问题。
-			*/
-			const reservedStateKeys = new Set(Reflect.ownKeys(formState));
-			/**
-			* `extendState` 的同步段（直到第一个 `await` 之前）所访问的任何响应式数据，
-			* 都会被 `watchEffect` 自动跟踪。这样可以兼容历史用法 ——
-			*
-			*   extendState: (formState) => ({
-			*     username: store.username,   // 同步读 store，会被跟踪
-			*     env: store.env,
-			*   })
-			*
-			* 当 `store.username` 变化时，整个 effect 重跑，新值会被刷进 `formState`。
-			*
-			* prop 派生字段（initValues / config / ...）已经在上方用 getter 定义，
-			* 这里不再重复同步；因此 `props.initValues` 这类高频变化也不会再触发
-			* `extendState` 重跑（旧版的性能问题修复点）。
-			*
-			* 实现细节：合并逻辑统一收口在 `applyExtendState`（utils/form）——
-			* data 描述符走 reactive proxy 的 set 触发依赖通知（与旧版「逐项赋值」语义等价），
-			* accessor 描述符按原样 defineProperty 支持读时求值；
-			* props 派生的只读 getter 字段（keyProp 等）以普通字段形式返回时会被跳过并告警。
+			* 宿主业务上下文：`props.context` 覆盖祖先注入的同名字段。
+			* 嵌套表单（Link / FormBox / FormDialog）通过下面的 provide 自动继承。
 			*/
-			(0, vue.watchEffect)(async (onCleanup) => {
-				const { extendState } = props;
-				if (typeof extendState !== "function") return;
-				let stale = false;
-				onCleanup(() => {
-					stale = true;
-				});
-				let state = {};
-				try {
-					state = await extendState(formState) || {};
-				} catch (e) {
-					console.error("[MForm] extendState failed:", e);
-					return;
-				}
-				if (stale) return;
-				applyExtendState(formState, state, reservedStateKeys);
-			});
+			const contextRef = (0, vue.computed)(() => mergeFormContexts(ancestorContext?.value, props.context));
+			const formState = createFormStateProxy(coreState, () => contextRef.value);
 			(0, vue.provide)("mForm", formState);
+			(0, vue.provide)(FORM_CONTEXT_KEY, contextRef);
 			/**
 			* 把生效主题（自身或祖先）再 provide 出去，供 form 子树内含 `Teleport` 的组件
 			* （如 `TMagicPopover`）在传送目标上挂 `m-theme--<theme>` 类。
@@ -4373,14 +5418,24 @@
 				}
 			});
 			const changeRecords = (0, vue.shallowRef)([]);
-			(0, vue.watch)([() => props.config, () => props.initValues], ([config], [preConfig]) => {
+			/**
+			* 两份配置的结构是否一致；函数一律视为相等。
+			*
+			* 宿主（如编辑器属性面板）往往在每次节点更新后整份重新生成配置，其中的
+			* `display` / `options` / `onChange` 都是新闭包，深比较必然判不等。若据此把 `initialized`
+			* 置 false，整棵表单会卸载重挂，滚动位置、展开态、输入焦点全部丢失。
+			* 配置是响应式 prop，闭包换了照样生效，只有结构变化（增删字段、换组件类型）才需要重挂。
+			*/
+			const isSameConfigShape = (config, preConfig) => isEqualWith(config, preConfig, (a, b) => typeof a === "function" && typeof b === "function" ? true : void 0);
+			(0, vue.watch)([() => props.config, () => props.initValues], async ([config], [preConfig]) => {
 				changeRecords.value = [];
-				if (!isEqual((0, vue.toRaw)(config), (0, vue.toRaw)(preConfig))) initialized.value = false;
+				if (!isSameConfigShape((0, vue.toRaw)(config), (0, vue.toRaw)(preConfig))) initialized.value = false;
 				initValue(formState, {
 					initValues: props.initValues,
 					config: props.config
 				}).then((value) => {
 					values.value = value;
+					applyMountValueEffects(formState, props.config, values.value);
 					initialized.value = !props.isCompare;
 					if (props.validateOnInit) (0, vue.nextTick)(() => {
 						tMagicFormRef.value?.validate();
@@ -4391,6 +5446,7 @@
 					config: props.config
 				}).then((value) => {
 					lastValuesProcessed.value = value;
+					applyMountValueEffects(formState, props.config, lastValuesProcessed.value);
 					initialized.value = true;
 				});
 			}, { immediate: true });
@@ -4408,51 +5464,17 @@
 			const submitHandler = (e) => {
 				if (props.preventSubmitDefault) e.preventDefault();
 			};
-			/**
-			* 通过 name 从 config 中查找对应的 text
-			* @param name - 字段名，支持点分隔的路径格式，如 'a.b.c'
-			* @param config - 表单配置数组
-			* @returns 找到的 text 值，如果未找到则返回 undefined
-			*/
-			const getTextByName = (name, config = props.config) => {
-				if (!name || !Array.isArray(config)) return void 0;
-				const nameParts = name.split(".");
-				const findInConfig = (configs, parts) => {
-					if (parts.length === 0) return void 0;
-					const [currentPart, ...remainingParts] = parts;
-					for (const item of configs) {
-						if (item.name === currentPart) {
-							if (remainingParts.length === 0) return typeof item.text === "string" ? item.text : void 0;
-							if ("items" in item && Array.isArray(item.items)) {
-								const result = findInConfig(item.items, remainingParts);
-								if (result !== void 0) return result;
-							}
-						}
-						if ("items" in item && Array.isArray(item.items)) {
-							const result = findInConfig(item.items, parts);
-							if (result !== void 0) return result;
-						}
-					}
-				};
-				return findInConfig(config, nameParts);
-			};
+			const getTextByName$1 = (name, config = props.config) => getTextByName(name, config);
 			/**
 			* 将校验返回的 invalidFields 汇总为可读的错误文案（多条以 `<br>` 拼接）。
 			*
-			* 抽离为独立方法，供 `submitForm`（提交校验）与 `validate`（返回错误文案的校验）复用，
-			* 保证两种校验入口产出的错误文案格式完全一致。
+			* 实现收口在 `utils/validateError`，供渲染式校验（本组件的 `submitForm` / `validate`）与
+			* 无渲染校验（`validateValues`）共用，保证两条链路产出的错误文案格式完全一致。
 			*/
-			const formatValidateError = (invalidFields) => {
-				const error = [];
-				Object.entries(invalidFields).forEach(([prop, validateError]) => {
-					validateError.forEach(({ field, message }) => {
-						const name = field || prop;
-						const text = (props.useFieldTextInError ? getTextByName(name, props.config) : void 0) || name;
-						error.push(`${text} -> ${message}`);
-					});
-				});
-				return error.join("<br>");
-			};
+			const formatValidateError$1 = (invalidFields) => formatValidateError(invalidFields, {
+				config: props.config,
+				useFieldTextInError: props.useFieldTextInError
+			});
 			__expose({
 				values,
 				lastValuesProcessed,
@@ -4472,7 +5494,7 @@
 						return native ? values.value : cloneDeep((0, vue.toRaw)(values.value));
 					} catch (invalidFields) {
 						emit("error", invalidFields);
-						throw new Error(formatValidateError(invalidFields));
+						throw new Error(formatValidateError$1(invalidFields));
 					}
 				},
 				/**
@@ -4497,10 +5519,10 @@
 						if (result !== true) throw result;
 						return "";
 					} catch (invalidFields) {
-						return formatValidateError(invalidFields);
+						return formatValidateError$1(invalidFields);
 					}
 				},
-				getTextByName
+				getTextByName: getTextByName$1
 			});
 			return (_ctx, _cache) => {
 				return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicForm), {
@@ -4526,6 +5548,7 @@
 							"last-values": lastValuesProcessed.value,
 							"is-compare": __props.isCompare,
 							"label-width": item.labelWidth || __props.labelWidth,
+							"label-position": item.labelPosition || __props.labelPosition,
 							"step-active": __props.stepActive,
 							size: __props.size,
 							onChange: changeHandler
@@ -4540,6 +5563,7 @@
 							"last-values",
 							"is-compare",
 							"label-width",
+							"label-position",
 							"step-active",
 							"size"
 						]);
@@ -4558,38 +5582,29 @@
 	});
 	//#endregion
 	//#region packages/form/src/submitForm.ts
-	/** 未指定或传入非正数 timeout 时的兜底超时（毫秒），保证非 debug 挂载始终能被清理 */
-	var DEFAULT_MOUNT_TIMEOUT = 1e4;
 	/**
-	* submitForm / validateForm 的公共脚手架：
+	* `dialog: true` 时 submitForm / validateForm 的公共脚手架：
 	*
-	* 创建临时容器 → 挂载一个 wrapper 组件（内含 MForm）→ 提供统一的 cleanup / timeout / appContext 继承 →
+	* 创建临时容器 → 挂载一个 wrapper 组件（内含 MForm）→ 提供统一的 cleanup / appContext 继承 →
 	* 由 `createWrapper` 决定「何时调用 MForm 的哪个方法、如何 resolve/reject」。
 	*
-	* 调用方只需关注差异逻辑（调用 `submitForm` 还是 `validate`、结果如何包装、是否需要调试弹层），
-	* 容器创建、卸载、超时、上下文注入等模板代码在此统一收口。
+	* 挂载出来的表单等待人工点击，因此没有超时兜底，靠「确定」/「取消」/`signal` 结束。
 	*/
 	var mountFormInstance = (options) => {
-		const { formProps, appContext, timeout, timeoutMessage, hidden = true, skipTimeout = false, signal, createWrapper } = options;
+		const { formProps, appContext, signal, createWrapper } = options;
 		return new Promise((resolve, reject) => {
 			if (signal?.aborted) {
 				reject(signal.reason ?? /* @__PURE__ */ new Error("mountFormInstance aborted"));
 				return;
 			}
 			let cleaned = false;
-			let timer = null;
 			let onAbort = null;
 			const instance = { app: null };
 			const container = document.createElement("div");
-			if (hidden) container.style.display = "none";
 			document.body.appendChild(container);
 			const cleanup = () => {
 				if (cleaned) return;
 				cleaned = true;
-				if (timer) {
-					clearTimeout(timer);
-					timer = null;
-				}
 				if (signal && onAbort) {
 					signal.removeEventListener("abort", onAbort);
 					onAbort = null;
@@ -4609,53 +5624,16 @@
 			}
 			try {
 				const formRef = (0, vue.ref)(null);
-				const { extendState, ...restFormProps } = formProps;
-				const userWrapper = createWrapper({
+				const wrapperComponent = createWrapper({
 					formRef,
-					formProps: restFormProps,
+					formProps,
 					cleanup,
 					resolve,
 					reject
 				});
-				const wrapperComponent = typeof extendState === "function" ? (0, vue.defineComponent)({
-					name: "MFormExtendStateInjector",
-					setup() {
-						(0, vue.watch)(() => formRef.value, (form) => {
-							if (!form) return;
-							let result;
-							try {
-								result = extendState(form.formState);
-							} catch (e) {
-								console.error("[MForm] extendState failed:", e);
-								return;
-							}
-							const reservedStateKeys = new Set(Reflect.ownKeys(form.formState));
-							const apply = (state) => applyExtendState(form.formState, state, reservedStateKeys);
-							if (result && typeof result.then === "function") result.then(apply, (e) => console.error("[MForm] extendState failed:", e));
-							else apply(result);
-						}, {
-							flush: "sync",
-							immediate: true
-						});
-						return () => (0, vue.h)(userWrapper);
-					}
-				}) : userWrapper;
-				const rootComponent = hidden ? (0, vue.defineComponent)({
-					name: "MFormSilentProvider",
-					setup() {
-						(0, vue.provide)(FORM_SILENT_MODE_KEY, true);
-						return () => (0, vue.h)(wrapperComponent);
-					}
-				}) : wrapperComponent;
-				const app = (0, vue.createApp)(rootComponent);
+				const app = (0, vue.createApp)(wrapperComponent);
 				instance.app = app;
 				if (appContext) Object.assign(app._context, appContext);
-				if (!skipTimeout) timer = setTimeout(() => {
-					if (!cleaned) {
-						reject(new Error(timeoutMessage));
-						cleanup();
-					}
-				}, timeout > 0 ? timeout : DEFAULT_MOUNT_TIMEOUT);
 				app.mount(container);
 			} catch (err) {
 				reject(err);
@@ -4664,12 +5642,12 @@
 		});
 	};
 	/**
-	* 构造调试模式下的可见弹层 wrapper：以 fixed 遮罩居中渲染 MForm，提供「确定 / 取消」按钮与错误展示区。
+	* 构造可见弹层 wrapper：以 fixed 遮罩居中渲染 MForm，提供「确定 / 取消」按钮与错误展示区。
 	*
-	* submitForm 与 validateForm 的调试弹层 UI 完全一致，仅「确定」时调用的实例方法、错误处理与取消文案不同，
+	* submitForm 与 validateForm 的弹层 UI 完全一致，仅「确定」时调用的实例方法、错误处理与取消文案不同，
 	* 这些差异通过 `onConfirm` / `onCancel` 注入，弹层结构在此统一收口。
 	*/
-	var createDebugWrapper = (options) => {
+	var createDialogWrapper = (options) => {
 		const { formRef, formProps, title, name, onConfirm, onCancel } = options;
 		const btnBase = {
 			padding: "8px 20px",
@@ -4752,57 +5730,17 @@
 		});
 	};
 	/**
-	* 以命令式方式调用 Form.vue 完成一次表单校验/提交。
+	* 可见弹层提交：把表单渲染在弹层里，点击「确定」才调用挂载实例的 `submitForm`。
 	*
-	* 类似 ElMessage 的用法：传入 props（包含 `config`/`initValues` 等），函数内部会临时挂载
-	* 一个不可见的 Form 组件实例，等待初始化完成后调用其 `submitForm` 方法，
-	* 校验通过则 resolve 表单值，校验失败则 reject 错误信息，最后自动卸载实例。
-	*
-	* @example
-	* ```ts
-	* import { submitForm } from '@tmagic/form';
-	*
-	* try {
-	*   const values = await submitForm({
-	*     config: [...],
-	*     initValues: { name: 'foo' },
-	*   });
-	*   console.log(values);
-	* } catch (e) {
-	*   console.error(e);
-	* }
-	*
-	* // 需要同时获取变更记录时：
-	* const { values, changeRecords } = await submitForm({
-	*   config: [...],
-	*   initValues: { name: 'foo' },
-	*   returnChangeRecords: true,
-	* });
-	*
-	* // 调试模式：可见地渲染表单，点击「确定」才提交：
-	* const values = await submitForm({
-	*   config: [...],
-	*   initValues: { name: 'foo' },
-	*   debug: true,
-	* });
-	* ```
+	* 用于需要用户填写/确认的场景；默认路径仍是无渲染校验（见 `submitForm` 的说明）。
 	*/
-	var submitForm = (options) => {
-		const { native, appContext, timeout = 1e4, returnChangeRecords, debug = false, signal, ...formProps } = options;
+	var submitFormByDialogRender = (options) => {
+		const { native, appContext, returnChangeRecords, signal, dialog, title, ...formProps } = options;
 		return mountFormInstance({
 			formProps,
 			appContext,
-			timeout,
 			signal,
-			hidden: !debug,
-			skipTimeout: debug,
-			timeoutMessage: `submitForm timeout after ${timeout}ms: form is not initialized.`,
 			createWrapper: ({ formRef, formProps, cleanup, resolve, reject }) => {
-				/**
-				* 执行一次提交：nextTick 等待子组件渲染 → 快照 changeRecords → 调用实例 submitForm → resolve。
-				* 校验失败时交给 `onValidateError` 决定「保留弹层展示错误（debug）」还是「reject 并清理（普通）」，
-				* 从而让 debug 与普通模式共享同一份提交逻辑。
-				*/
 				const doSubmit = async (onValidateError) => {
 					try {
 						await (0, vue.nextTick)();
@@ -4817,39 +5755,19 @@
 						onValidateError(err);
 					}
 				};
-				if (debug) return createDebugWrapper({
+				return createDialogWrapper({
 					formRef,
 					formProps,
 					name: "MFormSubmitWrapper",
-					title: "submitForm 调试",
+					title: title ?? "submitForm",
 					onConfirm: (setError) => doSubmit((err) => {
 						setError(err instanceof Error ? err.message : String(err));
 					}),
 					onCancel: () => {
-						reject(/* @__PURE__ */ new Error("submitForm canceled in debug mode."));
+						reject(/* @__PURE__ */ new Error("submitForm canceled."));
 						cleanup();
 					}
 				});
-				return (0, vue.defineComponent)({
-					name: "MFormSubmitWrapper",
-					setup() {
-						const stop = (0, vue.watch)(() => formRef.value?.initialized, (initialized) => {
-							if (!initialized) return;
-							stop();
-							doSubmit((err) => {
-								reject(err);
-								cleanup();
-							});
-						}, {
-							flush: "post",
-							immediate: true
-						});
-						return () => (0, vue.h)(Form_default, {
-							...formProps,
-							ref: formRef
-						});
-					}
-				});
 			}
 		});
 	};
@@ -4893,61 +5811,20 @@
 		return cloned;
 	};
 	/**
-	* 以命令式方式对一份「表单配置 + 值」做一次静默校验，**不依赖也不影响任何已渲染的表单**。
-	*
-	* 与 `submitForm` 类似，内部会临时挂载一个不可见的 MForm 实例，等待其初始化完成后调用
-	* 实例的 `validate` 方法，返回汇总后的错误文案，随后自动卸载实例。
-	*
-	* 与 `submitForm` 的区别：
-	* - 「静默」：校验失败不抛异常、不触发 `error` 事件、不返回表单值；
-	* - 仅用于「探测」配置是否合法，适合源码保存后校验、批量校验组件配置等场景。
-	*
-	* 由于每次都新建一个独立的 MForm 实例，调用方无需持有任何表单 ref，也不会污染
-	* 页面上正在展示的表单状态。
-	*
-	* @returns 校验通过返回空字符串 `''`，否则返回以 `<br>` 拼接的错误文案。
-	*   仅在初始化超时或挂载失败等异常情况下才会 reject。
-	*
-	* @example
-	* ```ts
-	* import { validateForm } from '@tmagic/form';
-	*
-	* const error = await validateForm({
-	*   config: [...],
-	*   initValues: { name: 'foo' },
-	*   appContext: getCurrentInstance()?.appContext,
-	* });
-	* if (error) {
-	*   // 配置不合法，error 为错误文案
-	* }
-	*
-	* // 调试模式：可见地渲染表单，点击「确定」才校验，校验失败保留弹层可修正重试：
-	* const error = await validateForm({
-	*   config: [...],
-	*   initValues: { name: 'foo' },
-	*   debug: true,
-	* });
-	* ```
+	* 可见弹层校验：把表单渲染在弹层里，点击「确定」才调用挂载实例的 `validate`。
+	*
+	* 用于需要用户填写/确认的场景；默认路径仍是无渲染校验（见 `validateForm` 的说明）。
 	*/
-	var validateForm = (options) => {
-		const { appContext, timeout = 1e4, debug = false, config, signal, ...rest } = options;
+	var validateFormByDialogRender = (options) => {
+		const { appContext, config, signal, dialog, title, ...rest } = options;
 		return mountFormInstance({
 			formProps: {
 				...rest,
 				config: stripTabItemsLazy(config)
 			},
 			appContext,
-			timeout,
 			signal,
-			hidden: !debug,
-			skipTimeout: debug,
-			timeoutMessage: `validateForm timeout after ${timeout}ms: form is not initialized.`,
 			createWrapper: ({ formRef, formProps, cleanup, resolve, reject }) => {
-				/**
-				* 执行一次校验：nextTick 等待子组件渲染 → 调用实例 validate → 通过则 resolve ''。
-				* 校验失败（返回非空错误文案）时交给 `onInvalid` 决定「静默 resolve 错误文案（普通）」
-				* 还是「在弹层展示错误并保留供重试（debug）」，从而让两种模式共享同一份校验逻辑。
-				*/
 				const doValidate = async (onInvalid) => {
 					try {
 						await (0, vue.nextTick)();
@@ -4962,42 +5839,40 @@
 						cleanup();
 					}
 				};
-				if (debug) return createDebugWrapper({
+				return createDialogWrapper({
 					formRef,
 					formProps,
 					name: "MFormValidateWrapper",
-					title: "validateForm 调试",
+					title: title ?? "validateForm",
 					onConfirm: (setError) => doValidate((error) => {
 						setError(error);
 					}),
 					onCancel: () => {
-						reject(/* @__PURE__ */ new Error("validateForm canceled in debug mode."));
+						reject(/* @__PURE__ */ new Error("validateForm canceled."));
 						cleanup();
 					}
 				});
-				return (0, vue.defineComponent)({
-					name: "MFormValidateWrapper",
-					setup() {
-						const stop = (0, vue.watch)(() => formRef.value?.initialized, (initialized) => {
-							if (!initialized) return;
-							stop();
-							doValidate((error) => {
-								resolve(error);
-								cleanup();
-							});
-						}, {
-							flush: "post",
-							immediate: true
-						});
-						return () => (0, vue.h)(Form_default, {
-							...formProps,
-							ref: formRef
-						});
-					}
-				});
 			}
 		});
 	};
+	/**
+	* 以命令式方式对一份「表单配置 + 值」做一次校验并取回表单值。
+	*
+	* 默认走无渲染实现（见 `@tmagic/form/headless`）。`dialog: true` 会把表单以弹层渲染出来。
+	*/
+	var submitForm = async (options) => {
+		if (options.dialog) return submitFormByDialogRender(options);
+		return submitForm$1(options);
+	};
+	/**
+	* 以命令式方式对一份「表单配置 + 值」做一次静默校验。
+	*
+	* 默认走无渲染实现。`dialog: true` 的处理详见 `submitForm`。
+	*/
+	var validateForm = async (options) => {
+		if (options.dialog) return validateFormByDialogRender(options);
+		return validateForm$1(options);
+	};
 	//#endregion
 	//#region packages/form/src/FormDialog.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$13 = { style: { "min-height": "1px" } };
@@ -5050,7 +5925,7 @@
 				type: Boolean,
 				default: true
 			},
-			extendState: {},
+			context: {},
 			theme: {}
 		},
 		emits: [
@@ -5208,7 +6083,7 @@
 						"use-field-text-in-error": __props.useFieldTextInError,
 						"type-match-valid": __props.typeMatchValid,
 						"validate-on-init": __props.validateOnInit,
-						"extend-state": __props.extendState,
+						context: __props.context,
 						theme: effectiveTheme.value,
 						onChange: changeHandler
 					}, null, 8, [
@@ -5225,7 +6100,7 @@
 						"use-field-text-in-error",
 						"type-match-valid",
 						"validate-on-init",
-						"extend-state",
+						"context",
 						"theme"
 					]), (0, vue.renderSlot)(_ctx.$slots, "default")], 4)) : (0, vue.createCommentVNode)("v-if", true)]),
 					_: 3
@@ -5280,7 +6155,7 @@
 				default: true
 			},
 			beforeClose: {},
-			extendState: {},
+			context: {},
 			theme: {}
 		},
 		emits: [
@@ -5431,7 +6306,7 @@
 						"use-field-text-in-error": __props.useFieldTextInError,
 						"type-match-valid": __props.typeMatchValid,
 						"validate-on-init": __props.validateOnInit,
-						"extend-state": __props.extendState,
+						context: __props.context,
 						theme: effectiveTheme.value,
 						onChange: changeHandler
 					}, null, 8, [
@@ -5447,7 +6322,7 @@
 						"use-field-text-in-error",
 						"type-match-valid",
 						"validate-on-init",
-						"extend-state",
+						"context",
 						"theme"
 					]), (0, vue.renderSlot)(_ctx.$slots, "default")], 512)) : (0, vue.createCommentVNode)("v-if", true)]),
 					_: 3
@@ -5493,7 +6368,7 @@
 				type: Boolean,
 				default: true
 			},
-			extendState: {}
+			context: {}
 		},
 		emits: [
 			"change",
@@ -5557,7 +6432,7 @@
 						inline: __props.inline,
 						"prevent-submit-default": __props.preventSubmitDefault,
 						"use-field-text-in-error": __props.useFieldTextInError,
-						"extend-state": __props.extendState,
+						context: __props.context,
 						"type-match-valid": __props.typeMatchValid,
 						"validate-on-init": __props.validateOnInit,
 						onChange: changeHandler
@@ -5572,7 +6447,7 @@
 						"inline",
 						"prevent-submit-default",
 						"use-field-text-in-error",
-						"extend-state",
+						"context",
 						"type-match-valid",
 						"validate-on-init"
 					]), (0, vue.renderSlot)(_ctx.$slots, "default")]),
@@ -5603,7 +6478,7 @@
 	var _hoisted_2$7 = ["innerHTML"];
 	var _hoisted_3$6 = { key: 1 };
 	var _hoisted_4$5 = ["innerHTML"];
-	var _hoisted_5$3 = ["innerHTML"];
+	var _hoisted_5$4 = ["innerHTML"];
 	var _hoisted_6$2 = {
 		key: 2,
 		style: { "display": "flex" }
@@ -5617,6 +6492,7 @@
 		__name: "Fieldset",
 		props: {
 			labelWidth: {},
+			labelPosition: {},
 			prop: { default: "" },
 			size: {},
 			model: {},
@@ -5656,6 +6532,7 @@
 				if (props.config.items) return props.config.labelWidth || props.labelWidth;
 				return props.config.labelWidth || props.labelWidth || (props.config.text ? void 0 : "0");
 			});
+			const lPosition = (0, vue.computed)(() => props.config.labelPosition || props.labelPosition);
 			const valueChangeHandler = (value) => {
 				emit("change", value, { modifyKey: checkboxName.value });
 			};
@@ -5692,7 +6569,7 @@
 					key: 0,
 					innerHTML: __props.config.extra,
 					class: "m-form-tip"
-				}, null, 8, _hoisted_5$3)) : (0, vue.createCommentVNode)("v-if", true)])), __props.config.schematic && show.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_6$2, [(0, vue.createElementVNode)("div", _hoisted_7$1, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.config.items, (item, index) => {
+				}, null, 8, _hoisted_5$4)) : (0, vue.createCommentVNode)("v-if", true)])), __props.config.schematic && show.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_6$2, [(0, vue.createElementVNode)("div", _hoisted_7$1, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.config.items, (item, index) => {
 					return (0, vue.openBlock)(), (0, vue.createBlock)(Container_default, {
 						key: key(item, index),
 						model: name.value ? __props.model[name.value] : __props.model,
@@ -5703,6 +6580,7 @@
 						prop: __props.prop,
 						disabled: __props.disabled,
 						labelWidth: lWidth.value,
+						labelPosition: lPosition.value,
 						size: __props.size,
 						onChange: changeHandler,
 						onAddDiffCount: _cache[0] || (_cache[0] = ($event) => onAddDiffCount())
@@ -5715,6 +6593,7 @@
 						"prop",
 						"disabled",
 						"labelWidth",
+						"labelPosition",
 						"size"
 					]);
 				}), 128))]), (0, vue.createElementVNode)("img", {
@@ -5730,6 +6609,7 @@
 						config: item,
 						prop: __props.prop,
 						labelWidth: lWidth.value,
+						labelPosition: lPosition.value,
 						size: __props.size,
 						disabled: __props.disabled,
 						onChange: changeHandler,
@@ -5742,6 +6622,7 @@
 						"config",
 						"prop",
 						"labelWidth",
+						"labelPosition",
 						"size",
 						"disabled"
 					]);
@@ -5761,6 +6642,7 @@
 			config: {},
 			name: {},
 			labelWidth: {},
+			labelPosition: {},
 			prop: {},
 			size: {},
 			disabled: { type: Boolean }
@@ -5794,6 +6676,7 @@
 						size: __props.size,
 						disabled: __props.disabled,
 						"label-width": __props.config.labelWidth || __props.labelWidth,
+						"label-position": __props.config.labelPosition || __props.labelPosition,
 						onChange: changeHandler,
 						onAddDiffCount: _cache[0] || (_cache[0] = ($event) => onAddDiffCount())
 					}, null, 8, [
@@ -5804,7 +6687,8 @@
 						"prop",
 						"size",
 						"disabled",
-						"label-width"
+						"label-width",
+						"label-position"
 					]);
 				}), 128))], 4);
 			};
@@ -5823,7 +6707,7 @@
 		style: { "display": "flex" }
 	};
 	var _hoisted_4$4 = { style: { "flex": "1" } };
-	var _hoisted_5$2 = ["src"];
+	var _hoisted_5$3 = ["src"];
 	//#endregion
 	//#region packages/form/src/containers/Panel.vue
 	var Panel_default = /* @__PURE__ */ (0, vue.defineComponent)({
@@ -5836,6 +6720,7 @@
 			config: {},
 			name: {},
 			labelWidth: {},
+			labelPosition: {},
 			prop: {},
 			size: {},
 			disabled: { type: Boolean },
@@ -5898,6 +6783,7 @@
 							size: __props.size,
 							disabled: __props.disabled,
 							"label-width": __props.config.labelWidth || __props.labelWidth,
+							"label-position": __props.config.labelPosition || __props.labelPosition,
 							onChange: changeHandler,
 							onAddDiffCount: _cache[2] || (_cache[2] = ($event) => onAddDiffCount())
 						}, null, 8, [
@@ -5908,12 +6794,13 @@
 							"prop",
 							"size",
 							"disabled",
-							"label-width"
+							"label-width",
+							"label-position"
 						]);
 					}), 128))]), (0, vue.createElementVNode)("img", {
 						class: "m-form-schematic",
 						src: __props.config.schematic
-					}, null, 8, _hoisted_5$2)])) : ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, (0, vue.renderList)(items.value, (item, index) => {
+					}, null, 8, _hoisted_5$3)])) : ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, (0, vue.renderList)(items.value, (item, index) => {
 						return (0, vue.openBlock)(), (0, vue.createBlock)(Container_default, {
 							key: item[(0, vue.unref)(mForm)?.keyProp || "__key"] ?? index,
 							config: item,
@@ -5924,6 +6811,7 @@
 							size: __props.size,
 							disabled: __props.disabled,
 							"label-width": __props.config.labelWidth || __props.labelWidth,
+							"label-position": __props.config.labelPosition || __props.labelPosition,
 							onChange: changeHandler,
 							onAddDiffCount: _cache[3] || (_cache[3] = ($event) => onAddDiffCount())
 						}, null, 8, [
@@ -5934,7 +6822,8 @@
 							"prop",
 							"size",
 							"disabled",
-							"label-width"
+							"label-width",
+							"label-position"
 						]);
 					}), 128))])]),
 					_: 3
@@ -5953,6 +6842,7 @@
 			isCompare: { type: Boolean },
 			config: {},
 			labelWidth: {},
+			labelPosition: {},
 			expandMore: { type: Boolean },
 			span: {},
 			size: {},
@@ -5977,6 +6867,7 @@
 						config: __props.config,
 						prop: __props.prop,
 						"label-width": __props.config.labelWidth || __props.labelWidth,
+						"label-position": __props.config.labelPosition || __props.labelPosition,
 						"expand-more": __props.expandMore,
 						size: __props.size,
 						disabled: __props.disabled,
@@ -5990,6 +6881,7 @@
 						"config",
 						"prop",
 						"label-width",
+						"label-position",
 						"expand-more",
 						"size",
 						"disabled"
@@ -6011,6 +6903,7 @@
 			config: {},
 			name: {},
 			labelWidth: {},
+			labelPosition: {},
 			prop: {},
 			size: {},
 			expandMore: { type: Boolean },
@@ -6033,6 +6926,7 @@
 							span: col.span || __props.config.span || 24 / __props.config.items.length,
 							config: col,
 							labelWidth: __props.config.labelWidth || __props.labelWidth,
+							labelPosition: __props.config.labelPosition || __props.labelPosition,
 							expandMore: __props.expandMore,
 							model: __props.name ? __props.model[__props.name] : __props.model,
 							lastValues: __props.name ? __props.lastValues[__props.name] : __props.lastValues,
@@ -6046,6 +6940,7 @@
 							"span",
 							"config",
 							"labelWidth",
+							"labelPosition",
 							"expandMore",
 							"model",
 							"lastValues",
@@ -6076,6 +6971,7 @@
 			name: {},
 			size: {},
 			labelWidth: {},
+			labelPosition: {},
 			prop: { default: "" },
 			expandMore: { type: Boolean },
 			disabled: { type: Boolean }
@@ -6152,12 +7048,15 @@
 						prop: props.prop,
 						config: props.config
 					});
+					const tabsModel = props.model[props.name];
+					if (Array.isArray(tabsModel) && Array.isArray(props.config.items)) for (const tab of tabsModel) applyMountValueEffects(mForm, props.config.items, tab);
 					emit("change", props.model[props.name]);
 				} else {
 					const newObj = await initValue(mForm, {
 						config: props.config.items,
 						initValues: {}
 					});
+					applyMountValueEffects(mForm, props.config.items, newObj);
 					newObj.title = `标签${tabs.value.length + 1}`;
 					props.model[props.name].push(newObj);
 					emit("change", props.model[props.name], { changeRecords: [{
@@ -6227,6 +7126,7 @@
 									prop: __props.config.dynamic ? `${__props.prop}${__props.prop ? "." : ""}${String(tabIndex)}` : tab.name ? `${__props.prop}${__props.prop ? "." : ""}${tab.name}` : __props.prop,
 									size: __props.size,
 									"label-width": tab.labelWidth || __props.labelWidth,
+									"label-position": tab.labelPosition || __props.labelPosition,
 									"expand-more": __props.expandMore,
 									onChange: changeHandler,
 									onAddDiffCount: ($event) => onAddDiffCount(Number(tabIndex))
@@ -6239,6 +7139,7 @@
 									"prop",
 									"size",
 									"label-width",
+									"label-position",
 									"expand-more",
 									"onAddDiffCount"
 								]);
@@ -6254,12 +7155,14 @@
 	//#endregion
 	//#region packages/form/src/containers/GroupListItem.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$9 = { class: "m-fields-group-list-item-header" };
-	var _hoisted_2$5 = ["innerHTML"];
-	var _hoisted_3$4 = { style: {
+	var _hoisted_2$5 = { class: "m-fields-group-list-item-title" };
+	var _hoisted_3$4 = ["innerHTML"];
+	var _hoisted_4$3 = { class: "m-fields-group-list-item-actions" };
+	var _hoisted_5$2 = { style: {
 		"text-align": "right",
 		"margin-top": "20px"
 	} };
-	var _hoisted_4$3 = ["innerHTML"];
+	var _hoisted_6$1 = ["innerHTML"];
 	//#endregion
 	//#region packages/form/src/containers/GroupListItem.vue
 	var GroupListItem_default = /* @__PURE__ */ (0, vue.defineComponent)({
@@ -6272,6 +7175,7 @@
 			groupModel: {},
 			config: {},
 			labelWidth: {},
+			labelPosition: {},
 			prop: {},
 			size: {},
 			index: {},
@@ -6290,13 +7194,8 @@
 			const mForm = (0, vue.inject)("mForm");
 			const defaultExpandQuantity = props.config.defaultExpandQuantity ?? 7;
 			const expand = (0, vue.ref)(props.config.expandAll || defaultExpandQuantity > props.index);
-			const rowConfig = (0, vue.computed)(() => ({
-				type: "row",
-				span: props.config.span || 24,
-				items: props.config.items,
-				labelWidth: props.config.labelWidth,
-				[mForm?.keyProp || "__key"]: `${props.config[mForm?.keyProp || "__key"]}${String(props.index)}`
-			}));
+			const rowConfig = (0, vue.computed)(() => getGroupListRowConfig(props.config, props.index, mForm?.keyProp));
+			const rowProp = (0, vue.computed)(() => appendProp(props.prop, props.index));
 			const title = (0, vue.computed)(() => {
 				if (props.config.titleKey && props.model[props.config.titleKey]) {
 					const { titlePrefix } = props.config;
@@ -6356,101 +7255,112 @@
 							})]),
 							_: 1
 						}, 8, ["disabled"]),
-						(0, vue.createElementVNode)("span", { innerHTML: title.value }, null, 8, _hoisted_2$5),
-						(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTooltip), { content: `删除 ${title.value}` }, {
-							default: (0, vue.withCtx)(() => [!__props.isCompare ? (0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicButton), {
+						(0, vue.createElementVNode)("div", _hoisted_2$5, [(0, vue.renderSlot)(_ctx.$slots, "title", {
+							model: __props.model,
+							index: __props.index,
+							lastValues: __props.lastValues,
+							prop: rowProp.value,
+							title: title.value
+						}, () => [(0, vue.createElementVNode)("span", { innerHTML: title.value }, null, 8, _hoisted_3$4)])]),
+						(0, vue.createElementVNode)("div", _hoisted_4$3, [
+							copyable.value && !__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicButton), {
 								key: 0,
+								link: "",
 								size: "default",
+								type: "primary",
+								icon: (0, vue.unref)(_element_plus_icons_vue.DocumentCopy),
+								disabled: __props.disabled,
+								onClick: copyHandler
+							}, {
+								default: (0, vue.withCtx)(() => [..._cache[6] || (_cache[6] = [(0, vue.createTextVNode)("复制", -1)])]),
+								_: 1
+							}, 8, ["icon", "disabled"])) : (0, vue.createCommentVNode)("v-if", true),
+							movable.value && !__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [(0, vue.withDirectives)((0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
 								link: "",
-								class: "delete-button",
-								icon: (0, vue.unref)(_element_plus_icons_vue.Delete),
+								size: "default",
 								disabled: __props.disabled,
-								onClick: removeHandler
-							}, null, 8, ["icon", "disabled"])), [[vue.vShow, showDelete.value]]) : (0, vue.createCommentVNode)("v-if", true)]),
-							_: 1
-						}, 8, ["content"]),
-						copyable.value && !__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicButton), {
-							key: 0,
-							link: "",
-							size: "default",
-							type: "primary",
-							icon: (0, vue.unref)(_element_plus_icons_vue.DocumentCopy),
-							disabled: __props.disabled,
-							onClick: copyHandler
-						}, {
-							default: (0, vue.withCtx)(() => [..._cache[6] || (_cache[6] = [(0, vue.createTextVNode)("复制", -1)])]),
-							_: 1
-						}, 8, ["icon", "disabled"])) : (0, vue.createCommentVNode)("v-if", true),
-						movable.value && !__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [(0, vue.withDirectives)((0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
-							link: "",
-							size: "default",
-							disabled: __props.disabled,
-							icon: (0, vue.unref)(_element_plus_icons_vue.Top),
-							onClick: _cache[0] || (_cache[0] = ($event) => changeOrder(-1))
-						}, {
-							default: (0, vue.withCtx)(() => [..._cache[7] || (_cache[7] = [(0, vue.createTextVNode)("上移", -1)])]),
-							_: 1
-						}, 8, ["disabled", "icon"]), [[vue.vShow, __props.index !== 0]]), (0, vue.withDirectives)((0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
-							link: "",
-							size: "default",
-							disabled: __props.disabled,
-							icon: (0, vue.unref)(_element_plus_icons_vue.Bottom),
-							onClick: _cache[1] || (_cache[1] = ($event) => changeOrder(1))
-						}, {
-							default: (0, vue.withCtx)(() => [..._cache[8] || (_cache[8] = [(0, vue.createTextVNode)("下移", -1)])]),
-							_: 1
-						}, 8, ["disabled", "icon"]), [[vue.vShow, __props.index !== length.value - 1]])], 64)) : (0, vue.createCommentVNode)("v-if", true),
-						__props.config.moveSpecifyLocation && !__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicPopover), {
-							key: 2,
-							trigger: "click",
-							placement: "top",
-							width: "200",
-							visible: moveSpecifyLocationVisible.value
-						}, {
-							reference: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+								icon: (0, vue.unref)(_element_plus_icons_vue.Top),
+								onClick: _cache[0] || (_cache[0] = ($event) => changeOrder(-1))
+							}, {
+								default: (0, vue.withCtx)(() => [..._cache[7] || (_cache[7] = [(0, vue.createTextVNode)("上移", -1)])]),
+								_: 1
+							}, 8, ["disabled", "icon"]), [[vue.vShow, __props.index !== 0]]), (0, vue.withDirectives)((0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
 								link: "",
-								size: "small",
-								type: "primary",
-								icon: (0, vue.unref)(_element_plus_icons_vue.Position),
+								size: "default",
 								disabled: __props.disabled,
-								onClick: _cache[2] || (_cache[2] = ($event) => moveSpecifyLocationVisible.value = true)
+								icon: (0, vue.unref)(_element_plus_icons_vue.Bottom),
+								onClick: _cache[1] || (_cache[1] = ($event) => changeOrder(1))
 							}, {
-								default: (0, vue.withCtx)(() => [..._cache[9] || (_cache[9] = [(0, vue.createTextVNode)("移动至", -1)])]),
+								default: (0, vue.withCtx)(() => [..._cache[8] || (_cache[8] = [(0, vue.createTextVNode)("下移", -1)])]),
 								_: 1
-							}, 8, ["icon", "disabled"])]),
-							default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", null, [(0, vue.createElementVNode)("div", null, [
-								_cache[10] || (_cache[10] = (0, vue.createTextVNode)(" 第", -1)),
-								(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicInputNumber), {
-									style: { "margin": "0 5px" },
-									modelValue: moveSpecifyLocationIndex.value,
-									"onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => moveSpecifyLocationIndex.value = $event),
-									size: "small",
-									min: 1,
-									disabled: __props.disabled
-								}, null, 8, ["modelValue", "disabled"]),
-								_cache[11] || (_cache[11] = (0, vue.createTextVNode)("行 ", -1))
-							]), (0, vue.createElementVNode)("div", _hoisted_3$4, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
-								size: "small",
-								text: "",
-								onClick: _cache[4] || (_cache[4] = ($event) => moveSpecifyLocationVisible.value = false)
+							}, 8, ["disabled", "icon"]), [[vue.vShow, __props.index !== length.value - 1]])], 64)) : (0, vue.createCommentVNode)("v-if", true),
+							__props.config.moveSpecifyLocation && !__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicPopover), {
+								key: 2,
+								trigger: "click",
+								placement: "top",
+								width: "200",
+								visible: moveSpecifyLocationVisible.value
 							}, {
-								default: (0, vue.withCtx)(() => [..._cache[12] || (_cache[12] = [(0, vue.createTextVNode)("取消", -1)])]),
+								reference: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+									link: "",
+									size: "small",
+									type: "primary",
+									icon: (0, vue.unref)(_element_plus_icons_vue.Position),
+									disabled: __props.disabled,
+									onClick: _cache[2] || (_cache[2] = ($event) => moveSpecifyLocationVisible.value = true)
+								}, {
+									default: (0, vue.withCtx)(() => [..._cache[9] || (_cache[9] = [(0, vue.createTextVNode)("移动至", -1)])]),
+									_: 1
+								}, 8, ["icon", "disabled"])]),
+								default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", null, [(0, vue.createElementVNode)("div", null, [
+									_cache[10] || (_cache[10] = (0, vue.createTextVNode)(" 第", -1)),
+									(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicInputNumber), {
+										style: { "margin": "0 5px" },
+										modelValue: moveSpecifyLocationIndex.value,
+										"onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => moveSpecifyLocationIndex.value = $event),
+										size: "small",
+										min: 1,
+										disabled: __props.disabled
+									}, null, 8, ["modelValue", "disabled"]),
+									_cache[11] || (_cache[11] = (0, vue.createTextVNode)("行 ", -1))
+								]), (0, vue.createElementVNode)("div", _hoisted_5$2, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+									size: "small",
+									text: "",
+									onClick: _cache[4] || (_cache[4] = ($event) => moveSpecifyLocationVisible.value = false)
+								}, {
+									default: (0, vue.withCtx)(() => [..._cache[12] || (_cache[12] = [(0, vue.createTextVNode)("取消", -1)])]),
+									_: 1
+								}), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+									size: "small",
+									type: "primary",
+									onClick: moveSpecifyLocationHandler
+								}, {
+									default: (0, vue.withCtx)(() => [..._cache[13] || (_cache[13] = [(0, vue.createTextVNode)("确认", -1)])]),
+									_: 1
+								})])])]),
 								_: 1
-							}), (0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
-								size: "small",
-								type: "primary",
-								onClick: moveSpecifyLocationHandler
+							}, 8, ["visible"])) : (0, vue.createCommentVNode)("v-if", true),
+							(0, vue.createCommentVNode)(" v-if 必须挂在 Tooltip 上：子节点为 false 时 ElOnlyChild 会报 no valid child node found "),
+							!__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+								key: 3,
+								content: `删除 ${title.value}`
 							}, {
-								default: (0, vue.withCtx)(() => [..._cache[13] || (_cache[13] = [(0, vue.createTextVNode)("确认", -1)])]),
+								default: (0, vue.withCtx)(() => [(0, vue.withDirectives)((0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+									size: "default",
+									link: "",
+									class: "delete-button",
+									icon: (0, vue.unref)(_element_plus_icons_vue.Delete),
+									disabled: __props.disabled,
+									onClick: removeHandler
+								}, null, 8, ["icon", "disabled"]), [[vue.vShow, showDelete.value]])]),
 								_: 1
-							})])])]),
-							_: 1
-						}, 8, ["visible"])) : (0, vue.createCommentVNode)("v-if", true),
-						itemExtra.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
-							key: 3,
-							innerHTML: itemExtra.value,
-							class: "m-form-tip"
-						}, null, 8, _hoisted_4$3)) : (0, vue.createCommentVNode)("v-if", true)
+							}, 8, ["content"])) : (0, vue.createCommentVNode)("v-if", true),
+							itemExtra.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+								key: 4,
+								innerHTML: itemExtra.value,
+								class: "m-form-tip"
+							}, null, 8, _hoisted_6$1)) : (0, vue.createCommentVNode)("v-if", true)
+						])
 					])]),
 					default: (0, vue.withCtx)(() => [expand.value ? ((0, vue.openBlock)(), (0, vue.createBlock)(Container_default, {
 						key: 0,
@@ -6459,7 +7369,8 @@
 						lastValues: __props.lastValues,
 						"is-compare": __props.isCompare,
 						labelWidth: __props.labelWidth,
-						prop: `${__props.prop}${__props.prop ? "." : ""}${String(__props.index)}`,
+						labelPosition: __props.labelPosition,
+						prop: rowProp.value,
 						size: __props.size,
 						disabled: __props.disabled,
 						onChange: changeHandler,
@@ -6470,11 +7381,12 @@
 						"lastValues",
 						"is-compare",
 						"labelWidth",
+						"labelPosition",
 						"prop",
 						"size",
 						"disabled"
 					])) : (0, vue.createCommentVNode)("v-if", true)]),
-					_: 1
+					_: 3
 				}, 8, ["flat", "body-style"]);
 			};
 		}
@@ -6488,11 +7400,7 @@
 		class: "el-table__empty-block"
 	};
 	var _hoisted_4$2 = { class: "el-table__empty-text t-table__empty" };
-	var _hoisted_5$1 = {
-		key: 3,
-		class: "m-fields-group-list-footer"
-	};
-	var _hoisted_6$1 = { style: {
+	var _hoisted_5$1 = { style: {
 		"display": "flex",
 		"justify-content": "flex-end",
 		"flex": "1"
@@ -6509,6 +7417,7 @@
 			config: {},
 			name: {},
 			labelWidth: {},
+			labelPosition: {},
 			prop: {},
 			size: {},
 			disabled: { type: Boolean },
@@ -6537,7 +7446,23 @@
 				emit("change", props.model[props.name]);
 			};
 			const onAddDiffCount = () => emit("addDiffCount");
-			const getLastValues = (item, index) => item?.[index] || {};
+			const asList = (value) => Array.isArray(value) ? value : [];
+			const currentList = (0, vue.computed)(() => asList(props.model[props.name]));
+			/** 对比时按当前/历史较长一侧对齐，已删除的项也能渲染出来 */
+			const displayItems = (0, vue.computed)(() => {
+				const current = currentList.value;
+				if (!props.isCompare) return current.map((item, index) => ({
+					item: item ?? {},
+					last: {},
+					index
+				}));
+				const last = asList(props.lastValues?.[props.name]);
+				return Array.from({ length: Math.max(current.length, last.length) }, (_, index) => ({
+					item: current[index] ?? {},
+					last: last[index] ?? {},
+					index
+				}));
+			});
 			return (_ctx, _cache) => {
 				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1$8, [
 					__props.config.extra ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
@@ -6545,25 +7470,30 @@
 						innerHTML: __props.config.extra,
 						style: { "color": "rgba(0, 0, 0, 0.45)" }
 					}, null, 8, _hoisted_2$4)) : (0, vue.createCommentVNode)("v-if", true),
-					!__props.model[__props.name] || !__props.model[__props.name].length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_3$3, [(0, vue.createElementVNode)("span", _hoisted_4$2, "暂无" + (0, vue.toDisplayString)(__props.config.titlePrefix || "") + "数据", 1)])) : ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 2 }, (0, vue.renderList)(__props.model[__props.name], (item, index) => {
+					!displayItems.value.length ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_3$3, [(0, vue.createElementVNode)("span", _hoisted_4$2, "暂无" + (0, vue.toDisplayString)(__props.config.titlePrefix || "") + "数据", 1)])) : ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 2 }, (0, vue.renderList)(displayItems.value, (entry) => {
 						return (0, vue.openBlock)(), (0, vue.createBlock)(GroupListItem_default, {
-							key: index,
-							model: item,
-							lastValues: getLastValues(__props.lastValues?.[__props.name], Number(index)),
+							key: entry.index,
+							model: entry.item,
+							lastValues: entry.last,
 							"is-compare": __props.isCompare,
 							config: __props.config,
 							prop: __props.prop,
-							index: Number(index),
+							index: entry.index,
 							"label-width": __props.labelWidth,
+							"label-position": __props.labelPosition,
 							size: __props.size,
 							disabled: __props.disabled,
-							"group-model": __props.model[__props.name],
+							"group-model": currentList.value,
 							onRemoveItem: removeHandler,
 							onCopyItem: copyHandler,
 							onSwapItem: swapHandler,
 							onChange: changeHandler,
 							onAddDiffCount: _cache[0] || (_cache[0] = ($event) => onAddDiffCount())
-						}, null, 8, [
+						}, (0, vue.createSlots)({ _: 2 }, [_ctx.$slots.title ? {
+							name: "title",
+							fn: (0, vue.withCtx)((slotProps) => [(0, vue.renderSlot)(_ctx.$slots, "title", (0, vue.mergeProps)({ ref_for: true }, slotProps))]),
+							key: "0"
+						} : void 0]), 1032, [
 							"model",
 							"lastValues",
 							"is-compare",
@@ -6571,12 +7501,16 @@
 							"prop",
 							"index",
 							"label-width",
+							"label-position",
 							"size",
 							"disabled",
 							"group-model"
 						]);
 					}), 128)),
-					!__props.isCompare ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_5$1, [(0, vue.renderSlot)(_ctx.$slots, "toggle-button"), (0, vue.createElementVNode)("div", _hoisted_6$1, [(0, vue.renderSlot)(_ctx.$slots, "add-button")])])) : (0, vue.createCommentVNode)("v-if", true)
+					!__props.isCompare && (_ctx.$slots["toggle-button"] || _ctx.$slots["add-button"]) ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+						key: 3,
+						class: (0, vue.normalizeClass)(["m-fields-group-list-footer", { "is-sticky-full": Boolean(__props.config.addButtonConfig?.sticky) }])
+					}, [(0, vue.renderSlot)(_ctx.$slots, "toggle-button"), (0, vue.createElementVNode)("div", _hoisted_5$1, [(0, vue.renderSlot)(_ctx.$slots, "add-button")])], 2)) : (0, vue.createCommentVNode)("v-if", true)
 				]);
 			};
 		}
@@ -6946,15 +7880,7 @@
 			if (typeof props.config.selection === "function") return props.config.selection(mForm, { model: props.model[modelName.value] });
 			return props.config.selection;
 		});
-		const getProp = (index) => {
-			return `${props.prop}${props.prop ? "." : ""}${index + 1 + currentPage.value * pageSize.value - 1}`;
-		};
-		const makeConfig = (config, row) => {
-			const newConfig = cloneDeep(config);
-			if (typeof config.itemsFunction === "function") newConfig.items = config.itemsFunction(row);
-			delete newConfig.display;
-			return newConfig;
-		};
+		const getProp = (index) => appendProp(props.prop, index + currentPage.value * pageSize.value);
 		const changeHandler = (v, eventData) => {
 			emit("change", props.model, eventData);
 		};
@@ -7033,7 +7959,7 @@
 				},
 				cell: ({ $index }) => (0, vue.h)("span", $index + 1 + currentPage.value * pageSize.value)
 			});
-			for (const column of props.config.items) if (column.type !== "hidden" && display$1(column.display)) {
+			for (const column of props.config.items) if (isTableColumnRendered(column, display$1)) {
 				const titleTipValue = titleTip(column.titleTip);
 				columns.push({
 					props: {
@@ -7049,7 +7975,7 @@
 						disabled: props.disabled,
 						prop: getProp($index),
 						rules: column.rules,
-						config: makeConfig(column, row),
+						config: makeTableColumnConfig(column, row),
 						model: row,
 						lastValues: lastData.value[$index],
 						isCompare: props.isCompare,
@@ -7081,7 +8007,7 @@
 	} };
 	var _hoisted_3$2 = { style: { "display": "flex" } };
 	var _hoisted_4$1 = {
-		key: 1,
+		key: 2,
 		class: "bottom",
 		style: { "text-align": "right" }
 	};
@@ -7148,12 +8074,14 @@
 						style: { "color": "rgba(0, 0, 0, 0.45)" },
 						innerHTML: __props.config.extra
 					}, null, 8, _hoisted_1$7)) : (0, vue.createCommentVNode)("v-if", true),
-					(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+					(0, vue.createCommentVNode)(" v-if 必须挂在 Tooltip 上：表格未就绪时 ElOnlyChild 会报 no valid child node found "),
+					__props.model[modelName.value] ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTooltip), {
+						key: 1,
 						content: "拖拽可排序",
 						placement: "left-start",
 						disabled: __props.config.dropSort !== true || __props.config.dropSortHandle
 					}, {
-						default: (0, vue.withCtx)(() => [__props.model[modelName.value] ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTable), {
+						default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicTable), {
 							ref: "tMagicTable",
 							style: { "width": "100%" },
 							"show-header": "",
@@ -7175,9 +8103,9 @@
 							"max-height",
 							"onSelect",
 							"empty-text"
-						])) : (0, vue.createCommentVNode)("v-if", true)]),
+						]))]),
 						_: 1
-					}, 8, ["disabled"]),
+					}, 8, ["disabled"])) : (0, vue.createCommentVNode)("v-if", true),
 					(0, vue.renderSlot)(_ctx.$slots, "default"),
 					(0, vue.createElementVNode)("div", _hoisted_2$3, [(0, vue.createElementVNode)("div", _hoisted_3$2, [
 						!(0, vue.unref)(isFullscreen) ? (0, vue.renderSlot)(_ctx.$slots, "toggle-button", {}, void 0, void 0, 0) : (0, vue.createCommentVNode)("v-if", true),
@@ -7256,39 +8184,46 @@
 		const addable = (0, vue.computed)(() => {
 			const modelName = props.name || props.config.name || "";
 			if (!modelName) return false;
-			if (!props.model[modelName]?.length) return true;
-			if (typeof props.config.addable === "function") return props.config.addable(mForm, {
+			if (typeof props.config.addable === "function") return Boolean(props.config.addable(mForm, {
 				model: props.model[modelName],
 				formValue: mForm?.values,
 				prop: props.prop,
 				config: props.config
-			});
-			return typeof props.config.addable === "undefined" ? true : props.config.addable;
+			}));
+			if (!props.model[modelName]?.length) return true;
+			return typeof props.config.addable === "undefined" ? true : Boolean(props.config.addable);
 		});
+		/**
+		* 新增一项，返回新增后列表应有的长度；没有新增（超上限 / 被 beforeAddRow 拦下 / enum 用尽）返回 null。
+		*
+		* 只抛 change，不直接改 `props.model`：写回由 `MForm` 按 changeRecords 的 propPath 完成。
+		* 返回长度是给调用方用的——新项要等写回后才出现在 DOM 里，靠它才能判断等到了没有。
+		*/
 		const newHandler = async (row) => {
-			const modelName = props.name || props.config.name || "";
-			if (props.config.max && props.model[modelName].length >= props.config.max) {
+			const modelName = `${props.name || props.config.name || ""}`;
+			const list = Array.isArray(props.model[modelName]) ? props.model[modelName] : [];
+			if (props.config.max && list.length >= props.config.max) {
 				_tmagic_design.tMagicMessage.error(`最多新增配置不能超过${props.config.max}条`);
-				return;
+				return null;
 			}
 			if (typeof props.config.beforeAddRow === "function") {
 				if (!await props.config.beforeAddRow(mForm, {
-					model: props.model[modelName],
+					model: list,
 					formValue: mForm?.values,
 					prop: props.prop
-				})) return;
+				})) return null;
 			}
 			const columns = props.config.items;
 			const enumValues = props.config.enum || [];
 			let enumV = [];
-			const { length } = props.model[modelName];
+			const { length } = list;
 			const key = props.config.key || "id";
 			let inputs = {};
 			if (enumValues.length) {
-				if (length >= enumValues.length) return;
+				if (length >= enumValues.length) return null;
 				enumV = enumValues.filter((item) => {
 					let i = 0;
-					for (; i < length; i++) if (item[key] === props.model[modelName][i][key]) break;
+					for (; i < length; i++) if (item[key] === list[i][key]) break;
 					return i === length;
 				});
 				if (enumV.length > 0) inputs = enumV[0];
@@ -7297,7 +8232,7 @@
 			});
 			else {
 				if (typeof props.config.defaultAdd === "function") inputs = await props.config.defaultAdd(mForm, {
-					model: props.model[modelName],
+					model: list,
 					prop: props.prop,
 					formValue: mForm?.values
 				});
@@ -7307,11 +8242,13 @@
 					initValues: inputs
 				});
 			}
-			if (props.sortKey && length) inputs[props.sortKey] = props.model[modelName][length - 1][props.sortKey] - 1;
-			emit("change", [...props.model[modelName], inputs], { changeRecords: [{
-				propPath: `${props.prop}.${props.model[modelName].length}`,
+			applyMountValueEffects(mForm, columns, inputs);
+			if (props.sortKey && length) inputs[props.sortKey] = list[length - 1][props.sortKey] - 1;
+			emit("change", [...list, inputs], { changeRecords: [{
+				propPath: `${props.prop}.${length}`,
 				value: inputs
 			}] });
+			return length + 1;
 		};
 		return {
 			addable,
@@ -7319,6 +8256,76 @@
 		};
 	};
 	//#endregion
+	//#region packages/form/src/containers/table-group-list/useScrollLastItemIntoView.ts
+	var nextFrame = () => new Promise((resolve) => requestAnimationFrame(() => resolve()));
+	/** 滚动要用的列表根与最后一项；组件已卸载（宿主重建了整棵表单）时返回 null */
+	var resolveScrollTarget = (listRef) => {
+		const inst = listRef.value;
+		const root = inst instanceof HTMLElement ? inst : inst?.$el;
+		if (!(root instanceof HTMLElement)) return null;
+		const items = root.querySelectorAll(":scope > .m-fields-group-list-item");
+		const last = items[items.length - 1];
+		return {
+			root,
+			last: last instanceof HTMLElement ? last : null,
+			count: items.length
+		};
+	};
+	/** 吸顶标题自身的高度：滚动后新项的标题不能被上一层标题压住 */
+	var getStickyHeaderOffset = (item) => {
+		const header = item.querySelector(":scope > .el-card__header, :scope > .t-card__header");
+		if (!(header instanceof HTMLElement)) return 0;
+		return Number.parseFloat(getComputedStyle(header).top) || 0;
+	};
+	/** 吸底「新增」按钮盖住的高度；嵌套列表的 footer 还用 bottom 给外层按钮留了位 */
+	var getStickyFooterOffset = (root) => {
+		const footer = root.querySelector(":scope > .m-fields-group-list-footer.is-sticky-full");
+		if (!(footer instanceof HTMLElement)) return 0;
+		return footer.getBoundingClientRect().height + (Number.parseFloat(getComputedStyle(footer).bottom) || 0);
+	};
+	/**
+	* 等列表渲染出至少 `expectedCount` 项、且最后一项的 DOM 节点连续两帧不变再返回。
+	*
+	* 新增只抛 change，写回要经过宿主（如编辑器属性面板）的异步校验与表单值重建，
+	* 新项不一定当帧就出现；期间宿主还可能自己再追加项，末尾节点会换掉。
+	* 只判「节点不变」会滚到旧的最后一项上，所以先等够数量再等稳定。
+	*/
+	var waitForStableTarget = async (listRef, expectedCount, timeout = 600) => {
+		const deadline = Date.now() + timeout;
+		let previous = null;
+		while (Date.now() < deadline) {
+			const target = resolveScrollTarget(listRef);
+			if (!target) return null;
+			if (target.count >= expectedCount && target.last && target.last === previous) return target;
+			previous = target.last;
+			await nextFrame();
+		}
+		return resolveScrollTarget(listRef);
+	};
+	/**
+	* 新增后把最后一项滚进视口，避开吸顶标题与吸底按钮。
+	*
+	* `enabled` 为 false（未开配置、或不在 group-list 形态）时直接返回。
+	*/
+	var useScrollLastItemIntoView = (listRef, enabled) => {
+		const scrollLastItemIntoView = async (expectedCount) => {
+			if (!enabled()) return;
+			await (0, vue.nextTick)();
+			const target = await waitForStableTarget(listRef, expectedCount);
+			if (!target?.last) return;
+			const { root, last } = target;
+			const top = getStickyHeaderOffset(last);
+			const bottom = getStickyFooterOffset(root);
+			last.style.scrollMarginTop = top ? `${top}px` : "";
+			last.style.scrollMarginBottom = bottom ? `${bottom}px` : "";
+			last.scrollIntoView({
+				behavior: "auto",
+				block: "nearest"
+			});
+		};
+		return { scrollLastItemIntoView };
+	};
+	//#endregion
 	//#region packages/form/src/containers/table-group-list/TableGroupList.vue
 	var TableGroupList_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormTableGroupList",
@@ -7332,6 +8339,7 @@
 			name: {},
 			prop: {},
 			labelWidth: {},
+			labelPosition: {},
 			disabled: { type: Boolean },
 			size: {},
 			enableToggleMode: { type: Boolean },
@@ -7348,63 +8356,47 @@
 			const props = __props;
 			const emit = __emit;
 			const { addable, newHandler } = useAdd(props, emit);
-			const isGroupListType = (type) => type === "groupList" || type === "group-list";
 			const displayMode = (0, vue.ref)(isGroupListType(props.config.type) ? "groupList" : "table");
-			const calcLabelWidth = (label) => {
-				if (!label) return "0px";
-				const zhLength = label.match(/[^\x00-\xff]/g)?.length || 0;
-				const chLength = label.length - zhLength;
-				return `${Math.max(chLength * 8 + zhLength * 20, 80)}px`;
-			};
-			const tableConfig = (0, vue.computed)(() => {
-				if (!isGroupListType(props.config.type)) return props.config;
-				const source = props.config;
-				return {
-					...props.config,
-					type: "table",
-					groupItems: source.items,
-					items: source.tableItems || source.items.map((item) => ({
-						...item,
-						label: item.label || item.text,
-						text: null
-					}))
-				};
-			});
-			const groupListConfig = (0, vue.computed)(() => {
-				if (isGroupListType(props.config.type)) return props.config;
-				const source = props.config;
-				return {
-					...props.config,
-					type: "groupList",
-					tableItems: source.items,
-					items: source.groupItems || source.items.map((item) => {
-						const text = item.text || item.label;
-						return {
-							...item,
-							text,
-							labelWidth: calcLabelWidth(text),
-							span: item.span || 12
-						};
-					})
-				};
-			});
+			const tableConfig = (0, vue.computed)(() => toTableConfig(props.config));
+			const groupListConfig = (0, vue.computed)(() => toGroupListConfig(props.config));
 			const currentConfig = (0, vue.computed)(() => displayMode.value === "table" ? tableConfig.value : groupListConfig.value);
 			const addButtonSize = (0, vue.computed)(() => {
+				if (currentConfig.value.addButtonConfig?.sticky) return "default";
 				if (displayMode.value === "table") return "small";
 				return props.config.enableToggleMode !== false ? "small" : "default";
 			});
+			const addButtonProps = (0, vue.computed)(() => {
+				const custom = currentConfig.value.addButtonConfig?.props;
+				if (custom) return {
+					type: "primary",
+					...custom
+				};
+				if (displayMode.value === "table") return {
+					type: "primary",
+					plain: true
+				};
+				return {
+					type: "primary",
+					text: true
+				};
+			});
 			const toggleDisplayMode = () => {
 				displayMode.value = displayMode.value === "table" ? "groupList" : "table";
 			};
+			const tableGroupListRef = (0, vue.useTemplateRef)("tableGroupList");
+			const { scrollLastItemIntoView } = useScrollLastItemIntoView(tableGroupListRef, () => Boolean(currentConfig.value.scrollLastItemIntoView) && displayMode.value === "groupList");
+			const handleAdd = async () => {
+				const expectedCount = await newHandler();
+				if (expectedCount !== null) await scrollLastItemIntoView(expectedCount);
+			};
 			const onChange = (v, eventData) => emit("change", v, eventData);
 			const onSelect = (...args) => emit("select", ...args);
 			const onAddDiffCount = () => emit("addDiffCount");
-			const onAdd = (rows) => {
-				rows.forEach((row) => {
-					newHandler(row);
-				});
+			const onAdd = async (rows) => {
+				let expectedCount = null;
+				for (const row of rows) expectedCount = await newHandler(row) ?? expectedCount;
+				if (expectedCount !== null) await scrollLastItemIntoView(expectedCount);
 			};
-			const tableGroupListRef = (0, vue.useTemplateRef)("tableGroupList");
 			__expose({ toggleRowSelection: (row, selected) => tableGroupListRef.value?.toggleRowSelection?.(row, selected) });
 			return (_ctx, _cache) => {
 				return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(displayMode.value === "table" ? Table_default : GroupList_default), (0, vue.mergeProps)({ ref: "tableGroupList" }, _ctx.$attrs, {
@@ -7417,6 +8409,7 @@
 					"last-values": __props.lastValues,
 					prop: __props.prop,
 					"label-width": __props.labelWidth,
+					"label-position": __props.labelPosition,
 					"show-index": __props.showIndex,
 					"sort-key": __props.sortKey,
 					sort: __props.sort,
@@ -7424,39 +8417,43 @@
 					onSelect,
 					onAddDiffCount,
 					onAdd
-				}), (0, vue.createSlots)({
-					"toggle-button": (0, vue.withCtx)(() => [__props.config.enableToggleMode || __props.enableToggleMode ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicButton), {
-						key: 0,
-						icon: (0, vue.unref)(_element_plus_icons_vue.Grid),
-						size: "small",
-						onClick: toggleDisplayMode
-					}, {
-						default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(displayMode.value === "table" ? "展开配置" : "切换为表格"), 1)]),
-						_: 1
-					}, 8, ["icon"])) : (0, vue.createCommentVNode)("v-if", true)]),
-					_: 2
-				}, [(0, vue.unref)(addable) ? {
-					name: "add-button",
-					fn: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), (0, vue.mergeProps)({
-						class: displayMode.value === "table" ? "m-form-table-add-button" : "",
-						size: addButtonSize.value,
-						plain: displayMode.value === "table",
-						icon: (0, vue.unref)(_element_plus_icons_vue.Plus),
-						text: "",
-						disabled: __props.disabled
-					}, currentConfig.value.addButtonConfig?.props || { type: "primary" }, { onClick: (0, vue.unref)(newHandler) }), {
-						default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(currentConfig.value.addButtonConfig?.text || (displayMode.value === "table" ? `新增一行${groupListConfig.value.titlePrefix || ""}` : `新增${groupListConfig.value.titlePrefix || ""}`)), 1)]),
-						_: 1
-					}, 16, [
-						"class",
-						"size",
-						"plain",
-						"icon",
-						"disabled",
-						"onClick"
-					])]),
-					key: "0"
-				} : void 0]), 1040, [
+				}), (0, vue.createSlots)({ _: 2 }, [
+					__props.config.enableToggleMode || __props.enableToggleMode ? {
+						name: "toggle-button",
+						fn: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), {
+							icon: (0, vue.unref)(_element_plus_icons_vue.Grid),
+							size: "small",
+							onClick: toggleDisplayMode
+						}, {
+							default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(displayMode.value === "table" ? "展开配置" : "切换为表格"), 1)]),
+							_: 1
+						}, 8, ["icon"])]),
+						key: "0"
+					} : void 0,
+					(0, vue.unref)(addable) ? {
+						name: "add-button",
+						fn: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicButton), (0, vue.mergeProps)({
+							class: displayMode.value === "table" ? "m-form-table-add-button" : "",
+							size: addButtonSize.value,
+							icon: (0, vue.unref)(_element_plus_icons_vue.Plus),
+							disabled: __props.disabled
+						}, addButtonProps.value, { onClick: handleAdd }), {
+							default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(currentConfig.value.addButtonConfig?.text || (displayMode.value === "table" ? `新增一行${groupListConfig.value.titlePrefix || ""}` : `新增${groupListConfig.value.titlePrefix || ""}`)), 1)]),
+							_: 1
+						}, 16, [
+							"class",
+							"size",
+							"icon",
+							"disabled"
+						])]),
+						key: "1"
+					} : void 0,
+					_ctx.$slots.title ? {
+						name: "title",
+						fn: (0, vue.withCtx)((slotProps) => [(0, vue.renderSlot)(_ctx.$slots, "title", (0, vue.normalizeProps)((0, vue.guardReactiveProps)(slotProps)))]),
+						key: "2"
+					} : void 0
+				]), 1040, [
 					"model",
 					"name",
 					"config",
@@ -7466,6 +8463,7 @@
 					"last-values",
 					"prop",
 					"label-width",
+					"label-position",
 					"show-index",
 					"sort-key",
 					"sort"
@@ -7784,13 +8782,13 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/fields/NumberRange.vue?vue&type=script&setup=true&lang.ts
+	//#region packages/form/src/fields/NumberRange/Index.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$5 = { class: "m-fields-number-range" };
 	//#endregion
-	//#region packages/form/src/fields/NumberRange.vue
-	var NumberRange_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	//#region packages/form/src/fields/NumberRange/Index.vue
+	var Index_default$5 = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormNumberRange",
-		__name: "NumberRange",
+		__name: "Index",
 		props: {
 			config: {},
 			model: {},
@@ -7820,7 +8818,6 @@
 				deep: true
 			});
 			useAddField(props.prop);
-			if (!Array.isArray(props.model[props.name])) props.model[props.name] = [];
 			const minChangeHandler = (v) => {
 				emit("change", [Number(v), props.model[props.name][1]]);
 			};
@@ -7920,10 +8917,10 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/fields/Date.vue
-	var Date_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	//#region packages/form/src/fields/Date/Index.vue
+	var Index_default$1 = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormDate",
-		__name: "Date",
+		__name: "Index",
 		props: {
 			config: {},
 			model: {},
@@ -7944,7 +8941,6 @@
 			const props = __props;
 			const emit = __emit;
 			useAddField(props.prop);
-			props.model[props.name] = datetimeFormatter(props.model[props.name], "", props.config.valueFormat || "YYYY/MM/DD");
 			const changeHandler = (v) => {
 				emit("change", v);
 			};
@@ -7970,10 +8966,10 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/fields/DateTime.vue
-	var DateTime_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	//#region packages/form/src/fields/DateTime/Index.vue
+	var Index_default$2 = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormDateTime",
-		__name: "DateTime",
+		__name: "Index",
 		props: {
 			config: {},
 			model: {},
@@ -7994,9 +8990,6 @@
 			const props = __props;
 			const emit = __emit;
 			useAddField(props.prop);
-			const value = props.model?.[props.name]?.toString();
-			if (props.model) if (!value || value === "Invalid Date") props.model[props.name] = "";
-			else props.model[props.name] = datetimeFormatter(props.model[props.name], "", props.config.valueFormat || "YYYY/MM/DD HH:mm:ss");
 			const changeHandler = (v) => {
 				emit("change", v);
 			};
@@ -8426,10 +9419,10 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/fields/CheckboxGroup.vue
-	var CheckboxGroup_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	//#region packages/form/src/fields/CheckboxGroup/Index.vue
+	var Index_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormCheckGroup",
-		__name: "CheckboxGroup",
+		__name: "Index",
 		props: {
 			config: {},
 			model: {},
@@ -8450,7 +9443,6 @@
 			const props = __props;
 			const emit = __emit;
 			useAddField(props.prop);
-			if (props.model && !props.model[props.name]) props.model[props.name] = [];
 			const changeHandler = (v) => {
 				emit("change", v);
 			};
@@ -8571,13 +9563,13 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/fields/Display.vue?vue&type=script&setup=true&lang.ts
+	//#region packages/form/src/fields/Display/Index.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1$3 = { key: 0 };
 	//#endregion
-	//#region packages/form/src/fields/Display.vue
-	var Display_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	//#region packages/form/src/fields/Display/Index.vue
+	var Index_default$3 = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormDisplay",
-		__name: "Display",
+		__name: "Index",
 		props: {
 			config: {},
 			model: {},
@@ -8596,7 +9588,6 @@
 		setup(__props) {
 			const props = __props;
 			const mForm = (0, vue.inject)("mForm");
-			if (props.config.initValue && props.model) props.model[props.name] = props.config.initValue;
 			const text = (0, vue.computed)(() => {
 				if (props.config.displayText) return filterFunction(mForm, props.config.displayText, props);
 				return props.model[props.name];
@@ -8927,7 +9918,10 @@
 					prop: props.prop,
 					postOptions
 				});
-				let initData = (0, _tmagic_utils.getValueByKeyPath)(initRoot || root, res);
+				let initData;
+				try {
+					initData = (0, _tmagic_utils.getValueByKeyPath)(initRoot || root, res);
+				} catch {}
 				if (initData) {
 					if (!Array.isArray(initData)) initData = [initData];
 					if (typeof option.item === "function") options = option.item(initData);
@@ -8958,8 +9952,12 @@
 					const v = props.model[props.name];
 					if (Array.isArray(v) ? !v.length : typeof v === "undefined") return;
 					if (typeof v === "undefined" || hasOption(v)) return;
-					const data = await getInitOption();
-					setOptions(data);
+					try {
+						const data = await getInitOption();
+						setOptions(data);
+					} catch {
+						setOptions([]);
+					}
 				};
 				(0, vue.watch)(() => props.model?.[props.name], () => {
 					initOption();
@@ -9054,7 +10052,7 @@
 					}), 128)) : ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, (0, vue.renderList)(options.value, (option) => {
 						return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(optionComponent)?.component || "el-option"), (0, vue.mergeProps)({
 							class: "tmagic-design-option",
-							key: __props.config.valueKey ? option.value[__props.config.valueKey] : option.value
+							key: __props.config.valueKey ? option.value?.[__props.config.valueKey] : option.value
 						}, { ref_for: true }, (0, vue.unref)(optionComponent)?.props({
 							label: option.text,
 							value: option.value,
@@ -9204,13 +10202,50 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/fields/DynamicField.vue?vue&type=script&setup=true&lang.ts
+	//#region packages/form/src/fields/DynamicField/effect.ts
+	/**
+	* 遍历动态字段列表，按「原值为空且声明了 defaultValue 则取默认值」求出每个字段当前的值。
+	*
+	* `isDefaultApplied` 为真表示该值来自 `defaultValue`，需要写回表单值
+	* （组件通过 emit change 写回，初始化写入直接写 `values`）。
+	*/
+	var eachDynamicField = (fields, model, onField) => {
+		for (const field of fields) {
+			if (typeof field !== "object" || field?.name === void 0) continue;
+			let value = model?.[field.name] || "";
+			let isDefaultApplied = false;
+			if (!value && field.defaultValue !== void 0) {
+				value = field.defaultValue;
+				isDefaultApplied = true;
+			}
+			onField(field, value, isDefaultApplied);
+		}
+	};
+	/**
+	* 同步 `returnFields` 的 defaultValue 按 prop 写入值根对象。
+	*
+	* 该组件读取的是同级 model，但写入走 Container 的 modifyKey 分支，落在 `${prop}.${key}`，
+	* 这里保持与渲染一致（含这层不对称），避免两条链路产出不同的值。
+	* 异步 returnFields 由组件挂载后的 watch 负责，此处不等待。
+	*/
+	var effect$5 = ({ config, model, prop, values }) => {
+		const { returnFields, dynamicKey } = config;
+		if (typeof returnFields !== "function" || !model) return;
+		if (model[dynamicKey] === "") return;
+		const result = returnFields(config, model, getConfig("request"));
+		if (!result || typeof result.then === "function" || !Array.isArray(result)) return;
+		eachDynamicField(result, model, (field, value, isDefaultApplied) => {
+			if (isDefaultApplied) (0, _tmagic_utils.setValueByKeyPath)(`${prop}.${field.name}`, value, values || model);
+		});
+	};
+	//#endregion
+	//#region packages/form/src/fields/DynamicField/Index.vue?vue&type=script&setup=true&lang.ts
 	var _hoisted_1 = { class: "m-fields-dynamic-field" };
 	//#endregion
-	//#region packages/form/src/fields/DynamicField.vue
-	var DynamicField_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	//#region packages/form/src/fields/DynamicField/Index.vue
+	var Index_default$4 = /* @__PURE__ */ (0, vue.defineComponent)({
 		name: "MFormDynamicField",
-		__name: "DynamicField",
+		__name: "Index",
 		props: {
 			config: {},
 			model: {},
@@ -9248,15 +10283,10 @@
 				const fields = await props.config.returnFields(props.config, props.model, request);
 				fieldMap.value = {};
 				fieldLabelMap.value = {};
-				fields.forEach((v) => {
-					if (typeof v !== "object" || v.name === void 0) return;
-					let oldVal = props.model?.[v.name] || "";
-					if (!oldVal && v.defaultValue !== void 0) {
-						oldVal = v.defaultValue;
-						emit("change", oldVal, { modifyKey: v.name });
-					}
-					fieldMap.value[v.name] = oldVal;
-					fieldLabelMap.value[v.name] = v.label || "";
+				eachDynamicField(fields, props.model, (field, value, isDefaultApplied) => {
+					if (isDefaultApplied) emit("change", value, { modifyKey: field.name });
+					fieldMap.value[field.name] = value;
+					fieldLabelMap.value[field.name] = field.label || "";
 				});
 			};
 			const unwatch = (0, vue.watch)(() => props.model?.[props.config.dynamicKey], (val) => {
@@ -9295,146 +10325,245 @@
 		}
 	});
 	//#endregion
-	//#region packages/form/src/containers/Step.vue
-	var Step_default = /* @__PURE__ */ (0, vue.defineComponent)({
-		name: "MFormStep",
-		__name: "Step",
-		props: {
-			model: {},
-			name: {},
-			lastValues: {},
-			isCompare: { type: Boolean },
-			config: {},
-			stepActive: { default: 1 },
-			labelWidth: {},
-			size: {},
-			disabled: { type: Boolean }
-		},
-		emits: ["change", "addDiffCount"],
-		setup(__props, { emit: __emit }) {
-			const props = __props;
-			const emit = __emit;
-			const mForm = (0, vue.inject)("mForm");
-			const active = (0, vue.ref)(1);
-			(0, vue.watchEffect)(() => {
-				active.value = props.stepActive;
-			});
-			const stepClick = (index) => {
-				active.value = index + 1;
-				mForm?.$emit("update:stepActive", active.value);
-			};
-			const changeHandler = (v, eventData) => {
-				emit("change", props.model, eventData);
-			};
-			const onAddDiffCount = () => emit("addDiffCount");
-			return (_ctx, _cache) => {
-				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", null, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicSteps), {
-					active: active.value,
-					"align-center": "",
-					space: __props.config.space
-				}, {
-					default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.config.items, (item, index) => {
-						return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicStep), {
-							key: item.__key,
-							title: item.title,
-							active: active.value,
-							onClick: ($event) => stepClick(index)
-						}, null, 8, [
-							"title",
-							"active",
-							"onClick"
-						]);
-					}), 128))]),
-					_: 1
-				}, 8, ["active", "space"]), ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.config.items, (step, index) => {
-					return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(step.items, (item) => {
-						return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [item ? (0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createBlock)(Container_default, {
-							key: item[(0, vue.unref)(mForm)?.keyProp || "__key"],
-							config: item,
-							model: step.name ? __props.model[step.name] : __props.model,
-							lastValues: step.name ? __props.lastValues[step.name] : __props.lastValues,
-							"is-compare": __props.isCompare,
-							prop: `${step.name}`,
-							size: __props.size,
-							disabled: __props.disabled,
-							"label-width": __props.config.labelWidth || __props.labelWidth,
-							onChange: changeHandler,
-							onAddDiffCount: _cache[0] || (_cache[0] = ($event) => onAddDiffCount())
-						}, null, 8, [
-							"config",
-							"model",
-							"lastValues",
-							"is-compare",
-							"prop",
-							"size",
-							"disabled",
-							"label-width"
-						])), [[vue.vShow, active.value - 1 === index]]) : (0, vue.createCommentVNode)("v-if", true)], 64);
-					}), 256))], 64);
-				}), 256))]);
-			};
+	//#region packages/form/src/fields/CheckboxGroup/effect.ts
+	/** 空值初始化为空数组。 */
+	var effect$4 = ({ config, model }) => {
+		const { name } = config;
+		if (model && !model[name]) model[name] = [];
+	};
+	//#endregion
+	//#region packages/form/src/fields/Date/effect.ts
+	/** 按 `valueFormat` 归一化日期值。 */
+	var effect$3 = ({ config, model }) => {
+		if (!model) return;
+		const { name, valueFormat } = config;
+		model[name] = datetimeFormatter(model[name], "", valueFormat || "YYYY/MM/DD");
+	};
+	//#endregion
+	//#region packages/form/src/fields/DateTime/effect.ts
+	/** 按 `valueFormat` 归一化日期时间值，空值与非法值统一为空字符串。 */
+	var effect$2 = ({ config, model }) => {
+		if (!model) return;
+		const { name, valueFormat } = config;
+		const value = model[name]?.toString();
+		if (!value || value === "Invalid Date") {
+			model[name] = "";
+			return;
 		}
-	});
+		model[name] = datetimeFormatter(model[name], "", valueFormat || "YYYY/MM/DD HH:mm:ss");
+	};
+	//#endregion
+	//#region packages/form/src/fields/Display/effect.ts
+	/** 把 `initValue` 写入 model。 */
+	var effect$1 = ({ config, model }) => {
+		const { initValue, name } = config;
+		if (initValue && model) model[name] = initValue;
+	};
+	//#endregion
+	//#region packages/form/src/fields/NumberRange/effect.ts
+	/** 值不是数组时修正为空数组。 */
+	var effect = ({ config, model }) => {
+		const { name } = config;
+		if (model && !Array.isArray(model[name])) model[name] = [];
+	};
+	//#endregion
+	//#region packages/form/src/utils/builtInFields.ts
+	/**
+	* 内置字段的无渲染登记表（不含 Vue 组件）。
+	*
+	* 本模块只导出数据，不登记。调用方自行 `registerBuiltInFields(builtInFields)`，
+	* 或 `app.use(MagicForm)`（install 里会登记叠上 Vue 组件后的表）。
+	*/
+	var builtInFields = {
+		text: {},
+		"img-upload": {},
+		number: {},
+		"number-range": { effect },
+		textarea: {},
+		hidden: {},
+		date: { effect: effect$3 },
+		datetime: { effect: effect$2 },
+		daterange: {},
+		timerange: {},
+		time: {},
+		checkbox: {},
+		switch: {},
+		"color-picker": {},
+		"checkbox-group": { effect: effect$4 },
+		"radio-group": {},
+		display: { effect: effect$1 },
+		link: {},
+		select: {},
+		cascader: {},
+		"dynamic-field": { effect: effect$5 },
+		component: {},
+		tab: { walk: expandTab },
+		row: { walk: expandRow },
+		"flex-layout": { walk: expandRow },
+		fieldset: { walk: expandFieldset },
+		panel: { walk: expandPanel },
+		step: { walk: expandStep },
+		table: { walk: expandTableGroupList },
+		"group-list": { walk: expandTableGroupList },
+		"table-group-list": { walk: expandTableGroupList }
+	};
 	//#endregion
 	//#region packages/form/src/plugin.ts
+	var builtInFieldVue = {
+		text: { component: Text_default },
+		"img-upload": { component: Text_default },
+		number: { component: Number_default },
+		"number-range": { component: Index_default$5 },
+		textarea: { component: Textarea_default },
+		hidden: { component: Hidden_default },
+		date: { component: Index_default$1 },
+		datetime: { component: Index_default$2 },
+		daterange: { component: Daterange_default },
+		timerange: { component: Timerange_default },
+		time: { component: Time_default },
+		checkbox: { component: Checkbox_default },
+		switch: { component: Switch_default },
+		"color-picker": { component: ColorPicker_default },
+		"checkbox-group": { component: Index_default },
+		"radio-group": { component: RadioGroup_default },
+		display: { component: Index_default$3 },
+		link: { component: Link_default },
+		select: { component: Select_default },
+		cascader: { component: Cascader_default },
+		"dynamic-field": { component: Index_default$4 },
+		container: { container: Container_default },
+		tab: { container: Tabs_default },
+		row: { container: Row_default },
+		"flex-layout": { container: FlexLayout_default },
+		fieldset: { container: Fieldset_default },
+		panel: { container: Panel_default },
+		step: { container: /* @__PURE__ */ (0, vue.defineComponent)({
+			name: "MFormStep",
+			__name: "Step",
+			props: {
+				model: {},
+				name: {},
+				lastValues: {},
+				isCompare: { type: Boolean },
+				config: {},
+				stepActive: { default: 1 },
+				labelWidth: {},
+				labelPosition: {},
+				size: {},
+				disabled: { type: Boolean }
+			},
+			emits: ["change", "addDiffCount"],
+			setup(__props, { emit: __emit }) {
+				const props = __props;
+				const emit = __emit;
+				const mForm = (0, vue.inject)("mForm");
+				const active = (0, vue.ref)(1);
+				(0, vue.watchEffect)(() => {
+					active.value = props.stepActive;
+				});
+				const stepClick = (index) => {
+					active.value = index + 1;
+					mForm?.$emit("update:stepActive", active.value);
+				};
+				const changeHandler = (v, eventData) => {
+					emit("change", props.model, eventData);
+				};
+				const onAddDiffCount = () => emit("addDiffCount");
+				return (_ctx, _cache) => {
+					return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", null, [(0, vue.createVNode)((0, vue.unref)(_tmagic_design.TMagicSteps), {
+						active: active.value,
+						"align-center": "",
+						space: __props.config.space
+					}, {
+						default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.config.items, (item, index) => {
+							return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(_tmagic_design.TMagicStep), {
+								key: item.__key,
+								title: item.title,
+								active: active.value,
+								onClick: ($event) => stepClick(index)
+							}, null, 8, [
+								"title",
+								"active",
+								"onClick"
+							]);
+						}), 128))]),
+						_: 1
+					}, 8, ["active", "space"]), ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.config.items, (step, index) => {
+						return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(step.items, (item) => {
+							return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [item ? (0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createBlock)(Container_default, {
+								key: item[(0, vue.unref)(mForm)?.keyProp || "__key"],
+								config: item,
+								model: step.name ? __props.model[step.name] : __props.model,
+								lastValues: step.name ? __props.lastValues[step.name] : __props.lastValues,
+								"is-compare": __props.isCompare,
+								prop: `${step.name}`,
+								size: __props.size,
+								disabled: __props.disabled,
+								"label-width": __props.config.labelWidth || __props.labelWidth,
+								"label-position": __props.config.labelPosition || __props.labelPosition,
+								onChange: changeHandler,
+								onAddDiffCount: _cache[0] || (_cache[0] = ($event) => onAddDiffCount())
+							}, null, 8, [
+								"config",
+								"model",
+								"lastValues",
+								"is-compare",
+								"prop",
+								"size",
+								"disabled",
+								"label-width",
+								"label-position"
+							])), [[vue.vShow, active.value - 1 === index]]) : (0, vue.createCommentVNode)("v-if", true)], 64);
+						}), 256))], 64);
+					}), 256))]);
+				};
+			}
+		}) },
+		table: { container: TableGroupList_default },
+		"group-list": { container: TableGroupList_default },
+		"table-group-list": { container: TableGroupList_default }
+	};
 	var defaultInstallOpt = {};
-	var plugin_default = { install(app, opt = {}) {
-		const option = Object.assign(defaultInstallOpt, opt);
+	var plugin_default = { 
+	/**
+	* 安装 `@tmagic/form`：登记内置字段、挂载 `m-form` / `m-form-dialog` / `m-form-drawer`。
+	*
+	* @param app - Vue 应用
+	* @param [opt] - 安装选项
+	*/
+install(app, opt = {}) {
+		const option = {
+			...defaultInstallOpt,
+			...opt
+		};
 		app.config.globalProperties.$MAGIC_FORM = option;
 		setConfig(option);
-		if (option.typeMatchRules) registerTypeMatchRules(option.typeMatchRules);
+		registerBuiltInFields(builtInFields);
+		registerBuiltInFields(builtInFieldVue, app);
+		if (option.fields) registerFields(option.fields, app);
 		app.component("m-form", Form_default);
 		app.component("m-form-dialog", FormDialog_default);
 		app.component("m-form-drawer", FormDrawer_default);
-		app.component("m-form-container", Container_default);
-		app.component("m-form-fieldset", Fieldset_default);
-		app.component("m-form-group-list", TableGroupList_default);
-		app.component("m-form-panel", Panel_default);
-		app.component("m-form-row", Row_default);
-		app.component("m-form-step", Step_default);
-		app.component("m-form-table", TableGroupList_default);
-		app.component("m-form-tab", Tabs_default);
-		app.component("m-form-flex-layout", FlexLayout_default);
-		app.component("m-fields-text", Text_default);
-		app.component("m-fields-img-upload", Text_default);
-		app.component("m-fields-number", Number_default);
-		app.component("m-fields-number-range", NumberRange_default);
-		app.component("m-fields-textarea", Textarea_default);
-		app.component("m-fields-hidden", Hidden_default);
-		app.component("m-fields-date", Date_default);
-		app.component("m-fields-datetime", DateTime_default);
-		app.component("m-fields-daterange", Daterange_default);
-		app.component("m-fields-timerange", Timerange_default);
-		app.component("m-fields-time", Time_default);
-		app.component("m-fields-checkbox", Checkbox_default);
-		app.component("m-fields-switch", Switch_default);
-		app.component("m-fields-color-picker", ColorPicker_default);
-		app.component("m-fields-checkbox-group", CheckboxGroup_default);
-		app.component("m-fields-radio-group", RadioGroup_default);
-		app.component("m-fields-display", Display_default);
-		app.component("m-fields-link", Link_default);
-		app.component("m-fields-select", Select_default);
-		app.component("m-fields-cascader", Cascader_default);
-		app.component("m-fields-dynamic-field", DynamicField_default);
 	} };
 	//#endregion
 	//#region packages/form/src/index.ts
 	var createForm = (config) => config;
 	//#endregion
+	exports.FORM_CONTEXT_KEY = FORM_CONTEXT_KEY;
 	exports.FORM_DIFF_CONFIG_KEY = FORM_DIFF_CONFIG_KEY;
-	exports.FORM_SILENT_MODE_KEY = FORM_SILENT_MODE_KEY;
 	exports.FORM_TYPE_MATCH_VALID_KEY = FORM_TYPE_MATCH_VALID_KEY;
+	exports.FieldInnerConfigError = FieldInnerConfigError;
 	exports.MAX_SUGGESTION_OPTIONS = MAX_SUGGESTION_OPTIONS;
 	exports.MCascader = Cascader_default;
 	exports.MCheckbox = Checkbox_default;
-	exports.MCheckboxGroup = CheckboxGroup_default;
+	exports.MCheckboxGroup = Index_default;
 	exports.MColorPicker = ColorPicker_default;
 	exports.MContainer = Container_default;
-	exports.MDate = Date_default;
-	exports.MDateTime = DateTime_default;
+	exports.MDate = Index_default$1;
+	exports.MDateTime = Index_default$2;
 	exports.MDaterange = Daterange_default;
-	exports.MDisplay = Display_default;
-	exports.MDynamicField = DynamicField_default;
+	exports.MDisplay = Index_default$3;
+	exports.MDynamicField = Index_default$4;
 	exports.MFieldset = Fieldset_default;
 	exports.MFlexLayout = FlexLayout_default;
 	exports.MForm = Form_default;
@@ -9445,7 +10574,7 @@
 	exports.MHidden = Hidden_default;
 	exports.MLink = Link_default;
 	exports.MNumber = Number_default;
-	exports.MNumberRange = NumberRange_default;
+	exports.MNumberRange = Index_default$5;
 	exports.MPanel = Panel_default;
 	exports.MRadioGroup = RadioGroup_default;
 	exports.MRow = Row_default;
@@ -9459,37 +10588,52 @@
 	exports.MTime = Time_default;
 	exports.MTimerange = Timerange_default;
 	exports.adaptFormValidator = adaptFormValidator;
-	exports.applyExtendState = applyExtendState;
-	exports.clearSilentLeafFieldTypes = clearSilentLeafFieldTypes;
+	exports.appendProp = appendProp;
+	exports.applyMountValueEffects = applyMountValueEffects;
+	exports.builtInFields = builtInFields;
+	exports.clearFields = clearFields;
 	exports.clearTypeMatchRules = clearTypeMatchRules;
+	exports.collectValidatableFields = collectValidatableFields;
 	exports.createForm = createForm;
+	exports.createFormStateBase = createFormStateBase;
+	exports.createFormStateProxy = createFormStateProxy;
+	exports.createHeadlessFormState = createHeadlessFormState;
 	exports.createObjectProp = createObjectProp;
 	exports.createValues = createValues;
 	exports.datetimeFormatter = datetimeFormatter;
 	exports.default = plugin_default;
-	exports.deleteFormField = deleteField;
 	exports.deleteTypeMatchRule = deleteTypeMatchRule;
 	exports.display = display;
 	exports.filterFunction = filterFunction;
+	exports.formatValidateError = formatValidateError;
 	exports.getDataByPage = getDataByPage;
 	exports.getFormField = getField;
+	exports.getItemProp = getItemProp;
+	exports.getNativeRules = getNativeRules;
 	exports.getRules = getRules;
-	exports.getSilentLeafFieldTypes = getSilentLeafFieldTypes;
+	exports.getTextByName = getTextByName;
 	exports.getTypeMatchRule = getTypeMatchRule;
 	exports.initValue = initValue;
+	exports.isFieldInnerConfigError = isFieldInnerConfigError;
+	exports.isLeafFieldType = isLeafFieldType;
+	exports.isValidName = isValidName;
+	exports.mergeFieldOptions = mergeFieldOptions;
+	exports.mergeFormContexts = mergeFormContexts;
 	exports.optionSuggestion = optionSuggestion;
-	exports.registerFormField = registerField;
-	exports.registerSilentLeafFieldTypes = registerSilentLeafFieldTypes;
-	exports.registerTypeMatchRule = registerTypeMatchRule;
-	exports.registerTypeMatchRules = registerTypeMatchRules;
+	exports.registerBuiltInFields = registerBuiltInFields;
+	exports.registerField = registerField;
+	exports.registerFields = registerFields;
+	exports.resolveItemType = resolveItemType;
 	exports.sortArray = sortArray;
 	exports.sortChange = sortChange;
 	exports.stringifyExampleValue = stringifyExampleValue;
 	exports.stripTabItemsLazy = stripTabItemsLazy;
 	exports.submitForm = submitForm;
+	exports.unregisterField = unregisterField;
 	exports.useAddField = useAddField;
 	exports.validateForm = validateForm;
 	exports.validateTypeMatch = validateTypeMatch;
+	exports.validateValues = validateValues;
 	var _tmagic_form_schema = require("@tmagic/form-schema");
 	Object.keys(_tmagic_form_schema).forEach(function(k) {
 		if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {