@schemx/vue 0.1.21 → 0.1.22

package/dist/index.mjs

@@ -1,10 +1,114 @@
 import "./style.css";
-import { computed, provide, onUnmounted, inject, shallowRef, ref, onMounted, watchEffect, onScopeDispose, defineComponent, createVNode, toRef, h as h$1, createTextVNode, watch, openBlock, createElementBlock, normalizeClass, Fragment, renderList, unref, createBlock, createSlots, withCtx, renderSlot, mergeProps } from "vue";
-import classnames from "classnames";
-import { omit } from "es-toolkit";
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { computed, provide, onUnmounted, inject, shallowRef, ref, onMounted, watchEffect, onScopeDispose, defineComponent, createVNode, toRef, h as h$1, createTextVNode, watch, openBlock, createElementBlock, normalizeClass, Fragment, renderList, unref, createBlock, createSlots, withCtx, renderSlot, mergeProps } from "vue";
+function _mergeNamespaces(n2, m2) {
+  for (var i2 = 0; i2 < m2.length; i2++) {
+    const e2 = m2[i2];
+    if (typeof e2 !== "string" && !Array.isArray(e2)) {
+      for (const k in e2) {
+        if (k !== "default" && !(k in n2)) {
+          const d2 = Object.getOwnPropertyDescriptor(e2, k);
+          if (d2) {
+            Object.defineProperty(n2, k, d2.get ? d2 : {
+              enumerable: true,
+              get: () => e2[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" }));
+}
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+}
+function getAugmentedNamespace(n2) {
+  if (n2.__esModule) return n2;
+  var f = n2.default;
+  if (typeof f == "function") {
+    var a2 = function a3() {
+      if (this instanceof a3) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a2.prototype = f.prototype;
+  } else a2 = {};
+  Object.defineProperty(a2, "__esModule", { value: true });
+  Object.keys(n2).forEach(function(k) {
+    var d2 = Object.getOwnPropertyDescriptor(n2, k);
+    Object.defineProperty(a2, k, d2.get ? d2 : {
+      enumerable: true,
+      get: function() {
+        return n2[k];
+      }
+    });
+  });
+  return a2;
+}
+var classnames$1 = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+(function(module) {
+  (function() {
+    var hasOwn = {}.hasOwnProperty;
+    function classNames() {
+      var classes = "";
+      for (var i2 = 0; i2 < arguments.length; i2++) {
+        var arg = arguments[i2];
+        if (arg) {
+          classes = appendClass(classes, parseValue(arg));
+        }
+      }
+      return classes;
+    }
+    function parseValue(arg) {
+      if (typeof arg === "string" || typeof arg === "number") {
+        return arg;
+      }
+      if (typeof arg !== "object") {
+        return "";
+      }
+      if (Array.isArray(arg)) {
+        return classNames.apply(null, arg);
+      }
+      if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+        return arg.toString();
+      }
+      var classes = "";
+      for (var key in arg) {
+        if (hasOwn.call(arg, key) && arg[key]) {
+          classes = appendClass(classes, key);
+        }
+      }
+      return classes;
+    }
+    function appendClass(value, newClass) {
+      if (!newClass) {
+        return value;
+      }
+      if (value) {
+        return value + " " + newClass;
+      }
+      return value + newClass;
+    }
+    if (module.exports) {
+      classNames.default = classNames;
+      module.exports = classNames;
+    } else {
+      window.classNames = classNames;
+    }
+  })();
+})(classnames$1);
+var classnamesExports = classnames$1.exports;
+const classnames = /* @__PURE__ */ getDefaultExportFromCjs(classnamesExports);
 var i = Symbol.for("preact-signals");
 function t() {
   if (!(s > 1)) {
@@ -136,13 +240,10 @@ l.prototype.U = function(i2) {
 l.prototype.subscribe = function(i2) {
   var t2 = this;
   return j(function() {
-    var n2 = t2.value, o2 = r;
-    r = void 0;
-    try {
-      i2(n2);
-    } finally {
-      r = o2;
-    }
+    var n2 = t2.value;
+    o(function() {
+      return i2(n2);
+    });
   }, { name: "sub" });
 };
 l.prototype.valueOf = function() {
@@ -221,14 +322,11 @@ function b(i2) {
   i2.s = n2;
 }
 function p(i2, t2) {
-  l.call(this, void 0);
+  l.call(this, void 0, t2);
   this.x = i2;
   this.s = void 0;
   this.g = d - 1;
   this.f = 4;
-  this.W = null == t2 ? void 0 : t2.watched;
-  this.Z = null == t2 ? void 0 : t2.unwatched;
-  this.name = null == t2 ? void 0 : t2.name;
 }
 p.prototype = new l();
 p.prototype.h = function() {
@@ -293,6 +391,9 @@ Object.defineProperty(p.prototype, "value", { get: function() {
   if (16 & this.f) throw this.v;
   return this.v;
 } });
+function g(i2, t2) {
+  return new p(i2, t2);
+}
 function S(i2) {
   var n2 = i2.m;
   i2.m = void 0;
@@ -631,6 +732,14 @@ function isPlainObject(value) {
 function isUnsafeProperty(key) {
   return key === "__proto__";
 }
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (let i2 = 0; i2 < keys.length; i2++) {
+    const key = keys[i2];
+    delete result[key];
+  }
+  return result;
+}
 function pick(obj, keys) {
   const result = {};
   for (let i2 = 0; i2 < keys.length; i2++) {
@@ -954,33 +1063,59 @@ function defaultNormalizeFieldKey(key) {
   }
   return String(key);
 }
-function createSignalEffect(fn) {
-  return j(fn);
+function createSignalEffect(fn, options = {}) {
+  if (!options.once) {
+    return j(fn);
+  }
+  const disposeRef = {};
+  disposeRef.current = j(() => {
+    var _a;
+    fn();
+    (_a = disposeRef.current) == null ? void 0 : _a.call(disposeRef);
+  });
+  return () => {
+    var _a;
+    return (_a = disposeRef.current) == null ? void 0 : _a.call(disposeRef);
+  };
 }
 function createDebouncedSignalEffect(collect, run, wait = 16, options = {}) {
-  const debouncedRun = debounce(run, wait, { edges: options.edges });
   let initialized = false;
+  const wrappedRun = (value) => {
+    run(value);
+    if (options.once) {
+      teardown();
+    }
+  };
+  const debouncedRun = debounce(wrappedRun, wait, { edges: options.edges });
   const disposeEffect = createSignalEffect(() => {
     const value = collect();
     if (!initialized && options.immediate) {
       initialized = true;
-      run(value);
+      wrappedRun(value);
       return;
     }
     initialized = true;
     debouncedRun(value);
   });
-  return () => {
+  const teardown = () => {
     disposeEffect();
     debouncedRun.cancel();
   };
+  return teardown;
 }
 function batchUpdates(fn) {
   n(fn);
 }
 class SignalMapImpl {
   constructor() {
+    /** 每个 key 独占一个 signal，保证字段级更新能细粒度触发 */
     __publicField(this, "signals", /* @__PURE__ */ new Map());
+    /**
+     * 结构版本 signal，用于追踪“新 key 创建”事件。
+     *
+     * effect 读取缺失 key 时会依赖这个版本；之后创建该 key 会推进版本，
+     * 让 effect 重新执行并订阅新 key 对应的 signal。
+     */
     __publicField(this, "version", createSignal(0));
   }
   /**
@@ -1095,6 +1230,9 @@ class SignalMapImpl {
 function createSignalMap() {
   return new SignalMapImpl();
 }
+function createComputed(compute, options) {
+  return g(compute, options);
+}
 function isBaseSchema(schema) {
   return !isGroupSchema(schema) && !isDependencySchema(schema);
 }
@@ -1131,7 +1269,8 @@ function getGroupFieldMissing(schema) {
 function getDependencyFieldMissing(schema) {
   const missing = [];
   if (!isLegalComponentType(schema)) missing.push("componentType");
-  if (!Object.hasOwn(schema, "to") || !Array.isArray(schema.to)) missing.push("to");
+  if (!Object.hasOwn(schema, "to") || !Array.isArray(schema.to) || schema.to.length === 0)
+    missing.push("to");
   if (typeof schema.renderer !== "function") missing.push("renderer");
   return missing;
 }
@@ -1142,6 +1281,7 @@ function buildWarnMessage(index, schema, missing) {
 function normalizeSchemas(schemas) {
   const result = [];
   const missings = [];
+  let changed = false;
   for (let i2 = 0; i2 < schemas.length; i2++) {
     const schema = schemas[i2];
     let missing = [];
@@ -1149,16 +1289,21 @@ function normalizeSchemas(schemas) {
       missing = getGroupFieldMissing(schema);
       if (missing.length > 0) {
         missings.push(buildWarnMessage(i2, schema, missing));
+        changed = true;
         continue;
       }
-      result.push({
-        ...schema,
-        children: normalizeSchemas(schema.children)
-      });
+      const normalizedChildren = normalizeSchemas(schema.children);
+      if (normalizedChildren === schema.children) {
+        result.push(schema);
+      } else {
+        result.push({ ...schema, children: normalizedChildren });
+        changed = true;
+      }
     } else if (isDependencySchema(schema)) {
       missing = getDependencyFieldMissing(schema);
       if (missing.length > 0) {
         missings.push(buildWarnMessage(i2, schema, missing));
+        changed = true;
         continue;
       }
       result.push(schema);
@@ -1166,13 +1311,16 @@ function normalizeSchemas(schemas) {
       missing = getBaseFieldMissing(schema);
       if (missing.length > 0) {
         missings.push(buildWarnMessage(i2, schema, missing));
+        changed = true;
         continue;
       }
       result.push(schema);
+    } else {
+      changed = true;
     }
   }
   if (missings.length) console.warn(missings.join("\n"));
-  return result;
+  return changed ? result : schemas;
 }
 function toString(value) {
   if (value == null) return "";
@@ -1456,7 +1604,9 @@ const defaultConfig = {
 const defaultConfigKey = Object.keys(defaultConfig);
 class ValidatorImpl {
   constructor() {
+    /** 校验规则映射表：字段路径 → 规则条目 */
     __publicField(this, "rules", /* @__PURE__ */ new Map());
+    /** 校验错误映射表：字段路径 → 错误信息数组（响应式） */
     __publicField(this, "errors", createSignalMap());
   }
   /**
@@ -1746,7 +1896,9 @@ class RendererRegistry {
    * @param defaultType - 默认渲染器类型，未找到指定类型时回退使用
    */
   constructor(defaultType) {
+    /** 渲染器存储 */
     __publicField(this, "renderers");
+    /** 默认渲染器类型 */
     __publicField(this, "defaultType");
     this.renderers = /* @__PURE__ */ new Map();
     this.defaultType = defaultType;
@@ -1949,6 +2101,7 @@ class ValidatorsRegistry {
    * 创建空的规则注册中心。
    */
   constructor() {
+    /** Validators 存储 */
     __publicField(this, "validators");
     this.validators = /* @__PURE__ */ new Map();
   }
@@ -2134,277 +2287,1427 @@ class ValidatorsRegistry {
 function createValidatorsRegistry() {
   return new ValidatorsRegistry();
 }
-function createSchemas(schemas = []) {
-  const source = createSignal(schemas);
-  const getValue = () => {
-    return source.value;
-  };
-  const peek = () => {
-    return source.peek();
+var build = {};
+var extendStatics = function(d2, b2) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d3, b3) {
+    d3.__proto__ = b3;
+  } || function(d3, b3) {
+    for (var p2 in b3) if (Object.prototype.hasOwnProperty.call(b3, p2)) d3[p2] = b3[p2];
   };
-  const set2 = (nextSchemas) => {
-    source.value = nextSchemas;
+  return extendStatics(d2, b2);
+};
+function __extends(d2, b2) {
+  if (typeof b2 !== "function" && b2 !== null)
+    throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
+  extendStatics(d2, b2);
+  function __() {
+    this.constructor = d2;
+  }
+  d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t2) {
+    for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
+      s2 = arguments[i2];
+      for (var p2 in s2) if (Object.prototype.hasOwnProperty.call(s2, p2)) t2[p2] = s2[p2];
+    }
+    return t2;
   };
-  const update = (updater) => {
-    source.value = updater(source.peek());
+  return __assign.apply(this, arguments);
+};
+function __rest(s2, e2) {
+  var t2 = {};
+  for (var p2 in s2) if (Object.prototype.hasOwnProperty.call(s2, p2) && e2.indexOf(p2) < 0)
+    t2[p2] = s2[p2];
+  if (s2 != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i2 = 0, p2 = Object.getOwnPropertySymbols(s2); i2 < p2.length; i2++) {
+      if (e2.indexOf(p2[i2]) < 0 && Object.prototype.propertyIsEnumerable.call(s2, p2[i2]))
+        t2[p2[i2]] = s2[p2[i2]];
+    }
+  return t2;
+}
+function __decorate(decorators, target, key, desc) {
+  var c2 = arguments.length, r2 = c2 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c2 < 3 ? d2(r2) : c2 > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c2 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+function __param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
   };
-  const subscribe = (listener) => {
-    let isInitialNotify = true;
-    const unsubscribe = source.subscribe((value) => {
-      if (isInitialNotify) {
-        isInitialNotify = false;
-        return;
-      }
-      listener(value);
+}
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _2, done = false;
+  for (var i2 = decorators.length - 1; i2 >= 0; i2--) {
+    var context = {};
+    for (var p2 in contextIn) context[p2] = p2 === "access" ? {} : contextIn[p2];
+    for (var p2 in contextIn.access) context.access[p2] = contextIn.access[p2];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i2])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_2 = accept(result.get)) descriptor.get = _2;
+      if (_2 = accept(result.set)) descriptor.set = _2;
+      if (_2 = accept(result.init)) initializers.unshift(_2);
+    } else if (_2 = accept(result)) {
+      if (kind === "field") initializers.unshift(_2);
+      else descriptor[key] = _2;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i2 = 0; i2 < initializers.length; i2++) {
+    value = useValue ? initializers[i2].call(thisArg, value) : initializers[i2].call(thisArg);
+  }
+  return useValue ? value : void 0;
+}
+function __propKey(x2) {
+  return typeof x2 === "symbol" ? x2 : "".concat(x2);
+}
+function __setFunctionName(f, name, prefix) {
+  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+}
+function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
     });
-    return () => {
-      unsubscribe();
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _2 = { label: 0, sent: function() {
+    if (t2[0] & 1) throw t2[1];
+    return t2[1];
+  }, trys: [], ops: [] }, f, y2, t2, g2 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g2.next = verb(0), g2["throw"] = verb(1), g2["return"] = verb(2), typeof Symbol === "function" && (g2[Symbol.iterator] = function() {
+    return this;
+  }), g2;
+  function verb(n2) {
+    return function(v2) {
+      return step([n2, v2]);
     };
-  };
-  return {
-    signal: source,
-    get value() {
-      return getValue();
-    },
-    peek,
-    set: set2,
-    update,
-    subscribe
-  };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g2 && (g2 = 0, op[0] && (_2 = 0)), _2) try {
+      if (f = 1, y2 && (t2 = op[0] & 2 ? y2["return"] : op[0] ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0) : y2.next) && !(t2 = t2.call(y2, op[1])).done) return t2;
+      if (y2 = 0, t2) op = [op[0] & 2, t2.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t2 = op;
+          break;
+        case 4:
+          _2.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _2.label++;
+          y2 = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _2.ops.pop();
+          _2.trys.pop();
+          continue;
+        default:
+          if (!(t2 = _2.trys, t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _2 = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
+            _2.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _2.label < t2[1]) {
+            _2.label = t2[1];
+            t2 = op;
+            break;
+          }
+          if (t2 && _2.label < t2[2]) {
+            _2.label = t2[2];
+            _2.ops.push(op);
+            break;
+          }
+          if (t2[2]) _2.ops.pop();
+          _2.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _2);
+    } catch (e2) {
+      op = [6, e2];
+      y2 = 0;
+    } finally {
+      f = t2 = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
 }
-function isSchemxSchemas(schemas) {
-  if (!schemas || Array.isArray(schemas)) {
-    return false;
+var __createBinding = Object.create ? function(o2, m2, k, k2) {
+  if (k2 === void 0) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m2, k);
+  if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+    desc = { enumerable: true, get: function() {
+      return m2[k];
+    } };
   }
-  const candidate = schemas;
-  return typeof candidate.peek === "function" && typeof candidate.set === "function" && typeof candidate.update === "function" && typeof candidate.subscribe === "function";
+  Object.defineProperty(o2, k2, desc);
+} : function(o2, m2, k, k2) {
+  if (k2 === void 0) k2 = k;
+  o2[k2] = m2[k];
+};
+function __exportStar(m2, o2) {
+  for (var p2 in m2) if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(o2, p2)) __createBinding(o2, m2, p2);
 }
-class CompileErrorImpl extends Error {
-  constructor(message, schema) {
-    super(message);
-    __publicField(this, "schemaKey");
-    __publicField(this, "schemaName");
-    this.name = "CompileError";
-    if (schema && "name" in schema) {
-      this.schemaName = schema.name;
+function __values(o2) {
+  var s2 = typeof Symbol === "function" && Symbol.iterator, m2 = s2 && o2[s2], i2 = 0;
+  if (m2) return m2.call(o2);
+  if (o2 && typeof o2.length === "number") return {
+    next: function() {
+      if (o2 && i2 >= o2.length) o2 = void 0;
+      return { value: o2 && o2[i2++], done: !o2 };
     }
-    if (schema && "key" in schema && schema.key) {
-      this.schemaKey = schema.key;
+  };
+  throw new TypeError(s2 ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o2, n2) {
+  var m2 = typeof Symbol === "function" && o2[Symbol.iterator];
+  if (!m2) return o2;
+  var i2 = m2.call(o2), r2, ar = [], e2;
+  try {
+    while ((n2 === void 0 || n2-- > 0) && !(r2 = i2.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e2 = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m2 = i2["return"])) m2.call(i2);
+    } finally {
+      if (e2) throw e2.error;
     }
   }
+  return ar;
 }
-const CompileError = CompileErrorImpl;
-function compileToDescriptors(schemas, options = {}, parentKey = "") {
-  const descriptors = [];
-  const normalized = normalizeSchemas(schemas);
-  for (let i2 = 0; i2 < normalized.length; i2++) {
-    const schema = normalized[i2];
-    let descriptor = void 0;
-    if (isGroupSchema(schema)) {
-      descriptor = compileGroup(schema, i2, options, parentKey);
-    } else if (isDependencySchema(schema)) {
-      descriptor = compileDependencySlot(schema, i2, parentKey);
-    } else {
-      descriptor = compileField(schema, i2, options, parentKey);
+function __spread() {
+  for (var ar = [], i2 = 0; i2 < arguments.length; i2++)
+    ar = ar.concat(__read(arguments[i2]));
+  return ar;
+}
+function __spreadArrays() {
+  for (var s2 = 0, i2 = 0, il = arguments.length; i2 < il; i2++) s2 += arguments[i2].length;
+  for (var r2 = Array(s2), k = 0, i2 = 0; i2 < il; i2++)
+    for (var a2 = arguments[i2], j2 = 0, jl = a2.length; j2 < jl; j2++, k++)
+      r2[k] = a2[j2];
+  return r2;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i2 = 0, l2 = from.length, ar; i2 < l2; i2++) {
+    if (ar || !(i2 in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i2);
+      ar[i2] = from[i2];
     }
-    descriptors.push(descriptor);
   }
-  return descriptors;
+  return to.concat(ar || Array.prototype.slice.call(from));
 }
-function compileField(schema, index, options = {}, parentKey = "") {
-  const key = schema.key ?? (parentKey ? `field:${parentKey}/${schema.name}` : `field:${schema.name}`);
-  const normalizedSchema = buildNormalizedFieldSchema(schema, options);
-  return {
-    type: "field",
-    key,
-    name: schema.name,
-    rendererType: schema.componentType,
-    schema: normalizedSchema,
-    dependencies: schema.dependencies
-  };
+function __await(v2) {
+  return this instanceof __await ? (this.v = v2, this) : new __await(v2);
 }
-function compileGroup(schema, index, options = {}, parentKey = "") {
-  const key = schema.key ?? (parentKey ? `group:${parentKey}/${index}` : `group:${index}`);
-  const { children: rawChildren, ...schemaWithoutChildren } = schema;
-  const children = compileToDescriptors(rawChildren, options, key);
-  return {
-    type: "group",
-    key,
-    schema: {
-      ...schemaWithoutChildren,
-      key
-    },
-    children
-  };
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g2 = generator.apply(thisArg, _arguments || []), i2, q = [];
+  return i2 = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i2[Symbol.asyncIterator] = function() {
+    return this;
+  }, i2;
+  function awaitReturn(f) {
+    return function(v2) {
+      return Promise.resolve(v2).then(f, reject);
+    };
+  }
+  function verb(n2, f) {
+    if (g2[n2]) {
+      i2[n2] = function(v2) {
+        return new Promise(function(a2, b2) {
+          q.push([n2, v2, a2, b2]) > 1 || resume(n2, v2);
+        });
+      };
+      if (f) i2[n2] = f(i2[n2]);
+    }
+  }
+  function resume(n2, v2) {
+    try {
+      step(g2[n2](v2));
+    } catch (e2) {
+      settle(q[0][3], e2);
+    }
+  }
+  function step(r2) {
+    r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q[0][2], r2);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v2) {
+    if (f(v2), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
 }
-function compileDependencySlot(schema, index, parentKey = "") {
-  const key = schema.key ?? (parentKey ? `dependency:${parentKey}/${index}` : `dependency:${index}`);
-  if (!schema.to || schema.to.length === 0) {
-    throw new CompileError("Dependency schema must have non-empty trigger fields", schema);
+function __asyncDelegator(o2) {
+  var i2, p2;
+  return i2 = {}, verb("next"), verb("throw", function(e2) {
+    throw e2;
+  }), verb("return"), i2[Symbol.iterator] = function() {
+    return this;
+  }, i2;
+  function verb(n2, f) {
+    i2[n2] = o2[n2] ? function(v2) {
+      return (p2 = !p2) ? { value: __await(o2[n2](v2)), done: false } : f ? f(v2) : v2;
+    } : f;
   }
-  const trigger = [...schema.to];
-  const renderer = (formApi, abortSignal) => {
-    const values = formApi.getValues();
-    return schema.renderer(values, formApi, {
-      abortSignal
-    });
-  };
-  return {
-    type: "dependency",
-    key,
-    trigger,
-    renderer
-  };
 }
-function buildNormalizedFieldSchema(schema, options = {}) {
-  const {
-    componentProps: cp,
-    visible,
-    readonly,
-    disabled,
-    required,
-    placeholder,
-    rules,
-    validationTrigger,
-    dependencies: _dependencies,
-    ...rest
-  } = schema;
-  const mergedVisible = visible ?? defaultConfig.visible;
-  const mergedReadonly = readonly ?? options.readonly ?? defaultConfig.readonly;
-  const mergedDisabled = disabled ?? options.disabled ?? defaultConfig.disabled;
-  const mergedAlign = mergedReadonly ? "right" : (cp == null ? void 0 : cp.align) ?? rest.contentAlign;
-  const mergedPlaceholder = getPlaceholder(schema);
-  const componentProps = {
-    ...cp,
-    readonly: mergedReadonly,
-    disabled: mergedDisabled,
-    placeholder: mergedPlaceholder,
-    align: mergedAlign
-  };
-  const rulesArray = (Array.isArray(rules) ? rules : [rules]).filter(Boolean);
-  const mergedRequired = required ?? (rulesArray.length > 0 || defaultConfig.required);
-  const normalizedSchema = {
-    ...rest ?? {},
-    key: rest.key,
-    name: rest.name,
-    label: rest.label,
-    componentType: rest.componentType,
-    visible: mergedVisible,
-    readonly: mergedReadonly,
-    disabled: mergedDisabled,
-    required: mergedRequired,
-    placeholder: mergedPlaceholder,
-    componentProps,
-    labelIcon: rest.labelIcon || defaultConfig.labelIcon,
-    labelAlign: rest.labelAlign || defaultConfig.labelAlign,
-    labelPosition: rest.labelPosition || defaultConfig.labelPosition,
-    labelWidth: rest.labelWidth || defaultConfig.labelWidth,
-    colon: rest.colon ?? defaultConfig.colon,
-    rules,
-    validationTrigger: validationTrigger || defaultConfig.validationTrigger
-  };
-  if (Object.hasOwn(schema, "initialValue")) {
-    normalizedSchema.initialValue = rest.initialValue;
+function __asyncValues(o2) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m2 = o2[Symbol.asyncIterator], i2;
+  return m2 ? m2.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
+    return this;
+  }, i2);
+  function verb(n2) {
+    i2[n2] = o2[n2] && function(v2) {
+      return new Promise(function(resolve, reject) {
+        v2 = o2[n2](v2), settle(resolve, reject, v2.done, v2.value);
+      });
+    };
   }
-  if (mergedReadonly) {
-    normalizedSchema.contentAlign = "right";
-    normalizedSchema.labelPosition = "left";
+  function settle(resolve, reject, d2, v2) {
+    Promise.resolve(v2).then(function(v3) {
+      resolve({ value: v3, done: d2 });
+    }, reject);
   }
-  return normalizedSchema;
 }
-function getPlaceholder(schema) {
-  var _a;
-  const existingplaceholder = ((_a = schema.componentProps) == null ? void 0 : _a.placeholder) ?? schema.placeholder;
-  if (existingplaceholder == null) {
-    return ["input", "text", "textarea"].includes(schema.componentType) ? `请输入${schema.label || schema.name}` : `请选择${schema.label || schema.name}`;
+function __makeTemplateObject(cooked, raw) {
+  if (Object.defineProperty) {
+    Object.defineProperty(cooked, "raw", { value: raw });
+  } else {
+    cooked.raw = raw;
   }
-  return existingplaceholder;
+  return cooked;
 }
-const isFieldDescriptor = (descriptor) => {
-  return descriptor.type === "field";
+var __setModuleDefault = Object.create ? function(o2, v2) {
+  Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
+} : function(o2, v2) {
+  o2["default"] = v2;
 };
-const isGroupDescriptor = (descriptor) => {
-  return descriptor.type === "group";
-};
-const isDependencyDescriptor = (descriptor) => {
-  return descriptor.type === "dependency";
-};
-function createFieldModel(descriptor) {
-  return {
-    snapshot: createSignal(createFieldModelSnapshot(descriptor))
+var ownKeys = function(o2) {
+  ownKeys = Object.getOwnPropertyNames || function(o3) {
+    var ar = [];
+    for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
+    return ar;
   };
-}
-function updateFieldModel(model, descriptor, resolved) {
-  const nextSnapshot = createFieldModelSnapshot(descriptor, resolved);
-  if (isSameFieldModelSnapshot(model.snapshot.peek(), nextSnapshot)) {
-    return;
+  return ownKeys(o2);
+};
+function __importStar(mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) {
+    for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
   }
-  model.snapshot.value = nextSnapshot;
-}
-function createFieldModelSnapshot(descriptor, resolved) {
-  const schema = descriptor.schema;
-  return {
-    visible: (resolved == null ? void 0 : resolved.visible) ?? schema.visible ?? defaultConfig.visible,
-    disabled: (resolved == null ? void 0 : resolved.disabled) ?? schema.disabled ?? defaultConfig.disabled,
-    readonly: (resolved == null ? void 0 : resolved.readonly) ?? schema.readonly ?? defaultConfig.readonly,
-    required: (resolved == null ? void 0 : resolved.required) ?? schema.required ?? defaultConfig.required,
-    label: schema.label || "",
-    rules: ((resolved == null ? void 0 : resolved.rules) ?? schema.rules) || [],
-    placeholder: (resolved == null ? void 0 : resolved.placeholder) ?? schema.placeholder ?? getPlaceholder(schema),
-    componentProps: ((resolved == null ? void 0 : resolved.componentProps) ?? schema.componentProps) || {}
-  };
-}
-function isSameFieldModelSnapshot(current, next) {
-  return current.visible === next.visible && current.disabled === next.disabled && current.readonly === next.readonly && current.required === next.required && current.label === next.label && isSameArrayOrValue(current.rules, next.rules) && current.placeholder === next.placeholder && isShallowEqualRecord(current.componentProps, next.componentProps);
+  __setModuleDefault(result, mod);
+  return result;
 }
-function isSameArrayOrValue(current, next) {
-  if (current === next) {
-    return true;
-  }
-  if (!Array.isArray(current) || !Array.isArray(next)) {
-    return false;
+function __importDefault(mod) {
+  return mod && mod.__esModule ? mod : { default: mod };
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+function __classPrivateFieldIn(state, receiver) {
+  if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
+  return typeof state === "function" ? receiver === state : state.has(receiver);
+}
+function __addDisposableResource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e2) {
+        return Promise.reject(e2);
+      }
+    };
+    env.stack.push({ value, dispose, async });
+  } else if (async) {
+    env.stack.push({ async: true });
   }
-  return current.length === next.length && current.every((value, index) => value === next[index]);
+  return value;
 }
-function isShallowEqualRecord(current, next) {
-  if (current === next) {
-    return true;
+var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e2 = new Error(message);
+  return e2.name = "SuppressedError", e2.error = error, e2.suppressed = suppressed, e2;
+};
+function __disposeResources(env) {
+  function fail(e2) {
+    env.error = env.hasError ? new _SuppressedError(e2, env.error, "An error was suppressed during disposal.") : e2;
+    env.hasError = true;
+  }
+  var r2, s2 = 0;
+  function next() {
+    while (r2 = env.stack.pop()) {
+      try {
+        if (!r2.async && s2 === 1) return s2 = 0, env.stack.push(r2), Promise.resolve().then(next);
+        if (r2.dispose) {
+          var result = r2.dispose.call(r2.value);
+          if (r2.async) return s2 |= 2, Promise.resolve(result).then(next, function(e2) {
+            fail(e2);
+            return next();
+          });
+        } else s2 |= 1;
+      } catch (e2) {
+        fail(e2);
+      }
+    }
+    if (s2 === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+    if (env.hasError) throw env.error;
   }
-  const currentKeys = Object.keys(current);
-  const nextKeys = Object.keys(next);
-  const currentRecord = current;
-  const nextRecord = next;
-  return currentKeys.length === nextKeys.length && currentKeys.every((key) => currentRecord[key] === nextRecord[key]);
+  return next();
 }
+function __rewriteRelativeImportExtension(path, preserveJsx) {
+  if (typeof path === "string" && /^\.\.?\//.test(path)) {
+    return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m2, tsx, d2, ext, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d2 && (!ext || !cm) ? m2 : d2 + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
+}
+const tslib_es6 = {
+  __extends,
+  __assign,
+  __rest,
+  __decorate,
+  __param,
+  __esDecorate,
+  __runInitializers,
+  __propKey,
+  __setFunctionName,
+  __metadata,
+  __awaiter,
+  __generator,
+  __createBinding,
+  __exportStar,
+  __values,
+  __read,
+  __spread,
+  __spreadArrays,
+  __spreadArray,
+  __await,
+  __asyncGenerator,
+  __asyncDelegator,
+  __asyncValues,
+  __makeTemplateObject,
+  __importStar,
+  __importDefault,
+  __classPrivateFieldGet,
+  __classPrivateFieldSet,
+  __classPrivateFieldIn,
+  __addDisposableResource,
+  __disposeResources,
+  __rewriteRelativeImportExtension
+};
+const tslib_es6$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  __addDisposableResource,
+  get __assign() {
+    return __assign;
+  },
+  __asyncDelegator,
+  __asyncGenerator,
+  __asyncValues,
+  __await,
+  __awaiter,
+  __classPrivateFieldGet,
+  __classPrivateFieldIn,
+  __classPrivateFieldSet,
+  __createBinding,
+  __decorate,
+  __disposeResources,
+  __esDecorate,
+  __exportStar,
+  __extends,
+  __generator,
+  __importDefault,
+  __importStar,
+  __makeTemplateObject,
+  __metadata,
+  __param,
+  __propKey,
+  __read,
+  __rest,
+  __rewriteRelativeImportExtension,
+  __runInitializers,
+  __setFunctionName,
+  __spread,
+  __spreadArray,
+  __spreadArrays,
+  __values,
+  default: tslib_es6
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(tslib_es6$1);
+var Polyfill$1 = {};
+var _Promise = {};
+var AsyncStack$1 = {};
+Object.defineProperty(AsyncStack$1, "__esModule", { value: true });
+AsyncStack$1.AsyncStack = void 0;
+const GlobalSymbol = Symbol("Global");
+class AsyncStack {
+  static getCurrent() {
+    const current = this.current;
+    return current;
+  }
+  static set(ctx) {
+    this.current = ctx;
+  }
+  static fork() {
+    const origin = AsyncStack.getCurrent();
+    const fork = new AsyncStack(origin);
+    fork.start();
+    return fork;
+  }
+  constructor(origin) {
+    if (origin !== GlobalSymbol) {
+      this.origin = origin;
+    }
+  }
+  start() {
+    AsyncStack.set(this);
+  }
+  // private yielded = false
+  yield() {
+    AsyncStack.set(this.origin);
+  }
+}
+AsyncStack$1.AsyncStack = AsyncStack;
+AsyncStack.Global = new AsyncStack(GlobalSymbol);
+AsyncStack.current = AsyncStack.Global;
+AsyncStack.NO_DATA = Symbol("NO_DATA");
+var _lib = {};
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.runInStack = exports.withContext = exports.createAsyncResolver = void 0;
+  exports.callWithContext = callWithContext;
+  const AsyncStack_12 = AsyncStack$1;
+  const createAsyncResolver = (stack, callback, onlyOnce = true) => {
+    let called = false;
+    return function(...args) {
+      if (onlyOnce && called)
+        return;
+      called = true;
+      stack.yield();
+      const result = callback.call(this, ...args);
+      return result;
+    };
+  };
+  exports.createAsyncResolver = createAsyncResolver;
+  function callWithContext(originalCallback, args) {
+    const fork = AsyncStack_12.AsyncStack.fork();
+    const patchedArgs = args.map((arg) => {
+      if (typeof arg === "function") {
+        return (0, exports.createAsyncResolver)(fork, arg);
+      }
+      return arg;
+    });
+    const result = originalCallback.call(this, ...patchedArgs);
+    fork.yield();
+    return result;
+  }
+  const withContext = (originalCallback, onlyOnce = true) => {
+    if (typeof originalCallback === "undefined")
+      return void 0;
+    return function(...args) {
+      return callWithContext.call(this, originalCallback, args);
+    };
+  };
+  exports.withContext = withContext;
+  const runInStack = (stackToUse, callback) => {
+    const currentStack = AsyncStack_12.AsyncStack.getCurrent();
+    stackToUse.start();
+    try {
+      const result = callback();
+      currentStack.start();
+      return result;
+    } catch (err) {
+      currentStack.start();
+      throw err;
+    }
+  };
+  exports.runInStack = runInStack;
+})(_lib);
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.PromiseWithContext = exports.OriginalPromise = void 0;
+  const AsyncStack_12 = AsyncStack$1;
+  const _lib_12 = _lib;
+  exports.OriginalPromise = Promise;
+  class PromiseWithContext extends exports.OriginalPromise {
+    constructor(callback) {
+      super((resolve, reject) => {
+        const fork = AsyncStack_12.AsyncStack.fork();
+        const wrapResolve = (0, _lib_12.createAsyncResolver)(fork, resolve);
+        const wrapReject = (0, _lib_12.createAsyncResolver)(fork, reject);
+        callback(wrapResolve, wrapReject);
+        fork.yield();
+      });
+    }
+    then(...args) {
+      return _lib_12.callWithContext.call(this, super.then, args);
+    }
+    catch(...args) {
+      return _lib_12.callWithContext.call(this, super.catch, args);
+    }
+    finally(...args) {
+      return _lib_12.callWithContext.call(this, super.finally, args);
+    }
+  }
+  exports.PromiseWithContext = PromiseWithContext;
+  Object.getOwnPropertyNames(Promise).forEach((method) => {
+    if (typeof Promise[method] === "function") {
+      PromiseWithContext[method] = exports.OriginalPromise[method].bind(PromiseWithContext);
+    }
+  });
+})(_Promise);
+var Events = {};
+Object.defineProperty(Events, "__esModule", { value: true });
+Events.addEventListenerWithContext = Events.dispatchWithContext = void 0;
+const AsyncStack_1 = AsyncStack$1;
+const _lib_1$1 = _lib;
+const originalAddEventListerner = EventTarget.prototype.addEventListener;
+const originalDispatchEvent = EventTarget.prototype.dispatchEvent;
+const stackByEvent = /* @__PURE__ */ new WeakMap();
+const dispatchWithContext = function(event) {
+  const stack = AsyncStack_1.AsyncStack.getCurrent();
+  stackByEvent.set(event, stack);
+  return originalDispatchEvent.call(this, event);
+};
+Events.dispatchWithContext = dispatchWithContext;
+const addEventListenerWithContext = function(event, callback, options) {
+  const wrappedCallback = function(event2) {
+    const stackWhenDispatched = stackByEvent.get(event2) || AsyncStack_1.AsyncStack.Global;
+    return (0, _lib_1$1.runInStack)(stackWhenDispatched, () => {
+      return callback.call(this, event2);
+    });
+  };
+  return originalAddEventListerner.call(this, event, wrappedCallback, options);
+};
+Events.addEventListenerWithContext = addEventListenerWithContext;
+Object.defineProperty(Polyfill$1, "__esModule", { value: true });
+Polyfill$1.Polyfill = void 0;
+const Promise_1 = _Promise;
+const Events_1 = Events;
+const _lib_1 = _lib;
+const root = typeof commonjsGlobal !== "undefined" && commonjsGlobal || typeof window !== "undefined" && window;
+class Polyfill {
+  static ensureEnabled() {
+    if (Polyfill.enabled)
+      return;
+    Polyfill.enabled = true;
+    root.Promise = Promise_1.PromiseWithContext;
+    root.setTimeout = (0, _lib_1.withContext)(root.setTimeout);
+    root.setInterval = (0, _lib_1.withContext)(root.setInterval);
+    root.setImmediate = (0, _lib_1.withContext)(root.setImmediate);
+    EventTarget.prototype.addEventListener = Events_1.addEventListenerWithContext;
+    EventTarget.prototype.dispatchEvent = Events_1.dispatchWithContext;
+  }
+}
+Polyfill$1.Polyfill = Polyfill;
+Polyfill.originalSetTimeout = setTimeout;
+Polyfill.OriginalPromise = Promise_1.OriginalPromise;
+Polyfill.enabled = false;
+var AsyncContext$1 = {};
+var AsyncVariable = {};
+var runInFork = {};
+var hasRequiredRunInFork;
+function requireRunInFork() {
+  if (hasRequiredRunInFork) return runInFork;
+  hasRequiredRunInFork = 1;
+  Object.defineProperty(runInFork, "__esModule", { value: true });
+  runInFork.runInFork = void 0;
+  const runInFork$1 = (callback) => {
+    let result;
+    let error;
+    new Promise((resolve) => {
+      try {
+        result = callback();
+        resolve(result);
+      } catch (err) {
+        error = err;
+      }
+    });
+    if (error) {
+      throw error;
+    }
+    return result;
+  };
+  runInFork.runInFork = runInFork$1;
+  return runInFork;
+}
+var hasRequiredAsyncVariable;
+function requireAsyncVariable() {
+  if (hasRequiredAsyncVariable) return AsyncVariable;
+  hasRequiredAsyncVariable = 1;
+  Object.defineProperty(AsyncVariable, "__esModule", { value: true });
+  AsyncVariable.AsyncVariable = void 0;
+  const AsyncStack_12 = AsyncStack$1;
+  const runInFork_1 = requireRunInFork();
+  let AsyncVariable$1 = class AsyncVariable2 {
+    constructor() {
+      this.data = /* @__PURE__ */ new WeakMap();
+    }
+    static registerVariable(variable, stack) {
+      if (!AsyncVariable2.variableByStack.has(stack)) {
+        AsyncVariable2.variableByStack.set(stack, /* @__PURE__ */ new Set());
+      }
+      AsyncVariable2.variableByStack.get(stack).add(variable);
+    }
+    getBox(stack) {
+      if (!stack)
+        return void 0;
+      const currentBox = this.data.get(stack);
+      if (currentBox)
+        return currentBox;
+      const canWalkOrigin = AsyncVariable2.stopWalkAt.has(stack);
+      if (canWalkOrigin)
+        return void 0;
+      const parentBox = this.getBox(stack.origin);
+      if (parentBox)
+        this.setBox(stack, parentBox);
+      return parentBox;
+    }
+    setBox(stack, box) {
+      AsyncVariable2.registerVariable(this, stack);
+      this.data.set(stack, box);
+    }
+    set(stack, data) {
+      this.setBox(stack, {
+        value: data
+      });
+    }
+    get() {
+      var _a;
+      const current = AsyncStack_12.AsyncStack.getCurrent();
+      return (_a = this.getBox(current)) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    run(data, callback) {
+      return (0, runInFork_1.runInFork)(() => {
+        const current = AsyncStack_12.AsyncStack.getCurrent();
+        this.set(current, data);
+        return callback();
+      });
+    }
+    wrap(data, callback) {
+      return (...args) => this.run(data, () => callback(...args));
+    }
+  };
+  AsyncVariable.AsyncVariable = AsyncVariable$1;
+  AsyncVariable$1.stopWalkAt = /* @__PURE__ */ new WeakSet();
+  AsyncVariable$1.variableByStack = /* @__PURE__ */ new WeakMap();
+  return AsyncVariable;
+}
+var AsyncSnapshot = {};
+var hasRequiredAsyncSnapshot;
+function requireAsyncSnapshot() {
+  if (hasRequiredAsyncSnapshot) return AsyncSnapshot;
+  hasRequiredAsyncSnapshot = 1;
+  Object.defineProperty(AsyncSnapshot, "__esModule", { value: true });
+  AsyncSnapshot.AsyncSnapshot = void 0;
+  const AsyncStack_12 = AsyncStack$1;
+  const AsyncVariable_1 = requireAsyncVariable();
+  const runInFork_1 = requireRunInFork();
+  let AsyncSnapshot$1 = class AsyncSnapshot2 {
+    capture() {
+      let current = AsyncStack_12.AsyncStack.getCurrent();
+      while (current) {
+        const variables = AsyncVariable_1.AsyncVariable.variableByStack.get(current);
+        variables === null || variables === void 0 ? void 0 : variables.forEach((variable) => {
+          const alreadyHasVariable = this.dataByVariable.has(variable);
+          if (!alreadyHasVariable) {
+            const value = variable.get();
+            this.dataByVariable.set(variable, value);
+          }
+        });
+        current = current.origin;
+      }
+    }
+    constructor() {
+      this.dataByVariable = /* @__PURE__ */ new Map();
+      this.capture();
+    }
+    static create() {
+      const snapshot = new AsyncSnapshot2();
+      return snapshot;
+    }
+    run(callback) {
+      return (0, runInFork_1.runInFork)(() => {
+        const current = AsyncStack_12.AsyncStack.getCurrent();
+        AsyncVariable_1.AsyncVariable.stopWalkAt.add(current);
+        this.dataByVariable.forEach((data, variable) => {
+          variable.set(current, data);
+        });
+        return callback();
+      });
+    }
+    wrap(callback) {
+      return (...args) => this.run(() => callback(...args));
+    }
+    static wrap(callback) {
+      return (0, runInFork_1.runInFork)(() => {
+        const snapshot = AsyncSnapshot2.create();
+        return snapshot.wrap(callback);
+      });
+    }
+  };
+  AsyncSnapshot.AsyncSnapshot = AsyncSnapshot$1;
+  return AsyncSnapshot;
+}
+var hasRequiredAsyncContext;
+function requireAsyncContext() {
+  if (hasRequiredAsyncContext) return AsyncContext$1;
+  hasRequiredAsyncContext = 1;
+  Object.defineProperty(AsyncContext$1, "__esModule", { value: true });
+  AsyncContext$1.AsyncContext = void 0;
+  const AsyncVariable_1 = requireAsyncVariable();
+  const AsyncSnapshot_1 = requireAsyncSnapshot();
+  class AsyncContext2 {
+  }
+  AsyncContext$1.AsyncContext = AsyncContext2;
+  AsyncContext2.Variable = AsyncVariable_1.AsyncVariable;
+  AsyncContext2.Snapshot = AsyncSnapshot_1.AsyncSnapshot;
+  return AsyncContext$1;
+}
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  const tslib_1 = require$$0;
+  const Polyfill_1 = Polyfill$1;
+  Polyfill_1.Polyfill.ensureEnabled();
+  tslib_1.__exportStar(requireAsyncContext(), exports);
+})(build);
+const AsyncContextNS = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null
+}, [build]);
+const CONTEXT_MARK = Symbol("schemx.async-context");
+const { AsyncContext } = AsyncContextNS;
+function createContext(name, defaultValue) {
+  const hasDefaultValue = arguments.length >= 2;
+  const variable = new AsyncContext.Variable();
+  const useContext = () => {
+    const value = variable.get();
+    if (value !== void 0) {
+      return value;
+    }
+    if (hasDefaultValue) {
+      return defaultValue;
+    }
+    throw new ContextNotProvidedError({ name });
+  };
+  const tryUseContext = () => {
+    const value = variable.get();
+    if (value !== void 0) {
+      return value;
+    }
+    if (hasDefaultValue) {
+      return defaultValue;
+    }
+    return void 0;
+  };
+  const Provider = (value, fn) => variable.run(value, fn);
+  return {
+    name,
+    useContext,
+    tryUseContext,
+    Provider,
+    [CONTEXT_MARK]: true
+  };
+}
+class ContextNotProvidedError extends Error {
+  /**
+   * 创建 Context 未提供错误。
+   *
+   * @param context - 读取失败的上下文声明（仅取 name 用于信息展示）。
+   */
+  constructor(context) {
+    super(`[schemx] Context "${context.name}" has not been provided.`);
+    this.name = "ContextNotProvidedError";
+  }
+}
+function isContext(value) {
+  return Boolean(
+    value && typeof value === "object" && CONTEXT_MARK in value && value[CONTEXT_MARK] === true
+  );
+}
+const schemxContextStore = createContext("SchemxContext");
+function withSchemxContext(context, run) {
+  return schemxContextStore.Provider(
+    {
+      type: "runtime",
+      value: context
+    },
+    run
+  );
+}
+function useSchemxContext() {
+  const current = schemxContextStore.tryUseContext();
+  if ((current == null ? void 0 : current.type) !== "runtime") {
+    throw new Error("[schemx] Form runtime context has not been provided.");
+  }
+  return current.value;
+}
+function maybeUseSchemxContext() {
+  const current = schemxContextStore.tryUseContext();
+  if ((current == null ? void 0 : current.type) !== "runtime") {
+    return void 0;
+  }
+  return current.value;
+}
+function createFieldDescriptor(options) {
+  const { schema, parentKey = "" } = options;
+  const key = schema.key ?? (parentKey ? `field:${parentKey}/${schema.name}` : `field:${schema.name}`);
+  const normalizedSchema = buildNormalizedFieldSchema(schema);
+  return {
+    type: "field",
+    key,
+    name: schema.name,
+    componentType: schema.componentType,
+    staticSchema: normalizedSchema,
+    dynamicProps: createFieldDynamicProps(schema.dependencies),
+    validation: createFieldValidation(normalizedSchema)
+  };
+}
+function createGroupDescriptor(options) {
+  const { schema, index, parentKey = "" } = options;
+  const key = createGroupDescriptorKey(schema.key, index, parentKey);
+  const { children: _rawChildren, ...schemaWithoutChildren } = schema;
+  return {
+    type: "group",
+    key,
+    staticSchema: {
+      ...schemaWithoutChildren,
+      key
+    },
+    children: []
+  };
+}
+function createDependencyDescriptor(options) {
+  const { schema, parentKey = "" } = options;
+  const trigger = [...schema.to];
+  const triggerKey = trigger.map(serializeNamePath).join(",");
+  const key = schema.key ?? (parentKey ? `dependency:${parentKey}/${triggerKey}` : `dependency:${triggerKey}`);
+  const renderer = (formApi, abortSignal) => {
+    const values = formApi.getValues();
+    return schema.renderer(values, formApi, {
+      abortSignal
+    });
+  };
+  return {
+    type: "dependency",
+    key,
+    triggerFields: trigger,
+    renderer
+  };
+}
+function getPlaceholder(schema) {
+  var _a;
+  const existingplaceholder = ((_a = schema.componentProps) == null ? void 0 : _a.placeholder) ?? schema.placeholder;
+  if (existingplaceholder == null) {
+    return ["input", "text", "textarea"].includes(schema.componentType) ? `请输入${schema.label || schema.name}` : `请选择${schema.label || schema.name}`;
+  }
+  return existingplaceholder;
+}
+function buildNormalizedFieldSchema(schema) {
+  const { defaultProps, instance } = useSchemxContext();
+  const {
+    componentProps: cp,
+    visible,
+    readonly,
+    disabled,
+    required,
+    rules,
+    validationTrigger,
+    dependencies: _dependencies,
+    ...rest
+  } = schema;
+  const mergedVisible = visible ?? defaultConfig.visible;
+  const mergedReadonly = readonly ?? defaultProps.readonly ?? defaultConfig.readonly;
+  const mergedDisabled = disabled ?? defaultProps.disabled ?? defaultConfig.disabled;
+  const mergedAlign = mergedReadonly ? "right" : (cp == null ? void 0 : cp.align) ?? rest.contentAlign;
+  const mergedValidationTrigger = validationTrigger ?? defaultProps.validationTrigger ?? defaultConfig.validationTrigger;
+  const mergedPlaceholder = getPlaceholder(schema);
+  const rulesArray = (Array.isArray(rules) ? rules : [rules]).filter(Boolean);
+  const mergedRequired = required ?? (rulesArray.length > 0 || defaultConfig.required);
+  const normalizedSchema = {
+    ...rest ?? {},
+    key: rest.key,
+    name: rest.name,
+    label: rest.label,
+    componentType: rest.componentType,
+    visible: mergedVisible,
+    readonly: mergedReadonly,
+    disabled: mergedDisabled,
+    required: mergedRequired,
+    placeholder: mergedPlaceholder,
+    labelIcon: rest.labelIcon || defaultConfig.labelIcon,
+    labelAlign: rest.labelAlign || defaultConfig.labelAlign,
+    labelPosition: rest.labelPosition || defaultConfig.labelPosition,
+    labelWidth: rest.labelWidth || defaultConfig.labelWidth,
+    colon: rest.colon ?? defaultConfig.colon,
+    rules,
+    validationTrigger: normalizeTrigger$1(mergedValidationTrigger)
+  };
+  if (Object.hasOwn(schema, "initialValue")) {
+    normalizedSchema.initialValue = rest.initialValue;
+  }
+  if (mergedReadonly) {
+    normalizedSchema.contentAlign = "right";
+    normalizedSchema.labelPosition = "left";
+  }
+  normalizedSchema.componentProps = {
+    ...cp,
+    align: mergedAlign,
+    readonly: mergedReadonly,
+    disabled: mergedDisabled,
+    placeholder: mergedPlaceholder,
+    formItemProps: normalizedSchema,
+    formInstance: instance
+  };
+  return normalizedSchema;
+}
+function createFieldDynamicProps(dependencies) {
+  if (!dependencies) {
+    return null;
+  }
+  return {
+    source: "dependencies",
+    triggerFields: dependencies.triggerFields,
+    dependencies
+  };
+}
+function createFieldValidation(schema) {
+  const rules = normalizeValidationRules(schema.rules);
+  if (!rules) {
+    return null;
+  }
+  return {
+    trigger: schema.validationTrigger,
+    rules
+  };
+}
+function normalizeValidationRules(rules) {
+  if (rules == null) {
+    return null;
+  }
+  if (Array.isArray(rules)) {
+    return rules.length > 0 ? rules : null;
+  }
+  return rules;
+}
+function createGroupDescriptorKey(explicitKey, index, parentKey) {
+  return explicitKey ?? (parentKey ? `group:${parentKey}/${index}` : `group:${index}`);
+}
+function serializeNamePath(name) {
+  if (Array.isArray(name)) {
+    return name.join(".");
+  }
+  return String(name);
+}
+function normalizeTrigger$1(trigger) {
+  const map = {
+    onBlur: "blur",
+    onChange: "change",
+    onSubmit: "submit",
+    blur: "blur",
+    change: "change",
+    submit: "submit"
+  };
+  const TArray = Array.isArray(trigger) ? trigger : [trigger];
+  return TArray.map((t2) => map[t2] ?? "submit");
+}
+function isDependencyDescriptor(descriptor) {
+  return descriptor.type === "dependency";
+}
+function createCompileCache() {
+  return {
+    version: 0,
+    entries: /* @__PURE__ */ new WeakMap()
+  };
+}
+function createCompile(options = {}) {
+  const compileOptions = {
+    defaultProps: options.defaultProps ?? {},
+    formInstance: options.formInstance ?? {}
+  };
+  const compileCache = createCompileCache();
+  function toDescriptors(schemas, parentKey = "") {
+    if (maybeUseSchemxContext()) {
+      return compileDescriptors(schemas, parentKey);
+    }
+    return withSchemxContext(
+      createFallbackCompileContext(),
+      () => compileDescriptors(schemas, parentKey)
+    );
+  }
+  function compileDescriptors(schemas, parentKey = "") {
+    const descriptors = [];
+    const normalized = normalizeSchemas([...schemas]);
+    for (let i2 = 0; i2 < normalized.length; i2++) {
+      const schema = normalized[i2];
+      let descriptor;
+      const cached = compileCache.entries.get(schema);
+      if (cached && cached.version === compileCache.version) {
+        descriptors.push(cached.descriptor);
+        continue;
+      }
+      if (isGroupSchema(schema)) {
+        descriptor = createGroupDescriptor({
+          schema,
+          index: i2,
+          parentKey
+        });
+        if (schema.children.length > 0) {
+          descriptor.children = toDescriptors(schema.children, descriptor.key);
+        }
+      } else if (isDependencySchema(schema)) {
+        descriptor = createDependencyDescriptor({
+          schema,
+          parentKey
+        });
+      } else {
+        descriptor = createFieldDescriptor({
+          schema,
+          parentKey
+        });
+      }
+      compileCache.entries.set(schema, {
+        version: compileCache.version,
+        descriptor
+      });
+      descriptors.push(descriptor);
+    }
+    return descriptors;
+  }
+  function createFallbackCompileContext() {
+    return {
+      defaultProps: compileOptions.defaultProps,
+      instance: compileOptions.formInstance
+    };
+  }
+  function getCacheVersion() {
+    return compileCache.version;
+  }
+  function invalidate() {
+    compileCache.version++;
+  }
+  function getVersion() {
+    return compileCache.version;
+  }
+  return {
+    cache: compileCache,
+    getCacheVersion,
+    toDescriptors,
+    invalidate,
+    getVersion
+  };
+}
+function createSchemas(schemas = []) {
+  const source = createSignal(schemas);
+  const getValue = () => {
+    return source.value;
+  };
+  const peek = () => {
+    return source.peek();
+  };
+  const set2 = (nextSchemas) => {
+    source.value = nextSchemas;
+  };
+  const update = (updater) => {
+    source.value = updater(source.peek());
+  };
+  const subscribe = (listener) => {
+    let isInitialNotify = true;
+    const unsubscribe = source.subscribe((value) => {
+      if (isInitialNotify) {
+        isInitialNotify = false;
+        return;
+      }
+      listener(value);
+    });
+    return () => {
+      unsubscribe();
+    };
+  };
+  return {
+    signal: source,
+    get value() {
+      return getValue();
+    },
+    peek,
+    set: set2,
+    update,
+    subscribe
+  };
+}
+function isSchemxSchemas(schemas) {
+  if (!schemas || Array.isArray(schemas)) {
+    return false;
+  }
+  const candidate = schemas;
+  return typeof candidate.peek === "function" && typeof candidate.set === "function" && typeof candidate.update === "function" && typeof candidate.subscribe === "function";
+}
+function createAbortableTaskRunner(options) {
+  const ownScope = options.scope.child();
+  let version = 0;
+  let controller = null;
+  const isStale = (currentVersion, currentController) => {
+    return ownScope.disposed || currentController.signal.aborted || currentVersion !== version;
+  };
+  const runCurrentTask = async (currentVersion, currentController) => {
+    var _a, _b, _c, _d;
+    try {
+      const value = await options.run(currentController.signal);
+      if (isStale(currentVersion, currentController)) {
+        return value;
+      }
+      (_a = options.onSuccess) == null ? void 0 : _a.call(options, value);
+      (_b = options.onSettled) == null ? void 0 : _b.call(options);
+      return value;
+    } catch (cause) {
+      const error = normalizeError$1(cause);
+      if (isStale(currentVersion, currentController)) {
+        if (options.throwOnError) {
+          throw error;
+        }
+        return;
+      }
+      (_c = options.onError) == null ? void 0 : _c.call(options, error);
+      (_d = options.onSettled) == null ? void 0 : _d.call(options);
+      if (options.throwOnError) {
+        throw error;
+      }
+    }
+  };
+  const run = async () => {
+    var _a;
+    if (ownScope.disposed) {
+      return;
+    }
+    const currentVersion = ++version;
+    controller == null ? void 0 : controller.abort();
+    controller = new AbortController();
+    (_a = options.onStart) == null ? void 0 : _a.call(options, controller);
+    return await options.scheduler.track(runCurrentTask(currentVersion, controller));
+  };
+  const dispose = () => {
+    version += 1;
+    controller == null ? void 0 : controller.abort();
+    ownScope.dispose();
+  };
+  options.scope.add(dispose);
+  return {
+    run,
+    dispose
+  };
+}
+function normalizeError$1(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+function createFieldRuntimeState(options) {
+  const { key, descriptor } = options;
+  const schema = descriptor.staticSchema;
+  const staticSchema = createSignal(schema, {
+    name: `field:${String(descriptor.name)}:staticSchema`
+  });
+  const dynamicOverrides = createSignal(
+    {},
+    { name: `field:${String(descriptor.name)}:dynamicOverrides` }
+  );
+  const diagnostics = createSignal(
+    createInitialDiagnostics(),
+    { name: `field:${String(descriptor.name)}:diagnostics` }
+  );
+  const name = createSignal(descriptor.name, {
+    name: `field:${String(descriptor.name)}:name`
+  });
+  const effectiveSchema = createComputed(() => {
+    const base = staticSchema.value;
+    const overrides = dynamicOverrides.value;
+    return {
+      key,
+      name: name.value,
+      componentType: base.componentType,
+      label: base.label || "",
+      visible: overrides.visible ?? base.visible ?? true,
+      disabled: overrides.disabled ?? base.disabled ?? false,
+      readonly: overrides.readonly ?? base.readonly ?? false,
+      required: overrides.required ?? base.required ?? false,
+      placeholder: overrides.placeholder ?? base.placeholder ?? "",
+      componentProps: overrides.componentProps ?? base.componentProps ?? {},
+      rules: overrides.rules ?? base.rules ?? [],
+      validationTrigger: base.validationTrigger
+    };
+  });
+  const viewSchema = createComputed(() => {
+    const effective = effectiveSchema.value;
+    return {
+      ...staticSchema.value,
+      visible: effective.visible,
+      disabled: effective.disabled,
+      readonly: effective.readonly,
+      required: effective.required,
+      label: effective.label,
+      placeholder: effective.placeholder,
+      componentProps: effective.componentProps,
+      rules: effective.rules
+    };
+  });
+  return {
+    name,
+    staticSchema,
+    dynamicOverrides,
+    effectiveSchema,
+    viewSchema,
+    diagnostics
+  };
+}
+function setFieldStaticSchema(state, descriptor) {
+  state.staticSchema.value = descriptor.staticSchema;
+  state.name.value = descriptor.name;
+  const prev = state.diagnostics.peek();
+  state.diagnostics.value = {
+    ...prev,
+    lastUpdatedBy: "static-schema",
+    version: prev.version + 1,
+    triggerFields: [],
+    overriddenKeys: [],
+    error: null
+  };
+}
+function setFieldDynamicOverrides(state, overrides, meta) {
+  state.dynamicOverrides.value = overrides;
+  const prev = state.diagnostics.peek();
+  state.diagnostics.value = {
+    ...prev,
+    lastUpdatedBy: "dependencies",
+    version: prev.version + 1,
+    triggerFields: meta.triggerFields,
+    overriddenKeys: Object.keys(overrides),
+    error: meta.error ?? null
+  };
+}
+function createInitialDiagnostics() {
+  return {
+    lastUpdatedBy: "static-schema",
+    version: 0,
+    triggerFields: [],
+    overriddenKeys: [],
+    error: null
+  };
+}
+const FIELD_DEPENDENCIES_PROP_KEYS = [
+  "componentProps",
+  "placeholder",
+  "required",
+  "readonly",
+  "disabled",
+  "visible",
+  "rules"
+];
 function createDependenciesEffect(options) {
-  const { descriptor, fieldModel, context, scope } = options;
-  const base = descriptor.schema;
-  const dependencies = descriptor.dependencies;
-  if (dependencies == null || dependencies.triggerFields == null || dependencies.triggerFields.length === 0) {
+  const { context, descriptor, runtimeState, scope } = options;
+  const { formApi, scheduler } = context;
+  const dynamicProps = descriptor.dynamicProps;
+  const dependencies = dynamicProps == null ? void 0 : dynamicProps.dependencies;
+  const triggerFields = dynamicProps == null ? void 0 : dynamicProps.triggerFields;
+  if (dependencies == null || triggerFields == null || triggerFields.length === 0) {
     return;
   }
-  let version = 0;
+  const taskRunner = createAbortableTaskRunner({
+    scope,
+    scheduler,
+    run: () => resolveDependencies(dependencies, formApi),
+    onSuccess: (resolvedProps) => {
+      setFieldDynamicOverrides(runtimeState, resolvedProps, {
+        triggerFields
+      });
+    },
+    onError: (error) => {
+      console.error("[schemx] dependencies 执行错误:", error);
+    }
+  });
   const dispose = createSignalEffect(() => {
-    const currentVersion = ++version;
-    void context.formApi.getValues(dependencies.triggerFields);
-    void context.scheduler.track(
-      resolveDependencies(dependencies, base, context.formApi).then((resolvedProps) => {
-        if (scope.disposed || currentVersion !== version) {
-          return;
-        }
-        updateFieldModel(fieldModel, descriptor, resolvedProps);
-      })
-    );
+    void formApi.getValues([...triggerFields]);
+    void taskRunner.run();
   });
   scope.add(() => {
-    version += 1;
     dispose();
   });
 }
-async function resolveDependencies(dependencies, base, formApi) {
+async function resolveDependencies(dependencies, formApi) {
   const values = formApi.getValues();
   const [resolvedProps] = await Promise.all([
-    resolveDependenciesProps(dependencies, base, values, formApi),
+    resolveDependenciesProps(dependencies, values, formApi),
     runDependenciesTrigger(dependencies, values, formApi)
   ]);
   return resolvedProps;
@@ -2419,67 +3722,17 @@ async function runDependenciesTrigger(dependencies, values, formApi) {
     console.error("[schemx] trigger 执行错误:", error);
   }
 }
-async function resolveDependenciesProps(dependencies, base, values, formApi) {
-  const [componentProps, placeholder, required, readonly, disabled, visible, rules] = await Promise.all([
-    resolveDependenciesProp({
-      condition: dependencies.componentProps,
-      values,
-      formApi,
-      defaultValue: base.componentProps
-    }),
-    resolveDependenciesProp({
-      condition: dependencies.placeholder,
-      values,
-      formApi,
-      defaultValue: base.placeholder
-    }),
-    resolveDependenciesProp({
-      condition: dependencies.required,
-      values,
-      formApi,
-      defaultValue: base.required
-    }),
-    resolveDependenciesProp({
-      condition: dependencies.readonly,
-      values,
-      formApi,
-      defaultValue: base.readonly
-    }),
-    resolveDependenciesProp({
-      condition: dependencies.disabled,
-      values,
-      formApi,
-      defaultValue: base.disabled
-    }),
-    resolveDependenciesProp({
-      condition: dependencies.visible,
-      values,
-      formApi,
-      defaultValue: base.visible
-    }),
-    resolveDependenciesProp({
-      condition: dependencies.rules,
-      values,
-      formApi,
-      defaultValue: base.rules
-    })
-  ]);
-  return {
-    componentProps,
-    placeholder,
-    required,
-    readonly,
-    disabled,
-    visible,
-    rules
-  };
-}
-async function resolveDependenciesProp(options) {
-  const { condition, values, formApi, defaultValue } = options;
-  if (condition == null) {
-    return defaultValue;
-  }
-  return resolveCondition(formApi, condition, values, defaultValue);
+async function resolveDependenciesProps(dependencies, values, formApi) {
+  const entries = await Promise.all(
+    FIELD_DEPENDENCIES_PROP_KEYS.filter((key) => dependencies[key] != null).map(
+      async (key) => {
+        const condition = dependencies[key];
+        const value = await resolveCondition(formApi, condition, values, void 0);
+        return [key, value];
+      }
+    )
+  );
+  return Object.fromEntries(entries);
 }
 async function resolveCondition(formApi, condition, formValues, defaultValue) {
   try {
@@ -2490,118 +3743,124 @@ async function resolveCondition(formApi, condition, formValues, defaultValue) {
     return defaultValue;
   }
 }
+const dependencyNodeResources = /* @__PURE__ */ new WeakMap();
 function createDependencyEffect(options) {
   var _a;
-  const { node, descriptor, context } = options;
+  const { context, node, descriptor } = options;
+  const { formApi, scheduler, compile, commitChildren } = context;
   const resourceScope = options.scope ?? node.scope.child();
-  (_a = node.dependencySlot) == null ? void 0 : _a.dispose();
-  const slot = {
+  let compileCacheVersion = compile.getCacheVersion();
+  const resources = context.nodeResources;
+  dependencyNodeResources.set(node, resources);
+  (_a = resources.dependencyEffects.get(node.id)) == null ? void 0 : _a.dispose();
+  const effectState = {
     loading: createSignal(false),
     error: createSignal(null),
-    version: createSignal(0),
-    abortController: createSignal(null),
-    run: async () => void 0,
-    dispose: () => void 0
-  };
-  node.dependencyResourceScope = resourceScope;
-  slot.run = () => {
-    var _a2;
-    if (resourceScope.disposed) return Promise.resolve();
-    const currentDescriptor = node.descriptor;
-    const currentVersion = slot.version.value + 1;
-    slot.version.value = currentVersion;
-    (_a2 = slot.abortController.value) == null ? void 0 : _a2.abort();
-    const controller = new AbortController();
-    slot.abortController.value = controller;
-    slot.loading.value = true;
-    slot.error.value = null;
-    return context.scheduler.track(
-      (async () => {
-        try {
-          const childSchemas = await Promise.resolve(
-            currentDescriptor.renderer(context.formApi, controller.signal)
-          );
-          if (resourceScope.disposed || controller.signal.aborted || currentVersion !== slot.version.value) {
-            return;
-          }
-          const descriptors = compileToDescriptors(
-            childSchemas,
-            context.defaultProps
-          );
-          context.commitChildren(node, descriptors);
-        } catch (cause) {
-          if (resourceScope.disposed || controller.signal.aborted || currentVersion !== slot.version.value) {
-            return;
-          }
-          slot.error.value = normalizeError$1(cause);
-        } finally {
-          if (!resourceScope.disposed && !controller.signal.aborted && currentVersion === slot.version.value) {
-            slot.loading.value = false;
-          }
-        }
-      })()
-    );
+    version: createSignal(0),
+    abortController: createSignal(null),
+    run: async () => void 0,
+    dispose: () => void 0
   };
-  slot.dispose = () => {
-    var _a2;
-    slot.version.value += 1;
-    (_a2 = slot.abortController.value) == null ? void 0 : _a2.abort();
+  resources.dependencyResourceScopes.set(node.id, resourceScope);
+  const taskRunner = createAbortableTaskRunner({
+    scope: resourceScope,
+    scheduler,
+    run: async (signal) => {
+      const currentDescriptor = resources.descriptors.get(node.id);
+      if (!currentDescriptor || !isDependencyDescriptor(currentDescriptor)) {
+        return [];
+      }
+      return await Promise.resolve(currentDescriptor.renderer(formApi, signal));
+    },
+    onStart: (controller) => {
+      effectState.version.value += 1;
+      effectState.abortController.value = controller;
+      effectState.loading.value = true;
+      effectState.error.value = null;
+    },
+    onSuccess: (childSchemas) => {
+      const nextCompileCacheVersion = compile.getCacheVersion();
+      if (nextCompileCacheVersion !== compileCacheVersion) {
+        compile.invalidate();
+        compileCacheVersion = nextCompileCacheVersion;
+      }
+      const descriptors = compile.toDescriptors(childSchemas, "");
+      commitChildren(node, descriptors);
+    },
+    onError: (error) => {
+      effectState.error.value = error;
+    },
+    onSettled: () => {
+      effectState.loading.value = false;
+    }
+  });
+  effectState.run = async () => {
+    if (resourceScope.disposed) return;
+    const currentDescriptor = resources.descriptors.get(node.id);
+    if (!currentDescriptor || !isDependencyDescriptor(currentDescriptor)) {
+      return;
+    }
+    await taskRunner.run();
+  };
+  effectState.dispose = () => {
+    effectState.version.value += 1;
+    taskRunner.dispose();
     resourceScope.dispose();
   };
   resourceScope.add(() => {
     var _a2;
-    (_a2 = slot.abortController.value) == null ? void 0 : _a2.abort();
-    slot.abortController.value = null;
-    if (node.dependencySlot === slot) {
-      node.dependencySlot = null;
+    (_a2 = effectState.abortController.value) == null ? void 0 : _a2.abort();
+    effectState.abortController.value = null;
+    if (resources.dependencyEffects.get(node.id) === effectState) {
+      resources.dependencyEffects.delete(node.id);
     }
-    if (node.dependencyResourceScope === resourceScope) {
-      node.dependencyResourceScope = null;
+    if (resources.dependencyResourceScopes.get(node.id) === resourceScope) {
+      resources.dependencyResourceScopes.delete(node.id);
     }
   });
-  if (descriptor.trigger.length > 0) {
-    setupTriggerSubscription(
-      descriptor.trigger,
-      context.formApi,
-      () => slot.run(),
-      resourceScope
-    );
-  }
-  node.dependencySlot = slot;
-  void slot.run().catch((runError) => {
-    console.error("DependencyEffectSlot initial run error:", runError);
+  setupTriggerSubscription(
+    descriptor.triggerFields,
+    formApi,
+    () => effectState.run(),
+    resourceScope,
+    scheduler,
+    `dependency:${node.id}:trigger`
+  );
+  resources.dependencyEffects.set(node.id, effectState);
+  void effectState.run().catch((runError) => {
+    console.error("DependencyEffectState initial run error:", runError);
   });
-  return slot;
+  return effectState;
 }
-function setupTriggerSubscription(triggers, formApi, run, scope) {
+function setupTriggerSubscription(triggers, formApi, run, scope, scheduler, taskId) {
   let isFirstRun = true;
-  let pendingRun = false;
   const disposeEffect = createSignalEffect(() => {
-    void formApi.getValues(triggers);
-    if (!isFirstRun && !pendingRun) {
-      pendingRun = true;
-      queueMicrotask(() => {
-        pendingRun = false;
-        if (scope.disposed) return;
-        run().catch((runError) => {
-          console.error("DependencyEffectSlot trigger run error:", runError);
-        });
+    void formApi.getValues([...triggers]);
+    if (!isFirstRun) {
+      scheduler.schedule({
+        id: taskId,
+        priority: "normal",
+        scope,
+        run,
+        onError: (runError) => {
+          console.error("DependencyEffectState trigger run error:", runError);
+        }
       });
     }
     isFirstRun = false;
   });
   scope.add(disposeEffect);
 }
-function normalizeError$1(cause) {
-  return cause instanceof Error ? cause : new Error(String(cause));
-}
 class RuntimeFieldRegistry {
   constructor() {
     __publicField(this, "fields", /* @__PURE__ */ new Map());
   }
   register(entry) {
     const key = entry.name;
-    this.fields.set(key, entry);
+    this.fields.set(key, {
+      name: entry.name,
+      node: entry.node
+    });
   }
   unregister(name, node) {
     const key = name;
@@ -2623,30 +3882,30 @@ function createFieldRegistry() {
   return new RuntimeFieldRegistry();
 }
 function createValidationEffect(options) {
-  const { name, fieldModel, scope, context } = options;
+  const { context, name, effectiveSchema, scope } = options;
   const taskScheduler = context.scheduler;
   const registered = createSignal(false);
-  const validating = createSignal(false);
   let registrationVersion = 0;
   const readValidationProps = () => {
-    const snapshot = fieldModel.snapshot.value;
+    const effective = effectiveSchema.value;
     return {
-      visible: snapshot.visible,
-      readonly: snapshot.readonly,
-      disabled: snapshot.disabled,
-      label: snapshot.label,
-      rules: snapshot.rules
+      visible: effective.visible,
+      readonly: effective.readonly,
+      disabled: effective.disabled,
+      label: effective.label,
+      rules: effective.rules
     };
   };
   const applyRegistration = (snapshot) => {
     const { visible, readonly, disabled, label, rules } = snapshot;
-    if (!visible || readonly || disabled || !rules) {
+    if (!visible || readonly || disabled || !hasRules(rules)) {
       context.instance.unregisterRules(name);
       context.instance.setFieldError(name, []);
       registered.value = false;
       return;
     }
-    context.instance.registerRules(name, rules, `${label}为必填项`);
+    const normalizedRules = rules ?? [];
+    context.instance.registerRules(name, normalizedRules, `${label}为必填项`);
     registered.value = true;
   };
   const scheduleRegistration = (snapshot) => {
@@ -2673,25 +3932,17 @@ function createValidationEffect(options) {
     scheduleRegistration(readValidationProps());
   });
   scope.add(disposeEffect);
-  const validate = async () => {
-    validating.value = true;
-    try {
-      const result = await context.instance.validateField(name);
-      return result;
-    } finally {
-      validating.value = false;
-    }
-  };
   const dispose = () => {
     scope.dispose();
   };
   return {
     registered,
-    validating,
-    validate,
     dispose
   };
 }
+function hasRules(rules) {
+  return Array.isArray(rules) ? rules.length > 0 : Boolean(rules);
+}
 function createLifecycleBus(initialListener) {
   const listeners = /* @__PURE__ */ new Set();
   if (initialListener) {
@@ -2780,139 +4031,6 @@ function createLifecycleBus(initialListener) {
   };
 }
 const createLifecycle = createLifecycleBus;
-function defaultGetChildren(node) {
-  return node.children;
-}
-function findNodeBFS(tree, predicate, options = {}) {
-  const getChildren = options.getChildren ?? defaultGetChildren;
-  const queue = Array.isArray(tree) ? [...tree] : [tree];
-  let index = 0;
-  while (index < queue.length) {
-    const node = queue[index];
-    index++;
-    if (predicate(node)) {
-      return node;
-    }
-    const children = getChildren(node);
-    if (children == null ? void 0 : children.length) {
-      queue.push(...children);
-    }
-  }
-  return void 0;
-}
-function hasDescriptor(node) {
-  return node.type !== "root";
-}
-function isRootRuntimeNode(node) {
-  return node.type === "root";
-}
-function isFieldRuntimeNode(node) {
-  return (node == null ? void 0 : node.type) === "field";
-}
-function isGroupRuntimeNode(node) {
-  return (node == null ? void 0 : node.type) === "group";
-}
-function isDependencyRuntimeNode(node) {
-  return (node == null ? void 0 : node.type) === "dependency";
-}
-function isContainerRuntimeNode(node) {
-  return node.type === "root" || node.type === "group" || node.type === "dependency";
-}
-function getChildRuntimeNodes(node) {
-  if (isRootRuntimeNode(node) || isGroupRuntimeNode(node)) {
-    return node.childNodes;
-  }
-  if (isDependencyRuntimeNode(node)) {
-    return node.dynamicChildNodes;
-  }
-  return [];
-}
-function setChildRuntimeNodes(node, children) {
-  if (isRootRuntimeNode(node) || isGroupRuntimeNode(node)) {
-    node.childNodes = children;
-    return;
-  }
-  if (isDependencyRuntimeNode(node)) {
-    node.dynamicChildNodes = children;
-    return;
-  }
-}
-function findFieldRuntimeNode(root, name) {
-  return findNodeBFS(
-    root,
-    (node) => isFieldRuntimeNode(node) && node.descriptor.name === name,
-    {
-      getChildren: (node) => getChildRuntimeNodes(node)
-    }
-  );
-}
-class RuntimeReconciler {
-  constructor(runtimeNodeManager) {
-    __publicField(this, "runtimeNodeManager");
-    this.runtimeNodeManager = runtimeNodeManager;
-  }
-  /**
-   * 将容器 RuntimeNode 的子节点更新为目标 descriptor 列表。
-   *
-   * @param parentNode - 承载子节点的 RuntimeNode。
-   * @param descriptors - 新一轮编译后的子节点描述符。
-   * @returns 子节点结构是否发生可观测变化（新增、移除、类型变更或子树变动）。
-   *
-   * @remarks
-   * 同 key 且同 type 的 RuntimeNode 会被复用；不同 type 即使 key 相同也会重建。
-   * 新子节点会先提交到 parent，再销毁被移除的旧节点，避免 cleanup 或视图投影
-   * 期间仍读取到过期结构。`viewRevision` 由外层 commit boundary 统一推进。
-   */
-  reconcileChildren(parentNode, descriptors) {
-    return this.reconcileChildrenTree(parentNode, descriptors);
-  }
-  reconcileChildrenTree(parentNode, descriptors) {
-    const previousByKey = new Map(
-      getChildRuntimeNodes(parentNode).map((node) => [node.key, node])
-    );
-    const next = [];
-    const groups = [];
-    let changed = false;
-    for (const descriptor of descriptors) {
-      const existingNode = previousByKey.get(descriptor.key);
-      if (existingNode && existingNode.type === descriptor.type) {
-        previousByKey.delete(descriptor.key);
-        existingNode.parent = parentNode;
-        this.runtimeNodeManager.update(existingNode, descriptor);
-        next.push(existingNode);
-        if (isGroupDescriptor(descriptor)) {
-          groups.push({ node: existingNode, descriptor });
-        }
-        continue;
-      }
-      changed = true;
-      const node = this.runtimeNodeManager.create(descriptor, parentNode);
-      this.runtimeNodeManager.mount(node);
-      next.push(node);
-      if (isGroupDescriptor(descriptor)) {
-        groups.push({ node, descriptor });
-      }
-    }
-    setChildRuntimeNodes(parentNode, next);
-    for (const { node, descriptor } of groups) {
-      if (isGroupDescriptor(descriptor)) {
-        if (this.reconcileChildrenTree(node, descriptor.children)) {
-          changed = true;
-        }
-      }
-    }
-    if (previousByKey.size > 0) {
-      changed = true;
-    }
-    for (const removed of previousByKey.values()) {
-      this.runtimeNodeManager.disposeTree(removed);
-    }
-    return changed;
-  }
-}
-function createReconciler(runtimeNodeManager) {
-  return new RuntimeReconciler(runtimeNodeManager);
-}
 function createScope() {
   let disposed = false;
   const cleanupRecords = [];
@@ -3000,367 +4118,811 @@ const runCleanup = (cleanup) => {
 function reportRuntimeCleanupError(error) {
   console.error("[Scope] Cleanup error:", error);
 }
-class DefaultRuntimeNodeManager {
-  constructor(context) {
-    __publicField(this, "nextId", 1);
-    __publicField(this, "context");
-    __publicField(this, "instance");
-    __publicField(this, "fieldRegistry");
-    __publicField(this, "lifecycleBus");
-    this.context = context;
-    this.fieldRegistry = context.fieldRegistry;
-    this.instance = context.instance;
-    this.lifecycleBus = context.lifecycleBus;
+function createRootRuntimeNode(options) {
+  return {
+    id: 0,
+    key: "schemx:root",
+    type: "root",
+    parent: null,
+    scope: options.scope,
+    mounted: createSignal(false),
+    disposed: createSignal(false),
+    childNodes: []
+  };
+}
+function getChildRuntimeNodes(node) {
+  switch (node.type) {
+    case "root":
+    case "group":
+      return node.childNodes;
+    case "dependency":
+      return node.childNodes;
+    case "field":
+      return [];
   }
-  /**
-   * 创建透明根 RuntimeNode。
-   *
-   * @returns root RuntimeNode，不对应任何表单 descriptor。
-   */
-  createRoot() {
-    return {
-      id: 0,
-      key: "schemx:root",
-      type: "root",
-      parent: null,
-      scope: createScope(),
-      disposed: createSignal(false),
-      mounted: createSignal(false),
-      childNodes: []
+}
+function setChildRuntimeNodes(node, children) {
+  switch (node.type) {
+    case "root":
+    case "group":
+      node.childNodes = children;
+      return;
+    case "dependency":
+      node.childNodes = children;
+      return;
+    case "field":
+      return;
+  }
+}
+function createFieldRuntimeNode(options) {
+  var _a;
+  return {
+    id: options.id,
+    key: options.key,
+    type: "field",
+    parent: options.parent ?? null,
+    scope: options.scope ?? ((_a = options.parent) == null ? void 0 : _a.scope.child()) ?? createScope(),
+    mounted: createSignal(false),
+    disposed: createSignal(false)
+  };
+}
+function createGroupRuntimeNode(options) {
+  var _a;
+  return {
+    id: options.id,
+    key: options.key,
+    type: "group",
+    parent: options.parent ?? null,
+    scope: options.scope ?? ((_a = options.parent) == null ? void 0 : _a.scope.child()) ?? createScope(),
+    mounted: createSignal(false),
+    disposed: createSignal(false),
+    childNodes: []
+  };
+}
+function createDependencyRuntimeNode(options) {
+  var _a;
+  return {
+    id: options.id,
+    key: options.key,
+    type: "dependency",
+    parent: options.parent ?? null,
+    scope: options.scope ?? ((_a = options.parent) == null ? void 0 : _a.scope.child()) ?? createScope(),
+    mounted: createSignal(false),
+    disposed: createSignal(false),
+    childNodes: []
+  };
+}
+function createRuntimeResources() {
+  return {
+    nodes: /* @__PURE__ */ new Map(),
+    descriptors: /* @__PURE__ */ new Map(),
+    fieldStates: /* @__PURE__ */ new Map(),
+    viewStates: /* @__PURE__ */ new Map(),
+    childrenStates: /* @__PURE__ */ new Map(),
+    dependencyEffects: /* @__PURE__ */ new Map(),
+    fieldResourceScopes: /* @__PURE__ */ new Map(),
+    fieldDynamicPropScopes: /* @__PURE__ */ new Map(),
+    dependencyResourceScopes: /* @__PURE__ */ new Map()
+  };
+}
+function deleteNodeResources(resources, nodeId) {
+  resources.nodes.delete(nodeId);
+  resources.descriptors.delete(nodeId);
+  resources.fieldStates.delete(nodeId);
+  resources.viewStates.delete(nodeId);
+  resources.childrenStates.delete(nodeId);
+  resources.dependencyEffects.delete(nodeId);
+  resources.fieldResourceScopes.delete(nodeId);
+  resources.fieldDynamicPropScopes.delete(nodeId);
+  resources.dependencyResourceScopes.delete(nodeId);
+}
+function createRuntimeNodeManager(context) {
+  const resources = context.nodeResources;
+  let nextId = 1;
+  const manager = {
+    resources,
+    nodes: resources.nodes,
+    createRoot,
+    create,
+    createNode,
+    getNode,
+    traverse,
+    insertChild,
+    replaceChildren,
+    removeChild,
+    removeSubtree
+  };
+  return manager;
+  function createRoot() {
+    const node = createRootRuntimeNode({ scope: createScope() });
+    registerNode(resources, node);
+    ensureChildrenState(node);
+    return node;
+  }
+  function create(descriptor, parent) {
+    const node = createNode({
+      type: descriptor.type,
+      key: descriptor.key,
+      scope: parent.scope.child()
+    });
+    node.parent = parent;
+    if (node.type !== "field") {
+      ensureChildrenState(node);
+    }
+    return node;
+  }
+  function createNode(createOptions) {
+    const nodeId = nextId++;
+    const scope = createOptions.scope ?? createScope();
+    const baseOptions = {
+      id: nodeId,
+      key: createOptions.key,
+      scope
     };
+    let node = {};
+    if (createOptions.type === "field") {
+      node = createFieldRuntimeNode(baseOptions);
+    } else if (createOptions.type === "group") {
+      node = createGroupRuntimeNode(baseOptions);
+    } else {
+      node = createDependencyRuntimeNode(baseOptions);
+    }
+    registerNode(resources, node);
+    if (node.type !== "field") {
+      ensureChildrenState(node);
+    }
+    return node;
   }
-  /**
-   * 根据 descriptor 创建单个未挂载 RuntimeNode。
-   *
-   * @param descriptor - 编译后的表单节点描述符。
-   * @param parent - 新 RuntimeNode 所属的容器 RuntimeNode。
-   */
-  create(descriptor, parent) {
-    if (descriptor.type === "field") {
-      return this.createField(descriptor, parent);
+  function getNode(nodeId) {
+    return resources.nodes.get(nodeId);
+  }
+  function traverse(root2) {
+    const result = [];
+    const visit = (node) => {
+      result.push(node);
+      for (const child of getChildRuntimeNodes(node)) {
+        visit(child);
+      }
+    };
+    visit(root2);
+    return result;
+  }
+  function insertChild(parent, child, index = getChildRuntimeNodes(parent).length) {
+    if (child.parent) {
+      detachChild(child.parent, child);
+    }
+    const currentChildren = getChildRuntimeNodes(parent).filter(
+      (current) => current !== child
+    );
+    const nextChildren = [...currentChildren];
+    const normalizedIndex = Math.max(0, Math.min(index, nextChildren.length));
+    nextChildren.splice(normalizedIndex, 0, child);
+    child.parent = parent;
+    setChildren(parent, nextChildren);
+  }
+  function replaceChildren(parent, children) {
+    const currentChildren = getChildRuntimeNodes(parent);
+    const nextChildren = Array.from(new Set(children));
+    const nextSet = new Set(nextChildren);
+    for (const child of currentChildren) {
+      if (!nextSet.has(child)) {
+        child.parent = null;
+      }
+    }
+    for (const child of nextChildren) {
+      if (child.parent && child.parent !== parent) {
+        detachChild(child.parent, child);
+      }
+      child.parent = parent;
+    }
+    setChildren(parent, nextChildren);
+  }
+  function removeChild(parent, child) {
+    detachChild(parent, child);
+  }
+  function removeSubtree(node) {
+    for (const child of getChildRuntimeNodes(node)) {
+      removeSubtree(child);
+    }
+    if (node.type !== "field") {
+      setChildren(node, []);
+    }
+    if (node.parent) {
+      detachChild(node.parent, node);
+    }
+    node.parent = null;
+    node.disposed.value = true;
+    node.scope.dispose();
+    deleteNodeResources(resources, node.id);
+  }
+  function detachChild(parent, child) {
+    const nextChildren = getChildRuntimeNodes(parent).filter(
+      (current) => current !== child
+    );
+    setChildren(parent, nextChildren);
+    if (child.parent === parent) {
+      child.parent = null;
+    }
+  }
+  function ensureChildrenState(node) {
+    let state = resources.childrenStates.get(node.id);
+    if (!state) {
+      state = {
+        children: createSignal(
+          getChildRuntimeNodes(node)
+        )
+      };
+      resources.childrenStates.set(node.id, state);
+    }
+    return state;
+  }
+  function setChildren(node, children) {
+    setChildRuntimeNodes(node, children);
+    ensureChildrenState(node).children.value = children;
+  }
+}
+function registerNode(resources, node) {
+  resources.nodes.set(node.id, node);
+}
+function createFieldNodeViewState(viewSchema, nodeKey, nodeId, diagnostics) {
+  return {
+    view: createComputed(() => {
+      const schema = viewSchema.value;
+      const meta = diagnostics == null ? void 0 : diagnostics.value;
+      return {
+        ...schema,
+        key: nodeKey ?? "",
+        placeholder: sanitizePlaceholder(schema.placeholder ?? ""),
+        componentProps: sanitizeComponentProps(schema.componentProps ?? {}),
+        debug: buildFieldDebugMeta(nodeId, meta)
+      };
+    })
+  };
+}
+function createGroupViewState(groupSchema, childrenView, nodeKey, nodeId) {
+  return {
+    view: createComputed(() => {
+      return {
+        ...groupSchema,
+        key: nodeKey ?? "",
+        children: childrenView.value,
+        debug: buildNodeDebugMeta(nodeId, "group", false, false)
+      };
+    })
+  };
+}
+function createDependencyViewState(childrenView) {
+  return {
+    view: createComputed(() => childrenView.value)
+  };
+}
+function createChildrenViewState(childrenSignal, resources) {
+  return createComputed(() => {
+    const result = [];
+    for (const child of childrenSignal.value) {
+      const view = readRuntimeNodeView(child, resources);
+      if (view == null) {
+        continue;
+      }
+      if (Array.isArray(view)) {
+        result.push(...view);
+      } else {
+        result.push(view);
+      }
+    }
+    return result;
+  });
+}
+function readRuntimeNodeView(node, resources = ((_a) => (_a = maybeUseSchemxContext()) == null ? void 0 : _a.nodeResources)()) {
+  if (node.disposed.value) {
+    return null;
+  }
+  if (!resources) {
+    return null;
+  }
+  const viewState = resources.viewStates.get(node.id);
+  if (node.type === "field") {
+    return hasNodeView(viewState) ? viewState.view.value ?? null : null;
+  }
+  if (node.type === "group") {
+    return hasNodeView(viewState) ? viewState.view.value ?? null : null;
+  }
+  if (node.type === "dependency") {
+    return hasNodeView(viewState) ? viewState.view.value ?? [] : [];
+  }
+  return null;
+}
+function hasNodeView(viewState) {
+  return viewState != null && "view" in viewState;
+}
+function createRootViewState(childrenSignal, resources) {
+  return {
+    viewSchemas: createChildrenViewState(childrenSignal, resources)
+  };
+}
+function readRootViewSchemas(root2) {
+  return root2.viewSchemas.value;
+}
+function buildFieldDebugMeta(nodeId, diagnostics) {
+  var _a;
+  return {
+    runtimeNodeId: nodeId ?? 0,
+    runtimeNodeType: "field",
+    hasRuntimeState: true,
+    hasDependencyEffect: false,
+    lastUpdatedBy: diagnostics == null ? void 0 : diagnostics.lastUpdatedBy,
+    overriddenKeys: diagnostics == null ? void 0 : diagnostics.overriddenKeys,
+    error: ((_a = diagnostics == null ? void 0 : diagnostics.error) == null ? void 0 : _a.message) ?? null
+  };
+}
+function buildNodeDebugMeta(nodeId, runtimeNodeType, hasRuntimeState, hasDependencyEffect) {
+  return {
+    runtimeNodeId: nodeId ?? 0,
+    runtimeNodeType,
+    hasRuntimeState,
+    hasDependencyEffect
+  };
+}
+function sanitizePlaceholder(value) {
+  if (!value) {
+    return "";
+  }
+  return value.length > 1e3 ? value.slice(0, 1e3) : value;
+}
+function sanitizeComponentProps(props, depth = 0) {
+  if (depth > 10) {
+    return {};
+  }
+  const result = {};
+  for (const key of Object.keys(props)) {
+    if (!isValidPropKey(key)) {
+      continue;
     }
-    if (descriptor.type === "group") {
-      return this.createGroup(descriptor, parent);
+    const value = props[key];
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = sanitizeComponentProps(
+        value,
+        depth + 1
+      );
+    } else {
+      result[key] = value;
     }
-    if (descriptor.type === "dependency") {
-      return this.createDependency(descriptor, parent);
+  }
+  return result;
+}
+function isValidPropKey(key) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+    return true;
+  }
+  return /^[a-zA-Z0-9_-]+$/.test(key);
+}
+function createRootRuntimeViewState(root2, resources) {
+  const childrenState = getChildrenState(root2, resources);
+  const viewState = createRootViewState(
+    childrenState.children,
+    resources
+  );
+  resources.viewStates.set(root2.id, viewState);
+  return viewState;
+}
+function createRuntimeViewState(node, descriptor, resources) {
+  if (node.type === "field" && descriptor.type === "field") {
+    return createFieldRuntimeViewState(node, descriptor, resources);
+  }
+  if (node.type === "group" && descriptor.type === "group") {
+    return createGroupRuntimeViewState(node, descriptor, resources);
+  }
+  if (node.type === "dependency" && descriptor.type === "dependency") {
+    return createDependencyRuntimeViewState(node, descriptor, resources);
+  }
+  throw new Error(
+    `[schemx] Cannot create viewState for node "${node.key}" with descriptor "${descriptor.type}".`
+  );
+}
+function updateRuntimeViewState(node, descriptor, resources) {
+  return createRuntimeViewState(node, descriptor, resources);
+}
+function deleteRuntimeViewState(node, resources) {
+  resources.viewStates.delete(node.id);
+}
+function createFieldRuntimeViewState(node, descriptor, resources) {
+  const runtimeState = resources.fieldStates.get(node.id);
+  if (!runtimeState) {
+    throw new Error(`[schemx] fieldState is required for node "${node.key}"`);
+  }
+  const viewState = createFieldNodeViewState(
+    runtimeState.viewSchema,
+    node.key,
+    node.id,
+    runtimeState.diagnostics
+  );
+  resources.viewStates.set(node.id, viewState);
+  return viewState;
+}
+function createGroupRuntimeViewState(node, descriptor, resources) {
+  const viewState = createGroupViewState(
+    descriptor.staticSchema,
+    createChildrenViewState(
+      getChildrenState(node, resources).children,
+      resources
+    ),
+    node.key,
+    node.id
+  );
+  resources.viewStates.set(node.id, viewState);
+  return viewState;
+}
+function createDependencyRuntimeViewState(node, _descriptor, resources) {
+  const viewState = createDependencyViewState(
+    createChildrenViewState(
+      getChildrenState(node, resources).children,
+      resources
+    )
+  );
+  resources.viewStates.set(node.id, viewState);
+  return viewState;
+}
+function getChildrenState(node, resources) {
+  const childrenState = resources.childrenStates.get(node.id);
+  if (!childrenState) {
+    throw new Error(`[schemx] childrenState is required for node "${node.key}"`);
+  }
+  return childrenState;
+}
+function createRuntimeLifecycle(context) {
+  const resources = context.nodeResources;
+  const bus = context.lifecycleBus;
+  return {
+    mount,
+    update,
+    unmount,
+    unmountSubtree
+  };
+  function mount(node, descriptor) {
+    resources.descriptors.set(node.id, descriptor);
+    bus.emitBeforeMount(node);
+    mountRuntimeResources(node, descriptor);
+    node.mounted.value = true;
+    bus.emitMount(node);
+  }
+  function update(node, previousDescriptor, nextDescriptor) {
+    if (node.type !== nextDescriptor.type) {
+      throw new Error(
+        `unexpected descriptor type: node ${node.type} cannot update with ${nextDescriptor.type}`
+      );
     }
-    throwUnknownDescriptor(descriptor);
+    const previousNode = { ...node };
+    bus.emitBeforeUpdate(node, previousNode);
+    resources.descriptors.set(node.id, nextDescriptor);
+    updateRuntimeResources(node, previousDescriptor, nextDescriptor);
+    bus.emitUpdate(node, previousNode);
+    bus.emitUpdated(node, previousNode);
   }
-  /**
-   * 挂载单个 RuntimeNode 的运行期资源。
-   *
-   * @param node - 要挂载的 RuntimeNode。
-   *
-   * @remarks
-   * Group RuntimeNode 只表示结构，不会创建领域资源；Field 和 Dependency 会在这里
-   * 创建各自的模型、effect 与资源 scope。
-   */
-  mount(node) {
-    if (!hasDescriptor(node)) {
+  function unmountSubtree(node) {
+    if (node.disposed.value) {
       return;
     }
-    this.lifecycleBus.emitBeforeMount(node);
-    switch (node.type) {
-      case "field":
-        this.mountField(node);
-        break;
-      case "group":
-        this.mountGroup(node);
-        break;
-      case "dependency":
-        this.mountDependency(node);
-        break;
+    for (const child of getChildRuntimeNodes(node)) {
+      unmountSubtree(child);
     }
-    node.mounted.value = true;
-    this.lifecycleBus.emitMount(node);
+    unmount(node);
   }
-  /**
-   * 更新单个 RuntimeNode 的 descriptor 快照和运行期资源。
-   *
-   * @param node - 要更新的 RuntimeNode。
-   * @param next - 更新后的表单 descriptor。
-   *
-   * @remarks
-   * descriptor 快照会先写入 RuntimeNode，再由具体 update 分支决定复用还是重启资源。
-   * 结构层面的 children reconcile 不在这里处理。
-   */
-  update(node, next) {
-    if (!hasDescriptor(node)) {
+  function unmount(node) {
+    if (node.type === "root") {
       return;
     }
-    switch (node.type) {
-      case "field": {
-        if (!isFieldDescriptor(next)) {
-          throwUnexpectedDescriptor(node, next);
-        }
-        const previousNode = createPreviousRuntimeNodeSnapshot(node);
-        this.lifecycleBus.emitBeforeUpdate(node, previousNode);
-        node.descriptor = next;
-        this.updateField(node, previousNode);
-        this.lifecycleBus.emitUpdate(node, previousNode);
-        this.lifecycleBus.emitUpdated(node, previousNode);
-        break;
-      }
-      case "group": {
-        if (!isGroupDescriptor(next)) {
-          throwUnexpectedDescriptor(node, next);
-        }
-        const previousNode = createPreviousRuntimeNodeSnapshot(node);
-        this.lifecycleBus.emitBeforeUpdate(node, previousNode);
-        node.descriptor = next;
-        this.updateGroup(node, next);
-        this.lifecycleBus.emitUpdate(node, previousNode);
-        this.lifecycleBus.emitUpdated(node, previousNode);
-        break;
-      }
-      case "dependency": {
-        if (!isDependencyDescriptor(next)) {
-          throwUnexpectedDescriptor(node, next);
-        }
-        const previousNode = createPreviousRuntimeNodeSnapshot(node);
-        this.lifecycleBus.emitBeforeUpdate(node, previousNode);
-        node.descriptor = next;
-        this.updateDependency(node, previousNode);
-        this.lifecycleBus.emitUpdate(node, previousNode);
-        this.lifecycleBus.emitUpdated(node, previousNode);
-        break;
-      }
-    }
+    bus.emitBeforeUnmount(node);
+    unmountRuntimeResources(node);
+    bus.emitUnmount(node);
   }
-  /**
-   * 卸载单个 RuntimeNode 的运行期资源。
-   *
-   * @param node - 要卸载的 RuntimeNode。
-   *
-   * @remarks
-   * 这个方法不递归销毁子节点；需要销毁整棵子树时使用 `disposeTree`。
-   */
-  unmount(node) {
-    if (!hasDescriptor(node)) {
+  function mountRuntimeResources(node, descriptor) {
+    if (node.type === "field" && descriptor.type === "field") {
+      mountFieldResources(node, descriptor);
+      return;
+    }
+    if (node.type === "group" && descriptor.type === "group") {
+      mountGroupResources(node, descriptor);
       return;
     }
-    switch (node.type) {
-      case "field":
-        this.unmountField(node);
-        break;
-      case "group":
-        this.unmountGroup(node);
-        break;
-      case "dependency":
-        this.unmountDependency(node);
-        break;
+    if (node.type === "dependency" && descriptor.type === "dependency") {
+      mountDependencyResources(node, descriptor);
     }
-    node.mounted.value = false;
   }
-  /**
-   * 递归销毁 RuntimeNode 子树。
-   *
-   * @param node - 要销毁的子树根 RuntimeNode。
-   *
-   * @remarks
-   * 销毁顺序是：标记 disposed、递归销毁 runtime 子节点、卸载自身领域资源、
-   * 释放 RuntimeNode scope、断开 parent。这样可以确保子资源先于父资源释放。
-   */
-  disposeTree(node) {
-    if (node.disposed.value) {
+  function updateRuntimeResources(node, previousDescriptor, nextDescriptor) {
+    if (node.type === "field" && nextDescriptor.type === "field") {
+      updateFieldResources(
+        node,
+        nextDescriptor,
+        (previousDescriptor == null ? void 0 : previousDescriptor.type) === "field" ? previousDescriptor : void 0
+      );
       return;
     }
-    if (node.type !== "root") {
-      this.lifecycleBus.emitBeforeUnmount(node);
+    if (node.type === "group" && nextDescriptor.type === "group") {
+      mountGroupResources(node, nextDescriptor);
+      return;
     }
-    node.disposed.value = true;
-    if (isContainerRuntimeNode(node)) {
-      for (const child of getChildRuntimeNodes(node)) {
-        this.disposeTree(child);
-      }
-      setChildRuntimeNodes(node, []);
+    if (node.type === "dependency" && nextDescriptor.type === "dependency") {
+      updateDependencyResources(
+        node,
+        nextDescriptor,
+        (previousDescriptor == null ? void 0 : previousDescriptor.type) === "dependency" ? previousDescriptor : void 0
+      );
     }
-    this.unmount(node);
-    node.scope.dispose();
-    node.parent = null;
-    if (node.type !== "root") {
-      this.lifecycleBus.emitUnmount(node);
+  }
+  function mountFieldResources(node, descriptor) {
+    const runtimeState = createFieldRuntimeState({
+      nodeId: node.id,
+      key: node.key,
+      descriptor
+    });
+    applyFieldInitialValue(descriptor);
+    resources.fieldStates.set(node.id, runtimeState);
+    createRuntimeViewState(node, descriptor, resources);
+    context.fieldRegistry.register({ name: descriptor.name, node });
+    recreateFieldEffectScopes(node, descriptor, runtimeState);
+  }
+  function updateFieldResources(node, descriptor, previousDescriptor) {
+    const runtimeState = resources.fieldStates.get(node.id);
+    if (!runtimeState) {
+      mountFieldResources(node, descriptor);
+      return;
+    }
+    if (previousDescriptor && previousDescriptor.name !== descriptor.name) {
+      context.fieldRegistry.unregister(previousDescriptor.name, node);
     }
+    setFieldStaticSchema(runtimeState, descriptor);
+    updateRuntimeViewState(node, descriptor, resources);
+    context.fieldRegistry.register({ name: descriptor.name, node });
+    recreateFieldEffectScopes(node, descriptor, runtimeState);
   }
-  createField(descriptor, parent) {
-    const fieldModel = createFieldModel(descriptor);
-    const node = {
-      id: this.nextId++,
-      key: descriptor.key,
-      type: descriptor.type,
-      parent,
-      scope: parent.scope.child(),
-      disposed: createSignal(false),
-      mounted: createSignal(false),
+  function recreateFieldEffectScopes(node, descriptor, runtimeState) {
+    var _a, _b;
+    (_a = resources.fieldResourceScopes.get(node.id)) == null ? void 0 : _a.dispose();
+    (_b = resources.fieldDynamicPropScopes.get(node.id)) == null ? void 0 : _b.dispose();
+    const validationScope = node.scope.child();
+    const dynamicPropScope = node.scope.child();
+    resources.fieldResourceScopes.set(node.id, validationScope);
+    resources.fieldDynamicPropScopes.set(node.id, dynamicPropScope);
+    validationScope.add(() => {
+      if (resources.fieldResourceScopes.get(node.id) === validationScope) {
+        resources.fieldResourceScopes.delete(node.id);
+      }
+    });
+    dynamicPropScope.add(() => {
+      if (resources.fieldDynamicPropScopes.get(node.id) === dynamicPropScope) {
+        resources.fieldDynamicPropScopes.delete(node.id);
+      }
+    });
+    createValidationEffect({
+      context,
+      name: descriptor.name,
+      effectiveSchema: runtimeState.effectiveSchema,
+      scope: validationScope
+    });
+    createDependenciesEffect({
+      context,
       descriptor,
-      fieldModel,
-      fieldResourceScope: null,
-      fieldDependenciesScope: null
-    };
-    return node;
+      runtimeState,
+      scope: dynamicPropScope
+    });
   }
-  createGroup(descriptor, parent) {
-    const node = {
-      id: this.nextId++,
-      key: descriptor.key,
-      type: descriptor.type,
-      parent,
-      scope: parent.scope.child(),
-      disposed: createSignal(false),
-      mounted: createSignal(false),
-      descriptor,
-      childNodes: []
-    };
-    return node;
+  function mountGroupResources(node, descriptor) {
+    createRuntimeViewState(node, descriptor, resources);
   }
-  createDependency(descriptor, parent) {
-    const node = {
-      id: this.nextId++,
-      key: descriptor.key,
-      type: descriptor.type,
-      parent,
-      scope: parent.scope.child(),
-      disposed: createSignal(false),
-      mounted: createSignal(false),
+  function mountDependencyResources(node, descriptor) {
+    createRuntimeViewState(node, descriptor, resources);
+    createDependencyEffect({
+      context,
+      node,
       descriptor,
-      dependencySlot: null,
-      dependencyResourceScope: null,
-      dynamicChildNodes: []
-    };
-    return node;
+      scope: node.scope.child()
+    });
   }
-  mountField(node) {
-    const resourceScope = node.scope.child();
-    const model = node.fieldModel;
-    if (!model) {
+  function updateDependencyResources(node, descriptor, previousDescriptor) {
+    var _a;
+    createRuntimeViewState(node, descriptor, resources);
+    if (previousDescriptor && hasSameTriggerFields(previousDescriptor.triggerFields, descriptor.triggerFields) && resources.dependencyEffects.has(node.id)) {
       return;
     }
-    this.initializeFieldValue(node);
-    node.fieldResourceScope = resourceScope;
-    this.fieldRegistry.register({
-      name: node.descriptor.name,
+    (_a = resources.dependencyResourceScopes.get(node.id)) == null ? void 0 : _a.dispose();
+    createDependencyEffect({
+      context,
       node,
-      model
-    });
-    resourceScope.add(() => {
-      this.fieldRegistry.unregister(node.descriptor.name, node);
-      if (node.fieldResourceScope === resourceScope) {
-        node.fieldResourceScope = null;
-      }
+      descriptor,
+      scope: node.scope.child()
     });
-    this.mountFieldValidation(node, model, resourceScope);
-    this.mountOrRestartFieldDependencies(node, model);
   }
-  initializeFieldValue(node) {
-    const { name, schema } = node.descriptor;
-    if (!Object.hasOwn(schema, "initialValue") || this.instance.getFieldSnapshot(name) !== void 0) {
+  function unmountRuntimeResources(node) {
+    var _a, _b, _c;
+    const descriptor = resources.descriptors.get(node.id);
+    deleteRuntimeViewState(node, resources);
+    if (node.type === "field" && (descriptor == null ? void 0 : descriptor.type) === "field") {
+      context.fieldRegistry.unregister(descriptor.name, node);
+      (_a = resources.fieldResourceScopes.get(node.id)) == null ? void 0 : _a.dispose();
+      (_b = resources.fieldDynamicPropScopes.get(node.id)) == null ? void 0 : _b.dispose();
+    } else if (node.type === "dependency") {
+      (_c = resources.dependencyResourceScopes.get(node.id)) == null ? void 0 : _c.dispose();
+    }
+  }
+  function applyFieldInitialValue(descriptor) {
+    if (!Object.hasOwn(descriptor.staticSchema, "initialValue")) {
+      return;
+    }
+    if (context.instance.getFieldValue(descriptor.name) !== void 0) {
       return;
     }
-    const values = {};
-    setByPath(values, name, schema.initialValue);
-    this.instance.setInitialValues(values);
-    this.instance.setFieldValue(name, schema.initialValue);
+    context.instance.setFieldValue(
+      descriptor.name,
+      descriptor.staticSchema.initialValue
+    );
   }
-  mountGroup(_node) {
+}
+function hasSameTriggerFields(previous, next) {
+  if (previous.length !== next.length) {
+    return false;
   }
-  mountDependency(node) {
-    createDependencyEffect({
-      node,
-      descriptor: node.descriptor,
-      context: this.context
+  return previous.every((field, index) => isSameNamePath(field, next[index]));
+}
+function isSameNamePath(previous, next) {
+  if (next === void 0) {
+    return false;
+  }
+  if (Array.isArray(previous) || Array.isArray(next)) {
+    return Array.isArray(previous) && Array.isArray(next) && previous.length === next.length && previous.every((part, index) => part === next[index]);
+  }
+  return previous === next;
+}
+function commitReconcilePlan(parent, plan, options) {
+  const createdByKey = /* @__PURE__ */ new Map();
+  for (const { descriptor } of plan.creates) {
+    const node = options.nodeManager.createNode({
+      type: descriptor.type,
+      key: descriptor.key,
+      scope: parent.scope.child()
     });
+    createdByKey.set(descriptor.key, node);
   }
-  updateField(node, previousNode) {
-    const model = node.fieldModel;
-    if (model && previousNode && previousNode.descriptor.name === node.descriptor.name) {
-      updateFieldModel(model, node.descriptor);
-      this.fieldRegistry.register({
-        name: node.descriptor.name,
-        node,
-        model
+  const nextChildren = plan.nextChildrenOrder.map((entry) => {
+    if (entry.node) {
+      return entry.node;
+    }
+    const created = createdByKey.get(entry.descriptor.key);
+    if (!created) {
+      throw new Error(
+        `[schemx] Missing created runtime node for descriptor "${entry.descriptor.key}".`
+      );
+    }
+    return created;
+  });
+  for (const { node, previousDescriptor, nextDescriptor } of plan.updates) {
+    options.lifecycle.update(node, previousDescriptor, nextDescriptor);
+  }
+  for (const { descriptor } of plan.creates) {
+    const node = createdByKey.get(descriptor.key);
+    if (!node) {
+      throw new Error(
+        `[schemx] Missing mounted runtime node for descriptor "${descriptor.key}".`
+      );
+    }
+    options.lifecycle.mount(node, descriptor);
+  }
+  options.nodeManager.replaceChildren(parent, nextChildren);
+  for (const { node } of plan.removes) {
+    options.lifecycle.unmountSubtree(node);
+    options.nodeManager.removeSubtree(node);
+  }
+  return nextChildren;
+}
+function createReconcilePlan(currentChildren, nextDescriptors, currentDescriptors) {
+  const currentByKey = indexNodesByKey(currentChildren);
+  const nextByKey = indexDescriptorsByKey(nextDescriptors);
+  const creates = [];
+  const updates = [];
+  const removes = [];
+  const nextChildrenOrder = [];
+  for (const descriptor of nextDescriptors) {
+    const existing = currentByKey.get(descriptor.key);
+    if (!existing || !canReuse(existing, descriptor)) {
+      creates.push({ descriptor });
+      nextChildrenOrder.push({ descriptor });
+      continue;
+    }
+    const previousDescriptor = currentDescriptors.get(existing.id);
+    if (previousDescriptor !== descriptor) {
+      updates.push({
+        node: existing,
+        previousDescriptor,
+        nextDescriptor: descriptor
       });
-      this.mountOrRestartFieldDependencies(node, model);
-      return;
     }
-    this.unmountField(node);
-    this.mountField(node);
+    nextChildrenOrder.push({ descriptor, node: existing });
+  }
+  for (const child of currentChildren) {
+    const nextDescriptor = nextByKey.get(child.key);
+    if (!nextDescriptor || !canReuse(child, nextDescriptor)) {
+      removes.push({ node: child });
+    }
   }
-  updateGroup(_node, _descriptor) {
+  return {
+    creates,
+    updates,
+    removes,
+    nextChildrenOrder
+  };
+}
+function canReuse(node, descriptor) {
+  return node.type === descriptor.type;
+}
+function indexNodesByKey(nodes) {
+  const result = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    result.set(node.key, node);
+  }
+  return result;
+}
+function indexDescriptorsByKey(descriptors) {
+  const result = /* @__PURE__ */ new Map();
+  for (const descriptor of descriptors) {
+    result.set(descriptor.key, descriptor);
   }
-  updateDependency(node, previousNode) {
-    if (!node.dependencySlot || !previousNode || !isSameNamePathList(node.descriptor.trigger, previousNode == null ? void 0 : previousNode.descriptor.trigger)) {
-      this.unmountDependency(node);
-      this.mountDependency(node);
+  return result;
+}
+function createReconciler(context) {
+  const runtime = normalizeReconcilerContext(context);
+  function reconcileChildren(parent, nextDescriptors) {
+    const currentChildren = getChildRuntimeNodes(parent);
+    const plan = createReconcilePlan(
+      currentChildren,
+      nextDescriptors,
+      runtime.getCurrentDescriptors()
+    );
+    const orderedNodes = commitReconcilePlan(parent, plan, runtime);
+    for (const [index, node] of orderedNodes.entries()) {
+      const descriptor = nextDescriptors[index];
+      if ((descriptor == null ? void 0 : descriptor.type) === "group" && node.type === "group") {
+        reconcileChildren(node, descriptor.children);
+      }
     }
   }
-  mountFieldValidation(node, model = node.fieldModel, scope = node.fieldResourceScope) {
-    if (!model || !scope) {
-      return;
+  function createRoot() {
+    const createRootNode = runtime.nodeManager.createRoot;
+    if (!createRootNode) {
+      throw new Error("[schemx] Reconciler nodeManager cannot create root node.");
     }
-    createValidationEffect({
-      name: node.descriptor.name,
-      fieldModel: model,
-      context: this.context,
-      scope
-    });
+    return createRootNode();
   }
-  mountOrRestartFieldDependencies(node, model = node.fieldModel) {
-    var _a;
-    (_a = node.fieldDependenciesScope) == null ? void 0 : _a.dispose();
-    if (!model || !node.descriptor.dependencies) {
-      node.fieldDependenciesScope = null;
+  function updateNode(node, nextDescriptor) {
+    const previousDescriptor = runtime.getCurrentDescriptors().get(node.id);
+    if (previousDescriptor === nextDescriptor) {
       return;
     }
-    const dependenciesScope = node.scope.child();
-    node.fieldDependenciesScope = dependenciesScope;
-    dependenciesScope.add(() => {
-      if (node.fieldDependenciesScope === dependenciesScope) {
-        node.fieldDependenciesScope = null;
-      }
-    });
-    createDependenciesEffect({
-      descriptor: node.descriptor,
-      fieldModel: model,
-      context: this.context,
-      scope: dependenciesScope
-    });
-  }
-  unmountField(node) {
-    var _a, _b;
-    (_a = node.fieldDependenciesScope) == null ? void 0 : _a.dispose();
-    node.fieldDependenciesScope = null;
-    (_b = node.fieldResourceScope) == null ? void 0 : _b.dispose();
-    node.fieldResourceScope = null;
-  }
-  unmountGroup(_node) {
+    runtime.lifecycle.update(node, previousDescriptor, nextDescriptor);
   }
-  unmountDependency(node) {
-    var _a;
-    (_a = node.dependencyResourceScope) == null ? void 0 : _a.dispose();
-    node.dependencyResourceScope = null;
-    node.dependencySlot = null;
+  function removeNode(node) {
+    runtime.lifecycle.unmountSubtree(node);
+    runtime.nodeManager.removeSubtree(node);
   }
+  return {
+    createRoot,
+    reconcileChildren,
+    updateNode,
+    removeNode
+  };
 }
-function createRuntimeNodeManager(context) {
-  return new DefaultRuntimeNodeManager(context);
-}
-function isSameNamePathList(a2, b2) {
-  if (a2.length !== b2.length) {
-    return false;
+function normalizeReconcilerContext(context) {
+  if (isReconcilerContext(context)) {
+    return context;
   }
-  return a2.every((name, index) => name === b2[index]);
-}
-function createPreviousRuntimeNodeSnapshot(node) {
-  return { ...node };
-}
-function throwUnknownDescriptor(descriptor) {
-  throw new Error(`unknown type: ${descriptor.type ?? "unknown"}`);
+  const nodeManager = createRuntimeNodeManager(context);
+  const lifecycle = createRuntimeLifecycle(context);
+  return {
+    nodeManager,
+    lifecycle,
+    getCurrentDescriptors: () => context.nodeResources.descriptors
+  };
 }
-function throwUnexpectedDescriptor(node, descriptor) {
-  throw new Error(
-    `unexpected descriptor type: node ${node.type} cannot update with ${descriptor.type}`
-  );
+function isReconcilerContext(context) {
+  return "nodeManager" in context && "lifecycle" in context;
 }
 const PRIORITY_ORDER = ["sync", "pre", "normal", "post"];
 function createScheduler() {
@@ -3386,18 +4948,23 @@ function createScheduler() {
   };
   const flushOnce = async () => {
     var _a, _b;
-    const batch = takeBatch();
-    for (const task of batch) {
-      if (disposed || ((_a = task.scope) == null ? void 0 : _a.disposed)) {
-        continue;
+    while (!disposed) {
+      const batch = takeBatch();
+      if (batch.length === 0) {
+        return;
       }
-      try {
-        const result = task.run();
-        if (isPromiseLike(result)) {
-          await track(result);
+      for (const task of batch) {
+        if (disposed || ((_a = task.scope) == null ? void 0 : _a.disposed)) {
+          continue;
+        }
+        try {
+          const result = task.run();
+          if (isPromiseLike(result)) {
+            await track(result);
+          }
+        } catch (error) {
+          (_b = task.onError) == null ? void 0 : _b.call(task, error);
         }
-      } catch (error) {
-        (_b = task.onError) == null ? void 0 : _b.call(task, error);
       }
     }
   };
@@ -3485,7 +5052,9 @@ class StoreImpl {
    * @param options - 配置选项
    */
   constructor(options = {}) {
+    /** 每个字段路径对应一个 FieldSignal */
     __publicField(this, "fieldSignals", createFieldSignalMap());
+    /** 初始值 */
     __publicField(this, "initialValues");
     const initialValues = options.initialValues ?? {};
     this.initialValues = cloneDeep(initialValues);
@@ -3920,143 +5489,19 @@ class StoreImpl {
 function createStore(options = {}) {
   return new StoreImpl(options);
 }
-const MAX_DEPTH = 100;
-function buildViewSchemas(root) {
-  if (!root) {
-    return [];
-  }
-  return buildRuntimeNodeChildren(getChildRuntimeNodes(root), 1);
-}
-function buildRuntimeNodeChildren(nodes, depth) {
-  if (depth > MAX_DEPTH) {
-    throw new RangeError(
-      `buildViewSchemas: max depth ${MAX_DEPTH} exceeded at depth ${depth}`
-    );
-  }
-  const results = [];
-  for (const node of nodes) {
-    const schema = buildRuntimeNodeSchema(node, depth);
-    if (schema === null) {
-      continue;
-    }
-    if (Array.isArray(schema)) {
-      for (const child of schema) {
-        results.push(child);
-      }
-      continue;
-    }
-    results.push(schema);
-  }
-  return results;
-}
-function buildRuntimeNodeSchema(node, depth) {
-  if (node.disposed.value) {
-    return null;
-  }
-  if (isGroupRuntimeNode(node)) {
-    return buildGroupViewSchema(node, depth);
-  }
-  if (isDependencyRuntimeNode(node)) {
-    return buildDependencyRuntimeNode(node, depth);
-  }
-  if (isFieldRuntimeNode(node)) {
-    return buildFieldViewSchema(node);
-  }
-  return null;
-}
-function buildFieldViewSchema(node) {
-  const descriptor = node.descriptor;
-  const model = node.fieldModel;
-  if (!model) {
-    console.warn(
-      `[buildViewSchemas] skipping field node "${node.key}": no FieldModel resource`
-    );
-    return null;
-  }
-  if ((descriptor == null ? void 0 : descriptor.type) !== "field") {
-    return null;
-  }
-  const schema = descriptor.schema;
-  const snapshot = model.snapshot.value;
-  return {
-    ...schema,
-    key: node.key,
-    visible: snapshot.visible,
-    label: snapshot.label,
-    readonly: snapshot.readonly,
-    disabled: snapshot.disabled,
-    required: snapshot.required,
-    placeholder: sanitizePlaceholder(snapshot.placeholder),
-    componentProps: sanitizeComponentProps(snapshot.componentProps ?? {}),
-    rules: snapshot.rules,
-    validationTrigger: schema.validationTrigger,
-    debug: buildDebugMeta(node)
-  };
-}
-function buildGroupViewSchema(node, depth) {
-  const children = buildRuntimeNodeChildren(
-    getChildRuntimeNodes(node),
-    depth + 1
-  );
-  const descriptor = node.descriptor;
-  return {
-    ...descriptor.schema,
-    key: node.key,
-    children,
-    debug: buildDebugMeta(node)
-  };
-}
-function buildDependencyRuntimeNode(node, depth) {
-  return buildRuntimeNodeChildren(getChildRuntimeNodes(node), depth + 1);
-}
-function sanitizePlaceholder(value) {
-  return value.length > 1e3 ? value.slice(0, 1e3) : value;
-}
-function sanitizeComponentProps(props, depth = 0) {
-  if (depth > 10) {
-    return {};
-  }
-  const result = {};
-  for (const key of Object.keys(props)) {
-    if (!isValidPropKey(key)) {
-      continue;
-    }
-    const value = props[key];
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = sanitizeComponentProps(value, depth + 1);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function isValidPropKey(key) {
-  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
-    return true;
-  }
-  if (/^[a-zA-Z0-9_-]+$/.test(key)) {
-    return true;
-  }
-  return false;
-}
-function buildDebugMeta(node) {
-  return {
-    runtimeNodeId: node.id,
-    runtimeNodeType: node.type,
-    hasFieldModel: node.type === "field" && node.fieldModel !== void 0,
-    hasDependencySlot: node.type === "dependency" && node.dependencySlot !== void 0
-  };
-}
-function subscribeViewSchemas(root, revision, onChange) {
+function subscribeViewSchemas(root2, resources, onChange) {
   let rootDisposed = false;
-  const rootScope = root.scope;
+  const rootScope = root2.scope;
   const disposeHandle = rootScope.add(() => {
     rootDisposed = true;
   });
   const disposeEffect = createDebouncedSignalEffect(
     () => {
-      void revision.revision.value;
-      return rootDisposed ? [] : buildViewSchemas(root);
+      if (rootDisposed) {
+        return [];
+      }
+      const rootViewState = resources.viewStates.get(root2.id);
+      return isRootViewState(rootViewState) ? rootViewState.viewSchemas.value : [];
     },
     (viewSchemas) => {
       try {
@@ -4075,34 +5520,49 @@ function subscribeViewSchemas(root, revision, onChange) {
   };
   return unsubscribe;
 }
-function createViewRevision() {
-  const revision = createSignal(0);
-  const bump = () => {
-    revision.value += 1;
-  };
-  return {
-    revision,
-    bump
-  };
+function isRootViewState(viewState) {
+  return viewState != null && "viewSchemas" in viewState;
 }
 class CreateForm {
   constructor(options = {}) {
+    /** 表单内部上下文，集中持有全局配置和运行时服务 */
     __publicField(this, "context");
+    /** 用户传入的表单级回调集合 */
     __publicField(this, "callbacks");
+    /** 表单状态存储，管理字段值、初始值和订阅 */
     __publicField(this, "store");
+    /** 渲染器注册表，解析 schema.componentType 到具体渲染实现 */
     __publicField(this, "rendererRegistry");
+    /** 校验规则注册表，解析字符串规则名称到 StandardSchema 或规则工厂 */
     __publicField(this, "validatorRegistry");
+    /** 字段校验器，维护规则、错误状态和校验执行流程 */
     __publicField(this, "validator");
+    /** Runtime node 的透明根节点，承载所有编译后的表单描述符节点 */
     __publicField(this, "root");
+    /** 运行时异步调度器，用于追踪 dependency renderer 和字段动态依赖 */
     __publicField(this, "scheduler");
-    __publicField(this, "viewRevision");
+    /** descriptor 到 RuntimeNode tree 的协调器，负责创建、复用和销毁节点 */
     __publicField(this, "reconciler");
-    __publicField(this, "runtimeNodeManager");
+    /** 字段 RuntimeNode 到字段模型的注册表，供表单 API 和视图投影读取 */
     __publicField(this, "fieldRegistry");
+    /** RuntimeNode 之外的 descriptor、state、view 和 effect 资源表 */
+    __publicField(this, "nodeResources");
+    /** 表单级资源作用域，统一管理回调 effect 等非 RuntimeNode 资源 */
     __publicField(this, "scope", createScope());
+    /** root schema 的统一数据源 */
     __publicField(this, "schemas");
+    /** schema 编译，让未变化的 schema 复用 descriptor 引用 */
+    __publicField(this, "compile");
+    /** 标记表单实例是否已销毁，保证 dispose 幂等 */
     __publicField(this, "disposed", false);
+    /** node 生命周期事件总线，连接 reconciler 与字段资源挂载流程 */
     __publicField(this, "lifecycleBus");
+    /**
+     * 表单实例接口
+     *
+     * 定义表单的所有操作方法，是 useForm 返回值的基础接口。
+     * SchemxInstance 类实现此接口，提供完整的表单操作能力。
+     */
     __publicField(this, "getFormInstance", () => {
       return {
         setFieldValue: this.store.setFieldValue.bind(this.store),
@@ -4133,8 +5593,8 @@ class CreateForm {
         batch: this.batch.bind(this),
         setSchemas: this.setSchemas.bind(this),
         updateSchemas: this.updateSchemas.bind(this),
+        updateFieldSchema: this.updateFieldSchema.bind(this),
         updateDefaultProps: this.updateDefaultProps.bind(this),
-        getViewRevision: () => this.viewRevision.revision.value,
         getViewSchemas: this.getViewSchemas.bind(this),
         subscribeViewSchemas: this.subscribeViewSchemas.bind(this),
         waitForDependencies: this.waitForIdle.bind(this),
@@ -4147,6 +5607,11 @@ class CreateForm {
         destroy: this.destroy.bind(this)
       };
     });
+    /**
+     * 表单 API，提供与表单交互的方法。
+     *
+     * 传递给动态渲染器，允许程序化操作表单。
+     */
     __publicField(this, "getFormApi", () => {
       return {
         setValue: this.store.setFieldValue.bind(this.store),
@@ -4166,6 +5631,11 @@ class CreateForm {
         validate: this.validate.bind(this)
       };
     });
+    /**
+     * 校验所有已注册字段
+     *
+     * 校验前检查是否有字段处于操作中状态，有则直接返回失败结果。
+     */
     __publicField(this, "validate", withLock(async () => {
       const pendingFields = this.store.getPendingFields();
       if (pendingFields.length > 0) {
@@ -4189,24 +5659,30 @@ class CreateForm {
       const result = await this.validator.validate(this.store.getFieldsValue());
       return result;
     }));
+    /**
+     * 提交表单
+     */
     __publicField(this, "submit", withLock(async () => {
-      var _a2, _b2, _c, _d;
+      var _a, _b, _c, _d;
       const depsReady = await this.waitForIdle();
       if (!depsReady) {
         return;
       }
       const result = await this.validate();
       if (result.ok) {
-        await ((_b2 = (_a2 = this.callbacks).onFinish) == null ? void 0 : _b2.call(_a2, result.values));
+        await ((_b = (_a = this.callbacks).onFinish) == null ? void 0 : _b.call(_a, result.values));
       } else {
         (_d = (_c = this.callbacks).onFinishFailed) == null ? void 0 : _d.call(_c, result.error);
       }
     }));
+    /**
+     * 唯一子节点提交边界。
+     *
+     * 所有结构输入先编译成 descriptor，再经由这里提交到某个 parent RuntimeNode。
+     * Reconciler 只负责 node 结构；视图层通过 childrenState signal 自动感知结构变化。
+     */
     __publicField(this, "commitChildren", (parentNode, descriptors) => {
-      const changed = this.reconciler.reconcileChildren(parentNode, descriptors);
-      if (changed) {
-        this.viewRevision.bump();
-      }
+      this.reconciler.reconcileChildren(parentNode, descriptors);
     });
     var _a, _b;
     const {
@@ -4237,20 +5713,31 @@ class CreateForm {
     });
     this.lifecycleBus = createLifecycleBus();
     this.scheduler = createScheduler();
-    this.viewRevision = createViewRevision();
     this.fieldRegistry = createFieldRegistry();
+    this.nodeResources = createRuntimeResources();
+    const defaultProps = pick(restOptions, defaultConfigKey);
+    this.compile = createCompile({
+      defaultProps,
+      formInstance: this.getFormInstance()
+    });
     this.context = {
-      defaultProps: pick(restOptions, defaultConfigKey),
+      defaultProps,
       instance: this.getFormInstance(),
       formApi: this.getFormApi(),
+      compile: this.compile,
       scheduler: this.scheduler,
       lifecycleBus: this.lifecycleBus,
       fieldRegistry: this.fieldRegistry,
+      nodeResources: this.nodeResources,
       commitChildren: this.commitChildren
     };
-    this.runtimeNodeManager = createRuntimeNodeManager(this.context);
-    this.reconciler = createReconciler(this.runtimeNodeManager);
-    this.root = this.runtimeNodeManager.createRoot();
+    this.reconciler = createReconciler(this.context);
+    this.root = this.reconciler.createRoot();
+    const rootChildrenState = this.nodeResources.childrenStates.get(this.root.id);
+    if (!rootChildrenState) {
+      throw new Error("[schemx] root childrenState is required");
+    }
+    createRootRuntimeViewState(this.root, this.nodeResources);
     if (options.lifecycleHooks) {
       this.lifecycleBus.on(options.lifecycleHooks);
     }
@@ -4285,9 +5772,11 @@ class CreateForm {
    * 注册字段校验规则
    */
   register(path, rules, defaultMessage) {
+    var _a;
     const resolvedRules = [];
-    const node = findFieldRuntimeNode(this.root, path);
-    const schema = node == null ? void 0 : node.descriptor.schema;
+    const node = (_a = this.fieldRegistry.get(path)) == null ? void 0 : _a.node;
+    const descriptor = node ? this.nodeResources.descriptors.get(node.id) : void 0;
+    const schema = (descriptor == null ? void 0 : descriptor.type) === "field" ? descriptor.staticSchema : void 0;
     this.validator.unregister(path);
     const schemaWithRules = {
       ...schema,
@@ -4355,6 +5844,41 @@ class CreateForm {
     }
     this.schemas.update(updater);
   }
+  /**
+   * 更新单个字段的静态 schema 呈现配置。
+   */
+  updateFieldSchema(name, patch) {
+    var _a;
+    if (this.disposed) {
+      return;
+    }
+    const entry = this.fieldRegistry.get(name);
+    if (!entry) {
+      return;
+    }
+    const node = entry.node;
+    const current = this.nodeResources.descriptors.get(node.id);
+    if ((current == null ? void 0 : current.type) !== "field") {
+      return;
+    }
+    const nextRawSchema = {
+      ...current.staticSchema,
+      ...patch,
+      componentProps: patch.componentProps ? {
+        ...current.staticSchema.componentProps,
+        ...patch.componentProps
+      } : current.staticSchema.componentProps,
+      key: current.key,
+      name: current.name,
+      componentType: current.staticSchema.componentType,
+      dependencies: (_a = current.dynamicProps) == null ? void 0 : _a.dependencies
+    };
+    const [next] = this.compile.toDescriptors([nextRawSchema]);
+    if (next.type !== "field") {
+      return;
+    }
+    this.reconciler.updateNode(node, next);
+  }
   /**
    * 更新表单默认配置。
    *
@@ -4366,6 +5890,7 @@ class CreateForm {
       return;
     }
     Object.assign(this.context.defaultProps, pick(partial, defaultConfigKey));
+    this.compile.invalidate();
     this.applySchemas(this.schemas.peek());
   }
   /**
@@ -4375,12 +5900,8 @@ class CreateForm {
     if (this.disposed) {
       return;
     }
-    const previousRevision = this.viewRevision.revision.value;
-    const descriptors = compileToDescriptors([...schemas], this.context.defaultProps);
+    const descriptors = this.compile.toDescriptors(schemas);
     this.commitChildren(this.root, descriptors);
-    if (this.viewRevision.revision.value === previousRevision) {
-      this.viewRevision.bump();
-    }
   }
   /**
    * 销毁表单实例
@@ -4393,7 +5914,7 @@ class CreateForm {
     }
     this.disposed = true;
     this.scope.dispose();
-    this.runtimeNodeManager.disposeTree(this.root);
+    this.reconciler.removeNode(this.root);
     this.scheduler.dispose();
     this.store.destroy();
   }
@@ -4401,13 +5922,17 @@ class CreateForm {
    * 获取当前 ViewSchemas。
    */
   getViewSchemas() {
-    return buildViewSchemas(this.root);
+    const rootViewState = this.nodeResources.viewStates.get(this.root.id);
+    if (!rootViewState || !("viewSchemas" in rootViewState)) {
+      return [];
+    }
+    return readRootViewSchemas(rootViewState);
   }
   /**
    * 订阅 ViewSchemas 变化。
    */
   subscribeViewSchemas(callback) {
-    return subscribeViewSchemas(this.root, this.viewRevision, callback);
+    return subscribeViewSchemas(this.root, this.nodeResources, callback);
   }
   /**
    * 等待内部异步任务完成。
@@ -4600,7 +6125,7 @@ function createWatch(form, nameOrNamesOrCallback, callbackOrOptions, maybeOption
 const rendererRegistry = createRendererRegistry("input");
 const validatorRegistry = createValidatorsRegistry();
 const SCHEMX_INSTANCE_KEY = Symbol("SCHEMX_INSTANCE");
-function useForm(options) {
+function useForm(options = {}) {
   const { ...formOptions } = options;
   const mergedOptions = {
     ...formOptions,
@@ -4614,13 +6139,14 @@ function useForm(options) {
   });
   return instance.value;
 }
-function useFormInstance() {
+function useFormContext() {
   const instance = inject(SCHEMX_INSTANCE_KEY);
   if (!instance) {
-    throw new Error("useFormInstance must be used within a Form");
+    throw new Error("useFormContext must be used within a Form");
   }
   return instance;
 }
+const FIELD_CONTEXT_KEY = Symbol("schemx:field");
 const fieldHookCache = /* @__PURE__ */ new WeakMap();
 function createFieldHook(form, name) {
   const field = createField(form, name);
@@ -4649,7 +6175,7 @@ function createFieldHook(form, name) {
   return { result, dispose };
 }
 const useField = (name) => {
-  const form = useFormInstance();
+  const form = useFormContext();
   const key = name;
   let formCache = fieldHookCache.get(form);
   if (!formCache) {
@@ -4678,8 +6204,18 @@ const useField = (name) => {
   });
   return activeEntry.result;
 };
+function createFieldContext(field) {
+  provide(FIELD_CONTEXT_KEY, field);
+}
+function useFieldContext() {
+  const field = inject(FIELD_CONTEXT_KEY);
+  if (!field) {
+    throw new Error("[schemx] useFieldContext() must be used inside a FormItem tree");
+  }
+  return field;
+}
 function useWatch(nameOrNamesOrCallback, callbackOrOptions, maybeOptions) {
-  const form = useFormInstance();
+  const form = useFormContext();
   const dispose = createWatch(
     form,
     nameOrNamesOrCallback,
@@ -4709,7 +6245,7 @@ function normalizeError(err) {
 }
 const useDictionary = (options, fieldName) => {
   var _a;
-  const instance = useFormInstance();
+  const instance = useFormContext();
   const list = ref([]);
   const loading = ref(false);
   const error = ref(void 0);
@@ -4791,13 +6327,13 @@ const useDictionary = (options, fieldName) => {
   return { list, loading, error, loadDict, refresh, mutate };
 };
 const FORM_CONTEXT_KEY = Symbol("FormContext");
-const createContext = (props) => {
+const createConfigContext = (props) => {
   provide(FORM_CONTEXT_KEY, props);
 };
-function useContext() {
+function useConfigContext() {
   const context = inject(FORM_CONTEXT_KEY);
   if (!context) {
-    throw new Error("useContext must be used within a Form");
+    throw new Error("useConfigContext must be used within a Form");
   }
   return context;
 }
@@ -4825,17 +6361,6 @@ function useViewSchemas(form) {
   onScopeDispose(unsubscribe);
   return viewSchemas;
 }
-const FIELD_CONTEXT_KEY = Symbol("schemx:field");
-function provideFieldContext(field) {
-  provide(FIELD_CONTEXT_KEY, field);
-}
-function useFieldContext() {
-  const field = inject(FIELD_CONTEXT_KEY);
-  if (!field) {
-    throw new Error("[schemx] useFieldContext() must be used inside a FormItem tree");
-  }
-  return field;
-}
 function isValidTrigger(v2) {
   if (v2 === void 0) return false;
   if (Array.isArray(v2) && v2.length === 0) return false;
@@ -4960,17 +6485,17 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
       }, slots);
     };
   }
-  const form = useFormInstance();
-  const formContext = useContext();
+  const form = useFormContext();
+  const formContext = useConfigContext();
   const schema = () => schemaRef.value;
   const field = useField(schema().name);
-  provideFieldContext(field);
+  createFieldContext(field);
   const trigger = computed(() => mergeTrigger(schema().validationTrigger, formContext.validationTrigger, "onChange"));
   const canVerified = computed(() => {
     const isOperate = schema().visible && !schema().readonly && !schema().disabled;
     const rules = schema().rules;
-    const hasRules = Array.isArray(rules) ? (rules == null ? void 0 : rules.length) > 0 : !!schema().rules;
-    return isOperate && hasRules;
+    const hasRules2 = Array.isArray(rules) ? (rules == null ? void 0 : rules.length) > 0 : !!schema().rules;
+    return isOperate && hasRules2;
   });
   const handleChange = (v2) => {
     var _a, _b;
@@ -4985,27 +6510,9 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
       field.validate();
     }
   };
-  const formItemProps = computed(() => {
-    return {
-      ...omit(schema(), ["componentProps"]),
-      name: schema().name,
-      componentType: schema().componentType,
-      class: classnames("schemx-item", schema().class),
-      required: schema().required,
-      readonly: schema().readonly,
-      disabled: schema().disabled,
-      visible: schema().visible,
-      placeholder: schema().placeholder,
-      validationTrigger: trigger.value
-    };
-  });
   const componentProps = useStableRef(() => ({
     ...schema().componentProps,
-    formItemProps: formItemProps.value,
     value: field.getValue(),
-    readonly: schema().readonly,
-    disabled: schema().disabled,
-    placeholder: schema().placeholder,
     onChange: handleChange,
     onBlur: handleBlur,
     "onUpdate:value": (v2) => field.setValue(v2)
@@ -5021,7 +6528,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
   const renderLabel = () => {
     const labelSlot = resolveSlot(slots, `${schema().name}Label`);
     if (labelSlot) {
-      return labelSlot(formItemProps.value);
+      return labelSlot(schema());
     }
     const labelAlign = schema().labelAlign || formContext.labelAlign;
     const labelWidth = schema().labelWidth || formContext.labelWidth;
@@ -5046,7 +6553,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
     const contentSlot = resolveSlot(slots, `${schema().name}Content`);
     if (contentSlot) {
       return contentSlot({
-        ...formItemProps.value,
+        ...schema(),
         columnElement
       });
     }
@@ -5058,7 +6565,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
     const errorSlot = resolveSlot(slots, `${schema().name}Error`);
     if (errorSlot) {
       return errorSlot({
-        ...formItemProps.value,
+        ...schema(),
         errors: field.error.value
       });
     }
@@ -5075,7 +6582,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
     }
     const itemSlot = resolveSlot(slots, normalizeNameKey(schema().name));
     if (itemSlot) {
-      return itemSlot(formItemProps.value);
+      return itemSlot(schema());
     }
     const labelPosition = schema().labelPosition || formContext.labelPosition;
     return createVNode("div", {
@@ -5179,7 +6686,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
-    createContext(
+    createConfigContext(
       omit(props, [
         "form",
         "modelValue",
@@ -5306,14 +6813,15 @@ function WithRemoteOptions(WrappedComponent) {
   });
 }
 export {
+  ContextNotProvidedError,
   FormGroup,
   FormItem,
   WithRemoteOptions,
   collectObjectPathsByLeaf,
+  createContext,
   createEffect,
   createField,
   createForm,
-  createForm as createFormInstance,
   createLifecycle,
   createLifecycleBus,
   createRendererRegistry,
@@ -5328,6 +6836,7 @@ export {
   getByPath,
   isBaseResolvedSchema,
   isBaseSchema,
+  isContext,
   isDependencySchema,
   isGroupResolvedSchema,
   isGroupSchema,
@@ -5335,12 +6844,13 @@ export {
   rendererRegistry,
   SchemxFormExport as schemxForm,
   setByPath,
-  useContext,
+  useConfigContext,
   useDictionary,
   useEffect,
   useField,
   useFieldContext,
   useForm,
+  useFormContext,
   useWatch,
   useWatchAll,
   useWatchField,